Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
3 paul 1
/***************************************************************************
2
                          scribusdoc.cpp  -  description
3
                             -------------------
4
    begin                : Fre Apr  6 21:47:55 CEST 2001
5
    copyright            : (C) 2001 by Franz Schmid
6
    email                : Franz.Schmid@altmuehlnet.de
7
 ***************************************************************************/
8
 
9
/***************************************************************************
10
 *                                                                         *
11
 *   This program is free software; you can redistribute it and/or modify  *
12
 *   it under the terms of the GNU General Public License as published by  *
13
 *   the Free Software Foundation; either version 2 of the License, or     *
14
 *   (at your option) any later version.                                   *
15
 *                                                                         *
16
 ***************************************************************************/
17
 
18
#include "scribusdoc.h"
410 Franz 19
#include "scribusXml.h"
20
#include "scribus.h"
2016 cbradney 21
 
22
#include <qfile.h>
23
 
456 fschmid 24
#include "page.h"
25
#include "pageitem.h"
1179 tsoots 26
#include "undomanager.h"
27
#include "undostate.h"
410 Franz 28
 
2016 cbradney 29
 
1179 tsoots 30
extern QPixmap loadIcon(QString nam);
31
 
2219 fschmid 32
ScribusDoc::ScribusDoc(struct ApplicationPrefs *prefsData) : UndoObject(QObject::tr("Document"))
3 paul 33
{
823 fschmid 34
        prefsValues = prefsData;
167 Franz 35
        modified = false;
36
        MasterP = false;
1330 fschmid 37
        NrItems = 0;
38
        First = 1;
39
        Last = 0;
40
        viewCount = 0;
41
        viewID = 0;
823 fschmid 42
        UsedFonts.clear();
43
        FT_Init_FreeType( &library );
44
        AllFonts = &prefsData->AvailFonts;
1194 fschmid 45
        AddFont(prefsData->toolSettings.defFont, prefsData->AvailFonts[prefsData->toolSettings.defFont]->Font);
46
        toolSettings.defFont = prefsData->toolSettings.defFont;
47
        toolSettings.defSize = prefsData->toolSettings.defSize;
2219 fschmid 48
        toolSettings.tabFillChar = prefsData->toolSettings.tabFillChar;
879 fschmid 49
        guidesSettings.marginsShown = prefsData->guidesSettings.marginsShown;
50
        guidesSettings.framesShown = prefsData->guidesSettings.framesShown;
51
        guidesSettings.gridShown = prefsData->guidesSettings.gridShown;
52
        guidesSettings.guidesShown = prefsData->guidesSettings.guidesShown;
53
        guidesSettings.baseShown = prefsData->guidesSettings.baseShown;
54
        guidesSettings.linkShown = prefsData->guidesSettings.linkShown;
55
        guidesSettings.showPic = prefsData->guidesSettings.showPic;
56
        guidesSettings.grabRad = prefsData->guidesSettings.grabRad;
57
        guidesSettings.guideRad = prefsData->guidesSettings.guideRad;
58
        guidesSettings.minorGrid = prefsData->guidesSettings.minorGrid;
59
        guidesSettings.majorGrid = prefsData->guidesSettings.majorGrid;
60
        guidesSettings.minorColor = prefsData->guidesSettings.minorColor;
61
        guidesSettings.majorColor = prefsData->guidesSettings.majorColor;
823 fschmid 62
        papColor = prefsData->DpapColor;
879 fschmid 63
        guidesSettings.margColor = prefsData->guidesSettings.margColor;
64
        guidesSettings.guideColor = prefsData->guidesSettings.guideColor;
65
        guidesSettings.baseColor = prefsData->guidesSettings.baseColor;
1187 fschmid 66
        guidesSettings.before = prefsData->guidesSettings.before;
823 fschmid 67
        PageColors.clear();
68
        PageColors.insert("Black", CMYKColor(0, 0, 0, 255));
69
        PageColors.insert("White", CMYKColor(0, 0, 0, 0));
1194 fschmid 70
        if (prefsData->toolSettings.dPen != "None")
71
                PageColors.insert(prefsData->toolSettings.dPen, prefsData->DColors[prefsData->toolSettings.dPen]);
72
        toolSettings.dPen = prefsData->toolSettings.dPen;
73
        if (prefsData->toolSettings.dPenLine != "None")
74
                PageColors.insert(prefsData->toolSettings.dPenLine, prefsData->DColors[prefsData->toolSettings.dPenLine]);
75
        toolSettings.dPenLine = prefsData->toolSettings.dPenLine;
76
        if (prefsData->toolSettings.dPenText != "None")
77
                PageColors.insert(prefsData->toolSettings.dPenText, prefsData->DColors[prefsData->toolSettings.dPenText]);
78
        toolSettings.dPenText = prefsData->toolSettings.dPenText;
79
        if (prefsData->toolSettings.dStrokeText != "None")
80
                PageColors.insert(prefsData->toolSettings.dStrokeText, prefsData->DColors[prefsData->toolSettings.dStrokeText]);
81
        toolSettings.dStrokeText = prefsData->toolSettings.dStrokeText;
82
        if (prefsData->toolSettings.dBrush != "None")
83
                PageColors.insert(prefsData->toolSettings.dBrush, prefsData->DColors[prefsData->toolSettings.dBrush]);
84
        toolSettings.dBrush = prefsData->toolSettings.dBrush;
85
        if (prefsData->toolSettings.dBrushPict != "None")
86
                PageColors.insert(prefsData->toolSettings.dBrushPict, prefsData->DColors[prefsData->toolSettings.dBrushPict]);
87
        toolSettings.dBrushPict = prefsData->toolSettings.dBrushPict;
823 fschmid 88
        typographicSetttings.valueSuperScript = prefsData->typographicSetttings.valueSuperScript;
89
        typographicSetttings.scalingSuperScript = prefsData->typographicSetttings.scalingSuperScript;
90
        typographicSetttings.valueSubScript = prefsData->typographicSetttings.valueSubScript;
91
        typographicSetttings.scalingSubScript = prefsData->typographicSetttings.scalingSubScript;
92
        typographicSetttings.valueSmallCaps = prefsData->typographicSetttings.valueSmallCaps;
93
        typographicSetttings.autoLineSpacing = prefsData->typographicSetttings.autoLineSpacing;
94
        typographicSetttings.valueBaseGrid = prefsData->typographicSetttings.valueBaseGrid;
95
        typographicSetttings.offsetBaseGrid = prefsData->typographicSetttings.offsetBaseGrid;
2163 fschmid 96
        typographicSetttings.valueUnderlinePos = prefsData->typographicSetttings.valueUnderlinePos;
97
        typographicSetttings.valueUnderlineWidth = prefsData->typographicSetttings.valueUnderlineWidth;
98
        typographicSetttings.valueStrikeThruPos = prefsData->typographicSetttings.valueStrikeThruPos;
99
        typographicSetttings.valueStrikeThruWidth = prefsData->typographicSetttings.valueStrikeThruWidth;
1194 fschmid 100
        toolSettings.dShade = prefsData->toolSettings.dShade;
101
        toolSettings.dShade2 = prefsData->toolSettings.dShade2;
102
        toolSettings.shadePict = prefsData->toolSettings.shadePict;
103
        toolSettings.scaleX = prefsData->toolSettings.scaleX;
104
        toolSettings.scaleY = prefsData->toolSettings.scaleY;
105
        toolSettings.scaleType = prefsData->toolSettings.scaleType;
106
        toolSettings.aspectRatio = prefsData->toolSettings.aspectRatio;
2040 fschmid 107
        toolSettings.useEmbeddedPath = prefsData->toolSettings.useEmbeddedPath;
2025 fschmid 108
        toolSettings.lowResType = prefsData->toolSettings.lowResType;
1194 fschmid 109
        toolSettings.dCols = prefsData->toolSettings.dCols;
110
        toolSettings.dGap = prefsData->toolSettings.dGap;
2285 fschmid 111
        toolSettings.dTabWidth = prefsData->toolSettings.dTabWidth;
1194 fschmid 112
        toolSettings.dLineArt = PenStyle(prefsData->toolSettings.dLineArt);
113
        toolSettings.dWidth = prefsData->toolSettings.dWidth;
114
        toolSettings.dShadeLine = prefsData->toolSettings.dShadeLine;
115
        toolSettings.dLstyleLine = PenStyle(prefsData->toolSettings.dLstyleLine);
116
        toolSettings.dWidthLine = prefsData->toolSettings.dWidthLine;
117
        toolSettings.dStartArrow = prefsData->toolSettings.dStartArrow;
118
        toolSettings.dEndArrow = prefsData->toolSettings.dEndArrow;
119
        toolSettings.polyC = prefsData->toolSettings.polyC;
120
        toolSettings.polyF = prefsData->toolSettings.polyF;
121
        toolSettings.polyS = prefsData->toolSettings.polyS;
122
        toolSettings.polyFd = prefsData->toolSettings.polyFd;
123
        toolSettings.polyR = prefsData->toolSettings.polyR;
124
        toolSettings.magMin = prefsData->toolSettings.magMin;
125
        toolSettings.magMax = prefsData->toolSettings.magMax;
126
        toolSettings.magStep = prefsData->toolSettings.magStep;
1261 fschmid 127
        checkerProfiles = prefsData->checkerProfiles;
128
        curCheckProfile = prefsData->curCheckProfile;
1065 cbradney 129
        docUnitIndex = prefsData->docUnitIndex;
130
        marginColored = prefsData->marginColored;
823 fschmid 131
        Language = prefsData->Language;
132
        MinWordLen = prefsData->MinWordLen;
133
        HyCount = prefsData->HyCount;
134
        Automatic = prefsData->Automatic;
135
        AutoCheck = prefsData->AutoCheck;
3 paul 136
        GuideLock = false;
137
        SnapGuides = false;
167 Franz 138
        useRaster = false;
139
        EditClip = false;
140
        EditClipMode = 0;
141
        loading = false;
178 Franz 142
        DocName = QObject::tr("Document")+"-";
3 paul 143
        CurrentSel = -1;
2142 cbradney 144
        pageCount = 0;
3 paul 145
        LastAuto = 0;
146
        FirstAuto = 0;
147
        DraggedElem = 0;
148
        GroupCounter = 1;
1065 cbradney 149
        docParagraphStyles.clear();
150
        struct ParagraphStyle vg;
3 paul 151
        vg.Vname = "Normal Internal";
152
        vg.LineSpa = 15;
1065 cbradney 153
        vg.textAlignment = 0;
3 paul 154
        vg.Indent = 0;
155
        vg.First = 0;
1065 cbradney 156
        vg.gapBefore = 0;
157
        vg.gapAfter = 0;
3 paul 158
        vg.Font = "";
1194 fschmid 159
        vg.FontSize = toolSettings.defSize;
140 Franz 160
        vg.TabValues.clear();
153 Franz 161
        vg.Drop = false;
162
        vg.DropLin = 2;
173 Franz 163
        vg.FontEffect = 0;
1194 fschmid 164
        vg.FColor = toolSettings.dBrush;
165
        vg.FShade = toolSettings.dShade;
166
        vg.SColor = toolSettings.dPen;
167
        vg.SShade = toolSettings.dShade2;
241 Franz 168
        vg.BaseAdj = false;
2273 fschmid 169
        vg.txtShadowX = 50;
170
        vg.txtShadowY = -50;
171
        vg.txtOutline = 10;
172
        vg.txtUnderPos = typographicSetttings.valueUnderlinePos;
173
        vg.txtUnderWidth = typographicSetttings.valueUnderlineWidth;
174
        vg.txtStrikePos = typographicSetttings.valueStrikeThruPos;
175
        vg.txtStrikeWidth = typographicSetttings.valueStrikeThruPos;
1065 cbradney 176
        docParagraphStyles.append(vg);
3 paul 177
        vg.Vname = "Center Internal";
1065 cbradney 178
        vg.textAlignment = 1;
179
        docParagraphStyles.append(vg);
3 paul 180
        vg.Vname = "Rechts Internal";
1065 cbradney 181
        vg.textAlignment = 2;
182
        docParagraphStyles.append(vg);
3 paul 183
        vg.Vname = "Block Internal";
1065 cbradney 184
        vg.textAlignment = 3;
185
        docParagraphStyles.append(vg);
3 paul 186
        vg.Vname = "EBlock Internal";
1065 cbradney 187
        vg.textAlignment = 4;
188
        docParagraphStyles.append(vg);
3 paul 189
        Layers.clear();
190
        struct Layer ll;
191
        ll.LNr = 0;
192
        ll.Level = 0;
178 Franz 193
        ll.Name = QObject::tr("Background");
1065 cbradney 194
        ll.isViewable = true;
195
        ll.isPrintable = true;
3 paul 196
        Layers.append(ll);
197
        ActiveLayer = 0;
198
        JavaScripts.clear();
167 Franz 199
        CurrentStyle = 0;
1065 cbradney 200
        currentParaStyle = 0;
3 paul 201
        TotalItems = 0;
2093 cbradney 202
        masterPageMode = false;
1545 cbradney 203
        PDF_Options.Thumbnails = prefsData->PDF_Options.Thumbnails;
204
        PDF_Options.Articles = prefsData->PDF_Options.Articles;
205
        PDF_Options.Compress = prefsData->PDF_Options.Compress;
206
        PDF_Options.CompressMethod = prefsData->PDF_Options.CompressMethod;
207
        PDF_Options.Quality = prefsData->PDF_Options.Quality;
208
        PDF_Options.RecalcPic = prefsData->PDF_Options.RecalcPic;
209
        PDF_Options.Bookmarks = prefsData->PDF_Options.Bookmarks;
210
        PDF_Options.PicRes = prefsData->PDF_Options.PicRes;
1973 craig 211
        // Fixme: Check PDF version input
212
        PDF_Options.Version = (PDFOptions::PDFVersion)prefsData->PDF_Options.Version;
1545 cbradney 213
        PDF_Options.Resolution = prefsData->PDF_Options.Resolution;
214
        PDF_Options.Binding = prefsData->PDF_Options.Binding;
215
        PDF_Options.EmbedList = prefsData->PDF_Options.EmbedList;
216
        PDF_Options.SubsetList = prefsData->PDF_Options.SubsetList;
217
        PDF_Options.MirrorH = prefsData->PDF_Options.MirrorH;
218
        PDF_Options.MirrorV = prefsData->PDF_Options.MirrorV;
219
        PDF_Options.RotateDeg = prefsData->PDF_Options.RotateDeg;
220
        PDF_Options.PresentMode = prefsData->PDF_Options.PresentMode;
221
        PDF_Options.Datei = prefsData->PDF_Options.Datei;
222
        PDF_Options.PresentVals = prefsData->PDF_Options.PresentVals;
223
        PDF_Options.isGrayscale = prefsData->PDF_Options.isGrayscale;
224
        PDF_Options.UseRGB = prefsData->PDF_Options.UseRGB;
225
        PDF_Options.UseProfiles = prefsData->PDF_Options.UseProfiles;
226
        PDF_Options.UseProfiles2 = prefsData->PDF_Options.UseProfiles2;
227
        PDF_Options.SolidProf = prefsData->PDF_Options.SolidProf;
228
        PDF_Options.SComp = prefsData->PDF_Options.SComp;
229
        PDF_Options.ImageProf = prefsData->PDF_Options.ImageProf;
230
        PDF_Options.PrintProf = prefsData->PDF_Options.PrintProf;
231
        PDF_Options.Info = prefsData->PDF_Options.Info;
232
        PDF_Options.Intent = prefsData->PDF_Options.Intent;
233
        PDF_Options.Intent2 = prefsData->PDF_Options.Intent2;
234
        PDF_Options.BleedTop = prefsData->PDF_Options.BleedTop;
235
        PDF_Options.BleedLeft = prefsData->PDF_Options.BleedLeft;
236
        PDF_Options.BleedRight = prefsData->PDF_Options.BleedRight;
237
        PDF_Options.BleedBottom = prefsData->PDF_Options.BleedBottom;
238
        PDF_Options.EmbeddedI = prefsData->PDF_Options.EmbeddedI;
239
        PDF_Options.Encrypt = prefsData->PDF_Options.Encrypt;
240
        PDF_Options.PassOwner = prefsData->PDF_Options.PassOwner;
241
        PDF_Options.PassUser = prefsData->PDF_Options.PassUser;
242
        PDF_Options.Permissions = prefsData->PDF_Options.Permissions;
243
        PDF_Options.UseLPI = prefsData->PDF_Options.UseLPI;
244
        PDF_Options.LPISettings = prefsData->PDF_Options.LPISettings;
1738 fschmid 245
        PDF_Options.useLayers = prefsData->PDF_Options.useLayers;
1641 cbradney 246
 
247
        docItemAttributes = prefsData->defaultItemAttributes;
1701 cbradney 248
        docToCSetups = prefsData->defaultToCSetups;
1641 cbradney 249
 
3 paul 250
        RePos = false;
251
        BookMarks.clear();
252
        OldBM = false;
253
        hasName = false;
63 Franz 254
        DoDrawing = true;
3 paul 255
        RotMode = 0;
123 Franz 256
        SubMode = -1;
3 paul 257
        ASaveTimer = new QTimer(this);
27 Franz 258
        MLineStyles.clear();
456 fschmid 259
        Pages.clear();
260
        MasterPages.clear();
261
        DocPages.clear();
262
        Items.clear();
263
        MasterItems.clear();
264
        DocItems.clear();
823 fschmid 265
        ScratchLeft = prefsData->ScratchLeft;
266
        ScratchRight = prefsData->ScratchRight;
267
        ScratchTop = prefsData->ScratchTop;
268
        ScratchBottom = prefsData->ScratchBottom;
269
        arrowStyles = prefsData->arrowStyles;
1179 tsoots 270
        undoManager = UndoManager::instance();
1235 fschmid 271
        docItemErrors.clear();
272
        masterItemErrors.clear();
3 paul 273
}
274
 
