Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
3 paul 1
/***************************************************************************
2
                          scribus.cpp  -  description
3
                             -------------------
4
    begin                : Fre Apr  6 21:09:31 CEST 2001
5
    copyright            : (C) 2001 by Franz Schmid
6
    email                : Franz.Schmid@altmuehlnet.de
7
 ***************************************************************************/
8
 
9
/***************************************************************************
10
 *                                                                         *
11
 *   This program is free software; you can redistribute it and/or modify  *
12
 *   it under the terms of the GNU General Public License as published by  *
13
 *   the Free Software Foundation; either version 2 of the License, or     *
14
 *   (at your option) any later version.                                   *
15
 *                                                                         *
16
 ***************************************************************************/
17
 
18
#include <qaccel.h>
19
#include <qapplication.h>
204 Franz 20
#include <qeventloop.h>
3 paul 21
#include <qcolordialog.h>
22
#include <qcolor.h>
23
#include <qiconset.h>
24
#include <qtextstream.h>
25
#include <qstylefactory.h>
26
#include <qregexp.h>
27
#include <qtextcodec.h>
28
#include <qcursor.h>
29
#include <qvbox.h>
1208 cbradney 30
#include <qpixmap.h>
31
#include <qkeysequence.h>
32
 
3 paul 33
#include <cstdio>
34
#include <cstdlib>
391 Franz 35
#include <cmath>
2629 craig 36
 
2688 craig 37
#include "scconfig.h"
2629 craig 38
 
39
#ifdef HAVE_DLFCN_H
3 paul 40
#include <dlfcn.h>
2629 craig 41
#endif
42
 
43
#ifdef HAVE_UNISTD_H
135 Franz 44
#include <unistd.h>
2629 craig 45
#endif
46
 
3 paul 47
#include <iostream>
119 Franz 48
#include <signal.h>
80 Franz 49
#include <string>
1208 cbradney 50
 
51
 
2160 cbradney 52
#include "scribusapp.h"
3 paul 53
#include "scribus.h"
54
#include "scribus.moc"
55
#include "newfile.h"
56
#include "page.h"
57
#include "query.h"
58
#include "mdup.h"
59
#include "docinfo.h"
60
#include "reformdoc.h"
61
#include "serializer.h"
2355 cbradney 62
#include "aligndistribute.h"
3 paul 63
#include "fmitem.h"
64
#include "fontprefs.h"
1641 cbradney 65
#include "prefs.h"
1158 cbradney 66
#include "prefstable.h"
3 paul 67
#include "pdfopts.h"
3133 fschmid 68
#include "pdflib.h"
3 paul 69
#include "inspage.h"
70
#include "delpages.h"
71
#include "movepage.h"
72
#include "helpbrowser.h"
73
#include "scribusXml.h"
1641 cbradney 74
#include "about.h"
910 fschmid 75
#include "libpostscript/pslib.h"
3 paul 76
#include "druck.h"
77
#include "editformats.h"
78
#include "muster.h"
1806 cbradney 79
#include "applytemplatedialog.h"
3 paul 80
#include "picstatus.h"
81
#include "customfdialog.h"
82
#include "cmsprefs.h"
83
#include "annot.h"
84
#include "annota.h"
85
#include "javadocs.h"
151 Franz 86
#include "colorm.h"
265 Franz 87
#include "mpalette.h"
1525 cbradney 88
#include "bookpalette.h"
89
#include "seiten.h"
90
#include "layers.h"
91
#include "frameedit.h"
92
#include "splash.h"
284 Franz 93
#include "measurements.h"
364 Franz 94
#include "gtgettext.h"
506 fschmid 95
#include "fileloader.h"
740 fschmid 96
#include "arrowchooser.h"
788 fschmid 97
#include "tabtypography.h"
879 fschmid 98
#include "tabguides.h"
1194 fschmid 99
#include "tabtools.h"
1114 tsoots 100
#include "undogui.h"
1151 fschmid 101
#include "filewatcher.h"
1202 fschmid 102
#include "charselect.h"
1232 fschmid 103
#include "checkDocument.h"
1235 fschmid 104
#include "tabcheckdoc.h"
1307 fschmid 105
#include "tabpdfoptions.h"
1641 cbradney 106
#include "docitemattrprefs.h"
1644 cbradney 107
#include "pageitemattributes.h"
1694 cbradney 108
#include "tocindexprefs.h"
2441 cbradney 109
#include "tocgenerator.h"
128 Franz 110
 
3 paul 111
#include "fpoint.h"
112
#include "fpointarray.h"
113
#include "hysettings.h"
114
#include "guidemanager.h"
284 Franz 115
#include "keymanager.h"
3 paul 116
#include "mergedoc.h"
27 Franz 117
#include "lineformats.h"
102 Franz 118
#include "story.h"
123 Franz 119
#include "autoform.h"
140 Franz 120
#include "tabmanager.h"
164 Franz 121
#include "search.h"
169 Franz 122
#include "fontcombo.h"
415 Franz 123
#include "prefsfile.h"
1114 tsoots 124
#include "undomanager.h"
731 fschmid 125
#include "polygonwidget.h"
766 cbradney 126
#include "werktoolb.h"
806 cbradney 127
#include "units.h"
838 cbradney 128
#include "hruler.h"
129
#include "vruler.h"
3053 avox 130
#include "pageselector.h"
1208 cbradney 131
#include "scraction.h"
132
#include "menumanager.h"
1293 tsoots 133
#include "undostate.h"
1414 fschmid 134
#include "tree.h"
1500 cbradney 135
#include "scrap.h"
1549 subik 136
#include "pluginmanager.h"
1693 craig 137
#include "scpaths.h"
1972 craig 138
#include "pdfoptions.h"
1993 cbradney 139
#include "actionmanager.h"
2024 cbradney 140
#include "documentinformation.h"
2056 fschmid 141
#include "effectsdialog.h"
2111 cbradney 142
#include "documentchecker.h"
2531 craig 143
#include "util.h"
2658 fschmid 144
#include "pagesize.h"
2707 subik 145
#include "loremipsum.h"
2769 fschmid 146
#include "marginWidget.h"
2777 fschmid 147
#include "margindialog.h"
2834 cbradney 148
#include "prefsmanager.h"
2901 fschmid 149
#include "pagelayout.h"
2952 cbradney 150
#include "commonstrings.h"
134 Franz 151
 
3 paul 152
using namespace std;
153
 
154
#ifdef HAVE_CMS
155
cmsHPROFILE CMSoutputProf;
156
cmsHPROFILE CMSprinterProf;
1781 fschmid 157
cmsHTRANSFORM stdTransG;
158
cmsHTRANSFORM stdProofG;
159
cmsHTRANSFORM stdTransImgG;
160
cmsHTRANSFORM stdProofImgG;
161
cmsHTRANSFORM stdTransCMYKG;
162
cmsHTRANSFORM stdProofCMYKG;
163
cmsHTRANSFORM stdTransRGBG;
3046 fschmid 164
cmsHTRANSFORM stdProofGCG;
165
cmsHTRANSFORM stdProofCMYKGCG;
1488 fschmid 166
bool BlackPoint;
3 paul 167
bool SoftProofing;
168
bool Gamut;
3133 fschmid 169
bool CMSuse;
3 paul 170
int IntentMonitor;
171
int IntentPrinter;
172
#endif
173
bool CMSavail;
2891 cbradney 174
 
3 paul 175
QString DocDir;
2536 cbradney 176
extern ScribusApp* ScApp;
177
extern ScribusQApp* ScQApp;
2634 cbradney 178
extern bool emergencyActivated;
3 paul 179
 
188 Franz 180
ScribusApp::ScribusApp()
2161 cbradney 181
{
2199 cbradney 182
        scribusInitialized=false;
2164 subik 183
        actionManager=NULL;
2178 cbradney 184
        scrMenuMgr=NULL;
2199 cbradney 185
        undoManager=NULL;
2834 cbradney 186
        prefsManager=NULL;
2161 cbradney 187
} // ScribusApp::ScribusApp()
188 Franz 188
 
767 cbradney 189
/*
190
 * retval 0 - ok, 1 - no fonts, ...
191
 */
2295 cbradney 192
int ScribusApp::initScribus(bool showSplash, bool showFontInfo, const QString newGuiLanguage)
188 Franz 193
{
2952 cbradney 194
        CommonStrings::languageChange();
2894 fschmid 195
        noneString = tr("None");
767 cbradney 196
        int retVal=0;
1155 fschmid 197
        ExternalApp = 0;
770 cbradney 198
        guiLanguage = newGuiLanguage;
767 cbradney 199
        initSplash(showSplash);
1208 cbradney 200
        setUsesBigPixmaps(true);
355 Franz 201
        CurrStED = NULL;
272 Franz 202
        setCaption( tr("Scribus " VERSION));
118 Franz 203
        setKeyCompression(false);
272 Franz 204
        setIcon(loadIcon("AppIcon.png"));
1325 cbradney 205
        scrActionGroups.clear();
206
        scrActionGroups.setAutoDelete(true);
1208 cbradney 207
        scrActions.clear();
208
        scrRecentFileActions.clear();
1260 cbradney 209
        scrWindowsActions.clear();
2408 cbradney 210
        scrLayersActions.clear();
1208 cbradney 211
        scrMenuMgr = new MenuManager(this->menuBar());
766 cbradney 212
 
2835 cbradney 213
        prefsManager = PrefsManager::instance();
2856 cbradney 214
        prefsManager->setup();
2835 cbradney 215
        PrefsPfad = prefsManager->preferencesLocation();
2907 subik 216
 
217
 
1247 tsoots 218
        undoManager = UndoManager::instance();
1443 tsoots 219
        objectSpecificUndo = false;
1549 subik 220
        pluginManager = new PluginManager();
2441 cbradney 221
        tocGenerator = new TOCGenerator();
1780 cbradney 222
        initDefaultValues();
2143 subik 223
 
2187 cbradney 224
        actionManager = new ActionManager(this, "actionManager");
272 Franz 225
        initMenuBar();
226
        initStatusBar();
766 cbradney 227
        initToolBars();
490 cbradney 228
        qApp->processEvents();
675 cbradney 229
 
3 paul 230
        BuFromApp = false;
1485 tsoots 231
 
2870 cbradney 232
        bool haveFonts=initFonts(showFontInfo);
233
        if (!haveFonts)
767 cbradney 234
                retVal=1;
272 Franz 235
        else
236
        {
777 fschmid 237
                buildFontMenu();
2835 cbradney 238
                prefsManager->initDefaults();
239
                prefsManager->initDefaultGUIFont(qApp->font());
240
                prefsManager->initArrowStyles();
3 paul 241
                resize(610, 600);
272 Franz 242
                QVBox* vb = new QVBox( this );
243
                vb->setFrameStyle( QFrame::StyledPanel | QFrame::Sunken );
244
                wsp = new QWorkspace( vb );
245
                setCentralWidget( vb );
3 paul 246
                connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
3097 cbradney 247
                //Connect windows cascade and tile actions to the workspace after its created. Only depends on wsp created.
248
                connect( scrActions["windowsCascade"], SIGNAL(activated()) , wsp, SLOT(cascade()) );
249
                connect( scrActions["windowsTile"], SIGNAL(activated()) , wsp, SLOT(tile()) );
770 cbradney 250
 
801 cbradney 251
                initPalettes();
770 cbradney 252
 
1155 fschmid 253
                fileWatcher = new FileWatcher(this);
1485 tsoots 254
 
2870 cbradney 255
                setSplashStatus( tr("Initializing Plugins") );
1550 cbradney 256
                pluginManager->initPlugs();
2870 cbradney 257
                setSplashStatus( tr("Initializing Keyboard Shortcuts") );
1437 cbradney 258
                initKeyboardShortcuts();
2870 cbradney 259
                setSplashStatus( tr("Reading Preferences") );
2859 cbradney 260
                prefsManager->ReadPrefs();
2870 cbradney 261
                setSplashStatus( tr("Initializing Story Editor") );
2494 cbradney 262
                storyEditor = new StoryEditor(this);
801 cbradney 263
 
2843 fschmid 264
#ifndef _WIN32
2862 cbradney 265
                HaveGS = system(prefsManager->ghostscriptExecutable()+" -h > /dev/null 2>&1");
266
                HavePngAlpha = system(prefsManager->ghostscriptExecutable()+" -sDEVICE=pngalpha -c quit > /dev/null 2>&1");
2843 fschmid 267
#else
2885 fschmid 268
                HaveGS = system(getShortPathName(prefsManager->ghostscriptExecutable())+" -h >NUL");
269
                HavePngAlpha = system(getShortPathName(prefsManager->ghostscriptExecutable())+" -sDEVICE=pngalpha -c quit >NUL");
2843 fschmid 270
#endif
2871 cbradney 271
                DocDir = prefsManager->documentDir();
801 cbradney 272
 
2870 cbradney 273
                setSplashStatus( tr("Reading ICC Profiles") );
831 cbradney 274
                CMSavail = false;
3 paul 275
                GetCMSProfiles();
803 cbradney 276
                initCMS();
831 cbradney 277
 
2870 cbradney 278
                setSplashStatus( tr("Initializing Hyphenator") );
766 cbradney 279
                initHyphenator();
2870 cbradney 280
                setSplashStatus( tr("Reading Scrapbook") );
801 cbradney 281
                initScrapbook();
2870 cbradney 282
                setSplashStatus( tr("Setting up Shortcuts") );
1230 cbradney 283
                SetShortCut();
1485 tsoots 284
 
1441 cbradney 285
                emit prefsChanged();
1485 tsoots 286
 
1208 cbradney 287
                connect(fileWatcher, SIGNAL(fileDeleted(QString )), this, SLOT(removeRecent(QString)));
3 paul 288
                connect(this, SIGNAL(TextIFont(QString)), this, SLOT(AdjustFontMenu(QString)));
289
                connect(this, SIGNAL(TextISize(int)), this, SLOT(setFSizeMenu(int)));
1545 cbradney 290
                connect(this, SIGNAL(TextISize(int)), propertiesPalette, SLOT(setSize(int)));
2382 fschmid 291
                connect(this, SIGNAL(TextUSval(int)), propertiesPalette, SLOT(setExtra(int)));
1545 cbradney 292
                connect(this, SIGNAL(TextStil(int)), propertiesPalette, SLOT(setStil(int)));
293
                connect(this, SIGNAL(TextScale(int)), propertiesPalette, SLOT(setTScale(int)));
2230 fschmid 294
                connect(this, SIGNAL(TextScaleV(int)), propertiesPalette, SLOT(setTScaleV(int)));
2234 fschmid 295
                connect(this, SIGNAL(TextBase(int)), propertiesPalette, SLOT(setTBase(int)));
2247 fschmid 296
                connect(this, SIGNAL(TextShadow(int, int )), propertiesPalette, SLOT(setShadowOffs(int, int )));
2257 fschmid 297
                connect(this, SIGNAL(TextOutline(int)), propertiesPalette, SLOT(setOutlineW(int)));
2262 fschmid 298
                connect(this, SIGNAL(TextUnderline(int, int)), propertiesPalette, SLOT(setUnderline(int, int)));
2272 fschmid 299
                connect(this, SIGNAL(TextStrike(int, int)), propertiesPalette, SLOT(setStrike(int, int)));
1545 cbradney 300
                connect(this, SIGNAL(TextFarben(QString, QString, int, int)), propertiesPalette, SLOT(setActFarben(QString, QString, int, int)));
3 paul 301
        }
767 cbradney 302
        closeSplash();
2199 cbradney 303
        scribusInitialized=true;
2223 cbradney 304
        //pluginManager->languageChange();
767 cbradney 305
        return retVal;
3 paul 306
}
307
 
