Subversion Repositories Scribus

Rev

Rev 4679 | Rev 4686 | 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()));
4679 fschmid 558
        connect(bookmarkPalette->BView, SIGNAL(SelectElement(PageItem *)), this, SLOT(selectItemsFromOutlines(PageItem *)));
801 cbradney 559
}
560
 
4026 craig 561
void ScribusMainWindow::initScrapbook()
801 cbradney 562
{
4611 fschmid 563
        QString scrapbookFileO = QDir::convertSeparators(PrefsPfad+"/scrap13.scs");
564
        QFileInfo scrapbookFileInfoO = QFileInfo(scrapbookFileO);
565
        if (scrapbookFileInfoO.exists())
566
        {
567
                scrapbookPalette->readOldContents(scrapbookFileO, QDir::convertSeparators(PrefsPfad+"/scrapbook/main"));
568
                QDir d = QDir();
569
                d.rename(scrapbookFileO, QDir::convertSeparators(PrefsPfad+"/scrap13.backup"));
570
        }
571
        QString scrapbookFile = QDir::convertSeparators(PrefsPfad+"/scrapbook/main");
801 cbradney 572
        QFileInfo scrapbookFileInfo = QFileInfo(scrapbookFile);
573
        if (scrapbookFileInfo.exists())
2144 cbradney 574
                scrapbookPalette->readContents(scrapbookFile);
575
        scrapbookPalette->setScrapbookFileName(scrapbookFile);
4649 fschmid 576
//      scrapbookPalette->AdjustMenu();
801 cbradney 577
}
578
 
4026 craig 579
const QString ScribusMainWindow::getGuiLanguage()
770 cbradney 580
{
581
        return guiLanguage;
582
}
583
 
4026 craig 584
bool ScribusMainWindow::warningVersion(QWidget *parent)
1525 cbradney 585
{
586
        bool retval = false;
3510 cbradney 587
        int t = ScMessageBox::warning(parent, QObject::tr("Scribus Development Version"), "<qt>" +
588
                                                                 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>",
589
                                                                 CommonStrings::tr_OK, CommonStrings::tr_Cancel, "", 1, 0);
3565 cbradney 590
        if (t == 0)
1525 cbradney 591
                retval = true;
592
        return retval;
593
}
594
 
