Subversion Repositories Scribus

Rev

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