Subversion Repositories Scribus

Rev

Rev 20221 | Rev 20316 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
3 paul 7
/***************************************************************************
8
                          scribus.cpp  -  description
9
                             -------------------
10
    begin                : Fre Apr  6 21:09:31 CEST 2001
11
    copyright            : (C) 2001 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
23
 
16546 jghali 24
#include <QAction>
8591 cbradney 25
#include <QApplication>
10862 cbradney 26
#include <QByteArray>
27
#include <QCloseEvent>
28
#include <QColor>
10223 cbradney 29
#include <QColorDialog>
30
#include <QCursor>
8635 cbradney 31
#include <QDesktopWidget>
18198 fschmid 32
#include <QDrag>
10862 cbradney 33
#include <QDragEnterEvent>
8501 cbradney 34
#include <QDropEvent>
35
#include <QEvent>
10862 cbradney 36
#include <QEventLoop>
15130 cbradney 37
#include <QFileDialog>
10862 cbradney 38
#include <QFrame>
16546 jghali 39
#include <QFont>
10862 cbradney 40
#include <QIcon>
41
#include <QInputDialog>
8501 cbradney 42
#include <QKeyEvent>
10862 cbradney 43
#include <QKeySequence>
44
#include <QLabel>
45
#include <QList>
46
#include <QLocale>
16546 jghali 47
#include <QMdiArea>
48
#include <QMdiSubWindow>
49
#include <QMessageBox>
10862 cbradney 50
#include <QMouseEvent>
51
#include <QPixmap>
16546 jghali 52
#include <QProgressBar>
19093 craig 53
#include <QPushButton>
18758 craig 54
//<<QML testing
55
#include <QHBoxLayout>
19001 craig 56
#include <QQuickView>
57
#include <QQmlEngine>
58
#include <QQmlComponent>
19004 craig 59
#include <QQuickItem>
60
#include <QQmlProperty>
18758 craig 61
//>>
10862 cbradney 62
#include <QRegExp>
18803 jghali 63
#include <QScopedPointer>
10862 cbradney 64
#include <QStyleFactory>
9853 fschmid 65
#include <QTableWidget>
10862 cbradney 66
#include <QTextCodec>
67
#include <QTranslator>
68
#include <QWheelEvent>
1208 cbradney 69
 
14539 jghali 70
#ifdef DEBUG_LOAD_TIMES
71
#include <QDebug>
72
#include <QTime>
73
#include <sys/times.h>
74
#endif
75
 
3 paul 76
#include <cstdio>
77
#include <cstdlib>
9082 avox 78
#include <cassert>
2629 craig 79
 
2688 craig 80
#include "scconfig.h"
2629 craig 81
 
82
#ifdef HAVE_DLFCN_H
3 paul 83
#include <dlfcn.h>
2629 craig 84
#endif
85
 
86
#ifdef HAVE_UNISTD_H
135 Franz 87
#include <unistd.h>
2629 craig 88
#endif
89
 
3 paul 90
#include <iostream>
8289 avox 91
#include <sstream>
119 Franz 92
#include <signal.h>
80 Franz 93
#include <string>
1208 cbradney 94
 
16546 jghali 95
 
96
#include "actionmanager.h"
19499 craig 97
#include "appmodehelper.h"
19067 craig 98
#include "appmodes.h"
16546 jghali 99
#include "canvasmode.h"
17735 craig 100
#include "canvasmode_imageimport.h"
16546 jghali 101
#include "commonstrings.h"
102
#include "desaxe/digester.h"
103
#include "desaxe/saxXML.h"
104
#include "desaxe/simple_actions.h"
105
#include "docinfo.h"
106
#include "documentchecker.h"
107
#include "documentinformation.h"
108
#include "fileloader.h"
109
#include "filewatcher.h"
110
#include "fpoint.h"
111
#include "fpointarray.h"
112
#include "gtgettext.h"
113
#include "hyphenator.h"
20185 craig 114
#include "iconmanager.h"
16546 jghali 115
#include "langmgr.h"
19093 craig 116
#include "loadsaveplugin.h"
17826 craig 117
#include "marks.h"
19093 craig 118
#include "nfttemplate.h"
17826 craig 119
#include "notesstyles.h"
16916 fschmid 120
#include "pageitem_group.h"
16546 jghali 121
#include "pageitem_imageframe.h"
122
#include "pageitem_latexframe.h"
19093 craig 123
#include "pageitem_noteframe.h"
16856 craig 124
#include "pageitem_table.h"
16546 jghali 125
#include "pageitem_textframe.h"
126
#include "pagesize.h"
127
#include "pdflib.h"
128
#include "pdfoptions.h"
129
#include "pluginmanager.h"
130
#include "plugins/formatidlist.h"
19093 craig 131
#include "plugins/formatidlist.h"
16546 jghali 132
#include "prefscontext.h"
133
#include "prefsfile.h"
134
#include "prefsmanager.h"
135
#include "prefstable.h"
136
#include "pslib.h"
137
#include "resourcecollection.h"
138
#include "sccolorengine.h"
139
#include "scgtplugin.h"
19093 craig 140
#include "scimagecachemanager.h"
16546 jghali 141
#include "scmimedata.h"
16736 jghali 142
#include "scpage.h"
16546 jghali 143
#include "scpaths.h"
144
#include "scprintengine_ps.h"
145
#include "scraction.h"
146
#include "scribusXml.h"
147
#include "scribusapp.h"
148
#include "scribuscore.h"
19093 craig 149
#include "scribusdoc.h"
16546 jghali 150
#include "scribusview.h"
151
#include "scribuswin.h"
152
#include "selection.h"
153
#include "serializer.h"
19093 craig 154
#include "styleoptions.h"
155
#include "tocgenerator.h"
13552 cbradney 156
#include "ui/about.h"
13544 cbradney 157
#include "ui/aboutplugins.h"
18972 craig 158
#include "ui/adjustcmsdialog.h"
13544 cbradney 159
#include "ui/aligndistribute.h"
13650 cbradney 160
#include "ui/annot.h"
161
#include "ui/annota.h"
13552 cbradney 162
#include "ui/applytemplatedialog.h"
13576 cbradney 163
#include "ui/arrowchooser.h"
13650 cbradney 164
#include "ui/autoform.h"
13576 cbradney 165
#include "ui/basepointwidget.h"
13551 cbradney 166
#include "ui/bookmarkpalette.h"
13544 cbradney 167
#include "ui/charselect.h"
13650 cbradney 168
#include "ui/checkDocument.h"
14798 cbradney 169
#include "ui/collectforoutput_ui.h"
13650 cbradney 170
#include "ui/colorcombo.h"
13576 cbradney 171
#include "ui/contextmenu.h"
19093 craig 172
#include "ui/copypagetomasterpagedialog.h"
13551 cbradney 173
#include "ui/cpalette.h"
13552 cbradney 174
#include "ui/customfdialog.h"
13650 cbradney 175
#include "ui/delpages.h"
19783 craig 176
#include "ui/downloadspalette.h"
19093 craig 177
#include "ui/edittoolbar.h"
13552 cbradney 178
#include "ui/effectsdialog.h"
19093 craig 179
#include "ui/filetoolbar.h"
13650 cbradney 180
#include "ui/fontcombo.h"
13544 cbradney 181
#include "ui/guidemanager.h"
13576 cbradney 182
#include "ui/helpbrowser.h"
183
#include "ui/hruler.h"
13552 cbradney 184
#include "ui/imageinfodialog.h"
17405 fschmid 185
#include "ui/inlinepalette.h"
13544 cbradney 186
#include "ui/insertaframe.h"
13650 cbradney 187
#include "ui/inspage.h"
188
#include "ui/javadocs.h"
13576 cbradney 189
#include "ui/layers.h"
13650 cbradney 190
#include "ui/loremipsum.h"
19093 craig 191
#include "ui/margindialog.h"
13650 cbradney 192
#include "ui/marginwidget.h"
17826 craig 193
#include "ui/mark2item.h"
194
#include "ui/mark2mark.h"
195
#include "ui/markanchor.h"
19093 craig 196
#include "ui/markinsert.h"
17826 craig 197
#include "ui/marknote.h"
19093 craig 198
#include "ui/marksmanager.h"
17826 craig 199
#include "ui/markvariabletext.h"
13650 cbradney 200
#include "ui/mergedoc.h"
19093 craig 201
#include "ui/modetoolbar.h"
13650 cbradney 202
#include "ui/movepage.h"
13544 cbradney 203
#include "ui/multipleduplicate.h"
13650 cbradney 204
#include "ui/newfile.h"
205
#include "ui/newtemp.h"
13544 cbradney 206
#include "ui/nftdialog.h"
207
#include "ui/nftwidget.h"
13551 cbradney 208
#include "ui/nodeeditpalette.h"
17826 craig 209
#include "ui/notesstyleseditor.h"
13551 cbradney 210
#include "ui/outlinepalette.h"
13544 cbradney 211
#include "ui/pageitemattributes.h"
13650 cbradney 212
#include "ui/pagelayout.h"
13551 cbradney 213
#include "ui/pagepalette.h"
13576 cbradney 214
#include "ui/pageselector.h"
15599 fschmid 215
#include "ui/paintmanager.h"
19966 craig 216
#include "ui/pdfexportdialog.h"
19093 craig 217
#include "ui/pdftoolbar.h"
13544 cbradney 218
#include "ui/picstatus.h"
219
#include "ui/polygonwidget.h"
13761 cbradney 220
#include "ui/preferencesdialog.h"
13650 cbradney 221
#include "ui/preview.h"
13544 cbradney 222
#include "ui/printdialog.h"
13551 cbradney 223
#include "ui/propertiespalette.h"
16546 jghali 224
#include "ui/propertiespalette_image.h"
225
#include "ui/propertiespalette_line.h"
226
#include "ui/propertiespalette_shape.h"
227
#include "ui/propertiespalette_text.h"
228
#include "ui/propertiespalette_xyz.h"
13650 cbradney 229
#include "ui/query.h"
13544 cbradney 230
#include "ui/replacecolors.h"
19821 craig 231
#include "ui/resourcemanager.h"
13650 cbradney 232
#include "ui/sccombobox.h"
17735 craig 233
#include "ui/scfilewidget.h"
13576 cbradney 234
#include "ui/scmessagebox.h"
19093 craig 235
#include "ui/scmwmenumanager.h"
13551 cbradney 236
#include "ui/scrapbookpalette.h"
19093 craig 237
#include "ui/scrspinbox.h"
238
#include "ui/search.h"
16546 jghali 239
#include "ui/selectobjects.h"
16856 craig 240
#include "ui/smcellstyle.h"
13544 cbradney 241
#include "ui/smlinestyle.h"
16856 craig 242
#include "ui/smtablestyle.h"
13544 cbradney 243
#include "ui/smtextstyles.h"
13551 cbradney 244
#include "ui/splash.h"
13576 cbradney 245
#include "ui/storyeditor.h"
13544 cbradney 246
#include "ui/stylemanager.h"
15060 fschmid 247
#include "ui/symbolpalette.h"
13544 cbradney 248
#include "ui/tabmanager.h"
15309 cbradney 249
#include "ui/transformdialog.h"
16034 fschmid 250
#include "ui/transparencypalette.h"
19009 craig 251
#include "ui/viewtoolbar.h"
19093 craig 252
#include "ui/vruler.h"
253
#include "ui_nftdialog.h"
10212 cbradney 254
#include "undogui.h"
255
#include "undomanager.h"
256
#include "undostate.h"
257
#include "units.h"
10311 cbradney 258
#include "urllauncher.h"
5184 avox 259
#include "util.h"
19917 fschmid 260
#include "util_file.h"
10212 cbradney 261
#include "util_formats.h"
262
#include "util_ghostscript.h"
14170 jghali 263
#include "util_math.h"
134 Franz 264
 
19093 craig 265
 
266
#ifdef HAVE_OSG
267
        #include "ui/osgeditor.h"
268
        #include <osgDB/ReaderWriter>
269
        #include <osgDB/PluginQuery>
270
#endif
271
 
4361 cbradney 272
#if defined(_WIN32)
5178 mrdocs 273
#include "scdocoutput_ps2.h"
10967 jghali 274
#include "scprintengine_gdi.h"
4361 cbradney 275
#endif
276
 
15023 jghali 277
#include "sclimits.h"
278
 
3 paul 279
using namespace std;
280
 
3234 fschmid 281
bool previewDinUse;
282
bool printDinUse;
2891 cbradney 283
 
3 paul 284
QString DocDir;
3205 craig 285
 
10532 avox 286
 
2536 cbradney 287
extern ScribusQApp* ScQApp;
2634 cbradney 288
extern bool emergencyActivated;
3 paul 289
 
10532 avox 290
 
4026 craig 291
ScribusMainWindow::ScribusMainWindow()
2161 cbradney 292
{
5781 cbradney 293
        actionManager=0;
19495 craig 294
        appModeHelper=0;
5781 cbradney 295
        scrMenuMgr=0;
296
        prefsManager=0;
10181 cbradney 297
        formatsManager=0;
19821 craig 298
        resourceManager=0;
10311 cbradney 299
        UrlLauncher::instance();
5781 cbradney 300
        mainWindowStatusLabel=0;
7354 cbradney 301
        ExternalApp=0;
19458 jghali 302
        ScriptRunning = 0;
18204 fschmid 303
#ifdef Q_OS_MAC
19839 craig 304
        //commenting this out until this is resolved :https://bugreports.qt.io/browse/QTBUG-44565
305
        //ScQApp->setAttribute(Qt::AA_DontShowIconsInMenus);
20193 craig 306
        //noIcon = IconManager::instance()->loadPixmap("noicon.xpm");
3580 avox 307
#endif
10625 cbradney 308
}
188 Franz 309
 
11158 avox 310
/*
311
static QCoreApplication::EventFilter origEventFilter = 0;
10532 avox 312
 
11158 avox 313
bool reportFocusChanges(void *message, long *result)
314
{
315
        unsigned* data = static_cast<unsigned*>(message);
316
        if (QApplication::focusWidget())
317
                qDebug() << QApplication::applicationFilePath() << reinterpret_cast<void*>(QApplication::focusWidget()) << typeid(*QApplication::focusWidget()).name() << QApplication::focusWidget()->objectName() << message << data[0] << data[1] << data[2] << data[3] << data[4] << data[5] << data[6] << data[7];
318
        else
319
                qDebug() << QApplication::applicationFilePath() << "no focus" << message << data[0] << data[1] << data[2] << data[3] << data[4] << data[5] << data[6] << data[7];
320
        return origEventFilter && origEventFilter(message, result);
321
}
322
*/
323
 
767 cbradney 324
/*
325
 * retval 0 - ok, 1 - no fonts, ...
326
 */
