Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
3 paul 7
/***************************************************************************
8
                          scribusdoc.cpp  -  description
9
                             -------------------
10
    begin                : Fre Apr  6 21:47:55 CEST 2001
11
    copyright            : (C) 2001 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
10455 cbradney 23
 
15193 jghali 24
#include <memory>
3670 cbradney 25
#include <utility>
15239 jghali 26
#include <sstream>
7736 cbradney 27
 
10749 cbradney 28
#include <QByteArray>
16856 craig 29
#include <QDebug>
30
#include <QDialog>
10749 cbradney 31
#include <QEventLoop>
10220 cbradney 32
#include <QFile>
10749 cbradney 33
#include <QList>
17944 jghali 34
#include <QMessageBox>
10220 cbradney 35
#include <QPainter>
10749 cbradney 36
#include <QPixmap>
16856 craig 37
#include <QPointer>
9953 cbradney 38
#include <QProgressBar>
17944 jghali 39
#include <QtAlgorithms>
40
#include <QTime>
18194 fschmid 41
//#include <qtconcurrentmap.h>
10011 fschmid 42
 
19495 craig 43
#include "actionmanager.h"
19067 craig 44
#include "appmodes.h"
10749 cbradney 45
#include "canvas.h"
17640 craig 46
#include "ui/masterpagepalette.h"
14150 fschmid 47
#include "colorblind.h"
10212 cbradney 48
#include "commonstrings.h"
15239 jghali 49
#include "desaxe/digester.h"
5642 cbradney 50
#include "fileloader.h"
3757 cbradney 51
#include "filewatcher.h"
16856 craig 52
#include "fpoint.h"
13544 cbradney 53
#include "ui/guidemanager.h"
17640 craig 54
#include "ui/outlinepalette.h"
3757 cbradney 55
#include "hyphenator.h"
16856 craig 56
#include "ui/inserttablecolumnsdialog.h"
57
#include "ui/inserttablerowsdialog.h"
17826 craig 58
#include "notesstyles.h"
18047 craig 59
#include "numeration.h"
17826 craig 60
#include "ui/notesstyleseditor.h"
456 fschmid 61
#include "pageitem.h"
3617 cbradney 62
#include "pageitem_imageframe.h"
10749 cbradney 63
#include "pageitem_latexframe.h"
3617 cbradney 64
#include "pageitem_line.h"
17863 jghali 65
#include "pageitem_noteframe.h"
3617 cbradney 66
#include "pageitem_pathtext.h"
67
#include "pageitem_polygon.h"
68
#include "pageitem_polyline.h"
16856 craig 69
#include "pageitem_table.h"
3617 cbradney 70
#include "pageitem_textframe.h"
13845 jghali 71
#ifdef HAVE_OSG
72
        #include "pageitem_osgframe.h"
73
#endif
19093 craig 74
#include "colormgmt/sccolormgmtenginefactory.h"
75
#include "pageitem_arc.h"
16105 fschmid 76
#include "pageitem_group.h"
16191 fschmid 77
#include "pageitem_regularpolygon.h"
16311 fschmid 78
#include "pageitem_spiral.h"
19093 craig 79
#include "pageitem_symbol.h"
10749 cbradney 80
#include "pagesize.h"
3757 cbradney 81
#include "pagestructs.h"
6124 cbradney 82
#include "prefsfile.h"
3757 cbradney 83
#include "prefsmanager.h"
8455 avox 84
#include "resourcecollection.h"
14744 fschmid 85
#include "scclocale.h"
19093 craig 86
#include "sccolorengine.h"
15023 jghali 87
#include "sclimits.h"
16729 fschmid 88
#include "scpage.h"
16736 jghali 89
#include "scpainter.h"
4688 cbradney 90
#include "scraction.h"
5642 cbradney 91
#include "scribusXml.h"
10749 cbradney 92
#include "scribuscore.h"
93
#include "scribusdoc.h"
94
#include "scribusview.h"
95
#include "scribuswin.h"
3903 cbradney 96
#include "selection.h"
12407 pierre 97
#include "serializer.h"
16856 craig 98
#include "tableborder.h"
19093 craig 99
#include "ui/hruler.h"
100
#include "ui/layers.h"
101
#include "ui/mark2item.h"
102
#include "ui/mark2mark.h"
103
#include "ui/markanchor.h"
104
#include "ui/markinsert.h"
105
#include "ui/marksmanager.h"
106
#include "ui/markvariabletext.h"
107
#include "ui/pagepalette.h"
108
#include "ui/storyeditor.h"
16856 craig 109
#include "ui/tablecolumnwidthsdialog.h"
110
#include "ui/tablerowheightsdialog.h"
1179 tsoots 111
#include "undomanager.h"
2965 cbradney 112
#include "units.h"
3809 cbradney 113
#include "util.h"
10212 cbradney 114
#include "util_icon.h"
10203 cbradney 115
#include "util_math.h"
410 Franz 116
 
3205 craig 117
 
10684 fschmid 118
// static const bool FRAMESELECTION_EDITS_DEFAULTSTYLE = false;
9607 avox 119
 
10532 avox 120
 
121
 
122
/**
123
 This class forwards change events for pages and pageitems to
124
 the region occupied by this page or pageitem.
125
 */
16729 fschmid 126
class DocUpdater : public Observer<ScPage*>, public Observer<PageItem*>
10532 avox 127
{
128
        ScribusDoc* doc;
14283 jghali 129
        int  m_updateEnabled;
130
        bool m_docChangeNeeded;
10532 avox 131
public:
14283 jghali 132
        DocUpdater(ScribusDoc* d) : doc(d), m_updateEnabled(0), m_docChangeNeeded(false) {}
133
 
14370 jghali 134
        bool inUpdateSession() const
135
        {
136
                return m_updateEnabled > 0;
137
        }
138
 
14283 jghali 139
        void beginUpdate(void)
140
        {
141
                if (m_updateEnabled == 0)
142
                        m_docChangeNeeded = false;
143
                ++m_updateEnabled;
144
        }
145
 
146
        void endUpdate(void)
147
        {
148
                --m_updateEnabled;
149
                if (m_updateEnabled <= 0)
150
                {
151
                        if (m_docChangeNeeded)
152
                        {
153
                                doc->changed();
154
                                m_docChangeNeeded = false;
155
                        }
156
                }
157
        }
10532 avox 158
 
16729 fschmid 159
        void changed(ScPage* pg, bool /*doLayout*/)
10532 avox 160
        {
11046 avox 161
                QRectF pagebox(pg->xOffset(), pg->yOffset(), pg->width(), pg->height());
162
                doc->invalidateRegion(pagebox);
163
                doc->regionsChanged()->update(pagebox);
14283 jghali 164
                if (m_updateEnabled <= 0)
165
                {
166
                        doc->changed();
167
                        return;
168
                }
169
                m_docChangeNeeded = true;
10532 avox 170
        }
171
 
16639 jghali 172
        void changed(PageItem* it, bool doLayout)
10532 avox 173
        {
11046 avox 174
                it->invalidateLayout();
16639 jghali 175
                if (doLayout)
176
                        it->layout();
17124 fschmid 177
                double x, y, w, h;
178
                QTransform t = it->getCombinedTransform();
179
                w = it->visualWidth();
180
                h = it->visualHeight();
181
                x = -it->visualLineWidth() / 2.0;
182
                y = -it->visualLineWidth() / 2.0;
183
                QRectF upRect = t.mapRect(QRectF(x, y, w, h));
184
                doc->regionsChanged()->update(upRect);
14283 jghali 185
                if (m_updateEnabled <= 0)
186
                {
187
                        doc->changed();
188
                        return;
189
                }
190
                m_docChangeNeeded = true;
10532 avox 191
        }
19286 jghali 192
 
193
        void setDocChangeNeeded(bool changeNeeded = true)
194
        {
195
                m_docChangeNeeded = changeNeeded;
196
        }
10532 avox 197
};
198
 
199
 
200
 
201
 
202
ScribusDoc::ScribusDoc() : UndoObject( tr("Document")), Observable<ScribusDoc>(NULL),
5892 jghali 203
        m_hasGUI(false),
18719 craig 204
        docFilePermissions(QFileDevice::ReadOwner|QFileDevice::WriteOwner),
14871 cbradney 205
        appPrefsData(PrefsManager::instance()->appPrefs),
206
        docPrefsData(PrefsManager::instance()->appPrefs),
3983 craig 207
        undoManager(UndoManager::instance()),
208
        loading(false),
209
        modified(false),
210
        ActiveLayer(0),
13839 fschmid 211
        rotMode(0),
3983 craig 212
        automaticTextFrames(0),
213
        m_masterPageMode(false),
16029 fschmid 214
        m_symbolEditMode(false),
17418 fschmid 215
        m_inlineEditMode(false),
5781 cbradney 216
        m_ScMW(0),
5798 jghali 217
        m_View(0),
7906 jghali 218
        m_guardedObject(this),
13659 cbradney 219
        m_serializer(NULL),
17743 jghali 220
        m_tserializer(NULL),
3983 craig 221
        is12doc(false),
222
        NrItems(0),
223
        First(1), Last(0),
224
        viewCount(0), viewID(0),
18027 jghali 225
        SnapGrid(false),
18029 jghali 226
        SnapGuides(true),
17744 craig 227
        SnapElement(false), GuideLock(false),
3983 craig 228
        minCanvasCoordinate(FPoint(0, 0)),
229
        rulerXoffset(0.0), rulerYoffset(0.0),
3984 craig 230
        Pages(0), MasterPages(), DocPages(),
3983 craig 231
        MasterNames(),
5885 jghali 232
        Items(0), MasterItems(), DocItems(), FrameItems(),
4847 cbradney 233
        m_Selection(new Selection(this, true)),
3983 craig 234
        PageSp(1), PageSpa(0),
235
        FirstPnum(1),
5892 jghali 236
        PageColors(this, true),
3983 craig 237
        appMode(modeNormal),
238
        SubMode(-1),
239
        ShapeValues(0),
240
        ValCount(0),
6260 fschmid 241
        DocName( tr("Document")+"-"),
3983 craig 242
        UsedFonts(),
14871 cbradney 243
        AllFonts(&appPrefsData.fontPrefs.AvailFonts),
3983 craig 244
        AObjects(),
245
        CurrentSel(-1),
10532 avox 246
        nodeEdit(),
3983 craig 247
        LastAuto(0), FirstAuto(0),
248
        DraggedElem(0),
249
        ElemToLink(0),
250
        DragElements(),
251
        docParagraphStyles(),
5980 avox 252
        docCharStyles(),
16856 craig 253
        docTableStyles(),
254
        docCellStyles(),
3983 craig 255
        Layers(),
256
        GroupCounter(1),
14170 jghali 257
        colorEngine(ScCore->defaultEngine),
3983 craig 258
        JavaScripts(),
259
        TotalItems(0),
260
        RePos(false),
261
        BookMarks(),
262
        OldBM(false),
263
        hasName(false),
17926 fschmid 264
        isConverted(false),
3983 craig 265
        autoSaveTimer(new QTimer(this)),
266
        MLineStyles(),
267
        WinHan(0),
268
        DoDrawing(true),
269
        OpenNodes(),
270
        CurTimer(0),
18485 craig 271
        pageErrors(),
5696 avox 272
        docLayerErrors(),
3983 craig 273
        docItemErrors(),
274
        masterItemErrors(),
275
        symReturn(), symNewLine(), symTab(), symNonBreak(), symNewCol(), symNewFrame(),
5781 cbradney 276
        docHyphenator(0),
11576 avox 277
        m_itemCreationTransaction(NULL),
11625 jghali 278
        m_alignTransaction(NULL),
279
        m_currentPage(NULL),
280
        m_updateManager(),
17826 craig 281
        m_docUpdater(NULL),
282
        flag_notesChanged(false),
283
        flag_restartMarksRenumbering(false),
284
        flag_updateMarksLabels(false),
285
        flag_updateEndNotes(false),
18047 craig 286
        flag_layoutNotesFrames(true),
287
        flag_Renumber(false),
288
        flag_NumUpdateRequest(false)
3 paul 289
{
14924 cbradney 290
        docUnitRatio=unitGetRatioFromIndex(docPrefsData.docSetupPrefs.docUnitIndex);
14991 cbradney 291
        docPrefsData.docSetupPrefs.pageHeight=0;
292
        docPrefsData.docSetupPrefs.pageWidth=0;
15407 craig 293
        docPrefsData.docSetupPrefs.pagePositioning=0;
14924 cbradney 294
        maxCanvasCoordinate=(FPoint(docPrefsData.displayPrefs.scratch.Left + docPrefsData.displayPrefs.scratch.Right, docPrefsData.displayPrefs.scratch.Top + docPrefsData.displayPrefs.scratch.Bottom)),
5789 cbradney 295
        init();
14992 cbradney 296
        docPrefsData.pdfPrefs.bleeds = docPrefsData.docSetupPrefs.bleeds;
14925 cbradney 297
        docPrefsData.pdfPrefs.useDocBleeds = true;
7104 fschmid 298
        Print_Options.firstUse = true;
16177 fschmid 299
        drawAsPreview = false;
16241 fschmid 300
        viewAsPreview = false;
17915 fschmid 301
        editOnPreview = false;
19009 craig 302
        previewVisual = 0;
17245 fschmid 303
        dontResize = false;
18047 craig 304
        //create default numeration
305
        NumStruct * numS = new NumStruct;
306
        numS->m_name = "default";
307
        Numeration newNum;
308
        numS->m_nums.insert(0, newNum);
309
        numS->m_counters.insert(0, 0);
310
        numS->m_lastlevel = -1;
311
        numerations.insert("default", numS);
312
 
18041 fschmid 313
        currentEditedTextframe = NULL;
5789 cbradney 314
}
315
 
10532 avox 316
 
5789 cbradney 317
ScribusDoc::ScribusDoc(const QString& docName, int unitindex, const PageSize& pagesize, const MarginStruct& margins, const DocPagesSetup& pagesSetup) : UndoObject( tr("Document")),
5892 jghali 318
        m_hasGUI(false),
18719 craig 319
        docFilePermissions(QFileDevice::ReadOwner|QFileDevice::WriteOwner),
