Subversion Repositories Scribus

Rev

Rev 6549 | Rev 6565 | 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
 
24
#include <qaccel.h>
25
#include <qapplication.h>
204 Franz 26
#include <qeventloop.h>
3 paul 27
#include <qcolordialog.h>
28
#include <qcolor.h>
29
#include <qiconset.h>
30
#include <qtextstream.h>
31
#include <qstylefactory.h>
32
#include <qregexp.h>
33
#include <qtextcodec.h>
34
#include <qcursor.h>
35
#include <qvbox.h>
1208 cbradney 36
#include <qpixmap.h>
37
#include <qkeysequence.h>
38
 
3 paul 39
#include <cstdio>
40
#include <cstdlib>
391 Franz 41
#include <cmath>
2629 craig 42
 
2688 craig 43
#include "scconfig.h"
2629 craig 44
 
45
#ifdef HAVE_DLFCN_H
3 paul 46
#include <dlfcn.h>
2629 craig 47
#endif
48
 
49
#ifdef HAVE_UNISTD_H
135 Franz 50
#include <unistd.h>
2629 craig 51
#endif
52
 
3 paul 53
#include <iostream>
119 Franz 54
#include <signal.h>
80 Franz 55
#include <string>
1208 cbradney 56
 
3457 avox 57
#include "sccombobox.h"
2160 cbradney 58
#include "scribusapp.h"
5243 cbradney 59
#include "scribuscore.h"
3 paul 60
#include "scribus.h"
61
#include "scribus.moc"
62
#include "newfile.h"
63
#include "page.h"
64
#include "query.h"
65
#include "mdup.h"
6442 cbradney 66
#include "multipleduplicate.h"
3 paul 67
#include "docinfo.h"
68
#include "reformdoc.h"
69
#include "serializer.h"
2355 cbradney 70
#include "aligndistribute.h"
3 paul 71
#include "fmitem.h"
72
#include "fontprefs.h"
1641 cbradney 73
#include "prefs.h"
3251 craig 74
#include "prefscontext.h"
1158 cbradney 75
#include "prefstable.h"
3 paul 76
#include "pdfopts.h"
3133 fschmid 77
#include "pdflib.h"
3 paul 78
#include "inspage.h"
79
#include "delpages.h"
80
#include "movepage.h"
81
#include "helpbrowser.h"
82
#include "scribusXml.h"
1641 cbradney 83
#include "about.h"
3247 craig 84
#include "aboutplugins.h"
3136 fschmid 85
#include "pslib.h"
3 paul 86
#include "druck.h"
87
#include "editformats.h"
88
#include "muster.h"
3187 fschmid 89
#include "newtemp.h"
1806 cbradney 90
#include "applytemplatedialog.h"
3 paul 91
#include "picstatus.h"
92
#include "customfdialog.h"
93
#include "cmsprefs.h"
94
#include "annot.h"
95
#include "annota.h"
96
#include "javadocs.h"
151 Franz 97
#include "colorm.h"
265 Franz 98
#include "mpalette.h"
3540 cbradney 99
#include "cpalette.h"
1525 cbradney 100
#include "bookpalette.h"
101
#include "seiten.h"
102
#include "layers.h"
103
#include "frameedit.h"
104
#include "splash.h"
284 Franz 105
#include "measurements.h"
364 Franz 106
#include "gtgettext.h"
506 fschmid 107
#include "fileloader.h"
740 fschmid 108
#include "arrowchooser.h"
788 fschmid 109
#include "tabtypography.h"
879 fschmid 110
#include "tabguides.h"
1194 fschmid 111
#include "tabtools.h"
1114 tsoots 112
#include "undogui.h"
1151 fschmid 113
#include "filewatcher.h"
1202 fschmid 114
#include "charselect.h"
1232 fschmid 115
#include "checkDocument.h"
1235 fschmid 116
#include "tabcheckdoc.h"
1307 fschmid 117
#include "tabpdfoptions.h"
1641 cbradney 118
#include "docitemattrprefs.h"
1644 cbradney 119
#include "pageitemattributes.h"
3829 cbradney 120
#include "pageitem_textframe.h"
4579 cbradney 121
#include "pageitem_imageframe.h"
1694 cbradney 122
#include "tocindexprefs.h"
2441 cbradney 123
#include "tocgenerator.h"
3201 subik 124
#include "collect4output.h"
6397 cbradney 125
#include "fpoint.h"
3 paul 126
#include "fpointarray.h"
127
#include "hysettings.h"
128
#include "guidemanager.h"
129
#include "mergedoc.h"
27 Franz 130
#include "lineformats.h"
102 Franz 131
#include "story.h"
123 Franz 132
#include "autoform.h"
140 Franz 133
#include "tabmanager.h"
164 Franz 134
#include "search.h"
169 Franz 135
#include "fontcombo.h"
4689 mrdocs 136
#include "colorcombo.h"
415 Franz 137
#include "prefsfile.h"
1114 tsoots 138
#include "undomanager.h"
731 fschmid 139
#include "polygonwidget.h"
766 cbradney 140
#include "werktoolb.h"
806 cbradney 141
#include "units.h"
838 cbradney 142
#include "hruler.h"
143
#include "vruler.h"
3053 avox 144
#include "pageselector.h"
1208 cbradney 145
#include "scraction.h"
146
#include "menumanager.h"
1293 tsoots 147
#include "undostate.h"
1414 fschmid 148
#include "tree.h"
1500 cbradney 149
#include "scrap.h"
1549 subik 150
#include "pluginmanager.h"
1693 craig 151
#include "scpaths.h"
1972 craig 152
#include "pdfoptions.h"
1993 cbradney 153
#include "actionmanager.h"
2024 cbradney 154
#include "documentinformation.h"
2056 fschmid 155
#include "effectsdialog.h"
2111 cbradney 156
#include "documentchecker.h"
4506 cbradney 157
#include "gsutil.h"
2658 fschmid 158
#include "pagesize.h"
2707 subik 159
#include "loremipsum.h"
2769 fschmid 160
#include "marginWidget.h"
2777 fschmid 161
#include "margindialog.h"
2834 cbradney 162
#include "prefsmanager.h"
2901 fschmid 163
#include "pagelayout.h"
2952 cbradney 164
#include "commonstrings.h"
3165 fschmid 165
#include "preview.h"
3252 craig 166
#include "scribuswin.h"
167
#include "hyphenator.h"
3510 cbradney 168
#include "scmessagebox.h"
3706 fschmid 169
#include "imageinfodialog.h"
3934 cbradney 170
#include "selection.h"
4829 tsoots 171
#include "stylemanager.h"
172
#include "smlinestyle.h"
5184 avox 173
#include "util.h"
174
#include "text/nlsconfig.h"
5653 cbradney 175
#include "plugins/formatidlist.h"
5731 avox 176
#include "scgtplugin.h"
5806 fschmid 177
#include "stencilreader.h"
5851 subik 178
#include "langmgr.h"
5850 tsoots 179
#include "smtextstyles.h"
6083 cbradney 180
#include "insertaframe.h"
6368 fschmid 181
#include "patterndialog.h"
134 Franz 182
 
4361 cbradney 183
#if defined(_WIN32)
184
#include "scwinprint.h"
5178 mrdocs 185
#include "scdocoutput_ps2.h"
4361 cbradney 186
#endif
187
 
3 paul 188
using namespace std;
189
 
3234 fschmid 190
bool previewDinUse;
191
bool printDinUse;
2891 cbradney 192
 
3 paul 193
QString DocDir;
3205 craig 194
 
5781 cbradney 195
//extern ScribusCore* ScCore;
2536 cbradney 196
extern ScribusQApp* ScQApp;
2634 cbradney 197
extern bool emergencyActivated;
3 paul 198
 
4026 craig 199
ScribusMainWindow::ScribusMainWindow()
2161 cbradney 200
{
5781 cbradney 201
        actionManager=0;
202
        scrMenuMgr=0;
203
        prefsManager=0;
204
        mainWindowStatusLabel=0;
3580 avox 205
#ifdef Q_WS_MAC
206
        noIcon = loadIcon("noicon.xpm");
207
#endif
4026 craig 208
} // ScribusMainWindow::ScribusMainWindow()
188 Franz 209
 
767 cbradney 210
/*
211
 * retval 0 - ok, 1 - no fonts, ...
212
 */
5243 cbradney 213
int ScribusMainWindow::initScMW(bool primaryMainWindow)
188 Franz 214
{
767 cbradney 215
        int retVal=0;
5243 cbradney 216
 
217
//      CommonStrings::languageChange();
3234 fschmid 218
        previewDinUse = false;
219
        printDinUse = false;
5243 cbradney 220
//      guiLanguage = newGuiLanguage;
221
//      initSplash(showSplash);
1208 cbradney 222
        setUsesBigPixmaps(true);
355 Franz 223
        CurrStED = NULL;
272 Franz 224
        setCaption( tr("Scribus " VERSION));
118 Franz 225
        setKeyCompression(false);
272 Franz 226
        setIcon(loadIcon("AppIcon.png"));
1325 cbradney 227
        scrActionGroups.clear();
228
        scrActionGroups.setAutoDelete(true);
1208 cbradney 229
        scrActions.clear();
230
        scrRecentFileActions.clear();
5800 fschmid 231
        scrRecentPasteActions.clear();
1260 cbradney 232
        scrWindowsActions.clear();
2408 cbradney 233
        scrLayersActions.clear();
5781 cbradney 234
        scrMenuMgr = new MenuManager(menuBar());
2835 cbradney 235
        prefsManager = PrefsManager::instance();
5243 cbradney 236
        objectSpecificUndo = false;
237
 
1247 tsoots 238
        undoManager = UndoManager::instance();
2441 cbradney 239
        tocGenerator = new TOCGenerator();
5243 cbradney 240
 
4510 subik 241
 
1780 cbradney 242
        initDefaultValues();
5243 cbradney 243
 
272 Franz 244
        initStatusBar();
5243 cbradney 245
 
490 cbradney 246
        qApp->processEvents();
675 cbradney 247
 
3 paul 248
        BuFromApp = false;
5243 cbradney 249
 
250
        actionManager = new ActionManager(this, "actionManager");
5257 cbradney 251
        actionManager->init(this);
5243 cbradney 252
        initMenuBar();
253
        initToolBars();
254
        buildFontMenu();
255
        ScCore->pluginManager->setupPluginActions(this);
256
        ScCore->pluginManager->languageChange();
5352 cbradney 257
        initKeyboardShortcuts();
5243 cbradney 258
        if (primaryMainWindow)
259
                ScCore->setSplashStatus( tr("Setting up Shortcuts") );
260
        SetShortCut();
1485 tsoots 261
 
5243 cbradney 262
        resize(610, 600);
263
        QVBox* vb = new QVBox( this );
264
        vb->setFrameStyle( QFrame::StyledPanel | QFrame::Sunken );
265
        wsp = new QWorkspace( vb );
266
        setCentralWidget( vb );
267
        connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
268
        //Connect windows cascade and tile actions to the workspace after its created. Only depends on wsp created.
269
        connect( scrActions["windowsCascade"], SIGNAL(activated()) , wsp, SLOT(cascade()) );
270
        connect( scrActions["windowsTile"], SIGNAL(activated()) , wsp, SLOT(tile()) );
271
        initPalettes();
272
 
273
        prefsManager->setupMainWindow(this);
770 cbradney 274
 
5243 cbradney 275
        if (primaryMainWindow)
276
                ScCore->setSplashStatus( tr("Initializing Story Editor") );
277
        storyEditor = new StoryEditor(this);
770 cbradney 278
 
5243 cbradney 279
        DocDir = prefsManager->documentDir();
1485 tsoots 280
 
801 cbradney 281
 
5243 cbradney 282
        if (primaryMainWindow)
5800 fschmid 283
                ScCore->setSplashStatus( tr("Initializing Hyphenator") );
284
        QString preLang = prefsManager->appPrefs.Language;
285
        initHyphenator();
286
        if (Sprachen.contains(preLang))
287
                prefsManager->appPrefs.Language = preLang;
288
        if (primaryMainWindow)
289
                ScCore->setSplashStatus( tr("Reading Scrapbook") );
290
        initScrapbook();
291
 
292
        scrActions["helpTooltips"]->setOn(prefsManager->appPrefs.showToolTips);
293
        ToggleTips();
294
        propertiesPalette->setFontSize();
6451 fschmid 295
        if (scrActions["SaveAsDocumentTemplate"])
296
                scrActions["SaveAsDocumentTemplate"]->setEnabled(false);
5800 fschmid 297
 
298
        connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString )), this, SLOT(removeRecent(QString)));
299
        connect(this, SIGNAL(TextIFont(QString)), this, SLOT(AdjustFontMenu(QString)));
300
        connect(this, SIGNAL(TextIFont(QString)), propertiesPalette, SLOT(setFontFace(QString)));
301
        connect(this, SIGNAL(TextISize(int)), this, SLOT(setFSizeMenu(int)));
302
        connect(this, SIGNAL(TextISize(int)), propertiesPalette, SLOT(setSize(int)));
303
        connect(this, SIGNAL(TextUSval(int)), propertiesPalette, SLOT(setExtra(int)));
304
        connect(this, SIGNAL(TextStil(int)), propertiesPalette, SLOT(setStil(int)));
305
        connect(this, SIGNAL(TextScale(int)), propertiesPalette, SLOT(setTScale(int)));
306
        connect(this, SIGNAL(TextScaleV(int)), propertiesPalette, SLOT(setTScaleV(int)));
307
        connect(this, SIGNAL(TextBase(int)), propertiesPalette, SLOT(setTBase(int)));
308
        connect(this, SIGNAL(TextShadow(int, int )), propertiesPalette, SLOT(setShadowOffs(int, int )));
