Subversion Repositories Scribus

Rev

Rev 7378 | Rev 7400 | 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");
7350 fschmid 735
        scrMenuMgr->addMenuItem(scrActions["stickyTools"], "Insert");
5800 fschmid 736
        scrMenuMgr->addMenuSeparator("Insert");
737
        scrMenuMgr->addMenuItem(scrActions["insertGlyph"], "Insert");
738
 
739
        scrMenuMgr->createMenu("InsertChar", QPixmap(noIcon), tr("&Character"), "Insert");
740
        //scrMenuMgr->addMenuToMenu("InsertChar", "Insert");
741
        scrMenuMgr->addMenuItem(scrActions["unicodePageNumber"], "InsertChar");
742
        scrMenuMgr->addMenuItem(scrActions["unicodeSmartHyphen"], "InsertChar");
743
        scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingHyphen"], "InsertChar");
744
        scrMenuMgr->addMenuSeparator("InsertChar");
745
        scrMenuMgr->addMenuItem(scrActions["unicodeCopyRight"], "InsertChar");
746
        scrMenuMgr->addMenuItem(scrActions["unicodeRegdTM"], "InsertChar");
747
        scrMenuMgr->addMenuItem(scrActions["unicodeTM"], "InsertChar");
748
        scrMenuMgr->addMenuItem(scrActions["unicodeSolidus"], "InsertChar");
749
        scrMenuMgr->addMenuItem(scrActions["unicodeBullet"], "InsertChar");
750
        scrMenuMgr->addMenuItem(scrActions["unicodeMidpoint"], "InsertChar");
751
        scrMenuMgr->addMenuSeparator("InsertChar");
752
        scrMenuMgr->addMenuItem(scrActions["unicodeDashEm"], "InsertChar");
753
        scrMenuMgr->addMenuItem(scrActions["unicodeDashEn"], "InsertChar");
754
        scrMenuMgr->addMenuItem(scrActions["unicodeDashFigure"], "InsertChar");
755
        scrMenuMgr->addMenuItem(scrActions["unicodeDashQuotation"], "InsertChar");
756
 
757
        scrMenuMgr->createMenu("InsertQuote", QPixmap(noIcon), tr("&Quote"), "Insert");
758
        //scrMenuMgr->addMenuToMenu("InsertQuote", "Insert");
759
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteApostrophe"], "InsertQuote");
760
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteStraight"], "InsertQuote");
761
        scrMenuMgr->addMenuSeparator("InsertQuote");
762
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeft"], "InsertQuote");
763
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRight"], "InsertQuote");
764
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeft"], "InsertQuote");
765
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRight"], "InsertQuote");
766
        scrMenuMgr->addMenuSeparator("InsertQuote");
767
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowSingleComma"], "InsertQuote");
768
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowDoubleComma"], "InsertQuote");
769
        scrMenuMgr->addMenuSeparator("InsertQuote");
770
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleReversed"], "InsertQuote");
771
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleReversed"], "InsertQuote");
772
        scrMenuMgr->addMenuSeparator("InsertQuote");
773
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeftGuillemet"], "InsertQuote");
774
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRightGuillemet"], "InsertQuote");
775
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeftGuillemet"], "InsertQuote");
776
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRightGuillemet"], "InsertQuote");
777
        scrMenuMgr->addMenuSeparator("InsertQuote");
778
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleLeft"], "InsertQuote");
779
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleRight"], "InsertQuote");
780
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleLeft"], "InsertQuote");
781
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleRight"], "InsertQuote");
782
 
783
        scrMenuMgr->createMenu("InsertSpace", QPixmap(noIcon), tr("S&paces && Breaks"), "Insert");
784
        scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingSpace"], "InsertSpace");
785
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEN"], "InsertSpace");
786
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEM"], "InsertSpace");
787
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThin"], "InsertSpace");
788
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThick"], "InsertSpace");
789
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceMid"], "InsertSpace");
790
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceHair"], "InsertSpace");
791
        scrMenuMgr->addMenuSeparator("InsertSpace");
792
        scrMenuMgr->addMenuItem(scrActions["unicodeNewLine"], "InsertSpace");
793
        scrMenuMgr->addMenuItem(scrActions["unicodeFrameBreak"], "InsertSpace");
794
        scrMenuMgr->addMenuItem(scrActions["unicodeColumnBreak"], "InsertSpace");
7038 avox 795
        scrMenuMgr->addMenuItem(scrActions["unicodeZerowidthSpace"], "InsertSpace");
5800 fschmid 796
 
797
        scrMenuMgr->createMenu("InsertLigature", QPixmap(noIcon), tr("Liga&ture"), "Insert");
798
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ff"], "InsertLigature");
799
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fi"], "InsertLigature");
800
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fl"], "InsertLigature");
801
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffi"], "InsertLigature");
802
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffl"], "InsertLigature");
803
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ft"], "InsertLigature");
804
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_st"], "InsertLigature");
805
 
806
        scrMenuMgr->addMenuSeparator("Insert");
807
        scrMenuMgr->addMenuItem(scrActions["insertSampleText"], "Insert");
6115 cbradney 808
        scrActions["insertFrame"]->setEnabled(false);
5800 fschmid 809
 
810
        //Page menu
811
        scrMenuMgr->createMenu("Page", tr("&Page"));
812
        scrMenuMgr->addMenuItem(scrActions["pageInsert"], "Page");
813
        scrMenuMgr->addMenuItem(scrActions["pageImport"], "Page");
814
        scrMenuMgr->addMenuItem(scrActions["pageDelete"], "Page");
815
        scrMenuMgr->addMenuItem(scrActions["pageCopy"], "Page");
816
        scrMenuMgr->addMenuItem(scrActions["pageMove"], "Page");
817
        scrMenuMgr->addMenuItem(scrActions["pageApplyMasterPage"], "Page");
818
        scrMenuMgr->addMenuItem(scrActions["pageCopyToMasterPage"], "Page");
819
        scrMenuMgr->addMenuItem(scrActions["pageManageGuides"], "Page");
820
        scrMenuMgr->addMenuItem(scrActions["pageManageMargins"], "Page");
821
        scrMenuMgr->addMenuSeparator("Page");
822
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGrid"], "Page");
823
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGuides"], "Page");
824
        scrActions["pageDelete"]->setEnabled(false);
825
        scrActions["pageMove"]->setEnabled(false);
826
 
827
        //View menu
828
        scrMenuMgr->createMenu("View", tr("&View"));
829
        scrMenuMgr->addMenuItem(scrActions["viewFitInWindow"], "View");
7164 fschmid 830
        scrMenuMgr->addMenuItem(scrActions["viewFitWidth"], "View");
5800 fschmid 831
        scrMenuMgr->addMenuItem(scrActions["viewFit50"], "View");
832
        scrMenuMgr->addMenuItem(scrActions["viewFit75"], "View");
833
        scrMenuMgr->addMenuItem(scrActions["viewFit100"], "View");
834
        scrMenuMgr->addMenuItem(scrActions["viewFit200"], "View");
835
        scrMenuMgr->addMenuItem(scrActions["viewFit20"], "View");
836
        scrMenuMgr->addMenuSeparator("View");
837
        scrMenuMgr->addMenuItem(scrActions["viewShowMargins"], "View");
7051 fschmid 838
        scrMenuMgr->addMenuItem(scrActions["viewShowBleeds"], "View");
5800 fschmid 839
        scrMenuMgr->addMenuItem(scrActions["viewShowFrames"], "View");
840
        scrMenuMgr->addMenuItem(scrActions["viewShowLayerMarkers"], "View");
841
        scrMenuMgr->addMenuItem(scrActions["viewShowImages"], "View");
842
        scrMenuMgr->addMenuItem(scrActions["viewShowGrid"], "View");
843
        scrMenuMgr->addMenuItem(scrActions["viewShowGuides"], "View");
844
        scrMenuMgr->addMenuItem(scrActions["viewShowColumnBorders"], "View");
845
        scrMenuMgr->addMenuItem(scrActions["viewShowBaseline"], "View");