14871 cbradney 320
        appPrefsData(PrefsManager::instance()->appPrefs),
321
        docPrefsData(PrefsManager::instance()->appPrefs),
5789 cbradney 322
        undoManager(UndoManager::instance()),
323
        loading(false),
324
        modified(false),
325
        ActiveLayer(0),
14924 cbradney 326
        docUnitRatio(unitGetRatioFromIndex(appPrefsData.docSetupPrefs.docUnitIndex)),
13839 fschmid 327
        rotMode(0),
5789 cbradney 328
        automaticTextFrames(pagesSetup.autoTextFrames),
329
        m_masterPageMode(false),
16029 fschmid 330
        m_symbolEditMode(false),
17418 fschmid 331
        m_inlineEditMode(false),
5789 cbradney 332
        m_ScMW(0),
333
        m_View(0),
7906 jghali 334
        m_guardedObject(this),
13659 cbradney 335
        m_serializer(NULL),
17743 jghali 336
        m_tserializer(NULL),
5789 cbradney 337
        is12doc(false),
338
        NrItems(0),
339
        First(1), Last(0),
340
        viewCount(0), viewID(0),
18027 jghali 341
        SnapGrid(false),
18029 jghali 342
        SnapGuides(true),
17744 craig 343
        SnapElement(false),
17789 fschmid 344
        GuideLock(false),
5789 cbradney 345
        minCanvasCoordinate(FPoint(0, 0)),
346
        rulerXoffset(0.0), rulerYoffset(0.0),
347
        Pages(0), MasterPages(), DocPages(),
348
        MasterNames(),
349
        Items(0), MasterItems(), DocItems(), FrameItems(),
350
        m_Selection(new Selection(this, true)),
351
        PageSp(pagesSetup.columnCount), PageSpa(pagesSetup.columnDistance),
352
        FirstPnum(pagesSetup.firstPageNumber),
5892 jghali 353
        PageColors(this, true),
5789 cbradney 354
        appMode(modeNormal),
355
        SubMode(-1),
356
        ShapeValues(0),
357
        ValCount(0),
358
        DocName(docName),
359
        UsedFonts(),
14871 cbradney 360
        AllFonts(&appPrefsData.fontPrefs.AvailFonts),
5789 cbradney 361
        AObjects(),
362
        CurrentSel(-1),
10532 avox 363
        nodeEdit(),
5789 cbradney 364
        LastAuto(0), FirstAuto(0),
365
        DraggedElem(0),
366
        ElemToLink(0),
367
        DragElements(),
368
        docParagraphStyles(),
5980 avox 369
        docCharStyles(),
16856 craig 370
        docTableStyles(),
371
        docCellStyles(),
5789 cbradney 372
        Layers(),
373
        GroupCounter(1),
14170 jghali 374
        colorEngine(ScCore->defaultEngine),
5789 cbradney 375
        JavaScripts(),
376
        TotalItems(0),
377
        RePos(false),
378
        BookMarks(),
379
        OldBM(false),
380
        hasName(false),
17926 fschmid 381
        isConverted(false),
5789 cbradney 382
        autoSaveTimer(new QTimer(this)),
383
        MLineStyles(),
384
        WinHan(0),
385
        DoDrawing(true),
386
        OpenNodes(),
387
        CurTimer(0),
18485 craig 388
        pageErrors(),
5789 cbradney 389
        docLayerErrors(),
390
        docItemErrors(),
391
        masterItemErrors(),
392
        symReturn(), symNewLine(), symTab(), symNonBreak(), symNewCol(), symNewFrame(),
393
        docHyphenator(0),
11576 avox 394
        m_itemCreationTransaction(NULL),
11625 jghali 395
        m_alignTransaction(NULL),
396
        m_currentPage(NULL),
397
        m_updateManager(),
17826 craig 398
        m_docUpdater(NULL),
399
        flag_notesChanged(false),
400
        flag_restartMarksRenumbering(false),
401
        flag_updateMarksLabels(false),
402
        flag_updateEndNotes(false),
18047 craig 403
        flag_layoutNotesFrames(true),
404
        flag_Renumber(false),
405
        flag_NumUpdateRequest(false)
5789 cbradney 406
{
14924 cbradney 407
        docPrefsData.docSetupPrefs.docUnitIndex=unitindex;
14991 cbradney 408
        docPrefsData.docSetupPrefs.pageHeight=pagesize.height();
409
        docPrefsData.docSetupPrefs.pageWidth=pagesize.width();
410
        docPrefsData.docSetupPrefs.pageSize=pagesize.name();
14994 cbradney 411
        docPrefsData.docSetupPrefs.margins=margins;
14924 cbradney 412
        maxCanvasCoordinate=(FPoint(docPrefsData.displayPrefs.scratch.Left + docPrefsData.displayPrefs.scratch.Right, docPrefsData.displayPrefs.scratch.Top + docPrefsData.displayPrefs.scratch.Bottom)),
413
        setPageSetFirstPage(pagesSetup.pageArrangement, pagesSetup.firstPageLocation);
5789 cbradney 414
        init();
14992 cbradney 415
        docPrefsData.pdfPrefs.bleeds = docPrefsData.docSetupPrefs.bleeds;
14925 cbradney 416
        docPrefsData.pdfPrefs.useDocBleeds = true;
14991 cbradney 417
        docPrefsData.docSetupPrefs.pageOrientation=pagesSetup.orientation;
15407 craig 418
        docPrefsData.docSetupPrefs.pagePositioning=pagesSetup.pageArrangement;
7104 fschmid 419
        Print_Options.firstUse = true;
16177 fschmid 420
        drawAsPreview = false;
16241 fschmid 421
        viewAsPreview = false;
17915 fschmid 422
        editOnPreview = false;
19009 craig 423
        previewVisual = 0;
17245 fschmid 424
        dontResize = false;
18041 fschmid 425
        currentEditedTextframe = NULL;
5789 cbradney 426
}
427
 
10532 avox 428
 
5789 cbradney 429
void ScribusDoc::init()
430
{
4847 cbradney 431
        Q_CHECK_PTR(m_Selection);
3983 craig 432
        Q_CHECK_PTR(autoSaveTimer);
433
 
5880 jghali 434
        HasCMS = false;
15001 cbradney 435
        docPrefsData.colorPrefs.DCMSset.CMSinUse = false;
6464 jghali 436
 
14170 jghali 437
        colorEngine = ScCore->defaultEngine;
10338 jghali 438
        SetDefaultCMSParams();
5880 jghali 439
 
10532 avox 440
        // init update change management
441
        setUpdateManager(&m_updateManager);
442
        m_itemsChanged.setUpdateManager(&m_updateManager);
443
        m_pagesChanged.setUpdateManager(&m_updateManager);
444
        m_regionsChanged.setUpdateManager(&m_updateManager);
445
        nodeEdit.setUpdateManager(&m_updateManager);
446
 
447
        // setup update() event chains
448
        m_docUpdater = new DocUpdater(this);
449
        m_itemsChanged.connectObserver(m_docUpdater);
450
        m_pagesChanged.connectObserver(m_docUpdater);
451
 
6464 jghali 452
        PrefsManager *prefsManager = PrefsManager::instance();
15001 cbradney 453
        docPrefsData.colorPrefs.DCMSset = prefsManager->appPrefs.colorPrefs.DCMSset;
454
        docPrefsData.pdfPrefs.SolidProf = docPrefsData.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
455
        docPrefsData.pdfPrefs.ImageProf = docPrefsData.colorPrefs.DCMSset.DefaultImageRGBProfile;
456
        docPrefsData.pdfPrefs.PrintProf = docPrefsData.colorPrefs.DCMSset.DefaultPrinterProfile;
18190 jghali 457
        docPrefsData.pdfPrefs.Intent  = docPrefsData.colorPrefs.DCMSset.DefaultIntentColors;
15001 cbradney 458
        docPrefsData.pdfPrefs.Intent2 = docPrefsData.colorPrefs.DCMSset.DefaultIntentImages;
6464 jghali 459
 
14871 cbradney 460
        AddFont(appPrefsData.itemToolPrefs.textFont);//, prefsData.AvailFonts[prefsData.itemToolPrefs.textFont]->Font);
14932 cbradney 461
        //FIXME: aren't we doing this now anyway with prefs struct copy?
462
        docPrefsData.itemToolPrefs.textFont = appPrefsData.itemToolPrefs.textFont;
463
        docPrefsData.itemToolPrefs.textSize = appPrefsData.itemToolPrefs.textSize;
464
        docPrefsData.itemToolPrefs.textTabFillChar = appPrefsData.itemToolPrefs.textTabFillChar;
465
        docPrefsData.opToolPrefs.dispX = appPrefsData.opToolPrefs.dispX;
466
        docPrefsData.opToolPrefs.dispY = appPrefsData.opToolPrefs.dispY;
467
        docPrefsData.opToolPrefs.constrain = appPrefsData.opToolPrefs.constrain;
5880 jghali 468
 
15912 jghali 469
        PageColors.ensureDefaultColors();
14871 cbradney 470
        if (appPrefsData.itemToolPrefs.shapeLineColor != CommonStrings::None)
471
                PageColors.insert(appPrefsData.itemToolPrefs.shapeLineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.shapeLineColor]);
14932 cbradney 472
        docPrefsData.itemToolPrefs.shapeLineColor = appPrefsData.itemToolPrefs.shapeLineColor;
14871 cbradney 473
        if (appPrefsData.itemToolPrefs.lineColor != CommonStrings::None)
474
                PageColors.insert(appPrefsData.itemToolPrefs.lineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.lineColor]);
14932 cbradney 475
        docPrefsData.itemToolPrefs.lineColor = appPrefsData.itemToolPrefs.lineColor;
14871 cbradney 476
        if (appPrefsData.itemToolPrefs.textColor != CommonStrings::None)
477
                PageColors.insert(appPrefsData.itemToolPrefs.textColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textColor]);
14932 cbradney 478
        docPrefsData.itemToolPrefs.textColor = appPrefsData.itemToolPrefs.textColor;
14871 cbradney 479
        if (appPrefsData.itemToolPrefs.textStrokeColor != CommonStrings::None)
480
                PageColors.insert(appPrefsData.itemToolPrefs.textStrokeColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textStrokeColor]);
14932 cbradney 481
        docPrefsData.itemToolPrefs.textStrokeColor = appPrefsData.itemToolPrefs.textStrokeColor;
14871 cbradney 482
        if (appPrefsData.itemToolPrefs.shapeFillColor != CommonStrings::None)
483
                PageColors.insert(appPrefsData.itemToolPrefs.shapeFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.shapeFillColor]);
14932 cbradney 484
        docPrefsData.itemToolPrefs.shapeFillColor = appPrefsData.itemToolPrefs.shapeFillColor;
14871 cbradney 485
        if (appPrefsData.itemToolPrefs.imageFillColor != CommonStrings::None)
486
                PageColors.insert(appPrefsData.itemToolPrefs.imageFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.imageFillColor]);
14932 cbradney 487
        docPrefsData.itemToolPrefs.imageFillColor = appPrefsData.itemToolPrefs.imageFillColor;
17054 fschmid 488
        if (appPrefsData.itemToolPrefs.imageStrokeColor != CommonStrings::None)
489
                PageColors.insert(appPrefsData.itemToolPrefs.imageStrokeColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.imageStrokeColor]);
490
        docPrefsData.itemToolPrefs.imageStrokeColor = appPrefsData.itemToolPrefs.imageStrokeColor;
14871 cbradney 491
        if (appPrefsData.itemToolPrefs.textFillColor != CommonStrings::None)
492
                PageColors.insert(appPrefsData.itemToolPrefs.textFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textFillColor]);
14932 cbradney 493
        docPrefsData.itemToolPrefs.textFillColor = appPrefsData.itemToolPrefs.textFillColor;
14871 cbradney 494
        if (appPrefsData.itemToolPrefs.textLineColor != CommonStrings::None)
495
                PageColors.insert(appPrefsData.itemToolPrefs.textLineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textLineColor]);
19378 craig 496
        if (appPrefsData.itemToolPrefs.calligraphicPenFillColor != CommonStrings::None)
497
                PageColors.insert(appPrefsData.itemToolPrefs.calligraphicPenFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.calligraphicPenFillColor]);
498
        if (appPrefsData.itemToolPrefs.calligraphicPenLineColor != CommonStrings::None)
499
                PageColors.insert(appPrefsData.itemToolPrefs.calligraphicPenLineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.calligraphicPenLineColor]);
6733 avox 500
 
501
 
7059 avox 502
        ParagraphStyle pstyle;
12283 cbradney 503
        pstyle.setDefaultStyle(true);
504
        pstyle.setName(CommonStrings::DefaultParagraphStyle);
7059 avox 505
        pstyle.setLineSpacingMode(ParagraphStyle::FixedLineSpacing);
506
        pstyle.setLineSpacing(15);
507
        pstyle.setAlignment(ParagraphStyle::Leftaligned);
508
        pstyle.setLeftMargin(0);
509
        pstyle.setFirstIndent(0);
510
        pstyle.setRightMargin(0);
511
        pstyle.setGapBefore(0);
512
        pstyle.setGapAfter(0);
513
        pstyle.setHasDropCap(false);
18047 craig 514
        pstyle.setHasBullet(false);
515
        pstyle.setHasNum(false);
7059 avox 516
        pstyle.setDropCapLines(2);
18047 craig 517
        pstyle.setParEffectOffset(0);
7095 avox 518
        pstyle.charStyle().setParent("");
6733 avox 519
 
7059 avox 520
        CharStyle cstyle;
12283 cbradney 521
        cstyle.setDefaultStyle(true);
522
        cstyle.setName(CommonStrings::DefaultCharacterStyle);
14932 cbradney 523
        cstyle.setFont(appPrefsData.fontPrefs.AvailFonts[docPrefsData.itemToolPrefs.textFont]);
524
        cstyle.setFontSize(docPrefsData.itemToolPrefs.textSize);
9607 avox 525
        cstyle.setFeatures(QStringList(CharStyle::INHERIT));
14932 cbradney 526
        cstyle.setFillColor(docPrefsData.itemToolPrefs.textColor);
527
        cstyle.setFillShade(docPrefsData.itemToolPrefs.textShade);
