Subversion Repositories Scribus

Rev

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