Subversion Repositories Scribus

Rev

Rev 4073 | Rev 4084 | 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();
1780 cbradney 240
        initDefaultValues();
2143 subik 241
 
2187 cbradney 242
        actionManager = new ActionManager(this, "actionManager");
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
 
2843 fschmid 289
#ifndef _WIN32
2862 cbradney 290
                HaveGS = system(prefsManager->ghostscriptExecutable()+" -h > /dev/null 2>&1");
291
                HavePngAlpha = system(prefsManager->ghostscriptExecutable()+" -sDEVICE=pngalpha -c quit > /dev/null 2>&1");
3169 fschmid 292
                HaveTiffSep = system(prefsManager->ghostscriptExecutable()+" -sDEVICE=tiffsep -c quit > /dev/null 2>&1");
2843 fschmid 293
#else
2885 fschmid 294
                HaveGS = system(getShortPathName(prefsManager->ghostscriptExecutable())+" -h >NUL");
295
                HavePngAlpha = system(getShortPathName(prefsManager->ghostscriptExecutable())+" -sDEVICE=pngalpha -c quit >NUL");
3169 fschmid 296
                HaveTiffSep = system(getShortPathName(prefsManager->ghostscriptExecutable())+" -sDEVICE=tiffsep -c quit >NUL");
2843 fschmid 297
#endif
2871 cbradney 298
                DocDir = prefsManager->documentDir();
801 cbradney 299
 
2870 cbradney 300
                setSplashStatus( tr("Reading ICC Profiles") );
831 cbradney 301
                CMSavail = false;
3 paul 302
                GetCMSProfiles();
803 cbradney 303
                initCMS();
831 cbradney 304
 
2870 cbradney 305
                setSplashStatus( tr("Initializing Hyphenator") );
3225 fschmid 306
                QString preLang = prefsManager->appPrefs.Language;
766 cbradney 307
                initHyphenator();
3225 fschmid 308
                if (Sprachen.contains(preLang))
309
                        prefsManager->appPrefs.Language = preLang;
2870 cbradney 310
                setSplashStatus( tr("Reading Scrapbook") );
801 cbradney 311
                initScrapbook();
2870 cbradney 312
                setSplashStatus( tr("Setting up Shortcuts") );
1230 cbradney 313
                SetShortCut();
4039 fschmid 314
                scrActions["helpTooltips"]->setOn(prefsManager->appPrefs.showToolTips);
315
                ToggleTips();
1441 cbradney 316
                emit prefsChanged();
1485 tsoots 317
 
1208 cbradney 318
                connect(fileWatcher, SIGNAL(fileDeleted(QString )), this, SLOT(removeRecent(QString)));
3 paul 319
                connect(this, SIGNAL(TextIFont(QString)), this, SLOT(AdjustFontMenu(QString)));
4073 cbradney 320
                connect(this, SIGNAL(TextIFont(QString)), propertiesPalette, SLOT(setFontFace(QString)));
3 paul 321
                connect(this, SIGNAL(TextISize(int)), this, SLOT(setFSizeMenu(int)));
1545 cbradney 322
                connect(this, SIGNAL(TextISize(int)), propertiesPalette, SLOT(setSize(int)));
2382 fschmid 323
                connect(this, SIGNAL(TextUSval(int)), propertiesPalette, SLOT(setExtra(int)));
1545 cbradney 324
                connect(this, SIGNAL(TextStil(int)), propertiesPalette, SLOT(setStil(int)));
325
                connect(this, SIGNAL(TextScale(int)), propertiesPalette, SLOT(setTScale(int)));
2230 fschmid 326
                connect(this, SIGNAL(TextScaleV(int)), propertiesPalette, SLOT(setTScaleV(int)));
2234 fschmid 327
                connect(this, SIGNAL(TextBase(int)), propertiesPalette, SLOT(setTBase(int)));
2247 fschmid 328
                connect(this, SIGNAL(TextShadow(int, int )), propertiesPalette, SLOT(setShadowOffs(int, int )));
2257 fschmid 329
                connect(this, SIGNAL(TextOutline(int)), propertiesPalette, SLOT(setOutlineW(int)));
2262 fschmid 330
                connect(this, SIGNAL(TextUnderline(int, int)), propertiesPalette, SLOT(setUnderline(int, int)));
2272 fschmid 331
                connect(this, SIGNAL(TextStrike(int, int)), propertiesPalette, SLOT(setStrike(int, int)));
1545 cbradney 332
                connect(this, SIGNAL(TextFarben(QString, QString, int, int)), propertiesPalette, SLOT(setActFarben(QString, QString, int, int)));
3 paul 333
        }
767 cbradney 334
        closeSplash();
2199 cbradney 335
        scribusInitialized=true;
2223 cbradney 336
        //pluginManager->languageChange();
767 cbradney 337
        return retVal;
3 paul 338
}
339
 
