Subversion Repositories Scribus

Rev

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