767 cbradney 308
void ScribusApp::initSplash(bool showSplash)
309
{
310
        if (showSplash)
311
        {
312
                splashScreen = new SplashScreen();
2870 cbradney 313
                setSplashStatus(QObject::tr("Initializing..."));
767 cbradney 314
        }
315
        else
316
                splashScreen = NULL;
317
}
318
 
2870 cbradney 319
void ScribusApp::setSplashStatus(const QString& newText)
320
{
321
        if (splashScreen != NULL)
322
                splashScreen->setStatus( newText );
323
        qApp->processEvents();
324
}
325
 
2835 cbradney 326
void ScribusApp::showSplash(bool shown)
327
{
328
        if (splashScreen!=NULL && shown!=splashScreen->isShown())
329
                splashScreen->setShown(shown);
330
}
331
 
767 cbradney 332
void ScribusApp::closeSplash()
333
{
334
        if (splashScreen!=NULL)
335
        {
336
                splashScreen->close();
337
                delete splashScreen;
338
                splashScreen = NULL;
339
        }
340
}
341
 
766 cbradney 342
void ScribusApp::initToolBars()
343
{
2859 cbradney 344
        fileToolBar = new QToolBar( tr("File"), this);
345
        scrActions["fileNew"]->addTo(fileToolBar);
346
        scrActions["fileOpen"]->addTo(fileToolBar);
1210 cbradney 347
        scrMenuMgr->addMenuToWidgetOfAction("FileOpenRecent", scrActions["fileOpen"]);
2859 cbradney 348
        scrActions["fileSave"]->addTo(fileToolBar);
349
        scrActions["fileClose"]->addTo(fileToolBar);
350
        scrActions["filePrint"]->addTo(fileToolBar);
351
        scrActions["toolsPreflightVerifier"]->addTo(fileToolBar);
352
        scrActions["fileExportAsPDF"]->addTo(fileToolBar);
1485 tsoots 353
 
2397 cbradney 354
        editToolBar = new QToolBar( tr("Edit"), this);
1114 tsoots 355
        UndoWidget* uWidget = new UndoWidget(editToolBar, "uWidget");
1247 tsoots 356
        undoManager->registerGui(uWidget);
1485 tsoots 357
 
2859 cbradney 358
        mainToolBar = new WerkToolB(this);
359
        setDockEnabled(mainToolBar, DockLeft, false);
360
        setDockEnabled(mainToolBar, DockRight, false);
361
        mainToolBar->Sichtbar = true;
362
        mainToolBar->setEnabled(false);
363
        pdfToolBar = new WerkToolBP(this);
364
        setDockEnabled(pdfToolBar, DockLeft, false);
365
        setDockEnabled(pdfToolBar, DockRight, false);
366
        pdfToolBar->setEnabled(false);
367
        pdfToolBar->Sichtbar = true;
801 cbradney 368
 
2859 cbradney 369
        connect(mainToolBar, SIGNAL(Schliessen()), this, SLOT(ToggleTools()));
370
        connect(pdfToolBar, SIGNAL(NewMode(int)), this, SLOT(setAppMode(int)));
371
        connect(pdfToolBar, SIGNAL(Schliessen()), this, SLOT(TogglePDFTools()));
766 cbradney 372
}
373
 
2870 cbradney 374
//Returns false when there are no fonts
375
const bool ScribusApp::initFonts(bool showFontInfo)
767 cbradney 376
{
2870 cbradney 377
        setSplashStatus( tr("Searching for Fonts") );
378
        bool haveFonts=prefsManager->GetAllFonts(showFontInfo);
379
        if (!haveFonts)
767 cbradney 380
        {
381
                if (splashScreen!=NULL)
382
                        splashScreen->close(); // 10/10/2004 pv fix #1200
1801 cbradney 383
                QString mess = tr("There are no fonts found on your system.");
384
                mess += "\n" + tr("Exiting now.");
767 cbradney 385
                QMessageBox::critical(this, tr("Fatal Error"), mess, 1, 0, 0);
386
        }
829 cbradney 387
        else
2870 cbradney 388
                setSplashStatus( tr("Font System Initialized") );
389
        return haveFonts;
767 cbradney 390
}
766 cbradney 391
 
801 cbradney 392
void ScribusApp::initDefaultValues()
393
{
2856 cbradney 394
        dirs = prefsManager->prefsFile->getContext("dirs");
1780 cbradney 395
        HaveDoc = false;
801 cbradney 396
        singleClose = false;
397
        ScriptRunning = false;
398
        view = NULL;
399
        doc = NULL;
400
        Buffer2 = "";
3034 cbradney 401
        unicodeTextEditMode = false;
402
        unicodeInputCount = 0;
403
        unicodeInputString = "";
801 cbradney 404
        DispX = 10;
405
        DispY = 10;
406
        DocNr = 1;
407
        PrinterUsed = false;
408
        PDef.Pname = "";
409
        PDef.Dname = "";
410
        PDef.Command = "";
411
        keyrep = false;
1204 tsoots 412
        _arrowKeyDown = false;
801 cbradney 413
        ClipB = QApplication::clipboard();
414
        PalettesStat[0] = false;
415
        GuidesStat[0] = false;
416
 
417
        connect(ClipB, SIGNAL(dataChanged()), this, SLOT(ClipChange()));
770 cbradney 418
}
419
 
801 cbradney 420
void ScribusApp::initKeyboardShortcuts()
421
{
1478 cbradney 422
        for( QMap<QString, QGuardedPtr<ScrAction> >::Iterator it = scrActions.begin(); it!=scrActions.end(); ++it )
1525 cbradney 423
        {
2178 cbradney 424
                if ((ScrAction*)(it.data())!=NULL)
2873 cbradney 425
                {
426
                        QString accelerator=it.data()->accel();
427
                        prefsManager->setKeyEntry(it.key(), it.data()->cleanMenuText(), accelerator,0);
428
                }
2178 cbradney 429
                //else
430
                //      qDebug(it.key());
1525 cbradney 431
                //qDebug(QString("|-\n|%1||%2||%3").arg(it.key()).arg(it.data()->cleanMenuText()).arg(QString(it.data()->accel())));
432
        }
801 cbradney 433
}
434
 
435
void ScribusApp::initPalettes()
436
{
1493 cbradney 437
        //CB TODO hide the publicly available members of some palettes
438
        // these must be filtered too as they take control of the palettes events
1545 cbradney 439
        outlinePalette = new Tree(this, this);
440
        connect( scrActions["toolsOutline"], SIGNAL(toggled(bool)) , outlinePalette, SLOT(setPaletteShown(bool)) );
441
        connect( outlinePalette, SIGNAL(paletteShown(bool)), scrActions["toolsOutline"], SLOT(setOn(bool)));
442
        outlinePalette->setPrefsContext("OutlinePalette");
443
        outlinePalette->reportDisplay->installEventFilter(this);
2834 cbradney 444
        propertiesPalette = new Mpalette(this);
1545 cbradney 445
        connect( scrActions["toolsProperties"], SIGNAL(toggled(bool)) , propertiesPalette, SLOT(setPaletteShown(bool)) );
446
        connect( propertiesPalette, SIGNAL(paletteShown(bool)), scrActions["toolsProperties"], SLOT(setOn(bool)));
447
        propertiesPalette->setPrefsContext("PropertiesPalette");
2871 cbradney 448
        propertiesPalette->Cpal->SetColors(prefsManager->colorSet());
1545 cbradney 449
        propertiesPalette->Cpal->UseTrans(true);
2508 fschmid 450
        propertiesPalette->Fonts->RebuildList(0);
1545 cbradney 451
        propertiesPalette->installEventFilter(this);
452
        nodePalette = new NodePalette(this);
453
        nodePalette->setPrefsContext("NodePalette");
454
        nodePalette->installEventFilter(this);
1549 subik 455
 
1545 cbradney 456
        layerPalette = new LayerPalette(this);
457
        connect( scrActions["toolsLayers"], SIGNAL(toggled(bool)) , layerPalette, SLOT(setPaletteShown(bool)) );
458
        connect( layerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsLayers"], SLOT(setOn(bool)));
459
        layerPalette->setPrefsContext("LayerPalette");
460
        layerPalette->installEventFilter(this);
461
        layerPalette->Table->installEventFilter(this);
2834 cbradney 462
        scrapbookPalette = new Biblio(this);
1545 cbradney 463
        connect( scrActions["toolsScrapbook"], SIGNAL(toggled(bool)) , scrapbookPalette, SLOT(setPaletteShown(bool)) );
464
        connect( scrapbookPalette, SIGNAL(paletteShown(bool)), scrActions["toolsScrapbook"], SLOT(setOn(bool)));
465
        scrapbookPalette->setPrefsContext("ScrapbookPalette");
466
        scrapbookPalette->installEventFilter(this);
467
        pagePalette = new SeitenPal(this);
468
        connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , pagePalette, SLOT(setPaletteShown(bool)) );
469
        connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , this, SLOT(setPagePalette(bool)) );
470
        connect( pagePalette, SIGNAL(paletteShown(bool)), scrActions["toolsPages"], SLOT(setOn(bool)));
471
        pagePalette->setPrefsContext("PagePalette");
472
        pagePalette->installEventFilter(this);
473
        bookmarkPalette = new BookPalette(this);
474
        connect( scrActions["toolsBookmarks"], SIGNAL(toggled(bool)) , bookmarkPalette, SLOT(setPaletteShown(bool)) );
475
        connect( bookmarkPalette, SIGNAL(paletteShown(bool)), scrActions["toolsBookmarks"], SLOT(setOn(bool)));
476
        bookmarkPalette->setPrefsContext("BookmarkPalette");
477
        bookmarkPalette->installEventFilter(this);
478
        measurementPalette = new Measurements(this);
479
        connect( scrActions["toolsMeasurements"], SIGNAL(toggled(bool)) , measurementPalette, SLOT(setPaletteShown(bool)) );
1525 cbradney 480
        connect( scrActions["toolsMeasurements"], SIGNAL(toggledData(bool, int)) , this, SLOT(setAppModeByToggle(bool, int)) );
1545 cbradney 481
        connect( measurementPalette, SIGNAL(paletteShown(bool)), scrActions["toolsMeasurements"], SLOT(setOn(bool)));
482
        measurementPalette->setPrefsContext("MeasurementPalette");
483
        measurementPalette->installEventFilter(this);
484
        measurementPalette->hide();
485
        docCheckerPalette = new CheckDocument(this, false);
486
        connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , docCheckerPalette, SLOT(setPaletteShown(bool)) );
487
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsPreflightVerifier"], SLOT(setOn(bool)));
1825 fschmid 488
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), this, SLOT(docCheckToggle(bool)));
1545 cbradney 489
        docCheckerPalette->setPrefsContext("DocCheckerPalette");
490
        docCheckerPalette->installEventFilter(this);
491
        docCheckerPalette->hide();
2707 subik 492
 
2355 cbradney 493
        alignDistributePalette = new AlignDistributePalette(this, "AlignDistributePalette", false);
494
        connect( scrActions["toolsAlignDistribute"], SIGNAL(toggled(bool)) , alignDistributePalette, SLOT(setPaletteShown(bool)) );
495
        connect( alignDistributePalette, SIGNAL(paletteShown(bool)), scrActions["toolsAlignDistribute"], SLOT(setOn(bool)));
496
        connect( alignDistributePalette, SIGNAL(documentChanged()), this, SLOT(slotDocCh()));
497
        alignDistributePalette->setPrefsContext("AlignDistributePalette");
498
        alignDistributePalette->installEventFilter(this);
499
        alignDistributePalette->hide();
2707 subik 500
 
1448 cbradney 501
        undoPalette = new UndoPalette(this, "undoPalette");
1493 cbradney 502
        undoPalette->installEventFilter(this);
1448 cbradney 503
        undoManager->registerGui(undoPalette);