4026 craig 340
void ScribusMainWindow::initSplash(bool showSplash)
767 cbradney 341
{
342
        if (showSplash)
343
        {
344
                splashScreen = new SplashScreen();
2870 cbradney 345
                setSplashStatus(QObject::tr("Initializing..."));
767 cbradney 346
        }
347
        else
348
                splashScreen = NULL;
349
}
350
 
4026 craig 351
void ScribusMainWindow::setSplashStatus(const QString& newText)
2870 cbradney 352
{
353
        if (splashScreen != NULL)
354
                splashScreen->setStatus( newText );
355
        qApp->processEvents();
356
}
357
 
4026 craig 358
void ScribusMainWindow::showSplash(bool shown)
2835 cbradney 359
{
360
        if (splashScreen!=NULL && shown!=splashScreen->isShown())
361
                splashScreen->setShown(shown);
362
}
363
 
4026 craig 364
bool ScribusMainWindow::splashShowing() const
3171 craig 365
{
366
        if (splashScreen != NULL)
367
                return splashScreen->isShown();
3172 subik 368
        return false;
3171 craig 369
}
370
 
4026 craig 371
void ScribusMainWindow::closeSplash()
767 cbradney 372
{
373
        if (splashScreen!=NULL)
374
        {
375
                splashScreen->close();
376
                delete splashScreen;
377
                splashScreen = NULL;
378
        }
379
}
380
 
4026 craig 381
void ScribusMainWindow::initToolBars()
766 cbradney 382
{
2859 cbradney 383
        fileToolBar = new QToolBar( tr("File"), this);
384
        scrActions["fileNew"]->addTo(fileToolBar);
385
        scrActions["fileOpen"]->addTo(fileToolBar);
1210 cbradney 386
        scrMenuMgr->addMenuToWidgetOfAction("FileOpenRecent", scrActions["fileOpen"]);
2859 cbradney 387
        scrActions["fileSave"]->addTo(fileToolBar);
388
        scrActions["fileClose"]->addTo(fileToolBar);
389
        scrActions["filePrint"]->addTo(fileToolBar);
390
        scrActions["toolsPreflightVerifier"]->addTo(fileToolBar);
391
        scrActions["fileExportAsPDF"]->addTo(fileToolBar);
1485 tsoots 392
 
2397 cbradney 393
        editToolBar = new QToolBar( tr("Edit"), this);
1114 tsoots 394
        UndoWidget* uWidget = new UndoWidget(editToolBar, "uWidget");
1247 tsoots 395
        undoManager->registerGui(uWidget);
1485 tsoots 396
 
2859 cbradney 397
        mainToolBar = new WerkToolB(this);
398
        setDockEnabled(mainToolBar, DockLeft, false);
399
        setDockEnabled(mainToolBar, DockRight, false);
400
        mainToolBar->Sichtbar = true;
401
        mainToolBar->setEnabled(false);
402
        pdfToolBar = new WerkToolBP(this);
403
        setDockEnabled(pdfToolBar, DockLeft, false);
404
        setDockEnabled(pdfToolBar, DockRight, false);
405
        pdfToolBar->setEnabled(false);
406
        pdfToolBar->Sichtbar = true;
801 cbradney 407
 
2859 cbradney 408
        connect(mainToolBar, SIGNAL(Schliessen()), this, SLOT(ToggleTools()));
409
        connect(pdfToolBar, SIGNAL(NewMode(int)), this, SLOT(setAppMode(int)));
410
        connect(pdfToolBar, SIGNAL(Schliessen()), this, SLOT(TogglePDFTools()));
766 cbradney 411
}
412
 
2870 cbradney 413
//Returns false when there are no fonts
4026 craig 414
const bool ScribusMainWindow::initFonts(bool showFontInfo)
767 cbradney 415
{
2870 cbradney 416
        setSplashStatus( tr("Searching for Fonts") );
417
        bool haveFonts=prefsManager->GetAllFonts(showFontInfo);
418
        if (!haveFonts)
767 cbradney 419
        {
420
                if (splashScreen!=NULL)
421
                        splashScreen->close(); // 10/10/2004 pv fix #1200
1801 cbradney 422
                QString mess = tr("There are no fonts found on your system.");
423
                mess += "\n" + tr("Exiting now.");
767 cbradney 424
                QMessageBox::critical(this, tr("Fatal Error"), mess, 1, 0, 0);
425
        }
829 cbradney 426
        else
2870 cbradney 427
                setSplashStatus( tr("Font System Initialized") );
428
        return haveFonts;
767 cbradney 429
}
766 cbradney 430
 
