Subversion Repositories Scribus

Rev

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

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