Subversion Repositories Scribus

Rev

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