Subversion Repositories Scribus

Rev

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