Subversion Repositories Scribus

Rev

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