Subversion Repositories Scribus

Rev

Rev 19692 | Rev 19893 | 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;
638
        docHyphenator=new Hyphenator(m_ScMW, this);
639
        Q_CHECK_PTR(docHyphenator);
640
}
641
 
10532 avox 642
 
2891 cbradney 643
void ScribusDoc::setLoading(const bool docLoading)
644
{
645
        loading = docLoading;
646
}
647
 
10532 avox 648
 
3985 cbradney 649
bool ScribusDoc::isLoading() const
2891 cbradney 650
{
651
        return loading;
652
}
653
 
10532 avox 654
 
655
//AV: eeks. That should not be used
4320 cbradney 656
ScribusView* ScribusDoc::view() const
657
{
5781 cbradney 658
//      return (WinHan ? (((ScribusWin*) WinHan)->view()) : 0);
659
        return m_View;
4320 cbradney 660
}
661
 
10532 avox 662
 
7906 jghali 663
const ScGuardedPtr<ScribusDoc>& ScribusDoc::guardedPtr() const
664
{
665
        return m_guardedObject;
666
}
667
 
10532 avox 668
 
1330 fschmid 669
void ScribusDoc::CloseCMSProfiles()
670
{
5880 jghali 671
        HasCMS = false;
10338 jghali 672
        SetDefaultCMSParams();
1330 fschmid 673
}
674
 
10338 jghali 675
void ScribusDoc::SetDefaultCMSParams()
676
{
677
        BlackPoint     = true;
678
        SoftProofing   = false;
679
        Gamut          = false;
15706 jghali 680
        IntentColors   = Intent_Relative_Colorimetric;
681
        IntentImages   = Intent_Relative_Colorimetric;
10338 jghali 682
        DocInputRGBProf       = ScCore->defaultRGBProfile;
683
        DocInputCMYKProf      = ScCore->defaultCMYKProfile;
684
        DocInputImageRGBProf  = ScCore->defaultRGBProfile;
685
        DocInputImageCMYKProf = ScCore->defaultCMYKProfile;
686
        DocOutputProf         = ScCore->defaultRGBProfile;
687
        DocPrinterProf        = ScCore->defaultCMYKProfile;
688
        stdTransRGBMon        = ScCore->defaultRGBToScreenSolidTrans;
689
        stdTransCMYKMon       = ScCore->defaultCMYKToRGBTrans;
10393 jghali 690
        stdTransRGB           = ScCore->defaultCMYKToRGBTrans;
691
        stdTransCMYK          = ScCore->defaultRGBToCMYKTrans;
10338 jghali 692
        stdProof              = ScCore->defaultRGBToScreenSolidTrans;
693
        stdProofGC            = ScCore->defaultRGBToScreenSolidTrans;
694
        stdProofCMYK          = ScCore->defaultCMYKToRGBTrans;
695
        stdProofCMYKGC        = ScCore->defaultCMYKToRGBTrans;
696
        stdTransImg           = ScCore->defaultRGBToScreenImageTrans;
697
        stdProofImg           = ScCore->defaultRGBToScreenImageTrans;
698
        stdProofImgCMYK       = ScCore->defaultCMYKToScreenImageTrans;
699
}
700
 
5345 mrdocs 701
bool ScribusDoc::OpenCMSProfiles(ProfilesL InPo, ProfilesL InPoCMYK, ProfilesL MoPo, ProfilesL PrPo)
1330 fschmid 702
{
5880 jghali 703
        HasCMS = false;
15706 jghali 704
        ScColorProfile inputProf = NULL;
705
 
706
        DocInputRGBProf  = ScColorMgmtEngine::openProfileFromFile( InPo[CMSSettings.DefaultSolidColorRGBProfile] );
707
        DocInputCMYKProf = ScColorMgmtEngine::openProfileFromFile( InPoCMYK[CMSSettings.DefaultSolidColorCMYKProfile] );
708
        DocOutputProf    =  ScColorMgmtEngine::openProfileFromFile( MoPo[CMSSettings.DefaultMonitorProfile] );
709
        DocPrinterProf   =  ScColorMgmtEngine::openProfileFromFile( PrPo[CMSSettings.DefaultPrinterProfile] );
710
        DocInputImageRGBProf =  ScColorMgmtEngine::openProfileFromFile( InPo[CMSSettings.DefaultImageRGBProfile] );
711
        DocInputImageCMYKProf =  ScColorMgmtEngine::openProfileFromFile( InPoCMYK[CMSSettings.DefaultImageCMYKProfile] );
712
 
713
        if ((!DocInputRGBProf) || (!DocInputCMYKProf) || (!DocOutputProf) || (!DocPrinterProf) || (!DocInputImageCMYKProf) || (!DocInputImageRGBProf))
5178 mrdocs 714
        {
5880 jghali 715
                CMSSettings.CMSinUse = false;
5178 mrdocs 716
                return false;
717
        }
15706 jghali 718
 
719
        int dcmsFlags   = 0;
5369 mrdocs 720
        int dcmsFlagsGC = 0;
15706 jghali 721
        dcmsFlags   |= Ctf_LowResPrecalc;
722
        dcmsFlagsGC |= Ctf_LowResPrecalc;
3046 fschmid 723
//      int dcmsFlags2 = cmsFLAGS_NOTPRECALC;
1488 fschmid 724
        if (CMSSettings.GamutCheck)
15706 jghali 725
                dcmsFlagsGC |= Ctf_GamutCheck;
1330 fschmid 726
        if (CMSSettings.BlackPoint)
727
        {
15706 jghali 728
                dcmsFlags   |= Ctf_BlackPointCompensation;
729
                dcmsFlagsGC |= Ctf_BlackPointCompensation;
1330 fschmid 730
        }
15706 jghali 731
 
732
        stdTransRGBMon  = ScColorMgmtEngine::createTransform(DocInputRGBProf, Format_RGB_16,
733
                                                                                DocOutputProf, Format_RGB_16,
734
                                                                                IntentColors, dcmsFlags);
735
        stdTransCMYKMon = ScColorMgmtEngine::createTransform(DocInputCMYKProf, Format_CMYK_16,
736
                                                                                DocOutputProf, Format_RGB_16,
737
                                                                                IntentColors, dcmsFlags);
5345 mrdocs 738
        // TODO : check input profiles used for images
15706 jghali 739
        stdProofImg = ScColorMgmtEngine::createProofingTransform(DocInputImageRGBProf, Format_RGBA_8,
740
                                        DocOutputProf, Format_RGBA_8, DocPrinterProf, IntentImages,
741
                                        Intent_Relative_Colorimetric, dcmsFlagsGC);
742
        stdProofImgCMYK = ScColorMgmtEngine::createProofingTransform(DocInputImageCMYKProf, Format_CMYK_8,
743
                                        DocOutputProf, Format_RGBA_8, DocPrinterProf, IntentImages,
744
                                        Intent_Relative_Colorimetric, dcmsFlagsGC);
745
        stdTransImg = ScColorMgmtEngine::createTransform(DocInputRGBProf, Format_RGBA_8,
746
                             DocOutputProf, Format_RGBA_8,
747
                             IntentImages, dcmsFlags);
748
        stdTransRGB = ScColorMgmtEngine::createTransform(DocInputCMYKProf, Format_CMYK_16,
749
                                                DocInputRGBProf, Format_RGB_16,
750
                                                IntentColors, dcmsFlags);
751
        stdTransCMYK = ScColorMgmtEngine::createTransform(DocInputRGBProf, Format_RGB_16,
752
                                                DocInputCMYKProf, Format_CMYK_16,
753
                                                IntentColors, dcmsFlags);
754
 
755
        ScColorProfile inputProfRGB;
756
        ScColorProfile inputProfCMYK;
757
        if (DocPrinterProf.colorSpace() == ColorSpace_Cmyk)
1491 fschmid 758
        {
5345 mrdocs 759
                inputProf = (CMSSettings.SoftProofOn && CMSSettings.SoftProofFullOn) ? DocInputCMYKProf : DocPrinterProf;
6070 jghali 760
                inputProfRGB  = DocInputRGBProf;
761
                inputProfCMYK = inputProf;
1491 fschmid 762
        }
763
        else
764
        {
5345 mrdocs 765
                inputProf = (CMSSettings.SoftProofOn && CMSSettings.SoftProofFullOn) ? DocInputRGBProf : DocPrinterProf;
6070 jghali 766
                inputProfRGB  = inputProf;
767
                inputProfCMYK = DocInputCMYKProf;
1491 fschmid 768
        }
15706 jghali 769
        stdProof = ScColorMgmtEngine::createProofingTransform(inputProfRGB, Format_RGB_16,
770
                            DocOutputProf, Format_RGB_16,
6070 jghali 771
                            DocPrinterProf,
772
                            IntentColors,
15706 jghali 773
                            Intent_Relative_Colorimetric, dcmsFlags);
774
        stdProofGC = ScColorMgmtEngine::createProofingTransform(inputProfRGB, Format_RGB_16,
775
                            DocOutputProf, Format_RGB_16,
6070 jghali 776
                            DocPrinterProf,
777
                            IntentColors,
15706 jghali 778
                            Intent_Relative_Colorimetric, dcmsFlags | Ctf_GamutCheck);
779
        stdProofCMYK = ScColorMgmtEngine::createProofingTransform(inputProfCMYK, Format_CMYK_16,
780
                                                DocOutputProf, Format_RGB_16,
6070 jghali 781
                                                DocPrinterProf,
782
                                                IntentColors,
15706 jghali 783
                                                Intent_Relative_Colorimetric, dcmsFlags);
784
        stdProofCMYKGC = ScColorMgmtEngine::createProofingTransform(inputProfCMYK, Format_CMYK_16,
785
                                                DocOutputProf, Format_RGB_16,
6070 jghali 786
                                                DocPrinterProf,
787
                                                IntentColors,
15706 jghali 788
                                                Intent_Relative_Colorimetric, dcmsFlags | Ctf_GamutCheck);
6464 jghali 789
 
15706 jghali 790
        if (DocInputRGBProf.colorSpace() == ColorSpace_Rgb)
6464 jghali 791
                        CMSSettings.ComponentsInput2 = 3;
15706 jghali 792
        if (DocInputRGBProf.colorSpace() == ColorSpace_Cmyk)
6464 jghali 793
                        CMSSettings.ComponentsInput2 = 4;
19690 jghali 794
        if (DocInputRGBProf.colorSpace() == ColorSpace_Cmy)
6464 jghali 795
                        CMSSettings.ComponentsInput2 = 3;
796
 
15706 jghali 797
        bool success  = (stdTransRGBMon && stdTransCMYKMon && stdProofImg  && stdProofImgCMYK &&
798
                             stdTransImg    && stdTransRGB     && stdTransCMYK && stdProof       &&
799
                         stdProofGC     && stdProofCMYK    && stdProofCMYKGC);
800
        if (!success)
801
        {
802
                // Reset to the default handler otherwise may enter a loop
803
                // if an error occur afterwards
804
                CloseCMSProfiles();
805
                CMSSettings.CMSinUse = false;
806
                QString message = tr("An error occurred while opening ICC profiles, color management is not enabled." );
807
                if (ScCore->usingGUI())
808
                        QMessageBox::warning(m_ScMW, CommonStrings::trWarning, message, QMessageBox::Ok, 0, 0);
809
                else
810
                        qWarning( "%s", message.toLocal8Bit().data() );
811
                return false;
812
        }
813
 
5178 mrdocs 814
        return true;
1330 fschmid 815
}
816
 
