Subversion Repositories Scribus

Rev

Rev 19364 | Rev 19424 | 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
 
8591 cbradney 24
#include <QApplication>
10862 cbradney 25
#include <QByteArray>
26
#include <QCloseEvent>
27
#include <QColor>
10223 cbradney 28
#include <QColorDialog>
29
#include <QCursor>
8635 cbradney 30
#include <QDesktopWidget>
10862 cbradney 31
#include <QDragEnterEvent>
8501 cbradney 32
#include <QDropEvent>
33
#include <QEvent>
10862 cbradney 34
#include <QEventLoop>
35
#include <QFrame>
36
#include <QIcon>
37
#include <QInputDialog>
8501 cbradney 38
#include <QKeyEvent>
10862 cbradney 39
#include <QKeySequence>
40
#include <QLabel>
41
#include <QList>
42
#include <QLocale>
43
#include <QMouseEvent>
44
#include <QPixmap>
45
#include <QRegExp>
18804 jghali 46
#include <QScopedPointer>
10862 cbradney 47
#include <QStyleFactory>
9853 fschmid 48
#include <QTableWidget>
10862 cbradney 49
#include <QTextCodec>
50
#include <QTranslator>
51
#include <QWheelEvent>
1208 cbradney 52
 
3 paul 53
#include <cstdio>
54
#include <cstdlib>
9082 avox 55
#include <cassert>
2629 craig 56
 
2688 craig 57
#include "scconfig.h"
2629 craig 58
 
59
#ifdef HAVE_DLFCN_H
3 paul 60
#include <dlfcn.h>
2629 craig 61
#endif
62
 
63
#ifdef HAVE_UNISTD_H
135 Franz 64
#include <unistd.h>
2629 craig 65
#endif
66
 
3 paul 67
#include <iostream>
8289 avox 68
#include <sstream>
119 Franz 69
#include <signal.h>
80 Franz 70
#include <string>
1208 cbradney 71
 
1641 cbradney 72
#include "about.h"
3247 craig 73
#include "aboutplugins.h"
10212 cbradney 74
#include "actionmanager.h"
75
#include "aligndistribute.h"
76
#include "annot.h"
77
#include "annota.h"
1806 cbradney 78
#include "applytemplatedialog.h"
10212 cbradney 79
#include "arrowchooser.h"
80
#include "autoform.h"
12092 fschmid 81
#include "basepointwidget.h"
10862 cbradney 82
#include "bookmarkpalette.h"
10532 avox 83
#include "canvasmode.h"
10212 cbradney 84
#include "charselect.h"
85
#include "checkDocument.h"
3 paul 86
#include "cmsprefs.h"
10212 cbradney 87
#include "collect4output.h"
88
#include "colorcombo.h"
151 Franz 89
#include "colorm.h"
10212 cbradney 90
#include "commonstrings.h"
11146 cbradney 91
#include "contextmenu.h"
3540 cbradney 92
#include "cpalette.h"
10212 cbradney 93
#include "customfdialog.h"
94
#include "delpages.h"
10862 cbradney 95
#include "desaxe/digester.h"
96
#include "desaxe/saxXML.h"
97
#include "desaxe/simple_actions.h"
10212 cbradney 98
#include "docinfo.h"
99
#include "docitemattrprefs.h"
100
#include "documentchecker.h"
101
#include "documentinformation.h"
102
#include "effectsdialog.h"
506 fschmid 103
#include "fileloader.h"
1151 fschmid 104
#include "filewatcher.h"
10212 cbradney 105
#include "fontcombo.h"
106
#include "fontprefs.h"
6397 cbradney 107
#include "fpoint.h"
3 paul 108
#include "fpointarray.h"
10212 cbradney 109
#include "gtgettext.h"
3 paul 110
#include "guidemanager.h"
10212 cbradney 111
#include "helpbrowser.h"
838 cbradney 112
#include "hruler.h"
10212 cbradney 113
#include "hyphenator.h"
114
#include "hysettings.h"
115
#include "imageinfodialog.h"
116
#include "insertaframe.h"
117
#include "inspage.h"
118
#include "javadocs.h"
119
#include "langmgr.h"
120
#include "layers.h"
2707 subik 121
#include "loremipsum.h"
11103 cbradney 122
#include "marginwidget.h"
2777 fschmid 123
#include "margindialog.h"
10862 cbradney 124
#include "masterpagepalette.h"
10212 cbradney 125
#include "menumanager.h"
126
#include "mergedoc.h"
127
#include "movepage.h"
128
#include "multipleduplicate.h"
10862 cbradney 129
#include "newfile.h"
10532 avox 130
#include "newtemp.h"
13188 fschmid 131
#include "nfttemplate.h"
132
#include "nftdialog.h"
133
#include "ui_nftdialog.h"
134
#include "nftwidget.h"
10862 cbradney 135
#include "nodeeditpalette.h"
136
#include "outlinepalette.h"
10212 cbradney 137
#include "page.h"
16342 mrdocs 138
#include "pageitem.h"
10212 cbradney 139
#include "pageitem_imageframe.h"
10532 avox 140
#include "pageitem_latexframe.h"
10212 cbradney 141
#include "pageitem_textframe.h"
10862 cbradney 142
#include "pageitemattributes.h"
10212 cbradney 143
#include "pagelayout.h"
10862 cbradney 144
#include "pagepalette.h"
10212 cbradney 145
#include "pageselector.h"
146
#include "pagesize.h"
147
#include "patterndialog.h"
10862 cbradney 148
#include "pdflib.h"
10212 cbradney 149
#include "pdfoptions.h"
150
#include "pdfopts.h"
151
#include "picstatus.h"
152
#include "pluginmanager.h"
10862 cbradney 153
#include "plugins/formatidlist.h"
10212 cbradney 154
#include "polygonwidget.h"
155
#include "prefs.h"
156
#include "prefscontext.h"
157
#include "prefsfile.h"
2834 cbradney 158
#include "prefsmanager.h"
10212 cbradney 159
#include "prefstable.h"
3165 fschmid 160
#include "preview.h"
10863 cbradney 161
#include "printdialog.h"
10862 cbradney 162
#include "propertiespalette.h"
10212 cbradney 163
#include "pslib.h"
164
#include "query.h"
165
#include "reformdoc.h"
11895 fschmid 166
#include "replacecolors.h"
10212 cbradney 167
#include "resourcecollection.h"
168
#include "sccolorengine.h"
10532 avox 169
#include "sccombobox.h"
170
#include "scgtplugin.h"
171
#include "scmessagebox.h"
12841 jghali 172
#include "scmimedata.h"
10532 avox 173
#include "scpaths.h"
10967 jghali 174
#include "scprintengine_ps.h"
10212 cbradney 175
#include "scraction.h"
10862 cbradney 176
#include "scrapbookpalette.h"
10212 cbradney 177
#include "scribus.h"
178
#include "scribusXml.h"
179
#include "scribusapp.h"
180
#include "scribuscore.h"
3252 craig 181
#include "scribuswin.h"
10212 cbradney 182
#include "search.h"
3934 cbradney 183
#include "selection.h"
11919 fschmid 184
#include "selectobjects.h"
10212 cbradney 185
#include "serializer.h"
186
#include "smlinestyle.h"
187
#include "smtextstyles.h"
188
#include "splash.h"
189
#include "stencilreader.h"
12939 jghali 190
#include "storyeditor.h"
4829 tsoots 191
#include "stylemanager.h"
10212 cbradney 192
#include "tabcheckdoc.h"
193
#include "tabguides.h"
194
#include "tabmanager.h"
195
#include "tabpdfoptions.h"
196
#include "tabtools.h"
197
#include "tabtypography.h"
10862 cbradney 198
#include "text/nlsconfig.h"
10212 cbradney 199
#include "tocgenerator.h"
200
#include "tocindexprefs.h"
10862 cbradney 201
#include "ui/copypagetomasterpagedialog.h"
10976 cbradney 202
#include "ui/edittoolbar.h"
203
#include "ui/filetoolbar.h"
204
#include "ui/modetoolbar.h"
205
#include "ui/pdftoolbar.h"
10212 cbradney 206
#include "undogui.h"
207
#include "undomanager.h"
208
#include "undostate.h"
209
#include "units.h"
10311 cbradney 210
#include "urllauncher.h"
5184 avox 211
#include "util.h"
10212 cbradney 212
#include "util_formats.h"
213
#include "util_ghostscript.h"
10200 cbradney 214
#include "util_icon.h"
15706 jghali 215
#include "util_math.h"
10212 cbradney 216
#include "vruler.h"
12110 fschmid 217
#include "loadsaveplugin.h"
134 Franz 218
 
10212 cbradney 219
 
4361 cbradney 220
#if defined(_WIN32)
5178 mrdocs 221
#include "scdocoutput_ps2.h"
10967 jghali 222
#include "scprintengine_gdi.h"
4361 cbradney 223
#endif
224
 
3 paul 225
using namespace std;
226
 
3234 fschmid 227
bool previewDinUse;
228
bool printDinUse;
2891 cbradney 229
 
3 paul 230
QString DocDir;
3205 craig 231
 
10532 avox 232
 
2536 cbradney 233
extern ScribusQApp* ScQApp;
2634 cbradney 234
extern bool emergencyActivated;
3 paul 235
 
10532 avox 236
 
4026 craig 237
ScribusMainWindow::ScribusMainWindow()
2161 cbradney 238
{
5781 cbradney 239
        actionManager=0;
240
        scrMenuMgr=0;
241
        prefsManager=0;
10181 cbradney 242
        formatsManager=0;
10311 cbradney 243
        UrlLauncher::instance();
5781 cbradney 244
        mainWindowStatusLabel=0;
7354 cbradney 245
        ExternalApp=0;
3580 avox 246
#ifdef Q_WS_MAC
247
        noIcon = loadIcon("noicon.xpm");
248
#endif
10625 cbradney 249
}
188 Franz 250
 
11158 avox 251
/*
252
static QCoreApplication::EventFilter origEventFilter = 0;
10532 avox 253
 
11158 avox 254
bool reportFocusChanges(void *message, long *result)
255
{
256
        unsigned* data = static_cast<unsigned*>(message);
257
        if (QApplication::focusWidget())
258
                qDebug() << QApplication::applicationFilePath() << reinterpret_cast<void*>(QApplication::focusWidget()) << typeid(*QApplication::focusWidget()).name() << QApplication::focusWidget()->objectName() << message << data[0] << data[1] << data[2] << data[3] << data[4] << data[5] << data[6] << data[7];
259
        else
260
                qDebug() << QApplication::applicationFilePath() << "no focus" << message << data[0] << data[1] << data[2] << data[3] << data[4] << data[5] << data[6] << data[7];
261
        return origEventFilter && origEventFilter(message, result);
262
}
263
*/
264
 
767 cbradney 265
/*
266
 * retval 0 - ok, 1 - no fonts, ...
267
 */
5243 cbradney 268
int ScribusMainWindow::initScMW(bool primaryMainWindow)
188 Franz 269
{
767 cbradney 270
        int retVal=0;
5243 cbradney 271
 
9909 avox 272
        QByteArray stylesheet;
9910 jghali 273
        if (loadRawText(ScPaths::getApplicationDataDir() + "/stylesheet.css", stylesheet))
9909 avox 274
        {
275
                qApp->setStyleSheet(QString(stylesheet));
276
        }
10953 subik 277
 
11158 avox 278
//      origEventFilter = qApp->setEventFilter(reportFocusChanges);
11960 subik 279
 
3234 fschmid 280
        previewDinUse = false;
281
        printDinUse = false;
9721 fschmid 282
        internalCopy = false;
355 Franz 283
        CurrStED = NULL;
10495 cbradney 284
        setWindowTitle( tr("Scribus " VERSION));
10564 fschmid 285
        setAttribute(Qt::WA_KeyCompression, false);
286
        setWindowIcon(loadIcon("AppIcon.png"));
1325 cbradney 287
        scrActionGroups.clear();
1208 cbradney 288
        scrActions.clear();
289
        scrRecentFileActions.clear();
5800 fschmid 290
        scrRecentPasteActions.clear();
1260 cbradney 291
        scrWindowsActions.clear();
2408 cbradney 292
        scrLayersActions.clear();
15524 fschmid 293
        scrScrapActions.clear();
5781 cbradney 294
        scrMenuMgr = new MenuManager(menuBar());
2835 cbradney 295
        prefsManager = PrefsManager::instance();
10181 cbradney 296
        formatsManager = FormatsManager::instance();
5243 cbradney 297
        objectSpecificUndo = false;
7087 subik 298
 
1247 tsoots 299
        undoManager = UndoManager::instance();
7880 fschmid 300
        PrefsContext *undoPrefs = prefsManager->prefsFile->getContext("undo");
301
        undoManager->setUndoEnabled(undoPrefs->getBool("enabled", true));
2441 cbradney 302
        tocGenerator = new TOCGenerator();
4510 subik 303
 
7087 subik 304
 
1780 cbradney 305
        initDefaultValues();
7087 subik 306
 
272 Franz 307
        initStatusBar();
7087 subik 308
 
490 cbradney 309
        qApp->processEvents();
675 cbradney 310
 
10427 cbradney 311
        actionManager = new ActionManager(this);
5257 cbradney 312
        actionManager->init(this);
11174 fschmid 313
//      if (primaryMainWindow)
314
//              ScCore->setSplashStatus( tr("Applying User Shortcuts") );
315
//      prefsManager->applyLoadedShortCuts();
316
//      initKeyboardShortcuts();
317
        initMenuBar();
318
        initToolBars();
319
        ScCore->pluginManager->setupPluginActions(this);
320
        ScCore->pluginManager->languageChange();
10977 cbradney 321
        if (primaryMainWindow)
322
                ScCore->setSplashStatus( tr("Applying User Shortcuts") );
323
        prefsManager->applyLoadedShortCuts();
324
        initKeyboardShortcuts();
11960 subik 325
 
5243 cbradney 326
        resize(610, 600);
8695 fschmid 327
        wsp = new QWorkspace( this );
328
        setCentralWidget( wsp );
5243 cbradney 329
        connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
330
        //Connect windows cascade and tile actions to the workspace after its created. Only depends on wsp created.
10725 jghali 331
        connect( scrActions["windowsCascade"], SIGNAL(triggered()) , wsp, SLOT(cascade()) );
332
        connect( scrActions["windowsTile"], SIGNAL(triggered()) , wsp, SLOT(tile()) );
5243 cbradney 333
        initPalettes();
7087 subik 334
 
5243 cbradney 335
        prefsManager->setupMainWindow(this);
770 cbradney 336
 
5243 cbradney 337
        if (primaryMainWindow)
338
                ScCore->setSplashStatus( tr("Initializing Story Editor") );
339
        storyEditor = new StoryEditor(this);
770 cbradney 340
 
5243 cbradney 341
        DocDir = prefsManager->documentDir();
1485 tsoots 342
 
5243 cbradney 343
        if (primaryMainWindow)
5800 fschmid 344
                ScCore->setSplashStatus( tr("Initializing Hyphenator") );
345
        QString preLang = prefsManager->appPrefs.Language;
346
        initHyphenator();
12787 pierre 347
        if (!LanguageManager::instance()->getHyphFilename( preLang, false ).isEmpty() )
5800 fschmid 348
                prefsManager->appPrefs.Language = preLang;
349
        if (primaryMainWindow)
350
                ScCore->setSplashStatus( tr("Reading Scrapbook") );
351
        initScrapbook();
352
 
10564 fschmid 353
        scrActions["helpTooltips"]->setChecked(prefsManager->appPrefs.showToolTips);
12754 fschmid 354
        scrActions["showMouseCoordinates"]->setChecked(prefsManager->appPrefs.showMouseCoordinates);
10564 fschmid 355
        scrActions["stickyTools"]->setChecked(prefsManager->appPrefs.stickyTools);
5800 fschmid 356
        ToggleTips();
12754 fschmid 357
        ToggleMouseTips();
5800 fschmid 358
        propertiesPalette->setFontSize();
6451 fschmid 359
        if (scrActions["SaveAsDocumentTemplate"])
360
                scrActions["SaveAsDocumentTemplate"]->setEnabled(false);
7087 subik 361
 
15948 jghali 362
        connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString )), this, SLOT(removeRecentFromWatcher(QString)));
