Subversion Repositories Scribus

Rev

Rev 5876 | Rev 5890 | 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");
5859 tsoots 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);
1417
                                                                        currItem->Sizing = false;
1418
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1419
                                                                }
1420
                                                        }
1421
                                                }
1422
                                                view->updateContents();
1423
                                                slotDocCh();
1424
                                        }
1425
                                        break;
1426
                                case Key_Right:
1427
                                        if (!currItem->locked())
1428
                                        {
1429
                                                if (!resizing)
1430
                                                {
1431
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1432
                                                        {
1433
                                                                FPoint np;
1434
                                                                if (view->EditContour)
1435
                                                                        np = currItem->ContourLine.point(view->ClRe);
1436
                                                                else
1437
                                                                        np = currItem->PoLine.point(view->ClRe);
1438
                                                                np = np + FPoint(moveBy, 0);
1439
                                                                view->MoveClipPoint(currItem, np);
1440
                                                        }
1441
                                                        else
1442
                                                        {
1443
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1444
                                                        /* as the user might be trying to fine tune a position */
1445
                                                                bool sav1 = doc->SnapGuides;
1446
                                                                bool sav2 = doc->useRaster;
1447
                                                                doc->SnapGuides = false;
1448
                                                                doc->useRaster = false;
1449
                                                                view->moveGroup(moveBy, 0);
1450
                                                                doc->SnapGuides = sav1;
1451
                                                                doc->useRaster = sav2;
1452
                                                        }
1453
                                                }
1454
                                                else
1455
                                                {
1456
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1457
                                                        if(view->EditContour)
1458
                                                                view->TransformPoly(11, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
1459
                                                        else
1460
                                                        {
1461
                                                                if (resizingsmaller)
1462
                                                                {
1463
                                                                        view->MoveItem(-resizeBy, 0, currItem, false);
1464
                                                                        currItem->Sizing = false;
1465
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1466
                                                                }
1467
                                                                else
1468
                                                                {
1469
                                                                        currItem->Sizing = false;
1470
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1471
                                                                }
1472
                                                        }
1473
                                                }
1474
                                                view->updateContents();
1475
                                                slotDocCh();
1476
                                        }
1477
                                        break;
1478
                                case Key_Up:
1479
                                        if (!currItem->locked())
1480
                                        {
1481
                                                if (!resizing)
1482
                                                {
1483
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1484
                                                        {
1485
                                                                FPoint np;
1486
                                                                if (view->EditContour)
1487
                                                                        np = currItem->ContourLine.point(view->ClRe);
1488
                                                                else
1489
                                                                        np = currItem->PoLine.point(view->ClRe);
1490
                                                                np = np - FPoint(0, moveBy);
1491
                                                                view->MoveClipPoint(currItem, np);
1492
                                                        }
1493
                                                        else
1494
                                                        {
1495
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1496
                                                        /* as the user might be trying to fine tune a position */
1497
                                                                bool sav1 = doc->SnapGuides;
1498
                                                                bool sav2 = doc->useRaster;
1499
                                                                doc->SnapGuides = false;
1500
                                                                doc->useRaster = false;
1501
                                                                view->moveGroup(0, -moveBy);
1502
                                                                doc->SnapGuides = sav1;
1503
                                                                doc->useRaster = sav2;
1504
                                                        }
1505
                                                }
1506
                                                else
1507
                                                {
1508
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1509
                                                        if(view->EditContour)
1510
                                                                view->TransformPoly(12, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
1511
                                                        else
1512
                                                        {
1513
                                                                if (resizingsmaller)
1514
                                                                {
1515
                                                                        currItem->Sizing = false;
1516
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1517
                                                                }
1518
                                                                else
1519
                                                                {
1520
                                                                        view->MoveItem(0, -resizeBy, currItem, false);
1521
                                                                        currItem->Sizing = false;
1522
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1523
                                                                }
1524
                                                        }
1525
                                                }
1526
                                                view->updateContents();
1527
                                                slotDocCh();
1528
                                        }
1529
                                        break;
1530
                                case Key_Down:
1531
                                        if (!currItem->locked())
1532
                                        {
1533
                                                if (!resizing)
1534
                                                {
1535
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1536
                                                        {
1537
                                                                FPoint np;
1538
                                                                if (view->EditContour)
1539
                                                                        np = currItem->ContourLine.point(view->ClRe);
1540
                                                                else
1541
                                                                        np = currItem->PoLine.point(view->ClRe);
1542
                                                                np = np + FPoint(0, moveBy);
1543
                                                                view->MoveClipPoint(currItem, np);
1544
                                                        }
1545
                                                        else
1546
                                                        {
1547
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1548
                                                        /* as the user might be trying to fine tune a position */
1549
                                                                bool sav1 = doc->SnapGuides;
1550
                                                                bool sav2 = doc->useRaster;
1551
                                                                doc->SnapGuides = false;
1552
                                                                doc->useRaster = false;
1553
                                                                view->moveGroup(0, moveBy);
1554
                                                                doc->SnapGuides = sav1;
1555
                                                                doc->useRaster = sav2;
1556
                                                        }
1557
                                                }
1558
                                                else
1559
                                                {
1560
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1561
                                                        if(view->EditContour)
1562
                                                                view->TransformPoly(13, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
1563
                                                        else
1564
                                                        {
1565
                                                                if (resizingsmaller)
1566
                                                                {
1567
                                                                        view->MoveItem(0, -resizeBy, currItem, false);
1568
                                                                        currItem->Sizing = false;
1569
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1570
                                                                }
1571
                                                                else
1572
                                                                {
1573
                                                                        currItem->Sizing = false;
1574
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1575
                                                                }
1576
                                                        }
1577
                                                }
1578
                                                view->updateContents();
1579
                                                slotDocCh();
1580
                                        }
1581
                                        break;
1582
                                default:
1583
                                        break;
1584
                                }
1585
                                break;
1586
                        case modeEdit:
1587
                                if (currItem->asImageFrame() && !currItem->locked())
1588
                                {
1589
                                        currItem->handleModeEditKey(k, keyrep);
1590
                                        /*
1591
                                        double dX=0.0,dY=0.0;
1592
                                        switch (kk)
1593
                                        {
1594
                                                case Key_Left:
1595
                                                        dX=-moveBy;
1596
                                                        break;
1597
                                                case Key_Right:
1598
                                                        dX=moveBy;
1599
                                                        break;
1600
                                                case Key_Up:
1601
                                                        dY=-moveBy;
1602
                                                        break;
1603
                                                case Key_Down:
1604
                                                        dY=moveBy;
1605
                                                        break;
1606
                                        }
1607
                                        if (dX!=0.0 || dY!=0.0)
1608
                                        {
1609
                                                currItem->moveImageInFrame(dX, dY);
1610
                                                view->updateContents(currItem->getRedrawBounding(view->scale()));
1611
                                        }*/
1612
                                }
1613
                                view->oldCp = currItem->CPos;
1614
                                if (currItem->itemType() == PageItem::TextFrame)
1615
                                {
1616
                                        bool kr=keyrep;
1617
                                        currItem->handleModeEditKey(k, keyrep);
1618
                                        keyrep=kr;
1619
                                }
1620
                                slotDocCh(false);
1621
                                break;
1622
                        }
1623
                }