275
ScribusDoc::~ScribusDoc()
276
{
456 fschmid 277
        MasterItems.setAutoDelete(true);
278
        DocItems.setAutoDelete(true);
279
        MasterItems.clear();
280
        DocItems.clear();
281
        MasterPages.setAutoDelete(true);
282
        DocPages.setAutoDelete(true);
283
        MasterPages.clear();
284
        DocPages.clear();
494 fschmid 285
        QMap<QString,QFont>::Iterator it3;
286
        for (it3 = UsedFonts.begin(); it3 != UsedFonts.end(); ++it3)
287
        {
288
                if ((*AllFonts)[it3.key()]->PrivateFont != "")
289
                        (*AllFonts).removeFont(it3.key());
290
        }
3 paul 291
        FT_Done_FreeType( library );
292
}
293
 
1330 fschmid 294
void ScribusDoc::CloseCMSProfiles()
295
{
296
#ifdef HAVE_CMS
297
        cmsCloseProfile(DocInputProf);
298
        cmsCloseProfile(DocOutputProf);
299
        cmsCloseProfile(DocPrinterProf);
300
        cmsDeleteTransform(stdTrans);
301
        cmsDeleteTransform(stdProof);
302
        cmsDeleteTransform(stdTransImg);
303
        cmsDeleteTransform(stdProofImg);
1488 fschmid 304
        cmsDeleteTransform(stdTransCMYK);
305
        cmsDeleteTransform(stdProofCMYK);
306
        cmsDeleteTransform(stdTransRGB);
1330 fschmid 307
#endif
308
}
309
 