9067 avox 363
        connect(this, SIGNAL(TextStyle(const ParagraphStyle&)), propertiesPalette, SLOT(updateStyle(const ParagraphStyle&)));
5800 fschmid 364
        connect(this, SIGNAL(TextIFont(QString)), propertiesPalette, SLOT(setFontFace(QString)));
9920 fschmid 365
        connect(this, SIGNAL(TextISize(double)), propertiesPalette, SLOT(setSize(double)));
366
        connect(this, SIGNAL(TextUSval(double)), propertiesPalette, SLOT(setExtra(double)));
5800 fschmid 367
        connect(this, SIGNAL(TextStil(int)), propertiesPalette, SLOT(setStil(int)));
9920 fschmid 368
        connect(this, SIGNAL(TextScale(double)), propertiesPalette, SLOT(setTScale(double)));
369
        connect(this, SIGNAL(TextScaleV(double)), propertiesPalette, SLOT(setTScaleV(double)));
370
        connect(this, SIGNAL(TextBase(double)), propertiesPalette, SLOT(setTBase(double)));
371
        connect(this, SIGNAL(TextShadow(double, double )), propertiesPalette, SLOT(setShadowOffs(double, double )));
372
        connect(this, SIGNAL(TextOutline(double)), propertiesPalette, SLOT(setOutlineW(double)));
373
        connect(this, SIGNAL(TextUnderline(double, double)), propertiesPalette, SLOT(setUnderline(double, double)));
374
        connect(this, SIGNAL(TextStrike(double, double)), propertiesPalette, SLOT(setStrike(double, double)));
375
        connect(this, SIGNAL(TextFarben(QString, QString, double, double)), propertiesPalette, SLOT(setActFarben(QString, QString, double, double)));
5800 fschmid 376
        connect(ClipB, SIGNAL(dataChanged()), this, SLOT(ClipChange()));
7337 fschmid 377
//      connect(ClipB, SIGNAL(selectionChanged()), this, SLOT(ClipChange()));
5800 fschmid 378
        setAcceptDrops(true);
9562 fschmid 379
        QCoreApplication::instance()->installEventFilter(this);
12846 fschmid 380
        scrActions["toolsSelect"]->setChecked(true);
11960 subik 381
 
5800 fschmid 382
        return retVal;
383
}
384
 
10532 avox 385
 
5800 fschmid 386
ScribusMainWindow::~ScribusMainWindow()
387
{
388
}
389
 
11040 fschmid 390
void ScribusMainWindow::addScToolBar(ScToolBar *tb, QString name)
391
{
392
        if (!scrToolBars.contains(name))
393
                scrToolBars.insert(name, tb);
394
        addToolBar(tb);
395
}
5800 fschmid 396
 
