Subversion Repositories Scribus

Rev

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