Subversion Repositories Scribus

Rev

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