Subversion Repositories Scribus

Rev

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

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