Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
1525 cbradney 7
#include <qdom.h>
506 fschmid 8
#include <qfile.h>
9
#include <qfileinfo.h>
517 fschmid 10
#include <qtl.h>
11
#include <qcursor.h>
12
#include <qregexp.h>
13
#include <qdir.h>
14
#include <qtextcodec.h>
1525 cbradney 15
#include <qcheckbox.h>
3650 cbradney 16
#include <qmessagebox.h>
17
#include <qprogressbar.h>
517 fschmid 18
#include <cstdlib>
19
#include <cmath>
20
#include <qtextstream.h>
3650 cbradney 21
 
22
#include "commonstrings.h"
838 cbradney 23
#include "fileloader.h"
3827 cbradney 24
#include "fileloader.moc"
3650 cbradney 25
#include "fontreplacedialog.h"
6838 cbradney 26
#include "hyphenator.h"
517 fschmid 27
#include "missing.h"
3670 cbradney 28
#include "page.h"
1549 subik 29
#include "pluginmanager.h"
2445 cbradney 30
#include "pagestructs.h"
2688 craig 31
#include "scconfig.h"
3650 cbradney 32
#include "scribus.h"
33
#include "scribusXml.h"
34
#include "units.h"
3696 craig 35
#include "loadsaveplugin.h"
3650 cbradney 36
 
4024 craig 37
// We need to include the headers for the plugins we support until we start
38
// using LoadSavePlugin to pick them for us. We only use these headers to
39
// get the format IDs, NOTHING ELSE.
40
#include "plugins/svgimplugin/svgplugin.h"
41
#include "plugins/psimport/importpsplugin.h"
42
#include "plugins/fileloader/oodraw/oodrawimp.h"
43
 
506 fschmid 44
#ifdef HAVE_LIBZ
45
        #include <zlib.h>
46
#endif
2531 craig 47
#include "util.h"
2834 cbradney 48
#include "prefsmanager.h"
506 fschmid 49
 
50
/*!
51
 \author Franz Schmid
52
 \date
53
 \brief Constructor, sets the variable "FileName" to the input parameter fileName
4645 subik 54
 \param fileName filename to load
506 fschmid 55
 \retval None
56
 */
3644 craig 57
FileLoader::FileLoader(const QString & fileName) :
4024 craig 58
        QObject(0, "FileLoader"),
59
        FileName(fileName),
60
        FileType(-1),
61
        formatPS(LoadSavePlugin::getFormatById(FORMATID_PSIMPORT)),
62
        formatSVG(LoadSavePlugin::getFormatById(FORMATID_SVGIMPORT)),
63
        formatSXD(LoadSavePlugin::getFormatById(FORMATID_SXDIMPORT)),
64
        formatODG(LoadSavePlugin::getFormatById(FORMATID_ODGIMPORT)),
65
        prefsManager(PrefsManager::instance())
506 fschmid 66
{
5445 cbradney 67
        dummyFois.setAutoDelete(true);
506 fschmid 68
}
69
 
3644 craig 70
// FIXME: This static method is here as a temporary transitional
71
// measure during the process of converting to file loader plugins.
72
const QString FileLoader::getLoadFilterString()
73
{
3696 craig 74
        /*
3644 craig 75
        PluginManager& pluginManager(PluginManager::instance());
76
        QString formats;
77
#ifdef HAVE_LIBZ
78
        formats += tr("Documents (*.sla *.sla.gz *.scd *.scd.gz);;");
79
#else
80
        formats += tr("Documents (*.sla *.scd);;");
81
#endif
82
        if (pluginManager.DLLexists("importps"))
83
                formats += tr("PostScript Files (*.eps *.EPS *.ps *.PS);;");
84
        if (pluginManager.DLLexists("svgimplugin"))
85
#ifdef HAVE_LIBZ
86
                formats += tr("SVG Images (*.svg *.svgz);;");
87
#else
88
                formats += tr("SVG Images (*.svg);;");
89
#endif
90
        if (pluginManager.DLLexists("oodrawimp"))
91
                formats += tr("OpenOffice.org Draw (*.sxd);;");
92
        formats += tr("All Files (*)");
93
        return formats;
3696 craig 94
        */
95
        return LoadSavePlugin::fileDialogLoadFilter().join(";;");
3644 craig 96
}
97
 
506 fschmid 98
/*!
99
 \fn int FileLoader::TestFile()
100
 \author Franz Schmid
101
 \date
102
 \brief Tests if the file "FileName" exists and determines the type of the file.
103
 \retval int -1 if the file doesn't exist or any other error has occured, 0 for the old Format, 1 for the new Format, 2 for EPS and PS files, 3 for SVG files and 4 for PDF files
104
 */
105
int FileLoader::TestFile()
106
{
107
        QFileInfo fi = QFileInfo(FileName);
108
        int ret = -1;
109
        if (!fi.exists())
110
                ret = -1;
111
        QString ext = fi.extension(true).lower();
550 fschmid 112
        if ((ext.endsWith("sla.gz")) || (ext.endsWith("sla")) || (ext.endsWith("scd.gz")) || (ext.endsWith("scd")))
506 fschmid 113
                ret = CheckScribus();
4024 craig 114
        else if (((ext.endsWith("ps")) || (ext.endsWith("eps"))) && (formatPS))
506 fschmid 115
                ret = 2;
4024 craig 116
        else if (((ext.endsWith("svg")) || (ext.endsWith("svgz"))) && (formatSVG))
506 fschmid 117
                ret = 3;
4024 craig 118
        else if ((ext.endsWith("sxd")) && (formatSXD))
541 fschmid 119
                ret = 5;
4024 craig 120
        else if ((ext.endsWith("odg")) && (formatODG))
121
                ret = 6;
506 fschmid 122
/*      if (ext == "pdf")
123
                ret = 4; */
124
        FileType = ret;
125
        return ret;
126
}
127
 
128
/*!
129
 \fn int FileLoader::CheckScribus()
130
 \author Franz Schmid
131
 \date
132
 \brief Checks which Scribus fileformat the File in FileName has.
133
 \retval 0 for old Scribus files, 1 for Scribus files created by Scribus 1.3 and above
134
 */
135
int FileLoader::CheckScribus()
136
{
137
        int ret = -1;
3646 craig 138
        QString fText(readSLA(FileName));
2877 cbradney 139
        if (fText.isEmpty())
506 fschmid 140
                return ret;
2680 cbradney 141
        if ((fText.startsWith("<SCRIBUSUTF8NEW")) && (fText.contains("<PAGE ", true) != 0))
517 fschmid 142
                return 1;
2680 cbradney 143
        if ((fText.startsWith("<SCRIBUS")) && (fText.contains("<PAGE ", true) != 0))
506 fschmid 144
                return 0;
145
        return ret;
146
}
147
 
148
/*!
149
 \author Franz Schmid
150
 \date
3646 craig 151
 \brief Auxiliary function loads the file "fileName" into a QString, taking care of any encoding issues
4645 subik 152
 \param fileName a filename to load
3646 craig 153
 \retval QString Contents of the file
154
 
155
 Note that this method will use the system text encoding when loading .sla /
156
 .scd files from before the conversion to utf-8 storage. There is presently no
157
 override for the encoding used.
506 fschmid 158
 */
3646 craig 159
QString FileLoader::readSLA(const QString & fileName)
506 fschmid 160
{
3646 craig 161
        QCString docBytes("");
506 fschmid 162
        if(fileName.right(2) == "gz")
163
        {
3646 craig 164
#ifdef HAVE_LIBZ
3968 craig 165
                static const int gzipExpansionFactor=8;
166
                // The file is gzip encoded and we can load gzip files.
3646 craig 167
                /**
168
                  * added to support gz docs
169
                  * 2.7.2002 C.Toepp
170
                  * <c.toepp@gmx.de>
171
                  */
3968 craig 172
                // Set up to read the gzip file
506 fschmid 173
                gzFile gzDoc;
174
                int i;
175
                gzDoc = gzopen(fileName.latin1(),"rb");
176
                if(gzDoc == NULL)
3968 craig 177
                {
178
                        // FIXME: Needs better error return
506 fschmid 179
                        return "";
3968 craig 180
                }
181
                // Allocate a buffer of a multiple of the compressed size of the file
182
                // as a starting point for loading. We'll expand this buffer by powers
183
                // of two if we run out of space.
184
                const QFileInfo fi(fileName);
185
                uint bufSize = fi.size()*gzipExpansionFactor;
186
                docBytes = QCString(bufSize);
187
                char* buf = docBytes.data();
188
                uint bytesRead = 0;
189
                // While there's free space, read into the buffer....
190
                while ((i = gzread(gzDoc,buf,bufSize-bytesRead-1)) > 0)
506 fschmid 191
                {
3968 craig 192
                        // Ensure the string is null-terminated and move the
193
                        // write pointer to the current position.
194
                        buf[i]=0;
195
                        buf+=i;
196
                        bytesRead += i;
197
                        // And check that there's free space to work with, expanding the
198
                        // buffer if there's not.
199
                        if (bufSize - bytesRead < 4096)
200
                        {
201
                                bufSize *= 2;
202
                                docBytes.resize(bufSize);
203
                                buf = docBytes.data() + bytesRead;
204
                        }
506 fschmid 205
                }
206
                gzclose(gzDoc);
3646 craig 207
#else
208
                // The file is gzip encoded but we can't load gzip files.
209
                // Leave `f' empty, since we have no way to
210
                // report a failure condition from here.
211
#endif
506 fschmid 212
        }
213
        else
3968 craig 214
        {
3646 craig 215
                // Not gzip encoded, just load it
216
                loadRawText(fileName, docBytes);
3968 craig 217
        }
3646 craig 218
        QString docText("");
219
        if (docBytes.left(12) == "<SCRIBUSUTF8")
220
                docText = QString::fromUtf8(docBytes);
221
        else if (docBytes.left(8) == "<SCRIBUS")
222
                docText = QString::fromLocal8Bit(docBytes);
223
        if (docText.endsWith(QChar(10)) || docText.endsWith(QChar(13)))
224
                docText.truncate(docText.length()-1);
225
        return docText;
506 fschmid 226
}
227
 
