Subversion Repositories Scribus

Rev

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