1624
        }
1625
        switch(kk)
1626
        {
1627
                case Key_Left:
1628
                case Key_Right:
1629
                case Key_Up:
1630
                case Key_Down:
1631
                        _arrowKeyDown = true;
1632
        }
1633
        keyrep = false;
1634
}
1635
 
1636
void ScribusMainWindow::keyReleaseEvent(QKeyEvent *k)
1637
{
1638
        if (HaveDoc && (k->state() & ControlButton))
1639
        {
1640
                if ((doc->appMode == modePanning) && (k->state() & Qt::RightButton))
1641
                        setAppMode(modeNormal);
1642
        }
1643
        if (k->isAutoRepeat() || !_arrowKeyDown)
1644
                return;
1645
        switch(k->key())
1646
        {
1647
                case Key_Left:
1648
                case Key_Right:
1649
                case Key_Up:
1650
                case Key_Down:
1651
                        _arrowKeyDown = false;
1652
                        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
1653
                        {
1654
                                uint docSelectionCount=doc->m_Selection->count();
1655
                                if ((docSelectionCount != 0) && (doc->appMode == modeNormal) && (doc->EditClip) && (view->ClRe != -1))
1656
                                        view->updateContents();
1657
                                for (uint i = 0; i < docSelectionCount; ++i)
1658
                                        doc->m_Selection->itemAt(i)->checkChanges(true);
1659
                                if (docSelectionCount > 1 && view->groupTransactionStarted())
1660
                                        undoManager->commit();
1661
                        }
1662
                        break;
1663
        }
1664
}
1665
 
