Subversion Repositories Scribus

Rev

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