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