1666
void ScribusMainWindow::closeEvent(QCloseEvent *ce)
1667
{
1668
        QWidgetList windows = wsp->windowList();
1669
        ScribusWin* tw;
1670
        disconnect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
1671
        if (!windows.isEmpty())
1672
        {
1673
                uint windowCount=windows.count();
1674
                for ( uint i = 0; i < windowCount; ++i )
1675
                {
1676
                        newActWin(windows.at(i));
1677
                        tw = ActWin;
1678
                        ActWin->close();
1679
                        if (tw == ActWin)
1680
                        {
1681
                                ce->ignore();
1682
                                connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
1683
                                return;
1684
                        }
1685
                }
1686
        }
1687
        propertiesPalette->hide();
1688
        outlinePalette->hide();
1689
        scrapbookPalette->hide();
1690
        bookmarkPalette->hide();
1691
        layerPalette->hide();
1692
        pagePalette->hide();
1693
        measurementPalette->hide();
1694
        docCheckerPalette->hide();
1695
        undoPalette->hide();
1696
        alignDistributePalette->hide();
1697
        guidePalette->hide();
1698
 
1699
        // Clean up plugins, THEN save prefs to disk
1700
        ScCore->pluginManager->cleanupPlugins();
1701
        if (!prefsManager->appPrefs.persistentScrapbook)
1702
                scrapbookPalette->CleanUpTemp();
1703
        prefsManager->appPrefs.RecentScrapbooks.clear();
1704
        prefsManager->appPrefs.RecentScrapbooks = scrapbookPalette->getOpenScrapbooks();
1705
        if (!emergencyActivated)
1706
                prefsManager->SavePrefs();
1707
        UndoManager::deleteInstance();
1708
        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1709
        exit(0);
1710
}
1711
 
1712
/////////////////////////////////////////////////////////////////////
1713
// SLOT IMPLEMENTATION
1714
/////////////////////////////////////////////////////////////////////
1715
 
1716
 
1717
bool ScribusMainWindow::arrowKeyDown()
1718
{
1719
        return _arrowKeyDown;
1720
}
1721
 
1722
void ScribusMainWindow::startUpDialog()
1723
{
1724
        PrefsContext* docContext = prefsManager->prefsFile->getContext("docdirs", false);
1725
        NewDoc* dia = new NewDoc(this, RecentDocs, true);
1726
        if (dia->exec())
1727
        {
1728
                if (dia->tabSelected == 0)
1729
                {
1730
                        int facingPages = dia->choosenLayout;
1731
                        int firstPage = dia->docLayout->firstPage->currentItem();
1732
                        double topMargin = dia->marginGroup->top();
1733
                        double bottomMargin = dia->marginGroup->bottom();
1734
                        double leftMargin = dia->marginGroup->left();
1735
                        double rightMargin = dia->marginGroup->right();
1736
                        double columnDistance = dia->Dist;
1737
                        double pageWidth = dia->pageWidth;
1738
                        double pageHeight = dia->pageHeight;
1739
                        double numberCols = dia->numberOfCols->value();
1740
                        bool autoframes = dia->AutoFrame->isChecked();
1741
                        int orientation = dia->Orient;
1742
                        int pageCount=dia->PgNum->value();
1743
                        PageSize ps2(dia->pageSizeComboBox->currentText());
1744
                        QString pagesize = ps2.name();
5808 cbradney 1745
                        doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->unitOfMeasure->currentItem(), firstPage, orientation, 1, pagesize, true, pageCount);
5800 fschmid 1746
                        doc->pageSets[facingPages].FirstPage = firstPage;
1747
                        HaveNewDoc();
1748
                }
1749
                else
1750
                {
1751
                        if (dia->tabSelected == 1)
1752
                        {
1753
                                QString fileName(dia->fileDialog->selectedFile());
1754
                                if (!fileName.isEmpty())
1755
                                {
1756
                                        docContext->set("docsopen", fileName.left(fileName.findRev("/")));
1757
                                        loadDoc(fileName);
1758
                                }
1759
                        }
1760
                        else
1761
                        {
1762
                                QString fileName(dia->recentDocListBox->currentText());
1763
                                if (!fileName.isEmpty())
1764
                                        loadRecent(fileName);
1765
                        }
1766
                }
1767
        }
