Subversion Repositories Scribus

Rev

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

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