Subversion Repositories Scribus

Rev

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

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