Subversion Repositories Scribus

Rev

Rev 5509 | Rev 5717 | 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;
1781 fschmid 185
cmsHTRANSFORM stdTransG;
186
cmsHTRANSFORM stdProofG;
187
cmsHTRANSFORM stdTransImgG;
188
cmsHTRANSFORM stdProofImgG;
189
cmsHTRANSFORM stdTransCMYKG;
190
cmsHTRANSFORM stdProofCMYKG;
191
cmsHTRANSFORM stdTransRGBG;
3046 fschmid 192
cmsHTRANSFORM stdProofGCG;
193
cmsHTRANSFORM stdProofCMYKGCG;
1488 fschmid 194
bool BlackPoint;
3 paul 195
bool SoftProofing;
196
bool Gamut;
3206 craig 197
bool SCRIBUS_API CMSuse;
3 paul 198
int IntentMonitor;
199
int IntentPrinter;
200
#endif
201
bool CMSavail;
3234 fschmid 202
bool previewDinUse;
203
bool printDinUse;
2891 cbradney 204
 
3 paul 205
QString DocDir;
3205 craig 206
 
2536 cbradney 207
extern ScribusQApp* ScQApp;
2634 cbradney 208
extern bool emergencyActivated;
3 paul 209
 
4026 craig 210
ScribusMainWindow::ScribusMainWindow()
2161 cbradney 211
{
2199 cbradney 212
        scribusInitialized=false;
2164 subik 213
        actionManager=NULL;
2178 cbradney 214
        scrMenuMgr=NULL;
2199 cbradney 215
        undoManager=NULL;
2834 cbradney 216
        prefsManager=NULL;
3580 avox 217
#ifdef Q_WS_MAC
218
        noIcon = loadIcon("noicon.xpm");
219
#endif
4026 craig 220
} // ScribusMainWindow::ScribusMainWindow()
188 Franz 221
 
767 cbradney 222
/*
223
 * retval 0 - ok, 1 - no fonts, ...
224
 */
4026 craig 225
int ScribusMainWindow::initScribus(bool showSplash, bool showFontInfo, const QString newGuiLanguage, const QString prefsUserFile)
188 Franz 226
{
2952 cbradney 227
        CommonStrings::languageChange();
767 cbradney 228
        int retVal=0;
1155 fschmid 229
        ExternalApp = 0;
3234 fschmid 230
        previewDinUse = false;
231
        printDinUse = false;
770 cbradney 232
        guiLanguage = newGuiLanguage;
767 cbradney 233
        initSplash(showSplash);
1208 cbradney 234
        setUsesBigPixmaps(true);
355 Franz 235
        CurrStED = NULL;
272 Franz 236
        setCaption( tr("Scribus " VERSION));
118 Franz 237
        setKeyCompression(false);
272 Franz 238
        setIcon(loadIcon("AppIcon.png"));
1325 cbradney 239
        scrActionGroups.clear();
240
        scrActionGroups.setAutoDelete(true);
1208 cbradney 241
        scrActions.clear();
242
        scrRecentFileActions.clear();
1260 cbradney 243
        scrWindowsActions.clear();
2408 cbradney 244
        scrLayersActions.clear();
1208 cbradney 245
        scrMenuMgr = new MenuManager(this->menuBar());
766 cbradney 246
 
2835 cbradney 247
        prefsManager = PrefsManager::instance();
2856 cbradney 248
        prefsManager->setup();
2835 cbradney 249
        PrefsPfad = prefsManager->preferencesLocation();
2907 subik 250
 
251
 
1247 tsoots 252
        undoManager = UndoManager::instance();
1443 tsoots 253
        objectSpecificUndo = false;
1549 subik 254
        pluginManager = new PluginManager();
2441 cbradney 255
        tocGenerator = new TOCGenerator();
4194 fschmid 256
        actionManager = new ActionManager(this, "actionManager");
4510 subik 257
 
1780 cbradney 258
        initDefaultValues();
272 Franz 259
        initMenuBar();
260
        initStatusBar();
766 cbradney 261
        initToolBars();
490 cbradney 262
        qApp->processEvents();
675 cbradney 263
 
3 paul 264
        BuFromApp = false;
1485 tsoots 265
 
3470 avox 266
#ifdef QT_MAC
267
        bool haveFonts=initFonts(true);
268
#else
2870 cbradney 269
        bool haveFonts=initFonts(showFontInfo);
3470 avox 270
#endif
2870 cbradney 271
        if (!haveFonts)
767 cbradney 272
                retVal=1;
272 Franz 273
        else
274
        {
777 fschmid 275
                buildFontMenu();
2835 cbradney 276
                prefsManager->initDefaults();
277
                prefsManager->initDefaultGUIFont(qApp->font());
278
                prefsManager->initArrowStyles();
3 paul 279
                resize(610, 600);
272 Franz 280
                QVBox* vb = new QVBox( this );
281
                vb->setFrameStyle( QFrame::StyledPanel | QFrame::Sunken );
282
                wsp = new QWorkspace( vb );
283
                setCentralWidget( vb );
3 paul 284
                connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
3097 cbradney 285
                //Connect windows cascade and tile actions to the workspace after its created. Only depends on wsp created.
286
                connect( scrActions["windowsCascade"], SIGNAL(activated()) , wsp, SLOT(cascade()) );
287
                connect( scrActions["windowsTile"], SIGNAL(activated()) , wsp, SLOT(tile()) );
770 cbradney 288
 
801 cbradney 289
                initPalettes();
770 cbradney 290
 
1155 fschmid 291
                fileWatcher = new FileWatcher(this);
1485 tsoots 292
 
2870 cbradney 293
                setSplashStatus( tr("Initializing Plugins") );
1550 cbradney 294
                pluginManager->initPlugs();
2870 cbradney 295
                setSplashStatus( tr("Initializing Keyboard Shortcuts") );
1437 cbradney 296
                initKeyboardShortcuts();
2870 cbradney 297
                setSplashStatus( tr("Reading Preferences") );
3873 subik 298
                if (prefsUserFile.isNull())
299
                        prefsManager->ReadPrefs();
300
                else
301
                        prefsManager->ReadPrefs(prefsUserFile);
2870 cbradney 302
                setSplashStatus( tr("Initializing Story Editor") );
2494 cbradney 303
                storyEditor = new StoryEditor(this);
801 cbradney 304
 
4194 fschmid 305
                HaveGS = testGSAvailability();
306
                HavePngAlpha = testGSDeviceAvailability("pngalpha");
307
                HaveTiffSep = testGSDeviceAvailability("tiffsep");
2871 cbradney 308
                DocDir = prefsManager->documentDir();
801 cbradney 309
 
2870 cbradney 310
                setSplashStatus( tr("Reading ICC Profiles") );
831 cbradney 311
                CMSavail = false;
3 paul 312
                GetCMSProfiles();
803 cbradney 313
                initCMS();
831 cbradney 314
 
2870 cbradney 315
                setSplashStatus( tr("Initializing Hyphenator") );
3225 fschmid 316
                QString preLang = prefsManager->appPrefs.Language;
766 cbradney 317
                initHyphenator();
3225 fschmid 318
                if (Sprachen.contains(preLang))
319
                        prefsManager->appPrefs.Language = preLang;
2870 cbradney 320
                setSplashStatus( tr("Reading Scrapbook") );
801 cbradney 321
                initScrapbook();
2870 cbradney 322
                setSplashStatus( tr("Setting up Shortcuts") );
1230 cbradney 323
                SetShortCut();
4039 fschmid 324
                scrActions["helpTooltips"]->setOn(prefsManager->appPrefs.showToolTips);
325
                ToggleTips();
1441 cbradney 326
                emit prefsChanged();
1485 tsoots 327
 
1208 cbradney 328
                connect(fileWatcher, SIGNAL(fileDeleted(QString )), this, SLOT(removeRecent(QString)));
3 paul 329
                connect(this, SIGNAL(TextIFont(QString)), this, SLOT(AdjustFontMenu(QString)));
4073 cbradney 330
                connect(this, SIGNAL(TextIFont(QString)), propertiesPalette, SLOT(setFontFace(QString)));
3 paul 331
                connect(this, SIGNAL(TextISize(int)), this, SLOT(setFSizeMenu(int)));
1545 cbradney 332
                connect(this, SIGNAL(TextISize(int)), propertiesPalette, SLOT(setSize(int)));
2382 fschmid 333
                connect(this, SIGNAL(TextUSval(int)), propertiesPalette, SLOT(setExtra(int)));
1545 cbradney 334
                connect(this, SIGNAL(TextStil(int)), propertiesPalette, SLOT(setStil(int)));
335
                connect(this, SIGNAL(TextScale(int)), propertiesPalette, SLOT(setTScale(int)));
2230 fschmid 336
                connect(this, SIGNAL(TextScaleV(int)), propertiesPalette, SLOT(setTScaleV(int)));
2234 fschmid 337
                connect(this, SIGNAL(TextBase(int)), propertiesPalette, SLOT(setTBase(int)));
2247 fschmid 338
                connect(this, SIGNAL(TextShadow(int, int )), propertiesPalette, SLOT(setShadowOffs(int, int )));
2257 fschmid 339
                connect(this, SIGNAL(TextOutline(int)), propertiesPalette, SLOT(setOutlineW(int)));
2262 fschmid 340
                connect(this, SIGNAL(TextUnderline(int, int)), propertiesPalette, SLOT(setUnderline(int, int)));
2272 fschmid 341
                connect(this, SIGNAL(TextStrike(int, int)), propertiesPalette, SLOT(setStrike(int, int)));
1545 cbradney 342
                connect(this, SIGNAL(TextFarben(QString, QString, int, int)), propertiesPalette, SLOT(setActFarben(QString, QString, int, int)));
3 paul 343
        }
767 cbradney 344
        closeSplash();
2199 cbradney 345
        scribusInitialized=true;
2223 cbradney 346
        //pluginManager->languageChange();
4556 cbradney 347
        setAcceptDrops(true);
767 cbradney 348
        return retVal;
3 paul 349
}
350
 
