Subversion Repositories Scribus

Rev

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