Subversion Repositories Scribus

Rev

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