4209 craig 351
ScribusMainWindow::~ScribusMainWindow()
4208 craig 352
{
353
}
354
 
4026 craig 355
void ScribusMainWindow::initSplash(bool showSplash)
767 cbradney 356
{
357
        if (showSplash)
358
        {
359
                splashScreen = new SplashScreen();
4130 cbradney 360
                if (splashScreen != NULL && splashScreen->isShown())
361
                        setSplashStatus(QObject::tr("Initializing..."));
767 cbradney 362
        }
363
        else
364
                splashScreen = NULL;
365
}
366
 
4026 craig 367
void ScribusMainWindow::setSplashStatus(const QString& newText)
2870 cbradney 368
{
369
        if (splashScreen != NULL)
370
                splashScreen->setStatus( newText );
371
        qApp->processEvents();
372
}
373
 
4026 craig 374
void ScribusMainWindow::showSplash(bool shown)
2835 cbradney 375
{
376
        if (splashScreen!=NULL && shown!=splashScreen->isShown())
377
                splashScreen->setShown(shown);
378
}
379
 
4026 craig 380
bool ScribusMainWindow::splashShowing() const
3171 craig 381
{
382
        if (splashScreen != NULL)
383
                return splashScreen->isShown();
3172 subik 384
        return false;
3171 craig 385
}
386
 
4026 craig 387
void ScribusMainWindow::closeSplash()
767 cbradney 388
{
389
        if (splashScreen!=NULL)
390
        {
391
                splashScreen->close();
392
                delete splashScreen;
393
                splashScreen = NULL;
394
        }
395
}
396
 