5243 cbradney 327
int ScribusMainWindow::initScMW(bool primaryMainWindow)
188 Franz 328
{
767 cbradney 329
        int retVal=0;
17407 fschmid 330
        qsrand(1234);
9909 avox 331
        QByteArray stylesheet;
9910 jghali 332
        if (loadRawText(ScPaths::getApplicationDataDir() + "/stylesheet.css", stylesheet))
9909 avox 333
        {
334
                qApp->setStyleSheet(QString(stylesheet));
335
        }
10953 subik 336
 
11158 avox 337
//      origEventFilter = qApp->setEventFilter(reportFocusChanges);
11960 subik 338
 
3234 fschmid 339
        previewDinUse = false;
340
        printDinUse = false;
9721 fschmid 341
        internalCopy = false;
17016 fschmid 342
        internalCopyBuffer = "";
16016 fschmid 343
        m_doc = new ScribusDoc();
344
        m_doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
345
        m_doc->setPage(100, 100, 0, 0, 0, 0, 0, 0, false, false);
346
        m_doc->addPage(0);
347
        m_doc->setGUI(false, this, 0);
355 Franz 348
        CurrStED = NULL;
10495 cbradney 349
        setWindowTitle( tr("Scribus " VERSION));
10564 fschmid 350
        setAttribute(Qt::WA_KeyCompression, false);
16546 jghali 351
        setAttribute(Qt::WA_InputMethodEnabled, true);
20185 craig 352
        setWindowIcon(IconManager::instance()->loadIcon("AppIcon.png"));
16612 fschmid 353
        setObjectName("MainWindow");
1325 cbradney 354
        scrActionGroups.clear();
1208 cbradney 355
        scrActions.clear();
356
        scrRecentFileActions.clear();
5800 fschmid 357
        scrRecentPasteActions.clear();
1260 cbradney 358
        scrWindowsActions.clear();
2408 cbradney 359
        scrLayersActions.clear();
15516 fschmid 360
        scrScrapActions.clear();
18533 craig 361
        actionManager = new ActionManager(this);
19495 craig 362
        appModeHelper = new AppModeHelper();
19509 craig 363
        appModeHelper->setup(actionManager, &scrActions, &scrRecentFileActions, &scrWindowsActions, &scrScrapActions, &scrLayersActions, &scrRecentPasteActions);
18533 craig 364
        scrMenuMgr = new ScMWMenuManager(menuBar(), actionManager);
2835 cbradney 365
        prefsManager = PrefsManager::instance();
10181 cbradney 366
        formatsManager = FormatsManager::instance();
5243 cbradney 367
        objectSpecificUndo = false;
7087 subik 368
 
1247 tsoots 369
        undoManager = UndoManager::instance();
7880 fschmid 370
        PrefsContext *undoPrefs = prefsManager->prefsFile->getContext("undo");
371
        undoManager->setUndoEnabled(undoPrefs->getBool("enabled", true));
2441 cbradney 372
        tocGenerator = new TOCGenerator();
17826 craig 373
        m_marksCount = 0;
4510 subik 374
 
1780 cbradney 375
        initDefaultValues();
7087 subik 376
 
272 Franz 377
        initStatusBar();
7087 subik 378
 
490 cbradney 379
        qApp->processEvents();
675 cbradney 380
 
18533 craig 381
 
5257 cbradney 382
        actionManager->init(this);
11174 fschmid 383
//      if (primaryMainWindow)
384
//              ScCore->setSplashStatus( tr("Applying User Shortcuts") );
385
//      prefsManager->applyLoadedShortCuts();
386
//      initKeyboardShortcuts();
387
        initMenuBar();
18548 craig 388
        createMenuBar();
11174 fschmid 389
        initToolBars();
18438 craig 390
        ScCore->pluginManager->setupPluginActions(this);
14509 cbradney 391
        ScCore->pluginManager->enableOnlyStartupPluginActions(this);
18438 craig 392
        ScCore->pluginManager->languageChange();
18548 craig 393
 
10977 cbradney 394
        if (primaryMainWindow)
395
                ScCore->setSplashStatus( tr("Applying User Shortcuts") );
396
        prefsManager->applyLoadedShortCuts();
397
        initKeyboardShortcuts();
11960 subik 398
 
5243 cbradney 399
        resize(610, 600);
13959 jghali 400
        mdiArea = new QMdiArea(this);
401
        mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
402
        mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
14224 fschmid 403
        if (prefsManager->appPrefs.uiPrefs.useTabs)
18724 fschmid 404
        {
14224 fschmid 405
                mdiArea->setViewMode(QMdiArea::TabbedView);
18724 fschmid 406
                mdiArea->setTabsClosable(true);
18728 fschmid 407
                mdiArea->setDocumentMode(true);
18724 fschmid 408
        }
14224 fschmid 409
        else
410
                mdiArea->setViewMode(QMdiArea::SubWindowView);
13959 jghali 411
        setCentralWidget( mdiArea );
412
        connect(mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow *)), this, SLOT(newActWin(QMdiSubWindow *)));
413
        //Connect windows cascade and tile actions to the workspace after its created. Only depends on mdiArea created.
414
        connect( scrActions["windowsCascade"], SIGNAL(triggered()) , mdiArea, SLOT(cascadeSubWindows()) );
415
        connect( scrActions["windowsTile"], SIGNAL(triggered()) , mdiArea, SLOT(tileSubWindows()) );
5243 cbradney 416
        initPalettes();
7087 subik 417
 
5243 cbradney 418
        prefsManager->setupMainWindow(this);
770 cbradney 419
 
19009 craig 420
        viewToolBar->previewQualitySwitcher->setCurrentIndex(prefsManager->appPrefs.itemToolPrefs.imageLowResType);
5243 cbradney 421
        if (primaryMainWindow)
422
                ScCore->setSplashStatus( tr("Initializing Story Editor") );
423
        storyEditor = new StoryEditor(this);
770 cbradney 424
 
5243 cbradney 425
        DocDir = prefsManager->documentDir();
1485 tsoots 426
 
5243 cbradney 427
        if (primaryMainWindow)
17798 craig 428
                ScCore->setSplashStatus( tr("Initializing Languages") );
429
        LanguageManager::instance();
430
 
13955 cbradney 431
        QString preLang(prefsManager->appPrefs.hyphPrefs.Language);
5800 fschmid 432
        initHyphenator();
17798 craig 433
        if (!LanguageManager::instance()->getHyphFilename( preLang ).isEmpty() )
13955 cbradney 434
                prefsManager->appPrefs.hyphPrefs.Language = preLang;
5800 fschmid 435
        if (primaryMainWindow)
436
                ScCore->setSplashStatus( tr("Reading Scrapbook") );
437
        initScrapbook();
438
 
13955 cbradney 439
        scrActions["helpTooltips"]->setChecked(prefsManager->appPrefs.displayPrefs.showToolTips);
440
        scrActions["showMouseCoordinates"]->setChecked(prefsManager->appPrefs.displayPrefs.showMouseCoordinates);
441
        scrActions["stickyTools"]->setChecked(prefsManager->appPrefs.uiPrefs.stickyTools);
5800 fschmid 442
        ToggleTips();
12754 fschmid 443
        ToggleMouseTips();
5800 fschmid 444
        propertiesPalette->setFontSize();
6451 fschmid 445
        if (scrActions["SaveAsDocumentTemplate"])
446
                scrActions["SaveAsDocumentTemplate"]->setEnabled(false);
7087 subik 447
 
15946 jghali 448
        connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString )), this, SLOT(removeRecentFromWatcher(QString)));
5800 fschmid 449
        connect(ClipB, SIGNAL(dataChanged()), this, SLOT(ClipChange()));
450
        setAcceptDrops(true);
9562 fschmid 451
        QCoreApplication::instance()->installEventFilter(this);
12846 fschmid 452
        scrActions["toolsSelect"]->setChecked(true);
16016 fschmid 453
        ColorSetManager csm;
454
        csm.findPaletteLocations();
455
        csm.findPalettes();
456
        csm.findUserPalettes();
16577 craig 457
        QString Cpfad = QDir::toNativeSeparators(ScPaths::getApplicationDataDir())+"DefaultColors.xml";
16016 fschmid 458
        QFile fc(Cpfad);
459
        if (fc.exists())
460
                csm.loadPalette(Cpfad, m_doc, prefsManager->appPrefs.colorPrefs.DColors, prefsManager->appPrefs.defaultGradients, prefsManager->appPrefs.defaultPatterns, false);
461
        else
462
        {
463
                if (prefsManager->appPrefs.colorPrefs.DColorSet != "Scribus Small")
464
                {
465
                        QStringList CustomColorSets = csm.userPaletteNames();
466
                        if (CustomColorSets.contains(prefsManager->appPrefs.colorPrefs.DColorSet))
467
                                Cpfad = csm.userPaletteFileFromName(prefsManager->appPrefs.colorPrefs.DColorSet);
468
                        else
469
                                Cpfad = csm.paletteFileFromName(prefsManager->appPrefs.colorPrefs.DColorSet);
18562 jghali 470
                        if (!Cpfad.isEmpty())
471
                                csm.loadPalette(Cpfad, m_doc, prefsManager->appPrefs.colorPrefs.DColors, prefsManager->appPrefs.defaultGradients, prefsManager->appPrefs.defaultPatterns, false);
16016 fschmid 472
                }
473
        }
19509 craig 474
        appModeHelper->setStartupActionsEnabled(false);
18556 craig 475
 
20196 craig 476
        setStyleSheet();
477
 
5800 fschmid 478
        return retVal;
479
}
480
 
10532 avox 481
 
5800 fschmid 482
ScribusMainWindow::~ScribusMainWindow()
483
{
18646 jghali 484
        if (actionManager)
485
                delete actionManager;
19495 craig 486
        if (appModeHelper)
487
                delete appModeHelper;
16016 fschmid 488
        delete m_doc;
5800 fschmid 489
}
490
 
11040 fschmid 491
void ScribusMainWindow::addScToolBar(ScToolBar *tb, QString name)
492
{
493
        if (!scrToolBars.contains(name))
494
                scrToolBars.insert(name, tb);
495
        addToolBar(tb);
496
}
5800 fschmid 497
 
