Subversion Repositories Scribus

Rev

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