Subversion Repositories Scribus

Rev

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