Subversion Repositories Scribus

Rev

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