528
        cstyle.setStrokeColor(docPrefsData.itemToolPrefs.textStrokeColor);
529
        cstyle.setStrokeShade(docPrefsData.itemToolPrefs.textStrokeShade);
6733 avox 530
        cstyle.setBaselineOffset(0);
531
        cstyle.setShadowXOffset(50);
532
        cstyle.setShadowYOffset(-50);
533
        cstyle.setOutlineWidth(10);
14932 cbradney 534
        cstyle.setUnderlineOffset(docPrefsData.typoPrefs.valueUnderlinePos);
535
        cstyle.setUnderlineWidth(docPrefsData.typoPrefs.valueUnderlineWidth);
536
        cstyle.setStrikethruOffset(docPrefsData.typoPrefs.valueStrikeThruPos);
537
        cstyle.setStrikethruWidth(docPrefsData.typoPrefs.valueStrikeThruPos);
6733 avox 538
        cstyle.setScaleH(1000);
539
        cstyle.setScaleV(1000);
540
        cstyle.setTracking(0);
13955 cbradney 541
        cstyle.setLanguage(PrefsManager::instance()->appPrefs.hyphPrefs.Language);
6733 avox 542
 
7059 avox 543
        docParagraphStyles.create(pstyle);
7018 avox 544
        docParagraphStyles.makeDefault( &(docParagraphStyles[0]) );
8058 avox 545
 
7059 avox 546
        docCharStyles.create(cstyle);
547
        docCharStyles.makeDefault( &(docCharStyles[0]) );
8058 avox 548
 
549
        docParagraphStyles[0].breakImplicitCharStyleInheritance();
8134 avox 550
        docParagraphStyles[0].charStyle().setContext( & docCharStyles );
8191 avox 551
//      docParagraphStyles[0].charStyle().setName( "cdocdefault" ); // DONT TRANSLATE
7059 avox 552
 
553
        currentStyle = pstyle;
16856 craig 554
 
555
        // Create default table style.
556
        // TODO: We should have preferences for the default values.
557
        TableStyle defaultTableStyle;
17318 fschmid 558
        defaultTableStyle.setDefaultStyle(true);
16856 craig 559
        defaultTableStyle.setName(CommonStrings::DefaultTableStyle);
560
        defaultTableStyle.setFillColor(CommonStrings::None);
17311 fschmid 561
        defaultTableStyle.setFillShade(100);
562
        defaultTableStyle.setLeftBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
563
        defaultTableStyle.setRightBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
564
        defaultTableStyle.setTopBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
565
        defaultTableStyle.setBottomBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
16856 craig 566
        docTableStyles.create(defaultTableStyle);
567
        docTableStyles.makeDefault(&(docTableStyles[0]));
568
 
569
        // Create default table cell style.
570
        // TODO: We should have preferences for the default values.
571
        CellStyle defaultCellStyle;
17318 fschmid 572
        defaultCellStyle.setDefaultStyle(true);
16856 craig 573
        defaultCellStyle.setName(CommonStrings::DefaultCellStyle);
574
        defaultCellStyle.setFillColor(CommonStrings::None);
17311 fschmid 575
        defaultCellStyle.setFillShade(100);
576
        defaultCellStyle.setLeftBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
577
        defaultCellStyle.setRightBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
578
        defaultCellStyle.setTopBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
579
        defaultCellStyle.setBottomBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
16856 craig 580
        defaultCellStyle.setLeftPadding(1.0);
581
        defaultCellStyle.setRightPadding(1.0);
582
        defaultCellStyle.setTopPadding(1.0);
583
        defaultCellStyle.setBottomPadding(1.0);
584
        docCellStyles.create(defaultCellStyle);
585
        docCellStyles.makeDefault(&(docCellStyles[0]));
5698 avox 586
 
10146 jghali 587
        Layers.addLayer( tr("Background") );
14925 cbradney 588
        // FIXME: Check PDF version input
589
        //TODO: Check if this is needed now we ue appPrefsData --> docPrefsData
590
        pdfOptions().Version = (PDFOptions::PDFVersion)appPrefsData.pdfPrefs.Version;
3201 subik 591
 
14925 cbradney 592
        pdfOptions().firstUse = true;
6368 fschmid 593
        docPatterns.clear();
14150 fschmid 594
        docGradients.clear();
6368 fschmid 595
 
14925 cbradney 596
        if (autoSave() && ScCore->usingGUI())
597
                autoSaveTimer->start(autoSaveTime());
3724 cbradney 598
        //Do this after all the collections have been created and cleared!
599
        m_masterPageMode=true; // quick hack to force the change of pointers in setMasterPageMode();
600
        setMasterPageMode(false);
2891 cbradney 601
        addSymbols();
17826 craig 602
        //for loading old documents where default notes style is not saved
603
        if (m_docNotesStylesList.isEmpty())
604
                m_docNotesStylesList.append(new NotesStyle());
3 paul 605
}
606
 
10532 avox 607
 
3 paul 608
ScribusDoc::~ScribusDoc()
609
{
7906 jghali 610
        m_guardedObject.nullify();
9616 jghali 611
        CloseCMSProfiles();
14662 fschmid 612
        ScCore->fileWatcher->stop();
613
        ScCore->fileWatcher->removeFile(DocName);
16105 fschmid 614
        QList<PageItem*> allItems;
14662 fschmid 615
        for (int a = 0; a < DocItems.count(); ++a)
616
        {
617
                PageItem *currItem = DocItems.at(a);
16105 fschmid 618
                if (currItem->isGroup())
16916 fschmid 619
                        allItems = currItem->asGroupFrame()->getItemList();
16105 fschmid 620
                else
621
                        allItems.append(currItem);
622
                for (int ii = 0; ii < allItems.count(); ii++)
14662 fschmid 623
                {
16105 fschmid 624
                        currItem = allItems.at(ii);
625
                        if (currItem->PictureIsAvailable)
626
                                ScCore->fileWatcher->removeFile(currItem->Pfile);
627
                        if ((currItem->asImageFrame()) && (!currItem->Pfile.isEmpty()))
628
                        {
629
                                QFileInfo fi(currItem->Pfile);
630
                                ScCore->fileWatcher->removeDir(fi.absolutePath());
631
                        }
14662 fschmid 632
                }
16148 fschmid 633
                allItems.clear();
14662 fschmid 634
        }
635
        for (int a = 0; a < MasterItems.count(); ++a)
636
        {
637
                PageItem *currItem = MasterItems.at(a);
16105 fschmid 638
                if (currItem->isGroup())
16916 fschmid 639
                        allItems = currItem->asGroupFrame()->getItemList();
16105 fschmid 640
                else
641
                        allItems.append(currItem);
642
                for (int ii = 0; ii < allItems.count(); ii++)
14662 fschmid 643
                {
16105 fschmid 644
                        currItem = allItems.at(ii);
645
                        if (currItem->PictureIsAvailable)
646
                                ScCore->fileWatcher->removeFile(currItem->Pfile);
647
                        if ((currItem->asImageFrame()) && (!currItem->Pfile.isEmpty()))
648
                        {
649
                                QFileInfo fi(currItem->Pfile);
650
                                ScCore->fileWatcher->removeDir(fi.absolutePath());
651
                        }
14662 fschmid 652
                }
16148 fschmid 653
                allItems.clear();
14662 fschmid 654
        }
17407 fschmid 655
        for (QHash<int, PageItem*>::iterator itf = FrameItems.begin(); itf != FrameItems.end(); ++itf)
14662 fschmid 656
        {
17407 fschmid 657
                PageItem *currItem = itf.value();
16105 fschmid 658
                if (currItem->isGroup())
16916 fschmid 659
                        allItems = currItem->asGroupFrame()->getItemList();
16105 fschmid 660
                else
661
                        allItems.append(currItem);
662
                for (int ii = 0; ii < allItems.count(); ii++)
14662 fschmid 663
                {
16105 fschmid 664
                        currItem = allItems.at(ii);
665
                        if (currItem->PictureIsAvailable)
666
                                ScCore->fileWatcher->removeFile(currItem->Pfile);
667
                        if ((currItem->asImageFrame()) && (!currItem->Pfile.isEmpty()))
668
                        {
669
                                QFileInfo fi(currItem->Pfile);
670
                                ScCore->fileWatcher->removeDir(fi.absolutePath());
671
                        }
14662 fschmid 672
                }
16148 fschmid 673
                allItems.clear();
14662 fschmid 674
        }
675
        QStringList patterns = docPatterns.keys();
676
        for (int c = 0; c < patterns.count(); ++c)
677
        {
678
                ScPattern pa = docPatterns[patterns[c]];
679
                for (int o = 0; o < pa.items.count(); o++)
680
                {
681
                        PageItem *currItem = pa.items.at(o);
16105 fschmid 682
                        if (currItem->isGroup())
16916 fschmid 683
                                allItems = currItem->asGroupFrame()->getItemList();
16105 fschmid 684
                        else
685
                                allItems.append(currItem);
686
                        for (int ii = 0; ii < allItems.count(); ii++)
14662 fschmid 687
                        {
16105 fschmid 688
                                currItem = allItems.at(ii);
689
                                if (currItem->itemType() == PageItem::ImageFrame)
16016 fschmid 690
                                {
16105 fschmid 691
                                        if ((currItem->PictureIsAvailable) && (!currItem->Pfile.isEmpty()))
692
                                        {
693
                                                ScCore->fileWatcher->removeFile(currItem->Pfile);
694
                                                QFileInfo fi(currItem->Pfile);
695
                                                ScCore->fileWatcher->removeDir(fi.absolutePath());
696
                                        }
16016 fschmid 697
                                }
14662 fschmid 698
                        }
16148 fschmid 699
                        allItems.clear();
14662 fschmid 700
                }
16016 fschmid 701
                while (!pa.items.isEmpty())
702
                {
703
                        delete pa.items.takeFirst();
704
                }
14662 fschmid 705
        }
17826 craig 706
        //deleting resources alocated for marks and notes
707
        while (! m_docNotesList.isEmpty())
708
                delete m_docNotesList.takeFirst();
709
        while (!m_docMarksList.isEmpty())
710
                delete m_docMarksList.takeFirst();
711
        while (! m_docNotesStylesList.isEmpty())
712
                delete m_docNotesStylesList.takeFirst();
16016 fschmid 713
        docPatterns.clear();
714
        docGradients.clear();
18047 craig 715
        foreach (NumStruct* ns, numerations.values())
716
                delete ns;
717
        numerations.clear();
9856 fschmid 718
        while (!DocItems.isEmpty())
719
        {
720
                delete DocItems.takeFirst();
721
        }
17407 fschmid 722
        QList<PageItem*> tmList = FrameItems.values();
723
        while (!tmList.isEmpty())
16016 fschmid 724
        {
17407 fschmid 725
                delete tmList.takeFirst();
16016 fschmid 726
        }
17407 fschmid 727
        FrameItems.clear();
10013 cbradney 728
 
729
        while (!MasterPages.isEmpty())
730
        {
731
                delete MasterPages.takeFirst();
732
        }
733
        while (!DocPages.isEmpty())
734
        {
735
                delete DocPages.takeFirst();
736
        }
9856 fschmid 737
        while (!MasterItems.isEmpty())
738
        {
739
                delete MasterItems.takeFirst();
740
        }
3544 avox 741
        QMap<QString,int>::Iterator it3;
494 fschmid 742
        for (it3 = UsedFonts.begin(); it3 != UsedFonts.end(); ++it3)
743
        {
5980 avox 744
                if (!(*AllFonts)[it3.key()].localForDocument().isEmpty())
494 fschmid 745
                        (*AllFonts).removeFont(it3.key());
5559 avox 746
                else
5980 avox 747
                        (*AllFonts)[it3.key()].decreaseUsage();
494 fschmid 748
        }
12993 jghali 749
        if (docHyphenator)
750
                delete docHyphenator;
14681 fschmid 751
        if (m_serializer)
752
                delete m_serializer;
17743 jghali 753
        if (m_tserializer)
754
                delete m_tserializer;
14662 fschmid 755
        ScCore->fileWatcher->start();
3 paul 756
}
757
 
19568 jghali 758
bool ScribusDoc::inAnEditMode() const
759
{
19612 craig 760
        bool inEditMode = (appMode == modeEdit ||
761
                                           appMode == modeEditTable ||
762
                                           appMode == modeEditSpiral ||
763
                                           appMode == modeEditGradientVectors ||
764
                                           appMode == modeEditClip ||
765
                                           appMode == modeEditMeshGradient ||
766
                                           appMode == modeEditArc ||
767
                                           appMode == modeEditMeshPatch ||
768
                                           appMode == modeEditWeldPoint ||
769
                                           appMode == modeEditPolygon ||
770
                                           appMode == modeDrawBezierLine
771
                                           ) ? true : false;
19568 jghali 772
 
773
        return inEditMode;
774
}
775
 
16105 fschmid 776
QList<PageItem*> ScribusDoc::getAllItems(QList<PageItem*> &items)
777
{
778
        QList<PageItem*> ret;
779
        for (int em = 0; em < items.count(); ++em)
780
        {
781
                PageItem* embedded = items.at(em);
782
                ret.append(embedded);
783
                if (embedded->isGroup())
16916 fschmid 784
                        ret += embedded->asGroupFrame()->getItemList();
16105 fschmid 785
        }
786
        return ret;
787
}
10532 avox 788
 
16594 fschmid 789
QList<PageItem*> *ScribusDoc::parentGroup(PageItem* item, QList<PageItem*> *list)
790
{
791
        QList<PageItem*> *retList = NULL;
792
        if (list->contains(item))
793
                retList = list;
794
        else
795
        {
796
                for (int a = 0; a < list->count(); ++a)
797
                {
798
                        PageItem* embedded = list->at(a);
799
                        if (embedded->isGroup())
800
                        {
801
                                retList = parentGroup(item, &embedded->asGroupFrame()->groupItemList);
802
                                if (retList != NULL)
803
                                        break;
804
                        }
805
                }
806
        }
807
        return retList;
808
}
809
 
