Subversion Repositories Scribus

Rev

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