Subversion Repositories Scribus

Rev

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