Subversion Repositories Scribus

Rev

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