310
void ScribusDoc::OpenCMSProfiles(ProfilesL InPo, ProfilesL MoPo, ProfilesL PrPo)
311
{
312
#ifdef HAVE_CMS
313
        DocInputProf = cmsOpenProfileFromFile(InPo[CMSSettings.DefaultInputProfile2], "r");
314
        DocOutputProf = cmsOpenProfileFromFile(MoPo[CMSSettings.DefaultMonitorProfile], "r");
315
        DocPrinterProf = cmsOpenProfileFromFile(PrPo[CMSSettings.DefaultPrinterProfile], "r");
316
        if ((DocInputProf == NULL) || (DocOutputProf == NULL) || (DocPrinterProf == NULL))
317
        {
318
                CMSSettings.CMSinUse = false;
319
                return;
320
        }
321
        int dcmsFlags = 0;
322
        int dcmsFlags2 = cmsFLAGS_NOTPRECALC;
1488 fschmid 323
        if (CMSSettings.GamutCheck)
1330 fschmid 324
                dcmsFlags |= cmsFLAGS_GAMUTCHECK;
1488 fschmid 325
        if (CMSSettings.SoftProofOn)
1330 fschmid 326
                dcmsFlags |= cmsFLAGS_SOFTPROOFING;
327
#ifdef cmsFLAGS_BLACKPOINTCOMPENSATION
328
        if (CMSSettings.BlackPoint)
329
        {
330
                dcmsFlags2 |= cmsFLAGS_BLACKPOINTCOMPENSATION;
331
                dcmsFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
332
        }
333
#endif
1525 cbradney 334
        // set Gamut alarm color to #00ff00
1488 fschmid 335
        cmsSetAlarmCodes(0, 255, 0);
1330 fschmid 336
        stdProof = cmsCreateProofingTransform(DocInputProf, TYPE_RGB_16,
337
                                              DocOutputProf, TYPE_RGB_16,
338
                                              DocPrinterProf,
339
                                              IntentPrinter,
340
                                              IntentMonitor, dcmsFlags);
341
        stdTrans = cmsCreateTransform(DocInputProf, TYPE_RGB_16,
342
                                      DocOutputProf, TYPE_RGB_16,
343
                                      IntentMonitor,
344
                                      dcmsFlags2);
345
        stdProofImg = cmsCreateProofingTransform(DocInputProf, TYPE_RGBA_8,
346
                      DocOutputProf, TYPE_RGBA_8,
347
                      DocPrinterProf,
348
                      IntentPrinter,
349
                      IntentMonitor, dcmsFlags);
350
        stdTransImg = cmsCreateTransform(DocInputProf, TYPE_RGBA_8,
351
                                        DocOutputProf, TYPE_RGBA_8,
352
                                         IntentMonitor,
353
                                         dcmsFlags2);
1491 fschmid 354
        if (static_cast<int>(cmsGetColorSpace(DocPrinterProf)) == icSigCmykData)
355
        {
356
                stdProofCMYK = cmsCreateProofingTransform(DocPrinterProf, TYPE_CMYK_16,
357
                                                        DocOutputProf, TYPE_RGB_16,
358
                                                        DocPrinterProf,
359
                                                        IntentPrinter,
360
                                                        IntentMonitor, dcmsFlags);
361
                stdTransCMYK = cmsCreateTransform(DocInputProf, TYPE_RGB_16,
362
                                                DocPrinterProf, TYPE_CMYK_16,
363
                                                IntentPrinter,
364
                                                dcmsFlags2);
365
                stdTransRGB = cmsCreateTransform(DocPrinterProf, TYPE_CMYK_16,
366
                                                DocInputProf, TYPE_RGB_16,
367
                                                IntentMonitor,
368
                                                dcmsFlags2);
369
        }
370
        else
371
        {
372
                stdProofCMYK = cmsCreateProofingTransform(DocPrinterProf, TYPE_RGB_16,
373
                                                        DocOutputProf, TYPE_RGB_16,
374
                                                        DocPrinterProf,
375
                                                        IntentPrinter,
376
                                                        IntentMonitor, dcmsFlags);
377
                stdTransCMYK = cmsCreateTransform(DocInputProf, TYPE_RGB_16,
378
                                                DocPrinterProf, TYPE_RGB_16,
379
                                                IntentPrinter,
380
                                                dcmsFlags2);
381
                stdTransRGB = cmsCreateTransform(DocPrinterProf, TYPE_RGB_16,
382
                                                DocInputProf, TYPE_RGB_16,
383
                                                IntentMonitor,
384
                                                dcmsFlags2);
385
        }
1330 fschmid 386
#endif
387
}
388
 