4678 cbradney 228
bool FileLoader::LoadPage(int PageToLoad, bool Mpage, QString renamedPageName)
3197 fschmid 229
{
7708 avox 230
        itemRemap.clear();
231
        itemNext.clear();
232
        itemCount = 0;
233
 
3197 fschmid 234
        bool ret = false;
235
        newReplacement = false;
236
        ReplacedFonts.clear();
237
        dummyFois.clear();
238
        dummyFois.setAutoDelete(true);
239
        switch (FileType)
240
        {
241
                case 0:
242
                        {
4209 craig 243
                                ScriXmlDoc ss;
244
                                ss.ReplacedFonts.clear();
245
                                ss.newReplacement = false;
246
                                ss.dummyFois.clear();
247
                                ret = ss.ReadPage(FileName, prefsManager->appPrefs.AvailFonts, ScMW->doc, ScMW->view, PageToLoad, Mpage);
248
                                ReplacedFonts = ss.ReplacedFonts;
249
                                newReplacement = ss.newReplacement;
250
                                dummyFois = ss.dummyFois;
5445 cbradney 251
                                ss.dummyFois.setAutoDelete(false);
3197 fschmid 252
                        }
253
                        break;
254
                case 1:
4678 cbradney 255
                        ret = ReadPage(FileName, prefsManager->appPrefs.AvailFonts, ScMW->doc, PageToLoad, Mpage, renamedPageName);
3197 fschmid 256
                        break;
257
                default:
258
                        ret = false;
259
                        break;
260
        }
261
        if (ReplacedFonts.count() != 0)
262
        {
263
                if ((prefsManager->appPrefs.askBeforeSubstituite) || (newReplacement))
264
                {
265
                        qApp->setOverrideCursor(QCursor(Qt::arrowCursor), true);
4209 craig 266
                        FontReplaceDialog dia(0, &ReplacedFonts);
267
                        if (dia.exec())
3197 fschmid 268
                        {
269
                                QMap<QString,QString>::Iterator itfsu;
270
                                for (itfsu = ReplacedFonts.begin(); itfsu != ReplacedFonts.end(); ++itfsu)
271
                                {
4209 craig 272
                                        if (dia.stickyReplacements->isChecked())
3197 fschmid 273
                                                prefsManager->appPrefs.GFontSub[itfsu.key()] = itfsu.data();
274
                                }
275
                        }
276
                        else
277
                        {
278
                                return false;
279
                        }
280
                }
4026 craig 281
                for (uint d = 0; d < ScMW->doc->MasterItems.count(); ++d)
3197 fschmid 282
                {
4026 craig 283
                        PageItem *it = ScMW->doc->MasterItems.at(d);
6803 cbradney 284
                        if (!ScMW->doc->UsedFonts.contains(it->font()))
4073 cbradney 285
                                it->setFont(ReplacedFonts[it->font()]);
3625 avox 286
                        if ((it->asTextFrame()) || (it->asPathText()))
3197 fschmid 287
                        {
288
                                for (uint e = 0; e < it->itemText.count(); ++e)
289
                                {
4026 craig 290
                                if (!ScMW->doc->UsedFonts.contains(it->itemText.at(e)->cfont->scName()))
291
                                        it->itemText.at(e)->cfont = (*ScMW->doc->AllFonts)[ReplacedFonts[it->itemText.at(e)->cfont->scName()]];
3197 fschmid 292
                                }
293
                        }
294
                }
4026 craig 295
                for (uint d = 0; d < ScMW->doc->DocItems.count(); ++d)
3197 fschmid 296
                {
4026 craig 297
                        PageItem *it = ScMW->doc->DocItems.at(d);
6803 cbradney 298
                        if (!ScMW->doc->UsedFonts.contains(it->font()))
4073 cbradney 299
                                it->setFont(ReplacedFonts[it->font()]);
3625 avox 300
                        if ((it->asTextFrame()) || (it->asPathText()))
3197 fschmid 301
                        {
302
                                for (uint e = 0; e < it->itemText.count(); ++e)
303
                                {
4026 craig 304
                                if (!ScMW->doc->UsedFonts.contains(it->itemText.at(e)->cfont->scName()))
305
                                        it->itemText.at(e)->cfont = (*ScMW->doc->AllFonts)[ReplacedFonts[it->itemText.at(e)->cfont->scName()]];
3197 fschmid 306
                                }
307
                        }
308
                }
4026 craig 309
                for (uint d = 0; d < ScMW->doc->FrameItems.count(); ++d)
3197 fschmid 310
                {
4026 craig 311
                        PageItem *it = ScMW->doc->FrameItems.at(d);
6803 cbradney 312
                        if (!ScMW->doc->UsedFonts.contains(it->font()))
4073 cbradney 313
                                it->setFont(ReplacedFonts[it->font()]);
3625 avox 314
                        if ((it->asTextFrame()) || (it->asPathText()))
3197 fschmid 315
                        {
316
                                for (uint e = 0; e < it->itemText.count(); ++e)
317
                                {
4026 craig 318
                                if (!ScMW->doc->UsedFonts.contains(it->itemText.at(e)->cfont->scName()))
319
                                        it->itemText.at(e)->cfont = (*ScMW->doc->AllFonts)[ReplacedFonts[it->itemText.at(e)->cfont->scName()]];
3197 fschmid 320
                                }
321
                        }
322
                }
4026 craig 323
                for (uint a = 0; a < ScMW->doc->docParagraphStyles.count(); ++a)
3197 fschmid 324
                {
4026 craig 325
                        if ((!ScMW->doc->UsedFonts.contains(ScMW->doc->docParagraphStyles[a].Font)) && (!ScMW->doc->docParagraphStyles[a].Font.isEmpty()))
326
                                ScMW->doc->docParagraphStyles[a].Font = ReplacedFonts[ScMW->doc->docParagraphStyles[a].Font];
3197 fschmid 327
                }
328
                QMap<QString,QString>::Iterator itfsu;
329
                for (itfsu = ReplacedFonts.begin(); itfsu != ReplacedFonts.end(); ++itfsu)
330
                {
4026 craig 331
                        if (!ScMW->doc->UsedFonts.contains(itfsu.data()))
3197 fschmid 332
                        {
3544 avox 333
//                              QFont fo = prefsManager->appPrefs.AvailFonts[itfsu.data()]->Font;
4026 craig 334
//                              fo.setPointSize(qRound(ScMW->doc->toolSettings.defSize / 10.0));
335
                                ScMW->doc->AddFont(itfsu.data(), qRound(ScMW->doc->toolSettings.defSize / 10.0));
3197 fschmid 336
                        }
337
                }
338
                if (prefsManager->appPrefs.askBeforeSubstituite)
339
                        ReplacedFonts.clear();
340
                dummyFois.clear();
341
        }
342
        return ret;
343
}
344
 
506 fschmid 345
/*!
3644 craig 346
 \fn bool FileLoader::LoadFile()
506 fschmid 347
 \author Franz Schmid
348
 \date
349
 \brief Loads the file "FileName" as a Scribus document
350
 \retval bool true when loading is succsessful, false otherwise
351
 */
3644 craig 352
bool FileLoader::LoadFile()
506 fschmid 353
{
354
        bool ret = false;
1468 fschmid 355
        newReplacement = false;
4026 craig 356
        ScMW->doc->guidesSettings.marginsShown = prefsManager->appPrefs.guidesSettings.marginsShown;
357
        ScMW->doc->guidesSettings.framesShown = prefsManager->appPrefs.guidesSettings.framesShown;
358
        ScMW->doc->guidesSettings.gridShown = prefsManager->appPrefs.guidesSettings.gridShown;
359
        ScMW->doc->guidesSettings.guidesShown = prefsManager->appPrefs.guidesSettings.guidesShown;
5560 cbradney 360
        ScMW->doc->guidesSettings.colBordersShown = prefsManager->appPrefs.guidesSettings.colBordersShown;
4026 craig 361
        ScMW->doc->guidesSettings.baseShown = prefsManager->appPrefs.guidesSettings.baseShown;
362
        ScMW->doc->guidesSettings.linkShown = prefsManager->appPrefs.guidesSettings.linkShown;
363
        ScMW->doc->toolSettings.polyC = prefsManager->appPrefs.toolSettings.polyC;
364
        ScMW->doc->toolSettings.polyF = prefsManager->appPrefs.toolSettings.polyF;
365
        ScMW->doc->toolSettings.polyR = prefsManager->appPrefs.toolSettings.polyR;
366
        ScMW->doc->toolSettings.polyFd = prefsManager->appPrefs.toolSettings.polyFd;
367
        ScMW->doc->toolSettings.polyS = prefsManager->appPrefs.toolSettings.polyS;
368
        ScMW->doc->AutoSave = prefsManager->appPrefs.AutoSave;
369
        ScMW->doc->AutoSaveTime = prefsManager->appPrefs.AutoSaveTime;
1428 fschmid 370
        ReplacedFonts.clear();
1789 fschmid 371
        dummyFois.clear();
372
        dummyFois.setAutoDelete(true);
506 fschmid 373
        switch (FileType)
374
        {
375
                case 0:
376
                        {
4209 craig 377
                                ScriXmlDoc ss;
3648 cbradney 378
                                //CB: WTF? We use a slot to make the new pages? hello!
4026 craig 379
                                //QObject::connect(ss, SIGNAL(NewPage(int)), ScMW, SLOT(slotNewPage(int)));
4209 craig 380
                                ss.ReplacedFonts.clear();
381
                                ss.newReplacement = false;
382
                                ss.dummyFois.clear();
383
                                ret = ss.ReadDoc(FileName, prefsManager->appPrefs.AvailFonts, ScMW->doc, ScMW->view, ScMW->mainWindowProgressBar);
4026 craig 384
                                //QObject::disconnect(ss, SIGNAL(NewPage(int)), ScMW, SLOT(slotNewPage(int)));
4209 craig 385
                                ReplacedFonts = ss.ReplacedFonts;
386
                                newReplacement = ss.newReplacement;
387
                                dummyFois = ss.dummyFois;
5445 cbradney 388
                                ss.dummyFois.setAutoDelete(false);
506 fschmid 389
                        }
390
                        break;
517 fschmid 391
                case 1:
4026 craig 392
                        ret = ReadDoc(FileName, prefsManager->appPrefs.AvailFonts, ScMW->doc, ScMW->mainWindowProgressBar);
517 fschmid 393
                        break;
506 fschmid 394
                case 2:
5535 mrdocs 395
                        ret = formatPS->loadFile(FileName, LoadSavePlugin::lfCreateDoc);
506 fschmid 396
                        break;
397
                case 3:
5535 mrdocs 398
                        ret = formatSVG->loadFile(FileName, LoadSavePlugin::lfCreateDoc);
506 fschmid 399
                        break;
541 fschmid 400
                case 5:
5535 mrdocs 401
                        ret = formatSXD->loadFile(FileName, LoadSavePlugin::lfCreateDoc);
541 fschmid 402
                        break;
4024 craig 403
                case 6:
5535 mrdocs 404
                        ret = formatODG->loadFile(FileName, LoadSavePlugin::lfCreateDoc);
4024 craig 405
                        break;
506 fschmid 406
                default:
407
                        ret = false;
408
                        break;
409
        }
410
        return ret;
411
}
517 fschmid 412
 