10532 avox 817
 
6726 fschmid 818
void ScribusDoc::enableCMS(bool enable)
819
{
820
        m_ScMW->setStatusBarInfoText( tr("Adjusting Colors"));
821
        m_ScMW->mainWindowProgressBar->reset();
14531 jghali 822
        int cc = PageColors.count() + MasterItems.count() + DocItems.count();
9953 cbradney 823
        m_ScMW->mainWindowProgressBar->setMaximum(cc);
18921 jghali 824
        qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
10726 jghali 825
        bool oldCM = CMSSettings.CMSinUse;
826
        bool newCM = enable;
827
        CloseCMSProfiles();
828
        CMSSettings.CMSinUse = newCM;
829
        HasCMS       = CMSSettings.CMSinUse;
10338 jghali 830
        BlackPoint   = CMSSettings.BlackPoint;
6726 fschmid 831
        SoftProofing = CMSSettings.SoftProofOn;
10338 jghali 832
        Gamut        = CMSSettings.GamutCheck;
6726 fschmid 833
        IntentColors = CMSSettings.DefaultIntentColors;
834
        IntentImages = CMSSettings.DefaultIntentImages;
835
        if (!CMSSettings.CMSinUse)
836
        {
837
                HasCMS = false;
838
                if      (oldCM)
839
                {
840
                        m_ScMW->recalcColors(m_ScMW->mainWindowProgressBar);
841
                        RecalcPictures(&ScCore->InputProfiles, &ScCore->InputProfilesCMYK, m_ScMW->mainWindowProgressBar);
842
                }
843
        }
844
        else if (OpenCMSProfiles(ScCore->InputProfiles, ScCore->InputProfilesCMYK, ScCore->MonitorProfiles, ScCore->PrinterProfiles) )
845
        {
846
                HasCMS = true;
847
                PDF_Options.SComp = CMSSettings.ComponentsInput2;
848
                PDF_Options.SolidProf = CMSSettings.DefaultSolidColorRGBProfile;
849
                PDF_Options.ImageProf = CMSSettings.DefaultImageRGBProfile;
850
                PDF_Options.PrintProf = CMSSettings.DefaultPrinterProfile;
851
                PDF_Options.Intent = CMSSettings.DefaultIntentColors;
852
                m_ScMW->recalcColors(m_ScMW->mainWindowProgressBar);
853
                RecalcPictures(&ScCore->InputProfiles, &ScCore->InputProfilesCMYK, m_ScMW->mainWindowProgressBar);
854
        }
855
        else
10338 jghali 856
        {
857
                SetDefaultCMSParams();
6726 fschmid 858
                HasCMS = false;
10338 jghali 859
        }
9953 cbradney 860
        m_ScMW->mainWindowProgressBar->setValue(cc);
18921 jghali 861
        qApp->restoreOverrideCursor();
6726 fschmid 862
        m_ScMW->setStatusBarInfoText("");
863
        m_ScMW->mainWindowProgressBar->reset();
864
}
7442 avox 865
 
866
 
8455 avox 867
void ScribusDoc::getNamedResources(ResourceCollection& lists) const
868
{
8776 cbradney 869
        lists.availableFonts = AllFonts;
8775 cbradney 870
        lists.availableColors = const_cast<ColorList*>(& PageColors);
871
 
9856 fschmid 872
        const QList<PageItem*> * itemlist = & MasterItems;
8455 avox 873
        while (itemlist != NULL)
874
        {
9856 fschmid 875
                for (int i=0; i < itemlist->count(); ++i)
8455 avox 876
                {
9856 fschmid 877
                        const PageItem * currItem = const_cast<QList<PageItem*>*>(itemlist)->at(i);
8455 avox 878
                        if (currItem)
9296 jghali 879
                                currItem->getNamedResources(lists);
8455 avox 880
                }
881
                if (itemlist == &MasterItems)
882
                        itemlist = &DocItems;
883
                else if (itemlist == &DocItems)
884
                        itemlist = &FrameItems;
885
                else
886
                        itemlist = NULL;
887
        }
10400 subik 888
        for (int i = 0; i < docParagraphStyles.count(); ++i)
8455 avox 889
                docParagraphStyles[i].getNamedResources(lists);
10400 subik 890
        for (int i = 0; i < docCharStyles.count(); ++i)
8455 avox 891
                docCharStyles[i].getNamedResources(lists);
892
//      for (uint i = 0; i < docLineStyles.count(); ++i)
893
//              docLineStyles[i].getNamedResources(lists);
894
 
895
        QMap<QString,ScPattern>::ConstIterator it;
896
        for (it = docPatterns.begin(); it != docPatterns.end(); ++it)
897
        {
898
                ScPattern pa = *it;
9856 fschmid 899
                for (int o = 0; o < pa.items.count(); o++)
8455 avox 900
                {
901
                        pa.items.at(o)->getNamedResources(lists);
902
                }
903
        }      
904
}
905
 
16385 fschmid 906
bool ScribusDoc::styleExists(QString styleName)
907
{
908
        for (int ff = 0; ff < paragraphStyles().count(); ++ff)
909
        {
910
                if (paragraphStyles()[ff].name() == styleName)
911
                        return true;
912
        }
913
        return false;
914
}
8455 avox 915
 
16660 jghali 916
QList<int> ScribusDoc::getSortedStyleList()
917
{
918
        QList<int> retList;
919
        for (int ff = 0; ff < docParagraphStyles.count(); ++ff)
920
        {
921
                if (docParagraphStyles[ff].parent().isEmpty())
922
                {
923
                        if (!retList.contains(ff))
924
                                retList.append(ff);
925
                        continue;
926
                }
16385 fschmid 927
 
16660 jghali 928
                QList<int> retList2;
16691 jghali 929
                QString name = docParagraphStyles[ff].name();
930
                QString par  = docParagraphStyles[ff].parent();
16660 jghali 931
                retList2.prepend(ff);
16691 jghali 932
                while ((!par.isEmpty()) && (par != name))
16660 jghali 933
                {
934
                        int pp = docParagraphStyles.find(par);
935
                        if ((pp >= 0) && (!retList2.contains(pp)))
936
                                retList2.prepend(pp);
937
                        par = (pp >= 0) ? docParagraphStyles[pp].parent() : QString();
938
                }
939
                for (int r = 0; r < retList2.count(); ++r)
940
                {
941
                        if (!retList.contains(retList2[r]))
942
                                retList.append(retList2[r]);
943
                }
944
        }
945
        return retList;
946
}
947
 
948
QList<int> ScribusDoc::getSortedCharStyleList()
949
{
950
        QList<int> retList;
951
        for (int ff = 0; ff < docCharStyles.count(); ++ff)
952
        {
953
                if (docCharStyles[ff].parent().isEmpty())
954
                {
955
                        if (!retList.contains(ff))
956
                                retList.append(ff);
957
                        continue;
958
                }
959
 
960
                QList<int> retList2;
16691 jghali 961
                QString name = docCharStyles[ff].name();
962
                QString par  = docCharStyles[ff].parent();
16660 jghali 963
                retList2.prepend(ff);
16691 jghali 964
                while ((!par.isEmpty()) && (par != name))
16660 jghali 965
                {
966
                        int pp = docCharStyles.find(par);
967
                        if ((pp >= 0) && (!retList2.contains(pp)))
968
                                retList2.prepend(pp);
969
                        par = (pp >= 0) ? docCharStyles[pp].parent() : QString();
970
                }
971
                for (int r = 0; r < retList2.count(); ++r)
972
                {
973
                        if (!retList.contains(retList2[r]))
974
                                retList.append(retList2[r]);
975
                }
976
        }
977
        return retList;
978
}
979
 
7947 cbradney 980
void ScribusDoc::replaceStyles(const QMap<QString,QString>& newNameForOld)
7442 avox 981
{
8455 avox 982
        ResourceCollection newNames;
8775 cbradney 983
        newNames.mapStyles(newNameForOld);
8455 avox 984
        replaceNamedResources(newNames);
985
}
986
 
987
 
988
void ScribusDoc::replaceNamedResources(ResourceCollection& newNames)
989
{
7595 avox 990
        // replace names in items
9856 fschmid 991
        QList<PageItem*> * itemlist = & MasterItems;
7442 avox 992
        while (itemlist != NULL)
993
        {
9856 fschmid 994
                for (int i=0; i < itemlist->count(); ++i)
7442 avox 995
                {
9433 jghali 996
                        PageItem * currItem = itemlist->at(i);
7442 avox 997
                        if (currItem)
9433 jghali 998
                                currItem->replaceNamedResources(newNames);
7442 avox 999
                }
1000
                if (itemlist == &MasterItems)
1001
                        itemlist = &DocItems;
1002
                else if (itemlist == &DocItems)
1003
                        itemlist = &FrameItems;
1004
                else
1005
                        itemlist = NULL;
1006
        }
8455 avox 1007
 
7595 avox 1008
        // replace names in styles...
1009
        for (int i=docParagraphStyles.count()-1; i >= 0; --i)
1010
        {
8814 cbradney 1011
                if (newNames.styles().contains(docParagraphStyles[i].name()))
1012
                        docParagraphStyles.remove(i);
1013
                else
1014
                        docParagraphStyles[i].replaceNamedResources(newNames);
8455 avox 1015
        }
1016
        for (int i=docCharStyles.count()-1; i >= 0; --i)
1017
        {
8814 cbradney 1018
                if (newNames.charStyles().contains(docCharStyles[i].name()))
1019
                        docCharStyles.remove(i);
1020
                else
1021
                        docCharStyles[i].replaceNamedResources(newNames);
8455 avox 1022
        }
1023
 
1024
        QMap<QString,ScPattern>::Iterator it;
1025
        for (it = docPatterns.begin(); it != docPatterns.end(); ++it)
1026
        {
8814 cbradney 1027
                if (newNames.patterns().contains(it.key()))
10571 fschmid 1028
                        docPatterns.erase(it);
8814 cbradney 1029
                else
8455 avox 1030
                {
8814 cbradney 1031
                        ScPattern pa = *it;
9856 fschmid 1032
                        for (int o = 0; o < pa.items.count(); o++)
8814 cbradney 1033
                        {
1034
                                pa.items.at(o)->replaceNamedResources(newNames);
1035
                        }
8058 avox 1036
                }
8772 cbradney 1037
        }
1038
 
8783 cbradney 1039
        if (newNames.colors().count() > 0 || newNames.fonts().count() > 0)
1040
        {
8772 cbradney 1041
                docCharStyles.invalidate();
1042
                docParagraphStyles.invalidate();       
8783 cbradney 1043
        }
1044
        else
1045
        {
1046
                if (newNames.charStyles().count() > 0)
1047
                        docCharStyles.invalidate();
1048
                if (newNames.styles().count() > 0)
1049
                        docParagraphStyles.invalidate();       
1050
        }
8916 avox 1051
        if (!isLoading() && !(newNames.colors().isEmpty() && newNames.fonts().isEmpty() && newNames.patterns().isEmpty()
1052
                                                  && newNames.styles().isEmpty() && newNames.charStyles().isEmpty() && newNames.lineStyles().isEmpty()) )
1053
                changed();
7442 avox 1054
}
1055
 