4026 craig 595
void ScribusMainWindow::initMenuBar()
3 paul 596
{
597
        RecentDocs.clear();
1208 cbradney 598
 
599
        scrMenuMgr->createMenu("File", tr("&File"));
600
        scrMenuMgr->addMenuItem(scrActions["fileNew"], "File");
601
        scrMenuMgr->addMenuItem(scrActions["fileOpen"], "File");
602
        recentFileMenuName="FileOpenRecent";
3580 avox 603
        scrMenuMgr->createMenu(recentFileMenuName, QIconSet(noIcon), tr("Open &Recent"), "File");
1208 cbradney 604
        scrMenuMgr->addMenuSeparator("File");
605
        scrMenuMgr->addMenuItem(scrActions["fileClose"], "File");
606
        scrMenuMgr->addMenuItem(scrActions["fileSave"], "File");
607
        scrMenuMgr->addMenuItem(scrActions["fileSaveAs"], "File");
608
        scrMenuMgr->addMenuItem(scrActions["fileRevert"], "File");
609
        scrMenuMgr->addMenuItem(scrActions["fileCollect"], "File");
610
        scrMenuMgr->addMenuSeparator("File");
3580 avox 611
        scrMenuMgr->createMenu("FileImport", QIconSet(noIcon), tr("&Import"), "File");
1208 cbradney 612
        scrMenuMgr->addMenuItem(scrActions["fileImportText"], "FileImport");
613
        scrMenuMgr->addMenuItem(scrActions["fileImportAppendText"], "FileImport");
614
        scrMenuMgr->addMenuItem(scrActions["fileImportImage"], "FileImport");
3580 avox 615
        scrMenuMgr->createMenu("FileExport", QIconSet(noIcon), tr("&Export"), "File");
1208 cbradney 616
        scrMenuMgr->addMenuItem(scrActions["fileExportText"], "FileExport");
617
        scrMenuMgr->addMenuItem(scrActions["fileExportAsEPS"], "FileExport");
618
        scrMenuMgr->addMenuItem(scrActions["fileExportAsPDF"], "FileExport");
619
        scrMenuMgr->addMenuSeparator("File");
4641 cbradney 620
        scrMenuMgr->addMenuItem(scrActions["fileDocSetup"], "File");
621
        scrMenuMgr->addMenuItem(scrActions["editPreferences"], "File");
622
        scrMenuMgr->addMenuSeparator("File");
1208 cbradney 623
        scrMenuMgr->addMenuItem(scrActions["filePrint"], "File");
3165 fschmid 624
        scrMenuMgr->addMenuItem(scrActions["PrintPreview"], "File");
1208 cbradney 625
        scrMenuMgr->addMenuSeparator("File");
626
        scrMenuMgr->addMenuItem(scrActions["fileQuit"], "File");
627
 
1485 tsoots 628
        scrActions["fileClose"]->setEnabled(false);
1208 cbradney 629
        scrActions["fileSave"]->setEnabled(false);
630
        scrActions["fileSaveAs"]->setEnabled(false);
631
        scrActions["fileRevert"]->setEnabled(false);
632
        scrActions["fileCollect"]->setEnabled(false);
633
        scrActions["fileImportText"]->setEnabled(false);
634
        scrActions["fileImportImage"]->setEnabled(false);
635
        scrActions["fileImportAppendText"]->setEnabled(false);
2093 cbradney 636
        scrActions["pageImport"]->setEnabled(false);
1208 cbradney 637
        scrActions["fileExportText"]->setEnabled(false);
638
        scrActions["fileExportAsEPS"]->setEnabled(false);
639
        scrActions["fileExportAsPDF"]->setEnabled(false);
640
        scrMenuMgr->setMenuEnabled("FileExport", false);
641
        scrActions["fileDocSetup"]->setEnabled(false);
642
        scrActions["filePrint"]->setEnabled(false);
3165 fschmid 643
        scrActions["PrintPreview"]->setEnabled(false);
1485 tsoots 644
 
1227 cbradney 645
        scrMenuMgr->createMenu("Edit", tr("&Edit"));
646
        scrMenuMgr->addMenuItem(scrActions["editUndoAction"], "Edit");
647
        scrMenuMgr->addMenuItem(scrActions["editRedoAction"], "Edit");
648
        scrMenuMgr->addMenuItem(scrActions["editActionMode"], "Edit");
649
        scrMenuMgr->addMenuSeparator("Edit");
650
        scrMenuMgr->addMenuItem(scrActions["editCut"], "Edit");
651
        scrMenuMgr->addMenuItem(scrActions["editCopy"], "Edit");
652
        scrMenuMgr->addMenuItem(scrActions["editPaste"], "Edit");
4579 cbradney 653
        scrMenuMgr->addMenuItem(scrActions["editCopyContents"], "Edit");
654
        scrMenuMgr->addMenuItem(scrActions["editPasteContents"], "Edit");
1963 cbradney 655
        scrMenuMgr->addMenuItem(scrActions["editClearContents"], "Edit");
1227 cbradney 656
        scrMenuMgr->addMenuItem(scrActions["editSelectAll"], "Edit");
1837 cbradney 657
        scrMenuMgr->addMenuItem(scrActions["editDeselectAll"], "Edit");
1227 cbradney 658
        scrMenuMgr->addMenuSeparator("Edit");
659
        scrMenuMgr->addMenuItem(scrActions["editSearchReplace"], "Edit");
1981 cbradney 660
        scrMenuMgr->addMenuItem(scrActions["toolsEditWithStoryEditor"], "Edit");
2259 cbradney 661
        scrMenuMgr->addMenuItem(scrActions["editEditWithImageEditor"], "Edit");
1227 cbradney 662
        scrMenuMgr->addMenuSeparator("Edit");
663
        scrMenuMgr->addMenuItem(scrActions["editColors"], "Edit");
664
        scrMenuMgr->addMenuItem(scrActions["editParaStyles"], "Edit");
665
        scrMenuMgr->addMenuItem(scrActions["editLineStyles"], "Edit");
2093 cbradney 666
        scrMenuMgr->addMenuItem(scrActions["editMasterPages"], "Edit");
1227 cbradney 667
        scrMenuMgr->addMenuItem(scrActions["editJavascripts"], "Edit");
4641 cbradney 668
        //scrMenuMgr->addMenuSeparator("Edit");
669
        //scrMenuMgr->addMenuItem(scrActions["fileDocSetup"], "Edit");
670
        //scrMenuMgr->addMenuItem(scrActions["editPreferences"], "Edit");
1227 cbradney 671
        scrActions["editUndoAction"]->setEnabled(false);
672
        scrActions["editRedoAction"]->setEnabled(false);
1446 tsoots 673
        scrActions["editActionMode"]->setEnabled(true);
1227 cbradney 674
        scrActions["editCut"]->setEnabled(false);
675
        scrActions["editCopy"]->setEnabled(false);
676
        scrActions["editPaste"]->setEnabled(false);
4579 cbradney 677
        scrActions["editCopyContents"]->setEnabled(false);
678
        scrActions["editPasteContents"]->setEnabled(false);
1963 cbradney 679
        scrActions["editClearContents"]->setEnabled(false);
1227 cbradney 680
        scrActions["editSelectAll"]->setEnabled(false);
1837 cbradney 681
        scrActions["editDeselectAll"]->setEnabled(false);
1227 cbradney 682
        scrActions["editSearchReplace"]->setEnabled(false);
683
        scrActions["editParaStyles"]->setEnabled(false);
684
        scrActions["editLineStyles"]->setEnabled(false);
2093 cbradney 685
        scrActions["editMasterPages"]->setEnabled(false);
1227 cbradney 686
        scrActions["editJavascripts"]->setEnabled(false);
1996 cbradney 687
        scrActions["toolsEditWithStoryEditor"]->setEnabled(false);
2279 cbradney 688
        scrActions["editEditWithImageEditor"]->setEnabled(false);
1227 cbradney 689
 
690
        //Style Menu
1325 cbradney 691
        scrMenuMgr->createMenu("Style", tr("St&yle"));
1437 cbradney 692
        //Color menu
693
        // CB TODO
694
        scrMenuMgr->createMenu("Color", tr("&Color"));
3457 avox 695
        ColorMenC = new ScComboBox(false);
1437 cbradney 696
        ColorMenC->setEditable(false);
697
        scrMenuMgr->addMenuItem(ColorMenC, "Color");
1485 tsoots 698
 
1437 cbradney 699
        //Text size menu
700
        scrMenuMgr->createMenu("FontSize", tr("&Size"));
701
        scrActionGroups["fontSize"]->addTo(scrMenuMgr->getLocalPopupMenu("FontSize"));
1485 tsoots 702
 
1437 cbradney 703
        //Shade menu
704
        scrMenuMgr->createMenu("Shade", tr("&Shade"));
705
        scrActionGroups["shade"]->addTo(scrMenuMgr->getLocalPopupMenu("Shade"));
1485 tsoots 706
 
1437 cbradney 707
        //Font menu
708
        scrMenuMgr->createMenu("Font", tr("&Font"));
709
        FontMenu = scrMenuMgr->getLocalPopupMenu("Font");
1485 tsoots 710
 
1437 cbradney 711
        //Type style menu
712
        scrMenuMgr->createMenu("TypeEffects", tr("&Effects"));
713
        scrActionGroups["typeEffects"]->addTo(scrMenuMgr->getLocalPopupMenu("TypeEffects"));
1485 tsoots 714
 
1236 cbradney 715
        //Item Menu
716
        scrMenuMgr->createMenu("Item", tr("&Item"));
717
        scrMenuMgr->addMenuItem(scrActions["itemDuplicate"], "Item");
718
        scrMenuMgr->addMenuItem(scrActions["itemMulDuplicate"], "Item");
719
        scrMenuMgr->addMenuItem(scrActions["itemDelete"], "Item");
720
        scrMenuMgr->addMenuSeparator("Item");
721
        scrMenuMgr->addMenuItem(scrActions["itemGroup"], "Item");
722
        scrMenuMgr->addMenuItem(scrActions["itemUngroup"], "Item");
723
        scrMenuMgr->addMenuItem(scrActions["itemLock"], "Item");
1858 cbradney 724
        scrMenuMgr->addMenuItem(scrActions["itemLockSize"], "Item");
2256 cbradney 725
        scrMenuMgr->addMenuSeparator("Item");
2026 cbradney 726
        scrMenuMgr->addMenuItem(scrActions["itemImageIsVisible"], "Item");
2260 cbradney 727
        scrMenuMgr->addMenuItem(scrActions["itemUpdateImage"], "Item");
2259 cbradney 728
        scrMenuMgr->addMenuItem(scrActions["itemAdjustFrameToImage"], "Item");
2260 cbradney 729
        scrMenuMgr->addMenuItem(scrActions["itemExtendedImageProperties"], "Item");
2959 subik 730
        scrMenuMgr->createMenu("ItemPreviewSettings", tr("Preview Settings"), "Item");
2256 cbradney 731
        scrMenuMgr->addMenuItem(scrActions["itemPreviewLow"], "ItemPreviewSettings");
732
        scrMenuMgr->addMenuItem(scrActions["itemPreviewNormal"], "ItemPreviewSettings");
733
        scrMenuMgr->addMenuItem(scrActions["itemPreviewFull"], "ItemPreviewSettings");
1236 cbradney 734
        scrMenuMgr->addMenuSeparator("Item");
2959 subik 735
        scrMenuMgr->createMenu("ItemLevel", tr("Level"));
1858 cbradney 736
        scrMenuMgr->addMenuToMenu("ItemLevel", "Item");
2104 cbradney 737
        scrMenuMgr->addMenuItem(scrActions["itemRaise"], "ItemLevel");
1858 cbradney 738
        scrMenuMgr->addMenuItem(scrActions["itemLower"], "ItemLevel");
2104 cbradney 739
        scrMenuMgr->addMenuItem(scrActions["itemRaiseToTop"], "ItemLevel");
740
        scrMenuMgr->addMenuItem(scrActions["itemLowerToBottom"], "ItemLevel");
2959 subik 741
        scrMenuMgr->createMenu("ItemLayer", tr("Send to La&yer"));
2408 cbradney 742
        scrMenuMgr->addMenuToMenu("ItemLayer", "Item");
743
        layerMenuName="ItemLayer";
1981 cbradney 744
        scrMenuMgr->addMenuItem(scrActions["itemSendToScrapbook"], "Item");
1236 cbradney 745
        scrMenuMgr->addMenuSeparator("Item");
2256 cbradney 746
        scrMenuMgr->addMenuItem(scrActions["itemAttributes"], "Item");
1981 cbradney 747
        scrMenuMgr->createMenu("ItemPDFOptions", tr("&PDF Options"));
748
        scrMenuMgr->addMenuToMenu("ItemPDFOptions", "Item");
749
        scrMenuMgr->addMenuItem(scrActions["itemPDFIsAnnotation"], "ItemPDFOptions");
2143 subik 750
        scrMenuMgr->addMenuItem(scrActions["itemPDFIsBookmark"], "ItemPDFOptions");
1981 cbradney 751
        scrMenuMgr->addMenuItem(scrActions["itemPDFAnnotationProps"], "ItemPDFOptions");
752
        scrMenuMgr->addMenuItem(scrActions["itemPDFFieldProps"], "ItemPDFOptions");
1236 cbradney 753
        scrMenuMgr->createMenu("ItemShapes", tr("&Shape"), "Item");
754
        // CB TODO
755
        //Shape menu
169 Franz 756
        SCustom = new Autoforms(0);
1236 cbradney 757
        scrMenuMgr->addMenuItem(SCustom, "ItemShapes");
272 Franz 758
        connect(SCustom, SIGNAL(FormSel(int, int, double *)), this, SLOT(MakeFrame(int, int, double *)));
1236 cbradney 759
        scrMenuMgr->addMenuItem(scrActions["itemShapeEdit"], "ItemShapes");
4518 cbradney 760
        scrMenuMgr->createMenu("ItemConvertTo", QPixmap(noIcon), tr("C&onvert To"), "Item");
761
        //scrMenuMgr->createMenu("ItemConvertTo", tr("C&onvert To"));
762
        //scrMenuMgr->addMenuToMenu("ItemConvertTo", "Item");
1858 cbradney 763
        scrMenuMgr->addMenuItem(scrActions["itemConvertToBezierCurve"], "ItemConvertTo");
764
        scrMenuMgr->addMenuItem(scrActions["itemConvertToImageFrame"], "ItemConvertTo");
765
        scrMenuMgr->addMenuItem(scrActions["itemConvertToOutlines"], "ItemConvertTo");
766
        scrMenuMgr->addMenuItem(scrActions["itemConvertToPolygon"], "ItemConvertTo");
767
        scrMenuMgr->addMenuItem(scrActions["itemConvertToTextFrame"], "ItemConvertTo");
2143 subik 768
 
1236 cbradney 769
        scrMenuMgr->addMenuItem(scrActions["itemAttachTextToPath"], "Item");
770
        scrMenuMgr->addMenuItem(scrActions["itemDetachTextFromPath"], "Item");
771
        scrMenuMgr->addMenuItem(scrActions["itemCombinePolygons"], "Item");
772
        scrMenuMgr->addMenuItem(scrActions["itemSplitPolygons"], "Item");
773
        scrMenuMgr->setMenuEnabled("ItemShapes", false);
774
        scrActions["itemGroup"]->setEnabled(false);
775
        scrActions["itemUngroup"]->setEnabled(false);
776
        scrActions["itemAttachTextToPath"]->setEnabled(false);
777
        scrActions["itemDetachTextFromPath"]->setEnabled(false);
778
        scrActions["itemCombinePolygons"]->setEnabled(false);
779
        scrActions["itemSplitPolygons"]->setEnabled(false);
780
        scrActions["itemLock"]->setEnabled(false);
1858 cbradney 781
        scrActions["itemLockSize"]->setEnabled(false);
2026 cbradney 782
        scrActions["itemImageIsVisible"]->setEnabled(false);
1858 cbradney 783
        scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
784
        scrActions["itemConvertToBezierCurve"]->setEnabled(false);
785
        scrActions["itemConvertToImageFrame"]->setEnabled(false);
1236 cbradney 786
        scrActions["itemConvertToOutlines"]->setEnabled(false);
1858 cbradney 787
        scrActions["itemConvertToPolygon"]->setEnabled(false);
788
        scrActions["itemConvertToTextFrame"]->setEnabled(false);
1485 tsoots 789
 
1801 cbradney 790
        //Insert menu
791
        scrMenuMgr->createMenu("Insert", tr("I&nsert"));
792
        scrMenuMgr->addMenuItem(scrActions["toolsInsertTextFrame"], "Insert");
793
        scrMenuMgr->addMenuItem(scrActions["toolsInsertImageFrame"], "Insert");
794
        scrMenuMgr->addMenuItem(scrActions["toolsInsertTableFrame"], "Insert");
795
        scrMenuMgr->addMenuItem(scrActions["toolsInsertShape"], "Insert");
796
        scrMenuMgr->addMenuItem(scrActions["toolsInsertPolygon"], "Insert");
797
        scrMenuMgr->addMenuItem(scrActions["toolsInsertLine"], "Insert");
798
        scrMenuMgr->addMenuItem(scrActions["toolsInsertBezier"], "Insert");
799
        scrMenuMgr->addMenuItem(scrActions["toolsInsertFreehandLine"], "Insert");
800
        scrMenuMgr->addMenuSeparator("Insert");
1903 cbradney 801
        scrMenuMgr->addMenuItem(scrActions["insertGlyph"], "Insert");
2143 subik 802
 
3580 avox 803
        scrMenuMgr->createMenu("InsertChar", QPixmap(noIcon), tr("Character"), "Insert");
2226 cbradney 804
        //scrMenuMgr->addMenuToMenu("InsertChar", "Insert");
4564 cbradney 805
        scrMenuMgr->addMenuItem(scrActions["unicodePageNumber"], "InsertChar");
806
        scrMenuMgr->addMenuItem(scrActions["unicodeSmartHyphen"], "InsertChar");
807
        scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingHyphen"], "InsertChar");
2039 cbradney 808
        scrMenuMgr->addMenuSeparator("InsertChar");
4564 cbradney 809
        scrMenuMgr->addMenuItem(scrActions["unicodeCopyRight"], "InsertChar");
810
        scrMenuMgr->addMenuItem(scrActions["unicodeRegdTM"], "InsertChar");
811
        scrMenuMgr->addMenuItem(scrActions["unicodeTM"], "InsertChar");
812
        scrMenuMgr->addMenuItem(scrActions["unicodeBullet"], "InsertChar");
1903 cbradney 813
        scrMenuMgr->addMenuSeparator("InsertChar");
4564 cbradney 814
        scrMenuMgr->addMenuItem(scrActions["unicodeDashEm"], "InsertChar");
815
        scrMenuMgr->addMenuItem(scrActions["unicodeDashEn"], "InsertChar");
816
        scrMenuMgr->addMenuItem(scrActions["unicodeDashFigure"], "InsertChar");
817
        scrMenuMgr->addMenuItem(scrActions["unicodeDashQuotation"], "InsertChar");
2143 subik 818
 
3580 avox 819
        scrMenuMgr->createMenu("InsertQuote", QPixmap(noIcon), tr("Quote"), "Insert");
2226 cbradney 820
        //scrMenuMgr->addMenuToMenu("InsertQuote", "Insert");
4564 cbradney 821
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteApostrophe"], "InsertQuote");
822
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteStraight"], "InsertQuote");
2039 cbradney 823
        scrMenuMgr->addMenuSeparator("InsertQuote");
4564 cbradney 824
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeft"], "InsertQuote");
825
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRight"], "InsertQuote");
826
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeft"], "InsertQuote");
827
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRight"], "InsertQuote");
2039 cbradney 828
        scrMenuMgr->addMenuSeparator("InsertQuote");
4564 cbradney 829
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowSingleComma"], "InsertQuote");
830
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowDoubleComma"], "InsertQuote");
3412 cbradney 831
        scrMenuMgr->addMenuSeparator("InsertQuote");
4564 cbradney 832
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleReversed"], "InsertQuote");
833
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleReversed"], "InsertQuote");
2039 cbradney 834
        scrMenuMgr->addMenuSeparator("InsertQuote");
4564 cbradney 835
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeftGuillemet"], "InsertQuote");
836
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRightGuillemet"], "InsertQuote");
837
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeftGuillemet"], "InsertQuote");
838
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRightGuillemet"], "InsertQuote");
2039 cbradney 839
        scrMenuMgr->addMenuSeparator("InsertQuote");
4564 cbradney 840
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleLeft"], "InsertQuote");
841
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleRight"], "InsertQuote");
842
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleLeft"], "InsertQuote");
843
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleRight"], "InsertQuote");
1903 cbradney 844
 
3580 avox 845
        scrMenuMgr->createMenu("InsertSpace", QPixmap(noIcon), tr("Space"), "Insert");
4564 cbradney 846
        scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingSpace"], "InsertSpace");
847
        scrMenuMgr->addMenuItem(scrActions["unicodeNewLine"], "InsertSpace");
848
        scrMenuMgr->addMenuItem(scrActions["unicodeFrameBreak"], "InsertSpace");
849
        scrMenuMgr->addMenuItem(scrActions["unicodeColumnBreak"], "InsertSpace");
850
 
851
        scrMenuMgr->createMenu("InsertLigature", QPixmap(noIcon), tr("Ligature"), "Insert");
852
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ff"], "InsertLigature");
853
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fi"], "InsertLigature");
854
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fl"], "InsertLigature");
855
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffi"], "InsertLigature");
856
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffl"], "InsertLigature");
857
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ft"], "InsertLigature");
858
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_st"], "InsertLigature");
859
 
1903 cbradney 860
        scrMenuMgr->addMenuSeparator("Insert");
1818 cbradney 861
        scrMenuMgr->addMenuItem(scrActions["insertSampleText"], "Insert");
1903 cbradney 862
        scrActions["insertGlyph"]->setEnabled(false);
2143 subik 863
 
1236 cbradney 864
        //Page menu
865
        scrMenuMgr->createMenu("Page", tr("&Page"));
866
        scrMenuMgr->addMenuItem(scrActions["pageInsert"], "Page");
2143 subik 867
        scrMenuMgr->addMenuItem(scrActions["pageImport"], "Page");
1236 cbradney 868
        scrMenuMgr->addMenuItem(scrActions["pageDelete"], "Page");
869
        scrMenuMgr->addMenuItem(scrActions["pageCopy"], "Page");
870
        scrMenuMgr->addMenuItem(scrActions["pageMove"], "Page");
2093 cbradney 871
        scrMenuMgr->addMenuItem(scrActions["pageApplyMasterPage"], "Page");
3187 fschmid 872
        scrMenuMgr->addMenuItem(scrActions["pageCopyToMasterPage"], "Page");
1236 cbradney 873
        scrMenuMgr->addMenuItem(scrActions["pageManageGuides"], "Page");
2777 fschmid 874
        scrMenuMgr->addMenuItem(scrActions["pageManageMargins"], "Page");
3098 cbradney 875
        scrMenuMgr->addMenuSeparator("Page");
876
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGrid"], "Page");
877
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGuides"], "Page");
1236 cbradney 878
        scrActions["pageDelete"]->setEnabled(false);
879
        scrActions["pageMove"]->setEnabled(false);
1485 tsoots 880
 
1236 cbradney 881
        //View menu
1246 cbradney 882
        scrMenuMgr->createMenu("View", tr("&View"));
883
        scrMenuMgr->addMenuItem(scrActions["viewFitInWindow"], "View");
884
        scrMenuMgr->addMenuItem(scrActions["viewFit50"], "View");
885
        scrMenuMgr->addMenuItem(scrActions["viewFit75"], "View");
886
        scrMenuMgr->addMenuItem(scrActions["viewFit100"], "View");
887
        scrMenuMgr->addMenuItem(scrActions["viewFit200"], "View");
888
        scrMenuMgr->addMenuItem(scrActions["viewFit20"], "View");
889
        scrMenuMgr->addMenuSeparator("View");
890
        scrMenuMgr->addMenuItem(scrActions["viewShowMargins"], "View");
891
        scrMenuMgr->addMenuItem(scrActions["viewShowFrames"], "View");
892
        scrMenuMgr->addMenuItem(scrActions["viewShowImages"], "View");
893
        scrMenuMgr->addMenuItem(scrActions["viewShowGrid"], "View");
894
        scrMenuMgr->addMenuItem(scrActions["viewShowGuides"], "View");
1334 cbradney 895
        scrMenuMgr->addMenuItem(scrActions["viewShowBaseline"], "View");
1246 cbradney 896
        scrMenuMgr->addMenuItem(scrActions["viewShowTextChain"], "View");
2353 fschmid 897
        scrMenuMgr->addMenuItem(scrActions["viewShowTextControls"], "View");
4651 cbradney 898
        scrMenuMgr->addMenuItem(scrActions["viewShowRulers"], "View");
2863 fschmid 899
        scrMenuMgr->addMenuItem(scrActions["viewRulerMode"], "View");
4653 cbradney 900
 
901
        scrActions["viewShowRulers"]->setEnabled(false);
3098 cbradney 902
 
903
        //CB If this is viewNewView imeplemented, it should be on the windows menu
1330 fschmid 904
//      scrMenuMgr->addMenuItem(scrActions["viewNewView"], "View");
1485 tsoots 905
 
1236 cbradney 906
        //Tool menu
3097 cbradney 907
        /*
1255 cbradney 908
        scrMenuMgr->createMenu("Tools", tr("&Tools"));
909
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Tools");
910
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Tools");
911
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Tools");
912
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Tools");
913
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Tools");
914
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Tools");
1525 cbradney 915
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Tools");
1255 cbradney 916
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Tools");
917
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Tools");
2355 cbradney 918
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Tools");
1255 cbradney 919
        scrMenuMgr->addMenuSeparator("Tools");
920
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Tools");
1485 tsoots 921
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Tools");
3097 cbradney 922
        //scrActions["toolsPreflightVerifier"]->setEnabled(false);*/
1485 tsoots 923
 
1236 cbradney 924
        //Extra menu
1260 cbradney 925
        scrMenuMgr->createMenu("Extras", tr("E&xtras"));
926
        scrMenuMgr->addMenuItem(scrActions["extrasManagePictures"], "Extras");
927
        scrMenuMgr->addMenuItem(scrActions["extrasHyphenateText"], "Extras");
2621 fschmid 928
        scrMenuMgr->addMenuItem(scrActions["extrasDeHyphenateText"], "Extras");
1694 cbradney 929
        scrMenuMgr->addMenuItem(scrActions["extrasGenerateTableOfContents"], "Extras");
2143 subik 930
 
1260 cbradney 931
        scrMenuMgr->setMenuEnabled("Extras", false);
932
        scrActions["extrasHyphenateText"]->setEnabled(false);
2621 fschmid 933
        scrActions["extrasDeHyphenateText"]->setEnabled(false);
1485 tsoots 934
 
1236 cbradney 935
        //Window menu
3580 avox 936
         scrMenuMgr->createMenu("Windows", tr("&Windows"), QString::null, true);
1260 cbradney 937
        connect(scrMenuMgr->getLocalPopupMenu("Windows"), SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
3097 cbradney 938
        addDefaultWindowMenuItems();
3172 subik 939
 
1260 cbradney 940
        //Help menu
1269 cbradney 941
        scrMenuMgr->createMenu("Help", tr("&Help"));
942
        scrMenuMgr->addMenuItem(scrActions["helpAboutScribus"], "Help");
3247 craig 943
        scrMenuMgr->addMenuItem(scrActions["helpAboutPlugins"], "Help");
1269 cbradney 944
        scrMenuMgr->addMenuItem(scrActions["helpAboutQt"], "Help");
945
        scrMenuMgr->addMenuSeparator("Help");
946
        scrMenuMgr->addMenuItem(scrActions["helpTooltips"], "Help");
947
        scrMenuMgr->addMenuItem(scrActions["helpManual"], "Help");
1485 tsoots 948
 
1208 cbradney 949
        scrMenuMgr->addMenuToMenuBar("File");
1227 cbradney 950
        scrMenuMgr->addMenuToMenuBar("Edit");
1325 cbradney 951
        scrMenuMgr->addMenuToMenuBar("Style");
952
        scrMenuMgr->setMenuEnabled("Style", false);
1236 cbradney 953
        scrMenuMgr->addMenuToMenuBar("Item");
1801 cbradney 954
        scrMenuMgr->setMenuEnabled("Item", false);
955
        scrMenuMgr->addMenuToMenuBar("Insert");
956
        scrMenuMgr->setMenuEnabled("Insert", false);
1236 cbradney 957
        scrMenuMgr->addMenuToMenuBar("Page");
958
        scrMenuMgr->setMenuEnabled("Page", false);
1246 cbradney 959
        scrMenuMgr->addMenuToMenuBar("View");
960
        scrMenuMgr->setMenuEnabled("View", false);
3097 cbradney 961
        //scrMenuMgr->addMenuToMenuBar("Tools");
1260 cbradney 962
        scrMenuMgr->addMenuToMenuBar("Extras");
963
        scrMenuMgr->setMenuEnabled("Extras", false);
964
        scrMenuMgr->addMenuToMenuBar("Windows");
3097 cbradney 965
        //scrMenuMgr->setMenuEnabled("Windows", false);
3 paul 966
        menuBar()->insertSeparator();
1269 cbradney 967
        scrMenuMgr->addMenuToMenuBar("Help");
968
 
1236 cbradney 969
        //Alignment menu
1325 cbradney 970
        scrMenuMgr->createMenu("Alignment", tr("&Alignment"));
1337 cbradney 971
        scrMenuMgr->addMenuItem(scrActions["alignLeft"], "Alignment");
972
        scrMenuMgr->addMenuItem(scrActions["alignCenter"], "Alignment");
973
        scrMenuMgr->addMenuItem(scrActions["alignRight"], "Alignment");
974
        scrMenuMgr->addMenuItem(scrActions["alignBlock"], "Alignment");
975
        scrMenuMgr->addMenuItem(scrActions["alignForced"], "Alignment");
1443 tsoots 976
 
801 cbradney 977
        connect(ColorMenC, SIGNAL(activated(int)), this, SLOT(setItemFarbe(int)));
978
        connect(FontMenu, SIGNAL(activated(int)), this, SLOT(setItemFont(int)));
3 paul 979
}
980
 
4026 craig 981
void ScribusMainWindow::addDefaultWindowMenuItems()
3097 cbradney 982
{
983
        scrMenuMgr->clearMenu("Windows");
984
        scrMenuMgr->addMenuItem(scrActions["windowsCascade"], "Windows");
985
        scrMenuMgr->addMenuItem(scrActions["windowsTile"], "Windows");
986
        scrMenuMgr->addMenuSeparator("Windows");
987
 
988
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Windows");
989
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Windows");
990
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Windows");
991
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Windows");
992
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Windows");
993
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Windows");
994
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Windows");
995
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Windows");
996
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Windows");
997
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Windows");
998
        scrMenuMgr->addMenuSeparator("Windows");
999
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Windows");
1000
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Windows");
1001
}
1002
 
1003
 
4026 craig 1004
void ScribusMainWindow::initStatusBar()
3 paul 1005
{
2433 cbradney 1006
        mainWindowStatusLabel = new QLabel( "           ", statusBar(), "ft");
1007
        mainWindowProgressBar = new QProgressBar(statusBar(), "p");
1008
        mainWindowProgressBar->setCenterIndicator(true);
1009
        mainWindowProgressBar->setFixedWidth( 100 );
1010
        mainWindowProgressBar->reset();
1011
        mainWindowXPosLabel = new QLabel( "X-Pos:", statusBar(), "xt");
1012
        mainWindowYPosLabel = new QLabel( "Y-Pos:", statusBar(), "yt");
4651 cbradney 1013
        mainWindowXPosDataLabel = new QLabel( "        ", statusBar(), "dt");
1014
        mainWindowYPosDataLabel = new QLabel( "        ", statusBar(), "ydt");
809 cbradney 1015
 
4651 cbradney 1016
        statusBar()->addWidget(mainWindowStatusLabel, 6, true);
2433 cbradney 1017
        statusBar()->addWidget(mainWindowProgressBar, 0, true);
1018
        statusBar()->addWidget(mainWindowXPosLabel, 0, true);
1019
        statusBar()->addWidget(mainWindowXPosDataLabel, 1, true);
1020
        statusBar()->addWidget(mainWindowYPosLabel, 0, true);
1021
        statusBar()->addWidget(mainWindowYPosDataLabel, 1, true);
3 paul 1022
}
1023
 
4026 craig 1024
void ScribusMainWindow::setMousePositionOnStatusBar(double xp, double yp)
3 paul 1025
{
2867 fschmid 1026
        double xn = xp;
1027
        double yn = yp;
1028
        if (doc->guidesSettings.rulerMode)
1029
        {
3200 cbradney 1030
                xn -= doc->currentPage->xOffset();
1031
                yn -= doc->currentPage->yOffset();
2867 fschmid 1032
        }
1033
        xn -= doc->rulerXoffset;
1034
        yn -= doc->rulerYoffset;
2965 cbradney 1035
        QString suffix=unitGetSuffixFromIndex(doc->unitIndex());
1036
        int multiplier=unitGetDecimalsFromIndex(doc->unitIndex());
2150 cbradney 1037
        double divisor=static_cast<double>(multiplier);
2965 cbradney 1038
        int precision=unitGetPrecisionFromIndex(doc->unitIndex());
809 cbradney 1039
        QString tmp;
2965 cbradney 1040
        mainWindowXPosDataLabel->setText(tmp.setNum(qRound(xn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
1041
        mainWindowYPosDataLabel->setText(tmp.setNum(qRound(yn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
3 paul 1042
}
1043
 
4026 craig 1044
void ScribusMainWindow::setTBvals(PageItem *currItem)
3 paul 1045
{
1957 cbradney 1046
        if (currItem->itemText.count() != 0)
272 Franz 1047
        {
1957 cbradney 1048
                int ChPos = QMIN(currItem->CPos, static_cast<int>(currItem->itemText.count()-1));
2185 fschmid 1049
                doc->CurrentStyle = currItem->itemText.at(ChPos)->cstyle & 1919;
1957 cbradney 1050
                doc->currentParaStyle = currItem->itemText.at(ChPos)->cab;
1065 cbradney 1051
                setAbsValue(doc->currentParaStyle);
1545 cbradney 1052
                propertiesPalette->setAli(doc->currentParaStyle);
3544 avox 1053
                doc->CurrFont = currItem->itemText.at(ChPos)->cfont->scName();
1957 cbradney 1054
                doc->CurrFontSize = currItem->itemText.at(ChPos)->csize;
1055
                doc->CurrTextFill = currItem->itemText.at(ChPos)->ccolor;
1056
                doc->CurrTextFillSh = currItem->itemText.at(ChPos)->cshade;
1057
                doc->CurrTextStroke = currItem->itemText.at(ChPos)->cstroke;
1058
                doc->CurrTextStrokeSh = currItem->itemText.at(ChPos)->cshade2;
1059
                doc->CurrTextScale = currItem->itemText.at(ChPos)->cscale;
2230 fschmid 1060
                doc->CurrTextScaleV = currItem->itemText.at(ChPos)->cscalev;
2234 fschmid 1061
                doc->CurrTextBase = currItem->itemText.at(ChPos)->cbase;
2247 fschmid 1062
                doc->CurrTextShadowX = currItem->itemText.at(ChPos)->cshadowx;
1063
                doc->CurrTextShadowY = currItem->itemText.at(ChPos)->cshadowy;
2257 fschmid 1064
                doc->CurrTextOutline = currItem->itemText.at(ChPos)->coutline;
2262 fschmid 1065
                doc->CurrTextUnderPos = currItem->itemText.at(ChPos)->cunderpos;
1066
                doc->CurrTextUnderWidth = currItem->itemText.at(ChPos)->cunderwidth;
2272 fschmid 1067
                doc->CurrTextStrikePos = currItem->itemText.at(ChPos)->cstrikepos;
1068
                doc->CurrTextStrikeWidth = currItem->itemText.at(ChPos)->cstrikewidth;
2262 fschmid 1069
                emit TextUnderline(doc->CurrTextUnderPos, doc->CurrTextUnderWidth);
2272 fschmid 1070
                emit TextStrike(doc->CurrTextStrikePos, doc->CurrTextStrikeWidth);
2247 fschmid 1071
                emit TextShadow(doc->CurrTextShadowX, doc->CurrTextShadowY);
68 Franz 1072
                emit TextFarben(doc->CurrTextStroke, doc->CurrTextFill, doc->CurrTextStrokeSh, doc->CurrTextFillSh);
1073
                emit TextIFont(doc->CurrFont);
272 Franz 1074
                emit TextISize(doc->CurrFontSize);
1957 cbradney 1075
                emit TextUSval(currItem->itemText.at(ChPos)->cextra);
272 Franz 1076
                emit TextStil(doc->CurrentStyle);
68 Franz 1077
                emit TextScale(doc->CurrTextScale);
2230 fschmid 1078
                emit TextScaleV(doc->CurrTextScaleV);
2234 fschmid 1079
                emit TextBase(doc->CurrTextBase);
2257 fschmid 1080
                emit TextOutline(doc->CurrTextOutline);
272 Franz 1081
        }
3 paul 1082
}
1083
 
4026 craig 1084
void ScribusMainWindow::wheelEvent(QWheelEvent *w)
3 paul 1085
{
1086
        if (HaveDoc)
239 Franz 1087
        {
2871 cbradney 1088
                int wheelVal=prefsManager->mouseWheelValue();
276 Franz 1089
                if ((w->orientation() != Qt::Vertical) || ( w->state() & ShiftButton ))
3 paul 1090
                {
239 Franz 1091
                        if (w->delta() < 0)
2871 cbradney 1092
                                view->scrollBy(wheelVal, 0);
239 Franz 1093
                        else
2871 cbradney 1094
                                view->scrollBy(-wheelVal, 0);
239 Franz 1095
                }
3 paul 1096
                else
239 Franz 1097
                {
1098
                        if (w->delta() < 0)
2871 cbradney 1099
                                view->scrollBy(0, wheelVal);
239 Franz 1100
                        else
2871 cbradney 1101
                                view->scrollBy(0, -wheelVal);
239 Franz 1102
                }
3 paul 1103
                w->accept();
239 Franz 1104
        }
3 paul 1105
}
1106
 
1485 tsoots 1107
//Special keys assigned to actions are stolen by the action and not passed to
1445 cbradney 1108
//keyPressEvent so process them here.
4026 craig 1109
void ScribusMainWindow::specialActionKeyEvent(QString actionName, int unicodevalue)
1445 cbradney 1110
{
4659 cbradney 1111
        if (HaveDoc)
1445 cbradney 1112
        {
2603 cbradney 1113
                if (doc->appMode==modeEdit)
1445 cbradney 1114
                {
3934 cbradney 1115
                        if (doc->selection->count() == 1)
1445 cbradney 1116
                        {
1117
                                struct ScText *hg = new ScText;
3934 cbradney 1118
                                PageItem *currItem = doc->selection->itemAt(0);
4513 cbradney 1119
                                if (currItem!=NULL)
1445 cbradney 1120
                                {
4659 cbradney 1121
                                        if (unicodevalue!=-1)
1122
                                        {
1123
                                                if (currItem->HasSel && currItem->itemType()==PageItem::TextFrame)
1124
                                                        currItem->asTextFrame()->deleteSelectedTextFromFrame();
1125
 
1126
                                                hg->ch = QString(QChar(unicodevalue));
1127
                                                doc->setScTextDefaultsFromDoc(hg);
1128
                                                hg->cselect = false;
1129
                                                hg->cextra = 0;
1130
                                                hg->xp = 0;
1131
                                                hg->yp = 0;
1132
                                                hg->PRot = 0;
1133
                                                hg->PtransX = 0;
1134
                                                hg->PtransY = 0;
1135
                                                hg->cembedded = 0;
1136
                                                currItem->itemText.insert(currItem->CPos, hg);
1137
                                                currItem->CPos += 1;
1138
                                                currItem->Tinput = true;
1139
                                                view->RefreshItem(currItem);
1140
                                        }
1141
                                        else if (actionName=="unicodeSmartHyphen") //ignore the char as we use an attribute if the text item, for now.
1142
                                        {
1143
                                                currItem->itemText.at(QMAX(currItem->CPos-1,0))->cstyle ^= 128;
1144
                                                currItem->Tinput = true;
1145
                                                view->RefreshItem(currItem);
1146
                                        }
1445 cbradney 1147
                                }
1148
                        }
1149
                }
1150
        }
1151
}
1152
 
4026 craig 1153
bool ScribusMainWindow::eventFilter( QObject */*o*/, QEvent *e )
1493 cbradney 1154
{
1525 cbradney 1155
        bool retVal;
1493 cbradney 1156
        if ( e->type() == QEvent::KeyPress ) {
1157
                QKeyEvent *k = (QKeyEvent *)e;
2357 cbradney 1158
                int keyMod=0;
1159
                if (k->state() & ShiftButton)
1160
                        keyMod |= SHIFT;
1161
                if (k->state() & ControlButton)
1162
                        keyMod |= CTRL;
1163
                if (k->state() & AltButton)
1164
                        keyMod |= ALT;
2369 cbradney 1165
 
1493 cbradney 1166
                QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
2878 cbradney 1167
                if (QString(currKeySeq).isNull())
2681 cbradney 1168
                        return false;
1525 cbradney 1169
                retVal=true;
2357 cbradney 1170
                //Palette actions
1493 cbradney 1171
                if (currKeySeq == scrActions["specialToggleAllPalettes"]->accel())
1172
                        scrActions["specialToggleAllPalettes"]->activate();
1173
                else
1174
                if (currKeySeq == scrActions["toolsProperties"]->accel())
1175
                        scrActions["toolsProperties"]->toggle();
1176
                else
1177
                if (currKeySeq == scrActions["toolsOutline"]->accel())
1178
                        scrActions["toolsOutline"]->toggle();
1179
                else
1180
                if (currKeySeq == scrActions["toolsScrapbook"]->accel())
1181
                        scrActions["toolsScrapbook"]->toggle();
1182
                else
1183
                if (currKeySeq == scrActions["toolsLayers"]->accel())
1184
                        scrActions["toolsLayers"]->toggle();
1185
                else
1186
                if (currKeySeq == scrActions["toolsPages"]->accel())
1187
                        scrActions["toolsPages"]->toggle();
1188
                else
1189
                if (currKeySeq == scrActions["toolsBookmarks"]->accel())
1190
                        scrActions["toolsBookmarks"]->toggle();
1191
                else
1192
                if (currKeySeq == scrActions["toolsActionHistory"]->accel())
1193
                        scrActions["toolsActionHistory"]->toggle();
1194
                else
1195
                if (currKeySeq == scrActions["toolsPreflightVerifier"]->accel())
1196
                        scrActions["toolsPreflightVerifier"]->toggle();
1525 cbradney 1197
                else
2355 cbradney 1198
                if (currKeySeq == scrActions["toolsAlignDistribute"]->accel())
1199
                        scrActions["toolsAlignDistribute"]->toggle();
1200
                else
2357 cbradney 1201
                //Undo actions
1202
                if (currKeySeq == scrActions["editUndoAction"]->accel() && scrActions["editUndoAction"]->isEnabled())
1203
                        scrActions["editUndoAction"]->activate();
1204
                else
1205
                if (currKeySeq == scrActions["editRedoAction"]->accel() && scrActions["editRedoAction"]->isEnabled())
1206
                        scrActions["editRedoAction"]->activate();
1207
                else
1208
                //Other actions
1565 cbradney 1209
                if (currKeySeq == scrActions["fileQuit"]->accel())
1210
                        scrActions["fileQuit"]->activate();
2143 subik 1211
                else
3412 cbradney 1212
                //Zoom actions
1213
                if (currKeySeq == scrActions["toolsZoomIn"]->accel())
1214
                        scrActions["toolsZoomIn"]->activate();
1215
                else
1216
                if (currKeySeq == scrActions["toolsZoomOut"]->accel())
1217
                        scrActions["toolsZoomOut"]->activate();
1218
                else
1525 cbradney 1219
                        retVal=false;
1493 cbradney 1220
        }
1525 cbradney 1221
        else
1222
                retVal=false;
1493 cbradney 1223
        //Return false to pass event to object
1224
        return retVal;
1225
}
1226
 
4026 craig 1227
void ScribusMainWindow::keyPressEvent(QKeyEvent *k)
3 paul 1228
{
146 Franz 1229
        QWidgetList windows;
237 Franz 1230
        QWidget* w = NULL;
3843 cbradney 1231
        //struct ScText *hg;
3 paul 1232
        int kk = k->key();
3843 cbradney 1233
        //int as = k->ascii();
1234
        //double altx, alty;
3 paul 1235
        QString uc = k->text();
1236
        QString cr, Tcha, Twort;
3843 cbradney 1237
        //uint Tcoun;
1238
        //int len, pos, c;
92 Franz 1239
        if (keyrep)
1240
                return;
1241
        keyrep = true;
3829 cbradney 1242
        int KeyMod;
3 paul 1243
        switch (k->state())
272 Franz 1244
        {
1245
        case ShiftButton:
1554 cbradney 1246
                KeyMod = SHIFT;
272 Franz 1247
                break;
1248
        case AltButton:
1554 cbradney 1249
                KeyMod = ALT;
272 Franz 1250
                break;
1251
        case ControlButton:
1554 cbradney 1252
                KeyMod = CTRL;
272 Franz 1253
                break;
1254
        default:
1255
                KeyMod = 0;
1256
                break;
1257
        }
3829 cbradney 1258
        //User presses escape and we have a doc open, and we have an item selected
292 Franz 1259
        if ((kk == Key_Escape) && (HaveDoc))
1260
        {
1261
                keyrep = false;
1957 cbradney 1262
                PageItem *currItem;
3934 cbradney 1263
                if (doc->selection->count() != 0)
855 fschmid 1264
                {
3934 cbradney 1265
                        currItem = doc->selection->itemAt(0);
1065 cbradney 1266
                        switch (doc->appMode)
855 fschmid 1267
                        {
2603 cbradney 1268
                                case modeNormal:
1957 cbradney 1269
                                        currItem->Sizing = false;
855 fschmid 1270
                                        if (doc->SubMode != -1)
1271
                                        {
1272
                                                view->Deselect(false);
3727 cbradney 1273
                                                doc->Items->remove(currItem->ItemNr);
855 fschmid 1274
                                        }
1275
                                        break;
2603 cbradney 1276
                                case modeLinkFrames:
1277
                                case modeUnlinkFrames:
1278
                                case modeEdit:
1279
                                case modeRotation:
1827 fschmid 1280
                                                view->Deselect(false);
2603 cbradney 1281
                                case modePanning:
855 fschmid 1282
                                        break;
2603 cbradney 1283
                                case modeDrawBezierLine:
1957 cbradney 1284
                                        currItem->PoLine.resize(currItem->PoLine.size()-2);
1285
                                        if (currItem->PoLine.size() < 4)
855 fschmid 1286
                                        {
1287
                                                view->Deselect(false);
3727 cbradney 1288
                                                doc->Items->remove(currItem->ItemNr);
855 fschmid 1289
                                        }
1290
                                        else
1291
                                        {
1957 cbradney 1292
                                                view->SizeItem(currItem->PoLine.WidthHeight().x(), currItem->PoLine.WidthHeight().y(), currItem->ItemNr, false, false);
4580 cbradney 1293
                                                currItem->SetPolyClip(qRound(QMAX(currItem->lineWidth() / 2.0, 1)));
1957 cbradney 1294
                                                view->AdjustItemSize(currItem);
1295
                                                currItem->ContourLine = currItem->PoLine.copy();
1296
                                                currItem->ClipEdited = true;
1297
                                                currItem->FrameType = 3;
855 fschmid 1298
                                                slotDocCh();
1299
                                        }
1300
                                        view->FirstPoly = true;
1301
                                        break;
1302
                                default:
1303
                                        view->Deselect(false);
3727 cbradney 1304
                                        doc->Items->remove(currItem->ItemNr);
855 fschmid 1305
                                        break;
1306
                        }
1307
                }
1308
                view->Mpressed = false;
1309
                doc->DragP = false;
1310
                doc->leaveDrag = false;
4663 cbradney 1311
                view->operItemMoving = false;
1312
                view->operItemResizing = false;
855 fschmid 1313
                view->MidButt = false;
1314
                doc->SubMode = -1;
1827 fschmid 1315
                doc->ElemToLink = NULL;
292 Franz 1316
                NoFrameEdit();
1317
                slotSelect();
1318
                return;
1319
        }
232 Franz 1320
        ButtonState buttonState = k->state();
3829 cbradney 1321
        /**If we have a doc and we are not changing the page or zoom level in the status bar */
3615 cbradney 1322
        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
272 Franz 1323
        {
3829 cbradney 1324
                /**
1325
                 * With no item selected we can:
1326
                 * - With space, get into panning mode (modePanning)
1327
                 * - With PageUp, scroll up
1328
                 * - With PageDown, scroll down
1329
                 * - With Tab, change active document windowActivated
1330
                 */
3873 subik 1331
 
3934 cbradney 1332
                if ((doc->appMode != modeEdit) && (doc->selection->count() == 0))
272 Franz 1333
                {
1334
                        switch (kk)
146 Franz 1335
                        {
272 Franz 1336
                        case Key_Space:
1337
                                keyrep = false;
2603 cbradney 1338
                                if (doc->appMode == modePanning)
1339
                                        setAppMode(modeNormal);
272 Franz 1340
                                else
2603 cbradney 1341
                                        setAppMode(modePanning);
272 Franz 1342
                                return;
1343
                                break;
1344
                        case Key_Prior:
2871 cbradney 1345
                                view->scrollBy(0, -prefsManager->mouseWheelValue());
272 Franz 1346
                                keyrep = false;
1347
                                return;
1348
                                break;
1349
                        case Key_Next:
2871 cbradney 1350
                                view->scrollBy(0, prefsManager->mouseWheelValue());
272 Franz 1351
                                keyrep = false;
1352
                                return;
1353
                                break;
1354
                        case Key_Tab:
1355
                                keyrep = false;
1356
                                windows = wsp->windowList();
1357
                                if (windows.count() > 1)
1358
                                {
1359
                                        for (int i = 0; i < static_cast<int>(windows.count()); ++i)
250 Franz 1360
                                        {
272 Franz 1361
                                                if (wsp->activeWindow() == windows.at(i))
1362
                                                {
1363
                                                        if (i == static_cast<int>(windows.count()-1))
1364
                                                                w = windows.at(0);
1365
                                                        else
1366
                                                                w = windows.at(i+1);
1367
                                                        break;
1368
                                                }
250 Franz 1369
                                        }
1545 cbradney 1370
                                        doc->OpenNodes = outlinePalette->buildReopenVals();
1371
                                        docCheckerPalette->clearErrorList();
272 Franz 1372
                                        if ( w )
1373
                                                w->showNormal();
1374
                                        newActWin(w);
1375
                                }
1376
                                return;
1377
                                break;
1378
                        }
1379
                }
3873 subik 1380
                /** Now if we have an item selected
3829 cbradney 1381
                 * - In normal mode we can:
1382
                 * -- Use backspace or delete to delete the item
1383
                 * -- Use PageUp to raise an item
1384
                 * -- Use PageDown to lower an item
4637 cbradney 1385
                 * -- Use the arrow keys to move an item or group around:
1386
                                With no meta, by 1.0 unit
1387
                                Ctrl Shift, by 0.1 units
1388
                                Shift by 10.0 units
1389
                                Ctrl Alt Shift 0.01 units
1390
                 * -- Use the arrow keys to resize an item:
1391
                                Alt right arrow, move right side outwards (expand)
1392
                                Alt left arrow, move left side outwards (expand)
1393
                                Alt Shift right arrow, move left side inwards (shrink)
1394
                                Alt Shift left arrow, move right side inwards (shrink)
3829 cbradney 1395
                 */
3934 cbradney 1396
                if (doc->selection->count() != 0)
272 Franz 1397
                {
3829 cbradney 1398
                        double moveBy=1.0;
4623 cbradney 1399
                        if ((buttonState & ShiftButton) && !(buttonState & ControlButton))
3829 cbradney 1400
                                moveBy=10.0;
4636 cbradney 1401
                        else if ((buttonState & ShiftButton) && (buttonState & ControlButton) && !(buttonState & AltButton))
3829 cbradney 1402
                                moveBy=0.1;
4636 cbradney 1403
                        else if ((buttonState & ShiftButton) && (buttonState & ControlButton) && (buttonState & AltButton))
1404
                                moveBy=0.01;
4623 cbradney 1405
                        moveBy/=doc->unitRatio();//Lets allow movement by the current doc ratio, not only points
4636 cbradney 1406
                        bool resizing=((buttonState & AltButton) && !(buttonState & ControlButton));
4623 cbradney 1407
                        bool resizingsmaller=(resizing && (buttonState & ShiftButton));
1408
                        double resizeBy=1.0;
4637 cbradney 1409
                        //CB with control locked out due to the requirement of moveby of 0.01, we cannot support
1410
                        //resizeby 10 units unless we move to supporting modifier keys that most people dont have.
1411
                        //if (buttonState & ControlButton)
1412
                        //      resizeBy*=10.0;
4623 cbradney 1413
                        resizeBy/=doc->unitRatio();
1414
                        if (resizingsmaller)
1415
                                resizeBy*=-1.0;
1416
 
3873 subik 1417
 
3934 cbradney 1418
                        PageItem *currItem = doc->selection->itemAt(0);
1065 cbradney 1419
                        switch (doc->appMode)
272 Franz 1420
                        {
2603 cbradney 1421
                        case modeNormal:
272 Franz 1422
                                switch (kk)
1423
                                {
360 Franz 1424
                                case Key_Backspace:
272 Franz 1425
                                case Key_Delete:
1426
                                        if (!doc->EditClip)
2148 fschmid 1427
                                        {
997 fschmid 1428
                                                view->DeleteItem();
2148 fschmid 1429
                                                slotDocCh();
1430
                                        }
272 Franz 1431
                                        break;
360 Franz 1432
                                case Key_Prior:
1957 cbradney 1433
                                        if (!currItem->locked())
2148 fschmid 1434
                                        {
456 fschmid 1435
                                                view->RaiseItem();
2148 fschmid 1436
                                                slotDocCh();
1437
                                        }
360 Franz 1438
                                        break;
1439
                                case Key_Next:
1957 cbradney 1440
                                        if (!currItem->locked())
2148 fschmid 1441
                                        {
456 fschmid 1442
                                                view->LowerItem();
2148 fschmid 1443
                                                slotDocCh();
1444
                                        }
360 Franz 1445
                                        break;
272 Franz 1446
                                case Key_Left:
1957 cbradney 1447
                                        if (!currItem->locked())
272 Franz 1448
                                        {
4623 cbradney 1449
                                                if (!resizing)
2664 fschmid 1450
                                                {
4623 cbradney 1451
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1452
                                                        {
1453
                                                                FPoint np;
1454
                                                                if (view->EditContour)
1455
                                                                        np = currItem->ContourLine.point(view->ClRe);
1456
                                                                else
1457
                                                                        np = currItem->PoLine.point(view->ClRe);
1458
                                                                np = np - FPoint(moveBy, 0);
1459
                                                                view->MoveClipPoint(currItem, np);
1460
                                                        }
2664 fschmid 1461
                                                        else
4623 cbradney 1462
                                                        {
1463
                                                                view->moveGroup(-moveBy, 0);
1464
                                                        }
2664 fschmid 1465
                                                }
272 Franz 1466
                                                else
2664 fschmid 1467
                                                {
4633 fschmid 1468
                                                        if (resizingsmaller)
1469
                                                        {
1470
                                                                currItem->Sizing = false;
1471
                                                                view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1472
                                                        }
1473
                                                        else
1474
                                                        {
1475
                                                                ScMW->view->MoveItem(-resizeBy, 0, currItem, false);
1476
                                                                currItem->Sizing = false;
1477
                                                                view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1478
                                                        }
2664 fschmid 1479
                                                }
2148 fschmid 1480
                                                slotDocCh();
272 Franz 1481
                                        }
1482
                                        break;
1483
                                case Key_Right:
1957 cbradney 1484
                                        if (!currItem->locked())
272 Franz 1485
                                        {
4623 cbradney 1486
                                                if (!resizing)
2664 fschmid 1487
                                                {
4623 cbradney 1488
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1489
                                                        {
1490
                                                                FPoint np;
1491
                                                                if (view->EditContour)
1492
                                                                        np = currItem->ContourLine.point(view->ClRe);
1493
                                                                else
1494
                                                                        np = currItem->PoLine.point(view->ClRe);
1495
                                                                np = np + FPoint(moveBy, 0);
1496
                                                                view->MoveClipPoint(currItem, np);
1497
                                                        }
2664 fschmid 1498
                                                        else
4623 cbradney 1499
                                                        {
1500
                                                                view->moveGroup(moveBy, 0);
1501
                                                        }
2664 fschmid 1502
                                                }
272 Franz 1503
                                                else
2664 fschmid 1504
                                                {
4633 fschmid 1505
                                                        if (resizingsmaller)
1506
                                                        {
1507
                                                                ScMW->view->MoveItem(-resizeBy, 0, currItem, false);
1508
                                                                currItem->Sizing = false;
1509
                                                                view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1510
                                                        }
1511
                                                        else
1512
                                                        {
1513
                                                                currItem->Sizing = false;
1514
                                                                view->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
1515
                                                        }
2664 fschmid 1516
                                                }
2148 fschmid 1517
                                                slotDocCh();
272 Franz 1518
                                        }
1519
                                        break;
1520
                                case Key_Up:
1957 cbradney 1521
                                        if (!currItem->locked())
272 Franz 1522
                                        {
4623 cbradney 1523
                                                if (!resizing)
2664 fschmid 1524
                                                {
4623 cbradney 1525
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1526
                                                        {
1527
                                                                FPoint np;
1528
                                                                if (view->EditContour)
1529
                                                                        np = currItem->ContourLine.point(view->ClRe);
1530
                                                                else
1531
                                                                        np = currItem->PoLine.point(view->ClRe);
1532
                                                                np = np - FPoint(0, moveBy);
1533
                                                                view->MoveClipPoint(currItem, np);
1534
                                                        }
2664 fschmid 1535
                                                        else
4623 cbradney 1536
                                                        {
1537
                                                                view->moveGroup(0, -moveBy);
1538
                                                        }
2664 fschmid 1539
                                                }
272 Franz 1540
                                                else
2664 fschmid 1541
                                                {
4633 fschmid 1542
                                                        if (resizingsmaller)
1543
                                                        {
1544
                                                                currItem->Sizing = false;
1545
                                                                view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1546
                                                        }
1547
                                                        else
1548
                                                        {
1549
                                                                ScMW->view->MoveItem(0, -resizeBy, currItem, false);
1550
                                                                currItem->Sizing = false;
1551
                                                                view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1552
                                                        }
2664 fschmid 1553
                                                }
2148 fschmid 1554
                                                slotDocCh();
272 Franz 1555
                                        }
1556
                                        break;
1557
                                case Key_Down:
1957 cbradney 1558
                                        if (!currItem->locked())
272 Franz 1559
                                        {
4623 cbradney 1560
                                                if (!resizing)
2664 fschmid 1561
                                                {
4623 cbradney 1562
                                                        if ((doc->EditClip) && (view->ClRe != -1))
1563
                                                        {
1564
                                                                FPoint np;
1565
                                                                if (view->EditContour)
1566
                                                                        np = currItem->ContourLine.point(view->ClRe);
1567
                                                                else
1568
                                                                        np = currItem->PoLine.point(view->ClRe);
1569
                                                                np = np + FPoint(0, moveBy);
1570
                                                                view->MoveClipPoint(currItem, np);
1571
                                                        }
2664 fschmid 1572
                                                        else
4623 cbradney 1573
                                                        {
1574
                                                                view->moveGroup(0, moveBy);
1575
                                                        }
2664 fschmid 1576
                                                }
272 Franz 1577
                                                else
2664 fschmid 1578
                                                {
4633 fschmid 1579
                                                        if (resizingsmaller)
1580
                                                        {
1581
                                                                ScMW->view->MoveItem(0, -resizeBy, currItem, false);
1582
                                                                currItem->Sizing = false;
1583
                                                                view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1584
                                                        }
1585
                                                        else
1586
                                                        {
1587
                                                                currItem->Sizing = false;
1588
                                                                view->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
1589
                                                        }
2664 fschmid 1590
                                                }
2148 fschmid 1591
                                                slotDocCh();
272 Franz 1592
                                        }
1593
                                        break;
1594
                                default:
1595
                                        break;
1596
                                }
1597
                                break;
2603 cbradney 1598
                        case modeEdit:
3783 cbradney 1599
                                if (currItem->asImageFrame() && !currItem->locked())
1298 fschmid 1600
                                {
4593 cbradney 1601
                                        double dX=0.0,dY=0.0;
1298 fschmid 1602
                                        switch (kk)
1603
                                        {
1604
                                                case Key_Left:
4593 cbradney 1605
                                                        dX=-moveBy;
1298 fschmid 1606
                                                        break;
1607
                                                case Key_Right:
4593 cbradney 1608
                                                        dX=moveBy;
1298 fschmid 1609
                                                        break;
1610
                                                case Key_Up:
4593 cbradney 1611
                                                        dY=-moveBy;
1298 fschmid 1612
                                                        break;
1613
                                                case Key_Down:
4593 cbradney 1614
                                                        dY=moveBy;
1298 fschmid 1615
                                                        break;
1616
                                        }
4593 cbradney 1617
                                        if (dX!=0.0 || dY!=0.0)
1618
                                        {
1619
                                                //view->MoveItemI(currItem, dX, dY, true);
1620
                                                currItem->moveImageInFrame(dX, dY);
1621
                                                view->updateContents(currItem->getRedrawBounding(view->scale()));
1622
                                        }
1298 fschmid 1623
                                }
3829 cbradney 1624
                                view->oldCp = currItem->CPos;
1957 cbradney 1625
                                if (currItem->itemType() == PageItem::TextFrame)
272 Franz 1626
                                {
3829 cbradney 1627
                                        bool kr=keyrep;
1628
                                        currItem->handleModeEditKey(k, keyrep);
1629
                                        keyrep=kr;
272 Franz 1630
                                }
1631
                                slotDocCh(false);
1632
                                break;
1633
                        }
1634
                }
1635
        }
1204 tsoots 1636
        switch(kk)
1637
        {
1638
                case Key_Left:
1639
                case Key_Right:
1640
                case Key_Up:
1641
                case Key_Down:
1642
                        _arrowKeyDown = true;
1643
        }
92 Franz 1644
        keyrep = false;
3 paul 1645
}
1646
 
4026 craig 1647
void ScribusMainWindow::keyReleaseEvent(QKeyEvent *k)
1204 tsoots 1648
{
4105 cbradney 1649
        if (k->state() & ControlButton)
1650
        {
4212 fschmid 1651
                if (HaveDoc)
1652
                {
1653
                        if ((doc->appMode == modePanning) && (k->state() & Qt::RightButton))
1654
                                setAppMode(modeNormal);
1655
                }
4105 cbradney 1656
        }
1204 tsoots 1657
        if (k->isAutoRepeat() || !_arrowKeyDown)
1658
                return;
1659
        switch(k->key())
1660
        {
1661
                case Key_Left:
1662
                case Key_Right:
1663
                case Key_Up:
1664
                case Key_Down:
1665
                        _arrowKeyDown = false;
3615 cbradney 1666
                        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
2951 fschmid 1667
                        {
3934 cbradney 1668
                                uint docSelectionCount=doc->selection->count();
1669
                                if ((docSelectionCount != 0) && (doc->appMode == modeNormal) && (doc->EditClip) && (view->ClRe != -1))
2951 fschmid 1670
                                        view->updateContents();
3934 cbradney 1671
                                for (uint i = 0; i < docSelectionCount; ++i)
1672
                                        doc->selection->itemAt(i)->checkChanges(true);
1673
                                if (docSelectionCount > 1 && view->groupTransactionStarted())
2951 fschmid 1674
                                        undoManager->commit();
1675
                        }
4105 cbradney 1676
                        break;
1204 tsoots 1677
        }
1678
}
1679
 
4026 craig 1680
void ScribusMainWindow::closeEvent(QCloseEvent *ce)
3 paul 1681
{
1682
        QWidgetList windows = wsp->windowList();
1683
        ScribusWin* tw;
3575 cbradney 1684
        disconnect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
3 paul 1685
        if (!windows.isEmpty())
272 Franz 1686
        {
135 Franz 1687
                singleClose = true;
3571 cbradney 1688
                uint windowCount=windows.count();
1689
                for ( uint i = 0; i < windowCount; ++i )
272 Franz 1690
                {
3 paul 1691
                        newActWin(windows.at(i));
272 Franz 1692
                        tw = ActWin;
3 paul 1693
                        ActWin->close();
1694
                        if (tw == ActWin)
272 Franz 1695
                        {
3 paul 1696
                                ce->ignore();
135 Franz 1697
                                singleClose = false;
3575 cbradney 1698
                                connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
3 paul 1699
                                return;
1700
                        }
272 Franz 1701
                }
1702
        }
3179 cbradney 1703
        propertiesPalette->hide();
1704
        outlinePalette->hide();
1705
        scrapbookPalette->hide();
1706
        bookmarkPalette->hide();
1707
        layerPalette->hide();
1708
        pagePalette->hide();
1709
        measurementPalette->hide();
1710
        docCheckerPalette->hide();
3923 tsoots 1711
        undoPalette->hide();
3924 tsoots 1712
        alignDistributePalette->hide();
3201 subik 1713
 
3294 craig 1714
        // Clean up plugins, THEN save prefs to disk
1715
        pluginManager->cleanupPlugins();
3170 craig 1716
        if (!emergencyActivated)
2859 cbradney 1717
                prefsManager->SavePrefs();
3170 craig 1718
        UndoManager::deleteInstance();
1719
        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1720
        exit(0);
3 paul 1721
}
1722
 
1723
/////////////////////////////////////////////////////////////////////
1724
// SLOT IMPLEMENTATION
1725
/////////////////////////////////////////////////////////////////////
1726
 
1485 tsoots 1727
 
4026 craig 1728
bool ScribusMainWindow::arrowKeyDown()
1204 tsoots 1729
{
1730
        return _arrowKeyDown;
1731
}
1732
 
4026 craig 1733
void ScribusMainWindow::startUpDialog()
2833 fschmid 1734
{
2856 cbradney 1735
        PrefsContext* docContext = prefsManager->prefsFile->getContext("docdirs", false);
2834 cbradney 1736
        NewDoc* dia = new NewDoc(this, true);
2833 fschmid 1737
        if (dia->exec())
1738
        {
1739
                if (dia->tabSelected == 0)
1740
                {
2901 fschmid 1741
                        int facingPages = dia->choosenLayout;
3016 fschmid 1742
                        int firstPage = dia->docLayout->firstPage->currentItem();
4638 subik 1743
                        double topMargin = dia->GroupRand->top();
1744
                        double bottomMargin = dia->GroupRand->bottom();
1745
                        double leftMargin = dia->GroupRand->left();
1746
                        double rightMargin = dia->GroupRand->right();
2901 fschmid 1747
                        double columnDistance = dia->Dist;
4555 cbradney 1748
                        double pageWidth = dia->pageWidth;
1749
                        double pageHeight = dia->pageHeight;
2901 fschmid 1750
                        double numberCols = dia->SpinBox10->value();
1751
                        bool autoframes = dia->AutoFrame->isChecked();
2833 fschmid 1752
                        int orientation = dia->Orient;
3778 cbradney 1753
                        int pageCount=dia->PgNum->value();
4555 cbradney 1754
                        PageSize *ps2 = new PageSize(dia->pageSizeComboBox->currentText());
2833 fschmid 1755
                        QString pagesize = ps2->getPageName();
4559 cbradney 1756
                        doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->ComboBox3->currentItem(), firstPage, orientation, 1, pagesize, pageCount);
3016 fschmid 1757
                        doc->pageSets[facingPages].FirstPage = firstPage;
2833 fschmid 1758
                        delete ps2;
3695 cbradney 1759
                        HaveNewDoc();
2833 fschmid 1760
                }
1761
                else
1762
                {
1763
                        if (dia->tabSelected == 1)
1764
                        {
3691 cbradney 1765
                                QString fileName(dia->fileDialog->selectedFile());
2877 cbradney 1766
                                if (!fileName.isEmpty())
2833 fschmid 1767
                                {
1768
                                        docContext->set("docsopen", fileName.left(fileName.findRev("/")));
1769
                                        loadDoc(fileName);
1770
                                }
1771
                        }
2842 fschmid 1772
                        else
1773
                        {
3691 cbradney 1774
                                QString fileName(dia->recentDocList->currentText());
2877 cbradney 1775
                                if (!fileName.isEmpty())
2842 fschmid 1776
                                        loadRecent(fileName);
1777
                        }
2833 fschmid 1778
                }
1779
        }
2871 cbradney 1780
        prefsManager->setShowStartupDialog(!dia->startUpDialog->isChecked());
2833 fschmid 1781
        delete dia;
1782
        mainWindowStatusLabel->setText( tr("Ready"));
1783
}
1784
 
4026 craig 1785
bool ScribusMainWindow::slotFileNew()
3 paul 1786
{
809 cbradney 1787
        bool retVal;
2834 cbradney 1788
        NewDoc* dia = new NewDoc(this);
3 paul 1789
        if (dia->exec())
272 Franz 1790
        {
2901 fschmid 1791
                int facingPages = dia->choosenLayout;
3016 fschmid 1792
                int firstPage = dia->docLayout->firstPage->currentItem();
4638 subik 1793
                double topMargin = dia->GroupRand->top();
1794
                double bottomMargin = dia->GroupRand->bottom();
1795
                double leftMargin = dia->GroupRand->left();
1796
                double rightMargin = dia->GroupRand->right();
2901 fschmid 1797
                double columnDistance = dia->Dist;
4555 cbradney 1798
                double pageWidth = dia->pageWidth;
1799
                double pageHeight = dia->pageHeight;
2901 fschmid 1800
                double numberCols = dia->SpinBox10->value();
1801
                bool autoframes = dia->AutoFrame->isChecked();
809 cbradney 1802
                int orientation = dia->Orient;
3778 cbradney 1803
                int pageCount=dia->PgNum->value();
4555 cbradney 1804
                PageSize *ps2 = new PageSize(dia->pageSizeComboBox->currentText());
2658 fschmid 1805
                QString pagesize = ps2->getPageName();
4559 cbradney 1806
                retVal = doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->ComboBox3->currentItem(), firstPage, orientation, 1, pagesize, pageCount);
3016 fschmid 1807
                doc->pageSets[facingPages].FirstPage = firstPage;
2433 cbradney 1808
                mainWindowStatusLabel->setText( tr("Ready"));
2658 fschmid 1809
                delete ps2;
3695 cbradney 1810
                HaveNewDoc();
272 Franz 1811
        }
3 paul 1812
        else
809 cbradney 1813
                retVal = false;
3 paul 1814
        delete dia;
809 cbradney 1815
        return retVal;
3 paul 1816
}
1817
 
4026 craig 1818
bool ScribusMainWindow::doFileNew(double width, double h, double tpr, double lr, double rr, double br, double ab, double sp,
3778 cbradney 1819
                           bool atf, int fp, int einh, int firstleft, int Ori, int SNr, const QString& defaultPageSize, int pageCount)
3 paul 1820
{
1821
        QString cc;
91 Franz 1822
        if (HaveDoc)
4049 cbradney 1823
        {
1545 cbradney 1824
                doc->OpenNodes = outlinePalette->buildReopenVals();
4049 cbradney 1825
        }
2834 cbradney 1826
        doc = new ScribusDoc();
2891 cbradney 1827
        doc->setLoading(true);
1828
        doc->setup(einh, fp, firstleft, Ori, SNr, defaultPageSize, doc->DocName+cc.setNum(DocNr));
3 paul 1829
        HaveDoc++;
1830
        DocNr++;
3695 cbradney 1831
        if (CMSavail && doc->CMSSettings.CMSinUse)
1832
                recalcColors();
1833
        doc->setPage(width, h, tpr, lr, rr, br, sp, ab, atf, fp);
3873 subik 1834
        doc->setMasterPageMode(false);
3695 cbradney 1835
        doc->addMasterPage(0, "Normal");
4672 cbradney 1836
        int createCount=QMAX(pageCount,1);
3778 cbradney 1837
        for (int i = 0; i < createCount; ++i)
3852 cbradney 1838
                doc->addPage(i, "Normal", true);
3757 cbradney 1839
        doc->addSection();
3793 cbradney 1840
        doc->setFirstSectionFromFirstPageNumber();
3695 cbradney 1841
        doc->setModified(false);
1842
        doc->setLoading(false);
3724 cbradney 1843
        doc->currentPage = doc->Pages->at(0);
3695 cbradney 1844
        doc->OpenNodes.clear();
3873 subik 1845
 
3695 cbradney 1846
        //<<View and window code
3 paul 1847
        ScribusWin* w = new ScribusWin(wsp, doc);
1822 cbradney 1848
        if (view!=NULL)
2626 cbradney 1849
        {
2026 cbradney 1850
                actionManager->disconnectNewViewActions();
2626 cbradney 1851
                disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
1852
        }
2834 cbradney 1853
        view = new ScribusView(w, doc);
2873 cbradney 1854
        view->setScale(prefsManager->displayScale());
2026 cbradney 1855
        actionManager->connectNewViewActions(view);
2355 cbradney 1856
        alignDistributePalette->setView(view);
3692 cbradney 1857
        docCheckerPalette->clearErrorList();
3 paul 1858
        w->setView(view);
1859
        ActWin = w;
59 Franz 1860
        doc->WinHan = w;
3 paul 1861
        w->setCentralWidget(view);
3757 cbradney 1862
        view->reformPages(true);
3692 cbradney 1863
        //>>
3873 subik 1864
 
3692 cbradney 1865
        connect(undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
1866