846
        scrMenuMgr->addMenuItem(scrActions["viewShowTextChain"], "View");
847
        scrMenuMgr->addMenuItem(scrActions["viewShowTextControls"], "View");
848
        scrMenuMgr->addMenuItem(scrActions["viewShowRulers"], "View");
849
        scrMenuMgr->addMenuItem(scrActions["viewRulerMode"], "View");
850
 
851
        scrActions["viewShowRulers"]->setEnabled(false);
852
 
853
        //CB If this is viewNewView imeplemented, it should be on the windows menu
854
//      scrMenuMgr->addMenuItem(scrActions["viewNewView"], "View");
855
 
856
        //Tool menu
857
        /*
858
        scrMenuMgr->createMenu("Tools", tr("&Tools"));
859
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Tools");
860
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Tools");
861
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Tools");
862
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Tools");
863
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Tools");
864
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Tools");
865
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Tools");
866
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Tools");
867
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Tools");
868
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Tools");
869
        scrMenuMgr->addMenuSeparator("Tools");
870
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Tools");
871
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Tools");
872
        //scrActions["toolsPreflightVerifier"]->setEnabled(false);*/
873
 
874
        //Extra menu
875
        scrMenuMgr->createMenu("Extras", tr("E&xtras"));
876
        scrMenuMgr->addMenuItem(scrActions["extrasManagePictures"], "Extras");
877
        scrMenuMgr->addMenuItem(scrActions["extrasHyphenateText"], "Extras");
878
        scrMenuMgr->addMenuItem(scrActions["extrasDeHyphenateText"], "Extras");
879
        scrMenuMgr->addMenuItem(scrActions["extrasGenerateTableOfContents"], "Extras");
880
 
881
        scrMenuMgr->setMenuEnabled("Extras", false);
882
        scrActions["extrasHyphenateText"]->setEnabled(false);
883
        scrActions["extrasDeHyphenateText"]->setEnabled(false);
884
 
885
        //Window menu
886
         scrMenuMgr->createMenu("Windows", tr("&Windows"), QString::null, true);
887
        connect(scrMenuMgr->getLocalPopupMenu("Windows"), SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
888
        addDefaultWindowMenuItems();
889
 
890
        //Help menu
891
        scrMenuMgr->createMenu("Help", tr("&Help"));
892
        scrMenuMgr->addMenuItem(scrActions["helpAboutScribus"], "Help");
893
        scrMenuMgr->addMenuItem(scrActions["helpAboutPlugins"], "Help");
894
        scrMenuMgr->addMenuItem(scrActions["helpAboutQt"], "Help");
895
        scrMenuMgr->addMenuSeparator("Help");
896
        scrMenuMgr->addMenuItem(scrActions["helpTooltips"], "Help");
897
        scrMenuMgr->addMenuItem(scrActions["helpManual"], "Help");
898
 
899
        scrMenuMgr->addMenuToMenuBar("File");
900
        scrMenuMgr->addMenuToMenuBar("Edit");
901
        scrMenuMgr->addMenuToMenuBar("Style");
902
        scrMenuMgr->setMenuEnabled("Style", false);
903
        scrMenuMgr->addMenuToMenuBar("Item");
904
        scrMenuMgr->setMenuEnabled("Item", false);
905
        scrMenuMgr->addMenuToMenuBar("Insert");
906
        scrMenuMgr->setMenuEnabled("Insert", false);
907
        scrMenuMgr->addMenuToMenuBar("Page");
908
        scrMenuMgr->setMenuEnabled("Page", false);
909
        scrMenuMgr->addMenuToMenuBar("View");
910
        scrMenuMgr->setMenuEnabled("View", false);
911
        //scrMenuMgr->addMenuToMenuBar("Tools");
912
        scrMenuMgr->addMenuToMenuBar("Extras");
913
        scrMenuMgr->setMenuEnabled("Extras", false);
914
        scrMenuMgr->addMenuToMenuBar("Windows");
915
        //scrMenuMgr->setMenuEnabled("Windows", false);
916
        menuBar()->insertSeparator();
917
        scrMenuMgr->addMenuToMenuBar("Help");
918
 
919
        //Alignment menu
920
        scrMenuMgr->createMenu("Alignment", tr("&Alignment"));
921
        scrMenuMgr->addMenuItem(scrActions["alignLeft"], "Alignment");
922
        scrMenuMgr->addMenuItem(scrActions["alignCenter"], "Alignment");
923
        scrMenuMgr->addMenuItem(scrActions["alignRight"], "Alignment");
924
        scrMenuMgr->addMenuItem(scrActions["alignBlock"], "Alignment");
925
        scrMenuMgr->addMenuItem(scrActions["alignForced"], "Alignment");
926
 
927
        connect(ColorMenC, SIGNAL(activated(int)), this, SLOT(setItemFarbe(int)));
928
        connect(FontMenu, SIGNAL(activated(int)), this, SLOT(setItemFont(int)));
929
}
930
 
931
void ScribusMainWindow::addDefaultWindowMenuItems()
932
{
933
        scrMenuMgr->clearMenu("Windows");
934
        scrMenuMgr->addMenuItem(scrActions["windowsCascade"], "Windows");
935
        scrMenuMgr->addMenuItem(scrActions["windowsTile"], "Windows");
936
        scrMenuMgr->addMenuSeparator("Windows");
937
 
938
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Windows");
939
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Windows");
940
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Windows");
941
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Windows");
942
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Windows");
943
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Windows");
944
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Windows");
945
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Windows");
946
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Windows");
947
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Windows");
948
        scrMenuMgr->addMenuSeparator("Windows");
949
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Windows");
950
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Windows");
951
}
952
 
953
 
954
void ScribusMainWindow::initStatusBar()
955
{
956
        mainWindowStatusLabel = new QLabel( "           ", statusBar(), "ft");
957
        mainWindowProgressBar = new QProgressBar(statusBar(), "p");
958
        mainWindowProgressBar->setCenterIndicator(true);
959
        mainWindowProgressBar->setFixedWidth( 100 );
960
        mainWindowProgressBar->reset();
961
        mainWindowXPosLabel = new QLabel( "X-Pos:", statusBar(), "xt");
962
        mainWindowYPosLabel = new QLabel( "Y-Pos:", statusBar(), "yt");
963
        mainWindowXPosDataLabel = new QLabel( "        ", statusBar(), "dt");
964
        mainWindowYPosDataLabel = new QLabel( "        ", statusBar(), "ydt");
965
 
966
        statusBar()->addWidget(mainWindowStatusLabel, 6, true);
967
        statusBar()->addWidget(mainWindowProgressBar, 0, true);
968
        statusBar()->addWidget(mainWindowXPosLabel, 0, true);
969
        statusBar()->addWidget(mainWindowXPosDataLabel, 1, true);
970
        statusBar()->addWidget(mainWindowYPosLabel, 0, true);
971
        statusBar()->addWidget(mainWindowYPosDataLabel, 1, true);
972
}
973
 