2901 fschmid 810
void ScribusDoc::setup(const int unitIndex, const int fp, const int firstLeft, const int orientation, const int firstPageNumber, const QString& defaultPageSize, const QString& documentName)
2891 cbradney 811
{
14924 cbradney 812
        docPrefsData.docSetupPrefs.docUnitIndex=unitIndex;
813
        setPageSetFirstPage(fp, firstLeft);
14991 cbradney 814
        docPrefsData.docSetupPrefs.pageOrientation = orientation;
815
        docPrefsData.docSetupPrefs.pageSize = defaultPageSize;
2891 cbradney 816
        FirstPnum = firstPageNumber;
15407 craig 817
        docPrefsData.docSetupPrefs.pagePositioning = fp;
2891 cbradney 818
        setName(documentName);
5880 jghali 819
        HasCMS = false;
14925 cbradney 820
        if (!pdfOptions().UseLPI)
4039 fschmid 821
        {
14925 cbradney 822
                pdfOptions().LPISettings.clear();
4039 fschmid 823
                struct LPIData lpo;
11726 cbradney 824
                lpo.Frequency = 133;
11720 cbradney 825
                lpo.SpotFunc = 3;
4039 fschmid 826
                lpo.Angle = 105;
14925 cbradney 827
                pdfOptions().LPISettings.insert("Cyan", lpo);
4039 fschmid 828
                lpo.Angle = 75;
14925 cbradney 829
                pdfOptions().LPISettings.insert("Magenta", lpo);
4039 fschmid 830
                lpo.Angle = 90;
14925 cbradney 831
                pdfOptions().LPISettings.insert("Yellow", lpo);
4039 fschmid 832
                lpo.Angle = 45;
14925 cbradney 833
                pdfOptions().LPISettings.insert("Black", lpo);
4039 fschmid 834
                ActiveLayer = 0;
835
        }
3201 subik 836
 
2891 cbradney 837
        appMode = modeNormal;
838
        PrefsManager *prefsManager=PrefsManager::instance();
14150 fschmid 839
 
15001 cbradney 840
        docPrefsData.colorPrefs.DCMSset = prefsManager->appPrefs.colorPrefs.DCMSset;
841
        docPrefsData.pdfPrefs.SolidProf = docPrefsData.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
842
        docPrefsData.pdfPrefs.ImageProf = docPrefsData.colorPrefs.DCMSset.DefaultImageRGBProfile;
843
        docPrefsData.pdfPrefs.PrintProf = docPrefsData.colorPrefs.DCMSset.DefaultPrinterProfile;
18190 jghali 844
        docPrefsData.pdfPrefs.Intent  = docPrefsData.colorPrefs.DCMSset.DefaultIntentColors;
15001 cbradney 845
        docPrefsData.pdfPrefs.Intent2 = docPrefsData.colorPrefs.DCMSset.DefaultIntentImages;
846
        BlackPoint   = docPrefsData.colorPrefs.DCMSset.BlackPoint;
847
        SoftProofing = docPrefsData.colorPrefs.DCMSset.SoftProofOn;
848
        Gamut        = docPrefsData.colorPrefs.DCMSset.GamutCheck;
849
        IntentColors = docPrefsData.colorPrefs.DCMSset.DefaultIntentColors;
850
        IntentImages = docPrefsData.colorPrefs.DCMSset.DefaultIntentImages;
851
        if (ScCore->haveCMS() && docPrefsData.colorPrefs.DCMSset.CMSinUse)
2891 cbradney 852
        {
5345 mrdocs 853
                if (OpenCMSProfiles(ScCore->InputProfiles, ScCore->InputProfilesCMYK, ScCore->MonitorProfiles, ScCore->PrinterProfiles))
5178 mrdocs 854
                {
5880 jghali 855
                        HasCMS = true;
15001 cbradney 856
                        pdfOptions().SComp = docPrefsData.colorPrefs.DCMSset.ComponentsInput2;
5178 mrdocs 857
                }
858
                else
10338 jghali 859
                {
860
                        SetDefaultCMSParams();
5880 jghali 861
                        HasCMS = false;
10338 jghali 862
                }
2891 cbradney 863
        }
864
}
865
 
10532 avox 866
 
5824 cbradney 867
void ScribusDoc::setGUI(bool hasgui, ScribusMainWindow* mw, ScribusView* view)
5781 cbradney 868
{
5824 cbradney 869
        m_hasGUI = hasgui;
14681 fschmid 870
        m_ScMW = mw;
10532 avox 871
        //FIXME: stop using m_View
14681 fschmid 872
        m_View = view;
873
        if (m_hasGUI)
874
        {
875
                docHyphenator = new Hyphenator(m_ScMW, this);
876
                Q_CHECK_PTR(docHyphenator);
877
        }
878
        else
879
                docHyphenator = NULL;
5781 cbradney 880
}
881
 
10532 avox 882
 
2891 cbradney 883
void ScribusDoc::setLoading(const bool docLoading)
884
{
885
        loading = docLoading;
886
}
887
 
10532 avox 888
 
3985 cbradney 889
bool ScribusDoc::isLoading() const
2891 cbradney 890
{
891
        return loading;
892
}
893
 
10532 avox 894
 
895
//AV: eeks. That should not be used
4320 cbradney 896
ScribusView* ScribusDoc::view() const
897
{
5781 cbradney 898
//      return (WinHan ? (((ScribusWin*) WinHan)->view()) : 0);
899
        return m_View;
4320 cbradney 900
}
901
 
10532 avox 902
 
7906 jghali 903
const ScGuardedPtr<ScribusDoc>& ScribusDoc::guardedPtr() const
904
{
905
        return m_guardedObject;
906
}
907
 
10532 avox 908
 
1330 fschmid 909
void ScribusDoc::CloseCMSProfiles()
910
{
5880 jghali 911
        HasCMS = false;
10338 jghali 912
        SetDefaultCMSParams();
1330 fschmid 913
}
914
 
10338 jghali 915
void ScribusDoc::SetDefaultCMSParams()
916
{
917
        BlackPoint     = true;
918
        SoftProofing   = false;
919
        Gamut          = false;
14170 jghali 920
        IntentColors   = Intent_Relative_Colorimetric;
921
        IntentImages   = Intent_Relative_Colorimetric;
10338 jghali 922
        DocInputRGBProf       = ScCore->defaultRGBProfile;
923
        DocInputCMYKProf      = ScCore->defaultCMYKProfile;
924
        DocInputImageRGBProf  = ScCore->defaultRGBProfile;
925
        DocInputImageCMYKProf = ScCore->defaultCMYKProfile;
14281 jghali 926
        DocDisplayProf        = ScCore->defaultRGBProfile;
10338 jghali 927
        DocPrinterProf        = ScCore->defaultCMYKProfile;
928
        stdTransRGBMon        = ScCore->defaultRGBToScreenSolidTrans;
929
        stdTransCMYKMon       = ScCore->defaultCMYKToRGBTrans;
10393 jghali 930
        stdTransRGB           = ScCore->defaultCMYKToRGBTrans;
931
        stdTransCMYK          = ScCore->defaultRGBToCMYKTrans;
10338 jghali 932
        stdProof              = ScCore->defaultRGBToScreenSolidTrans;
933
        stdProofGC            = ScCore->defaultRGBToScreenSolidTrans;
934
        stdProofCMYK          = ScCore->defaultCMYKToRGBTrans;
935
        stdProofCMYKGC        = ScCore->defaultCMYKToRGBTrans;
936
        stdTransImg           = ScCore->defaultRGBToScreenImageTrans;
937
        stdProofImg           = ScCore->defaultRGBToScreenImageTrans;
938
        stdProofImgCMYK       = ScCore->defaultCMYKToScreenImageTrans;
939
}
940
 
5345 mrdocs 941
bool ScribusDoc::OpenCMSProfiles(ProfilesL InPo, ProfilesL InPoCMYK, ProfilesL MoPo, ProfilesL PrPo)
1330 fschmid 942
{
5880 jghali 943
        HasCMS = false;
14170 jghali 944
        ScColorProfile inputProf;
945
 
14491 jghali 946
        colorEngine = colorMgmtEngineFactory.createDefaultEngine();
947
        ScColorMgmtStrategy colorStrategy;
15001 cbradney 948
        colorStrategy.useBlackPointCompensation = docPrefsData.colorPrefs.DCMSset.BlackPoint;
14170 jghali 949
        colorStrategy.useBlackPreservation      = false;
950
        colorEngine.setStrategy(colorStrategy);
951
 
14281 jghali 952
        DocDisplayProf   = ScCore->monitorProfile;
15001 cbradney 953
        DocInputRGBProf  = colorEngine.openProfileFromFile( InPo[docPrefsData.colorPrefs.DCMSset.DefaultSolidColorRGBProfile] );
954
        DocInputCMYKProf = colorEngine.openProfileFromFile( InPoCMYK[docPrefsData.colorPrefs.DCMSset.DefaultSolidColorCMYKProfile] );
955
        DocPrinterProf   = colorEngine.openProfileFromFile( PrPo[docPrefsData.colorPrefs.DCMSset.DefaultPrinterProfile] );
956
        DocInputImageRGBProf  = colorEngine.openProfileFromFile( InPo[docPrefsData.colorPrefs.DCMSset.DefaultImageRGBProfile] );
957
        DocInputImageCMYKProf = colorEngine.openProfileFromFile( InPoCMYK[docPrefsData.colorPrefs.DCMSset.DefaultImageCMYKProfile] );
14281 jghali 958
        if ((!DocDisplayProf) || (!DocInputRGBProf) || (!DocInputCMYKProf) || (!DocPrinterProf) || (!DocInputImageCMYKProf) || (!DocInputImageRGBProf))
1330 fschmid 959
        {
15001 cbradney 960
                docPrefsData.colorPrefs.DCMSset.CMSinUse = false;
5178 mrdocs 961
                return false;
1330 fschmid 962
        }
14170 jghali 963
 
964
        int dcmsFlags   = 0;
5369 mrdocs 965
        int dcmsFlagsGC = 0;
15001 cbradney 966
        if (docPrefsData.colorPrefs.DCMSset.GamutCheck)
14170 jghali 967
                dcmsFlagsGC |= Ctf_GamutCheck;
15001 cbradney 968
        if (docPrefsData.colorPrefs.DCMSset.BlackPoint)
1330 fschmid 969
        {
14170 jghali 970
                dcmsFlags   |= Ctf_BlackPointCompensation;
971
                dcmsFlagsGC |= Ctf_BlackPointCompensation;
1330 fschmid 972
        }
14170 jghali 973
        stdTransRGBMon  = colorEngine.createTransform(DocInputRGBProf, Format_RGB_16,
14281 jghali 974
                                                                                DocDisplayProf, Format_RGB_16,
14170 jghali 975
                                                                                IntentColors, dcmsFlags);
976
        stdTransCMYKMon = colorEngine.createTransform(DocInputCMYKProf, Format_CMYK_16,
14281 jghali 977
                                                                                DocDisplayProf, Format_RGB_16,
14170 jghali 978
                                                                                IntentColors, dcmsFlags);
5345 mrdocs 979
        // TODO : check input profiles used for images
15128 jghali 980
        stdProofImg = colorEngine.createProofingTransform(DocInputImageRGBProf, Format_BGRA_8,
981
                          DocDisplayProf, Format_BGRA_8, DocPrinterProf,
14170 jghali 982
                          IntentImages, Intent_Relative_Colorimetric, dcmsFlagsGC);
983
        stdProofImgCMYK = colorEngine.createProofingTransform(DocInputImageCMYKProf, Format_CMYK_8,
15128 jghali 984
                          DocDisplayProf, Format_BGRA_8, DocPrinterProf,
14170 jghali 985
                          IntentImages, Intent_Relative_Colorimetric, dcmsFlagsGC);
15128 jghali 986
        stdTransImg = colorEngine.createTransform(DocInputRGBProf, Format_BGRA_8,
987
                          DocDisplayProf, Format_BGRA_8,
14170 jghali 988
                                          IntentImages, dcmsFlags);
989
        stdTransRGB = colorEngine.createTransform(DocInputCMYKProf, Format_CMYK_16,
990
                                          DocInputRGBProf, Format_RGB_16,
991
                                          IntentColors, dcmsFlags);
992
        stdTransCMYK = colorEngine.createTransform(DocInputRGBProf, Format_RGB_16,
993
                                          DocInputCMYKProf, Format_CMYK_16,
994
                                          IntentColors, dcmsFlags);
995
 
996
        ScColorProfile inputProfRGB;
997
        ScColorProfile inputProfCMYK;
14772 jghali 998
        if (DocPrinterProf.colorSpace() == ColorSpace_Cmyk)
1491 fschmid 999
        {
15001 cbradney 1000
                inputProf = (docPrefsData.colorPrefs.DCMSset.SoftProofOn && docPrefsData.colorPrefs.DCMSset.SoftProofFullOn) ? DocInputCMYKProf : DocPrinterProf;
6070 jghali 1001
                inputProfRGB  = DocInputRGBProf;
1002
                inputProfCMYK = inputProf;
1491 fschmid 1003
        }
1004
        else
1005
        {
15001 cbradney 1006
                inputProf = (docPrefsData.colorPrefs.DCMSset.SoftProofOn && docPrefsData.colorPrefs.DCMSset.SoftProofFullOn) ? DocInputRGBProf : DocPrinterProf;
6070 jghali 1007
                inputProfRGB  = inputProf;
1008
                inputProfCMYK = DocInputCMYKProf;
1491 fschmid 1009
        }
14170 jghali 1010
        stdProof = colorEngine.createProofingTransform(inputProfRGB, Format_RGB_16,
14281 jghali 1011
                            DocDisplayProf, Format_RGB_16,
6070 jghali 1012
                            DocPrinterProf,
1013
                            IntentColors,
14170 jghali 1014
                            Intent_Relative_Colorimetric, dcmsFlags);
1015
        stdProofGC = colorEngine.createProofingTransform(inputProfRGB, Format_RGB_16,
14281 jghali 1016
                            DocDisplayProf, Format_RGB_16,
14170 jghali 1017
                            DocPrinterProf, IntentColors,
14179 jghali 1018
                            Intent_Relative_Colorimetric, dcmsFlags| Ctf_GamutCheck);
14170 jghali 1019
        stdProofCMYK = colorEngine.createProofingTransform(inputProfCMYK, Format_CMYK_16,
14281 jghali 1020
                                                DocDisplayProf, Format_RGB_16,
14170 jghali 1021
                                                DocPrinterProf, IntentColors,
1022
                                                Intent_Relative_Colorimetric, dcmsFlags);
1023
        stdProofCMYKGC = colorEngine.createProofingTransform(inputProfCMYK, Format_CMYK_16,
14281 jghali 1024
                                                DocDisplayProf, Format_RGB_16,
6070 jghali 1025
                                                DocPrinterProf,
1026
                                                IntentColors,
14179 jghali 1027
                                                Intent_Relative_Colorimetric, dcmsFlags | Ctf_GamutCheck);
6464 jghali 1028
 
14772 jghali 1029
        if (DocInputRGBProf.colorSpace() == ColorSpace_Rgb)
15001 cbradney 1030
                        docPrefsData.colorPrefs.DCMSset.ComponentsInput2 = 3;
14772 jghali 1031
        if (DocInputRGBProf.colorSpace() == ColorSpace_Cmyk)
15001 cbradney 1032
                        docPrefsData.colorPrefs.DCMSset.ComponentsInput2 = 4;
14772 jghali 1033
        if (DocInputRGBProf.colorSpace() == ColorSpace_Cmy)
15001 cbradney 1034
                        docPrefsData.colorPrefs.DCMSset.ComponentsInput2 = 3;
6464 jghali 1035
 
14179 jghali 1036
        bool success  = (stdTransRGBMon && stdTransCMYKMon && stdProofImg  && stdProofImgCMYK &&
1037
                             stdTransImg    && stdTransRGB     && stdTransCMYK && stdProof       &&
1038
                         stdProofGC     && stdProofCMYK    && stdProofCMYKGC);
1039
        if (!success)
1040
        {
1041
                CloseCMSProfiles();
15001 cbradney 1042
                docPrefsData.colorPrefs.DCMSset.CMSinUse = false;
14179 jghali 1043
                QString message = tr("An error occurred while opening ICC profiles, color management is not enabled." );
19605 jghali 1044
                ScMessageBox::warning(m_ScMW, CommonStrings::trWarning, message);
14179 jghali 1045
        }
5178 mrdocs 1046
        return true;
1330 fschmid 1047
}
1048
 
