Rev 10255 | Rev 10727 | 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 | ***************************************************************************/ |
||
3120 | fschmid | 23 | #include "scribusdoc.moc" |
2952 | cbradney | 24 | #include "scribus.h" |
25 | #include "scribusapp.h" |
||
3 | paul | 26 | #include "scribusdoc.h" |
4320 | cbradney | 27 | #include "scribusview.h" |
28 | #include "scribuswin.h" |
||
410 | Franz | 29 | #include "scribusXml.h" |
2016 | cbradney | 30 | |
6071 | jghali | 31 | #include <assert.h> |
3670 | cbradney | 32 | #include <utility> |
2016 | cbradney | 33 | #include <qfile.h> |
3942 | cbradney | 34 | #include <qprogressbar.h> |
2016 | cbradney | 35 | |
3757 | cbradney | 36 | #include "filewatcher.h" |
4584 | cbradney | 37 | //CBVTD |
38 | #include "hruler.h" |
||
3757 | cbradney | 39 | #include "hyphenator.h" |
40 | #include "layers.h" |
||
456 | fschmid | 41 | #include "page.h" |
42 | #include "pageitem.h" |
||
3617 | cbradney | 43 | #include "pageitem_imageframe.h" |
44 | #include "pageitem_line.h" |
||
45 | #include "pageitem_pathtext.h" |
||
46 | #include "pageitem_polygon.h" |
||
47 | #include "pageitem_polyline.h" |
||
48 | #include "pageitem_textframe.h" |
||
3757 | cbradney | 49 | #include "pagestructs.h" |
50 | #include "prefsmanager.h" |
||
4705 | cbradney | 51 | #include "scmessagebox.h" |
4584 | cbradney | 52 | #include "scfontmetrics.h" |
4688 | cbradney | 53 | #include "scraction.h" |
3903 | cbradney | 54 | #include "selection.h" |
4707 | cbradney | 55 | #include "story.h" |
56 | #include "tree.h" |
||
1179 | tsoots | 57 | #include "undomanager.h" |
58 | #include "undostate.h" |
||
2965 | cbradney | 59 | #include "units.h" |
3809 | cbradney | 60 | #include "util.h" |
4546 | subik | 61 | #include "commonstrings.h" |
410 | Franz | 62 | |
3205 | craig | 63 | |
2952 | cbradney | 64 | extern ScribusQApp* ScQApp; |
2016 | cbradney | 65 | |
2891 | cbradney | 66 | #ifdef HAVE_CMS |
6071 | jghali | 67 | #include "cmsutil.h" |
5177 | mrdocs | 68 | #include "cmserrorhandling.h" |
2891 | cbradney | 69 | extern cmsHPROFILE CMSoutputProf; |
70 | extern cmsHPROFILE CMSprinterProf; |
||
6106 | jghali | 71 | extern cmsHTRANSFORM stdTransRGBDoc2CMYKG; |
72 | extern cmsHTRANSFORM stdTransCMYK2RGBDocG; |
||
73 | extern cmsHTRANSFORM stdTransRGBDoc2MonG; |
||
74 | extern cmsHTRANSFORM stdTransCMYK2MonG; |
||
75 | extern cmsHTRANSFORM stdProofRGBG; |
||
76 | extern cmsHTRANSFORM stdProofRGBGCG; |
||
77 | extern cmsHTRANSFORM stdProofCMYKG; |
||
78 | extern cmsHTRANSFORM stdProofCMYKGCG; |
||
2891 | cbradney | 79 | extern cmsHTRANSFORM stdTransImgG; |
80 | extern cmsHTRANSFORM stdProofImgG; |
||
81 | extern bool BlackPoint; |
||
82 | extern bool SoftProofing; |
||
83 | extern bool Gamut; |
||
84 | extern bool CMSuse; |
||
85 | extern int IntentMonitor; |
||
86 | extern int IntentPrinter; |
||
87 | #endif |
||
88 | |||
89 | extern bool CMSavail; |
||
1179 | tsoots | 90 | extern QPixmap loadIcon(QString nam); |
91 | |||
3983 | craig | 92 | ScribusDoc::ScribusDoc() : UndoObject( tr("Document")), |
93 | prefsData(PrefsManager::instance()->appPrefs), |
||
94 | undoManager(UndoManager::instance()), |
||
95 | loading(false), |
||
96 | modified(false), |
||
97 | ActiveLayer(0), |
||
98 | docUnitIndex(prefsData.docUnitIndex), |
||
99 | docUnitRatio(unitGetRatioFromIndex(docUnitIndex)), |
||
100 | automaticTextFrames(0), |
||
101 | m_masterPageMode(false), |
||
102 | is12doc(false), |
||
103 | NrItems(0), |
||
104 | First(1), Last(0), |
||
105 | viewCount(0), viewID(0), |
||
106 | SnapGuides(false), GuideLock(false), |
||
107 | ScratchLeft(prefsData.ScratchLeft), |
||
108 | ScratchRight(prefsData.ScratchRight), |
||
109 | ScratchTop(prefsData.ScratchTop), |
||
110 | ScratchBottom(prefsData.ScratchBottom), |
||
111 | minCanvasCoordinate(FPoint(0, 0)), |
||
112 | maxCanvasCoordinate(FPoint(ScratchLeft + ScratchRight, ScratchTop + ScratchBottom)), |
||
113 | rulerXoffset(0.0), rulerYoffset(0.0), |
||
3984 | craig | 114 | Pages(0), MasterPages(), DocPages(), |
3983 | craig | 115 | MasterNames(), |
3984 | craig | 116 | Items(0), MasterItems(), DocItems(), FrameItems(), |
4847 | cbradney | 117 | m_Selection(new Selection(this, true)), |
4069 | craig | 118 | pageWidth(0), pageHeight(0), |
119 | // pageCount(0) CR |
||
3983 | craig | 120 | // pageMargins |
121 | pageSets(prefsData.pageSets), |
||
122 | PageSp(1), PageSpa(0), |
||
123 | currentPageLayout(0), |
||
124 | PageOri(0), PageSize(0), |
||
125 | FirstPnum(1), |
||
126 | useRaster(false), |
||
127 | currentPage(0), |
||
128 | // documentInfo |
||
129 | appMode(modeNormal), |
||
130 | SubMode(-1), |
||
131 | ShapeValues(0), |
||
132 | ValCount(0), |
||
7121 | fschmid | 133 | DocName( tr("Document")+"-"), |
3983 | craig | 134 | UsedFonts(), |
135 | AllFonts(&prefsData.AvailFonts), |
||
136 | AObjects(), |
||
137 | papColor(prefsData.DpapColor), |
||
138 | CurrentSel(-1), |
||
139 | CurrentStyle(0), currentParaStyle(0), |
||
140 | // CurrFont, blah blah to CurrTextStrikeWidth are poked externally |
||
141 | EditClip(false), |
||
142 | EditClipMode(0), |
||
143 | typographicSettings(prefsData.typographicSettings), |
||
144 | guidesSettings(prefsData.guidesSettings), |
||
145 | toolSettings(prefsData.toolSettings), |
||
146 | checkerProfiles(prefsData.checkerProfiles), |
||
147 | curCheckProfile(prefsData.curCheckProfile), |
||
148 | LastAuto(0), FirstAuto(0), |
||
149 | // DragP, leaveDrag |
||
150 | DraggedElem(0), |
||
151 | ElemToLink(0), |
||
152 | DragElements(), |
||
153 | docParagraphStyles(), |
||
154 | Layers(), |
||
155 | marginColored(prefsData.marginColored), |
||
156 | GroupCounter(1), |
||
157 | // CMSSettings, HasCMS, etc done by setup() |
||
158 | JavaScripts(), |
||
159 | TotalItems(0), |
||
160 | MinWordLen(prefsData.MinWordLen), |
||
161 | HyCount(prefsData.HyCount), |
||
162 | Language(prefsData.Language), |
||
163 | Automatic(prefsData.Automatic), |
||
164 | AutoCheck(prefsData.AutoCheck), |
||
165 | PDF_Options(prefsData.PDF_Options), |
||
166 | RePos(false), |
||
167 | BookMarks(), |
||
168 | OldBM(false), |
||
169 | hasName(false), |
||
170 | RotMode(0), |
||
171 | AutoSave(prefsData.AutoSave), |
||
172 | AutoSaveTime(prefsData.AutoSaveTime), |
||
173 | autoSaveTimer(new QTimer(this)), |
||
174 | // library |
||
175 | FFonts(), |
||
176 | MLineStyles(), |
||
177 | arrowStyles(prefsData.arrowStyles), |
||
178 | WinHan(0), |
||
179 | DoDrawing(true), |
||
180 | OpenNodes(), |
||
181 | CurTimer(0), |
||
182 | docItemErrors(), |
||
183 | masterItemErrors(), |
||
184 | docItemAttributes(prefsData.defaultItemAttributes), |
||
185 | docToCSetups(prefsData.defaultToCSetups), |
||
186 | // sections |
||
187 | symReturn(), symNewLine(), symTab(), symNonBreak(), symNewCol(), symNewFrame(), |
||
4026 | craig | 188 | docHyphenator(new Hyphenator(ScMW, this)), // MUST be constructed late |
3983 | craig | 189 | _itemCreationTransactionStarted(false) |
3 | paul | 190 | { |
4847 | cbradney | 191 | Q_CHECK_PTR(m_Selection); |
3983 | craig | 192 | Q_CHECK_PTR(docHyphenator); |
193 | Q_CHECK_PTR(autoSaveTimer); |
||
194 | |||
823 | fschmid | 195 | FT_Init_FreeType( &library ); |
3983 | craig | 196 | AddFont(prefsData.toolSettings.defFont);//, prefsData.AvailFonts[prefsData.toolSettings.defFont]->Font); |
197 | toolSettings.defFont = prefsData.toolSettings.defFont; |
||
198 | toolSettings.defSize = prefsData.toolSettings.defSize; |
||
199 | toolSettings.tabFillChar = prefsData.toolSettings.tabFillChar; |
||
9294 | jghali | 200 | PageColors.ensureBlackAndWhite(); |
4546 | subik | 201 | if (prefsData.toolSettings.dPen != CommonStrings::None) |
3983 | craig | 202 | PageColors.insert(prefsData.toolSettings.dPen, prefsData.DColors[prefsData.toolSettings.dPen]); |
203 | toolSettings.dPen = prefsData.toolSettings.dPen; |
||
4546 | subik | 204 | if (prefsData.toolSettings.dPenLine != CommonStrings::None) |
3983 | craig | 205 | PageColors.insert(prefsData.toolSettings.dPenLine, prefsData.DColors[prefsData.toolSettings.dPenLine]); |
206 | toolSettings.dPenLine = prefsData.toolSettings.dPenLine; |
||
4546 | subik | 207 | if (prefsData.toolSettings.dPenText != CommonStrings::None) |
3983 | craig | 208 | PageColors.insert(prefsData.toolSettings.dPenText, prefsData.DColors[prefsData.toolSettings.dPenText]); |
209 | toolSettings.dPenText = prefsData.toolSettings.dPenText; |
||
4546 | subik | 210 | if (prefsData.toolSettings.dStrokeText != CommonStrings::None) |
3983 | craig | 211 | PageColors.insert(prefsData.toolSettings.dStrokeText, prefsData.DColors[prefsData.toolSettings.dStrokeText]); |
212 | toolSettings.dStrokeText = prefsData.toolSettings.dStrokeText; |
||
4546 | subik | 213 | if (prefsData.toolSettings.dBrush != CommonStrings::None) |
3983 | craig | 214 | PageColors.insert(prefsData.toolSettings.dBrush, prefsData.DColors[prefsData.toolSettings.dBrush]); |
215 | toolSettings.dBrush = prefsData.toolSettings.dBrush; |
||
4546 | subik | 216 | if (prefsData.toolSettings.dBrushPict != CommonStrings::None) |
3983 | craig | 217 | PageColors.insert(prefsData.toolSettings.dBrushPict, prefsData.DColors[prefsData.toolSettings.dBrushPict]); |
218 | toolSettings.dBrushPict = prefsData.toolSettings.dBrushPict; |
||
4546 | subik | 219 | if (prefsData.toolSettings.dTextBackGround != CommonStrings::None) |
3983 | craig | 220 | PageColors.insert(prefsData.toolSettings.dTextBackGround, prefsData.DColors[prefsData.toolSettings.dTextBackGround]); |
221 | toolSettings.dTextBackGround = prefsData.toolSettings.dTextBackGround; |
||
4546 | subik | 222 | if (prefsData.toolSettings.dTextLineColor != CommonStrings::None) |
3983 | craig | 223 | PageColors.insert(prefsData.toolSettings.dTextLineColor, prefsData.DColors[prefsData.toolSettings.dTextLineColor]); |
1065 | cbradney | 224 | struct ParagraphStyle vg; |
3 | paul | 225 | vg.Vname = "Normal Internal"; |
2309 | fschmid | 226 | vg.LineSpaMode = 0; |
3 | paul | 227 | vg.LineSpa = 15; |
1065 | cbradney | 228 | vg.textAlignment = 0; |
3 | paul | 229 | vg.Indent = 0; |
230 | vg.First = 0; |
||
1065 | cbradney | 231 | vg.gapBefore = 0; |
232 | vg.gapAfter = 0; |
||
3 | paul | 233 | vg.Font = ""; |
1194 | fschmid | 234 | vg.FontSize = toolSettings.defSize; |
140 | Franz | 235 | vg.TabValues.clear(); |
153 | Franz | 236 | vg.Drop = false; |
237 | vg.DropLin = 2; |
||
2362 | fschmid | 238 | vg.DropDist = 0; |
173 | Franz | 239 | vg.FontEffect = 0; |
9066 | jghali | 240 | vg.FColor = toolSettings.dPenText; |
241 | vg.FShade = toolSettings.dTextPenShade; |
||
242 | vg.SColor = toolSettings.dStrokeText; |
||
243 | vg.SShade = toolSettings.dTextStrokeShade; |
||
241 | Franz | 244 | vg.BaseAdj = false; |
2273 | fschmid | 245 | vg.txtShadowX = 50; |
246 | vg.txtShadowY = -50; |
||
247 | vg.txtOutline = 10; |
||
2889 | cbradney | 248 | vg.txtUnderPos = typographicSettings.valueUnderlinePos; |
249 | vg.txtUnderWidth = typographicSettings.valueUnderlineWidth; |
||
250 | vg.txtStrikePos = typographicSettings.valueStrikeThruPos; |
||
251 | vg.txtStrikeWidth = typographicSettings.valueStrikeThruPos; |
||
2379 | fschmid | 252 | vg.scaleH = 1000; |
253 | vg.scaleV = 1000; |
||
254 | vg.baseOff = 0; |
||
255 | vg.kernVal = 0; |
||
1065 | cbradney | 256 | docParagraphStyles.append(vg); |
3 | paul | 257 | vg.Vname = "Center Internal"; |
1065 | cbradney | 258 | vg.textAlignment = 1; |
259 | docParagraphStyles.append(vg); |
||
3 | paul | 260 | vg.Vname = "Rechts Internal"; |
1065 | cbradney | 261 | vg.textAlignment = 2; |
262 | docParagraphStyles.append(vg); |
||
3 | paul | 263 | vg.Vname = "Block Internal"; |
1065 | cbradney | 264 | vg.textAlignment = 3; |
265 | docParagraphStyles.append(vg); |
||
3 | paul | 266 | vg.Vname = "EBlock Internal"; |
1065 | cbradney | 267 | vg.textAlignment = 4; |
268 | docParagraphStyles.append(vg); |
||
3 | paul | 269 | struct Layer ll; |
270 | ll.LNr = 0; |
||
271 | ll.Level = 0; |
||
3173 | fschmid | 272 | ll.Name = tr("Background"); |
1065 | cbradney | 273 | ll.isViewable = true; |
274 | ll.isPrintable = true; |
||
4832 | fschmid | 275 | ll.isEditable = true; |
3 | paul | 276 | Layers.append(ll); |
1973 | craig | 277 | // Fixme: Check PDF version input |
3983 | craig | 278 | PDF_Options.Version = (PDFOptions::PDFVersion)prefsData.PDF_Options.Version; |
3201 | subik | 279 | |
3784 | cbradney | 280 | if (AutoSave && ScQApp->usingGUI()) |
281 | autoSaveTimer->start(AutoSaveTime); |
||
3724 | cbradney | 282 | //Do this after all the collections have been created and cleared! |
283 | m_masterPageMode=true; // quick hack to force the change of pointers in setMasterPageMode(); |
||
284 | setMasterPageMode(false); |
||
2891 | cbradney | 285 | addSymbols(); |
5177 | mrdocs | 286 | |
287 | #ifdef HAVE_CMS |
||
288 | DocInputProf = NULL; |
||
289 | DocOutputProf = NULL; |
||
290 | DocPrinterProf = NULL; |
||
6106 | jghali | 291 | stdTransRGBDoc2CMYK = NULL; |
292 | stdTransCMYK2RGBDoc = NULL; |
||
293 | stdTransRGBDoc2Mon = NULL; |
||
294 | stdTransCMYK2Mon = NULL; |
||
295 | stdProofRGB = NULL; |
||
296 | stdProofRGBGC = NULL; |
||
297 | stdProofCMYK = NULL; |
||
298 | stdProofCMYKGC = NULL; |
||
5177 | mrdocs | 299 | stdTransImg = NULL; |
300 | stdProofImg = NULL; |
||
9956 | jghali | 301 | SetDefaultCMSParams(); |
5177 | mrdocs | 302 | #endif |
3 | paul | 303 | } |
304 | |||
305 | ScribusDoc::~ScribusDoc() |
||
306 | { |
||
456 | fschmid | 307 | DocItems.setAutoDelete(true); |
2498 | fschmid | 308 | FrameItems.setAutoDelete(true); |
456 | fschmid | 309 | DocItems.clear(); |
2498 | fschmid | 310 | FrameItems.clear(); |
456 | fschmid | 311 | MasterPages.setAutoDelete(true); |
312 | DocPages.setAutoDelete(true); |
||
313 | MasterPages.clear(); |
||
314 | DocPages.clear(); |
||
4199 | mrdocs | 315 | MasterItems.setAutoDelete(true); |
316 | MasterItems.clear(); |
||
3544 | avox | 317 | QMap<QString,int>::Iterator it3; |
494 | fschmid | 318 | for (it3 = UsedFonts.begin(); it3 != UsedFonts.end(); ++it3) |
319 | { |
||
2877 | cbradney | 320 | if (!(*AllFonts)[it3.key()]->PrivateFont.isEmpty()) |
494 | fschmid | 321 | (*AllFonts).removeFont(it3.key()); |
322 | } |
||
3 | paul | 323 | FT_Done_FreeType( library ); |
324 | } |
||
325 | |||
2901 | fschmid | 326 | void ScribusDoc::setup(const int unitIndex, const int fp, const int firstLeft, const int orientation, const int firstPageNumber, const QString& defaultPageSize, const QString& documentName) |
2891 | cbradney | 327 | { |
328 | docUnitIndex=unitIndex; |
||
3016 | fschmid | 329 | pageSets[fp].FirstPage = firstLeft; |
2891 | cbradney | 330 | PageOri = orientation; |
331 | PageSize = defaultPageSize; |
||
332 | FirstPnum = firstPageNumber; |
||
3032 | fschmid | 333 | currentPageLayout = fp; |
2891 | cbradney | 334 | setName(documentName); |
335 | HasCMS = true; |
||
4039 | fschmid | 336 | if (!PDF_Options.UseLPI) |
337 | { |
||
338 | PDF_Options.LPISettings.clear(); |
||
339 | struct LPIData lpo; |
||
340 | lpo.Frequency = 75; |
||
341 | lpo.SpotFunc = 2; |
||
342 | lpo.Angle = 105; |
||
343 | PDF_Options.LPISettings.insert("Cyan", lpo); |
||
344 | lpo.Angle = 75; |
||
345 | PDF_Options.LPISettings.insert("Magenta", lpo); |
||
346 | lpo.Angle = 90; |
||
347 | PDF_Options.LPISettings.insert("Yellow", lpo); |
||
348 | lpo.Angle = 45; |
||
349 | PDF_Options.LPISettings.insert("Black", lpo); |
||
350 | ActiveLayer = 0; |
||
351 | } |
||
3201 | subik | 352 | |
2891 | cbradney | 353 | appMode = modeNormal; |
354 | PrefsManager *prefsManager=PrefsManager::instance(); |
||
355 | PageColors = prefsManager->colorSet(); |
||
9294 | jghali | 356 | PageColors.ensureBlackAndWhite(); |
3201 | subik | 357 | |
3983 | craig | 358 | CMSSettings = prefsManager->appPrefs.DCMSset; |
2984 | fschmid | 359 | PDF_Options.SolidProf = CMSSettings.DefaultSolidColorProfile; |
360 | PDF_Options.ImageProf = CMSSettings.DefaultImageRGBProfile; |
||
2891 | cbradney | 361 | PDF_Options.PrintProf = CMSSettings.DefaultPrinterProfile; |
362 | PDF_Options.Intent = CMSSettings.DefaultIntentMonitor; |
||
2984 | fschmid | 363 | PDF_Options.Intent2 = CMSSettings.DefaultIntentImages; |
4546 | subik | 364 | #ifdef HAVE_CMS |
8462 | jghali | 365 | BlackPoint = CMSSettings.BlackPoint; |
2892 | fschmid | 366 | SoftProofing = CMSSettings.SoftProofOn; |
367 | Gamut = CMSSettings.GamutCheck; |
||
368 | IntentPrinter = CMSSettings.DefaultIntentPrinter; |
||
369 | IntentMonitor = CMSSettings.DefaultIntentMonitor; |
||
370 | BlackPoint = CMSSettings.BlackPoint; |
||
3051 | fschmid | 371 | if ((CMSavail) && (CMSSettings.CMSinUse)) |
2891 | cbradney | 372 | { |
5177 | mrdocs | 373 | if (OpenCMSProfiles(ScMW->InputProfiles, ScMW->MonitorProfiles, ScMW->PrinterProfiles)) |
374 | { |
||
375 | if (static_cast<int>(cmsGetColorSpace(DocInputProf)) == icSigRgbData) |
||
376 | CMSSettings.ComponentsInput2 = 3; |
||
377 | if (static_cast<int>(cmsGetColorSpace(DocInputProf)) == icSigCmykData) |
||
378 | CMSSettings.ComponentsInput2 = 4; |
||
379 | if (static_cast<int>(cmsGetColorSpace(DocInputProf)) == icSigCmyData) |
||
380 | CMSSettings.ComponentsInput2 = 3; |
||
381 | if (static_cast<int>(cmsGetColorSpace(DocPrinterProf)) == icSigRgbData) |
||
382 | CMSSettings.ComponentsPrinter = 3; |
||
383 | if (static_cast<int>(cmsGetColorSpace(DocPrinterProf)) == icSigCmykData) |
||
384 | CMSSettings.ComponentsPrinter = 4; |
||
385 | if (static_cast<int>(cmsGetColorSpace(DocPrinterProf)) == icSigCmyData) |
||
386 | CMSSettings.ComponentsPrinter = 3; |
||
387 | PDF_Options.SComp = CMSSettings.ComponentsInput2; |
||
388 | } |
||
389 | else |
||
9858 | jghali | 390 | { |
391 | SetDefaultCMSParams(); |
||
5177 | mrdocs | 392 | CMSSettings.CMSinUse = false; |
9858 | jghali | 393 | } |
394 | } |
||
395 | else |
||
396 | SetDefaultCMSParams(); |
||
9957 | jghali | 397 | SetGlobalCMSParams(); |
2891 | cbradney | 398 | #endif |
399 | } |
||
400 | |||
401 | void ScribusDoc::setLoading(const bool docLoading) |
||
402 | { |
||
403 | loading = docLoading; |
||
404 | } |
||
405 | |||
3985 | cbradney | 406 | bool ScribusDoc::isLoading() const |
2891 | cbradney | 407 | { |
408 | return loading; |
||
409 | } |
||
410 | |||
4320 | cbradney | 411 | ScribusView* ScribusDoc::view() const |
412 | { |
||
413 | return (WinHan ? (((ScribusWin*) WinHan)->view()) : 0); |
||
414 | } |
||
415 | |||
1330 | fschmid | 416 | void ScribusDoc::CloseCMSProfiles() |
417 | { |
||
418 | #ifdef HAVE_CMS |
||
5177 | mrdocs | 419 | if ((CMSavail) /*&& (CMSSettings.CMSinUse)*/) |
3051 | fschmid | 420 | { |
10167 | jghali | 421 | ResetGlobalCMSParams(); |
9858 | jghali | 422 | if (DocInputProf && !ScMW->IsDefaultProfile(DocInputProf)) |
5177 | mrdocs | 423 | cmsCloseProfile(DocInputProf); |
9858 | jghali | 424 | if (DocOutputProf && !ScMW->IsDefaultProfile(DocOutputProf)) |
5177 | mrdocs | 425 | cmsCloseProfile(DocOutputProf); |
9858 | jghali | 426 | if (DocPrinterProf && !ScMW->IsDefaultProfile(DocPrinterProf)) |
5177 | mrdocs | 427 | cmsCloseProfile(DocPrinterProf); |
9858 | jghali | 428 | if (stdTransRGBDoc2CMYK && !ScMW->IsDefaultTransform(stdTransRGBDoc2CMYK)) |
6106 | jghali | 429 | cmsDeleteTransform(stdTransRGBDoc2CMYK); |
9858 | jghali | 430 | if (stdTransCMYK2RGBDoc && !ScMW->IsDefaultTransform(stdTransCMYK2RGBDoc)) |
6106 | jghali | 431 | cmsDeleteTransform(stdTransCMYK2RGBDoc); |
9858 | jghali | 432 | if (stdTransRGBDoc2Mon && !ScMW->IsDefaultTransform(stdTransRGBDoc2Mon)) |
6106 | jghali | 433 | cmsDeleteTransform(stdTransRGBDoc2Mon); |
9858 | jghali | 434 | if (stdTransCMYK2Mon && !ScMW->IsDefaultTransform(stdTransCMYK2Mon)) |
6106 | jghali | 435 | cmsDeleteTransform(stdTransCMYK2Mon); |
9858 | jghali | 436 | if (stdProofRGB && !ScMW->IsDefaultTransform(stdProofRGB)) |
6106 | jghali | 437 | cmsDeleteTransform(stdProofRGB); |
9858 | jghali | 438 | if (stdProofRGBGC && !ScMW->IsDefaultTransform(stdProofRGBGC)) |
6106 | jghali | 439 | cmsDeleteTransform(stdProofRGBGC); |
9858 | jghali | 440 | if (stdProofCMYK && !ScMW->IsDefaultTransform(stdProofCMYK)) |
6106 | jghali | 441 | cmsDeleteTransform(stdProofCMYK); |
9858 | jghali | 442 | if (stdProofCMYKGC && !ScMW->IsDefaultTransform(stdProofCMYKGC)) |
6106 | jghali | 443 | cmsDeleteTransform(stdProofCMYKGC); |
9858 | jghali | 444 | if (stdTransImg && !ScMW->IsDefaultTransform(stdTransImg)) |
5177 | mrdocs | 445 | cmsDeleteTransform(stdTransImg); |
9858 | jghali | 446 | if (stdProofImg && !ScMW->IsDefaultTransform(stdProofImg)) |
5177 | mrdocs | 447 | cmsDeleteTransform(stdProofImg); |
9858 | jghali | 448 | SetDefaultCMSParams(); |
3051 | fschmid | 449 | } |
1330 | fschmid | 450 | #endif |
451 | } |
||
452 | |||
9858 | jghali | 453 | void ScribusDoc::SetDefaultCMSParams() |
454 | { |
||
9956 | jghali | 455 | BlackPoint = true; |
456 | SoftProofing = false; |
||
457 | Gamut = false; |
||
458 | IntentPrinter = 1; // INTENT_RELATIVE_COLORIMETRIC |
||
459 | IntentMonitor = 1; // INTENT_RELATIVE_COLORIMETRIC |
||
9858 | jghali | 460 | DocInputProf = ScMW->defaultRGBProfile; |
461 | DocOutputProf = ScMW->defaultRGBProfile; |
||
462 | DocPrinterProf = ScMW->defaultCMYKProfile; |
||
463 | stdTransRGBDoc2CMYK = ScMW->defaultRGBToCMYKTrans; |
||
464 | stdTransCMYK2RGBDoc = ScMW->defaultCMYKToRGBTrans; |
||
465 | stdTransRGBDoc2Mon = ScMW->defaultRGBToScreenTrans; |
||
466 | stdTransCMYK2Mon = ScMW->defaultCMYKToRGBTrans; |
||
467 | stdProofRGB = ScMW->defaultRGBToScreenTrans; |
||
468 | stdProofRGBGC = ScMW->defaultRGBToScreenTrans; |
||
469 | stdProofCMYK = ScMW->defaultCMYKToRGBTrans; |
||
470 | stdProofCMYKGC = ScMW->defaultCMYKToRGBTrans; |
||
471 | stdTransImg = ScMW->defaultRGBToScreenImgTrans; |
||
472 | stdProofImg = ScMW->defaultRGBToScreenImgTrans; |
||
473 | } |
||
474 | |||
9957 | jghali | 475 | void ScribusDoc::SetGlobalCMSParams() |
476 | { |
||
477 | #ifdef HAVE_CMS |
||
478 | ::BlackPoint = BlackPoint; |
||
479 | ::SoftProofing = SoftProofing; |
||
480 | ::Gamut = Gamut; |
||
481 | ::IntentPrinter = IntentPrinter; |
||
482 | ::IntentMonitor = IntentMonitor; |
||
483 | CMSoutputProf = DocOutputProf; |
||
484 | CMSprinterProf = DocPrinterProf; |
||
485 | stdTransRGBDoc2CMYKG = stdTransRGBDoc2CMYK; |
||
486 | stdTransCMYK2RGBDocG = stdTransCMYK2RGBDoc; |
||
487 | stdTransRGBDoc2MonG = stdTransRGBDoc2Mon; |
||
488 | stdTransCMYK2MonG = stdTransCMYK2Mon; |
||
489 | stdProofRGBG = stdProofRGB; |
||
490 | stdProofRGBGCG = stdProofRGBGC; |
||
491 | stdProofCMYKG = stdProofCMYK; |
||
492 | stdProofCMYKGCG = stdProofCMYKGC; |
||
493 | stdTransImgG = stdTransImg; |
||
494 | stdProofImgG = stdProofImg; |
||
495 | #endif |
||
496 | } |
||
497 | |||
10167 | jghali | 498 | void ScribusDoc::ResetGlobalCMSParams() |
499 | { |
||
500 | #ifdef HAVE_CMS |
||
501 | if (CMSoutputProf == DocOutputProf) |
||
502 | CMSoutputProf = NULL; |
||
503 | if (CMSprinterProf == DocPrinterProf) |
||
504 | CMSprinterProf = NULL; |
||
505 | if (stdTransRGBDoc2CMYKG == stdTransRGBDoc2CMYK) |
||
506 | stdTransRGBDoc2CMYKG = NULL; |
||
507 | if (stdTransCMYK2RGBDocG == stdTransCMYK2RGBDoc) |
||
508 | stdTransCMYK2RGBDocG = NULL; |
||
509 | if (stdTransRGBDoc2MonG == stdTransRGBDoc2Mon) |
||
510 | stdTransRGBDoc2MonG = NULL; |
||
511 | if (stdTransCMYK2MonG == stdTransCMYK2Mon) |
||
512 | stdTransCMYK2MonG = NULL; |
||
513 | if (stdProofRGBG == stdProofRGB) |
||
514 | stdProofRGBG = NULL; |
||
515 | if (stdProofRGBGCG == stdProofRGBGC) |
||
516 | stdProofRGBGCG = NULL; |
||
517 | if (stdProofCMYKG == stdProofCMYK) |
||
518 | stdProofCMYKG = NULL; |
||
519 | if (stdProofCMYKGCG == stdProofCMYKGC) |
||
520 | stdProofCMYKGCG = NULL; |
||
521 | if (stdTransImgG == stdTransImg) |
||
522 | stdTransImgG = NULL; |
||
523 | if (stdProofImgG == stdProofImg) |
||
524 | stdProofImgG = NULL; |
||
525 | #endif |
||
526 | } |
||
527 | |||
10097 | jghali | 528 | bool ScribusDoc::UseColorManagement() |
529 | { |
||
530 | #ifdef HAVE_CMS |
||
531 | if ( !DocInputProf || !DocOutputProf || !DocPrinterProf) |
||
532 | return false; |
||
533 | if ( !stdTransRGBDoc2CMYK || !stdTransCMYK2RGBDoc || !stdTransRGBDoc2Mon || !stdTransCMYK2Mon ) |
||
534 | return false; |
||
535 | if ( !stdProofRGB || !stdProofRGBGC || !stdProofCMYK || !stdProofCMYK || !stdProofCMYKGC ) |
||
536 | return false; |
||
537 | if ( !stdTransImg || !stdProofImg ) |
||
538 | return false; |
||
539 | return true; |
||
540 | #else |
||
541 | return false; |
||
542 | #endif |
||
543 | } |
||
544 | |||
5177 | mrdocs | 545 | bool ScribusDoc::OpenCMSProfiles(ProfilesL InPo, ProfilesL MoPo, ProfilesL PrPo) |
1330 | fschmid | 546 | { |
547 | #ifdef HAVE_CMS |
||
5177 | mrdocs | 548 | cmsErrorAction(LCMS_ERROR_ABORT); |
549 | if (setjmp(cmsJumpBuffer)) |
||
550 | { |
||
551 | // Reset to the default handler otherwise may enter a loop |
||
552 | // if an error occur afterwards |
||
553 | cmsSetErrorHandler(NULL); |
||
5530 | avox | 554 | cmsErrorAction(LCMS_ERROR_IGNORE); |
5177 | mrdocs | 555 | CloseCMSProfiles(); |
5530 | avox | 556 | cmsErrorAction(LCMS_ERROR_ABORT); |
5177 | mrdocs | 557 | CMSSettings.CMSinUse = CMSuse = false; |
6435 | cbradney | 558 | QString message = tr("An error occurred while opening ICC profiles, color management is not enabled." ); |
5177 | mrdocs | 559 | if (ScQApp->usingGUI()) |
560 | QMessageBox::warning(ScMW, CommonStrings::trWarning, message, QMessageBox::Ok, 0, 0); |
||
561 | else |
||
5611 | cbradney | 562 | qWarning( "%s", message.local8Bit().data() ); |
5177 | mrdocs | 563 | return false; |
564 | } |
||
565 | cmsSetErrorHandler(&cmsErrorHandler); |
||
3745 | craig | 566 | const QCString inputProfilePath(InPo[CMSSettings.DefaultSolidColorProfile].local8Bit()); |
567 | DocInputProf = cmsOpenProfileFromFile(inputProfilePath.data(), "r"); |
||
568 | const QCString monitorProfilePath(MoPo[CMSSettings.DefaultMonitorProfile].local8Bit()); |
||
569 | DocOutputProf = cmsOpenProfileFromFile(monitorProfilePath.data(), "r"); |
||
570 | const QCString printerProfilePath(PrPo[CMSSettings.DefaultPrinterProfile].local8Bit()); |
||
571 | DocPrinterProf = cmsOpenProfileFromFile(printerProfilePath, "r"); |
||
1330 | fschmid | 572 | if ((DocInputProf == NULL) || (DocOutputProf == NULL) || (DocPrinterProf == NULL)) |
573 | { |
||
574 | CMSSettings.CMSinUse = false; |
||
5530 | avox | 575 | cmsSetErrorHandler(NULL); |
5177 | mrdocs | 576 | return false; |
1330 | fschmid | 577 | } |
578 | int dcmsFlags = 0; |
||
6106 | jghali | 579 | int dcmsFlagsImg = 0; |
3046 | fschmid | 580 | dcmsFlags |= cmsFLAGS_LOWRESPRECALC; |
6106 | jghali | 581 | dcmsFlagsImg |= cmsFLAGS_LOWRESPRECALC; |
1488 | fschmid | 582 | if (CMSSettings.GamutCheck) |
6106 | jghali | 583 | dcmsFlagsImg |= cmsFLAGS_GAMUTCHECK; |
1330 | fschmid | 584 | if (CMSSettings.BlackPoint) |
585 | { |
||
6106 | jghali | 586 | dcmsFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION; |
587 | dcmsFlagsImg |= cmsFLAGS_BLACKPOINTCOMPENSATION; |
||
1330 | fschmid | 588 | } |
1525 | cbradney | 589 | // set Gamut alarm color to #00ff00 |
1488 | fschmid | 590 | cmsSetAlarmCodes(0, 255, 0); |
6106 | jghali | 591 | // Document RGB colorspace to monitor colorspace transform |
592 | stdTransRGBDoc2Mon = scCmsCreateTransform(DocInputProf, TYPE_RGB_16, |
||
1330 | fschmid | 593 | DocOutputProf, TYPE_RGB_16, |
6106 | jghali | 594 | IntentMonitor, dcmsFlags); |
595 | // Proof document RGB colorspace to monitor |
||
596 | stdProofRGB = scCmsCreateProofingTransform(DocInputProf, TYPE_RGB_16, |
||
597 | DocOutputProf, TYPE_RGB_16, |
||
598 | DocPrinterProf, IntentPrinter, |
||
599 | INTENT_RELATIVE_COLORIMETRIC, dcmsFlags | cmsFLAGS_SOFTPROOFING); |
||
600 | // Proof document RGB colorspace to monitor + gamut ckeck |
||
601 | stdProofRGBGC = scCmsCreateProofingTransform(DocInputProf, TYPE_RGB_16, |
||
602 | DocOutputProf, TYPE_RGB_16, |
||
603 | DocPrinterProf, IntentPrinter, |
||
604 | INTENT_RELATIVE_COLORIMETRIC, dcmsFlags | cmsFLAGS_SOFTPROOFING | cmsFLAGS_GAMUTCHECK); |
||
605 | // Document RGB to monitor colorspace image transform |
||
606 | stdTransImg = scCmsCreateTransform(DocInputProf, TYPE_RGBA_8, |
||
607 | DocOutputProf, TYPE_RGBA_8, |
||
608 | IntentMonitor, dcmsFlagsImg); |
||
609 | // Proof RGB images to monitor colorspace image proofing transform |
||
6071 | jghali | 610 | stdProofImg = scCmsCreateProofingTransform(DocInputProf, TYPE_RGBA_8, |
611 | DocOutputProf, TYPE_RGBA_8, |
||
612 | DocPrinterProf, IntentPrinter, |
||
6106 | jghali | 613 | INTENT_RELATIVE_COLORIMETRIC, dcmsFlagsImg | cmsFLAGS_SOFTPROOFING); |
614 | |||
1491 | fschmid | 615 | if (static_cast<int>(cmsGetColorSpace(DocPrinterProf)) == icSigCmykData) |
616 | { |
||
6106 | jghali | 617 | // Document (and printer) CMYK colorspace to monitor colorspace transform |
618 | stdTransCMYK2Mon = scCmsCreateTransform(DocPrinterProf, TYPE_CMYK_16, |
||
619 | DocOutputProf, TYPE_RGB_16, |
||
620 | IntentMonitor, dcmsFlags); |
||
621 | // Document (and printer) CMYK colorspace to document RGB colorspace transform |
||
622 | stdTransCMYK2RGBDoc = scCmsCreateTransform(DocPrinterProf, TYPE_CMYK_16, |
||
623 | DocInputProf, TYPE_RGB_16, |
||
624 | IntentMonitor, dcmsFlags); |
||
625 | // Document RGB colorspace to document (and printer) CMYK colorspace transform |
||
626 | stdTransRGBDoc2CMYK = scCmsCreateTransform(DocInputProf, TYPE_RGB_16, |
||
627 | DocPrinterProf, TYPE_CMYK_16, |
||
628 | IntentMonitor, dcmsFlags); |
||
629 | // Proof document (and printer) CMYK colorspace on monitor |
||
6071 | jghali | 630 | stdProofCMYK = scCmsCreateTransform(DocPrinterProf, TYPE_CMYK_16, |
6106 | jghali | 631 | DocOutputProf, TYPE_RGB_16, |
632 | IntentPrinter, dcmsFlags); |
||
633 | // Proof document (and printer) CMYK colorspace on monitor |
||
6071 | jghali | 634 | stdProofCMYKGC = scCmsCreateTransform(DocPrinterProf, TYPE_CMYK_16, |
6106 | jghali | 635 | DocOutputProf, TYPE_RGB_16, |
636 | IntentPrinter, dcmsFlags); |
||
1491 | fschmid | 637 | } |
638 | else |
||
6071 | jghali | 639 | assert(false); |
5211 | mrdocs | 640 | cmsSetErrorHandler(NULL); |
5177 | mrdocs | 641 | return true; |
1330 | fschmid | 642 | #endif |
9858 | jghali | 643 | return false; |
1330 | fschmid | 644 | } |
645 | |||
456 | fschmid | 646 | /* |
647 | * Split out from loadStyles in editFormats.cpp so it's callable from anywhere, |
||
648 | * including plugins. |
||
649 | * - 2004-09-14 Craig Ringer |
||
650 | */ |
||
1065 | cbradney | 651 | void ScribusDoc::loadStylesFromFile(QString fileName, QValueList<ParagraphStyle> *tempStyles) |
456 | fschmid | 652 | { |
1065 | cbradney | 653 | // This won't create the QValueList<ParagraphStyle> will it? |
654 | QValueList<ParagraphStyle> *wrkStyles = NULL; |
||
456 | fschmid | 655 | /* |
656 | * Use the working styles struct if passed, or work directly |
||
657 | * on the document styles otherwise. Note that tempStyles, |
||
658 | * if passed, MUST have the first five styles initialised already |
||
659 | * or this function will segfault. |
||
660 | */ |
||
661 | if (tempStyles != NULL) |
||
662 | wrkStyles = tempStyles; |
||
663 | else |
||
1065 | cbradney | 664 | wrkStyles = &docParagraphStyles; |
456 | fschmid | 665 | if (!fileName.isEmpty()) |
666 | { |
||
667 | ScriXmlDoc *ss = new ScriXmlDoc(); |
||
1065 | cbradney | 668 | ss->docParagraphStyles.clear(); |
456 | fschmid | 669 | for (uint x = 5; x < wrkStyles->count(); ++x) |
1065 | cbradney | 670 | ss->docParagraphStyles.append((*wrkStyles)[x]); |
456 | fschmid | 671 | uint old = wrkStyles->count()-5; |
2834 | cbradney | 672 | if (ss->ReadStyles(fileName, this)) |
456 | fschmid | 673 | { |
1065 | cbradney | 674 | if (ss->docParagraphStyles.count() > old) |
456 | fschmid | 675 | { |
1065 | cbradney | 676 | for (uint xx=old; xx<ss->docParagraphStyles.count(); ++xx) |
456 | fschmid | 677 | { |
1065 | cbradney | 678 | struct ParagraphStyle sty; |
679 | sty.Vname = ss->docParagraphStyles[xx].Vname; |
||
2309 | fschmid | 680 | sty.LineSpaMode = ss->docParagraphStyles[xx].LineSpaMode; |
1065 | cbradney | 681 | sty.LineSpa = ss->docParagraphStyles[xx].LineSpa; |
682 | sty.textAlignment = ss->docParagraphStyles[xx].textAlignment; |
||
683 | sty.Indent = ss->docParagraphStyles[xx].Indent; |
||
684 | sty.First = ss->docParagraphStyles[xx].First; |
||
685 | sty.gapBefore = ss->docParagraphStyles[xx].gapBefore; |
||
686 | sty.gapAfter = ss->docParagraphStyles[xx].gapAfter; |
||
687 | sty.Font = ss->docParagraphStyles[xx].Font; |
||
688 | sty.FontSize = ss->docParagraphStyles[xx].FontSize; |
||
689 | sty.TabValues = ss->docParagraphStyles[xx].TabValues; |
||
690 | sty.Drop = ss->docParagraphStyles[xx].Drop; |
||
691 | sty.DropLin = ss->docParagraphStyles[xx].DropLin; |
||
2362 | fschmid | 692 | sty.DropDist = ss->docParagraphStyles[xx].DropDist; |
1065 | cbradney | 693 | sty.FontEffect = ss->docParagraphStyles[xx].FontEffect; |
694 | sty.FColor = ss->docParagraphStyles[xx].FColor; |
||
695 | sty.FShade = ss->docParagraphStyles[xx].FShade; |
||
696 | sty.SColor = ss->docParagraphStyles[xx].SColor; |
||
697 | sty.SShade = ss->docParagraphStyles[xx].SShade; |
||
698 | sty.BaseAdj = ss->docParagraphStyles[xx].BaseAdj; |
||
2273 | fschmid | 699 | sty.txtShadowX = ss->docParagraphStyles[xx].txtShadowX; |
700 | sty.txtShadowY = ss->docParagraphStyles[xx].txtShadowY; |
||
701 | sty.txtOutline = ss->docParagraphStyles[xx].txtOutline; |
||
702 | sty.txtUnderPos = ss->docParagraphStyles[xx].txtUnderPos; |
||
703 | sty.txtUnderWidth = ss->docParagraphStyles[xx].txtUnderWidth; |
||
704 | sty.txtStrikePos = ss->docParagraphStyles[xx].txtStrikePos; |
||
705 | sty.txtStrikeWidth = ss->docParagraphStyles[xx].txtStrikeWidth; |
||
2379 | fschmid | 706 | sty.scaleH = ss->docParagraphStyles[xx].scaleH; |
707 | sty.scaleV = ss->docParagraphStyles[xx].scaleV; |
||
708 | sty.baseOff = ss->docParagraphStyles[xx].baseOff; |
||
709 | sty.kernVal = ss->docParagraphStyles[xx].kernVal; |
||
456 | fschmid | 710 | wrkStyles->append(sty); |
711 | } |
||
712 | } |
||
713 | } |
||
714 | delete ss; |
||
715 | } |
||
716 | } |
||
717 | |||
1179 | tsoots | 718 | void ScribusDoc::lockGuides(bool isLocked) |
719 | { |
||
1180 | tsoots | 720 | if (GuideLock == isLocked) |
721 | return; |
||
1179 | tsoots | 722 | GuideLock = isLocked; |
723 | if (UndoManager::undoEnabled()) |
||
724 | { |
||
725 | QString name; |
||
726 | if (isLocked) |
||
1190 | tsoots | 727 | name = Um::LockGuides; |
1179 | tsoots | 728 | else |
1190 | tsoots | 729 | name = Um::UnlockGuides; |
730 | SimpleState *ss = new SimpleState(name, "", Um::ILockGuides); |
||
1179 | tsoots | 731 | ss->set("GUIDE_LOCK", isLocked); |
732 | undoManager->action(this, ss); |
||
733 | } |
||
734 | } |
||
735 | |||
736 | void ScribusDoc::restore(UndoState* state, bool isUndo) |
||
737 | { |
||
738 | SimpleState *ss = dynamic_cast<SimpleState*>(state); |
||
739 | if (ss) |
||
740 | { |
||
2941 | cbradney | 741 | bool layersUndo=false; |
1179 | tsoots | 742 | if (ss->contains("GUIDE_LOCK")) |
743 | { |
||
744 | if (isUndo) |
||
745 | GuideLock = !ss->getBool("GUIDE_LOCK"); |
||
746 | else |
||
3201 | subik | 747 | GuideLock = ss->getBool("GUIDE_LOCK"); |
1179 | tsoots | 748 | } |
2937 | cbradney | 749 | else if (ss->contains("UP_LAYER")) |
750 | { |
||
751 | if (isUndo) |
||
752 | lowerLayer(ss->getInt("ACTIVE")); |
||
753 | else |
||
754 | raiseLayer(ss->getInt("ACTIVE")); |
||
2941 | cbradney | 755 | layersUndo=true; |
2937 | cbradney | 756 | } |
757 | else if (ss->contains("DOWN_LAYER")) |
||
758 | { |
||
759 | if (isUndo) |
||
760 | raiseLayer(ss->getInt("ACTIVE")); |
||
761 | else |
||
762 | lowerLayer(ss->getInt("ACTIVE")); |
||
2941 | cbradney | 763 | layersUndo=true; |
2937 | cbradney | 764 | } |
765 | else if (ss->contains("PRINT_LAYER")) |
||
766 | { |
||
767 | bool print = ss->getBool("PRINT"); |
||
768 | setLayerPrintable(ss->getInt("ACTIVE"), isUndo ? !print : print); |
||
2941 | cbradney | 769 | layersUndo=true; |
2937 | cbradney | 770 | } |
771 | else if (ss->contains("ADD_LAYER")) |
||
772 | { |
||
773 | if (isUndo) |
||
2944 | cbradney | 774 | deleteLayer(ss->getInt("LAYER_NR"), false); |
2937 | cbradney | 775 | else |
776 | { |
||
2944 | cbradney | 777 | int layerNumber=addLayer( ss->get("NAME"), false ); |
778 | int newLayerNumber=ss->getInt("LAYER_NR"); |
||
779 | bool renumberedOk=renumberLayer(layerNumber, newLayerNumber); |
||
780 | Q_ASSERT(renumberedOk); |
||
2937 | cbradney | 781 | } |
2944 | cbradney | 782 | layersUndo=true; |
2937 | cbradney | 783 | } |
784 | else if (ss->contains("REMOVE_LAYER")) |
||
785 | { |
||
786 | if (isUndo) |
||
787 | { |
||
2944 | cbradney | 788 | int layerNumber=addLayer( ss->get("NAME"), false ); |
789 | int newLayerNumber=ss->getInt("LAYER_NR"); |
||
790 | bool renumberedOk=renumberLayer(layerNumber, newLayerNumber); |
||
791 | Q_ASSERT(renumberedOk); |
||
792 | layerNumber=newLayerNumber; |
||
793 | //Layer is at the top now, lower it until it reaches the old level |
||
2937 | cbradney | 794 | int level = ss->getInt("LEVEL"); |
2944 | cbradney | 795 | while (layerLevelFromNumber(layerNumber)!=level) |
796 | lowerLayer(layerNumber); |
||
2937 | cbradney | 797 | } |
798 | else |
||
2944 | cbradney | 799 | deleteLayer(ss->getInt("LAYER_NR"), ss->getBool("DELETE")); |
800 | layersUndo=true; |
||
2937 | cbradney | 801 | } |
802 | else if (ss->contains("CHANGE_NAME")) |
||
803 | { |
||
804 | QString name = ss->get("OLD_NAME"); |
||
805 | if (!isUndo) |
||
806 | name = ss->get("NEW_NAME"); |
||
2938 | cbradney | 807 | changeLayerName(ss->getInt("ACTIVE"), name); |
2941 | cbradney | 808 | layersUndo=true; |
809 | } |
||
3004 | cbradney | 810 | else if (ss->contains("OLD_MASTERPAGE")) |
811 | restoreMasterPageApplying(ss, isUndo); |
||
3201 | subik | 812 | |
2941 | cbradney | 813 | if (layersUndo) |
814 | { |
||
2952 | cbradney | 815 | if (ScQApp->usingGUI()) |
816 | { |
||
4026 | craig | 817 | ScMW->changeLayer(ss->getInt("ACTIVE")); |
818 | ScMW->layerPalette->rebuildList(); |
||
2952 | cbradney | 819 | } |
2937 | cbradney | 820 | } |
1179 | tsoots | 821 | } |
822 | } |
||
823 | |||
824 | void ScribusDoc::setName(const QString& name) |
||
825 | { |
||
826 | DocName = name; |
||
827 | QString uname = name; |
||
828 | if (name.find("/") > -1) |
||
829 | uname = name.right(name.length() - name.findRev("/") - 1); |
||
1190 | tsoots | 830 | if (uname.find(".sl") > -1) |
831 | uname = uname.left(uname.findRev(".sl")); |
||
1179 | tsoots | 832 | setUName(uname); // set the name for the undo object |
833 | } |
||
834 | |||
2891 | cbradney | 835 | void ScribusDoc::setModified(const bool isModified) |
3 | paul | 836 | { |
2891 | cbradney | 837 | modified = isModified; |
3 | paul | 838 | } |
839 | |||
840 | bool ScribusDoc::isModified() const |
||
841 | { |
||
842 | return modified; |
||
843 | } |
||
844 | /** Setzt die Seitenattribute */ |
||
2894 | fschmid | 845 | void ScribusDoc::setPage(double b, double h, double t, double l, double r, double bo, double sp, double ab, bool atf, int fp) |
3 | paul | 846 | { |
2142 | cbradney | 847 | pageWidth = b; |
848 | pageHeight = h; |
||
849 | pageMargins.Top = t; |
||
850 | pageMargins.Left = l; |
||
851 | pageMargins.Right = r; |
||
852 | pageMargins.Bottom = bo; |
||
3 | paul | 853 | PageSp = sp; |
854 | PageSpa = ab; |
||
3032 | fschmid | 855 | currentPageLayout = fp; |
3648 | cbradney | 856 | automaticTextFrames = atf; |
4546 | subik | 857 | |
3695 | cbradney | 858 | //CB Moved from scribus.cpp. Overrides the defaults... |
859 | PDF_Options.BleedTop = pageMargins.Top; |
||
860 | PDF_Options.BleedLeft = pageMargins.Left; |
||
861 | PDF_Options.BleedRight = pageMargins.Right; |
||
862 | PDF_Options.BleedBottom = pageMargins.Bottom; |
||
3 | paul | 863 | } |
864 | |||
2894 | fschmid | 865 | void ScribusDoc::resetPage(double t, double l, double r, double bo, int fp) |
3 | paul | 866 | { |
2142 | cbradney | 867 | pageMargins.Top = t; |
868 | pageMargins.Left = l; |
||
869 | pageMargins.Right = r; |
||
870 | pageMargins.Bottom = bo; |
||
3032 | fschmid | 871 | currentPageLayout = fp; |
3 | paul | 872 | } |
873 | |||
3544 | avox | 874 | bool ScribusDoc::AddFont(QString name, int fsize) |
3 | paul | 875 | { |
220 | Franz | 876 | bool ret = false; |
877 | bool error; |
||
3 | paul | 878 | FT_Face face; |
2295 | cbradney | 879 | |
3201 | subik | 880 | if (UsedFonts.contains(name)) |
881 | return true; |
||
2295 | cbradney | 882 | |
3572 | avox | 883 | if (! ((*AllFonts)[name]) ) |
884 | return ret; |
||
885 | |||
3544 | avox | 886 | error = FT_New_Face( library, (*AllFonts)[name]->fontFilePath(), (*AllFonts)[name]->faceIndex(), &face ); |
220 | Franz | 887 | if (error) |
888 | return ret; |
||
2295 | cbradney | 889 | |
220 | Franz | 890 | if ((*AllFonts)[name]->ReadMetrics()) |
167 | Franz | 891 | { |
220 | Franz | 892 | (*AllFonts)[name]->CharWidth[13] = 0; |
249 | Franz | 893 | (*AllFonts)[name]->CharWidth[28] = 0; |
2384 | fschmid | 894 | (*AllFonts)[name]->CharWidth[26] = 0; |
220 | Franz | 895 | (*AllFonts)[name]->CharWidth[9] = 1; |
3500 | avox | 896 | QString afnm = (*AllFonts)[name]->fontFilePath().left((*AllFonts)[name]->fontFilePath().length()-3); |
220 | Franz | 897 | QFile afm(afnm+"afm"); |
3 | paul | 898 | if(!(afm.exists())) |
220 | Franz | 899 | { |
900 | afm.setName(afnm+"Afm"); |
||
901 | if(!(afm.exists())) |
||
902 | afm.setName(afnm+"AFM"); |
||
903 | } |
||
904 | if (afm.exists()) |
||
905 | FT_Attach_File(face, afm.name()); |
||
906 | FFonts[name] = face; |
||
3544 | avox | 907 | UsedFonts[name] = fsize; |
220 | Franz | 908 | ret = true; |
167 | Franz | 909 | } |
220 | Franz | 910 | else |
911 | FT_Done_Face( face ); |
||
912 | return ret; |
||
3 | paul | 913 | } |
1694 | cbradney | 914 | |
915 | QStringList ScribusDoc::getItemAttributeNames() |
||
916 | { |
||
917 | QStringList nameList; |
||
3201 | subik | 918 | |
1694 | cbradney | 919 | for(ObjAttrVector::Iterator it = docItemAttributes.begin(); it!= docItemAttributes.end(); ++it) |
920 | nameList.append((*it).name); |
||
921 | return nameList; |
||
1749 | craig | 922 | } |
923 | |||
2891 | cbradney | 924 | void ScribusDoc::addSymbols() |
925 | { |
||
926 | symReturn.resize(0); |
||
927 | symReturn.addQuadPoint(1.98438, 9.14062, 1.98438, 9.14062, 1.98438, 4.03125, 1.98438, 4.03125); |
||
928 | symReturn.addQuadPoint(1.98438, 4.03125, 1.98438, 4.03125, 0.546875, 3.45312, 1.09375, 4); |
||
929 | symReturn.addQuadPoint(0.546875, 3.45312, 0.546875, 3.45312, 0, 2.0625, 0, 2.92188); |
||
930 | symReturn.addQuadPoint(0, 2.0625, 0, 2.0625, 0.65625, 0.5, 0, 1.04688); |
||
931 | symReturn.addQuadPoint(0.65625, 0.5, 0.65625, 0.5, 2.3125, 0, 1.28125, 0); |
||
932 | symReturn.addQuadPoint(2.3125, 0, 2.3125, 0, 5.40625, 0, 5.40625, 0); |
||
933 | symReturn.addQuadPoint(5.40625, 0, 5.40625, 0, 5.40625, 0.84375, 5.40625, 0.84375); |
||
934 | symReturn.addQuadPoint(5.40625, 0.84375, 5.40625, 0.84375, 4.70312, 0.84375, 4.70312, 0.84375); |
||
935 | symReturn.addQuadPoint(4.70312, 0.84375, 4.70312, 0.84375, 4.70312, 9.14062, 4.70312, 9.14062); |
||
936 | symReturn.addQuadPoint(4.70312, 9.14062, 4.70312, 9.14062, 3.875, 9.14062, 3.875, 9.14062); |
||
937 | symReturn.addQuadPoint(3.875, 9.14062, 3.875, 9.14062, 3.875, 0.84375, 3.875, 0.84375); |
||
938 | symReturn.addQuadPoint(3.875, 0.84375, 3.875, 0.84375, 2.78125, 0.84375, 2.78125, 0.84375); |
||
939 | symReturn.addQuadPoint(2.78125, 0.84375, 2.78125, 0.84375, 2.78125, 9.14062, 2.78125, 9.14062); |
||
940 | symReturn.addQuadPoint(2.78125, 9.14062, 2.78125, 9.14062, 1.98438, 9.14062, 1.98438, 9.14062); |
||
941 | symNewLine.resize(0); |
||
942 | symNewLine.addQuadPoint(6.51562, 2.625, 6.51562, 2.625, 0.90625, 2.64062, 0.90625, 2.64062); |
||
943 | symNewLine.addQuadPoint(0.90625, 2.64062, 0.90625, 2.64062, 1.4375, 1.92188, 1.26562, 2.1875); |
||
944 | symNewLine.addQuadPoint(1.4375, 1.92188, 1.4375, 1.92188, 1.76562, 1.14062, 1.75, 1.42188); |
||
945 | symNewLine.addQuadPoint(1.76562, 1.14062, 1.76562, 1.14062, 1.60938, 1.03125, 1.60938, 1.03125); |
||
946 | symNewLine.addQuadPoint(1.60938, 1.03125, 1.60938, 1.03125, 0.90625, 1.92188, 0.90625, 1.92188); |
||
947 | symNewLine.addQuadPoint(0.90625, 1.92188, 0.90625, 1.92188, 0, 2.90625, 0.578125, 2.23438); |
||
948 | symNewLine.addQuadPoint(0, 2.90625, 0, 2.90625, 0.75, 3.875, 0.75, 3.875); |
||
949 | symNewLine.addQuadPoint(0.75, 3.875, 0.75, 3.875, 1.57812, 4.78125, 1.1875, 4.40625); |
||
950 | symNewLine.addQuadPoint(1.57812, 4.78125, 1.57812, 4.78125, 1.65625, 4.79688, 1.65625, 4.79688); |
||
951 | symNewLine.addQuadPoint(1.65625, 4.79688, 1.65625, 4.79688, 1.76562, 4.65625, 1.76562, 4.65625); |
||
952 | symNewLine.addQuadPoint(1.76562, 4.65625, 1.76562, 4.65625, 0.90625, 3.17188, 1.73438, 4.34375); |
||
953 | symNewLine.addQuadPoint(0.90625, 3.17188, 0.90625, 3.17188, 0.96875, 3.125, 0.96875, 3.125); |
||
954 | symNewLine.addQuadPoint(0.96875, 3.125, 0.96875, 3.125, 6.75, 3.125, 6.75, 3.125); |
||
955 | symNewLine.addQuadPoint(6.75, 3.125, 6.75, 3.125, 6.51562, 2.625, 6.51562, 2.625); |
||
956 | symNewLine.addQuadPoint(6.51562, 2.625, 6.51562, 2.625, 6.51562, 2.625, 6.51562, 2.625); |
||
957 | symNewLine.addQuadPoint(999999, 999999, 999999, 999999, 999999, 999999, 999999, 999999); |
||
958 | symNewLine.addQuadPoint(6.875, 0, 6.875, 0, 6.51562, 0, 6.51562, 0); |
||
959 | symNewLine.addQuadPoint(6.51562, 0, 6.51562, 0, 6.51562, 2.84375, 6.51562, 2.84375); |
||
960 | symNewLine.addQuadPoint(6.51562, 2.84375, 6.51562, 2.84375, 6.75, 3.125, 6.51562, 3.125); |
||
961 | symNewLine.addQuadPoint(6.75, 3.125, 6.75, 3.125, 6.85938, 3.0625, 6.85938, 3.0625); |
||
962 | symNewLine.addQuadPoint(6.85938, 3.0625, 6.85938, 3.0625, 6.875, 0, 6.875, 0); |
||
963 | symTab.resize(0); |
||
964 | symTab.addQuadPoint(4.82812, 3.96875, 4.82812, 3.96875, 4.5625, 3.73438, 4.5625, 3.96875); |
||
965 | symTab.addQuadPoint(4.5625, 3.73438, 4.5625, 3.73438, 5.07812, 3.10938, 4.5625, 3.57812); |
||
966 | symTab.addQuadPoint(5.07812, 3.10938, 5.07812, 3.10938, 0, 3.10938, 0, 3.10938); |
||
967 | symTab.addQuadPoint(0, 3.10938, 0, 3.10938, 0, 2.625, 0, 2.625); |
||
968 | symTab.addQuadPoint(0, 2.625, 0, 2.625, 5.53125, 2.625, 5.53125, 2.625); |
||
969 | symTab.addQuadPoint(5.53125, 2.625, 5.53125, 2.625, 6.3125, 1.8125, 6.3125, 1.8125); |
||
970 | symTab.addQuadPoint(6.3125, 1.8125, 6.3125, 1.8125, 5.64062, 1.29688, 5.64062, 1.29688); |
||
971 | symTab.addQuadPoint(5.64062, 1.29688, 5.64062, 1.29688, 0, 1.29688, 0, 1.29688); |
||
972 | symTab.addQuadPoint(0, 1.29688, 0, 1.29688, 0, 0.8125, 0, 0.8125); |
||
973 | symTab.addQuadPoint(0, 0.8125, 0, 0.8125, 5.01562, 0.8125, 5.01562, 0.8125); |
||
974 | symTab.addQuadPoint(5.01562, 0.8125, 5.01562, 0.8125, 4.45312, 0.265625, 4.45312, 0.453125); |
||
975 | symTab.addQuadPoint(4.45312, 0.265625, 4.45312, 0.265625, 4.6875, 0, 4.45312, 0); |
||
976 | symTab.addQuadPoint(4.6875, 0, 4.6875, 0, 5.90625, 0.828125, 4.875, 0); |
||
977 | symTab.addQuadPoint(5.90625, 0.828125, 5.90625, 0.828125, 6.9375, 1.79688, 6.9375, 1.64062); |
||
978 | symTab.addQuadPoint(6.9375, 1.79688, 6.9375, 1.79688, 5.95312, 2.96875, 6.9375, 1.95312); |
||
979 | symTab.addQuadPoint(5.95312, 2.96875, 5.95312, 2.96875, 4.82812, 3.96875, 4.98438, 3.96875); |
||
980 | symNonBreak.resize(0); |
||
981 | symNonBreak.addQuadPoint(1.32812, 2.59375, 1.32812, 2.59375, 0.390625, 2.21875, 0.796875, 2.59375); |
||
982 | symNonBreak.addQuadPoint(0.390625, 2.21875, 0.390625, 2.21875, 0, 1.3125, 0, 1.84375); |
||
983 | symNonBreak.addQuadPoint(0, 1.3125, 0, 1.3125, 0.390625, 0.390625, 0, 0.765625); |
||
984 | symNonBreak.addQuadPoint(0.390625, 0.390625, 0.390625, 0.390625, 1.32812, 0, 0.796875, 0); |
||
985 | symNonBreak.addQuadPoint(1.32812, 0, 1.32812, 0, 2.23438, 0.390625, 1.85938, 0); |
||
986 | symNonBreak.addQuadPoint(2.23438, 0.390625, 2.23438, 0.390625, 2.60938, 1.29688, 2.60938, 0.765625); |
||
987 | symNonBreak.addQuadPoint(2.60938, 1.29688, 2.60938, 1.29688, 2.23438, 2.21875, 2.60938, 1.84375); |
||
988 | symNonBreak.addQuadPoint(2.23438, 2.21875, 2.23438, 2.21875, 1.32812, 2.59375, 1.875, 2.59375); |
||
989 | symNewCol.resize(0); |
||
990 | symNewCol.addQuadPoint(1.73438, 0, 1.73438, 0, 2.67188, 0.109375, 2.03125, 0); |
||
991 | symNewCol.addQuadPoint(2.67188, 0.109375, 2.67188, 0.109375, 3.59375, 0.203125, 3.26562, 0.21875); |
||
992 | symNewCol.addQuadPoint(3.59375, 0.203125, 3.59375, 0.203125, 3.79688, 0.1875, 3.64062, 0.203125); |
||
993 | symNewCol.addQuadPoint(3.79688, 0.1875, 3.79688, 0.1875, 4, 0.171875, 3.92188, 0.171875); |
||
994 | symNewCol.addQuadPoint(4, 0.171875, 4, 0.171875, 4.20312, 0.1875, 4.20312, 0.1875); |
||
995 | symNewCol.addQuadPoint(4.20312, 0.1875, 4.20312, 0.1875, 4.3125, 1.39062, 4.20312, 0.5625); |
||
996 | symNewCol.addQuadPoint(4.3125, 1.39062, 4.3125, 1.39062, 4.42188, 2.64062, 4.42188, 2.21875); |
||
997 | symNewCol.addQuadPoint(4.42188, 2.64062, 4.42188, 2.64062, 4.28125, 2.73438, 4.28125, 2.73438); |
||
998 | symNewCol.addQuadPoint(4.28125, 2.73438, 4.28125, 2.73438, 3.75, 1.03125, 4.01562, 2.64062); |
||
999 | symNewCol.addQuadPoint(3.75, 1.03125, 3.75, 1.03125, 3.67188, 1.03125, 3.67188, 1.03125); |
||
1000 | symNewCol.addQuadPoint(3.67188, 1.03125, 3.67188, 1.03125, 0.28125, 6.20312, 0.28125, 6.20312); |
||
1001 | symNewCol.addQuadPoint(0.28125, 6.20312, 0.28125, 6.20312, 0, 5.95312, 0.03125, 6.17188); |
||
1002 | symNewCol.addQuadPoint(0, 5.95312, 0, 5.95312, 3.35938, 0.71875, 3.35938, 0.71875); |
||
1003 | symNewCol.addQuadPoint(3.35938, 0.71875, 3.35938, 0.71875, 3.375, 0.640625, 3.375, 0.640625); |
||
1004 | symNewCol.addQuadPoint(3.375, 0.640625, 3.375, 0.640625, 2.4375, 0.484375, 2.79688, 0.5625); |
||
1005 | symNewCol.addQuadPoint(2.4375, 0.484375, 2.4375, 0.484375, 1.67188, 0.140625, 1.71875, 0.328125); |
||
1006 | symNewCol.addQuadPoint(1.67188, 0.140625, 1.67188, 0.140625, 1.73438, 0, 1.73438, 0); |
||
1007 | symNewFrame.resize(0); |
||
1008 | symNewFrame.addQuadPoint(1.75, 6.20312, 1.75, 6.20312, 2.67188, 6.09375, 2.0625, 6.20312); |
||
1009 | symNewFrame.addQuadPoint(2.67188, 6.09375, 2.67188, 6.09375, 3.60938, 5.98438, 3.28125, 5.98438); |
||
1010 | symNewFrame.addQuadPoint(3.60938, 5.98438, 3.60938, 5.98438, 3.84375, 6.01562, 3.6875, 5.98438); |
||
1011 | symNewFrame.addQuadPoint(3.84375, 6.01562, 3.84375, 6.01562, 4.07812, 6.03125, 4, 6.03125); |
||
1012 | symNewFrame.addQuadPoint(4.07812, 6.03125, 4.07812, 6.03125, 4.20312, 6.01562, 4.20312, 6.01562); |
||
1013 | symNewFrame.addQuadPoint(4.20312, 6.01562, 4.20312, 6.01562, 4.32812, 4.79688, 4.21875, 5.625); |
||
1014 | symNewFrame.addQuadPoint( 4.32812, 4.79688, 4.32812, 4.79688, 4.42188, 3.5625, 4.42188, 3.98438); |
||
1015 | symNewFrame.addQuadPoint(4.42188, 3.5625, 4.42188, 3.5625, 4.29688, 3.45312, 4.29688, 3.45312); |
||
1016 | symNewFrame.addQuadPoint(4.29688, 3.45312, 4.29688, 3.45312, 3.75, 5.17188, 4.03125, 3.54688); |
||
1017 | symNewFrame.addQuadPoint(3.75, 5.17188, 3.75, 5.17188, 3.67188, 5.17188, 3.67188, 5.17188); |
||
1018 | symNewFrame.addQuadPoint(3.67188, 5.17188, 3.67188, 5.17188, 0.28125, 0, 0.28125, 0); |
||
1019 | symNewFrame.addQuadPoint(0.28125, 0, 0.28125, 0, 0, 0.25, 0.03125, 0.015625); |
||
1020 | symNewFrame.addQuadPoint(0, 0.25, 0, 0.25, 3.375, 5.46875, 3.375, 5.46875); |
||
1021 | symNewFrame.addQuadPoint(3.375, 5.46875, 3.375, 5.46875, 3.39062, 5.54688, 3.39062, 5.54688); |
||
1022 | symNewFrame.addQuadPoint(3.39062, 5.54688, 3.39062, 5.54688, 2.4375, 5.70312, 2.8125, 5.625); |
||
1023 | symNewFrame.addQuadPoint(2.4375, 5.70312, 2.4375, 5.70312, 1.67188, 6.0625, 1.71875, 5.875); |
||
1024 | symNewFrame.addQuadPoint(1.67188, 6.0625, 1.67188, 6.0625, 1.75, 6.20312, 1.75, 6.20312); |
||
1025 | } |
||
2893 | cbradney | 1026 | |
3852 | cbradney | 1027 | Page* ScribusDoc::addPage(const int pageIndex, const QString& masterPageName, const bool addAutoFrame) |
2893 | cbradney | 1028 | { |
3787 | cbradney | 1029 | Q_ASSERT(masterPageMode()==false); |
4069 | craig | 1030 | Page* addedPage = new Page(ScratchLeft, DocPages.count()*(pageHeight+ScratchBottom+ScratchTop)+ScratchTop, pageWidth, pageHeight); |
2893 | cbradney | 1031 | Q_ASSERT(addedPage!=NULL); |
4738 | cbradney | 1032 | addedPage->setDocument(this); |
2893 | cbradney | 1033 | addedPage->Margins.Top = pageMargins.Top; |
1034 | addedPage->Margins.Bottom = pageMargins.Bottom; |
||
1035 | addedPage->initialMargins.Top = pageMargins.Top; |
||
1036 | addedPage->initialMargins.Bottom = pageMargins.Bottom; |
||
1037 | addedPage->initialMargins.Left = pageMargins.Left; |
||
1038 | addedPage->initialMargins.Right = pageMargins.Right; |
||
3852 | cbradney | 1039 | addedPage->setPageNr(pageIndex); |
2893 | cbradney | 1040 | addedPage->PageSize = PageSize; |
1041 | addedPage->PageOri = PageOri; |
||
3852 | cbradney | 1042 | bool insertsuccess=DocPages.insert(pageIndex, addedPage); |
1043 | Q_ASSERT(insertsuccess==true && DocPages.at(pageIndex)!=NULL); |
||
2893 | cbradney | 1044 | currentPage = addedPage; |
3787 | cbradney | 1045 | //if (!masterPageMode()) |
3985 | cbradney | 1046 | if (!masterPageName.isEmpty()) |
3911 | cbradney | 1047 | applyMasterPage(masterPageName, pageIndex); |
3852 | cbradney | 1048 | setLocationBasedPageLRMargins(pageIndex); |
1049 | if (addAutoFrame && automaticTextFrames) |
||
1050 | addAutomaticTextFrame(pageIndex); |
||
2893 | cbradney | 1051 | return addedPage; |
1052 | } |
||
2895 | cbradney | 1053 | |
3695 | cbradney | 1054 | Page* ScribusDoc::addMasterPage(const int pageNumber, const QString& pageName) |
1055 | { |
||
1056 | //CB We dont create master pages (yet) with a pageCount based location |
||
4069 | craig | 1057 | //Page* addedPage = new Page(ScratchLeft, MasterPages.count()*(pageHeight+ScratchBottom+ScratchTop)+ScratchTop, pageWidth, pageHeight); |
3695 | cbradney | 1058 | Page* addedPage = new Page(ScratchLeft, ScratchTop, pageWidth, pageHeight); |
1059 | Q_ASSERT(addedPage!=NULL); |
||
4738 | cbradney | 1060 | addedPage->setDocument(this); |
3695 | cbradney | 1061 | addedPage->Margins.Top = pageMargins.Top; |
1062 | addedPage->Margins.Bottom = pageMargins.Bottom; |
||
3912 | cbradney | 1063 | addedPage->Margins.Left = pageMargins.Left;//todo fix for layouts |
3911 | cbradney | 1064 | addedPage->Margins.Right = pageMargins.Right; |
3695 | cbradney | 1065 | addedPage->initialMargins.Top = pageMargins.Top; |
1066 | addedPage->initialMargins.Bottom = pageMargins.Bottom; |
||
1067 | addedPage->initialMargins.Left = pageMargins.Left; |
||
1068 | addedPage->initialMargins.Right = pageMargins.Right; |
||
1069 | addedPage->PageSize = PageSize; |
||
1070 | addedPage->PageOri = PageOri; |
||
3787 | cbradney | 1071 | addedPage->MPageNam = ""; |
3695 | cbradney | 1072 | addedPage->setPageName(pageName); |
4715 | fschmid | 1073 | addedPage->setPageNr(pageNumber); |
3695 | cbradney | 1074 | MasterNames.insert(pageName, pageNumber); |
1075 | bool insertsuccess=MasterPages.insert(pageNumber, addedPage); |
||
1076 | Q_ASSERT(insertsuccess==true && MasterPages.at(pageNumber)!=NULL); |
||
1077 | return addedPage; |
||
1078 | } |
||
1079 | |||
6955 | cbradney | 1080 | bool ScribusDoc::renameMasterPage(const QString& oldPageName, const QString& newPageName) |
1081 | { |
||
1082 | Q_ASSERT(oldPageName!=CommonStrings::masterPageNormal && oldPageName!=CommonStrings::trMasterPageNormal); |
||
1083 | if (MasterNames.contains(oldPageName) && !MasterNames.contains(newPageName)) |
||
1084 | { |
||
1085 | //Rename our master page lists |
||
1086 | int number=MasterNames[oldPageName]; |
||
1087 | MasterNames.insert(newPageName, number); |
||
1088 | MasterNames.remove(oldPageName); |
||
1089 | Q_ASSERT(MasterPages.at(number)->pageName()==oldPageName); |
||
1090 | MasterPages.at(number)->setPageName(newPageName); |
||
1091 | //Update any pages that were linking to our old name |
||
1092 | for (Page* docPage = DocPages.first(); docPage; docPage = DocPages.next() ) |
||
1093 | { |
||
1094 | if (docPage->MPageNam == oldPageName) |
||
1095 | docPage->MPageNam = newPageName; |
||
1096 | } |
||
1097 | //Update any items that were linking to our old name |
||
1098 | uint masterItemsCount=MasterItems.count(); |
||
1099 | for (uint i = 0; i < masterItemsCount; ++i) |
||
1100 | { |
||
1101 | if (MasterItems.at(i)->OnMasterPage == oldPageName) |
||
1102 | MasterItems.at(i)->OnMasterPage = newPageName; |
||
1103 | } |
||
1104 | changed(); |
||
1105 | return true; |
||
1106 | } |
||
1107 | return false; |
||
1108 | } |
||
1109 | |||
4069 | craig | 1110 | void ScribusDoc::deleteMasterPage(const int pageNumber) |
2895 | cbradney | 1111 | { |
4166 | fschmid | 1112 | Q_ASSERT( Pages->count() > 1 && Pages->count() > static_cast<uint>(pageNumber) ); |
4069 | craig | 1113 | Page* page = Pages->at(pageNumber); |
4615 | cbradney | 1114 | QString oldPageName=page->PageNam; |
4069 | craig | 1115 | Pages->remove(pageNumber); |
1116 | delete page; |
||
1117 | // remove the master page from the master page name list |
||
4615 | cbradney | 1118 | //MasterNames.remove(page->PageNam); |
1119 | /*CB TODO moved back to muster.cpp for now as this must happen after reformPages |
||
1120 | MasterNames.clear(); |
||
1121 | for (uint a = 0; a < Pages->count(); ++a) |
||
1122 | MasterNames[Pages->at(a)->PageNam] = Pages->at(a)->pageNr(); |
||
4069 | craig | 1123 | // and fix up any pages that refer to the deleted master page |
1124 | for (Page* docPage = DocPages.first(); docPage; docPage = DocPages.next() ) |
||
2895 | cbradney | 1125 | { |
4615 | cbradney | 1126 | if (docPage->MPageNam == oldPageName) |
4069 | craig | 1127 | docPage->MPageNam = "Normal"; |
2895 | cbradney | 1128 | } |
4615 | cbradney | 1129 | */ |
4730 | subik | 1130 | //QPtrList docs: The item after the removed item becomes the new current list item if the removed item is not the last item in the list. If the last item is removed, the new last item becomes the current item. |
4615 | cbradney | 1131 | currentPage = Pages->at(0); |
4069 | craig | 1132 | } |
1133 | |||
10158 | jghali | 1134 | void ScribusDoc::rebuildMasterNames(void) |
1135 | { |
||
1136 | MasterNames.clear(); |
||
1137 | for (uint a = 0; a < MasterPages.count(); ++a) |
||
1138 | MasterNames[MasterPages.at(a)->pageName()] = MasterPages.at(a)->pageNr(); |
||
1139 | } |
||
1140 | |||
1141 | void ScribusDoc::replaceMasterPage(const QString& oldMasterPage) |
||
1142 | { |
||
1143 | for (Page* docPage = DocPages.first(); docPage; docPage = DocPages.next() ) |
||
1144 | { |
||
1145 | if (docPage->MPageNam == oldMasterPage) |
||
1146 | docPage->MPageNam = "Normal"; |
||
1147 | } |
||
1148 | } |
||
1149 | |||
4069 | craig | 1150 | void ScribusDoc::deletePage(const int pageNumber) |
1151 | { |
||
4166 | fschmid | 1152 | Q_ASSERT( Pages->count() > 1 && Pages->count() > static_cast<uint>(pageNumber) ); |
4069 | craig | 1153 | Page* page = Pages->at(pageNumber); |
3724 | cbradney | 1154 | Pages->remove(pageNumber); |
4069 | craig | 1155 | delete page; |
3724 | cbradney | 1156 | currentPage = Pages->at(0); |
2895 | cbradney | 1157 | } |
1158 | |||
1159 | void ScribusDoc::movePage(const int from, const int to, const int ziel, const int art) |
||
1160 | { |
||
1161 | QPtrList<Page> Buf; |
||
1162 | int zz = ziel; |
||
1163 | Buf.clear(); |
||
3778 | cbradney | 1164 | for (int a = from; a < to; ++a) |
2895 | cbradney | 1165 | { |
3724 | cbradney | 1166 | Buf.append(Pages->at(from)); |
1167 | Pages->remove(from); |
||
2895 | cbradney | 1168 | if (a <= zz) |
3778 | cbradney | 1169 | --zz; |
2895 | cbradney | 1170 | } |
3778 | cbradney | 1171 | uint bufCount=Buf.count(); |
2895 | cbradney | 1172 | switch (art) |
1173 | { |
||
1174 | case 0: |
||
3778 | cbradney | 1175 | for (uint b = 0; b < bufCount; ++b) |
3724 | cbradney | 1176 | Pages->insert(zz++, Buf.at(b)); |
2895 | cbradney | 1177 | break; |
1178 | case 1: |
||
3778 | cbradney | 1179 | for (uint b = 0; b < bufCount; ++b) |
3724 | cbradney | 1180 | Pages->insert(++zz, Buf.at(b)); |
2895 | cbradney | 1181 | break; |
1182 | case 2: |
||
3778 | cbradney | 1183 | for (uint b = 0; b < bufCount; ++b) |
3724 | cbradney | 1184 | Pages->append(Buf.at(b)); |
2895 | cbradney | 1185 | break; |
1186 | } |
||
1187 | } |
||
2937 | cbradney | 1188 | |
3985 | cbradney | 1189 | int ScribusDoc::addAutomaticTextFrame(const int pageNumber) |
3778 | cbradney | 1190 | { |
3852 | cbradney | 1191 | if (!automaticTextFrames) |
1192 | return -1; |
||
3778 | cbradney | 1193 | Page *addToPage=DocPages.at(pageNumber); |
3843 | cbradney | 1194 | if ((!masterPageMode()) && (usesAutomaticTextFrames()))// && (!isLoading())) |
3778 | cbradney | 1195 | { |
4546 | subik | 1196 | int z = itemAdd(PageItem::TextFrame, PageItem::Unspecified, |
3778 | cbradney | 1197 | addToPage->Margins.Left+addToPage->xOffset(), |
1198 | addToPage->Margins.Top+addToPage->yOffset(), pageWidth-addToPage->Margins.Right-addToPage->Margins.Left, |
||
1199 | pageHeight-addToPage->Margins.Bottom-addToPage->Margins.Top, |
||
4546 | subik | 1200 | 1, CommonStrings::None, toolSettings.dPen, true); |
3778 | cbradney | 1201 | Items->at(z)->isAutoText = true; |
1202 | Items->at(z)->BackBox = LastAuto; |
||
1203 | Items->at(z)->Cols = qRound(PageSp); |
||
1204 | Items->at(z)->ColGap = PageSpa; |
||
1205 | if (LastAuto != 0) |
||
1206 | LastAuto->NextBox = Items->at(z); |
||
1207 | else |
||
1208 | FirstAuto = Items->at(z); |
||
1209 | LastAuto = Items->at(z); |
||
1210 | Items->at(z)->setRedrawBounding(); |
||
3781 | cbradney | 1211 | return z; |
3778 | cbradney | 1212 | } |
3781 | cbradney | 1213 | return -1; |
3778 | cbradney | 1214 | } |
1215 | |||
4645 | subik | 1216 | int ScribusDoc::addLayer(const QString& layerName, const bool activate) |
2937 | cbradney | 1217 | { |
1218 | struct Layer ll; |
||
1219 | ll.LNr = Layers.last().LNr + 1; |
||
1220 | ll.Level = Layers.count(); |
||
1221 | if (layerName.isNull() || layerName.isEmpty()) |
||
1222 | { |
||
1223 | QString tmp; |
||
1224 | ll.Name = tr("New Layer")+" "+tmp.setNum(ll.LNr); |
||
1225 | } |
||
1226 | else |
||
1227 | ll.Name = layerName; |
||
1228 | ll.isViewable = true; |
||
1229 | ll.isPrintable = true; |
||
4832 | fschmid | 1230 | ll.isEditable = true; |
2937 | cbradney | 1231 | Layers.append(ll); |
1232 | if (activate) |
||
1233 | setActiveLayer(ll.LNr); |
||
3201 | subik | 1234 | |
2937 | cbradney | 1235 | if (UndoManager::undoEnabled()) |
1236 | { |
||
1237 | SimpleState *ss = new SimpleState(Um::AddLayer, "", Um::ICreate); |
||
1238 | ss->set("ADD_LAYER", "add_layer"); |
||
1239 | ss->set("ACTIVE", ActiveLayer); |
||
2944 | cbradney | 1240 | ss->set("NAME", ll.Name); |
2937 | cbradney | 1241 | ss->set("LAYER_NR", ll.LNr); |
1242 | undoManager->action(this, ss, DocName, Um::ILayer); |
||
1243 | } |
||
2944 | cbradney | 1244 | return ll.LNr; |
2937 | cbradney | 1245 | } |
1246 | |||
3985 | cbradney | 1247 | bool ScribusDoc::deleteLayer(const int layerNumber, const bool deleteItems) |
2937 | cbradney | 1248 | { |
1249 | if (Layers.count() < 2) |
||
1250 | return false; |
||
1251 | QValueList<Layer>::iterator it2; |
||
1252 | QValueList<Layer>::iterator it2end=Layers.end(); |
||
1253 | bool found=false; |
||
1254 | int layerLevel; |
||
1255 | for (it2 = Layers.begin(); it2 != it2end; ++it2) |
||
1256 | { |
||
1257 | if ((*it2).LNr == layerNumber) |
||
1258 | { |
||
1259 | layerLevel=(*it2).Level; |
||
1260 | found=true; |
||
1261 | break; |
||
1262 | } |
||
1263 | } |
||
1264 | if (!found) |
||
1265 | return false; |
||
2944 | cbradney | 1266 | if (UndoManager::undoEnabled()) |
1267 | undoManager->beginTransaction("Layer", Um::IDocument, Um::DeleteLayer, "", Um::IDelete); |
||
1268 | |||
2952 | cbradney | 1269 | if (ScQApp->usingGUI()) |
4713 | cbradney | 1270 | removeLayer(layerNumber, deleteItems); |
2937 | cbradney | 1271 | /* |
1272 | //Layer found, do we want to delete its items too? |
||
1273 | if (masterPageMode) |
||
1274 | MasterPages = Pages; |
||
1275 | else |
||
1276 | DocPages = Pages; |
||
1277 | for (uint b = 0; b < MasterItems.count(); ++b) |
||
1278 | { |
||
1279 | if (MasterItems.at(b)->LayerNr == layerNumber) |
||
1280 | { |
||
1281 | if (deleteItems) |
||
1282 | { |
||
1283 | MasterItems.at(b)->setTagged(true); |
||
1284 | DocItems.at(b)->setLocked(false); |
||
1285 | } |
||
1286 | else |
||
1287 | MasterItems.at(b)->setTagged(false); |
||
1288 | } |
||
1289 | } |
||
1290 | // if (view->SelItem.count() != 0) |
||
1291 | // view->DeleteItem(); |
||
1292 | // view->SelItem.clear(); |
||
1293 | for (uint b = 0; b < DocItems.count(); ++b) |
||
1294 | { |
||
1295 | if (DocItems.at(b)->LayerNr == l) |
||
1296 | { |
||
1297 | if (deleteItems) |
||
1298 | { |
||
1299 | DocItems.at(b)->setTagged(true); |
||
1300 | DocItems.at(b)->setLocked(false); |
||
1301 | } |
||
1302 | else |
||
1303 | DocItems.at(b)->setLayer(0); |
||
1304 | } |
||
1305 | } |
||
1306 | // if (view->SelItem.count() != 0) |
||
1307 | // view->DeleteItem(); |
||
1308 | |||
1309 | bool deletedOk=deleteTaggedItems(); |
||
1310 | Q_ASSERT(deletedOk); |
||
3201 | subik | 1311 | |
2937 | cbradney | 1312 | */ |
1313 | //Now delete the layer |
||
3201 | subik | 1314 | |
2937 | cbradney | 1315 | QString name = (*it2).Name; |
1316 | Layers.remove(it2); |
||
1317 | QValueList<Layer>::iterator it; |
||
1318 | QValueList<Layer>::iterator itend=Layers.end(); |
||
1319 | for (it = Layers.begin(); it != itend; ++it) |
||
1320 | { |
||
1321 | if ((*it).Level > layerLevel) |
||
1322 | (*it).Level -= 1; |
||
1323 | } |
||
1324 | if (UndoManager::undoEnabled()) |
||
1325 | { |
||
1326 | SimpleState *ss = new SimpleState(Um::DeleteLayer, "", Um::IDelete); |
||
1327 | ss->set("REMOVE_LAYER", "remove_layer"); |
||
1328 | ss->set("ACTIVE", layerNumber); |
||
1329 | ss->set("LEVEL", layerLevel); |
||
1330 | ss->set("NAME", name); |
||
1331 | ss->set("LAYER_NR", layerNumber); |
||
1332 | ss->set("DELETE", deleteItems); |
||
1333 | undoManager->action(this, ss, DocName, Um::ILayer); |
||
1334 | undoManager->commit(); |
||
1335 | } |
||
2944 | cbradney | 1336 | setActiveLayer(layerNumberFromLevel(0)); |
2947 | cbradney | 1337 | return true; |
2937 | cbradney | 1338 | } |
1339 | |||
3985 | cbradney | 1340 | int ScribusDoc::activeLayer() |
2937 | cbradney | 1341 | { |
1342 | return ActiveLayer; |
||
1343 | } |
||
1344 | |||
1345 | const QString& ScribusDoc::activeLayerName() |
||
1346 | { |
||
1347 | QValueList<Layer>::iterator itend=Layers.end(); |
||
1348 | QValueList<Layer>::iterator it; |
||
1349 | bool found=false; |
||
1350 | for (it = Layers.begin(); it != itend; ++it) |
||
1351 | { |
||
1352 | if ((*it).LNr == ActiveLayer) |
||
1353 | { |
||
1354 | found=true; |
||
1355 | break; |
||
1356 | } |
||
1357 | } |
||
1358 | Q_ASSERT(found); |
||
1359 | return (*it).Name; |
||
1360 | } |
||
1361 | |||
3985 | cbradney | 1362 | bool ScribusDoc::setActiveLayer(const int layerToActivate) |
2937 | cbradney | 1363 | { |
1364 | bool found=false; |
||
2948 | cbradney | 1365 | uint layerCount=Layers.count(); |
4546 | subik | 1366 | |
2937 | cbradney | 1367 | for (uint i=0; i < layerCount; ++i) |
1368 | { |
||
1369 | if (Layers[i].LNr == layerToActivate) |
||
1370 | { |
||
1371 | found = true; |
||
1372 | break; |
||
1373 | } |
||
1374 | } |
||
3855 | cbradney | 1375 | Q_ASSERT(found); |
2937 | cbradney | 1376 | if (found) |
1377 | ActiveLayer=layerToActivate; |
||
1378 | return found; |
||
1379 | } |
||
1380 | |||
3985 | cbradney | 1381 | bool ScribusDoc::setActiveLayer(const QString& layerNameToActivate) |
2937 | cbradney | 1382 | { |
1383 | bool found=false; |
||
2948 | cbradney | 1384 | uint layerCount=Layers.count(); |
2937 | cbradney | 1385 | uint i; |
1386 | for (i=0; i < layerCount; ++i) |
||
1387 | { |
||
1388 | if (Layers[i].Name == layerNameToActivate) |
||
1389 | { |
||
1390 | found = true; |
||
1391 | break; |
||
1392 | } |
||
1393 | } |
||
1394 | if (found) |
||
1395 | ActiveLayer=Layers[i].LNr; |
||
1396 | return found; |
||
1397 | } |
||
1398 | |||
3985 | cbradney | 1399 | bool ScribusDoc::setLayerPrintable(const int layerNumber, const bool isPrintable) |
2937 | cbradney | 1400 | { |
1401 | QValueList<Layer>::iterator itend=Layers.end(); |
||
1402 | QValueList<Layer>::iterator it; |
||
1403 | bool found=false; |
||
1404 | for (it = Layers.begin(); it != itend; ++it) |
||
1405 | { |
||
1406 | if ((*it).LNr == layerNumber) |
||
1407 | { |
||
1408 | bool oldPrintable = (*it).isPrintable; |
||
1409 | (*it).isPrintable = isPrintable; |
||
3201 | subik | 1410 | |
2937 | cbradney | 1411 | if (oldPrintable!=isPrintable && UndoManager::undoEnabled()) |
1412 | { |
||
1413 | SimpleState *ss = new SimpleState(isPrintable ? Um::PrintLayer : Um::DoNotPrintLayer, |
||
1414 | "", Um::IPrint); |
||
1415 | ss->set("PRINT_LAYER", "print_layer"); |
||
1416 | ss->set("ACTIVE", (*it).LNr); |
||
1417 | ss->set("PRINT", isPrintable); |
||
1418 | undoManager->action(this, ss, DocName, Um::IDocument); |
||
1419 | } |
||
1420 | found=true; |
||
1421 | break; |
||
1422 | } |
||
1423 | } |
||
1424 | return found; |
||
1425 | } |
||
1426 | |||
3985 | cbradney | 1427 | bool ScribusDoc::layerPrintable(const int layerNumber) |
2937 | cbradney | 1428 | { |
1429 | QValueList<Layer>::iterator itend=Layers.end(); |
||
1430 | QValueList<Layer>::iterator it; |
||
1431 | for (it = Layers.begin(); it != itend; ++it) |
||
1432 | { |
||
1433 | if ((*it).LNr == layerNumber) |
||
1434 | return (*it).isPrintable; |
||
1435 | } |
||
1436 | return false; |
||
1437 | } |
||
1438 | |||
3985 | cbradney | 1439 | bool ScribusDoc::setLayerVisible(const int layerNumber, const bool isViewable) |
2937 | cbradney | 1440 | { |
1441 | QValueList<Layer>::iterator itend=Layers.end(); |
||
1442 | QValueList<Layer>::iterator it; |
||
1443 | bool found=false; |
||
1444 | for (it = Layers.begin(); it != itend; ++it) |
||
1445 | { |
||
1446 | if ((*it).LNr == layerNumber) |
||
1447 | { |
||
1448 | (*it).isViewable = isViewable; |
||
1449 | found=true; |
||
1450 | break; |
||
1451 | } |
||
1452 | } |
||
1453 | return found; |
||
1454 | } |
||
1455 | |||
3985 | cbradney | 1456 | bool ScribusDoc::layerVisible(const int layerNumber) |
2937 | cbradney | 1457 | { |
1458 | QValueList<Layer>::iterator itend=Layers.end(); |
||
1459 | QValueList<Layer>::iterator it; |
||
1460 | for (it = Layers.begin(); it != itend; ++it) |
||
1461 | { |
||
1462 | if ((*it).LNr == layerNumber) |
||
1463 | return (*it).isViewable; |
||
1464 | } |
||
1465 | return false; |
||
1466 | } |
||
1467 | |||
4832 | fschmid | 1468 | bool ScribusDoc::setLayerLocked(const int layerNumber, const bool isLocked) |
1469 | { |
||
1470 | QValueList<Layer>::iterator itend=Layers.end(); |
||
1471 | QValueList<Layer>::iterator it; |
||
1472 | bool found=false; |
||
1473 | for (it = Layers.begin(); it != itend; ++it) |
||
1474 | { |
||
1475 | if ((*it).LNr == layerNumber) |
||
1476 | { |
||
1477 | (*it).isEditable = !isLocked; |
||
1478 | found=true; |
||
1479 | break; |
||
1480 | } |
||
1481 | } |
||
1482 | return found; |
||
1483 | } |
||
1484 | |||
1485 | bool ScribusDoc::layerLocked(const int layerNumber) |
||
1486 | { |
||
1487 | QValueList<Layer>::iterator itend=Layers.end(); |
||
1488 | QValueList<Layer>::iterator it; |
||
1489 | for (it = Layers.begin(); it != itend; ++it) |
||
1490 | { |
||
1491 | if ((*it).LNr == layerNumber) |
||
1492 | return !(*it).isEditable; |
||
1493 | } |
||
1494 | return false; |
||
1495 | } |
||
1496 | |||
3985 | cbradney | 1497 | int ScribusDoc::layerLevelFromNumber(const int layerNumber) |
2937 | cbradney | 1498 | { |
2948 | cbradney | 1499 | uint layerCount=Layers.count(); |
2937 | cbradney | 1500 | for (uint i=0; i < layerCount; ++i) |
1501 | { |
||
1502 | if (Layers[i].LNr == layerNumber) |
||
1503 | return Layers[i].Level; |
||
1504 | } |
||
1505 | return -1; |
||
1506 | } |
||
1507 | |||
3985 | cbradney | 1508 | int ScribusDoc::layerCount() const |
2937 | cbradney | 1509 | { |
1510 | return Layers.count(); |
||
1511 | } |
||
1512 | |||
3985 | cbradney | 1513 | int ScribusDoc::layerNumberFromLevel(const int layerLevel) |
2937 | cbradney | 1514 | { |
2948 | cbradney | 1515 | uint layerCount=Layers.count(); |
2937 | cbradney | 1516 | for (uint i=0; i < layerCount; ++i) |
1517 | { |
||
1518 | if (Layers[i].Level == layerLevel) |
||
1519 | return Layers[i].LNr; |
||
1520 | } |
||
1521 | return -1; |
||
1522 | } |
||
1523 | |||
3985 | cbradney | 1524 | bool ScribusDoc::lowerLayer(const int layerNumber) |
2937 | cbradney | 1525 | { |
2942 | mrdocs | 1526 | return lowerLayerByLevel(layerLevelFromNumber(layerNumber)); |
2941 | cbradney | 1527 | } |
1528 | |||
3985 | cbradney | 1529 | bool ScribusDoc::lowerLayerByLevel(const int layerLevel) |
2941 | cbradney | 1530 | { |
2937 | cbradney | 1531 | if (Layers.count() < 2) |
1532 | return false; |
||
1533 | if (UndoManager::undoEnabled()) |
||
1534 | { |
||
1535 | SimpleState *ss = new SimpleState(Um::LowerLayer, "", Um::IDown); |
||
1536 | ss->set("DOWN_LAYER", "down_layer"); |
||
2941 | cbradney | 1537 | ss->set("ACTIVE", layerLevel-1); |
2937 | cbradney | 1538 | undoManager->action(this, ss, DocName, Um::ILayer); |
1539 | } |
||
3201 | subik | 1540 | |
2937 | cbradney | 1541 | QValueList<Layer>::iterator it; |
1542 | QValueList<Layer>::iterator itend=Layers.end(); |
||
1543 | for (it = Layers.begin(); it != itend; ++it) |
||
1544 | { |
||
2941 | cbradney | 1545 | if ((*it).Level == layerLevel-1) |
2937 | cbradney | 1546 | break; |
1547 | } |
||
1548 | QValueList<Layer>::iterator it2; |
||
1549 | QValueList<Layer>::iterator it2end=Layers.end(); |
||
1550 | for (it2 = Layers.begin(); it2 != it2end; ++it2) |
||
1551 | { |
||
2941 | cbradney | 1552 | if ((*it2).Level == layerLevel) |
2937 | cbradney | 1553 | break; |
1554 | } |
||
1555 | (*it2).Level -= 1; |
||
1556 | (*it).Level += 1; |
||
1557 | return true; |
||
1558 | } |
||
1559 | |||
3985 | cbradney | 1560 | bool ScribusDoc::raiseLayer(const int layerNumber) |
2937 | cbradney | 1561 | { |
2942 | mrdocs | 1562 | return raiseLayerByLevel(layerLevelFromNumber(layerNumber)); |
2941 | cbradney | 1563 | } |
1564 | |||
3985 | cbradney | 1565 | bool ScribusDoc::raiseLayerByLevel(const int layerLevel) |
2941 | cbradney | 1566 | { |
2937 | cbradney | 1567 | if (Layers.count() < 2) |
1568 | return false; |
||
1569 | if (UndoManager::undoEnabled()) |
||
1570 | { |
||
1571 | SimpleState *ss = new SimpleState(Um::RaiseLayer, "", Um::IUp); |
||
1572 | ss->set("UP_LAYER", "up_layer"); |
||
2941 | cbradney | 1573 | ss->set("ACTIVE", layerLevel+1); |
2937 | cbradney | 1574 | undoManager->action(this, ss, DocName, Um::ILayer); |
1575 | } |
||
3201 | subik | 1576 | |
2937 | cbradney | 1577 | QValueList<Layer>::iterator it; |
1578 | QValueList<Layer>::iterator itend=Layers.end(); |
||
1579 | for (it = Layers.begin(); it != itend; ++it) |
||
1580 | { |
||
2941 | cbradney | 1581 | if ((*it).Level == layerLevel+1) |
2937 | cbradney | 1582 | break; |
1583 | } |
||
1584 | QValueList<Layer>::iterator it2; |
||
1585 | QValueList<Layer>::iterator it2end=Layers.end(); |
||
1586 | for (it2 = Layers.begin(); it2 != it2end; ++it2) |
||
1587 | { |
||
2941 | cbradney | 1588 | if ((*it2).Level == layerLevel) |
2937 | cbradney | 1589 | break; |
1590 | } |
||
1591 | (*it2).Level += 1; |
||
1592 | (*it).Level -= 1; |
||
1593 | return true; |
||
1594 | } |
||
1595 | |||
3985 | cbradney | 1596 | const QString& ScribusDoc::layerName(const int layerNumber) const |
2937 | cbradney | 1597 | { |
2948 | cbradney | 1598 | uint layerCount=Layers.count(); |
2937 | cbradney | 1599 | for (uint i=0; i < layerCount; ++i) |
1600 | { |
||
1601 | if (Layers[i].LNr == layerNumber) |
||
1602 | return Layers[i].Name; |
||
1603 | } |
||
1604 | return QString::null; |
||
1605 | } |
||
1606 | |||
3985 | cbradney | 1607 | bool ScribusDoc::changeLayerName(const int layerNumber, const QString& newName) |
2937 | cbradney | 1608 | { |
2948 | cbradney | 1609 | uint layerCount=Layers.count(); |
2947 | cbradney | 1610 | bool found=false; |
2937 | cbradney | 1611 | for (uint i=0; i < layerCount; ++i) |
1612 | { |
||
1613 | if (Layers[i].LNr == layerNumber) |
||
1614 | { |
||
1615 | if (UndoManager::undoEnabled()) |
||
1616 | { |
||
1617 | SimpleState *ss = new SimpleState(Um::SetLayerName, |
||
1618 | QString(Um::FromTo).arg(Layers[i].Name).arg(newName), |
||
1619 | Um::IDown); |
||
1620 | ss->set("CHANGE_NAME", "change_name"); |
||
2938 | cbradney | 1621 | ss->set("ACTIVE", ActiveLayer); |
2937 | cbradney | 1622 | ss->set("NEW_NAME", newName); |
1623 | ss->set("OLD_NAME", Layers[i].Name); |
||
1624 | undoManager->action(this, ss, DocName, Um::ILayer); |
||
1625 | } |
||
1626 | Layers[i].Name = newName; |
||
2947 | cbradney | 1627 | found=true; |
1628 | break; |
||
2937 | cbradney | 1629 | } |
1630 | } |
||
2947 | cbradney | 1631 | return found; |
2937 | cbradney | 1632 | } |
1633 | |||
3985 | cbradney | 1634 | bool ScribusDoc::layerContainsItems(const int layerNumber) |
2937 | cbradney | 1635 | { |
2948 | cbradney | 1636 | uint masterItemsCount=MasterItems.count(); |
2937 | cbradney | 1637 | for (uint i = 0; i < masterItemsCount; ++i) |
1638 | { |
||
1639 | if (MasterItems.at(i)->LayerNr == layerNumber) |
||
1640 | return true; |
||
1641 | } |
||
2948 | cbradney | 1642 | uint docItemsCount=DocItems.count(); |
2937 | cbradney | 1643 | for (uint i = 0; i < docItemsCount; ++i) |
1644 | { |
||
1645 | if (DocItems.at(i)->LayerNr == layerNumber) |
||
1646 | return true; |
||
1647 | } |
||
1648 | return false; |
||
1649 | } |
||
1650 | |||
1651 | void ScribusDoc::orderedLayerList(QStringList* list) |
||
1652 | { |
||
1653 | Q_ASSERT(list!=NULL); |
||
2948 | cbradney | 1654 | uint layerCount=Layers.count(); |
1655 | if (layerCount != 0) |
||
2937 | cbradney | 1656 | { |
2948 | cbradney | 1657 | for (uint i=0; i < layerCount; ++i) |
2937 | cbradney | 1658 | { |
2948 | cbradney | 1659 | QValueList<Layer>::iterator itend=Layers.end(); |
1660 | for (QValueList<Layer>::iterator it = Layers.begin(); it != itend; ++it) |
||
2937 | cbradney | 1661 | { |
2948 | cbradney | 1662 | if (layerCount-(*it).Level-1 == i) |
2937 | cbradney | 1663 | list->append((*it).Name); |
1664 | } |
||
1665 | } |
||
1666 | } |
||
1667 | } |
||
1668 | |||
3985 | cbradney | 1669 | bool ScribusDoc::renumberLayer(const int layerNumber, const int newLayerNumber) |
2944 | cbradney | 1670 | { |
2948 | cbradney | 1671 | uint layerCount=Layers.count(); |
1672 | uint foundIndex; |
||
1673 | bool found=false; |
||
2944 | cbradney | 1674 | //Find layer to renumber, if found the new number, return as it exists already. |
1675 | for (uint i=0; i < layerCount; ++i) |
||
1676 | { |
||
1677 | if (Layers[i].LNr == layerNumber) |
||
2948 | cbradney | 1678 | { |
2944 | cbradney | 1679 | foundIndex=i; |
2948 | cbradney | 1680 | found=true; |
1681 | } |
||
2944 | cbradney | 1682 | else |
1683 | if (Layers[i].LNr == newLayerNumber) |
||
1684 | return false; |
||
1685 | } |
||
2948 | cbradney | 1686 | if (!found) |
2944 | cbradney | 1687 | return false; |
1688 | Layers[foundIndex].LNr=newLayerNumber; |
||
1689 | return true; |
||
1690 | } |
||
1691 | |||
2937 | cbradney | 1692 | //Make the doc delete the items, not the view. TODO: Currently does nada, zilch, zero |
3985 | cbradney | 1693 | bool ScribusDoc::deleteTaggedItems() |
2937 | cbradney | 1694 | { |
1695 | QString tooltip = Um::ItemsInvolved + "\n"; |
||
1696 | //Master Items |
||
1697 | for (uint b = 0; b < MasterItems.count(); ++b) |
||
1698 | { |
||
1699 | if (MasterItems.at(b)->isTagged()) |
||
1700 | { |
||
1701 | } |
||
1702 | } |
||
1703 | //Doc Items |
||
1704 | for (uint b = 0; b < DocItems.count(); ++b) |
||
1705 | { |
||
1706 | if (DocItems.at(b)->isTagged()) |
||
1707 | { |
||
1708 | } |
||
1709 | } |
||
1710 | return true; |
||
2944 | cbradney | 1711 | } |
1712 | |||
8981 | jghali | 1713 | void ScribusDoc::replaceItemColors(QPtrList<PageItem>& itemList, const QMap<QString, QString>& colorMap) |
1714 | { |
||
1715 | uint c, d; |
||
1716 | QColor tmpc; |
||
1717 | PageItem *ite; |
||
1718 | QMap<QString,QString>::ConstIterator it; |
||
1719 | for (it = colorMap.begin(); it != colorMap.end(); ++it) |
||
1720 | { |
||
1721 | for (c=0; c < itemList.count(); ++c) |
||
1722 | { |
||
1723 | ite = itemList.at(c); |
||
1724 | if ((ite->asTextFrame()) || (ite->asPathText())) |
||
1725 | { |
||
1726 | for (d=0; d< ite->itemText.count(); ++d) |
||
1727 | { |
||
1728 | if (it.key() == ite->itemText.at(d)->ccolor) |
||
1729 | ite->itemText.at(d)->ccolor = it.data(); |
||
1730 | if (it.key() == ite->itemText.at(d)->cstroke) |
||
1731 | ite->itemText.at(d)->cstroke = it.data(); |
||
1732 | } |
||
1733 | } |
||
1734 | if (it.key() == ite->fillColor()) |
||
1735 | ite->setFillColor(it.data()); |
||
1736 | if (it.key() == ite->lineColor()) |
||
1737 | ite->setLineColor(it.data()); |
||
1738 | QPtrVector<VColorStop> cstops = ite->fill_gradient.colorStops(); |
||
1739 | for (uint cst = 0; cst < ite->fill_gradient.Stops(); ++cst) |
||
1740 | { |
||
1741 | if (it.key() == cstops.at(cst)->name) |
||
1742 | { |
||
1743 | ite->SetFarbe(&tmpc, it.data(), cstops.at(cst)->shade); |
||
1744 | cstops.at(cst)->color = tmpc; |
||
1745 | cstops.at(cst)->name = it.data(); |
||
1746 | } |
||
1747 | } |
||
1748 | } |
||
1749 | } |
||
1750 | } |
||
1751 | |||
1752 | void ScribusDoc::replaceLineStyleColors(const QMap<QString, QString>& colorMap) |
||
1753 | { |
||
1754 | multiLine::iterator its; |
||
1755 | QMap<QString, QString>::const_iterator it; |
||
1756 | QMap<QString,multiLine>::iterator itl; |
||
1757 | for (itl = MLineStyles.begin(); itl != MLineStyles.end(); ++itl) |
||
1758 | { |
||
1759 | multiLine& mline = itl.data(); |
||
1760 | for (its = mline.begin(); its != mline.end(); ++its) |
||
1761 | { |
||
1762 | struct SingleLine& sline = *its; |
||
1763 | it = colorMap.find(sline.Color); |
||
1764 | if (it != colorMap.end()) |
||
1765 | sline.Color = it.data(); |
||
1766 | } |
||
1767 | } |
||
1768 | } |
||
1769 | |||
1770 | void ScribusDoc::replaceParagraphStyleColors(const QMap<QString, QString>& colorMap) |
||
1771 | { |
||
1772 | QMap<QString, QString>::const_iterator it; |
||
1773 | QValueList<ParagraphStyle>::iterator itp; |
||
1774 | for (itp = docParagraphStyles.begin(); itp != docParagraphStyles.end(); ++itp) |
||
1775 | { |
||
1776 | struct ParagraphStyle& pstyle = *itp; |
||
1777 | it = colorMap.find(pstyle.FColor); |
||
1778 | if (it != colorMap.end()) |
||
1779 | pstyle.FColor = it.data(); |
||
1780 | it = colorMap.find(pstyle.SColor); |
||
1781 | if (it != colorMap.end()) |
||
1782 | pstyle.SColor = it.data(); |
||
1783 | } |
||
1784 | } |
||
1785 | |||
3068 | fschmid | 1786 | void ScribusDoc::getUsedColors(ColorList &colorsToUse, bool spot) |
3057 | fschmid | 1787 | { |
1788 | bool found; |
||
1789 | colorsToUse.clear(); |
||
1790 | ColorList::Iterator it; |
||
1791 | for (it = PageColors.begin(); it != PageColors.end(); ++it) |
||
1792 | { |
||
1793 | found = false; |
||
1794 | if ((it.key() == toolSettings.dBrush) || (it.key() == toolSettings.dPen) || (it.key() == toolSettings.dBrushPict) |
||
1795 | || (it.key() == toolSettings.dPenLine) || (it.key() == toolSettings.dPenText)) |
||
1796 | { |
||
3068 | fschmid | 1797 | if (spot) |
1798 | { |
||
1799 | if (it.data().isSpotColor()) |
||
1800 | colorsToUse.insert(it.key(), it.data()); |
||
1801 | } |
||
1802 | else |
||
1803 | colorsToUse.insert(it.key(), it.data()); |
||
3057 | fschmid | 1804 | continue; |
1805 | } |
||
8936 | jghali | 1806 | if (!found) |
1807 | found = itemsUseColor(MasterItems, it.key()); |
||
1808 | if (!found) |
||
1809 | found = itemsUseColor(DocItems, it.key()); |
||
1810 | if (!found) |
||
1811 | found = itemsUseColor(FrameItems, it.key()); |
||
1812 | if (!found) |
||
1813 | found = lineStylesUseColor(it.key()); |
||
1814 | if (!found) |
||
1815 | found = paragraphStylesUseColor(it.key()); |
||
3057 | fschmid | 1816 | if (found) |
1817 | { |
||
3068 | fschmid | 1818 | if (spot) |
1819 | { |
||
1820 | if (it.data().isSpotColor()) |
||
1821 | colorsToUse.insert(it.key(), it.data()); |
||
1822 | } |
||
1823 | else |
||
1824 | colorsToUse.insert(it.key(), it.data()); |
||
3057 | fschmid | 1825 | continue; |
1826 | } |
||
8936 | jghali | 1827 | } |
1828 | } |
||
1829 | |||
1830 | bool ScribusDoc::itemsUseColor(QPtrList<PageItem>& itemList, const QString& colorName) |
||
1831 | { |
||
1832 | PageItem* ite; |
||
1833 | bool found = false; |
||
1834 | for (uint c = 0; c < itemList.count() && !found; ++c) |
||
1835 | { |
||
1836 | ite = itemList.at(c); |
||
1837 | QPtrVector<VColorStop> cstops = ite->fill_gradient.colorStops(); |
||
1838 | for (uint cst = 0; cst < ite->fill_gradient.Stops() && !found; ++cst) |
||
3057 | fschmid | 1839 | { |
9000 | jghali | 1840 | if (colorName == cstops.at(cst)->name) |
3057 | fschmid | 1841 | found = true; |
1842 | } |
||
8936 | jghali | 1843 | if ((ite->itemType() == PageItem::TextFrame) || (ite->itemType() == PageItem::PathText)) |
3057 | fschmid | 1844 | { |
8936 | jghali | 1845 | for (int d=0; d<ite->itemText.length() && !found; ++d) |
3068 | fschmid | 1846 | { |
9000 | jghali | 1847 | if (colorName == ite->itemText.charStyle(d).ccolor || colorName == ite->itemText.charStyle(d).cstroke) |
8936 | jghali | 1848 | found = true; |
3068 | fschmid | 1849 | } |
3057 | fschmid | 1850 | } |
8936 | jghali | 1851 | /* PFJ - 29.02.04 - merged if's to one line */ |
9000 | jghali | 1852 | if ((colorName == ite->fillColor()) || (colorName == ite->lineColor())) |
8936 | jghali | 1853 | found = true; |
1854 | } |
||
1855 | return found; |
||
1856 | } |
||
1857 | |||
1858 | bool ScribusDoc::lineStylesUseColor(const QString& colorName) |
||
1859 | { |
||
1860 | bool found = false; |
||
1861 | QMap<QString,multiLine>::const_iterator itm, itmend; |
||
1862 | multiLine::const_iterator its, itsend; |
||
1863 | itmend = MLineStyles.constEnd(); |
||
1864 | for (itm = MLineStyles.constBegin(); itm != itmend && !found; ++itm) |
||
1865 | { |
||
1866 | const multiLine& ml = itm.data(); |
||
1867 | itsend = ml.constEnd(); |
||
1868 | for (its = ml.constBegin(); its != itsend; ++its) |
||
3057 | fschmid | 1869 | { |
8936 | jghali | 1870 | if ( its->Color == colorName ) |
3057 | fschmid | 1871 | { |
1872 | found = true; |
||
1873 | break; |
||
8936 | jghali | 1874 | } |
3057 | fschmid | 1875 | } |
8936 | jghali | 1876 | } |
1877 | return found; |
||
1878 | } |
||
1879 | |||
1880 | bool ScribusDoc::paragraphStylesUseColor(const QString& colorName) |
||
1881 | { |
||
1882 | bool found = false; |
||
1883 | QValueList<ParagraphStyle>::const_iterator it, itend; |
||
1884 | itend = docParagraphStyles.constEnd(); |
||
1885 | for (it = docParagraphStyles.constBegin(); it != itend; ++it) |
||
1886 | { |
||
1887 | if ( (*it).FColor == colorName || (*it).SColor == colorName) |
||
3057 | fschmid | 1888 | { |
8936 | jghali | 1889 | found = true; |
1890 | break; |
||
3057 | fschmid | 1891 | } |
1892 | } |
||
8936 | jghali | 1893 | return found; |
3057 | fschmid | 1894 | } |
1895 | |||
3544 | avox | 1896 | void ScribusDoc::getUsedFonts(QMap<QString,int> *Really) |
2960 | cbradney | 1897 | { |
1898 | PageItem* it; |
||
1899 | FPointArray gly; |
||
1900 | QString chx; |
||
1901 | uint counter = 0; |
||
1902 | for (uint lc = 0; lc < 3; ++lc) |
||
1903 | { |
||
1904 | switch (lc) |
||
1905 | { |
||
1906 | case 0: |
||
1907 | counter = MasterItems.count(); |
||
1908 | break; |
||
1909 | case 1: |
||
1910 | counter = DocItems.count(); |
||
1911 | break; |
||
1912 | case 2: |
||
1913 | counter = FrameItems.count(); |
||
1914 | break; |
||
1915 | } |
||
1916 | for (uint d = 0; d < counter; ++d) |
||
1917 | { |
||
1918 | switch (lc) |
||
1919 | { |
||
1920 | case 0: |
||
1921 | it = MasterItems.at(d); |
||
1922 | break; |
||
1923 | case 1: |
||
1924 | it = DocItems.at(d); |
||
1925 | break; |
||
1926 | case 2: |
||
1927 | it = FrameItems.at(d); |
||
1928 | break; |
||
1929 | } |
||
1930 | if ((it->itemType() == PageItem::TextFrame) || (it->itemType() == PageItem::PathText)) |
||
1931 | { |
||
8473 | fschmid | 1932 | if (it->isAnnotation()) |
1933 | Really->insert(it->font(), UsedFonts[it->font()]); |
||
4749 | avox | 1934 | for (int e = 0; e < it->itemText.length(); ++e) |
2960 | cbradney | 1935 | { |
4749 | avox | 1936 | Really->insert(it->itemText.charStyle(e).cfont->scName(), UsedFonts[it->itemText.charStyle(e).cfont->scName()]); |
1937 | uint chr = it->itemText.text(e).unicode(); |
||
2960 | cbradney | 1938 | if ((chr == 13) || (chr == 32) || (chr == 29)) |
1939 | continue; |
||
1940 | if (chr == 9) |
||
1941 | { |
||
1942 | for (uint t1 = 0; t1 < docParagraphStyles[it->itemText.at(e)->cab].TabValues.count(); t1++) |
||
1943 | { |
||
1944 | if (docParagraphStyles[it->itemText.at(e)->cab].TabValues[t1].tabFillChar.isNull()) |
||
1945 | continue; |
||
1946 | chx = QString(docParagraphStyles[it->itemText.at(e)->cab].TabValues[t1].tabFillChar); |
||
4749 | avox | 1947 | if ((it->itemText.charStyle(e).cstyle & ScStyle_SmallCaps) || (it->itemText.charStyle(e).cstyle & ScStyle_AllCaps)) |
2960 | cbradney | 1948 | { |
1949 | if (chx.upper() != QString(docParagraphStyles[it->itemText.at(e)->cab].TabValues[t1].tabFillChar)) |
||
1950 | chx = chx.upper(); |
||
1951 | } |
||
1952 | chr = chx[0].unicode(); |
||
4749 | avox | 1953 | gly = it->itemText.charStyle(e).cfont->GlyphArray[chr].Outlines.copy(); |
1954 | it->itemText.charStyle(e).cfont->RealGlyphs.insert(chr, gly); |
||
2960 | cbradney | 1955 | } |
1956 | for (uint t1 = 0; t1 < it->TabValues.count(); t1++) |
||
1957 | { |
||
1958 | if (it->TabValues[t1].tabFillChar.isNull()) |
||
1959 | continue; |
||
1960 | chx = QString(it->TabValues[t1].tabFillChar); |
||
4749 | avox | 1961 | if ((it->itemText.charStyle(e).cstyle & ScStyle_SmallCaps) || (it->itemText.charStyle(e).cstyle & ScStyle_AllCaps)) |
2960 | cbradney | 1962 | { |
1963 | if (chx.upper() != QString(it->TabValues[t1].tabFillChar)) |
||
1964 | chx = chx.upper(); |
||
1965 | } |
||
1966 | chr = chx[0].unicode(); |
||
4749 | avox | 1967 | gly = it->itemText.charStyle(e).cfont->GlyphArray[chr].Outlines.copy(); |
1968 | it->itemText.charStyle(e).cfont->RealGlyphs.insert(chr, gly); |
||
2960 | cbradney | 1969 | } |
1970 | continue; |
||
1971 | } |
||
1972 | if (chr == 30) |
||
1973 | { |
||
3761 | cbradney | 1974 | /* CB Removed forced loading of 0-9 for section based numbering |
2960 | cbradney | 1975 | for (uint numco = 0x30; numco < 0x3A; ++numco) |
1976 | { |
||
4749 | avox | 1977 | if (it->itemText.charStyle(e)->cfont->CharWidth.contains(numco)) |
2960 | cbradney | 1978 | { |
4749 | avox | 1979 | gly = it->itemText.charStyle(e)->cfont->GlyphArray[numco].Outlines.copy(); |
1980 | it->itemText.charStyle(e)->cfont->RealGlyphs.insert(numco, gly); |
||
2960 | cbradney | 1981 | } |
3761 | cbradney | 1982 | }*/ |
1983 | //Our page number collection string |
||
1984 | QString pageNumberText(QString::null); |
||
1985 | //If not on a master page just get the page number for the page and the text |
||
1986 | if (lc!=0) |
||
1987 | pageNumberText=getSectionPageNumberForPageIndex(it->OwnPage); |
||
1988 | else |
||
1989 | { |
||
1990 | //Else, for a page number in a text frame on a master page we must scan |
||
1991 | //all pages to see which ones use this page and get their page numbers. |
||
1992 | //We only add each character of the pages' page number text if its nothing |
||
1993 | //already in the pageNumberText variable. No need to add glyphs twice. |
||
1994 | QString newText; |
||
1995 | uint docPageCount=DocPages.count(); |
||
1996 | for (uint a = 0; a < docPageCount; ++a) |
||
1997 | { |
||
4784 | fschmid | 1998 | if (DocPages.at(a)->MPageNam == it->OnMasterPage) |
3761 | cbradney | 1999 | { |
2000 | newText=getSectionPageNumberForPageIndex(a); |
||
2001 | for (uint nti=0;nti<newText.length();++nti) |
||
2002 | if (pageNumberText.find(newText[nti])==-1) |
||
2003 | pageNumberText+=newText[nti]; |
||
2004 | } |
||
2005 | } |
||
2960 | cbradney | 2006 | } |
3761 | cbradney | 2007 | //Now scan and add any glyphs used in page numbers |
2008 | for (uint pnti=0;pnti<pageNumberText.length(); ++pnti) |
||
2009 | { |
||
2010 | uint chr = pageNumberText[pnti].unicode(); |
||
4749 | avox | 2011 | if (it->itemText.charStyle(e).cfont->CharWidth.contains(chr)) |
3761 | cbradney | 2012 | { |
4749 | avox | 2013 | FPointArray gly(it->itemText.charStyle(e).cfont->GlyphArray[chr].Outlines.copy()); |
2014 | it->itemText.charStyle(e).cfont->RealGlyphs.insert(chr, gly); |
||
3761 | cbradney | 2015 | } |
2016 | } |
||
2960 | cbradney | 2017 | continue; |
2018 | } |
||
4749 | avox | 2019 | if ((it->itemText.charStyle(e).cstyle & ScStyle_SmallCaps) || (it->itemText.charStyle(e).cstyle & ScStyle_AllCaps)) |
2960 | cbradney | 2020 | { |
4749 | avox | 2021 | chx = it->itemText.text(e, 1); |
2022 | if (chx.upper() != it->itemText.text(e, 1)) |
||
2960 | cbradney | 2023 | chx = chx.upper(); |
2024 | chr = chx[0].unicode(); |
||
2025 | } |
||
4749 | avox | 2026 | if (it->itemText.charStyle(e).cfont->CharWidth.contains(chr)) |
2960 | cbradney | 2027 | { |
4749 | avox | 2028 | gly = it->itemText.charStyle(e).cfont->GlyphArray[chr].Outlines.copy(); |
2029 | it->itemText.charStyle(e).cfont->RealGlyphs.insert(chr, gly); |
||
2960 | cbradney | 2030 | } |
2031 | } |
||
2032 | } |
||
2033 | } |
||
2034 | } |
||
2035 | } |
||
2036 | |||
2037 | void ScribusDoc::reorganiseFonts() |
||
2038 | { |
||
3544 | avox | 2039 | QMap<QString,int> Really; |
2960 | cbradney | 2040 | //QMap<QString,QFont> DocF; |
2041 | //DocF = UsedFonts; |
||
2042 | uint counter = 0; |
||
2043 | for (uint lc = 0; lc < 3; ++lc) |
||
2044 | { |
||
2045 | switch (lc) |
||
2046 | { |
||
2047 | case 0: |
||
2048 | counter = MasterItems.count(); |
||
2049 | break; |
||
2050 | case 1: |
||
2051 | counter = DocItems.count(); |
||
2052 | break; |
||
2053 | case 2: |
||
2054 | counter = FrameItems.count(); |
||
2055 | break; |
||
2056 | } |
||
2057 | PageItem* it; |
||
2058 | for (uint d = 0; d < counter; ++d) |
||
2059 | { |
||
2060 | switch (lc) |
||
2061 | { |
||
2062 | case 0: |
||
2063 | it = MasterItems.at(d); |
||
2064 | break; |
||
2065 | case 1: |
||
2066 | it = DocItems.at(d); |
||
2067 | break; |
||
2068 | case 2: |
||
2069 | it = FrameItems.at(d); |
||
2070 | break; |
||
2071 | } |
||
4073 | cbradney | 2072 | Really.insert(it->font(), UsedFonts[it->font()]); |
2960 | cbradney | 2073 | if ((it->itemType() == PageItem::TextFrame) || (it->itemType() == PageItem::PathText)) |
2074 | { |
||
4749 | avox | 2075 | uint itemTextCount=it->itemText.length(); |
2960 | cbradney | 2076 | for (uint e = 0; e < itemTextCount; ++e) |
2077 | { |
||
4749 | avox | 2078 | Really.insert(it->itemText.charStyle(e).cfont->scName(), UsedFonts[it->itemText.charStyle(e).cfont->scName()]); |
2960 | cbradney | 2079 | } |
2080 | } |
||
2081 | } |
||
2082 | } |
||
3544 | avox | 2083 | QMap<QString,int>::Iterator itfo, itnext; |
2960 | cbradney | 2084 | for (itfo = UsedFonts.begin(); itfo != UsedFonts.end(); itfo = itnext) |
2085 | { |
||
2086 | itnext = itfo; |
||
2087 | ++itnext; |
||
2088 | if (!Really.contains(itfo.key())) |
||
2089 | { |
||
2090 | FT_Done_Face(FFonts[itfo.key()]); |
||
2091 | FFonts.remove(itfo.key()); |
||
2092 | UsedFonts.remove(itfo); |
||
2093 | } |
||
2094 | } |
||
2095 | PrefsManager* prefsManager=PrefsManager::instance(); |
||
3544 | avox | 2096 | AddFont(prefsManager->appPrefs.toolSettings.defFont);//, prefsManager->appPrefs.AvailFonts[prefsManager->appPrefs.toolSettings.defFont]->Font); |
2097 | AddFont(toolSettings.defFont);//, prefsManager->appPrefs.AvailFonts[toolSettings.defFont]->Font); |
||
2960 | cbradney | 2098 | } |
2965 | cbradney | 2099 | |
2100 | void ScribusDoc::setUnitIndex(const int newIndex) |
||
2101 | { |
||
2102 | docUnitIndex=newIndex; |
||
2103 | docUnitRatio = unitGetRatioFromIndex( docUnitIndex ); |
||
2104 | } |
||
2105 | |||
3985 | cbradney | 2106 | int ScribusDoc::unitIndex() const |
2965 | cbradney | 2107 | { |
2108 | return docUnitIndex; |
||
2109 | } |
||
2110 | |||
3985 | cbradney | 2111 | double ScribusDoc::unitRatio() const |
2965 | cbradney | 2112 | { |
2113 | return docUnitRatio; |
||
2114 | } |
||
3004 | cbradney | 2115 | |
3985 | cbradney | 2116 | bool ScribusDoc::applyMasterPage(const QString& in, const int pageNumber) |
3004 | cbradney | 2117 | { |
2118 | if (UndoManager::undoEnabled()) |
||
2119 | { |
||
3817 | cbradney | 2120 | if (DocPages.at(pageNumber)->MPageNam != in) |
3004 | cbradney | 2121 | { |
3817 | cbradney | 2122 | SimpleState *ss = new SimpleState(Um::ApplyMasterPage, QString(Um::FromTo).arg(DocPages.at(pageNumber)->MPageNam).arg(in)); |
3004 | cbradney | 2123 | ss->set("PAGE_NUMBER", pageNumber); |
3817 | cbradney | 2124 | ss->set("OLD_MASTERPAGE", DocPages.at(pageNumber)->MPageNam); |
3004 | cbradney | 2125 | ss->set("NEW_MASTERPAGE", in); |
2126 | undoManager->action(this, ss); |
||
2127 | } |
||
2128 | } |
||
3174 | fschmid | 2129 | |
3004 | cbradney | 2130 | QString mna = in; |
2131 | if (mna == tr("Normal")) |
||
2132 | mna = "Normal"; |
||
2133 | if (!MasterNames.contains(mna)) |
||
2134 | mna = "Normal"; |
||
3817 | cbradney | 2135 | Page* Ap = DocPages.at(pageNumber); |
3004 | cbradney | 2136 | Ap->MPageNam = mna; |
2137 | int MpNr = MasterNames[mna]; |
||
2138 | Page* Mp = MasterPages.at(MpNr); |
||
2139 | PageItem *currItem; |
||
2140 | for (currItem |