Subversion Repositories Scribus

Rev

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

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