1056
 
7947 cbradney 1057
void ScribusDoc::replaceCharStyles(const QMap<QString,QString>& newNameForOld)
7442 avox 1058
{
8455 avox 1059
        ResourceCollection newNames;
8775 cbradney 1060
        newNames.mapCharStyles(newNameForOld);
8455 avox 1061
        replaceNamedResources(newNames);
1062
 
1063
        /*
7595 avox 1064
        // replace style in items
7442 avox 1065
        QPtrList<PageItem> * itemlist = & MasterItems;
1066
        while (itemlist != NULL)
1067
        {
7595 avox 1068
                for (uint i=0; i < itemlist->count(); ++i)
7442 avox 1069
                {
1070
                        PageItem_TextFrame * currItem = itemlist->at(i)->asTextFrame();
1071
                        if (currItem)
1072
                                currItem->itemText.replaceCharStyles(newNameForOld);
1073
                }
1074
                if (itemlist == &MasterItems)
1075
                        itemlist = &DocItems;
1076
                else if (itemlist == &DocItems)
1077
                        itemlist = &FrameItems;
1078
                else
1079
                        itemlist = NULL;
1080
        }
7595 avox 1081
        // replace names in styles
1082
        for (uint i=0; i < docParagraphStyles.count(); ++i)
1083
        {
1084
                // ...parent of parstyle's charstyle
1085
                const QString& parent(docParagraphStyles[i].charStyle().parent());
1086
                if (newNameForOld.contains(parent))
1087
                        docParagraphStyles[i].charStyle().setParent(newNameForOld[parent]);
1088
        }
1089
        for (int i=docCharStyles.count()-1; i >= 0; --i)
1090
        {
1091
                // ...parent of charstyle
1092
                const QString& parent(docCharStyles[i].parent());
1093
                if (newNameForOld.contains(parent))
1094
                        docCharStyles[i].setParent(newNameForOld[parent]);
1095
                // ... as name
1096
                if (newNameForOld.contains(docCharStyles[i].name()))
1097
                        docCharStyles.remove(i);
1098
        }
8455 avox 1099
        */
7442 avox 1100
}
1101
 
10532 avox 1102
 
7595 avox 1103
void ScribusDoc::redefineStyles(const StyleSet<ParagraphStyle>& newStyles, bool removeUnused)
1104
{
1105
        docParagraphStyles.redefine(newStyles, false);
1106
        if (removeUnused)
1107
        {
1108
                QMap<QString, QString> deletion;
1109
                QString deflt("");
10400 subik 1110
                for (int i=0; i < docParagraphStyles.count(); ++i)
7595 avox 1111
                {
1112
                        const QString& nam(docParagraphStyles[i].name());
1113
                        if (newStyles.find(nam) < 0)
1114
                                deletion[nam] = deflt;
1115
                }
1116
                if (deletion.count() > 0)
1117
                        replaceStyles(deletion);
1118
        }
8134 avox 1119
        // repair charstyle context:
10400 subik 1120
        for (int i=0; i < docParagraphStyles.count(); ++i)
8058 avox 1121
        {
1122
                ParagraphStyle& sty(docParagraphStyles[i]);
1123
                if (docParagraphStyles.isDefault(sty))
1124
                {
1125
                        sty.breakImplicitCharStyleInheritance(true);
8134 avox 1126
                        sty.charStyle().setContext( & docCharStyles );
8191 avox 1127
//                      sty.charStyle().setName( "cdocdefault" ); // DONT TRANSLATE
8058 avox 1128
                }
1129
                else {
1130
                        sty.breakImplicitCharStyleInheritance(false);
1131
                }
1132
        }
8772 cbradney 1133
        docParagraphStyles.invalidate();
7595 avox 1134
}
1135
 
10532 avox 1136
 
7595 avox 1137
void ScribusDoc::redefineCharStyles(const StyleSet<CharStyle>& newStyles, bool removeUnused)
1138
{
1139
        docCharStyles.redefine(newStyles, false);
1140
        if (removeUnused)
1141
        {
1142
                QMap<QString, QString> deletion;
1143
                QString deflt("");
10400 subik 1144
                for (int i=0; i < docCharStyles.count(); ++i)
7595 avox 1145
                {
1146
                        const QString& nam(docCharStyles[i].name());
1147
                        if (newStyles.find(nam) < 0)
8772 cbradney 1148
                        {
7595 avox 1149
                                deletion[nam] = deflt;
8772 cbradney 1150
                        }
7595 avox 1151
                }
1152
                if (deletion.count() > 0)
1153
                        replaceCharStyles(deletion);
1154
        }
8772 cbradney 1155
        docCharStyles.invalidate();
7595 avox 1156
}
1157
 
8274 tsoots 1158
 
456 fschmid 1159
/*
1160
 * Split out from loadStyles in editFormats.cpp so it's callable from anywhere,
1161
 * including plugins.
1162
 * - 2004-09-14 Craig Ringer
1163
 */
8455 avox 1164
// dont like this here. could as well be a static method for reading this stuff into temp., then always use redefineXY() - av
12548 pierre 1165
void ScribusDoc::loadStylesFromFile(QString fileName)
1166
{
1167
        StyleSet<ParagraphStyle> *wrkStyles     = &docParagraphStyles;
1168
        StyleSet<CharStyle> *wrkCharStyles      = &docCharStyles;
1169
        QMap<QString, multiLine> *wrkLineStyles = &MLineStyles;
1170
 
1171
        int oldStyles = wrkStyles->count();
1172
        int oldCharStyles = wrkCharStyles->count();
1173
        int oldLineStyles = wrkLineStyles->count();
1174
 
1175
        if (!fileName.isEmpty())
1176
        {
1177
                FileLoader fl(fileName);
17325 jghali 1178
                if (fl.testFile() == -1)
12548 pierre 1179
                //TODO put in nice user warning
1180
                        return;
1181
 
17325 jghali 1182
                if (!fl.readStyles(this, *wrkStyles))
12548 pierre 1183
                {
1184
                        //TODO put in nice user warning
1185
                }
1186
 
17325 jghali 1187
                if (!fl.readCharStyles(this, *wrkCharStyles))
12548 pierre 1188
                {
1189
                        //TODO put in nice user warning
1190
                }
1191
 
17325 jghali 1192
                if (!fl.readLineStyles(wrkLineStyles))
12548 pierre 1193
                {
1194
                        //TODO put in nice user warning
1195
                }
1196
 
1197
                if ( !isLoading() && ((wrkStyles->count() > oldStyles)
1198
                                    || (wrkCharStyles->count() > oldCharStyles)
1199
                                    || (wrkLineStyles->count() > oldLineStyles) ) )
1200
                        changed();
1201
        }
1202
}
1203
 
8274 tsoots 1204
void ScribusDoc::loadStylesFromFile(QString fileName, StyleSet<ParagraphStyle> *tempStyles,
1205
                                                      StyleSet<CharStyle> *tempCharStyles,
1206
                                                      QMap<QString, multiLine> *tempLineStyles)
456 fschmid 1207
{
12548 pierre 1208
        StyleSet<ParagraphStyle> *wrkStyles     = tempStyles;
1209
        StyleSet<CharStyle> *wrkCharStyles      = tempCharStyles;
1210
        QMap<QString, multiLine> *wrkLineStyles = tempLineStyles;
8916 avox 1211
 
456 fschmid 1212
        if (!fileName.isEmpty())
1213
        {
5642 cbradney 1214
                FileLoader fl(fileName);
17325 jghali 1215
                if (fl.testFile() == -1)
5642 cbradney 1216
                //TODO put in nice user warning
1217
                        return;
5980 avox 1218
 
17325 jghali 1219
                if (!fl.readStyles(this, *wrkStyles))
456 fschmid 1220
                {
8274 tsoots 1221
                        //TODO put in nice user warning
456 fschmid 1222
                }
8274 tsoots 1223
 
17325 jghali 1224
                if (!fl.readCharStyles(this, *wrkCharStyles))
8274 tsoots 1225
                {
1226
                        //TODO put in nice user warning
1227
                }
1228
 
17325 jghali 1229
                if (!fl.readLineStyles(wrkLineStyles))
8274 tsoots 1230
                {
1231
                        //TODO put in nice user warning
1232
                }
12550 pierre 1233
 
1234
                // Which are the default styles 
1235
                // Sadly StyleSet is not updated at import
1236
                // and it might break something to do so. 
1237
                // We need to loop then - pm
1238
//              ParagraphStyle* parDefault(wrkStyles->getDefault());
1239
//              CharStyle* charDefault(wrkCharStyles->getDefault());
1240
 
1241
                QFileInfo fi(fileName);
1242
                QString importPrefix(tr("Imported ","Prefix of imported default style"));
1243
                QString importSuffix(" (" +  fi.baseName() + ")");
1244
 
1245
                for(int j(0) ; j < wrkStyles->count() ; ++j)
1246
                {
1247
                        if((*wrkStyles)[j].isDefaultStyle())
1248
                        {
1249
                                ParagraphStyle& parDefault((*wrkStyles)[j]);
1250
                                parDefault.setDefaultStyle(false);
1251
                                QMap<QString, QString> namesMap;
1252
                                namesMap[parDefault.name()] = importPrefix + parDefault.name() + importSuffix;
1253
                                for(int i(0) ; i < wrkStyles->count() ; ++i)
1254
                                {
1255
                                        if( (*wrkStyles)[i] != parDefault )
1256
                                                namesMap[(*wrkStyles)[i].name()] = (*wrkStyles)[i].name();
1257
                                }
1258
                                wrkStyles->rename(namesMap);
1259
                        }
1260
                }
1261
                for(int j(0) ; j < wrkCharStyles->count() ; ++j)
1262
                {
1263
                        if((*wrkCharStyles)[j].isDefaultStyle())
1264
                        {
1265
                                CharStyle& charDefault((*wrkCharStyles)[j]);
1266
                                charDefault.setDefaultStyle(false);
1267
                                QMap<QString, QString> namesMap;
1268
                                namesMap[charDefault.name()] = importPrefix + charDefault.name() + importSuffix;
1269
                                for(int i(0) ; i < wrkCharStyles->count() ; ++i)
1270
                                {
1271
                                        if( (*wrkCharStyles)[i] != charDefault )
1272
                                                namesMap[(*wrkCharStyles)[i].name()] = (*wrkCharStyles)[i].name();
1273
                                }
1274
                                wrkCharStyles->rename(namesMap);
1275
                        }
1276
                }
456 fschmid 1277
        }
1278
}
1279
 
10532 avox 1280
 
1179 tsoots 1281
void ScribusDoc::lockGuides(bool isLocked)
1282
{
1180 tsoots 1283
        if (GuideLock == isLocked)
1284
                return;
1179 tsoots 1285
        GuideLock = isLocked;
1286
        if (UndoManager::undoEnabled())
1287
        {
1288
                QString name;
1289
                if (isLocked)
1190 tsoots 1290
                        name = Um::LockGuides;
1179 tsoots 1291
                else
1190 tsoots 1292
                        name = Um::UnlockGuides;
1293
                SimpleState *ss = new SimpleState(name, "", Um::ILockGuides);
1179 tsoots 1294
                ss->set("GUIDE_LOCK", isLocked);
1295
                undoManager->action(this, ss);
1296
        }
1297
}
1298
 
