Subversion Repositories Scribus

Rev

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