Subversion Repositories Scribus

Rev

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

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