4026 craig 397
void ScribusMainWindow::initToolBars()
766 cbradney 398
{
4566 tsoots 399
        fileToolBar = new ScToolBar(tr("File"), "File", this);
2859 cbradney 400
        scrActions["fileNew"]->addTo(fileToolBar);
401
        scrActions["fileOpen"]->addTo(fileToolBar);
1210 cbradney 402
        scrMenuMgr->addMenuToWidgetOfAction("FileOpenRecent", scrActions["fileOpen"]);
2859 cbradney 403
        scrActions["fileSave"]->addTo(fileToolBar);
404
        scrActions["fileClose"]->addTo(fileToolBar);
405
        scrActions["filePrint"]->addTo(fileToolBar);
406
        scrActions["toolsPreflightVerifier"]->addTo(fileToolBar);
407
        scrActions["fileExportAsPDF"]->addTo(fileToolBar);
1485 tsoots 408
 
4566 tsoots 409
        editToolBar = new ScToolBar( tr("Edit"), "Edit", this);
1114 tsoots 410
        UndoWidget* uWidget = new UndoWidget(editToolBar, "uWidget");
1247 tsoots 411
        undoManager->registerGui(uWidget);
1485 tsoots 412
 
2859 cbradney 413
        mainToolBar = new WerkToolB(this);
414
        mainToolBar->setEnabled(false);
415
        pdfToolBar = new WerkToolBP(this);
416
        pdfToolBar->setEnabled(false);
801 cbradney 417
 
4541 tsoots 418
        connect(mainToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarTools"], SLOT(setOn(bool)));
419
        connect(scrActions["toolsToolbarPDF"], SIGNAL(toggled(bool)), pdfToolBar, SLOT(setShown(bool)));
2859 cbradney 420
        connect(pdfToolBar, SIGNAL(NewMode(int)), this, SLOT(setAppMode(int)));
4541 tsoots 421
        connect(pdfToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarPDF"], SLOT(setOn(bool)));
422
        connect(scrActions["toolsToolbarTools"], SIGNAL(toggled(bool)), mainToolBar, SLOT(setShown(bool)) );
4729 subik 423
 
766 cbradney 424
}
425
 
2870 cbradney 426
//Returns false when there are no fonts
4026 craig 427
const bool ScribusMainWindow::initFonts(bool showFontInfo)
767 cbradney 428
{
2870 cbradney 429
        setSplashStatus( tr("Searching for Fonts") );
430
        bool haveFonts=prefsManager->GetAllFonts(showFontInfo);
431
        if (!haveFonts)
767 cbradney 432
        {
433
                if (splashScreen!=NULL)
434
                        splashScreen->close(); // 10/10/2004 pv fix #1200
1801 cbradney 435
                QString mess = tr("There are no fonts found on your system.");
436
                mess += "\n" + tr("Exiting now.");
767 cbradney 437
                QMessageBox::critical(this, tr("Fatal Error"), mess, 1, 0, 0);
438
        }
829 cbradney 439
        else
2870 cbradney 440
                setSplashStatus( tr("Font System Initialized") );
441
        return haveFonts;
767 cbradney 442
}
766 cbradney 443
 
4026 craig 444
void ScribusMainWindow::initDefaultValues()
801 cbradney 445
{
2856 cbradney 446
        dirs = prefsManager->prefsFile->getContext("dirs");
1780 cbradney 447
        HaveDoc = false;
801 cbradney 448
        singleClose = false;
449
        ScriptRunning = false;
450
        view = NULL;
451
        doc = NULL;
452
        Buffer2 = "";
453
        DispX = 10;
454
        DispY = 10;
455
        DocNr = 1;
456
        PrinterUsed = false;
457
        PDef.Pname = "";
458
        PDef.Dname = "";
459
        PDef.Command = "";
460
        keyrep = false;
1204 tsoots 461
        _arrowKeyDown = false;
801 cbradney 462
        ClipB = QApplication::clipboard();
4651 cbradney 463
        palettesStatus[0] = false;
464
        guidesStatus[0] = false;
801 cbradney 465
 
466
        connect(ClipB, SIGNAL(dataChanged()), this, SLOT(ClipChange()));
4194 fschmid 467
        connect(ClipB, SIGNAL(selectionChanged()), this, SLOT(ClipChange()));
770 cbradney 468
}
469
 
4026 craig 470
void ScribusMainWindow::initKeyboardShortcuts()
801 cbradney 471
{
1478 cbradney 472
        for( QMap<QString, QGuardedPtr<ScrAction> >::Iterator it = scrActions.begin(); it!=scrActions.end(); ++it )
1525 cbradney 473
        {
2178 cbradney 474
                if ((ScrAction*)(it.data())!=NULL)
2873 cbradney 475
                {
476
                        QString accelerator=it.data()->accel();
477
                        prefsManager->setKeyEntry(it.key(), it.data()->cleanMenuText(), accelerator,0);
478
                }
2178 cbradney 479
                //else
480
                //      qDebug(it.key());
1525 cbradney 481
                //qDebug(QString("|-\n|%1||%2||%3").arg(it.key()).arg(it.data()->cleanMenuText()).arg(QString(it.data()->accel())));
482
        }
801 cbradney 483
}
484
 
4026 craig 485
void ScribusMainWindow::initPalettes()
801 cbradney 486
{
1493 cbradney 487
        //CB TODO hide the publicly available members of some palettes
488
        // these must be filtered too as they take control of the palettes events
1545 cbradney 489
        outlinePalette = new Tree(this, this);
490
        connect( scrActions["toolsOutline"], SIGNAL(toggled(bool)) , outlinePalette, SLOT(setPaletteShown(bool)) );
491
        connect( outlinePalette, SIGNAL(paletteShown(bool)), scrActions["toolsOutline"], SLOT(setOn(bool)));
2834 cbradney 492
        propertiesPalette = new Mpalette(this);
1545 cbradney 493
        connect( scrActions["toolsProperties"], SIGNAL(toggled(bool)) , propertiesPalette, SLOT(setPaletteShown(bool)) );
494
        connect( propertiesPalette, SIGNAL(paletteShown(bool)), scrActions["toolsProperties"], SLOT(setOn(bool)));
3928 tsoots 495
 
3873 subik 496
        //CB dont need this until we have a doc...
3540 cbradney 497
        //propertiesPalette->Cpal->SetColors(prefsManager->colorSet());
1545 cbradney 498
        propertiesPalette->Cpal->UseTrans(true);
2508 fschmid 499
        propertiesPalette->Fonts->RebuildList(0);
1545 cbradney 500
        propertiesPalette->installEventFilter(this);
501
        nodePalette = new NodePalette(this);
502
        nodePalette->installEventFilter(this);
503
        layerPalette = new LayerPalette(this);
504
        connect( scrActions["toolsLayers"], SIGNAL(toggled(bool)) , layerPalette, SLOT(setPaletteShown(bool)) );
505
        connect( layerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsLayers"], SLOT(setOn(bool)));
506
        layerPalette->installEventFilter(this);
507
        layerPalette->Table->installEventFilter(this);
2834 cbradney 508
        scrapbookPalette = new Biblio(this);
1545 cbradney 509
        connect( scrActions["toolsScrapbook"], SIGNAL(toggled(bool)) , scrapbookPalette, SLOT(setPaletteShown(bool)) );
510
        connect( scrapbookPalette, SIGNAL(paletteShown(bool)), scrActions["toolsScrapbook"], SLOT(setOn(bool)));
511
        scrapbookPalette->installEventFilter(this);
3623 cbradney 512
        pagePalette = new PagePalette(this);
1545 cbradney 513
        connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , pagePalette, SLOT(setPaletteShown(bool)) );
514
        connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , this, SLOT(setPagePalette(bool)) );
515
        connect( pagePalette, SIGNAL(paletteShown(bool)), scrActions["toolsPages"], SLOT(setOn(bool)));
516
        pagePalette->installEventFilter(this);
517
        bookmarkPalette = new BookPalette(this);
518
        connect( scrActions["toolsBookmarks"], SIGNAL(toggled(bool)) , bookmarkPalette, SLOT(setPaletteShown(bool)) );
519
        connect( bookmarkPalette, SIGNAL(paletteShown(bool)), scrActions["toolsBookmarks"], SLOT(setOn(bool)));
520
        bookmarkPalette->installEventFilter(this);
521
        measurementPalette = new Measurements(this);
522
        connect( scrActions["toolsMeasurements"], SIGNAL(toggled(bool)) , measurementPalette, SLOT(setPaletteShown(bool)) );
1525 cbradney 523
        connect( scrActions["toolsMeasurements"], SIGNAL(toggledData(bool, int)) , this, SLOT(setAppModeByToggle(bool, int)) );
1545 cbradney 524
        connect( measurementPalette, SIGNAL(paletteShown(bool)), scrActions["toolsMeasurements"], SLOT(setOn(bool)));
525
        measurementPalette->installEventFilter(this);
526
        measurementPalette->hide();
527
        docCheckerPalette = new CheckDocument(this, false);
528
        connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , docCheckerPalette, SLOT(setPaletteShown(bool)) );
3866 fschmid 529
        connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , this, SLOT(docCheckToggle(bool)) );
