Subversion Repositories Scribus

Rev

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

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