Subversion Repositories Scribus

Rev

Rev 6939 | Rev 6954 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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