Subversion Repositories Scribus

Rev

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