Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
3 paul 7
/***************************************************************************
8
                          scribus.cpp  -  description
9
                             -------------------
10
    begin                : Fre Apr  6 21:09:31 CEST 2001
11
    copyright            : (C) 2001 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
23
 
24
#include <qaccel.h>
25
#include <qapplication.h>
204 Franz 26
#include <qeventloop.h>
3 paul 27
#include <qcolordialog.h>
28
#include <qcolor.h>
29
#include <qiconset.h>
30
#include <qtextstream.h>
31
#include <qstylefactory.h>
32
#include <qregexp.h>
33
#include <qtextcodec.h>
34
#include <qcursor.h>
35
#include <qvbox.h>
1208 cbradney 36
#include <qpixmap.h>
37
#include <qkeysequence.h>
38
 
3 paul 39
#include <cstdio>
40
#include <cstdlib>
391 Franz 41
#include <cmath>
2629 craig 42
 
2688 craig 43
#include "scconfig.h"
2629 craig 44
 
45
#ifdef HAVE_DLFCN_H
3 paul 46
#include <dlfcn.h>
2629 craig 47
#endif
48
 
49
#ifdef HAVE_UNISTD_H
135 Franz 50
#include <unistd.h>
2629 craig 51
#endif
52
 
3 paul 53
#include <iostream>
119 Franz 54
#include <signal.h>
80 Franz 55
#include <string>
1208 cbradney 56
 
3457 avox 57
#include "sccombobox.h"
2160 cbradney 58
#include "scribusapp.h"
3 paul 59
#include "scribus.h"
60
#include "scribus.moc"
61
#include "newfile.h"
62
#include "page.h"
63
#include "query.h"
64
#include "mdup.h"
65
#include "docinfo.h"
66
#include "reformdoc.h"
67
#include "serializer.h"
2355 cbradney 68
#include "aligndistribute.h"
3 paul 69
#include "fmitem.h"
70
#include "fontprefs.h"
1641 cbradney 71
#include "prefs.h"
3251 craig 72
#include "prefscontext.h"
1158 cbradney 73
#include "prefstable.h"
3 paul 74
#include "pdfopts.h"
3133 fschmid 75
#include "pdflib.h"
3 paul 76
#include "inspage.h"
77
#include "delpages.h"
78
#include "movepage.h"
79
#include "helpbrowser.h"
80
#include "scribusXml.h"
1641 cbradney 81
#include "about.h"
3247 craig 82
#include "aboutplugins.h"
3136 fschmid 83
#include "pslib.h"
3 paul 84
#include "druck.h"
85
#include "editformats.h"
86
#include "muster.h"
3187 fschmid 87
#include "newtemp.h"
1806 cbradney 88
#include "applytemplatedialog.h"
3 paul 89
#include "picstatus.h"
90
#include "customfdialog.h"
91
#include "cmsprefs.h"
92
#include "annot.h"
93
#include "annota.h"
94
#include "javadocs.h"
151 Franz 95
#include "colorm.h"
265 Franz 96
#include "mpalette.h"
3540 cbradney 97
#include "cpalette.h"
1525 cbradney 98
#include "bookpalette.h"
99
#include "seiten.h"
100
#include "layers.h"
101
#include "frameedit.h"
102
#include "splash.h"
284 Franz 103
#include "measurements.h"
364 Franz 104
#include "gtgettext.h"
506 fschmid 105
#include "fileloader.h"
740 fschmid 106
#include "arrowchooser.h"
788 fschmid 107
#include "tabtypography.h"
879 fschmid 108
#include "tabguides.h"
1194 fschmid 109
#include "tabtools.h"
1114 tsoots 110
#include "undogui.h"
1151 fschmid 111
#include "filewatcher.h"
1202 fschmid 112
#include "charselect.h"
1232 fschmid 113
#include "checkDocument.h"
1235 fschmid 114
#include "tabcheckdoc.h"
1307 fschmid 115
#include "tabpdfoptions.h"
1641 cbradney 116
#include "docitemattrprefs.h"
1644 cbradney 117
#include "pageitemattributes.h"
3829 cbradney 118
#include "pageitem_textframe.h"
4579 cbradney 119
#include "pageitem_imageframe.h"
1694 cbradney 120
#include "tocindexprefs.h"
2441 cbradney 121
#include "tocgenerator.h"
3201 subik 122
#include "collect4output.h"
3 paul 123
#include "fpoint.h"
124
#include "fpointarray.h"
125
#include "hysettings.h"
126
#include "guidemanager.h"
284 Franz 127
#include "keymanager.h"
3 paul 128
#include "mergedoc.h"
27 Franz 129
#include "lineformats.h"
102 Franz 130
#include "story.h"
123 Franz 131
#include "autoform.h"
140 Franz 132
#include "tabmanager.h"
164 Franz 133
#include "search.h"
169 Franz 134
#include "fontcombo.h"
4689 mrdocs 135
#include "colorcombo.h"
415 Franz 136
#include "prefsfile.h"
1114 tsoots 137
#include "undomanager.h"
731 fschmid 138
#include "polygonwidget.h"
766 cbradney 139
#include "werktoolb.h"
806 cbradney 140
#include "units.h"
838 cbradney 141
#include "hruler.h"
142
#include "vruler.h"
3053 avox 143
#include "pageselector.h"
1208 cbradney 144
#include "scraction.h"
145
#include "menumanager.h"
1293 tsoots 146
#include "undostate.h"
1414 fschmid 147
#include "tree.h"
1500 cbradney 148
#include "scrap.h"
1549 subik 149
#include "pluginmanager.h"
1693 craig 150
#include "scpaths.h"
1972 craig 151
#include "pdfoptions.h"
1993 cbradney 152
#include "actionmanager.h"
2024 cbradney 153
#include "documentinformation.h"
2056 fschmid 154
#include "effectsdialog.h"
2111 cbradney 155
#include "documentchecker.h"
4506 cbradney 156
#include "gsutil.h"
2531 craig 157
#include "util.h"
2658 fschmid 158
#include "pagesize.h"
2707 subik 159
#include "loremipsum.h"
2769 fschmid 160
#include "marginWidget.h"
2777 fschmid 161
#include "margindialog.h"
2834 cbradney 162
#include "prefsmanager.h"
2901 fschmid 163
#include "pagelayout.h"
2952 cbradney 164
#include "commonstrings.h"
3165 fschmid 165
#include "preview.h"
3252 craig 166
#include "scribuswin.h"
167
#include "hyphenator.h"
3510 cbradney 168
#include "scmessagebox.h"
3706 fschmid 169
#include "imageinfodialog.h"
3934 cbradney 170
#include "selection.h"
4829 tsoots 171
#include "stylemanager.h"
172
#include "smlinestyle.h"
134 Franz 173
 
4361 cbradney 174
#if defined(_WIN32)
175
#include "scwinprint.h"
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
 */
