Subversion Repositories Scribus

Rev

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