4678 cbradney 413
bool FileLoader::ReadPage(const QString & fileName, SCFonts &avail, ScribusDoc *doc, int PageToLoad, bool Mpage, QString renamedPageName)
3197 fschmid 414
{
415
        struct ParagraphStyle vg;
416
        struct Layer la;
417
        struct ScribusDoc::BookMa bok;
418
        PageItem *Neu;
419
        Page* Apage;
7708 avox 420
        itemRemap.clear();
421
        itemNext.clear();
3646 craig 422
        QString tmV, tmp, tmpf, tmp2, tmp3, tmp4, PgNam, Defont, tmf;
3197 fschmid 423
        QFont fo;
424
        QMap<int,int> TableID;
425
        QPtrList<PageItem> TableItems;
426
        int a, counter, baseobj;
427
        double xf, pageX, pageY;
428
        bool newVersion = false;
429
        bool VorLFound = false;
430
        QMap<int,int> layerTrans;
431
        int maxLayer = 0;
432
        int maxLevel = 0;
433
        layerTrans.clear();
434
        uint layerCount=doc->layerCount();
435
        for (uint la2 = 0; la2 < layerCount; ++la2)
436
        {
437
                maxLayer = QMAX(doc->Layers[la2].LNr, maxLayer);
438
                maxLevel = QMAX(doc->Layers[la2].Level, maxLevel);
439
        }
440
        DoVorl.clear();
441
        DoVorl[0] = "0";
442
        DoVorl[1] = "1";
443
        DoVorl[2] = "2";
444
        DoVorl[3] = "3";
445
        DoVorl[4] = "4";
446
        VorlC = 5;
447
        QDomDocument docu("scridoc");
3646 craig 448
        QString f(readSLA(fileName));
3197 fschmid 449
        if (f.isEmpty())
450
                return false;
451
        if(!docu.setContent(f))
452
                return false;
453
        ScColor lf = ScColor();
454
        QDomElement elem=docu.documentElement();
455
        if (elem.tagName() != "SCRIBUSUTF8NEW")
456
                return false;
457
        if (elem.hasAttribute("Version"))
458
                newVersion = true;
459
        QDomNode DOC=elem.firstChild();
3727 cbradney 460
        counter = doc->Items->count();
3197 fschmid 461
        baseobj = counter;
462
        while(!DOC.isNull())
463
        {
464
                QDomElement dc=DOC.toElement();
465
                QDomNode PAGE=DOC.firstChild();
466
                while(!PAGE.isNull())
467
                {
468
                        QDomElement pg=PAGE.toElement();
4546 subik 469
                        if(pg.tagName()=="COLOR" && pg.attribute("NAME")!=CommonStrings::None)
3197 fschmid 470
                        {
471
                                if (pg.hasAttribute("CMYK"))
472
                                        lf.setNamedColor(pg.attribute("CMYK"));
473
                                else
474
                                        lf.fromQColor(QColor(pg.attribute("RGB")));
475
                                if (pg.hasAttribute("Spot"))
4026 craig 476
                                        lf.setSpotColor(static_cast<bool>(pg.attribute("Spot").toInt()));
3197 fschmid 477
                                else
478
                                        lf.setSpotColor(false);
479
                                if (pg.hasAttribute("Register"))
4026 craig 480
                                        lf.setRegistrationColor(static_cast<bool>(pg.attribute("Register").toInt()));
3197 fschmid 481
                                else
482
                                        lf.setRegistrationColor(false);
483
                          doc->PageColors[pg.attribute("NAME")] = lf;
484
                        }
485
                        if(pg.tagName()=="STYLE")
486
                        {
487
                                GetStyle(&pg, &vg, doc->docParagraphStyles, doc, true);
488
                                VorLFound = true;
489
                        }
490
                        if(pg.tagName()=="JAVA")
491
                                doc->JavaScripts[pg.attribute("NAME")] = pg.attribute("SCRIPT");
492
                        if(pg.tagName()=="LAYERS")
493
                        {
4026 craig 494
                                la.LNr = pg.attribute("NUMMER").toInt();
495
                                la.Level = pg.attribute("LEVEL").toInt();
3197 fschmid 496
                                la.Name = pg.attribute("NAME");
4026 craig 497
                                la.isViewable = pg.attribute("SICHTBAR").toInt();
498
                                la.isPrintable = pg.attribute("DRUCKEN").toInt();
4832 fschmid 499
                                la.isEditable = pg.attribute("EDIT", "1").toInt();
3197 fschmid 500
                                bool laex = false;
501
                                uint layerCount=doc->layerCount();
502
                                for (uint la2 = 0; la2 < layerCount; ++la2)
503
                                {
504
                                        if (doc->Layers[la2].Name == la.Name)
505
                                        {
506
                                                laex = true;
507
                                                layerTrans.insert(la.LNr, doc->Layers[la2].LNr);
508
                                        }
509
                                }
510
                                if (!laex)
511
                                {
512
                                        maxLayer++;
513
                                        maxLevel++;
514
                                        layerTrans.insert(la.LNr, maxLayer);
515
                                        la.LNr = maxLayer;
516
                                        la.Level = maxLevel;
517
                                        doc->Layers.append(la);
518
                                }
519
                        }
520
                        if(pg.tagName()=="MultiLine")
521
                        {
522
                                multiLine ml;
523
                                QDomNode MuLn = PAGE.firstChild();
524
                                while(!MuLn.isNull())
525
                                {
526
                                        QDomElement MuL = MuLn.toElement();
527
                                        struct SingleLine sl;
528
                                        sl.Color = MuL.attribute("Color");
4026 craig 529
                                        sl.Dash = MuL.attribute("Dash").toInt();
530
                                        sl.LineEnd = MuL.attribute("LineEnd").toInt();
531
                                        sl.LineJoin = MuL.attribute("LineJoin").toInt();
532
                                        sl.Shade = MuL.attribute("Shade").toInt();
533
                                        sl.Width = MuL.attribute("Width").toDouble();
3197 fschmid 534
                                        ml.push_back(sl);
535
                                        MuLn = MuLn.nextSibling();
536
                                }
537
                                QString Nam = pg.attribute("Name");
538
                                QString Nam2 = Nam;
539
                                int copyC = 1;
540
                                while (doc->MLineStyles.contains(Nam2))
541
                                {
542
                                        Nam2 = QObject::tr("Copy #%1 of ").arg(copyC)+Nam;
543
                                        copyC++;
544
                                }
545
                                doc->MLineStyles.insert(Nam2, ml);
546
                        }
547
                        if(pg.tagName()=="Arrows")
548
                        {
549
                                struct ArrowDesc arrow;
550
                                arrow.name = pg.attribute("Name");
551
                                arrow.userArrow = true;
552
                                double xa, ya;
553
                                QString tmp = pg.attribute("Points");
554
                                QTextStream fp(&tmp, IO_ReadOnly);
555
                                for (uint cx = 0; cx < pg.attribute("NumPoints").toUInt(); ++cx)
556
                                {
557
                                        fp >> xa;
558
                                        fp >> ya;
559
                                        arrow.points.addPoint(xa, ya);
560
                                }
561
                                doc->arrowStyles.append(arrow);
562
                        }
4026 craig 563
                        if (((pg.tagName()=="PAGE") || (pg.tagName()=="MASTERPAGE")) && (pg.attribute("NUM").toInt() == PageToLoad))
3197 fschmid 564
                        {
3200 cbradney 565
                                a = doc->currentPage->pageNr();
3724 cbradney 566
                                Apage = doc->Pages->at(a);
3197 fschmid 567
                                if ((pg.tagName()!="MASTERPAGE") && (Mpage))
568
                                {
569
                                        PAGE=PAGE.nextSibling();
570
                                        continue;
571
                                }
572
                                if (Mpage)
573
                                {
4026 craig 574
                                        Apage->LeftPg=pg.attribute("LEFT", "0").toInt();
4678 cbradney 575
 
576
                                        if (!renamedPageName.isEmpty())
577
                                                Apage->setPageName(renamedPageName);
578
                                        else
579
                                                Apage->setPageName(pg.attribute("NAM",""));
3197 fschmid 580
                                }
581
                                if (pg.hasAttribute("Size"))
582
                                        Apage->PageSize = pg.attribute("Size");
583
                                if (pg.hasAttribute("Orientation"))
4026 craig 584
                                        Apage->PageOri = pg.attribute("Orientation").toInt();
3197 fschmid 585
                                if (pg.hasAttribute("PAGEWIDTH"))
4026 craig 586
                                        Apage->setWidth(pg.attribute("PAGEWIDTH").toDouble());
3197 fschmid 587
                                else
4026 craig 588
                                        Apage->setWidth(pg.attribute("PAGEWITH").toDouble());
589
                                Apage->setHeight(pg.attribute("PAGEHEIGHT").toDouble());
3200 cbradney 590
                                Apage->setInitialHeight(Apage->height());
591
                                Apage->setInitialWidth(Apage->width());
4595 fschmid 592
                                Apage->initialMargins.Top = QMAX(0.0, pg.attribute("BORDERTOP").toDouble());
593
                                Apage->initialMargins.Bottom = QMAX(0.0, pg.attribute("BORDERBOTTOM").toDouble());
594
                                Apage->initialMargins.Left = QMAX(0.0, pg.attribute("BORDERLEFT").toDouble());
595
                                Apage->initialMargins.Right = QMAX(0.0, pg.attribute("BORDERRIGHT").toDouble());
3197 fschmid 596
                                Apage->Margins.Top = Apage->initialMargins.Top;
597
                                Apage->Margins.Bottom = Apage->initialMargins.Bottom;
4026 craig 598
                                pageX = pg.attribute("PAGEXPOS").toDouble();
599
                                pageY = pg.attribute("PAGEYPOS").toDouble();
600
                                if ((pg.hasAttribute("NumVGuides")) && (pg.attribute("NumVGuides", "0").toInt() != 0))
3197 fschmid 601
                                {
602
                                        tmp = pg.attribute("VerticalGuides");
603
                                        QTextStream fgv(&tmp, IO_ReadOnly);
604
                                        Apage->YGuides.clear();
4026 craig 605
                                        for (int cxv = 0; cxv < pg.attribute("NumVGuides", "0").toInt(); ++cxv)
3197 fschmid 606
                                        {
607
                                                fgv >> xf;
608
                                                Apage->YGuides.append(xf);
609
                                        }
610
                                        qHeapSort(Apage->YGuides);
611
                                        tmp = "";
612
                                }
4026 craig 613
                                if ((pg.hasAttribute("NumHGuides")) && (pg.attribute("NumHGuides", "0").toInt() != 0))
3197 fschmid 614
                                {
615
                                        tmp = pg.attribute("HorizontalGuides");
616
                                        QTextStream fgh(&tmp, IO_ReadOnly);
617
                                        Apage->XGuides.clear();
4026 craig 618
                                        for (int cxh = 0; cxh < pg.attribute("NumHGuides", "0").toInt(); ++cxh)
3197 fschmid 619
                                        {
620
                                                fgh >> xf;
621
                                                Apage->XGuides.append(xf);
622
                                        }
623
                                        qHeapSort(Apage->XGuides);
624
                                        tmp = "";
625
                                }
626
                        }
627
                        if ((pg.tagName()=="PAGEOBJECT") || (pg.tagName()=="MASTEROBJECT") || (pg.tagName()=="FRAMEOBJECT"))
628
                        {
629
                                if ((pg.tagName()!="MASTEROBJECT") && (Mpage))
630
                                {
631
                                        PAGE=PAGE.nextSibling();
632
                                        continue;
633
                                }
7708 avox 634
                                if (pg.attribute("OwnPage").toInt() != PageToLoad)
635
                                {                      
636
                                        if (pg.tagName()=="PAGEOBJECT")
637
                                                itemRemap[itemCount++] = -1;
638
                                }
639
                                else
3197 fschmid 640
                                {
7708 avox 641
                                        // first of linked chain?
642
                                        if (pg.tagName()=="PAGEOBJECT")
3197 fschmid 643
                                        {
7708 avox 644
                                                itemRemap[itemCount++] = doc->Items->count();
645
                                                if (pg.attribute("NEXTITEM").toInt() != -1)
646
                                                {
647
                                                        itemNext[doc->Items->count()] = pg.attribute("NEXTITEM").toInt();
648
                                                }
3197 fschmid 649
                                        }
650
                                        int docGc = doc->GroupCounter;
651
                                        doc->GroupCounter = 0;
3657 cbradney 652
                                        Neu = PasteItem(&pg, doc);
3934 cbradney 653
                                        Neu->moveBy(-pageX + Apage->xOffset(), - pageY + Apage->yOffset());
3656 cbradney 654
                                        Neu->setRedrawBounding();
4651 cbradney 655
                                        //CB Must run onpage as we cant use pagetoload if the page has been renamed. 
4616 cbradney 656
                                        //CB TODO Make this accept a page to place onto.
4675 cbradney 657
                                        //Neu->OwnPage = doc->OnPage(Neu);
4678 cbradney 658
                                        //Neu->OwnPage = PageToLoad;
659
                                        Neu->OwnPage = doc->currentPageNumber();
3197 fschmid 660
                                        if (pg.tagName()=="PAGEOBJECT")
661
                                                Neu->OnMasterPage = "";
662
                                        doc->GroupCounter = docGc;
663
                                        tmpf = pg.attribute("IFONT", doc->toolSettings.defFont);
664
                                        if ((!avail.find(tmpf)) || (!avail[tmpf]->UseFont))
665
                                        {
3650 cbradney 666
                                                if ((!prefsManager->appPrefs.GFontSub.contains(tmpf)) || (!avail[prefsManager->appPrefs.GFontSub[tmpf]]->UseFont))
3197 fschmid 667
                                                {
668
                                                        newReplacement = true;
3650 cbradney 669
                                                        ReplacedFonts.insert(tmpf, prefsManager->appPrefs.toolSettings.defFont);
3197 fschmid 670
                                                }
671
                                                else
3650 cbradney 672
                                                        ReplacedFonts.insert(tmpf, prefsManager->appPrefs.GFontSub[tmpf]);
3197 fschmid 673
                                        }
674
                                        else
675
                                        {
676
                                                if (!doc->UsedFonts.contains(tmpf))
677
                                                {
3544 avox 678
//                                                      QFont fo = avail[tmpf]->Font;
679
//                                                      fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
680
                                                        doc->AddFont(tmpf, qRound(doc->toolSettings.defSize / 10.0));
3197 fschmid 681
                                                }
682
                                        }
4073 cbradney 683
                                        Neu->setFont(tmpf);
3197 fschmid 684
                                        QDomNode IT=pg.firstChild();
685
                                        while(!IT.isNull())
686
                                        {
687
                                                QDomElement it=IT.toElement();
688
                                                if (it.tagName()=="CSTOP")
689
                                                {
690
                                                        QString name = it.attribute("NAME");
4026 craig 691
                                                        double ramp = it.attribute("RAMP", "0.0").toDouble();
692
                                                        int shade = it.attribute("SHADE", "100").toInt();
693
                                                        double opa = it.attribute("TRANS", "1").toDouble();
3197 fschmid 694
                                                        Neu->fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
695
                                                }
696
                                                if (it.tagName()=="ITEXT")
697
                                                        GetItemText(&it, doc, Neu, true, VorLFound);
698
                                                if(it.tagName()=="PageItemAttributes")
699
                                                {
700
                                                        QDomNode PIA = it.firstChild();
701
                                                        ObjAttrVector pageItemAttributes;
702
                                                        while(!PIA.isNull())
703
                                                        {
704
                                                                QDomElement itemAttr = PIA.toElement();
705
                                                                if(itemAttr.tagName() == "ItemAttribute")
706
                                                                {
707
                                                                        ObjectAttribute objattr;
708
                                                                        objattr.name=itemAttr.attribute("Name");
709
                                                                        objattr.type=itemAttr.attribute("Type");
710
                                                                        objattr.value=itemAttr.attribute("Value");
711
                                                                        objattr.parameter=itemAttr.attribute("Parameter");
712
                                                                        objattr.relationship=itemAttr.attribute("Relationship");
713
                                                                        objattr.relationshipto=itemAttr.attribute("RelationshipTo");
714
                                                                        objattr.autoaddto=itemAttr.attribute("AutoAddTo");
715
                                                                        pageItemAttributes.append(objattr);
716
                                                                }
717
                                                                PIA = PIA.nextSibling();
718
                                                        }
719
                                                        Neu->setObjectAttributes(&pageItemAttributes);
720
                                                }
721
                                                IT=IT.nextSibling();
722
                                        }
723
                                        if (Neu->fill_gradient.Stops() == 0)
724
                                        {
725
                                                Neu->fill_gradient.addStop(doc->PageColors[doc->toolSettings.dBrush].getRGBColor(), 0.0, 0.5, 1.0, doc->toolSettings.dBrush, 100);
726
                                                Neu->fill_gradient.addStop(doc->PageColors[doc->toolSettings.dPen].getRGBColor(), 1.0, 0.5, 1.0, doc->toolSettings.dPen, 100);
727
                                        }
4026 craig 728
//                                      Neu->Language = ScMW->GetLang(pg.attribute("LANGUAGE", doc->Language));
3197 fschmid 729
                                        Neu->Language = doc->Language;
4026 craig 730
                                        Neu->isAutoText = static_cast<bool>(pg.attribute("AUTOTEXT").toInt());
731
                                        Neu->isEmbedded = static_cast<bool>(pg.attribute("isInline", "0").toInt());
732
                                        Neu->gXpos = pg.attribute("gXpos", "0.0").toDouble();
733
                                        Neu->gYpos = pg.attribute("gYpos", "0.0").toDouble();
3197 fschmid 734
                                        QString defaultVal;
3934 cbradney 735
                                        defaultVal.setNum(Neu->width());
4026 craig 736
                                        Neu->gWidth = pg.attribute("gWidth",defaultVal).toDouble();
3934 cbradney 737
                                        defaultVal.setNum(Neu->height());
4026 craig 738
                                        Neu->gHeight = pg.attribute("gHeight",defaultVal).toDouble();
4584 cbradney 739
                                        if (Neu->lineSpacingMode() == 3)
3197 fschmid 740
                                        {
741
                                                doc->docParagraphStyles[0].BaseAdj = true;
4584 cbradney 742
                                                Neu->setLineSpacing(doc->typographicSettings.valueBaseGrid-1);
3197 fschmid 743
                                        }
744
                                        if (Neu->isAutoText)
745
                                                doc->LastAuto = Neu;
746
                                        if (Neu->isTableItem)
747
                                        {
748
                                                TableItems.append(Neu);
4026 craig 749
                                                TableID.insert(pg.attribute("OwnLINK", "0").toInt(), Neu->ItemNr);
3197 fschmid 750
                                        }
751
                                        if (pg.tagName()=="FRAMEOBJECT")
752
                                        {
3727 cbradney 753
                                                doc->FrameItems.append(doc->Items->take(Neu->ItemNr));
3197 fschmid 754
                                                Neu->ItemNr = doc->FrameItems.count()-1;
755
                                        }
756
                                }
757
                                counter++;
758
                        }
759
                        PAGE=PAGE.nextSibling();
760
                }
4679 fschmid 761
                PAGE=DOC.firstChild();
762
                while(!PAGE.isNull())
763
                {
764
                        QDomElement pg=PAGE.toElement();
765
                        if(pg.tagName()=="Bookmark")
766
                        {
6572 fschmid 767
                                uint elem = pg.attribute("Element").toInt();
768
                                if (elem < doc->Items->count())
769
                                {
770
                                        bok.Title = pg.attribute("Title");
771
                                        bok.Text = pg.attribute("Text");
772
                                        bok.Aktion = pg.attribute("Aktion");
773
                                        bok.ItemNr = pg.attribute("ItemNr").toInt();
774
                                        bok.PageObject = doc->Items->at(elem);
775
                                        bok.First = pg.attribute("First").toInt();
776
                                        bok.Last = pg.attribute("Last").toInt();
777
                                        bok.Prev = pg.attribute("Prev").toInt();
778
                                        bok.Next = pg.attribute("Next").toInt();
779
                                        bok.Parent = pg.attribute("Parent").toInt();
780
                                        doc->BookMarks.append(bok);
781
                                }
4679 fschmid 782
                        }
783
                        PAGE=PAGE.nextSibling();
784
                }
3197 fschmid 785
                DOC=DOC.nextSibling();
786
        }
787
        if (TableItems.count() != 0)
788
        {
789
                for (uint ttc = 0; ttc < TableItems.count(); ++ttc)
790
                {
791
                        PageItem* ta = TableItems.at(ttc);
792
                        if (ta->TopLinkID != -1)
3727 cbradney 793
                                ta->TopLink = doc->Items->at(TableID[ta->TopLinkID]);
3197 fschmid 794
                        else
795
                                ta->TopLink = 0;
796
                        if (ta->LeftLinkID != -1)
3727 cbradney 797
                                ta->LeftLink = doc->Items->at(TableID[ta->LeftLinkID]);
3197 fschmid 798
                        else
799
                                ta->LeftLink = 0;
800
                        if (ta->RightLinkID != -1)
3727 cbradney 801
                                ta->RightLink = doc->Items->at(TableID[ta->RightLinkID]);
3197 fschmid 802
                        else
803
                                ta->RightLink = 0;
804
                        if (ta->BottomLinkID != -1)
3727 cbradney 805
                                ta->BottomLink = doc->Items->at(TableID[ta->BottomLinkID]);
3197 fschmid 806
                        else
807
                                ta->BottomLink = 0;
808
                }
809
        }
7708 avox 810
        // reestablish textframe links
811
        if (itemNext.count() != 0)
3197 fschmid 812
        {
7708 avox 813
                QMap<int,int>::Iterator lc;
814
                for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
3197 fschmid 815
                {
7708 avox 816
                        if (itemRemap[lc.data()] >= 0)
3197 fschmid 817
                        {
7708 avox 818
                                PageItem * Its = doc->Items->at(lc.key());
819
                                PageItem * Itn = doc->Items->at(itemRemap[lc.data()]);
820
                                if (Itn->BackBox)
3197 fschmid 821
                                {
7708 avox 822
                                        qDebug("scribus13format: corruption in linked textframes detected");
823
                                        continue;
3197 fschmid 824
                                }
7708 avox 825
                                Its->NextBox = Itn;
826
                                Itn->BackBox = Its;
3197 fschmid 827
                        }
828
                }
7708 avox 829
        }      
830
 
831
        // reestablish first/lastAuto
832
        doc->FirstAuto = doc->LastAuto;
833
        if (doc->LastAuto)
834
        {
835
                while (doc->LastAuto->NextBox)
836
                        doc->LastAuto = doc->LastAuto->NextBox;
837
                while (doc->FirstAuto->BackBox)
838
                        doc->FirstAuto = doc->FirstAuto->BackBox;
3197 fschmid 839
        }
840
        return true;
841
}
842
 
