Subversion Repositories Scribus

Rev

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