Subversion Repositories Scribus

Rev

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