1545 cbradney 530
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsPreflightVerifier"], SLOT(setOn(bool)));
1825 fschmid 531
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), this, SLOT(docCheckToggle(bool)));
1545 cbradney 532
        docCheckerPalette->installEventFilter(this);
533
        docCheckerPalette->hide();
2707 subik 534
 
2355 cbradney 535
        alignDistributePalette = new AlignDistributePalette(this, "AlignDistributePalette", false);
536
        connect( scrActions["toolsAlignDistribute"], SIGNAL(toggled(bool)) , alignDistributePalette, SLOT(setPaletteShown(bool)) );
537
        connect( alignDistributePalette, SIGNAL(paletteShown(bool)), scrActions["toolsAlignDistribute"], SLOT(setOn(bool)));
538
        connect( alignDistributePalette, SIGNAL(documentChanged()), this, SLOT(slotDocCh()));
539
        alignDistributePalette->installEventFilter(this);
3934 cbradney 540
        //alignDistributePalette->hide();
2707 subik 541
 
1448 cbradney 542
        undoPalette = new UndoPalette(this, "undoPalette");
1493 cbradney 543
        undoPalette->installEventFilter(this);
1448 cbradney 544
        undoManager->registerGui(undoPalette);
1493 cbradney 545
        connect(undoPalette, SIGNAL(paletteShown(bool)), this, SLOT(setUndoPalette(bool)));
1448 cbradney 546
        connect(undoPalette, SIGNAL(objectMode(bool)), this, SLOT(setUndoMode(bool)));
1485 tsoots 547
 
4829 tsoots 548
        // initializing style manager here too even it's not strictly a palette
549
        styleManager = new StyleManager(this, "styleManager");
550
        styleManager->addStyle(new SMLineStyle());
551
        connect(styleManager, SIGNAL(closed()), scrActions["editStyles"], SLOT(toggle()));
3540 cbradney 552
 
3025 cbradney 553
        connect(docCheckerPalette, SIGNAL(selectElement(int, int)), this, SLOT(selectItemsFromOutlines(int, int)));
