Subversion Repositories Scribus

Rev

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