4026 craig 431
void ScribusMainWindow::initDefaultValues()
801 cbradney 432
{
2856 cbradney 433
        dirs = prefsManager->prefsFile->getContext("dirs");
1780 cbradney 434
        HaveDoc = false;
801 cbradney 435
        singleClose = false;
436
        ScriptRunning = false;
437
        view = NULL;
438
        doc = NULL;
439
        Buffer2 = "";
440
        DispX = 10;
441
        DispY = 10;
442
        DocNr = 1;
443
        PrinterUsed = false;
444
        PDef.Pname = "";
445
        PDef.Dname = "";
446
        PDef.Command = "";
447
        keyrep = false;
1204 tsoots 448
        _arrowKeyDown = false;
801 cbradney 449
        ClipB = QApplication::clipboard();
450
        PalettesStat[0] = false;
451
        GuidesStat[0] = false;
452
 
453
        connect(ClipB, SIGNAL(dataChanged()), 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
1302
                                {
2603 cbradney 1303
                                        setAppMode(modePanning);
272 Franz 1304
                                        qApp->setOverrideCursor(QCursor(loadIcon("HandC.xpm")), true);
1305
                                }
1306
                                return;
1307
                                break;
1308
                        case Key_Prior:
2871 cbradney 1309
                                view->scrollBy(0, -prefsManager->mouseWheelValue());
272 Franz 1310
                                keyrep = false;
1311
                                return;
1312
                                break;
1313
                        case Key_Next:
2871 cbradney 1314
                                view->scrollBy(0, prefsManager->mouseWheelValue());
272 Franz 1315
                                keyrep = false;
1316
                                return;
1317
                                break;
1318
                        case Key_Tab:
1319
                                keyrep = false;
1320
                                windows = wsp->windowList();
1321
                                if (windows.count() > 1)
1322
                                {
1323
                                        for (int i = 0; i < static_cast<int>(windows.count()); ++i)
250 Franz 1324
                                        {
272 Franz 1325
                                                if (wsp->activeWindow() == windows.at(i))
1326
                                                {
1327
                                                        if (i == static_cast<int>(windows.count()-1))
1328
                                                                w = windows.at(0);
1329
                                                        else
1330
                                                                w = windows.at(i+1);
1331
                                                        break;
1332
                                                }
250 Franz 1333
                                        }
1545 cbradney 1334
                                        doc->OpenNodes = outlinePalette->buildReopenVals();
1335
                                        docCheckerPalette->clearErrorList();
272 Franz 1336
                                        if ( w )
1337
                                                w->showNormal();
1338
                                        newActWin(w);
1339
                                }
1340
                                return;
1341
                                break;
1342
                        }
1343
                }
3873 subik 1344
                /** Now if we have an item selected
3829 cbradney 1345
                 * - In normal mode we can:
1346
                 * -- Use backspace or delete to delete the item
1347
                 * -- Use PageUp to raise an item
1348
                 * -- Use PageDown to lower an item
1349
                 * -- 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.
1350
                 */
3934 cbradney 1351
                if (doc->selection->count() != 0)