1768
        prefsManager->setShowStartupDialog(!dia->startUpDialog->isChecked());
1769
        delete dia;
1770
        mainWindowStatusLabel->setText( tr("Ready"));
1771
}
1772
 
1773
bool ScribusMainWindow::slotFileNew()
1774
{
1775
        NewDoc* dia = new NewDoc(this, RecentDocs);
1776
        if (dia->exec())
1777
        {
1778
                int facingPages = dia->choosenLayout;
1779
                int firstPage = dia->docLayout->firstPage->currentItem();
1780
                double topMargin = dia->marginGroup->top();
1781
                double bottomMargin = dia->marginGroup->bottom();
1782
                double leftMargin = dia->marginGroup->left();
1783
                double rightMargin = dia->marginGroup->right();
1784
                double columnDistance = dia->Dist;
1785
                double pageWidth = dia->pageWidth;
1786
                double pageHeight = dia->pageHeight;
1787
                double numberCols = dia->numberOfCols->value();
1788
                bool autoframes = dia->AutoFrame->isChecked();
1789
                int orientation = dia->Orient;
1790
                int pageCount=dia->PgNum->value();
1791
                PageSize ps2(dia->pageSizeComboBox->currentText());
5808 cbradney 1792
                if (!doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->unitOfMeasure->currentItem(), firstPage, orientation, 1, ps2.name(), true, pageCount))
5800 fschmid 1793
                        return false;
1794
                doc->pageSets[facingPages].FirstPage = firstPage;
1795
                mainWindowStatusLabel->setText( tr("Ready"));
1796
                HaveNewDoc();
1797
        }
1798
        delete dia;
5876 subik 1799
        return true;
5800 fschmid 1800
}
1801
 