13349 jghali 1299
void ScribusDoc::undoRedoBegin()
1300
{
14369 jghali 1301
        m_docUpdater->beginUpdate();
13349 jghali 1302
        m_Selection->delaySignalsOn();
1303
}
10532 avox 1304
 
13349 jghali 1305
void ScribusDoc::undoRedoDone()
1306
{
1307
        m_Selection->delaySignalsOff();
14369 jghali 1308
        m_docUpdater->endUpdate();
15919 jghali 1309
        // Ensure PP is properly disabled when selection is empty
1310
        // after undoing or redoing an action
1311
        if (m_Selection->count() == 0)
1312
                emit firstSelectedItemType(-1);
13349 jghali 1313
}
1314
 
1179 tsoots 1315
void ScribusDoc::restore(UndoState* state, bool isUndo)
1316
{
1317
        SimpleState *ss = dynamic_cast<SimpleState*>(state);
1318
        if (ss)
1319
        {
2941 cbradney 1320
                bool layersUndo=false;
13331 jghali 1321
 
13194 jghali 1322
                if (ss->contains("GROUP"))
1323
                        restoreGrouping(ss, isUndo);
1324
                else if (ss->contains("UNGROUP"))
1325
                        restoreUngrouping(ss, isUndo);
1326
                else if (ss->contains("GUIDE_LOCK"))
1179 tsoots 1327
                {
1328
                        if (isUndo)
1329
                                GuideLock = !ss->getBool("GUIDE_LOCK");
1330
                        else
3201 subik 1331
                                GuideLock = ss->getBool("GUIDE_LOCK");
1179 tsoots 1332
                }
2937 cbradney 1333
                else if (ss->contains("UP_LAYER"))
1334
                {
1335
                        if (isUndo)
1336
                                lowerLayer(ss->getInt("ACTIVE"));
1337
                        else
1338
                                raiseLayer(ss->getInt("ACTIVE"));
2941 cbradney 1339
                        layersUndo=true;
2937 cbradney 1340
                }
1341
                else if (ss->contains("DOWN_LAYER"))
1342
                {
1343
                        if (isUndo)
1344
                                raiseLayer(ss->getInt("ACTIVE"));
1345
                        else
1346
                                lowerLayer(ss->getInt("ACTIVE"));
2941 cbradney 1347
                        layersUndo=true;
2937 cbradney 1348
                }
1349
                else if (ss->contains("PRINT_LAYER"))
1350
                {
1351
                        bool print = ss->getBool("PRINT");
1352
                        setLayerPrintable(ss->getInt("ACTIVE"), isUndo ? !print : print);
2941 cbradney 1353
                        layersUndo=true;
2937 cbradney 1354
                }
16496 craig 1355
                else if (ss->contains("LAYER_FLOW"))
16491 craig 1356
                {
1357
                        bool flow = ss->getBool("FLOW");
1358
                        setLayerFlow(ss->getInt("ACTIVE"), isUndo ? !flow : flow);
1359
                        layersUndo=true;
1360
                }
16498 craig 1361
                else if (ss->contains("LAYER_LOCK"))
1362
                {
1363
                        bool lock = ss->getBool("LOCK");
1364
                        setLayerLocked(ss->getInt("ACTIVE"), isUndo ? !lock : lock);
1365
                        layersUndo=true;
1366
                }
16496 craig 1367
                else if (ss->contains("LAYER_TRANSPARENCY"))
1368
                {
1369
                        double old_trans = ss->getDouble("OLD_TRANS");
1370
                        double new_trans = ss->getDouble("NEW_TRANS");
1371
                        setLayerTransparency(ss->getInt("ACTIVE"), isUndo ? old_trans : new_trans);
1372
                        layersUndo=true;
1373
                }
1374
                else if (ss->contains("LAYER_BLENDMODE"))
1375
                {
1376
                        int old_blend = ss->getInt("OLD_BLENDMODE");
1377
                        int new_blend = ss->getInt("NEW_BLENDMODE");
1378
                        setLayerBlendMode(ss->getInt("ACTIVE"), isUndo ? old_blend : new_blend);
1379
                        layersUndo=true;
1380
                }
2937 cbradney 1381
                else if (ss->contains("ADD_LAYER"))
1382
                {
1383
                        if (isUndo)
2944 cbradney 1384
                                deleteLayer(ss->getInt("LAYER_NR"), false);
2937 cbradney 1385
                        else
1386
                        {
2944 cbradney 1387
                                int layerNumber=addLayer( ss->get("NAME"), false );
1388
                                int newLayerNumber=ss->getInt("LAYER_NR");
1389
                                bool renumberedOk=renumberLayer(layerNumber, newLayerNumber);
1390
                                Q_ASSERT(renumberedOk);
2937 cbradney 1391
                        }
2944 cbradney 1392
                        layersUndo=true;
2937 cbradney 1393
                }
1394
                else if (ss->contains("REMOVE_LAYER"))
1395
                {
1396
                        if (isUndo)
1397
                        {
2944 cbradney 1398
                                int layerNumber=addLayer( ss->get("NAME"), false );
1399
                                int newLayerNumber=ss->getInt("LAYER_NR");
1400
                                bool renumberedOk=renumberLayer(layerNumber, newLayerNumber);
1401
                                Q_ASSERT(renumberedOk);
1402
                                layerNumber=newLayerNumber;
1403
                                //Layer is at the top now, lower it until it reaches the old level
2937 cbradney 1404
                                int level = ss->getInt("LEVEL");
2944 cbradney 1405
                                while (layerLevelFromNumber(layerNumber)!=level)
1406
                                        lowerLayer(layerNumber);
2937 cbradney 1407
                        }
1408
                        else
2944 cbradney 1409
                                deleteLayer(ss->getInt("LAYER_NR"), ss->getBool("DELETE"));
1410
                        layersUndo=true;
2937 cbradney 1411
                }
1412
                else if (ss->contains("CHANGE_NAME"))
1413
                {
1414
                        QString name = ss->get("OLD_NAME");
1415
                        if (!isUndo)
1416
                                name = ss->get("NEW_NAME");
2938 cbradney 1417
                        changeLayerName(ss->getInt("ACTIVE"), name);
2941 cbradney 1418
                        layersUndo=true;
1419
                }
3004 cbradney 1420
                else if (ss->contains("OLD_MASTERPAGE"))
1421
                        restoreMasterPageApplying(ss, isUndo);
17212 craig 1422
                else if (ss->contains("PAGE_COPY"))
1423
                        restoreCopyPage(ss, isUndo);
1424
                else if (ss->contains("PAGE_MOVE"))
1425
                        restoreMovePage(ss, isUndo);
16507 craig 1426
                else if (ss->contains("PAGE_CHANGEPROPS"))
1427
                {
1428
                        if (isUndo)
1429
                        {
1430
                                changePageMargins(ss->getDouble("OLD_PAGE_INITIALTOP"), ss->getDouble("OLD_PAGE_INITIALBOTTOM"),
1431
                                                ss->getDouble("OLD_PAGE_INITIALLEFT"), ss->getDouble("OLD_PAGE_INITIALRIGHT"),
1432
                                                ss->getDouble("OLD_PAGE_INITIALHEIGHT"), ss->getDouble("OLD_PAGE_INITIALWIDTH"),
1433
                                                ss->getDouble("OLD_PAGE_HEIGHT"), ss->getDouble("OLD_PAGE_WIDTH"), ss->getInt("OLD_PAGE_ORIENTATION"),
1434
                                                ss->get("OLD_PAGE_SIZE"), ss->getInt("OLD_PAGE_MARGINPRESET"), ss->getBool("OLD_PAGE_MOVEOBJECTS"), ss->getInt("PAGE_NUM"), ss->getInt("OLD_PAGE_TYPE"));
1435
                        }
1436
                        else
1437
                        {
1438
                                changePageMargins(ss->getDouble("NEW_PAGE_INITIALTOP"), ss->getDouble("NEW_PAGE_INITIALBOTTOM"),
1439
                                                ss->getDouble("NEW_PAGE_INITIALLEFT"), ss->getDouble("NEW_PAGE_INITIALRIGHT"),
1440
                                                ss->getDouble("NEW_PAGE_INITIALHEIGHT"), ss->getDouble("NEW_PAGE_INITIALWIDTH"),
1441
                                                ss->getDouble("NEW_PAGE_HEIGHT"), ss->getDouble("NEW_PAGE_WIDTH"), ss->getInt("NEW_PAGE_ORIENTATION"),
1442
                                                ss->get("NEW_PAGE_SIZE"), ss->getInt("NEW_PAGE_MARGINPRESET"), ss->getBool("OLD_PAGE_MOVEOBJECTS"), ss->getInt("PAGE_NUM"), ss->getInt("NEW_PAGE_TYPE"));
1443
                        }
1444
                }
1445
 
2941 cbradney 1446
                if (layersUndo)
1447
                {
5243 cbradney 1448
                        if (ScCore->usingGUI())
2952 cbradney 1449
                        {
5781 cbradney 1450
                                m_ScMW->changeLayer(ss->getInt("ACTIVE"));
1451
                                m_ScMW->layerPalette->rebuildList();
16496 craig 1452
                                m_ScMW->layerPalette->markActiveLayer(activeLayer());
2952 cbradney 1453
                        }
2937 cbradney 1454
                }
1179 tsoots 1455
        }
1456
}
1457
 
13194 jghali 1458
void ScribusDoc::restoreGrouping(SimpleState *state, bool isUndo)
1459
{
1460
        double x, y, w, h;
1461
        Selection tmpSelection(this, false);
1462
        int itemCount = state->getInt("itemcount");
1463
        m_Selection->setGroupRect();
1464
        m_Selection->getGroupRect(&x, &y, &w, &h);
1465
        m_Selection->delaySignalsOn();
1466
        m_Selection->clear();
1467
        for (int i = 0; i < itemCount; ++i)
1468
        {
1469
                int itemNr = getItemNrfromUniqueID(state->getUInt(QString("item%1").arg(i)));
1470
                if (Items->at(itemNr)->uniqueNr == state->getUInt(QString("item%1").arg(i)))
1471
                        tmpSelection.addItem(Items->at(itemNr));
1472
        }
1473
        if (isUndo)
1474
        {
1475
                uint docSelectionCount=tmpSelection.count();
1476
                PageItem *currItem;
1477
                uint lowestItem = 999999;
1478
                for (uint a=0; a<docSelectionCount; ++a)
1479
                {
1480
                        currItem = tmpSelection.itemAt(a);
1481
                        lowestItem = qMin(lowestItem, currItem->ItemNr);
1482
                }
1483
                if ((lowestItem > 0) && (Items->at(lowestItem-1)->Groups.count() != 0))
1484
                {
13200 jghali 1485
                        if (Items->at(lowestItem-1)->Groups.top() == tmpSelection.itemAt(0)->Groups.top())
13194 jghali 1486
                        {
1487
                                tmpSelection.addItem(Items->at(lowestItem-1), true);
1488
                        }
1489
                }
1490
                itemSelection_UnGroupObjects(&tmpSelection);
1491
        }
1492
        else
1493
                itemSelection_GroupObjects(false, false, &tmpSelection);
1494
        QRectF rect(x, y , w, h);
1495
        regionsChanged()->update(rect.adjusted(-10, -10, 20, 20));
1496
        m_Selection->delaySignalsOff();
1497
}
10532 avox 1498
 
