Subversion Repositories Scribus

Rev

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