554
        connect(docCheckerPalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
2093 cbradney 555
        connect(docCheckerPalette, SIGNAL(selectMasterPage(QString)), this, SLOT(manageMasterPages(QString)));
3025 cbradney 556
        connect(outlinePalette, SIGNAL(selectElement(int, int, bool)), this, SLOT(selectItemsFromOutlines(int, int, bool)));
557
        connect(outlinePalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
2093 cbradney 558
        connect(outlinePalette, SIGNAL(selectMasterPage(QString)), this, SLOT(manageMasterPages(QString)));
1545 cbradney 559
        connect(propertiesPalette->Spal, SIGNAL(newStyle(int)), this, SLOT(setNewAbStyle(int)));
560
        connect(propertiesPalette, SIGNAL(EditLSt()), this, SLOT(slotEditLineStyles()));
561
        connect(nodePalette, SIGNAL(Schliessen()), this, SLOT(NoFrameEdit()));
4078 fschmid 562
        connect(nodePalette, SIGNAL(DocChanged()), this, SLOT(slotDocCh()));
1545 cbradney 563
        connect(layerPalette, SIGNAL(LayerChanged()), this, SLOT(showLayer()));
3623 cbradney 564
 
1545 cbradney 565
        connect(bookmarkPalette->BView, SIGNAL(MarkMoved()), this, SLOT(StoreBookmarks()));
4784 fschmid 566
        connect(bookmarkPalette->BView, SIGNAL(changed()), this, SLOT(slotDocCh()));
4679 fschmid 567
        connect(bookmarkPalette->BView, SIGNAL(SelectElement(PageItem *)), this, SLOT(selectItemsFromOutlines(PageItem *)));
801 cbradney 568
}
569
 
4026 craig 570
void ScribusMainWindow::initScrapbook()
801 cbradney 571
{
4611 fschmid 572
        QString scrapbookFileO = QDir::convertSeparators(PrefsPfad+"/scrap13.scs");
573
        QFileInfo scrapbookFileInfoO = QFileInfo(scrapbookFileO);
574
        if (scrapbookFileInfoO.exists())
575
        {
576
                scrapbookPalette->readOldContents(scrapbookFileO, QDir::convertSeparators(PrefsPfad+"/scrapbook/main"));
577
                QDir d = QDir();
578
                d.rename(scrapbookFileO, QDir::convertSeparators(PrefsPfad+"/scrap13.backup"));
579
        }
580
        QString scrapbookFile = QDir::convertSeparators(PrefsPfad+"/scrapbook/main");
801 cbradney 581
        QFileInfo scrapbookFileInfo = QFileInfo(scrapbookFile);
582
        if (scrapbookFileInfo.exists())
2144 cbradney 583
                scrapbookPalette->readContents(scrapbookFile);
584
        scrapbookPalette->setScrapbookFileName(scrapbookFile);
4735 fschmid 585
        scrapbookPalette->setOpenScrapbooks(prefsManager->appPrefs.RecentScrapbooks);
801 cbradney 586
}
587
 
4026 craig 588
const QString ScribusMainWindow::getGuiLanguage()
770 cbradney 589
{
590
        return guiLanguage;
591
}
592
 
4026 craig 593
bool ScribusMainWindow::warningVersion(QWidget *parent)
1525 cbradney 594
{
595
        bool retval = false;
3510 cbradney 596
        int t = ScMessageBox::warning(parent, QObject::tr("Scribus Development Version"), "<qt>" +
597
                                                                 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>",
598
                                                                 CommonStrings::tr_OK, CommonStrings::tr_Cancel, "", 1, 0);
3565 cbradney 599
        if (t == 0)
1525 cbradney 600
                retval = true;
601
        return retval;
602
}
603
 
4026 craig 604
void ScribusMainWindow::initMenuBar()
3 paul 605
{
606
        RecentDocs.clear();
1208 cbradney 607
 
608
        scrMenuMgr->createMenu("File", tr("&File"));
609
        scrMenuMgr->addMenuItem(scrActions["fileNew"], "File");
610
        scrMenuMgr->addMenuItem(scrActions["fileOpen"], "File");
611
        recentFileMenuName="FileOpenRecent";
3580 avox 612
        scrMenuMgr->createMenu(recentFileMenuName, QIconSet(noIcon), tr("Open &Recent"), "File");
1208 cbradney 613
        scrMenuMgr->addMenuSeparator("File");
614
        scrMenuMgr->addMenuItem(scrActions["fileClose"], "File");
615
        scrMenuMgr->addMenuItem(scrActions["fileSave"], "File");
616
        scrMenuMgr->addMenuItem(scrActions["fileSaveAs"], "File");
617
        scrMenuMgr->addMenuItem(scrActions["fileRevert"], "File");
618
        scrMenuMgr->addMenuItem(scrActions["fileCollect"], "File");
619
        scrMenuMgr->addMenuSeparator("File");
3580 avox 620
        scrMenuMgr->createMenu("FileImport", QIconSet(noIcon), tr("&Import"), "File");
1208 cbradney 621
        scrMenuMgr->addMenuItem(scrActions["fileImportText"], "FileImport");
622
        scrMenuMgr->addMenuItem(scrActions["fileImportAppendText"], "FileImport");
623
        scrMenuMgr->addMenuItem(scrActions["fileImportImage"], "FileImport");
3580 avox 624
        scrMenuMgr->createMenu("FileExport", QIconSet(noIcon), tr("&Export"), "File");
1208 cbradney 625
        scrMenuMgr->addMenuItem(scrActions["fileExportText"], "FileExport");
626
        scrMenuMgr->addMenuItem(scrActions["fileExportAsEPS"], "FileExport");
627
        scrMenuMgr->addMenuItem(scrActions["fileExportAsPDF"], "FileExport");
628
        scrMenuMgr->addMenuSeparator("File");
4641 cbradney 629
        scrMenuMgr->addMenuItem(scrActions["fileDocSetup"], "File");
630
        scrMenuMgr->addMenuItem(scrActions["editPreferences"], "File");
631
        scrMenuMgr->addMenuSeparator("File");
1208 cbradney 632
        scrMenuMgr->addMenuItem(scrActions["filePrint"], "File");
3165 fschmid 633
        scrMenuMgr->addMenuItem(scrActions["PrintPreview"], "File");
1208 cbradney 634
        scrMenuMgr->addMenuSeparator("File");
635
        scrMenuMgr->addMenuItem(scrActions["fileQuit"], "File");
636
 
1485 tsoots 637
        scrActions["fileClose"]->setEnabled(false);
1208 cbradney 638
        scrActions["fileSave"]->setEnabled(false);
639
        scrActions["fileSaveAs"]->setEnabled(false);
640
        scrActions["fileRevert"]->setEnabled(false);
641
        scrActions["fileCollect"]->setEnabled(false);
642
        scrActions["fileImportText"]->setEnabled(false);
643
        scrActions["fileImportImage"]->setEnabled(false);
644
        scrActions["fileImportAppendText"]->setEnabled(false);
2093 cbradney 645
        scrActions["pageImport"]->setEnabled(false);
1208 cbradney 646
        scrActions["fileExportText"]->setEnabled(false);
647
        scrActions["fileExportAsEPS"]->setEnabled(false);
648
        scrActions["fileExportAsPDF"]->setEnabled(false);
649
        scrMenuMgr->setMenuEnabled("FileExport", false);
650
        scrActions["fileDocSetup"]->setEnabled(false);
651
        scrActions["filePrint"]->setEnabled(false);
3165 fschmid 652
        scrActions["PrintPreview"]->setEnabled(false);
1485 tsoots 653
 
1227 cbradney 654
        scrMenuMgr->createMenu("Edit", tr("&Edit"));
655
        scrMenuMgr->addMenuItem(scrActions["editUndoAction"], "Edit");
656
        scrMenuMgr->addMenuItem(scrActions["editRedoAction"], "Edit");
657
        scrMenuMgr->addMenuItem(scrActions["editActionMode"], "Edit");
658
        scrMenuMgr->addMenuSeparator("Edit");
659
        scrMenuMgr->addMenuItem(scrActions["editCut"], "Edit");
660
        scrMenuMgr->addMenuItem(scrActions["editCopy"], "Edit");
661
        scrMenuMgr->addMenuItem(scrActions["editPaste"], "Edit");
4952 cbradney 662
        scrMenuMgr->createMenu("EditContents", tr("Contents"));
663
        scrMenuMgr->addMenuToMenu("EditContents", "Edit");
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
 
4026 craig 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
1419
                                Ctrl Shift, by 0.1 units
1420
                                Shift by 10.0 units
1421
                                Ctrl Alt Shift 0.01 units
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)
3829 cbradney 1427
                 */
4847 cbradney 1428
                if (doc->m_Selection->count() != 0)
272 Franz 1429
                {
3829 cbradney 1430
                        double moveBy=1.0;
4623 cbradney 1431
                        if ((buttonState & ShiftButton) && !(buttonState & ControlButton))
3829 cbradney 1432
                                moveBy=10.0;
4636 cbradney 1433
                        else if ((buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
3829 cbradney 1434
                                moveBy=0.1;
4636 cbradney 1435
                        else if ((buttonState & ShiftButton) && (buttonState & ControlButton) && (buttonState & AltButton))
1436
                                moveBy=0.01;
4623 cbradney 1437
                        moveBy/=doc->unitRatio();//Lets allow movement by the current doc ratio, not only points
4636 cbradney 1438
                        bool resizing=((buttonState & AltButton) && !(buttonState & ControlButton));
4623 cbradney 1439
                        bool resizingsmaller=(resizing && (buttonState & ShiftButton));
1440
                        double resizeBy=1.0;
4637 cbradney 1441
                        //CB with control locked out due to the requirement of moveby of 0.01, we cannot support
1442
                        //resizeby 10 units unless we move to supporting modifier keys that most people dont have.
1443
                        //if (buttonState & ControlButton)
1444
                        //      resizeBy*=10.0;
4623 cbradney 1445
                        resizeBy/=doc->unitRatio();
1446
                        if (resizingsmaller)
1447
                                resizeBy*=-1.0;
3873 subik 1448
 
4729 subik 1449
 
4847 cbradney 1450
                        PageItem *currItem = doc->m_Selection->itemAt(0);
1065 cbradney 1451
                        switch (doc->appMode)
272 Franz 1452
                        {
2603 cbradney 1453
                        case modeNormal:
272 Franz 1454
                                switch (kk)
1455
                                {
360 Franz 1456
                                case Key_Backspace:
272 Franz 1457
                                case Key_Delete:
4713 cbradney 1458
                                        doc->itemSelection_DeleteItem();
272 Franz 1459
                                        break;
360 Franz 1460
                                case Key_Prior:
1957 cbradney 1461
                                        if (!currItem->locked())
2148 fschmid 1462
                                        {
456 fschmid 1463
                                                view->RaiseItem();
2148 fschmid 1464
                                                slotDocCh();
1465
                                        }
360 Franz 1466
                                        break;
1467
                                case Key_Next:
1957 cbradney 1468
                                        if (!currItem->locked())
2148 fschmid 1469
                                        {
456 fschmid 1470
                                                view->LowerItem();
2148 fschmid 1471
                                                slotDocCh();
1472
                                        }
360 Franz 1473
                                        break;
272 Franz 1474
                                case Key_Left:
1957 cbradney 1475
                                        if (!currItem->locked())
272 Franz 1476
                                        {
4623 cbradney 1477
                                                if (!resizing)
2664 fschmid 1478
                                                {
4623 cbradney 1479
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1480
                                                        {
1481
                                                                FPoint np;
1482
                                                                if (view->EditContour)
1483
                                                                        np = currItem->ContourLine.point(view->ClRe);
1484
                                                                else
1485
                                                                        np = currItem->PoLine.point(view->ClRe);
1486
                                                                np = np - FPoint(moveBy, 0);
1487
                                                                view->MoveClipPoint(currItem, np);
1488
                                                        }
2664 fschmid 1489
                                                        else
4623 cbradney 1490
                                                        {
5013 fschmid 1491
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1492
                                                        /* as the user might be trying to fine tune a position */
1493
                                                                bool sav1 = doc->SnapGuides;
1494
                                                                bool sav2 = doc->useRaster;
1495
                                                                doc->SnapGuides = false;
1496
                                                                doc->useRaster = false;
4623 cbradney 1497
                                                                view->moveGroup(-moveBy, 0);
5013 fschmid 1498
                                                                doc->SnapGuides = sav1;
1499
                                                                doc->useRaster = sav2;
4623 cbradney 1500
                                                        }
2664 fschmid 1501
                                                }
272 Franz 1502
                                                else
2664 fschmid 1503
                                                {
4633 fschmid 1504
                                                        if (resizingsmaller)
1505
                                                        {
1506
                                                                currItem->Sizing = false;
1507
                                                                view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1508
                                                        }
1509
                                                        else
1510
                                                        {
1511
                                                                ScMW->view->MoveItem(-resizeBy, 0, currItem, false);
1512
                                                                currItem->Sizing = false;
1513
                                                                view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1514
                                                        }
2664 fschmid 1515
                                                }
5017 cbradney 1516
                                                view->updateContents();
2148 fschmid 1517
                                                slotDocCh();
272 Franz 1518
                                        }
1519
                                        break;
1520
                                case Key_Right:
1957 cbradney 1521
                                        if (!currItem->locked())
272 Franz 1522
                                        {
4623 cbradney 1523
                                                if (!resizing)
2664 fschmid 1524
                                                {
4623 cbradney 1525
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1526
                                                        {
1527
                                                                FPoint np;
1528
                                                                if (view->EditContour)
1529
                                                                        np = currItem->ContourLine.point(view->ClRe);
1530
                                                                else
1531
                                                                        np = currItem->PoLine.point(view->ClRe);
1532
                                                                np = np + FPoint(moveBy, 0);
1533
                                                                view->MoveClipPoint(currItem, np);
1534
                                                        }
2664 fschmid 1535
                                                        else
4623 cbradney 1536
                                                        {
5013 fschmid 1537
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1538
                                                        /* as the user might be trying to fine tune a position */
1539
                                                                bool sav1 = doc->SnapGuides;
1540
                                                                bool sav2 = doc->useRaster;
1541
                                                                doc->SnapGuides = false;
1542
                                                                doc->useRaster = false;
4623 cbradney 1543
                                                                view->moveGroup(moveBy, 0);
5013 fschmid 1544
                                                                doc->SnapGuides = sav1;
1545
                                                                doc->useRaster = sav2;
4623 cbradney 1546
                                                        }
2664 fschmid 1547
                                                }
272 Franz 1548
                                                else
2664 fschmid 1549
                                                {
4633 fschmid 1550
                                                        if (resizingsmaller)
1551
                                                        {
1552
                                                                ScMW->view->MoveItem(-resizeBy, 0, currItem, false);
1553
                                                                currItem->Sizing = false;
1554
                                                                view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1555
                                                        }
1556
                                                        else
1557
                                                        {
1558
                                                                currItem->Sizing = false;
1559
                                                                view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1560
                                                        }
2664 fschmid 1561
                                                }
5017 cbradney 1562
                                                view->updateContents();
2148 fschmid 1563
                                                slotDocCh();
272 Franz 1564
                                        }
1565
                                        break;
1566
                                case Key_Up:
1957 cbradney 1567
                                        if (!currItem->locked())
272 Franz 1568
                                        {
4623 cbradney 1569
                                                if (!resizing)
2664 fschmid 1570
                                                {
4623 cbradney 1571
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1572
                                                        {
1573
                                                                FPoint np;
1574
                                                                if (view->EditContour)
1575
                                                                        np = currItem->ContourLine.point(view->ClRe);
1576
                                                                else
1577
                                                                        np = currItem->PoLine.point(view->ClRe);
1578
                                                                np = np - FPoint(0, moveBy);
1579
                                                                view->MoveClipPoint(currItem, np);
1580
                                                        }
2664 fschmid 1581
                                                        else
4623 cbradney 1582
                                                        {
5013 fschmid 1583
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1584
                                                        /* as the user might be trying to fine tune a position */
1585
                                                                bool sav1 = doc->SnapGuides;
1586
                                                                bool sav2 = doc->useRaster;
1587
                                                                doc->SnapGuides = false;
1588
                                                                doc->useRaster = false;
4623 cbradney 1589
                                                                view->moveGroup(0, -moveBy);
5013 fschmid 1590
                                                                doc->SnapGuides = sav1;
1591
                                                                doc->useRaster = sav2;
4623 cbradney 1592
                                                        }
2664 fschmid 1593
                                                }
272 Franz 1594
                                                else
2664 fschmid 1595
                                                {
4633 fschmid 1596
                                                        if (resizingsmaller)
1597
                                                        {
1598
                                                                currItem->Sizing = false;
1599
                                                                view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1600
                                                        }
1601
                                                        else
1602
                                                        {
1603
                                                                ScMW->view->MoveItem(0, -resizeBy, currItem, false);
1604
                                                                currItem->Sizing = false;
1605
                                                                view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1606
                                                        }
2664 fschmid 1607
                                                }
5017 cbradney 1608
                                                view->updateContents();
2148 fschmid 1609
                                                slotDocCh();
272 Franz 1610
                                        }
1611
                                        break;
1612
                                case Key_Down:
1957 cbradney 1613
                                        if (!currItem->locked())
272 Franz 1614
                                        {
4623 cbradney 1615
                                                if (!resizing)
2664 fschmid 1616
                                                {
4623 cbradney 1617
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1618
                                                        {
1619
                                                                FPoint np;
1620
                                                                if (view->EditContour)
1621
                                                                        np = currItem->ContourLine.point(view->ClRe);
1622
                                                                else
1623
                                                                        np = currItem->PoLine.point(view->ClRe);
1624
                                                                np = np + FPoint(0, moveBy);
1625
                                                                view->MoveClipPoint(currItem, np);
1626
                                                        }
2664 fschmid 1627
                                                        else
4623 cbradney 1628
                                                        {
5013 fschmid 1629
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1630
                                                        /* as the user might be trying to fine tune a position */
1631
                                                                bool sav1 = doc->SnapGuides;
1632
                                                                bool sav2 = doc->useRaster;
1633
                                                                doc->SnapGuides = false;
1634
                                                                doc->useRaster = false;
4623 cbradney 1635
                                                                view->moveGroup(0, moveBy);
5013 fschmid 1636
                                                                doc->SnapGuides = sav1;
1637
                                                                doc->useRaster = sav2;
4623 cbradney 1638
                                                        }
2664 fschmid 1639
                                                }
272 Franz 1640
                                                else
2664 fschmid 1641
                                                {
4633 fschmid 1642
                                                        if (resizingsmaller)
1643
                                                        {
1644
                                                                ScMW->view->MoveItem(0, -resizeBy, currItem, false);
1645
                                                                currItem->Sizing = false;
1646
                                                                view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1647
                                                        }
1648
                                                        else
1649
                                                        {
1650
                                                                currItem->Sizing = false;
1651
                                                                view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1652
                                                        }
2664 fschmid 1653
                                                }
5017 cbradney 1654
                                                view->updateContents();
2148 fschmid 1655
                                                slotDocCh();
272 Franz 1656
                                        }
1657
                                        break;
1658
                                default:
1659
                                        break;
1660
                                }
1661
                                break;
2603 cbradney 1662
                        case modeEdit:
3783 cbradney 1663
                                if (currItem->asImageFrame() && !currItem->locked())
1298 fschmid 1664
                                {
4593 cbradney 1665
                                        double dX=0.0,dY=0.0;
1298 fschmid 1666
                                        switch (kk)
1667
                                        {
1668
                                                case Key_Left:
4593 cbradney 1669
                                                        dX=-moveBy;
1298 fschmid 1670
                                                        break;
1671
                                                case Key_Right:
4593 cbradney 1672
                                                        dX=moveBy;
1298 fschmid 1673
                                                        break;
1674
                                                case Key_Up:
4593 cbradney 1675
                                                        dY=-moveBy;
1298 fschmid 1676
                                                        break;
1677
                                                case Key_Down:
4593 cbradney 1678
                                                        dY=moveBy;
1298 fschmid 1679
                                                        break;
1680
                                        }
4593 cbradney 1681
                                        if (dX!=0.0 || dY!=0.0)
1682
                                        {
1683
                                                currItem->moveImageInFrame(dX, dY);
1684
                                                view->updateContents(currItem->getRedrawBounding(view->scale()));
1685
                                        }
1298 fschmid 1686
                                }
3829 cbradney 1687
                                view->oldCp = currItem->CPos;
1957 cbradney 1688
                                if (currItem->itemType() == PageItem::TextFrame)
272 Franz 1689
                                {
3829 cbradney 1690
                                        bool kr=keyrep;
1691
                                        currItem->handleModeEditKey(k, keyrep);
1692
                                        keyrep=kr;
272 Franz 1693
                                }
1694
                                slotDocCh(false);
1695
                                break;
1696
                        }
1697
                }
1698
        }
1204 tsoots 1699
        switch(kk)
1700
        {
1701
                case Key_Left:
1702
                case Key_Right:
1703
                case Key_Up:
1704
                case Key_Down:
1705
                        _arrowKeyDown = true;
1706
        }
92 Franz 1707
        keyrep = false;
3 paul 1708
}
1709
 
4026 craig 1710
void ScribusMainWindow::keyReleaseEvent(QKeyEvent *k)
1204 tsoots 1711
{
4105 cbradney 1712
        if (k->state() & ControlButton)
1713
        {
4212 fschmid 1714
                if (HaveDoc)
1715
                {
1716
                        if ((doc->appMode == modePanning) && (k->state() & Qt::RightButton))
1717
                                setAppMode(modeNormal);
1718
                }
4105 cbradney 1719
        }
1204 tsoots 1720
        if (k->isAutoRepeat() || !_arrowKeyDown)
1721
                return;
1722
        switch(k->key())
1723
        {
1724
                case Key_Left:
1725
                case Key_Right:
1726
                case Key_Up:
1727
                case Key_Down:
1728
                        _arrowKeyDown = false;
3615 cbradney 1729
                        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
2951 fschmid 1730
                        {
4847 cbradney 1731
                                uint docSelectionCount=doc->m_Selection->count();
3934 cbradney 1732
                                if ((docSelectionCount != 0) && (doc->appMode == modeNormal) && (doc->EditClip) && (view->ClRe != -1))
2951 fschmid 1733
                                        view->updateContents();
3934 cbradney 1734
                                for (uint i = 0; i < docSelectionCount; ++i)
4847 cbradney 1735
                                        doc->m_Selection->itemAt(i)->checkChanges(true);
3934 cbradney 1736
                                if (docSelectionCount > 1 && view->groupTransactionStarted())
2951 fschmid 1737
                                        undoManager->commit();
1738
                        }
4105 cbradney 1739
                        break;
1204 tsoots 1740
        }
1741
}
1742
 
4026 craig 1743
void ScribusMainWindow::closeEvent(QCloseEvent *ce)
3 paul 1744
{
1745
        QWidgetList windows = wsp->windowList();
1746
        ScribusWin* tw;
3575 cbradney 1747
        disconnect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
3 paul 1748
        if (!windows.isEmpty())
272 Franz 1749
        {
135 Franz 1750
                singleClose = true;
3571 cbradney 1751
                uint windowCount=windows.count();
1752
                for ( uint i = 0; i < windowCount; ++i )
272 Franz 1753
                {
3 paul 1754
                        newActWin(windows.at(i));
272 Franz 1755
                        tw = ActWin;
3 paul 1756
                        ActWin->close();
1757
                        if (tw == ActWin)
272 Franz 1758
                        {
3 paul 1759
                                ce->ignore();
135 Franz 1760
                                singleClose = false;
3575 cbradney 1761
                                connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
3 paul 1762
                                return;
1763
                        }
272 Franz 1764
                }
1765
        }
3179 cbradney 1766
        propertiesPalette->hide();
1767
        outlinePalette->hide();
1768
        scrapbookPalette->hide();
1769
        bookmarkPalette->hide();
1770
        layerPalette->hide();
1771
        pagePalette->hide();
1772
        measurementPalette->hide();
1773
        docCheckerPalette->hide();
3923 tsoots 1774
        undoPalette->hide();
3924 tsoots 1775
        alignDistributePalette->hide();
3201 subik 1776
 
3294 craig 1777
        // Clean up plugins, THEN save prefs to disk
1778
        pluginManager->cleanupPlugins();
4735 fschmid 1779
        prefsManager->appPrefs.RecentScrapbooks.clear();
1780
        prefsManager->appPrefs.RecentScrapbooks = scrapbookPalette->getOpenScrapbooks();
3170 craig 1781
        if (!emergencyActivated)
2859 cbradney 1782
                prefsManager->SavePrefs();
3170 craig 1783
        UndoManager::deleteInstance();
1784
        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1785
        exit(0);
3 paul 1786
}
1787
 
1788
/////////////////////////////////////////////////////////////////////
1789
// SLOT IMPLEMENTATION
1790
/////////////////////////////////////////////////////////////////////
1791
 
1485 tsoots 1792
 
4026 craig 1793
bool ScribusMainWindow::arrowKeyDown()
1204 tsoots 1794
{
1795
        return _arrowKeyDown;
1796
}
1797
 
4026 craig 1798
void ScribusMainWindow::startUpDialog()
2833 fschmid 1799
{
2856 cbradney 1800
        PrefsContext* docContext = prefsManager->prefsFile->getContext("docdirs", false);
2834 cbradney 1801
        NewDoc* dia = new NewDoc(this, true);
2833 fschmid 1802
        if (dia->exec())
1803
        {
1804
                if (dia->tabSelected == 0)
1805
                {
2901 fschmid 1806
                        int facingPages = dia->choosenLayout;
3016 fschmid 1807
                        int firstPage = dia->docLayout->firstPage->currentItem();
4638 subik 1808
                        double topMargin = dia->GroupRand->top();
1809
                        double bottomMargin = dia->GroupRand->bottom();
1810
                        double leftMargin = dia->GroupRand->left();
1811
                        double rightMargin = dia->GroupRand->right();
2901 fschmid 1812
                        double columnDistance = dia->Dist;
4555 cbradney 1813
                        double pageWidth = dia->pageWidth;
1814
                        double pageHeight = dia->pageHeight;
2901 fschmid 1815
                        double numberCols = dia->SpinBox10->value();
1816
                        bool autoframes = dia->AutoFrame->isChecked();
2833 fschmid 1817
                        int orientation = dia->Orient;
3778 cbradney 1818
                        int pageCount=dia->PgNum->value();
4555 cbradney 1819
                        PageSize *ps2 = new PageSize(dia->pageSizeComboBox->currentText());
2833 fschmid 1820
                        QString pagesize = ps2->getPageName();
4559 cbradney 1821
                        doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->ComboBox3->currentItem(), firstPage, orientation, 1, pagesize, pageCount);
3016 fschmid 1822
                        doc->pageSets[facingPages].FirstPage = firstPage;
2833 fschmid 1823
                        delete ps2;
3695 cbradney 1824
                        HaveNewDoc();
2833 fschmid 1825
                }
1826
                else
1827
                {
1828
                        if (dia->tabSelected == 1)
1829
                        {
3691 cbradney 1830
                                QString fileName(dia->fileDialog->selectedFile());
2877 cbradney 1831
                                if (!fileName.isEmpty())
2833 fschmid 1832
                                {
1833
                                        docContext->set("docsopen", fileName.left(fileName.findRev("/")));
1834
                                        loadDoc(fileName);
1835
                                }
1836
                        }
2842 fschmid 1837
                        else
1838
                        {
3691 cbradney 1839
                                QString fileName(dia->recentDocList->currentText());
2877 cbradney 1840
                                if (!fileName.isEmpty())
2842 fschmid 1841
                                        loadRecent(fileName);
1842
                        }
2833 fschmid 1843
                }
1844
        }
2871 cbradney 1845
        prefsManager->setShowStartupDialog(!dia->startUpDialog->isChecked());
2833 fschmid 1846
        delete dia;
1847
        mainWindowStatusLabel->setText( tr("Ready"));
1848
}
1849
 
4026 craig 1850
bool ScribusMainWindow::slotFileNew()
3 paul 1851
{
809 cbradney 1852
        bool retVal;
2834 cbradney 1853
        NewDoc* dia = new NewDoc(this