13194 jghali 1499
void ScribusDoc::restoreUngrouping(SimpleState *state, bool isUndo)
1500
{
1501
        double x, y, w, h;
1502
        Selection tmpSelection(this, false);
1503
        int itemCount = state->getInt("itemcount");
1504
        m_Selection->setGroupRect();
1505
        m_Selection->getGroupRect(&x, &y, &w, &h);
1506
        m_Selection->delaySignalsOn();
1507
        m_Selection->clear();
1508
        for (int i = 0; i < itemCount; ++i)
1509
        {
1510
                int itemNr = getItemNrfromUniqueID(state->getUInt(QString("item%1").arg(i)));
1511
                if (Items->at(itemNr)->uniqueNr == state->getUInt(QString("item%1").arg(i)))
1512
                {
1513
                        if (isUndo)
1514
                                Items->at(itemNr)->isTableItem = static_cast<bool>(state->getInt(QString("tableitem%1").arg(i)));
1515
                        tmpSelection.addItem(Items->at(itemNr));
1516
                }
1517
        }
1518
        if (isUndo)
1519
                itemSelection_GroupObjects(false, false, &tmpSelection);
1520
        else
1521
        {
13200 jghali 1522
                uint docSelectionCount=tmpSelection.count();
13194 jghali 1523
                PageItem *currItem;
1524
                uint lowestItem = 999999;
1525
                for (uint a=0; a<docSelectionCount; ++a)
1526
                {
13200 jghali 1527
                        currItem = tmpSelection.itemAt(a);
13194 jghali 1528
                        lowestItem = qMin(lowestItem, currItem->ItemNr);
1529
                }
1530
                if ((lowestItem > 0) && (Items->at(lowestItem-1)->Groups.count() != 0))
1531
                {
13200 jghali 1532
                        if (Items->at(lowestItem-1)->Groups.top() == tmpSelection.itemAt(0)->Groups.top())
13194 jghali 1533
                        {
1534
                                tmpSelection.addItem(Items->at(lowestItem-1));
1535
                        }
1536
                }
1537
                itemSelection_UnGroupObjects(&tmpSelection);
1538
        }
1539
        QRectF rect(x, y , w, h);
1540
        regionsChanged()->update(rect.adjusted(-10, -10, 20, 20));
1541
        m_Selection->delaySignalsOff();
1542
}
1543
 
1179 tsoots 1544
void ScribusDoc::setName(const QString& name)
1545
{
1546
        DocName = name;
1547
}
1548
 
10532 avox 1549
 
2891 cbradney 1550
void ScribusDoc::setModified(const bool isModified)
3 paul 1551
{
10532 avox 1552
        if (modified != isModified)
1553
        {
1554
                modified = isModified;
1555
                update();
1556
        }
3 paul 1557
}
1558
 
10532 avox 1559
 
3 paul 1560
bool ScribusDoc::isModified() const
1561
{
12034 cbradney 1562
        return modified;
3 paul 1563
}
10532 avox 1564
 
1565
 
1566
/** sets page properties */
2894 fschmid 1567
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 1568
{
2142 cbradney 1569
        pageWidth = b;
1570
        pageHeight = h;
1571
        pageMargins.Top = t;
1572
        pageMargins.Left = l;
1573
        pageMargins.Right = r;
1574
        pageMargins.Bottom = bo;
3 paul 1575
        PageSp = sp;
1576
        PageSpa = ab;
3032 fschmid 1577
        currentPageLayout = fp;
3648 cbradney 1578
        automaticTextFrames = atf;
4546 subik 1579
 
3695 cbradney 1580
        //CB Moved from scribus.cpp. Overrides the defaults...
6921 fschmid 1581
//      PDF_Options.BleedTop = pageMargins.Top;
1582
//      PDF_Options.BleedLeft = pageMargins.Left;
1583
//      PDF_Options.BleedRight = pageMargins.Right;
1584
//      PDF_Options.BleedBottom = pageMargins.Bottom;
3 paul 1585
}
1586
 
12326 cbradney 1587
void ScribusDoc::resetPage(MarginStruct& newMargins, int fp)
3 paul 1588
{
12326 cbradney 1589
        pageMargins = newMargins;
3032 fschmid 1590
        currentPageLayout = fp;
3 paul 1591
}
1592
 
10532 avox 1593
 
3544 avox 1594
bool ScribusDoc::AddFont(QString name, int fsize)
3 paul 1595
{
220 Franz 1596
        bool ret = false;
6549 fschmid 1597
//      FT_Face      face;
2295 cbradney 1598
 
3201 subik 1599
        if (UsedFonts.contains(name))
1600
                return true;
2295 cbradney 1601
 
5980 avox 1602
        if (! AllFonts->contains(name) || name == "" )
5559 avox 1603
                return false;
3572 avox 1604
 
5980 avox 1605
//      face = (*AllFonts)[name]->ftFace();
1606
//      if ( !face )
1607
//              return false;
2295 cbradney 1608
 
5980 avox 1609
/*      if ((*AllFonts)[name].ReadMetrics())         FIXME: needed?
167 Franz 1610
        {
5387 avox 1611
//              (*AllFonts)[name]->CharWidth[13] = 0;
1612
//              (*AllFonts)[name]->CharWidth[28] = 0;
1613
//              (*AllFonts)[name]->CharWidth[26] = 0;
1614
//              (*AllFonts)[name]->CharWidth[9] = 1;
5980 avox 1615
                QString afnm = (*AllFonts)[name].fontFilePath().left((*AllFonts)[name].fontFilePath().length()-3);
220 Franz 1616
                QFile afm(afnm+"afm");
3 paul 1617
                if(!(afm.exists()))
220 Franz 1618
                {
5387 avox 1619
                        afm.setName(afnm+"pfm");
1620
                }
1621
                if(!(afm.exists())) {
1622
                        afm.setName(afnm+"AFM");
1623
                }
1624
                if(!(afm.exists()))
1625
                {
1626
                        afm.setName(afnm+"PFM");
1627
                }
1628
                if(!(afm.exists()))
1629
                {
220 Franz 1630
                        afm.setName(afnm+"Afm");
1631
                }
5387 avox 1632
                if(!(afm.exists()))
1633
                {
1634
                        afm.setName(afnm+"Pfm");
1635
                }
220 Franz 1636
                if (afm.exists())
1637
                        FT_Attach_File(face, afm.name());
167 Franz 1638
        }
5980 avox 1639
        */
1640
        UsedFonts[name] = fsize;
1641
        (*AllFonts)[name].increaseUsage();
1642
        ret = true;
220 Franz 1643
        return ret;
3 paul 1644
}
1694 cbradney 1645
 
10532 avox 1646
 
1694 cbradney 1647
QStringList ScribusDoc::getItemAttributeNames()
1648
{
1649
        QStringList nameList;
3201 subik 1650
 
1694 cbradney 1651
        for(ObjAttrVector::Iterator it = docItemAttributes.begin(); it!= docItemAttributes.end(); ++it)
1652
                nameList.append((*it).name);
1653
        return nameList;
1749 craig 1654
}
1655
 
10532 avox 1656
 
