Subversion Repositories Scribus

Rev

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