397
void ScribusMainWindow::initToolBars()
398
{
10976 cbradney 399
        fileToolBar = new FileToolBar(this);
400
        editToolBar = new EditToolBar(this);
5800 fschmid 401
        UndoWidget* uWidget = new UndoWidget(editToolBar, "uWidget");
402
        undoManager->registerGui(uWidget);
10976 cbradney 403
        modeToolBar = new ModeToolBar(this);
5800 fschmid 404
        pdfToolBar = new PDFToolBar(this);
10953 subik 405
 
11040 fschmid 406
        addScToolBar(fileToolBar, "ToolBar-File");
407
        addScToolBar(editToolBar, "ToolBar-Edit");
408
        addScToolBar(modeToolBar, "ToolBar-Tools");
409
        addScToolBar(pdfToolBar, "ToolBar-PDF_Tools");
7087 subik 410
 
10976 cbradney 411
        connect(modeToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarTools"], SLOT(setChecked(bool)));
10734 jghali 412
        connect(scrActions["toolsToolbarPDF"], SIGNAL(toggled(bool)), pdfToolBar, SLOT(setVisible(bool)));
10969 subik 413
        connect(pdfToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarPDF"], SLOT(setChecked(bool)));
10976 cbradney 414
        connect(scrActions["toolsToolbarTools"], SIGNAL(toggled(bool)), modeToolBar, SLOT(setVisible(bool)) );
5800 fschmid 415
}
416
 
10532 avox 417
 
5800 fschmid 418
void ScribusMainWindow::initDefaultValues()
419
{
420
        HaveDoc = false;
14755 jghali 421
        ScriptRunning = 0;
5800 fschmid 422
        view = NULL;
423
        doc = NULL;
424
        DocNr = 1;
425
        PrinterUsed = false;
426
        PDef.Pname = "";
427
        PDef.Dname = "";
428
        PDef.Command = "";
429
        keyrep = false;
430
        _arrowKeyDown = false;
431
        ClipB = QApplication::clipboard();
432
        palettesStatus[0] = false;
433
        guidesStatus[0] = false;
434
}
435
 
10532 avox 436
 
5800 fschmid 437
void ScribusMainWindow::initKeyboardShortcuts()
438
{
8501 cbradney 439
        for( QMap<QString, QPointer<ScrAction> >::Iterator it = scrActions.begin(); it!=scrActions.end(); ++it )
5800 fschmid 440
        {
10516 cbradney 441
                if ((ScrAction*)(it.value())!=NULL)
5800 fschmid 442
                {
10564 fschmid 443
                        QString accelerator=it.value()->shortcut();
10516 cbradney 444
                        prefsManager->setKeyEntry(it.key(), it.value()->cleanMenuText(), accelerator,0);
5800 fschmid 445
                }
446
                //else
13085 jghali 447
                //      qDebug() << it.key();
448
                //qDebug() << QString("|-\n|%1||%2||%3").arg(it.key()).arg(it.value()->cleanMenuText()).arg(QString(it.data()->accel()));
5800 fschmid 449
        }
450
}
451
 
10532 avox 452
 
5800 fschmid 453
void ScribusMainWindow::initPalettes()
454
{
455
        //CB TODO hide the publicly available members of some palettes
456
        // these must be filtered too as they take control of the palettes events
10862 cbradney 457
        outlinePalette = new OutlinePalette(this);
5800 fschmid 458
        outlinePalette->setMainWindow(this);
459
        connect( scrActions["toolsOutline"], SIGNAL(toggled(bool)) , outlinePalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 460
        connect( outlinePalette, SIGNAL(paletteShown(bool)), scrActions["toolsOutline"], SLOT(setChecked(bool)));
10862 cbradney 461
        propertiesPalette = new PropertiesPalette(this);
5800 fschmid 462
        propertiesPalette->setMainWindow(this);
463
        connect( scrActions["toolsProperties"], SIGNAL(toggled(bool)) , propertiesPalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 464
        connect( propertiesPalette, SIGNAL(paletteShown(bool)), scrActions["toolsProperties"], SLOT(setChecked(bool)));
5800 fschmid 465
 
466
        //CB dont need this until we have a doc...
467
        //propertiesPalette->Cpal->SetColors(prefsManager->colorSet());
468
        propertiesPalette->Fonts->RebuildList(0);
469
        propertiesPalette->installEventFilter(this);
470
        nodePalette = new NodePalette(this);
471
        nodePalette->installEventFilter(this);
472
        layerPalette = new LayerPalette(this);
473
        guidePalette = new GuideManager(this);
7087 subik 474
        charPalette = new CharSelect(this);
5800 fschmid 475
        connect( scrActions["toolsLayers"], SIGNAL(toggled(bool)) , layerPalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 476
        connect( layerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsLayers"], SLOT(setChecked(bool)));
5800 fschmid 477
        layerPalette->installEventFilter(this);
478
        layerPalette->Table->installEventFilter(this);
479
        scrapbookPalette = new Biblio(this);
480
        connect( scrActions["toolsScrapbook"], SIGNAL(toggled(bool)) , scrapbookPalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 481
        connect( scrapbookPalette, SIGNAL(paletteShown(bool)), scrActions["toolsScrapbook"], SLOT(setChecked(bool)));
11554 fschmid 482
        connect( scrapbookPalette, SIGNAL(pasteToActualPage(QString)), this, SLOT(pasteFromScrapbook(QString)));
5800 fschmid 483
        scrapbookPalette->installEventFilter(this);
484
        pagePalette = new PagePalette(this);
485
        connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , pagePalette, SLOT(setPaletteShown(bool)) );
486
        connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , this, SLOT(setPagePalette(bool)) );
10581 cbradney 487
        connect( pagePalette, SIGNAL(paletteShown(bool)), scrActions["toolsPages"], SLOT(setChecked(bool)));
5800 fschmid 488
        pagePalette->installEventFilter(this);
489
        bookmarkPalette = new BookPalette(this);
490
        connect( scrActions["toolsBookmarks"], SIGNAL(toggled(bool)) , bookmarkPalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 491
        connect( bookmarkPalette, SIGNAL(paletteShown(bool)), scrActions["toolsBookmarks"], SLOT(setChecked(bool)));
5800 fschmid 492
        bookmarkPalette->installEventFilter(this);
11190 avox 493
//      measurementPalette = new Measurements(this);
494
//      connect( scrActions["toolsMeasurements"], SIGNAL(toggled(bool)) , measurementPalette, SLOT(setPaletteShown(bool)) );
5800 fschmid 495
        connect( scrActions["toolsMeasurements"], SIGNAL(toggledData(bool, int)) , this, SLOT(setAppModeByToggle(bool, int)) );
11190 avox 496
//      connect( measurementPalette, SIGNAL(paletteShown(bool)), scrActions["toolsMeasurements"], SLOT(setChecked(bool)));
497
//      measurementPalette->installEventFilter(this);
498
//      measurementPalette->hide();
5800 fschmid 499
        docCheckerPalette = new CheckDocument(this, false);
500
        connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , docCheckerPalette, SLOT(setPaletteShown(bool)) );
501
        connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , this, SLOT(docCheckToggle(bool)) );
10581 cbradney 502
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsPreflightVerifier"], SLOT(setChecked(bool)));
5800 fschmid 503
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), this, SLOT(docCheckToggle(bool)));
504
        docCheckerPalette->installEventFilter(this);
505
        docCheckerPalette->hide();
506
 
507
        alignDistributePalette = new AlignDistributePalette(this, "AlignDistributePalette", false);
508
        connect( scrActions["toolsAlignDistribute"], SIGNAL(toggled(bool)) , alignDistributePalette, SLOT(setPaletteShown(bool)) );
10581 cbradney 509
        connect( alignDistributePalette, SIGNAL(paletteShown(bool)), scrActions["toolsAlignDistribute"], SLOT(setChecked(bool)));
5800 fschmid 510
        connect( alignDistributePalette, SIGNAL(documentChanged()), this, SLOT(slotDocCh()));
511
        alignDistributePalette->installEventFilter(this);
7087 subik 512
 
5800 fschmid 513
        undoPalette = new UndoPalette(this, "undoPalette");
514
        undoPalette->installEventFilter(this);
515
        undoManager->registerGui(undoPalette);
516
        connect(undoPalette, SIGNAL(paletteShown(bool)), this, SLOT(setUndoPalette(bool)));
517
        connect(undoPalette, SIGNAL(objectMode(bool)), this, SLOT(setUndoMode(bool)));
518
 
519
        // initializing style manager here too even it's not strictly a palette
520
        styleManager = new StyleManager(this, "styleManager");
521
        styleManager->addStyle(new SMLineStyle());
7063 tsoots 522
        SMCharacterStyle *tmpCS = new SMCharacterStyle();
523
        styleManager->addStyle(new SMParagraphStyle(tmpCS->tmpStyles()));
524
        styleManager->addStyle(tmpCS);
10627 cbradney 525
        connect( scrActions["editStyles"], SIGNAL(toggled(bool)), styleManager, SLOT(setPaletteShown(bool)) );
10581 cbradney 526
        connect( styleManager, SIGNAL(paletteShown(bool)), scrActions["editStyles"], SLOT(setChecked(bool)));
8005 cbradney 527
        styleManager->installEventFilter(this);
5800 fschmid 528
 
529
        connect(docCheckerPalette, SIGNAL(selectElement(int, int)), this, SLOT(selectItemsFromOutlines(int, int)));
530
        connect(docCheckerPalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
531
        connect(docCheckerPalette, SIGNAL(selectMasterPage(QString)), this, SLOT(manageMasterPages(QString)));
532
        connect(outlinePalette, SIGNAL(selectElement(int, int, bool)), this, SLOT(selectItemsFromOutlines(int, int, bool)));
533
        connect(outlinePalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
534
        connect(outlinePalette, SIGNAL(selectMasterPage(QString)), this, SLOT(manageMasterPages(QString)));
9067 avox 535
        connect(propertiesPalette->paraStyleCombo, SIGNAL(newStyle(const QString&)), this, SLOT(setNewParStyle(const QString&)));
536
        connect(propertiesPalette->charStyleCombo, SIGNAL(newStyle(const QString&)), this, SLOT(setNewCharStyle(const QString&)));
5800 fschmid 537
//      connect(propertiesPalette, SIGNAL(EditLSt()), this, SLOT(slotEditLineStyles()));
11852 fschmid 538
        connect(nodePalette, SIGNAL(Schliessen()), propertiesPalette, SLOT(endEdit2()));
10532 avox 539
        connect(nodePalette, SIGNAL(Schliessen()), this, SLOT(slotSelect()));
5800 fschmid 540
        connect(nodePalette, SIGNAL(DocChanged()), this, SLOT(slotDocCh()));
541
        connect(layerPalette, SIGNAL(LayerChanged()), this, SLOT(showLayer()));
542
 
543
        connect(bookmarkPalette->BView, SIGNAL(MarkMoved()), this, SLOT(StoreBookmarks()));
544
        connect(bookmarkPalette->BView, SIGNAL(changed()), this, SLOT(slotDocCh()));
545
        connect(bookmarkPalette->BView, SIGNAL(SelectElement(PageItem *)), this, SLOT(selectItemsFromOutlines(PageItem *)));
546
        // guides
547
        connect(scrActions["pageManageGuides"], SIGNAL(toggled(bool)), guidePalette, SLOT(setPaletteShown(bool)));
10581 cbradney 548
        connect(guidePalette, SIGNAL(paletteShown(bool)), scrActions["pageManageGuides"], SLOT(setChecked(bool)));
7087 subik 549
        // char palette
550
        connect(scrActions["insertGlyph"], SIGNAL(toggled(bool)), charPalette, SLOT(setPaletteShown(bool)));
10581 cbradney 551
        connect(charPalette, SIGNAL(paletteShown(bool)), scrActions["insertGlyph"], SLOT(setChecked(bool)));
5800 fschmid 552
}
553
 
10532 avox 554
 
5800 fschmid 555
void ScribusMainWindow::initScrapbook()
556
{
16576 craig 557
        QString scrapbookFileO = QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrap13.scs");
5800 fschmid 558
        QFileInfo scrapbookFileInfoO = QFileInfo(scrapbookFileO);
559
        if (scrapbookFileInfoO.exists())
560
        {
16576 craig 561
                scrapbookPalette->readOldContents(scrapbookFileO, QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrapbook/main"));
5800 fschmid 562
                QDir d = QDir();
16576 craig 563
                d.rename(scrapbookFileO, QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrap13.backup"));
5800 fschmid 564
        }
16576 craig 565
        QString scrapbookTemp = QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrapbook/tmp");
5800 fschmid 566
        QFileInfo scrapbookTempInfo = QFileInfo(scrapbookTemp);
567
        if (scrapbookTempInfo.exists())
568
                scrapbookPalette->readTempContents(scrapbookTemp);
16576 craig 569
        QString scrapbookFile = QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrapbook/main");
5800 fschmid 570
        QFileInfo scrapbookFileInfo = QFileInfo(scrapbookFile);
571
        if (scrapbookFileInfo.exists())
572
                scrapbookPalette->readContents(scrapbookFile);
573
        scrapbookPalette->setScrapbookFileName(scrapbookFile);
574
        scrapbookPalette->setOpenScrapbooks(prefsManager->appPrefs.RecentScrapbooks);
575
        rebuildRecentPasteMenu();
5806 fschmid 576
        connect(scrapbookPalette, SIGNAL(updateRecentMenue()), this, SLOT(rebuildRecentPasteMenu()));
5800 fschmid 577
}
578
 
10532 avox 579
 
5800 fschmid 580
bool ScribusMainWindow::warningVersion(QWidget *parent)
581
{
582
        bool retval = false;
583
        int t = ScMessageBox::warning(parent, QObject::tr("Scribus Development Version"), "<qt>" +
6442 cbradney 584
                                                                 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.x.  Saving the current file under 1.3.x renders it unable to be edited in Scribus 1.2.x versions. To preserve the ability to edit in 1.2.x, save this file under a different name and further edit the newly named file and the original will be untouched. Are you sure you wish to proceed with this operation?") + "</qt>",
9422 fschmid 585
                                                                 QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Cancel);
586
        if (t == QMessageBox::Ok)
5800 fschmid 587
                retval = true;
588
        return retval;
589
}
590
 
10532 avox 591
 
5800 fschmid 592
void ScribusMainWindow::initMenuBar()
593
{
594
        RecentDocs.clear();
12940 cbradney 595
        scrMenuMgr->createMenu("File", ActionManager::defaultMenuNameEntryTranslated("File"));
5800 fschmid 596
        scrMenuMgr->addMenuItem(scrActions["fileNew"], "File");
13188 fschmid 597
        scrMenuMgr->addMenuItem(scrActions["fileNewFromTemplate"], "File");
5800 fschmid 598
        scrMenuMgr->addMenuItem(scrActions["fileOpen"], "File");
599
        recentFileMenuName="FileOpenRecent";
10558 cbradney 600
        scrMenuMgr->createMenu(recentFileMenuName, tr("Open &Recent"), "File");
5800 fschmid 601
        scrMenuMgr->addMenuSeparator("File");
602
        scrMenuMgr->addMenuItem(scrActions["fileClose"], "File");
603
        scrMenuMgr->addMenuItem(scrActions["fileSave"], "File");
604
        scrMenuMgr->addMenuItem(scrActions["fileSaveAs"], "File");
605
        scrMenuMgr->addMenuItem(scrActions["fileRevert"], "File");
606
        scrMenuMgr->addMenuItem(scrActions["fileCollect"], "File");
607
        scrMenuMgr->addMenuSeparator("File");
10558 cbradney 608
        scrMenuMgr->createMenu("FileImport", tr("&Import"), "File");
5800 fschmid 609
        scrMenuMgr->addMenuItem(scrActions["fileImportText"], "FileImport");
7615 cbradney 610
//      scrMenuMgr->addMenuItem(scrActions["fileImportText2"], "FileImport");
5800 fschmid 611
        scrMenuMgr->addMenuItem(scrActions["fileImportAppendText"], "FileImport");
612
        scrMenuMgr->addMenuItem(scrActions["fileImportImage"], "FileImport");
12110 fschmid 613
        scrMenuMgr->addMenuItem(scrActions["fileImportVector"], "FileImport");
614
 
10558 cbradney 615
        scrMenuMgr->createMenu("FileExport", tr("&Export"), "File");
5800 fschmid 616
        scrMenuMgr->addMenuItem(scrActions["fileExportText"], "FileExport");
617
        scrMenuMgr->addMenuItem(scrActions["fileExportAsEPS"], "FileExport");
618
        scrMenuMgr->addMenuItem(scrActions["fileExportAsPDF"], "FileExport");
619
        scrMenuMgr->addMenuSeparator("File");
620
        scrMenuMgr->addMenuItem(scrActions["fileDocSetup"], "File");
621
        scrMenuMgr->addMenuItem(scrActions["filePreferences"], "File");
622
        scrMenuMgr->addMenuSeparator("File");
623
        scrMenuMgr->addMenuItem(scrActions["filePrint"], "File");
624
        scrMenuMgr->addMenuItem(scrActions["PrintPreview"], "File");
625
        scrMenuMgr->addMenuSeparator("File");
626
        scrMenuMgr->addMenuItem(scrActions["fileQuit"], "File");
627
 
628
        scrActions["fileClose"]->setEnabled(false);
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["fileImportText2"]->setEnabled(false);
635
        scrActions["fileImportImage"]->setEnabled(false);
636
        scrActions["fileImportAppendText"]->setEnabled(false);
637
        scrActions["pageImport"]->setEnabled(false);
638
        scrActions["fileExportText"]->setEnabled(false);
639
        scrActions["fileExportAsEPS"]->setEnabled(false);
640
        scrActions["fileExportAsPDF"]->setEnabled(false);
6451 fschmid 641
        scrMenuMgr->setMenuEnabled("FileImport", false);
5800 fschmid 642
        scrMenuMgr->setMenuEnabled("FileExport", false);
643
        scrActions["fileDocSetup"]->setEnabled(false);
644
        scrActions["filePrint"]->setEnabled(false);
645
        scrActions["PrintPreview"]->setEnabled(false);
646
 
12940 cbradney 647
        scrMenuMgr->createMenu("Edit", ActionManager::defaultMenuNameEntryTranslated("Edit"));
5800 fschmid 648
        scrMenuMgr->addMenuItem(scrActions["editUndoAction"], "Edit");
649
        scrMenuMgr->addMenuItem(scrActions["editRedoAction"], "Edit");
650
        scrMenuMgr->addMenuItem(scrActions["editActionMode"], "Edit");
651
        scrMenuMgr->addMenuSeparator("Edit");
652
        scrMenuMgr->addMenuItem(scrActions["editCut"], "Edit");
653
        scrMenuMgr->addMenuItem(scrActions["editCopy"], "Edit");
654
        scrMenuMgr->addMenuItem(scrActions["editPaste"], "Edit");
655
        recentPasteMenuName="EditPasteRecent";
10558 cbradney 656
        scrMenuMgr->createMenu(recentPasteMenuName, tr("Paste Recent"), "Edit");
657
        scrMenuMgr->createMenu("EditContents", tr("Contents"), "Edit");
5800 fschmid 658
        scrMenuMgr->addMenuItem(scrActions["editCopyContents"], "EditContents");
659
        scrMenuMgr->addMenuItem(scrActions["editPasteContents"], "EditContents");
660
        scrMenuMgr->addMenuItem(scrActions["editPasteContentsAbs"], "EditContents");
661
        scrMenuMgr->addMenuItem(scrActions["editClearContents"], "EditContents");
662
        scrMenuMgr->addMenuSeparator("Edit");
663
        scrMenuMgr->addMenuItem(scrActions["editSelectAll"], "Edit");
11893 cbradney 664
        scrMenuMgr->addMenuItem(scrActions["editSelectAllOnLayer"], "Edit");
5800 fschmid 665
        scrMenuMgr->addMenuItem(scrActions["editDeselectAll"], "Edit");
666
        scrMenuMgr->addMenuSeparator("Edit");
667
        scrMenuMgr->addMenuItem(scrActions["editSearchReplace"], "Edit");
668
        scrMenuMgr->addMenuItem(scrActions["toolsEditWithStoryEditor"], "Edit");
669
        scrMenuMgr->addMenuItem(scrActions["editEditWithImageEditor"], "Edit");
12401 cbradney 670
        scrMenuMgr->addMenuItem(scrActions["editEditRenderSource"], "Edit");
5800 fschmid 671
        scrMenuMgr->addMenuSeparator("Edit");
672
        scrMenuMgr->addMenuItem(scrActions["editColors"], "Edit");
11895 fschmid 673
        scrMenuMgr->addMenuItem(scrActions["editReplaceColors"], "Edit");
6368 fschmid 674
        scrMenuMgr->addMenuItem(scrActions["editPatterns"], "Edit");
5922 cbradney 675
        scrMenuMgr->addMenuItem(scrActions["editStyles"], "Edit");
5800 fschmid 676
        scrMenuMgr->addMenuItem(scrActions["editMasterPages"], "Edit");
677
        scrMenuMgr->addMenuItem(scrActions["editJavascripts"], "Edit");
678
        scrActions["editUndoAction"]->setEnabled(false);
679
        scrActions["editRedoAction"]->setEnabled(false);
680
        scrActions["editActionMode"]->setEnabled(true);
681
        scrActions["editCut"]->setEnabled(false);
682
        scrActions["editCopy"]->setEnabled(false);
683
        scrActions["editPaste"]->setEnabled(false);
5827 fschmid 684
        scrMenuMgr->setMenuEnabled("EditPasteRecent", false);
7565 cbradney 685
        scrMenuMgr->setMenuEnabled("EditContents", false);
5800 fschmid 686
        scrActions["editCopyContents"]->setEnabled(false);
687
        scrActions["editPasteContents"]->setEnabled(false);
688
        scrActions["editPasteContentsAbs"]->setEnabled(false);
689
        scrActions["editClearContents"]->setEnabled(false);
690
        scrActions["editSelectAll"]->setEnabled(false);
11893 cbradney 691
        scrActions["editSelectAllOnLayer"]->setEnabled(false);
5800 fschmid 692
        scrActions["editDeselectAll"]->setEnabled(false);
693
        scrActions["editSearchReplace"]->setEnabled(false);
11895 fschmid 694
        scrActions["editReplaceColors"]->setEnabled(false);
6368 fschmid 695
        scrActions["editPatterns"]->setEnabled(false);
9566 cbradney 696
        scrActions["editStyles"]->setEnabled(false);
5800 fschmid 697
        scrActions["editMasterPages"]->setEnabled(false);
698
        scrActions["editJavascripts"]->setEnabled(false);
699
        scrActions["toolsEditWithStoryEditor"]->setEnabled(false);
700
        scrActions["editEditWithImageEditor"]->setEnabled(false);
12401 cbradney 701
        scrActions["editEditRenderSource"]->setEnabled(false);
5800 fschmid 702
 
703
        //Item Menu
12940 cbradney 704
        scrMenuMgr->createMenu("Item", ActionManager::defaultMenuNameEntryTranslated("Item"));
5800 fschmid 705
        scrMenuMgr->addMenuItem(scrActions["itemDuplicate"], "Item");
706
        scrMenuMgr->addMenuItem(scrActions["itemMulDuplicate"], "Item");
707
        scrMenuMgr->addMenuItem(scrActions["itemDelete"], "Item");
708
        scrMenuMgr->addMenuSeparator("Item");
709
        scrMenuMgr->addMenuItem(scrActions["itemGroup"], "Item");
710
        scrMenuMgr->addMenuItem(scrActions["itemUngroup"], "Item");
711
        scrMenuMgr->addMenuItem(scrActions["itemLock"], "Item");
712
        scrMenuMgr->addMenuItem(scrActions["itemLockSize"], "Item");
713
        scrMenuMgr->addMenuSeparator("Item");
714
        scrMenuMgr->createMenu("ItemLevel", tr("Level"));
715
        scrMenuMgr->addMenuToMenu("ItemLevel", "Item");
716
        scrMenuMgr->addMenuItem(scrActions["itemRaise"], "ItemLevel");
717
        scrMenuMgr->addMenuItem(scrActions["itemLower"], "ItemLevel");
718
        scrMenuMgr->addMenuItem(scrActions["itemRaiseToTop"], "ItemLevel");
719
        scrMenuMgr->addMenuItem(scrActions["itemLowerToBottom"], "ItemLevel");
720
        scrMenuMgr->createMenu("ItemLayer", tr("Send to La&yer"));
721
        scrMenuMgr->addMenuToMenu("ItemLayer", "Item");
722
        layerMenuName="ItemLayer";
15524 fschmid 723
        scrMenuMgr->createMenu("itemSendToScrapbook", tr("Send to Scrapbook"));
724
        scrMenuMgr->addMenuToMenu("itemSendToScrapbook", "Item");
6410 fschmid 725
        scrMenuMgr->addMenuItem(scrActions["itemSendToPattern"], "Item");
5800 fschmid 726
        scrMenuMgr->addMenuSeparator("Item");
8020 cbradney 727
        scrMenuMgr->addMenuItem(scrActions["itemAdjustFrameToImage"], "Item");
12591 fschmid 728
        scrMenuMgr->addMenuItem(scrActions["itemAdjustImageToFrame"], "Item");
14779 cbradney 729
        scrMenuMgr->addMenuItem(scrActions["itemUpdateImage"], "Item");
730
        scrMenuMgr->addMenuItem(scrActions["styleImageEffects"], "Item");
8020 cbradney 731
        scrMenuMgr->addMenuItem(scrActions["itemExtendedImageProperties"], "Item");
732
        scrMenuMgr->createMenu("ItemPreviewSettings", tr("Preview Settings"), "Item");
733
        scrMenuMgr->addMenuItem(scrActions["itemImageIsVisible"], "ItemPreviewSettings");
734
        scrMenuMgr->addMenuSeparator("ItemPreviewSettings");
735
        scrMenuMgr->addMenuItem(scrActions["itemPreviewLow"], "ItemPreviewSettings");
736
        scrMenuMgr->addMenuItem(scrActions["itemPreviewNormal"], "ItemPreviewSettings");
737
        scrMenuMgr->addMenuItem(scrActions["itemPreviewFull"], "ItemPreviewSettings");
738
        scrMenuMgr->addMenuSeparator("Item");
5800 fschmid 739
        scrMenuMgr->addMenuItem(scrActions["itemAttributes"], "Item");
740
        scrMenuMgr->createMenu("ItemPDFOptions", tr("&PDF Options"));
741
        scrMenuMgr->addMenuToMenu("ItemPDFOptions", "Item");
742
        scrMenuMgr->addMenuItem(scrActions["itemPDFIsAnnotation"], "ItemPDFOptions");
743
        scrMenuMgr->addMenuItem(scrActions["itemPDFIsBookmark"], "ItemPDFOptions");
744
        scrMenuMgr->addMenuItem(scrActions["itemPDFAnnotationProps"], "ItemPDFOptions");
745
        scrMenuMgr->addMenuItem(scrActions["itemPDFFieldProps"], "ItemPDFOptions");
11067 cbradney 746
        //scrMenuMgr->createMenu("ItemShapes", tr("&Shape"), "Item");
10558 cbradney 747
        scrMenuMgr->createMenu("ItemConvertTo", tr("C&onvert To"), "Item");
5800 fschmid 748
        scrMenuMgr->addMenuItem(scrActions["itemConvertToBezierCurve"], "ItemConvertTo");
749
        scrMenuMgr->addMenuItem(scrActions["itemConvertToImageFrame"], "ItemConvertTo");
750
        scrMenuMgr->addMenuItem(scrActions["itemConvertToOutlines"], "ItemConvertTo");
751
        scrMenuMgr->addMenuItem(scrActions["itemConvertToPolygon"], "ItemConvertTo");
752
        scrMenuMgr->addMenuItem(scrActions["itemConvertToTextFrame"], "ItemConvertTo");
15109 cbradney 753
        scrMenuMgr->addMenuSeparator("Item");
754
        scrMenuMgr->addMenuItem(scrActions["toolsLinkTextFrame"], "Item");
755
        scrMenuMgr->addMenuItem(scrActions["toolsUnlinkTextFrame"], "Item");
756
        scrMenuMgr->addMenuSeparator("Item");
5800 fschmid 757
        scrMenuMgr->addMenuItem(scrActions["itemAttachTextToPath"], "Item");
758
        scrMenuMgr->addMenuItem(scrActions["itemDetachTextFromPath"], "Item");
11050 fschmid 759
//      scrMenuMgr->createMenu("ItemPathOps", tr("Path Tools"), "Item");
760
        scrMenuMgr->addMenuItem(scrActions["itemCombinePolygons"], "Item");
761
        scrMenuMgr->addMenuItem(scrActions["itemSplitPolygons"], "Item");
11067 cbradney 762
        //scrMenuMgr->setMenuEnabled("ItemShapes", false);
5800 fschmid 763
        scrActions["itemGroup"]->setEnabled(false);
764
        scrActions["itemUngroup"]->setEnabled(false);
765
        scrActions["itemAttachTextToPath"]->setEnabled(false);
766
        scrActions["itemDetachTextFromPath"]->setEnabled(false);
767
        scrActions["itemCombinePolygons"]->setEnabled(false);
768
        scrActions["itemSplitPolygons"]->setEnabled(false);
769
        scrActions["itemLock"]->setEnabled(false);
770
        scrActions["itemLockSize"]->setEnabled(false);
771
        scrActions["itemPrintingEnabled"]->setEnabled(false);
772
        scrActions["itemImageIsVisible"]->setEnabled(false);
14779 cbradney 773
        scrActions["styleImageEffects"]->setEnabled(false);
5800 fschmid 774
        scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
775
        scrActions["itemConvertToBezierCurve"]->setEnabled(false);
776
        scrActions["itemConvertToImageFrame"]->setEnabled(false);
777
        scrActions["itemConvertToOutlines"]->setEnabled(false);
778
        scrActions["itemConvertToPolygon"]->setEnabled(false);
779
        scrActions["itemConvertToTextFrame"]->setEnabled(false);
780
 
781
        //Insert menu
12940 cbradney 782
        scrMenuMgr->createMenu("Insert", ActionManager::defaultMenuNameEntryTranslated("Insert"));
6090 cbradney 783
        scrMenuMgr->addMenuItem(scrActions["insertFrame"], "Insert");
784
        scrMenuMgr->addMenuSeparator("Insert");
5800 fschmid 785
        scrMenuMgr->addMenuItem(scrActions["toolsInsertTextFrame"], "Insert");
786
        scrMenuMgr->addMenuItem(scrActions["toolsInsertImageFrame"], "Insert");
12616 cbradney 787
        scrMenuMgr->addMenuItem(scrActions["toolsInsertRenderFrame"], "Insert");
5800 fschmid 788
        scrMenuMgr->addMenuItem(scrActions["toolsInsertTableFrame"], "Insert");
789
        scrMenuMgr->addMenuItem(scrActions["toolsInsertShape"], "Insert");
790
        scrMenuMgr->addMenuItem(scrActions["toolsInsertPolygon"], "Insert");
791
        scrMenuMgr->addMenuItem(scrActions["toolsInsertLine"], "Insert");
792
        scrMenuMgr->addMenuItem(scrActions["toolsInsertBezier"], "Insert");
793
        scrMenuMgr->addMenuItem(scrActions["toolsInsertFreehandLine"], "Insert");
7400 cbradney 794
        scrMenuMgr->addMenuSeparator("Insert");
7350 fschmid 795
        scrMenuMgr->addMenuItem(scrActions["stickyTools"], "Insert");
5800 fschmid 796
        scrMenuMgr->addMenuSeparator("Insert");
797
        scrMenuMgr->addMenuItem(scrActions["insertGlyph"], "Insert");
798
 
10558 cbradney 799
        scrMenuMgr->createMenu("InsertChar", tr("&Character"), "Insert");
5800 fschmid 800
        scrMenuMgr->addMenuItem(scrActions["unicodePageNumber"], "InsertChar");
11713 fschmid 801
        scrMenuMgr->addMenuItem(scrActions["unicodePageCount"], "InsertChar");
5800 fschmid 802
        scrMenuMgr->addMenuItem(scrActions["unicodeSmartHyphen"], "InsertChar");
803
        scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingHyphen"], "InsertChar");
804
        scrMenuMgr->addMenuSeparator("InsertChar");
805
        scrMenuMgr->addMenuItem(scrActions["unicodeCopyRight"], "InsertChar");
806
        scrMenuMgr->addMenuItem(scrActions["unicodeRegdTM"], "InsertChar");
807
        scrMenuMgr->addMenuItem(scrActions["unicodeTM"], "InsertChar");
808
        scrMenuMgr->addMenuItem(scrActions["unicodeSolidus"], "InsertChar");
809
        scrMenuMgr->addMenuItem(scrActions["unicodeBullet"], "InsertChar");
810
        scrMenuMgr->addMenuItem(scrActions["unicodeMidpoint"], "InsertChar");
811
        scrMenuMgr->addMenuSeparator("InsertChar");
812
        scrMenuMgr->addMenuItem(scrActions["unicodeDashEm"], "InsertChar");
813
        scrMenuMgr->addMenuItem(scrActions["unicodeDashEn"], "InsertChar");
814
        scrMenuMgr->addMenuItem(scrActions["unicodeDashFigure"], "InsertChar");
815
        scrMenuMgr->addMenuItem(scrActions["unicodeDashQuotation"], "InsertChar");
816
 
10558 cbradney 817
        scrMenuMgr->createMenu("InsertQuote", tr("&Quote"), "Insert");
5800 fschmid 818
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteApostrophe"], "InsertQuote");
819
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteStraight"], "InsertQuote");
820
        scrMenuMgr->addMenuSeparator("InsertQuote");
821
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeft"], "InsertQuote");
822
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRight"], "InsertQuote");
823
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeft"], "InsertQuote");
824
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRight"], "InsertQuote");
825
        scrMenuMgr->addMenuSeparator("InsertQuote");
8755 cbradney 826
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleReversed"], "InsertQuote");
827
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleReversed"], "InsertQuote");
828
        scrMenuMgr->addMenuSeparator("InsertQuote");
5800 fschmid 829
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowSingleComma"], "InsertQuote");
830
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowDoubleComma"], "InsertQuote");
831
        scrMenuMgr->addMenuSeparator("InsertQuote");
832
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeftGuillemet"], "InsertQuote");
833
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRightGuillemet"], "InsertQuote");
834
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeftGuillemet"], "InsertQuote");
835
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRightGuillemet"], "InsertQuote");
836
        scrMenuMgr->addMenuSeparator("InsertQuote");
837
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleLeft"], "InsertQuote");
838
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleRight"], "InsertQuote");
839
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleLeft"], "InsertQuote");
840
        scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleRight"], "InsertQuote");
841
 
10558 cbradney 842
        scrMenuMgr->createMenu("InsertSpace", tr("S&paces && Breaks"), "Insert");
5800 fschmid 843
        scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingSpace"], "InsertSpace");
844
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEN"], "InsertSpace");
845
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEM"], "InsertSpace");
846
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThin"], "InsertSpace");
847
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThick"], "InsertSpace");
848
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceMid"], "InsertSpace");
849
        scrMenuMgr->addMenuItem(scrActions["unicodeSpaceHair"], "InsertSpace");
850
        scrMenuMgr->addMenuSeparator("InsertSpace");
851
        scrMenuMgr->addMenuItem(scrActions["unicodeNewLine"], "InsertSpace");
852
        scrMenuMgr->addMenuItem(scrActions["unicodeFrameBreak"], "InsertSpace");
853
        scrMenuMgr->addMenuItem(scrActions["unicodeColumnBreak"], "InsertSpace");
7038 avox 854
        scrMenuMgr->addMenuItem(scrActions["unicodeZerowidthSpace"], "InsertSpace");
5800 fschmid 855
 
10558 cbradney 856
        scrMenuMgr->createMenu("InsertLigature", tr("Liga&ture"), "Insert");
5800 fschmid 857
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ff"], "InsertLigature");
858
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fi"], "InsertLigature");
859
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fl"], "InsertLigature");
860
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffi"], "InsertLigature");
861
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffl"], "InsertLigature");
862
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ft"], "InsertLigature");
863
        scrMenuMgr->addMenuItem(scrActions["unicodeLigature_st"], "InsertLigature");
864
 
865
        scrMenuMgr->addMenuSeparator("Insert");
866
        scrMenuMgr->addMenuItem(scrActions["insertSampleText"], "Insert");
6115 cbradney 867
        scrActions["insertFrame"]->setEnabled(false);
5800 fschmid 868
 
869
        //Page menu
12940 cbradney 870
        scrMenuMgr->createMenu("Page", ActionManager::defaultMenuNameEntryTranslated("Page"));
5800 fschmid 871
        scrMenuMgr->addMenuItem(scrActions["pageInsert"], "Page");
872
        scrMenuMgr->addMenuItem(scrActions["pageImport"], "Page");
873
        scrMenuMgr->addMenuItem(scrActions["pageDelete"], "Page");
874
        scrMenuMgr->addMenuItem(scrActions["pageCopy"], "Page");
875
        scrMenuMgr->addMenuItem(scrActions["pageMove"], "Page");
876
        scrMenuMgr->addMenuItem(scrActions["pageApplyMasterPage"], "Page");
877
        scrMenuMgr->addMenuItem(scrActions["pageCopyToMasterPage"], "Page");
878
        scrMenuMgr->addMenuItem(scrActions["pageManageGuides"], "Page");
879
        scrMenuMgr->addMenuItem(scrActions["pageManageMargins"], "Page");
880
        scrMenuMgr->addMenuSeparator("Page");
881
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGrid"], "Page");
882
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGuides"], "Page");
883
        scrActions["pageDelete"]->setEnabled(false);
884
        scrActions["pageMove"]->setEnabled(false);
885
 
886
        //View menu
12940 cbradney 887
        scrMenuMgr->createMenu("View", ActionManager::defaultMenuNameEntryTranslated("View"));
5800 fschmid 888
        scrMenuMgr->addMenuItem(scrActions["viewFitInWindow"], "View");
7164 fschmid 889
        scrMenuMgr->addMenuItem(scrActions["viewFitWidth"], "View");
5800 fschmid 890
        scrMenuMgr->addMenuItem(scrActions["viewFit50"], "View");
891
        scrMenuMgr->addMenuItem(scrActions["viewFit75"], "View");
892
        scrMenuMgr->addMenuItem(scrActions["viewFit100"], "View");
893
        scrMenuMgr->addMenuItem(scrActions["viewFit200"], "View");
9744 jghali 894
        scrMenuMgr->addMenuItem(scrActions["viewFit400"], "View");
5800 fschmid 895
        scrMenuMgr->addMenuSeparator("View");
7587 cbradney 896
        scrMenuMgr->addMenuItem(scrActions["viewFitPreview"], "View");
897
        scrMenuMgr->addMenuSeparator("View");
5800 fschmid 898
        scrMenuMgr->addMenuItem(scrActions["viewShowMargins"], "View");
7051 fschmid 899
        scrMenuMgr->addMenuItem(scrActions["viewShowBleeds"], "View");
5800 fschmid 900
        scrMenuMgr->addMenuItem(scrActions["viewShowFrames"], "View");
901
        scrMenuMgr->addMenuItem(scrActions["viewShowLayerMarkers"], "View");
902
        scrMenuMgr->addMenuItem(scrActions["viewShowImages"], "View");
903
        scrMenuMgr->addMenuItem(scrActions["viewShowGrid"], "View");
904
        scrMenuMgr->addMenuItem(scrActions["viewShowGuides"], "View");
905
        scrMenuMgr->addMenuItem(scrActions["viewShowColumnBorders"], "View");
906
        scrMenuMgr->addMenuItem(scrActions["viewShowBaseline"], "View");
907
        scrMenuMgr->addMenuItem(scrActions["viewShowTextChain"], "View");
908
        scrMenuMgr->addMenuItem(scrActions["viewShowTextControls"], "View");
909
        scrMenuMgr->addMenuItem(scrActions["viewShowRulers"], "View");
910
        scrMenuMgr->addMenuItem(scrActions["viewRulerMode"], "View");
12754 fschmid 911
        scrMenuMgr->addMenuItem(scrActions["showMouseCoordinates"], "View");
5800 fschmid 912
 
913
        scrActions["viewShowRulers"]->setEnabled(false);
914
 
915
        //CB If this is viewNewView imeplemented, it should be on the windows menu
916
//      scrMenuMgr->addMenuItem(scrActions["viewNewView"], "View");
917
 
918
        //Tool menu
919
        /*
920
        scrMenuMgr->createMenu("Tools", tr("&Tools"));
921
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Tools");
922
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Tools");
923
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Tools");
924
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Tools");
925
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Tools");
926
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Tools");
927
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Tools");
928
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Tools");
929
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Tools");
930
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Tools");
931
        scrMenuMgr->addMenuSeparator("Tools");
932
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Tools");
933
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Tools");
934
        //scrActions["toolsPreflightVerifier"]->setEnabled(false);*/
935
 
936
        //Extra menu
12940 cbradney 937
        scrMenuMgr->createMenu("Extras", ActionManager::defaultMenuNameEntryTranslated("Extras"));
11439 cbradney 938
        scrMenuMgr->addMenuItem(scrActions["extrasManageImages"], "Extras");
5800 fschmid 939
        scrMenuMgr->addMenuItem(scrActions["extrasHyphenateText"], "Extras");
940
        scrMenuMgr->addMenuItem(scrActions["extrasDeHyphenateText"], "Extras");
941
        scrMenuMgr->addMenuItem(scrActions["extrasGenerateTableOfContents"], "Extras");
942
 
943
        scrMenuMgr->setMenuEnabled("Extras", false);
944
        scrActions["extrasHyphenateText"]->setEnabled(false);
945
        scrActions["extrasDeHyphenateText"]->setEnabled(false);
11129 subik 946
        connect(scrMenuMgr->getLocalPopupMenu("Extras"), SIGNAL(aboutToShow()), this, SLOT(extrasMenuAboutToShow()));
5800 fschmid 947
 
948
        //Window menu
12940 cbradney 949
         scrMenuMgr->createMenu("Windows", ActionManager::defaultMenuNameEntryTranslated("Windows"), QString::null, true);
5800 fschmid 950
        connect(scrMenuMgr->getLocalPopupMenu("Windows"), SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
951
        addDefaultWindowMenuItems();
952
 
953
        //Help menu
12940 cbradney 954
        scrMenuMgr->createMenu("Help", ActionManager::defaultMenuNameEntryTranslated("Help"));
7425 cbradney 955
        scrMenuMgr->addMenuItem(scrActions["helpManual"], "Help");
10051 cbradney 956
        scrMenuMgr->addMenuItem(scrActions["helpManual2"], "Help");
7425 cbradney 957
        scrMenuMgr->addMenuSeparator("Help");
958
        scrMenuMgr->addMenuItem(scrActions["helpTooltips"], "Help");
959
        scrMenuMgr->addMenuSeparator("Help");
10311 cbradney 960
        scrMenuMgr->addMenuItem(scrActions["helpOnlineWWW"], "Help");
961
        scrMenuMgr->addMenuItem(scrActions["helpOnlineDocs"], "Help");
962
        scrMenuMgr->addMenuItem(scrActions["helpOnlineWiki"], "Help");
10558 cbradney 963
        scrMenuMgr->createMenu("HelpOnlineTutorials", tr("Online &Tutorials"), "Help");
10325 cbradney 964
        scrMenuMgr->addMenuItem(scrActions["helpOnlineTutorial1"], "HelpOnlineTutorials");
10311 cbradney 965
        scrMenuMgr->addMenuSeparator("Help");
10913 jghali 966
        scrMenuMgr->addMenuItem(scrActions["helpCheckUpdates"], "Help");
967
        scrMenuMgr->addMenuSeparator("Help");
5800 fschmid 968
        scrMenuMgr->addMenuItem(scrActions["helpAboutScribus"], "Help");
969
        scrMenuMgr->addMenuItem(scrActions["helpAboutPlugins"], "Help");
970
        scrMenuMgr->addMenuItem(scrActions["helpAboutQt"], "Help");
10953 subik 971
 
5800 fschmid 972
        scrMenuMgr->addMenuToMenuBar("File");
973
        scrMenuMgr->addMenuToMenuBar("Edit");
974
        scrMenuMgr->addMenuToMenuBar("Item");
975
        scrMenuMgr->setMenuEnabled("Item", false);
976
        scrMenuMgr->addMenuToMenuBar("Insert");
977
        scrMenuMgr->setMenuEnabled("Insert", false);
978
        scrMenuMgr->addMenuToMenuBar("Page");
979
        scrMenuMgr->setMenuEnabled("Page", false);
980
        scrMenuMgr->addMenuToMenuBar("View");
981
        scrMenuMgr->setMenuEnabled("View", false);
982
        //scrMenuMgr->addMenuToMenuBar("Tools");
983
        scrMenuMgr->addMenuToMenuBar("Extras");
984
        scrMenuMgr->setMenuEnabled("Extras", false);
985
        scrMenuMgr->addMenuToMenuBar("Windows");
986
        //scrMenuMgr->setMenuEnabled("Windows", false);
10564 fschmid 987
        menuBar()->addSeparator();
5800 fschmid 988
        scrMenuMgr->addMenuToMenuBar("Help");
989
}
990
 
10532 avox 991
 
5800 fschmid 992
void ScribusMainWindow::addDefaultWindowMenuItems()
993
{
994
        scrMenuMgr->clearMenu("Windows");
995
        scrMenuMgr->addMenuItem(scrActions["windowsCascade"], "Windows");
996
        scrMenuMgr->addMenuItem(scrActions["windowsTile"], "Windows");
997
        scrMenuMgr->addMenuSeparator("Windows");
998
 
999
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Windows");
1000
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Windows");
1001
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Windows");
1002
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Windows");
1003
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Windows");
1004
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Windows");
1005
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Windows");
1006
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Windows");
1007
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Windows");
1008
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Windows");
1009
        scrMenuMgr->addMenuSeparator("Windows");
1010
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Windows");
1011
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Windows");
1012
}
1013
 
1014
 
1015
void ScribusMainWindow::initStatusBar()
1016
{
10564 fschmid 1017
        mainWindowStatusLabel = new QLabel( "           ", statusBar());
9953 cbradney 1018
        mainWindowProgressBar = new QProgressBar(statusBar());
1019
        mainWindowProgressBar->setAlignment(Qt::AlignHCenter);
5800 fschmid 1020
        mainWindowProgressBar->setFixedWidth( 100 );
1021
        mainWindowProgressBar->reset();
12904 jghali 1022
        mainWindowXPosLabel = new QLabel( tr("X-Pos:"), statusBar());
1023
        mainWindowYPosLabel = new QLabel( tr("Y-Pos:"), statusBar());
10564 fschmid 1024
        mainWindowXPosDataLabel = new QLabel( "        ", statusBar());
1025
        mainWindowYPosDataLabel = new QLabel( "        ", statusBar());
5800 fschmid 1026
 
10564 fschmid 1027
        statusBar()->addPermanentWidget(mainWindowStatusLabel, 6);
1028
        statusBar()->addPermanentWidget(mainWindowProgressBar, 0);
1029
        statusBar()->addPermanentWidget(mainWindowXPosLabel, 0);
1030
        statusBar()->addPermanentWidget(mainWindowXPosDataLabel, 1);
1031
        statusBar()->addPermanentWidget(mainWindowYPosLabel, 0);
1032
        statusBar()->addPermanentWidget(mainWindowYPosDataLabel, 1);
5800 fschmid 1033
}
1034
 
10532 avox 1035
 
5800 fschmid 1036
void ScribusMainWindow::setStatusBarMousePosition(double xp, double yp)
1037
{
1038
        double xn = xp;
1039
        double yn = yp;
1040
        if (doc->guidesSettings.rulerMode)
1041
        {
1042
                xn -= doc->currentPage()->xOffset();
1043
                yn -= doc->currentPage()->yOffset();
1044
        }
1045
        xn -= doc->rulerXoffset;
1046
        yn -= doc->rulerYoffset;
12652 cbradney 1047
        mainWindowXPosDataLabel->setText(value2String(xn, doc->unitIndex(), true, true));
1048
        mainWindowYPosDataLabel->setText(value2String(yn, doc->unitIndex(), true, true));
5800 fschmid 1049
}
1050
 
15468 craig 1051
void ScribusMainWindow::setStatusBarTextPosition(double base, double xp)
1052
{
1053
        mainWindowXPosDataLabel->setText(base + xp >= 0? value2String(xp, doc->unitIndex(), true, true): QString("-"));
1054
        mainWindowYPosDataLabel->setText("-");
1055
}
10532 avox 1056
 
5800 fschmid 1057
void ScribusMainWindow::setStatusBarInfoText(QString newText)
1058
{
1059
        if (mainWindowStatusLabel)
1060
                mainWindowStatusLabel->setText(newText);
1061
}
1062
 
10532 avox 1063
 
1064
//AV to be replaced with Selection::update and listener in PropertiesPalette
5800 fschmid 1065
void ScribusMainWindow::setTBvals(PageItem *currItem)
1066
{
1067
        if (currItem->itemText.length() != 0)
1068
        {
8562 jghali 1069
//              int ChPos = qMin(currItem->CPos, static_cast<int>(currItem->itemText.length()-1));
12715 pierre 1070
                const ParagraphStyle& currPStyle( (doc->appMode == modeEdit) ? currItem->currentStyle() : currItem->itemText.defaultStyle());
5800 fschmid 1071
                setAbsValue(currPStyle.alignment());
6866 avox 1072
                propertiesPalette->setParStyle(currPStyle.parent());
9607 avox 1073
                propertiesPalette->setCharStyle(currItem->currentCharStyle().parent());
9067 avox 1074
                doc->currentStyle = currItem->currentStyle();
13615 jghali 1075
                // #8112 : do not use operator= here as it does not update style features
1076
                doc->currentStyle.charStyle().setStyle( currItem->currentCharStyle() );
9067 avox 1077
                emit TextStyle(doc->currentStyle);
1078
                // to go: (av)
5800 fschmid 1079
                emit TextUnderline(doc->currentStyle.charStyle().underlineOffset(), doc->currentStyle.charStyle().underlineWidth());
1080
                emit TextStrike(doc->currentStyle.charStyle().strikethruOffset(), doc->currentStyle.charStyle().strikethruWidth());
1081
                emit TextShadow(doc->currentStyle.charStyle().shadowXOffset(), doc->currentStyle.charStyle().shadowYOffset());
7087 subik 1082
                emit TextFarben(doc->currentStyle.charStyle().strokeColor(),
1083
                                                doc->currentStyle.charStyle().fillColor(),
1084
                                                doc->currentStyle.charStyle().strokeShade(),
5800 fschmid 1085
                                                doc->currentStyle.charStyle().fillShade());
5980 avox 1086
                emit TextIFont(doc->currentStyle.charStyle().font().scName());
5800 fschmid 1087
                emit TextISize(doc->currentStyle.charStyle().fontSize());
1088
                emit TextUSval(doc->currentStyle.charStyle().tracking());
1089
                emit TextStil(doc->currentStyle.charStyle().effects());
1090
                emit TextScale(doc->currentStyle.charStyle().scaleH());
1091
                emit TextScaleV(doc->currentStyle.charStyle().scaleV());
1092
                emit TextBase(doc->currentStyle.charStyle().baselineOffset());
1093
                emit TextOutline(doc->currentStyle.charStyle().outlineWidth());
1094
        }
1095
}
1096
 
1097
//Special keys assigned to actions are stolen by the action and not passed to
1098
//keyPressEvent so process them here.
8080 cbradney 1099
void ScribusMainWindow::specialActionKeyEvent(const QString& actionName, int unicodevalue)
5800 fschmid 1100
{
1101
        if (HaveDoc)
1102
        {
1103
                if (doc->appMode==modeEdit)
1104
                {
1105
                        if (doc->m_Selection->count() == 1)
1106
                        {
1107
                                PageItem *currItem = doc->m_Selection->itemAt(0);
1108
                                if (currItem!=NULL)
1109
                                {
1110
                                        if (unicodevalue!=-1)
1111
                                        {
1112
                                                if (currItem->HasSel && currItem->itemType()==PageItem::TextFrame)
16342 mrdocs 1113
                                                {
1114
                                                        currItem->oldCPos = currItem->itemText.startOfSelection();
1115
                                                        currItem->itemTextSaxed = currItem->getItemTextSaxed(PageItem::SELECTION);
5800 fschmid 1116
                                                        currItem->asTextFrame()->deleteSelectedTextFromFrame();
16342 mrdocs 1117
                                                }
1118
                                                else
16638 jghali 1119
                                                        currItem->oldCPos = currItem->itemText.cursorPosition();
1120
                                                currItem->itemText.insertChars(QString(QChar(unicodevalue)), true);
16342 mrdocs 1121
                                                if (currItem->itemTextSaxed.isEmpty())
1122
                                                        currItem->asTextFrame()->updateUndo(PageItem::INS, QString(QChar(unicodevalue)));
1123
                                                else
1124
                                                        currItem->asTextFrame()->updateUndo(PageItem::REPSAX, currItem->getTextSaxed(QString(QChar(unicodevalue))));
8177 avox 1125
//                                              currItem->Tinput = true;
10532 avox 1126
                                                currItem->update();
5800 fschmid 1127
                                        }
1128
                                        else if (actionName=="unicodeSmartHyphen") //ignore the char as we use an attribute if the text item, for now.
1129
                                        {
7087 subik 1130
                                                // this code is currently dead since unicodeSmartHyphen
6999 avox 1131
                                                // doesnt have unicodevalue == -1 any more
16638 jghali 1132
                                                if (currItem->itemText.cursorPosition() - 1 > 0)
5800 fschmid 1133
                                                {
7442 avox 1134
#if 0
16638 jghali 1135
                                                        StyleFlag fl = currItem->itemText.item(qMax(currItem->itemText.cursorPosition()-1,0))->effects();
5800 fschmid 1136
                                                        fl |= ScStyle_HyphenationPossible;
8562 jghali 1137
                                                        currItem->itemText.item(qMax(currItem->CPos-1,0))->setEffects(fl);
5800 fschmid 1138
#else
16638 jghali 1139
                                                        currItem->oldCPos = currItem->itemText.cursorPosition() ;
1140
                                                        currItem->itemText.insertChars(QString(SpecialChars::SHYPHEN), true);
16342 mrdocs 1141
                                                        currItem->asTextFrame()->updateUndo(PageItem::INS, QString(SpecialChars::SHYPHEN));
5800 fschmid 1142
#endif
8177 avox 1143
//                                                      currItem->Tinput = true;
10532 avox 1144
                                                        currItem->update();
5800 fschmid 1145
                                                }
1146
                                        }
1147
                                }
1148
                        }
1149
                }
1150
        }
1151
}
1152
 
1153
bool ScribusMainWindow::eventFilter( QObject* /*o*/, QEvent *e )
1154
{
1155
        bool retVal;
9562 fschmid 1156
        if (e->type() == QEvent::ToolTip)
1157
        {
12476 cbradney 1158
                return (!prefsManager->appPrefs.showToolTips);
9562 fschmid 1159
        }
11960 subik 1160
        if ( e->type() == QEvent::KeyPress )
11893 cbradney 1161
        {
5800 fschmid 1162
                QKeyEvent *k = (QKeyEvent *)e;
1163
                int keyMod=0;
10390 cbradney 1164
                if (k->modifiers() & Qt::ShiftModifier)
8523 cbradney 1165
                        keyMod |= Qt::SHIFT;
10390 cbradney 1166
                if (k->modifiers() & Qt::ControlModifier)
8523 cbradney 1167
                        keyMod |= Qt::CTRL;
10390 cbradney 1168
                if (k->modifiers() & Qt::AltModifier)
8523 cbradney 1169
                        keyMod |= Qt::ALT;
5800 fschmid 1170
 
1171
                QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
1172
                if (QString(currKeySeq).isNull())
1173
                        return false;
1174
                retVal=true;
1175
                //Palette actions
10564 fschmid 1176
                if (currKeySeq == scrActions["specialToggleAllPalettes"]->shortcut())
8613 cbradney 1177
                        scrActions["specialToggleAllPalettes"]->activate(QAction::Trigger);
5800 fschmid 1178
                else
15303 cbradney 1179
                if (currKeySeq == scrActions["specialToggleAllGuides"]->shortcut())
1180
                        scrActions["specialToggleAllGuides"]->activate(QAction::Trigger);
1181
                else
10390 cbradney 1182
// CB These were moved to ActionManager via the setShortcutContext(Qt::ApplicationShortcut) calls, leaving for notes for now
10181 cbradney 1183
//              if (currKeySeq == scrActions["toolsProperties"]->accel())
1184
//                      scrActions["toolsProperties"]->toggle();
1185
//              else
1186
//              if (currKeySeq == scrActions["toolsOutline"]->accel())
1187
//                      scrActions["toolsOutline"]->toggle();
1188
//              else
1189
//              if (currKeySeq == scrActions["toolsScrapbook"]->accel())
1190
//                      scrActions["toolsScrapbook"]->toggle();
1191
//              else
1192
//              if (currKeySeq == scrActions["toolsLayers"]->accel())
1193
//                      scrActions["toolsLayers"]->toggle();
1194
//              else
1195
//              if (currKeySeq == scrActions["toolsPages"]->accel())
1196
//                      scrActions["toolsPages"]->toggle();
1197
//              else
1198
//              if (currKeySeq == scrActions["toolsBookmarks"]->accel())
1199
//                      scrActions["toolsBookmarks"]->toggle();
1200
//              else
1201
//              if (currKeySeq == scrActions["toolsActionHistory"]->accel())
1202
//                      scrActions["toolsActionHistory"]->toggle();
1203
//              else
1204
//              if (currKeySeq == scrActions["toolsPreflightVerifier"]->accel())
1205
//                      scrActions["toolsPreflightVerifier"]->toggle();
1206
//              else
1207
//              if (currKeySeq == scrActions["toolsAlignDistribute"]->accel())
1208
//                      scrActions["toolsAlignDistribute"]->toggle();
1209
//              else
8005 cbradney 1210
                //Edit actions
15723 fschmid 1211
// commented out to fix Bug #9437
1212
/*              if (currKeySeq == scrActions["editStyles"]->shortcut())
8005 cbradney 1213
                        scrActions["editStyles"]->toggle();
1214
                else
10564 fschmid 1215
                if (currKeySeq == scrActions["editUndoAction"]->shortcut() && scrActions["editUndoAction"]->isEnabled())
8613 cbradney 1216
                        scrActions["editUndoAction"]->activate(QAction::Trigger);
5800 fschmid 1217
                else
10564 fschmid 1218
                if (currKeySeq == scrActions["editRedoAction"]->shortcut() && scrActions["editRedoAction"]->isEnabled())
8613 cbradney 1219
                        scrActions["editRedoAction"]->activate(QAction::Trigger);
5800 fschmid 1220
                else
1221
                //Other actions
10564 fschmid 1222
                if (currKeySeq == scrActions["fileQuit"]->shortcut())
8613 cbradney 1223
                        scrActions["fileQuit"]->activate(QAction::Trigger);
5800 fschmid 1224
                else
1225
                //Zoom actions
10564 fschmid 1226
                if (currKeySeq == scrActions["toolsZoomIn"]->shortcut())
8613 cbradney 1227
                        scrActions["toolsZoomIn"]->activate(QAction::Trigger);
5800 fschmid 1228
                else
10564 fschmid 1229
                if (currKeySeq == scrActions["toolsZoomOut"]->shortcut())
8613 cbradney 1230
                        scrActions["toolsZoomOut"]->activate(QAction::Trigger);
15723 fschmid 1231
                else */
5800 fschmid 1232
                        retVal=false;
1233
        }
1234
        else
1235
                retVal=false;
1236
        //Return false to pass event to object
1237
        return retVal;
1238
}
1239
 
10532 avox 1240
 
1241
//AV -> CanvasMode
5800 fschmid 1242
void ScribusMainWindow::keyPressEvent(QKeyEvent *k)
1243
{
1244
        QWidgetList windows;
1245
        QWidget* w = NULL;
1246
        int kk = k->key();
1247
        QString uc = k->text();
11146 cbradney 1248
//      QString cr, Tcha, Twort;
7435 fschmid 1249
        if (HaveDoc)
1250
        {
8523 cbradney 1251
                if ((doc->appMode == modeMagnifier) && (kk == Qt::Key_Shift))
7435 fschmid 1252
                {
18921 jghali 1253
                        view->setCursor(QCursor(loadIcon("LupeZm.xpm")));
7435 fschmid 1254
                        return;
1255
                }
1256
        }
5800 fschmid 1257
        if (keyrep)
1258
                return;
1259
        keyrep = true;
10390 cbradney 1260
        int keyMod=0;
1261
        if (k->modifiers() & Qt::ShiftModifier)
1262
                keyMod |= Qt::SHIFT;
1263
        if (k->modifiers() & Qt::ControlModifier)
1264
                keyMod |= Qt::CTRL;
1265
        if (k->modifiers() & Qt::AltModifier)
1266
                keyMod |= Qt::ALT;
5800 fschmid 1267
        //User presses escape and we have a doc open, and we have an item selected
8523 cbradney 1268
        if ((kk == Qt::Key_Escape) && (HaveDoc))
5800 fschmid 1269
        {
1270
                keyrep = false;
1271
                PageItem *currItem;
1272
                if (doc->m_Selection->count() != 0)
1273
                {
1274
                        currItem = doc->m_Selection->itemAt(0);
1275
                        switch (doc->appMode)
1276
                        {
1277
                                case modeNormal:
10532 avox 1278
                                case modeEditClip:
5800 fschmid 1279
                                        currItem->Sizing = false;
1280
                                        if (doc->SubMode != -1)
1281
                                        {
1282
                                                view->Deselect(false);
9856 fschmid 1283
                                                doc->Items->removeAt(currItem->ItemNr);
5800 fschmid 1284
                                        }
5967 fschmid 1285
                                        else
1286
                                                view->Deselect(false);
11576 avox 1287
                                        view->cancelGroupTransaction();
5800 fschmid 1288
                                        break;
7436 fschmid 1289
                                case modeEdit:
11576 avox 1290
                                        view->cancelGroupTransaction();
7436 fschmid 1291
                                        break;
5800 fschmid 1292
                                case modeLinkFrames:
1293
                                case modeUnlinkFrames:
1294
                                case modeRotation:
1295
                                case modeEditGradientVectors:
8942 cbradney 1296
                                case modeCopyProperties:
5800 fschmid 1297
                                        view->Deselect(false);
12022 cbradney 1298
                                case modeEyeDropper:
12971 jghali 1299
                                case modeImportObject:
5800 fschmid 1300
                                case modePanning:
11490 avox 1301
                                        view->requestMode(modeNormal);
5800 fschmid 1302
                                        break;
1303
                                case modeDrawBezierLine:
11672 cbradney 1304
                                        currItem->PoLine.resize(qMax(0, static_cast<int>(currItem->PoLine.size())-2));
5800 fschmid 1305
                                        if (currItem->PoLine.size() < 4)
1306
                                        {
1307
                                                view->Deselect(false);
9856 fschmid 1308
                                                doc->Items->removeAt(currItem->ItemNr);
5800 fschmid 1309
                                        }
1310
                                        else
1311
                                        {
7736 cbradney 1312
                                                doc->SizeItem(currItem->PoLine.WidthHeight().x(), currItem->PoLine.WidthHeight().y(), currItem->ItemNr, false, false);
8591 cbradney 1313
                                                currItem->setPolyClip(qRound(qMax(currItem->lineWidth() / 2.0, 1.0)));
7736 cbradney 1314
                                                doc->AdjustItemSize(currItem);
5800 fschmid 1315
                                                currItem->ContourLine = currItem->PoLine.copy();
1316
                                                currItem->ClipEdited = true;
1317
                                                currItem->FrameType = 3;
1318
                                                slotDocCh();
1319
                                        }
1320
                                        view->FirstPoly = true;
1321
                                        break;
1322
                                default:
11704 fschmid 1323
                                        if (currItem->Sizing)
1324
                                        {
1325
                                                view->Deselect(false);
1326
                                                doc->Items->removeAt(currItem->ItemNr);
1327
                                        }
5800 fschmid 1328
                                        break;
1329
                        }
1330
                }
1331
                doc->DragP = false;
1332
                doc->leaveDrag = false;
10532 avox 1333
                view->stopAllDrags();
5800 fschmid 1334
                doc->SubMode = -1;
1335
                doc->ElemToLink = NULL;
1336
                slotSelect();
11704 fschmid 1337
                if (doc->m_Selection->count() == 0)
1338
                        HaveNewSel(-1);
11606 fschmid 1339
                prefsManager->appPrefs.stickyTools = false;
1340
                scrActions["stickyTools"]->setChecked(prefsManager->appPrefs.stickyTools);
5800 fschmid 1341
                return;
1342
        }
10390 cbradney 1343
        Qt::KeyboardModifiers buttonModifiers = k->modifiers();
5800 fschmid 1344
        /**If we have a doc and we are not changing the page or zoom level in the status bar */
1345
        if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
1346
        {
11146 cbradney 1347
                //Show our context menu
1348
                QKeySequence currKeySeq = QKeySequence(kk | keyMod);
11149 cbradney 1349
                if (currKeySeq.matches(scrActions["viewShowContextMenu"]->shortcut()) == QKeySequence::ExactMatch)
11146 cbradney 1350
                {
1351
                        ContextMenu* cmen=NULL;
1352
                        if (doc->m_Selection->count() == 0)
1353
                        {
1354
                                //CB We should be able to get this calculated by the canvas.... it is already in m_canvas->globalToCanvas(m->globalPos());
1355
                                QPoint p(QCursor::pos() - mapToGlobal(QPoint(0,0)));
1356
                                FPoint fp(p.x() / view->scale() + doc->minCanvasCoordinate.x(),
11960 subik 1357
                                p.y() / view->scale() + doc->minCanvasCoordinate.y());
11146 cbradney 1358
                                cmen = new ContextMenu(this, doc, fp.x(), fp.y());
1359
                        }
1360
                        else
1361
                                cmen = new ContextMenu(*(doc->m_Selection), this, doc);
1362
                        if (cmen)
1363
                        {
1364
                                setUndoMode(true);
1365
                                cmen->exec(QCursor::pos());
1366
                                setUndoMode(false);
1367
                        }
1368
                        delete cmen;
1369
                }
11960 subik 1370
 
1371
 
5800 fschmid 1372
                /**
1373
                 * With no item selected we can:
1374
                 * - With space, get into panning mode (modePanning)
1375
                 * - With PageUp, scroll up
1376
                 * - With PageDown, scroll down
1377
                 * - With Tab, change active document windowActivated
1378
                 */
1379
 
1380
                if ((doc->appMode != modeEdit) && (doc->m_Selection->count() == 0))
1381
                {
6284 fschmid 1382
                        int pg;
8970 fschmid 1383
                        int wheelVal = prefsManager->mouseWheelValue();
10390 cbradney 1384
                        if ((buttonModifiers & Qt::ShiftModifier) && !(buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
8970 fschmid 1385
                                wheelVal = qMax(qRound(wheelVal / 10.0), 1);
5800 fschmid 1386
                        switch (kk)
1387
                        {
8523 cbradney 1388
                        case Qt::Key_Space:
5800 fschmid 1389
                                keyrep = false;
1390
                                if (doc->appMode == modePanning)
10532 avox 1391
                                        view->requestMode(modeNormal);
5800 fschmid 1392
                                else
10532 avox 1393
                                        view->requestMode(modePanning);
5800 fschmid 1394
                                return;
1395
                                break;
10564 fschmid 1396
                        case Qt::Key_PageUp:
6284 fschmid 1397
                                if (doc->masterPageMode())
1398
                                        view->scrollBy(0, -prefsManager->mouseWheelValue());
1399
                                else
1400
                                {
1401
                                        pg = doc->currentPageNumber();
10390 cbradney 1402
                                        if ((buttonModifiers & Qt::ShiftModifier) && !(buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
6284 fschmid 1403
                                                pg--;
1404
                                        else
1405
                                                pg -= doc->pageSets[doc->currentPageLayout].Columns;
1406
                                        if (pg > -1)
1407
                                                view->GotoPage(pg);
1408
                                }
5800 fschmid 1409
                                keyrep = false;
1410
                                return;
1411
                                break;
10564 fschmid 1412
                        case Qt::Key_PageDown:
6284 fschmid 1413
                                if (doc->masterPageMode())
1414
                                        view->scrollBy(0, prefsManager->mouseWheelValue());
1415
                                else
1416
                                {
1417
                                        pg = doc->currentPageNumber();
10390 cbradney 1418
                                        if ((buttonModifiers & Qt::ShiftModifier) && !(buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
6284 fschmid 1419
                                                pg++;
1420
                                        else
1421
                                                pg += doc->pageSets[doc->currentPageLayout].Columns;
7328 fschmid 1422
                                        if (pg < static_cast<int>(doc->Pages->count()))
6284 fschmid 1423
                                                view->GotoPage(pg);
1424
                                }
5800 fschmid 1425
                                keyrep = false;
1426
                                return;
1427
                                break;
8970 fschmid 1428
                        case Qt::Key_Left:
1429
                                view->scrollBy(-wheelVal, 0);
1430
                                keyrep = false;
1431
                                return;
1432
                                break;
1433
                        case Qt::Key_Right:
1434
                                view->scrollBy(wheelVal, 0);
1435
                                keyrep = false;
1436
                                return;
1437
                                break;
1438
                        case Qt::Key_Up:
1439
                                view->scrollBy(0, -wheelVal);
1440
                                keyrep = false;
1441
                                return;
1442
                                break;
1443
                        case Qt::Key_Down:
1444
                                view->scrollBy(0, wheelVal);
1445
                                keyrep = false;
1446
                                return;
1447
                                break;
8523 cbradney 1448
                        case Qt::Key_Tab:
14035 jghali 1449
                                if (buttonModifiers == Qt::ControlModifier)
5800 fschmid 1450
                                {
14035 jghali 1451
                                        keyrep = false;
1452
                                        windows = wsp->windowList();
1453
                                        if (windows.count() > 1)
5800 fschmid 1454
                                        {
14035 jghali 1455
                                                for (int i = 0; i < static_cast<int>(windows.count()); ++i)
5800 fschmid 1456
                                                {
14035 jghali 1457
                                                        if (wsp->activeWindow() == windows.at(i))
1458
                                                        {
1459
                                                                if (i == static_cast<int>(windows.count()-1))
1460
                                                                        w = windows.at(0);
1461
                                                                else
1462
                                                                        w = windows.at(i+1);
1463
                                                                break;
1464
                                                        }
5800 fschmid 1465
                                                }
14035 jghali 1466
                                                outlinePalette->buildReopenVals();
1467
                                                docCheckerPalette->clearErrorList();
1468
                                                if ( w )
1469
                                                        w->showNormal();
1470
                                                newActWin(w);
5800 fschmid 1471
                                        }
14035 jghali 1472
                                        return;
5800 fschmid 1473
                                }
1474
                                break;
1475
                        }
1476
                }
1477
                /** Now if we have an item selected
1478
                 * - In normal mode we can:
1479
                 * -- Use backspace or delete to delete the item
13142 cbradney 1480
                 * -- Use itemRaise action shortcut to raise an item (actionmanager.cpp connect, no code here)
1481
                 * -- Use itemLower action shortcut to lower an item (actionmanager.cpp connect, no code here)
6083 cbradney 1482
                 * -- Use the arrow keys to move an item or group around for !inches:
5800 fschmid 1483
                                With no meta, by 1.0 unit
5975 cbradney 1484
                                Ctrl, by 10.0 units
1485
                                Shift by 0.1 units
1486
                                Ctrl Shift 0.01 units
6083 cbradney 1487
                        - For inches:
1488
                                With no meta, by 1.0 pt
1489
                                Ctrl, by 1.0 unit
1490
                                Shift by 0.1 units
1491
                                Ctrl Shift 0.01 units
5800 fschmid 1492
                 * -- Use the arrow keys to resize an item:
1493
                                Alt right arrow, move right side outwards (expand)
1494
                                Alt left arrow, move left side outwards (expand)
1495
                                Alt Shift right arrow, move left side inwards (shrink)
1496
                                Alt Shift left arrow, move right side inwards (shrink)
1497
                 * -- In edit mode of an image frame, use the arrow keys to resize the image:
1498
                                (flows to pageitem_imageframe for control)
1499
                                Alt right arrow, move right side of image outwards (expand)
1500
                                Alt left arrow, move right side inwards (shrink)
1501
                                Alt down arrow, move bottom side downwards (expand)
1502
                                Alt up arrow, move top side inwards (shrink)
1503
                 */
1504
                if (doc->m_Selection->count() != 0)
1505
                {
1506
                        double moveBy=1.0;
6083 cbradney 1507
                        if (doc->unitIndex()!=SC_INCHES)
1508
                        {
10390 cbradney 1509
                                if ((buttonModifiers & Qt::ShiftModifier) && !(buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
6083 cbradney 1510
                                        moveBy=0.1;
10390 cbradney 1511
                                else if (!(buttonModifiers & Qt::ShiftModifier) && (buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
6083 cbradney 1512
                                        moveBy=10.0;
10390 cbradney 1513
                                else if ((buttonModifiers & Qt::ShiftModifier) && (buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
6083 cbradney 1514
                                        moveBy=0.01;
7087 subik 1515
 
6083 cbradney 1516
                                moveBy/=doc->unitRatio();//Lets allow movement by the current doc ratio, not only points
1517
                        }
1518
                        else
1519
                        {
10390 cbradney 1520
                                if ((buttonModifiers & Qt::ShiftModifier) && !(buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
6083 cbradney 1521
                                        moveBy=0.1/doc->unitRatio();
10390 cbradney 1522
                                else if (!(buttonModifiers & Qt::ShiftModifier) && (buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
6083 cbradney 1523
                                        moveBy=1.0/doc->unitRatio();
10390 cbradney 1524
                                else if ((buttonModifiers & Qt::ShiftModifier) && (buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
6083 cbradney 1525
                                        moveBy=0.01/doc->unitRatio();
1526
                        }
10390 cbradney 1527
                        bool resizing=((buttonModifiers & Qt::AltModifier) && !(buttonModifiers & Qt::ControlModifier));
1528
                        bool resizingsmaller=(resizing && (buttonModifiers & Qt::ShiftModifier));
5800 fschmid 1529
                        double resizeBy=1.0;
1530
                        //CB with control locked out due to the requirement of moveby of 0.01, we cannot support
1531
                        //resizeby 10 units unless we move to supporting modifier keys that most people dont have.
10537 cbradney 1532
                        //if (buttonModifiers & Qt::ControlModifier)
5800 fschmid 1533
                        //      resizeBy*=10.0;
1534
                        resizeBy/=doc->unitRatio();
1535
                        if (resizingsmaller)
1536
                                resizeBy*=-1.0;
1537
 
1538
 
1539
                        PageItem *currItem = doc->m_Selection->itemAt(0);
1540
                        switch (doc->appMode)
1541
                        {
1542
                        case modeNormal:
10532 avox 1543
                        case modeEditClip:
5800 fschmid 1544
                                switch (kk)
1545
                                {
8523 cbradney 1546
                                case Qt::Key_Backspace:
1547
                                case Qt::Key_Delete:
5800 fschmid 1548
                                        doc->itemSelection_DeleteItem();
1549
                                        break;
13142 cbradney 1550
                                        /* CB: Stop using inflexible hardcoded keys here, actions for lower/raise work without this
1551
                                                per note above with shortcuts.
10564 fschmid 1552
                                case Qt::Key_PageUp:
5800 fschmid 1553
                                        if (!currItem->locked())
1554
                                        {
1555
                                                view->RaiseItem();
1556
                                        }
1557
                                        break;
10564 fschmid 1558
                                case Qt::Key_PageDown:
5800 fschmid 1559
                                        if (!currItem->locked())
1560
                                        {
1561
                                                view->LowerItem();
1562
                                        }
1563
                                        break;
13142 cbradney 1564
                                        */
8523 cbradney 1565
                                case Qt::Key_Left:
5800 fschmid 1566
                                        if (!currItem->locked())
1567
                                        {
1568
                                                if (!resizing)
1569
                                                {
10532 avox 1570
                                                        if ((doc->appMode == modeEditClip) && (doc->nodeEdit.hasNodeSelected()))
5800 fschmid 1571
                                                        {
10532 avox 1572
                                                                int storedClRe = doc->nodeEdit.ClRe;
1573
                                                                if ((doc->nodeEdit.SelNode.count() != 0) && (doc->nodeEdit.EdPoints))
9735 fschmid 1574
                                                                {
16975 fschmid 1575
                                                                        QPolygonF poly;
10532 avox 1576
                                                                        for (int itm = 0; itm < doc->nodeEdit.SelNode.count(); ++itm)
9735 fschmid 1577
                                                                        {
1578
                                                                                FPoint np;
10532 avox 1579
                                                                                int clRe = doc->nodeEdit.SelNode.at(itm);
11395 fschmid 1580
                                                                                if (doc->nodeEdit.isContourLine)
1581
                                                                                        np = currItem->ContourLine.point(clRe);
1582
                                                                                else
1583
                                                                                        np = currItem->PoLine.point(clRe);
1584
                                                                                doc->nodeEdit.ClRe = clRe;
1585
                                                                                np = np - FPoint(moveBy, 0);
1586
                                                                                doc->nodeEdit.moveClipPoint(currItem, np);
16975 fschmid 1587
                                                                                poly.append(QPointF(np.x(), np.y()));
9735 fschmid 1588
                                                                        }
16975 fschmid 1589
                                                                        QMatrix m = currItem->getTransform();
1590
                                                                        poly = m.map(poly);
1591
                                                                        QRectF oldR = poly.boundingRect().adjusted(-5, -5, 10, 10);
1592
                                                                        QRectF newR(currItem->getBoundingRect());
1593
                                                                        doc->regionsChanged()->update(newR.unite(oldR));
9735 fschmid 1594
                                                                }
10532 avox 1595
                                                                doc->nodeEdit.ClRe = storedClRe;
5800 fschmid 1596
                                                        }
1597
                                                        else
1598
                                                        {
1599
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1600
                                                        /* as the user might be trying to fine tune a position */
1601
                                                                bool sav1 = doc->SnapGuides;
1602
                                                                bool sav2 = doc->useRaster;
1603
                                                                doc->SnapGuides = false;
1604
                                                                doc->useRaster = false;
11490 avox 1605
                                                                if (doc->m_Selection->count() > 1)
1606
                                                                        view->startGroupTransaction(Um::Move, "", Um::IMove);
1607
                                                                doc->moveGroup(-moveBy, 0);
1608
                                                                if (doc->m_Selection->count() > 1)
1609
                                                                        view->endGroupTransaction();
5800 fschmid 1610
                                                                doc->SnapGuides = sav1;
1611
                                                                doc->useRaster = sav2;
1612
                                                        }
1613
                                                }
1614
                                                else
1615
                                                {
1616
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
10532 avox 1617
                                                        if(doc->nodeEdit.isContourLine)
5800 fschmid 1618
                                                                view->TransformPoly(10, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
16889 jghali 1619
                                                        else if (!currItem->sizeLocked())
5800 fschmid 1620
                                                        {
16889 jghali 1621
                                                                if (!resizingsmaller)
5800 fschmid 1622
                                                                {
7736 cbradney 1623
                                                                        doc->MoveItem(-resizeBy, 0, currItem, false);
16889 jghali 1624
                                                                        currItem->moveImageXYOffsetBy(resizeBy / currItem->imageXScale(), 0);
5800 fschmid 1625
                                                                }
16889 jghali 1626
                                                                currItem->Sizing = false;
1627
                                                                doc->SizeItem(currItem->width() + resizeBy, currItem->height(), currItem->ItemNr);
5800 fschmid 1628
                                                        }
1629
                                                }
17151 jghali 1630
                                                if (doc->m_Selection->count() > 1)
1631
                                                {
1632
                                                        double x, y, w, h;
1633
                                                        doc->m_Selection->setGroupRect();
1634
                                                        doc->m_Selection->getGroupRect(&x, &y, &w, &h);
1635
                                                        propertiesPalette->setXY(x, y);
1636
                                                        propertiesPalette->setBH(w, h);
1637
                                                }
10532 avox 1638
                                                currItem->update();
5800 fschmid 1639
                                                slotDocCh();
1640
                                        }
1641
                                        break;
8523 cbradney 1642
                                case Qt::Key_Right:
5800 fschmid 1643
                                        if (!currItem->locked())
1644
                                        {
1645
                                                if (!resizing)
1646
                                                {
10532 avox 1647
                                                        if ((doc->appMode == modeEditClip) && (doc->nodeEdit.hasNodeSelected()))
5800 fschmid 1648
                                                        {
10532 avox 1649
                                                                int storedClRe = doc->nodeEdit.ClRe;
1650
                                                                if ((doc->nodeEdit.SelNode.count() != 0) && (doc->nodeEdit.EdPoints))
9735 fschmid 1651
                                                                {
16975 fschmid 1652
                                                                        QPolygonF poly;
10532 avox 1653
                                                                        for (int itm = 0; itm < doc->nodeEdit.SelNode.count(); ++itm)
9735 fschmid 1654
                                                                        {
1655
                                                                                FPoint np;
10532 avox 1656
                                                                                int clRe = doc->nodeEdit.SelNode.at(itm);
11395 fschmid 1657
                                                                                if (doc->nodeEdit.isContourLine)
1658
                                                                                        np = currItem->ContourLine.point(clRe);
1659
                                                                                else
1660
                                                                                        np = currItem->PoLine.point(clRe);
1661
                                                                                doc->nodeEdit.ClRe = clRe;
1662
                                                                                np = np + FPoint(moveBy, 0);
1663
                                                                                doc->nodeEdit.moveClipPoint(currItem, np);
16975 fschmid 1664
                                                                                poly.append(QPointF(np.x(), np.y()));
9735 fschmid 1665
                                                                        }
16975 fschmid 1666
                                                                        QMatrix m = currItem->getTransform();
1667
                                                                        poly = m.map(poly);
1668
                                                                        QRectF oldR = poly.boundingRect().adjusted(-5, -5, 10, 10);
1669
                                                                        QRectF newR(currItem->getBoundingRect());
1670
                                                                        doc->regionsChanged()->update(newR.unite(oldR));
9735 fschmid 1671
                                                                }
10532 avox 1672
                                                                doc->nodeEdit.ClRe = storedClRe;
5800 fschmid 1673
                                                        }
1674
                                                        else
1675
                                                        {
1676
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1677
                                                        /* as the user might be trying to fine tune a position */
1678
                                                                bool sav1 = doc->SnapGuides;
1679
                                                                bool sav2 = doc->useRaster;
1680
                                                                doc->SnapGuides = false;
1681
                                                                doc->useRaster = false;
11490 avox 1682
                                                                if (doc->m_Selection->count() > 1)
1683
                                                                        view->startGroupTransaction(Um::Move, "", Um::IMove);
1684
                                                                doc->moveGroup(moveBy, 0);
1685
                                                                if (doc->m_Selection->count() > 1)
1686
                                                                        view->endGroupTransaction();
5800 fschmid 1687
                                                                doc->SnapGuides = sav1;
1688
                                                                doc->useRaster = sav2;
1689
                                                        }
1690
                                                }
1691
                                                else
1692
                                                {
1693
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
10532 avox 1694
                                                        if(doc->nodeEdit.isContourLine)
5800 fschmid 1695
                                                                view->TransformPoly(11, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
16889 jghali 1696
                                                        else if (!currItem->sizeLocked())
5800 fschmid 1697
                                                        {
1698
                                                                if (resizingsmaller)
1699
                                                                {
7736 cbradney 1700
                                                                        doc->MoveItem(-resizeBy, 0, currItem, false);
16889 jghali 1701
                                                                        currItem->moveImageXYOffsetBy(resizeBy / currItem->imageXScale(), 0);
5800 fschmid 1702
                                                                }
16889 jghali 1703
                                                                currItem->Sizing = false;
1704
                                                                doc->SizeItem(currItem->width() + resizeBy, currItem->height(), currItem->ItemNr);
5800 fschmid 1705
                                                        }
1706
                                                }
17151 jghali 1707
                                                if (doc->m_Selection->count() > 1)
1708
                                                {
1709
                                                        double x, y, w, h;
1710
                                                        doc->m_Selection->setGroupRect();
1711
                                                        doc->m_Selection->getGroupRect(&x, &y, &w, &h);
1712
                                                        propertiesPalette->setXY(x, y);
1713
                                                        propertiesPalette->setBH(w, h);
1714
                                                }
10532 avox 1715
                                                currItem->update();
5800 fschmid 1716
                                                slotDocCh();
1717
                                        }
1718
                                        break;
8523 cbradney 1719
                                case Qt::Key_Up:
5800 fschmid 1720
                                        if (!currItem->locked())
1721
                                        {
1722
                                                if (!resizing)
1723
                                                {
10532 avox 1724
                                                        if ((doc->appMode == modeEditClip) && (doc->nodeEdit.hasNodeSelected()))
5800 fschmid 1725
                                                        {
10532 avox 1726
                                                                int storedClRe = doc->nodeEdit.ClRe;
1727
                                                                if ((doc->nodeEdit.SelNode.count() != 0) && (doc->nodeEdit.EdPoints))
9735 fschmid 1728
                                                                {
16975 fschmid 1729
                                                                        QPolygonF poly;
10532 avox 1730
                                                                        for (int itm = 0; itm < doc->nodeEdit.SelNode.count(); ++itm)
9735 fschmid 1731
                                                                        {
1732
                                                                                FPoint np;
10532 avox 1733
                                                                                int clRe = doc->nodeEdit.SelNode.at(itm);
11395 fschmid 1734
                                                                                if (doc->nodeEdit.isContourLine)
1735
                                                                                        np = currItem->ContourLine.point(clRe);
1736
                                                                                else
1737
                                                                                        np = currItem->PoLine.point(clRe);
1738
                                                                                doc->nodeEdit.ClRe = clRe;
1739
                                                                                np = np - FPoint(0, moveBy);
1740
                                                                                doc->nodeEdit.moveClipPoint(currItem, np);
16975 fschmid 1741
                                                                                poly.append(QPointF(np.x(), np.y()));
9735 fschmid 1742
                                                                        }
16975 fschmid 1743
                                                                        QMatrix m = currItem->getTransform();
1744
                                                                        poly = m.map(poly);
1745
                                                                        QRectF oldR = poly.boundingRect().adjusted(-5, -5, 10, 10);
1746
                                                                        QRectF newR(currItem->getBoundingRect());
1747
                                                                        doc->regionsChanged()->update(newR.unite(oldR));
9735 fschmid 1748
                                                                }
10532 avox 1749
                                                                doc->nodeEdit.ClRe = storedClRe;
5800 fschmid 1750
                                                        }
1751
                                                        else
1752
                                                        {
1753
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1754
                                                        /* as the user might be trying to fine tune a position */
1755
                                                                bool sav1 = doc->SnapGuides;
1756
                                                                bool sav2 = doc->useRaster;
1757
                                                                doc->SnapGuides = false;
1758
                                                                doc->useRaster = false;
11490 avox 1759
                                                                if (doc->m_Selection->count() > 1)
1760
                                                                        view->startGroupTransaction(Um::Move, "", Um::IMove);
1761
                                                                doc->moveGroup(0, -moveBy);
1762
                                                                if (doc->m_Selection->count() > 1)
1763
                                                                        view->endGroupTransaction();
5800 fschmid 1764
                                                                doc->SnapGuides = sav1;
1765
                                                                doc->useRaster = sav2;
1766
                                                        }
1767
                                                }
1768
                                                else
1769
                                                {
1770
                                                        //CB If in EditContour mode, allow contour line to be scaled with arrow keys too
10532 avox 1771
                                                        if(doc->nodeEdit.isContourLine)
5800 fschmid 1772
                                                                view->TransformPoly(12, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
16889 jghali 1773
                                                        else if (!currItem->sizeLocked())
5800 fschmid 1774
                                                        {
16889 jghali 1775
                                                                if (!resizingsmaller)
5800 fschmid 1776
                                                                {
7736 cbradney 1777
                                                                        doc->MoveItem(0, -resizeBy, currItem, false);
16889 jghali 1778
                                                                        currItem->moveImageXYOffsetBy(0, resizeBy / currItem->imageYScale());
5800 fschmid 1779
                                                                }
16889 jghali 1780
                                                                currItem->Sizing = false;
1781
                                                                doc->SizeItem(currItem->width(), currItem->height() + resizeBy, currItem->ItemNr);
5800 fschmid 1782
                                                        }
1783
                                                }
17151 jghali 1784
                                                if (doc->m_Selection->count() > 1)
1785
                                                {
1786
                                                        double x, y, w, h;
1787
                                                        doc->m_Selection->setGroupRect();
1788
                                                        doc->m_Selection->getGroupRect(&x, &y, &w, &h);
1789
                                                        propertiesPalette->setXY(x, y);
1790
                                                        propertiesPalette->setBH(w, h);
1791
                                                }
10532 avox 1792
                                                currItem->update();
5800 fschmid 1793
                                                slotDocCh();
1794
                                        }
1795
                                        break;
8523 cbradney 1796
                                case Qt::Key_Down:
5800 fschmid 1797
                                        if (!currItem->locked())
1798
                                        {
1799
                                                if (!resizing)
1800
                                                {
10532 avox 1801
                                                        if ((doc->appMode == modeEditClip) && (doc->nodeEdit.hasNodeSelected()))
5800 fschmid 1802
                                                        {
10532 avox 1803
                                                                int storedClRe = doc->nodeEdit.ClRe;
1804
                                                                if ((doc->nodeEdit.SelNode.count() != 0) && (doc->nodeEdit.EdPoints))
9735 fschmid 1805
                                                                {
16975 fschmid 1806
                                                                        QPolygonF poly;
10532 avox 1807
                                                                        for (int itm = 0; itm < doc->nodeEdit.SelNode.count(); ++itm)
9735 fschmid 1808
                                                                        {
1809
                                                                                FPoint np;
10532 avox 1810
                                                                                int clRe = doc->nodeEdit.SelNode.at(itm);
11395 fschmid 1811
                                                                                if (doc->nodeEdit.isContourLine)
1812
                                                                                        np = currItem->ContourLine.point(clRe);
1813
                                                                                else
1814
                                                                                        np = currItem->PoLine.point(clRe);
1815
                                                                                doc->nodeEdit.ClRe = clRe;
1816
                                                                                np = np - FPoint(0, -moveBy);
1817
                                                                                doc->nodeEdit.moveClipPoint(currItem, np);
16975 fschmid 1818
                                                                                poly.append(QPointF(np.x(), np.y()));
9735 fschmid 1819
                                                                        }
16975 fschmid 1820
                                                                        QMatrix m = currItem->getTransform();
1821
                                                                        poly = m.map(poly);
1822
                                                                        QRectF oldR = poly.boundingRect().adjusted(-5, -5, 10, 10);
1823
                                                                        QRectF newR(currItem->getBoundingRect());
1824
                                                                        doc->regionsChanged()->update(newR.unite(oldR));
9735 fschmid 1825
                                                                }
10532 avox 1826
                                                                doc->nodeEdit.ClRe = storedClRe;
5800 fschmid 1827
                                                        }
1828
                                                        else
1829
                                                        {
1830
                                                        /* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
1831
                                                        /* as the user might be trying to fine tune a position */
1832
                                                                bool sav1 = doc->SnapGuides;
1833
                                                                bool sav2 = doc->useRaster;
1834
                                                                doc->SnapGuides = false;
1835
                                                                doc->useRaster = false;
11490 avox 1836
                                                                if (doc->m_Selection->count() > 1)
1837
                                                                        view->startGroupTransaction(Um::Move, "", Um::IMove);
1838
                                                                doc->moveGroup(0, moveBy);
1839
                                                                if (doc->m_Selection->count()