Subversion Repositories Scribus

Rev

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