1802
//TODO move to core, assign doc to doc list, optionally create gui for it
5808 cbradney 1803
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 1804
{
5808 cbradney 1805
        return doFileNew(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, columnCount, autoTextFrames, pageArrangement, unitIndex, firstPageLocation, orientation, firstPageNumber, defaultPageSize, requiresGUI, pageCount, showView);
5800 fschmid 1806
        /* TODO CB finish later this week.
1807
        if (HaveDoc)
1808
                doc->OpenNodes = outlinePalette->buildReopenVals();
1809
        MarginStruct margins(topMargin, leftMargin, bottomMargin, rightMargin);
1810
        DocPagesSetup pagesSetup(pageArrangement, firstPageLocation, firstPageNumber, orientation, autoTextFrames, columnDistance, columnCount);
1811
        QString newDocName(tr("Document")+"-"+QString::number(DocNr));
1812
        doc = new ScribusDoc(newDocName, unitindex, pagesize, margins, pagesSetup);
1813
                doc->setLoading(true);
1814
        doc->setup(unitIndex, pageArrangement, firstPageLocation, orientation, firstPageNumber, defaultPageSize, newDocName);
1815
        HaveDoc++;
1816
        DocNr++;
5880 jghali 1817
        if (ScCore->haveCMS() && doc->CMSSettings.CMSinUse)
5800 fschmid 1818
                recalcColors();
1819
        //CB NOTE should be all done now
1820
        doc->setPage(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, columnCount, autoTextFrames, pageArrangement);
1821
        doc->setMasterPageMode(false);
1822
        doc->addMasterPage(0, "Normal");
1823
        int createCount=QMAX(pageCount,1);
1824
        for (int i = 0; i < createCount; ++i)
1825
                doc->addPage(i, "Normal", true);
1826
        doc->addSection();
1827
        doc->setFirstSectionFromFirstPageNumber();
1828
        doc->setModified(false);
1829
        doc->OpenNodes.clear();
1830
        actionManager->disconnectNewDocActions();
1831
        actionManager->connectNewDocActions(doc);
1832
        //<<View and window code
1833
        ScribusWin* w = new ScribusWin(wsp, doc);
1834
        w->setMainWindow(this);
1835
        if (view!=NULL)
1836
        {
1837
                actionManager->disconnectNewViewActions();
1838
                disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
1839
        }
1840
        view = new ScribusView(w, this, doc);
1841
        doc->setCurrentPage(doc->Pages->at(0));
1842
        doc->setGUI(this, view);
1843
        doc->setLoading(false);
1844
        //run after setGUI to set up guidepalette ok
1845
 
1846
        view->setScale(prefsManager->displayScale());
1847
        actionManager->connectNewViewActions(view);
1848
        alignDistributePalette->setDoc(doc);
1849
        docCheckerPalette->clearErrorList();
1850
        w->setView(view);
1851
        ActWin = w;
1852
        doc->WinHan = w;
1853
        w->setCentralWidget(view);
1854
        doc->connectDocSignals(); //Must be before the first reformpages
1855
        view->reformPages(true);
1856
        //>>
1857
 
1858
        connect(undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
1859
        //connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
1860
        connect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
1861
        //      connect(w, SIGNAL(SaveAndClose()), this, SLOT(DoSaveClose()));
1862
 
1863
        //Independent finishing tasks after doc setup
1864
        if (showView)
1865
        {
1866
                if ( wsp->windowList().isEmpty() )
1867
                        w->showMaximized();
1868
                else
1869
                        w->show();
1870
                view->show();
1871
        }
1872
        connect(w, SIGNAL(AutoSaved()), this, SLOT(slotAutoSaved()));
1873
        connect(ScCore->fileWatcher, SIGNAL(fileChanged(QString)), doc, SLOT(updatePict(QString)));
1874
        connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), doc, SLOT(removePict(QString)));
1875
        scrActions["fileSave"]->setEnabled(false);
1876
        undoManager->switchStack(doc->DocName);
1877
        styleManager->currentDoc(doc);
1878
        tocGenerator->setDoc(doc);
1879
 
1880
        return doc;
1881
        */
1882
}
1883
 
