Subversion Repositories Scribus

Rev

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