Subversion Repositories Scribus

Rev

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