5808 cbradney 1884
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 1885
{
1886
        if (HaveDoc)
1887
        {
1888
                doc->OpenNodes = outlinePalette->buildReopenVals();
1889
        }
1890
 
1891
        MarginStruct margins(topMargin, leftMargin, bottomMargin, rightMargin);
1892
        DocPagesSetup pagesSetup(pageArrangement, firstPageLocation, firstPageNumber, orientation, autoTextFrames, columnDistance, columnCount);
1893
        QString newDocName(tr("Document")+"-"+QString::number(DocNr));
5808 cbradney 1894
        ScribusDoc *tempDoc = new ScribusDoc();
1895
        if (requiresGUI)
1896
                doc=tempDoc;
1897
        //tempDoc = new ScribusDoc(newDocName, unitindex, pagesize, margins, pagesSetup);
1898
        tempDoc->setLoading(true);
1899
        tempDoc->setup(unitIndex, pageArrangement, firstPageLocation, orientation, firstPageNumber, defaultPageSize, newDocName);
1900
        if (requiresGUI)
1901
        {
1902
                HaveDoc++;
1903
                DocNr++;
1904
        }
5880 jghali 1905
        if (ScCore->haveCMS() && tempDoc->CMSSettings.CMSinUse)
5800 fschmid 1906
                recalcColors();
1907
        //CB NOTE should be all done now
5808 cbradney 1908
        tempDoc->setPage(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, columnCount, autoTextFrames, pageArrangement);
1909
        tempDoc->setMasterPageMode(false);
1910
        tempDoc->addMasterPage(0, "Normal");
5800 fschmid 1911
        int createCount=QMAX(pageCount,1);
1912
        for (int i = 0; i < createCount; ++i)
5808 cbradney 1913
                tempDoc->addPage(i, "Normal", true);
1914
        tempDoc->addSection();
1915
        tempDoc->setFirstSectionFromFirstPageNumber();
1916
        tempDoc->setModified(false);
1917
        tempDoc->OpenNodes.clear();
1918
        if (requiresGUI)
1919
        {
1920
                actionManager->disconnectNewDocActions();
1921
                actionManager->connectNewDocActions(tempDoc);
1922
        }
5800 fschmid 1923
        //<<View and window code
5808 cbradney 1924
        QWorkspace* qwsp=0;
1925
        if (requiresGUI)
1926
                qwsp=wsp;
1927
        ScribusWin* w = new ScribusWin(qwsp, tempDoc);
5800 fschmid 1928
        w->setMainWindow(this);
5808 cbradney 1929
        if (requiresGUI && view!=NULL)
5800 fschmid 1930
        {
1931
                actionManager->disconnectNewViewActions();
1932
                disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
1933
        }
5808 cbradney 1934
        ScribusView* tempView = new ScribusView(w, this, tempDoc);
1935
        if (requiresGUI)
1936
                view = tempView;
1937
        tempDoc->setCurrentPage(tempDoc->Pages->at(0));
5824 cbradney 1938
        tempDoc->setGUI(requiresGUI, this, tempView);
5808 cbradney 1939
        tempDoc->setLoading(false);
5800 fschmid 1940
        //run after setGUI to set up guidepalette ok
1941
 
5808 cbradney 1942
        tempView->setScale(prefsManager->displayScale());
1943
        if (requiresGUI)
1944
        {
1945
                actionManager->connectNewViewActions(tempView);
1946
                alignDistributePalette->setDoc(tempDoc);
1947
                docCheckerPalette->clearErrorList();
1948
        }
1949
        w->setView(tempView);
5800 fschmid 1950
        ActWin = w;
5808 cbradney 1951
        tempDoc->WinHan = w;
1952
        w->setCentralWidget(tempView);
1953
        if (requiresGUI)
1954
                tempDoc->connectDocSignals(); //Must be before the first reformpages
1955
        tempView->reformPages(true);
5800 fschmid 1956
        //>>
5808 cbradney 1957
        if (requiresGUI)
1958
        {
1959
                connect(undoManager, SIGNAL(undoRedoDone()), tempView, SLOT(DrawNew()));
1960
                //connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
1961
                connect(tempView, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
1962
                //      connect(w, SIGNAL(SaveAndClose()), this, SLOT(DoSaveClose()));
1963
        }
1964
        //Independent finishing tasks after tempDoc setup
5800 fschmid 1965
        if (showView)
1966
        {
1967
                if ( wsp->windowList().isEmpty() )
1968
                        w->showMaximized();
1969
                else
1970
                        w->show();
5808 cbradney 1971
                tempView->show();
5800 fschmid 1972
        }
5808 cbradney 1973
        if (requiresGUI)
1974
        {
1975
                connect(w, SIGNAL(AutoSaved()), this, SLOT(slotAutoSaved()));
1976
                connect(ScCore->fileWatcher, SIGNAL(fileChanged(QString)), tempDoc, SLOT(updatePict(QString)));
1977
                connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), tempDoc, SLOT(removePict(QString)));
5855 cbradney 1978
                //scrActions["fileSave"]->setEnabled(false);
5808 cbradney 1979
                undoManager->switchStack(tempDoc->DocName);
1980
                styleManager->currentDoc(tempDoc);
1981
                tocGenerator->setDoc(tempDoc);
1982
        }
1983
        return tempDoc;
5800 fschmid 1984
}
1985
 
