Subversion Repositories Scribus

Rev

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

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