Subversion Repositories Scribus

Rev

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