1986
void ScribusMainWindow::newView()
1987
{
1988
        ScribusWin* w = new ScribusWin(wsp, doc);
1989
        w->setMainWindow(this);
1990
        view = new ScribusView(w, this, doc);
1991
        view->setScale(prefsManager->displayScale());
1992
        w->setView(view);
1993
        ActWin = w;
1994
        w->setCentralWidget(view);
1995
        alignDistributePalette->setDoc(doc);
1996
        connect(undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
1997
        //connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
1998
}
1999
 
2000
void ScribusMainWindow::windowsMenuAboutToShow()
2001
{
2002
        for( QMap<QString, QGuardedPtr<ScrAction> >::Iterator it = scrWindowsActions.begin(); it!=scrWindowsActions.end(); ++it )
2003
                scrMenuMgr->removeMenuItem((*it), "Windows");
2004
        scrWindowsActions.clear();
2005
        addDefaultWindowMenuItems();
2006
        QWidgetList windows = wsp->windowList();
2007
        bool windowsListNotEmpty=!windows.isEmpty();
2008
        scrActions["windowsCascade"]->setEnabled(windowsListNotEmpty);
2009
        scrActions["windowsTile"]->setEnabled(windowsListNotEmpty);
2010
        if (windowsListNotEmpty)
2011
        {
2012
                scrMenuMgr->addMenuSeparator("Windows");
2013
 
2014
                int windowCount=static_cast<int>(windows.count());
2015
                for ( int i = 0; i < windowCount; ++i )
2016
                {
2017
                        QString docInWindow=windows.at(i)->caption();
2018
                        scrWindowsActions.insert(docInWindow, new ScrAction( ScrAction::Window, noIcon, docInWindow, QKeySequence(), this, docInWindow, i));
2019
                        scrWindowsActions[docInWindow]->setToggleAction(true);
2020
                        connect( scrWindowsActions[docInWindow], SIGNAL(activatedData(int)), this, SLOT(windowsMenuActivated(int)) );
2021
                        scrMenuMgr->addMenuItem(scrWindowsActions[docInWindow], "Windows");
2022
                        scrWindowsActions[docInWindow]->setOn(wsp->activeWindow() == windows.at(i));
2023
                }
2024
        }
2025
}
2026
 
2027
void ScribusMainWindow::newActWin(QWidget *w)
2028
{
2029
        if (w == NULL)
2030
        {
2031
                ActWin = NULL;
2032
                return;
2033
        }
5808 cbradney 2034
        ScribusWin* scw = (ScribusWin*)w;
2035
        if (scw && scw->doc())
5823 cbradney 2036
                if (!scw->doc()->hasGUI())
5808 cbradney 2037
                        return;
2038
        ActWin = scw;
5800 fschmid 2039
        if (ActWin->doc()==NULL)
2040
                return;
2041
        QString oldDocName = "";
2042
        if (ActWin && ActWin->doc())
2043
        {
2044
                oldDocName = ActWin->doc()->DocName;
2045
        }
2046
/*      if (doc != NULL)
2047
        {
2048
                if ((HaveDoc) && (doc != ActWin->doc))
2049
                        doc->OpenNodes = outlinePalette->buildReopenVals();
2050
        } */
2051
        docCheckerPalette->clearErrorList();
2052
        QString newDocName = "";
2053
        if (ActWin && ActWin->doc())
2054
                newDocName = ActWin->doc()->DocName;
2055
 
2056
        if (oldDocName != newDocName)
2057
                undoManager->switchStack(newDocName);
2058
 
2059
        if (view!=NULL)
2060
        {
2061
                actionManager->disconnectNewViewActions();
2062
                disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
2063
                if (ScCore->usingGUI())
2064
                {
2065
                        disconnect(doc->m_Selection, SIGNAL(selectionIsMultiple(bool)), 0, 0);
2066
                        //disconnect(doc->m_Selection, SIGNAL(empty()), 0, 0);
2067
                }
2068
        }
2069
        doc = ActWin->doc();
2070
        view = ActWin->view();
2071
        actionManager->connectNewViewActions(view);
2072
        actionManager->disconnectNewDocActions();
2073
        actionManager->connectNewDocActions(doc);
2074
        styleManager->currentDoc(doc);
2075
        connect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
2076
        if (ScCore->usingGUI())
2077
        {
2078
                connect(doc->m_Selection, SIGNAL(selectionIsMultiple(bool)), propertiesPalette, SLOT( setMultipleSelection(bool)));
2079
                //connect(doc->m_Selection, SIGNAL(empty()), propertiesPalette, SLOT( unsetItem()));
2080
        }
2081
 
2082
        pagePalette->setView(view);
2083
        alignDistributePalette->setDoc(doc);
2084
        if (!doc->isLoading())
2085
        {
2086
                scanDocument();
2087
                docCheckerPalette->buildErrorList(doc);
2088
                SwitchWin();
2089
                QWidgetList windows = wsp->windowList();
2090
                ScribusWin* swin;
2091
                for ( int i = 0; i < static_cast<int>(windows.count()); ++i )
2092
                {
2093
                        swin = (ScribusWin*)windows.at(i);
2094
                        if (swin==ActWin && doc->masterPageMode())
2095
                                swin->setMasterPagesPaletteShown(true);
2096
                        else
2097
                                swin->setMasterPagesPaletteShown(false);
2098
                }
2099
                //if (doc->masterPageMode())
2100
                //      ActWin->setMasterPagesPaletteShown(true);
2101
                setAppMode(doc->appMode);
2102
        }
2103
        w->setFocus();
2104
        wsp->setScrollBarsEnabled(!(w->isMaximized()));
2105
        scrActions["viewShowMargins"]->setOn(doc->guidesSettings.marginsShown);
2106
        scrActions["viewShowFrames"]->setOn(doc->guidesSettings.framesShown);
2107
        scrActions["viewShowLayerMarkers"]->setOn(doc->guidesSettings.layerMarkersShown);
2108
        scrActions["viewShowGrid"]->setOn(doc->guidesSettings.gridShown);
2109
        scrActions["viewShowGuides"]->setOn(doc->guidesSettings.guidesShown);
2110
        scrActions["viewShowColumnBorders"]->setOn(doc->guidesSettings.colBordersShown);
2111
        scrActions["viewShowBaseline"]->setOn(doc->guidesSettings.baseShown);
2112
        scrActions["viewShowImages"]->setOn(doc->guidesSettings.showPic);
2113
        scrActions["viewShowTextChain"]->setOn(doc->guidesSettings.linkShown);
2114
        scrActions["viewShowTextControls"]->setOn(doc->guidesSettings.showControls);
2115
        scrActions["viewShowRulers"]->setOn(doc->guidesSettings.rulersShown);
2116
        scrActions["viewRulerMode"]->setOn(doc->guidesSettings.rulerMode);
2117
        if (!doc->masterPageMode())
2118
                pagePalette->Rebuild();
2119
        outlinePalette->setDoc(doc);
2120
        outlinePalette->BuildTree();
2121
//      outlinePalette->reopenTree(doc->OpenNodes);
2122
/*      bookmarkPalette->BView->NrItems = doc->NrItems;
2123
        bookmarkPalette->BView->First = doc->First;
2124
        bookmarkPalette->BView->Last = doc->Last; */
2125
        RestoreBookMarks();
2126
        if (!doc->isLoading())
2127
        {
2128
                if (doc->m_Selection->count() != 0)
2129
                {
2130
                        HaveNewSel(doc->m_Selection->itemAt(0)->itemType());
2131
                        doc->m_Selection->itemAt(0)->emitAllToGUI();
2132
                }
2133
                else
2134
                        HaveNewSel(-1);
2135
        }
2136
        tocGenerator->setDoc(doc);
2137
}
2138
 
2139
void ScribusMainWindow::windowsMenuActivated( int id )
2140
{
2141
        if (HaveDoc)
2142
                doc->OpenNodes = outlinePalette->buildReopenVals();
2143
        QWidget* windowWidget = wsp->windowList().at( id );
2144
        if ( windowWidget )
2145
                windowWidget->showNormal();
2146
        newActWin(windowWidget);
2147
}
2148
 
2149
void ScribusMainWindow::docSetup(ReformDoc* dia)
2150
{
2151
        slotChangeUnit(dia->getSelectedUnit(), false);
2152
        dia->updateDocumentSettings();
2153
        if (dia->imageResolutionChanged())
2154
                doc->recalcPicturesRes();
2155
        FontSub->RebuildList(doc);