Subversion Repositories Scribus

Rev

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