Subversion Repositories Scribus

Rev

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