456 fschmid 389
/*
390
 * Split out from loadStyles in editFormats.cpp so it's callable from anywhere,
391
 * including plugins.
392
 * - 2004-09-14 Craig Ringer
393
 */
1065 cbradney 394
void ScribusDoc::loadStylesFromFile(QString fileName, QValueList<ParagraphStyle> *tempStyles)
456 fschmid 395
{
1065 cbradney 396
        // This won't create the QValueList<ParagraphStyle> will it?
397
        QValueList<ParagraphStyle> *wrkStyles = NULL;
456 fschmid 398
        /*
399
         * Use the working styles struct if passed, or work directly
400
         * on the document styles otherwise. Note that tempStyles,
401
         * if passed, MUST have the first five styles initialised already
402
         * or this function will segfault.
403
         */
404
        if (tempStyles != NULL)
405
                wrkStyles = tempStyles;
406
         else
1065 cbradney 407
                wrkStyles = &docParagraphStyles;
456 fschmid 408
        if (!fileName.isEmpty())
409
        {
410
                ScriXmlDoc *ss = new ScriXmlDoc();
1065 cbradney 411
                ss->docParagraphStyles.clear();
456 fschmid 412
                for (uint x = 5; x < wrkStyles->count(); ++x)
1065 cbradney 413
                        ss->docParagraphStyles.append((*wrkStyles)[x]);
456 fschmid 414
                uint old = wrkStyles->count()-5;
823 fschmid 415
                if (ss->ReadStyles(fileName, this, prefsValues))
456 fschmid 416
                {
1065 cbradney 417
                        if (ss->docParagraphStyles.count() > old)
456 fschmid 418
                        {
1065 cbradney 419
                                for (uint xx=old; xx<ss->docParagraphStyles.count(); ++xx)
456 fschmid 420
                                {
1065 cbradney 421
                                        struct ParagraphStyle sty;
422
                                        sty.Vname = ss->docParagraphStyles[xx].Vname;
423
                                        sty.LineSpa = ss->docParagraphStyles[xx].LineSpa;
424
                                        sty.textAlignment = ss->docParagraphStyles[xx].textAlignment;
425
                                        sty.Indent = ss->docParagraphStyles[xx].Indent;
426
                                        sty.First = ss->docParagraphStyles[xx].First;
427
                                        sty.gapBefore = ss->docParagraphStyles[xx].gapBefore;
428
                                        sty.gapAfter = ss->docParagraphStyles[xx].gapAfter;
429
                                        sty.Font = ss->docParagraphStyles[xx].Font;
430
                                        sty.FontSize = ss->docParagraphStyles[xx].FontSize;
431
                                        sty.TabValues = ss->docParagraphStyles[xx].TabValues;
432
                                        sty.Drop = ss->docParagraphStyles[xx].Drop;
433
                                        sty.DropLin = ss->docParagraphStyles[xx].DropLin;
434
                                        sty.FontEffect = ss->docParagraphStyles[xx].FontEffect;
435
                                        sty.FColor = ss->docParagraphStyles[xx].FColor;
436
                                        sty.FShade = ss->docParagraphStyles[xx].FShade;
437
                                        sty.SColor = ss->docParagraphStyles[xx].SColor;
438
                                        sty.SShade = ss->docParagraphStyles[xx].SShade;
439
                                        sty.BaseAdj = ss->docParagraphStyles[xx].BaseAdj;
2273 fschmid 440
                                        sty.txtShadowX = ss->docParagraphStyles[xx].txtShadowX;
441
                                        sty.txtShadowY = ss->docParagraphStyles[xx].txtShadowY;
442
                                        sty.txtOutline = ss->docParagraphStyles[xx].txtOutline;
443
                                        sty.txtUnderPos = ss->docParagraphStyles[xx].txtUnderPos;
444
                                        sty.txtUnderWidth = ss->docParagraphStyles[xx].txtUnderWidth;
445
                                        sty.txtStrikePos = ss->docParagraphStyles[xx].txtStrikePos;
446
                                        sty.txtStrikeWidth = ss->docParagraphStyles[xx].txtStrikeWidth;
456 fschmid 447
                                        wrkStyles->append(sty);
448
                                }
449
                        }
450
                }
451
                delete ss;
452
        }
453
}
454
 