309
        connect(this, SIGNAL(TextOutline(int)), propertiesPalette, SLOT(setOutlineW(int)));
310
        connect(this, SIGNAL(TextUnderline(int, int)), propertiesPalette, SLOT(setUnderline(int, int)));
311
        connect(this, SIGNAL(TextStrike(int, int)), propertiesPalette, SLOT(setStrike(int, int)));
312
        connect(this, SIGNAL(TextFarben(QString, QString, int, int)), propertiesPalette, SLOT(setActFarben(QString, QString, int, int)));
313
        connect(ClipB, SIGNAL(dataChanged()), this, SLOT(ClipChange()));
314
        connect(ClipB, SIGNAL(selectionChanged()), this, SLOT(ClipChange()));
315
        setAcceptDrops(true);
316
        return retVal;
317
}
318
 
319
ScribusMainWindow::~ScribusMainWindow()
320
{
321
}
322
 
323
 
324
void ScribusMainWindow::initToolBars()
325
{
6259 fschmid 326
        fileToolBar = new ScToolBar( tr("File"), "File", this);
5800 fschmid 327
        scrActions["fileNew"]->addTo(fileToolBar);
328
        scrActions["fileOpen"]->addTo(fileToolBar);
329
        scrMenuMgr->addMenuToWidgetOfAction("FileOpenRecent", scrActions["fileOpen"]);
330
        scrActions["fileSave"]->addTo(fileToolBar);
331
        scrActions["fileClose"]->addTo(fileToolBar);
332
        scrActions["filePrint"]->addTo(fileToolBar);
333
        scrActions["toolsPreflightVerifier"]->addTo(fileToolBar);
334
        scrActions["fileExportAsPDF"]->addTo(fileToolBar);
335
 
336
        editToolBar = new ScToolBar( tr("Edit"), "Edit", this);
337
        UndoWidget* uWidget = new UndoWidget(editToolBar, "uWidget");
338
        undoManager->registerGui(uWidget);
339
 
340
        mainToolBar = new ModeToolBar(this);
341
        pdfToolBar = new PDFToolBar(this);
342
 
343
        connect(mainToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarTools"], SLOT(setOn(bool)));
344
        connect(scrActions["toolsToolbarPDF"], SIGNAL(toggled(bool)), pdfToolBar, SLOT(setShown(bool)));
345
        connect(pdfToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarPDF"], SLOT(setOn(bool)));
346
        connect(scrActions["toolsToolbarTools"], SIGNAL(toggled(bool)), mainToolBar, SLOT(setShown(bool)) );
347
}
348
 
349
void ScribusMainWindow::initDefaultValues()
350
{
351
        HaveDoc = false;
352
        ScriptRunning = false;
353
        view = NULL;
354
        doc = NULL;
355
        Buffer2 = "";
356
        DispX = 10;
357
        DispY = 10;
358
        DocNr = 1;
359
        PrinterUsed = false;
360
        PDef.Pname = "";
361
        PDef.Dname = "";
362
        PDef.Command = "";
363
        keyrep = false;
364
        _arrowKeyDown = false;
365
        ClipB = QApplication::clipboard();
366
        palettesStatus[0] = false;
367
        guidesStatus[0] = false;
368
}
369
 
370
void ScribusMainWindow::initKeyboardShortcuts()
371
{
372
        for( QMap<QString, QGuardedPtr<ScrAction> >::Iterator it = scrActions.begin(); it!=scrActions.end(); ++it )
373
        {
374
                if ((ScrAction*)(it.data())!=NULL)
375
                {
376
                        QString accelerator=it.data()->accel();
377
                        prefsManager->setKeyEntry(it.key(), it.data()->cleanMenuText(), accelerator,0);
378
                }
379
                //else
380
                //      qDebug(it.key());
381
                //qDebug(QString("|-\n|%1||%2||%3").arg(it.key()).arg(it.data()->cleanMenuText()).arg(QString(it.data()->accel())));
382
        }
383
}
384
 
385
void ScribusMainWindow::initPalettes()
386
{
387
        //CB TODO hide the publicly available members of some palettes
388
        // these must be filtered too as they take control of the palettes events
389
        outlinePalette = new Tree(this);
390
        outlinePalette->setMainWindow(this);
391
        connect( scrActions["toolsOutline"], SIGNAL(toggled(bool)) , outlinePalette, SLOT(setPaletteShown(bool)) );
392
        connect( outlinePalette, SIGNAL(paletteShown(bool)), scrActions["toolsOutline"], SLOT(setOn(bool)));
393
        propertiesPalette = new Mpalette(ScCore->m_PaletteParent);
394
        propertiesPalette->setMainWindow(this);
395
        connect( scrActions["toolsProperties"], SIGNAL(toggled(bool)) , propertiesPalette, SLOT(setPaletteShown(bool)) );
396
        connect( propertiesPalette, SIGNAL(paletteShown(bool)), scrActions["toolsProperties"], SLOT(setOn(bool)));
397
 
398
        //CB dont need this until we have a doc...
399
        //propertiesPalette->Cpal->SetColors(prefsManager->colorSet());
400
        propertiesPalette->Fonts->RebuildList(0);
401
        propertiesPalette->installEventFilter(this);
402
        nodePalette = new NodePalette(this);
403
        nodePalette->installEventFilter(this);
404
        layerPalette = new LayerPalette(this);
405
        guidePalette = new GuideManager(this);
406
        connect( scrActions["toolsLayers"], SIGNAL(toggled(bool)) , layerPalette, SLOT(setPaletteShown(bool)) );
407
        connect( layerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsLayers"], SLOT(setOn(bool)));
408
        layerPalette->installEventFilter(this);
409
        layerPalette->Table->installEventFilter(this);
410
        scrapbookPalette = new Biblio(this);
411
        connect( scrActions["toolsScrapbook"], SIGNAL(toggled(bool)) , scrapbookPalette, SLOT(setPaletteShown(bool)) );
412
        connect( scrapbookPalette, SIGNAL(paletteShown(bool)), scrActions["toolsScrapbook"], SLOT(setOn(bool)));
413
        scrapbookPalette->installEventFilter(this);
414
        pagePalette = new PagePalette(this);
415
        connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , pagePalette, SLOT(setPaletteShown(bool)) );
416
        connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , this, SLOT(setPagePalette(bool)) );
417
        connect( pagePalette, SIGNAL(paletteShown(bool)), scrActions["toolsPages"], SLOT(setOn(bool)));
418
        pagePalette->installEventFilter(this);
419
        bookmarkPalette = new BookPalette(this);
420
        connect( scrActions["toolsBookmarks"], SIGNAL(toggled(bool)) , bookmarkPalette, SLOT(setPaletteShown(bool)) );
421
        connect( bookmarkPalette, SIGNAL(paletteShown(bool)), scrActions["toolsBookmarks"], SLOT(setOn(bool)));
422
        bookmarkPalette->installEventFilter(this);
423
        measurementPalette = new Measurements(this);
424
        connect( scrActions["toolsMeasurements"], SIGNAL(toggled(bool)) , measurementPalette, SLOT(setPaletteShown(bool)) );
425
        connect( scrActions["toolsMeasurements"], SIGNAL(toggledData(bool, int)) , this, SLOT(setAppModeByToggle(bool, int)) );
426
        connect( measurementPalette, SIGNAL(paletteShown(bool)), scrActions["toolsMeasurements"], SLOT(setOn(bool)));
427
        measurementPalette->installEventFilter(this);
428
        measurementPalette->hide();
429
        docCheckerPalette = new CheckDocument(this, false);
430
        connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , docCheckerPalette, SLOT(setPaletteShown(bool)) );
431
        connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , this, SLOT(docCheckToggle(bool)) );
432
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsPreflightVerifier"], SLOT(setOn(bool)));
433
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), this, SLOT(docCheckToggle(bool)));
434
        docCheckerPalette->installEventFilter(this);
435
        docCheckerPalette->hide();
436
 
437
        alignDistributePalette = new AlignDistributePalette(this, "AlignDistributePalette", false);
438
        connect( scrActions["toolsAlignDistribute"], SIGNAL(toggled(bool)) , alignDistributePalette, SLOT(setPaletteShown(bool)) );
439
        connect( alignDistributePalette, SIGNAL(paletteShown(bool)), scrActions["toolsAlignDistribute"], SLOT(setOn(bool)));
440
        connect( alignDistributePalette, SIGNAL(documentChanged()), this, SLOT(slotDocCh()));
441
        alignDistributePalette->installEventFilter(this);
6467 cbradney 442
 
5800 fschmid 443
        undoPalette = new UndoPalette(this, "undoPalette");
444
        undoPalette->installEventFilter(this);
445
        undoManager->registerGui(undoPalette);
446
        connect(undoPalette, SIGNAL(paletteShown(bool)), this, SLOT(setUndoPalette(bool)));
447
        connect(undoPalette, SIGNAL(objectMode(bool)), this, SLOT(setUndoMode(bool)));
448
 
449
        // initializing style manager here too even it's not strictly a palette
450
        styleManager = new StyleManager(this, "styleManager");
451
        styleManager->addStyle(new SMLineStyle());
5850 tsoots 452
        styleManager->addStyle(new SMParagraphStyle());
453
        styleManager->addStyle(new SMCharacterStyle());
5800 fschmid 454
        connect(styleManager, SIGNAL(closed()), scrActions["editStyles"], SLOT(toggle()));
455
 
456
        connect(docCheckerPalette, SIGNAL(selectElement(int, int)), this, SLOT(selectItemsFromOutlines(int, int)));