2891 cbradney 1657
void ScribusDoc::addSymbols()
1658
{
1659
        symReturn.resize(0);
1660
        symReturn.addQuadPoint(1.98438, 9.14062, 1.98438, 9.14062, 1.98438, 4.03125, 1.98438, 4.03125);
1661
        symReturn.addQuadPoint(1.98438, 4.03125, 1.98438, 4.03125, 0.546875, 3.45312, 1.09375, 4);
1662
        symReturn.addQuadPoint(0.546875, 3.45312, 0.546875, 3.45312, 0, 2.0625, 0, 2.92188);
1663
        symReturn.addQuadPoint(0, 2.0625, 0, 2.0625, 0.65625, 0.5, 0, 1.04688);
1664
        symReturn.addQuadPoint(0.65625, 0.5, 0.65625, 0.5, 2.3125, 0, 1.28125, 0);
1665
        symReturn.addQuadPoint(2.3125, 0, 2.3125, 0, 5.40625, 0, 5.40625, 0);
1666
        symReturn.addQuadPoint(5.40625, 0, 5.40625, 0, 5.40625, 0.84375, 5.40625, 0.84375);
1667
        symReturn.addQuadPoint(5.40625, 0.84375, 5.40625, 0.84375, 4.70312, 0.84375, 4.70312, 0.84375);
1668
        symReturn.addQuadPoint(4.70312, 0.84375, 4.70312, 0.84375, 4.70312, 9.14062, 4.70312, 9.14062);
1669
        symReturn.addQuadPoint(4.70312, 9.14062, 4.70312, 9.14062, 3.875, 9.14062, 3.875, 9.14062);
1670
        symReturn.addQuadPoint(3.875, 9.14062, 3.875, 9.14062, 3.875, 0.84375, 3.875, 0.84375);
1671
        symReturn.addQuadPoint(3.875, 0.84375, 3.875, 0.84375, 2.78125, 0.84375, 2.78125, 0.84375);
1672
        symReturn.addQuadPoint(2.78125, 0.84375, 2.78125, 0.84375, 2.78125, 9.14062, 2.78125, 9.14062);
1673
        symReturn.addQuadPoint(2.78125, 9.14062, 2.78125, 9.14062, 1.98438, 9.14062, 1.98438, 9.14062);
1674
        symNewLine.resize(0);
1675
        symNewLine.addQuadPoint(6.51562, 2.625, 6.51562, 2.625, 0.90625, 2.64062, 0.90625, 2.64062);
1676
        symNewLine.addQuadPoint(0.90625, 2.64062, 0.90625, 2.64062, 1.4375, 1.92188, 1.26562, 2.1875);
1677
        symNewLine.addQuadPoint(1.4375, 1.92188, 1.4375, 1.92188, 1.76562, 1.14062, 1.75, 1.42188);
1678
        symNewLine.addQuadPoint(1.76562, 1.14062, 1.76562, 1.14062, 1.60938, 1.03125, 1.60938, 1.03125);
1679
        symNewLine.addQuadPoint(1.60938, 1.03125, 1.60938, 1.03125, 0.90625, 1.92188, 0.90625, 1.92188);
1680
        symNewLine.addQuadPoint(0.90625, 1.92188, 0.90625, 1.92188, 0, 2.90625, 0.578125, 2.23438);
1681
        symNewLine.addQuadPoint(0, 2.90625, 0, 2.90625, 0.75, 3.875, 0.75, 3.875);
1682
        symNewLine.addQuadPoint(0.75, 3.875, 0.75, 3.875, 1.57812, 4.78125, 1.1875, 4.40625);
1683
        symNewLine.addQuadPoint(1.57812, 4.78125, 1.57812, 4.78125, 1.65625, 4.79688, 1.65625, 4.79688);
1684
        symNewLine.addQuadPoint(1.65625, 4.79688, 1.65625, 4.79688, 1.76562, 4.65625, 1.76562, 4.65625);
1685
        symNewLine.addQuadPoint(1.76562, 4.65625, 1.76562, 4.65625, 0.90625, 3.17188, 1.73438, 4.34375);
1686
        symNewLine.addQuadPoint(0.90625, 3.17188, 0.90625, 3.17188, 0.96875, 3.125, 0.96875, 3.125);
1687
        symNewLine.addQuadPoint(0.96875, 3.125, 0.96875, 3.125, 6.75, 3.125, 6.75, 3.125);
1688
        symNewLine.addQuadPoint(6.75, 3.125, 6.75, 3.125, 6.51562, 2.625, 6.51562, 2.625);
1689
        symNewLine.addQuadPoint(6.51562, 2.625, 6.51562, 2.625, 6.51562, 2.625, 6.51562, 2.625);
1690
        symNewLine.addQuadPoint(999999, 999999, 999999, 999999, 999999, 999999, 999999, 999999);
1691
        symNewLine.addQuadPoint(6.875, 0, 6.875, 0, 6.51562, 0, 6.51562, 0);
1692
        symNewLine.addQuadPoint(6.51562, 0, 6.51562, 0, 6.51562, 2.84375, 6.51562, 2.84375);
1693
        symNewLine.addQuadPoint(6.51562, 2.84375, 6.51562, 2.84375, 6.75, 3.125, 6.51562, 3.125);
1694
        symNewLine.addQuadPoint(6.75, 3.125, 6.75, 3.125, 6.85938, 3.0625, 6.85938, 3.0625);
1695
        symNewLine.addQuadPoint(6.85938, 3.0625, 6.85938, 3.0625, 6.875, 0, 6.875, 0);
1696
        symTab.resize(0);
1697
        symTab.addQuadPoint(4.82812, 3.96875, 4.82812, 3.96875, 4.5625, 3.73438, 4.5625, 3.96875);
1698
        symTab.addQuadPoint(4.5625, 3.73438, 4.5625, 3.73438, 5.07812, 3.10938, 4.5625, 3.57812);
1699
        symTab.addQuadPoint(5.07812, 3.10938, 5.07812, 3.10938, 0, 3.10938, 0, 3.10938);
1700
        symTab.addQuadPoint(0, 3.10938, 0, 3.10938, 0, 2.625, 0, 2.625);
1701
        symTab.addQuadPoint(0, 2.625, 0, 2.625, 5.53125, 2.625, 5.53125, 2.625);
1702
        symTab.addQuadPoint(5.53125, 2.625, 5.53125, 2.625, 6.3125, 1.8125, 6.3125, 1.8125);
1703
        symTab.addQuadPoint(6.3125, 1.8125, 6.3125, 1.8125, 5.64062, 1.29688, 5.64062, 1.29688);
1704
        symTab.addQuadPoint(5.64062, 1.29688, 5.64062, 1.29688, 0, 1.29688, 0, 1.29688);
1705
        symTab.addQuadPoint(0, 1.29688, 0, 1.29688, 0, 0.8125, 0, 0.8125);
1706
        symTab.addQuadPoint(0, 0.8125, 0, 0.8125, 5.01562, 0.8125, 5.01562, 0.8125);
1707
        symTab.addQuadPoint(5.01562, 0.8125, 5.01562, 0.8125, 4.45312, 0.265625, 4.45312, 0.453125);
1708
        symTab.addQuadPoint(4.45312, 0.265625, 4.45312, 0.265625, 4.6875, 0, 4.45312, 0);
1709
        symTab.addQuadPoint(4.6875, 0, 4.6875, 0, 5.90625, 0.828125, 4.875, 0);
1710
        symTab.addQuadPoint(5.90625, 0.828125, 5.90625, 0.828125, 6.9375, 1.79688, 6.9375, 1.64062);
1711
        symTab.addQuadPoint(6.9375, 1.79688, 6.9375, 1.79688, 5.95312, 2.96875, 6.9375, 1.95312);
1712
        symTab.addQuadPoint(5.95312, 2.96875, 5.95312, 2.96875, 4.82812, 3.96875, 4.98438, 3.96875);
1713
        symNonBreak.resize(0);
1714
        symNonBreak.addQuadPoint(1.32812, 2.59375, 1.32812, 2.59375, 0.390625, 2.21875, 0.796875, 2.59375);
1715
        symNonBreak.addQuadPoint(0.390625, 2.21875, 0.390625, 2.21875, 0, 1.3125, 0, 1.84375);
1716
        symNonBreak.addQuadPoint(0, 1.3125, 0, 1.3125, 0.390625, 0.390625, 0, 0.765625);
1717
        symNonBreak.addQuadPoint(0.390625, 0.390625, 0.390625, 0.390625, 1.32812, 0, 0.796875, 0);
1718
        symNonBreak.addQuadPoint(1.32812, 0, 1.32812, 0, 2.23438, 0.390625, 1.85938, 0);
1719
        symNonBreak.addQuadPoint(2.23438, 0.390625, 2.23438, 0.390625, 2.60938, 1.29688, 2.60938, 0.765625);
1720
        symNonBreak.addQuadPoint(2.60938, 1.29688, 2.60938, 1.29688, 2.23438, 2.21875, 2.60938, 1.84375);
1721
        symNonBreak.addQuadPoint(2.23438, 2.21875, 2.23438, 2.21875, 1.32812, 2.59375, 1.875, 2.59375);
1722
        symNewCol.resize(0);
1723
        symNewCol.addQuadPoint(1.73438, 0, 1.73438, 0, 2.67188, 0.109375, 2.03125, 0);
1724
        symNewCol.addQuadPoint(2.67188, 0.109375, 2.67188, 0.109375, 3.59375, 0.203125, 3.26562, 0.21875);
1725
        symNewCol.addQuadPoint(3.59375, 0.203125, 3.59375, 0.203125, 3.79688, 0.1875, 3.64062, 0.203125);
1726
        symNewCol.addQuadPoint(3.79688, 0.1875, 3.79688, 0.1875, 4, 0.171875, 3.92188, 0.171875);
1727
        symNewCol.addQuadPoint(4, 0.171875, 4, 0.171875, 4.20312, 0.1875, 4.20312, 0.1875);
1728
        symNewCol.addQuadPoint(4.20312, 0.1875, 4.20312, 0.1875, 4.3125, 1.39062, 4.20312, 0.5625);
1729
        symNewCol.addQuadPoint(4.3125, 1.39062, 4.3125, 1.39062, 4.42188, 2.64062, 4.42188, 2.21875);
1730
        symNewCol.addQuadPoint(4.42188, 2.64062, 4.42188, 2.64062, 4.28125, 2.73438, 4.28125, 2.73438);
1731
        symNewCol.addQuadPoint(4.28125, 2.73438, 4.28125, 2.73438, 3.75, 1.03125, 4.01562, 2.64062);
1732
        symNewCol.addQuadPoint(3.75, 1.03125, 3.75, 1.03125, 3.67188, 1.03125, 3.67188, 1.03125);
1733
        symNewCol.addQuadPoint(3.67188, 1.03125, 3.67188, 1.03125, 0.28125, 6.20312, 0.28125, 6.20312);
1734
        symNewCol.addQuadPoint(0.28125, 6.20312, 0.28125, 6.20312, 0, 5.95312, 0.03125, 6.17188);
1735
        symNewCol.addQuadPoint(0, 5.95312, 0, 5.95312, 3.35938, 0.71875, 3.35938, 0.71875);
1736
        symNewCol.addQuadPoint(3.35938, 0.71875, 3.35938, 0.71875, 3.375, 0.640625, 3.375, 0.640625);
1737
        symNewCol.addQuadPoint(3.375, 0.640625, 3.375, 0.640625, 2.4375, 0.484375, 2.79688, 0.5625);
1738
        symNewCol.addQuadPoint(2.4375, 0.484375, 2.4375, 0.484375, 1.67188, 0.140625, 1.71875, 0.328125);
1739
        symNewCol.addQuadPoint(1.67188, 0.140625, 1.67188, 0.140625, 1.73438, 0, 1.73438, 0);
1740
        symNewFrame.resize(0);
1741
        symNewFrame.addQuadPoint(1.75, 6.20312, 1.75, 6.20312, 2.67188, 6.09375, 2.0625, 6.20312);
1742
        symNewFrame.addQuadPoint(2.67188, 6.09375, 2.67188, 6.09375, 3.60938, 5.98438, 3.28125, 5.98438);
1743
        symNewFrame.addQuadPoint(3.60938, 5.98438, 3.60938, 5.98438, 3.84375, 6.01562, 3.6875, 5.98438);
1744
        symNewFrame.addQuadPoint(3.84375, 6.01562, 3.84375, 6.01562, 4.07812, 6.03125, 4, 6.03125);
1745
        symNewFrame.addQuadPoint(4.07812, 6.03125, 4.07812, 6.03125, 4.20312, 6.01562, 4.20312, 6.01562);
1746
        symNewFrame.addQuadPoint(4.20312, 6.01562, 4.20312, 6.01562, 4.32812, 4.79688, 4.21875, 5.625);
1747
        symNewFrame.addQuadPoint( 4.32812, 4.79688, 4.32812, 4.79688, 4.42188, 3.5625, 4.42188, 3.98438);
1748
        symNewFrame.addQuadPoint(4.42188, 3.5625, 4.42188, 3.5625, 4.29688, 3.45312, 4.29688, 3.45312);
1749
        symNewFrame.addQuadPoint(4.29688, 3.45312, 4.29688, 3.45312, 3.75, 5.17188, 4.03125, 3.54688);
1750
        symNewFrame.addQuadPoint(3.75, 5.17188, 3.75, 5.17188, 3.67188, 5.17188, 3.67188, 5.17188);
1751
        symNewFrame.addQuadPoint(3.67188, 5.17188, 3.67188, 5.17188, 0.28125, 0, 0.28125, 0);
1752
        symNewFrame.addQuadPoint(0.28125, 0, 0.28125, 0, 0, 0.25, 0.03125, 0.015625);
1753
        symNewFrame.addQuadPoint(0, 0.25, 0, 0.25, 3.375, 5.46875, 3.375, 5.46875);
1754
        symNewFrame.addQuadPoint(3.375, 5.46875, 3.375, 5.46875, 3.39062, 5.54688, 3.39062, 5.54688);
1755
        symNewFrame.addQuadPoint(3.39062, 5.54688, 3.39062, 5.54688, 2.4375, 5.70312, 2.8125, 5.625);
1756
        symNewFrame.addQuadPoint(2.4375, 5.70312, 2.4375, 5.70312, 1.67188, 6.0625, 1.71875, 5.875);
1757
        symNewFrame.addQuadPoint(1.67188, 6.0625, 1.67188, 6.0625, 1.75, 6.20312, 1.75, 6.20312);
1758
}
2893 cbradney 1759
 
10532 avox 1760
 
