Subversion Repositories Scribus

Rev

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