272 Franz 1352
                {
3829 cbradney 1353
                        double moveBy=1.0;
1354
                        if (buttonState & ShiftButton)
1355
                                moveBy=10.0;
1356
                        else if (buttonState & ControlButton)
1357
                                moveBy=0.1;
3873 subik 1358
 
3934 cbradney 1359
                        PageItem *currItem = doc->selection->itemAt(0);
1065 cbradney 1360
                        switch (doc->appMode)
272 Franz 1361
                        {
2603 cbradney 1362
                        case modeNormal:
272 Franz 1363
                                switch (kk)
1364
                                {
360 Franz 1365
                                case Key_Backspace:
272 Franz 1366
                                case Key_Delete:
1367
                                        if (!doc->EditClip)
2148 fschmid 1368
                                        {
997 fschmid 1369
                                                view->DeleteItem();
2148 fschmid 1370
                                                slotDocCh();
1371
                                        }
272 Franz 1372
                                        break;
360 Franz 1373
                                case Key_Prior:
1957 cbradney 1374
                                        if (!currItem->locked())
2148 fschmid 1375
                                        {
456 fschmid 1376
                                                view->RaiseItem();
2148 fschmid 1377
                                                slotDocCh();
1378
                                        }
360 Franz 1379
                                        break;
1380
                                case Key_Next:
1957 cbradney 1381
                                        if (!currItem->locked())
2148 fschmid 1382
                                        {
456 fschmid 1383
                                                view->LowerItem();
2148 fschmid 1384
                                                slotDocCh();
1385
                                        }
360 Franz 1386
                                        break;
272 Franz 1387
                                case Key_Left:
1957 cbradney 1388
                                        if (!currItem->locked())
272 Franz 1389
                                        {
2664 fschmid 1390
                                                if ((doc->EditClip) && (view->ClRe != -1))
1391
                                                {
1392
                                                        FPoint np;
1393
                                                        if (view->EditContour)
1394
                                                                np = currItem->ContourLine.point(view->ClRe);
1395
                                                        else
1396
                                                                np = currItem->PoLine.point(view->ClRe);
3829 cbradney 1397
                                                        np = np - FPoint(moveBy, 0);
2664 fschmid 1398
                                                        view->MoveClipPoint(currItem, np);
1399
                                                }
272 Franz 1400
                                                else
2664 fschmid 1401
                                                {
3829 cbradney 1402
                                                        view->moveGroup(-moveBy, 0);
2664 fschmid 1403
                                                }
2148 fschmid 1404
                                                slotDocCh();
272 Franz 1405
                                        }
1406
                                        break;
1407
                                case Key_Right:
1957 cbradney 1408
                                        if (!currItem->locked())
272 Franz 1409
                                        {
2664 fschmid 1410
                                                if ((doc->EditClip) && (view->ClRe != -1))
1411
                                                {
1412
                                                        FPoint np;
1413
                                                        if (view->EditContour)
1414
                                                                np = currItem->ContourLine.point(view->ClRe);
1415
                                                        else
1416
                                                                np = currItem->PoLine.point(view->ClRe);
3829 cbradney 1417
                                                        np = np + FPoint(moveBy, 0);
2664 fschmid 1418
                                                        view->MoveClipPoint(currItem, np);
1419
                                                }
272 Franz 1420
                                                else
2664 fschmid 1421
                                                {
3829 cbradney 1422
                                                        view->moveGroup(moveBy, 0);
2664 fschmid 1423
                                                }
2148 fschmid 1424
                                                slotDocCh();
272 Franz 1425
                                        }
1426
                                        break;
1427
                                case Key_Up:
1957 cbradney 1428
                                        if (!currItem->locked())
272 Franz 1429
                                        {
2664 fschmid 1430
                                                if ((doc->EditClip) && (view->ClRe != -1))
1431
                                                {
1432
                                                        FPoint np;
1433
                                                        if (view->EditContour)
1434
                                                                np = currItem->ContourLine.point(view->ClRe);
1435
                                                        else
1436
                                                                np = currItem->PoLine.point(view->ClRe);
3829 cbradney 1437
                                                        np = np - FPoint(0, moveBy);
2664 fschmid 1438
                                                        view->MoveClipPoint(currItem, np);
1439
                                                }
272 Franz 1440
                                                else
2664 fschmid 1441
                                                {
3829 cbradney 1442
                                                        view->moveGroup(0, -moveBy);
2664 fschmid 1443
                                                }
2148 fschmid 1444
                                                slotDocCh();
272 Franz 1445
                                        }
1446
                                        break;
1447
                                case Key_Down:
1957 cbradney 1448
                                        if (!currItem->locked())
272 Franz 1449
                                        {
2664 fschmid 1450
                                                if ((doc->EditClip) && (view->ClRe != -1))
1451
                                                {
1452
                                                        FPoint np;
1453
                                                        if (view->EditContour)
1454
                                                                np = currItem->ContourLine.point(view->ClRe);
1455
                                                        else
1456
                                                                np = currItem->PoLine.point(view->ClRe);
3829 cbradney 1457
                                                        np = np + FPoint(0, moveBy);
2664 fschmid 1458
                                                        view->MoveClipPoint(currItem, np);
1459
                                                }
272 Franz 1460
                                                else
2664 fschmid 1461
                                                {
3829 cbradney 1462
                                                        view->moveGroup(0, moveBy);
2664 fschmid 1463
                                                }
2148 fschmid 1464
                                                slotDocCh();
272 Franz 1465
                                        }
1466
                                        break;
1467
                                default:
1468
                                        break;
1469
                                }
1470
                                break;
2603 cbradney 1471
                        case modeEdit:
3783 cbradney 1472
                                if (currItem->asImageFrame() && !currItem->locked())
1298 fschmid 1473
                                {
1474
                                        switch (kk)
1475
                                        {
1476
                                                case Key_Left:
3783 cbradney 1477
                                                        view->MoveItemI(currItem, -moveBy, 0, true);
1298 fschmid 1478
                                                        break;
1479
                                                case Key_Right:
3783 cbradney 1480
                                                        view->MoveItemI(currItem, moveBy, 0, true);
1298 fschmid 1481
                                                        break;
1482
                                                case Key_Up:
3783 cbradney 1483
                                                        view->MoveItemI(currItem, 0, -moveBy, true);
1298 fschmid 1484
                                                        break;
1485
                                                case Key_Down:
3783 cbradney 1486
                                                        view->MoveItemI(currItem, 0, moveBy, true);
1298 fschmid 1487
                                                        break;
1488
                                        }
1489
                                }
3829 cbradney 1490
                                view->oldCp = currItem->CPos;
1957 cbradney 1491
                                if (currItem->itemType() == PageItem::TextFrame)
272 Franz 1492
                                {
3829 cbradney 1493
                                        bool kr=keyrep;
1494
                                        currItem->handleModeEditKey(k, keyrep);
1495
                                        keyrep=kr;
272 Franz 1496
                                }
1497
                                slotDocCh(false);
1498
                                break;
1499
                        }
1500
                }
1501
        }
1204 tsoots 1502
        switch(kk)
1503
        {
1504
                case Key_Left:
1505
                case Key_Right:
1506
                case Key_Up:
1507
                case Key_Down:
1508
                        _arrowKeyDown = true;
1509
        }
92 Franz 1510
        keyrep = false;
3 paul 1511
}
1512
 