3852 cbradney 1761
Page* ScribusDoc::addPage(const int pageIndex, const QString& masterPageName, const bool addAutoFrame)
2893 cbradney 1762
{
9119 avox 1763
        assert(masterPageMode()==false);
8504 cbradney 1764
        Page* addedPage = new Page(scratch.Left, DocPages.count()*(pageHeight+scratch.Bottom+scratch.Top)+scratch.Top, pageWidth, pageHeight);
9119 avox 1765
        assert(addedPage!=NULL);
4738 cbradney 1766
        addedPage->setDocument(this);
8504 cbradney 1767
        addedPage->Margins.Top = pageMargins.Top;
1768
        addedPage->Margins.Bottom = pageMargins.Bottom;
1769
        addedPage->initialMargins.Top = pageMargins.Top;
1770
        addedPage->initialMargins.Bottom = pageMargins.Bottom;
1771
        addedPage->initialMargins.Left = pageMargins.Left;
1772
        addedPage->initialMargins.Right = pageMargins.Right;
3852 cbradney 1773
        addedPage->setPageNr(pageIndex);
5789 cbradney 1774
        addedPage->m_pageSize = m_pageSize;
2893 cbradney 1775
        addedPage->PageOri = PageOri;
12334 fschmid 1776
        addedPage->marginPreset = marginPreset;
10013 cbradney 1777
        DocPages.insert(pageIndex, addedPage);
1778
        assert(DocPages.at(pageIndex)!=NULL);
5087 subik 1779
        setCurrentPage(addedPage);
3787 cbradney 1780
        //if (!masterPageMode())
3985 cbradney 1781
        if (!masterPageName.isEmpty())
3911 cbradney 1782
                applyMasterPage(masterPageName, pageIndex);
6330 fschmid 1783
        setLocationBasedPageLRMargins(pageIndex);
3852 cbradney 1784
        if (addAutoFrame && automaticTextFrames)
1785
                addAutomaticTextFrame(pageIndex);
11916 fschmid 1786
//      if (!isLoading())
1787
//              changed();
2893 cbradney 1788
        return addedPage;
1789
}
2895 cbradney 1790
 
10532 avox 1791
 
3695 cbradney 1792
Page* ScribusDoc::addMasterPage(const int pageNumber, const QString& pageName)
1793
{
1794
        //CB We dont create master pages (yet) with a pageCount based location
4069 craig 1795
        //Page* addedPage = new Page(ScratchLeft, MasterPages.count()*(pageHeight+ScratchBottom+ScratchTop)+ScratchTop, pageWidth, pageHeight);
8012 cbradney 1796
        Page* addedPage = new Page(scratch.Left, scratch.Top, pageWidth, pageHeight);
18048 fschmid 1797
        int pgN = pageNumber;
1798
        if (pageNumber > MasterPages.count())
1799
                pgN = MasterPages.count();
9119 avox 1800
        assert(addedPage!=NULL);
4738 cbradney 1801
        addedPage->setDocument(this);
3695 cbradney 1802
        addedPage->Margins.Top = pageMargins.Top;
1803
        addedPage->Margins.Bottom = pageMargins.Bottom;
3912 cbradney 1804
        addedPage->Margins.Left = pageMargins.Left;//todo fix for layouts
3911 cbradney 1805
        addedPage->Margins.Right = pageMargins.Right;
3695 cbradney 1806
        addedPage->initialMargins.Top = pageMargins.Top;
1807
        addedPage->initialMargins.Bottom = pageMargins.Bottom;
1808
        addedPage->initialMargins.Left = pageMargins.Left;
1809
        addedPage->initialMargins.Right = pageMargins.Right;
5789 cbradney 1810
        addedPage->m_pageSize = m_pageSize;
3695 cbradney 1811
        addedPage->PageOri = PageOri;
12334 fschmid 1812
        addedPage->marginPreset = marginPreset;
3787 cbradney 1813
        addedPage->MPageNam = "";
3695 cbradney 1814
        addedPage->setPageName(pageName);
18048 fschmid 1815
        addedPage->setPageNr(pgN);
1816
        MasterNames.insert(pageName, pgN);
1817
        MasterPages.insert(pgN, addedPage);
1818
        assert(MasterPages.at(pgN)!=NULL);
8916 avox 1819
        if  (!isLoading())
1820
                changed();
3695 cbradney 1821
        return addedPage;
1822
}
1823
 
10532 avox 1824
 
5685 cbradney 1825
bool ScribusDoc::renameMasterPage(const QString& oldPageName, const QString& newPageName)
1826
{
6715 cbradney 1827
        Q_ASSERT(oldPageName!=CommonStrings::masterPageNormal && oldPageName!=CommonStrings::trMasterPageNormal);
5685 cbradney 1828
        if (MasterNames.contains(oldPageName) && !MasterNames.contains(newPageName))
1829
        {
1830
                //Rename our master page lists
1831
                int number=MasterNames[oldPageName];
1832
                MasterNames.insert(newPageName, number);
1833
                MasterNames.remove(oldPageName);
1834
                Q_ASSERT(MasterPages.at(number)->pageName()==oldPageName);
1835
                MasterPages.at(number)->setPageName(newPageName);
1836
                //Update any pages that were linking to our old name
10013 cbradney 1837
                Page* docPage=NULL;
1838
                for (int i=0; i < DocPages.count(); ++i )
5685 cbradney 1839
                {
10013 cbradney 1840
                        docPage=DocPages[i];
5685 cbradney 1841
                        if (docPage->MPageNam == oldPageName)
1842
                                docPage->MPageNam = newPageName;
1843
                }
5686 cbradney 1844
                //Update any items that were linking to our old name
1845
                uint masterItemsCount=MasterItems.count();
1846
                for (uint i = 0; i < masterItemsCount; ++i)
1847
                {
1848
                        if (MasterItems.at(i)->OnMasterPage == oldPageName)
1849
                                MasterItems.at(i)->OnMasterPage = newPageName;
1850
                }
5685 cbradney 1851
                changed();
1852
                return true;
1853
        }
1854
        return false;
1855
}
1856
 
10532 avox 1857
 
4069 craig 1858
void ScribusDoc::deleteMasterPage(const int pageNumber)
2895 cbradney 1859
{
9119 avox 1860
        assert(masterPageMode());
10013 cbradney 1861
        assert( Pages->count() > 1 && Pages->count() > pageNumber );
7890 fschmid 1862
        setCurrentPage(Pages->at(0));
10014 cbradney 1863
        Page* page = Pages->takeAt(pageNumber);
5685 cbradney 1864
        QString oldPageName(page->pageName());
4069 craig 1865
        delete page;
17416 jghali 1866
        // #10658 : renumber masterpages and masterpage objects
1867
        // in order to avoid crash after masterpage deletion
17414 jghali 1868
        for (int i = 0; i < MasterPages.count(); ++i)
1869
                MasterPages.at(i)->setPageNr(i);
1870
        for (int i = 0; i < MasterItems.count(); ++i)
1871
        {
1872
                if (MasterItems.at(i)->OwnPage > pageNumber)
1873
                        MasterItems.at(i)->OwnPage--;
1874
        }
4069 craig 1875
        // remove the master page from the master page name list
4615 cbradney 1876
        //MasterNames.remove(page->PageNam);
1877
        /*CB TODO moved back to muster.cpp for now as this must happen after reformPages
1878
        MasterNames.clear();
1879
        for (uint a = 0; a < Pages->count(); ++a)
1880
                MasterNames[Pages->at(a)->PageNam] = Pages->at(a)->pageNr();
4069 craig 1881
        // and fix up any pages that refer to the deleted master page
1882
        for (Page* docPage = DocPages.first(); docPage; docPage = DocPages.next() )
2895 cbradney 1883
        {
4615 cbradney 1884
                if (docPage->MPageNam == oldPageName)
6715 cbradney 1885
                        docPage->MPageNam = CommonStrings::masterPageNormal;
2895 cbradney 1886
        }
4615 cbradney 1887
        */
4730 subik 1888
        //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 1889
        changed();
4069 craig 1890
}
1891
 
10532 avox 1892
 
10155 jghali 1893
void ScribusDoc::rebuildMasterNames(void)
1894
{
1895
        MasterNames.clear();
10162 cbradney 1896
        for (int a = 0; a < MasterPages.count(); ++a)
10155 jghali 1897
                MasterNames[MasterPages.at(a)->pageName()] = MasterPages.at(a)->pageNr();
1898
}
1899
 
10532 avox 1900
 
10155 jghali 1901
void ScribusDoc::replaceMasterPage(const QString& oldMasterPage)
1902
{
1903
        uint pageIndex = 0;
1904
        QMap<QString,int>::Iterator it = MasterNames.begin();
1905
        QListIterator<Page *> dpIt(DocPages);
1906
        Page* docPage=NULL;
1907
        while(dpIt.hasNext())
1908
        //for (Page* docPage = currentDoc->DocPages.first(); docPage; docPage = currentDoc->DocPages.next() )
1909
        {
1910
                docPage=dpIt.next();
1911
                if (docPage->MPageNam == oldMasterPage)
1912
                {
1913
                        PageLocation pageLoc = locationOfPage(pageIndex);
1914
                        if (pageLoc == LeftPage)
1915
                        {
1916
                                if (MasterNames.contains( CommonStrings::trMasterPageNormalLeft))
1917
                                        docPage->MPageNam = CommonStrings::trMasterPageNormalLeft;
1918
                                else if (MasterNames.contains( CommonStrings::trMasterPageNormal))
1919
                                        docPage->MPageNam = CommonStrings::trMasterPageNormal;
1920
                                else
1921
                                        docPage->MPageNam = it.key();
1922
                        }
1923
                        else if (pageLoc == RightPage)
1924
                        {
1925
                                if (MasterNames.contains( CommonStrings::trMasterPageNormalRight))
1926
                                        docPage->MPageNam = CommonStrings::trMasterPageNormalRight;
1927
                                else if (MasterNames.contains( CommonStrings::trMasterPageNormal))
1928
                                        docPage->MPageNam = CommonStrings::trMasterPageNormal;
1929
                                else
1930
                                        docPage->MPageNam = it.key();
1931
                        }
1932
                        else
1933
                        {
1934
                                if (MasterNames.contains( CommonStrings::trMasterPageNormalMiddle))
1935
                                        docPage->MPageNam = CommonStrings::trMasterPageNormalMiddle;
1936
                                else if (MasterNames.contains( CommonStrings::trMasterPageNormal))
1937
                                        docPage->MPageNam = CommonStrings::trMasterPageNormal;
1938
                                else
1939
                                        docPage->MPageNam = it.key();
1940
                        }
1941
                }
1942
                pageIndex++;
1943
        }
1944
}
1945
 
10532 avox 1946
 
4069 craig 1947
void ScribusDoc::deletePage(const int pageNumber)
1948
{
10013 cbradney 1949
        assert( Pages->count() > 1 && Pages->count() > pageNumber );
9030 cbradney 1950
        //#5561: If we are going to delete the first page, do not set the current page to it
9855 jghali 1951
        setCurrentPage(Pages->at(pageNumber!=0?0:1));
10014 cbradney 1952
        Page* page = Pages->takeAt(pageNumber);
4069 craig 1953
        delete page;
17212 craig 1954
        reformPages();
5545 cbradney 1955
        changed();
2895 cbradney 1956
}
1957
 
10532 avox 1958
 
