Subversion Repositories Scribus

Rev

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