Subversion Repositories Scribus

Rev

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