Subversion Repositories Scribus

Rev

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

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