Subversion Repositories Scribus

Rev

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

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