Subversion Repositories Scribus

Rev

Rev 23162 | Rev 23174 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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