1493 cbradney 504
        connect(undoPalette, SIGNAL(paletteShown(bool)), this, SLOT(setUndoPalette(bool)));
1448 cbradney 505
        connect(undoPalette, SIGNAL(objectMode(bool)), this, SLOT(setUndoMode(bool)));
1485 tsoots 506
 
1545 cbradney 507
        connect(propertiesPalette, SIGNAL(DocChanged()), this, SLOT(slotDocCh()));
508
        connect(propertiesPalette, SIGNAL(NewAbStyle(int)), this, SLOT(setNewAbStyle(int)));
509
        connect(propertiesPalette, SIGNAL(BackHome()), this, SLOT(Aktiv()));
510
        connect(propertiesPalette, SIGNAL(Stellung(int)), this, SLOT(setItemHoch(int)));
511
        connect(propertiesPalette, SIGNAL(EditCL()), this, SLOT(ToggleFrameEdit()));
512
        connect(propertiesPalette, SIGNAL(NewTF(QString)), this, SLOT(SetNewFont(QString)));
513
        connect(propertiesPalette, SIGNAL(UpdtGui(int)), this, SLOT(HaveNewSel(int)));
514
        connect(propertiesPalette->Cpal, SIGNAL(NewPen(QString)), this, SLOT(setPenFarbe(QString)));
515
        connect(propertiesPalette->Cpal, SIGNAL(NewBrush(QString)), this, SLOT(setBrushFarbe(QString)));
516
        connect(propertiesPalette->Cpal, SIGNAL(NewPenShade(int)), this, SLOT(setPenShade(int)));
517
        connect(propertiesPalette->Cpal, SIGNAL(NewBrushShade(int)), this, SLOT(setBrushShade(int)));
2026 cbradney 518
        connect(propertiesPalette->Cpal, SIGNAL(NewTrans(double)), this, SLOT(setItemFillTransparency(double)));
519
        connect(propertiesPalette->Cpal, SIGNAL(NewTransS(double)), this, SLOT(setItemLineTransparency(double)));
1545 cbradney 520
        connect(propertiesPalette->Cpal, SIGNAL(NewGradient(int)), this, SLOT(setGradFill(int)));
521
        connect(propertiesPalette->Cpal->gradEdit->Preview, SIGNAL(gradientChanged()), this, SLOT(updtGradFill()));
522
        connect(propertiesPalette->Cpal, SIGNAL(gradientChanged()), this, SLOT(updtGradFill()));
523
        connect(propertiesPalette->Cpal, SIGNAL(QueryItem()), this, SLOT(GetBrushPen()));
3025 cbradney 524
        connect(docCheckerPalette, SIGNAL(selectElement(int, int)), this, SLOT(selectItemsFromOutlines(int, int)));
