Subversion Repositories Scribus

Rev

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