Subversion Repositories Scribus

Rev

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

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