525
        connect(docCheckerPalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
2093 cbradney 526
        connect(docCheckerPalette, SIGNAL(selectMasterPage(QString)), this, SLOT(manageMasterPages(QString)));
3025 cbradney 527
        connect(outlinePalette, SIGNAL(selectElement(int, int, bool)), this, SLOT(selectItemsFromOutlines(int, int, bool)));
528
        connect(outlinePalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
2093 cbradney 529
        connect(outlinePalette, SIGNAL(selectMasterPage(QString)), this, SLOT(manageMasterPages(QString)));
1545 cbradney 530
        connect(propertiesPalette->Spal, SIGNAL(newStyle(int)), this, SLOT(setNewAbStyle(int)));
531
        connect(propertiesPalette, SIGNAL(EditLSt()), this, SLOT(slotEditLineStyles()));
532
        connect(nodePalette, SIGNAL(Schliessen()), this, SLOT(NoFrameEdit()));
533
        connect(layerPalette, SIGNAL(LayerChanged()), this, SLOT(showLayer()));
2093 cbradney 534
        connect(pagePalette, SIGNAL(EditTemp(QString)), this, SLOT(manageMasterPages(QString)));
535
        connect(pagePalette->PageView, SIGNAL(UseTemp(QString, int)), this, SLOT(Apply_MasterPage(QString, int)));
1545 cbradney 536
        connect(pagePalette->PageView, SIGNAL(NewPage(int, QString)), this, SLOT(slotNewPageP(int, QString)));
537
        connect(pagePalette->Trash, SIGNAL(DelPage(int)), this, SLOT(DeletePage2(int)));
3025 cbradney 538
        connect(pagePalette, SIGNAL(GotoSeite(int)), this, SLOT(selectPagesFromOutlines(int)));
1545 cbradney 539
        connect(bookmarkPalette->BView, SIGNAL(MarkMoved()), this, SLOT(StoreBookmarks()));
540
        connect(bookmarkPalette->BView, SIGNAL(ChangeBMNr(int, int, int)), this, SLOT(ChBookmarks(int, int, int)));
3025 cbradney 541
        connect(bookmarkPalette->BView, SIGNAL(SelectElement(int, int)), this, SLOT(selectItemsFromOutlines(int, int)));
801 cbradney 542
}
543
 
544
void ScribusApp::initScrapbook()
545
{
1554 cbradney 546
        QString scrapbookFile = QDir::convertSeparators(PrefsPfad+"/scrap13.scs");
801 cbradney 547
        QFileInfo scrapbookFileInfo = QFileInfo(scrapbookFile);
548
        if (scrapbookFileInfo.exists())
2144 cbradney 549
                scrapbookPalette->readContents(scrapbookFile);
550
        scrapbookPalette->setScrapbookFileName(scrapbookFile);
1545 cbradney 551
        scrapbookPalette->AdjustMenu();
801 cbradney 552
}
553
 
770 cbradney 554
const QString ScribusApp::getGuiLanguage()
555
{
556
        return guiLanguage;
557
}
558
 
1525 cbradney 559
bool ScribusApp::warningVersion(QWidget *parent)
560
{
561
        bool retval = false;
2143 subik 562
        int t = QMessageBox::warning(parent, QObject::tr("Scribus Development Version"), "<qt>" +
2132 cbradney 563
                                                                 QObject::tr("You are running a development version of Scribus 1.3.x. The current document you are working with was originally created in Scribus 1.2.2 or lower. The process of saving will make this file unusable again in Scribus 1.2.2 unless you use File->Save As. Are you sure you wish to proceed with this operation?") + "</qt>",
2952 cbradney 564
                                                                 CommonStrings::tr_Cancel, QObject::tr("&Proceed"), "", 1, 0);
1525 cbradney 565
        if (t == 1)
566
                retval = true;
567
        return retval;
568
}
569
 
3 paul 570
void ScribusApp::initMenuBar()
571
{
572
        QFont tmp;
573
        RecentDocs.clear();
1208 cbradney 574
 
575
        scrMenuMgr->createMenu("File", tr("&File"));
576
        scrMenuMgr->addMenuItem(scrActions["fileNew"], "File");
577
        scrMenuMgr->addMenuItem(scrActions["fileOpen"], "File");
578
        recentFileMenuName="FileOpenRecent";
579
        scrMenuMgr->createMenu(recentFileMenuName, tr("Open &Recent"), "File");
580
        scrMenuMgr->addMenuSeparator("File");
581
        scrMenuMgr->addMenuItem(scrActions["fileClose"], "File");
582
        scrMenuMgr->addMenuItem(scrActions["fileSave"], "File");
583
        scrMenuMgr->addMenuItem(scrActions["fileSaveAs"], "File");
584
        scrMenuMgr->addMenuItem(scrActions["fileRevert"], "File");
585
        scrMenuMgr->addMenuItem(scrActions["fileCollect"], "File");
586
        scrMenuMgr->addMenuSeparator("File");
587
        scrMenuMgr->createMenu("FileImport", tr("&Import"), "File");
588
        scrMenuMgr->addMenuItem(scrActions["fileImportText"], "FileImport");
589
        scrMenuMgr->addMenuItem(scrActions["fileImportAppendText"], "FileImport");
590
        scrMenuMgr->addMenuItem(scrActions["fileImportImage"], "FileImport");
591
        scrMenuMgr->createMenu("FileExport", tr("&Export"), "File");
592
        scrMenuMgr->addMenuItem(scrActions["fileExportText"], "FileExport");
593
        scrMenuMgr->addMenuItem(scrActions["fileExportAsEPS"], "FileExport");
594
        scrMenuMgr->addMenuItem(scrActions["fileExportAsPDF"], "FileExport");
595
        scrMenuMgr->addMenuSeparator("File");
596
        scrMenuMgr->addMenuItem(scrActions["fileDocSetup"], "File");
597
        scrMenuMgr->addMenuItem(scrActions["filePrint"], "File");
598
        scrMenuMgr->addMenuSeparator("File");
599
        scrMenuMgr->addMenuItem(scrActions["fileQuit"], "File");
600
 
1485 tsoots 601
        scrActions["fileClose"]->setEnabled(false);
1208 cbradney 602
        scrActions["fileSave"]->setEnabled(false);
603
        scrActions["fileSaveAs"]->setEnabled(false);
604
        scrActions["fileRevert"]->setEnabled(false);
605
        scrActions["fileCollect"]->setEnabled(false);
606
        scrActions["fileImportText"]->setEnabled(false);
607
        scrActions["fileImportImage"]->setEnabled(false);
608
        scrActions["fileImportAppendText"]->setEnabled(false);
2093 cbradney 609
        scrActions["pageImport"]->setEnabled(false);
1208 cbradney 610
        scrActions["fileExportText"]->setEnabled(false);
611
        scrActions["fileExportAsEPS"]->setEnabled(false);
612
        scrActions["fileExportAsPDF"]->setEnabled(false);
613
        scrMenuMgr->setMenuEnabled("FileExport", false);
614
        scrActions["fileDocSetup"]->setEnabled(false);
615
        scrActions["filePrint"]->setEnabled(false);
1485 tsoots 616
 
1227 cbradney 617
        scrMenuMgr->createMenu("Edit", tr("&Edit"));
618
        scrMenuMgr->addMenuItem(scrActions["editUndoAction"], "Edit");
619
        scrMenuMgr->addMenuItem(scrActions["editRedoAction"], "Edit");
620
        scrMenuMgr->addMenuItem(scrActions["editActionMode"], "Edit");
621
        scrMenuMgr->addMenuSeparator("Edit");
622
        scrMenuMgr->addMenuItem(scrActions["editCut"], "Edit");
623
        scrMenuMgr->addMenuItem(scrActions["editCopy"], "Edit");
624
        scrMenuMgr->addMenuItem(scrActions["editPaste"], "Edit");
1963 cbradney 625
        scrMenuMgr->addMenuItem(scrActions["editClearContents"], "Edit");
1227 cbradney 626
        scrMenuMgr->addMenuItem(scrActions["editSelectAll"], "Edit");
1837 cbradney 627
        scrMenuMgr->addMenuItem(scrActions["editDeselectAll"], "Edit");
1227 cbradney 628
        scrMenuMgr->addMenuSeparator("Edit");
629
        scrMenuMgr->addMenuItem(scrActions["editSearchReplace"], "Edit");
1981 cbradney 630
        scrMenuMgr->addMenuItem(scrActions["toolsEditWithStoryEditor"], "Edit");
2259 cbradney 631
        scrMenuMgr->addMenuItem(scrActions["editEditWithImageEditor"], "Edit");
1227 cbradney 632
        scrMenuMgr->addMenuSeparator("Edit");
633
        scrMenuMgr->addMenuItem(scrActions["editColors"], "Edit");
634
        scrMenuMgr->addMenuItem(scrActions["editParaStyles"], "Edit");
635
        scrMenuMgr->addMenuItem(scrActions["editLineStyles"], "Edit");
2093 cbradney 636
        scrMenuMgr->addMenuItem(scrActions["editMasterPages"], "Edit");
1227 cbradney 637
        scrMenuMgr->addMenuItem(scrActions["editJavascripts"], "Edit");
638
        scrMenuMgr->addMenuSeparator("Edit");
639
        scrMenuMgr->addMenuItem(scrActions["editPreferences"], "Edit");
640
        scrActions["editUndoAction"]->setEnabled(false);
641
        scrActions["editRedoAction"]->setEnabled(false);
1446 tsoots 642
        scrActions["editActionMode"]->setEnabled(true);
1227 cbradney 643
        scrActions["editCut"]->setEnabled(false);
644
        scrActions["editCopy"]->setEnabled(false);
645
        scrActions["editPaste"]->setEnabled(false);
1963 cbradney 646
        scrActions["editClearContents"]->setEnabled(false);
1227 cbradney 647
        scrActions["editSelectAll"]->setEnabled(false);
1837 cbradney 648
        scrActions["editDeselectAll"]->setEnabled(false);
1227 cbradney 649
        scrActions["editSearchReplace"]->setEnabled(false);
650
        scrActions["editParaStyles"]->setEnabled(false);
651
        scrActions["editLineStyles"]->setEnabled(false);
2093 cbradney 652
        scrActions["editMasterPages"]->setEnabled(false);
1227 cbradney 653
        scrActions["editJavascripts"]->setEnabled(false);
1996 cbradney 654
        scrActions["toolsEditWithStoryEditor"]->setEnabled(false);
2279 cbradney 655
        scrActions["editEditWithImageEditor"]->setEnabled(false);
1227 cbradney 656
 
657
        //Style Menu
1325 cbradney 658
        scrMenuMgr->createMenu("Style", tr("St&yle"));
1437 cbradney 659
        //Color menu
660
        // CB TODO
661
        scrMenuMgr->createMenu("Color", tr("&Color"));
662
        ColorMenC = new QComboBox(false);
663
        ColorMenC->setEditable(false);
664
        scrMenuMgr->addMenuItem(ColorMenC, "Color");
1485 tsoots 665
 
1437 cbradney 666
        //Text size menu
667
        scrMenuMgr->createMenu("FontSize", tr("&Size"));
668
        scrActionGroups["fontSize"]->addTo(scrMenuMgr->getLocalPopupMenu("FontSize"));
1485 tsoots 669
 
1437 cbradney 670
        //Shade menu
671
        scrMenuMgr->createMenu("Shade", tr("&Shade"));
672
        scrActionGroups["shade"]->addTo(scrMenuMgr->getLocalPopupMenu("Shade"));
1485 tsoots 673
 
1437 cbradney 674
        //Font menu
675
        scrMenuMgr->createMenu("Font", tr("&Font"));
676
        FontMenu = scrMenuMgr->getLocalPopupMenu("Font");
1485 tsoots 677
 
1437 cbradney 678
        //Type style menu
679
        scrMenuMgr->createMenu("TypeEffects", tr("&Effects"));
680
        scrActionGroups["typeEffects"]->addTo(scrMenuMgr->getLocalPopupMenu("TypeEffects"));
1485 tsoots 681
 
1236 cbradney 682
        //Item Menu
683
        scrMenuMgr->createMenu("Item", tr("&Item"));
684
        scrMenuMgr->addMenuItem(scrActions["itemDuplicate"], "Item");
685
        scrMenuMgr->addMenuItem(scrActions["itemMulDuplicate"], "Item");
686
        scrMenuMgr->addMenuItem(scrActions["itemDelete"], "Item");
687
        scrMenuMgr->addMenuSeparator("Item");
688
        scrMenuMgr->addMenuItem(scrActions["itemGroup"], "Item");
689
        scrMenuMgr->addMenuItem(scrActions["itemUngroup"], "Item");
690
        scrMenuMgr->addMenuItem(scrActions["itemLock"], "Item");
1858 cbradney 691
        scrMenuMgr->addMenuItem(scrActions["itemLockSize"], "Item");
2256 cbradney 692
        scrMenuMgr->addMenuSeparator("Item");
2026 cbradney 693
        scrMenuMgr->addMenuItem(scrActions["itemImageIsVisible"], "Item");
2260 cbradney 694
        scrMenuMgr->addMenuItem(scrActions["itemUpdateImage"], "Item");
2259 cbradney 695
        scrMenuMgr->addMenuItem(scrActions["itemAdjustFrameToImage"], "Item");
2260 cbradney 696
        scrMenuMgr->addMenuItem(scrActions["itemExtendedImageProperties"], "Item");
2959 subik 697
        scrMenuMgr->createMenu("ItemPreviewSettings", tr("Preview Settings"), "Item");
2256 cbradney 698
        scrMenuMgr->addMenuItem(scrActions["itemPreviewLow"], "ItemPreviewSettings");
699
        scrMenuMgr->addMenuItem(scrActions["itemPreviewNormal"], "ItemPreviewSettings");
700
        scrMenuMgr->addMenuItem(scrActions["itemPreviewFull"], "ItemPreviewSettings");
1236 cbradney 701
        scrMenuMgr->addMenuSeparator("Item");
2959 subik 702
        scrMenuMgr->createMenu("ItemLevel", tr("Level"));
1858 cbradney 703
        scrMenuMgr->addMenuToMenu("ItemLevel", "Item");
2104 cbradney 704
        scrMenuMgr->addMenuItem(scrActions["itemRaise"], "ItemLevel");
1858 cbradney 705
        scrMenuMgr->addMenuItem(scrActions["itemLower"], "ItemLevel");
2104 cbradney 706
        scrMenuMgr->addMenuItem(scrActions["itemRaiseToTop"], "ItemLevel");
707
        scrMenuMgr->addMenuItem(scrActions["itemLowerToBottom"], "ItemLevel");
2959 subik 708
        scrMenuMgr->createMenu("ItemLayer", tr("Send to La&yer"));
2408 cbradney 709
        scrMenuMgr->addMenuToMenu("ItemLayer", "Item");
710
        layerMenuName="ItemLayer";
1981 cbradney 711
        scrMenuMgr->addMenuItem(scrActions["itemSendToScrapbook"], "Item");
1236 cbradney 712
        scrMenuMgr->addMenuSeparator("Item");
2256 cbradney 713
        scrMenuMgr->addMenuItem(scrActions["itemAttributes"], "Item");
1981 cbradney 714
        scrMenuMgr->createMenu("ItemPDFOptions", tr("&PDF Options"));
715
        scrMenuMgr->addMenuToMenu("ItemPDFOptions", "Item");
716
        scrMenuMgr->addMenuItem(scrActions["itemPDFIsAnnotation"], "ItemPDFOptions");
2143 subik 717
        scrMenuMgr->addMenuItem(scrActions["itemPDFIsBookmark"], "ItemPDFOptions");
1981 cbradney 718
        scrMenuMgr->addMenuItem(scrActions["itemPDFAnnotationProps"], "ItemPDFOptions");
719
        scrMenuMgr->addMenuItem(scrActions["itemPDFFieldProps"], "ItemPDFOptions");
1236 cbradney 720
        scrMenuMgr->createMenu("ItemShapes", tr("&Shape"), "Item");
721
        // CB TODO
722
        //Shape menu
169 Franz 723
        SCustom = new Autoforms(0);
1236 cbradney 724
        scrMenuMgr->addMenuItem(SCustom, "ItemShapes");
272 Franz 725
        connect(SCustom, SIGNAL(FormSel(int, int, double *)), this, SLOT(MakeFrame(int, int, double *)));
1236 cbradney 726
        scrMenuMgr->addMenuItem(scrActions["itemShapeEdit"], "ItemShapes");
1858 cbradney 727
        scrMenuMgr->createMenu("ItemConvertTo", tr("C&onvert To"));
728
        scrMenuMgr->addMenuToMenu("ItemConvertTo", "Item");
729
        scrMenuMgr->addMenuItem(scrActions["itemConvertToBezierCurve"], "ItemConvertTo");
730
        scrMenuMgr->addMenuItem(scrActions["itemConvertToImageFrame"], "ItemConvertTo");
731
        scrMenuMgr->addMenuItem(scrActions["itemConvertToOutlines"], "ItemConvertTo");
732
        scrMenuMgr->addMenuItem(scrActions["itemConvertToPolygon"], "ItemConvertTo");
733
        scrMenuMgr->addMenuItem(scrActions["itemConvertToTextFrame"], "ItemConvertTo");
2143 subik 734
 
1236 cbradney 735
        scrMenuMgr->addMenuItem(scrActions["itemAttachTextToPath"], "Item");
736
        scrMenuMgr->addMenuItem(scrActions["itemDetachTextFromPath"], "Item");
737
        scrMenuMgr->addMenuItem(scrActions["itemCombinePolygons"], "Item");
738
        scrMenuMgr->addMenuItem(scrActions["itemSplitPolygons"], "Item");
739
        scrMenuMgr->setMenuEnabled("ItemShapes", false);
740
        scrActions["itemGroup"]->setEnabled(false);
741
        scrActions["itemUngroup"]->setEnabled(false);
742
        scrActions["itemAttachTextToPath"]->setEnabled(false);
743
        scrActions["itemDetachTextFromPath"]->setEnabled(false);
744
        scrActions["itemCombinePolygons"]->setEnabled(false);
745
        scrActions["itemSplitPolygons"]->setEnabled(false);
746
        scrActions["itemLock"]->setEnabled(false);
1858 cbradney 747
        scrActions["itemLockSize"]->setEnabled(false);
2026 cbradney 748
        scrActions["itemImageIsVisible"]->setEnabled(false);
1858 cbradney 749
        scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
750
        scrActions["itemConvertToBezierCurve"]->setEnabled(false);
751
        scrActions["itemConvertToImageFrame"]->setEnabled(false);
1236 cbradney 752
        scrActions["itemConvertToOutlines"]->setEnabled(false);
1858 cbradney 753
        scrActions["itemConvertToPolygon"]->setEnabled(false);
754
        scrActions["itemConvertToTextFrame"]->setEnabled(false);
1485 tsoots 755
 
1801 cbradney 756
        //Insert menu
757
        scrMenuMgr->createMenu("Insert", tr("I&nsert"));
758
        scrMenuMgr->addMenuItem(scrActions["toolsInsertTextFrame"], "Insert");
759
        scrMenuMgr->addMenuItem(scrActions["toolsInsertImageFrame"], "Insert");
760
        scrMenuMgr->addMenuItem(scrActions["toolsInsertTableFrame"], "Insert");
761
        scrMenuMgr->addMenuItem(scrActions["toolsInsertShape"], "Insert");
762
        scrMenuMgr->addMenuItem(scrActions["toolsInsertPolygon"], "Insert");
763
        scrMenuMgr->addMenuItem(scrActions["toolsInsertLine"], "Insert");
764
        scrMenuMgr->addMenuItem(scrActions["toolsInsertBezier"], "Insert");
765
        scrMenuMgr->addMenuItem(scrActions["toolsInsertFreehandLine"], "Insert");
766
        scrMenuMgr->addMenuSeparator("Insert");
1903 cbradney 767
        scrMenuMgr->addMenuItem(scrActions["insertGlyph"], "Insert");
2143 subik 768
 
2226 cbradney 769
        scrMenuMgr->createMenu("InsertChar", tr("Character"), "Insert");
770
        //scrMenuMgr->addMenuToMenu("InsertChar", "Insert");
1903 cbradney 771
        scrMenuMgr->addMenuItem(scrActions["specialPageNumber"], "InsertChar");
772
        scrMenuMgr->addMenuItem(scrActions["specialSmartHyphen"], "InsertChar");
2407 fschmid 773
        scrMenuMgr->addMenuItem(scrActions["specialNonBreakingHyphen"], "InsertChar");
2039 cbradney 774
        scrMenuMgr->addMenuSeparator("InsertChar");
1903 cbradney 775
        scrMenuMgr->addMenuItem(scrActions["specialCopyRight"], "InsertChar");
776
        scrMenuMgr->addMenuItem(scrActions["specialRegdTM"], "InsertChar");
777
        scrMenuMgr->addMenuItem(scrActions["specialTM"], "InsertChar");
778
        scrMenuMgr->addMenuItem(scrActions["specialBullet"], "InsertChar");
779
        scrMenuMgr->addMenuSeparator("InsertChar");
780
        scrMenuMgr->addMenuItem(scrActions["specialDashEm"], "InsertChar");
781
        scrMenuMgr->addMenuItem(scrActions["specialDashEn"], "InsertChar");
782
        scrMenuMgr->addMenuItem(scrActions["specialDashFigure"], "InsertChar");
783
        scrMenuMgr->addMenuItem(scrActions["specialDashQuotation"], "InsertChar");
2143 subik 784
 
2226 cbradney 785
        scrMenuMgr->createMenu("InsertQuote", tr("Quote"), "Insert");
786
        //scrMenuMgr->addMenuToMenu("InsertQuote", "Insert");
2039 cbradney 787
        scrMenuMgr->addMenuItem(scrActions["specialQuoteApostrophe"], "InsertQuote");
788
        scrMenuMgr->addMenuItem(scrActions["specialQuoteStraight"], "InsertQuote");
789
        scrMenuMgr->addMenuSeparator("InsertQuote");
790
        scrMenuMgr->addMenuItem(scrActions["specialQuoteSingleLeft"], "InsertQuote");
791
        scrMenuMgr->addMenuItem(scrActions["specialQuoteSingleRight"], "InsertQuote");
792
        scrMenuMgr->addMenuItem(scrActions["specialQuoteDoubleLeft"], "InsertQuote");
793
        scrMenuMgr->addMenuItem(scrActions["specialQuoteDoubleRight"], "InsertQuote");
794
        scrMenuMgr->addMenuSeparator("InsertQuote");
795
        scrMenuMgr->addMenuItem(scrActions["specialQuoteSingleReversed"], "InsertQuote");
796
        scrMenuMgr->addMenuItem(scrActions["specialQuoteDoubleReversed"], "InsertQuote");
797
        scrMenuMgr->addMenuSeparator("InsertQuote");
798
        scrMenuMgr->addMenuItem(scrActions["specialQuoteSingleLeftGuillemet"], "InsertQuote");
799
        scrMenuMgr->addMenuItem(scrActions["specialQuoteSingleRightGuillemet"], "InsertQuote");
800
        scrMenuMgr->addMenuItem(scrActions["specialQuoteDoubleLeftGuillemet"], "InsertQuote");
801
        scrMenuMgr->addMenuItem(scrActions["specialQuoteDoubleRightGuillemet"], "InsertQuote");
802
        scrMenuMgr->addMenuSeparator("InsertQuote");
803
        scrMenuMgr->addMenuItem(scrActions["specialQuoteLowSingleComma"], "InsertQuote");
804
        scrMenuMgr->addMenuItem(scrActions["specialQuoteLowDoubleComma"], "InsertQuote");
805
        scrMenuMgr->addMenuItem(scrActions["specialQuoteDoubleTurnedComma"], "InsertQuote");
806
        scrMenuMgr->addMenuSeparator("InsertQuote");
807
        scrMenuMgr->addMenuItem(scrActions["specialQuoteCJKSingleLeft"], "InsertQuote");
808
        scrMenuMgr->addMenuItem(scrActions["specialQuoteCJKSingleRight"], "InsertQuote");
809
        scrMenuMgr->addMenuItem(scrActions["specialQuoteCJKDoubleLeft"], "InsertQuote");
810
        scrMenuMgr->addMenuItem(scrActions["specialQuoteCJKDoubleRight"], "InsertQuote");
1903 cbradney 811
 
2226 cbradney 812
        scrMenuMgr->createMenu("InsertSpace", tr("Space"), "Insert");
813
        //scrMenuMgr->addMenuToMenu("InsertSpace", "Insert");
1903 cbradney 814
        scrMenuMgr->addMenuItem(scrActions["specialNonBreakingSpace"], "InsertSpace");
2352 fschmid 815
        scrMenuMgr->addMenuItem(scrActions["specialNewLine"], "InsertSpace");
816
        scrMenuMgr->addMenuItem(scrActions["specialFrameBreak"], "InsertSpace");
2384 fschmid 817
        scrMenuMgr->addMenuItem(scrActions["specialColumnBreak"], "InsertSpace");
1903 cbradney 818
        scrMenuMgr->addMenuSeparator("Insert");
1818 cbradney 819
        scrMenuMgr->addMenuItem(scrActions["insertSampleText"], "Insert");
1903 cbradney 820
        scrActions["insertGlyph"]->setEnabled(false);
2143 subik 821
 
1236 cbradney 822
        //Page menu
823
        scrMenuMgr->createMenu("Page", tr("&Page"));
824
        scrMenuMgr->addMenuItem(scrActions["pageInsert"], "Page");
2143 subik 825
        scrMenuMgr->addMenuItem(scrActions["pageImport"], "Page");
1236 cbradney 826
        scrMenuMgr->addMenuItem(scrActions["pageDelete"], "Page");
827
        scrMenuMgr->addMenuItem(scrActions["pageCopy"], "Page");
828
        scrMenuMgr->addMenuItem(scrActions["pageMove"], "Page");
2093 cbradney 829
        scrMenuMgr->addMenuItem(scrActions["pageApplyMasterPage"], "Page");
1236 cbradney 830
        scrMenuMgr->addMenuItem(scrActions["pageManageGuides"], "Page");
2777 fschmid 831
        scrMenuMgr->addMenuItem(scrActions["pageManageMargins"], "Page");
3098 cbradney 832
        scrMenuMgr->addMenuSeparator("Page");
833
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGrid"], "Page");
834
        scrMenuMgr->addMenuItem(scrActions["viewSnapToGuides"], "Page");
1236 cbradney 835
        scrActions["pageDelete"]->setEnabled(false);
836
        scrActions["pageMove"]->setEnabled(false);
1485 tsoots 837
 
1236 cbradney 838
        //View menu
1246 cbradney 839
        scrMenuMgr->createMenu("View", tr("&View"));
840
        scrMenuMgr->addMenuItem(scrActions["viewFitInWindow"], "View");
841
        scrMenuMgr->addMenuItem(scrActions["viewFit50"], "View");
842
        scrMenuMgr->addMenuItem(scrActions["viewFit75"], "View");
843
        scrMenuMgr->addMenuItem(scrActions["viewFit100"], "View");
844
        scrMenuMgr->addMenuItem(scrActions["viewFit200"], "View");
845
        scrMenuMgr->addMenuItem(scrActions["viewFit20"], "View");
846
        scrMenuMgr->addMenuSeparator("View");
847
        scrMenuMgr->addMenuItem(scrActions["viewShowMargins"], "View");
848
        scrMenuMgr->addMenuItem(scrActions["viewShowFrames"], "View");
849
        scrMenuMgr->addMenuItem(scrActions["viewShowImages"], "View");
850
        scrMenuMgr->addMenuItem(scrActions["viewShowGrid"], "View");
851
        scrMenuMgr->addMenuItem(scrActions["viewShowGuides"], "View");
1334 cbradney 852
        scrMenuMgr->addMenuItem(scrActions["viewShowBaseline"], "View");
1246 cbradney 853
        scrMenuMgr->addMenuItem(scrActions["viewShowTextChain"], "View");
2353 fschmid 854
        scrMenuMgr->addMenuItem(scrActions["viewShowTextControls"], "View");
2863 fschmid 855
        scrMenuMgr->addMenuItem(scrActions["viewRulerMode"], "View");
3098 cbradney 856
 
857
        //CB If this is viewNewView imeplemented, it should be on the windows menu
1330 fschmid 858
//      scrMenuMgr->addMenuItem(scrActions["viewNewView"], "View");
1485 tsoots 859
 
1236 cbradney 860
        //Tool menu
3097 cbradney 861
        /*
1255 cbradney 862
        scrMenuMgr->createMenu("Tools", tr("&Tools"));
863
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Tools");
864
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Tools");
865
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Tools");
866
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Tools");
867
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Tools");
868
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Tools");
1525 cbradney 869
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Tools");
1255 cbradney 870
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Tools");
871
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Tools");
2355 cbradney 872
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Tools");
1255 cbradney 873
        scrMenuMgr->addMenuSeparator("Tools");
874
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Tools");
1485 tsoots 875
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Tools");
3097 cbradney 876
        //scrActions["toolsPreflightVerifier"]->setEnabled(false);*/
1485 tsoots 877
 
1236 cbradney 878
        //Extra menu
1260 cbradney 879
        scrMenuMgr->createMenu("Extras", tr("E&xtras"));
880
        scrMenuMgr->addMenuItem(scrActions["extrasManagePictures"], "Extras");
881
        scrMenuMgr->addMenuItem(scrActions["extrasHyphenateText"], "Extras");
2621 fschmid 882
        scrMenuMgr->addMenuItem(scrActions["extrasDeHyphenateText"], "Extras");
1694 cbradney 883
        scrMenuMgr->addMenuItem(scrActions["extrasGenerateTableOfContents"], "Extras");
2143 subik 884
 
1260 cbradney 885
        scrMenuMgr->setMenuEnabled("Extras", false);
886
        scrActions["extrasHyphenateText"]->setEnabled(false);
2621 fschmid 887
        scrActions["extrasDeHyphenateText"]->setEnabled(false);
1485 tsoots 888
 
1236 cbradney 889
        //Window menu
1260 cbradney 890
        scrMenuMgr->createMenu("Windows", tr("&Windows"));
891
        connect(scrMenuMgr->getLocalPopupMenu("Windows"), SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
3097 cbradney 892
        addDefaultWindowMenuItems();
893
 
1260 cbradney 894
        //Help menu
1269 cbradney 895
        scrMenuMgr->createMenu("Help", tr("&Help"));
896
        scrMenuMgr->addMenuItem(scrActions["helpAboutScribus"], "Help");
897
        scrMenuMgr->addMenuItem(scrActions["helpAboutQt"], "Help");
898
        scrMenuMgr->addMenuSeparator("Help");
899
        scrMenuMgr->addMenuItem(scrActions["helpTooltips"], "Help");
900
        scrMenuMgr->addMenuItem(scrActions["helpManual"], "Help");
1485 tsoots 901
 
1208 cbradney 902
        scrMenuMgr->addMenuToMenuBar("File");
1227 cbradney 903
        scrMenuMgr->addMenuToMenuBar("Edit");
1325 cbradney 904
        scrMenuMgr->addMenuToMenuBar("Style");
905
        scrMenuMgr->setMenuEnabled("Style", false);
1236 cbradney 906
        scrMenuMgr->addMenuToMenuBar("Item");
1801 cbradney 907
        scrMenuMgr->setMenuEnabled("Item", false);
908
        scrMenuMgr->addMenuToMenuBar("Insert");
909
        scrMenuMgr->setMenuEnabled("Insert", false);
1236 cbradney 910
        scrMenuMgr->addMenuToMenuBar("Page");
911
        scrMenuMgr->setMenuEnabled("Page", false);
1246 cbradney 912
        scrMenuMgr->addMenuToMenuBar("View");
913
        scrMenuMgr->setMenuEnabled("View", false);
3097 cbradney 914
        //scrMenuMgr->addMenuToMenuBar("Tools");
1260 cbradney 915
        scrMenuMgr->addMenuToMenuBar("Extras");
916
        scrMenuMgr->setMenuEnabled("Extras", false);
917
        scrMenuMgr->addMenuToMenuBar("Windows");
3097 cbradney 918
        //scrMenuMgr->setMenuEnabled("Windows", false);
3 paul 919
        menuBar()->insertSeparator();
1269 cbradney 920
        scrMenuMgr->addMenuToMenuBar("Help");
921
 
1236 cbradney 922
        //Alignment menu
1325 cbradney 923
        scrMenuMgr->createMenu("Alignment", tr("&Alignment"));
1337 cbradney 924
        scrMenuMgr->addMenuItem(scrActions["alignLeft"], "Alignment");
925
        scrMenuMgr->addMenuItem(scrActions["alignCenter"], "Alignment");
926
        scrMenuMgr->addMenuItem(scrActions["alignRight"], "Alignment");
927
        scrMenuMgr->addMenuItem(scrActions["alignBlock"], "Alignment");
928
        scrMenuMgr->addMenuItem(scrActions["alignForced"], "Alignment");
1443 tsoots 929
 
801 cbradney 930
        connect(ColorMenC, SIGNAL(activated(int)), this, SLOT(setItemFarbe(int)));
931
        connect(FontMenu, SIGNAL(activated(int)), this, SLOT(setItemFont(int)));
3 paul 932
}
933
 
3097 cbradney 934
void ScribusApp::addDefaultWindowMenuItems()
935
{
936
        scrMenuMgr->clearMenu("Windows");
937
        scrMenuMgr->addMenuItem(scrActions["windowsCascade"], "Windows");
938
        scrMenuMgr->addMenuItem(scrActions["windowsTile"], "Windows");
939
        scrMenuMgr->addMenuSeparator("Windows");
940
 
941
        scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Windows");
942
        scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Windows");
943
        scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Windows");
944
        scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Windows");
945
        scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Windows");
946
        scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Windows");
947
        scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Windows");
948
        scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Windows");
949
        scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Windows");
950
        scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Windows");
951
        scrMenuMgr->addMenuSeparator("Windows");
952
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Windows");
953
        scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Windows");
954
}
955
 
956
 
3 paul 957
void ScribusApp::initStatusBar()
958
{
2433 cbradney 959
        mainWindowStatusLabel = new QLabel( "           ", statusBar(), "ft");
960
        mainWindowProgressBar = new QProgressBar(statusBar(), "p");
961
        mainWindowProgressBar->setCenterIndicator(true);
962
        mainWindowProgressBar->setFixedWidth( 100 );
963
        mainWindowProgressBar->reset();
964
        mainWindowXPosLabel = new QLabel( "X-Pos:", statusBar(), "xt");
965
        mainWindowYPosLabel = new QLabel( "Y-Pos:", statusBar(), "yt");
966
        mainWindowXPosDataLabel = new QLabel( "         ", statusBar(), "dt");
967
        mainWindowYPosDataLabel = new QLabel( "         ", statusBar(), "ydt");
809 cbradney 968
 
2433 cbradney 969
        statusBar()->addWidget(mainWindowStatusLabel, 3, true);
970
        statusBar()->addWidget(mainWindowProgressBar, 0, true);
971
        statusBar()->addWidget(mainWindowXPosLabel, 0, true);
972
        statusBar()->addWidget(mainWindowXPosDataLabel, 1, true);
973
        statusBar()->addWidget(mainWindowYPosLabel, 0, true);
974
        statusBar()->addWidget(mainWindowYPosDataLabel, 1, true);
3 paul 975
}
976
 
2150 cbradney 977
void ScribusApp::setMousePositionOnStatusBar(double xp, double yp)
3 paul 978
{
2867 fschmid 979
        double xn = xp;
980
        double yn = yp;
981
        if (doc->guidesSettings.rulerMode)
982
        {
983
                xn -= doc->currentPage->Xoffset;
984
                yn -= doc->currentPage->Yoffset;
985
        }
986
        xn -= doc->rulerXoffset;
987
        yn -= doc->rulerYoffset;
2965 cbradney 988
        QString suffix=unitGetSuffixFromIndex(doc->unitIndex());
989
        int multiplier=unitGetDecimalsFromIndex(doc->unitIndex());
2150 cbradney 990
        double divisor=static_cast<double>(multiplier);
2965 cbradney 991
        int precision=unitGetPrecisionFromIndex(doc->unitIndex());
809 cbradney 992
        QString tmp;
2965 cbradney 993
        mainWindowXPosDataLabel->setText(tmp.setNum(qRound(xn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
994
        mainWindowYPosDataLabel->setText(tmp.setNum(qRound(yn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
3 paul 995
}
996
 
2150 cbradney 997
void ScribusApp::deleteSelectedTextFromFrame(PageItem *currItem)
3 paul 998
{
2150 cbradney 999
        int firstSelection = 0;
238 Franz 1000
        bool first = false;
1957 cbradney 1001
        for (ScText *it = currItem->itemText.first(); it != 0; it = currItem->itemText.next())
272 Franz 1002
        {
1003
                if (it->cselect)
1004
                {
238 Franz 1005
                        first = true;
2434 fschmid 1006
                        if ((it->ch == QChar(25)) && (it->cembedded != 0))
2499 fschmid 1007
                        {
2447 fschmid 1008
                                doc->FrameItems.remove(it->cembedded);
2499 fschmid 1009
                                delete it->cembedded;
1010
                        }
1957 cbradney 1011
                        currItem->itemText.remove();
1012
                        it = currItem->itemText.prev();
272 Franz 1013
                        if (it == 0)
1957 cbradney 1014
                                it = currItem->itemText.first();
272 Franz 1015
                }
238 Franz 1016
                if (!first)
2150 cbradney 1017
                        firstSelection++;
272 Franz 1018
        }
1957 cbradney 1019
        if (currItem->itemText.count() != 0)
238 Franz 1020
        {
1957 cbradney 1021
                if (currItem->itemText.first()->cselect)
3 paul 1022
                {
1957 cbradney 1023
                        currItem->itemText.remove();
1024
                        currItem->CPos = 0;
238 Franz 1025
                }
3 paul 1026
                else
2150 cbradney 1027
                        currItem->CPos = firstSelection;
238 Franz 1028
        }
3 paul 1029
        else
1957 cbradney 1030
                currItem->CPos = 0;
1031
        currItem->HasSel = false;
2447 fschmid 1032
        for (uint a = 0; a < doc->FrameItems.count(); ++a)
2443 fschmid 1033
        {
2447 fschmid 1034
                doc->FrameItems.at(a)->ItemNr = a;
2443 fschmid 1035
        }
272 Franz 1036
        DisableTxEdit();
3 paul 1037
}
1038
 
1957 cbradney 1039
void ScribusApp::setTBvals(PageItem *currItem)
3 paul 1040
{
1957 cbradney 1041
        if (currItem->itemText.count() != 0)
272 Franz 1042
        {
1957 cbradney 1043
                int ChPos = QMIN(currItem->CPos, static_cast<int>(currItem->itemText.count()-1));
2185 fschmid 1044
                doc->CurrentStyle = currItem->itemText.at(ChPos)->cstyle & 1919;
1957 cbradney 1045
                doc->currentParaStyle = currItem->itemText.at(ChPos)->cab;
1065 cbradney 1046
                setAbsValue(doc->currentParaStyle);
1545 cbradney 1047
                propertiesPalette->setAli(doc->currentParaStyle);
1957 cbradney 1048
                doc->CurrFont = currItem->itemText.at(ChPos)->cfont->SCName;
1049
                doc->CurrFontSize = currItem->itemText.at(ChPos)->csize;
1050
                doc->CurrTextFill = currItem->itemText.at(ChPos)->ccolor;
1051
                doc->CurrTextFillSh = currItem->itemText.at(ChPos)->cshade;
1052
                doc->CurrTextStroke = currItem->itemText.at(ChPos)->cstroke;
1053
                doc->CurrTextStrokeSh = currItem->itemText.at(ChPos)->cshade2;
1054
                doc->CurrTextScale = currItem->itemText.at(ChPos)->cscale;
2230 fschmid 1055
                doc->CurrTextScaleV = currItem->itemText.at(ChPos)->cscalev;
2234 fschmid 1056
                doc->CurrTextBase = currItem->itemText.at(ChPos)->cbase;
2247 fschmid 1057
                doc->CurrTextShadowX = currItem->itemText.at(ChPos)->cshadowx;
1058
                doc->CurrTextShadowY = currItem->itemText.at(ChPos)->cshadowy;
2257 fschmid 1059
                doc->CurrTextOutline = currItem->itemText.at(ChPos)->coutline;
2262 fschmid 1060
                doc->CurrTextUnderPos = currItem->itemText.at(ChPos)->cunderpos;
1061
                doc->CurrTextUnderWidth = currItem->itemText.at(ChPos)->cunderwidth;
2272 fschmid 1062
                doc->CurrTextStrikePos = currItem->itemText.at(ChPos)->cstrikepos;
1063
                doc->CurrTextStrikeWidth = currItem->itemText.at(ChPos)->cstrikewidth;
2262 fschmid 1064
                emit TextUnderline(doc->CurrTextUnderPos, doc->CurrTextUnderWidth);
2272 fschmid 1065
                emit TextStrike(doc->CurrTextStrikePos, doc->CurrTextStrikeWidth);
2247 fschmid 1066
                emit TextShadow(doc->CurrTextShadowX, doc->CurrTextShadowY);
68 Franz 1067
                emit TextFarben(doc->CurrTextStroke, doc->CurrTextFill, doc->CurrTextStrokeSh, doc->CurrTextFillSh);
1068
                emit TextIFont(doc->CurrFont);
272 Franz 1069
                emit TextISize(doc->CurrFontSize);
1957 cbradney 1070
                emit TextUSval(currItem->itemText.at(ChPos)->cextra);
272 Franz 1071
                emit TextStil(doc->CurrentStyle);
68 Franz 1072
                emit TextScale(doc->CurrTextScale);
2230 fschmid 1073
                emit TextScaleV(doc->CurrTextScaleV);
2234 fschmid 1074
                emit TextBase(doc->CurrTextBase);
2257 fschmid 1075
                emit TextOutline(doc->CurrTextOutline);
272 Franz 1076
        }
3 paul 1077
}
1078
 
1079
void ScribusApp::wheelEvent(QWheelEvent *w)
1080
{
1081
        if (HaveDoc)
239 Franz 1082
        {
2871 cbradney 1083
                int wheelVal=prefsManager->mouseWheelValue();
276 Franz 1084
                if ((w->orientation() != Qt::Vertical) || ( w->state() & ShiftButton ))
3 paul 1085
                {
239 Franz 1086
                        if (w->delta() < 0)
2871 cbradney 1087
                                view->scrollBy(wheelVal, 0);
239 Franz 1088
                        else
2871 cbradney 1089
                                view->scrollBy(-wheelVal, 0);
239 Franz 1090
                }
3 paul 1091
                else
239 Franz 1092
                {
1093
                        if (w->delta() < 0)
2871 cbradney 1094
                                view->scrollBy(0, wheelVal);
239 Franz 1095
                        else
2871 cbradney 1096
                                view->scrollBy(0, -wheelVal);
239 Franz 1097
                }
3 paul 1098
                w->accept();
239 Franz 1099
        }
3 paul 1100
}
1101
 
1485 tsoots 1102
//Special keys assigned to actions are stolen by the action and not passed to
1445 cbradney 1103
//keyPressEvent so process them here.
1903 cbradney 1104
void ScribusApp::specialActionKeyEvent(QString actionName, int unicodevalue)
1445 cbradney 1105
{
1106
        if (HaveDoc)
1107
        {
2603 cbradney 1108
                if (doc->appMode==modeEdit)
1445 cbradney 1109
                {
1110
                        if (view->SelItem.count() == 1)
1111
                        {
1112
                                struct ScText *hg = new ScText;
1957 cbradney 1113
                                PageItem *currItem = view->SelItem.at(0);
1903 cbradney 1114
                                if (unicodevalue!=-1)
1445 cbradney 1115
                                {
1903 cbradney 1116
                                        hg->ch = QString(QChar(unicodevalue));
1789 fschmid 1117
                                        hg->cfont = (*doc->AllFonts)[doc->CurrFont];
1445 cbradney 1118
                                        hg->csize = doc->CurrFontSize;
1119
                                        hg->ccolor = doc->CurrTextFill;
1120
                                        hg->cshade = doc->CurrTextFillSh;
1121
                                        hg->cstroke = doc->CurrTextStroke;
1122
                                        hg->cshade2 = doc->CurrTextStrokeSh;
1123
                                        hg->cscale = doc->CurrTextScale;
2230 fschmid 1124
                                        hg->cscalev = doc->CurrTextScaleV;
2234 fschmid 1125
                                        hg->cbase = doc->CurrTextBase;
2247 fschmid 1126
                                        hg->cshadowx = doc->CurrTextShadowX;
1127
                                        hg->cshadowy = doc->CurrTextShadowY;
2257 fschmid 1128
                                        hg->coutline = doc->CurrTextOutline;
2262 fschmid 1129
                                        hg->cunderpos = doc->CurrTextUnderPos;
1130
                                        hg->cunderwidth = doc->CurrTextUnderWidth;
2272 fschmid 1131
                                        hg->cstrikepos = doc->CurrTextStrikePos;
1132
                                        hg->cstrikewidth = doc->CurrTextStrikeWidth;
1445 cbradney 1133
                                        hg->cselect = false;
1134
                                        hg->cstyle = doc->CurrentStyle;
1135
                                        hg->cab = doc->currentParaStyle;
2877 cbradney 1136
                                        if (!doc->docParagraphStyles[doc->currentParaStyle].Font.isEmpty())
1445 cbradney 1137
                                        {
1789 fschmid 1138
                                                hg->cfont = (*doc->AllFonts)[doc->docParagraphStyles[doc->currentParaStyle].Font];
1445 cbradney 1139
                                                hg->csize = doc->docParagraphStyles[doc->currentParaStyle].FontSize;
1140
                                        }
1141
                                        hg->cextra = 0;
1142
                                        hg->xp = 0;
1143
                                        hg->yp = 0;
1144
                                        hg->PRot = 0;
1145
                                        hg->PtransX = 0;
1146
                                        hg->PtransY = 0;
2434 fschmid 1147
                                        hg->cembedded = 0;
1957 cbradney 1148
                                        currItem->itemText.insert(currItem->CPos, hg);
1149
                                        currItem->CPos += 1;
1150
                                        currItem->Tinput = true;
1151
                                        view->RefreshItem(currItem);
1445 cbradney 1152
                                }
1903 cbradney 1153
                                else if (actionName=="specialSmartHyphen") //ignore the char as we use an attribute if the text item, for now.
1445 cbradney 1154
                                {
1957 cbradney 1155
                                        currItem->itemText.at(QMAX(currItem->CPos-1,0))->cstyle ^= 128;
1156
                                        currItem->Tinput = true;
1157
                                        view->RefreshItem(currItem);
1485 tsoots 1158
                                }
1445 cbradney 1159
                        }
1160
                }
1161
        }
1162
}
1163
 
1493 cbradney 1164
/*!
1165
  \brief Receive key events from palettes such as palette hiding events. Possibly eaier way but this is cleaner than before. No need to modify all those palettes and each new one in future.
1166
 */
1525 cbradney 1167
bool ScribusApp::eventFilter( QObject */*o*/, QEvent *e )
1493 cbradney 1168
{
1525 cbradney 1169
        bool retVal;
1493 cbradney 1170
        if ( e->type() == QEvent::KeyPress ) {
1171
                QKeyEvent *k = (QKeyEvent *)e;
2357 cbradney 1172
                int keyMod=0;
1173
                if (k->state() & ShiftButton)
1174
                        keyMod |= SHIFT;
1175
                if (k->state() & ControlButton)
1176
                        keyMod |= CTRL;
1177
                if (k->state() & AltButton)
1178
                        keyMod |= ALT;
2369 cbradney 1179
 
1493 cbradney 1180
                QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
2878 cbradney 1181
                if (QString(currKeySeq).isNull())
2681 cbradney 1182
                        return false;
1525 cbradney 1183
                retVal=true;
2357 cbradney 1184
                //Palette actions
1493 cbradney 1185
                if (currKeySeq == scrActions["specialToggleAllPalettes"]->accel())
1186
                        scrActions["specialToggleAllPalettes"]->activate();
1187
                else
1188
                if (currKeySeq == scrActions["toolsProperties"]->accel())
1189
                        scrActions["toolsProperties"]->toggle();
1190
                else
1191
                if (currKeySeq == scrActions["toolsOutline"]->accel())
1192
                        scrActions["toolsOutline"]->toggle();
1193
                else
1194
                if (currKeySeq == scrActions["toolsScrapbook"]->accel())
1195
                        scrActions["toolsScrapbook"]->toggle();
1196
                else
1197
                if (currKeySeq == scrActions["toolsLayers"]->accel())
1198
                        scrActions["toolsLayers"]->toggle();
1199
                else
1200
                if (currKeySeq == scrActions["toolsPages"]->accel())
1201
                        scrActions["toolsPages"]->toggle();
1202
                else
1203
                if (currKeySeq == scrActions["toolsBookmarks"]->accel())
1204
                        scrActions["toolsBookmarks"]->toggle();
1205
                else
1206
                if (currKeySeq == scrActions["toolsActionHistory"]->accel())
1207
                        scrActions["toolsActionHistory"]->toggle();
1208
                else
1209
                if (currKeySeq == scrActions["toolsPreflightVerifier"]->accel())
1210
                        scrActions["toolsPreflightVerifier"]->toggle();
1525 cbradney 1211
                else
2355 cbradney 1212
                if (currKeySeq == scrActions["toolsAlignDistribute"]->accel())
1213
                        scrActions["toolsAlignDistribute"]->toggle();
1214
                else
2357 cbradney 1215
                //Undo actions
1216
                if (currKeySeq == scrActions["editUndoAction"]->accel() && scrActions["editUndoAction"]->isEnabled())
1217
                        scrActions["editUndoAction"]->activate();
1218
                else
1219
                if (currKeySeq == scrActions["editRedoAction"]->accel() && scrActions["editRedoAction"]->isEnabled())
1220
                        scrActions["editRedoAction"]->activate();
1221
                else
1222
                //Other actions
1565 cbradney 1223
                if (currKeySeq == scrActions["fileQuit"]->accel())
1224
                        scrActions["fileQuit"]->activate();
2143 subik 1225
                else
1525 cbradney 1226
                        retVal=false;
1493 cbradney 1227
        }
1525 cbradney 1228
        else
1229
                retVal=false;
1493 cbradney 1230
        //Return false to pass event to object
1231
        return retVal;
1232
}
1233
 
3 paul 1234
void ScribusApp::keyPressEvent(QKeyEvent *k)
1235
{
146 Franz 1236
        QWidgetList windows;
237 Franz 1237
        QWidget* w = NULL;
1065 cbradney 1238
        struct ScText *hg;
3 paul 1239
        int kk = k->key();
1240
        int as = k->ascii();
80 Franz 1241
        double altx, alty;
3 paul 1242
        QString uc = k->text();
1243
        QString cr, Tcha, Twort;
1244
        uint Tcoun;
237 Franz 1245
        int len, pos, c;
92 Franz 1246
        if (keyrep)
1247
                return;
1248
        keyrep = true;
3 paul 1249
        switch (k->state())
272 Franz 1250
        {
1251
        case ShiftButton:
1554 cbradney 1252
                KeyMod = SHIFT;
272 Franz 1253
                break;
1254
        case AltButton:
1554 cbradney 1255
                KeyMod = ALT;
272 Franz 1256
                break;
1257
        case ControlButton:
1554 cbradney 1258
                KeyMod = CTRL;
272 Franz 1259
                break;
1260
        default:
1261
                KeyMod = 0;
1262
                break;
1263
        }
292 Franz 1264
        if ((kk == Key_Escape) && (HaveDoc))
1265
        {
1266
                keyrep = false;
1957 cbradney 1267
                PageItem *currItem;
855 fschmid 1268
                if ((view->SelItem.count() != 0))
1269
                {
1957 cbradney 1270
                        currItem = view->SelItem.at(0);
1065 cbradney 1271
                        switch (doc->appMode)
855 fschmid 1272
                        {
2603 cbradney 1273
                                case modeNormal:
1957 cbradney 1274
                                        currItem->Sizing = false;
855 fschmid 1275
                                        if (doc->SubMode != -1)
1276
                                        {
1277
                                                view->Deselect(false);
1957 cbradney 1278
                                                doc->Items.remove(currItem->ItemNr);
855 fschmid 1279
                                        }
1280
                                        break;
2603 cbradney 1281
                                case modeLinkFrames:
1282
                                case modeUnlinkFrames:
1283
                                case modeEdit:
1284
                                case modeRotation:
1827 fschmid 1285
                                                view->Deselect(false);
2603 cbradney 1286
                                case modePanning:
855 fschmid 1287
                                        break;
2603 cbradney 1288
                                case modeDrawBezierLine:
1957 cbradney 1289
                                        currItem->PoLine.resize(currItem->PoLine.size()-2);
1290
                                        if (currItem->PoLine.size() < 4)
855 fschmid 1291
                                        {
1292
                                                view->Deselect(false);
1957 cbradney 1293
                                                doc->Items.remove(currItem->ItemNr);
855 fschmid 1294
                                        }
1295
                                        else
1296
                                        {
1957 cbradney 1297
                                                view->SizeItem(currItem->PoLine.WidthHeight().x(), currItem->PoLine.WidthHeight().y(), currItem->ItemNr, false, false);
1298
                                                view->SetPolyClip(currItem, qRound(QMAX(currItem->Pwidth / 2, 1)));
1299
                                                view->AdjustItemSize(currItem);
1300
                                                currItem->ContourLine = currItem->PoLine.copy();
1301
                                                currItem->ClipEdited = true;
1302
                                                currItem->FrameType = 3;
855 fschmid 1303
                                                slotDocCh();
1304
                                        }
1305
                                        view->FirstPoly = true;
1306
                                        break;
1307
                                default:
1308
                                        view->Deselect(false);
1957 cbradney 1309
                                        doc->Items.remove(currItem->ItemNr);
855 fschmid 1310
                                        break;
1311
                        }
1312
                }
1313
                view->Mpressed = false;
1314
                doc->DragP = false;
1315
                doc->leaveDrag = false;
1316
                view->Imoved = false;
1317
                view->mCG = false;
1318
                view->MidButt = false;
1319
                doc->SubMode = -1;
1827 fschmid 1320
                doc->ElemToLink = NULL;
292 Franz 1321
                NoFrameEdit();
1322
                slotSelect();
1323
                return;
1324
        }
232 Franz 1325
        ButtonState buttonState = k->state();
3053 avox 1326
        if ((HaveDoc) && (!view->LE->hasFocus()) && (!view->PGS->focused()))
272 Franz 1327
        {
2603 cbradney 1328
                if ((doc->appMode != modeEdit) && (view->SelItem.count() == 0))
272 Franz 1329
                {
1330
                        switch (kk)
146 Franz 1331
                        {
272 Franz 1332
                        case Key_Space:
1333
                                keyrep = false;
2603 cbradney 1334
                                if (doc->appMode == modePanning)
1335
                                        setAppMode(modeNormal);
272 Franz 1336
                                else
1337
                                {
2603 cbradney 1338
                                        setAppMode(modePanning);
272 Franz 1339
                                        qApp->setOverrideCursor(QCursor(loadIcon("HandC.xpm")), true);
1340
                                }
1341
                                return;
1342
                                break;
1343
                        case Key_Prior:
2871 cbradney 1344
                                view->scrollBy(0, -prefsManager->mouseWheelValue());
272 Franz 1345
                                keyrep = false;
1346
                                return;
1347
                                break;
1348
                        case Key_Next:
2871 cbradney 1349
                                view->scrollBy(0, prefsManager->mouseWheelValue());
272 Franz 1350
                                keyrep = false;
1351
                                return;
1352
                                break;
1353
                        case Key_Tab:
1354
                                keyrep = false;
1355
                                windows = wsp->windowList();
1356
                                if (windows.count() > 1)
1357
                                {
1358
                                        for (int i = 0; i < static_cast<int>(windows.count()); ++i)
250 Franz 1359
                                        {
272 Franz 1360
                                                if (wsp->activeWindow() == windows.at(i))
1361
                                                {
1362
                                                        if (i == static_cast<int>(windows.count()-1))
1363
                                                                w = windows.at(0);
1364
                                                        else
1365
                                                                w = windows.at(i+1);
1366
                                                        break;
1367
                                                }
250 Franz 1368
                                        }
1545 cbradney 1369
                                        doc->OpenNodes = outlinePalette->buildReopenVals();
1370
                                        docCheckerPalette->clearErrorList();
272 Franz 1371
                                        if ( w )
1372
                                                w->showNormal();
1373
                                        newActWin(w);
1374
                                }
1375
                                return;
1376
                                break;
1377
                        }
1378
                }
456 fschmid 1379
                if (view->SelItem.count() != 0)
272 Franz 1380
                {
1957 cbradney 1381
                        PageItem *currItem = view->SelItem.at(0);
1065 cbradney 1382
                        switch (doc->appMode)
272 Franz 1383
                        {
2603 cbradney 1384
                        case modeNormal:
272 Franz 1385
                                switch (kk)
1386
                                {
360 Franz 1387
                                case Key_Backspace:
272 Franz 1388
                                case Key_Delete:
1389
                                        if (!doc->EditClip)
2148 fschmid 1390
                                        {
997 fschmid 1391
                                                view->DeleteItem();
2148 fschmid 1392
                                                slotDocCh();
1393
                                        }
272 Franz 1394
                                        break;
360 Franz 1395
                                case Key_Prior:
1957 cbradney 1396
                                        if (!currItem->locked())
2148 fschmid 1397
                                        {
456 fschmid 1398
                                                view->RaiseItem();
2148 fschmid 1399
                                                slotDocCh();
1400
                                        }
360 Franz 1401
                                        break;
1402
                                case Key_Next:
1957 cbradney 1403
                                        if (!currItem->locked())
2148 fschmid 1404
                                        {
456 fschmid 1405
                                                view->LowerItem();
2148 fschmid 1406
                                                slotDocCh();
1407
                                        }
360 Franz 1408
                                        break;
272 Franz 1409
                                case Key_Left:
1957 cbradney 1410
                                        if (!currItem->locked())
272 Franz 1411
                                        {
2664 fschmid 1412
                                                if ((doc->EditClip) && (view->ClRe != -1))
1413
                                                {
1414
                                                        FPoint np;
1415
                                                        if (view->EditContour)
1416
                                                                np = currItem->ContourLine.point(view->ClRe);
1417
                                                        else
1418
                                                                np = currItem->PoLine.point(view->ClRe);
1419
                                                        if ( buttonState & ShiftButton )
1420
                                                                np = np - FPoint(10.0, 0);
1421
                                                        else if ( buttonState & ControlButton )
1422
                                                                np = np - FPoint(0.1, 0);
1423
                                                        else
1424
                                                                np = np - FPoint(1.0, 0);
1425
                                                        view->MoveClipPoint(currItem, np);
1426
                                                }
272 Franz 1427
                                                else
2664 fschmid 1428
                                                {
1429
                                                        if ( buttonState & ShiftButton )
1430
                                                                view->moveGroup(-10, 0);
1431
                                                        else if ( buttonState & ControlButton )
1432
                                                                view->moveGroup(-0.1, 0);
1433
                                                        else
1434
                                                                view->moveGroup(-1, 0);
1435
                                                }
2148 fschmid 1436
                                                slotDocCh();
272 Franz 1437
                                        }
1438
                                        break;
1439
                                case Key_Right:
1957 cbradney 1440
                                        if (!currItem->locked())
272 Franz 1441
                                        {
2664 fschmid 1442
                                                if ((doc->EditClip) && (view->ClRe != -1))
1443
                                                {
1444
                                                        FPoint np;
1445
                                                        if (view->EditContour)
1446
                                                                np = currItem->ContourLine.point(view->ClRe);
1447
                                                        else
1448
                                                                np = currItem->PoLine.point(view->ClRe);
1449
                                                        if ( buttonState & ShiftButton )
1450
                                                                np = np + FPoint(10.0, 0);
1451
                                                        else if ( buttonState & ControlButton )
1452
                                                                np = np + FPoint(0.1, 0);
1453
                                                        else
1454
                                                                np = np + FPoint(1.0, 0);
1455
                                                        view->MoveClipPoint(currItem, np);
1456
                                                }
272 Franz 1457
                                                else
2664 fschmid 1458
                                                {
1459
                                                        if ( buttonState & ShiftButton )
1460
                                                                view->moveGroup(10, 0);
1461
                                                        else if ( buttonState & ControlButton )
1462
                                                                view->moveGroup(0.1, 0);
1463
                                                        else
1464
                                                                view->moveGroup(1, 0);
1465
                                                }
2148 fschmid 1466
                                                slotDocCh();
272 Franz 1467
                                        }
1468
                                        break;
1469
                                case Key_Up:
1957 cbradney 1470
                                        if (!currItem->locked())
272 Franz 1471
                                        {
2664 fschmid 1472
                                                if ((doc->EditClip) && (view->ClRe != -1))
1473
                                                {
1474
                                                        FPoint np;
1475
                                                        if (view->EditContour)
1476
                                                                np = currItem->ContourLine.point(view->ClRe);
1477
                                                        else
1478
                                                                np = currItem->PoLine.point(view->ClRe);
1479
                                                        if ( buttonState & ShiftButton )
1480
                                                                np = np - FPoint(0, 10.0);
1481
                                                        else if ( buttonState & ControlButton )
1482
                                                                np = np - FPoint(0, 0.1);
1483
                                                        else
1484
                                                                np = np - FPoint(0, 1.0);
1485
                                                        view->MoveClipPoint(currItem, np);
1486
                                                }
272 Franz 1487
                                                else
2664 fschmid 1488
                                                {
1489
                                                        if ( buttonState & ShiftButton )
1490
                                                                view->moveGroup(0, -10);
1491
                                                        else if ( buttonState & ControlButton )
1492
                                                                view->moveGroup(0, -0.1);
1493
                                                        else
1494
                                                                view->moveGroup(0, -1);
1495
                                                }
2148 fschmid 1496
                                                slotDocCh();
272 Franz 1497
                                        }
1498
                                        break;
1499
                                case Key_Down:
1957 cbradney 1500
                                        if (!currItem->locked())
272 Franz 1501
                                        {
2664 fschmid 1502
                                                if ((doc->EditClip) && (view->ClRe != -1))
1503
                                                {
1504
                                                        FPoint np;
1505
                                                        if (view->EditContour)
1506
                                                                np = currItem->ContourLine.point(view->ClRe);
1507
                                                        else
1508
                                                                np = currItem->PoLine.point(view->ClRe);
1509
                                                        if ( buttonState & ShiftButton )
1510
                                                                np = np + FPoint(0, 10.0);
1511
                                                        else if ( buttonState & ControlButton )
1512
                                                                np = np + FPoint(0, 0.1);
1513
                                                        else
1514
                                                                np = np + FPoint(0, 1.0);
1515
                                                        view->MoveClipPoint(currItem, np);
1516
                                                }
272 Franz 1517
                                                else
2664 fschmid 1518
                                                {
1519
                                                        if ( buttonState & ShiftButton )
1520
                                                                view->moveGroup(0, 10);
1521
                                                        else if ( buttonState & ControlButton )
1522
                                                                view->moveGroup(0, 0.1);
1523
                                                        else
1524
                                                                view->moveGroup(0, 1);
1525
                                                }
2148 fschmid 1526
                                                slotDocCh();
272 Franz 1527
                                        }
1528
                                        break;
1529
                                default:
1530
                                        break;
1531
                                }
1532
                                break;
2603 cbradney 1533
                        case modeEdit:
1957 cbradney 1534
                                int oldPos = currItem->CPos; // 15-mar-2004 jjsa for cursor movement with Shift + Arrow key
1535
                                view->oldCp = currItem->CPos;
1536
                                if (currItem->itemType() == PageItem::ImageFrame)
1298 fschmid 1537
                                {
1538
                                        switch (kk)
1539
                                        {
1540
                                                case Key_Left:
1957 cbradney 1541
                                                        if (!currItem->locked())
1298 fschmid 1542
                                                        {
1543
                                                                if ( buttonState & ShiftButton )
1957 cbradney 1544
                                                                        view->MoveItemI(-10, 0, currItem->ItemNr, true);
1298 fschmid 1545
                                                                else if ( buttonState & ControlButton )
1957 cbradney 1546
                                                                        view->MoveItemI(-0.1, 0, currItem->ItemNr, true);
1298 fschmid 1547
                                                                else
1957 cbradney 1548
                                                                        view->MoveItemI(-1, 0, currItem->ItemNr, true);
1298 fschmid 1549
                                                        }
1550
                                                        break;
1551
                                                case Key_Right:
1957 cbradney 1552
                                                        if (!currItem->locked())
1298 fschmid 1553
                                                        {
1554
                                                                if ( buttonState & ShiftButton )
1957 cbradney 1555
                                                                        view->MoveItemI(10, 0, currItem->ItemNr, true);
1298 fschmid 1556
                                                                else if ( buttonState & ControlButton )
1957 cbradney 1557
                                                                        view->MoveItemI(0.1, 0, currItem->ItemNr, true);
1298 fschmid 1558
                                                                else
1957 cbradney 1559
                                                                        view->MoveItemI(1, 0, currItem->ItemNr, true);
1298 fschmid 1560
                                                        }
1561
                                                        break;
1562
                                                case Key_Up:
1957 cbradney 1563
                                                        if (!currItem->locked())
1298 fschmid 1564
                                                        {
1565
                                                                if ( buttonState & ShiftButton )
1957 cbradney 1566
                                                                        view->MoveItemI(0, -10, currItem->ItemNr, true);
1298 fschmid 1567
                                                                else if ( buttonState & ControlButton )
1957 cbradney 1568
                                                                        view->MoveItemI(0, -0.1, currItem->ItemNr, true);
1298 fschmid 1569
                                                                else
1957 cbradney 1570
                                                                        view->MoveItemI(0, -1, currItem->ItemNr, true);
1298 fschmid 1571
                                                        }
1572
                                                        break;
1573
                                                case Key_Down:
1957 cbradney 1574
                                                        if (!currItem->locked())
1298 fschmid 1575
                                                        {
1576
                                                                if ( buttonState & ShiftButton )
1957 cbradney 1577
                                                                        view->MoveItemI(0, 10, currItem->ItemNr, true);
1298 fschmid 1578
                                                                else if ( buttonState & ControlButton )
1957 cbradney 1579
                                                                        view->MoveItemI(0, 0.1, currItem->ItemNr, true);
1298 fschmid 1580
                                                                else
1957 cbradney 1581
                                                                        view->MoveItemI(0, 1, currItem->ItemNr, true);
1298 fschmid 1582
                                                        }
1583
                                                        break;
1584
                                        }
1585
                                }
1957 cbradney 1586
                                if (currItem->itemType() == PageItem::TextFrame)
272 Franz 1587
                                {
456 fschmid 1588
                                        view->slotDoCurs(false);
272 Franz 1589
                                        switch (kk)
1590
                                        {
1591
                                        case Key_Prior:
1592
                                        case Key_Next:
1593
                                        case Key_End:
1594
                                        case Key_Home:
1595
                                        case Key_Right:
1596
                                        case Key_Left:
1597
                                        case Key_Up:
1598
                                        case Key_Down:
1599
                                                if ( (buttonState & ShiftButton) == 0 )
1957 cbradney 1600
                                                        view->deselectAll(currItem);
272 Franz 1601
                                        }
1903 cbradney 1602
                                        /* ISO 14755
1603
                                        if ((buttonState & ControlButton) && (buttonState & ShiftButton))
1604
                                        {
3034 cbradney 1605
                                                if (!unicodeTextEditMode)
1903 cbradney 1606
                                                {
3034 cbradney 1607
                                                        unicodeTextEditMode=true;
1608
                                                        unicodeInputCount = 0;
1609
                                                        unicodeInputString = "";
1903 cbradney 1610
                                                        keyrep = false;
1611
                                                }
1612
                                                qDebug(QString("%1 %2 %3 %4 %5").arg("uni").arg("c+s").arg(uc).arg(kk).arg(as));
1613
                                        }
1614
                                        */
3034 cbradney 1615
                                        if (unicodeTextEditMode)
272 Franz 1616
                                        {
1617
                                                int conv = 0;
1618
                                                bool ok = false;
3034 cbradney 1619
                                                unicodeInputString += uc;
1620
                                                conv = unicodeInputString.toInt(&ok, 16);
272 Franz 1621
                                                if (!ok)
1622
                                                {
3034 cbradney 1623
                                                        unicodeTextEditMode = false;
1624
                                                        unicodeInputCount = 0;
1625
                                                        unicodeInputString = "";
272 Franz 1626
                                                        keyrep = false;
1627
                                                        return;
1628
                                                }
3034 cbradney 1629
                                                unicodeInputCount++;
1630
                                                if (unicodeInputCount == 4)
272 Franz 1631
                                                {
3034 cbradney 1632
                                                        unicodeTextEditMode = false;
1633
                                                        unicodeInputCount = 0;
1634
                                                        unicodeInputString = "";
272 Franz 1635
                                                        if (ok)
146 Franz 1636
                                                        {
1957 cbradney 1637
                                                                if (currItem->HasSel)
2150 cbradney 1638
                                                                        deleteSelectedTextFromFrame(currItem);
272 Franz 1639
                                                                if (conv < 31)
1640
                                                                        conv = 32;
1065 cbradney 1641
                                                                hg = new ScText;
272 Franz 1642
                                                                hg->ch = QString(QChar(conv));
1789 fschmid 1643
                                                                hg->cfont = (*doc->AllFonts)[doc->CurrFont];
272 Franz 1644
                                                                hg->csize = doc->CurrFontSize;
1645
                                                                hg->ccolor = doc->CurrTextFill;
1646
                                                                hg->cshade = doc->CurrTextFillSh;
1647
                                                                hg->cstroke = doc->CurrTextStroke;
1648
                                                                hg->cshade2 = doc->CurrTextStrokeSh;
1649
                                                                hg->cscale = doc->CurrTextScale;
2230 fschmid 1650
                                                                hg->cscalev = doc->CurrTextScaleV;
2234 fschmid 1651
                                                                hg->cbase = doc->CurrTextBase;
2247 fschmid 1652
                                                                hg->cshadowx = doc->CurrTextShadowX;
1653
                                                                hg->cshadowy = doc->CurrTextShadowY;
2257 fschmid 1654
                                                                hg->coutline = doc->CurrTextOutline;
2262 fschmid 1655
                                                                hg->cunderpos = doc->CurrTextUnderPos;
1656
                                                                hg->cunderwidth = doc->CurrTextUnderWidth;
2272 fschmid 1657
                                                                hg->cstrikepos = doc->CurrTextStrikePos;
1658
                                                                hg->cstrikewidth = doc->CurrTextStrikeWidth;
272 Franz 1659
                                                                hg->cselect = false;
1660
                                                                hg->cstyle = doc->CurrentStyle;
1065 cbradney 1661
                                                                hg->cab = doc->currentParaStyle;
2877 cbradney 1662
                                                                if (!doc->docParagraphStyles[doc->currentParaStyle].Font.isEmpty())
146 Franz 1663
                                                                {
1789 fschmid 1664
                                                                        hg->cfont = (*doc->AllFonts)[doc->docParagraphStyles[doc->currentParaStyle].Font];
1065 cbradney 1665
                                                                        hg->csize = doc->docParagraphStyles[doc->currentParaStyle].FontSize;
146 Franz 1666
                                                                }
272 Franz 1667
                                                                hg->cextra = 0;
1668
                                                                hg->xp = 0;
1669
                                                                hg->yp = 0;
1670
                                                                hg->PRot = 0;
1671
                                                                hg->PtransX = 0;
1672
                                                                hg->PtransY = 0;
2434 fschmid 1673
                                                                hg->cembedded = 0;
1957 cbradney 1674
                                                                currItem->itemText.insert(currItem->CPos, hg);
1675
                                                                currItem->CPos += 1;
1676
                                                                currItem->Tinput = true;
1677
                                                                setTBvals(currItem);
1678
                                                                view->RefreshItem(currItem);
272 Franz 1679
                                                                keyrep = false;
1680
                                                                return;
146 Franz 1681
                                                        }
1682
                                                }
272 Franz 1683
                                                else
1684
                                                {
1685
                                                        keyrep = false;
1686
                                                        return;
1687
                                                }
1688
                                        }
1689
                                        switch (kk)
1690
                                        {
1691
                                        case Key_F12:
3034 cbradney 1692
                                                unicodeTextEditMode = true;
1693
                                                unicodeInputCount = 0;
1694
                                                unicodeInputString = "";
272 Franz 1695
                                                keyrep = false;
1696
                                                return;
1697
                                                break;
291 Franz 1698
                                        case Key_Home:
272 Franz 1699
                                                // go to begin of line
1957 cbradney 1700
                                                if ( (pos = currItem->CPos) == 0 )
272 Franz 1701
                                                        break; // at begin of frame
1957 cbradney 1702
                                                len = static_cast<int>(currItem->itemText.count());
272 Franz 1703
                                                if ( pos == len )
1704
                                                        pos--;
1705
                                                if ( (buttonState & ControlButton) == 0 )
1706
                                                {
1957 cbradney 1707
                                                        alty =  currItem->itemText.at(pos)->yp;
1708
                                                        c = currItem->itemText.at(pos)->ch.at(0).latin1();
272 Franz 1709
                                                        if ( c == 13 ) // new line, position is wrong
1710
                                                                if ( --pos > 0 )
1957 cbradney 1711
                                                                        alty =  currItem->itemText.at(pos)->yp;
272 Franz 1712
                                                        // check for yp at actual position
1713
                                                        if ( pos < len )
1714
                                                        {
1957 cbradney 1715
                                                                altx =  currItem->itemText.at(pos)->yp;
272 Franz 1716
                                                                if ( altx > alty )
3 paul 1717
                                                                {
272 Franz 1718
                                                                        // we was at begin of line
1719
                                                                        break;
3 paul 1720
                                                                }
272 Franz 1721
                                                        }
1957 cbradney 1722
                                                        while (  pos > 0 && currItem->itemText.at(pos-1)->yp == alty )
3034 cbradney 1723
                                                                --pos;
1957 cbradney 1724
                                                        if ( currItem->itemText.at(pos)->ch.at(0).latin1() == 13 )
3034 cbradney 1725
                                                                ++pos;
272 Franz 1726
                                                }
1727
                                                else
1728
                                                {
1729
                                                        // paragraph begin
1730
                                                        if ( pos < len &&
1957 cbradney 1731
                                                                currItem->itemText.at(pos)->ch.at(0).latin1() == 13 )
3034 cbradney 1732
                                                                --pos;
272 Franz 1733
                                                        while(pos > 0 )
1957 cbradney 1734
                                                                if ( currItem->itemText.at(pos)->ch.at(0).latin1() == 13 )
3 paul 1735
                                                                {
3034 cbradney 1736
                                                                        ++pos;
272 Franz 1737
                                                                        break;
3 paul 1738
                                                                }
272 Franz 1739
                                                                else
3034 cbradney 1740
                                                                        --pos;
272 Franz 1741
                                                }
1957 cbradney 1742
                                                currItem->CPos = pos;
272 Franz 1743
                                                if ( buttonState & ShiftButton )
1957 cbradney 1744
                                                        view->ExpandSel(currItem, -1, oldPos);
272 Franz 1745
                                                break;
291 Franz 1746
                                        case Key_End:
272 Franz 1747
                                                // go to end of line
1957 cbradney 1748
                                                len = static_cast<int>(currItem->itemText.count());
1749
                                                if ( currItem->CPos >= len )
272 Franz 1750
                                                        break; // at end of frame
1751
                                                if ( (buttonState & ControlButton) == 0 )
1752
                                                {
1957 cbradney 1753
                                                        if ((currItem->CPos < len) && ((currItem->itemText.at(currItem->CPos)->ch.at(0).latin1() == 13) || (currItem->itemText.at(currItem->CPos)->ch.at(0).latin1() == 28)))
239 Franz 1754
                                                        {
272 Franz 1755
                                                                // at end of paragraph and therefore line
1756
                                                                break;
239 Franz 1757
                                                        }
1957 cbradney 1758
                                                        QString nextCh = currItem->itemText.at(currItem->CPos)->ch;
1759
                                                        int nextChs = currItem->itemText.at(currItem->CPos)->csize;
1760
                                                        alty =  currItem->itemText.at(currItem->CPos)->yp - currItem->SetZeichAttr(currItem->itemText.at(currItem->CPos), &nextChs, &nextCh);
1827 fschmid 1761
                                                        double nextY;
1957 cbradney 1762
                                                        while (currItem->CPos < len-1)
1827 fschmid 1763
                                                        {
1957 cbradney 1764
                                                                nextCh = currItem->itemText.at(currItem->CPos+1)->ch;
1765
                                                                nextChs = currItem->itemText.at(currItem->CPos+1)->csize;
1766
                                                                nextY = currItem->itemText.at(currItem->CPos+1)->yp - currItem->SetZeichAttr(currItem->itemText.at(currItem->CPos+1), &nextChs, &nextCh);
1827 fschmid 1767
                                                                if (fabs(nextY - alty) > 1.0)
1768
                                                                        break;
1957 cbradney 1769
                                                                currItem->CPos++;
1770
                                                                if ( currItem->CPos == len-1)
1827 fschmid 1771
                                                                        break;
1772
                                                        }
1957 cbradney 1773
                                                        if ( currItem->CPos < len -1 )
1774
                                                                c = currItem->itemText.at(currItem->CPos+1)->ch.at(0).latin1();
1775
                                                        else if ( currItem->CPos == len - 1 )
272 Franz 1776
                                                                c = 13;
1777
                                                        else
1778
                                                                c = 0;
1109 fschmid 1779
                                                        if (( c == 13 ) || (c = 28))
1957 cbradney 1780
                                                                currItem->CPos++;
272 Franz 1781
                                                }
1782
                                                else
1783
                                                {
1784
                                                        // go to end of paragraph
1957 cbradney 1785
                                                        if ( currItem->itemText.at(currItem->CPos)->ch.at(0).latin1() == 13 )
239 Franz 1786
                                                        {
272 Franz 1787
                                                                break;
239 Franz 1788
                                                        }
1957 cbradney 1789
                                                        pos = currItem->CPos;
272 Franz 1790
                                                        while ( pos < len )
239 Franz 1791
                                                        {
1957 cbradney 1792
                                                                if ( currItem->itemText.at(pos)->ch.at(0).latin1() == 13 )
272 Franz 1793
                                                                        break;
239 Franz 1794
                                                                else
3034 cbradney 1795
                                                                        ++pos;
239 Franz 1796
                                                        }
1957 cbradney 1797
                                                        currItem->CPos