Subversion Repositories Scribus

Rev

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

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