Subversion Repositories Scribus

Rev

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

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