17212 craig 1959
void ScribusDoc::movePage(const int fromPage, const int toPage, const int dest, const int position)
2895 cbradney 1960
{
17212 craig 1961
        QList<Page*> pageList;
1962
        int numPages = dest;
1963
        for (int i = fromPage; i < toPage; ++i)
2895 cbradney 1964
        {
17212 craig 1965
                pageList.append(Pages->takeAt(fromPage));
1966
                if (i <= numPages)
1967
                        --numPages;
2895 cbradney 1968
        }
17212 craig 1969
        int pageListCount=pageList.count();
1970
        switch (position)
2895 cbradney 1971
        {
17212 craig 1972
                case 0: //Before Page
1973
                        for (int j = 0; j < pageListCount; ++j)
1974
                                Pages->insert(numPages++, pageList.at(j));
2895 cbradney 1975
                        break;
17212 craig 1976
                case 1: //After Page
1977
                        for (int j = 0; j < pageListCount; ++j)
1978
                                Pages->insert(++numPages, pageList.at(j));
2895 cbradney 1979
                        break;
17212 craig 1980
                case 2: //To End
1981
                        for (int j = 0; j < pageListCount; ++j)
1982
                                Pages->append(pageList.at(j));
2895 cbradney 1983
                        break;
1984
        }
17212 craig 1985
 
1986
        if (UndoManager::undoEnabled())
1987
        {
1988
                SimpleState *ss = new SimpleState(Um::MovePage, "", Um::IDocument);
1989
                ss->set("PAGE_MOVE", "page_move");
1990
                ss->set("PAGE_MOVE_FROM", fromPage);
1991
                ss->set("PAGE_MOVE_TO", toPage);
1992
                ss->set("PAGE_MOVE_DEST", dest);
1993
                ss->set("PAGE_MOVE_NEWPOS", position);
1994
                undoManager->action(this, ss, DocName, Um::IDocument);
1995
        }
1996
        reformPages();
1997
        if (m_View && m_ScMW )
1998
        {
1999
                m_View->reformPagesView();
2000
                m_ScMW->updateGUIAfterPagesChanged();
2001
        }
5226 cbradney 2002
        changed();
2895 cbradney 2003
}
2937 cbradney 2004
 
17212 craig 2005
void ScribusDoc::restoreMovePage(SimpleState *state, bool isUndo)
2006
{
2007
        int fromPage = state->getInt("PAGE_MOVE_FROM");
2008
        int toPage = state->getInt("PAGE_MOVE_TO");
2009
        int position = state->getInt("PAGE_MOVE_NEWPOS");
2010
        int dest = state->getInt("PAGE_MOVE_DEST");
10532 avox 2011
 
17212 craig 2012
        if (isUndo)
2013
        {
18804 jghali 2014
                int newPageDest = fromPage;
2015
                int newPageFrom = 0;
2016
                int newPageTo   = 0;
2017
                int newPosition = 0;
2018
                int pagesMoved  = toPage - fromPage;
17212 craig 2019
                switch (position)
2020
                {
2021
                        case 0: //Before Page
18804 jghali 2022
                                newPageDest = (toPage <= dest) ? fromPage : toPage;
2023
                                newPageFrom = (toPage <= dest) ? (dest - pagesMoved) : dest;
17212 craig 2024
                                break;
2025
                        case 1: //After Page
18804 jghali 2026
                                newPageDest = (toPage <= dest) ? fromPage : toPage;
2027
                                newPageFrom = (toPage <= dest) ? (dest-pagesMoved + 1) : (dest + 1);
17212 craig 2028
                                break;
2029
                        case 2: //To End
18804 jghali 2030
                                newPageFrom = Pages->count() - pagesMoved;
17212 craig 2031
                                break;
2032
                }
18804 jghali 2033
                newPageTo = newPageFrom + pagesMoved;
17212 craig 2034
                movePage(newPageFrom, newPageTo, newPageDest, newPosition);
2035
        }
2036
        else
2037
                movePage(fromPage, toPage, dest, position);
2038
}
2039
 
2040
 
3985 cbradney 2041
int ScribusDoc::addAutomaticTextFrame(const int pageNumber)
3778 cbradney 2042
{
3852 cbradney 2043
        if (!automaticTextFrames)
2044
                return -1;
3778 cbradney 2045
        Page *addToPage=DocPages.at(pageNumber);
3843 cbradney 2046
        if ((!masterPageMode()) && (usesAutomaticTextFrames()))// && (!isLoading()))
3778 cbradney 2047
        {
4546 subik 2048
                int z = itemAdd(PageItem::TextFrame, PageItem::Unspecified,
3778 cbradney 2049
                                     addToPage->Margins.Left+addToPage->xOffset(),
2050
                                     addToPage->Margins.Top+addToPage->yOffset(), pageWidth-addToPage->Margins.Right-addToPage->Margins.Left,
2051
                                     pageHeight-addToPage->Margins.Bottom-addToPage->Margins.Top,
4546 subik 2052
                                                         1, CommonStrings::None, toolSettings.dPen, true);
3778 cbradney 2053
                Items->at(z)->isAutoText = true;
2054
                Items->at(z)->Cols = qRound(PageSp);
2055
                Items->at(z)->ColGap = PageSpa;
5732 avox 2056
                if (LastAuto != 0) {
7994 avox 2057
                        LastAuto->link(Items->at(z));
5732 avox 2058
                }      
3778 cbradney 2059
                else
2060
                        FirstAuto = Items->at(z);
2061
                LastAuto = Items->at(z);
2062
                Items->at(z)->setRedrawBounding();
3781 cbradney 2063
                return z;
3778 cbradney 2064
        }
3781 cbradney 2065
        return -1;
3778 cbradney 2066
}
2067
 
10532 avox 2068
 
4645 subik 2069
int ScribusDoc::addLayer(const QString& layerName, const bool activate)
2937 cbradney 2070
{
10140 jghali 2071
        int lnr = Layers.addLayer(layerName);
12793 cbradney 2072
        if (lnr==-1)
2073
                return -1;
2937 cbradney 2074
        if (activate)
10140 jghali 2075
                setActiveLayer(lnr);
2076
        const ScLayer* ll = Layers.layerByNumber(lnr);
12793 cbradney 2077
        if (!ll)
2078
                qWarning() << "Layer added without undo, could not get layer back for undo action creation";
2079
        else
2937 cbradney 2080
        if (UndoManager::undoEnabled())
2081
        {
2082
                SimpleState *ss = new SimpleState(Um::AddLayer, "", Um::ICreate);
2083
                ss->set("ADD_LAYER", "add_layer");
2084
                ss->set("ACTIVE", ActiveLayer);
10140 jghali 2085
                ss->set("NAME", ll->Name);
2086
                ss->set("LAYER_NR", ll->LNr);
2937 cbradney 2087
                undoManager->action(this, ss, DocName, Um::ILayer);
2088
        }
10140 jghali 2089
        return lnr;
2937 cbradney 2090
}
2091
 
10532 avox 2092
 
6290 fschmid 2093
void ScribusDoc::copyLayer(int layerNumberToCopy, int whereToInsert)
2094
{
12405 pierre 2095
        if(!setActiveLayer(whereToInsert))
2096
                return;
12407 pierre 2097
        Selection sourceSelection(this);
2098
        for (int ite(0); ite < Items->count(); ++ite)
6290 fschmid 2099
        {
2100
                PageItem *itemToCopy = Items->at(ite);
2101
                if (itemToCopy->LayerNr == layerNumberToCopy)
2102
                {
12407 pierre 2103
                        sourceSelection.addItem(itemToCopy);
6290 fschmid 2104
                }
2105
        }
16083 jghali 2106
        if (sourceSelection.count() > 0)
12407 pierre 2107
        {
16083 jghali 2108
                Selection targetSelection(Serializer(*this).cloneObjects(sourceSelection));
2109
                for(int si(0); si < targetSelection.count(); ++si)
2110
                {
2111
                        targetSelection.itemAt(si)->setLayer(whereToInsert);
2112
                }
12407 pierre 2113
        }
6290 fschmid 2114
}
2115
 
10532 avox 2116
 
3985 cbradney 2117
bool ScribusDoc::deleteLayer(const int layerNumber, const bool deleteItems)
2937 cbradney 2118
{
2119
        if (Layers.count() < 2)
2120
                return false;
10140 jghali 2121
        const ScLayer* lToRemove = Layers.layerByNumber(layerNumber);
2122
        if (!lToRemove)
2937 cbradney 2123
                return false;
10140 jghali 2124
        int layerLevel = lToRemove->Level;
2125
        QString name   = lToRemove->Name;
11576 avox 2126
        UndoTransaction* activeTransaction = NULL;
2944 cbradney 2127
        if (UndoManager::undoEnabled())
11576 avox 2128
                activeTransaction = new UndoTransaction(undoManager->beginTransaction("Layer", Um::IDocument, Um::DeleteLayer, "", Um::IDelete));
2944 cbradney 2129
 
10144 jghali 2130
        rebuildItemLists();
5243 cbradney 2131
        if (ScCore->usingGUI())
4713 cbradney 2132
                removeLayer(layerNumber, deleteItems);
10144 jghali 2133
 
2937 cbradney 2134
        /*
2135
        //Layer found, do we want to delete its items too?
2136
        if (masterPageMode)
2137
                MasterPages = Pages;
2138
        else
2139
                DocPages = Pages;
2140
        for (uint b = 0; b < MasterItems.count(); ++b)
2141
        {
2142
                if (MasterItems.at(b)->LayerNr == layerNumber)
2143
                {
2144
                        if (deleteItems)
2145
                        {
2146
                                MasterItems.at(b)->setTagged(true);
10144 jghali 2147
                                MasterItems.at(b)->setLocked(false);
2937 cbradney 2148
                        }
2149
                        else
2150
                                MasterItems.at(b)->setTagged(false);
2151
                }
2152
        }
2153
//      if (view->SelItem.count() != 0)
2154
//              view->DeleteItem();
2155
//      view->SelItem.clear();
2156
        for (uint b = 0; b < DocItems.count(); ++b)
2157
        {
2158
                if (DocItems.at(b)->LayerNr == l)
2159
                {
2160
                        if (deleteItems)
2161
                        {
2162
                                DocItems.at(b)->setTagged(true);
2163
                                DocItems.at(b)->setLocked(false);
2164
                        }
2165
                        else
2166
                                DocItems.at(b)->setLayer(0);
2167
                }
2168
        }
2169
//      if (view->SelItem.count() != 0)
2170
//              view->DeleteItem();
2171
 
2172
        bool deletedOk=deleteTaggedItems();
2173
        Q_ASSERT(deletedOk);
3201 subik 2174
 
2937 cbradney 2175
        */
2176
        //Now delete the layer
10140 jghali 2177
        Layers.removeLayerByNumber(layerNumber);
3201 subik 2178
 
11576 avox 2179
        if (activeTransaction)
2937 cbradney 2180
        {
2181
                SimpleState *ss = new SimpleState(Um::DeleteLayer, "", Um::IDelete);
2182
                ss->set("REMOVE_LAYER", "remove_layer");
2183
                ss->set("ACTIVE", layerNumber);
2184
                ss->set("LEVEL", layerLevel);
2185
                ss->set("NAME", name);
2186
                ss->set("LAYER_NR", layerNumber);