4026 craig 1513
void ScribusMainWindow::keyReleaseEvent(QKeyEvent *k)
1204 tsoots 1514
{
1515
        if (k->isAutoRepeat() || !_arrowKeyDown)
1516
                return;
1517
        switch(k->key())
1518
        {
1519
                case Key_Left:
1520
                case Key_Right:
1521
                case Key_Up:
1522
                case Key_Down:
1523
                        _arrowKeyDown = false;
3615 cbradney 1524
                        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
2951 fschmid 1525
                        {
3934 cbradney 1526
                                uint docSelectionCount=doc->selection->count();
1527
                                if ((docSelectionCount != 0) && (doc->appMode == modeNormal) && (doc->EditClip) && (view->ClRe != -1))
2951 fschmid 1528
                                        view->updateContents();
3934 cbradney 1529
                                for (uint i = 0; i < docSelectionCount; ++i)
1530
                                        doc->selection->itemAt(i)->checkChanges(true);
1531
                                if (docSelectionCount > 1 && view->groupTransactionStarted())
2951 fschmid 1532
                                        undoManager->commit();
1533
                        }
1204 tsoots 1534
        }
1535
}
1536
 
4026 craig 1537
void ScribusMainWindow::closeEvent(QCloseEvent *ce)
3 paul 1538
{
1539
        QWidgetList windows = wsp->windowList();
1540
        ScribusWin* tw;
3575 cbradney 1541
        disconnect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
3 paul 1542
        if (!windows.isEmpty())
272 Franz 1543
        {
135 Franz 1544
                singleClose = true;
3571 cbradney 1545
                uint windowCount=windows.count();
1546
                for ( uint i = 0; i < windowCount; ++i )
272 Franz 1547
                {
3 paul 1548
                        newActWin(windows.at(i));
272 Franz 1549
                        tw = ActWin;
3 paul 1550
                        ActWin->close();
1551
                        if (tw == ActWin)
272 Franz 1552
                        {
3 paul 1553
                                ce->ignore();
135 Franz 1554
                                singleClose = false;
3575 cbradney 1555
                                connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
3 paul 1556
                                return;
1557
                        }
272 Franz 1558
                }
1559
        }
3179 cbradney 1560
        propertiesPalette->hide();
1561
        outlinePalette->hide();
1562
        scrapbookPalette->hide();
1563
        bookmarkPalette->hide();
1564
        layerPalette->hide();
1565
        pagePalette->hide();
1566
        measurementPalette->hide();
1567
        docCheckerPalette->hide();
3923 tsoots 1568
        undoPalette->hide();
3924 tsoots 1569
        alignDistributePalette->hide();
3201 subik 1570
 
3294 craig 1571
        // Clean up plugins, THEN save prefs to disk
1572
        pluginManager->cleanupPlugins();
3170 craig 1573
        if (!emergencyActivated)
2859 cbradney 1574
                prefsManager->SavePrefs();
3170 craig 1575
        UndoManager::deleteInstance();
1576
        if ((prefsManager->appPrefs.SaveAtQ) && (scrapbookPalette->changed()))
1577
        {
1578
                if (scrapbookPalette->getScrapbookFileName().isEmpty())
1579
                        scrapbookPalette->setScrapbookFileName(PrefsPfad+"/scrap13.scs");
1580
                scrapbookPalette->Save();
272 Franz 1581
        }
3170 craig 1582
        if (scrapbookPalette->objectCount() == 0)
1583
                unlink(PrefsPfad+"/scrap13.scs");
1584
        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1585
        exit(0);
3 paul 1586
}
1587
 
1588
/////////////////////////////////////////////////////////////////////
1589
// SLOT IMPLEMENTATION
1590
/////////////////////////////////////////////////////////////////////
1591
 
1485 tsoots 1592
 
4026 craig 1593
bool ScribusMainWindow::arrowKeyDown()
1204 tsoots 1594
{
1595
        return _arrowKeyDown;
1596
}
1597
 