498
void ScribusMainWindow::initToolBars()
499
{
10976 cbradney 500
        fileToolBar = new FileToolBar(this);
501
        editToolBar = new EditToolBar(this);
5800 fschmid 502
        UndoWidget* uWidget = new UndoWidget(editToolBar, "uWidget");
503
        undoManager->registerGui(uWidget);
10976 cbradney 504
        modeToolBar = new ModeToolBar(this);
5800 fschmid 505
        pdfToolBar = new PDFToolBar(this);
19009 craig 506
        viewToolBar = new ViewToolBar(this);
10953 subik 507
 
15260 cbradney 508
        addScToolBar(fileToolBar, fileToolBar->objectName());
509
        addScToolBar(editToolBar, editToolBar->objectName());
510
        addScToolBar(modeToolBar, modeToolBar->objectName());
511
        addScToolBar(pdfToolBar, pdfToolBar->objectName());
19009 craig 512
        addScToolBar(viewToolBar, viewToolBar->objectName());
10976 cbradney 513
        connect(modeToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarTools"], SLOT(setChecked(bool)));
10734 jghali 514
        connect(scrActions["toolsToolbarPDF"], SIGNAL(toggled(bool)), pdfToolBar, SLOT(setVisible(bool)));
10969 subik 515
        connect(pdfToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarPDF"], SLOT(setChecked(bool)));
10976 cbradney 516
        connect(scrActions["toolsToolbarTools"], SIGNAL(toggled(bool)), modeToolBar, SLOT(setVisible(bool)) );
19009 craig 517
        connect(viewToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarView"], SLOT(setChecked(bool)));
518
        connect(scrActions["toolsToolbarView"], SIGNAL(toggled(bool)), viewToolBar, SLOT(setVisible(bool)) );
5800 fschmid 519
}
520
 
20196 craig 521
void ScribusMainWindow::setStyleSheet()
522
{
523
        QByteArray stylesheet;
524
        if (loadRawText(ScPaths::instance().libDir() + "scribus.css", stylesheet))
525
        {
526
                QString downArrow(IconManager::instance()->pathForIcon("16/go-down.png"));
527
                QByteArray da;
528
                da.append(downArrow);
529
                stylesheet.replace("___downArrow___", da);
530
                QString toolbararrow(IconManager::instance()->pathForIcon("stylesheet/down_arrow.png"));
531
                QByteArray tba;
532
                tba.append(toolbararrow);
533
                stylesheet.replace("___tb_menu_arrow___", tba);
534
        }
10532 avox 535
 
20196 craig 536
        layerMenu->setStyleSheet(stylesheet);
537
        unitSwitcher->setStyleSheet(stylesheet);
538
        zoomDefaultToolbarButton->setStyleSheet(stylesheet);
539
        zoomInToolbarButton->setStyleSheet(stylesheet);
540
        zoomOutToolbarButton->setStyleSheet(stylesheet);
541
        zoomSpinBox->setStyleSheet(stylesheet);
542
 
543
        fileToolBar->setStyleSheet(stylesheet);
544
        editToolBar->setStyleSheet(stylesheet);
545
        modeToolBar->setStyleSheet(stylesheet);
546
        pdfToolBar->setStyleSheet(stylesheet);
547
        viewToolBar->setStyleSheet(stylesheet);
548
}
549
 
550
 
5800 fschmid 551
void ScribusMainWindow::initDefaultValues()
552
{
553
        HaveDoc = false;
554
        view = NULL;
555
        doc = NULL;
556
        DocNr = 1;
557
        PrinterUsed = false;
558
        PDef.Pname = "";
559
        PDef.Dname = "";
560
        PDef.Command = "";
561
        keyrep = false;
562
        _arrowKeyDown = false;
563
        ClipB = QApplication::clipboard();
19853 craig 564
        for (int i=0; i<PS_MAX ; ++i)
19783 craig 565
                palettesStatus[i] = false;
19853 craig 566
        for (int i=0; i<GS_MAX ; ++i)
567
                guidesStatus[i] = false;
17781 fschmid 568
#ifdef HAVE_OSG
18207 fschmid 569
        QStringList supportedExts;
570
        supportedExts << "osg" << "dxf" << "flt" << "ive" << "geo" << "sta" << "stl" << "logo" << "3ds" << "ac" << "obj";
571
        QStringList realSupportedExts;
572
        QMap<QString, QString> formats;
573
        osgDB::FileNameList plugins = osgDB::listAllAvailablePlugins();
574
        for(osgDB::FileNameList::iterator itr = plugins.begin(); itr != plugins.end(); ++itr)
575
        {
576
                osgDB::ReaderWriterInfoList infoList;
577
                if (QString::fromStdString(*itr).contains("qfont"))
578
                        continue;
579
                if (osgDB::queryPlugin(*itr, infoList))
17781 fschmid 580
                {
18207 fschmid 581
                        for(osgDB::ReaderWriterInfoList::iterator rwi_itr = infoList.begin(); rwi_itr != infoList.end(); ++rwi_itr)
17781 fschmid 582
                        {
18207 fschmid 583
                                osgDB::ReaderWriterInfo& info = *(*rwi_itr);
584
                                osgDB::ReaderWriter::FormatDescriptionMap::iterator fdm_itr;
585
                                for(fdm_itr = info.extensions.begin(); fdm_itr != info.extensions.end(); ++fdm_itr)
17781 fschmid 586
                                {
18207 fschmid 587
                                        if (supportedExts.contains(QString::fromStdString(fdm_itr->first)))
588
                                                formats.insert("*." + QString::fromStdString(fdm_itr->first) + " *." + QString::fromStdString(fdm_itr->first).toUpper(), QString::fromStdString(fdm_itr->second) + " (*." + QString::fromStdString(fdm_itr->first) + " *." + QString::fromStdString(fdm_itr->first).toUpper() + ")");
17781 fschmid 589
                                }
590
                        }
591
                }
18207 fschmid 592
        }
593
        realSupportedExts = formats.keys();
594
        QString docexts = realSupportedExts.join(" ");
595
        QStringList longList = formats.values();
596
        QString longDesc = longList.join(";;") + ";;";
597
        osgFilterString = tr("All Supported Formats (%1);;%2All Files (*)").arg(docexts).arg(longDesc);
17781 fschmid 598
#endif
5800 fschmid 599
}
600
 
10532 avox 601
 
5800 fschmid 602
void ScribusMainWindow::initKeyboardShortcuts()
603
{
8501 cbradney 604
        for( QMap<QString, QPointer<ScrAction> >::Iterator it = scrActions.begin(); it!=scrActions.end(); ++it )
5800 fschmid 605
        {
10516 cbradney 606
                if ((ScrAction*)(it.value())!=NULL)
5800 fschmid 607
                {
18194 fschmid 608
                        QString accelerator = it.value()->shortcut().toString();
10516 cbradney 609
                        prefsManager->setKeyEntry(it.key(), it.value()->cleanMenuText(), accelerator,0);
5800 fschmid 610
                }
611
                //else
13085 jghali 612
                //      qDebug() << it.key();
613
                //qDebug() << QString("|-\n|%1||%2||%3").arg(it.key()).arg(it.value()->cleanMenuText()).arg(QString(it.data()->accel()));
5800 fschmid 614
        }
615
}
616
 
10532 avox 617
 
5800 fschmid 618
void ScribusMainWindow::initPalettes()
619
{
620
        //CB TODO hide the publicly available members of some palettes
621
        // these must be filtered too as they take control of the palettes events
10862 cbradney 622
        outlinePalette = new OutlinePalette(this);
5800 fschmid 623
        outlinePalette->setMainWindow(this);
624
        connect( scrActions["toolsOutline"], SIGNAL(toggled(bool)) , outlinePalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 625
        connect( outlinePalette, SIGNAL(paletteShown(bool)), scrActions["toolsOutline"], SLOT(setChecked(bool)));
16546 jghali 626
 
10862 cbradney 627
        propertiesPalette = new PropertiesPalette(this);
5800 fschmid 628
        propertiesPalette->setMainWindow(this);
629
        connect( scrActions["toolsProperties"], SIGNAL(toggled(bool)) , propertiesPalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 630
        connect( propertiesPalette, SIGNAL(paletteShown(bool)), scrActions["toolsProperties"], SLOT(setChecked(bool)));
16546 jghali 631
        emit UpdateRequest(reqDefFontListUpdate);
5800 fschmid 632
        propertiesPalette->installEventFilter(this);
633
        nodePalette = new NodePalette(this);
634
        nodePalette->installEventFilter(this);
635
        layerPalette = new LayerPalette(this);
636
        guidePalette = new GuideManager(this);
7087 subik 637
        charPalette = new CharSelect(this);
5800 fschmid 638
        connect( scrActions["toolsLayers"], SIGNAL(toggled(bool)) , layerPalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 639
        connect( layerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsLayers"], SLOT(setChecked(bool)));
5800 fschmid 640
        layerPalette->installEventFilter(this);
641
        layerPalette->Table->installEventFilter(this);
642
        scrapbookPalette = new Biblio(this);
643
        connect( scrActions["toolsScrapbook"], SIGNAL(toggled(bool)) , scrapbookPalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 644
        connect( scrapbookPalette, SIGNAL(paletteShown(bool)), scrActions["toolsScrapbook"], SLOT(setChecked(bool)));
11554 fschmid 645
        connect( scrapbookPalette, SIGNAL(pasteToActualPage(QString)), this, SLOT(pasteFromScrapbook(QString)));
18924 craig 646
        connect( scrapbookPalette, SIGNAL(scrapbookListChanged()), this, SLOT(rebuildScrapbookMenu()));
5800 fschmid 647
        scrapbookPalette->installEventFilter(this);
648
        pagePalette = new PagePalette(this);
649
        connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , pagePalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 650
        connect( pagePalette, SIGNAL(paletteShown(bool)), scrActions["toolsPages"], SLOT(setChecked(bool)));
5800 fschmid 651
        pagePalette->installEventFilter(this);
652
        bookmarkPalette = new BookPalette(this);
653
        connect( scrActions["toolsBookmarks"], SIGNAL(toggled(bool)) , bookmarkPalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 654
        connect( bookmarkPalette, SIGNAL(paletteShown(bool)), scrActions["toolsBookmarks"], SLOT(setChecked(bool)));
5800 fschmid 655
        bookmarkPalette->installEventFilter(this);
19783 craig 656
        downloadsPalette = new DownloadsPalette(this);
657
        connect( scrActions["toolsDownloads"], SIGNAL(toggled(bool)) , downloadsPalette, SLOT(setPaletteShown(bool)) );
658
        connect( downloadsPalette, SIGNAL(paletteShown(bool)), scrActions["toolsDownloads"], SLOT(setChecked(bool)));
659
        downloadsPalette->installEventFilter(this);
5800 fschmid 660
        connect( scrActions["toolsMeasurements"], SIGNAL(toggledData(bool, int)) , this, SLOT(setAppModeByToggle(bool, int)) );
661
        docCheckerPalette = new CheckDocument(this, false);
662
        connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , docCheckerPalette, SLOT(setPaletteShown(bool)) );
663
        connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , this, SLOT(docCheckToggle(bool)) );
10581 cbradney 664
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsPreflightVerifier"], SLOT(setChecked(bool)));
5800 fschmid 665
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), this, SLOT(docCheckToggle(bool)));
666
        docCheckerPalette->installEventFilter(this);
667
        docCheckerPalette->hide();
668
 
18194 fschmid 669
        alignDistributePalette = new AlignDistributePalette(this, "AlignDistributePalette");
5800 fschmid 670
        connect( scrActions["toolsAlignDistribute"], SIGNAL(toggled(bool)) , alignDistributePalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 671
        connect( alignDistributePalette, SIGNAL(paletteShown(bool)), scrActions["toolsAlignDistribute"], SLOT(setChecked(bool)));
5800 fschmid 672
        connect( alignDistributePalette, SIGNAL(documentChanged()), this, SLOT(slotDocCh()));
673
        alignDistributePalette->installEventFilter(this);
7087 subik 674
 
15060 fschmid 675
        symbolPalette = new SymbolPalette(this);
676
        symbolPalette->setMainWindow(this);
16029 fschmid 677
        connect(scrActions["toolsSymbols"], SIGNAL(toggled(bool)), symbolPalette, SLOT(setPaletteShown(bool)));
678
        connect(symbolPalette, SIGNAL(paletteShown(bool)), scrActions["toolsSymbols"], SLOT(setChecked(bool)));
679
        connect(symbolPalette, SIGNAL(startEdit(QString)), this, SLOT(editSymbolStart(QString)));
680
        connect(symbolPalette, SIGNAL(endEdit()), this, SLOT(editSymbolEnd()));
17793 fschmid 681
        connect(symbolPalette, SIGNAL(objectDropped()), this, SLOT(PutToPatterns()));
15060 fschmid 682
        symbolPalette->installEventFilter(this);
683
        symbolPalette->hide();
17405 fschmid 684
 
685
        inlinePalette = new InlinePalette(this);
686
        inlinePalette->setMainWindow(this);
687
        connect(scrActions["toolsInline"], SIGNAL(toggled(bool)), inlinePalette, SLOT(setPaletteShown(bool)));
688
        connect(inlinePalette, SIGNAL(paletteShown(bool)), scrActions["toolsInline"], SLOT(setChecked(bool)));
17410 fschmid 689
        connect(inlinePalette, SIGNAL(startEdit(int)), this, SLOT(editInlineStart(int)));
690
        connect(inlinePalette, SIGNAL(endEdit()), this, SLOT(editInlineEnd()));
17804 fschmid 691
        connect(inlinePalette, SIGNAL(objectDropped(QString)), this, SLOT(PutToInline(QString)));
17405 fschmid 692
        inlinePalette->installEventFilter(this);
693
        inlinePalette->hide();
15060 fschmid 694
 
5800 fschmid 695
        undoPalette = new UndoPalette(this, "undoPalette");
696
        undoPalette->installEventFilter(this);
697
        undoManager->registerGui(undoPalette);
698
        connect(undoPalette, SIGNAL(paletteShown(bool)), this, SLOT(setUndoPalette(bool)));
699
        connect(undoPalette, SIGNAL(objectMode(bool)), this, SLOT(setUndoMode(bool)));
700
 
701
        // initializing style manager here too even it's not strictly a palette
702
        styleManager = new StyleManager(this, "styleManager");
7063 tsoots 703
        SMCharacterStyle *tmpCS = new SMCharacterStyle();
704
        styleManager->addStyle(new SMParagraphStyle(tmpCS->tmpStyles()));
705
        styleManager->addStyle(tmpCS);
16856 craig 706
        styleManager->addStyle(new SMTableStyle());
707
        styleManager->addStyle(new SMCellStyle());
19157 craig 708
        styleManager->addStyle(new SMLineStyle());
10627 cbradney 709
        connect( scrActions["editStyles"], SIGNAL(toggled(bool)), styleManager, SLOT(setPaletteShown(bool)) );
10581 cbradney 710
        connect( styleManager, SIGNAL(paletteShown(bool)), scrActions["editStyles"], SLOT(setChecked(bool)));
8005 cbradney 711
        styleManager->installEventFilter(this);
5800 fschmid 712
 
17826 craig 713
        // initializing mark`s manager
714
        marksManager = new MarksManager(this, "marksManager");
715
        connect( scrActions["editMarks"], SIGNAL(toggled(bool)), marksManager, SLOT(setPaletteShown(bool)) );
716
        connect( marksManager, SIGNAL(paletteShown(bool)), scrActions["editMarks"], SLOT(setChecked(bool)));
717
        marksManager->installEventFilter(this);
718
        // initializing notes styles manager
719
        nsEditor = new NotesStylesEditor(this, "notesStylesEditor");
720
        connect( scrActions["editNotesStyles"], SIGNAL(toggled(bool)), nsEditor, SLOT(setPaletteShown(bool)) );
721
        connect( nsEditor, SIGNAL(paletteShown(bool)), scrActions["editNotesStyles"], SLOT(setChecked(bool)));
722
        nsEditor->installEventFilter(this);
723
 
16122 fschmid 724
//      connect(docCheckerPalette, SIGNAL(selectElement(int, int)), this, SLOT(selectItemsFromOutlines(int, int)));
725
        connect(docCheckerPalette, SIGNAL(selectElementByItem(PageItem *, bool)), this, SLOT(selectItemsFromOutlines(PageItem *, bool)));
17013 fschmid 726
        connect(docCheckerPalette, SIGNAL(selectElement(PageItem *, bool, int)), this, SLOT(selectItemFromOutlines(PageItem *, bool, int)));
5800 fschmid 727
        connect(docCheckerPalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
18888 craig 728
        connect(docCheckerPalette, SIGNAL(selectMasterPage(QString)), this, SLOT(editMasterPagesStart(QString)));
16156 fschmid 729
//      connect(outlinePalette, SIGNAL(selectElement(int, int, bool)), this, SLOT(selectItemsFromOutlines(int, int, bool)));
16122 fschmid 730
        connect(outlinePalette, SIGNAL(selectElementByItem(PageItem *, bool)), this, SLOT(selectItemsFromOutlines(PageItem *, bool)));
16999 fschmid 731
        connect(outlinePalette, SIGNAL(editElementByItem(PageItem *)), this, SLOT(editItemsFromOutlines(PageItem *)));
5800 fschmid 732
        connect(outlinePalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
18888 craig 733
        connect(outlinePalette, SIGNAL(selectMasterPage(QString)), this, SLOT(editMasterPagesStart(QString)));
5800 fschmid 734
//      connect(propertiesPalette, SIGNAL(EditLSt()), this, SLOT(slotEditLineStyles()));
16546 jghali 735
//      connect(nodePalette, SIGNAL(paletteClosed()), propertiesPalette, SLOT(endEdit2()));
736
        connect(nodePalette, SIGNAL(paletteClosed()), this, SLOT(slotSelect()));
5800 fschmid 737
        connect(nodePalette, SIGNAL(DocChanged()), this, SLOT(slotDocCh()));
738
        connect(layerPalette, SIGNAL(LayerChanged()), this, SLOT(showLayer()));
739
 
740
        connect(bookmarkPalette->BView, SIGNAL(MarkMoved()), this, SLOT(StoreBookmarks()));
741
        connect(bookmarkPalette->BView, SIGNAL(changed()), this, SLOT(slotDocCh()));
16122 fschmid 742
        connect(bookmarkPalette->BView, SIGNAL(SelectElement(PageItem *, bool)), this, SLOT(selectItemsFromOutlines(PageItem *, bool)));
5800 fschmid 743
        // guides
744
        connect(scrActions["pageManageGuides"], SIGNAL(toggled(bool)), guidePalette, SLOT(setPaletteShown(bool)));
10581 cbradney 745
        connect(guidePalette, SIGNAL(paletteShown(bool)), scrActions["pageManageGuides"], SLOT(setChecked(bool)));
7087 subik 746
        // char palette
747
        connect(scrActions["insertGlyph"], SIGNAL(toggled(bool)), charPalette, SLOT(setPaletteShown(bool)));
10581 cbradney 748
        connect(charPalette, SIGNAL(paletteShown(bool)), scrActions["insertGlyph"], SLOT(setChecked(bool)));
5800 fschmid 749
}
750
 
10532 avox 751
 
5800 fschmid 752
void ScribusMainWindow::initScrapbook()
753
{
16577 craig 754
        QString scrapbookFileO = QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrap13.scs");
5800 fschmid 755
        QFileInfo scrapbookFileInfoO = QFileInfo(scrapbookFileO);
756
        if (scrapbookFileInfoO.exists())
757
        {
16577 craig 758
                scrapbookPalette->readOldContents(scrapbookFileO, QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrapbook/main"));
5800 fschmid 759
                QDir d = QDir();
16577 craig 760
                d.rename(scrapbookFileO, QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrap13.backup"));
5800 fschmid 761
        }
16577 craig 762
        QString scrapbookTemp = QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrapbook/tmp");
5800 fschmid 763
        QFileInfo scrapbookTempInfo = QFileInfo(scrapbookTemp);
764
        if (scrapbookTempInfo.exists())
765
                scrapbookPalette->readTempContents(scrapbookTemp);
16577 craig 766
        QString scrapbookFile = QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrapbook/main");
5800 fschmid 767
        QFileInfo scrapbookFileInfo = QFileInfo(scrapbookFile);
768
        if (scrapbookFileInfo.exists())
769
                scrapbookPalette->readContents(scrapbookFile);
770
        scrapbookPalette->setScrapbookFileName(scrapbookFile);
15527 fschmid 771
        ScCore->fileWatcher->addDir(scrapbookFile, true);
13955 cbradney 772
        scrapbookPalette->setOpenScrapbooks(prefsManager->appPrefs.scrapbookPrefs.RecentScrapbooks);
5800 fschmid 773
        rebuildRecentPasteMenu();
5806 fschmid 774
        connect(scrapbookPalette, SIGNAL(updateRecentMenue()), this, SLOT(rebuildRecentPasteMenu()));
15526 fschmid 775
        connect(ScCore->fileWatcher, SIGNAL(dirChanged(QString )), scrapbookPalette, SLOT(reloadLib(QString )));
15527 fschmid 776
        connect(ScCore->fileWatcher, SIGNAL(dirDeleted(QString )), scrapbookPalette, SLOT(closeOnDel(QString )));
5800 fschmid 777
}
778
 
10532 avox 779
 
5800 fschmid 780
bool ScribusMainWindow::warningVersion(QWidget *parent)
781
{
782
        bool retval = false;
19605 jghali 783
        int t = ScMessageBox::warning(parent, QObject::tr("Scribus Development Version"), "<qt>" +
17948 jghali 784
                                                                 QObject::tr("You are running a development version of Scribus 1.5.x. The document you are working with was created in Scribus 1.2.x.  Saving the current file under 1.5.x renders it unable to be edited in Scribus 1.2.x versions. To preserve the ability to edit in 1.2.x, save this file under a different name and further edit the newly named file and the original will be untouched. Are you sure you wish to proceed with this operation?") + "</qt>",
19605 jghali 785
                                                                 QMessageBox::Ok | QMessageBox::Cancel,
786
                                                                 QMessageBox::Cancel,   // GUI default
787
                                                                 QMessageBox::Ok);      // batch default
9422 fschmid 788
        if (t == QMessageBox::Ok)
5800 fschmid 789
                retval = true;
790
        return retval;
791
}
792
 
10532 avox 793
 
5800 fschmid 794
void ScribusMainWindow::initMenuBar()
795
{
796
        RecentDocs.clear();
12940 cbradney 797
        scrMenuMgr->createMenu("File", ActionManager::defaultMenuNameEntryTranslated("File"));
18533 craig 798
        scrMenuMgr->addMenuItemString("fileNew", "File");
799
        scrMenuMgr->addMenuItemString("fileNewFromTemplate", "File");
800
        scrMenuMgr->addMenuItemString("fileOpen", "File");
801
        scrMenuMgr->addMenuItemString("FileOpenRecent", "File");
18583 craig 802
        scrMenuMgr->createMenu("FileOpenRecent", tr("Open &Recent"), "File", false, true);
18533 craig 803
        scrMenuMgr->addMenuItemString("SEPARATOR", "File");
804
        scrMenuMgr->addMenuItemString("fileClose", "File");
805
        scrMenuMgr->addMenuItemString("fileSave", "File");
806
        scrMenuMgr->addMenuItemString("fileSaveAs", "File");
807
        scrMenuMgr->addMenuItemString("fileRevert", "File");
808
        scrMenuMgr->addMenuItemString("fileCollect", "File");
809
        scrMenuMgr->addMenuItemString("SEPARATOR", "File");
10558 cbradney 810
        scrMenuMgr->createMenu("FileImport", tr("&Import"), "File");
18533 craig 811
        scrMenuMgr->addMenuItemString("FileImport", "File");
812
        scrMenuMgr->addMenuItemString("fileImportText", "FileImport");
813
        scrMenuMgr->addMenuItemString("fileImportAppendText", "FileImport");
814
        scrMenuMgr->addMenuItemString("fileImportImage", "FileImport");
815
        scrMenuMgr->addMenuItemString("fileImportVector", "FileImport");
816
        scrMenuMgr->addMenuItemString("FileExport", "File");
10558 cbradney 817
        scrMenuMgr->createMenu("FileExport", tr("&Export"), "File");
18533 craig 818
        scrMenuMgr->addMenuItemString("fileExportText", "FileExport");
819
        scrMenuMgr->addMenuItemString("fileExportAsEPS", "FileExport");
820
        scrMenuMgr->addMenuItemString("fileExportAsPDF", "FileExport");
821
        scrMenuMgr->addMenuItemString("SEPARATOR", "File");
822
        scrMenuMgr->addMenuItemString("fileDocSetup150", "File");
823
        scrMenuMgr->addMenuItemString("filePreferences150", "File");
824
        scrMenuMgr->addMenuItemString("SEPARATOR", "File");
825
        scrMenuMgr->addMenuItemString("filePrint", "File");
19179 craig 826
        if ( ScCore->haveGS() || ScCore->isWinGUI() )
827
                scrMenuMgr->addMenuItemString("PrintPreview", "File");
18533 craig 828
        scrMenuMgr->addMenuItemString("SEPARATOR", "File");
829
        scrMenuMgr->addMenuItemString("fileQuit", "File");
5800 fschmid 830
 
6451 fschmid 831
        scrMenuMgr->setMenuEnabled("FileImport", false);
5800 fschmid 832
        scrMenuMgr->setMenuEnabled("FileExport", false);
833
 
12940 cbradney 834
        scrMenuMgr->createMenu("Edit", ActionManager::defaultMenuNameEntryTranslated("Edit"));
18533 craig 835
        scrMenuMgr->addMenuItemString("editUndoAction", "Edit");
836
        scrMenuMgr->addMenuItemString("editRedoAction", "Edit");
837
        scrMenuMgr->addMenuItemString("editActionMode", "Edit");
838
        scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
839
        scrMenuMgr->addMenuItemString("editCut", "Edit");
840
        scrMenuMgr->addMenuItemString("editCopy", "Edit");
841
        scrMenuMgr->addMenuItemString("editPaste", "Edit");
18583 craig 842
        scrMenuMgr->createMenu("EditPasteRecent", tr("Paste Recent"), "Edit",false,true);
10558 cbradney 843
        scrMenuMgr->createMenu("EditContents", tr("Contents"), "Edit");
18533 craig 844
        scrMenuMgr->addMenuItemString("editCopyContents", "EditContents");
845
        scrMenuMgr->addMenuItemString("editPasteContents", "EditContents");
846
        scrMenuMgr->addMenuItemString("editPasteContentsAbs", "EditContents");
847
        scrMenuMgr->addMenuItemString("editClearContents", "EditContents");
19188 craig 848
        scrMenuMgr->addMenuItemString("editTruncateContents", "EditTruncateContents");
18533 craig 849
        scrMenuMgr->addMenuItemString("itemDelete", "Edit");
850
        scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
851
        scrMenuMgr->addMenuItemString("editSelectAll", "Edit");
852
        scrMenuMgr->addMenuItemString("editSelectAllOnLayer", "Edit");
853
        scrMenuMgr->addMenuItemString("editDeselectAll", "Edit");
854
        scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
855
        scrMenuMgr->addMenuItemString("editSearchReplace", "Edit");
856
        scrMenuMgr->addMenuItemString("toolsEditWithStoryEditor", "Edit");
857
        scrMenuMgr->addMenuItemString("editEditWithImageEditor", "Edit");
858
        scrMenuMgr->addMenuItemString("editEditRenderSource", "Edit");
859
        scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
860
        scrMenuMgr->addMenuItemString("editColors", "Edit");
861
        scrMenuMgr->addMenuItemString("editReplaceColors", "Edit");
862
        scrMenuMgr->addMenuItemString("editStyles", "Edit");
863
        scrMenuMgr->addMenuItemString("editMarks", "Edit");
864
        scrMenuMgr->addMenuItemString("editNotesStyles", "Edit");
865
        scrMenuMgr->addMenuItemString("editMasterPages", "Edit");
866
        scrMenuMgr->addMenuItemString("editJavascripts", "Edit");
5827 fschmid 867
        scrMenuMgr->setMenuEnabled("EditPasteRecent", false);
7565 cbradney 868
        scrMenuMgr->setMenuEnabled("EditContents", false);
5800 fschmid 869
 
18756 craig 870
 
5800 fschmid 871
        //Item Menu
12940 cbradney 872
        scrMenuMgr->createMenu("Item", ActionManager::defaultMenuNameEntryTranslated("Item"));
18070 fschmid 873
        scrMenuMgr->createMenu("DuplicateTransform", tr("Duplicate/Transform"), "Item");
18533 craig 874
        scrMenuMgr->addMenuItemString("DuplicateTransform", "Item");
875
        scrMenuMgr->addMenuItemString("itemDuplicate", "DuplicateTransform");
876
        scrMenuMgr->addMenuItemString("itemMulDuplicate", "DuplicateTransform");
877
        scrMenuMgr->addMenuItemString("itemTransform", "DuplicateTransform");
18070 fschmid 878
        scrMenuMgr->createMenu("Grouping", tr("Grouping"), "Item");
18533 craig 879
        scrMenuMgr->addMenuItemString("Grouping", "Item");
880
        scrMenuMgr->addMenuItemString("itemGroup", "Grouping");
881
        scrMenuMgr->addMenuItemString("itemUngroup", "Grouping");
882
        scrMenuMgr->addMenuItemString("itemGroupAdjust", "Grouping");
18070 fschmid 883
        scrMenuMgr->createMenu("Locking", tr("Locking"), "Item");
18533 craig 884
        scrMenuMgr->addMenuItemString("Locking", "Item");
885
        scrMenuMgr->addMenuItemString("itemLock", "Locking");
886
        scrMenuMgr->addMenuItemString("itemLockSize", "Locking");
18070 fschmid 887
        scrMenuMgr->createMenu("ItemLevel", tr("Level"), "Item");
18533 craig 888
        scrMenuMgr->addMenuItemString("ItemLevel", "Item");
18547 craig 889
        scrMenuMgr->addMenuItemString("itemRaise", "ItemLevel");
890
        scrMenuMgr->addMenuItemString("itemLower", "ItemLevel");
891
        scrMenuMgr->addMenuItemString("itemRaiseToTop", "ItemLevel");
892
        scrMenuMgr->addMenuItemString("itemLowerToBottom", "ItemLevel");
18583 craig 893
        scrMenuMgr->createMenu("ItemLayer", tr("Send to La&yer"), "",false, true);
18533 craig 894
        scrMenuMgr->addMenuItemString("ItemLayer", "Item");
18070 fschmid 895
        scrMenuMgr->createMenu("SendTo", tr("Send to"), "Item");
18533 craig 896
        scrMenuMgr->addMenuItemString("SendTo", "Item");
18582 craig 897
        scrMenuMgr->createMenu("ItemSendToScrapbook", tr("Scrapbook"),"",false,true);
18539 craig 898
        scrMenuMgr->addMenuItemString("ItemSendToScrapbook", "SendTo");
18533 craig 899
        scrMenuMgr->addMenuItemString("itemSendToPattern", "SendTo");
900
        scrMenuMgr->addMenuItemString("itemSendToInline", "SendTo");
18070 fschmid 901
        scrMenuMgr->createMenu("Adjust", tr("Adjust"), "Item");
18533 craig 902
        scrMenuMgr->addMenuItemString("Adjust", "Item");
903
        scrMenuMgr->addMenuItemString("itemAdjustFrameHeightToText", "Adjust");
904
        scrMenuMgr->addMenuItemString("itemAdjustFrameToImage", "Adjust");
905
        scrMenuMgr->addMenuItemString("itemAdjustImageToFrame", "Adjust");
18070 fschmid 906
        scrMenuMgr->createMenu("Image", tr("Image"), "Item");
18533 craig 907
        scrMenuMgr->addMenuItemString("Image", "Item");
908
        scrMenuMgr->addMenuItemString("itemUpdateImage", "Image");
909
        scrMenuMgr->addMenuItemString("styleImageEffects", "Image");
910
        scrMenuMgr->addMenuItemString("itemExtendedImageProperties", "Image");
911
        scrMenuMgr->addMenuItemString("itemToggleInlineImage", "Image");
19253 craig 912
        scrMenuMgr->createMenu("ItemPreviewSettings", tr("Preview Settings"));
18533 craig 913
        scrMenuMgr->addMenuItemString("ItemPreviewSettings", "Image");
914
        scrMenuMgr->addMenuItemString("itemImageIsVisible", "ItemPreviewSettings");
915
        scrMenuMgr->addMenuItemString("SEPARATOR", "ItemPreviewSettings");
19465 jghali 916
        scrMenuMgr->addMenuItemString("itemPreviewFull", "ItemPreviewSettings");
917
        scrMenuMgr->addMenuItemString("itemPreviewNormal", "ItemPreviewSettings");
18533 craig 918
        scrMenuMgr->addMenuItemString("itemPreviewLow", "ItemPreviewSettings");
5800 fschmid 919
        scrMenuMgr->createMenu("ItemPDFOptions", tr("&PDF Options"));
18533 craig 920
        scrMenuMgr->addMenuItemString("ItemPDFOptions", "Item");
921
        scrMenuMgr->addMenuItemString("itemPDFIsAnnotation", "ItemPDFOptions");
922
        scrMenuMgr->addMenuItemString("itemPDFIsBookmark", "ItemPDFOptions");
923
        scrMenuMgr->addMenuItemString("itemPDFAnnotationProps", "ItemPDFOptions");
924
        scrMenuMgr->addMenuItemString("itemPDFFieldProps", "ItemPDFOptions");
19436 jghali 925
        scrMenuMgr->createMenu("ItemConvertTo", tr("C&onvert to"), "Item");
18533 craig 926
        scrMenuMgr->addMenuItemString("ItemConvertTo", "Item");
18629 craig 927
        scrMenuMgr->addMenuItemString("itemConvertToTextFrame", "ItemConvertTo");
928
        scrMenuMgr->addMenuItemString("itemConvertToImageFrame", "ItemConvertTo");
929
        scrMenuMgr->addMenuItemString("itemConvertToPolygon", "ItemConvertTo");
18533 craig 930
        scrMenuMgr->addMenuItemString("itemConvertToBezierCurve", "ItemConvertTo");
931
        scrMenuMgr->addMenuItemString("itemConvertToOutlines", "ItemConvertTo");
932
        scrMenuMgr->addMenuItemString("itemConvertToSymbolFrame", "ItemConvertTo");
18070 fschmid 933
        scrMenuMgr->createMenu("TextLinking", tr("Text Frame Links"), "Item");
18533 craig 934
        scrMenuMgr->addMenuItemString("TextLinking", "Item");
935
        scrMenuMgr->addMenuItemString("toolsLinkTextFrame", "TextLinking");
936
        scrMenuMgr->addMenuItemString("toolsUnlinkTextFrame", "TextLinking");
937
        scrMenuMgr->addMenuItemString("toolsUnlinkTextFrameWithTextCopy", "TextLinking");
938
        scrMenuMgr->addMenuItemString("toolsUnlinkTextFrameWithTextCut", "TextLinking");
18070 fschmid 939
        scrMenuMgr->createMenu("ItemPathOps", tr("Path Tools"), "Item");
18533 craig 940
        scrMenuMgr->addMenuItemString("ItemPathOps", "Item");
941
        scrMenuMgr->addMenuItemString("itemCombinePolygons", "ItemPathOps");
942
        scrMenuMgr->addMenuItemString("itemSplitPolygons", "ItemPathOps");
943
        scrMenuMgr->addMenuItemString("itemAttachTextToPath", "ItemPathOps");
944
        scrMenuMgr->addMenuItemString("itemDetachTextFromPath", "ItemPathOps");
15108 cbradney 945
 
5800 fschmid 946
        scrActions["itemPrintingEnabled"]->setEnabled(false);
947
        scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
948
 
18070 fschmid 949
        scrMenuMgr->createMenu("Weld", tr("Welding"), "Item");
18533 craig 950
        scrMenuMgr->addMenuItemString("Weld", "Item");
18629 craig 951
        scrMenuMgr->addMenuItemString("itemWeld", "Weld");
18533 craig 952
        scrMenuMgr->addMenuItemString("itemsUnWeld", "Weld");
953
        scrMenuMgr->addMenuItemString("itemEditWeld", "Weld");
954
        scrMenuMgr->addMenuItemString("editMark", "Item");
17826 craig 955
 
5800 fschmid 956
        //Insert menu
12940 cbradney 957
        scrMenuMgr->createMenu("Insert", ActionManager::defaultMenuNameEntryTranslated("Insert"));
18533 craig 958
        scrMenuMgr->addMenuItemString("insertFrame", "Insert");
959
        scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
960
        scrMenuMgr->addMenuItemString("toolsInsertTextFrame", "Insert");
961
        scrMenuMgr->addMenuItemString("toolsInsertImageFrame", "Insert");
962
        scrMenuMgr->addMenuItemString("toolsInsertRenderFrame", "Insert");
963
        scrMenuMgr->addMenuItemString("toolsInsertTable", "Insert");
964
        scrMenuMgr->addMenuItemString("toolsInsertShape", "Insert");
965
        scrMenuMgr->addMenuItemString("toolsInsertPolygon", "Insert");
966
        scrMenuMgr->addMenuItemString("toolsInsertArc", "Insert");
967
        scrMenuMgr->addMenuItemString("toolsInsertSpiral", "Insert");
968
        scrMenuMgr->addMenuItemString("toolsInsertLine", "Insert");
969
        scrMenuMgr->addMenuItemString("toolsInsertBezier", "Insert");
970
        scrMenuMgr->addMenuItemString("toolsInsertFreehandLine", "Insert");
971
        scrMenuMgr->addMenuItemString("toolsInsertCalligraphicLine", "Insert");
972
        scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
973
        scrMenuMgr->addMenuItemString("stickyTools", "Insert");
974
        scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
975
        scrMenuMgr->addMenuItemString("insertGlyph", "Insert");
5800 fschmid 976
 
10558 cbradney 977
        scrMenuMgr->createMenu("InsertChar", tr("&Character"), "Insert");
18533 craig 978
        scrMenuMgr->addMenuItemString("InsertChar", "Insert");
979
        scrMenuMgr->addMenuItemString("unicodePageNumber", "InsertChar");
980
        scrMenuMgr->addMenuItemString("unicodePageCount", "InsertChar");
981
        scrMenuMgr->addMenuItemString("unicodeSoftHyphen", "InsertChar");
982
        scrMenuMgr->addMenuItemString("unicodeNonBreakingHyphen", "InsertChar");
983
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertChar");
984
        scrMenuMgr->addMenuItemString("unicodeCopyRight", "InsertChar");
985
        scrMenuMgr->addMenuItemString("unicodeRegdTM", "InsertChar");
986
        scrMenuMgr->addMenuItemString("unicodeTM", "InsertChar");
987
        scrMenuMgr->addMenuItemString("unicodeSolidus", "InsertChar");
988
        scrMenuMgr->addMenuItemString("unicodeBullet", "InsertChar");
989
        scrMenuMgr->addMenuItemString("unicodeMidpoint", "InsertChar");
990
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertChar");
991
        scrMenuMgr->addMenuItemString("unicodeDashEm", "InsertChar");
992
        scrMenuMgr->addMenuItemString("unicodeDashEn", "InsertChar");
993
        scrMenuMgr->addMenuItemString("unicodeDashFigure", "InsertChar");
994
        scrMenuMgr->addMenuItemString("unicodeDashQuotation", "InsertChar");
5800 fschmid 995
 
10558 cbradney 996
        scrMenuMgr->createMenu("InsertQuote", tr("&Quote"), "Insert");
18533 craig 997
        scrMenuMgr->addMenuItemString("InsertQuote", "Insert");
998
        scrMenuMgr->addMenuItemString("unicodeQuoteApostrophe", "InsertQuote");
999
        scrMenuMgr->addMenuItemString("unicodeQuoteStraight", "InsertQuote");
1000
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
1001
        scrMenuMgr->addMenuItemString("unicodeQuoteSingleLeft", "InsertQuote");
1002
        scrMenuMgr->addMenuItemString("unicodeQuoteSingleRight", "InsertQuote");
1003
        scrMenuMgr->addMenuItemString("unicodeQuoteDoubleLeft", "InsertQuote");
1004
        scrMenuMgr->addMenuItemString("unicodeQuoteDoubleRight", "InsertQuote");
1005
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
1006
        scrMenuMgr->addMenuItemString("unicodeQuoteSingleReversed", "InsertQuote");
1007
        scrMenuMgr->addMenuItemString("unicodeQuoteDoubleReversed", "InsertQuote");
1008
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
1009
        scrMenuMgr->addMenuItemString("unicodeQuoteLowSingleComma", "InsertQuote");
1010
        scrMenuMgr->addMenuItemString("unicodeQuoteLowDoubleComma", "InsertQuote");
1011
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
1012
        scrMenuMgr->addMenuItemString("unicodeQuoteSingleLeftGuillemet", "InsertQuote");
1013
        scrMenuMgr->addMenuItemString("unicodeQuoteSingleRightGuillemet", "InsertQuote");
1014
        scrMenuMgr->addMenuItemString("unicodeQuoteDoubleLeftGuillemet", "InsertQuote");
1015
        scrMenuMgr->addMenuItemString("unicodeQuoteDoubleRightGuillemet", "InsertQuote");
1016
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
1017
        scrMenuMgr->addMenuItemString("unicodeQuoteCJKSingleLeft", "InsertQuote");
1018
        scrMenuMgr->addMenuItemString("unicodeQuoteCJKSingleRight", "InsertQuote");
1019
        scrMenuMgr->addMenuItemString("unicodeQuoteCJKDoubleLeft", "InsertQuote");
1020
        scrMenuMgr->addMenuItemString("unicodeQuoteCJKDoubleRight", "InsertQuote");
5800 fschmid 1021
 
19100 craig 1022
        scrMenuMgr->createMenu("InsertSpace", tr("S&paces / Breaks"), "Insert");
18533 craig 1023
        scrMenuMgr->addMenuItemString("InsertSpace", "Insert");
1024
        scrMenuMgr->addMenuItemString("unicodeNonBreakingSpace", "InsertSpace");
1025
        scrMenuMgr->addMenuItemString("unicodeSpaceEN", "InsertSpace");
1026
        scrMenuMgr->addMenuItemString("unicodeSpaceEM", "InsertSpace");
1027
        scrMenuMgr->addMenuItemString("unicodeSpaceThin", "InsertSpace");
1028
        scrMenuMgr->addMenuItemString("unicodeSpaceThick", "InsertSpace");
1029
        scrMenuMgr->addMenuItemString("unicodeSpaceMid", "InsertSpace");
1030
        scrMenuMgr->addMenuItemString("unicodeSpaceHair", "InsertSpace");
1031
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertSpace");
1032
        scrMenuMgr->addMenuItemString("unicodeNewLine", "InsertSpace");
1033
        scrMenuMgr->addMenuItemString("unicodeFrameBreak", "InsertSpace");
1034
        scrMenuMgr->addMenuItemString("unicodeColumnBreak", "InsertSpace");
1035
        scrMenuMgr->addMenuItemString("unicodeZerowidthSpace", "InsertSpace");
5800 fschmid 1036
 
10558 cbradney 1037
        scrMenuMgr->createMenu("InsertLigature", tr("Liga&ture"), "Insert");
18533 craig 1038
        scrMenuMgr->addMenuItemString("InsertLigature", "Insert");
1039
        scrMenuMgr->addMenuItemString("unicodeLigature_ff", "InsertLigature");
1040
        scrMenuMgr->addMenuItemString("unicodeLigature_fi", "InsertLigature");
1041
        scrMenuMgr->addMenuItemString("unicodeLigature_fl", "InsertLigature");
1042
        scrMenuMgr->addMenuItemString("unicodeLigature_ffi", "InsertLigature");
1043
        scrMenuMgr->addMenuItemString("unicodeLigature_ffl", "InsertLigature");
1044
        scrMenuMgr->addMenuItemString("unicodeLigature_ft", "InsertLigature");
1045
        scrMenuMgr->addMenuItemString("unicodeLigature_st", "InsertLigature");
5800 fschmid 1046
 
18533 craig 1047
        scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
1048
        scrMenuMgr->addMenuItemString("insertSampleText", "Insert");
1049
        scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
17826 craig 1050
        scrMenuMgr->createMenu("InsertMark", tr("Marks"), "Insert");
18533 craig 1051
        scrMenuMgr->addMenuItemString("InsertMark", "Insert");
1052
        scrMenuMgr->addMenuItemString("insertMarkAnchor", "InsertMark");
18914 craig 1053
        scrMenuMgr->addMenuItemString("insertMark2Mark", "InsertMark");
1054
        scrMenuMgr->addMenuItemString("insertMarkItem", "InsertMark");
18533 craig 1055
        scrMenuMgr->addMenuItemString("insertMarkVariableText", "InsertMark");
1056
        scrMenuMgr->addMenuItemString("insertMarkNote", "InsertMark");
5800 fschmid 1057
 
1058
        //Page menu
12940 cbradney 1059
        scrMenuMgr->createMenu("Page", ActionManager::defaultMenuNameEntryTranslated("Page"));
18533 craig 1060
        scrMenuMgr->addMenuItemString("pageInsert", "Page");
1061
        scrMenuMgr->addMenuItemString("pageImport", "Page");
1062
        scrMenuMgr->addMenuItemString("pageDelete", "Page");
1063
        scrMenuMgr->addMenuItemString("pageCopy", "Page");
1064
        scrMenuMgr->addMenuItemString("pageMove", "Page");
1065
        scrMenuMgr->addMenuItemString("SEPARATOR", "Page");
1066
        scrMenuMgr->addMenuItemString("pageApplyMasterPage", "Page");
1067
        scrMenuMgr->addMenuItemString("pageCopyToMasterPage", "Page");
1068
        scrMenuMgr->addMenuItemString("pageManageGuides", "Page");
19907 craig 1069
        scrMenuMgr->addMenuItemString("pageManageProperties", "Page");
18533 craig 1070
        scrMenuMgr->addMenuItemString("SEPARATOR", "Page");
1071
        scrMenuMgr->addMenuItemString("viewSnapToGrid", "Page");
1072
        scrMenuMgr->addMenuItemString("viewSnapToGuides", "Page");
1073
        scrMenuMgr->addMenuItemString("viewSnapToElements", "Page");
5800 fschmid 1074
 
1075
        //View menu
12940 cbradney 1076
        scrMenuMgr->createMenu("View", ActionManager::defaultMenuNameEntryTranslated("View"));
18249 craig 1077
        scrMenuMgr->createMenu("ViewZoom", tr("Zoom"), "View");
18533 craig 1078
        scrMenuMgr->addMenuItemString("ViewZoom", "View");
1079
        scrMenuMgr->addMenuItemString("viewFitInWindow", "ViewZoom");
1080
        scrMenuMgr->addMenuItemString("viewFitWidth", "ViewZoom");
1081
        scrMenuMgr->addMenuItemString("viewFit50", "ViewZoom");
1082
        scrMenuMgr->addMenuItemString("viewFit75", "ViewZoom");
1083
        scrMenuMgr->addMenuItemString("viewFit100", "ViewZoom");
1084
        scrMenuMgr->addMenuItemString("viewFit200", "ViewZoom");
1085
        scrMenuMgr->addMenuItemString("viewFit400", "ViewZoom");
18249 craig 1086
        scrMenuMgr->createMenu("ViewPreview", tr("Preview"), "View");
18533 craig 1087
        scrMenuMgr->addMenuItemString("ViewPreview", "View");
1088
        scrMenuMgr->addMenuItemString("viewPreviewMode", "ViewPreview");
20252 craig 1089
        scrMenuMgr->createMenu("ViewMeasuring", tr("Measurement"), "View");
18533 craig 1090
        scrMenuMgr->addMenuItemString("ViewMeasuring", "View");
1091
        scrMenuMgr->addMenuItemString("viewShowRulers", "ViewMeasuring");
1092
        scrMenuMgr->addMenuItemString("viewRulerMode", "ViewMeasuring");
1093
        scrMenuMgr->addMenuItemString("showMouseCoordinates", "ViewMeasuring");
18249 craig 1094
        scrMenuMgr->createMenu("ViewTextFrames", tr("Text Frames"), "View");
18533 craig 1095
        scrMenuMgr->addMenuItemString("ViewTextFrames", "View");
1096
        scrMenuMgr->addMenuItemString("viewShowBaseline", "ViewTextFrames");
1097
        scrMenuMgr->addMenuItemString("viewShowColumnBorders", "ViewTextFrames");
1098
        scrMenuMgr->addMenuItemString("viewShowTextChain", "ViewTextFrames");
1099
        scrMenuMgr->addMenuItemString("viewShowTextControls", "ViewTextFrames");
18249 craig 1100
        scrMenuMgr->createMenu("ViewImageFrames", tr("Image Frames"), "View");
18533 craig 1101
        scrMenuMgr->addMenuItemString("ViewImageFrames", "View");
1102
        scrMenuMgr->addMenuItemString("viewShowImages", "ViewImageFrames");
18249 craig 1103
        scrMenuMgr->createMenu("ViewDocument", tr("Document"), "View");
18533 craig 1104
        scrMenuMgr->addMenuItemString("ViewDocument", "View");
1105
        scrMenuMgr->addMenuItemString("viewShowMargins", "ViewDocument");
1106
        scrMenuMgr->addMenuItemString("viewShowBleeds", "ViewDocument");
1107
        scrMenuMgr->addMenuItemString("viewShowFrames", "ViewDocument");
1108
        scrMenuMgr->addMenuItemString("viewShowLayerMarkers", "ViewDocument");
18249 craig 1109
        scrMenuMgr->createMenu("ViewGrids", tr("Grids and Guides"), "View");
18533 craig 1110
        scrMenuMgr->addMenuItemString("ViewGrids", "View");
18545 craig 1111
        scrMenuMgr->addMenuItemString("viewShowGrid", "ViewGrids");
1112
        scrMenuMgr->addMenuItemString("viewShowGuides", "ViewGrids");
5800 fschmid 1113
 
1114
        //CB If this is viewNewView imeplemented, it should be on the windows menu
1115
//      scrMenuMgr->addMenuItem(scrActions["viewNewView"], "View");
1116
 
18070 fschmid 1117
        // Table menu.
1118
        scrMenuMgr->createMenu("ItemTable", ActionManager::defaultMenuNameEntryTranslated("Table"));
18533 craig 1119
        scrMenuMgr->addMenuItemString("tableInsertRows", "ItemTable");
1120
        scrMenuMgr->addMenuItemString("tableInsertColumns", "ItemTable");
1121
        scrMenuMgr->addMenuItemString("tableDeleteRows", "ItemTable");
1122
        scrMenuMgr->addMenuItemString("tableDeleteColumns", "ItemTable");
1123
        scrMenuMgr->addMenuItemString("SEPARATOR", "ItemTable");
1124
        scrMenuMgr->addMenuItemString("tableMergeCells", "ItemTable");
1125
        scrMenuMgr->addMenuItemString("tableSplitCells", "ItemTable");
1126
        scrMenuMgr->addMenuItemString("SEPARATOR", "ItemTable");
1127
        scrMenuMgr->addMenuItemString("tableSetRowHeights", "ItemTable");
1128
        scrMenuMgr->addMenuItemString("tableSetColumnWidths", "ItemTable");
1129
        scrMenuMgr->addMenuItemString("tableDistributeRowsEvenly", "ItemTable");
1130
        scrMenuMgr->addMenuItemString("tableDistributeColumnsEvenly", "ItemTable");
1131
        scrMenuMgr->addMenuItemString("SEPARATOR", "ItemTable");
1132
        scrMenuMgr->addMenuItemString("tableAdjustFrameToTable", "ItemTable");
1133
        scrMenuMgr->addMenuItemString("tableAdjustTableToFrame", "ItemTable");
5800 fschmid 1134
 
1135
        //Extra menu
12940 cbradney 1136
        scrMenuMgr->createMenu("Extras", ActionManager::defaultMenuNameEntryTranslated("Extras"));
18533 craig 1137
        scrMenuMgr->addMenuItemString("extrasHyphenateText", "Extras");
1138
        scrMenuMgr->addMenuItemString("extrasDeHyphenateText", "Extras");
1139
        scrMenuMgr->addMenuItemString("extrasGenerateTableOfContents", "Extras");
18586 craig 1140
        scrMenuMgr->addMenuItemString("itemUpdateMarks", "Extras");
1141
        scrMenuMgr->addMenuItemString("SEPARATOR", "Extras");
1142
        scrMenuMgr->addMenuItemString("extrasManageImages", "Extras");
1143
        scrMenuMgr->addMenuItemString("SEPARATOR", "Extras");
18533 craig 1144
        scrMenuMgr->addMenuItemString("extrasUpdateDocument", "Extras");
1145
        scrMenuMgr->addMenuItemString("extrasTestQTQuick2_1", "Extras");
5800 fschmid 1146
 
1147
        //Window menu
15117 cbradney 1148
        scrMenuMgr->createMenu("Windows", ActionManager::defaultMenuNameEntryTranslated("Windows"), QString::null, true);
5800 fschmid 1149
 
1150
        //Help menu
12940 cbradney 1151
        scrMenuMgr->createMenu("Help", ActionManager::defaultMenuNameEntryTranslated("Help"));
18533 craig 1152
        scrMenuMgr->addMenuItemString("helpManual", "Help");
1153
        scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
1154
        scrMenuMgr->addMenuItemString("helpTooltips", "Help");
1155
        scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
1156
        scrMenuMgr->addMenuItemString("helpOnlineWWW", "Help");
1157
        scrMenuMgr->addMenuItemString("helpOnlineDocs", "Help");
1158
        scrMenuMgr->addMenuItemString("helpOnlineWiki", "Help");
1159
        scrMenuMgr->addMenuItemString("HelpOnlineTutorials", "Help");
1160
        scrMenuMgr->addMenuItemString("helpOnlineTutorial1", "Help");
1161
        scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
1162
        scrMenuMgr->addMenuItemString("helpCheckUpdates", "Help");
1163
        scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
1164
        scrMenuMgr->addMenuItemString("helpAboutScribus", "Help");
1165
        scrMenuMgr->addMenuItemString("helpAboutPlugins", "Help");
1166
        scrMenuMgr->addMenuItemString("helpAboutQt", "Help");
18548 craig 1167
}
10953 subik 1168
 
18548 craig 1169
void ScribusMainWindow::createMenuBar()
1170
{
18533 craig 1171
        scrMenuMgr->addMenuStringToMenuBar("File");
1172
        scrMenuMgr->addMenuItemStringstoMenuBar("File", scrActions);
1173
        scrMenuMgr->addMenuStringToMenuBar("Edit");
1174
        scrMenuMgr->addMenuItemStringstoMenuBar("Edit", scrActions);
1175
        scrMenuMgr->addMenuStringToMenuBar("Item");
1176
        scrMenuMgr->addMenuItemStringstoMenuBar("Item", scrActions);
1177
        scrMenuMgr->addMenuStringToMenuBar("Insert");
1178
        scrMenuMgr->addMenuItemStringstoMenuBar("Insert", scrActions);
1179
        scrMenuMgr->addMenuStringToMenuBar("Page");
1180
        scrMenuMgr->addMenuItemStringstoMenuBar("Page", scrActions);
1181
        scrMenuMgr->addMenuStringToMenuBar("ItemTable");
1182
        scrMenuMgr->addMenuItemStringstoMenuBar("ItemTable", scrActions);
1183
        scrMenuMgr->addMenuStringToMenuBar("Extras");
1184
        scrMenuMgr->addMenuItemStringstoMenuBar("Extras", scrActions);
1185
        scrMenuMgr->addMenuStringToMenuBar("View");
1186
        scrMenuMgr->addMenuItemStringstoMenuBar("View", scrActions);
18583 craig 1187
        scrMenuMgr->addMenuStringToMenuBar("Windows", true);
18533 craig 1188
        addDefaultWindowMenuItems();
10564 fschmid 1189
        menuBar()->addSeparator();
18533 craig 1190
        scrMenuMgr->addMenuStringToMenuBar("Help");
1191
        scrMenuMgr->addMenuItemStringstoMenuBar("Help", scrActions);
18557 craig 1192
        connect(scrMenuMgr->getLocalPopupMenu("Extras"), SIGNAL(aboutToShow()), this, SLOT(extrasMenuAboutToShow()));
1193
        connect(scrMenuMgr->getLocalPopupMenu("Windows"), SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
1194
 
5800 fschmid 1195
}
1196
 
10532 avox 1197
 
5800 fschmid 1198
void ScribusMainWindow::addDefaultWindowMenuItems()
1199
{
1200
        scrMenuMgr->clearMenu("Windows");
18533 craig 1201
        scrMenuMgr->addMenuItemString("windowsCascade", "Windows");
1202
        scrMenuMgr->addMenuItemString("windowsTile", "Windows");
1203
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
1204
        scrMenuMgr->addMenuItemString("toolsProperties", "Windows");
1205
        scrMenuMgr->addMenuItemString("toolsActionHistory", "Windows");
1206
        scrMenuMgr->addMenuItemString("toolsAlignDistribute", "Windows");
1207
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
1208
        scrMenuMgr->addMenuItemString("toolsOutline", "Windows");
1209
        scrMenuMgr->addMenuItemString("toolsPages", "Windows");
1210
        scrMenuMgr->addMenuItemString("toolsLayers", "Windows");
1211
        scrMenuMgr->addMenuItemString("toolsBookmarks", "Windows");
20039 craig 1212
//      scrMenuMgr->addMenuItemString("toolsDownloads", "Windows");
19821 craig 1213
        scrMenuMgr->addMenuItemString("toolsResources", "Windows");
18533 craig 1214
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
1215
        scrMenuMgr->addMenuItemString("toolsScrapbook", "Windows");
1216
        scrMenuMgr->addMenuItemString("toolsSymbols", "Windows");
1217
        scrMenuMgr->addMenuItemString("toolsInline", "Windows");
1218
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
1219
        scrMenuMgr->addMenuItemString("toolsMeasurements", "Windows");
1220
        scrMenuMgr->addMenuItemString("toolsPreflightVerifier", "Windows");
1221
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
1222
        scrMenuMgr->addMenuItemString("toolsToolbarTools", "Windows");
1223
        scrMenuMgr->addMenuItemString("toolsToolbarPDF", "Windows");
19009 craig 1224
        scrMenuMgr->addMenuItemString("toolsToolbarView", "Windows");
19962 fschmid 1225
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
18533 craig 1226
        scrMenuMgr->addMenuItemStringstoMenuBar("Windows", scrActions);
5800 fschmid 1227
}
1228
 
1229
 
1230
void ScribusMainWindow::initStatusBar()
1231
{
18972 craig 1232
        QFont fo = QFont(font());
1233
        int posi = fo.pointSize() - (ScCore->isWinGUI() ? 1 : 2);
1234
        fo.setPointSize(posi);
1235
        unitSwitcher = new QComboBox( this );
19954 craig 1236
        unitSwitcher->setObjectName("unitSwitcher");
18972 craig 1237
        unitSwitcher->setFocusPolicy(Qt::NoFocus);
1238
        unitSwitcher->setFont(fo);
1239
        int maxUindex = unitGetMaxIndex() - 2;
1240
        for (int i = 0; i <= maxUindex; ++i)
1241
                unitSwitcher->addItem(unitGetStrFromIndex(i));
19954 craig 1242
 
1243
 
1244
        QWidget* zoomWidget = new QWidget( statusBar() );
1245
        QHBoxLayout* zoomLayout = new QHBoxLayout( zoomWidget );
1246
        zoomLayout->setMargin(0);
1247
        zoomLayout->setSpacing(1);
1248
 
1249
        zoomSpinBox = new ScrSpinBox( 1, 32000, zoomWidget, 6 );
18972 craig 1250
        zoomSpinBox->setTabAdvance(false);
1251
        zoomSpinBox->setFont(fo);
1252
        zoomSpinBox->setValue( 100 );
1253
        zoomSpinBox->setSingleStep(10);
1254
        zoomSpinBox->setFocusPolicy(Qt::ClickFocus);
1255
        zoomSpinBox->setSuffix( tr( " %" ) );
1256
        layerMenu = new QComboBox( this );
19954 craig 1257
        layerMenu->setObjectName("layerMenu");
18972 craig 1258
        layerMenu->setEditable(false);
1259
        layerMenu->setFont(fo);
1260
        layerMenu->setFocusPolicy(Qt::NoFocus);
1261
        layerMenu->setSizeAdjustPolicy(QComboBox::AdjustToContents);
1262
 
1263
        pageSelector = new PageSelector(this, 1);
19954 craig 1264
        pageSelector->setObjectName("pageSelector");
18972 craig 1265
        pageSelector->setFont(fo);
1266
        pageSelector->setFocusPolicy(Qt::ClickFocus);
1267
 
19954 craig 1268
        zoomDefaultToolbarButton = new QPushButton(zoomWidget);
18972 craig 1269
        zoomDefaultToolbarButton->setFocusPolicy(Qt::NoFocus);
1270
        zoomDefaultToolbarButton->setDefault( false );
1271
        zoomDefaultToolbarButton->setAutoDefault( false );
19954 craig 1272
        zoomOutToolbarButton = new QPushButton(zoomWidget);
18972 craig 1273
        zoomOutToolbarButton->setFocusPolicy(Qt::NoFocus);
1274
        zoomOutToolbarButton->setDefault( false );
1275
        zoomOutToolbarButton->setAutoDefault( false );
19954 craig 1276
        zoomInToolbarButton = new QPushButton(zoomWidget);
18972 craig 1277
        zoomInToolbarButton->setFocusPolicy(Qt::NoFocus);
1278
        zoomInToolbarButton->setDefault( false );
1279
        zoomInToolbarButton->setAutoDefault( false );
19954 craig 1280
 
20196 craig 1281
        zoomDefaultToolbarButton->setIcon(IconManager::instance()->loadIcon("16/zoom-original.png"));
1282
        zoomOutToolbarButton->setIcon(IconManager::instance()->loadIcon("16/zoom-out.png"));
1283
        zoomInToolbarButton->setIcon(IconManager::instance()->loadIcon("16/zoom-in.png"));
18972 craig 1284
 
1285
 
19954 craig 1286
        zoomLayout->addWidget( zoomSpinBox );
1287
        zoomLayout->addWidget( zoomOutToolbarButton );
1288
        zoomLayout->addWidget( zoomDefaultToolbarButton );
1289
        zoomLayout->addWidget( zoomInToolbarButton );
1290
 
10564 fschmid 1291
        mainWindowStatusLabel = new QLabel( "           ", statusBar());
18978 craig 1292
        mainWindowStatusLabel->setFont(fo);
9953 cbradney 1293
        mainWindowProgressBar = new QProgressBar(statusBar());
1294
        mainWindowProgressBar->setAlignment(Qt::AlignHCenter);
5800 fschmid 1295
        mainWindowProgressBar->setFixedWidth( 100 );
1296
        mainWindowProgressBar->reset();
18972 craig 1297
        mainWindowXPosLabel = new QLabel( tr("X:"), statusBar());
18978 craig 1298
        mainWindowXPosLabel->setFont(fo);
18972 craig 1299
        mainWindowYPosLabel = new QLabel( tr("Y:"), statusBar());
18978 craig 1300
        mainWindowYPosLabel->setFont(fo);
19954 craig 1301
        mainWindowXPosDataLabel = new QLabel( "", statusBar());
18978 craig 1302
        mainWindowXPosDataLabel->setFont(fo);
19954 craig 1303
        mainWindowYPosDataLabel = new QLabel( "", statusBar());
18978 craig 1304
        mainWindowYPosDataLabel->setFont(fo);
19954 craig 1305
        mainWindowXPosDataLabel->setMinimumWidth(mainWindowXPosDataLabel->fontMetrics().width("99999.999"));
1306
        mainWindowYPosDataLabel->setMinimumWidth(mainWindowYPosDataLabel->fontMetrics().width("99999.999"));
18972 craig 1307
        statusBarLanguageChange();
1308
 
20196 craig 1309
        /*
19956 craig 1310
        QByteArray stylesheet;
1311
        if (loadRawText(ScPaths::instance().libDir() + "scribus.css", stylesheet))
1312
        {
20185 craig 1313
                QString downArrow(IconManager::instance()->pathForIcon("16/go-down.png"));
19956 craig 1314
                QByteArray da;
1315
                da.append(downArrow);
1316
                stylesheet.replace("___downArrow___", da);
1317
        }
20196 craig 1318
        */
19956 craig 1319
 
1320
        layerMenu->setObjectName("layerMenu");
1321
        unitSwitcher->setObjectName("unitSwitcher");
1322
        zoomDefaultToolbarButton->setObjectName("zoomDefaultToolbarButton");
1323
        zoomInToolbarButton->setObjectName("zoomInToolbarButton");
1324
        zoomOutToolbarButton->setObjectName("zoomOutToolbarButton");
1325
        zoomSpinBox->setObjectName("zoomSpinBox");
1326
 
20196 craig 1327
        /*
19956 craig 1328
        layerMenu->setStyleSheet(stylesheet);
1329
        unitSwitcher->setStyleSheet(stylesheet);
1330
        zoomDefaultToolbarButton->setStyleSheet(stylesheet);
1331
        zoomInToolbarButton->setStyleSheet(stylesheet);
1332
        zoomOutToolbarButton->setStyleSheet(stylesheet);
1333
        zoomSpinBox->setStyleSheet(stylesheet);
20196 craig 1334
        */
19956 craig 1335
 
19009 craig 1336
        statusBar()->setFont(fo);
1337
        statusBar()->addPermanentWidget(mainWindowStatusLabel, 5);
1338
        QLabel *s=new QLabel("");
1339
        QLabel *s2=new QLabel("");
19954 craig 1340
        QLabel *s3=new QLabel("");
19009 craig 1341
        statusBar()->addPermanentWidget(s,1);
19954 craig 1342
        statusBar()->addPermanentWidget(s2,1);
1343
        statusBar()->addPermanentWidget(zoomWidget,0);
1344
        statusBar()->addPermanentWidget(pageSelector,0);
19009 craig 1345
        statusBar()->addPermanentWidget(layerMenu,1);
19954 craig 1346
        statusBar()->addPermanentWidget(s3,3);
10564 fschmid 1347
        statusBar()->addPermanentWidget(mainWindowXPosLabel, 0);
19954 craig 1348
        statusBar()->addPermanentWidget(mainWindowXPosDataLabel, 0);
10564 fschmid 1349
        statusBar()->addPermanentWidget(mainWindowYPosLabel, 0);
19954 craig 1350
        statusBar()->addPermanentWidget(mainWindowYPosDataLabel, 0);
1351
 
19009 craig 1352
        statusBar()->addPermanentWidget(unitSwitcher,0);
1353
        statusBar()->addPermanentWidget(mainWindowProgressBar, 0);
15675 fschmid 1354
        connect(statusBar(), SIGNAL(messageChanged(const QString &)), this, SLOT(setTempStatusBarText(const QString &)));
18972 craig 1355
 
5800 fschmid 1356
}
1357
 
10532 avox 1358
 
5800 fschmid 1359
void ScribusMainWindow::setStatusBarMousePosition(double xp, double yp)
1360
{
18065 fschmid 1361
        if (doc->Pages->count() == 0)
1362
                return;
5800 fschmid 1363
        double xn = xp;
1364
        double yn = yp;
14932 cbradney 1365
        if (doc->guidesPrefs().rulerMode)
5800 fschmid 1366
        {
1367
                xn -= doc->currentPage()->xOffset();
1368
                yn -= doc->currentPage()->yOffset();
1369
        }
1370
        xn -= doc->rulerXoffset;
1371
        yn -= doc->rulerYoffset;
19009 craig 1372
        mainWindowXPosDataLabel->setText(value2String(xn, doc->unitIndex(), true, false));
1373
        mainWindowYPosDataLabel->setText(value2String(yn, doc->unitIndex(), true, false));
5800 fschmid 1374
}
1375
 
15465 avox 1376
void ScribusMainWindow::setStatusBarTextPosition(double base, double xp)
1377
{
18065 fschmid 1378
        if (doc->Pages->count() == 0)
1379
                return;
15465 avox 1380
        mainWindowXPosDataLabel->setText(base + xp >= 0? value2String(xp, doc->unitIndex(), true, true): QString("-"));
1381
        mainWindowYPosDataLabel->setText("-");
1382
}
10532 avox 1383
 
19386 craig 1384
void ScribusMainWindow::setStatusBarTextSelectedItemInfo()
1385
{
1386
        const uint docSelectionCount = doc->m_Selection->count();
1387
        if (docSelectionCount == 0)
19581 craig 1388
        {
19386 craig 1389
                setStatusBarInfoText("");
19581 craig 1390
                return;
1391
        }
1392
        QString widthTxt = value2String(doc->m_Selection->width(), doc->unitIndex(), true, true);
1393
        QString heightTxt = value2String(doc->m_Selection->height(), doc->unitIndex(), true, true);
1394
        if (docSelectionCount == 1)
19386 craig 1395
        {
1396
                QString whatSel = tr("Unknown");
1397
                switch (doc->m_Selection->itemAt(0)->itemType())
1398
                {
1399
                        case 2:
1400
                                whatSel = CommonStrings::itemType_ImageFrame;
1401
                                break;
1402
                        case 4:
1403
                                whatSel = CommonStrings::itemType_TextFrame;
1404
                                break;
1405
                        case 5:
1406
                                whatSel = CommonStrings::itemType_Line;
1407
                                break;
1408
                        case 6:
1409
                                whatSel = CommonStrings::itemType_Polygon;
1410
                                break;
1411
                        case 7:
1412
                                whatSel = CommonStrings::itemType_Polyline;
1413
                                break;
1414
                        case 8:
1415
                                whatSel = CommonStrings::itemType_PathText;
1416
                                break;
1417
                        case 9:
1418
                                whatSel = CommonStrings::itemType_LatexFrame;
1419
                                break;
1420
                        case 11:
1421
                                whatSel = CommonStrings::itemType_Symbol;
1422
                                break;
1423
                        case 12:
1424
                                whatSel = CommonStrings::itemType_Group;
1425
                                break;
1426
                        case 13:
1427
                                whatSel = CommonStrings::itemType_RegularPolygon;
1428
                                break;
1429
                        case 14:
1430
                                whatSel = CommonStrings::itemType_Arc;
1431
                                break;
1432
                        case 15:
1433
                                whatSel = CommonStrings::itemType_Spiral;
1434
                                break;
1435
                        case 16:
1436
                                whatSel = CommonStrings::itemType_Table;
1437
                                break;
1438
                        default:
1439
                                whatSel = "Unknown";
1440
                                break;
1441
                }
1442
                QString txtBody = tr("%1 selected").arg(whatSel) + " : " + tr("Size");
1443
                setStatusBarInfoText( QString("%1 = %3 x %4").arg(txtBody).arg(widthTxt).arg(heightTxt));
1444
        }
1445
        else
1446
        {
1447
                setStatusBarInfoText( tr("%1 Objects selected, Selection Size = %2 x %3").arg(docSelectionCount).arg(widthTxt).arg(heightTxt));
1448
        }
1449
}
1450
 
15675 fschmid 1451
void ScribusMainWindow::setTempStatusBarText(const QString &text)
1452
{
1453
        if (mainWindowStatusLabel)
1454
        {
1455
                if (text.isEmpty())
1456
                        mainWindowStatusLabel->setText(statusLabelText);
1457
                else
1458
                        mainWindowStatusLabel->setText(text);
1459
        }
1460
}
15465 avox 1461
 
5800 fschmid 1462
void ScribusMainWindow::setStatusBarInfoText(QString newText)
1463
{
1464
        if (mainWindowStatusLabel)
1465
                mainWindowStatusLabel->setText(newText);
15675 fschmid 1466
        statusLabelText = newText;
5800 fschmid 1467
}
1468
 
10532 avox 1469
 
1470
//AV to be replaced with Selection::update and listener in PropertiesPalette
5800 fschmid 1471
void ScribusMainWindow::setTBvals(PageItem *currItem)
1472
{
17826 craig 1473
        scrActions["editMark"]->setEnabled(false);
18794 jghali 1474
 
1475
        PageItem* item  = currItem;
1476
        bool inEditMode = (doc->appMode == modeEdit);
1477
        if (doc->appMode == modeEditTable)
5800 fschmid 1478
        {
18794 jghali 1479
                if (currItem->isTable())
1480
                        item = currItem->asTable()->activeCell().textFrame();
1481
                inEditMode = item->isTextFrame();
1482
        }
1483
        if (!item || item->itemText.length() <= 0)
1484
                return;
1485
 
1486
        const ParagraphStyle& currPStyle( inEditMode ? item->currentStyle() : item->itemText.defaultStyle());
1487
        setAlignmentValue(currPStyle.alignment());
18795 jghali 1488
        propertiesPalette->textPal->showParStyle(currPStyle.parent());
1489
        propertiesPalette->textPal->showCharStyle(item->currentCharStyle().parent());
18794 jghali 1490
        doc->currentStyle = item->currentStyle();
1491
        // #8112 : do not use operator= here as it does not update style features
1492
        doc->currentStyle.charStyle().setStyle(item->currentCharStyle());
1493
        emit TextStyle(doc->currentStyle);
1494
        // to go: (av)
1495
        propertiesPalette->textPal->updateStyle(doc->currentStyle);
1496
        //check if mark in cursor place and enable editMark action
1497
        if (doc->appMode == modeEdit && item->itemText.cursorPosition() < item->itemText.length())
1498
        {
18920 craig 1499
                if (item->itemText.hasMark(item->itemText.cursorPosition()))
17826 craig 1500
                {
18920 craig 1501
                        Mark* mark = item->itemText.mark(item->itemText.cursorPosition());
18794 jghali 1502
                        scrActions["editMark"]->setEnabled(true);
18920 craig 1503
                        if ((mark->isType(MARKNoteMasterType) || mark->isType(MARKNoteFrameType)) && (mark->getNotePtr() != NULL))
1504
                                nsEditor->setNotesStyle(mark->getNotePtr()->notesStyle());
17826 craig 1505
                }
18794 jghali 1506
                else
1507
                        scrActions["editMark"]->setEnabled(false);
5800 fschmid 1508
        }
1509
}
1510
 
1511
//Special keys assigned to actions are stolen by the action and not passed to
1512
//keyPressEvent so process them here.
19100 craig 1513
void ScribusMainWindow::specialActionKeyEvent(int unicodevalue)
5800 fschmid 1514
{
19581 craig 1515
        if (!HaveDoc)
1516
                return;
19758 fschmid 1517
//      const QString& actionName="";
19581 craig 1518
        if (doc->m_Selection->count() == 1)
5800 fschmid 1519
        {
19581 craig 1520
                PageItem* selItem = doc->m_Selection->itemAt(0);
1521
                if (((doc->appMode == modeEdit) || (doc->appMode == modeEditTable)) && (selItem->isTextFrame() || selItem->isTable()))
5800 fschmid 1522
                {
19581 craig 1523
                        PageItem_TextFrame *currItem;
1524
                        if (doc->appMode == modeEditTable)
1525
                                currItem = selItem->asTable()->activeCell().textFrame();
1526
                        else
1527
                                currItem = selItem->asTextFrame();
1528
                        if (currItem!=NULL)
5800 fschmid 1529
                        {
19581 craig 1530
                                if (unicodevalue!=-1)
5800 fschmid 1531
                                {
19581 craig 1532
                                        UndoTransaction activeTransaction;
1533
                                        if (currItem->HasSel){
1534
                                                if (UndoManager::undoEnabled())
1535
                                                        activeTransaction = undoManager->beginTransaction(Um::Selection, Um::IGroup, Um::ReplaceText, "", Um::IDelete);
1536
                                                currItem->deleteSelectedTextFromFrame();
1537
                                        }
1538
                                        if (UndoManager::undoEnabled())
5800 fschmid 1539
                                        {
19581 craig 1540
                                                SimpleState *ss = dynamic_cast<SimpleState*>(undoManager->getLastUndo());
19932 jghali 1541
                                                if (ss && ss->get("ETEA") == "insert_frametext")
1542
                                                        ss->set("TEXT_STR",ss->get("TEXT_STR") + QString(QChar(unicodevalue)));
19581 craig 1543
                                                else {
1544
                                                        ss = new SimpleState(Um::InsertText,"",Um::ICreate);
1545
                                                        ss->set("INSERT_FRAMETEXT", "insert_frametext");
1546
                                                        ss->set("ETEA", QString("insert_frametext"));
1547
                                                        ss->set("TEXT_STR", QString(QChar(unicodevalue)));
1548
                                                        ss->set("START", currItem->itemText.cursorPosition());
1549
                                                        UndoObject * undoTarget = currItem;
1550
                                                        if (currItem->isNoteFrame())
1551
                                                        {
1552
                                                                undoTarget = doc;
1553
                                                                ss->set("noteframeName", currItem->getUName());
1554
                                                        }
1555
                                                        undoManager->action(undoTarget, ss);
17641 craig 1556
                                                }
19581 craig 1557
                                        }
1558
                                        currItem->itemText.insertChars(QString(QChar(unicodevalue)), true);
1559
                                        if (activeTransaction)
1560
                                                activeTransaction.commit();
1561
                                }
1562
                                else if (unicodevalue==SpecialChars::SHYPHEN.unicode()) //ignore the char as we use an attribute if the text item, for now.
1563
                                {
1564
                                        // this code is currently dead since unicodeSoftHyphen
1565
                                        // doesnt have unicodevalue == -1 any more
1566
                                        if (currItem->itemText.cursorPosition() > 1)
1567
                                        {
1568
#if 0
1569
                                                StyleFlag fl = currItem->itemText.item(qMax(currItem->CPos-1,0))->effects();
1570
                                                fl |= ScStyle_HyphenationPossible;
1571
                                                currItem->itemText.item(qMax(currItem->CPos-1,0))->setEffects(fl);
1572
#else
17641 craig 1573
                                                if (UndoManager::undoEnabled())
1574
                                                {
1575
                                                        SimpleState *ss = dynamic_cast<SimpleState*>(undoManager->getLastUndo());
19932 jghali 1576
                                                        if (ss && ss->get("ETEA") == "insert_frametext")
1577
                                                                ss->set("TEXT_STR",ss->get("TEXT_STR") + QString(SpecialChars::SHYPHEN));
17641 craig 1578
                                                        else {
1579
                                                                ss = new SimpleState(Um::InsertText,"",Um::ICreate);
1580
                                                                ss->set("INSERT_FRAMETEXT", "insert_frametext");
1581
                                                                ss->set("ETEA", QString("insert_frametext"));
19581 craig 1582
                                                                ss->set("TEXT_STR", QString(SpecialChars::SHYPHEN));
17641 craig 1583
                                                                ss->set("START", currItem->itemText.cursorPosition());
17826 craig 1584
                                                                UndoObject * undoTarget = currItem;
1585
                                                                if (currItem->isNoteFrame())
1586
                                                                {
1587
                                                                        undoTarget = doc;
1588
                                                                        ss->set("noteframeName", currItem->getUName());
1589
                                                                }
1590
                                                                undoManager->action(undoTarget, ss);
17641 craig 1591
                                                        }
1592
                                                }
19581 craig 1593
                                                currItem->itemText.insertChars(QString(SpecialChars::SHYPHEN), true);
5800 fschmid 1594
#endif
1595
                                        }
1596
                                }
19581 craig 1597
                                if (doc->appMode == modeEditTable)
1598
                                        selItem->asTable()->update();
1599
                                else
1600
                                        currItem->update();
5800 fschmid 1601
                        }
1602
                }
1603
        }
1604
}
1605
 
1606
bool ScribusMainWindow::eventFilter( QObject* /*o*/, QEvent *e )
1607
{
1608
        bool retVal;
9562 fschmid 1609
        if (e->type() == QEvent::ToolTip)
13955 cbradney 1610
                return (!prefsManager->appPrefs.displayPrefs.showToolTips);
19581 craig 1611
 
11960 subik 1612
        if ( e->type() == QEvent::KeyPress )
11893 cbradney 1613
        {
5800 fschmid 1614
                QKeyEvent *k = (QKeyEvent *)e;
1615
                int keyMod=0;
10390 cbradney 1616
                if (k->modifiers() & Qt::ShiftModifier)
8523 cbradney 1617
                        keyMod |= Qt::SHIFT;
10390 cbradney 1618
                if (k->modifiers() & Qt::ControlModifier)
8523 cbradney 1619
                        keyMod |= Qt::CTRL;
10390 cbradney 1620
                if (k->modifiers() & Qt::AltModifier)
8523 cbradney 1621
                        keyMod |= Qt::ALT;
5800 fschmid 1622
 
1623
                QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
18194 fschmid 1624
                if (QString(currKeySeq.toString()).isNull())
1625
                        return false;
5800 fschmid 1626
                retVal=true;
1627
                //Palette actions
19304 craig 1628
                if (actionManager->compareKeySeqToShortcut(currKeySeq, "specialToggleAllPalettes"))
8613 cbradney 1629
                        scrActions["specialToggleAllPalettes"]->activate(QAction::Trigger);
5800 fschmid 1630
                else
19304 craig 1631
                if (actionManager->compareKeySeqToShortcut(currKeySeq, "specialToggleAllGuides"))
15302 cbradney 1632
                        scrActions["specialToggleAllGuides"]->activate(QAction::Trigger);
1633
                else
18920 craig 1634
                        retVal=false;
5800 fschmid 1635
        }
1636
        else
1637
                retVal=false;
1638
        //Return false to pass event to object
1639
        return retVal;
1640
}
1641
 
10532 avox 1642
 
16546 jghali 1643
void ScribusMainWindow::inputMethodEvent ( QInputMethodEvent * event )
1644
{
17761 jghali 1645
        //qDebug() << "IMEmw" << event->commitString() << event->preeditString() << "attributes:" << event->attributes().count();
16546 jghali 1646
}
1647
 
1648
QVariant ScribusMainWindow::inputMethodQuery ( Qt::InputMethodQuery query ) const
1649
{
17761 jghali 1650
        //qDebug() << "IMQmw" << query;
16546 jghali 1651
        return QVariant();
1652
}
1653
 
10532 avox 1654
//AV -> CanvasMode
5800 fschmid 1655
void ScribusMainWindow::keyPressEvent(QKeyEvent *k)
1656
{
13950 fschmid 1657
        QList<QMdiSubWindow *> windows;
1658
        QMdiSubWindow* w = NULL;
5800 fschmid 1659
        int kk = k->key();
7435 fschmid 1660
        if (HaveDoc)
1661
        {
8523 cbradney 1662
                if ((doc->appMode == modeMagnifier) && (kk == Qt::Key_Shift))
7435 fschmid 1663
                {
20185 craig 1664
                        view->setCursor(IconManager::instance()->loadCursor("LupeZm.xpm"));
7435 fschmid 1665
                        return;
1666
                }
1667
        }
5800 fschmid 1668
        if (keyrep)
1669
                return;
1670
        keyrep = true;
10390 cbradney 1671
        int keyMod=0;
1672
        if (k->modifiers() & Qt::ShiftModifier)
1673
                keyMod |= Qt::SHIFT;
1674
        if (k->modifiers() & Qt::ControlModifier)
1675
                keyMod |= Qt::CTRL;
1676
        if (k->modifiers() & Qt::AltModifier)
1677
                keyMod |= Qt::ALT;
5800 fschmid 1678
        //User presses escape and we have a doc open, and we have an item selected
8523 cbradney 1679
        if ((kk == Qt::Key_Escape) && (HaveDoc))
5800 fschmid 1680
        {
1681
                keyrep = false;
1682
                PageItem *currItem;
18871 craig 1683
                if (!doc->m_Selection->isEmpty())
5800 fschmid 1684
                {
1685
                        currItem = doc->m_Selection->itemAt(0);
1686
                        switch (doc->appMode)
1687
                        {
1688
                                case modeNormal:
10532 avox 1689
                                case modeEditClip:
5800 fschmid 1690
                                        currItem->Sizing = false;
1691
                                        if (doc->SubMode != -1)
1692
                                        {
1693
                                                view->Deselect(false);
16943 fschmid 1694
                                                doc->Items->removeOne(currItem);
5800 fschmid 1695
                                        }
5967 fschmid 1696
                                        else
1697
                                                view->Deselect(false);
11576 avox 1698
                                        view->cancelGroupTransaction();
5800 fschmid 1699
                                        break;
7436 fschmid 1700
                                case modeEdit:
11576 avox 1701
                                        view->cancelGroupTransaction();
7436 fschmid 1702
                                        break;
17094 jghali 1703
                                case modeCopyProperties:
1704
                                case modeEditGradientVectors:
1705
                                case modeEditMeshGradient:
5800 fschmid 1706
                                case modeLinkFrames:
1707
                                case modeUnlinkFrames:
1708
                                case modeRotation:
1709
                                        view->Deselect(false);
17094 jghali 1710
                                case modeEditWeldPoint:
12022 cbradney 1711
                                case modeEyeDropper:
12971 jghali 1712
                                case modeImportObject:
17735 craig 1713
                                case modeImportImage:
5800 fschmid 1714
                                case modePanning:
11490 avox 1715
                                        view->requestMode(modeNormal);
5800 fschmid 1716
                                        break;
1717
                                case modeDrawBezierLine:
11672 cbradney 1718
                                        currItem->PoLine.resize(qMax(0, static_cast<int>(currItem->PoLine.size())-2));
5800 fschmid 1719
                                        if (currItem->PoLine.size() < 4)
1720
                                        {
1721
                                                view->Deselect(false);
16943 fschmid 1722
                                                doc->Items->removeOne(currItem);
5800 fschmid 1723
                                        }
1724
                                        else
1725
                                        {
16943 fschmid 1726
                                                doc->SizeItem(currItem->PoLine.WidthHeight().x(), currItem->PoLine.WidthHeight().y(), currItem, false, false);
8591 cbradney 1727
                                                currItem->setPolyClip(qRound(qMax(currItem->lineWidth() / 2.0, 1.0)));
7736 cbradney 1728
                                                doc->AdjustItemSize(currItem);
5800 fschmid 1729
                                                currItem->ContourLine = currItem->PoLine.copy();
1730
                                                currItem->ClipEdited = true;
1731
                                                currItem->FrameType = 3;
1732
                                                slotDocCh();
1733
                                        }
1734
                                        view->FirstPoly = true;
1735
                                        break;
1736
                                default:
11704 fschmid 1737
                                        if (currItem->Sizing)
1738
                                        {
1739
                                                view->Deselect(false);
16943 fschmid 1740
                                                doc->Items->removeOne(currItem);
11704 fschmid 1741
                                        }
5800 fschmid 1742
                                        break;
1743
                        }
1744
                }
1745
                doc->DragP = false;
1746
                doc->leaveDrag = false;
10532 avox 1747
                view->stopAllDrags();
5800 fschmid 1748
                doc->SubMode = -1;
1749
                doc->ElemToLink = NULL;
1750
                slotSelect();
18871 craig 1751
                if (doc->m_Selection->isEmpty())
19288 jghali 1752
                        HaveNewSel();
13955 cbradney 1753
                prefsManager->appPrefs.uiPrefs.stickyTools = false;
1754
                scrActions["stickyTools"]->setChecked(false);
5800 fschmid 1755
                return;
1756
        }
10390 cbradney 1757
        Qt::KeyboardModifiers buttonModifiers = k->modifiers();
5800 fschmid 1758
        /**If we have a doc and we are not changing the page or zoom level in the status bar */
18972 craig 1759
        if ((HaveDoc) && (!zoomSpinBox->hasFocus()) && (!pageSelector->hasFocus()))
5800 fschmid 1760
        {
11146 cbradney 1761
                //Show our context menu
19304 craig 1762
                if (actionManager->compareKeySeqToShortcut(kk, buttonModifiers, "viewShowContextMenu"))
11146 cbradney 1763
                {
1764
                        ContextMenu* cmen=NULL;
18871 craig 1765
                        if (doc->m_Selection->isEmpty())
11146 cbradney 1766
                        {
1767
                                //CB We should be able to get this calculated by the canvas.... it is already in m_canvas->globalToCanvas(m->globalPos());
1768
                                QPoint p(QCursor::pos() - mapToGlobal(QPoint(0,0)));
1769
                                FPoint fp(p.x() / view->scale() + doc->minCanvasCoordinate.x(),
11960 subik 1770
                                p.y() / view->scale() + doc->minCanvasCoordinate.y());
11146 cbradney 1771
                                cmen = new ContextMenu(this, doc, fp.x(), fp.y());
1772
                        }
1773
                        else
1774
                                cmen = new ContextMenu(*(doc->m_Selection), this, doc);
1775
                        if (cmen)
1776
                        {
1777
                                setUndoMode(true);
1778
                                cmen->exec(QCursor::pos());
1779
                                setUndoMode(false);
1780
                        }
1781
                        delete cmen;
1782
                }
11960 subik 1783
 
1784
 
5800 fschmid 1785
                /**
1786
                 * With no item selected we can:
1787
                 * - With space, get into panning mode (modePanning)
1788
                 * - With PageUp, scroll up
1789
                 * - With PageDown, scroll down
1790
                 * - With Tab, change active document windowActivated
1791
                 */
1792
 
18871 craig 1793
                if ((doc->appMode != modeEdit) && (doc->m_Selection->isEmpty()))
5800 fschmid 1794
                {
6284 fschmid 1795
                        int pg;
13870 cbradney 1796
                        int wheelVal = prefsManager->mouseWheelJump();
10390 cbradney 1797
                        if ((buttonModifiers & Qt::ShiftModifier) && !(buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
8970 fschmid 1798
                                wheelVal = qMax(qRound(wheelVal / 10.0), 1);
5800 fschmid 1799
                        switch (kk)
1800
                        {
8523 cbradney 1801
                        case Qt::Key_Space:
5800 fschmid 1802
                                keyrep = false;
1803
                                if (doc->appMode == modePanning)
10532 avox 1804
                                        view->requestMode(modeNormal);
5800 fschmid 1805
                                else
10532 avox 1806
                                        view->requestMode(modePanning);
5800 fschmid 1807
                                return;
1808
                                break;
10564 fschmid 1809
                        case Qt::Key_PageUp:
17410 fschmid 1810
                                if (doc->masterPageMode() || doc->symbolEditMode() || doc->inlineEditMode())
13870 cbradney 1811
                                        view->scrollBy(0, -prefsManager->mouseWheelJump());
6284 fschmid 1812
                                else
1813
                                {
1814
                                        pg = doc->currentPageNumber();
10390 cbradney 1815
                                        if ((buttonModifiers & Qt::ShiftModifier) && !(buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
6284 fschmid 1816
                                                pg--;
1817
                                        else
15407 craig 1818
                                                pg -= doc->pageSets()[doc->pagePositioning()].Columns;
6284 fschmid 1819
                                        if (pg > -1)
1820
                                                view->GotoPage(pg);
1821
                                }
5800 fschmid 1822
                                keyrep = false;
1823
                                return;
1824
                                break;
10564 fschmid 1825
                        case Qt::Key_PageDown:
17410 fschmid 1826
                                if (doc->masterPageMode() || doc->symbolEditMode() || doc->inlineEditMode())
13870 cbradney 1827
                                        view->scrollBy(0, prefsManager->mouseWheelJump());
6284 fschmid 1828
                                else
1829
                                {
1830
                                        pg = doc->currentPageNumber();
10390 cbradney 1831
                                        if ((buttonModifiers & Qt::ShiftModifier) && !(buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
6284 fschmid 1832
                                                pg++;
1833
                                        else
15407 craig 1834
                                                pg += doc->pageSets()[doc->pagePositioning()].Columns;
7328 fschmid 1835
                                        if (pg < static_cast<int>(doc->Pages->count()))
6284 fschmid 1836
                                                view->GotoPage(pg);
1837
                                }
5800 fschmid 1838
                                keyrep = false;
1839
                                return;
1840
                                break;
8970 fschmid 1841
                        case Qt::Key_Left:
1842
                                view->scrollBy(-wheelVal, 0);
1843
                                keyrep = false;
1844
                                return;
1845
                                break;
1846
                        case Qt::Key_Right:
1847
                                view->scrollBy(wheelVal, 0);
1848
                                keyrep = false;
1849
                                return;
1850
                                break;
1851
                        case Qt::Key_Up:
1852
                                view->scrollBy(0, -wheelVal);
1853
                                keyrep = false;
1854
                                return;
1855
                                break;
1856
                        case Qt::Key_Down:
1857
                                view->scrollBy(0, wheelVal);
1858
                                keyrep = false;
1859
                                return;
1860
                                break;
8523 cbradney 1861
                        case Qt::Key_Tab:
14034 jghali 1862
                                if (buttonModifiers == Qt::ControlModifier)
5800 fschmid 1863
                                {
14034 jghali 1864
                                        keyrep = false;
1865
                                        windows = mdiArea->subWindowList();
1866
                                        if (windows.count() > 1)
5800 fschmid 1867
                                        {
14034 jghali 1868
                                                for (int i = 0; i < static_cast<int>(windows.count()); ++i)
5800 fschmid 1869
                                                {
14034 jghali 1870
                                                        if (mdiArea->activeSubWindow() == windows.at(i))
1871
                                                        {
1872
                                                                if (i == static_cast<int>(windows.count()-1))
1873
                                                                        w = windows.at(0);
1874
                                                                else
1875
                                                                        w = windows.at(i+1);
1876
                                                                break;
1877
                                                        }
5800 fschmid 1878
                                                }
14034 jghali 1879
                                                outlinePalette->buildReopenVals();
1880
                                                docCheckerPalette->clearErrorList();
1881
                                                if ( w )
1882
                                                        w->showNormal();
1883
                                                newActWin(w);
5800 fschmid 1884
                                        }
14034 jghali 1885
                                        return;
5800 fschmid 1886
                                }
1887
                                break;
1888
                        }
1889
                }
1890
        }
1891
        switch(kk)
1892
        {
8523 cbradney 1893
                case Qt::Key_Left:
1894
                case Qt::Key_Right:
1895
                case Qt::Key_Up:
1896
                case Qt::Key_Down:
5800 fschmid 1897
                        _arrowKeyDown = true;
1898
        }
1899
        keyrep = false;
1900
}
1901
 
1902
void ScribusMainWindow::keyReleaseEvent(QKeyEvent *k)
1903
{
10390 cbradney 1904
        //Exit out of panning mode if Control is release while the right mouse button is pressed
1905
        if (HaveDoc)
5800 fschmid 1906
        {
10390 cbradney 1907
                if ((doc->appMode == modePanning) && (k->key() == Qt::Key_Control) && (QApplication::mouseButtons() & Qt::RightButton))
10532 avox 1908
                        view->requestMode(modeNormal);
5800 fschmid 1909
        }
7435 fschmid 1910
        if (HaveDoc)
1911
        {
1912
                if (doc->appMode == modeMagnifier)
20185 craig 1913
                        view->setCursor(IconManager::instance()->loadCursor("LupeZ.xpm"));
7435 fschmid 1914
        }
5800 fschmid 1915
        if (k->isAutoRepeat() || !_arrowKeyDown)
1916
                return;
1917
        switch(k->key())
1918
        {
8523 cbradney 1919
                case Qt::Key_Left:
1920
                case Qt::Key_Right:
1921
                case Qt::Key_Up:
1922
                case Qt::Key_Down:
5800 fschmid 1923
                        _arrowKeyDown = false;
18972 craig 1924
                        if ((HaveDoc) && (!zoomSpinBox->hasFocus()) && (!pageSelector->hasFocus()))
5800 fschmid 1925
                        {
10390 cbradney 1926
                                int docSelectionCount=doc->m_Selection->count();
10532 avox 1927
                                if ((docSelectionCount != 0) && (doc->appMode == modeEditClip) && (doc->nodeEdit.hasNodeSelected()))
9735 fschmid 1928
                                {
1929
                                        PageItem *currItem = doc->m_Selection->itemAt(0);
1930
                                        double xposOrig = currItem->xPos();
1931
                                        double yposOrig = currItem->yPos();
1932
                                        doc->AdjustItemSize(currItem);
19946 craig 1933
                                        if (!doc->nodeEdit.isContourLine())
9735 fschmid 1934
                                                currItem->ContourLine.translate(xposOrig - currItem->xPos(),yposOrig - currItem->yPos());
10532 avox 1935
                                        currItem->update();
9735 fschmid 1936
                                }
10390 cbradney 1937
                                for (int i = 0; i < docSelectionCount; ++i)
5800 fschmid 1938
                                        doc->m_Selection->itemAt(i)->checkChanges(true);
1939
                                if (docSelectionCount > 1 && view->groupTransactionStarted())
11576 avox 1940
                                        view->endGroupTransaction();
5800 fschmid 1941
                        }
1942
                        break;
1943
        }
1944
}
1945
 
10859 cbradney 1946
void ScribusMainWindow::changeEvent(QEvent *e)
1947
{
1948
        if (e->type() == QEvent::LanguageChange)
1949
                languageChange();
10903 cbradney 1950
        else
1951
                QWidget::changeEvent(e);
10859 cbradney 1952
}
1953
 
5800 fschmid 1954
void ScribusMainWindow::closeEvent(QCloseEvent *ce)
1955
{
13487 cbradney 1956
        //Do not quit if Preferences or new doc window is open
14658 cbradney 1957
        PreferencesDialog *prefsDialog = findChild<PreferencesDialog *>(QString::fromLocal8Bit("PreferencesDialog"));
13487 cbradney 1958
        NewDoc *newDocWin = findChild<NewDoc *>(QString::fromLocal8Bit("NewDocumentWindow"));
15834 fschmid 1959
        if <