1179 tsoots 455
void ScribusDoc::lockGuides(bool isLocked)
456
{
1180 tsoots 457
        if (GuideLock == isLocked)
458
                return;
1179 tsoots 459
        GuideLock = isLocked;
460
        if (UndoManager::undoEnabled())
461
        {
462
                QString name;
463
                if (isLocked)
1190 tsoots 464
                        name = Um::LockGuides;
1179 tsoots 465
                else
1190 tsoots 466
                        name = Um::UnlockGuides;
467
                SimpleState *ss = new SimpleState(name, "", Um::ILockGuides);
1179 tsoots 468
                ss->set("GUIDE_LOCK", isLocked);
469
                undoManager->action(this, ss);
470
        }
471
}
472
 
473
void ScribusDoc::restore(UndoState* state, bool isUndo)
474
{
475
        SimpleState *ss = dynamic_cast<SimpleState*>(state);
476
        if (ss)
477
        {
478
                if (ss->contains("GUIDE_LOCK"))
479
                {
480
                        if (isUndo)
481
                                GuideLock = !ss->getBool("GUIDE_LOCK");
482
                        else
483
                                GuideLock = ss->getBool("GUIDE_LOCK"); 
484
                }
485
        }
486
}
487
 
488
void ScribusDoc::setName(const QString& name)
489
{
490
        DocName = name;
491
        QString uname = name;
492
        if (name.find("/") > -1)
493
                uname = name.right(name.length() - name.findRev("/") - 1);
1190 tsoots 494
        if (uname.find(".sl") > -1)
495
                uname = uname.left(uname.findRev(".sl"));
1179 tsoots 496
        setUName(uname); // set the name for the undo object
497
}
498
 