4026 craig 1598
void ScribusMainWindow::startUpDialog()
2833 fschmid 1599
{
2856 cbradney 1600
        PrefsContext* docContext = prefsManager->prefsFile->getContext("docdirs", false);
2834 cbradney 1601
        NewDoc* dia = new NewDoc(this, true);
2833 fschmid 1602
        if (dia->exec())
1603
        {
1604
                if (dia->tabSelected == 0)
1605
                {
2901 fschmid 1606
                        int facingPages = dia->choosenLayout;
3016 fschmid 1607
                        int firstPage = dia->docLayout->firstPage->currentItem();
2901 fschmid 1608
                        double topMargin = dia->GroupRand->RandT;
1609
                        double bottomMargin = dia->GroupRand->RandB;
1610
                        double leftMargin = dia->GroupRand->RandL;
1611
                        double rightMargin = dia->GroupRand->RandR;
1612
                        double columnDistance = dia->Dist;
1613
                        double pageWidth = dia->Pagebr;
1614
                        double pageHeight = dia->Pageho;
1615
                        double numberCols = dia->SpinBox10->value();
1616
                        bool autoframes = dia->AutoFrame->isChecked();
2833 fschmid 1617
                        int orientation = dia->Orient;
3778 cbradney 1618
                        int pageCount=dia->PgNum->value();
2833 fschmid 1619
                        PageSize *ps2 = new PageSize(dia->ComboBox1->currentText());
1620
                        QString pagesize = ps2->getPageName();
3778 cbradney 1621
                        doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->ComboBox3->currentItem(), firstPage, orientation, dia->PgNr->value(), pagesize, pageCount);
3016 fschmid 1622
                        doc->pageSets[facingPages].FirstPage = firstPage;
2833 fschmid 1623
                        delete ps2;
3695 cbradney 1624
                        HaveNewDoc();
2833 fschmid 1625
                }
1626
                else
1627
                {
1628
                        if (dia->tabSelected == 1)
1629
                        {
3691 cbradney 1630
                                QString fileName(dia->fileDialog->selectedFile());
2877 cbradney 1631
                                if (!fileName.isEmpty())
2833 fschmid 1632
                                {
1633
                                        docContext->set("docsopen", fileName.left(fileName.findRev("/")));
1634
                                        loadDoc(fileName);
1635
                                }
1636
                        }
2842 fschmid 1637
                        else
1638
                        {
3691 cbradney 1639
                                QString fileName(dia->recentDocList->currentText());
2877 cbradney 1640
                                if (!fileName.isEmpty())
2842 fschmid 1641
                                        loadRecent(fileName);
1642
                        }
2833 fschmid 1643
                }
1644
        }
2871 cbradney 1645
        prefsManager->setShowStartupDialog(!dia->startUpDialog->isChecked());
2833 fschmid 1646
        delete dia;
1647
        mainWindowStatusLabel->setText( tr("Ready"));
1648
}
1649
 
4026 craig 1650
bool ScribusMainWindow::slotFileNew()
3 paul 1651
{
809 cbradney 1652
        bool retVal;
2834 cbradney 1653
        NewDoc* dia = new NewDoc(this);
3 paul 1654
        if (dia->exec())
272 Franz 1655
        {
2901 fschmid 1656
                int facingPages = dia->choosenLayout;
3016 fschmid 1657
                int firstPage = dia->docLayout->firstPage->currentItem();
2901 fschmid 1658
                double topMargin = dia->GroupRand->RandT;
1659
                double bottomMargin = dia->GroupRand->RandB;
1660
                double leftMargin = dia->GroupRand->RandL;
1661
                double rightMargin = dia->GroupRand->RandR;
1662
                double columnDistance = dia->Dist;
1663
                double pageWidth = dia->Pagebr;
1664
                double pageHeight = dia->Pageho;
1665
                double numberCols = dia->SpinBox10->value();
1666
                bool autoframes = dia->AutoFrame->isChecked();
809 cbradney 1667
                int orientation = dia->Orient;
3778 cbradney 1668
                int pageCount=dia->PgNum->value();
2658 fschmid 1669
                PageSize *ps2 = new PageSize(dia->ComboBox1->currentText());
1670
                QString pagesize = ps2->getPageName();
3778 cbradney 1671
                retVal = doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->ComboBox3->currentItem(), firstPage, orientation, dia->PgNr->value(), pagesize, pageCount);
3016 fschmid 1672
                doc->pageSets[facingPages].FirstPage = firstPage;
2433 cbradney 1673
                mainWindowStatusLabel->setText( tr("Ready"));
2658 fschmid 1674
                delete ps2;
3695 cbradney 1675
                HaveNewDoc();
272 Franz 1676
        }
3 paul 1677
        else
809 cbradney 1678
                retVal = false;
3 paul 1679
        delete dia;
809 cbradney 1680
        return retVal;
3 paul 1681
}
1682
 
4026 craig 1683
bool ScribusMainWindow::doFileNew(double width, double h, double tpr, double lr, double rr, double br, double ab, double sp,
3778 cbradney 1684
                           bool atf, int fp, int einh, int firstleft, int Ori, int SNr, const QString& defaultPageSize, int pageCount)
