Subversion Repositories Scribus

Rev

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