Subversion Repositories Scribus

Rev

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