Subversion Repositories Scribus

Rev

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