457
        connect(docCheckerPalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
458
        connect(docCheckerPalette, SIGNAL(selectMasterPage(QString)), this, SLOT(manageMasterPages(QString)));
459
        connect(outlinePalette, SIGNAL(selectElement(int, int, bool)), this, SLOT(selectItemsFromOutlines(int, int, bool)));
460
        connect(outlinePalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
461
        connect(outlinePalette, SIGNAL(selectMasterPage(QString)), this, SLOT(manageMasterPages(QString)));
462
        connect(propertiesPalette->Spal, SIGNAL(newStyle(int)), this, SLOT(setNewParStyle(int)));
463
//      connect(propertiesPalette, SIGNAL(EditLSt()), this, SLOT(slotEditLineStyles()));
464
        connect(nodePalette, SIGNAL(Schliessen()), this, SLOT(NoFrameEdit()));
465
        connect(nodePalette, SIGNAL(DocChanged()), this, SLOT(slotDocCh()));
466
        connect(layerPalette, SIGNAL(LayerChanged()), this, SLOT(showLayer()));
467
 
468
        connect(bookmarkPalette->BView, SIGNAL(MarkMoved()), this, SLOT(StoreBookmarks()));
469
        connect(bookmarkPalette->BView, SIGNAL(changed()), this, SLOT(slotDocCh()));
470
        connect(bookmarkPalette->BView, SIGNAL(SelectElement(PageItem *)), this, SLOT(selectItemsFromOutlines(PageItem *)));
471
        // guides
472
        connect(scrActions["pageManageGuides"], SIGNAL(toggled(bool)), guidePalette, SLOT(setPaletteShown(bool)));
473
        connect(guidePalette, SIGNAL(paletteShown(bool)), scrActions["pageManageGuides"], SLOT(setOn(bool)));
474
}
475
 
476
void ScribusMainWindow::initScrapbook()
477
{
478
        QString scrapbookFileO = QDir::convertSeparators(prefsManager->preferencesLocation()+"/scrap13.scs");
479
        QFileInfo scrapbookFileInfoO = QFileInfo(scrapbookFileO);
480
        if (scrapbookFileInfoO.exists())
481
        {
482
                scrapbookPalette->readOldContents(scrapbookFileO, QDir::convertSeparators(prefsManager->preferencesLocation()+"/scrapbook/main"));
483
                QDir d = QDir();
484
                d.rename(scrapbookFileO, QDir::convertSeparators(prefsManager->preferencesLocation()+"/scrap13.backup"));
485
        }
486
        QString scrapbookTemp = QDir::convertSeparators(prefsManager->preferencesLocation()+"/scrapbook/tmp");
487
        QFileInfo scrapbookTempInfo = QFileInfo(scrapbookTemp);
488
        if (scrapbookTempInfo.exists())
489
                scrapbookPalette->readTempContents(scrapbookTemp);
490
        QString scrapbookFile = QDir::convertSeparators(prefsManager->preferencesLocation()+"/scrapbook/main");
491
        QFileInfo scrapbookFileInfo = QFileInfo(scrapbookFile);
492
        if (scrapbookFileInfo.exists())
493
                scrapbookPalette->readContents(scrapbookFile);
494
        scrapbookPalette->setScrapbookFileName(scrapbookFile);
495
        scrapbookPalette->setOpenScrapbooks(prefsManager->appPrefs.RecentScrapbooks);
496
        rebuildRecentPasteMenu();
5806 fschmid 497
        connect(scrapbookPalette, SIGNAL(updateRecentMenue()), this, SLOT(rebuildRecentPasteMenu()));
5800 fschmid 498
}
499
 
500
bool ScribusMainWindow::warningVersion(QWidget *parent)
501
{
502
        bool retval = false;
503
        int t = ScMessageBox::warning(parent, QObject::tr("Scribus Development Version"), "<qt>" +
6442 cbradney 504
                                                                 QObject::tr("You are running a development version of Scribus 1.3.x. The document you are working with was created in Scribus 1.2.x.  Saving the current file under 1.3.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>",
5800 fschmid 505
                                                                 CommonStrings::tr_OK, CommonStrings::tr_Cancel, "", 1, 0);
506
        if (t == 0)
507
                retval = true;
508
        return retval;
509
}
510
 
511
void ScribusMainWindow::initMenuBar()
512
{
513
        RecentDocs.clear();
514
 
515
        scrMenuMgr->createMenu("File", tr("&File"));
516
        scrMenuMgr->addMenuItem(scrActions["fileNew"], "File");
517
        scrMenuMgr->addMenuItem(scrActions["fileOpen"], "File");
518
        recentFileMenuName="FileOpenRecent";
519
        scrMenuMgr->createMenu(recentFileMenuName, QIconSet(noIcon), tr("Open &Recent"), "File");
520
        scrMenuMgr->addMenuSeparator("File");
521
        scrMenuMgr->addMenuItem(scrActions["fileClose"], "File");
522
        scrMenuMgr->addMenuItem(scrActions["fileSave"], "File");
523
        scrMenuMgr->addMenuItem(scrActions["fileSaveAs"], "File");
524
        scrMenuMgr->addMenuItem(scrActions["fileRevert"], "File");
525
        scrMenuMgr->addMenuItem(scrActions["fileCollect"], "File");
526
        scrMenuMgr->addMenuSeparator("File");
527
        scrMenuMgr->createMenu("FileImport", QIconSet(noIcon), tr("&Import"), "File");
528
        scrMenuMgr->addMenuItem(scrActions["fileImportText"], "FileImport");
529
        scrMenuMgr->addMenuItem(scrActions["fileImportText2"], "FileImport");
530
        scrMenuMgr->addMenuItem(scrActions["fileImportAppendText"], "FileImport");
531
        scrMenuMgr->addMenuItem(scrActions["fileImportImage"], "FileImport");
532
        scrMenuMgr->createMenu("FileExport", QIconSet(noIcon), tr("&Export"), "File");
533
        scrMenuMgr->addMenuItem(scrActions["fileExportText"], "FileExport");
534
        scrMenuMgr->addMenuItem(scrActions["fileExportAsEPS"], "FileExport");
535
        scrMenuMgr->addMenuItem(scrActions["fileExportAsPDF"], "FileExport");
536
        scrMenuMgr->addMenuSeparator("File");
537
        scrMenuMgr->addMenuItem(scrActions["fileDocSetup"], "File");
538
        scrMenuMgr->addMenuItem(scrActions["filePreferences"], "File");
539
        scrMenuMgr->addMenuSeparator("File");
540
        scrMenuMgr->addMenuItem(scrActions["filePrint"], "File");
541
        scrMenuMgr->addMenuItem(scrActions["PrintPreview"], "File");
542
        scrMenuMgr->addMenuSeparator("File");
543
        scrMenuMgr->addMenuItem(scrActions["fileQuit"], "File");
544
 
545
        scrActions["fileClose"]->setEnabled(false);
546
        scrActions["fileSave"]->setEnabled(false);
547
        scrActions["fileSaveAs"]->setEnabled(false);
548
        scrActions["fileRevert"]->setEnabled(false);
549
        scrActions["fileCollect"]->setEnabled(false);
550
        scrActions["fileImportText"]->setEnabled(false);
551
        scrActions["fileImportText2"]->setEnabled(false);
552
        scrActions["fileImportImage"]->setEnabled(false);
553
        scrActions["fileImportAppendText"]->setEnabled(false);
554
        scrActions["pageImport"]->setEnabled(false);
555
        scrActions["fileExportText"]->setEnabled(false);
556
        scrActions["fileExportAsEPS"]->setEnabled(false);
557
        scrActions["fileExportAsPDF"]->setEnabled(false);
6451 fschmid 558
        scrMenuMgr->setMenuEnabled("FileImport", false);
5800 fschmid 559
        scrMenuMgr->setMenuEnabled("FileExport", false);
560
        scrActions["fileDocSetup"]->setEnabled(false);
561
        scrActions["filePrint"]->setEnabled(false);
562
        scrActions["PrintPreview"]->setEnabled(false);
563
 
564
        scrMenuMgr->createMenu("Edit", tr("&Edit"));
565
        scrMenuMgr->addMenuItem(scrActions["editUndoAction"], "Edit");
566
        scrMenuMgr->addMenuItem(scrActions["editRedoAction"], "Edit");
567
        scrMenuMgr->addMenuItem(scrActions["editActionMode"], "Edit");
568
        scrMenuMgr->addMenuSeparator("Edit");
569
        scrMenuMgr->addMenuItem(scrActions["editCut"], "Edit");
570
        scrMenuMgr->addMenuItem(scrActions["editCopy"], "Edit");
571
        scrMenuMgr->addMenuItem(scrActions["editPaste"], "Edit");
572
        recentPasteMenuName="EditPasteRecent";
573
        scrMenuMgr->createMenu(recentPasteMenuName, QIconSet(noIcon), tr("Paste Recent"), "Edit");
5943 cbradney 574
        scrMenuMgr->createMenu("EditContents", QPixmap(noIcon), tr("Contents"), "Edit");
5800 fschmid 575
        scrMenuMgr->addMenuItem(scrActions["editCopyContents"], "EditContents");
576
        scrMenuMgr->addMenuItem(scrActions["editPasteContents"], "EditContents");
577
        scrMenuMgr->addMenuItem(scrActions["editPasteContentsAbs"], "EditContents");
578
        scrMenuMgr->addMenuItem(scrActions["editClearContents"], "EditContents");
579
        scrMenuMgr->addMenuSeparator("Edit");
580
        scrMenuMgr->addMenuItem(scrActions["editSelectAll"], "Edit");
581
        scrMenuMgr->addMenuItem(scrActions["editDeselectAll"], "Edit");
582
        scrMenuMgr->addMenuSeparator("Edit");
583
        scrMenuMgr->addMenuItem(scrActions["editSearchReplace"], "Edit");
584
        scrMenuMgr->addMenuItem(scrActions["toolsEditWithStoryEditor"], "Edit");
585
        scrMenuMgr->addMenuItem(scrActions["editEditWithImageEditor"], "Edit");
586
        scrMenuMgr->addMenuSeparator("Edit");
587
        scrMenuMgr->addMenuItem(scrActions["editColors"], "Edit");
6368 fschmid 588
        scrMenuMgr->addMenuItem(scrActions["editPatterns"], "Edit");
5922 cbradney 589
        scrMenuMgr->addMenuItem(scrActions["editStyles"], "Edit");
5800 fschmid 590
        scrMenuMgr->addMenuItem(scrActions["editParaStyles"], "Edit");
591
        scrMenuMgr->addMenuItem(scrActions["editLineStyles"], "Edit");
592
        scrMenuMgr->addMenuItem(scrActions["editMasterPages"], "Edit");
593
        scrMenuMgr->addMenuItem(scrActions["editJavascripts"], "Edit");
594
        scrActions["editUndoAction"]->setEnabled(false);
595
        scrActions["editRedoAction"]->setEnabled(false);
596
        scrActions["editActionMode"]->setEnabled(true);
597
        scrActions["editCut"]->setEnabled(false);
598
        scrActions["editCopy"]->setEnabled(false);
599
        scrActions["editPaste"]->setEnabled(false);
5827 fschmid 600
        scrMenuMgr->setMenuEnabled("EditPasteRecent", false);
5800 fschmid 601
        scrActions["editCopyContents"]->setEnabled(false);
602
        scrActions["editPasteContents"]->setEnabled(false);
603
        scrActions["editPasteContentsAbs"]->setEnabled(false);
604
        scrActions["editClearContents"]->setEnabled(false);
605
        scrActions["editSelectAll"]->setEnabled(false);
606
        scrActions["editDeselectAll"]->setEnabled(false);
607
        scrActions["editSearchReplace"]->setEnabled(false);
6368 fschmid 608
        scrActions["editPatterns"]->setEnabled(false);
5800 fschmid 609
        scrActions["editParaStyles"]->setEnabled(false);
610
        scrActions["editLineStyles"]->setEnabled(false);
611
        scrActions["editMasterPages"]->setEnabled(false);
612
        scrActions["editJavascripts"]->setEnabled(false);
613
        scrActions["toolsEditWithStoryEditor"]->setEnabled(false);
614
        scrActions["editEditWithImageEditor"]->setEnabled(false);
615
 
616
        //Style Menu
617
        scrMenuMgr->createMenu("Style", tr("St&yle"));
618
        //Color menu
619
        // CB TODO
620
        scrMenuMgr->createMenu("Color", tr("&Color"));
621
        ColorMenC = new ColorCombo(false);
622
        ColorMenC->setEditable(false);
623
        scrMenuMgr->addMenuItem(ColorMenC, "Color");
624
 
625
        //Text size menu
626
        scrMenuMgr->createMenu("FontSize", tr("&Size"));
627
        scrActionGroups["fontSize"]->addTo(scrMenuMgr->getLocalPopupMenu("FontSize"));
628
 
629
        //Shade menu
630
        scrMenuMgr->createMenu("Shade", tr("&Shade"));
631
        scrActionGroups["shade"]->addTo(scrMenuMgr->getLocalPopupMenu("Shade"));
632
 
633
        //Font menu
634
        scrMenuMgr->createMenu("Font", tr("&Font"));
635
        FontMenu = scrMenuMgr->getLocalPopupMenu("Font");
636
 
637
        //Type style menu
638
        scrMenuMgr->createMenu("TypeEffects", tr("&Effects"));
639
        scrActionGroups["typeEffects"]->addTo(scrMenuMgr->getLocalPopupMenu("TypeEffects"));
640
 
641
        //Item Menu
642
        scrMenuMgr->createMenu("Item", tr("&Item"));
643
        scrMenuMgr->addMenuItem(scrActions["itemDuplicate"], "Item");
644
        scrMenuMgr->addMenuItem(scrActions["itemMulDuplicate"], "Item");
645
        scrMenuMgr->addMenuItem(scrActions["itemDelete"], "Item");
646
        scrMenuMgr->addMenuSeparator("Item");
647
        scrMenuMgr->addMenuItem(scrActions["itemGroup"], "Item");
648
        scrMenuMgr->addMenuItem(scrActions["itemUngroup"], "Item");
649
        scrMenuMgr->addMenuItem(scrActions["itemLock"], "Item");
650
        scrMenuMgr->addMenuItem(scrActions["itemLockSize"], "Item");
651
        scrMenuMgr->addMenuSeparator("Item");
652
        scrMenuMgr->addMenuItem(scrActions["itemImageIsVisible"], "Item");
653
        scrMenuMgr->addMenuItem(scrActions["itemUpdateImage"], "Item");
654
        scrMenuMgr->addMenuItem(scrActions["itemAdjustFrameToImage"], "Item");
655
        scrMenuMgr->addMenuItem(scrActions["itemExtendedImageProperties"], "Item");
656
        scrMenuMgr->createMenu("ItemPreviewSettings", tr("Preview Settings"), "Item");
657
        scrMenuMgr->addMenuItem(scrActions["itemPreviewLow"], "ItemPreviewSettings");
658
        scrMenuMgr->addMenuItem(scrActions["itemPreviewNormal"], "ItemPreviewSettings");
659
        scrMenuMgr->addMenuItem(scrActions["itemPreviewFull"], "ItemPreviewSettings");
660
        scrMenuMgr->addMenuSeparator("Item");
661
        scrMenuMgr->createMenu("ItemLevel", tr("Level"));
662
        scrMenuMgr->addMenuToMenu("ItemLevel", "Item");
663
        scrMenuMgr->addMenuItem(scrActions["itemRaise"], "ItemLevel");
664
        scrMenuMgr->addMenuItem(scrActions["itemLower"], "ItemLevel");
665
        scrMenuMgr->addMenuItem(scrActions["itemRaiseToTop"], "ItemLevel");
666
        scrMenuMgr->addMenuItem(scrActions["itemLowerToBottom"], "ItemLevel");
667
        scrMenuMgr->createMenu("ItemLayer", tr("Send to La&yer"));
668
        scrMenuMgr->addMenuToMenu("ItemLayer", "Item");
669
        layerMenuName="ItemLayer";
670
        scrMenuMgr->addMenuItem(scrActions["itemSendToScrapbook"], "Item");
6410 fschmid 671
        scrMenuMgr->addMenuItem(scrActions["itemSendToPattern"], "Item");
5800 fschmid 672
        scrMenuMgr->addMenuSeparator("Item");
673
        scrMenuMgr->addMenuItem(scrActions["itemAttributes"], "Item");
674
        scrMenuMgr->createMenu("ItemPDFOptions", tr("&PDF Options"));
675
        scrMenuMgr->addMenuToMenu("ItemPDFOptions", "Item");
676
        scrMenuMgr->addMenuItem(scrActions["itemPDFIsAnnotation"], "ItemPDFOptions");
677
        scrMenuMgr->addMenuItem(scrActions["itemPDFIsBookmark"], "ItemPDFOptions");
678
        scrMenuMgr->addMenuItem(scrActions["itemPDFAnnotationProps"], "ItemPDFOptions");
679
        scrMenuMgr->addMenuItem(scrActions["itemPDFFieldProps"], "ItemPDFOptions");
680
        scrMenuMgr->createMenu("ItemShapes", tr("&Shape"), "Item");
681
        // CB TODO
682
        //Shape menu
683
        SCustom = new Autoforms(0);
684
        scrMenuMgr->addMenuItem(SCustom, "ItemShapes");
685
        connect(SCustom, SIGNAL(FormSel(int, int, double *)), this, SLOT(MakeFrame(int, int, double *)));
686
        scrMenuMgr->addMenuItem(scrActions["itemShapeEdit"], "ItemShapes");
687
        scrMenuMgr->createMenu("ItemConvertTo", QPixmap(noIcon), tr("C&onvert To"), "Item");
688
        //scrMenuMgr->createMenu("ItemConvertTo", tr("C&onvert To"));
689
        //scrMenuMgr->addMenuToMenu("ItemConvertTo", "Item");
690
        scrMenuMgr->addMenuItem(scrActions["itemConvertToBezierCurve"], "ItemConvertTo");
691
        scrMenuMgr->addMenuItem(scrActions["itemConvertToImageFrame"], "ItemConvertTo");
692
        scrMenuMgr->addMenuItem(scrActions["itemConvertToOutlines"], "ItemConvertTo");
693
        scrMenuMgr->addMenuItem(scrActions["itemConvertToPolygon"], "ItemConvertTo");
694
        scrMenuMgr->addMenuItem(scrActions["itemConvertToTextFrame"], "ItemConvertTo");
695
 
696
        scrMenuMgr->addMenuItem(scrActions["itemAttachTextToPath"], "Item");
697
        scrMenuMgr->addMenuItem(scrActions["itemDetachTextFromPath"], "Item");
698
        scrMenuMgr->addMenuItem(scrActions["itemCombinePolygons"], "Item");
699
        scrMenuMgr->addMenuItem(scrActions["itemSplitPolygons"], "Item");
700
        scrMenuMgr->setMenuEnabled("ItemShapes", false);
701
        scrActions["itemGroup"]->setEnabled(false);
702
        scrActions["itemUngroup"]->setEnabled(false);
703
        scrActions["itemAttachTextToPath"]->setEnabled(false);
704
        scrActions["itemDetachTextFromPath"]->setEnabled(false);
705
        scrActions["itemCombinePolygons"]->setEnabled(false);
706
        scrActions["itemSplitPolygons"]->setEnabled(false);
707
        scrActions["itemLock"]->setEnabled(false);
708
        scrActions["itemLockSize"]->setEnabled(false);
709
        scrActions["itemPrintingEnabled"]->setEnabled(false);
710
        scrActions["itemImageIsVisible"]->setEnabled(false);
711
        scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
712
        scrActions["itemConvertToBezierCurve"]->setEnabled(false);
713
        scrActions["itemConvertToImageFrame"]->setEnabled(false);
714
        scrActions["itemConvertToOutlines"]->setEnabled(false);
715
        scrActions["itemConvertToPolygon"]->setEnabled(false);
716
        scrActions["itemConvertToTextFrame"]->setEnabled(false);
717
 
718
        //Insert menu
719
        scrMenuMgr->createMenu("Insert", tr("I&nsert"));
6090 cbradney 720
        scrMenuMgr->addMenuItem(scrActions["insertFrame"], "Insert");
721
        scrMenuMgr->addMenuSeparator("Insert");
5800 fschmid 722
        scrMenuMgr->addMenuItem(scrActions["toolsInsertTextFrame"], "Insert");
723
        scrMenuMgr->addMenuItem(scrActions["toolsInsertImageFrame"], "Insert");
724
        scrMenuMgr->addMenuItem(scrActions["toolsInsertTableFrame"], "Insert");
725
        scrMenuMgr->addMenuItem(scrActions["toolsInsertShape"], "Insert");
726
        scrMenuMgr->addMenuItem(scrActions["toolsInsertPolygon"], "Insert");
727
        scrMenuMgr->addMenuItem(scrActions["toolsInsertLine"], "Insert");
728
        scrMenuMgr->addMenuItem(scrActions["toolsInsertBezier"], "Insert");
729
        scrMenuMgr->addMenuItem(scrActions["toolsInsertFreehandLine"], "Insert");
730
        scrMenuMgr->addMenuSeparator("Insert");
731
        scrMenuMgr->addMenuItem(scrActions["insertGlyph"], "Insert");
732
 
733
        scrMenuMgr->createMenu("InsertChar", QPixmap(noIcon), tr("&Character"), "Insert");
734
        //scrMenuMgr->addMenuToMenu("InsertChar", "Insert");
735
        scrMenuMgr->addMenuItem(scrActions["unicodePageNumber"], "InsertChar");
736
        scrMenuMgr->addMenuItem(scrActions["unicodeSmartHyphen"], "InsertChar");
737
        scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingHyphen"], "InsertChar");
738
        scrMenuMgr->addMenuSeparator("InsertChar");
739
        scrMenuMgr->addMenuItem(scrActions["unicodeCopyRight"], "InsertChar");
740
        scrMenuMgr->addMenuItem(scrActions["unicodeRegdTM"], "InsertChar");
741
        scrMenuMgr->addMenuItem(scrActions["unicodeTM"], "InsertChar");
742
        scrMenuMgr->addMenuItem(scrActions["unicodeSolidus"], "InsertChar");
743
        scrMenuMgr->addMenuItem(scrActions["unicodeBullet"], "InsertChar");
744
        scrMenuMgr->addMenuItem(scrActions["unicodeMidpoint"], "InsertChar");
745
        scrMenuMgr->addMenuSeparator("InsertChar");
746
        scrMenuMgr->addMenuItem(scrActions["unicodeDashEm"], "InsertChar");
747
        scrMenuMgr->addMenuItem(scrActions["unicodeDashEn"], "InsertChar");
748
        scrMenuMgr->addMenuItem(scrActions["unicodeDashFigure"], "InsertChar");
749
        scrMenuMgr->addMenuItem(scrActions["unicodeDashQuotation"], "InsertChar");
750
 
751
        scrMenuMgr->createMenu("InsertQuote", QPixmap(noIcon), tr("&Quote"), "Insert");
752
        //scrMenuMgr->addMenuToMenu("InsertQuote", "Insert");
753
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteApostrophe"], "InsertQuote");
754
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteStraight"], "InsertQuote");
755
        scrMenuMgr->addMenuSeparator("InsertQuote");
756
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeft"], "InsertQuote");
757
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRight"], "InsertQuote");
758
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeft"], "InsertQuote");
759
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRight"], "InsertQuote");
760
        scrMenuMgr->addMenuSeparator("InsertQuote");
761
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowSingleComma"], "InsertQuote");
762
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowDoubleComma"], "InsertQuote");
763
        scrMenuMgr->addMenuSeparator("InsertQuote");
764
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleReversed"], "InsertQuote");
765
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleReversed"], "InsertQuote");
766
        scrMenuMgr->addMenuSeparator("InsertQuote");
767
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeftGuillemet"], "InsertQuote");
768
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRightGuillemet"], "InsertQuote");
769
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeftGuillemet"], "InsertQuote");
770
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRightGuillemet"], "InsertQuote");
771
        scrMenuMgr->addMenuSeparator("InsertQuote");
772
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleLeft"], "InsertQuote");
773
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleRight"], "InsertQuote");
774
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleLeft"], "InsertQuote");
775
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleRight"], "InsertQuote");
776
 
777
        scrMenuMgr->createMenu("InsertSpace", QPixmap(noIcon), tr("S&paces && Breaks"), "Insert");
778
        scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingSpace"], "InsertSpace");
779
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEN"], "InsertSpace");
780
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEM"], "InsertSpace");
781
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThin"], "InsertSpace");
782
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThick"], "InsertSpace");
783
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceMid"], "InsertSpace");
784
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceHair"], "InsertSpace");
785
        scrMenuMgr->addMenuSeparator("InsertSpace");
786
        scrMenuMgr->addMenuItem(scrActions["unicodeNewLine"], "InsertSpace");
787
        scrMenuMgr->addMenuItem(scrActions["unicodeFrameBreak"], "InsertSpace");
788
        scrMenuMgr->addMenuItem(scrActions["unicodeColumnBreak"], "InsertSpace");
789
 
790
        scrMenuMgr->createMenu("InsertLigature", QPixmap(noIcon), tr("Liga&ture"), "Insert");
791
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ff"], "InsertLigature");
792
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fi"], "InsertLigature");
793
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fl"], "InsertLigature");
794
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffi"], "InsertLigature");
795
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffl"], "InsertLigature");
796
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ft"], "InsertLigature");
797
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_st"], "InsertLigature");
798
 
799
        scrMenuMgr->addMenuSeparator("Insert");
800
        scrMenuMgr->addMenuItem(scrActions["insertSampleText"], "Insert");
6115 cbradney 801
        scrActions["insertFrame"]->setEnabled(false);
5800 fschmid 802
        scrActions["insertGlyph"]->setEnabled(false);
803
 
804
        //Page menu
805
        scrMenuMgr->createMenu("Page", tr("&Page"));
806
        scrMenuMgr->addMenuItem(scrActions["pageInsert"], "Page");
807
        scrMenuMgr->addMenuItem(scrActions["pageImport"], "Page");
808
        scrMenuMgr->addMenuItem(scrActions["pageDelete"], "Page");
809
        scrMenuMgr->addMenuItem(scrActions["pageCopy"], "Page");
810
        scrMenuMgr->addMenuItem(scrActions["pageMove"], "Page");
811
        scrMenuMgr->addMenuItem(scrActions["pageApplyMasterPage"], "Page");
812
        scrMenuMgr->addMenuItem(scrActions["pageCopyToMasterPage"], "Page");
813
        scrMenuMgr->addMenuItem(scrActions["pageManageGuides"], "Page");
814
        scrMenuMgr->addMenuItem(scrActions["pageManageMargins"], "Page");
815
        scrMenuMgr->addMenuSeparator("Page");
816
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGrid"], "Page");
817
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGuides"], "Page");
818
        scrActions["pageDelete"]->setEnabled(false);
819
        scrActions["pageMove"]->setEnabled(false);
820
 
821
        //View menu
822
        scrMenuMgr->createMenu("View", tr("&View"));
823
        scrMenuMgr->addMenuItem(scrActions["viewFitInWindow"], "View");
824
        scrMenuMgr->addMenuItem(scrActions["viewFit50"], "View");
825
        scrMenuMgr->addMenuItem(scrActions["viewFit75"], "View");
826
        scrMenuMgr->addMenuItem(scrActions["viewFit100"], "View");
827
        scrMenuMgr->addMenuItem(scrActions["viewFit200"], "View");
828
        scrMenuMgr->addMenuItem(scrActions["viewFit20"], "View");
829
        scrMenuMgr->addMenuSeparator("View");
830
        scrMenuMgr->addMenuItem(scrActions["viewShowMargins"], "View");
831
        scrMenuMgr->addMenuItem(scrActions["viewShowFrames"], "View");
832
        scrMenuMgr->addMenuItem(scrActions["viewShowLayerMarkers"], "View");
833
        scrMenuMgr->addMenuItem(scrActions["viewShowImages"], "View");
834
        scrMenuMgr->addMenuItem(scrActions["viewShowGrid"], "View");
835
        scrMenuMgr->addMenuItem(scrActions["viewShowGuides"], "View");
836
        scrMenuMgr->addMenuItem(scrActions["viewShowColumnBorders"], "View");
837
        scrMenuMgr->addMenuItem(scrActions["viewShowBaseline"], "View");
838
        scrMenuMgr->addMenuItem(scrActions["viewShowTextChain"], "View");
839
        scrMenuMgr->addMenuItem(scrActions["viewShowTextControls"], "View");
840
        scrMenuMgr->addMenuItem(scrActions["viewShowRulers"], "View");
841
        scrMenuMgr->addMenuItem(scrActions["viewRulerMode"], "View");
842
 
843
        scrActions["viewShowRulers"]->setEnabled(false);
844
 
845
        //CB If this is viewNewView imeplemented, it should be on the windows menu
846
//      scrMenuMgr->addMenuItem(scrActions["viewNewView"], "View");
847
 
848
        //Tool menu
849
        /*
850
        scrMenuMgr->createMenu("Tools", tr("&Tools"));
851
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Tools");
852
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Tools");
853
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Tools");
854
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Tools");
855
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Tools");
856
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Tools");
857
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Tools");
858
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Tools");
859
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Tools");
860
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Tools");
861
        scrMenuMgr->addMenuSeparator("Tools");
862
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Tools");
863
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Tools");
864
        //scrActions["toolsPreflightVerifier"]->setEnabled(false);*/
865
 
866
        //Extra menu
867
        scrMenuMgr->createMenu("Extras", tr("E&xtras"));
868
        scrMenuMgr->addMenuItem(scrActions["extrasManagePictures"], "Extras");
869
        scrMenuMgr->addMenuItem(scrActions["extrasHyphenateText"], "Extras");
870
        scrMenuMgr->addMenuItem(scrActions["extrasDeHyphenateText"], "Extras");
871
        scrMenuMgr->addMenuItem(scrActions["extrasGenerateTableOfContents"], "Extras");
872
 
873
        scrMenuMgr->setMenuEnabled("Extras", false);
874
        scrActions["extrasHyphenateText"]->setEnabled(false);
875
        scrActions["extrasDeHyphenateText"]->setEnabled(false);
876
 
877
        //Window menu
878
         scrMenuMgr->createMenu("Windows", tr("&Windows"), QString::null, true);
879
        connect(scrMenuMgr->getLocalPopupMenu("Windows"), SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
880
        addDefaultWindowMenuItems();
881
 
882
        //Help menu
883
        scrMenuMgr->createMenu("Help", tr("&Help"));
884
        scrMenuMgr->addMenuItem(scrActions["helpAboutScribus"], "Help");
885
        scrMenuMgr->addMenuItem(scrActions["helpAboutPlugins"], "Help");
886
        scrMenuMgr->addMenuItem(scrActions["helpAboutQt"], "Help");
887
        scrMenuMgr->addMenuSeparator("Help");
888
        scrMenuMgr->addMenuItem(scrActions["helpTooltips"], "Help");
889
        scrMenuMgr->addMenuItem(scrActions["helpManual"], "Help");
890
 
891
        scrMenuMgr->addMenuToMenuBar("File");
892
        scrMenuMgr->addMenuToMenuBar("Edit");
893
        scrMenuMgr->addMenuToMenuBar("Style");
894
        scrMenuMgr->setMenuEnabled("Style", false);
895
        scrMenuMgr->addMenuToMenuBar("Item");
896
        scrMenuMgr->setMenuEnabled("Item", false);
897
        scrMenuMgr->addMenuToMenuBar("Insert");
898
        scrMenuMgr->setMenuEnabled("Insert", false);
899
        scrMenuMgr->addMenuToMenuBar("Page");
900
        scrMenuMgr->setMenuEnabled("Page", false);
901
        scrMenuMgr->addMenuToMenuBar("View");
902
        scrMenuMgr->setMenuEnabled("View", false);
903
        //scrMenuMgr->addMenuToMenuBar("Tools");
904
        scrMenuMgr->addMenuToMenuBar("Extras");
905
        scrMenuMgr->setMenuEnabled("Extras", false);
906
        scrMenuMgr->addMenuToMenuBar("Windows");
907
        //scrMenuMgr->setMenuEnabled("Windows", false);
908
        menuBar()->insertSeparator();
909
        scrMenuMgr->addMenuToMenuBar("Help");
910
 
911
        //Alignment menu
912
        scrMenuMgr->createMenu("Alignment", tr("&Alignment"));
913
        scrMenuMgr->addMenuItem(scrActions["alignLeft"], "Alignment");
914
        scrMenuMgr->addMenuItem(scrActions["alignCenter"], "Alignment");
915
        scrMenuMgr->addMenuItem(scrActions["alignRight"], "Alignment");
916
        scrMenuMgr->addMenuItem(scrActions["alignBlock"], "Alignment");
917
        scrMenuMgr->addMenuItem(scrActions["alignForced"], "Alignment");
918
 
919
        connect(ColorMenC, SIGNAL(activated(int)), this, SLOT(setItemFarbe(int)));
920
        connect(FontMenu, SIGNAL(activated(int)), this, SLOT(setItemFont(int)));
921
}
922
 
923
void ScribusMainWindow::addDefaultWindowMenuItems()
924
{
925
        scrMenuMgr->clearMenu("Windows");
926
        scrMenuMgr->addMenuItem(scrActions["windowsCascade"], "Windows");
927
        scrMenuMgr->addMenuItem(scrActions["windowsTile"], "Windows");
928
        scrMenuMgr->addMenuSeparator("Windows");
929
 
930
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Windows");
931
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Windows");
932
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Windows");
933
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Windows");
934
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Windows");
935
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Windows");
936
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Windows");
937
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Windows");
938
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Windows");
939
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Windows");
940
        scrMenuMgr->addMenuSeparator("Windows");
941
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Windows");
942
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Windows");
943
}
944
 
945
 
946
void ScribusMainWindow::initStatusBar()
947
{
948
        mainWindowStatusLabel = new QLabel( "           ", statusBar(), "ft");
949
        mainWindowProgressBar = new QProgressBar(statusBar(), "p");
950
        mainWindowProgressBar->setCenterIndicator(true);
951
        mainWindowProgressBar->setFixedWidth( 100 );
952
        mainWindowProgressBar->reset();
953
        mainWindowXPosLabel = new QLabel( "X-Pos:", statusBar(), "xt");
954
        mainWindowYPosLabel = new QLabel( "Y-Pos:", statusBar(), "yt");
955
        mainWindowXPosDataLabel = new QLabel( "        ", statusBar(), "dt");
956
        mainWindowYPosDataLabel = new QLabel( "        ", statusBar(), "ydt");
957
 
958
        statusBar()->addWidget(mainWindowStatusLabel, 6, true);
959
        statusBar()->addWidget(mainWindowProgressBar, 0, true);
960
        statusBar()->addWidget(mainWindowXPosLabel, 0, true);
961
        statusBar()->addWidget(mainWindowXPosDataLabel, 1, true);
962
        statusBar()->addWidget(mainWindowYPosLabel, 0, true);
963
        statusBar()->addWidget(mainWindowYPosDataLabel, 1, true);
964
}
965
 
966
void ScribusMainWindow::setStatusBarMousePosition(double xp, double yp)
967
{
968
        double xn = xp;
969
        double yn = yp;
970
        if (doc->guidesSettings.rulerMode)
971
        {
972
                xn -= doc->currentPage()->xOffset();
973
                yn -= doc->currentPage()->yOffset();
974
        }
975
        xn -= doc->rulerXoffset;
976
        yn -= doc->rulerYoffset;
977
        QString suffix=unitGetSuffixFromIndex(doc->unitIndex());
978
        int multiplier=unitGetDecimalsFromIndex(doc->unitIndex());
979
        double divisor=static_cast<double>(multiplier);
980
        int precision=unitGetPrecisionFromIndex(doc->unitIndex());
981
        QString tmp;
982
        mainWindowXPosDataLabel->setText(tmp.setNum(qRound(xn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
983
        mainWindowYPosDataLabel->setText(tmp.setNum(qRound(yn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
984
}
985
 
986
void ScribusMainWindow::setStatusBarInfoText(QString newText)
987
{
988
        if (mainWindowStatusLabel)
989
                mainWindowStatusLabel->setText(newText);
990
}
991
 
992
//CB-->Doc
993
void ScribusMainWindow::setTBvals(PageItem *currItem)
994
{
995
        if (currItem->itemText.length() != 0)
996
        {
997
//              int ChPos = QMIN(currItem->CPos, static_cast<int>(currItem->itemText.length()-1));
998
                const ParagraphStyle currPStyle(currItem->currentStyle());
5980 avox 999
                int currentParaStyle = currPStyle.parent()? findParagraphStyle(doc, *dynamic_cast<const ParagraphStyle*>(currPStyle.parent())) : 0;
5800 fschmid 1000
                setAbsValue(currPStyle.alignment());
1001
                propertiesPalette->setParStyle(currentParaStyle);
1002
                doc->currentStyle.charStyle() = currItem->currentCharStyle();
1003
                emit TextUnderline(doc->currentStyle.charStyle().underlineOffset(), doc->currentStyle.charStyle().underlineWidth());
1004
                emit TextStrike(doc->currentStyle.charStyle().strikethruOffset(), doc->currentStyle.charStyle().strikethruWidth());
1005
                emit TextShadow(doc->currentStyle.charStyle().shadowXOffset(), doc->currentStyle.charStyle().shadowYOffset());
1006
                emit TextFarben(doc->currentStyle.charStyle().strokeColor(),
1007
                                                doc->currentStyle.charStyle().fillColor(),
1008
                                                doc->currentStyle.charStyle().strokeShade(),
1009
                                                doc->currentStyle.charStyle().fillShade());
5980 avox 1010
                emit TextIFont(doc->currentStyle.charStyle().font().scName());
5800 fschmid 1011
                emit TextISize(doc->currentStyle.charStyle().fontSize());
1012
                emit TextUSval(doc->currentStyle.charStyle().tracking());
1013
                emit TextStil(doc->currentStyle.charStyle().effects());
1014
                emit TextScale(doc->currentStyle.charStyle().scaleH());
1015
                emit TextScaleV(doc->currentStyle.charStyle().scaleV());
1016
                emit TextBase(doc->currentStyle.charStyle().baselineOffset());
1017
                emit TextOutline(doc->currentStyle.charStyle().outlineWidth());
1018
        }
1019
}
1020
 
1021
void ScribusMainWindow::wheelEvent(QWheelEvent *w)
1022
{
1023
        if (HaveDoc)
1024
        {
1025
                int wheelVal=prefsManager->mouseWheelValue();
1026
                if ((w->orientation() != Qt::Vertical) || ( w->state() & ShiftButton ))
1027
                {
1028
                        if (w->delta() < 0)
1029
                                view->scrollBy(wheelVal, 0);
1030
                        else
1031
                                view->scrollBy(-wheelVal, 0);
1032
                }
1033
                else
1034
                {
1035
                        if (w->delta() < 0)
1036
                                view->scrollBy(0, wheelVal);
1037
                        else
1038
                                view->scrollBy(0, -wheelVal);
1039
                }
1040
                w->accept();
1041
        }
1042
}
1043
 
1044
//Special keys assigned to actions are stolen by the action and not passed to
1045
//keyPressEvent so process them here.
1046
void ScribusMainWindow::specialActionKeyEvent(QString actionName, int unicodevalue)
1047
{
1048
        if (HaveDoc)
1049
        {
1050
                if (doc->appMode==modeEdit)
1051
                {
1052
                        if (doc->m_Selection->count() == 1)
1053
                        {
1054
                                PageItem *currItem = doc->m_Selection->itemAt(0);
1055
                                if (currItem!=NULL)
1056
                                {
1057
                                        if (unicodevalue!=-1)
1058
                                        {
1059
                                                if (currItem->HasSel && currItem->itemType()==PageItem::TextFrame)
1060
                                                        currItem->asTextFrame()->deleteSelectedTextFromFrame();
1061
 
1062
                                                currItem->itemText.insertChars(currItem->CPos, QString(QChar(unicodevalue)));
1063
                                                currItem->CPos += 1;
1064
                                                currItem->Tinput = true;
1065
                                                view->RefreshItem(currItem);
1066
                                        }
1067
                                        else if (actionName=="unicodeSmartHyphen") //ignore the char as we use an attribute if the text item, for now.
1068
                                        {
1069
                                                if (currItem->CPos-1>0)
1070
                                                {
1071
#ifndef NLS_PROTO
1072
                                                        StyleFlag fl = currItem->itemText.item(QMAX(currItem->CPos-1,0))->effects();
1073
                                                        fl |= ScStyle_HyphenationPossible;
1074
                                                        currItem->itemText.item(QMAX(currItem->CPos-1,0))->setEffects(fl);
1075
#else
1076
                                                        currItem->itemText.insertChars(currItem->CPos, QString(SpecialChars::SHYPHEN));
1077
                                                        currItem->CPos += 1;
1078
#endif
1079
                                                        currItem->Tinput = true;
1080
                                                        view->RefreshItem(currItem);
1081
                                                }
1082
                                        }
1083
                                }
1084
                        }
1085
                }
1086
        }
1087
}
1088
 
1089
bool ScribusMainWindow::eventFilter( QObject* /*o*/, QEvent *e )
1090
{
1091
        bool retVal;
1092
        if ( e->type() == QEvent::KeyPress ) {
1093
                QKeyEvent *k = (QKeyEvent *)e;
1094
                int keyMod=0;
1095
                if (k->state() & ShiftButton)
1096
                        keyMod |= SHIFT;
1097
                if (k->state() & ControlButton)
1098
                        keyMod |= CTRL;
1099
                if (k->state() & AltButton)
1100
                        keyMod |= ALT;
1101
 
1102
                QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
1103
                if (QString(currKeySeq).isNull())
1104
                        return false;
1105
                retVal=true;
1106
                //Palette actions
1107
                if (currKeySeq == scrActions["specialToggleAllPalettes"]->accel())
1108
                        scrActions["specialToggleAllPalettes"]->activate();
1109
                else
1110
                if (currKeySeq == scrActions["toolsProperties"]->accel())
1111
                        scrActions["toolsProperties"]->toggle();
1112
                else
1113
                if (currKeySeq == scrActions["toolsOutline"]->accel())
1114
                        scrActions["toolsOutline"]->toggle();
1115
                else
1116
                if (currKeySeq == scrActions["toolsScrapbook"]->accel())
1117
                        scrActions["toolsScrapbook"]->toggle();
1118
                else
1119
                if (currKeySeq == scrActions["toolsLayers"]->accel())
1120
                        scrActions["toolsLayers"]->toggle();
1121
                else
1122
                if (currKeySeq == scrActions["toolsPages"]->accel())
1123
                        scrActions["toolsPages"]->toggle();
1124
                else
1125
                if (currKeySeq == scrActions["toolsBookmarks"]->accel())
1126
                        scrActions["toolsBookmarks"]->toggle();
1127
                else
1128
                if (currKeySeq == scrActions["toolsActionHistory"]->accel())
1129
                        scrActions["toolsActionHistory"]->toggle();
1130
                else
1131
                if (currKeySeq == scrActions["toolsPreflightVerifier"]->accel())
1132
                        scrActions["toolsPreflightVerifier"]->toggle();
1133
                else
1134
                if (currKeySeq == scrActions["toolsAlignDistribute"]->accel())
1135
                        scrActions["toolsAlignDistribute"]->toggle();
1136
                else
1137
                //Undo actions
1138
                if (currKeySeq == scrActions["editUndoAction"]->accel() && scrActions["editUndoAction"]->isEnabled())
1139
                        scrActions["editUndoAction"]->activate();
1140
                else
1141
                if (currKeySeq == scrActions["editRedoAction"]->accel() && scrActions["editRedoAction"]->isEnabled())
1142
                        scrActions["editRedoAction"]->activate();
1143
                else
1144
                //Other actions
1145
                if (currKeySeq == scrActions["fileQuit"]->accel())
1146
                        scrActions["fileQuit"]->activate();
1147
                else
1148
                //Zoom actions
1149
                if (currKeySeq == scrActions["toolsZoomIn"]->accel())
1150
                        scrActions["toolsZoomIn"]->activate();
1151
                else
1152
                if (currKeySeq == scrActions["toolsZoomOut"]->accel())
1153
                        scrActions["toolsZoomOut"]->activate();
1154
                else
1155
                        retVal=false;
1156
        }
1157
        else
1158
                retVal=false;
1159
        //Return false to pass event to object
1160
        return retVal;
1161
}
1162
 
1163
void ScribusMainWindow::keyPressEvent(QKeyEvent *k)
1164
{
1165
        QWidgetList windows;
1166
        QWidget* w = NULL;
1167
        //struct ScText *hg;
1168
        int kk = k->key();
1169
        //int as = k->ascii();
1170
        //double altx, alty;
1171
        QString uc = k->text();
1172
        QString cr, Tcha, Twort;
1173
        //uint Tcoun;
1174
        //int len, pos, c;
1175
        if (keyrep)
1176
                return;
1177
        keyrep = true;
1178
        int KeyMod;
1179
        switch (k->state())
1180
        {
1181
        case ShiftButton:
1182
                KeyMod = SHIFT;
1183
                break;
1184
        case AltButton:
1185
                KeyMod = ALT;
1186
                break;
1187
        case ControlButton:
1188
                KeyMod = CTRL;
1189
                break;
1190
        default:
1191
                KeyMod = 0;
1192
                break;
1193
        }
1194
        //User presses escape and we have a doc open, and we have an item selected
1195
        if ((kk == Key_Escape) && (HaveDoc))
1196
        {
1197
                keyrep = false;
1198
                PageItem *currItem;
1199
                if (doc->m_Selection->count() != 0)
1200
                {
1201
                        currItem = doc->m_Selection->itemAt(0);
1202
                        switch (doc->appMode)
1203
                        {
1204
                                case modeNormal:
1205
                                        currItem->Sizing = false;
1206
                                        if (doc->SubMode != -1)
1207
                                        {
1208
                                                view->Deselect(false);
1209
                                                doc->Items->remove(currItem->ItemNr);
1210
                                        }
5967 fschmid 1211
                                        else
1212
                                                view->Deselect(false);
5800 fschmid 1213
                                        break;
1214
                                case modeLinkFrames:
1215
                                case modeUnlinkFrames:
1216
                                case modeEdit:
1217
                                case modeRotation:
1218
                                case modeEditGradientVectors:
1219
                                        view->Deselect(false);
1220
                                case modePanning:
1221
                                        break;
1222
                                case modeDrawBezierLine:
1223
                                        currItem->PoLine.resize(currItem->PoLine.size()-2);
1224
                                        if (currItem->PoLine.size() < 4)
1225
                                        {
1226
                                                view->Deselect(false);
1227
                                                doc->Items->remove(currItem->ItemNr);
1228
                                        }
1229
                                        else
1230
                                        {
1231
                                                view->SizeItem(currItem->PoLine.WidthHeight().x(), currItem->PoLine.WidthHeight().y(), currItem->ItemNr, false, false);
1232
                                                currItem->setPolyClip(qRound(QMAX(currItem->lineWidth() / 2.0, 1)));
1233
                                                view->AdjustItemSize(currItem);
1234
                                                currItem->ContourLine = currItem->PoLine.copy();
1235
                                                currItem->ClipEdited = true;
1236
                                                currItem->FrameType = 3;
1237
                                                slotDocCh();
1238
                                        }
1239
                                        view->FirstPoly = true;
1240
                                        break;
1241
                                default:
1242
                                        view->Deselect(false);
1243
                                        doc->Items->remove(currItem->ItemNr);
1244
                                        break;
1245
                        }
1246
                }
1247
                view->m_MouseButtonPressed = false;
1248
                doc->DragP = false;
1249
                doc->leaveDrag = false;
1250
                view->operItemMoving = false;
1251
                view->operItemResizing = false;
1252
                view->MidButt = false;
1253
                doc->SubMode = -1;
1254
                doc->ElemToLink = NULL;
1255
                NoFrameEdit();
1256
                slotSelect();
1257
                return;
1258
        }
1259
        ButtonState buttonState = k->state();
1260
        /**If we have a doc and we are not changing the page or zoom level in the status bar */
1261
        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
1262
        {
1263
                /**
1264
                 * With no item selected we can:
1265
                 * - With space, get into panning mode (modePanning)
1266
                 * - With PageUp, scroll up
1267
                 * - With PageDown, scroll down
1268
                 * - With Tab, change active document windowActivated
1269
                 */
1270
 
1271
                if ((doc->appMode != modeEdit) && (doc->m_Selection->count() == 0))
1272
                {
6284 fschmid 1273
                        int pg;
5800 fschmid 1274
                        switch (kk)
1275
                        {
1276
                        case Key_Space:
1277
                                keyrep = false;
1278
                                if (doc->appMode == modePanning)
1279
                                        setAppMode(modeNormal);
1280
                                else
1281
                                        setAppMode(modePanning);
1282
                                return;
1283
                                break;
1284
                        case Key_Prior:
6284 fschmid 1285
                                if (doc->masterPageMode())
1286
                                        view->scrollBy(0, -prefsManager->mouseWheelValue());
1287
                                else
1288
                                {
1289
                                        pg = doc->currentPageNumber();
1290
                                        if ((buttonState & ShiftButton) && !(buttonState & ControlButton) && !(buttonState & AltButton))
1291
                                                pg--;
1292
                                        else
1293
                                                pg -= doc->pageSets[doc->currentPageLayout].Columns;
1294
                                        if (pg > -1)
1295
                                                view->GotoPage(pg);
1296
                                }
5800 fschmid 1297
                                keyrep = false;
1298
                                return;
1299
                                break;
1300
                        case Key_Next:
6284 fschmid 1301
                                if (doc->masterPageMode())
1302
                                        view->scrollBy(0, prefsManager->mouseWheelValue());
1303
                                else
1304
                                {
1305
                                        pg = doc->currentPageNumber();
1306
                                        if ((buttonState & ShiftButton) && !(buttonState & ControlButton) && !(buttonState & AltButton))
1307
                                                pg++;
1308
                                        else
1309
                                                pg += doc->pageSets[doc->currentPageLayout].Columns;
1310
                                        if (pg < doc->Pages->count())
1311
                                                view->GotoPage(pg);
1312
                                }
5800 fschmid 1313
                                keyrep = false;
1314
                                return;
1315
                                break;
1316
                        case Key_Tab:
1317
                                keyrep = false;
1318
                                windows = wsp->windowList();
1319
                                if (windows.count() > 1)
1320
                                {
1321
                                        for (int i = 0; i < static_cast<int>(windows.count()); ++i)
1322
                                        {
1323
                                                if (wsp->activeWindow() == windows.at(i))
1324
                                                {
1325
                                                        if (i == static_cast<int>(windows.count()-1))
1326
                                                                w = windows.at(0);
1327
                                                        else
1328
                                                                w = windows.at(i+1);
1329
                                                        break;
1330
                                                }
1331
                                        }
1332
                                        doc->OpenNodes = outlinePalette->buildReopenVals();
1333
                                        docCheckerPalette->clearErrorList();
1334
                                        if ( w )
1335
                                                w->showNormal();
1336
                                        newActWin(w);
1337
                                }
1338
                                return;
1339
                                break;
1340
                        }
1341
                }
1342
                /** Now if we have an item selected
1343
                 * - In normal mode we can:
1344
                 * -- Use backspace or delete to delete the item
1345
                 * -- Use PageUp to raise an item
1346
                 * -- Use PageDown to lower an item
6083 cbradney 1347
                 * -- Use the arrow keys to move an item or group around for !inches:
5800 fschmid 1348
                                With no meta, by 1.0 unit
5975 cbradney 1349
                                Ctrl, by 10.0 units
1350
                                Shift by 0.1 units
1351
                                Ctrl Shift 0.01 units
6083 cbradney 1352
                        - For inches:
1353
                                With no meta, by 1.0 pt
1354
                                Ctrl, by 1.0 unit
1355
                                Shift by 0.1 units
1356
                                Ctrl Shift 0.01 units
5800 fschmid 1357
                 * -- Use the arrow keys to resize an item:
1358
                                Alt right arrow, move right side outwards (expand)
1359
                                Alt left arrow, move left side outwards (expand)
1360
                                Alt Shift right arrow, move left side inwards (shrink)
1361
                                Alt Shift left arrow, move right side inwards (shrink)
1362
                 * -- In edit mode of an image frame, use the arrow keys to resize the image:
1363
                                (flows to pageitem_imageframe for control)
1364
                                Alt right arrow, move right side of image outwards (expand)
1365
                                Alt left arrow, move right side inwards (shrink)
1366
                                Alt down arrow, move bottom side downwards (expand)
1367
                                Alt up arrow, move top side inwards (shrink)
1368
                 */
1369
                if (doc->m_Selection->count() != 0)
1370
                {
1371
                        double moveBy=1.0;
6083 cbradney 1372
                        if (doc->unitIndex()!=SC_INCHES)
1373
                        {
1374
                                if ((buttonState & ShiftButton) && !(buttonState & ControlButton) && !(buttonState & AltButton))
1375
                                        moveBy=0.1;
1376
                                else if (!(buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
1377
                                        moveBy=10.0;
1378
                                else if ((buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
1379
                                        moveBy=0.01;
1380
 
1381
                                moveBy/=doc->unitRatio();//Lets allow movement by the current doc ratio, not only points
1382
                        }
1383
                        else
1384
                        {
1385
                                if ((buttonState & ShiftButton) && !(buttonState & ControlButton) && !(buttonState & AltButton))
1386
                                        moveBy=0.1/doc->unitRatio();
1387
                                else if (!(buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
1388
                                        moveBy=1.0/doc->unitRatio();
1389
                                else if ((buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
1390
                                        moveBy=0.01/doc->unitRatio();
1391
                        }
5800 fschmid 1392
                        bool resizing=((buttonState & AltButton) && !(buttonState & ControlButton));
1393
                        bool resizingsmaller=(resizing && (buttonState & ShiftButton));
1394
                        double resizeBy=1.0;
1395
                        //CB with control locked out due to the requirement of moveby of 0.01, we cannot support
1396
                        //resizeby 10 units unless we move to supporting modifier keys that most people dont have.
1397
                        //if (buttonState & ControlButton)
1398
                        //      resizeBy*=10.0;
1399
                        resizeBy/=doc->unitRatio();
1400
                        if (resizingsmaller)
1401
                                resizeBy*=-1.0;
1402
 
1403
 
1404
                        PageItem *currItem = doc->m_Selection->itemAt(0);
1405
                        switch (doc->appMode)
1406
                        {
1407
                        case modeNormal:
1408
                                switch (kk)
1409
                                {
1410
                                case Key_Backspace:
1411
                                case Key_Delete:
1412
                                        doc->itemSelection_DeleteItem();
1413
                                        break;
1414
                                case Key_Prior:
1415
                                        if (!currItem->locked())
1416
                                        {
1417
                                                view->RaiseItem();
1418
                                        }
1419
                                        break;
1420
                                case Key_Next:
1421
                                        if (!currItem->locked())
1422
                                        {
1423
                                                view->LowerItem();
1424
                                        }
1425
                                        break;
1426
                                case Key_Left:
1427
                                        if (!currItem->locked())
1428
                                        {
1429
                                                if (!resizing)
1430
                                                {
1431
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1432
                                                        {
1433
                                                                FPoint np;
1434
                                                                if (view->EditContour)
1435
                                                                        np = currItem->ContourLine.point(view->ClRe);
1436
                                                                else
1437
                                                                        np = currItem->PoLine.point(view->ClRe);
1438
                                                                np = np - FPoint(moveBy, 0);
1439
                                                                view->MoveClipPoint(currItem, np);
1440
                                                        }
1441
                                                        else
1442
                                                        {
1443
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1444
                                                        /* as the user might be trying to fine tune a position */
1445
                                                                bool sav1 = doc->SnapGuides;
1446
                                                                bool sav2 = doc->useRaster;
1447
                                                                doc->SnapGuides = false;
1448
                                                                doc->useRaster = false;
1449
                                                                view->moveGroup(-moveBy, 0);
1450
                                                                doc->SnapGuides = sav1;
1451
                                                                doc->useRaster = sav2;
1452
                                                        }
1453
                                                }
1454
                                                else
1455
                                                {
1456
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1457
                                                        if(view->EditContour)
1458
                                                                view->TransformPoly(10, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
1459
                                                        else
1460
                                                        {
1461
                                                                if (resizingsmaller)
1462
                                                                {
1463
                                                                        currItem->Sizing = false;
1464
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1465
                                                                }
1466
                                                                else
1467
                                                                {
1468
                                                                        view->MoveItem(-resizeBy, 0, currItem, false);
5922 cbradney 1469
                                                                        currItem->moveImageXYOffsetBy(resizeBy/currItem->imageXScale(), 0);
5800 fschmid 1470
                                                                        currItem->Sizing = false;
1471
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1472
                                                                }
1473
                                                        }
1474
                                                }
1475
                                                view->updateContents();
1476
                                                slotDocCh();
1477
                                        }
1478
                                        break;
1479
                                case Key_Right:
1480
                                        if (!currItem->locked())
1481
                                        {
1482
                                                if (!resizing)
1483
                                                {
1484
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1485
                                                        {
1486
                                                                FPoint np;
1487
                                                                if (view->EditContour)
1488
                                                                        np = currItem->ContourLine.point(view->ClRe);
1489
                                                                else
1490
                                                                        np = currItem->PoLine.point(view->ClRe);
1491
                                                                np = np + FPoint(moveBy, 0);
1492
                                                                view->MoveClipPoint(currItem, np);
1493
                                                        }
1494
                                                        else
1495
                                                        {
1496
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1497
                                                        /* as the user might be trying to fine tune a position */
1498
                                                                bool sav1 = doc->SnapGuides;
1499
                                                                bool sav2 = doc->useRaster;
1500
                                                                doc->SnapGuides = false;
1501
                                                                doc->useRaster = false;
1502
                                                                view->moveGroup(moveBy, 0);
1503
                                                                doc->SnapGuides = sav1;
1504
                                                                doc->useRaster = sav2;
1505
                                                        }
1506
                                                }
1507
                                                else
1508
                                                {
1509
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1510
                                                        if(view->EditContour)
1511
                                                                view->TransformPoly(11, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
1512
                                                        else
1513
                                                        {
1514
                                                                if (resizingsmaller)
1515
                                                                {
1516
                                                                        view->MoveItem(-resizeBy, 0, currItem, false);
5922 cbradney 1517
                                                                        currItem->moveImageXYOffsetBy(resizeBy/currItem->imageXScale(), 0);
5800 fschmid 1518
                                                                        currItem->Sizing = false;
1519
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1520
                                                                }
1521
                                                                else
1522
                                                                {
1523
                                                                        currItem->Sizing = false;
1524
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1525
                                                                }
1526
                                                        }
1527
                                                }
1528
                                                view->updateContents();
1529
                                                slotDocCh();
1530
                                        }
1531
                                        break;
1532
                                case Key_Up:
1533
                                        if (!currItem->locked())
1534
                                        {
1535
                                                if (!resizing)
1536
                                                {
1537
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1538
                                                        {
1539
                                                                FPoint np;
1540
                                                                if (view->EditContour)
1541
                                                                        np = currItem->ContourLine.point(view->ClRe);
1542
                                                                else
1543
                                                                        np = currItem->PoLine.point(view->ClRe);
1544
                                                                np = np - FPoint(0, moveBy);
1545
                                                                view->MoveClipPoint(currItem, np);
1546
                                                        }
1547
                                                        else
1548
                                                        {
1549
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1550
                                                        /* as the user might be trying to fine tune a position */
1551
                                                                bool sav1 = doc->SnapGuides;
1552
                                                                bool sav2 = doc->useRaster;
1553
                                                                doc->SnapGuides = false;
1554
                                                                doc->useRaster = false;
1555
                                                                view->moveGroup(0, -moveBy);
1556
                                                                doc->SnapGuides = sav1;
1557
                                                                doc->useRaster = sav2;
1558
                                                        }
1559
                                                }
1560
                                                else
1561
                                                {
1562
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1563
                                                        if(view->EditContour)
1564
                                                                view->TransformPoly(12, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
1565
                                                        else
1566
                                                        {
1567
                                                                if (resizingsmaller)
1568
                                                                {
1569
                                                                        currItem->Sizing = false;
1570
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1571
                                                                }
1572
                                                                else
1573
                                                                {
1574
                                                                        view->MoveItem(0, -resizeBy, currItem, false);
5922 cbradney 1575
                                                                        currItem->moveImageXYOffsetBy(0, resizeBy/currItem->imageYScale());
5800 fschmid 1576
                                                                        currItem->Sizing = false;
1577
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1578
                                                                }
1579
                                                        }
1580
                                                }
1581
                                                view->updateContents();
1582
                                                slotDocCh();
1583
                                        }
1584
                                        break;
1585
                                case Key_Down:
1586
                                        if (!currItem->locked())
1587
                                        {
1588
                                                if (!resizing)
1589
                                                {
1590
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1591
                                                        {
1592
                                                                FPoint np;
1593
                                                                if (view->EditContour)
1594
                                                                        np = currItem->ContourLine.point(view->ClRe);
1595
                                                                else
1596
                                                                        np = currItem->PoLine.point(view->ClRe);
1597
                                                                np = np + FPoint(0, moveBy);
1598
                                                                view->MoveClipPoint(currItem, np);
1599
                                                        }
1600
                                                        else
1601
                                                        {
1602
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1603
                                                        /* as the user might be trying to fine tune a position */
1604
                                                                bool sav1 = doc->SnapGuides;
1605
                                                                bool sav2 = doc->useRaster;
1606
                                                                doc->SnapGuides = false;
1607
                                                                doc->useRaster = false;
1608
                                                                view->moveGroup(0, moveBy);
1609
                                                                doc->SnapGuides = sav1;
1610
                                                                doc->useRaster = sav2;
1611
                                                        }
1612
                                                }
1613
                                                else
1614
                                                {
1615
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1616
                                                        if(view->EditContour)
1617
                                                                view->TransformPoly(13, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
1618
                                                        else
1619
                                                        {
1620
                                                                if (resizingsmaller)
1621
                                                                {
1622
                                                                        view->MoveItem(0, -resizeBy, currItem, false);
5922 cbradney 1623
                                                                        currItem->moveImageXYOffsetBy(0, resizeBy/currItem->imageYScale());
5800 fschmid 1624
                                                                        currItem->Sizing = false;
1625
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1626
                                                                }
1627
                                                                else
1628
                                                                {
1629
                                                                        currItem->Sizing = false;
1630
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1631
                                                                }
1632
                                                        }
1633
                                                }
1634
                                                view->updateContents();
1635
                                                slotDocCh();
1636
                                        }
1637
                                        break;
1638
                                default:
1639
                                        break;
1640
                                }
1641
                                break;
1642
                        case modeEdit:
1643
                                if (currItem->asImageFrame() && !currItem->locked())
1644
                                {
1645
                                        currItem->handleModeEditKey(k, keyrep);
1646
                                        /*
1647
                                        double dX=0.0,dY=0.0;
1648
                                        switch (kk)
1649
                                        {
1650
                                                case Key_Left:
1651
                                                        dX=-moveBy;
1652
                                                        break;
1653
                                                case Key_Right:
1654
                                                        dX=moveBy;
1655
                                                        break;
1656
                                                case Key_Up:
1657
                                                        dY=-moveBy;
1658
                                                        break;
1659
                                                case Key_Down:
1660
                                                        dY=moveBy;
1661
                                                        break;
1662
                                        }
1663
                                        if (dX!=0.0 || dY!=0.0)
1664
                                        {
1665
                                                currItem->moveImageInFrame(dX, dY);
1666
                                                view->updateContents(currItem->getRedrawBounding(view->scale()));
1667
                                        }*/
1668
                                }
1669
                                view->oldCp = currItem->CPos;
1670
                                if (currItem->itemType() == PageItem::TextFrame)
1671
                                {
1672
                                        bool kr=keyrep;
1673
                                        currItem->handleModeEditKey(k, keyrep);
1674
                                        keyrep=kr;
1675
                                }
1676
                                slotDocCh(false);
1677
                                break;
1678
                        }
1679
                }
1680
        }
1681
        switch(kk)
1682
        {
1683
                case Key_Left:
1684
                case Key_Right:
1685
                case Key_Up:
1686
                case Key_Down:
1687
                        _arrowKeyDown = true;
1688
        }
1689
        keyrep = false;
1690
}
1691
 
1692
void ScribusMainWindow::keyReleaseEvent(QKeyEvent *k)
1693
{
1694
        if (HaveDoc && (k->state() & ControlButton))
1695
        {
1696
                if ((doc->appMode == modePanning) && (k->state() & Qt::RightButton))
1697
                        setAppMode(modeNormal);
1698
        }
1699
        if (k->isAutoRepeat() || !_arrowKeyDown)
1700
                return;
1701
        switch(k->key())
1702
        {
1703
                case Key_Left:
1704
                case Key_Right:
1705
                case Key_Up:
1706
                case Key_Down:
1707
                        _arrowKeyDown = false;
1708
                        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
1709
                        {
1710
                                uint docSelectionCount=doc->m_Selection->count();
1711
                                if ((docSelectionCount != 0) && (doc->appMode == modeNormal) && (doc->EditClip) && (view->ClRe != -1))
1712
                                        view->updateContents();
1713
                                for (uint i = 0; i < docSelectionCount; ++i)
1714
                                        doc->m_Selection->itemAt(i)->checkChanges(true);
1715
                                if (docSelectionCount > 1 && view->groupTransactionStarted())
1716
                                        undoManager->commit();
1717
                        }
1718
                        break;
1719
        }
1720
}
1721
 
1722
void ScribusMainWindow::closeEvent(QCloseEvent *ce)
1723
{
1724
        QWidgetList windows = wsp->windowList();
1725
        ScribusWin* tw;
1726
        disconnect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
1727
        if (!windows.isEmpty())
1728
        {
1729
                uint windowCount=windows.count();
1730
                for ( uint i = 0; i < windowCount; ++i )
1731
                {
1732
                        newActWin(windows.at(i));
1733
                        tw = ActWin;
1734
                        ActWin->close();
1735
                        if (tw == ActWin)
1736
                        {
1737
                                ce->ignore();
1738
                                connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
1739
                                return;
1740
                        }
1741
                }
1742
        }
1743
        propertiesPalette->hide();
1744
        outlinePalette->hide();
1745
        scrapbookPalette->hide();
1746
        bookmarkPalette->hide();
1747
        layerPalette->hide();
1748
        pagePalette->hide();
1749
        measurementPalette->hide();
1750
        docCheckerPalette->hide();
1751
        undoPalette->hide();
1752
        alignDistributePalette->hide();
1753
        guidePalette->hide();
1754
 
1755
        // Clean up plugins, THEN save prefs to disk
1756
        ScCore->pluginManager->cleanupPlugins();
1757
        if (!prefsManager->appPrefs.persistentScrapbook)
1758
                scrapbookPalette->CleanUpTemp();
1759
        prefsManager->appPrefs.RecentScrapbooks.clear();
1760
        prefsManager->appPrefs.RecentScrapbooks = scrapbookPalette->getOpenScrapbooks();
1761
        if (!emergencyActivated)
1762
                prefsManager->SavePrefs();
1763
        UndoManager::deleteInstance();
1764
        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1765
        exit(0);
1766
}
1767
 
1768
/////////////////////////////////////////////////////////////////////
1769
// SLOT IMPLEMENTATION
1770
/////////////////////////////////////////////////////////////////////
1771
 
1772
 
1773
bool ScribusMainWindow::arrowKeyDown()
1774
{
1775
        return _arrowKeyDown;
1776
}
1777
 
1778
void ScribusMainWindow::startUpDialog()
1779
{
1780
        PrefsContext* docContext = prefsManager->prefsFile->getContext("docdirs", false);
1781
        NewDoc* dia = new NewDoc(this, RecentDocs, true);
1782
        if (dia->exec())
1783
        {
1784
                if (dia->tabSelected == 0)
1785
                {
1786
                        int facingPages = dia->choosenLayout;
1787
                        int firstPage = dia->docLayout->firstPage->currentItem();
1788
                        double topMargin = dia->marginGroup->top();
1789
                        double bottomMargin = dia->marginGroup->bottom();
1790
                        double leftMargin = dia->marginGroup->left();
1791
                        double rightMargin = dia->marginGroup->right();
1792
                        double columnDistance = dia->Dist;
1793
                        double pageWidth = dia->pageWidth;
1794
                        double pageHeight = dia->pageHeight;
1795
                        double numberCols = dia->numberOfCols->value();
5918 cbradney 1796
                        bool autoframes = dia->autoTextFrameGroupBox->isChecked();
5800 fschmid 1797
                        int orientation = dia->Orient;
5918 cbradney 1798
                        int pageCount=dia->pageCountSpinBox->value();
5800 fschmid 1799
                        PageSize ps2(dia->pageSizeComboBox->currentText());
1800
                        QString pagesize = ps2.name();
5918 cbradney 1801
                        doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->unitOfMeasureComboBox->currentItem(), firstPage, orientation, 1, pagesize, true, pageCount);
5800 fschmid 1802
                        doc->pageSets[facingPages].FirstPage = firstPage;
1803
                        HaveNewDoc();
1804
                }
1805
                else
1806
                {
1807
                        if (dia->tabSelected == 1)
1808
                        {
1809
                                QString fileName(dia->fileDialog->selectedFile());
1810
                                if (!fileName.isEmpty())
1811
                                {
1812
                                        docContext->set("docsopen", fileName.left(fileName.findRev("/")));
1813
                                        loadDoc(fileName);
1814
                                }
1815
                        }
1816
                        else
1817
                        {
1818
                                QString fileName(dia->recentDocListBox->currentText());
1819
                                if (!fileName.isEmpty())
1820
                                        loadRecent(fileName);
1821
                        }
1822
                }
1823
        }
1824
        prefsManager->setShowStartupDialog(!dia->startUpDialog->isChecked());
1825
        delete dia;
1826
        mainWindowStatusLabel->setText( tr("Ready"));
1827
}
1828
 
1829
bool ScribusMainWindow::slotFileNew()
1830
{
6541 cbradney 1831
        if (HaveDoc && doc->EditClip)
1832
                ToggleFrameEdit();
6189 jghali 1833
        bool retVal = false;
5800 fschmid 1834
        NewDoc* dia = new NewDoc(this, RecentDocs);
1835
        if (dia->exec())
1836
        {
1837
                int facingPages = dia->choosenLayout;
1838
                int firstPage = dia->docLayout->firstPage->currentItem();
1839
                double topMargin = dia->marginGroup->top();
1840
                double bottomMargin = dia->marginGroup->bottom();
1841
                double leftMargin = dia->marginGroup->left();
1842
                double rightMargin = dia->marginGroup->right();
1843
                double columnDistance = dia->Dist;
1844
                double pageWidth = dia->pageWidth;
1845
                double pageHeight = dia->pageHeight;
1846
                double numberCols = dia->numberOfCols->value();
5918 cbradney 1847
                bool autoframes = dia->autoTextFrameGroupBox->isChecked();
5800 fschmid 1848
                int orientation = dia->Orient;
5918 cbradney 1849
                int pageCount=dia->pageCountSpinBox->value();
5800 fschmid 1850
                PageSize ps2(dia->pageSizeComboBox->currentText());
6189 jghali 1851
                if (doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->unitOfMeasureComboBox->currentItem(), firstPage, orientation, 1, ps2.name(), true, pageCount))
1852
                {
1853
                        doc->pageSets[facingPages].FirstPage = firstPage;
1854
                        mainWindowStatusLabel->setText( tr("Ready"));
1855
                        HaveNewDoc();
1856
                        retVal = true;
1857
                }
5800 fschmid 1858
        }
1859
        delete dia;
6189 jghali 1860
        return retVal;
5800 fschmid 1861
}
1862
 
1863
//TODO move to core, assign doc to doc list, optionally create gui for it
5808 cbradney 1864
ScribusDoc *ScribusMainWindow::newDoc(double width, double height, double topMargin, double leftMargin, double rightMargin, double bottomMargin, double columnDistance, double columnCount, bool autoTextFrames, int pageArrangement, int unitIndex, int firstPageLocation, int orientation, int firstPageNumber, const QString& defaultPageSize, bool requiresGUI, int pageCount, bool showView)
5800 fschmid 1865
{
5808 cbradney 1866
        return doFileNew(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, columnCount, autoTextFrames, pageArrangement, unitIndex, firstPageLocation, orientation, firstPageNumber, defaultPageSize, requiresGUI, pageCount, showView);
5800 fschmid 1867
        /* TODO CB finish later this week.
1868
        if (HaveDoc)
1869
                doc->OpenNodes = outlinePalette->buildReopenVals();
1870
        MarginStruct margins(topMargin, leftMargin, bottomMargin, rightMargin);
1871
        DocPagesSetup pagesSetup(pageArrangement, firstPageLocation, firstPageNumber, orientation, autoTextFrames, columnDistance, columnCount);
1872
        QString newDocName(tr("Document")+"-"+QString::number(DocNr));
1873
        doc = new ScribusDoc(newDocName, unitindex, pagesize, margins, pagesSetup);
1874
                doc->setLoading(true);
1875
        doc->setup(unitIndex, pageArrangement, firstPageLocation, orientation, firstPageNumber, defaultPageSize, newDocName);
1876
        HaveDoc++;
1877
        DocNr++;
5880 jghali 1878
        if (ScCore->haveCMS() && doc->CMSSettings.CMSinUse)
5800 fschmid 1879
                recalcColors();
1880
        //CB NOTE should be all done now
1881
        doc->setPage(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, columnCount, autoTextFrames, pageArrangement);
1882
        doc->setMasterPageMode(false);
1883
        doc->addMasterPage(0, "Normal");
1884
        int createCount=QMAX(pageCount,1);
1885
        for (int i = 0; i < createCount; ++i)
1886
                doc->addPage(i, "Normal", true);
1887
        doc->addSection();
1888
        doc->setFirstSectionFromFirstPageNumber();
1889
        doc->setModified(false);
1890
        doc->OpenNodes.clear();
1891
        actionManager->disconnectNewDocActions();
1892
        actionManager->connectNewDocActions(doc);
1893
        //<<View and window code
1894
        ScribusWin* w = new ScribusWin(wsp, doc);
1895
        w->setMainWindow(this);
1896
        if (view!=NULL)
1897
        {
1898
                actionManager->disconnectNewViewActions();
1899
                disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
1900
        }
1901
        view = new ScribusView(w, this, doc);
1902
        doc->setCurrentPage(doc->Pages->at(0));
1903
        doc->setGUI(this, view);
1904
        doc->setLoading(false);
1905
        //run after setGUI to set up guidepalette ok
1906
 
1907
        view->setScale(prefsManager->displayScale());
1908
        actionManager->connectNewViewActions(view);
1909
        alignDistributePalette->setDoc(doc);
1910
        docCheckerPalette->clearErrorList();
1911
        w->setView(view);
1912
        ActWin = w;
1913
        doc->WinHan = w;
1914
        w->setCentralWidget(view);
1915
        doc->connectDocSignals(); //Must be before the first reformpages
1916
        view->reformPages(true);
1917
        //>>
1918
 
1919
        connect(undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
1920
        //connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
1921
        connect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
1922
        //      connect(w, SIGNAL(SaveAndClose()), this, SLOT(DoSaveClose()));
1923
 
1924
        //Independent finishing tasks after doc setup
1925
        if (showView)
1926
        {
1927
                if ( wsp->windowList().isEmpty() )
1928
                        w->showMaximized();
1929
                else
1930
                        w->show();
1931
                view->show();
1932
        }
1933
        connect(w, SIGNAL(AutoSaved()), this, SLOT(slotAutoSaved()));
1934
        connect(ScCore->fileWatcher, SIGNAL(fileChanged(QString)), doc, SLOT(updatePict(QString)));
1935
        connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), doc, SLOT(removePict(QString)));
1936
        scrActions["fileSave"]->setEnabled(false);
1937
        undoManager->switchStack(doc->DocName);
1938
        styleManager->currentDoc(doc);
1939
        tocGenerator->setDoc(doc);
1940
 
1941
        return doc;
1942
        */
1943
}
1944
 
5808 cbradney 1945
ScribusDoc *ScribusMainWindow::doFileNew(double width, double height, double topMargin, double leftMargin, double rightMargin, double bottomMargin, double columnDistance, double columnCount, bool autoTextFrames, int pageArrangement, int unitIndex, int firstPageLocation, int orientation, int firstPageNumber, const QString& defaultPageSize, bool requiresGUI, int pageCount, bool showView)
5800 fschmid 1946
{
1947
        if (HaveDoc)
1948
        {
1949
                doc->OpenNodes = outlinePalette->buildReopenVals();
1950
        }
1951
 
1952
        MarginStruct margins(topMargin, leftMargin, bottomMargin, rightMargin);
1953
        DocPagesSetup pagesSetup(pageArrangement, firstPageLocation, firstPageNumber, orientation, autoTextFrames, columnDistance, columnCount);
6259 fschmid 1954
        QString newDocName( tr("Document")+"-"+QString::number(DocNr));
5808 cbradney 1955
        ScribusDoc *tempDoc = new ScribusDoc();
1956
        if (requiresGUI)
1957
                doc=tempDoc;
1958
        //tempDoc = new ScribusDoc(newDocName, unitindex, pagesize, margins, pagesSetup);
1959
        tempDoc->setLoading(true);
1960
        tempDoc->setup(unitIndex, pageArrangement, firstPageLocation, orientation, firstPageNumber, defaultPageSize, newDocName);
1961
        if (requiresGUI)
1962
        {
1963
                HaveDoc++;
1964
                DocNr++;
1965
        }
5880 jghali 1966
        if (ScCore->haveCMS() && tempDoc->CMSSettings.CMSinUse)
5800 fschmid 1967
                recalcColors();
1968
        //CB NOTE should be all done now
5914 fschmid 1969
        tempDoc->setPage(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnCount, columnDistance, autoTextFrames, pageArrangement);
5808 cbradney 1970
        tempDoc->setMasterPageMode(false);
6241 fschmid 1971
        int setcol = tempDoc->pageSets[tempDoc->currentPageLayout].Columns;
6240 fschmid 1972
        if (setcol == 1)
6241 fschmid 1973
        {
6259 fschmid 1974
                tempDoc->addMasterPage(0, tr("Normal"));
6240 fschmid 1975
                int createCount=QMAX(pageCount,1);
1976
                for (int i = 0; i < createCount; ++i)
6259 fschmid 1977
                        tempDoc->addPage(i, tr("Normal"), true);
6241 fschmid 1978
        }
6240 fschmid 1979
        else if (setcol == 2)
1980
        {
6259 fschmid 1981
                Page *lp = tempDoc->addMasterPage(0, tr("Normal Left"));
6240 fschmid 1982
                lp->LeftPg = 1;
1983
                lp->Margins.Left = lp->initialMargins.Right;
1984
                lp->Margins.Right = lp->initialMargins.Left;
6259 fschmid 1985
                lp = tempDoc->addMasterPage(1, tr("Normal Right"));
6240 fschmid 1986
                lp->LeftPg = 0;
1987
                lp->Margins.Right = lp->initialMargins.Right;
1988
                lp->Margins.Left = lp->initialMargins.Left;
1989
                int createCount=QMAX(pageCount,1);
1990
                for (int i = 0; i < createCount; ++i)
1991
                {
1992
                        PageLocation pageLoc = tempDoc->locationOfPage(i);
1993
                        if (pageLoc == LeftPage)
6259 fschmid 1994
                                tempDoc->addPage(i, tr("Normal Left"), true);
6240 fschmid 1995
                        else
6259 fschmid 1996
                                tempDoc->addPage(i, tr("Normal Right"), true);
6240 fschmid 1997
                }
1998
        }
1999
        else if ((setcol == 3) || (setcol == 4))
2000
        {
6259 fschmid 2001
                Page *lp = tempDoc->addMasterPage(0, tr("Normal Left"));
6240 fschmid 2002
                lp->LeftPg = 1;
2003
                lp->Margins.Left = lp->initialMargins.Right;
2004
                lp->Margins.Right = lp->initialMargins.Left;
6259 fschmid 2005
                lp = tempDoc->addMasterPage(1, tr("Normal Right"));
6240 fschmid 2006
                lp->LeftPg = 0;
2007
                lp->Margins.Right = lp->initialMargins.Right;
2008
                lp->Margins.Left = lp->initialMargins.Left;
6259 fschmid 2009
                lp = tempDoc->addMasterPage(2, tr("Normal Middle"));
6240 fschmid 2010
                lp->LeftPg = 2;
2011
                lp->Margins.Left = lp->initialMargins.Left;
2012
                lp->Margins.Right = lp->initialMargins.Left;
2013
                int createCount=QMAX(pageCount,1);
2014
                for (int i = 0; i < createCount; ++i)
2015
                {
2016
                        PageLocation pageLoc = tempDoc->locationOfPage(i);
2017
                        if (pageLoc == LeftPage)
6259 fschmid 2018
                                tempDoc->addPage(i, tr("Normal Left"), true);
6240 fschmid 2019
                        else if (pageLoc == RightPage)
6259 fschmid 2020
                                tempDoc->addPage(i, tr("Normal Right"), true);
6240 fschmid 2021
                        else
6259 fschmid 2022
                                tempDoc->addPage(i, tr("Normal Middle"), true);
6240 fschmid 2023
                }
6241 fschmid 2024
        }
5808 cbradney 2025
        tempDoc->addSection();
2026
        tempDoc->setFirstSectionFromFirstPageNumber();
2027
        tempDoc->setModified(false);
2028
        tempDoc->OpenNodes.clear();
2029
        if (requiresGUI)
2030
        {
2031
                actionManager->disconnectNewDocActions();
2032
                actionManager->connectNewDocActions(tempDoc);
2033
        }
5800 fschmid 2034
        //<<View and window code
5808 cbradney 2035
        QWorkspace* qwsp=0;
2036
        if (requiresGUI)
2037
                qwsp=wsp;
2038
        ScribusWin* w = new ScribusWin(qwsp, tempDoc);
5800 fschmid 2039
        w->setMainWindow(this);
5808 cbradney 2040
        if (requiresGUI && view!=NULL)
5800 fschmid 2041
        {
2042
                actionManager->disconnectNewViewActions();
2043
                disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
2044
        }
5808 cbradney 2045
        ScribusView* tempView = new ScribusView(w, this, tempDoc);
2046
        if (requiresGUI)
2047
                view = tempView;
2048
        tempDoc->setCurrentPage(tempDoc->Pages->at(0));
5824 cbradney 2049
        tempDoc->setGUI(requiresGUI, this, tempView);
5808 cbradney 2050
        tempDoc->setLoading(false);
5800 fschmid 2051
        //run after setGUI to set up guidepalette ok
2052
 
5808 cbradney 2053
        tempView->setScale(prefsManager->displayScale());
2054
        if (requiresGUI)
2055
        {
2056
                actionManager->connectNewViewActions(tempView);
2057
                alignDistributePalette->setDoc(tempDoc);
2058
                docCheckerPalette->clearErrorList();
2059
        }
2060
        w->setView(tempView);
5800 fschmid 2061
        ActWin = w;
5808 cbradney 2062
        tempDoc->WinHan = w;
2063
        w->setCentralWidget(tempView);
2064
        if (requiresGUI)
2065
                tempDoc->connectDocSignals(); //Must be before the first reformpages
2066
        tempView->reformPages(true);
5800 fschmid 2067
        //>>
5808 cbradney 2068
        if (requiresGUI)
2069
        {
2070
                connect(undoManager, SIGNAL(undoRedoDone()), tempView, SLOT(DrawNew()));
2071
                //connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
2072
                connect(tempView, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
2073
                //      connect(w, SIGNAL(SaveAndClose()), this, SLOT(DoSaveClose()));
2074
        }
2075
        //Independent finishing tasks after tempDoc setup
5800 fschmid 2076
        if (showView)
2077
        {
2078
                if ( wsp->windowList().isEmpty() )
2079
                        w->showMaximized();
2080
                else
2081
                        w->show();
5808 cbradney 2082
                tempView->show();
5800 fschmid 2083
        }
5808 cbradney 2084
        if (requiresGUI)
2085
        {
2086
                connect(w, SIGNAL(AutoSaved()), this, SLOT(slotAutoSaved()));
2087
                connect(ScCore->fileWatcher, SIGNAL(fileChanged(QString)), tempDoc, SLOT(updatePict(QString)));
2088
                connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), tempDoc, SLOT(removePict(QString)));
5855 cbradney 2089
                //scrActions["fileSave"]->setEnabled(false);
5808 cbradney 2090
                undoManager->switchStack(tempDoc->DocName);
2091
                styleManager->currentDoc(tempDoc);
2092
                tocGenerator->setDoc(tempDoc);
2093
        }
2094
        return tempDoc;
5800 fschmid 2095
}
2096
 
2097
void ScribusMainWindow::newView()
2098
{
2099
        ScribusWin* w = new ScribusWin(wsp, doc);
2100
        w->setMainWindow(