Subversion Repositories Scribus

Rev

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