Subversion Repositories Scribus

Rev

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