10055 jghali 232
int ScribusMainWindow::initScribus(bool showSplash, bool showFontInfo, 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;
3 paul 318
                GetCMSProfiles();
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");
2039 cbradney 830
        scrMenuMgr->addMenuSeparator("InsertChar");
4564 cbradney 831
        scrMenuMgr->addMenuItem(scrActions["unicodeCopyRight"], "InsertChar");
832
        scrMenuMgr->addMenuItem(scrActions["unicodeRegdTM"], "InsertChar");
833
        scrMenuMgr->addMenuItem(scrActions["unicodeTM"], "InsertChar");
4720 cbradney 834
        scrMenuMgr->addMenuItem(scrActions["unicodeSolidus"], "InsertChar");
4564 cbradney 835
        scrMenuMgr->addMenuItem(scrActions["unicodeBullet"], "InsertChar");
4720 cbradney 836
        scrMenuMgr->addMenuItem(scrActions["unicodeMidpoint"], "InsertChar");
1903 cbradney 837
        scrMenuMgr->addMenuSeparator("InsertChar");
4564 cbradney 838
        scrMenuMgr->addMenuItem(scrActions["unicodeDashEm"], "InsertChar");
839
        scrMenuMgr->addMenuItem(scrActions["unicodeDashEn"], "InsertChar");
840
        scrMenuMgr->addMenuItem(scrActions["unicodeDashFigure"], "InsertChar");
841
        scrMenuMgr->addMenuItem(scrActions["unicodeDashQuotation"], "InsertChar");
2143 subik 842
 
3580 avox 843
        scrMenuMgr->createMenu("InsertQuote", QPixmap(noIcon), tr("Quote"), "Insert");
2226 cbradney 844
        //scrMenuMgr->addMenuToMenu("InsertQuote", "Insert");
4564 cbradney 845
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteApostrophe"], "InsertQuote");
846
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteStraight"], "InsertQuote");
2039 cbradney 847
        scrMenuMgr->addMenuSeparator("InsertQuote");
4564 cbradney 848
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeft"], "InsertQuote");
849
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRight"], "InsertQuote");
850
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeft"], "InsertQuote");
851
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRight"], "InsertQuote");
2039 cbradney 852
        scrMenuMgr->addMenuSeparator("InsertQuote");
4564 cbradney 853
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowSingleComma"], "InsertQuote");
854
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowDoubleComma"], "InsertQuote");
3412 cbradney 855
        scrMenuMgr->addMenuSeparator("InsertQuote");
4564 cbradney 856
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleReversed"], "InsertQuote");
857
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleReversed"], "InsertQuote");
2039 cbradney 858
        scrMenuMgr->addMenuSeparator("InsertQuote");
4564 cbradney 859
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeftGuillemet"], "InsertQuote");
860
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRightGuillemet"], "InsertQuote");
861
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeftGuillemet"], "InsertQuote");
862
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRightGuillemet"], "InsertQuote");
2039 cbradney 863
        scrMenuMgr->addMenuSeparator("InsertQuote");
4564 cbradney 864
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleLeft"], "InsertQuote");
865
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleRight"], "InsertQuote");
866
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleLeft"], "InsertQuote");
867
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleRight"], "InsertQuote");
1903 cbradney 868
 
4720 cbradney 869
        scrMenuMgr->createMenu("InsertSpace", QPixmap(noIcon), tr("Spaces && Breaks"), "Insert");
4564 cbradney 870
        scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingSpace"], "InsertSpace");
4720 cbradney 871
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEN"], "InsertSpace");
872
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEM"], "InsertSpace");
873
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThin"], "InsertSpace");
874
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThick"], "InsertSpace");
875
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceMid"], "InsertSpace");
876
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceHair"], "InsertSpace");
877
        scrMenuMgr->addMenuSeparator("InsertSpace");
4564 cbradney 878
        scrMenuMgr->addMenuItem(scrActions["unicodeNewLine"], "InsertSpace");
879
        scrMenuMgr->addMenuItem(scrActions["unicodeFrameBreak"], "InsertSpace");
880
        scrMenuMgr->addMenuItem(scrActions["unicodeColumnBreak"], "InsertSpace");
4729 subik 881
 
4564 cbradney 882
        scrMenuMgr->createMenu("InsertLigature", QPixmap(noIcon), tr("Ligature"), "Insert");
883
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ff"], "InsertLigature");
884
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fi"], "InsertLigature");
885
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fl"], "InsertLigature");
886
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffi"], "InsertLigature");
887
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffl"], "InsertLigature");
888
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ft"], "InsertLigature");
889
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_st"], "InsertLigature");
4729 subik 890
 
1903 cbradney 891
        scrMenuMgr->addMenuSeparator("Insert");
1818 cbradney 892
        scrMenuMgr->addMenuItem(scrActions["insertSampleText"], "Insert");
1903 cbradney 893
        scrActions["insertGlyph"]->setEnabled(false);
2143 subik 894
 
1236 cbradney 895
        //Page menu
896
        scrMenuMgr->createMenu("Page", tr("&Page"));
897
        scrMenuMgr->addMenuItem(scrActions["pageInsert"], "Page");
2143 subik 898
        scrMenuMgr->addMenuItem(scrActions["pageImport"], "Page");
1236 cbradney 899
        scrMenuMgr->addMenuItem(scrActions["pageDelete"], "Page");
900
        scrMenuMgr->addMenuItem(scrActions["pageCopy"], "Page");
901
        scrMenuMgr->addMenuItem(scrActions["pageMove"], "Page");
2093 cbradney 902
        scrMenuMgr->addMenuItem(scrActions["pageApplyMasterPage"], "Page");
3187 fschmid 903
        scrMenuMgr->addMenuItem(scrActions["pageCopyToMasterPage"], "Page");
1236 cbradney 904
        scrMenuMgr->addMenuItem(scrActions["pageManageGuides"], "Page");
2777 fschmid 905
        scrMenuMgr->addMenuItem(scrActions["pageManageMargins"], "Page");
3098 cbradney 906
        scrMenuMgr->addMenuSeparator("Page");
907
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGrid"], "Page");
908
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGuides"], "Page");
1236 cbradney 909
        scrActions["pageDelete"]->setEnabled(false);
910
        scrActions["pageMove"]->setEnabled(false);
1485 tsoots 911
 
1236 cbradney 912
        //View menu
1246 cbradney 913
        scrMenuMgr->createMenu("View", tr("&View"));
914
        scrMenuMgr->addMenuItem(scrActions["viewFitInWindow"], "View");
915
        scrMenuMgr->addMenuItem(scrActions["viewFit50"], "View");
916
        scrMenuMgr->addMenuItem(scrActions["viewFit75"], "View");
917
        scrMenuMgr->addMenuItem(scrActions["viewFit100"], "View");
918
        scrMenuMgr->addMenuItem(scrActions["viewFit200"], "View");
9743 jghali 919
        scrMenuMgr->addMenuItem(scrActions["viewFit400"], "View");
1246 cbradney 920
        scrMenuMgr->addMenuItem(scrActions["viewFit20"], "View");
921
        scrMenuMgr->addMenuSeparator("View");
922
        scrMenuMgr->addMenuItem(scrActions["viewShowMargins"], "View");
923
        scrMenuMgr->addMenuItem(scrActions["viewShowFrames"], "View");
924
        scrMenuMgr->addMenuItem(scrActions["viewShowImages"], "View");
925
        scrMenuMgr->addMenuItem(scrActions["viewShowGrid"], "View");
926
        scrMenuMgr->addMenuItem(scrActions["viewShowGuides"], "View");
5506 cbradney 927
        scrMenuMgr->addMenuItem(scrActions["viewShowColumnBorders"], "View");
1334 cbradney 928
        scrMenuMgr->addMenuItem(scrActions["viewShowBaseline"], "View");
1246 cbradney 929
        scrMenuMgr->addMenuItem(scrActions["viewShowTextChain"], "View");
2353 fschmid 930
        scrMenuMgr->addMenuItem(scrActions["viewShowTextControls"], "View");
4651 cbradney 931
        scrMenuMgr->addMenuItem(scrActions["viewShowRulers"], "View");
2863 fschmid 932
        scrMenuMgr->addMenuItem(scrActions["viewRulerMode"], "View");
4729 subik 933
 
4653 cbradney 934
        scrActions["viewShowRulers"]->setEnabled(false);
3098 cbradney 935
 
936
        //CB If this is viewNewView imeplemented, it should be on the windows menu
1330 fschmid 937
//      scrMenuMgr->addMenuItem(scrActions["viewNewView"], "View");
1485 tsoots 938
 
1236 cbradney 939
        //Tool menu
3097 cbradney 940
        /*
1255 cbradney 941
        scrMenuMgr->createMenu("Tools", tr("&Tools"));
942
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Tools");
943
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Tools");
944
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Tools");
945
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Tools");
946
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Tools");
947
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Tools");
1525 cbradney 948
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Tools");
1255 cbradney 949
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Tools");
950
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Tools");
2355 cbradney 951
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Tools");
1255 cbradney 952
        scrMenuMgr->addMenuSeparator("Tools");
953
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Tools");
1485 tsoots 954
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Tools");
3097 cbradney 955
        //scrActions["toolsPreflightVerifier"]->setEnabled(false);*/
1485 tsoots 956
 
1236 cbradney 957
        //Extra menu
1260 cbradney 958
        scrMenuMgr->createMenu("Extras", tr("E&xtras"));
959
        scrMenuMgr->addMenuItem(scrActions["extrasManagePictures"], "Extras");
960
        scrMenuMgr->addMenuItem(scrActions["extrasHyphenateText"], "Extras");
2621 fschmid 961
        scrMenuMgr->addMenuItem(scrActions["extrasDeHyphenateText"], "Extras");
1694 cbradney 962
        scrMenuMgr->addMenuItem(scrActions["extrasGenerateTableOfContents"], "Extras");
2143 subik 963
 
1260 cbradney 964
        scrMenuMgr->setMenuEnabled("Extras", false);
965
        scrActions["extrasHyphenateText"]->setEnabled(false);
2621 fschmid 966
        scrActions["extrasDeHyphenateText"]->setEnabled(false);
1485 tsoots 967
 
1236 cbradney 968
        //Window menu
3580 avox 969
         scrMenuMgr->createMenu("Windows", tr("&Windows"), QString::null, true);
1260 cbradney 970
        connect(scrMenuMgr->getLocalPopupMenu("Windows"), SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
3097 cbradney 971
        addDefaultWindowMenuItems();
3172 subik 972
 
1260 cbradney 973
        //Help menu
1269 cbradney 974
        scrMenuMgr->createMenu("Help", tr("&Help"));
975
        scrMenuMgr->addMenuItem(scrActions["helpAboutScribus"], "Help");
3247 craig 976
        scrMenuMgr->addMenuItem(scrActions["helpAboutPlugins"], "Help");
1269 cbradney 977
        scrMenuMgr->addMenuItem(scrActions["helpAboutQt"], "Help");
978
        scrMenuMgr->addMenuSeparator("Help");
979
        scrMenuMgr->addMenuItem(scrActions["helpTooltips"], "Help");
980
        scrMenuMgr->addMenuItem(scrActions["helpManual"], "Help");
1485 tsoots 981
 
1208 cbradney 982
        scrMenuMgr->addMenuToMenuBar("File");
1227 cbradney 983
        scrMenuMgr->addMenuToMenuBar("Edit");
1325 cbradney 984
        scrMenuMgr->addMenuToMenuBar("Style");
985
        scrMenuMgr->setMenuEnabled("Style", false);
1236 cbradney 986
        scrMenuMgr->addMenuToMenuBar("Item");
1801 cbradney 987
        scrMenuMgr->setMenuEnabled("Item", false);
988
        scrMenuMgr->addMenuToMenuBar("Insert");
989
        scrMenuMgr->setMenuEnabled("Insert", false);
1236 cbradney 990
        scrMenuMgr->addMenuToMenuBar("Page");
991
        scrMenuMgr->setMenuEnabled("Page", false);
1246 cbradney 992
        scrMenuMgr->addMenuToMenuBar("View");
993
        scrMenuMgr->setMenuEnabled("View", false);
3097 cbradney 994
        //scrMenuMgr->addMenuToMenuBar("Tools");
1260 cbradney 995
        scrMenuMgr->addMenuToMenuBar("Extras");
996
        scrMenuMgr->setMenuEnabled("Extras", false);
997
        scrMenuMgr->addMenuToMenuBar("Windows");
3097 cbradney 998
        //scrMenuMgr->setMenuEnabled("Windows", false);
3 paul 999
        menuBar()->insertSeparator();
1269 cbradney 1000
        scrMenuMgr->addMenuToMenuBar("Help");
1001
 
1236 cbradney 1002
        //Alignment menu
1325 cbradney 1003
        scrMenuMgr->createMenu("Alignment", tr("&Alignment"));
1337 cbradney 1004
        scrMenuMgr->addMenuItem(scrActions["alignLeft"], "Alignment");
1005
        scrMenuMgr->addMenuItem(scrActions["alignCenter"], "Alignment");
1006
        scrMenuMgr->addMenuItem(scrActions["alignRight"], "Alignment");
1007
        scrMenuMgr->addMenuItem(scrActions["alignBlock"], "Alignment");
1008
        scrMenuMgr->addMenuItem(scrActions["alignForced"], "Alignment");
1443 tsoots 1009
 
801 cbradney 1010
        connect(ColorMenC, SIGNAL(activated(int)), this, SLOT(setItemFarbe(int)));
1011
        connect(FontMenu, SIGNAL(activated(int)), this, SLOT(setItemFont(int)));
3 paul 1012
}
1013
 
4026 craig 1014
void ScribusMainWindow::addDefaultWindowMenuItems()
3097 cbradney 1015
{
1016
        scrMenuMgr->clearMenu("Windows");
1017
        scrMenuMgr->addMenuItem(scrActions["windowsCascade"], "Windows");
1018
        scrMenuMgr->addMenuItem(scrActions["windowsTile"], "Windows");
1019
        scrMenuMgr->addMenuSeparator("Windows");
1020
 
1021
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Windows");
1022
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Windows");
1023
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Windows");
1024
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Windows");
1025
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Windows");
1026
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Windows");
1027
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Windows");
1028
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Windows");
1029
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Windows");
1030
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Windows");
1031
        scrMenuMgr->addMenuSeparator("Windows");
1032
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Windows");
1033
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Windows");
1034
}
1035
 
1036
 
4026 craig 1037
void ScribusMainWindow::initStatusBar()
3 paul 1038
{
2433 cbradney 1039
        mainWindowStatusLabel = new QLabel( "           ", statusBar(), "ft");
1040
        mainWindowProgressBar = new QProgressBar(statusBar(), "p");
1041
        mainWindowProgressBar->setCenterIndicator(true);
1042
        mainWindowProgressBar->setFixedWidth( 100 );
1043
        mainWindowProgressBar->reset();
1044
        mainWindowXPosLabel = new QLabel( "X-Pos:", statusBar(), "xt");
1045
        mainWindowYPosLabel = new QLabel( "Y-Pos:", statusBar(), "yt");
4651 cbradney 1046
        mainWindowXPosDataLabel = new QLabel( "        ", statusBar(), "dt");
1047
        mainWindowYPosDataLabel = new QLabel( "        ", statusBar(), "ydt");
809 cbradney 1048
 
4651 cbradney 1049
        statusBar()->addWidget(mainWindowStatusLabel, 6, true);
2433 cbradney 1050
        statusBar()->addWidget(mainWindowProgressBar, 0, true);
1051
        statusBar()->addWidget(mainWindowXPosLabel, 0, true);
1052
        statusBar()->addWidget(mainWindowXPosDataLabel, 1, true);
1053
        statusBar()->addWidget(mainWindowYPosLabel, 0, true);
1054
        statusBar()->addWidget(mainWindowYPosDataLabel, 1, true);
3 paul 1055
}
1056
 
4026 craig 1057
void ScribusMainWindow::setMousePositionOnStatusBar(double xp, double yp)
3 paul 1058
{
2867 fschmid 1059
        double xn = xp;
1060
        double yn = yp;
1061
        if (doc->guidesSettings.rulerMode)
1062
        {
3200 cbradney 1063
                xn -= doc->currentPage->xOffset();
1064
                yn -= doc->currentPage->yOffset();
2867 fschmid 1065
        }
1066
        xn -= doc->rulerXoffset;
1067
        yn -= doc->rulerYoffset;
2965 cbradney 1068
        QString suffix=unitGetSuffixFromIndex(doc->unitIndex());
1069
        int multiplier=unitGetDecimalsFromIndex(doc->unitIndex());
2150 cbradney 1070
        double divisor=static_cast<double>(multiplier);
2965 cbradney 1071
        int precision=unitGetPrecisionFromIndex(doc->unitIndex());
809 cbradney 1072
        QString tmp;
2965 cbradney 1073
        mainWindowXPosDataLabel->setText(tmp.setNum(qRound(xn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
1074
        mainWindowYPosDataLabel->setText(tmp.setNum(qRound(yn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
3 paul 1075
}
1076
 
4713 cbradney 1077
 
1078
//CB-->Doc
4026 craig 1079
void ScribusMainWindow::setTBvals(PageItem *currItem)
3 paul 1080
{
1957 cbradney 1081
        if (currItem->itemText.count() != 0)
272 Franz 1082
        {
1957 cbradney 1083
                int ChPos = QMIN(currItem->CPos, static_cast<int>(currItem->itemText.count()-1));
2185 fschmid 1084
                doc->CurrentStyle = currItem->itemText.at(ChPos)->cstyle & 1919;
1957 cbradney 1085
                doc->currentParaStyle = currItem->itemText.at(ChPos)->cab;
1065 cbradney 1086
                setAbsValue(doc->currentParaStyle);
1545 cbradney 1087
                propertiesPalette->setAli(doc->currentParaStyle);
3544 avox 1088
                doc->CurrFont = currItem->itemText.at(ChPos)->cfont->scName();
1957 cbradney 1089
                doc->CurrFontSize = currItem->itemText.at(ChPos)->csize;
1090
                doc->CurrTextFill = currItem->itemText.at(ChPos)->ccolor;
1091
                doc->CurrTextFillSh = currItem->itemText.at(ChPos)->cshade;
1092
                doc->CurrTextStroke = currItem->itemText.at(ChPos)->cstroke;
1093
                doc->CurrTextStrokeSh = currItem->itemText.at(ChPos)->cshade2;
1094
                doc->CurrTextScale = currItem->itemText.at(ChPos)->cscale;
2230 fschmid 1095
                doc->CurrTextScaleV = currItem->itemText.at(ChPos)->cscalev;
2234 fschmid 1096
                doc->CurrTextBase = currItem->itemText.at(ChPos)->cbase;
2247 fschmid 1097
                doc->CurrTextShadowX = currItem->itemText.at(ChPos)->cshadowx;
1098
                doc->CurrTextShadowY = currItem->itemText.at(ChPos)->cshadowy;
2257 fschmid 1099
                doc->CurrTextOutline = currItem->itemText.at(ChPos)->coutline;
2262 fschmid 1100
                doc->CurrTextUnderPos = currItem->itemText.at(ChPos)->cunderpos;
1101
                doc->CurrTextUnderWidth = currItem->itemText.at(ChPos)->cunderwidth;
2272 fschmid 1102
                doc->CurrTextStrikePos = currItem->itemText.at(ChPos)->cstrikepos;
1103
                doc->CurrTextStrikeWidth = currItem->itemText.at(ChPos)->cstrikewidth;
2262 fschmid 1104
                emit TextUnderline(doc->CurrTextUnderPos, doc->CurrTextUnderWidth);
2272 fschmid 1105
                emit TextStrike(doc->CurrTextStrikePos, doc->CurrTextStrikeWidth);
2247 fschmid 1106
                emit TextShadow(doc->CurrTextShadowX, doc->CurrTextShadowY);
68 Franz 1107
                emit TextFarben(doc->CurrTextStroke, doc->CurrTextFill, doc->CurrTextStrokeSh, doc->CurrTextFillSh);
1108
                emit TextIFont(doc->CurrFont);
272 Franz 1109
                emit TextISize(doc->CurrFontSize);
1957 cbradney 1110
                emit TextUSval(currItem->itemText.at(ChPos)->cextra);
272 Franz 1111
                emit TextStil(doc->CurrentStyle);
68 Franz 1112
                emit TextScale(doc->CurrTextScale);
2230 fschmid 1113
                emit TextScaleV(doc->CurrTextScaleV);
2234 fschmid 1114
                emit TextBase(doc->CurrTextBase);
2257 fschmid 1115
                emit TextOutline(doc->CurrTextOutline);
272 Franz 1116
        }
3 paul 1117
}
1118
 
4026 craig 1119
void ScribusMainWindow::wheelEvent(QWheelEvent *w)
3 paul 1120
{
1121
        if (HaveDoc)
239 Franz 1122
        {
2871 cbradney 1123
                int wheelVal=prefsManager->mouseWheelValue();
276 Franz 1124
                if ((w->orientation() != Qt::Vertical) || ( w->state() & ShiftButton ))
3 paul 1125
                {
239 Franz 1126
                        if (w->delta() < 0)
2871 cbradney 1127
                                view->scrollBy(wheelVal, 0);
239 Franz 1128
                        else
2871 cbradney 1129
                                view->scrollBy(-wheelVal, 0);
239 Franz 1130
                }
3 paul 1131
                else
239 Franz 1132
                {
1133
                        if (w->delta() < 0)
2871 cbradney 1134
                                view->scrollBy(0, wheelVal);
239 Franz 1135
                        else
2871 cbradney 1136
                                view->scrollBy(0, -wheelVal);
239 Franz 1137
                }
3 paul 1138
                w->accept();
239 Franz 1139
        }
3 paul 1140
}
1141
 
1485 tsoots 1142
//Special keys assigned to actions are stolen by the action and not passed to
1445 cbradney 1143
//keyPressEvent so process them here.
8079 cbradney 1144
void ScribusMainWindow::specialActionKeyEvent(const QString& actionName, int unicodevalue)
1445 cbradney 1145
{
4659 cbradney 1146
        if (HaveDoc)
1445 cbradney 1147
        {
2603 cbradney 1148
                if (doc->appMode==modeEdit)
1445 cbradney 1149
                {
4847 cbradney 1150
                        if (doc->m_Selection->count() == 1)
1445 cbradney 1151
                        {
4689 mrdocs 1152
                                ScText *hg = new ScText;
4847 cbradney 1153
                                PageItem *currItem = doc->m_Selection->itemAt(0);
4513 cbradney 1154
                                if (currItem!=NULL)
1445 cbradney 1155
                                {
4659 cbradney 1156
                                        if (unicodevalue!=-1)
1157
                                        {
1158
                                                if (currItem->HasSel && currItem->itemType()==PageItem::TextFrame)
1159
                                                        currItem->asTextFrame()->deleteSelectedTextFromFrame();
4729 subik 1160
 
4659 cbradney 1161
                                                hg->ch = QString(QChar(unicodevalue));
1162
                                                doc->setScTextDefaultsFromDoc(hg);
1163
                                                hg->cselect = false;
1164
                                                hg->cextra = 0;
1165
                                                hg->xp = 0;
1166
                                                hg->yp = 0;
1167
                                                hg->PRot = 0;
1168
                                                hg->PtransX = 0;
1169
                                                hg->PtransY = 0;
1170
                                                hg->cembedded = 0;
1171
                                                currItem->itemText.insert(currItem->CPos, hg);
1172
                                                currItem->CPos += 1;
1173
                                                currItem->Tinput = true;
1174
                                                view->RefreshItem(currItem);
1175
                                        }
1176
                                        else if (actionName=="unicodeSmartHyphen") //ignore the char as we use an attribute if the text item, for now.
1177
                                        {
5068 cbradney 1178
                                                if (currItem->CPos-1>0)
1179
                                                {
1180
                                                        currItem->itemText.at(currItem->CPos-1)->cstyle ^= 128;
1181
                                                        currItem->Tinput = true;
1182
                                                        view->RefreshItem(currItem);
1183
                                                }
4659 cbradney 1184
                                        }
1445 cbradney 1185
                                }
1186
                        }
1187
                }
1188
        }
1189
}
1190
 
5978 jghali 1191
bool ScribusMainWindow::eventFilter( QObject* /*o*/, QEvent *e )
1493 cbradney 1192
{
1525 cbradney 1193
        bool retVal;
1493 cbradney 1194
        if ( e->type() == QEvent::KeyPress ) {
1195
                QKeyEvent *k = (QKeyEvent *)e;
2357 cbradney 1196
                int keyMod=0;
1197
                if (k->state() & ShiftButton)
1198
                        keyMod |= SHIFT;
1199
                if (k->state() & ControlButton)
1200
                        keyMod |= CTRL;
1201
                if (k->state() & AltButton)
1202
                        keyMod |= ALT;
2369 cbradney 1203
 
1493 cbradney 1204
                QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
2878 cbradney 1205
                if (QString(currKeySeq).isNull())
2681 cbradney 1206
                        return false;
1525 cbradney 1207
                retVal=true;
2357 cbradney 1208
                //Palette actions
1493 cbradney 1209
                if (currKeySeq == scrActions["specialToggleAllPalettes"]->accel())
1210
                        scrActions["specialToggleAllPalettes"]->activate();
1211
                else
1212
                if (currKeySeq == scrActions["toolsProperties"]->accel())
1213
                        scrActions["toolsProperties"]->toggle();
1214
                else
1215
                if (currKeySeq == scrActions["toolsOutline"]->accel())
1216
                        scrActions["toolsOutline"]->toggle();
1217
                else
1218
                if (currKeySeq == scrActions["toolsScrapbook"]->accel())
1219
                        scrActions["toolsScrapbook"]->toggle();
1220
                else
1221
                if (currKeySeq == scrActions["toolsLayers"]->accel())
1222
                        scrActions["toolsLayers"]->toggle();
1223
                else
1224
                if (currKeySeq == scrActions["toolsPages"]->accel())
1225
                        scrActions["toolsPages"]->toggle();
1226
                else
1227
                if (currKeySeq == scrActions["toolsBookmarks"]->accel())
1228
                        scrActions["toolsBookmarks"]->toggle();
1229
                else
1230
                if (currKeySeq == scrActions["toolsActionHistory"]->accel())
1231
                        scrActions["toolsActionHistory"]->toggle();
1232
                else
1233
                if (currKeySeq == scrActions["toolsPreflightVerifier"]->accel())
1234
                        scrActions["toolsPreflightVerifier"]->toggle();
1525 cbradney 1235
                else
2355 cbradney 1236
                if (currKeySeq == scrActions["toolsAlignDistribute"]->accel())
1237
                        scrActions["toolsAlignDistribute"]->toggle();
1238
                else
2357 cbradney 1239
                //Undo actions
1240
                if (currKeySeq == scrActions["editUndoAction"]->accel() && scrActions["editUndoAction"]->isEnabled())
1241
                        scrActions["editUndoAction"]->activate();
1242
                else
1243
                if (currKeySeq == scrActions["editRedoAction"]->accel() && scrActions["editRedoAction"]->isEnabled())
1244
                        scrActions["editRedoAction"]->activate();
1245
                else
1246
                //Other actions
1565 cbradney 1247
                if (currKeySeq == scrActions["fileQuit"]->accel())
1248
                        scrActions["fileQuit"]->activate();
2143 subik 1249
                else
3412 cbradney 1250
                //Zoom actions
1251
                if (currKeySeq == scrActions["toolsZoomIn"]->accel())
1252
                        scrActions["toolsZoomIn"]->activate();
1253
                else
1254
                if (currKeySeq == scrActions["toolsZoomOut"]->accel())
1255
                        scrActions["toolsZoomOut"]->activate();
1256
                else
1525 cbradney 1257
                        retVal=false;
1493 cbradney 1258
        }
1525 cbradney 1259
        else
1260
                retVal=false;
1493 cbradney 1261
        //Return false to pass event to object
1262
        return retVal;
1263
}
1264
 
4026 craig 1265
void ScribusMainWindow::keyPressEvent(QKeyEvent *k)
3 paul 1266
{
146 Franz 1267
        QWidgetList windows;
237 Franz 1268
        QWidget* w = NULL;
3843 cbradney 1269
        //struct ScText *hg;
3 paul 1270
        int kk = k->key();
3843 cbradney 1271
        //int as = k->ascii();
1272
        //double altx, alty;
3 paul 1273
        QString uc = k->text();
1274
        QString cr, Tcha, Twort;
3843 cbradney 1275
        //uint Tcoun;
1276
        //int len, pos, c;
92 Franz 1277
        if (keyrep)
1278
                return;
1279
        keyrep = true;
3829 cbradney 1280
        int KeyMod;
3 paul 1281
        switch (k->state())
272 Franz 1282
        {
1283
        case ShiftButton:
1554 cbradney 1284
                KeyMod = SHIFT;
272 Franz 1285
                break;
1286
        case AltButton:
1554 cbradney 1287
                KeyMod = ALT;
272 Franz 1288
                break;
1289
        case ControlButton:
1554 cbradney 1290
                KeyMod = CTRL;
272 Franz 1291
                break;
1292
        default:
1293
                KeyMod = 0;
1294
                break;
1295
        }
3829 cbradney 1296
        //User presses escape and we have a doc open, and we have an item selected
292 Franz 1297
        if ((kk == Key_Escape) && (HaveDoc))
1298
        {
1299
                keyrep = false;
1957 cbradney 1300
                PageItem *currItem;
4847 cbradney 1301
                if (doc->m_Selection->count() != 0)
855 fschmid 1302
                {
4847 cbradney 1303
                        currItem = doc->m_Selection->itemAt(0);
1065 cbradney 1304
                        switch (doc->appMode)
855 fschmid 1305
                        {
2603 cbradney 1306
                                case modeNormal:
1957 cbradney 1307
                                        currItem->Sizing = false;
855 fschmid 1308
                                        if (doc->SubMode != -1)
1309
                                        {
1310
                                                view->Deselect(false);
3727 cbradney 1311
                                                doc->Items->remove(currItem->ItemNr);
855 fschmid 1312
                                        }
1313
                                        break;
2603 cbradney 1314
                                case modeLinkFrames:
1315
                                case modeUnlinkFrames:
1316
                                case modeEdit:
1317
                                case modeRotation:
4934 cbradney 1318
                                case modeEditGradientVectors:
8943 cbradney 1319
                                case modeCopyProperties:
4934 cbradney 1320
                                        view->Deselect(false);
2603 cbradney 1321
                                case modePanning:
855 fschmid 1322
                                        break;
2603 cbradney 1323
                                case modeDrawBezierLine:
1957 cbradney 1324
                                        currItem->PoLine.resize(currItem->PoLine.size()-2);
1325
                                        if (currItem->PoLine.size() < 4)
855 fschmid 1326
                                        {
1327
                                                view->Deselect(false);
3727 cbradney 1328
                                                doc->Items->remove(currItem->ItemNr);
855 fschmid 1329
                                        }
1330
                                        else
1331
                                        {
1957 cbradney 1332
                                                view->SizeItem(currItem->PoLine.WidthHeight().x(), currItem->PoLine.WidthHeight().y(), currItem->ItemNr, false, false);
4688 cbradney 1333
                                                currItem->setPolyClip(qRound(QMAX(currItem->lineWidth() / 2.0, 1)));
1957 cbradney 1334
                                                view->AdjustItemSize(currItem);
1335
                                                currItem->ContourLine = currItem->PoLine.copy();
1336
                                                currItem->ClipEdited = true;
1337
                                                currItem->FrameType = 3;
855 fschmid 1338
                                                slotDocCh();
1339
                                        }
1340
                                        view->FirstPoly = true;
1341
                                        break;
1342
                                default:
1343
                                        view->Deselect(false);
3727 cbradney 1344
                                        doc->Items->remove(currItem->ItemNr);
855 fschmid 1345
                                        break;
1346
                        }
1347
                }
4704 cbradney 1348
                view->m_MouseButtonPressed = false;
855 fschmid 1349
                doc->DragP = false;
1350
                doc->leaveDrag = false;
4663 cbradney 1351
                view->operItemMoving = false;
1352
                view->operItemResizing = false;
855 fschmid 1353
                view->MidButt = false;
1354
                doc->SubMode = -1;
1827 fschmid 1355
                doc->ElemToLink = NULL;
292 Franz 1356
                NoFrameEdit();
1357
                slotSelect();
1358
                return;
1359
        }
232 Franz 1360
        ButtonState buttonState = k->state();
3829 cbradney 1361
        /**If we have a doc and we are not changing the page or zoom level in the status bar */
3615 cbradney 1362
        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
272 Franz 1363
        {
3829 cbradney 1364
                /**
1365
                 * With no item selected we can:
1366
                 * - With space, get into panning mode (modePanning)
1367
                 * - With PageUp, scroll up
1368
                 * - With PageDown, scroll down
1369
                 * - With Tab, change active document windowActivated
1370
                 */
3873 subik 1371
 
4847 cbradney 1372
                if ((doc->appMode != modeEdit) && (doc->m_Selection->count() == 0))
272 Franz 1373
                {
8971 fschmid 1374
                        int wheelVal = prefsManager->mouseWheelValue();
1375
                        if ((buttonState & ShiftButton) && !(buttonState & ControlButton) && !(buttonState & AltButton))
1376
                                wheelVal = QMAX(qRound(wheelVal / 10.0), 1);
272 Franz 1377
                        switch (kk)
146 Franz 1378
                        {
272 Franz 1379
                        case Key_Space:
1380
                                keyrep = false;
2603 cbradney 1381
                                if (doc->appMode == modePanning)
1382
                                        setAppMode(modeNormal);
272 Franz 1383
                                else
2603 cbradney 1384
                                        setAppMode(modePanning);
272 Franz 1385
                                return;
1386
                                break;
1387
                        case Key_Prior:
2871 cbradney 1388
                                view->scrollBy(0, -prefsManager->mouseWheelValue());
272 Franz 1389
                                keyrep = false;
1390
                                return;
1391
                                break;
1392
                        case Key_Next:
2871 cbradney 1393
                                view->scrollBy(0, prefsManager->mouseWheelValue());
272 Franz 1394
                                keyrep = false;
1395
                                return;
1396
                                break;
8971 fschmid 1397
                        case Key_Left:
1398
                                view->scrollBy(-wheelVal, 0);
1399
                                keyrep = false;
1400
                                return;
1401
                                break;
1402
                        case Key_Right:
1403
                                view->scrollBy(wheelVal, 0);
1404
                                keyrep = false;
1405
                                return;
1406
                                break;
1407
                        case Key_Up:
1408
                                view->scrollBy(0, -wheelVal);
1409
                                keyrep = false;
1410
                                return;
1411
                                break;
1412
                        case Key_Down:
1413
                                view->scrollBy(0, wheelVal);
1414
                                keyrep = false;
1415
                                return;
1416
                                break;
272 Franz 1417
                        case Key_Tab:
1418
                                keyrep = false;
1419
                                windows = wsp->windowList();
1420
                                if (windows.count() > 1)
1421
                                {
1422
                                        for (int i = 0; i < static_cast<int>(windows.count()); ++i)
250 Franz 1423
                                        {
272 Franz 1424
                                                if (wsp->activeWindow() == windows.at(i))
1425
                                                {
1426
                                                        if (i == static_cast<int>(windows.count()-1))
1427
                                                                w = windows.at(0);
1428
                                                        else
1429
                                                                w = windows.at(i+1);
1430
                                                        break;
1431
                                                }
250 Franz 1432
                                        }
1545 cbradney 1433
                                        doc->OpenNodes = outlinePalette->buildReopenVals();
1434
                                        docCheckerPalette->clearErrorList();
272 Franz 1435
                                        if ( w )
1436
                                                w->showNormal();
1437
                                        newActWin(w);
1438
                                }
1439
                                return;
1440
                                break;
1441
                        }
1442
                }
3873 subik 1443
                /** Now if we have an item selected
3829 cbradney 1444
                 * - In normal mode we can:
1445
                 * -- Use backspace or delete to delete the item
1446
                 * -- Use PageUp to raise an item
1447
                 * -- Use PageDown to lower an item
4637 cbradney 1448
                 * -- Use the arrow keys to move an item or group around:
1449
                                With no meta, by 1.0 unit
6004 cbradney 1450
                                Ctrl, by 10.0 units
1451
                                Shift by 0.1 units
1452
                                Ctrl Shift 0.01 units
4637 cbradney 1453
                 * -- Use the arrow keys to resize an item:
1454
                                Alt right arrow, move right side outwards (expand)
1455
                                Alt left arrow, move left side outwards (expand)
1456
                                Alt Shift right arrow, move left side inwards (shrink)
1457
                                Alt Shift left arrow, move right side inwards (shrink)
6004 cbradney 1458
                 * -- In edit mode of an image frame, use the arrow keys to resize the image:
1459
                                (flows to pageitem_imageframe for control)
1460
                                Alt right arrow, move right side of image outwards (expand)
1461
                                Alt left arrow, move right side inwards (shrink)
1462
                                Alt down arrow, move bottom side downwards (expand)
1463
                                Alt up arrow, move top side inwards (shrink)
3829 cbradney 1464
                 */
4847 cbradney 1465
                if (doc->m_Selection->count() != 0)
272 Franz 1466
                {
3829 cbradney 1467
                        double moveBy=1.0;
6004 cbradney 1468
                        if ((buttonState & ShiftButton) && !(buttonState & ControlButton) && !(buttonState & AltButton))
1469
                                moveBy=0.1;
1470
                        else if (!(buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
3829 cbradney 1471
                                moveBy=10.0;
4636 cbradney 1472
                        else if ((buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
1473
                                moveBy=0.01;
4623 cbradney 1474
                        moveBy/=doc->unitRatio();//Lets allow movement by the current doc ratio, not only points
4636 cbradney 1475
                        bool resizing=((buttonState & AltButton) && !(buttonState & ControlButton));
4623 cbradney 1476
                        bool resizingsmaller=(resizing && (buttonState & ShiftButton));
1477
                        double resizeBy=1.0;
4637 cbradney 1478
                        //CB with control locked out due to the requirement of moveby of 0.01, we cannot support
1479
                        //resizeby 10 units unless we move to supporting modifier keys that most people dont have.
1480
                        //if (buttonState & ControlButton)
1481
                        //      resizeBy*=10.0;
4623 cbradney 1482
                        resizeBy/=doc->unitRatio();
1483
                        if (resizingsmaller)
1484
                                resizeBy*=-1.0;
3873 subik 1485
 
4729 subik 1486
 
4847 cbradney 1487
                        PageItem *currItem = doc->m_Selection->itemAt(0);
1065 cbradney 1488
                        switch (doc->appMode)
272 Franz 1489
                        {
2603 cbradney 1490
                        case modeNormal:
272 Franz 1491
                                switch (kk)
1492
                                {
360 Franz 1493
                                case Key_Backspace:
272 Franz 1494
                                case Key_Delete:
4713 cbradney 1495
                                        doc->itemSelection_DeleteItem();
272 Franz 1496
                                        break;
360 Franz 1497
                                case Key_Prior:
1957 cbradney 1498
                                        if (!currItem->locked())
2148 fschmid 1499
                                        {
456 fschmid 1500
                                                view->RaiseItem();
2148 fschmid 1501
                                                slotDocCh();
1502
                                        }
360 Franz 1503
                                        break;
1504
                                case Key_Next:
1957 cbradney 1505
                                        if (!currItem->locked())
2148 fschmid 1506
                                        {
456 fschmid 1507
                                                view->LowerItem();
2148 fschmid 1508
                                                slotDocCh();
1509
                                        }
360 Franz 1510
                                        break;
272 Franz 1511
                                case Key_Left:
1957 cbradney 1512
                                        if (!currItem->locked())
272 Franz 1513
                                        {
4623 cbradney 1514
                                                if (!resizing)
2664 fschmid 1515
                                                {
4623 cbradney 1516
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1517
                                                        {
1518
                                                                FPoint np;
1519
                                                                if (view->EditContour)
1520
                                                                        np = currItem->ContourLine.point(view->ClRe);
1521
                                                                else
1522
                                                                        np = currItem->PoLine.point(view->ClRe);
1523
                                                                np = np - FPoint(moveBy, 0);
1524
                                                                view->MoveClipPoint(currItem, np);
1525
                                                        }
2664 fschmid 1526
                                                        else
4623 cbradney 1527
                                                        {
5013 fschmid 1528
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1529
                                                        /* as the user might be trying to fine tune a position */
1530
                                                                bool sav1 = doc->SnapGuides;
1531
                                                                bool sav2 = doc->useRaster;
1532
                                                                doc->SnapGuides = false;
1533
                                                                doc->useRaster = false;
4623 cbradney 1534
                                                                view->moveGroup(-moveBy, 0);
5013 fschmid 1535
                                                                doc->SnapGuides = sav1;
1536
                                                                doc->useRaster = sav2;
4623 cbradney 1537
                                                        }
2664 fschmid 1538
                                                }
272 Franz 1539
                                                else
2664 fschmid 1540
                                                {
5717 cbradney 1541
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1542
                                                        if(view->EditContour)
1543
                                                                view->TransformPoly(10, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
4633 fschmid 1544
                                                        else
1545
                                                        {
5717 cbradney 1546
                                                                if (resizingsmaller)
1547
                                                                {
1548
                                                                        currItem->Sizing = false;
1549
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1550
                                                                }
1551
                                                                else
1552
                                                                {
6004 cbradney 1553
                                                                        view->MoveItem(-resizeBy, 0, currItem, false);
1554
                                                                        currItem->moveImageXYOffsetBy(resizeBy/currItem->imageXScale(), 0);
5717 cbradney 1555
                                                                        currItem->Sizing = false;
1556
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1557
                                                                }
4633 fschmid 1558
                                                        }
2664 fschmid 1559
                                                }
5017 cbradney 1560
                                                view->updateContents();
2148 fschmid 1561
                                                slotDocCh();
272 Franz 1562
                                        }
1563
                                        break;
1564
                                case Key_Right:
1957 cbradney 1565
                                        if (!currItem->locked())
272 Franz 1566
                                        {
4623 cbradney 1567
                                                if (!resizing)
2664 fschmid 1568
                                                {
4623 cbradney 1569
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1570
                                                        {
1571
                                                                FPoint np;
1572
                                                                if (view->EditContour)
1573
                                                                        np = currItem->ContourLine.point(view->ClRe);
1574
                                                                else
1575
                                                                        np = currItem->PoLine.point(view->ClRe);
1576
                                                                np = np + FPoint(moveBy, 0);
1577
                                                                view->MoveClipPoint(currItem, np);
1578
                                                        }
2664 fschmid 1579
                                                        else
4623 cbradney 1580
                                                        {
5013 fschmid 1581
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1582
                                                        /* as the user might be trying to fine tune a position */
1583
                                                                bool sav1 = doc->SnapGuides;
1584
                                                                bool sav2 = doc->useRaster;
1585
                                                                doc->SnapGuides = false;
1586
                                                                doc->useRaster = false;
4623 cbradney 1587
                                                                view->moveGroup(moveBy, 0);
5013 fschmid 1588
                                                                doc->SnapGuides = sav1;
1589
                                                                doc->useRaster = sav2;
4623 cbradney 1590
                                                        }
2664 fschmid 1591
                                                }
272 Franz 1592
                                                else
2664 fschmid 1593
                                                {
5717 cbradney 1594
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1595
                                                        if(view->EditContour)
1596
                                                                view->TransformPoly(11, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
4633 fschmid 1597
                                                        else
1598
                                                        {
5717 cbradney 1599
                                                                if (resizingsmaller)
1600
                                                                {
6004 cbradney 1601
                                                                        view->MoveItem(-resizeBy, 0, currItem, false);
1602
                                                                        currItem->moveImageXYOffsetBy(resizeBy/currItem->imageXScale(), 0);
5717 cbradney 1603
                                                                        currItem->Sizing = false;
1604
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1605
                                                                }
1606
                                                                else
1607
                                                                {
1608
                                                                        currItem->Sizing = false;
1609
                                                                        view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1610
                                                                }
4633 fschmid 1611
                                                        }
2664 fschmid 1612
                                                }
5017 cbradney 1613
                                                view->updateContents();
2148 fschmid 1614
                                                slotDocCh();
272 Franz 1615
                                        }
1616
                                        break;
1617
                                case Key_Up:
1957 cbradney 1618
                                        if (!currItem->locked())
272 Franz 1619
                                        {
4623 cbradney 1620
                                                if (!resizing)
2664 fschmid 1621
                                                {
4623 cbradney 1622
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1623
                                                        {
1624
                                                                FPoint np;
1625
                                                                if (view->EditContour)
1626
                                                                        np = currItem->ContourLine.point(view->ClRe);
1627
                                                                else
1628
                                                                        np = currItem->PoLine.point(view->ClRe);
1629
                                                                np = np - FPoint(0, moveBy);
1630
                                                                view->MoveClipPoint(currItem, np);
1631
                                                        }
2664 fschmid 1632
                                                        else
4623 cbradney 1633
                                                        {
5013 fschmid 1634
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1635
                                                        /* as the user might be trying to fine tune a position */
1636
                                                                bool sav1 = doc->SnapGuides;
1637
                                                                bool sav2 = doc->useRaster;
1638
                                                                doc->SnapGuides = false;
1639
                                                                doc->useRaster = false;
4623 cbradney 1640
                                                                view->moveGroup(0, -moveBy);
5013 fschmid 1641
                                                                doc->SnapGuides = sav1;
1642
                                                                doc->useRaster = sav2;
4623 cbradney 1643
                                                        }
2664 fschmid 1644
                                                }
272 Franz 1645
                                                else
2664 fschmid 1646
                                                {
5717 cbradney 1647
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1648
                                                        if(view->EditContour)
1649
                                                                view->TransformPoly(12, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
4633 fschmid 1650
                                                        else
1651
                                                        {
5717 cbradney 1652
                                                                if (resizingsmaller)
1653
                                                                {
1654
                                                                        currItem->Sizing = false;
1655
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1656
                                                                }
1657
                                                                else
1658
                                                                {
6004 cbradney 1659
                                                                        view->MoveItem(0, -resizeBy, currItem, false);
1660
                                                                        currItem->moveImageXYOffsetBy(0, resizeBy/currItem->imageYScale());
5717 cbradney 1661
                                                                        currItem->Sizing = false;
1662
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1663
                                                                }
4633 fschmid 1664
                                                        }
2664 fschmid 1665
                                                }
5017 cbradney 1666
                                                view->updateContents();
2148 fschmid 1667
                                                slotDocCh();
272 Franz 1668
                                        }
1669
                                        break;
1670
                                case Key_Down:
1957 cbradney 1671
                                        if (!currItem->locked())
272 Franz 1672
                                        {
4623 cbradney 1673
                                                if (!resizing)
2664 fschmid 1674
                                                {
4623 cbradney 1675
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1676
                                                        {
1677
                                                                FPoint np;
1678
                                                                if (view->EditContour)
1679
                                                                        np = currItem->ContourLine.point(view->ClRe);
1680
                                                                else
1681
                                                                        np = currItem->PoLine.point(view->ClRe);
1682
                                                                np = np + FPoint(0, moveBy);
1683
                                                                view->MoveClipPoint(currItem, np);
1684
                                                        }
2664 fschmid 1685
                                                        else
4623 cbradney 1686
                                                        {
5013 fschmid 1687
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1688
                                                        /* as the user might be trying to fine tune a position */
1689
                                                                bool sav1 = doc->SnapGuides;
1690
                                                                bool sav2 = doc->useRaster;
1691
                                                                doc->SnapGuides = false;
1692
                                                                doc->useRaster = false;
4623 cbradney 1693
                                                                view->moveGroup(0, moveBy);
5013 fschmid 1694
                                                                doc->SnapGuides = sav1;
1695
                                                                doc->useRaster = sav2;
4623 cbradney 1696
                                                        }
2664 fschmid 1697
                                                }
272 Franz 1698
                                                else
2664 fschmid 1699
                                                {
5717 cbradney 1700
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
1701
                                                        if(view->EditContour)
1702
                                                                view->TransformPoly(13, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
4633 fschmid 1703
                                                        else
1704
                                                        {
5717 cbradney 1705
                                                                if (resizingsmaller)
1706
                                                                {
6004 cbradney 1707
                                                                        view->MoveItem(0, -resizeBy, currItem, false);
1708
                                                                        currItem->moveImageXYOffsetBy(0, resizeBy/currItem->imageYScale());
5717 cbradney 1709
                                                                        currItem->Sizing = false;
1710
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1711
                                                                }
1712
                                                                else
1713
                                                                {
1714
                                                                        currItem->Sizing = false;
1715
                                                                        view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1716
                                                                }
4633 fschmid 1717
                                                        }
2664 fschmid 1718
                                                }
5017 cbradney 1719
                                                view->updateContents();
2148 fschmid 1720
                                                slotDocCh();
272 Franz 1721
                                        }
1722
                                        break;
1723
                                default:
1724
                                        break;
1725
                                }
1726
                                break;
2603 cbradney 1727
                        case modeEdit:
3783 cbradney 1728
                                if (currItem->asImageFrame() && !currItem->locked())
1298 fschmid 1729
                                {
5837 cbradney 1730
                                        currItem->handleModeEditKey(k, keyrep);
1731
                                        /*CB Moved to image frame handle mode edit
4593 cbradney 1732
                                        double dX=0.0,dY=0.0;
1298 fschmid 1733
                                        switch (kk)
1734
                                        {
1735
                                                case Key_Left:
4593 cbradney 1736
                                                        dX=-moveBy;
1298 fschmid 1737
                                                        break;
1738
                                                case Key_Right:
4593 cbradney 1739
                                                        dX=moveBy;
1298 fschmid 1740
                                                        break;
1741
                                                case Key_Up:
4593 cbradney 1742
                                                        dY=-moveBy;
1298 fschmid 1743
                                                        break;
1744
                                                case Key_Down:
4593 cbradney 1745
                                                        dY=moveBy;
1298 fschmid 1746
                                                        break;
1747
                                        }
4593 cbradney 1748
                                        if (dX!=0.0 || dY!=0.0)
1749
                                        {
1750
                                                currItem->moveImageInFrame(dX, dY);
1751
                                                view->updateContents(currItem->getRedrawBounding(view->scale()));
5837 cbradney 1752
                                        }*/
1298 fschmid 1753
                                }
3829 cbradney 1754
                                view->oldCp = currItem->CPos;
1957 cbradney 1755
                                if (currItem->itemType() == PageItem::TextFrame)
272 Franz 1756
                                {
3829 cbradney 1757
                                        bool kr=keyrep;
1758
                                        currItem->handleModeEditKey(k, keyrep);
1759
                                        keyrep=kr;
272 Franz 1760
                                }
1761
                                slotDocCh(false);
1762
                                break;
1763
                        }
1764
                }
1765
        }
1204 tsoots 1766
        switch(kk)
1767
        {
1768
                case Key_Left:
1769
                case Key_Right:
1770
                case Key_Up:
1771
                case Key_Down:
1772
                        _arrowKeyDown = true;
1773
        }
92 Franz 1774
        keyrep = false;
3 paul 1775
}
1776
 
4026 craig 1777
void ScribusMainWindow::keyReleaseEvent(QKeyEvent *k)
1204 tsoots 1778
{
4105 cbradney 1779
        if (k->state() & ControlButton)
1780
        {
4212 fschmid 1781
                if (HaveDoc)
1782
                {
1783
                        if ((doc->appMode == modePanning) && (k->state() & Qt::RightButton))
1784
                                setAppMode(modeNormal);
1785
                }
4105 cbradney 1786
        }
1204 tsoots 1787
        if (k->isAutoRepeat() || !_arrowKeyDown)
1788
                return;
1789
        switch(k->key())
1790
        {
1791
                case Key_Left:
1792
                case Key_Right:
1793
                case Key_Up:
1794
                case Key_Down:
1795
                        _arrowKeyDown = false;
3615 cbradney 1796
                        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
2951 fschmid 1797
                        {
4847 cbradney 1798
                                uint docSelectionCount=doc->m_Selection->count();
3934 cbradney 1799
                                if ((docSelectionCount != 0) && (doc->appMode == modeNormal) && (doc->EditClip) && (view->ClRe != -1))
2951 fschmid 1800
                                        view->updateContents();
3934 cbradney 1801
                                for (uint i = 0; i < docSelectionCount; ++i)
4847 cbradney 1802
                                        doc->m_Selection->itemAt(i)->checkChanges(true);
3934 cbradney 1803
                                if (docSelectionCount > 1 && view->groupTransactionStarted())
2951 fschmid 1804
                                        undoManager->commit();
1805
                        }
4105 cbradney 1806
                        break;
1204 tsoots 1807
        }
1808
}
1809
 
4026 craig 1810
void ScribusMainWindow::closeEvent(QCloseEvent *ce)
3 paul 1811
{
1812
        QWidgetList windows = wsp->windowList();
1813
        ScribusWin* tw;
3575 cbradney 1814
        disconnect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
3 paul 1815
        if (!windows.isEmpty())
272 Franz 1816
        {
135 Franz 1817
                singleClose = true;
3571 cbradney 1818
                uint windowCount=windows.count();
1819
                for ( uint i = 0; i < windowCount; ++i )
272 Franz 1820
                {
3 paul 1821
                        newActWin(windows.at(i));
272 Franz 1822
                        tw = ActWin;
3 paul 1823
                        ActWin->close();
1824
                        if (tw == ActWin)
272 Franz 1825
                        {
3 paul 1826
                                ce->ignore();
135 Franz 1827
                                singleClose = false;
3575 cbradney 1828
                                connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
3 paul 1829
                                return;
1830
                        }
272 Franz 1831
                }
1832
        }
3179 cbradney 1833
        propertiesPalette->hide();
1834
        outlinePalette->hide();
1835
        scrapbookPalette->hide();
1836
        bookmarkPalette->hide();
1837
        layerPalette->hide();
1838
        pagePalette->hide();
1839
        measurementPalette->hide();
1840
        docCheckerPalette->hide();
3923 tsoots 1841