3657 cbradney 843
bool FileLoader::ReadDoc(const QString & fileName, SCFonts &avail, ScribusDoc *doc, QProgressBar *dia2)
517 fschmid 844
{
1065 cbradney 845
        struct ParagraphStyle vg;
517 fschmid 846
        struct Layer la;
847
        struct ScribusDoc::BookMa bok;
3757 cbradney 848
        int counter;//, Pgc;
849
        //bool AtFl;
517 fschmid 850
        bool newVersion = false;
851
        QString tmp, tmpf, tmp2, tmp3, tmp4, PgNam, Defont, tmf;
852
        QFont fo;
853
        QMap<int,int> TableID;
854
        QPtrList<PageItem> TableItems;
7512 fschmid 855
        QMap<int,int> TableIDM;
856
        QPtrList<PageItem> TableItemsM;
857
        QMap<int,int> TableIDF;
858
        QPtrList<PageItem> TableItemsF;
1779 fschmid 859
        int a;
2282 fschmid 860
        double xf, xf2;
517 fschmid 861
        PageItem *Neu;
862
        Page* Apage;
7708 avox 863
        itemRemap.clear();
864
        itemNext.clear();
865
        itemCount = 0;
517 fschmid 866
        QDomDocument docu("scridoc");
3646 craig 867
        QString f(readSLA(fileName));
517 fschmid 868
        /* 2004/10/02 - petr vanek - bug #1092 - missing <PAGE> crash Scribus. The check constraint moved into IsScribus()
2680 cbradney 869
        FIXME: I've add test on containig tag PAGE but returning false freezes S. in scribus.cpp need some hack too...  */
517 fschmid 870
        if (!docu.setContent(f))
871
                return false;
1549 subik 872
        doc->PageColors.clear();
517 fschmid 873
        doc->Layers.clear();
3855 cbradney 874
        int layerToSetActive=0;
2886 fschmid 875
        ScColor lf = ScColor();
517 fschmid 876
        QDomElement elem=docu.documentElement();
877
        if (elem.tagName() != "SCRIBUSUTF8NEW")
878
                return false;
879
        if (elem.hasAttribute("Version"))
880
                newVersion = true;
881
        QDomNode DOC=elem.firstChild();
882
        dia2->setTotalSteps(DOC.childNodes().count());
883
        dia2->setProgress(0);
884
        int ObCount = 0;
885
        TableItems.clear();
886
        TableID.clear();
7512 fschmid 887
        TableItemsM.clear();
888
        TableIDM.clear();
889
        TableItemsF.clear();
890
        TableIDF.clear();
517 fschmid 891
        while(!DOC.isNull())
892
        {
893
                QDomElement dc=DOC.toElement();
894
        /*
895
        * Attribute von DOCUMENT auslesen
896
        */
4546 subik 897
                //CB Add this in to set this in the file in memory. Its saved, why not load it.
1542 cbradney 898
                //Will of course be replaced by per page settings although we still probably need a document default
899
                doc->PageSize = dc.attribute("PAGESIZE");
4026 craig 900
                doc->PageOri = dc.attribute("ORIENTATION", "0").toInt();
901
                doc->FirstPnum = dc.attribute("FIRSTNUM", "1").toInt();
902
                doc->currentPageLayout=dc.attribute("BOOK", "0").toInt();
3016 fschmid 903
                int fp;
3035 fschmid 904
                if (doc->currentPageLayout == 0)
905
                        fp = 0;
2912 fschmid 906
                else
907
                {
4026 craig 908
                        if (dc.attribute("FIRSTLEFT", "0").toInt() == 1)
3016 fschmid 909
                                fp = 0;
2912 fschmid 910
                        else
3035 fschmid 911
                                fp = 1;
2912 fschmid 912
                }
3016 fschmid 913
                if (DOC.namedItem("PageSets").isNull())
914
                {
3032 fschmid 915
                        doc->pageSets[doc->currentPageLayout].FirstPage = fp;
4026 craig 916
                        doc->pageSets[doc->currentPageLayout].GapHorizontal = dc.attribute("GapHorizontal", "0").toDouble();
3032 fschmid 917
                        doc->pageSets[doc->currentPageLayout].GapVertical = 0.0;
4026 craig 918
                        doc->pageSets[doc->currentPageLayout].GapBelow = dc.attribute("GapVertical", "40").toDouble();
3016 fschmid 919
                }
4026 craig 920
                doc->setUsesAutomaticTextFrames(dc.attribute("AUTOTEXT").toInt());
921
                doc->PageSp=dc.attribute("AUTOSPALTEN").toInt();
922
                doc->PageSpa=dc.attribute("ABSTSPALTEN").toDouble();
923
                doc->setUnitIndex(dc.attribute("UNITS", "0").toInt());
924
                doc->toolSettings.defSize=qRound(dc.attribute("DSIZE").toDouble() * 10);
517 fschmid 925
                Defont=dc.attribute("DFONT");
1428 fschmid 926
                if ((!avail.find(Defont)) || (!avail[Defont]->UseFont))
517 fschmid 927
                {
3650 cbradney 928
                        ReplacedFonts.insert(Defont, prefsManager->appPrefs.toolSettings.defFont);
929
                        Defont = prefsManager->appPrefs.toolSettings.defFont;
517 fschmid 930
                }
931
                else
1428 fschmid 932
                {
3544 avox 933
//                      QFont fo = avail[Defont]->Font;
934
//                      fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
935
                        doc->AddFont(Defont, qRound(doc->toolSettings.defSize / 10.0));
1428 fschmid 936
                }
1194 fschmid 937
                doc->toolSettings.defFont = Defont;
4026 craig 938
                doc->toolSettings.dCols=dc.attribute("DCOL", "1").toInt();
939
                doc->toolSettings.dGap=dc.attribute("DGAP", "0.0").toDouble();
2024 cbradney 940
                doc->documentInfo.setAuthor(dc.attribute("AUTHOR"));
941
                doc->documentInfo.setComments(dc.attribute("COMMENTS"));
942
                doc->documentInfo.setKeywords(dc.attribute("KEYWORDS",""));
943
                doc->documentInfo.setTitle(dc.attribute("TITLE"));
944
                doc->documentInfo.setPublisher(dc.attribute("PUBLISHER", ""));
945
                doc->documentInfo.setDate(dc.attribute("DOCDATE", ""));
946
                doc->documentInfo.setType(dc.attribute("DOCTYPE", ""));
947
                doc->documentInfo.setFormat(dc.attribute("DOCFORMAT", ""));
948
                doc->documentInfo.setIdent(dc.attribute("DOCIDENT", ""));
949
                doc->documentInfo.setSource(dc.attribute("DOCSOURCE", ""));
950
                doc->documentInfo.setLangInfo(dc.attribute("DOCLANGINFO", ""));
951
                doc->documentInfo.setRelation(dc.attribute("DOCRELATION", ""));
952
                doc->documentInfo.setCover(dc.attribute("DOCCOVER", ""));
953
                doc->documentInfo.setRights(dc.attribute("DOCRIGHTS", ""));
954
                doc->documentInfo.setContrib(dc.attribute("DOCCONTRIB", ""));
4026 craig 955
                doc->typographicSettings.valueSuperScript = dc.attribute("VHOCH").toInt();
956
                doc->typographicSettings.scalingSuperScript = dc.attribute("VHOCHSC").toInt();
957
                doc->typographicSettings.valueSubScript = dc.attribute("VTIEF").toInt();
958
                doc->typographicSettings.scalingSubScript = dc.attribute("VTIEFSC").toInt();
959
                doc->typographicSettings.valueSmallCaps = dc.attribute("VKAPIT").toInt();
960
                doc->typographicSettings.valueBaseGrid = dc.attribute("BASEGRID", "12").toDouble();
961
                doc->typographicSettings.offsetBaseGrid = dc.attribute("BASEO", "0").toDouble();
962
                doc->typographicSettings.autoLineSpacing = dc.attribute("AUTOL", "20").toInt();
963
                doc->typographicSettings.valueUnderlinePos = dc.attribute("UnderlinePos", "-1").toInt();
964
                doc->typographicSettings.valueUnderlineWidth = dc.attribute("UnderlineWidth", "-1").toInt();
965
                doc->typographicSettings.valueStrikeThruPos = dc.attribute("StrikeThruPos", "-1").toInt();
966
                doc->typographicSettings.valueStrikeThruWidth = dc.attribute("StrikeThruWidth", "-1").toInt();
967
                doc->GroupCounter=dc.attribute("GROUPC", "1").toInt();
968
                doc->HasCMS = static_cast<bool>(dc.attribute("HCMS", "0").toInt());
969
                doc->CMSSettings.SoftProofOn = static_cast<bool>(dc.attribute("DPSo", "0").toInt());
970
                doc->CMSSettings.CMSinUse = static_cast<bool>(dc.attribute("DPuse", "0").toInt());
971
                doc->CMSSettings.GamutCheck = static_cast<bool>(dc.attribute("DPgam", "0").toInt());
972
                doc->CMSSettings.BlackPoint = static_cast<bool>(dc.attribute("DPbla", "1").toInt());
517 fschmid 973
                doc->CMSSettings.DefaultMonitorProfile = dc.attribute("DPMo","");
974
                doc->CMSSettings.DefaultPrinterProfile = dc.attribute("DPPr","");
2984 fschmid 975
                doc->CMSSettings.DefaultImageRGBProfile = dc.attribute("DPIn","");
976
                doc->CMSSettings.DefaultImageCMYKProfile = dc.attribute("DPInCMYK","");
977
                doc->CMSSettings.DefaultSolidColorProfile = dc.attribute("DPIn2","");
4026 craig 978
                doc->CMSSettings.DefaultIntentPrinter = dc.attribute("DIPr", "0").toInt();
979
                doc->CMSSettings.DefaultIntentMonitor = dc.attribute("DIMo", "1").toInt();
980
                doc->CMSSettings.DefaultIntentImages = dc.attribute("DIMo2", "1").toInt();
981
                layerToSetActive=dc.attribute("ALAYER", "0").toInt();
517 fschmid 982
                doc->Language = dc.attribute("LANGUAGE", "");
4026 craig 983
                doc->MinWordLen = dc.attribute("MINWORDLEN", "3").toInt();
984
                doc->HyCount = dc.attribute("HYCOUNT", "2").toInt();
2305 cbradney 985
                if (dc.hasAttribute("PAGEWIDTH"))
4026 craig 986
                        doc->pageWidth=dc.attribute("PAGEWIDTH").toDouble();
2305 cbradney 987
                else
4026 craig 988
                        doc->pageWidth=dc.attribute("PAGEWITH").toDouble();
989
                doc->pageHeight=dc.attribute("PAGEHEIGHT").toDouble();
4595 fschmid 990
                doc->pageMargins.Left=QMAX(0.0, dc.attribute("BORDERLEFT").toDouble());
991
                doc->pageMargins.Right=QMAX(0.0, dc.attribute("BORDERRIGHT").toDouble());
992
                doc->pageMargins.Top=QMAX(0.0, dc.attribute("BORDERTOP").toDouble());
993
                doc->pageMargins.Bottom=QMAX(0.0, dc.attribute("BORDERBOTTOM").toDouble());
4026 craig 994
                doc->Automatic = static_cast<bool>(dc.attribute("AUTOMATIC", "1").toInt());
995
                doc->AutoCheck = static_cast<bool>(dc.attribute("AUTOCHECK", "0").toInt());
996
                doc->GuideLock = static_cast<bool>(dc.attribute("GUIDELOCK", "0").toInt());
997
                doc->guidesSettings.minorGrid = dc.attribute("MINGRID", tmp.setNum(prefsManager->appPrefs.guidesSettings.minorGrid)).toDouble();
998
                doc->guidesSettings.majorGrid = dc.attribute("MAJGRID", tmp.setNum(prefsManager->appPrefs.guidesSettings.majorGrid)).toDouble();
999
                doc->guidesSettings.gridShown = static_cast<bool>(dc.attribute("SHOWGRID", "0").toInt());
1000
                doc->guidesSettings.guidesShown = static_cast<bool>(dc.attribute("SHOWGUIDES", "1").toInt());
5560 cbradney 1001
                doc->guidesSettings.colBordersShown = static_cast<bool>(dc.attribute("showcolborders", "0").toInt());
4026 craig 1002
                doc->guidesSettings.framesShown = static_cast<bool>(dc.attribute("SHOWFRAME", "1").toInt());
1003
                doc->guidesSettings.marginsShown = static_cast<bool>(dc.attribute("SHOWMARGIN", "1").toInt());
1004
                doc->guidesSettings.baseShown = static_cast<bool>(dc.attribute("SHOWBASE", "0").toInt());
1005
                doc->guidesSettings.showPic = static_cast<bool>(dc.attribute("SHOWPICT", "1").toInt());
1006
                doc->guidesSettings.linkShown = static_cast<bool>(dc.attribute("SHOWLINK", "0").toInt());
1007
                doc->guidesSettings.showControls = static_cast<bool>(dc.attribute("SHOWControl", "0").toInt());
1008
                doc->guidesSettings.rulerMode = static_cast<bool>(dc.attribute("rulerMode", "1").toInt());
4651 cbradney 1009
                doc->guidesSettings.rulersShown = static_cast<bool>(dc.attribute("showrulers", "1").toInt());
4026 craig 1010
                doc->rulerXoffset = dc.attribute("rulerXoffset", "0").toDouble();
1011
                doc->rulerYoffset =dc.attribute("rulerYoffset", "0").toDouble();
1012
                doc->SnapGuides = static_cast<bool>(dc.attribute("SnapToGuides", "0").toInt());
1013
                doc->useRaster = static_cast<bool>(dc.attribute("SnapToGrid", "0").toInt());
1014
                doc->toolSettings.polyC = dc.attribute("POLYC", "4").toInt();
1015
                doc->toolSettings.polyF = dc.attribute("POLYF", "0.5").toDouble();
1016
                doc->toolSettings.polyR = dc.attribute("POLYR", "0").toDouble();
1017
                doc->toolSettings.polyFd = dc.attribute("POLYFD", "0").toInt();
1018
                doc->toolSettings.polyS = static_cast<bool>(dc.attribute("POLYS", "0").toInt());
1019
                doc->AutoSave = static_cast<bool>(dc.attribute("AutoSave", "0").toInt());
1020
                doc->AutoSaveTime = dc.attribute("AutoSaveTime", "600000").toInt();
1021
                doc->ScratchBottom = dc.attribute("ScratchBottom", "20").toDouble();
1719 craig 1022
                // FIXME A typo in early 1.3cvs (MAR 05) means we must support loading of
1023
                // FIXME 'ScatchLeft' for a while too. This can be removed in a few months.
1024
                if (dc.hasAttribute("ScatchLeft"))
4026 craig 1025
                        doc->ScratchLeft = dc.attribute("ScatchLeft", "100").toDouble();
1719 craig 1026
                else
4026 craig 1027
                        doc->ScratchLeft = dc.attribute("ScratchLeft", "100").toDouble();
1028
                doc->ScratchRight = dc.attribute("ScratchRight", "100").toDouble();
1029
                doc->ScratchTop = dc.attribute("ScratchTop", "20").toDouble();
1030
                doc->toolSettings.dStartArrow = dc.attribute("StartArrow", "0").toInt();
1031
                doc->toolSettings.dEndArrow = dc.attribute("EndArrow", "0").toInt();
1032
                doc->toolSettings.scaleX = dc.attribute("PICTSCX", "1").toDouble();
1033
                doc->toolSettings.scaleY = dc.attribute("PICTSCY", "1").toDouble();
1034
                doc->toolSettings.scaleType = static_cast<bool>(dc.attribute("PSCALE", "1").toInt());
1035
                doc->toolSettings.aspectRatio = static_cast<bool>(dc.attribute("PASPECT", "0").toInt());
1036
                doc->toolSettings.lowResType = dc.attribute("HalfRes", "1").toInt();
1037
                doc->toolSettings.useEmbeddedPath = static_cast<bool>(dc.attribute("EmbeddedPath", "0").toInt());
745 fschmid 1038
                if (dc.hasAttribute("PEN"))
1194 fschmid 1039
                        doc->toolSettings.dPen = dc.attribute("PEN");
745 fschmid 1040
                if (dc.hasAttribute("BRUSH"))
1194 fschmid 1041
                        doc->toolSettings.dBrush = dc.attribute("BRUSH");
745 fschmid 1042
                if (dc.hasAttribute("PENLINE"))
1194 fschmid 1043
                        doc->toolSettings.dPenLine = dc.attribute("PENLINE");
745 fschmid 1044
                if (dc.hasAttribute("PENTEXT"))
1194 fschmid 1045
                        doc->toolSettings.dPenText = dc.attribute("PENTEXT");
745 fschmid 1046
                if (dc.hasAttribute("StrokeText"))
1194 fschmid 1047
                        doc->toolSettings.dStrokeText = dc.attribute("StrokeText");
4546 subik 1048
                doc->toolSettings.dTextBackGround = dc.attribute("TextBackGround", CommonStrings::None);
1049
                doc->toolSettings.dTextLineColor = dc.attribute("TextLineColor", CommonStrings::None);
4026 craig 1050
                doc->toolSettings.dTextBackGroundShade = dc.attribute("TextBackGroundShade", "100").toInt();
1051
                doc->toolSettings.dTextLineShade = dc.attribute("TextLineShade", "100").toInt();
1052
                doc->toolSettings.dTextPenShade = dc.attribute("TextPenShade", "100").toInt();
1053
                doc->toolSettings.dTextStrokeShade = dc.attribute("TextStrokeShade", "100").toInt();
1054
                doc->toolSettings.dLineArt = static_cast<Qt::PenStyle>(dc.attribute("STIL").toInt());
1055
                doc->toolSettings.dLstyleLine = static_cast<Qt::PenStyle>(dc.attribute("STILLINE").toInt());
1056
                doc->toolSettings.dWidth = dc.attribute("WIDTH", "1").toDouble();
1057
                doc->toolSettings.dWidthLine = dc.attribute("WIDTHLINE", "1").toDouble();
1058
                doc->toolSettings.dShade2 = dc.attribute("PENSHADE", "100").toInt();
1059
                doc->toolSettings.dShadeLine = dc.attribute("LINESHADE", "100").toInt();
1060
                doc->toolSettings.dShade = dc.attribute("BRUSHSHADE", "100").toInt();
1061
                doc->toolSettings.magMin = dc.attribute("MAGMIN", "10").toInt();
1062
                doc->toolSettings.magMax = dc.attribute("MAGMAX", "3200").toInt();
4295 cbradney 1063
                doc->toolSettings.magStep = dc.attribute("MAGSTEP", "200").toInt();
1064
                //CB Reset doc zoom step value to 200% instead of old values.
1065
                if (doc->toolSettings.magStep<100)
1066
                        doc->toolSettings.magStep=200;
2219 fschmid 1067
                doc->toolSettings.tabFillChar = dc.attribute("TabFill","");
4026 craig 1068
                doc->toolSettings.dTabWidth=dc.attribute("TabWidth", "36.0").toDouble();
745 fschmid 1069
                if (dc.hasAttribute("CPICT"))
1194 fschmid 1070
                        doc->toolSettings.dBrushPict = dc.attribute("CPICT");
4026 craig 1071
                doc->toolSettings.shadePict = dc.attribute("PICTSHADE", "100").toInt();
745 fschmid 1072
                if (dc.hasAttribute("PAGEC"))
1073
                        doc->papColor = QColor(dc.attribute("PAGEC"));
1074
                if (dc.hasAttribute("MARGC"))
879 fschmid 1075
                        doc->guidesSettings.margColor = QColor(dc.attribute("MARGC"));
745 fschmid 1076
                if (dc.hasAttribute("MINORC"))
879 fschmid 1077
                        doc->guidesSettings.minorColor = QColor(dc.attribute("MINORC"));
745 fschmid 1078
                if (dc.hasAttribute("MAJORC"))
879 fschmid 1079
                        doc->guidesSettings.majorColor = QColor(dc.attribute("MAJORC"));
745 fschmid 1080
                if (dc.hasAttribute("GuideC"))
879 fschmid 1081
                        doc->guidesSettings.guideColor = QColor(dc.attribute("GuideC"));
745 fschmid 1082
                if (dc.hasAttribute("BaseC"))
879 fschmid 1083
                        doc->guidesSettings.baseColor = QColor(dc.attribute("BaseC"));
4026 craig 1084
                doc->marginColored = static_cast<bool>(dc.attribute("RANDF", "0").toInt());
1085
                doc->guidesSettings.before = static_cast<bool>(dc.attribute("BACKG", "1").toInt());
1086
                doc->guidesSettings.guideRad = dc.attribute("GuideRad", "10").toDouble();
1087
                doc->guidesSettings.grabRad = dc.attribute("GRAB", "4").toInt();
1261 fschmid 1088
                if (dc.hasAttribute("currentProfile"))
1284 fschmid 1089
                {
1090
                        doc->checkerProfiles.clear();
1261 fschmid 1091
                        doc->curCheckProfile = dc.attribute("currentProfile");
1284 fschmid 1092
                }
1016 fschmid 1093
                doc->LastAuto = 0;
517 fschmid 1094
                QDomNode PAGE=DOC.firstChild();
1095
                counter = 0;
1096
                while(!PAGE.isNull())
1097
                {
1098
                        ObCount++;
1099
                        dia2->setProgress(ObCount);
1100
                        QDomElement pg=PAGE.toElement();
3016 fschmid 1101
                        if (pg.tagName()=="PageSets")
1102
                        {
1103
                                QDomNode PGS = PAGE.firstChild();
1104
                                doc->pageSets.clear();
1105
                                while(!PGS.isNull())
1106
                                {
1107
                                        QDomElement PgsAttr = PGS.toElement();
1108
                                        if(PgsAttr.tagName() == "Set")
1109
                                        {
1110
                                                struct PageSet pageS;
4538 cbradney 1111
                                                pageS.Name = CommonStrings::untranslatePageSetString(PgsAttr.attribute("Name"));
4026 craig 1112
                                                pageS.FirstPage = PgsAttr.attribute("FirstPage", "0").toInt();
1113
                                                pageS.Rows = PgsAttr.attribute("Rows", "1").toInt();
1114
                                                pageS.Columns = PgsAttr.attribute("Columns", "1").toInt();
1115
                                                pageS.GapHorizontal = PgsAttr.attribute("GapHorizontal", "0").toDouble();
1116
                                                pageS.GapVertical = PgsAttr.attribute("GapVertical", "0").toDouble();
1117
                                                pageS.GapBelow = PgsAttr.attribute("GapBelow", "0").toDouble();
3026 fschmid 1118
                                                pageS.pageNames.clear();
1119
                                                QDomNode PGSN = PGS.firstChild();
1120
                                                while(!PGSN.isNull())
1121
                                                {
1122
                                                        QDomElement PgsAttrN = PGSN.toElement();
1123
                                                        if(PgsAttrN.tagName() == "PageNames")
4538 cbradney 1124
                                                                pageS.pageNames.append(CommonStrings::untranslatePageSetLocString(PgsAttrN.attribute("Name")));
3026 fschmid 1125
                                                        PGSN = PGSN.nextSibling();
1126
                                                }
3016 fschmid 1127
                                                doc->pageSets.append(pageS);
1128
                                        }
1129
                                        PGS = PGS.nextSibling();
1130
                                }
1131
                        }
1261 fschmid 1132
                        if (pg.tagName()=="CheckProfile")
1133
                        {
1134
                                struct checkerPrefs checkerSettings;
4026 craig 1135
                                checkerSettings.ignoreErrors = static_cast<bool>(pg.attribute("ignoreErrors", "0").toInt());
1136
                                checkerSettings.autoCheck = static_cast<bool>(pg.attribute("autoCheck", "1").toInt());
1137
                                checkerSettings.checkGlyphs = static_cast<bool>(pg.attribute("checkGlyphs", "1").toInt());
1138
                                checkerSettings.checkOrphans = static_cast<bool>(pg.attribute("checkOrphans", "1").toInt());
1139
                                checkerSettings.checkOverflow = static_cast<bool>(pg.attribute("checkOverflow", "1").toInt());
1140
                                checkerSettings.checkPictures = static_cast<bool>(pg.attribute("checkPictures", "1").toInt());
1141
                                checkerSettings.checkResolution = static_cast<bool>(pg.attribute("checkResolution", "1").toInt());
1142
                                checkerSettings.checkTransparency = static_cast<bool>(pg.attribute("checkTransparency", "1").toInt());
1143
                                checkerSettings.minResolution = pg.attribute("minResolution", "72").toDouble();
1144
                                checkerSettings.checkAnnotations = static_cast<bool>(pg.attribute("checkAnnotations", "0").toInt());
1145
                                checkerSettings.checkRasterPDF = static_cast<bool>(pg.attribute("checkRasterPDF", "1").toInt());
1261 fschmid 1146
                                doc->checkerProfiles[pg.attribute("Name")] = checkerSettings;
1147
                        }
517 fschmid 1148
                        // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
4546 subik 1149
                        if(pg.tagName()=="COLOR" && pg.attribute("NAME")!=CommonStrings::None)
517 fschmid 1150
                        {
1151
                                if (pg.hasAttribute("CMYK"))
1152
                                        lf.setNamedColor(pg.attribute("CMYK"));
1153
                                else
1154
                                        lf.fromQColor(QColor(pg.attribute("RGB")));
3051 fschmid 1155
                                if (pg.hasAttribute("Spot"))
4026 craig 1156
                                        lf.setSpotColor(static_cast<bool>(pg.attribute("Spot").toInt()));
3051 fschmid 1157
                                else
1158
                                        lf.setSpotColor(false);
3060 fschmid 1159
                                if (pg.hasAttribute("Register"))
4026 craig 1160
                                        lf.setRegistrationColor(static_cast<bool>(pg.attribute("Register").toInt()));
3060 fschmid 1161
                                else
1162
                                        lf.setRegistrationColor(false);
517 fschmid 1163
                          doc->PageColors[pg.attribute("NAME")] = lf;
1164
                        }
1165
                        if(pg.tagName()=="STYLE")
1166
                        {
1167
                                vg.Vname = pg.attribute("NAME");
4026 craig 1168
                                vg.LineSpaMode = pg.attribute("LINESPMode", "0").toInt();
1169
                                vg.LineSpa = pg.attribute("LINESP").toDouble();
1170
                                vg.Indent = pg.attribute("INDENT", "0").toDouble();
1171
                                vg.First = pg.attribute("FIRST", "0").toDouble();
1172
                                vg.textAlignment = pg.attribute("ALIGN").toInt();
1173
                                vg.gapBefore = pg.attribute("VOR", "0").toDouble();
1174
                                vg.gapAfter = pg.attribute("NACH", "0").toDouble();
1194 fschmid 1175
                                tmpf = pg.attribute("FONT", doc->toolSettings.defFont);
1428 fschmid 1176
                                if ((!avail.find(tmpf)) || (!avail[tmpf]->UseFont))
1177
                                {
3650 cbradney 1178
                                        if ((!prefsManager->appPrefs.GFontSub.contains(tmpf)) || (!avail[prefsManager->appPrefs.GFontSub[tmpf]]->UseFont))
1468 fschmid 1179
                                        {
1180
                                                newReplacement = true;
3650 cbradney 1181
                                                ReplacedFonts.insert(tmpf, prefsManager->appPrefs.toolSettings.defFont);
1468 fschmid 1182
                                        }
1428 fschmid 1183
                                        else
3650 cbradney 1184
                                                ReplacedFonts.insert(tmpf, prefsManager->appPrefs.GFontSub[tmpf]);
1428 fschmid 1185
                                }
517 fschmid 1186
                                else
1428 fschmid 1187
                                {
1786 fschmid 1188
                                        if (!doc->UsedFonts.contains(tmpf))
1189
                                        {
3544 avox 1190
//                                              QFont fo = avail[tmpf]->Font;
1191
//                                              fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
1192
                                                doc->AddFont(tmpf, qRound(doc->toolSettings.defSize / 10.0));
1786 fschmid 1193
                                        }
1428 fschmid 1194
                                }
517 fschmid 1195
                                vg.Font = tmpf;
4026 craig 1196
                                vg.FontSize = qRound(pg.attribute("FONTSIZE", "12").toDouble() * 10.0);
1197
                                vg.Drop = static_cast<bool>(pg.attribute("DROP", "0").toInt());
1198
                                vg.DropLin = pg.attribute("DROPLIN", "2").toInt();
1199
                                vg.DropDist = pg.attribute("DROPDIST", "0").toDouble();
1200
                                vg.FontEffect = pg.attribute("EFFECT", "0").toInt();
1194 fschmid 1201
                                vg.FColor = pg.attribute("FCOLOR", doc->toolSettings.dBrush);
4026 craig 1202
                                vg.FShade = pg.attribute("FSHADE", "100").toInt();
1194 fschmid 1203
                                vg.SColor = pg.attribute("SCOLOR", doc->toolSettings.dPen);
4026 craig 1204
                                vg.SShade = pg.attribute("SSHADE", "100").toInt();
1205
                                vg.BaseAdj = static_cast<bool>(pg.attribute("BASE", "0").toInt());
1206
                                vg.txtShadowX=qRound(pg.attribute("TXTSHX", "5").toDouble() * 10);
1207
                                vg.txtShadowY=qRound(pg.attribute("TXTSHY", "-5").toDouble() * 10);
1208
                                vg.txtOutline=qRound(pg.attribute("TXTOUT", "1").toDouble() * 10);
1209
                                vg.txtUnderPos=qRound(pg.attribute("TXTULP", "-0.1").toDouble() * 10);
1210
                                vg.txtUnderWidth=qRound(pg.attribute("TXTULW", "-0.1").toDouble() * 10);
1211
                                vg.txtStrikePos=qRound(pg.attribute("TXTSTP", "-0.1").toDouble() * 10);
1212
                                vg.txtStrikeWidth=qRound(pg.attribute("TXTSTW", "-0.1").toDouble() * 10);
1213
                                vg.scaleH = qRound(pg.attribute("SCALEH", "100").toDouble() * 10);
1214
                                vg.scaleV = qRound(pg.attribute("SCALEV", "100").toDouble() * 10);
1215
                                vg.baseOff = qRound(pg.attribute("BASEO", "0").toDouble() * 10);
1216
                                vg.kernVal = qRound(pg.attribute("KERN", "0").toDouble() * 10);
2282 fschmid 1217
                                vg.TabValues.clear();
4026 craig 1218
                                if ((pg.hasAttribute("NUMTAB")) && (pg.attribute("NUMTAB", "0").toInt() != 0))
517 fschmid 1219
                                {
2282 fschmid 1220
                                        struct PageItem::TabRecord tb;
517 fschmid 1221
                                        tmp = pg.attribute("TABS");
1222
                                        QTextStream tgv(&tmp, IO_ReadOnly);
4026 craig 1223
                                        for (int cxv = 0; cxv < pg.attribute("NUMTAB", "0").toInt(); cxv += 2)
517 fschmid 1224
                                        {
1225
                                                tgv >> xf;
2282 fschmid 1226
                                                tgv >> xf2;
1227
                                                tb.tabPosition = xf2;
1228
                                                tb.tabType = static_cast<int>(xf);
1229
                                                tb.tabFillChar =  QChar();
1230
                                                vg.TabValues.append(tb);
517 fschmid 1231
                                        }
1232
                                        tmp = "";
1233
                                }
1234
                                else
2282 fschmid 1235
                                {
1236
                                        QDomNode IT = pg.firstChild();
1237
                                        while(!IT.isNull())
1238
                                        {
1239
                                                QDomElement it = IT.toElement();
1240
                                                if (it.tagName()=="Tabs")
1241
                                                {
1242
                                                        struct PageItem::TabRecord tb;
4026 craig 1243
                                                        tb.tabPosition = it.attribute("Pos").toDouble();
1244
                                                        tb.tabType = it.attribute("Type").toInt();
2282 fschmid 1245
                                                        QString tbCh = "";
1246
                                                        tbCh = it.attribute("Fill","");
2877 cbradney 1247
                                                        if (tbCh.isEmpty())
2282 fschmid 1248
                                                                tb.tabFillChar = QChar();
1249
                                                        else
1250
                                                                tb.tabFillChar = tbCh[0];
1251
                                                        vg.TabValues.append(tb);
1252
                                                }
1253
                                                IT=IT.nextSibling();
1254
                                        }
1255
                                }
1065 cbradney 1256
                                doc->docParagraphStyles.append(vg);
517 fschmid 1257
                        }
1258
                        if(pg.tagName()=="JAVA")
1259
                                doc->JavaScripts[pg.attribute("NAME")] = pg.attribute("SCRIPT");
1260
                        if(pg.tagName()=="LAYERS")
1261
                        {
4026 craig 1262
                                la.LNr = pg.attribute("NUMMER").toInt();
1263
                                la.Level = pg.attribute("LEVEL").toInt();
517 fschmid 1264
                                la.Name = pg.attribute("NAME");
4026 craig 1265
                                la.isViewable = pg.attribute("SICHTBAR").toInt();
1266
                                la.isPrintable = pg.attribute("DRUCKEN").toInt();
4832 fschmid 1267
                                la.isEditable = pg.attribute("EDIT", "1").toInt();
517 fschmid 1268
                                doc->Layers.append(la);
1269
                        }
4679 fschmid 1270
/*                      if(pg.tagName()=="Bookmark")
517 fschmid 1271
                        {
1272
                                bok.Title = pg.attribute("Title");
1273
                                bok.Text = pg.attribute("Text");
1274
                                bok.Aktion = pg.attribute("Aktion");
4026 craig 1275
                                bok.ItemNr = pg.attribute("ItemNr").toInt();
1276
                                bok.Seite = pg.attribute("Seite").toInt();
1277
                                bok.Element = pg.attribute("Element").toInt();
1278
                                bok.First = pg.attribute("First").toInt();
1279
                                bok.Last = pg.attribute("Last").toInt();
1280
                                bok.Prev = pg.attribute("Prev").toInt();
1281
                                bok.Next = pg.attribute("Next").toInt();
1282
                                bok.Parent = pg.attribute("Parent").toInt();
517 fschmid 1283
                                doc->BookMarks.append(bok);
4679 fschmid 1284
                        } */
517 fschmid 1285
                        if(pg.tagName()=="MultiLine")
1286
                        {
1287
                                multiLine ml;
1288
                                QDomNode MuLn = PAGE.firstChild();
1289
                                while(!MuLn.isNull())
1290
                                {
1291
                                        QDomElement MuL = MuLn.toElement();
1065 cbradney 1292
                                        struct SingleLine sl;
517 fschmid 1293
                                        sl.Color = MuL.attribute("Color");
4026 craig 1294
                                        sl.Dash = MuL.attribute("Dash").toInt();
1295
                                        sl.LineEnd = MuL.attribute("LineEnd").toInt();
1296
                                        sl.LineJoin = MuL.attribute("LineJoin").toInt();
1297
                                        sl.Shade = MuL.attribute("Shade").toInt();
1298
                                        sl.Width = MuL.attribute("Width").toDouble();
517 fschmid 1299
                                        ml.push_back(sl);
1300
                                        MuLn = MuLn.nextSibling();
1301
                                }
1302
                                doc->MLineStyles.insert(pg.attribute("Name"), ml);
1303
                        }
741 fschmid 1304
                        if(pg.tagName()=="Arrows")
1305
                        {
1065 cbradney 1306
                                struct ArrowDesc arrow;
760 fschmid 1307
                                arrow.name = pg.attribute("Name");
776 fschmid 1308
                                arrow.userArrow = true;
741 fschmid 1309
                                double xa, ya;
1310
                                QString tmp = pg.attribute("Points");
1311
                                QTextStream fp(&tmp, IO_ReadOnly);
1312
                                for (uint cx = 0; cx < pg.attribute("NumPoints").toUInt(); ++cx)
1313
                                {
1314
                                        fp >> xa;
1315
                                        fp >> ya;
760 fschmid 1316
                                        arrow.points.addPoint(xa, ya);
741 fschmid 1317
                                }
1318
                                doc->arrowStyles.append(arrow);
1319
                        }
1642 cbradney 1320
                        if(pg.tagName()=="PDF")
1321
                        {
4026 craig 1322
                                doc->PDF_Options.Articles = static_cast<bool>(pg.attribute("Articles").toInt());
1323
                                doc->PDF_Options.Thumbnails = static_cast<bool>(pg.attribute("Thumbnails").toInt());
1324
                                doc->PDF_Options.Compress = static_cast<bool>(pg.attribute("Compress").toInt());
1325
                                doc->PDF_Options.CompressMethod = pg.attribute("CMethod", "0").toInt();
1326
                                doc->PDF_Options.Quality = pg.attribute("Quality", "0").toInt();
1327
                                doc->PDF_Options.RecalcPic = static_cast<bool>(pg.attribute("RecalcPic").toInt());
1328
                                doc->PDF_Options.Bookmarks = static_cast<bool>(pg.attribute("Bookmarks").toInt());
1642 cbradney 1329
                                if (pg.hasAttribute("MirrorH"))
4026 craig 1330
                                        doc->PDF_Options.MirrorH = static_cast<bool>(pg.attribute("MirrorH").toInt());
1642 cbradney 1331
                                else
1332
                                        doc->PDF_Options.MirrorH = false;
1333
                                if (pg.hasAttribute("MirrorV"))
4026 craig 1334
                                        doc->PDF_Options.MirrorV = static_cast<bool>(pg.attribute("MirrorV").toInt());
1642 cbradney 1335
                                else
1336
                                        doc->PDF_Options.MirrorV = false;
1337
                                if (pg.hasAttribute("RotateDeg"))
4026 craig 1338
                                        doc->PDF_Options.RotateDeg = pg.attribute("RotateDeg", "0").toInt();
1642 cbradney 1339
                                else
1340
                                        doc->PDF_Options.RotateDeg = 0;
4649 fschmid 1341
                                if (pg.hasAttribute("Clip"))
1342
                                        doc->PDF_Options.doClip = static_cast<bool>(pg.attribute("Clip").toInt());
1343
                                else
1344
                                        doc->PDF_Options.doClip = false;
4026 craig 1345
                                doc->PDF_Options.PresentMode = static_cast<bool>(pg.attribute("PresentMode").toInt());
1346
                                doc->PDF_Options.PicRes = pg.attribute("PicRes").toInt();
1973 craig 1347
                                // Fixme: check input pdf version
4026 craig 1348
                                doc->PDF_Options.Version = (PDFOptions::PDFVersion)pg.attribute("Version").toInt();
1349
                                doc->PDF_Options.Resolution = pg.attribute("Resolution").toInt();
1350
                                doc->PDF_Options.Binding = pg.attribute("Binding").toInt();
1642 cbradney 1351
                                doc->PDF_Options.Datei = "";
4026 craig 1352
                                doc->PDF_Options.isGrayscale = static_cast<bool>(pg.attribute("Grayscale", "0").toInt());
1353
                                doc->PDF_Options.UseRGB = static_cast<bool>(pg.attribute("RGBMode", "0").toInt());
1354
                                doc->PDF_Options.UseProfiles = static_cast<bool>(pg.attribute("UseProfiles", "0").toInt());
1355
                                doc->PDF_Options.UseProfiles2 = static_cast<bool>(pg.attribute("UseProfiles2", "0").toInt());
1356
                                doc->PDF_Options.Intent = pg.attribute("Intent", "1").toInt();
1357
                                doc->PDF_Options.Intent2 = pg.attribute("Intent2", "1").toInt();
1642 cbradney 1358
                                doc->PDF_Options.SolidProf = pg.attribute("SolidP", "");
1359
                                doc->PDF_Options.ImageProf = pg.attribute("ImageP", "");
1360
                                doc->PDF_Options.PrintProf = pg.attribute("PrintP", "");
1361
                                doc->PDF_Options.Info = pg.attribute("InfoString", "");
4026 craig 1362
                                doc->PDF_Options.BleedTop = pg.attribute("BTop", "0").toDouble();
1363
                                doc->PDF_Options.BleedLeft = pg.attribute("BLeft", "0").toDouble();
1364
                                doc->PDF_Options.BleedRight = pg.attribute("BRight", "0").toDouble();
1365
                                doc->PDF_Options.BleedBottom = pg.attribute("BBottom", "0").toDouble();
1366
                                doc->PDF_Options.EmbeddedI = static_cast<bool>(pg.attribute("ImagePr", "0").toInt());
1642 cbradney 1367
                                doc->PDF_Options.PassOwner = pg.attribute("PassOwner", "");
1368
                                doc->PDF_Options.PassUser = pg.attribute("PassUser", "");
4026 craig 1369
                                doc->PDF_Options.Permissions = pg.attribute("Permissions", "-4").toInt();
1370
                                doc->PDF_Options.Encrypt = static_cast<bool>(pg.attribute("Encrypt", "0").toInt());
1371
                                doc->PDF_Options.useLayers = static_cast<bool>(pg.attribute("UseLayers", "0").toInt());
1372
                                doc->PDF_Options.UseLPI = static_cast<bool>(pg.attribute("UseLpi", "0").toInt());
4201 fschmid 1373
                                doc->PDF_Options.UseSpotColors = static_cast<bool>(pg.attribute("UseSpotColors", "1").toInt());
1374
                                doc->PDF_Options.doMultiFile = static_cast<bool>(pg.attribute("doMultiFile", "0").toInt());
1375
                                doc->PDF_Options.displayBookmarks = static_cast<bool>(pg.attribute("displayBookmarks", "0").toInt());
1376
                                doc->PDF_Options.displayFullscreen = static_cast<bool>(pg.attribute("displayFullscreen", "0").toInt());
1377
                                doc->PDF_Options.displayLayers = static_cast<bool>(pg.attribute("displayLayers", "0").toInt());
1378
                                doc->PDF_Options.displayThumbs = static_cast<bool>(pg.attribute("displayThumbs", "0").toInt());
1379
                                doc->PDF_Options.hideMenuBar = static_cast<bool>(pg.attribute("hideMenuBar", "0").toInt());
1380
                                doc->PDF_Options.hideToolBar = static_cast<bool>(pg.attribute("hideToolBar", "0").toInt());
1381
                                doc->PDF_Options.fitWindow = static_cast<bool>(pg.attribute("fitWindow", "0").toInt());
1382
                                doc->PDF_Options.PageLayout = pg.attribute("PageLayout", "0").toInt();
1383
                                doc->PDF_Options.openAction = pg.attribute("openAction", "");
1642 cbradney 1384
                                QDomNode PFO = PAGE.firstChild();
1385
                                while(!PFO.isNull())
1386
                                {
1387
                                        QDomElement pdfF = PFO.toElement();
1388
                                        if(pdfF.tagName() == "LPI")
1389
                                        {
1390
                                                struct LPIData lpo;
4026 craig 1391
                                                lpo.Angle = pdfF.attribute("Angle").toInt();
1392
                                                lpo.Frequency = pdfF.attribute("Frequency").toInt();
1393
                                                lpo.SpotFunc = pdfF.attribute("SpotFunction").toInt();
1642 cbradney 1394
                                                doc->PDF_Options.LPISettings[pdfF.attribute("Color")] = lpo;
1395
                                        }
1396
                                        if(pdfF.tagName() == "Fonts")
1397
                                        {
1398
                                                if (!doc->PDF_Options.EmbedList.contains(pdfF.attribute("Name")))
1399
                                                        doc->PDF_Options.EmbedList.append(pdfF.attribute("Name"));
1400
                                        }
1401
                                        if(pdfF.tagName() == "Subset")
1402
                                        {
1403
                                                if (!doc->PDF_Options.SubsetList.contains(pdfF.attribute("Name")))
1404
                                                        doc->PDF_Options.SubsetList.append(pdfF.attribute("Name"));
1405
                                        }
1406
                                        if(pdfF.tagName() == "Effekte")
1407
                                        {
1408
                                                struct PDFPresentationData ef;
4026 craig 1409
                                                ef.pageEffectDuration = pdfF.attribute("pageEffectDuration").toInt();
1410
                                                ef.pageViewDuration = pdfF.attribute("pageViewDuration").toInt();
1411
                                                ef.effectType = pdfF.attribute("effectType").toInt();
1412
                                                ef.Dm = pdfF.attribute("Dm").toInt();
1413
                                                ef.M = pdfF.attribute("M").toInt();
1414
                                                ef.Di = pdfF.attribute("Di").toInt();
1642 cbradney 1415
                                                doc->PDF_Options.PresentVals.append(ef);
1416
                                        }
1417
                                        PFO = PFO.nextSibling();
1418
                                }
1419
                        }
1420
                        if(pg.tagName()=="DocItemAttributes")
1421
                        {
1422
                                QDomNode DIA = PAGE.firstChild();
1423
                                doc->docItemAttributes.clear();
1424
                                while(!DIA.isNull())
1425
                                {
1426
                                        QDomElement itemAttr = DIA.toElement();
1427
                                        if(itemAttr.tagName() == "ItemAttribute")
1428
                                        {
1429
                                                ObjectAttribute objattr;
1430
                                                objattr.name=itemAttr.attribute("Name");
1431
                                                objattr.type=itemAttr.attribute("Type");
1432
                                                objattr.value=itemAttr.attribute("Value");
1433
                                                objattr.parameter=itemAttr.attribute("Parameter");
1654 cbradney 1434
                                                objattr.relationship=itemAttr.attribute("Relationship");
1435
                                                objattr.relationshipto=itemAttr.attribute("RelationshipTo");
1436
                                                objattr.autoaddto=itemAttr.attribute("AutoAddTo");
1649 cbradney 1437
                                                doc->docItemAttributes.append(objattr);
1642 cbradney 1438
                                        }
1439
                                        DIA = DIA.nextSibling();
1440
                                }
1441
                        }
1694 cbradney 1442
                        if(pg.tagName()=="TablesOfContents")
1443
                        {
1444
                                QDomNode TOC = PAGE.firstChild();
1445
                                doc->docToCSetups.clear();
1446
                                while(!TOC.isNull())
1447
                                {
1448
                                        QDomElement tocElem = TOC.toElement();
1449
                                        if(tocElem.tagName() == "TableOfContents")
1450
                                        {
1451
                                                ToCSetup tocsetup;
1452
                                                tocsetup.name=tocElem.attribute("Name");
1453
                                                tocsetup.itemAttrName=tocElem.attribute("ItemAttributeName");
1454
                                                tocsetup.frameName=tocElem.attribute("FrameName");
2449 cbradney 1455
                                                tocsetup.listNonPrintingFrames=tocElem.attribute("ListNonPrinting");
2445 cbradney 1456
                                                tocsetup.textStyle=tocElem.attribute("Style");
1457
                                                QString numberPlacement=tocElem.attribute("NumberPlacement");
1458
                                                if (numberPlacement=="Beginning")
1459
                                                        tocsetup.pageLocation=Beginning;
1460
                                                if (numberPlacement=="End")
1461
                                                        tocsetup.pageLocation=End;
1462
                                                if (numberPlacement=="NotShown")
1463
                                                        tocsetup.pageLocation=NotShown;
1694 cbradney 1464
                                                doc->docToCSetups.append(tocsetup);
1465
                                        }
1466
                                        TOC = TOC.nextSibling();
1467
                                }
1468
                        }
3757 cbradney 1469
                        if(pg.tagName()=="Sections")
1470
                        {
1471
                                QDomNode Section = PAGE.firstChild();
1472
                                while(!Section.isNull())
1473
                                {
1474
                                        QDomElement sectionElem = Section.toElement();
1475
                                        if(sectionElem.tagName() == "Section")
1476
                                        {
1477
                                                struct DocumentSection newSection;
4026 craig 1478
                                                newSection.number=sectionElem.attribute("Number").toInt();
3757 cbradney 1479
                                                newSection.name=sectionElem.attribute("Name");
4026 craig 1480
                                                newSection.fromindex=sectionElem.attribute("From").toInt();
1481
                                                newSection.toindex=sectionElem.attribute("To").toInt();
3757 cbradney 1482
                                                if (sectionElem.attribute("Type")=="Type_1_2_3")
1483
                                                        newSection.type=Type_1_2_3;
1484
                                                if (sectionElem.attribute("Type")=="Type_i_ii_iii")
1485
                                                        newSection.type=Type_i_ii_iii;
1486
                                                if (sectionElem.attribute("Type")=="Type_I_II_III")
1487
                                                        newSection.type=Type_I_II_III;
1488
                                                if (sectionElem.attribute("Type")=="Type_a_b_c")
1489
                                                        newSection.type=Type_a_b_c;
1490
                                                if (sectionElem.attribute("Type")=="Type_A_B_C")
1491
                                                        newSection.type=Type_A_B_C;
4026 craig 1492
                                                newSection.sectionstartindex=sectionElem.attribute("Start").toInt();
1493
                                                newSection.reversed=static_cast<bool>(sectionElem.attribute("Reversed").toInt());
1494
                                                newSection.active=static_cast<bool>(sectionElem.attribute("Active").toInt());
3757 cbradney 1495
                                                doc->sections.insert(newSection.number, newSection);
1496
                                        }
1497
                                        Section = Section.nextSibling();
1498
                                }
1499
                        }
517 fschmid 1500
                        if ((pg.tagName()=="PAGE") || (pg.tagName()=="MASTERPAGE"))
1501
                        {
4026 craig 1502
                                a = pg.attribute("NUM").toInt();
517 fschmid 1503
                                PgNam = "";
1504
                                PgNam = pg.attribute("NAM", "");
3757 cbradney 1505
                                //Pgc = doc->pageCount;
1506
                                //AtFl = doc->usesAutomaticTextFrames();
2877 cbradney 1507
                                if (PgNam.isEmpty())
517 fschmid 1508
                                {
3757 cbradney 1509
                                        //doc->pageCount = Pgc;
3724 cbradney 1510
                                        //doc->Pages = &doc->DocPages;
3757 cbradney 1511
                                        //doc->setUsesAutomaticTextFrames(AtFl);
3724 cbradney 1512
                                        doc->setMasterPageMode(false);
517 fschmid 1513
                                }
1514
                                else
1515
                                {
3757 cbradney 1516
                                        //doc->pageCount = 0;
1517
                                        //doc->setUsesAutomaticTextFrames(false);
3724 cbradney 1518
                                        //doc->Pages = &doc->MasterPages;
1519
                                        doc->setMasterPageMode(true);
517 fschmid 1520
                                }
4546 subik 1521
                                //CB: Stop calling damn GUI code in loading docs! IT doesnt *look* like
3648 cbradney 1522
                                //this makes a difference apart from being faster, of course.
4026 craig 1523
                                //ScMW->slotNewPage(a);
3648 cbradney 1524
                                //Apage = doc->Pages.at(a);
2877 cbradney 1525
                                if (PgNam.isEmpty())
2109 fschmid 1526
                                {
3757 cbradney 1527
                                        Apage = doc->addPage(a);
3724 cbradney 1528
                                        //doc->DocPages = doc->Pages;
4069 craig 1529
                                        //++doc->pageCount;
2109 fschmid 1530
                                }
517 fschmid 1531
                                else
1532
                                {
3757 cbradney 1533
                                        Apage = doc->addMasterPage(a, PgNam);
1534
                                        //Apage->setPageName(PgNam);
1535
                                        //doc->MasterNames[PgNam] = a;
3724 cbradney 1536
                                        //doc->MasterPages = doc->Pages;
3757 cbradney 1537
                                        //doc->pageCount = Pgc;
517 fschmid 1538
                                }
3757 cbradney 1539
                                //doc->setUsesAutomaticTextFrames(AtFl);
4026 craig 1540
                                Apage->LeftPg=pg.attribute("LEFT", "0").toInt();
517 fschmid 1541
                                QString Mus = "";
1542
                                Mus = pg.attribute("MNAM","Normal");
3724 cbradney 1543
                                if (!doc->masterPageMode())
517 fschmid 1544
                                        Apage->MPageNam = Mus;
1545
                                else
1546
                                        Apage->MPageNam = "";
2880 fschmid 1547
                                if (pg.hasAttribute("Size"))
1548
                                        Apage->PageSize = pg.attribute("Size");
1549
                                if (pg.hasAttribute("Orientation"))
4026 craig 1550
                                        Apage->PageOri = pg.attribute("Orientation").toInt();
1551
                                Apage->setXOffset(pg.attribute("PAGEXPOS").toDouble());
1552
                                Apage->setYOffset(pg.attribute("PAGEYPOS").toDouble());
2305 cbradney 1553
                                if (pg.hasAttribute("PAGEWIDTH"))
4026 craig 1554
                                        Apage->setWidth(pg.attribute("PAGEWIDTH").toDouble());
2305 cbradney 1555
                                else
4026 craig 1556
                                        Apage->setWidth(pg.attribute("PAGEWITH").toDouble());
1557
                                Apage->setHeight(pg.attribute("PAGEHEIGHT").toDouble());
3200 cbradney 1558
                                Apage->setInitialHeight(Apage->height());
1559
                                Apage->setInitialWidth(Apage->width());
4595 fschmid 1560
                                Apage->initialMargins.Top = QMAX(0.0, pg.attribute("BORDERTOP").toDouble());
1561
                                Apage->initialMargins.Bottom = QMAX(0.0, pg.attribute("BORDERBOTTOM").toDouble());
1562
                                Apage->initialMargins.Left = QMAX(0.0, pg.attribute("BORDERLEFT").toDouble());
1563
                                Apage->initialMargins.Right = QMAX(0.0, pg.attribute("BORDERRIGHT").toDouble());
2777 fschmid 1564
                                Apage->Margins.Top = Apage->initialMargins.Top;
1565
                                Apage->Margins.Bottom = Apage->initialMargins.Bottom;
3724 cbradney 1566
                                doc->setMasterPageMode(false);
1567
                                //doc->Pages=&doc->DocPages;
4026 craig 1568
                                if ((pg.hasAttribute("NumVGuides")) && (pg.attribute("NumVGuides", "0").toInt() != 0))
517 fschmid 1569
                                {
1570
                                        tmp = pg.attribute("VerticalGuides");
1571
                                        QTextStream fgv(&tmp, IO_ReadOnly);
1572
                                        Apage->YGuides.clear();
4026 craig 1573
                                        for (int cxv = 0; cxv < pg.attribute("NumVGuides", "0").toInt(); ++cxv)
517 fschmid 1574
                                        {
1575
                                                fgv >> xf;
1576
                                                Apage->YGuides.append(xf);
1577
                                        }
1578
                                        qHeapSort(Apage->YGuides);
1579
                                        tmp = "";
1580
                                }
1581
                                else
1582
                                        Apage->YGuides.clear();
4026 craig 1583
                                if ((pg.hasAttribute("NumHGuides")) && (pg.attribute("NumHGuides", "0").toInt() != 0))
517 fschmid 1584
                                {
1585
                                        tmp = pg.attribute("HorizontalGuides");
1586
                                        QTextStream fgh(&tmp, IO_ReadOnly);
1587
                                        Apage->XGuides.clear();
4026 craig 1588
                                        for (int cxh = 0; cxh < pg.attribute("NumHGuides", "0").toInt(); ++cxh)
517 fschmid 1589
                                        {
1590
                                                fgh >> xf;
1591
                                                Apage->XGuides.append(xf);
1592
                                        }
1593
                                        qHeapSort(Apage->XGuides);
1594
                                        tmp = "";
1595
                                }
1596
                                else
1597
                                        Apage->XGuides.clear();
1800 cbradney 1598
                        }
2447 fschmid 1599
                        if ((pg.tagName()=="PAGEOBJECT") || (pg.tagName()=="MASTEROBJECT") || (pg.tagName()=="FRAMEOBJECT"))
517 fschmid 1600
                        {
2447 fschmid 1601
                                        if ((pg.tagName()=="PAGEOBJECT") || (pg.tagName()=="FRAMEOBJECT"))
522 fschmid 1602
                                        {
3727 cbradney 1603
                                                //doc->Items = doc->DocItems;
3724 cbradney 1604
                                                //doc->Pages = &doc->DocPages;
1605
                                                doc->setMasterPageMode(false);
522 fschmid 1606
                                        }
517 fschmid 1607
                                        else
522 fschmid 1608
                                        {
3727 cbradney 1609
                                                //doc->Items = doc->MasterItems;
3724 cbradney 1610
                                                //doc->Pages = &doc->MasterPages;
1611
                                                doc->setMasterPageMode(true);
522 fschmid 1612
                                        }
2877 cbradney 1613
                                        if ((!pg.attribute("OnMasterPage").isEmpty()) && (pg.tagName()=="MASTEROBJECT"))
1065 cbradney 1614
                                                doc->currentPage = doc->MasterPages.at(doc->MasterNames[pg.attribute("OnMasterPage")]);
7708 avox 1615
 
1616
                                if (pg.tagName()=="PAGEOBJECT")
1617
                                {
1618
                                        itemRemap[itemCount++] = doc->Items->count();
1619
                                        // member of linked chain?
1620
                                        if ((pg.attribute("NEXTITEM").toInt() != -1) )
517 fschmid 1621
                                        {
7708 avox 1622
                                                itemNext[doc->Items->count()] = pg.attribute("NEXTITEM").toInt();
517 fschmid 1623
                                        }
7708 avox 1624
                                }
1779 fschmid 1625
                                        int docGc = doc->GroupCounter;
1626
                                        doc->GroupCounter = 0;
3657 cbradney 1627
                                        Neu = PasteItem(&pg, doc);
1628
                                        Neu->setRedrawBounding();
4784 fschmid 1629
                                        if (pg.tagName()=="MASTEROBJECT")
1630
                                                Neu->OwnPage = doc->OnPage(Neu);
1631
                                        else
1632
                                                Neu->OwnPage = pg.attribute("OwnPage").toInt();
1786 fschmid 1633
                                        if (pg.tagName()=="PAGEOBJECT")
1634
                                                Neu->OnMasterPage = "";
1779 fschmid 1635
                                        doc->GroupCounter = docGc;
1194 fschmid 1636
                                        tmpf = pg.attribute("IFONT", doc->toolSettings.defFont);
1428 fschmid 1637
                                        if ((!avail.find(tmpf)) || (!avail[tmpf]->UseFont))
1638
                                        {
3650 cbradney 1639
                                                if ((!prefsManager->appPrefs.GFontSub.contains(tmpf)) || (!avail[prefsManager->appPrefs.GFontSub[tmpf]]->UseFont))
1468 fschmid 1640
                                                {
1641
                                                        newReplacement = true;
3650 cbradney 1642
                                                        ReplacedFonts.insert(tmpf, prefsManager->appPrefs.toolSettings.defFont);
1468 fschmid 1643
                                                }
1428 fschmid 1644
                                                else
3650 cbradney 1645
                                                        ReplacedFonts.insert(tmpf, prefsManager->appPrefs.GFontSub[tmpf]);
1428 fschmid 1646
                                        }
517 fschmid 1647
                                        else
1428 fschmid 1648
                                        {
1786 fschmid 1649
                                                if (!doc->UsedFonts.contains(tmpf))
1650
                                                {
3544 avox 1651
//                                                      QFont fo = avail[tmpf]->Font;
1652
//                                                      fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
1653
                                                        doc->AddFont(tmpf, qRound(doc->toolSettings.defSize / 10.0));
1786 fschmid 1654
                                                }
1428 fschmid 1655
                                        }
4073 cbradney 1656
                                        Neu->setFont(tmpf);
517 fschmid 1657
                                        QDomNode IT=pg.firstChild();
1658
                                        while(!IT.isNull())
1659
                                        {
1660
                                                QDomElement it=IT.toElement();
1661
                                                if (it.tagName()=="CSTOP")
1662
                                                {
1663
                                                        QString name = it.attribute("NAME");
4026 craig 1664
                                                        double ramp = it.attribute("RAMP", "0.0").toDouble();
1665
                                                        int shade = it.attribute("SHADE", "100").toInt();
1666
                                                        double opa = it.attribute("TRANS", "1").toDouble();
1779 fschmid 1667
                                                        Neu->fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
517 fschmid 1668
                                                }
1669
                                                if (it.tagName()=="ITEXT")
2834 cbradney 1670
                                                        GetItemText(&it, doc, Neu);
4546 subik 1671
 
1655 cbradney 1672
                                                //CB PageItemAttributes
1673
                                                if(it.tagName()=="PageItemAttributes")
1674
                                                {
1675
                                                        QDomNode PIA = it.firstChild();
1676
                                                        ObjAttrVector pageItemAttributes;
1677
                                                        while(!PIA.isNull())
1678
                                                        {
1679
                                                                QDomElement itemAttr = PIA.toElement();
1680
                                                                if(itemAttr.tagName() == "ItemAttribute")
1681
                                                                {
1682
                                                                        ObjectAttribute objattr;
1683
                                                                        objattr.name=itemAttr.attribute("Name");
1684
                                                                        objattr.type=itemAttr.attribute("Type");
1685
                                                                        objattr.value=itemAttr.attribute("Value");
1686
                                                                        objattr.parameter=itemAttr.attribute("Parameter");