10532 avox 1049
 
6726 fschmid 1050
void ScribusDoc::enableCMS(bool enable)
1051
{
1052
        m_ScMW->setStatusBarInfoText( tr("Adjusting Colors"));
1053
        m_ScMW->mainWindowProgressBar->reset();
17371 fschmid 1054
        int cc = PageColors.count() + MasterItems.count() + DocItems.count() + FrameItems.count();
9953 cbradney 1055
        m_ScMW->mainWindowProgressBar->setMaximum(cc);
18181 fschmid 1056
        qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
15001 cbradney 1057
        bool oldCM = docPrefsData.colorPrefs.DCMSset.CMSinUse;
10726 jghali 1058
        bool newCM = enable;
1059
        CloseCMSProfiles();
15001 cbradney 1060
        docPrefsData.colorPrefs.DCMSset.CMSinUse = newCM;
1061
        HasCMS       = docPrefsData.colorPrefs.DCMSset.CMSinUse;
1062
        BlackPoint   = docPrefsData.colorPrefs.DCMSset.BlackPoint;
1063
        SoftProofing = docPrefsData.colorPrefs.DCMSset.SoftProofOn;
1064
        Gamut        = docPrefsData.colorPrefs.DCMSset.GamutCheck;
1065
        IntentColors = docPrefsData.colorPrefs.DCMSset.DefaultIntentColors;
1066
        IntentImages = docPrefsData.colorPrefs.DCMSset.DefaultIntentImages;
1067
        if (!docPrefsData.colorPrefs.DCMSset.CMSinUse)
6726 fschmid 1068
        {
1069
                HasCMS = false;
1070
                if      (oldCM)
1071
                {
1072
                        m_ScMW->recalcColors(m_ScMW->mainWindowProgressBar);
1073
                        RecalcPictures(&ScCore->InputProfiles, &ScCore->InputProfilesCMYK, m_ScMW->mainWindowProgressBar);
1074
                }
1075
        }
1076
        else if (OpenCMSProfiles(ScCore->InputProfiles, ScCore->InputProfilesCMYK, ScCore->MonitorProfiles, ScCore->PrinterProfiles) )
1077
        {
1078
                HasCMS = true;
15001 cbradney 1079
                docPrefsData.pdfPrefs.SComp = docPrefsData.colorPrefs.DCMSset.ComponentsInput2;
1080
                docPrefsData.pdfPrefs.SolidProf = docPrefsData.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
1081
                docPrefsData.pdfPrefs.ImageProf = docPrefsData.colorPrefs.DCMSset.DefaultImageRGBProfile;
1082
                docPrefsData.pdfPrefs.PrintProf = docPrefsData.colorPrefs.DCMSset.DefaultPrinterProfile;
18190 jghali 1083
                docPrefsData.pdfPrefs.Intent  = docPrefsData.colorPrefs.DCMSset.DefaultIntentColors;
1084
                docPrefsData.pdfPrefs.Intent2 = docPrefsData.colorPrefs.DCMSset.DefaultIntentImages;
6726 fschmid 1085
                m_ScMW->recalcColors(m_ScMW->mainWindowProgressBar);
1086
                RecalcPictures(&ScCore->InputProfiles, &ScCore->InputProfilesCMYK, m_ScMW->mainWindowProgressBar);
1087
        }
1088
        else
10338 jghali 1089
        {
1090
                SetDefaultCMSParams();
6726 fschmid 1091
                HasCMS = false;
10338 jghali 1092
        }
9953 cbradney 1093
        m_ScMW->mainWindowProgressBar->setValue(cc);
18181 fschmid 1094
        qApp->restoreOverrideCursor();
6726 fschmid 1095
        m_ScMW->setStatusBarInfoText("");
1096
        m_ScMW->mainWindowProgressBar->reset();
1097
}
7442 avox 1098
 
1099
 
8455 avox 1100
void ScribusDoc::getNamedResources(ResourceCollection& lists) const
1101
{
8776 cbradney 1102
        lists.availableFonts = AllFonts;
8775 cbradney 1103
        lists.availableColors = const_cast<ColorList*>(& PageColors);
1104
 
9856 fschmid 1105
        const QList<PageItem*> * itemlist = & MasterItems;
8455 avox 1106
        while (itemlist != NULL)
1107
        {
9856 fschmid 1108
                for (int i=0; i < itemlist->count(); ++i)
8455 avox 1109
                {
9856 fschmid 1110
                        const PageItem * currItem = const_cast<QList<PageItem*>*>(itemlist)->at(i);
8455 avox 1111
                        if (currItem)
9296 jghali 1112
                                currItem->getNamedResources(lists);
8455 avox 1113
                }
1114
                if (itemlist == &MasterItems)
1115
                        itemlist = &DocItems;
1116
                else
1117
                        itemlist = NULL;
1118
        }
17407 fschmid 1119
        for (QHash<int, PageItem*>::const_iterator itf = FrameItems.begin(); itf != FrameItems.end(); ++itf)
1120
        {
1121
                PageItem *currItem = itf.value();
1122
                if (currItem)
1123
                        currItem->getNamedResources(lists);
1124
        }
10400 subik 1125
        for (int i = 0; i < docParagraphStyles.count(); ++i)
8455 avox 1126
                docParagraphStyles[i].getNamedResources(lists);
10400 subik 1127
        for (int i = 0; i < docCharStyles.count(); ++i)
8455 avox 1128
                docCharStyles[i].getNamedResources(lists);
16856 craig 1129
        for (int i = 0; i < docTableStyles.count(); ++i)
1130
                docTableStyles[i].getNamedResources(lists);
1131
        for (int i = 0; i < docCellStyles.count(); ++i)
1132
                docCellStyles[i].getNamedResources(lists);
8455 avox 1133
//      for (uint i = 0; i < docLineStyles.count(); ++i)
1134
//              docLineStyles[i].getNamedResources(lists);
1135
 
17400 fschmid 1136
        QHash<QString,ScPattern>::ConstIterator it;
8455 avox 1137
        for (it = docPatterns.begin(); it != docPatterns.end(); ++it)
1138
        {
1139
                ScPattern pa = *it;
9856 fschmid 1140
                for (int o = 0; o < pa.items.count(); o++)
8455 avox 1141
                {
1142
                        pa.items.at(o)->getNamedResources(lists);
1143
                }
14813 fschmid 1144
        }
17400 fschmid 1145
        QHash<QString,VGradient>::ConstIterator itg;
14813 fschmid 1146
        for (itg = docGradients.begin(); itg != docGradients.end(); ++itg)
1147
        {
1148
                QList<VColorStop*> cstops = itg.value().colorStops();
1149
                for (uint cst = 0; cst < itg.value().Stops(); ++cst)
1150
                {
1151
                        lists.collectColor(cstops.at(cst)->name);
1152
                }
1153
        }
8455 avox 1154
}
1155
 
16386 fschmid 1156
bool ScribusDoc::styleExists(QString styleName)
1157
{
19582 craig 1158
        for (int i = 0; i < paragraphStyles().count(); ++i)
16386 fschmid 1159
        {
19582 craig 1160
                if (paragraphStyles()[i].name() == styleName)
16386 fschmid 1161
                        return true;
1162
        }
1163
        return false;
1164
}
8455 avox 1165
 
16396 fschmid 1166
QList<int> ScribusDoc::getSortedStyleList()
1167
{
1168
        QList<int> retList;
19582 craig 1169
        for (int i = 0; i < docParagraphStyles.count(); ++i)
16396 fschmid 1170
        {
19582 craig 1171
                if (docParagraphStyles[i].parent().isEmpty())
16396 fschmid 1172
                {
19582 craig 1173
                        if (!retList.contains(i))
1174
                                retList.append(i);
16692 jghali 1175
                        continue;
16396 fschmid 1176
                }
16692 jghali 1177
 
1178
                QList<int> retList2;
19582 craig 1179
                QString name = docParagraphStyles[i].name();
1180
                QString par  = docParagraphStyles[i].parent();
1181
                retList2.prepend(i);
16692 jghali 1182
                while ((!par.isEmpty()) && (par != name))
16396 fschmid 1183
                {
16692 jghali 1184
                        int pp = docParagraphStyles.find(par);
1185
                        if ((pp >= 0) && (!retList2.contains(pp)))
1186
                                retList2.prepend(pp);
1187
                        par = (pp >= 0) ? docParagraphStyles[pp].parent() : QString();
16396 fschmid 1188
                }
16692 jghali 1189
                for (int r = 0; r < retList2.count(); ++r)
1190
                {
1191
                        if (!retList.contains(retList2[r]))
1192
                                retList.append(retList2[r]);
1193
                }
16396 fschmid 1194
        }
1195
        return retList;
1196
}
16386 fschmid 1197
 
16396 fschmid 1198
QList<int> ScribusDoc::getSortedCharStyleList()
1199
{
1200
        QList<int> retList;
19582 craig 1201
        for (int i = 0; i < docCharStyles.count(); ++i)
16396 fschmid 1202
        {
19582 craig 1203
                if (docCharStyles[i].parent().isEmpty())
16396 fschmid 1204
                {
19582 craig 1205
                        if (!retList.contains(i))
1206
                                retList.append(i);
16692 jghali 1207
                        continue;
16396 fschmid 1208
                }
16692 jghali 1209
 
1210
                QList<int> retList2;
19582 craig 1211
                QString name = docCharStyles[i].name();
1212
                QString par  = docCharStyles[i].parent();
1213
                retList2.prepend(i);
16692 jghali 1214
                while ((!par.isEmpty()) && (par != name))
16396 fschmid 1215
                {
16692 jghali 1216
                        int pp = docCharStyles.find(par);
1217
                        if ((pp >= 0) && (!retList2.contains(pp)))
1218
                                retList2.prepend(pp);
1219
                        par = (pp >= 0) ? docCharStyles[pp].parent() : QString();
16396 fschmid 1220
                }
16692 jghali 1221
                for (int r = 0; r < retList2.count(); ++r)
1222
                {
1223
                        if (!retList.contains(retList2[r]))
1224
                                retList.append(retList2[r]);
1225
                }
16396 fschmid 1226
        }
1227
        return retList;
1228
}
1229
 
16859 craig 1230
QList<int> ScribusDoc::getSortedTableStyleList()
1231
{
1232
        QList<int> retList;
19582 craig 1233
        for (int i = 0; i < docTableStyles.count(); ++i)
16859 craig 1234
        {
19582 craig 1235
                if (docTableStyles[i].parent().isEmpty())
16859 craig 1236
                {
19582 craig 1237
                        if (!retList.contains(i))
1238
                                retList.append(i);
16859 craig 1239
                        continue;
1240
                }
1241
 
1242
                QList<int> retList2;
19582 craig 1243
                QString name = docTableStyles[i].name();
1244
                QString par  = docTableStyles[i].parent();
1245
                retList2.prepend(i);
16859 craig 1246
                while ((!par.isEmpty()) && (par != name))
1247
                {
1248
                        int pp = docTableStyles.find(par);
1249
                        if ((pp >= 0) && (!retList2.contains(pp)))
1250
                                retList2.prepend(pp);
1251
                        par = (pp >= 0) ? docTableStyles[pp].parent() : QString();
1252
                }
1253
                for (int r = 0; r < retList2.count(); ++r)
1254
                {
1255
                        if (!retList.contains(retList2[r]))
1256
                                retList.append(retList2[r]);
1257
                }
1258
        }
1259
        return retList;
1260
}
1261
 