3 paul 1685
{
1686
        QString cc;
91 Franz 1687
        if (HaveDoc)
4049 cbradney 1688
        {
1545 cbradney 1689
                doc->OpenNodes = outlinePalette->buildReopenVals();
4049 cbradney 1690
        }
2834 cbradney 1691
        doc = new ScribusDoc();
2891 cbradney 1692
        doc->setLoading(true);
1693
        doc->setup(einh, fp, firstleft, Ori, SNr, defaultPageSize, doc->DocName+cc.setNum(DocNr));
3 paul 1694
        HaveDoc++;
1695
        DocNr++;
3695 cbradney 1696
        if (CMSavail && doc->CMSSettings.CMSinUse)
1697
                recalcColors();
1698
        doc->setPage(width, h, tpr, lr, rr, br, sp, ab, atf, fp);
3873 subik 1699
        doc->setMasterPageMode(false);
3695 cbradney 1700
        doc->addMasterPage(0, "Normal");
3778 cbradney 1701
        int createCount=pageCount;
1702
        if (createCount<=0)
1703
                createCount=1;
1704
        for (int i = 0; i < createCount; ++i)
3852 cbradney 1705
                doc->addPage(i, "Normal", true);
3757 cbradney 1706
        doc->addSection();
3793 cbradney 1707
        doc->setFirstSectionFromFirstPageNumber();
3695 cbradney 1708
        doc->setModified(false);
1709
        doc->setLoading(false);
3724 cbradney 1710
        doc->currentPage = doc->Pages->at(0);
3695 cbradney 1711
        doc->OpenNodes.clear();
3873 subik 1712
 
3695 cbradney 1713
        //<<View and window code
3 paul 1714
        ScribusWin* w = new ScribusWin(wsp, doc);
1822 cbradney 1715
        if (view!=NULL)
2626 cbradney 1716
        {
2026 cbradney 1717
                actionManager->disconnectNewViewActions();
2626 cbradney 1718
                disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
1719
        }
2834 cbradney 1720
        view = new ScribusView(w, doc);
2873 cbradney 1721
        view->setScale(prefsManager->displayScale());
2026 cbradney 1722
        actionManager->connectNewViewActions(view);
2355 cbradney 1723
        alignDistributePalette->setView(view);
3692 cbradney 1724
        docCheckerPalette->clearErrorList();
3 paul 1725
        w->setView(view);
1726
        ActWin = w;
59 Franz 1727
        doc->WinHan = w;
3 paul 1728
        w->setCentralWidget(view);
3757 cbradney 1729
        view->reformPages(true);
3692 cbradney 1730
        //>>
3873 subik 1731
 
3692 cbradney 1732
        connect(undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
1733
        //connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
1734
        connect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
1735
        //      connect(w, SIGNAL(SaveAndClose()), this, SLOT(DoSaveClose()));
1736
 
2893 cbradney 1737
        //Independent finishing tasks after doc setup
3 paul 1738
        if ( wsp->windowList().isEmpty() )
1739
                w->showMaximized();
1740
        else
1741
                w->show();
1742
        view->show();
2891 cbradney 1743
        connect(doc->autoSaveTimer, SIGNAL(timeout()), w, SLOT(slotAutoSave()));
81 Franz 1744
        connect(w, SIGNAL(AutoSaved()), this, SLOT(slotAutoSaved()));
2893 cbradney 1745
        connect(fileWatcher, SIGNAL(fileChanged(QString)), view, SLOT(updatePict(QString)));
1746
        connect(fileWatcher, SIGNAL(fileDeleted(QString)), view, SLOT(removePict(QString)));
1208 cbradney 1747
        scrActions["fileSave"]->setEnabled(false);
1247 tsoots 1748
        undoManager->switchStack(doc->DocName);
2441 cbradney 1749
        tocGenerator->setDoc(doc);
3 paul 1750
        return true;
1751
}
1752
 
4026 craig 1753
void ScribusMainWindow::newView()
1330 fschmid 1754
{
1755
        ScribusWin* w = new ScribusWin(wsp, doc);
2834 cbradney 1756
        view = new ScribusView(w, doc);
2873 cbradney 1757
        view->setScale(prefsManager->displayScale());
1330 fschmid 1758
        w->setView(view);
1759
        ActWin = w;
1760
        w->setCentralWidget(view);
2355 cbradney 1761
        alignDistributePalette->setView(view);
1330 fschmid 1762
        connect(undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
3571 cbradney 1763
        //connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
1330 fschmid 1764
}
1765
 
4051 cbradney 1766
/*CB Unnecessary code, used once, lets use the slot directly
4026 craig 1767
bool ScribusMainWindow::DoSaveClose()
3 paul 1768
{
272 Franz 1769
        return slotFileSave();
3 paul 1770
}
4051 cbradney 1771
*/
3 paul 1772
 
4026 craig 1773
void ScribusMainWindow::windowsMenuAboutToShow()
3 paul 1774
{
1478 cbradney 1775
        for( QMap<QString, QGuardedPtr<ScrAction> >::Iterator it = scrWindowsActions.begin(); it!=scrWindowsActions.end(); ++it )
1776
                scrMenuMgr->removeMenuItem((*it), "Windows");
1260 cbradney 1777
        scrWindowsActions.clear();
3097 cbradney 1778
        addDefaultWindowMenuItems();
1779
        QWidgetList windows = wsp->windowList();
3123 cbradney 1780
        bool windowsListNotEmpty=!windows.isEmpty();
1781
        scrActions["windowsCascade"]->setEnabled(windowsListNotEmpty);
1782
        scrActions["windowsTile"]->setEnabled(windowsListNotEmpty);
1783
        if (windowsListNotEmpty)
272 Franz 1784
        {
3097 cbradney 1785
                scrMenuMgr->addMenuSeparator("Windows");
3172 subik 1786
 
3097 cbradney 1787
                int windowCount=static_cast<int>(windows.count());
1788
                for ( int i = 0; i < windowCount; ++i )
1789
                {
1790
                        QString docInWindow=windows.at(i)->caption();
3580 avox 1791
                        scrWindowsActions.insert(docInWindow, new ScrAction( ScrAction::Window, noIcon, docInWindow, QKeySequence(), this, docInWindow, i));
3097 cbradney 1792
                        scrWindowsActions[docInWindow]->setToggleAction(true);
1793
                        connect( scrWindowsActions[docInWindow], SIGNAL(activatedData(int)), this, SLOT(windowsMenuActivated(int)) );
1794
                        scrMenuMgr->addMenuItem(scrWindowsActions[docInWindow], "Windows");
1795
                        scrWindowsActions[docInWindow]->setOn(wsp->activeWindow() == windows.at(i));
1796
                }
272 Franz 1797
        }
3 paul 1798
}
1799
 
4026 craig 1800
void ScribusMainWindow::newActWin(QWidget *w)
3 paul 1801
{
1802
        if (w == NULL)
272 Franz 1803
        {
3 paul 1804
                ActWin = NULL;
1805
                return;
272 Franz 1806
        }
3571 cbradney 1807
        ActWin = (ScribusWin*)w;
1808
        if (ActWin->doc==NULL)
1809
                return;
1114 tsoots 1810
        QString oldDocName = "";
1811
        if (ActWin && ActWin->doc)
1812
                oldDocName = ActWin->doc->DocName;
1813
 
456 fschmid 1814
/*      if (doc != NULL)
272 Franz 1815
        {
91 Franz 1816
                if ((HaveDoc) && (doc != ActWin->doc))
1545 cbradney 1817
                        doc->OpenNodes = outlinePalette->buildReopenVals();
456 fschmid 1818
        } */
1545 cbradney 1819
        docCheckerPalette->clearErrorList();
1114 tsoots 1820
        QString newDocName = "";
1821
        if (ActWin && ActWin->doc)
1822
                newDocName = ActWin->doc->DocName;
3873 subik 1823
 
1114 tsoots 1824
        if (oldDocName != newDocName)
1247 tsoots 1825
                undoManager->switchStack(newDocName);
1114 tsoots 1826
 
1822 cbradney 1827
        if (view!=NULL)
2626 cbradney 1828
        {
2026 cbradney 1829
                actionManager->disconnectNewViewActions();
2626 cbradney 1830
                disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
4049 cbradney 1831
                if (ScQApp->usingGUI())
1832
                        disconnect(doc->selection, SIGNAL(selectionIsMultiple(int, bool)), 0, 0);
2626 cbradney 1833
        }
3 paul 1834
        doc = ActWin->doc;
1835
        view = ActWin->view;
2026 cbradney 1836
        actionManager->connectNewViewActions(view);
2626 cbradney 1837
        connect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
4049 cbradney 1838
        if (ScQApp->usingGUI())
1839
                connect(doc->selection, SIGNAL(selectionIsMultiple(int, bool)), propertiesPalette, SLOT( setMultipleSelection(int, bool)));
1840
 
3623 cbradney 1841
        pagePalette->setView(view);
2355 cbradney 1842
        alignDistributePalette->setView(view);
809 cbradney 1843
        ScribusWin* swin;
2891 cbradney 1844
        if (!doc->isLoading())
272 Franz 1845
        {
1428 fschmid 1846
                scanDocument();
1545 cbradney 1847
                docCheckerPalette->buildErrorList(doc);
3 paul 1848
                SwitchWin();
1849
                QWidgetList windows = wsp->windowList();
1850
                for ( int i = 0; i < static_cast<int>(windows.count()); ++i )
272 Franz 1851
                {
3 paul 1852
                        swin = (ScribusWin*)windows.at(i);
1853
                        if (swin->muster != NULL)
1854
                                swin->muster->hide();
272 Franz 1855
                }
3724 cbradney 1856
                if (doc->masterPageMode())
3 paul 1857
                        ActWin->muster->show();
1065 cbradney 1858
                setAppMode(doc->appMode);
272 Franz 1859
        }
3 paul 1860
        w->setFocus();
2026 cbradney 1861
        wsp->setScrollBarsEnabled(!(w->isMaximized()));
1246 cbradney 1862
        scrActions["viewShowMargins"]->setOn(doc->guidesSettings.marginsShown);
1863
        scrActions["viewShowFrames"]->setOn(doc->guidesSettings.framesShown);
1864
        scrActions["viewShowGrid"]->setOn(doc->guidesSettings.gridShown);
1865
        scrActions["viewShowGuides"]->setOn(doc->guidesSettings.guidesShown);
1866
        scrActions["viewShowBaseline"]->setOn(doc->guidesSettings.baseShown);
1867
        scrActions["viewShowImages"]->setOn(doc->guidesSettings.showPic);
1868
        scrActions["viewShowTextChain"]->setOn(doc->guidesSettings.linkShown);
2353 fschmid 1869
        scrActions["viewShowTextControls"]->setOn(doc->guidesSettings.showControls);
2863 fschmid 1870
        scrActions["viewRulerMode"]->setOn<