Subversion Repositories Scribus

Rev

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