Subversion Repositories Scribus

Rev

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