1262
QList<int> ScribusDoc::getSortedCellStyleList()
1263
{
1264
        QList<int> retList;
19582 craig 1265
        for (int i = 0; i < docCellStyles.count(); ++i)
16859 craig 1266
        {
19582 craig 1267
                if (docCellStyles[i].parent().isEmpty())
16859 craig 1268
                {
19582 craig 1269
                        if (!retList.contains(i))
1270
                                retList.append(i);
16859 craig 1271
                        continue;
1272
                }
1273
 
1274
                QList<int> retList2;
19582 craig 1275
                QString name = docCellStyles[i].name();
1276
                QString par  = docCellStyles[i].parent();
1277
                retList2.prepend(i);
16859 craig 1278
                while ((!par.isEmpty()) && (par != name))
1279
                {
1280
                        int pp = docCellStyles.find(par);
1281
                        if ((pp >= 0) && (!retList2.contains(pp)))
1282
                                retList2.prepend(pp);
1283
                        par = (pp >= 0) ? docCellStyles[pp].parent() : QString();
1284
                }
1285
                for (int r = 0; r < retList2.count(); ++r)
1286
                {
1287
                        if (!retList.contains(retList2[r]))
1288
                                retList.append(retList2[r]);
1289
                }
1290
        }
1291
        return retList;
1292
}
1293
 
7947 cbradney 1294
void ScribusDoc::replaceStyles(const QMap<QString,QString>& newNameForOld)
7442 avox 1295
{
8455 avox 1296
        ResourceCollection newNames;
8775 cbradney 1297
        newNames.mapStyles(newNameForOld);
8455 avox 1298
        replaceNamedResources(newNames);
1299
}
1300
 
1301
void ScribusDoc::replaceNamedResources(ResourceCollection& newNames)
1302
{
7595 avox 1303
        // replace names in items
17376 fschmid 1304
 
17969 fschmid 1305
//#ifndef QT_NO_CONCURRENT
1306
//      QtConcurrent::blockingMap(DocItems, ResMapped(newNames));
1307
//      QtConcurrent::blockingMap(MasterItems, ResMapped(newNames));
1308
//#else
17376 fschmid 1309
 
9856 fschmid 1310
        QList<PageItem*> * itemlist = & MasterItems;
7442 avox 1311
        while (itemlist != NULL)
1312
        {
9856 fschmid 1313
                for (int i=0; i < itemlist->count(); ++i)
7442 avox 1314
                {
9433 jghali 1315
                        PageItem * currItem = itemlist->at(i);
7442 avox 1316
                        if (currItem)
9433 jghali 1317
                                currItem->replaceNamedResources(newNames);
7442 avox 1318
                }
1319
                if (itemlist == &MasterItems)
1320
                        itemlist = &DocItems;
1321
                else
1322
                        itemlist = NULL;
1323
        }
17969 fschmid 1324
//#endif
17826 craig 1325
        foreach (NotesStyle* nStyle, m_docNotesStylesList)
1326
        { //update styles names in notes styles
1327
                if (nStyle == NULL)
1328
                        continue;
1329
                if (newNames.styles().contains(nStyle->notesParStyle()))
1330
                        nStyle->setNotesParStyle(newNames.styles().value(nStyle->notesParStyle()));
1331
                if (newNames.charStyles().contains(nStyle->marksChStyle()))
1332
                        nStyle->setMarksCharStyle(newNames.charStyles().value(nStyle->marksChStyle()));
1333
        }
17407 fschmid 1334
        for (QHash<int, PageItem*>::iterator itf = FrameItems.begin(); itf != FrameItems.end(); ++itf)
1335
        {
1336
                PageItem *currItem = itf.value();
1337
                if (currItem)
1338
                        currItem->replaceNamedResources(newNames);
1339
        }
7595 avox 1340
        // replace names in styles...
1341
        for (int i=docParagraphStyles.count()-1; i >= 0; --i)
1342
        {
8814 cbradney 1343
                if (newNames.styles().contains(docParagraphStyles[i].name()))
1344
                        docParagraphStyles.remove(i);
1345
                else
1346
                        docParagraphStyles[i].replaceNamedResources(newNames);
8455 avox 1347
        }
1348
        for (int i=docCharStyles.count()-1; i >= 0; --i)
1349
        {
8814 cbradney 1350
                if (newNames.charStyles().contains(docCharStyles[i].name()))
1351
                        docCharStyles.remove(i);
1352
                else
1353
                        docCharStyles[i].replaceNamedResources(newNames);
8455 avox 1354
        }
16856 craig 1355
        for (int i = docTableStyles.count() - 1; i >= 0; --i)
1356
        {
1357
                if (newNames.tableStyles().contains(docTableStyles[i].name()))
1358
                        docTableStyles.remove(i);
1359
                else
1360
                        docTableStyles[i].replaceNamedResources(newNames);
1361
        }
1362
        for (int i = docCellStyles.count() - 1; i >= 0; --i)
1363
        {
1364
                if (newNames.cellStyles().contains(docCellStyles[i].name()))
1365
                        docCellStyles.remove(i);
1366
                else
1367
                        docCellStyles[i].replaceNamedResources(newNames);
1368
        }
8455 avox 1369
 
17400 fschmid 1370
        QHash<QString,ScPattern>::Iterator it;
8455 avox 1371
        for (it = docPatterns.begin(); it != docPatterns.end(); ++it)
1372
        {
8814 cbradney 1373
                if (newNames.patterns().contains(it.key()))
10571 fschmid 1374
                        docPatterns.erase(it);
8814 cbradney 1375
                else
8455 avox 1376
                {
8814 cbradney 1377
                        ScPattern pa = *it;
9856 fschmid 1378
                        for (int o = 0; o < pa.items.count(); o++)
8814 cbradney 1379
                        {
1380
                                pa.items.at(o)->replaceNamedResources(newNames);
1381
                        }
8058 avox 1382
                }
8772 cbradney 1383
        }
14150 fschmid 1384
 
17400 fschmid 1385
        QHash<QString,VGradient>::Iterator itg;
14150 fschmid 1386
        for (itg = docGradients.begin(); itg != docGradients.end(); ++itg)
1387
        {
1388
                if (newNames.gradients().contains(itg.key()))
1389
                        docGradients.erase(itg);
1390
                else
1391
                {
1392
                        QMap<QString,QString>::ConstIterator itc;
1393
                        QList<VColorStop*> cstops = itg.value().colorStops();
1394
                        for (uint cst = 0; cst < itg.value().Stops(); ++cst)
1395
                        {
1396
                                itc = newNames.colors().find(cstops.at(cst)->name);
1397
                                if (itc != newNames.colors().end())
1398
                                {
1399
                                        if (*itc != CommonStrings::None)
1400
                                                cstops.at(cst)->name = *itc;
1401
                                }
1402
                        }
1403
                }
1404
        }
8772 cbradney 1405
 
8783 cbradney 1406
        if (newNames.colors().count() > 0 || newNames.fonts().count() > 0)
1407
        {
8772 cbradney 1408
                docCharStyles.invalidate();
16856 craig 1409
                docParagraphStyles.invalidate();
1410
                docTableStyles.invalidate();
1411
                docCellStyles.invalidate();
8783 cbradney 1412
        }
1413
        else
1414
        {
1415
                if (newNames.charStyles().count() > 0)
1416
                        docCharStyles.invalidate();
1417
                if (newNames.styles().count() > 0)
16856 craig 1418
                        docParagraphStyles.invalidate();
1419
                if (newNames.tableStyles().count() > 0)
1420
                        docTableStyles.invalidate();
1421
                if (newNames.cellStyles().count() > 0)
1422
                        docCellStyles.invalidate();
8783 cbradney 1423
        }
8916 avox 1424
        if (!isLoading() && !(newNames.colors().isEmpty() && newNames.fonts().isEmpty() && newNames.patterns().isEmpty()
16856 craig 1425
                        && newNames.styles().isEmpty() && newNames.charStyles().isEmpty() && newNames.lineStyles().isEmpty()
1426
                        && newNames.tableStyles().isEmpty() && newNames.cellStyles().isEmpty()))
8916 avox 1427
                changed();
7442 avox 1428
}
1429
 
1430
 
7947 cbradney 1431
void ScribusDoc::replaceCharStyles(const QMap<QString,QString>& newNameForOld)
7442 avox 1432
{
8455 avox 1433
        ResourceCollection newNames;
8775 cbradney 1434
        newNames.mapCharStyles(newNameForOld);
8455 avox 1435
        replaceNamedResources(newNames);
1436
 
1437
        /*
7595 avox 1438
        // replace style in items
7442 avox 1439
        QPtrList<PageItem> * itemlist = & MasterItems;
1440
        while (itemlist != NULL)
1441
        {
7595 avox 1442
                for (uint i=0; i < itemlist->count(); ++i)
7442 avox 1443
                {
1444
                        PageItem_TextFrame * currItem = itemlist->at(i)->asTextFrame();
1445
                        if (currItem)
1446
                                currItem->itemText.replaceCharStyles(newNameForOld);
1447
                }
1448
                if (itemlist == &MasterItems)
1449
                        itemlist = &DocItems;
1450
                else if (itemlist == &DocItems)
1451
                        itemlist = &FrameItems;
1452
                else
1453
                        itemlist = NULL;
1454
        }
7595 avox 1455
        // replace names in styles
1456
        for (uint i=0; i < docParagraphStyles.count(); ++i)
1457
        {
1458
                // ...parent of parstyle's charstyle
1459
                const QString& parent(docParagraphStyles[i].charStyle().parent());
1460
                if (newNameForOld.contains(parent))
1461
                        docParagraphStyles[i].charStyle().setParent(newNameForOld[parent]);
1462
        }
1463
        for (int i=docCharStyles.count()-1; i >= 0; --i)
1464
        {
1465
                // ...parent of charstyle
1466
                const QString& parent(docCharStyles[i].parent());
1467
                if (newNameForOld.contains(parent))
1468
                        docCharStyles[i].setParent(newNameForOld[parent]);
1469
                // ... as name
1470
                if (newNameForOld.contains(docCharStyles[i].name()))
1471
                        docCharStyles.remove(i);
1472
        }
8455 avox 1473
        */
7442 avox 1474
}
1475
 
16856 craig 1476
void ScribusDoc::replaceTableStyles(const QMap<QString, QString>& newNameForOld)
1477
{
1478
        ResourceCollection newNames;
1479
        newNames.mapTableStyles(newNameForOld);
1480
        replaceNamedResources(newNames);
1481
}
10532 avox 1482
 
16856 craig 1483
void ScribusDoc::replaceCellStyles(const QMap<QString, QString>& newNameForOld)
1484
{
1485
        ResourceCollection newNames;
1486
        newNames.mapCellStyles(newNameForOld);
1487
        replaceNamedResources(newNames);
1488
}
1489
 
7595 avox 1490
void ScribusDoc::redefineStyles(const StyleSet<ParagraphStyle>& newStyles, bool removeUnused)
1491
{
1492
        docParagraphStyles.redefine(newStyles, false);
1493
        if (removeUnused)
1494
        {
1495
                QMap<QString, QString> deletion;
1496
                QString deflt("");
10400 subik 1497
                for (int i=0; i < docParagraphStyles.count(); ++i)
7595 avox 1498
                {
1499
                        const QString& nam(docParagraphStyles[i].name());
1500
                        if (newStyles.find(nam) < 0)
1501
                                deletion[nam] = deflt;
1502
                }
1503
                if (deletion.count() > 0)
1504
                        replaceStyles(deletion);
1505
        }
8134 avox 1506
        // repair charstyle context:
10400 subik 1507
        for (int i=0; i < docParagraphStyles.count(); ++i)
8058 avox 1508
        {
1509
                ParagraphStyle& sty(docParagraphStyles[i]);
1510
                if (docParagraphStyles.isDefault(sty))
1511
                {
1512
                        sty.breakImplicitCharStyleInheritance(true);
8134 avox 1513
                        sty.charStyle().setContext( & docCharStyles );
8191 avox 1514
//                      sty.charStyle().setName( "cdocdefault" ); // DONT TRANSLATE
8058 avox 1515
                }
1516
                else {
1517
                        sty.breakImplicitCharStyleInheritance(false);
1518
                }
1519
        }
8772 cbradney 1520
        docParagraphStyles.invalidate();
18047 craig 1521
        if (!isLoading())
1522
        {
1523
                flag_Renumber = true;
1524
                flag_NumUpdateRequest = true;
1525
        }
7595 avox 1526
}
1527
 
1528
void ScribusDoc::redefineCharStyles(const StyleSet<CharStyle>& newStyles, bool removeUnused)
1529
{
1530
        docCharStyles.redefine(newStyles, false);
1531
        if (removeUnused)
1532
        {
1533
                QMap<QString, QString> deletion;
1534
                QString deflt("");
10400 subik 1535
                for (int i=0; i < docCharStyles.count(); ++i)
7595 avox 1536
                {
1537
                        const QString& nam(docCharStyles[i].name());
1538
                        if (newStyles.find(nam) < 0)
8772 cbradney 1539
                        {
7595 avox 1540
                                deletion[nam] = deflt;
8772 cbradney 1541
                        }
7595 avox 1542
                }
1543
                if (deletion.count() > 0)
1544
                        replaceCharStyles(deletion);
1545
        }
8772 cbradney 1546
        docCharStyles.invalidate();
7595 avox 1547
}
1548
 
16856 craig 1549
void ScribusDoc::redefineTableStyles(const StyleSet<TableStyle>& newStyles, bool removeUnused)
1550
{
1551
        docTableStyles.redefine(newStyles, false);
1552
        if (removeUnused)
1553
        {
1554
                QMap<QString, QString> deletion;
1555
                QString deflt("");
1556
                for (int i = 0; i < docTableStyles.count(); ++i)
1557
                {
1558
                        const QString& nam(docTableStyles[i].name());
1559
                        if (newStyles.find(nam) < 0)
1560
                        {
1561
                                deletion[nam] = deflt;
1562
                        }
1563
                }
1564
                if (deletion.count() > 0)
1565
                        replaceTableStyles(deletion);
1566
        }
1567
        docTableStyles.invalidate();
1568
}
8274 tsoots 1569
 
16856 craig 1570
void ScribusDoc::redefineCellStyles(const StyleSet<CellStyle>& newStyles, bool removeUnused)
1571
{
1572
        docCellStyles.redefine(newStyles, false);
1573
        if (removeUnused)
1574
        {
1575
                QMap<QString, QString> deletion;
1576
                QString deflt("");
1577
                for (int i = 0; i < docCellStyles.count(); ++i)
1578
                {
1579
                        const QString& nam(docCellStyles[i].name());
1580
                        if (newStyles.find(nam) < 0)
1581
                        {
1582
                                deletion[nam] = deflt;
1583
                        }
1584
                }
1585
                if (deletion.count() > 0)
1586
                        replaceCellStyles(deletion);
1587
        }
1588
        docCellStyles.invalidate();
1589
}
1590
 
