Subversion Repositories Scribus

Rev

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