Subversion Repositories Scribus

Rev

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