456 fschmid 1591
/*
1592
 * Split out from loadStyles in editFormats.cpp so it's callable from anywhere,
1593
 * including plugins.
1594
 * - 2004-09-14 Craig Ringer
1595
 */
8455 avox 1596
// dont like this here. could as well be a static method for reading this stuff into temp., then always use redefineXY() - av
12548 pierre 1597
void ScribusDoc::loadStylesFromFile(QString fileName)
1598
{
1599
        StyleSet<ParagraphStyle> *wrkStyles     = &docParagraphStyles;
1600
        StyleSet<CharStyle> *wrkCharStyles      = &docCharStyles;
17400 fschmid 1601
        QHash<QString, multiLine> *wrkLineStyles = &MLineStyles;
12548 pierre 1602
 
1603
        int oldStyles = wrkStyles->count();
1604
        int oldCharStyles = wrkCharStyles->count();
1605
        int oldLineStyles = wrkLineStyles->count();
1606
 
1607
        if (!fileName.isEmpty())
1608
        {
1609
                FileLoader fl(fileName);
17326 jghali 1610
                if (fl.testFile() == -1)
12548 pierre 1611
                //TODO put in nice user warning
1612
                        return;
1613
 
17326 jghali 1614
                if (!fl.readStyles(this, *wrkStyles))
12548 pierre 1615
                {
1616
                        //TODO put in nice user warning
1617
                }
1618
 
17326 jghali 1619
                if (!fl.readCharStyles(this, *wrkCharStyles))
12548 pierre 1620
                {
1621
                        //TODO put in nice user warning
1622
                }
1623
 
17326 jghali 1624
                if (!fl.readLineStyles(wrkLineStyles))
12548 pierre 1625
                {
1626
                        //TODO put in nice user warning
1627
                }
1628
 
1629
                if ( !isLoading() && ((wrkStyles->count() > oldStyles)
1630
                                    || (wrkCharStyles->count() > oldCharStyles)
1631
                                    || (wrkLineStyles->count() > oldLineStyles) ) )
1632
                        changed();
1633
        }
1634
}
1635
 
8274 tsoots 1636
void ScribusDoc::loadStylesFromFile(QString fileName, StyleSet<ParagraphStyle> *tempStyles,
1637
                                                      StyleSet<CharStyle> *tempCharStyles,
17400 fschmid 1638
                                                                                                          QHash<QString, multiLine> *tempLineStyles)
456 fschmid 1639
{
12548 pierre 1640
        StyleSet<ParagraphStyle> *wrkStyles     = tempStyles;
1641
        StyleSet<CharStyle> *wrkCharStyles      = tempCharStyles;
17400 fschmid 1642
        QHash<QString, multiLine> *wrkLineStyles = tempLineStyles;
8916 avox 1643
 
456 fschmid 1644
        if (!fileName.isEmpty())
1645
        {
5642 cbradney 1646
                FileLoader fl(fileName);
17326 jghali 1647
                if (fl.testFile() == -1)
5642 cbradney 1648
                //TODO put in nice user warning
1649
                        return;
5980 avox 1650
 
17326 jghali 1651
                if (!fl.readStyles(this, *wrkStyles))
456 fschmid 1652
                {
8274 tsoots 1653
                        //TODO put in nice user warning
456 fschmid 1654
                }
8274 tsoots 1655
 
17326 jghali 1656
                if (!fl.readCharStyles(this, *wrkCharStyles))
8274 tsoots 1657
                {
1658
                        //TODO put in nice user warning
1659
                }
1660
 
17326 jghali 1661
                if (!fl.readLineStyles(wrkLineStyles))
8274 tsoots 1662
                {
1663
                        //TODO put in nice user warning
1664
                }
12550 pierre 1665
 
1666
                // Which are the default styles 
1667
                // Sadly StyleSet is not updated at import
1668
                // and it might break something to do so. 
1669
                // We need to loop then - pm
1670
//              ParagraphStyle* parDefault(wrkStyles->getDefault());
1671
//              CharStyle* charDefault(wrkCharStyles->getDefault());
1672
 
1673
                QFileInfo fi(fileName);
1674
                QString importPrefix(tr("Imported ","Prefix of imported default style"));
1675
                QString importSuffix(" (" +  fi.baseName() + ")");
1676
 
19429 jghali 1677
                for (int j(0) ; j < wrkStyles->count() ; ++j)
12550 pierre 1678
                {
19429 jghali 1679
                        if ((*wrkStyles)[j].isDefaultStyle())
12550 pierre 1680
                        {
1681
                                ParagraphStyle& parDefault((*wrkStyles)[j]);
1682
                                parDefault.setDefaultStyle(false);
1683
                                QMap<QString, QString> namesMap;
1684
                                namesMap[parDefault.name()] = importPrefix + parDefault.name() + importSuffix;
19429 jghali 1685
                                for (int i(0) ; i < wrkStyles->count() ; ++i)
12550 pierre 1686
                                {
19429 jghali 1687
                                        if ((*wrkStyles)[i] != parDefault)
12550 pierre 1688
                                                namesMap[(*wrkStyles)[i].name()] = (*wrkStyles)[i].name();
1689
                                }
1690
                                wrkStyles->rename(namesMap);
1691
                        }
1692
                }
19429 jghali 1693
                for (int j(0) ; j < wrkCharStyles->count() ; ++j)
12550 pierre 1694
                {
19429 jghali 1695
                        if ((*wrkCharStyles)[j].isDefaultStyle())
12550 pierre 1696
                        {
1697
                                CharStyle& charDefault((*wrkCharStyles)[j]);
1698
                                charDefault.setDefaultStyle(false);
1699
                                QMap<QString, QString> namesMap;
1700
                                namesMap[charDefault.name()] = importPrefix + charDefault.name() + importSuffix;
19429 jghali 1701
                                for (int i(0) ; i < wrkCharStyles->count() ; ++i)
12550 pierre 1702
                                {
19429 jghali 1703
                                        if ((*wrkCharStyles)[i] != charDefault)
12550 pierre 1704
                                                namesMap[(*wrkCharStyles)[i].name()] = (*wrkCharStyles)[i].name();
1705
                                }
1706
                                wrkCharStyles->rename(namesMap);
1707
                        }
1708
                }
456 fschmid 1709
        }
1710
}
1711
 
10532 avox 1712
 
1179 tsoots 1713
void ScribusDoc::lockGuides(bool isLocked)
1714
{
1180 tsoots 1715
        if (GuideLock == isLocked)
1716
                return;
1179 tsoots 1717
        GuideLock = isLocked;
1718
        if (UndoManager::undoEnabled())
1719
        {
1720
                QString name;
1721
                if (isLocked)
1190 tsoots 1722
                        name = Um::LockGuides;
1179 tsoots 1723
                else
1190 tsoots 1724
                        name = Um::UnlockGuides;
1725
                SimpleState *ss = new SimpleState(name, "", Um::ILockGuides);
1179 tsoots 1726
                ss->set("GUIDE_LOCK", isLocked);
1727
                undoManager->action(this, ss);
1728
        }
1729
}
1730
 
13349 jghali 1731
void ScribusDoc::undoRedoBegin()
1732
{
14370 jghali 1733
        m_docUpdater->beginUpdate();
13349 jghali 1734
        m_Selection->delaySignalsOn();
1735
}
10532 avox 1736
 
13349 jghali 1737
void ScribusDoc::undoRedoDone()
1738
{
1739
        m_Selection->delaySignalsOff();
14370 jghali 1740
        m_docUpdater->endUpdate();
13349 jghali 1741
}
1742
 
