Subversion Repositories Scribus

Rev

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

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