3 paul 499
void ScribusDoc::setModified()
500
{
501
        modified = true;
502
}
503
 
504
void ScribusDoc::setUnModified()
505
{
506
        modified = false;
507
}
508
 
509
bool ScribusDoc::isModified() const
510
{
511
  return modified;
512
}
513
/** Setzt die Seitenattribute */
80 Franz 514
void ScribusDoc::setPage(double b, double h, double t, double l, double r, double bo, double sp, double ab, bool atf, bool fp)
3 paul 515
{
2142 cbradney 516
        pageWidth = b;
517
        pageHeight = h;
518
        pageMargins.Top = t;
519
        pageMargins.Left = l;
520
        pageMargins.Right = r;
521
        pageMargins.Bottom = bo;
3 paul 522
        PageSp = sp;
523
        PageSpa = ab;
524
        PageFP = fp;
525
        PageAT = atf;
526
}
527
 
80 Franz 528
void ScribusDoc::resetPage(double t, double l, double r, double bo, bool fp)
3 paul 529
{
2142 cbradney 530
        pageMargins.Top = t;
531
        pageMargins.Left = l;
532
        pageMargins.Right = r;
533
        pageMargins.Bottom = bo;
3 paul 534
        PageFP = fp;
535
}
536
 
220 Franz 537
bool ScribusDoc::AddFont(QString name, QFont fo)
3 paul 538
{
220 Franz 539
        bool ret = false;
540
        bool error;
3 paul 541
        FT_Face      face;
2295 cbradney 542
 
543
        if (UsedFonts.contains(name))
544
                return true;
545
 
546
        error = FT_New_Face( library, (*AllFonts)[name]->Datei, (*AllFonts)[name]->faceIndex, &face );
220 Franz 547
        if (error)
548
                return ret;
2295 cbradney 549
 
220 Franz 550
        if ((*AllFonts)[name]->ReadMetrics())
167 Franz 551
        {
220 Franz 552
                (*AllFonts)[name]->CharWidth[13] = 0;
249 Franz 553
                (*AllFonts)[name]->CharWidth[28] = 0;
220 Franz 554
                (*AllFonts)[name]->CharWidth[9] = 1;
555
                QString afnm = (*AllFonts)[name]->Datei.left((*AllFonts)[name]->Datei.length()-3);
556
                QFile afm(afnm+"afm");
3 paul 557
                if(!(afm.exists()))
220 Franz 558
                {
559
                        afm.setName(afnm+"Afm");
560
                        if(!(afm.exists()))
561
                                afm.setName(afnm+"AFM");
562
                }
563
                if (afm.exists())
564
                        FT_Attach_File(face, afm.name());
565
                FFonts[name] = face;
566
                UsedFonts[name] = fo;
567
                ret = true;
167 Franz 568
        }
220 Franz 569
        else
570
                FT_Done_Face( face );
571
        return ret;
3 paul 572
}
1694 cbradney 573
 
574
QStringList ScribusDoc::getItemAttributeNames()
575
{
576
        QStringList nameList;
577
 
578
        for(ObjAttrVector::Iterator it = docItemAttributes.begin(); it!= docItemAttributes.end(); ++it)
579
                nameList.append((*it).name);
580
        return nameList;
1749 craig 581
}
582