1179 tsoots 1743
void ScribusDoc::restore(UndoState* state, bool isUndo)
1744
{
1745
        SimpleState *ss = dynamic_cast<SimpleState*>(state);
1746
        if (ss)
1747
        {
2941 cbradney 1748
                bool layersUndo=false;
13331 jghali 1749
 
13194 jghali 1750
                if (ss->contains("GROUP"))
1751
                        restoreGrouping(ss, isUndo);
1752
                else if (ss->contains("UNGROUP"))
17644 craig 1753
                        restoreGrouping(ss, !isUndo);
13194 jghali 1754
                else if (ss->contains("GUIDE_LOCK"))
1179 tsoots 1755
                {
1756
                        if (isUndo)
1757
                                GuideLock = !ss->getBool("GUIDE_LOCK");
1758
                        else
3201 subik 1759
                                GuideLock = ss->getBool("GUIDE_LOCK");
1179 tsoots 1760
                }
2937 cbradney 1761
                else if (ss->contains("UP_LAYER"))
1762
                {
1763
                        if (isUndo)
1764
                                lowerLayer(ss->getInt("ACTIVE"));
1765
                        else
1766
                                raiseLayer(ss->getInt("ACTIVE"));
2941 cbradney 1767
                        layersUndo=true;
2937 cbradney 1768
                }
1769
                else if (ss->contains("DOWN_LAYER"))
1770
                {
1771
                        if (isUndo)
1772
                                raiseLayer(ss->getInt("ACTIVE"));
1773
                        else
1774
                                lowerLayer(ss->getInt("ACTIVE"));
2941 cbradney 1775
                        layersUndo=true;
2937 cbradney 1776
                }
1777
                else if (ss->contains("PRINT_LAYER"))
1778
                {
1779
                        bool print = ss->getBool("PRINT");
1780
                        setLayerPrintable(ss->getInt("ACTIVE"), isUndo ? !print : print);
2941 cbradney 1781
                        layersUndo=true;
2937 cbradney 1782
                }
16497 craig 1783
                else if (ss->contains("LAYER_FLOW"))
16492 craig 1784
                {
1785
                        bool flow = ss->getBool("FLOW");
1786
                        setLayerFlow(ss->getInt("ACTIVE"), isUndo ? !flow : flow);
1787
                        layersUndo=true;
1788
                }
16499 craig 1789
                else if (ss->contains("LAYER_LOCK"))
1790
                {
1791
                        bool lock = ss->getBool("LOCK");
1792
                        setLayerLocked(ss->getInt("ACTIVE"), isUndo ? !lock : lock);
1793
                        layersUndo=true;
1794
                }
16497 craig 1795
                else if (ss->contains("LAYER_TRANSPARENCY"))
1796
                {
1797
                        double old_trans = ss->getDouble("OLD_TRANS");
1798
                        double new_trans = ss->getDouble("NEW_TRANS");
1799
                        setLayerTransparency(ss->getInt("ACTIVE"), isUndo ? old_trans : new_trans);
1800
                        layersUndo=true;
1801
                }
1802
                else if (ss->contains("LAYER_BLENDMODE"))
1803
                {
1804
                        int old_blend = ss->getInt("OLD_BLENDMODE");
1805
                        int new_blend = ss->getInt("NEW_BLENDMODE");
1806
                        setLayerBlendMode(ss->getInt("ACTIVE"), isUndo ? old_blend : new_blend);
1807
                        layersUndo=true;
1808
                }
2937 cbradney 1809
                else if (ss->contains("ADD_LAYER"))
1810
                {
1811
                        if (isUndo)
2944 cbradney 1812
                                deleteLayer(ss->getInt("LAYER_NR"), false);
2937 cbradney 1813
                        else
1814
                        {
13875 jghali 1815
                                int layerID=addLayer( ss->get("NAME"), false );
1816
                                int newLayerID=ss->getInt("LAYER_NR");
1817
                                bool renumberedOk=renumberLayer(layerID, newLayerID);
2944 cbradney 1818
                                Q_ASSERT(renumberedOk);
2937 cbradney 1819
                        }
2944 cbradney 1820
                        layersUndo=true;
2937 cbradney 1821
                }
1822
                else if (ss->contains("REMOVE_LAYER"))
1823
                {
1824
                        if (isUndo)
1825
                        {
13875 jghali 1826
                                int layerID=addLayer( ss->get("NAME"), false );
1827
                                int newLayerID=ss->getInt("LAYER_NR");
1828
                                bool renumberedOk=renumberLayer(layerID, newLayerID);
2944 cbradney 1829
                                Q_ASSERT(renumberedOk);
13875 jghali 1830
                                layerID=newLayerID;
2944 cbradney 1831
                                //Layer is at the top now, lower it until it reaches the old level
2937 cbradney 1832
                                int level = ss->getInt("LEVEL");
13875 jghali 1833
                                while (layerLevelFromID(layerID)!=level)
1834
                                        lowerLayer(layerID);
2937 cbradney 1835
                        }
1836
                        else
2944 cbradney 1837
                                deleteLayer(ss->getInt("LAYER_NR"), ss->getBool("DELETE"));
1838
                        layersUndo=true;
2937 cbradney 1839
                }
1840
                else if (ss->contains("CHANGE_NAME"))
1841
                {
1842
                        QString name = ss->get("OLD_NAME");
1843
                        if (!isUndo)
1844
                                name = ss->get("NEW_NAME");
2938 cbradney 1845
                        changeLayerName(ss->getInt("ACTIVE"), name);
2941 cbradney 1846
                        layersUndo=true;
1847
                }
19356 jghali 1848
                else if (ss->contains("MASTERPAGE_ADD"))
1849
                        restoreAddMasterPage(ss, isUndo);
1850
                else if (ss->contains("MASTERPAGE_RENAME"))
1851
                        restoreMasterPageRenaming(ss, isUndo);
3004 cbradney 1852
                else if (ss->contains("OLD_MASTERPAGE"))
1853
                        restoreMasterPageApplying(ss, isUndo);
17213 craig 1854
                else if (ss->contains("PAGE_COPY"))
1855
                        restoreCopyPage(ss, isUndo);
1856
                else if (ss->contains("PAGE_MOVE"))
1857
                        restoreMovePage(ss, isUndo);
17640 craig 1858
                else if (ss->contains("LEVEL_DOWN"))
1859
                        restoreLevelDown(ss,isUndo);
1860
                else if (ss->contains("LEVEL_UP"))
1861
                        restoreLevelDown(ss,!isUndo);
1862
                else if (ss->contains("LEVEL_BOTTOM"))
1863
                        restoreLevelBottom(ss,isUndo);
1864
                else if (ss->contains("LEVEL_TOP"))
1865
                        restoreLevelBottom(ss,!isUndo);
16509 craig 1866
                else if (ss->contains("PAGE_CHANGEPROPS"))
1867
                {
1868
                        if (isUndo)
1869
                        {
1870
                                changePageMargins(ss->getDouble("OLD_PAGE_INITIALTOP"), ss->getDouble("OLD_PAGE_INITIALBOTTOM"),
1871
                                                ss->getDouble("OLD_PAGE_INITIALLEFT"), ss->getDouble("OLD_PAGE_INITIALRIGHT"),
1872
                                                ss->getDouble("OLD_PAGE_INITIALHEIGHT"), ss->getDouble("OLD_PAGE_INITIALWIDTH"),
1873
                                                ss->getDouble("OLD_PAGE_HEIGHT"), ss->getDouble("OLD_PAGE_WIDTH"), ss->getInt("OLD_PAGE_ORIENTATION"),
1874
                                                ss->get("OLD_PAGE_SIZE"), ss->getInt("OLD_PAGE_MARGINPRESET"), ss->getBool("OLD_PAGE_MOVEOBJECTS"), ss->getInt("PAGE_NUM"), ss->getInt("OLD_PAGE_TYPE"));
1875
                        }
1876
                        else
1877
                        {
1878
                                changePageMargins(ss->getDouble("NEW_PAGE_INITIALTOP"), ss->getDouble("NEW_PAGE_INITIALBOTTOM"),
1879
                                                ss->getDouble("NEW_PAGE_INITIALLEFT"), ss->getDouble("NEW_PAGE_INITIALRIGHT"),
1880
                                                ss->getDouble("NEW_PAGE_INITIALHEIGHT"), ss->getDouble("NEW_PAGE_INITIALWIDTH"),
1881
                                                ss->getDouble("NEW_PAGE_HEIGHT"), ss->getDouble("NEW_PAGE_WIDTH"), ss->getInt("NEW_PAGE_ORIENTATION"),
1882
                                                ss->get("NEW_PAGE_SIZE"), ss->getInt("NEW_PAGE_MARGINPRESET"), ss->getBool("OLD_PAGE_MOVEOBJECTS"), ss->getInt("PAGE_NUM"), ss->getInt("NEW_PAGE_TYPE"));
1883
                        }
1884
                }
17826 craig 1885
                else if (ss->contains("DELETE_FRAMETEXT"))
1886
                {
1887
                        PageItem * nF = getItemFromName(ss->get("noteframeName"));
1888
                        Q_ASSERT(nF != NULL);
1889
                        nF->asNoteFrame()->restoreDeleteNoteText(ss, isUndo);
1890
                }
1891
                else if (ss->contains("INSERT_FRAMETEXT"))
1892
                {
1893
                        PageItem * nF = getItemFromName(ss->get("noteframeName"));
1894
                        Q_ASSERT(nF != NULL);
1895
                        nF->asNoteFrame()->restoreInsertNoteText(ss,isUndo);
1896
                }
1897
                else if (ss->contains("NSTYLE"))
1898
                {
1899
                        NotesStyle* NS = NULL;
1900
                        if ((ss->get("NSTYLE") == "new" && isUndo) || (ss->get("NSTYLE") == "delete" && !isUndo))
1901
                                deleteNotesStyle(ss->get("name"));
1902
                        else if ((ss->get("NSTYLE") == "new" && !isUndo) || (ss->get("NSTYLE") == "delete" && isUndo))
1903
                        {
1904
                                NS = new NotesStyle();
1905
                                NS->setName(ss->get("name"));
1906
                                NS->setStart(ss->getInt("start"));
1907
                                NS->setEndNotes(ss->getBool("endNotes"));
18047 craig 1908
                                NS->setType((NumFormat) ss->getInt("numFormat"));
17826 craig 1909
                                NS->setRange((NumerationRange) ss->getInt("range"));
1910
                                NS->setPrefix(ss->get("prefix"));
1911
                                NS->setSuffix(ss->get("suffix"));
1912
                                NS->setAutoNotesHeight(ss->getBool("autoH"));
1913
                                NS->setAutoNotesWidth(ss->getBool("autoW"));
1914
                                NS->setAutoWeldNotesFrames(ss->getBool("autoWeld"));
1915
                                NS->setAutoRemoveEmptyNotesFrames(ss->getBool("autoRemove"));
1916
                                NS->setSuperscriptInMaster(ss->getBool("superMaster"));
1917
                                NS->setSuperscriptInNote(ss->getBool("superNote"));
1918
                                NS->setMarksCharStyle(ss->get("marksChStyle"));
1919
                                NS->setNotesParStyle(ss->get("notesParStyle"));
1920
                                m_docNotesStylesList.append(NS);
1921
                                scMW()->emitUpdateRequest(reqMarksUpdate);
1922
                        }
1923
                        else if (ss->get("NSTYLE") == "edit")
1924
                        {
1925
                                if (isUndo)
1926
                                        NS = getNotesStyle(ss->get("NEWname"));
1927
                                else
1928
                                        NS = getNotesStyle(ss->get("name"));
1929
                                Q_ASSERT(NS != NULL);
1930
                                //check if Notes Style change form footnotes to endnotes or range of numeration was changed
1931
                                //if use delete all notes frames with current style
1932
                                bool delNF = false;
1933
                                if (ss->getBool("NEWendNotes") != ss->getBool("endNotes")
1934
                                        || ((isUndo && (ss->getBool("endNotes") && (NumerationRange) ss->getInt("range") != (NumerationRange) ss->getInt("NEWrange")))
1935
                                        || (!isUndo && (ss->getBool("NEWendNotes") && ((NumerationRange) ss->getInt("NEWrange") != (NumerationRange) ss->getInt("range"))))))
1936
                                                delNF = true;
1937
                                if (delNF)
1938
                                {
1939
                                        foreach (PageItem_NoteFrame* nF, listNotesFrames(NS))
1940
                                                delNoteFrame(nF, false);
1941
                                        flag_updateEndNotes = NS->isEndNotes();
1942
                                }
1943
                                if (isUndo)
1944
                                {
1945
                                        NS->setName(ss->get("name"));
1946
                                        NS->setStart(ss->getInt("start"));
1947
                                        NS->setRange((NumerationRange) ss->getInt("range"));
1948
                                        NS->setEndNotes(ss->getBool("endNotes"));
18047 craig 1949
                                        NS->setType((NumFormat) ss->getInt("numFormat"));
17826 craig 1950
                                        NS->setPrefix(ss->get("prefix"));
1951
                                        NS->setSuffix(ss->get("suffix"));
1952
                                        NS->setAutoNotesHeight(ss->getBool("autoH"));
1953
                                        NS->setAutoNotesWidth(ss->getBool("autoW"));
1954
                                        NS->setAutoWeldNotesFrames(ss->getBool("autoWeld"));
1955
                                        NS->setAutoRemoveEmptyNotesFrames(ss->getBool("autoRemove"));
1956
                                        NS->setSuperscriptInMaster(ss->getBool("superMaster"));
1957
                                        NS->setSuperscriptInNote(ss->getBool("superNote"));
1958
                                        NS->setMarksCharStyle(ss->get("marksChStyle"));
1959
                                        NS->setNotesParStyle(ss->get("notesParStyle"));
1960
                                }
1961
                                else
1962
                                {
1963
                                        NS->setName(ss->get("NEWname"));
1964
                                        NS->setStart(ss->getInt("NEWstart"));
1965
                                        NS->setRange((NumerationRange) ss->getInt("NEWrange"));
1966
                                        NS->setEndNotes(ss->getBool("NEWendNotes"));
18047 craig 1967
                                        NS->setType((NumFormat) ss->getInt("NEWnumFormat"));
17826 craig 1968
                                        NS->setPrefix(ss->get("NEWprefix"));
1969
                                        NS->setSuffix(ss->get("NEWsuffix"));
1970
                                        NS->setAutoNotesHeight(ss->getBool("NEWautoH"));
1971
                                        NS->setAutoNotesWidth(ss->getBool("NEWautoW"));
1972
                                        NS->setAutoWeldNotesFrames(ss->getBool("NEWautoWeld"));
1973
                                        NS->setAutoRemoveEmptyNotesFrames(ss->getBool("NEWautoRemove"));
1974
                                        NS->setSuperscriptInMaster(ss->getBool("NEWsuperMaster"));
1975
                                        NS->setSuperscriptInNote(ss->getBool("NEWsuperNote"));
1976
                                        NS->setMarksCharStyle(ss->get("NEWmarksChStyle"));
1977
                                        NS->setNotesParStyle(ss->get("NEWnotesParStyle"));
1978
                                }
1979
                                setNotesChanged(true);
1980
                                if ((ss->get("marksChStyle") != ss->get("NEWmarksChStyle"))
1981
                                        || (ss->getBool("superMaster") != ss->getBool("NEWsuperMaster")))
1982
                                        invalidateMasterFrames(NS);
1983
                                updateNotesNums(NS);
1984
                                updateNotesFramesSettings(NS);
1985
                                if (flag_updateEndNotes)
1986
                                        updateEndnotesFrames(NS, true);
1987
                                updateNotesFramesStyles(NS);
1988
                                if (notesChanged())
1989
                                {
1990
                                        flag_updateMarksLabels = true;
1991
                                        changed();
1992
                                        regionsChanged()->update(QRectF());
1993
                                }
1994
                        }
1995
                        if (NS != NULL)
1996
                                scMW()->nsEditor->setNotesStyle(NS);
1997
                        else
1998
                                scMW()->nsEditor->updateNSList();
1999
                }
2000
                else if (ss->contains("DELETE_NOTE"))
2001
                {
2002
                        ScItemsState *is = dynamic_cast<ScItemsState*>(state);
2003
                        if (is)
2004
                        {
2005
                                NotesStyle* nStyle = getNotesStyle(is->get("nStyle"));
2006
                                PageItem* master = NULL;
2007
                                if (is->contains("noteframeName"))
2008
                                        master = getItemFromName(is->get("noteframeName"));
2009
                                else
2010
                                        master = (PageItem*) is->getItem("inItem");
2011
                                if (isUndo)
2012
                                {
2013
                                        TextNote* note = newNote(nStyle);
2014
                                        Mark* mrk = newMark();
2015
                                        mrk->setType(MARKNoteMasterType);
2016
                                        mrk->setNotePtr(note);
2017
                                        note->setMasterMark(mrk);
2018
                                        note->setSaxedText(is->get("noteTXT"));
2019
                                        master->itemText.insertMark(mrk, is->getInt("at"));
2020
                                        master->invalid = true;
2021
                                        if (!nStyle->isAutoRemoveEmptyNotesFrames())
2022
                                        {
2023
                                                PageItem_NoteFrame* nF = (PageItem_NoteFrame*) is->getItem("noteframe");
2024
                                                Q_ASSERT(nF != NULL);
2025
                                                master->asTextFrame()->setNoteFrame(nF);
2026
                                        }
2027
                                        setNotesChanged(true);
2028
                                        if (note->isEndNote())
2029
                                                flag_updateEndNotes = true;
2030
                                }
2031
                                else
2032
                                {
19582 craig 2033
                                        TextNote* note = master->itemText.mark(is->getInt("at"))->getNotePtr();
17826 craig 2034
                                        if (note->isEndNote())
2035
                                                flag_updateEndNotes = true;
2036
                                        deleteNote(note);
2037
                                }
2038
                                master->invalidateLayout();
2039
                                master->updateLayout();
2040
                        }
2041
                }
2042
                else if (ss->contains("MARK"))
2043
                {
2044
                        ScItemsState *is = dynamic_cast<ScItemsState*>(state);
2045
                        if (is)
2046
                        {
2047
                                Mark* mrk = getMarkDefinied(is->get("label"), (MarkType) is->getInt("type"));
2048
                                if (mrk == NULL && is->contains("labelOLD"))
2049
                                        mrk = getMarkDefinied(is->get("labelOLD"), (MarkType) is->getInt("type"));
2050
                                int pos = is->getInt("at");
2051
                                bool isAutoNoteFrame = false;
2052
                                PageItem* currItem = NULL;
2053
                                if (is->contains("noteframeName"))
2054
                                {
2055
                                        currItem = getItemFromName(is->get("noteframeName"));
2056
                                        if (currItem != NULL)
2057
                                                isAutoNoteFrame = currItem->asNoteFrame()->isAutoFrame();
2058
                                }
2059
                                else
2060
                                        currItem = (PageItem*) is->getItem("inItem");
2061
                                if (isUndo)
2062
                                {
2063
                                        if (is->get("MARK") == "new")
2064
                                        {
2065
                                                Q_ASSERT(mrk != NULL);
2066
                                                if (mrk->isNoteType())
2067
                                                {
2068
                                                        TextNote* note = mrk->getNotePtr();
2069
                                                        NotesStyle* nStyle = note->notesStyle();
2070
                                                        if (note->isEndNote())
2071
                                                                flag_updateEndNotes = true;
2072
                                                        deleteNote(note);
2073
                                                        updateNotesNums(nStyle);
2074
                                                }
2075
                                                else
2076
                                                        eraseMark(mrk, true, currItem, true);
2077
                                        }
2078
                                        else if (is->get("MARK") == "replace")
2079
                                        {
2080
                                                Q_ASSERT(pos >= 0);
2081
                                                Q_ASSERT(currItem != NULL);
2082
                                                Q_ASSERT(mrk != NULL);
2083
                                                Mark* mrk = getMarkDefinied(is->get("label"), (MarkType) is->getInt("type"));
19582 craig 2084
                                                currItem->itemText.replaceMark(pos, mrk);
17826 craig 2085
                                                if (is->contains("strtxtOLD"))
2086
                                                {
2087
                                                        mrk->setString(is->get("strtxtOLD"));
2088
                                                        invalidateVariableTextFrames(mrk, false);
2089
                                                }
2090
                                                if (is->contains("labelOLD"))
2091
                                                        mrk->label = is->get("labelOLD");
2092
                                        }
2093
                                        else if (is->get("MARK") == "edit")
2094
                                        {
2095
                                                Q_ASSERT(mrk != NULL);
2096
                                                if (is-