Subversion Repositories Scribus

Rev

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