974
void ScribusMainWindow::setStatusBarMousePosition(double xp, double yp)
975
{
976
        double xn = xp;
977
        double yn = yp;
978
        if (doc->guidesSettings.rulerMode)
979
        {
980
                xn -= doc->currentPage()->xOffset();
981
                yn -= doc->currentPage()->yOffset();
982
        }
983
        xn -= doc->rulerXoffset;
984
        yn -= doc->rulerYoffset;
985
        QString suffix=unitGetSuffixFromIndex(doc->unitIndex());
986
        int multiplier=unitGetDecimalsFromIndex(doc->unitIndex());
987
        double divisor=static_cast<double>(multiplier);
988
        int precision=unitGetPrecisionFromIndex(doc->unitIndex());
989
        QString tmp;
990
        mainWindowXPosDataLabel->setText(tmp.setNum(qRound(xn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
991
        mainWindowYPosDataLabel->setText(tmp.setNum(qRound(yn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
992
}
993
 
994
void ScribusMainWindow::setStatusBarInfoText(QString newText)
995
{
996
        if (mainWindowStatusLabel)
997
                mainWindowStatusLabel->setText(newText);
998
}
999
 
1000
//CB-->Doc
1001
void ScribusMainWindow::setTBvals(PageItem *currItem)
1002
{
1003
        if (currItem->itemText.length() != 0)
1004
        {
1005
//              int ChPos = QMIN(currItem->CPos, static_cast<int>(currItem->itemText.length()-1));
6866 avox 1006
                const ParagraphStyle& currPStyle(currItem->currentStyle());
5800 fschmid 1007
                setAbsValue(currPStyle.alignment());
6866 avox 1008
                propertiesPalette->setParStyle(currPStyle.parent());
5800 fschmid 1009
                doc->currentStyle.charStyle() = currItem->currentCharStyle();
1010
                emit TextUnderline(doc->currentStyle.charStyle().underlineOffset(), doc->currentStyle.charStyle().underlineWidth());
1011
                emit TextStrike(doc->currentStyle.charStyle().strikethruOffset(), doc->currentStyle.charStyle().strikethruWidth());
1012
                emit TextShadow(doc->currentStyle.charStyle().shadowXOffset(), doc->currentStyle.charStyle().shadowYOffset());
7087 subik 1013
                emit TextFarben(doc->currentStyle.charStyle().strokeColor(),
1014
                                                doc->currentStyle.charStyle().fillColor(),
1015
                                                doc->currentStyle.charStyle().strokeShade(),
5800 fschmid 1016
                                                doc->currentStyle.charStyle().fillShade());
5980 avox 1017
                emit TextIFont(doc->currentStyle.charStyle().font().scName());
5800 fschmid 1018
                emit TextISize(doc->currentStyle.charStyle().fontSize());
1019
                emit TextUSval(doc->currentStyle.charStyle().tracking());
1020
                emit TextStil(doc->currentStyle.charStyle().effects());
1021
                emit TextScale(doc->currentStyle.charStyle().scaleH());
1022
                emit TextScaleV(doc->currentStyle.charStyle().scaleV());
1023
                emit TextBase(doc->currentStyle.charStyle().baselineOffset());
1024
                emit TextOutline(doc->currentStyle.charStyle().outlineWidth());
1025
        }
1026
}
1027
 
1028
void ScribusMainWindow::wheelEvent(QWheelEvent *w)
1029
{
1030
        if (HaveDoc)
1031
        {
1032
                int wheelVal=prefsManager->mouseWheelValue();
1033
                if ((w->orientation() != Qt::Vertical) || ( w->state() & ShiftButton ))
1034
                {
1035
                        if (w->delta() < 0)
1036
                                view->scrollBy(wheelVal, 0);
1037
                        else
1038
                                view->scrollBy(-wheelVal, 0);
1039
                }
1040
                else
1041
                {
1042
                        if (w->delta() < 0)
1043
                                view->scrollBy(0, wheelVal);
1044
                        else
1045
                                view->scrollBy(0, -wheelVal);
1046
                }
1047
                w->accept();
1048
        }
1049
}
1050
 
1051
//Special keys assigned to actions are stolen by the action and not passed to
1052
//keyPressEvent so process them here.
1053
void ScribusMainWindow::specialActionKeyEvent(QString actionName, int unicodevalue)
1054
{
1055
        if (HaveDoc)
1056
        {
1057
                if (doc->appMode==modeEdit)
1058
                {
1059
                        if (doc->m_Selection->count() == 1)
1060
                        {
1061
                                PageItem *currItem = doc->m_Selection->itemAt(0);
1062
                                if (currItem!=NULL)
1063
                                {
1064
                                        if (unicodevalue!=-1)
1065
                                        {
1066
                                                if (currItem->HasSel && currItem->itemType()==PageItem::TextFrame)
1067
                                                        currItem->asTextFrame()->deleteSelectedTextFromFrame();
1068
 
1069
                                                currItem->itemText.insertChars(currItem->CPos, QString(QChar(unicodevalue)));
1070
                                                currItem->CPos += 1;
1071
                                                currItem->Tinput = true;
1072
                                                view->RefreshItem(currItem);
1073
                                        }
1074
                                        else if (actionName=="unicodeSmartHyphen") //ignore the char as we use an attribute if the text item, for now.
1075
                                        {
7087 subik 1076
                                                // this code is currently dead since unicodeSmartHyphen
6999 avox 1077
                                                // doesnt have unicodevalue == -1 any more
5800 fschmid 1078
                                                if (currItem->CPos-1>0)
1079
                                                {
6999 avox 1080
#if 1
5800 fschmid 1081
                                                        StyleFlag fl = currItem->itemText.item(QMAX(currItem->CPos-1,0))->effects();
1082
                                                        fl |= ScStyle_HyphenationPossible;
1083
                                                        currItem->itemText.item(QMAX(currItem->CPos-1,0))->setEffects(fl);
1084
#else
1085
                                                        currItem->itemText.insertChars(currItem->CPos, QString(SpecialChars::SHYPHEN));
1086
                                                        currItem->CPos += 1;
1087
#endif
1088
                                                        currItem->Tinput = true;
1089
                                                        view->RefreshItem(currItem);
1090
                                                }
1091
                                        }
1092
                                }
1093
                        }
1094
                }
1095
        }
1096
}
1097
 
1098
bool ScribusMainWindow::eventFilter( QObject* /*o*/, QEvent *e )
1099
{
1100
        bool retVal;
1101
        if ( e->type() == QEvent::KeyPress ) {
1102
                QKeyEvent *k = (QKeyEvent *)e;
1103
                int keyMod=0;
1104
                if (k->state() & ShiftButton)
1105
                        keyMod |= SHIFT;
1106
                if (k->state() & ControlButton)
1107
                        keyMod |= CTRL;
1108
                if (k->state() & AltButton)
1109
                        keyMod |= ALT;
1110
 
1111
                QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
1112
                if (QString(currKeySeq).isNull())
1113
                        return false;
1114
                retVal=true;
1115
                //Palette actions
1116
                if (currKeySeq == scrActions["specialToggleAllPalettes"]->accel())
1117
                        scrActions["specialToggleAllPalettes"]->activate();
1118
                else
1119
                if (currKeySeq == scrActions["toolsProperties"]->accel())
1120
                        scrActions["toolsProperties"]->toggle();
1121
                else
1122
                if (currKeySeq == scrActions["toolsOutline"]->accel())
1123
                        scrActions["toolsOutline"]->toggle();
1124
                else
1125
                if (currKeySeq == scrActions["toolsScrapbook"]->accel())
1126
                        scrActions["toolsScrapbook"]->toggle();
1127
                else
1128
                if (currKeySeq == scrActions["toolsLayers"]->accel())
1129
                        scrActions["toolsLayers"]->toggle();
1130
                else
1131
                if (currKeySeq == scrActions["toolsPages"]->accel())
1132
                        scrActions["toolsPages"]->toggle();
1133
                else
1134
                if (currKeySeq == scrActions["toolsBookmarks"]->accel())
1135
                        scrActions["toolsBookmarks"]->toggle();
1136
                else
1137
                if (currKeySeq == scrActions["toolsActionHistory"]->accel())
1138
                        scrActions["toolsActionHistory"]->toggle();
1139
                else
1140
                if (currKeySeq == scrActions["toolsPreflightVerifier"]->accel())
1141
                        scrActions["toolsPreflightVerifier"]->toggle();
1142
                else
1143
                if (currKeySeq == scrActions["toolsAlignDistribute"]->accel())
1144
                        scrActions["toolsAlignDistribute"]->toggle();
1145
                else
1146
                //Undo actions
1147
                if (currKeySeq == scrActions["editUndoAction"]->accel() && scrActions["editUndoAction"]->isEnabled())
1148
                        scrActions["editUndoAction"]->activate();
1149
                else
1150
                if (currKeySeq == scrActions["editRedoAction"]->accel() && scrActions["editRedoAction"]->isEnabled())
1151
                        scrActions["editRedoAction"]->activate();
1152
                else
1153
                //Other actions
1154
                if (currKeySeq == scrActions["fileQuit"]->accel())
1155
                        scrActions["fileQuit"]->activate();
1156
                else
1157
                //Zoom actions
1158
                if (currKeySeq == scrActions["toolsZoomIn"]->accel())
1159
                        scrActions["toolsZoomIn"]->activate();
1160
                else
1161
                if (currKeySeq == scrActions["toolsZoomOut"]->accel())
1162
                        scrActions["toolsZoomOut"]->activate();
1163
                else
1164
                        retVal=false;
1165
        }
1166
        else
1167
                retVal=false;
1168
        //Return false to pass event to object
1169
        return retVal;
1170
}
1171
 
1172
void ScribusMainWindow::keyPressEvent(QKeyEvent *k)
1173
{
1174
        QWidgetList windows;
1175
        QWidget* w = NULL;
1176
        //struct ScText *hg;
1177
        int kk = k->key();
1178
        //int as = k->ascii();
1179
        //double altx, alty;
1180
        QString uc = k->text();
1181
        QString cr, Tcha, Twort;
1182
        //uint Tcoun;
1183
        //int len, pos, c;
1184
        if (keyrep)
1185
                return;
1186
        keyrep = true;
1187
        int KeyMod;
1188
        switch (k->state())
1189
        {
1190
        case ShiftButton:
1191
                KeyMod = SHIFT;
1192
                break;
1193
        case AltButton:
1194
                KeyMod = ALT;
1195
                break;
1196
        case ControlButton:
1197
                KeyMod = CTRL;
1198
                break;
1199
        default:
1200
                KeyMod = 0;
1201
                break;
1202
        }
1203
        //User presses escape and we have a doc open, and we have an item selected
1204
        if ((kk == Key_Escape) && (HaveDoc))
1205
        {
1206
                keyrep = false;
1207
                PageItem *currItem;
1208
                if (doc->m_Selection->count() != 0)
1209
                {
1210
                        currItem = doc->m_Selection->itemAt(0);
1211
                        switch (doc->appMode)
1212
                        {
1213
                                case modeNormal:
1214
                                        currItem->Sizing = false;
1215
                                        if (doc->SubMode != -1)
1216
                                        {
1217
                                                view->Deselect(false);
1218
                                                doc->Items->remove(currItem->ItemNr);
1219
                                        }
5967 fschmid 1220
                                        else
1221
                                                view->Deselect(false);
5800 fschmid 1222
                                        break;
1223
                                case modeLinkFrames:
1224
                                case modeUnlinkFrames:
1225
                                case modeEdit:
1226
                                case modeRotation:
1227
                                case modeEditGradientVectors:
1228
                                        view->Deselect(false);
1229
                                case modePanning:
1230
                                        break;
1231
                                case modeDrawBezierLine:
1232
                                        currItem->PoLine.resize(currItem->PoLine.size()-2);
1233
                                        if (currItem->PoLine.size() < 4)
1234
                                        {
1235
                                                view->Deselect(false);
1236
                                                doc->Items->remove(currItem->ItemNr);
1237
                                        }
1238
                                        else
1239
                                        {
1240
                                                view->SizeItem(currItem->PoLine.WidthHeight().x(), currItem->PoLine.WidthHeight().y(), currItem->ItemNr, false, false);
1241
                                                currItem->setPolyClip(qRound(QMAX(currItem->lineWidth() / 2.0, 1)));
1242
                                                view->AdjustItemSize(currItem);
1243
                                                currItem->ContourLine = currItem->PoLine.copy();
1244
                                                currItem->ClipEdited = true;
1245
                                                currItem->FrameType = 3;
1246
                                                slotDocCh();
1247
                                        }
1248
                                        view->FirstPoly = true;
1249
                                        break;
1250
                                default:
1251
                                        view->Deselect(false);
1252
                                        doc->Items->remove(currItem->ItemNr);
1253
                                        break;
1254
                        }
1255
                }
1256
                view->m_MouseButtonPressed = false;
1257
                doc->DragP = false;
1258
                doc->leaveDrag = false;
1259
                view->operItemMoving = false;
1260
                view->operItemResizing = false;
7284 fschmid 1261
                view->inItemCreation = false;
5800 fschmid 1262
                view->MidButt = false;
1263
                doc->SubMode = -1;
1264
                doc->ElemToLink = NULL;
1265
                NoFrameEdit();
1266
                slotSelect();
1267
                return;
1268
        }
1269
        ButtonState buttonState = k->state();
1270
        /**If we have a doc and we are not changing the page or zoom level in the status bar */
1271
        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
1272
        {
1273
                /**
1274
                 * With no item selected we can:
1275
                 * - With space, get into panning mode (modePanning)
1276
                 * - With PageUp, scroll up
1277
                 * - With PageDown, scroll down
1278
                 * - With Tab, change active document windowActivated
1279
                 */
1280
 
1281
                if ((doc->appMode != modeEdit) && (doc->m_Selection->count() == 0))
1282
                {
6284 fschmid 1283
                        int pg;
5800 fschmid 1284
                        switch (kk)
1285
                        {
1286
                        case Key_Space:
1287
                                keyrep = false;
1288
                                if (doc->appMode == modePanning)
1289
                                        setAppMode(modeNormal);
1290
                                else
1291
                                        setAppMode(modePanning);
1292
                                return;
1293
                                break;
1294
                        case Key_Prior:
6284 fschmid 1295
                                if (doc->masterPageMode())
1296
                                        view->scrollBy(0, -prefsManager->mouseWheelValue());
1297
                                else
1298
                                {
1299
                                        pg = doc->currentPageNumber();
1300
                                        if ((buttonState & ShiftButton) && !(buttonState & ControlButton) && !(buttonState & AltButton))
1301
                                                pg--;
1302
                                        else
1303
                                                pg -= doc->pageSets[doc->currentPageLayout].Columns;
1304
                                        if (pg > -1)
1305
                                                view->GotoPage(pg);
1306
                                }
5800 fschmid 1307
                                keyrep = false;
1308
                                return;
1309
                                break;
1310
                        case Key_Next:
6284 fschmid 1311
                                if (doc->masterPageMode())
1312
                                        view->scrollBy(0, prefsManager->mouseWheelValue());
1313
                                else
1314
                                {
1315
                                        pg = doc->currentPageNumber();
1316
                                        if ((buttonState & ShiftButton) && !(buttonState & ControlButton) && !(buttonState & AltButton))
1317
                                                pg++;
1318
                                        else
1319
                                                pg += doc->pageSets[doc->currentPageLayout].Columns;
7328 fschmid 1320
                                        if (pg < static_cast<int>(doc->Pages->count()))
6284 fschmid 1321
                                                view->GotoPage(pg);
1322
                                }
5800 fschmid 1323
                                keyrep = false;
1324
                                return;
1325
                                break;
1326
                        case Key_Tab:
1327
                                keyrep = false;
1328
                                windows = wsp->windowList();
1329
                                if (windows.count() > 1)
1330
                                {
1331
                                        for (int i = 0; i < static_cast<int>(windows.count()); ++i)
1332
                                        {
1333
                                                if (wsp->activeWindow() == windows.at(i))
1334
                                                {
1335
                                                        if (i == static_cast<int>(windows.count()-1))
1336
                                                                w = windows.at(0);
1337
                                                        else
1338
                                                                w = windows.at(i+1);
1339
                                                        break;
1340
                                                }
1341
                                        }
1342
                                        doc->OpenNodes = outlinePalette->buildReopenVals();
1343
                                        docCheckerPalette->clearErrorList();
1344
                                        if ( w )
1345
                                                w->showNormal();
1346
                                        newActWin(w);
1347
                                }
1348
                                return;
1349
                                break;
1350
                        }
1351
                }
1352
                /** Now if we have an item selected
1353
                 * - In normal mode we can:
1354
                 * -- Use backspace or delete to delete the item
1355
                 * -- Use PageUp to raise an item
1356
                 * -- Use PageDown to lower an item
6083 cbradney 1357
                 * -- Use the arrow keys to move an item or group around for !inches:
5800 fschmid 1358
                                With no meta, by 1.0 unit
5975 cbradney 1359
                                Ctrl, by 10.0 units
1360
                                Shift by 0.1 units
1361
                                Ctrl Shift 0.01 units
6083 cbradney 1362
                        - For inches:
1363
                                With no meta, by 1.0 pt
1364
                                Ctrl, by 1.0 unit
1365
                                Shift by 0.1 units
1366
                                Ctrl Shift 0.01 units
5800 fschmid 1367
                 * -- Use the arrow keys to resize an item:
1368
                                Alt right arrow, move right side outwards (expand)
1369
                                Alt left arrow, move left side outwards (expand)
1370
                                Alt Shift right arrow, move left side inwards (shrink)
1371
                                Alt Shift left arrow, move right side inwards (shrink)
1372
                 * -- In edit mode of an image frame, use the arrow keys to resize the image:
1373
                                (flows to pageitem_imageframe for control)
1374
                                Alt right arrow, move right side of image outwards (expand)
1375
                                Alt left arrow, move right side inwards (shrink)
1376
                                Alt down arrow, move bottom side downwards (expand)
1377
                                Alt up arrow, move top side inwards (shrink)
1378
                 */
1379
                if (doc->m_Selection->count() != 0)
1380
                {
1381
                        double moveBy=1.0;
6083 cbradney 1382
                        if (doc->unitIndex()!=SC_INCHES)
1383
                        {
1384
                                if ((buttonState & ShiftButton) && !(buttonState & ControlButton) && !(buttonState & AltButton))
1385
                                        moveBy=0.1;
1386
                                else if (!(buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
1387
                                        moveBy=10.0;
1388
                                else if ((buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
1389
                                        moveBy=0.01;
7087 subik 1390
 
6083 cbradney 1391
                                moveBy/=doc->unitRatio();//Lets allow movement by the current doc ratio, not only points
1392
                        }
1393
                        else
1394
                        {
1395
                                if ((buttonState & ShiftButton) && !(buttonState & ControlButton) && !(buttonState & AltButton))
1396
                                        moveBy=0.1/doc->unitRatio();
1397
                                else if (!(buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
1398
                                        moveBy=1.0/doc->unitRatio();
1399
                                else if ((buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
1400
                                        moveBy=0.01/doc->unitRatio();
1401
                        }
5800 fschmid 1402
                        bool resizing=((buttonState & AltButton) && !(buttonState & ControlButton));
1403
                        bool resizingsmaller=(resizing && (buttonState & ShiftButton));
1404
                        double resizeBy=1.0;
1405
                        //CB with control locked out due to the requirement of moveby of 0.01, we cannot support
1406
                        //resizeby 10 units unless we move to supporting modifier keys that most people dont have.
1407
                        //if (buttonState & ControlButton)
1408
                        //      resizeBy*=10.0;
1409
                        resizeBy/=doc->unitRatio();
1410
                        if (resizingsmaller)
1411
                                resizeBy*=-1.0;
1412
 
1413
 
1414
                        PageItem *currItem = doc->m_Selection->itemAt(0);
1415
                        switch (doc->appMode)
1416
                        {
1417
                        case modeNormal:
1418
                                switch (kk)
1419
                                {
1420
                                case Key_Backspace:
1421
                                case Key_Delete:
1422
                                        doc->itemSelection_DeleteItem();
1423
                                        break;
1424
                                case Key_Prior:
1425
                                        if (!currItem->locked())
1426
                                        {
1427
                                                view->RaiseItem();
1428
                                        }
1429
                                        break;
1430
                                case Key_Next:
1431
                                        if (!currItem->locked())
1432
                                        {
1433
                                                view->LowerItem();
1434
                                        }
1435
                                        break;
1436
                                case Key_Left:
1437
                                        if (!currItem->locked())
1438
                                        {
1439
                                                if (!resizing)
1440
                                                {
1441
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1442
                                                        {
1443
                                                                FPoint np;
1444
                                                                if (view->EditContour)
1445
                                                                        np = currItem->ContourLine.point(view->ClRe);
1446
                                                                else
1447
                                                                        np = currItem->PoLine.point(view->ClRe);
1448
                                                                np = np - FPoint(moveBy, 0);
1449
                                                                view->MoveClipPoint(currItem, np);
1450
                                                        }
1451
                                                        else
1452
                                                        {
1453
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1454
                                                        /* as the user might be trying to fine tune a position */
1455
                                                                bool sav1 = doc->SnapGuides;
1456
                                                                bool sav2 = doc->useRaster;
1457
                                                                doc->SnapGuides = false;
1458
                                                                doc->useRaster = false;
1459
                                                                view->moveGroup(-moveBy, 0);
1460
                                                                doc->SnapGuides = sav1;
1461
                                                                doc->useRaster = sav2;
1462
                                                        }
1463
                                                }
1464
                                                else
1465
                                                {
1466
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1467
                                                        if(view->EditContour)
1468
                                                                view->TransformPoly(10, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
1469
                                                        else
1470
                                                        {
1471
                                                                if (resizingsmaller)
1472
                                                                {
1473
                                                                        currItem->Sizing = false;
1474
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1475
                                                                }
1476
                                                                else
1477
                                                                {
1478
                                                                        view->MoveItem(-resizeBy, 0, currItem, false);
5922 cbradney 1479
                                                                        currItem->moveImageXYOffsetBy(resizeBy/currItem->imageXScale(), 0);
5800 fschmid 1480
                                                                        currItem->Sizing = false;
1481
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1482
                                                                }
1483
                                                        }
1484
                                                }
1485
                                                view->updateContents();
1486
                                                slotDocCh();
1487
                                        }
1488
                                        break;
1489
                                case Key_Right:
1490
                                        if (!currItem->locked())
1491
                                        {
1492
                                                if (!resizing)
1493
                                                {
1494
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1495
                                                        {
1496
                                                                FPoint np;
1497
                                                                if (view->EditContour)
1498
                                                                        np = currItem->ContourLine.point(view->ClRe);
1499
                                                                else
1500
                                                                        np = currItem->PoLine.point(view->ClRe);
1501
                                                                np = np + FPoint(moveBy, 0);
1502
                                                                view->MoveClipPoint(currItem, np);
1503
                                                        }
1504
                                                        else
1505
                                                        {
1506
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1507
                                                        /* as the user might be trying to fine tune a position */
1508
                                                                bool sav1 = doc->SnapGuides;
1509
                                                                bool sav2 = doc->useRaster;
1510
                                                                doc->SnapGuides = false;
1511
                                                                doc->useRaster = false;
1512
                                                                view->moveGroup(moveBy, 0);
1513
                                                                doc->SnapGuides = sav1;
1514
                                                                doc->useRaster = sav2;
1515
                                                        }
1516
                                                }
1517
                                                else
1518
                                                {
1519
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1520
                                                        if(view->EditContour)
1521
                                                                view->TransformPoly(11, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
1522
                                                        else
1523
                                                        {
1524
                                                                if (resizingsmaller)
1525
                                                                {
1526
                                                                        view->MoveItem(-resizeBy, 0, currItem, false);
5922 cbradney 1527
                                                                        currItem->moveImageXYOffsetBy(resizeBy/currItem->imageXScale(), 0);
5800 fschmid 1528
                                                                        currItem->Sizing = false;
1529
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1530
                                                                }
1531
                                                                else
1532
                                                                {
1533
                                                                        currItem->Sizing = false;
1534
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1535
                                                                }
1536
                                                        }
1537
                                                }
1538
                                                view->updateContents();
1539
                                                slotDocCh();
1540
                                        }
1541
                                        break;
1542
                                case Key_Up:
1543
                                        if (!currItem->locked())
1544
                                        {
1545
                                                if (!resizing)
1546
                                                {
1547
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1548
                                                        {
1549
                                                                FPoint np;
1550
                                                                if (view->EditContour)
1551
                                                                        np = currItem->ContourLine.point(view->ClRe);
1552
                                                                else
1553
                                                                        np = currItem->PoLine.point(view->ClRe);
1554
                                                                np = np - FPoint(0, moveBy);
1555
                                                                view->MoveClipPoint(currItem, np);
1556
                                                        }
1557
                                                        else
1558
                                                        {
1559
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1560
                                                        /* as the user might be trying to fine tune a position */
1561
                                                                bool sav1 = doc->SnapGuides;
1562
                                                                bool sav2 = doc->useRaster;
1563
                                                                doc->SnapGuides = false;
1564
                                                                doc->useRaster = false;
1565
                                                                view->moveGroup(0, -moveBy);
1566
                                                                doc->SnapGuides = sav1;
1567
                                                                doc->useRaster = sav2;
1568
                                                        }
1569
                                                }
1570
                                                else
1571
                                                {
1572
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1573
                                                        if(view->EditContour)
1574
                                                                view->TransformPoly(12, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
1575
                                                        else
1576
                                                        {
1577
                                                                if (resizingsmaller)
1578
                                                                {
1579
                                                                        currItem->Sizing = false;
1580
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1581
                                                                }
1582
                                                                else
1583
                                                                {
1584
                                                                        view->MoveItem(0, -resizeBy, currItem, false);
5922 cbradney 1585
                                                                        currItem->moveImageXYOffsetBy(0, resizeBy/currItem->imageYScale());
5800 fschmid 1586
                                                                        currItem->Sizing = false;
1587
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1588
                                                                }
1589
                                                        }
1590
                                                }
1591
                                                view->updateContents();
1592
                                                slotDocCh();
1593
                                        }
1594
                                        break;
1595
                                case Key_Down:
1596
                                        if (!currItem->locked())
1597
                                        {
1598
                                                if (!resizing)
1599
                                                {
1600
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1601
                                                        {
1602
                                                                FPoint np;
1603
                                                                if (view->EditContour)
1604
                                                                        np = currItem->ContourLine.point(view->ClRe);
1605
                                                                else
1606
                                                                        np = currItem->PoLine.point(view->ClRe);
1607
                                                                np = np + FPoint(0, moveBy);
1608
                                                                view->MoveClipPoint(currItem, np);
1609
                                                        }
1610
                                                        else
1611
                                                        {
1612
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1613
                                                        /* as the user might be trying to fine tune a position */
1614
                                                                bool sav1 = doc->SnapGuides;
1615
                                                                bool sav2 = doc->useRaster;
1616
                                                                doc->SnapGuides = false;
1617
                                                                doc->useRaster = false;
1618
                                                                view->moveGroup(0, moveBy);
1619
                                                                doc->SnapGuides = sav1;
1620
                                                                doc->useRaster = sav2;
1621
                                                        }
1622
                                                }
1623
                                                else
1624
                                                {
1625
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1626
                                                        if(view->EditContour)
1627
                                                                view->TransformPoly(13, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
1628
                                                        else
1629
                                                        {
1630
                                                                if (resizingsmaller)
1631
                                                                {
1632
                                                                        view->MoveItem(0, -resizeBy, currItem, false);
5922 cbradney 1633
                                                                        currItem->moveImageXYOffsetBy(0, resizeBy/currItem->imageYScale());
5800 fschmid 1634
                                                                        currItem->Sizing = false;
1635
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1636
                                                                }
1637
                                                                else
1638
                                                                {
1639
                                                                        currItem->Sizing = false;
1640
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1641
                                                                }
1642
                                                        }
1643
                                                }
1644
                                                view->updateContents();
1645
                                                slotDocCh();
1646
                                        }
1647
                                        break;
1648
                                default:
1649
                                        break;
1650
                                }
1651
                                break;
1652
                        case modeEdit:
1653
                                if (currItem->asImageFrame() && !currItem->locked())
1654
                                {
1655
                                        currItem->handleModeEditKey(k, keyrep);
1656
                                        /*
1657
                                        double dX=0.0,dY=0.0;
1658
                                        switch (kk)
1659
                                        {
1660
                                                case Key_Left:
1661
                                                        dX=-moveBy;
1662
                                                        break;
1663
                                                case Key_Right:
1664
                                                        dX=moveBy;
1665
                                                        break;
1666
                                                case Key_Up:
1667
                                                        dY=-moveBy;
1668
                                                        break;
1669
                                                case Key_Down:
1670
                                                        dY=moveBy;
1671
                                                        break;
1672
                                        }
1673
                                        if (dX!=0.0 || dY!=0.0)
1674
                                        {
1675
                                                currItem->moveImageInFrame(dX, dY);
1676
                                                view->updateContents(currItem->getRedrawBounding(view->scale()));
1677
                                        }*/
1678
                                }
1679
                                view->oldCp = currItem->CPos;
1680
                                if (currItem->itemType() == PageItem::TextFrame)
1681
                                {
1682
                                        bool kr=keyrep;
1683
                                        currItem->handleModeEditKey(k, keyrep);
1684
                                        keyrep=kr;
1685
                                }
1686
                                slotDocCh(false);
1687
                                break;
1688
                        }
1689
                }
1690
        }
1691
        switch(kk)
1692
        {
1693
                case Key_Left:
1694
                case Key_Right:
1695
                case Key_Up:
1696
                case Key_Down:
1697
                        _arrowKeyDown = true;
1698
        }
1699
        keyrep = false;
1700
}
1701
 
1702
void ScribusMainWindow::keyReleaseEvent(QKeyEvent *k)
1703
{
1704
        if (HaveDoc && (k->state() & ControlButton))
1705
        {
1706
                if ((doc->appMode == modePanning) && (k->state() & Qt::RightButton))
1707
                        setAppMode(modeNormal);
1708
        }
1709
        if (k->isAutoRepeat() || !_arrowKeyDown)
1710
                return;
1711
        switch(k->key())
1712
        {
1713
                case Key_Left:
1714
                case Key_Right:
1715
                case Key_Up:
1716
                case Key_Down:
1717
                        _arrowKeyDown = false;
1718
                        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
1719
                        {
1720
                                uint docSelectionCount=doc->m_Selection->count();
1721
                                if ((docSelectionCount != 0) && (doc->appMode == modeNormal) && (doc->EditClip) && (view->ClRe != -1))
1722
                                        view->updateContents();
1723
                                for (uint i = 0; i < docSelectionCount; ++i)
1724
                                        doc->m_Selection->itemAt(i)->checkChanges(true);
1725
                                if (docSelectionCount > 1 && view->groupTransactionStarted())
1726
                                        undoManager->commit();
1727
                        }
1728
                        break;
1729
        }
1730
}
1731
 
1732
void ScribusMainWindow::closeEvent(QCloseEvent *ce)
1733
{
1734
        QWidgetList windows = wsp->windowList();
1735
        ScribusWin* tw;
1736
        disconnect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
1737
        if (!windows.isEmpty())
1738
        {
1739
                uint windowCount=windows.count();
1740
                for ( uint i = 0; i < windowCount; ++i )
1741
                {
1742
                        newActWin(windows.at(i));
1743
                        tw = ActWin;
1744
                        ActWin->close();
1745
                        if (tw == ActWin)
1746
                        {
1747
                                ce->ignore();
1748
                                connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
1749
                                return;
1750
                        }
1751
                }
1752
        }
1753
        propertiesPalette->hide();
1754
        outlinePalette->hide();
1755
        scrapbookPalette->hide();
1756
        bookmarkPalette->hide();
1757
        layerPalette->hide();
1758
        pagePalette->hide();
1759
        measurementPalette->hide();
1760
        docCheckerPalette->hide();
1761
        undoPalette->hide();
1762
        alignDistributePalette->hide();
1763
        guidePalette->hide();
7087 subik 1764
        charPalette->hide();
5800 fschmid 1765
 
1766
        // Clean up plugins, THEN save prefs to disk
1767
        ScCore->pluginManager->cleanupPlugins();
1768
        if (!prefsManager->appPrefs.persistentScrapbook)
1769
                scrapbookPalette->CleanUpTemp();
1770
        prefsManager->appPrefs.RecentScrapbooks.clear();
1771
        prefsManager->appPrefs.RecentScrapbooks = scrapbookPalette->getOpenScrapbooks();
1772
        if (!emergencyActivated)
1773
                prefsManager->SavePrefs();
1774
        UndoManager::deleteInstance();
1775
        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1776
        exit(0);
1777
}
1778
 
1779
/////////////////////////////////////////////////////////////////////
1780
// SLOT IMPLEMENTATION
1781
/////////////////////////////////////////////////////////////////////
1782
 
1783
 
1784
bool ScribusMainWindow::arrowKeyDown()
1785
{
1786
        return _arrowKeyDown;
1787
}
1788
 
1789
void ScribusMainWindow::startUpDialog()
1790
{
7025 fschmid 1791
        bool docSet = false;
5800 fschmid 1792
        PrefsContext* docContext = prefsManager->prefsFile->getContext("docdirs", false);
1793
        NewDoc* dia = new NewDoc(this, RecentDocs, true);
1794
        if (dia->exec())
1795
        {
1796
                if (dia->tabSelected == 0)
1797
                {
1798
                        int facingPages = dia->choosenLayout;
7025 fschmid 1799
                        int firstPage = dia->firstPage->currentItem();
1800
                        docSet = dia->startDocSetup->isChecked();
5800 fschmid 1801
                        double topMargin = dia->marginGroup->top();
1802
                        double bottomMargin = dia->marginGroup->bottom();
1803
                        double leftMargin = dia->marginGroup->left();
1804
                        double rightMargin = dia->marginGroup->right();
1805
                        double columnDistance = dia->Dist;
1806
                        double pageWidth = dia->pageWidth;
1807
                        double pageHeight = dia->pageHeight;
1808
                        double numberCols = dia->numberOfCols->value();
7023 fschmid 1809
                        bool autoframes = dia->autoTextFrame->isChecked();
5800 fschmid 1810
                        int orientation = dia->Orient;
5918 cbradney 1811
                        int pageCount=dia->pageCountSpinBox->value();
5800 fschmid 1812
                        PageSize ps2(dia->pageSizeComboBox->currentText());
1813
                        QString pagesize = ps2.name();
5918 cbradney 1814
                        doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->unitOfMeasureComboBox->currentItem(), firstPage, orientation, 1, pagesize, true, pageCount);
5800 fschmid 1815
                        doc->pageSets[facingPages].FirstPage = firstPage;
7225 cbradney 1816
                        doc->bleeds.Bottom = dia->bleedBottom;
1817
                        doc->bleeds.Top = dia->bleedTop;
1818
                        doc->bleeds.Left = dia->bleedLeft;
1819
                        doc->bleeds.Right = dia->bleedRight;
5800 fschmid 1820
                        HaveNewDoc();
1821
                }
1822
                else
1823
                {
1824
                        if (dia->tabSelected == 1)
1825
                        {
1826
                                QString fileName(dia->fileDialog->selectedFile());
1827
                                if (!fileName.isEmpty())
1828
                                {
1829
                                        docContext->set("docsopen", fileName.left(fileName.findRev("/")));
1830
                                        loadDoc(fileName);
1831
                                }
1832
                        }
1833
                        else
1834
                        {
1835
                                QString fileName(dia->recentDocListBox->currentText());
1836
                                if (!fileName.isEmpty())
7117 jghali 1837
                                        loadRecent(ScPaths::separatorsToSlashes(fileName));
5800 fschmid 1838
                        }
1839
                }
1840
        }
1841
        prefsManager->setShowStartupDialog(!dia->startUpDialog->isChecked());
1842
        delete dia;
1843
        mainWindowStatusLabel->setText( tr("Ready"));
7025 fschmid 1844
        if (docSet)
1845
                slotDocSetup();
5800 fschmid 1846
}
1847
 
1848
bool ScribusMainWindow::slotFileNew()
1849
{
6541 cbradney 1850
        if (HaveDoc && doc->EditClip)
1851
                ToggleFrameEdit();
6189 jghali 1852
        bool retVal = false;
7025 fschmid 1853
        bool docSet = false;
5800 fschmid 1854
        NewDoc* dia = new NewDoc(this, RecentDocs);
1855
        if (dia->exec())
1856
        {
1857
                int facingPages = dia->choosenLayout;
7025 fschmid 1858
                int firstPage = dia->firstPage->currentItem();
1859
                docSet = dia->startDocSetup->isChecked();
5800 fschmid 1860
                double topMargin = dia->marginGroup->top();
1861
                double bottomMargin = dia->marginGroup->bottom();
1862
                double leftMargin = dia->marginGroup->left();
1863
                double rightMargin = dia->marginGroup->right();
1864
                double columnDistance = dia->Dist;
1865
                double pageWidth = dia->pageWidth;
1866
                double pageHeight = dia->pageHeight;
1867
                double numberCols = dia->numberOfCols->value();
7023 fschmid 1868
                bool autoframes = dia->autoTextFrame->isChecked();
5800 fschmid 1869
                int orientation = dia->Orient;
5918 cbradney 1870
                int pageCount=dia->pageCountSpinBox->value();
5800 fschmid 1871
                PageSize ps2(dia->pageSizeComboBox->currentText());
6189 jghali 1872
                if (doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->unitOfMeasureComboBox->currentItem(), firstPage, orientation, 1, ps2.name(), true, pageCount))
1873
                {
1874
                        doc->pageSets[facingPages].FirstPage = firstPage;
7225 cbradney 1875
                        doc->bleeds.Bottom = dia->bleedBottom;
1876
                        doc->bleeds.Top = dia->bleedTop;
1877
                        doc->bleeds.Left = dia->bleedLeft;
1878
                        doc->bleeds.Right = dia->bleedRight;
6189 jghali 1879
                        mainWindowStatusLabel->setText( tr("Ready"));
1880
                        HaveNewDoc();
1881
                        retVal = true;
1882
                }
5800 fschmid 1883
        }
1884
        delete dia;
7025 fschmid 1885
        if (docSet)
1886
                slotDocSetup();
6189 jghali 1887
        return retVal;
5800 fschmid 1888
}
1889
 
1890
//TODO move to core, assign doc to doc list, optionally create gui for it
5808 cbradney 1891
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 1892
{
5808 cbradney 1893
        return doFileNew(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, columnCount, autoTextFrames, pageArrangement, unitIndex, firstPageLocation, orientation, firstPageNumber, defaultPageSize, requiresGUI, pageCount, showView);
5800 fschmid 1894
        /* TODO CB finish later this week.
1895
        if (HaveDoc)
1896
                doc->OpenNodes = outlinePalette->buildReopenVals();
1897
        MarginStruct margins(topMargin, leftMargin, bottomMargin, rightMargin);
1898
        DocPagesSetup pagesSetup(pageArrangement, firstPageLocation, firstPageNumber, orientation, autoTextFrames, columnDistance, columnCount);
1899
        QString newDocName(tr("Document")+"-"+QString::number(DocNr));
1900
        doc = new ScribusDoc(newDocName, unitindex, pagesize, margins, pagesSetup);
1901
                doc->setLoading(true);
1902
        doc->setup(unitIndex, pageArrangement, firstPageLocation, orientation, firstPageNumber, defaultPageSize, newDocName);
1903
        HaveDoc++;
1904
        DocNr++;
5880 jghali 1905
        if (ScCore->haveCMS() && doc->CMSSettings.CMSinUse)
5800 fschmid 1906
                recalcColors();
1907
        //CB NOTE should be all done now
1908
        doc->setPage(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, columnCount, autoTextFrames, pageArrangement);
1909
        doc->setMasterPageMode(false);
6715 cbradney 1910
        doc->addMasterPage(0, CommonStrings::masterPageNormal);
5800 fschmid 1911
        int createCount=QMAX(pageCount,1);
1912
        for (int i = 0; i < createCount; ++i)
6715 cbradney 1913
                doc->addPage(i, CommonStrings::masterPageNormal, true);
5800 fschmid 1914
        doc->addSection();
1915
        doc->setFirstSectionFromFirstPageNumber();
1916
        doc->setModified(false);
1917
        doc->OpenNodes.clear();
1918
        actionManager->disconnectNewDocActions();
1919
        actionManager->connectNewDocActions(doc);
1920
        //<<View and window code
1921
        ScribusWin* w = new ScribusWin(wsp, doc);
1922
        w->setMainWindow(this);
1923
        if (view!=NULL)
1924
        {
1925
                actionManager->disconnectNewViewActions();
1926
                disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
1927
        }
1928
        view = new ScribusView(w, this, doc);
1929
        doc->setCurrentPage(doc->Pages->at(0));
1930
        doc->setGUI(this, view);
1931
        doc->setLoading(false);
1932
        //run after setGUI to set up guidepalette ok
7087 subik 1933
 
5800 fschmid 1934
        view->setScale(prefsManager->displayScale());
1935
        actionManager->connectNewViewActions(view);
1936
        alignDistributePalette->setDoc(doc);
1937
        docCheckerPalette->clearErrorList();
1938
        w->setView(view);
1939
        ActWin = w;
1940
        doc->WinHan = w;
1941
        w->setCentralWidget(view);
1942
        doc->connectDocSignals(); //Must be before the first reformpages
1943
        view->reformPages(true);
1944
        //>>
1945
 
1946
        connect(undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
1947
        //connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
1948
        connect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
1949
        //      connect(w, SIGNAL(SaveAndClose()), this, SLOT(DoSaveClose()));
1950
 
1951
        //Independent finishing tasks after doc setup
1952
        if (showView)
1953
        {
1954
                if ( wsp->windowList().isEmpty() )
1955
                        w->showMaximized();
1956
                else
1957
                        w->show();
1958
                view->show();
1959
        }
1960
        connect(w, SIGNAL(AutoSaved()), this, SLOT(slotAutoSaved()));
1961
        connect(ScCore->fileWatcher, SIGNAL(fileChanged(QString)), doc, SLOT(updatePict(QString)));
1962
        connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), doc, SLOT(removePict(QString)));
1963
        scrActions["fileSave"]->setEnabled(false);
1964
        undoManager->switchStack(doc->DocName);
1965
        styleManager->currentDoc(doc);
1966
        tocGenerator->setDoc(doc);
1967
 
1968
        return doc;
1969
        */
1970
}
1971
 
5808 cbradney 1972
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 1973
{
1974
        if (HaveDoc)
1975
        {
1976
                doc->OpenNodes = outlinePalette->buildReopenVals();
1977
        }
6725 tsoots 1978
        undoManager->setUndoEnabled(false);
5800 fschmid 1979
        MarginStruct margins(topMargin, leftMargin, bottomMargin, rightMargin);
1980
        DocPagesSetup pagesSetup(pageArrangement, firstPageLocation, firstPageNumber, orientation, autoTextFrames, columnDistance, columnCount);
6259 fschmid 1981
        QString newDocName( tr("Document")+"-"+QString::number(DocNr));
5808 cbradney 1982
        ScribusDoc *tempDoc = new ScribusDoc();
1983
        if (requiresGUI)
1984
                doc=tempDoc;
1985
        //tempDoc = new ScribusDoc(newDocName, unitindex, pagesize, margins, pagesSetup);
1986
        tempDoc->setLoading(true);
7099 fschmid 1987
        outlinePalette->setDoc(tempDoc);
5808 cbradney 1988
        tempDoc->setup(unitIndex, pageArrangement, firstPageLocation, orientation, firstPageNumber, defaultPageSize, newDocName);
1989
        if (requiresGUI)
1990
        {
1991
                HaveDoc++;
1992
                DocNr++;
1993
        }
5880 jghali 1994
        if (ScCore->haveCMS() && tempDoc->CMSSettings.CMSinUse)
5800 fschmid 1995
                recalcColors();
1996
        //CB NOTE should be all done now
5914 fschmid 1997
        tempDoc->setPage(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnCount, columnDistance, autoTextFrames, pageArrangement);
5808 cbradney 1998
        tempDoc->setMasterPageMode(false);
6715 cbradney 1999
        tempDoc->createDefaultMasterPages();
2000
        tempDoc->createNewDocPages(pageCount);
5808 cbradney 2001
        tempDoc->addSection();
2002
        tempDoc->setFirstSectionFromFirstPageNumber();
2003
        tempDoc->setModified(false);
2004
        tempDoc->OpenNodes.clear();
2005
        if (requiresGUI)
2006
        {
2007
                actionManager->disconnectNewDocActions();
2008
                actionManager->connectNewDocActions(tempDoc);
2009
        }
5800 fschmid 2010
        //<<View and window code
5808 cbradney 2011
        QWorkspace* qwsp=0;
2012
        if (requiresGUI)
2013
                qwsp=wsp;
2014
        ScribusWin* w = new ScribusWin(qwsp, tempDoc);
5800 fschmid 2015
        w->setMainWindow(this);
5808 cbradney 2016
        if (requiresGUI && view!=NULL)
5800 fschmid 2017
        {
2018
                actionManager->disconnectNewViewActions();
2019
                disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
2020
        }
5808 cbradney 2021
        ScribusView* tempView = new ScribusView(w, this, tempDoc);
2022
        if (requiresGUI)
2023
                view = tempView;
2024
        tempDoc->setCurrentPage(tempDoc->Pages->at(0));
5824 cbradney 2025
        tempDoc->setGUI(requiresGUI, this, tempView);
5808 cbradney 2026
        tempDoc->setLoading(false);
5800 fschmid 2027
        //run after setGUI to set up guidepalette ok
7087 subik 2028
 
5808 cbradney 2029
        tempView->setScale(prefsManager->displayScale());
2030
        if (requiresGUI)
2031
        {
2032
                actionManager->connectNewViewActions(tempView);
2033
                alignDistributePalette->setDoc(tempDoc);
2034
                docCheckerPalette->clearErrorList();
2035
        }
2036
        w->setView(tempView);
5800 fschmid 2037
        ActWin = w;
5808 cbradney 2038
        tempDoc->WinHan = w;
2039
        w->setCentralWidget(tempView);
2040
        if (requiresGUI)
2041
                tempDoc->connectDocSignals(); //Must be before the first reformpages
2042
        tempView->reformPages(true);
5800 fschmid 2043
        //>>
5808 cbradney 2044
        if (requiresGUI)
2045
        {
2046
                connect(undoManager, SIGNAL(undoRedoDone()), tempView, SLOT(DrawNew()));
2047
                //connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
2048
                connect(tempView, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
2049
                //      connect(w, SIGNAL(SaveAndClose()), this, SLOT(DoSaveClose()));
2050
        }
2051
        //Independent finishing tasks after tempDoc setup
5800 fschmid 2052
        if (showView)
2053
        {
2054
                if ( wsp->windowList().isEmpty() )
2055
                        w->showMaximized();
2056
                else
2057
                        w->show();
5808 cbradney 2058
                tempView->show();
5800 fschmid 2059
        }
5808 cbradney 2060
        if (requiresGUI)
2061
        {
2062
                connect(w, SIGNAL(AutoSaved()), this, SLOT(slotAutoSaved()));
2063
                connect(ScCore->fileWatcher, SIGNAL(fileChanged(QString)), tempDoc, SLOT(updatePict(QString)));
2064
                connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), tempDoc, SLOT(removePict(QString)));
5855 cbradney 2065
                //scrActions["fileSave"]->setEnabled(false);
6726 fschmid 2066
                tempView->cmsToolbarButton->setOn(tempDoc->HasCMS);
5808 cbradney 2067
                undoManager->switchStack(tempDoc->DocName);
2068
                styleManager->currentDoc(tempDoc);
2069
                tocGenerator->setDoc(tempDoc);
2070
        }
6725 tsoots 2071
        undoManager->setUndoEnabled(true);
5808 cbradney 2072
        return tempDoc;
5800 fschmid 2073
}
2074
 
2075
void ScribusMainWindow::newView()
2076
{
2077
        ScribusWin* w = new ScribusWin(wsp, doc);
2078
        w->setMainWindow(this);
2079
        view = new ScribusView(w, this, doc);
2080
        view->setScale(prefsManager->displayScale());
2081
        w->setView(view);
2082
        ActWin = w;
2083
        w->setCentralWidget(view);
6312 fschmid 2084
        actionManager->connectNewViewActions(view);
5800 fschmid 2085
        alignDistributePalette