Subversion Repositories Scribus

Rev

Rev 4672 | 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
 
3644 craig 226
bool FileLoader::LoadPage(int PageToLoad, bool Mpage)
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:
4026 craig 248
                        ret = ReadPage(FileName, prefsManager->appPrefs.AvailFonts, ScMW->doc, PageToLoad, Mpage);
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
 
3657 cbradney 404
bool FileLoader::ReadPage(const QString & fileName, SCFonts &avail, ScribusDoc *doc, int PageToLoad, bool Mpage)
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();
3197 fschmid 579
                                        Apage->setPageName(pg.attribute("NAM",""));
580
                                }
581
                                if (pg.hasAttribute("Size"))
582
                                        Apage->PageSize = pg.attribute("Size");
583
                                if (pg.hasAttribute("Orientation"))
4026 craig 584
                                        Apage->PageOri = pg.attribute("Orientation").toInt();
3197 fschmid 585
                                if (pg.hasAttribute("PAGEWIDTH"))
4026 craig 586
                                        Apage->setWidth(pg.attribute("PAGEWIDTH").toDouble());
3197 fschmid 587
                                else
4026 craig 588
                                        Apage->setWidth(pg.attribute("PAGEWITH").toDouble());
589
                                Apage->setHeight(pg.attribute("PAGEHEIGHT").toDouble());
3200 cbradney 590
                                Apage->setInitialHeight(Apage->height());
591
                                Apage->setInitialWidth(Apage->width());
4595 fschmid 592
                                Apage->initialMargins.Top = QMAX(0.0, pg.attribute("BORDERTOP").toDouble());
593
                                Apage->initialMargins.Bottom = QMAX(0.0, pg.attribute("BORDERBOTTOM").toDouble());
594
                                Apage->initialMargins.Left = QMAX(0.0, pg.attribute("BORDERLEFT").toDouble());
595
                                Apage->initialMargins.Right = QMAX(0.0, pg.attribute("BORDERRIGHT").toDouble());
3197 fschmid 596
                                Apage->Margins.Top = Apage->initialMargins.Top;
597
                                Apage->Margins.Bottom = Apage->initialMargins.Bottom;
4026 craig 598
                                pageX = pg.attribute("PAGEXPOS").toDouble();
599
                                pageY = pg.attribute("PAGEYPOS").toDouble();
600
                                if ((pg.hasAttribute("NumVGuides")) && (pg.attribute("NumVGuides", "0").toInt() != 0))
3197 fschmid 601
                                {
602
                                        tmp = pg.attribute("VerticalGuides");
603
                                        QTextStream fgv(&tmp, IO_ReadOnly);
604
                                        Apage->YGuides.clear();
4026 craig 605
                                        for (int cxv = 0; cxv < pg.attribute("NumVGuides", "0").toInt(); ++cxv)
3197 fschmid 606
                                        {
607
                                                fgv >> xf;
608
                                                Apage->YGuides.append(xf);
609
                                        }
610
                                        qHeapSort(Apage->YGuides);
611
                                        tmp = "";
612
                                }
4026 craig 613
                                if ((pg.hasAttribute("NumHGuides")) && (pg.attribute("NumHGuides", "0").toInt() != 0))
3197 fschmid 614
                                {
615
                                        tmp = pg.attribute("HorizontalGuides");
616
                                        QTextStream fgh(&tmp, IO_ReadOnly);
617
                                        Apage->XGuides.clear();
4026 craig 618
                                        for (int cxh = 0; cxh < pg.attribute("NumHGuides", "0").toInt(); ++cxh)
3197 fschmid 619
                                        {
620
                                                fgh >> xf;
621
                                                Apage->XGuides.append(xf);
622
                                        }
623
                                        qHeapSort(Apage->XGuides);
624
                                        tmp = "";
625
                                }
626
                        }
627
                        if ((pg.tagName()=="PAGEOBJECT") || (pg.tagName()=="MASTEROBJECT") || (pg.tagName()=="FRAMEOBJECT"))
628
                        {
629
                                if ((pg.tagName()!="MASTEROBJECT") && (Mpage))
630
                                {
631
                                        PAGE=PAGE.nextSibling();
632
                                        continue;
633
                                }
4026 craig 634
                                if (pg.attribute("OwnPage").toInt() == PageToLoad)
3197 fschmid 635
                                {
4026 craig 636
                                        if (pg.attribute("NEXTITEM").toInt() != -1)
3197 fschmid 637
                                        {
4026 craig 638
                                                if (pg.attribute("BACKITEM").toInt() == -1)
3727 cbradney 639
                                                        LFrames.append(doc->Items->count());
3197 fschmid 640
                                        }
641
                                        int docGc = doc->GroupCounter;
642
                                        doc->GroupCounter = 0;
3657 cbradney 643
                                        Neu = PasteItem(&pg, doc);
3934 cbradney 644
                                        Neu->moveBy(-pageX + Apage->xOffset(), - pageY + Apage->yOffset());
3656 cbradney 645
                                        //view->setRedrawBounding(Neu);
646
                                        Neu->setRedrawBounding();
4651 cbradney 647
                                        //CB Must run onpage as we cant use pagetoload if the page has been renamed. 
4616 cbradney 648
                                        //CB TODO Make this accept a page to place onto.
4675 cbradney 649
                                        //Neu->OwnPage = doc->OnPage(Neu);
650
                                        Neu->OwnPage = PageToLoad;
3197 fschmid 651
                                        if (pg.tagName()=="PAGEOBJECT")
652
                                                Neu->OnMasterPage = "";
653
                                        doc->GroupCounter = docGc;
654
                                        tmpf = pg.attribute("IFONT", doc->toolSettings.defFont);
655
                                        if ((!avail.find(tmpf)) || (!avail[tmpf]->UseFont))
656
                                        {
3650 cbradney 657
                                                if ((!prefsManager->appPrefs.GFontSub.contains(tmpf)) || (!avail[prefsManager->appPrefs.GFontSub[tmpf]]->UseFont))
3197 fschmid 658
                                                {
659
                                                        newReplacement = true;
3650 cbradney 660
                                                        ReplacedFonts.insert(tmpf, prefsManager->appPrefs.toolSettings.defFont);
3197 fschmid 661
                                                }
662
                                                else
3650 cbradney 663
                                                        ReplacedFonts.insert(tmpf, prefsManager->appPrefs.GFontSub[tmpf]);
3197 fschmid 664
                                        }
665
                                        else
666
                                        {
667
                                                if (!doc->UsedFonts.contains(tmpf))
668
                                                {
3544 avox 669
//                                                      QFont fo = avail[tmpf]->Font;
670
//                                                      fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
671
                                                        doc->AddFont(tmpf, qRound(doc->toolSettings.defSize / 10.0));
3197 fschmid 672
                                                }
673
                                        }
4073 cbradney 674
                                        Neu->setFont(tmpf);
3197 fschmid 675
                                        QDomNode IT=pg.firstChild();
676
                                        while(!IT.isNull())
677
                                        {
678
                                                QDomElement it=IT.toElement();
679
                                                if (it.tagName()=="CSTOP")
680
                                                {
681
                                                        QString name = it.attribute("NAME");
4026 craig 682
                                                        double ramp = it.attribute("RAMP", "0.0").toDouble();
683
                                                        int shade = it.attribute("SHADE", "100").toInt();
684
                                                        double opa = it.attribute("TRANS", "1").toDouble();
3197 fschmid 685
                                                        Neu->fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
686
                                                }
687
                                                if (it.tagName()=="ITEXT")
688
                                                        GetItemText(&it, doc, Neu, true, VorLFound);
689
                                                if(it.tagName()=="PageItemAttributes")
690
                                                {
691
                                                        QDomNode PIA = it.firstChild();
692
                                                        ObjAttrVector pageItemAttributes;
693
                                                        while(!PIA.isNull())
694
                                                        {
695
                                                                QDomElement itemAttr = PIA.toElement();
696
                                                                if(itemAttr.tagName() == "ItemAttribute")
697
                                                                {
698
                                                                        ObjectAttribute objattr;
699
                                                                        objattr.name=itemAttr.attribute("Name");
700
                                                                        objattr.type=itemAttr.attribute("Type");
701
                                                                        objattr.value=itemAttr.attribute("Value");
702
                                                                        objattr.parameter=itemAttr.attribute("Parameter");
703
                                                                        objattr.relationship=itemAttr.attribute("Relationship");
704
                                                                        objattr.relationshipto=itemAttr.attribute("RelationshipTo");
705
                                                                        objattr.autoaddto=itemAttr.attribute("AutoAddTo");
706
                                                                        pageItemAttributes.append(objattr);
707
                                                                }
708
                                                                PIA = PIA.nextSibling();
709
                                                        }
710
                                                        Neu->setObjectAttributes(&pageItemAttributes);
711
                                                }
712
                                                IT=IT.nextSibling();
713
                                        }
714
                                        if (Neu->fill_gradient.Stops() == 0)
715
                                        {
716
                                                Neu->fill_gradient.addStop(doc->PageColors[doc->toolSettings.dBrush].getRGBColor(), 0.0, 0.5, 1.0, doc->toolSettings.dBrush, 100);
717
                                                Neu->fill_gradient.addStop(doc->PageColors[doc->toolSettings.dPen].getRGBColor(), 1.0, 0.5, 1.0, doc->toolSettings.dPen, 100);
718
                                        }
4026 craig 719
//                                      Neu->Language = ScMW->GetLang(pg.attribute("LANGUAGE", doc->Language));
3197 fschmid 720
                                        Neu->Language = doc->Language;
4026 craig 721
                                        Neu->isAutoText = static_cast<bool>(pg.attribute("AUTOTEXT").toInt());
722
                                        Neu->isEmbedded = static_cast<bool>(pg.attribute("isInline", "0").toInt());
723
                                        Neu->gXpos = pg.attribute("gXpos", "0.0").toDouble();
724
                                        Neu->gYpos = pg.attribute("gYpos", "0.0").toDouble();
3197 fschmid 725
                                        QString defaultVal;
3934 cbradney 726
                                        defaultVal.setNum(Neu->width());
4026 craig 727
                                        Neu->gWidth = pg.attribute("gWidth",defaultVal).toDouble();
3934 cbradney 728
                                        defaultVal.setNum(Neu->height());
4026 craig 729
                                        Neu->gHeight = pg.attribute("gHeight",defaultVal).toDouble();
4584 cbradney 730
                                        if (Neu->lineSpacingMode() == 3)
3197 fschmid 731
                                        {
732
                                                doc->docParagraphStyles[0].BaseAdj = true;
4584 cbradney 733
                                                Neu->setLineSpacing(doc->typographicSettings.valueBaseGrid-1);
3197 fschmid 734
                                        }
735
                                        if (Neu->isAutoText)
736
                                                doc->LastAuto = Neu;
4026 craig 737
                                        Neu->NextIt = baseobj + pg.attribute("NEXTITEM").toInt();
3197 fschmid 738
                                        if (Neu->isTableItem)
739
                                        {
740
                                                TableItems.append(Neu);
4026 craig 741
                                                TableID.insert(pg.attribute("OwnLINK", "0").toInt(), Neu->ItemNr);
3197 fschmid 742
                                        }
743
                                        if (pg.tagName()=="FRAMEOBJECT")
744
                                        {
3727 cbradney 745
                                                doc->FrameItems.append(doc->Items->take(Neu->ItemNr));
3197 fschmid 746
                                                Neu->ItemNr = doc->FrameItems.count()-1;
747
                                        }
748
                                }
749
                                counter++;
750
                        }
751
                        PAGE=PAGE.nextSibling();
752
                }
753
                DOC=DOC.nextSibling();
754
        }
755
        if (TableItems.count() != 0)
756
        {
757
                for (uint ttc = 0; ttc < TableItems.count(); ++ttc)
758
                {
759
                        PageItem* ta = TableItems.at(ttc);
760
                        if (ta->TopLinkID != -1)
3727 cbradney 761
                                ta->TopLink = doc->Items->at(TableID[ta->TopLinkID]);
3197 fschmid 762
                        else
763
                                ta->TopLink = 0;
764
                        if (ta->LeftLinkID != -1)
3727 cbradney 765
                                ta->LeftLink = doc->Items->at(TableID[ta->LeftLinkID]);
3197 fschmid 766
                        else
767
                                ta->LeftLink = 0;
768
                        if (ta->RightLinkID != -1)
3727 cbradney 769
                                ta->RightLink = doc->Items->at(TableID[ta->RightLinkID]);
3197 fschmid 770
                        else
771
                                ta->RightLink = 0;
772
                        if (ta->BottomLinkID != -1)
3727 cbradney 773
                                ta->BottomLink = doc->Items->at(TableID[ta->BottomLinkID]);
3197 fschmid 774
                        else
775
                                ta->BottomLink = 0;
776
                }
777
        }
778
        if (LFrames.count() != 0)
779
        {
780
                PageItem *Its;
781
                PageItem *Itn;
782
                PageItem *Itr;
783
                QValueList<int>::Iterator lc;
784
                for (lc = LFrames.begin(); lc != LFrames.end(); ++lc)
785
                {
3727 cbradney 786
                        Its = doc->Items->at((*lc));
3197 fschmid 787
                        Itr = Its;
788
                        Its->BackBox = 0;
789
                        while (Its->NextIt != -1)
790
                        {
3727 cbradney 791
                                if (Its->NextIt < static_cast<int>(doc->Items->count()))
3197 fschmid 792
                                {
3727 cbradney 793
                                        Itn = doc->Items->at(Its->NextIt);
3197 fschmid 794
                                        Its->NextBox = Itn;
795
                                        Itn->BackBox = Its;
796
                                        Its = Itn;
797
                                }
798
                                else
799
                                        Its->NextIt = -1;
800
                        }
801
                        Its->NextBox = 0;
802
                }
803
        }
804
        return true;
805
}
806
 
3657 cbradney 807
bool FileLoader::ReadDoc(const QString & fileName, SCFonts &avail, ScribusDoc *doc, QProgressBar *dia2)
517 fschmid 808
{
1065 cbradney 809
        struct ParagraphStyle vg;
517 fschmid 810
        struct Layer la;
811
        struct ScribusDoc::BookMa bok;
3757 cbradney 812
        int counter;//, Pgc;
813
        //bool AtFl;
517 fschmid 814
        bool newVersion = false;
815
        QString tmp, tmpf, tmp2, tmp3, tmp4, PgNam, Defont, tmf;
816
        QFont fo;
817
        QMap<int,int> TableID;
818
        QPtrList<PageItem> TableItems;
1779 fschmid 819
        int a;
2282 fschmid 820
        double xf, xf2;
517 fschmid 821
        PageItem *Neu;
822
        Page* Apage;
823
        LFrames.clear();
824
        QDomDocument docu("scridoc");
3646 craig 825
        QString f(readSLA(fileName));
517 fschmid 826
        /* 2004/10/02 - petr vanek - bug #1092 - missing <PAGE> crash Scribus. The check constraint moved into IsScribus()
2680 cbradney 827
        FIXME: I've add test on containig tag PAGE but returning false freezes S. in scribus.cpp need some hack too...  */
517 fschmid 828
        if (!docu.setContent(f))
829
                return false;
1549 subik 830
        doc->PageColors.clear();
517 fschmid 831
        doc->Layers.clear();
3855 cbradney 832
        int layerToSetActive=0;
2886 fschmid 833
        ScColor lf = ScColor();
517 fschmid 834
        QDomElement elem=docu.documentElement();
835
        if (elem.tagName() != "SCRIBUSUTF8NEW")
836
                return false;
837
        if (elem.hasAttribute("Version"))
838
                newVersion = true;
839
        QDomNode DOC=elem.firstChild();
840
        dia2->setTotalSteps(DOC.childNodes().count());
841
        dia2->setProgress(0);
842
        int ObCount = 0;
843
        TableItems.clear();
844
        TableID.clear();
845
        while(!DOC.isNull())
846
        {
847
                QDomElement dc=DOC.toElement();
848
        /*
849
        * Attribute von DOCUMENT auslesen
850
        */
4546 subik 851
                //CB Add this in to set this in the file in memory. Its saved, why not load it.
1542 cbradney 852
                //Will of course be replaced by per page settings although we still probably need a document default
853
                doc->PageSize = dc.attribute("PAGESIZE");
4026 craig 854
                doc->PageOri = dc.attribute("ORIENTATION", "0").toInt();
855
                doc->FirstPnum = dc.attribute("FIRSTNUM", "1").toInt();
856
                doc->currentPageLayout=dc.attribute("BOOK", "0").toInt();
3016 fschmid 857
                int fp;
3035 fschmid 858
                if (doc->currentPageLayout == 0)
859
                        fp = 0;
2912 fschmid 860
                else
861
                {
4026 craig 862
                        if (dc.attribute("FIRSTLEFT", "0").toInt() == 1)
3016 fschmid 863
                                fp = 0;
2912 fschmid 864
                        else
3035 fschmid 865
                                fp = 1;
2912 fschmid 866
                }
3016 fschmid 867
                if (DOC.namedItem("PageSets").isNull())
868
                {
3032 fschmid 869
                        doc->pageSets[doc->currentPageLayout].FirstPage = fp;
4026 craig 870
                        doc->pageSets[doc->currentPageLayout].GapHorizontal = dc.attribute("GapHorizontal", "0").toDouble();
3032 fschmid 871
                        doc->pageSets[doc->currentPageLayout].GapVertical = 0.0;
4026 craig 872
                        doc->pageSets[doc->currentPageLayout].GapBelow = dc.attribute("GapVertical", "40").toDouble();
3016 fschmid 873
                }
4026 craig 874
                doc->setUsesAutomaticTextFrames(dc.attribute("AUTOTEXT").toInt());
875
                doc->PageSp=dc.attribute("AUTOSPALTEN").toInt();
876
                doc->PageSpa=dc.attribute("ABSTSPALTEN").toDouble();
877
                doc->setUnitIndex(dc.attribute("UNITS", "0").toInt());
878
                doc->toolSettings.defSize=qRound(dc.attribute("DSIZE").toDouble() * 10);
517 fschmid 879
                Defont=dc.attribute("DFONT");
1428 fschmid 880
                if ((!avail.find(Defont)) || (!avail[Defont]->UseFont))
517 fschmid 881
                {
3650 cbradney 882
                        ReplacedFonts.insert(Defont, prefsManager->appPrefs.toolSettings.defFont);
883
                        Defont = prefsManager->appPrefs.toolSettings.defFont;
517 fschmid 884
                }
885
                else
1428 fschmid 886
                {
3544 avox 887
//                      QFont fo = avail[Defont]->Font;
888
//                      fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
889
                        doc->AddFont(Defont, qRound(doc->toolSettings.defSize / 10.0));
1428 fschmid 890
                }
1194 fschmid 891
                doc->toolSettings.defFont = Defont;
4026 craig 892
                doc->toolSettings.dCols=dc.attribute("DCOL", "1").toInt();
893
                doc->toolSettings.dGap=dc.attribute("DGAP", "0.0").toDouble();
2024 cbradney 894
                doc->documentInfo.setAuthor(dc.attribute("AUTHOR"));
895
                doc->documentInfo.setComments(dc.attribute("COMMENTS"));
896
                doc->documentInfo.setKeywords(dc.attribute("KEYWORDS",""));
897
                doc->documentInfo.setTitle(dc.attribute("TITLE"));
898
                doc->documentInfo.setPublisher(dc.attribute("PUBLISHER", ""));
899
                doc->documentInfo.setDate(dc.attribute("DOCDATE", ""));
900
                doc->documentInfo.setType(dc.attribute("DOCTYPE", ""));
901
                doc->documentInfo.setFormat(dc.attribute("DOCFORMAT", ""));
902
                doc->documentInfo.setIdent(dc.attribute("DOCIDENT", ""));
903
                doc->documentInfo.setSource(dc.attribute("DOCSOURCE", ""));
904
                doc->documentInfo.setLangInfo(dc.attribute("DOCLANGINFO", ""));
905
                doc->documentInfo.setRelation(dc.attribute("DOCRELATION", ""));
906
                doc->documentInfo.setCover(dc.attribute("DOCCOVER", ""));
907
                doc->documentInfo.setRights(dc.attribute("DOCRIGHTS", ""));
908
                doc->documentInfo.setContrib(dc.attribute("DOCCONTRIB", ""));
4026 craig 909
                doc->typographicSettings.valueSuperScript = dc.attribute("VHOCH").toInt();
910
                doc->typographicSettings.scalingSuperScript = dc.attribute("VHOCHSC").toInt();
911
                doc->typographicSettings.valueSubScript = dc.attribute("VTIEF").toInt();
912
                doc->typographicSettings.scalingSubScript = dc.attribute("VTIEFSC").toInt();
913
                doc->typographicSettings.valueSmallCaps = dc.attribute("VKAPIT").toInt();
914
                doc->typographicSettings.valueBaseGrid = dc.attribute("BASEGRID", "12").toDouble();
915
                doc->typographicSettings.offsetBaseGrid = dc.attribute("BASEO", "0").toDouble();
916
                doc->typographicSettings.autoLineSpacing = dc.attribute("AUTOL", "20").toInt();
917
                doc->typographicSettings.valueUnderlinePos = dc.attribute("UnderlinePos", "-1").toInt();
918
                doc->typographicSettings.valueUnderlineWidth = dc.attribute("UnderlineWidth", "-1").toInt();
919
                doc->typographicSettings.valueStrikeThruPos = dc.attribute("StrikeThruPos", "-1").toInt();
920
                doc->typographicSettings.valueStrikeThruWidth = dc.attribute("StrikeThruWidth", "-1").toInt();
921
                doc->GroupCounter=dc.attribute("GROUPC", "1").toInt();
922
                doc->HasCMS = static_cast<bool>(dc.attribute("HCMS", "0").toInt());
923
                doc->CMSSettings.SoftProofOn = static_cast<bool>(dc.attribute("DPSo", "0").toInt());
924
                doc->CMSSettings.CMSinUse = static_cast<bool>(dc.attribute("DPuse", "0").toInt());
925
                doc->CMSSettings.GamutCheck = static_cast<bool>(dc.attribute("DPgam", "0").toInt());
926
                doc->CMSSettings.BlackPoint = static_cast<bool>(dc.attribute("DPbla", "1").toInt());
517 fschmid 927
                doc->CMSSettings.DefaultMonitorProfile = dc.attribute("DPMo","");
928
                doc->CMSSettings.DefaultPrinterProfile = dc.attribute("DPPr","");
2984 fschmid 929
                doc->CMSSettings.DefaultImageRGBProfile = dc.attribute("DPIn","");
930
                doc->CMSSettings.DefaultImageCMYKProfile = dc.attribute("DPInCMYK","");
931
                doc->CMSSettings.DefaultSolidColorProfile = dc.attribute("DPIn2","");
4026 craig 932
                doc->CMSSettings.DefaultIntentPrinter = dc.attribute("DIPr", "0").toInt();
933
                doc->CMSSettings.DefaultIntentMonitor = dc.attribute("DIMo", "1").toInt();
934
                doc->CMSSettings.DefaultIntentImages = dc.attribute("DIMo2", "1").toInt();
935
                layerToSetActive=dc.attribute("ALAYER", "0").toInt();
517 fschmid 936
                doc->Language = dc.attribute("LANGUAGE", "");
4026 craig 937
                doc->MinWordLen = dc.attribute("MINWORDLEN", "3").toInt();
938
                doc->HyCount = dc.attribute("HYCOUNT", "2").toInt();
2305 cbradney 939
                if (dc.hasAttribute("PAGEWIDTH"))
4026 craig 940
                        doc->pageWidth=dc.attribute("PAGEWIDTH").toDouble();
2305 cbradney 941
                else
4026 craig 942
                        doc->pageWidth=dc.attribute("PAGEWITH").toDouble();
943
                doc->pageHeight=dc.attribute("PAGEHEIGHT").toDouble();
4595 fschmid 944
                doc->pageMargins.Left=QMAX(0.0, dc.attribute("BORDERLEFT").toDouble());
945
                doc->pageMargins.Right=QMAX(0.0, dc.attribute("BORDERRIGHT").toDouble());
946
                doc->pageMargins.Top=QMAX(0.0, dc.attribute("BORDERTOP").toDouble());
947
                doc->pageMargins.Bottom=QMAX(0.0, dc.attribute("BORDERBOTTOM").toDouble());
4026 craig 948
                doc->Automatic = static_cast<bool>(dc.attribute("AUTOMATIC", "1").toInt());
949
                doc->AutoCheck = static_cast<bool>(dc.attribute("AUTOCHECK", "0").toInt());
950
                doc->GuideLock = static_cast<bool>(dc.attribute("GUIDELOCK", "0").toInt());
951
                doc->guidesSettings.minorGrid = dc.attribute("MINGRID", tmp.setNum(prefsManager->appPrefs.guidesSettings.minorGrid)).toDouble();
952
                doc->guidesSettings.majorGrid = dc.attribute("MAJGRID", tmp.setNum(prefsManager->appPrefs.guidesSettings.majorGrid)).toDouble();
953
                doc->guidesSettings.gridShown = static_cast<bool>(dc.attribute("SHOWGRID", "0").toInt());
954
                doc->guidesSettings.guidesShown = static_cast<bool>(dc.attribute("SHOWGUIDES", "1").toInt());
955
                doc->guidesSettings.framesShown = static_cast<bool>(dc.attribute("SHOWFRAME", "1").toInt());
956
                doc->guidesSettings.marginsShown = static_cast<bool>(dc.attribute("SHOWMARGIN", "1").toInt());
957
                doc->guidesSettings.baseShown = static_cast<bool>(dc.attribute("SHOWBASE", "0").toInt());
958
                doc->guidesSettings.showPic = static_cast<bool>(dc.attribute("SHOWPICT", "1").toInt());
959
                doc->guidesSettings.linkShown = static_cast<bool>(dc.attribute("SHOWLINK", "0").toInt());
960
                doc->guidesSettings.showControls = static_cast<bool>(dc.attribute("SHOWControl", "0").toInt());
961
                doc->guidesSettings.rulerMode = static_cast<bool>(dc.attribute("rulerMode", "1").toInt());
4651 cbradney 962
                doc->guidesSettings.rulersShown = static_cast<bool>(dc.attribute("showrulers", "1").toInt());
4026 craig 963
                doc->rulerXoffset = dc.attribute("rulerXoffset", "0").toDouble();
964
                doc->rulerYoffset =dc.attribute("rulerYoffset", "0").toDouble();
965
                doc->SnapGuides = static_cast<bool>(dc.attribute("SnapToGuides", "0").toInt());
966
                doc->useRaster = static_cast<bool>(dc.attribute("SnapToGrid", "0").toInt());
967
                doc->toolSettings.polyC = dc.attribute("POLYC", "4").toInt();
968
                doc->toolSettings.polyF = dc.attribute("POLYF", "0.5").toDouble();
969
                doc->toolSettings.polyR = dc.attribute("POLYR", "0").toDouble();
970
                doc->toolSettings.polyFd = dc.attribute("POLYFD", "0").toInt();
971
                doc->toolSettings.polyS = static_cast<bool>(dc.attribute("POLYS", "0").toInt());
972
                doc->AutoSave = static_cast<bool>(dc.attribute("AutoSave", "0").toInt());
973
                doc->AutoSaveTime = dc.attribute("AutoSaveTime", "600000").toInt();
974
                doc->ScratchBottom = dc.attribute("ScratchBottom", "20").toDouble();
1719 craig 975
                // FIXME A typo in early 1.3cvs (MAR 05) means we must support loading of
976
                // FIXME 'ScatchLeft' for a while too. This can be removed in a few months.
977
                if (dc.hasAttribute("ScatchLeft"))
4026 craig 978
                        doc->ScratchLeft = dc.attribute("ScatchLeft", "100").toDouble();
1719 craig 979
                else
4026 craig 980
                        doc->ScratchLeft = dc.attribute("ScratchLeft", "100").toDouble();
981
                doc->ScratchRight = dc.attribute("ScratchRight", "100").toDouble();
982
                doc->ScratchTop = dc.attribute("ScratchTop", "20").toDouble();
983
                doc->toolSettings.dStartArrow = dc.attribute("StartArrow", "0").toInt();
984
                doc->toolSettings.dEndArrow = dc.attribute("EndArrow", "0").toInt();
985
                doc->toolSettings.scaleX = dc.attribute("PICTSCX", "1").toDouble();
986
                doc->toolSettings.scaleY = dc.attribute("PICTSCY", "1").toDouble();
987
                doc->toolSettings.scaleType = static_cast<bool>(dc.attribute("PSCALE", "1").toInt());
988
                doc->toolSettings.aspectRatio = static_cast<bool>(dc.attribute("PASPECT", "0").toInt());
989
                doc->toolSettings.lowResType = dc.attribute("HalfRes", "1").toInt();
990
                doc->toolSettings.useEmbeddedPath = static_cast<bool>(dc.attribute("EmbeddedPath", "0").toInt());
745 fschmid 991
                if (dc.hasAttribute("PEN"))
1194 fschmid 992
                        doc->toolSettings.dPen = dc.attribute("PEN");
745 fschmid 993
                if (dc.hasAttribute("BRUSH"))
1194 fschmid 994
                        doc->toolSettings.dBrush = dc.attribute("BRUSH");
745 fschmid 995
                if (dc.hasAttribute("PENLINE"))
1194 fschmid 996
                        doc->toolSettings.dPenLine = dc.attribute("PENLINE");
745 fschmid 997
                if (dc.hasAttribute("PENTEXT"))
1194 fschmid 998
                        doc->toolSettings.dPenText = dc.attribute("PENTEXT");
745 fschmid 999
                if (dc.hasAttribute("StrokeText"))
1194 fschmid 1000
                        doc->toolSettings.dStrokeText = dc.attribute("StrokeText");
4546 subik 1001
                doc->toolSettings.dTextBackGround = dc.attribute("TextBackGround", CommonStrings::None);
1002
                doc->toolSettings.dTextLineColor = dc.attribute("TextLineColor", CommonStrings::None);
4026 craig 1003
                doc->toolSettings.dTextBackGroundShade = dc.attribute("TextBackGroundShade", "100").toInt();
1004
                doc->toolSettings.dTextLineShade = dc.attribute("TextLineShade", "100").toInt();
1005
                doc->toolSettings.dTextPenShade = dc.attribute("TextPenShade", "100").toInt();
1006
                doc->toolSettings.dTextStrokeShade = dc.attribute("TextStrokeShade", "100").toInt();
1007
                doc->toolSettings.dLineArt = static_cast<Qt::PenStyle>(dc.attribute("STIL").toInt());
1008
                doc->toolSettings.dLstyleLine = static_cast<Qt::PenStyle>(dc.attribute("STILLINE").toInt());
1009
                doc->toolSettings.dWidth = dc.attribute("WIDTH", "1").toDouble();
1010
                doc->toolSettings.dWidthLine = dc.attribute("WIDTHLINE", "1").toDouble();
1011
                doc->toolSettings.dShade2 = dc.attribute("PENSHADE", "100").toInt();
1012
                doc->toolSettings.dShadeLine = dc.attribute("LINESHADE", "100").toInt();
1013
                doc->toolSettings.dShade = dc.attribute("BRUSHSHADE", "100").toInt();
1014
                doc->toolSettings.magMin = dc.attribute("MAGMIN", "10").toInt();
1015
                doc->toolSettings.magMax = dc.attribute("MAGMAX", "3200").toInt();
4295 cbradney 1016
                doc->toolSettings.magStep = dc.attribute("MAGSTEP", "200").toInt();
1017
                //CB Reset doc zoom step value to 200% instead of old values.
1018
                if (doc->toolSettings.magStep<100)
1019
                        doc->toolSettings.magStep=200;
2219 fschmid 1020
                doc->toolSettings.tabFillChar = dc.attribute("TabFill","");
4026 craig 1021
                doc->toolSettings.dTabWidth=dc.attribute("TabWidth", "36.0").toDouble();
745 fschmid 1022
                if (dc.hasAttribute("CPICT"))
1194 fschmid 1023
                        doc->toolSettings.dBrushPict = dc.attribute("CPICT");
4026 craig 1024
                doc->toolSettings.shadePict = dc.attribute("PICTSHADE", "100").toInt();
745 fschmid 1025
                if (dc.hasAttribute("PAGEC"))
1026
                        doc->papColor = QColor(dc.attribute("PAGEC"));
1027
                if (dc.hasAttribute("MARGC"))
879 fschmid 1028
                        doc->guidesSettings.margColor = QColor(dc.attribute("MARGC"));
745 fschmid 1029
                if (dc.hasAttribute("MINORC"))
879 fschmid 1030
                        doc->guidesSettings.minorColor = QColor(dc.attribute("MINORC"));
745 fschmid 1031
                if (dc.hasAttribute("MAJORC"))
879 fschmid 1032
                        doc->guidesSettings.majorColor = QColor(dc.attribute("MAJORC"));
745 fschmid 1033
                if (dc.hasAttribute("GuideC"))
879 fschmid 1034
                        doc->guidesSettings.guideColor = QColor(dc.attribute("GuideC"));
745 fschmid 1035
                if (dc.hasAttribute("BaseC"))
879 fschmid 1036
                        doc->guidesSettings.baseColor = QColor(dc.attribute("BaseC"));
4026 craig 1037
                doc->marginColored = static_cast<bool>(dc.attribute("RANDF", "0").toInt());
1038
                doc->guidesSettings.before = static_cast<bool>(dc.attribute("BACKG", "1").toInt());
1039
                doc->guidesSettings.guideRad = dc.attribute("GuideRad", "10").toDouble();
1040
                doc->guidesSettings.grabRad = dc.attribute("GRAB", "4").toInt();
1261 fschmid 1041
                if (dc.hasAttribute("currentProfile"))
1284 fschmid 1042
                {
1043
                        doc->checkerProfiles.clear();
1261 fschmid 1044
                        doc->curCheckProfile = dc.attribute("currentProfile");
1284 fschmid 1045
                }
1016 fschmid 1046
                doc->LastAuto = 0;
517 fschmid 1047
                QDomNode PAGE=DOC.firstChild();
1048
                counter = 0;
1049
                while(!PAGE.isNull())
1050
                {
1051
                        ObCount++;
1052
                        dia2->setProgress(ObCount);
1053
                        QDomElement pg=PAGE.toElement();
3016 fschmid 1054
                        if (pg.tagName()=="PageSets")
1055
                        {
1056
                                QDomNode PGS = PAGE.firstChild();
1057
                                doc->pageSets.clear();
1058
                                while(!PGS.isNull())
1059
                                {
1060
                                        QDomElement PgsAttr = PGS.toElement();
1061
                                        if(PgsAttr.tagName() == "Set")
1062
                                        {
1063
                                                struct PageSet pageS;
4538 cbradney 1064
                                                pageS.Name = CommonStrings::untranslatePageSetString(PgsAttr.attribute("Name"));
4026 craig 1065
                                                pageS.FirstPage = PgsAttr.attribute("FirstPage", "0").toInt();
1066
                                                pageS.Rows = PgsAttr.attribute("Rows", "1").toInt();
1067
                                                pageS.Columns = PgsAttr.attribute("Columns", "1").toInt();
1068
                                                pageS.GapHorizontal = PgsAttr.attribute("GapHorizontal", "0").toDouble();
1069
                                                pageS.GapVertical = PgsAttr.attribute("GapVertical", "0").toDouble();
1070
                                                pageS.GapBelow = PgsAttr.attribute("GapBelow", "0").toDouble();
3026 fschmid 1071
                                                pageS.pageNames.clear();
1072
                                                QDomNode PGSN = PGS.firstChild();
1073
                                                while(!PGSN.isNull())
1074
                                                {
1075
                                                        QDomElement PgsAttrN = PGSN.toElement();
1076
                                                        if(PgsAttrN.tagName() == "PageNames")
4538 cbradney 1077
                                                                pageS.pageNames.append(CommonStrings::untranslatePageSetLocString(PgsAttrN.attribute("Name")));
3026 fschmid 1078
                                                        PGSN = PGSN.nextSibling();
1079
                                                }
3016 fschmid 1080
                                                doc->pageSets.append(pageS);
1081
                                        }
1082
                                        PGS = PGS.nextSibling();
1083
                                }
1084
                        }
1261 fschmid 1085
                        if (pg.tagName()=="CheckProfile")
1086
                        {
1087
                                struct checkerPrefs checkerSettings;
4026 craig 1088
                                checkerSettings.ignoreErrors = static_cast<bool>(pg.attribute("ignoreErrors", "0").toInt());
1089
                                checkerSettings.autoCheck = static_cast<bool>(pg.attribute("autoCheck", "1").toInt());
1090
                                checkerSettings.checkGlyphs = static_cast<bool>(pg.attribute("checkGlyphs", "1").toInt());
1091
                                checkerSettings.checkOrphans = static_cast<bool>(pg.attribute("checkOrphans", "1").toInt());
1092
                                checkerSettings.checkOverflow = static_cast<bool>(pg.attribute("checkOverflow", "1").toInt());
1093
                                checkerSettings.checkPictures = static_cast<bool>(pg.attribute("checkPictures", "1").toInt());
1094
                                checkerSettings.checkResolution = static_cast<bool>(pg.attribute("checkResolution", "1").toInt());
1095
                                checkerSettings.checkTransparency = static_cast<bool>(pg.attribute("checkTransparency", "1").toInt());
1096
                                checkerSettings.minResolution = pg.attribute("minResolution", "72").toDouble();
1097
                                checkerSettings.checkAnnotations = static_cast<bool>(pg.attribute("checkAnnotations", "0").toInt());
1098
                                checkerSettings.checkRasterPDF = static_cast<bool>(pg.attribute("checkRasterPDF", "1").toInt());
1261 fschmid 1099
                                doc->checkerProfiles[pg.attribute("Name")] = checkerSettings;
1100
                        }
517 fschmid 1101
                        // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
4546 subik 1102
                        if(pg.tagName()=="COLOR" && pg.attribute("NAME")!=CommonStrings::None)
517 fschmid 1103
                        {
1104
                                if (pg.hasAttribute("CMYK"))
1105
                                        lf.setNamedColor(pg.attribute("CMYK"));
1106
                                else
1107
                                        lf.fromQColor(QColor(pg.attribute("RGB")));
3051 fschmid 1108
                                if (pg.hasAttribute("Spot"))
4026 craig 1109
                                        lf.setSpotColor(static_cast<bool>(pg.attribute("Spot").toInt()));
3051 fschmid 1110
                                else
1111
                                        lf.setSpotColor(false);
3060 fschmid 1112
                                if (pg.hasAttribute("Register"))
4026 craig 1113
                                        lf.setRegistrationColor(static_cast<bool>(pg.attribute("Register").toInt()));
3060 fschmid 1114
                                else
1115
                                        lf.setRegistrationColor(false);
517 fschmid 1116
                          doc->PageColors[pg.attribute("NAME")] = lf;
1117
                        }
1118
                        if(pg.tagName()=="STYLE")
1119
                        {
1120
                                vg.Vname = pg.attribute("NAME");
4026 craig 1121
                                vg.LineSpaMode = pg.attribute("LINESPMode", "0").toInt();
1122
                                vg.LineSpa = pg.attribute("LINESP").toDouble();
1123
                                vg.Indent = pg.attribute("INDENT", "0").toDouble();
1124
                                vg.First = pg.attribute("FIRST", "0").toDouble();
1125
                                vg.textAlignment = pg.attribute("ALIGN").toInt();
1126
                                vg.gapBefore = pg.attribute("VOR", "0").toDouble();
1127
                                vg.gapAfter = pg.attribute("NACH", "0").toDouble();
1194 fschmid 1128
                                tmpf = pg.attribute("FONT", doc->toolSettings.defFont);
1428 fschmid 1129
                                if ((!avail.find(tmpf)) || (!avail[tmpf]->UseFont))
1130
                                {
3650 cbradney 1131
                                        if ((!prefsManager->appPrefs.GFontSub.contains(tmpf)) || (!avail[prefsManager->appPrefs.GFontSub[tmpf]]->UseFont))
1468 fschmid 1132
                                        {
1133
                                                newReplacement = true;
3650 cbradney 1134
                                                ReplacedFonts.insert(tmpf, prefsManager->appPrefs.toolSettings.defFont);
1468 fschmid 1135
                                        }
1428 fschmid 1136
                                        else
3650 cbradney 1137
                                                ReplacedFonts.insert(tmpf, prefsManager->appPrefs.GFontSub[tmpf]);
1428 fschmid 1138
                                }
517 fschmid 1139
                                else
1428 fschmid 1140
                                {
1786 fschmid 1141
                                        if (!doc->UsedFonts.contains(tmpf))
1142
                                        {
3544 avox 1143
//                                              QFont fo = avail[tmpf]->Font;
1144
//                                              fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
1145
                                                doc->AddFont(tmpf, qRound(doc->toolSettings.defSize / 10.0));
1786 fschmid 1146
                                        }
1428 fschmid 1147
                                }
517 fschmid 1148
                                vg.Font = tmpf;
4026 craig 1149
                                vg.FontSize = qRound(pg.attribute("FONTSIZE", "12").toDouble() * 10.0);
1150
                                vg.Drop = static_cast<bool>(pg.attribute("DROP", "0").toInt());
1151
                                vg.DropLin = pg.attribute("DROPLIN", "2").toInt();
1152
                                vg.DropDist = pg.attribute("DROPDIST", "0").toDouble();
1153
                                vg.FontEffect = pg.attribute("EFFECT", "0").toInt();
1194 fschmid 1154
                                vg.FColor = pg.attribute("FCOLOR", doc->toolSettings.dBrush);
4026 craig 1155
                                vg.FShade = pg.attribute("FSHADE", "100").toInt();
1194 fschmid 1156
                                vg.SColor = pg.attribute("SCOLOR", doc->toolSettings.dPen);
4026 craig 1157
                                vg.SShade = pg.attribute("SSHADE", "100").toInt();
1158
                                vg.BaseAdj = static_cast<bool>(pg.attribute("BASE", "0").toInt());
1159
                                vg.txtShadowX=qRound(pg.attribute("TXTSHX", "5").toDouble() * 10);
1160
                                vg.txtShadowY=qRound(pg.attribute("TXTSHY", "-5").toDouble() * 10);
1161
                                vg.txtOutline=qRound(pg.attribute("TXTOUT", "1").toDouble() * 10);
1162
                                vg.txtUnderPos=qRound(pg.attribute("TXTULP", "-0.1").toDouble() * 10);
1163
                                vg.txtUnderWidth=qRound(pg.attribute("TXTULW", "-0.1").toDouble() * 10);
1164
                                vg.txtStrikePos=qRound(pg.attribute("TXTSTP", "-0.1").toDouble() * 10);
1165
                                vg.txtStrikeWidth=qRound(pg.attribute("TXTSTW", "-0.1").toDouble() * 10);
1166
                                vg.scaleH = qRound(pg.attribute("SCALEH", "100").toDouble() * 10);
1167
                                vg.scaleV = qRound(pg.attribute("SCALEV", "100").toDouble() * 10);
1168
                                vg.baseOff = qRound(pg.attribute("BASEO", "0").toDouble() * 10);
1169
                                vg.kernVal = qRound(pg.attribute("KERN", "0").toDouble() * 10);
2282 fschmid 1170
                                vg.TabValues.clear();
4026 craig 1171
                                if ((pg.hasAttribute("NUMTAB")) && (pg.attribute("NUMTAB", "0").toInt() != 0))
517 fschmid 1172
                                {
2282 fschmid 1173
                                        struct PageItem::TabRecord tb;
517 fschmid 1174
                                        tmp = pg.attribute("TABS");
1175
                                        QTextStream tgv(&tmp, IO_ReadOnly);
4026 craig 1176
                                        for (int cxv = 0; cxv < pg.attribute("NUMTAB", "0").toInt(); cxv += 2)
517 fschmid 1177
                                        {
1178
                                                tgv >> xf;
2282 fschmid 1179
                                                tgv >> xf2;
1180
                                                tb.tabPosition = xf2;
1181
                                                tb.tabType = static_cast<int>(xf);
1182
                                                tb.tabFillChar =  QChar();
1183
                                                vg.TabValues.append(tb);
517 fschmid 1184
                                        }
1185
                                        tmp = "";
1186
                                }
1187
                                else
2282 fschmid 1188
                                {
1189
                                        QDomNode IT = pg.firstChild();
1190
                                        while(!IT.isNull())
1191
                                        {
1192
                                                QDomElement it = IT.toElement();
1193
                                                if (it.tagName()=="Tabs")
1194
                                                {
1195
                                                        struct PageItem::TabRecord tb;
4026 craig 1196
                                                        tb.tabPosition = it.attribute("Pos").toDouble();
1197
                                                        tb.tabType = it.attribute("Type").toInt();
2282 fschmid 1198
                                                        QString tbCh = "";
1199
                                                        tbCh = it.attribute("Fill","");
2877 cbradney 1200
                                                        if (tbCh.isEmpty())
2282 fschmid 1201
                                                                tb.tabFillChar = QChar();
1202
                                                        else
1203
                                                                tb.tabFillChar = tbCh[0];
1204
                                                        vg.TabValues.append(tb);
1205
                                                }
1206
                                                IT=IT.nextSibling();
1207
                                        }
1208
                                }
1065 cbradney 1209
                                doc->docParagraphStyles.append(vg);
517 fschmid 1210
                        }
1211
                        if(pg.tagName()=="JAVA")
1212
                                doc->JavaScripts[pg.attribute("NAME")] = pg.attribute("SCRIPT");
1213
                        if(pg.tagName()=="LAYERS")
1214
                        {
4026 craig 1215
                                la.LNr = pg.attribute("NUMMER").toInt();
1216
                                la.Level = pg.attribute("LEVEL").toInt();
517 fschmid 1217
                                la.Name = pg.attribute("NAME");
4026 craig 1218
                                la.isViewable = pg.attribute("SICHTBAR").toInt();
1219
                                la.isPrintable = pg.attribute("DRUCKEN").toInt();
517 fschmid 1220
                                doc->Layers.append(la);
1221
                        }
1222
                        if(pg.tagName()=="Bookmark")
1223
                        {
1224
                                bok.Title = pg.attribute("Title");
1225
                                bok.Text = pg.attribute("Text");
1226
                                bok.Aktion = pg.attribute("Aktion");
4026 craig 1227
                                bok.ItemNr = pg.attribute("ItemNr").toInt();
1228
                                bok.Seite = pg.attribute("Seite").toInt();
1229
                                bok.Element = pg.attribute("Element").toInt();
1230
                                bok.First = pg.attribute("First").toInt();
1231
                                bok.Last = pg.attribute("Last").toInt();
1232
                                bok.Prev = pg.attribute("Prev").toInt();
1233
                                bok.Next = pg.attribute("Next").toInt();
1234
                                bok.Parent = pg.attribute("Parent").toInt();
517 fschmid 1235
                                doc->BookMarks.append(bok);
1236
                        }
1237
                        if(pg.tagName()=="MultiLine")
1238
                        {
1239
                                multiLine ml;
1240
                                QDomNode MuLn = PAGE.firstChild();
1241
                                while(!MuLn.isNull())
1242
                                {
1243
                                        QDomElement MuL = MuLn.toElement();
1065 cbradney 1244
                                        struct SingleLine sl;
517 fschmid 1245
                                        sl.Color = MuL.attribute("Color");
4026 craig 1246
                                        sl.Dash = MuL.attribute("Dash").toInt();
1247
                                        sl.LineEnd = MuL.attribute("LineEnd").toInt();
1248
                                        sl.LineJoin = MuL.attribute("LineJoin").toInt();
1249
                                        sl.Shade = MuL.attribute("Shade").toInt();
1250
                                        sl.Width = MuL.attribute("Width").toDouble();
517 fschmid 1251
                                        ml.push_back(sl);
1252
                                        MuLn = MuLn.nextSibling();
1253
                                }
1254
                                doc->MLineStyles.insert(pg.attribute("Name"), ml);
1255
                        }
741 fschmid 1256
                        if(pg.tagName()=="Arrows")
1257
                        {
1065 cbradney 1258
                                struct ArrowDesc arrow;
760 fschmid 1259
                                arrow.name = pg.attribute("Name");
776 fschmid 1260
                                arrow.userArrow = true;
741 fschmid 1261
                                double xa, ya;
1262
                                QString tmp = pg.attribute("Points");
1263
                                QTextStream fp(&tmp, IO_ReadOnly);
1264
                                for (uint cx = 0; cx < pg.attribute("NumPoints").toUInt(); ++cx)
1265
                                {
1266
                                        fp >> xa;
1267
                                        fp >> ya;
760 fschmid 1268
                                        arrow.points.addPoint(xa, ya);
741 fschmid 1269
                                }
1270
                                doc->arrowStyles.append(arrow);
1271
                        }
1642 cbradney 1272
                        if(pg.tagName()=="PDF")
1273
                        {
4026 craig 1274
                                doc->PDF_Options.Articles = static_cast<bool>(pg.attribute("Articles").toInt());
1275
                                doc->PDF_Options.Thumbnails = static_cast<bool>(pg.attribute("Thumbnails").toInt());
1276
                                doc->PDF_Options.Compress = static_cast<bool>(pg.attribute("Compress").toInt());
1277
                                doc->PDF_Options.CompressMethod = pg.attribute("CMethod", "0").toInt();
1278
                                doc->PDF_Options.Quality = pg.attribute("Quality", "0").toInt();
1279
                                doc->PDF_Options.RecalcPic = static_cast<bool>(pg.attribute("RecalcPic").toInt());
1280
                                doc->PDF_Options.Bookmarks = static_cast<bool>(pg.attribute("Bookmarks").toInt());
1642 cbradney 1281
                                if (pg.hasAttribute("MirrorH"))
4026 craig 1282
                                        doc->PDF_Options.MirrorH = static_cast<bool>(pg.attribute("MirrorH").toInt());
1642 cbradney 1283
                                else
1284
                                        doc->PDF_Options.MirrorH = false;
1285
                                if (pg.hasAttribute("MirrorV"))
4026 craig 1286
                                        doc->PDF_Options.MirrorV = static_cast<bool>(pg.attribute("MirrorV").toInt());
1642 cbradney 1287
                                else
1288
                                        doc->PDF_Options.MirrorV = false;
1289
                                if (pg.hasAttribute("RotateDeg"))
4026 craig 1290
                                        doc->PDF_Options.RotateDeg = pg.attribute("RotateDeg", "0").toInt();
1642 cbradney 1291
                                else
1292
                                        doc->PDF_Options.RotateDeg = 0;
4649 fschmid 1293
                                if (pg.hasAttribute("Clip"))
1294
                                        doc->PDF_Options.doClip = static_cast<bool>(pg.attribute("Clip").toInt());
1295
                                else
1296
                                        doc->PDF_Options.doClip = false;
4026 craig 1297
                                doc->PDF_Options.PresentMode = static_cast<bool>(pg.attribute("PresentMode").toInt());
1298
                                doc->PDF_Options.PicRes = pg.attribute("PicRes").toInt();
1973 craig 1299
                                // Fixme: check input pdf version
4026 craig 1300
                                doc->PDF_Options.Version = (PDFOptions::PDFVersion)pg.attribute("Version").toInt();
1301
                                doc->PDF_Options.Resolution = pg.attribute("Resolution").toInt();
1302
                                doc->PDF_Options.Binding = pg.attribute("Binding").toInt();
1642 cbradney 1303
                                doc->PDF_Options.Datei = "";
4026 craig 1304
                                doc->PDF_Options.isGrayscale = static_cast<bool>(pg.attribute("Grayscale", "0").toInt());
1305
                                doc->PDF_Options.UseRGB = static_cast<bool>(pg.attribute("RGBMode", "0").toInt());
1306
                                doc->PDF_Options.UseProfiles = static_cast<bool>(pg.attribute("UseProfiles", "0").toInt());
1307
                                doc->PDF_Options.UseProfiles2 = static_cast<bool>(pg.attribute("UseProfiles2", "0").toInt());
1308
                                doc->PDF_Options.Intent = pg.attribute("Intent", "1").toInt();
1309
                                doc->PDF_Options.Intent2 = pg.attribute("Intent2", "1").toInt();
1642 cbradney 1310
                                doc->PDF_Options.SolidProf = pg.attribute("SolidP", "");
1311
                                doc->PDF_Options.ImageProf = pg.attribute("ImageP", "");
1312
                                doc->PDF_Options.PrintProf = pg.attribute("PrintP", "");
1313
                                doc->PDF_Options.Info = pg.attribute("InfoString", "");
4026 craig 1314
                                doc->PDF_Options.BleedTop = pg.attribute("BTop", "0").toDouble();
1315
                                doc->PDF_Options.BleedLeft = pg.attribute("BLeft", "0").toDouble();
1316
                                doc->PDF_Options.BleedRight = pg.attribute("BRight", "0").toDouble();
1317
                                doc->PDF_Options.BleedBottom = pg.attribute("BBottom", "0").toDouble();
1318
                                doc->PDF_Options.EmbeddedI = static_cast<bool>(pg.attribute("ImagePr", "0").toInt());
1642 cbradney 1319
                                doc->PDF_Options.PassOwner = pg.attribute("PassOwner", "");
1320
                                doc->PDF_Options.PassUser = pg.attribute("PassUser", "");
4026 craig 1321
                                doc->PDF_Options.Permissions = pg.attribute("Permissions", "-4").toInt();
1322
                                doc->PDF_Options.Encrypt = static_cast<bool>(pg.attribute("Encrypt", "0").toInt());
1323
                                doc->PDF_Options.useLayers = static_cast<bool>(pg.attribute("UseLayers", "0").toInt());
1324
                                doc->PDF_Options.UseLPI = static_cast<bool>(pg.attribute("UseLpi", "0").toInt());
4201 fschmid 1325
                                doc->PDF_Options.UseSpotColors = static_cast<bool>(pg.attribute("UseSpotColors", "1").toInt());
1326
                                doc->PDF_Options.doMultiFile = static_cast<bool>(pg.attribute("doMultiFile", "0").toInt());
1327
                                doc->PDF_Options.displayBookmarks = static_cast<bool>(pg.attribute("displayBookmarks", "0").toInt());
1328
                                doc->PDF_Options.displayFullscreen = static_cast<bool>(pg.attribute("displayFullscreen", "0").toInt());
1329
                                doc->PDF_Options.displayLayers = static_cast<bool>(pg.attribute("displayLayers", "0").toInt());
1330
                                doc->PDF_Options.displayThumbs = static_cast<bool>(pg.attribute("displayThumbs", "0").toInt());
1331
                                doc->PDF_Options.hideMenuBar = static_cast<bool>(pg.attribute("hideMenuBar", "0").toInt());
1332
                                doc->PDF_Options.hideToolBar = static_cast<bool>(pg.attribute("hideToolBar", "0").toInt());
1333
                                doc->PDF_Options.fitWindow = static_cast<bool>(pg.attribute("fitWindow", "0").toInt());
1334
                                doc->PDF_Options.PageLayout = pg.attribute("PageLayout", "0").toInt();
1335
                                doc->PDF_Options.openAction = pg.attribute("openAction", "");
1642 cbradney 1336
                                QDomNode PFO = PAGE.firstChild();
1337
                                while(!PFO.isNull())
1338
                                {
1339
                                        QDomElement pdfF = PFO.toElement();
1340
                                        if(pdfF.tagName() == "LPI")
1341
                                        {
1342
                                                struct LPIData lpo;
4026 craig 1343
                                                lpo.Angle = pdfF.attribute("Angle").toInt();
1344
                                                lpo.Frequency = pdfF.attribute("Frequency").toInt();
1345
                                                lpo.SpotFunc = pdfF.attribute("SpotFunction").toInt();
1642 cbradney 1346
                                                doc->PDF_Options.LPISettings[pdfF.attribute("Color")] = lpo;
1347
                                        }
1348
                                        if(pdfF.tagName() == "Fonts")
1349
                                        {
1350
                                                if (!doc->PDF_Options.EmbedList.contains(pdfF.attribute("Name")))
1351
                                                        doc->PDF_Options.EmbedList.append(pdfF.attribute("Name"));
1352
                                        }
1353
                                        if(pdfF.tagName() == "Subset")
1354
                                        {
1355
                                                if (!doc->PDF_Options.SubsetList.contains(pdfF.attribute("Name")))
1356
                                                        doc->PDF_Options.SubsetList.append(pdfF.attribute("Name"));
1357
                                        }
1358
                                        if(pdfF.tagName() == "Effekte")
1359
                                        {
1360
                                                struct PDFPresentationData ef;
4026 craig 1361
                                                ef.pageEffectDuration = pdfF.attribute("pageEffectDuration").toInt();
1362
                                                ef.pageViewDuration = pdfF.attribute("pageViewDuration").toInt();
1363
                                                ef.effectType = pdfF.attribute("effectType").toInt();
1364
                                                ef.Dm = pdfF.attribute("Dm").toInt();
1365
                                                ef.M = pdfF.attribute("M").toInt();
1366
                                                ef.Di = pdfF.attribute("Di").toInt();
1642 cbradney 1367
                                                doc->PDF_Options.PresentVals.append(ef);
1368
                                        }
1369
                                        PFO = PFO.nextSibling();
1370
                                }
1371
                        }
1372
                        if(pg.tagName()=="DocItemAttributes")
1373
                        {
1374
                                QDomNode DIA = PAGE.firstChild();
1375
                                doc->docItemAttributes.clear();
1376
                                while(!DIA.isNull())
1377
                                {
1378
                                        QDomElement itemAttr = DIA.toElement();
1379
                                        if(itemAttr.tagName() == "ItemAttribute")
1380
                                        {
1381
                                                ObjectAttribute objattr;
1382
                                                objattr.name=itemAttr.attribute("Name");
1383
                                                objattr.type=itemAttr.attribute("Type");
1384
                                                objattr.value=itemAttr.attribute("Value");
1385
                                                objattr.parameter=itemAttr.attribute("Parameter");
1654 cbradney 1386
                                                objattr.relationship=itemAttr.attribute("Relationship");
1387
                                                objattr.relationshipto=itemAttr.attribute("RelationshipTo");
1388
                                                objattr.autoaddto=itemAttr.attribute("AutoAddTo");
1649 cbradney 1389
                                                doc->docItemAttributes.append(objattr);
1642 cbradney 1390
                                        }
1391
                                        DIA = DIA.nextSibling();
1392
                                }
1393
                        }
1694 cbradney 1394
                        if(pg.tagName()=="TablesOfContents")
1395
                        {
1396
                                QDomNode TOC = PAGE.firstChild();
1397
                                doc->docToCSetups.clear();
1398
                                while(!TOC.isNull())
1399
                                {
1400
                                        QDomElement tocElem = TOC.toElement();
1401
                                        if(tocElem.tagName() == "TableOfContents")
1402
                                        {
1403
                                                ToCSetup tocsetup;
1404
                                                tocsetup.name=tocElem.attribute("Name");
1405
                                                tocsetup.itemAttrName=tocElem.attribute("ItemAttributeName");
1406
                                                tocsetup.frameName=tocElem.attribute("FrameName");
2449 cbradney 1407
                                                tocsetup.listNonPrintingFrames=tocElem.attribute("ListNonPrinting");
2445 cbradney 1408
                                                tocsetup.textStyle=tocElem.attribute("Style");
1409
                                                QString numberPlacement=tocElem.attribute("NumberPlacement");
1410
                                                if (numberPlacement=="Beginning")
1411
                                                        tocsetup.pageLocation=Beginning;
1412
                                                if (numberPlacement=="End")
1413
                                                        tocsetup.pageLocation=End;
1414
                                                if (numberPlacement=="NotShown")
1415
                                                        tocsetup.pageLocation=NotShown;
1694 cbradney 1416
                                                doc->docToCSetups.append(tocsetup);
1417
                                        }
1418
                                        TOC = TOC.nextSibling();
1419
                                }
1420
                        }
3757 cbradney 1421
                        if(pg.tagName()=="Sections")
1422
                        {
1423
                                QDomNode Section = PAGE.firstChild();
1424
                                while(!Section.isNull())
1425
                                {
1426
                                        QDomElement sectionElem = Section.toElement();
1427
                                        if(sectionElem.tagName() == "Section")
1428
                                        {
1429
                                                struct DocumentSection newSection;
4026 craig 1430
                                                newSection.number=sectionElem.attribute("Number").toInt();
3757 cbradney 1431
                                                newSection.name=sectionElem.attribute("Name");
4026 craig 1432
                                                newSection.fromindex=sectionElem.attribute("From").toInt();
1433
                                                newSection.toindex=sectionElem.attribute("To").toInt();
3757 cbradney 1434
                                                if (sectionElem.attribute("Type")=="Type_1_2_3")
1435
                                                        newSection.type=Type_1_2_3;
1436
                                                if (sectionElem.attribute("Type")=="Type_i_ii_iii")
1437
                                                        newSection.type=Type_i_ii_iii;
1438
                                                if (sectionElem.attribute("Type")=="Type_I_II_III")
1439
                                                        newSection.type=Type_I_II_III;
1440
                                                if (sectionElem.attribute("Type")=="Type_a_b_c")
1441
                                                        newSection.type=Type_a_b_c;
1442
                                                if (sectionElem.attribute("Type")=="Type_A_B_C")
1443
                                                        newSection.type=Type_A_B_C;
4026 craig 1444
                                                newSection.sectionstartindex=sectionElem.attribute("Start").toInt();
1445
                                                newSection.reversed=static_cast<bool>(sectionElem.attribute("Reversed").toInt());
1446
                                                newSection.active=static_cast<bool>(sectionElem.attribute("Active").toInt());
3757 cbradney 1447
                                                doc->sections.insert(newSection.number, newSection);
1448
                                        }
1449
                                        Section = Section.nextSibling();
1450
                                }
1451
                        }
517 fschmid 1452
                        if ((pg.tagName()=="PAGE") || (pg.tagName()=="MASTERPAGE"))
1453
                        {
4026 craig 1454
                                a = pg.attribute("NUM").toInt();
517 fschmid 1455
                                PgNam = "";
1456
                                PgNam = pg.attribute("NAM", "");
3757 cbradney 1457
                                //Pgc = doc->pageCount;
1458
                                //AtFl = doc->usesAutomaticTextFrames();
2877 cbradney 1459
                                if (PgNam.isEmpty())
517 fschmid 1460
                                {
3757 cbradney 1461
                                        //doc->pageCount = Pgc;
3724 cbradney 1462
                                        //doc->Pages = &doc->DocPages;
3757 cbradney 1463
                                        //doc->setUsesAutomaticTextFrames(AtFl);
3724 cbradney 1464
                                        doc->setMasterPageMode(false);
517 fschmid 1465
                                }
1466
                                else
1467
                                {
3757 cbradney 1468
                                        //doc->pageCount = 0;
1469
                                        //doc->setUsesAutomaticTextFrames(false);
3724 cbradney 1470
                                        //doc->Pages = &doc->MasterPages;
1471
                                        doc->setMasterPageMode(true);
517 fschmid 1472
                                }
4546 subik 1473
                                //CB: Stop calling damn GUI code in loading docs! IT doesnt *look* like
3648 cbradney 1474
                                //this makes a difference apart from being faster, of course.
4026 craig 1475
                                //ScMW->slotNewPage(a);
3648 cbradney 1476
                                //Apage = doc->Pages.at(a);
2877 cbradney 1477
                                if (PgNam.isEmpty())
2109 fschmid 1478
                                {
3757 cbradney 1479
                                        Apage = doc->addPage(a);
3724 cbradney 1480
                                        //doc->DocPages = doc->Pages;
4069 craig 1481
                                        //++doc->pageCount;
2109 fschmid 1482
                                }
517 fschmid 1483
                                else
1484
                                {
3757 cbradney 1485
                                        Apage = doc->addMasterPage(a, PgNam);
1486
                                        //Apage->setPageName(PgNam);
1487
                                        //doc->MasterNames[PgNam] = a;
3724 cbradney 1488
                                        //doc->MasterPages = doc->Pages;
3757 cbradney 1489
                                        //doc->pageCount = Pgc;
517 fschmid 1490
                                }
3757 cbradney 1491
                                //doc->setUsesAutomaticTextFrames(AtFl);
4026 craig 1492
                                Apage->LeftPg=pg.attribute("LEFT", "0").toInt();
517 fschmid 1493
                                QString Mus = "";
1494
                                Mus = pg.attribute("MNAM","Normal");
3724 cbradney 1495
                                if (!doc->masterPageMode())
517 fschmid 1496
                                        Apage->MPageNam = Mus;
1497
                                else
1498
                                        Apage->MPageNam = "";
2880 fschmid 1499
                                if (pg.hasAttribute("Size"))
1500
                                        Apage->PageSize = pg.attribute("Size");
1501
                                if (pg.hasAttribute("Orientation"))
4026 craig 1502
                                        Apage->PageOri = pg.attribute("Orientation").toInt();
1503
                                Apage->setXOffset(pg.attribute("PAGEXPOS").toDouble());
1504
                                Apage->setYOffset(pg.attribute("PAGEYPOS").toDouble());
2305 cbradney 1505
                                if (pg.hasAttribute("PAGEWIDTH"))
4026 craig 1506
                                        Apage->setWidth(pg.attribute("PAGEWIDTH").toDouble());
2305 cbradney 1507
                                else
4026 craig 1508
                                        Apage->setWidth(pg.attribute("PAGEWITH").toDouble());
1509
                                Apage->setHeight(pg.attribute("PAGEHEIGHT").toDouble());
3200 cbradney 1510
                                Apage->setInitialHeight(Apage->height());
1511
                                Apage->setInitialWidth(Apage->width());
4595 fschmid 1512
                                Apage->initialMargins.Top = QMAX(0.0, pg.attribute("BORDERTOP").toDouble());
1513
                                Apage->initialMargins.Bottom = QMAX(0.0, pg.attribute("BORDERBOTTOM").toDouble());
1514
                                Apage->initialMargins.Left = QMAX(0.0, pg.attribute("BORDERLEFT").toDouble());
1515
                                Apage->initialMargins.Right = QMAX(0.0, pg.attribute("BORDERRIGHT").toDouble());
2777 fschmid 1516
                                Apage->Margins.Top = Apage->initialMargins.Top;
1517
                                Apage->Margins.Bottom = Apage->initialMargins.Bottom;
3724 cbradney 1518
                                doc->setMasterPageMode(false);
1519
                                //doc->Pages=&doc->DocPages;
4026 craig 1520
                                if ((pg.hasAttribute("NumVGuides")) && (pg.attribute("NumVGuides", "0").toInt() != 0))
517 fschmid 1521
                                {
1522
                                        tmp = pg.attribute("VerticalGuides");
1523
                                        QTextStream fgv(&tmp, IO_ReadOnly);
1524
                                        Apage->YGuides.clear();
4026 craig 1525
                                        for (int cxv = 0; cxv < pg.attribute("NumVGuides", "0").toInt(); ++cxv)
517 fschmid 1526
                                        {
1527
                                                fgv >> xf;
1528
                                                Apage->YGuides.append(xf);
1529
                                        }
1530
                                        qHeapSort(Apage->YGuides);
1531
                                        tmp = "";
1532
                                }
1533
                                else
1534
                                        Apage->YGuides.clear();
4026 craig 1535
                                if ((pg.hasAttribute("NumHGuides")) && (pg.attribute("NumHGuides", "0").toInt() != 0))
517 fschmid 1536
                                {
1537
                                        tmp = pg.attribute("HorizontalGuides");
1538
                                        QTextStream fgh(&tmp, IO_ReadOnly);
1539
                                        Apage->XGuides.clear();
4026 craig 1540
                                        for (int cxh = 0; cxh < pg.attribute("NumHGuides", "0").toInt(); ++cxh)
517 fschmid 1541
                                        {
1542
                                                fgh >> xf;
1543
                                                Apage->XGuides.append(xf);
1544
                                        }
1545
                                        qHeapSort(Apage->XGuides);
1546
                                        tmp = "";
1547
                                }
1548
                                else
1549
                                        Apage->XGuides.clear();
1800 cbradney 1550
                        }
2447 fschmid 1551
                        if ((pg.tagName()=="PAGEOBJECT") || (pg.tagName()=="MASTEROBJECT") || (pg.tagName()=="FRAMEOBJECT"))
517 fschmid 1552
                        {
2447 fschmid 1553
                                        if ((pg.tagName()=="PAGEOBJECT") || (pg.tagName()=="FRAMEOBJECT"))
522 fschmid 1554
                                        {
3727 cbradney 1555
                                                //doc->Items = doc->DocItems;
3724 cbradney 1556
                                                //doc->Pages = &doc->DocPages;
1557
                                                doc->setMasterPageMode(false);
522 fschmid 1558
                                        }
517 fschmid 1559
                                        else
522 fschmid 1560
                                        {
3727 cbradney 1561
                                                //doc->Items = doc->MasterItems;
3724 cbradney 1562
                                                //doc->Pages = &doc->MasterPages;
1563
                                                doc->setMasterPageMode(true);
522 fschmid 1564
                                        }
2877 cbradney 1565
                                        if ((!pg.attribute("OnMasterPage").isEmpty()) && (pg.tagName()=="MASTEROBJECT"))
1065 cbradney 1566
                                                doc->currentPage = doc->MasterPages.at(doc->MasterNames[pg.attribute("OnMasterPage")]);
4026 craig 1567
                                        if ((pg.attribute("NEXTITEM").toInt() != -1) || (static_cast<bool>(pg.attribute("AUTOTEXT").toInt())))
517 fschmid 1568
                                        {
4026 craig 1569
                                                if (pg.attribute("BACKITEM").toInt() == -1)
3727 cbradney 1570
                                                        LFrames.append(doc->Items->count());
517 fschmid 1571
                                        }
1779 fschmid 1572
                                        int docGc = doc->GroupCounter;
1573
                                        doc->GroupCounter = 0;
3657 cbradney 1574
                                        Neu = PasteItem(&pg, doc);
1575
                                        Neu->setRedrawBounding();
1576
                                        Neu->OwnPage = pg.attribute("OwnPage").toInt();
1786 fschmid 1577
                                        if (pg.tagName()=="PAGEOBJECT")
1578
                                                Neu->OnMasterPage = "";
1779 fschmid 1579
                                        doc->GroupCounter = docGc;
1194 fschmid 1580
                                        tmpf = pg.attribute("IFONT", doc->toolSettings.defFont);
1428 fschmid 1581
                                        if ((!avail.find(tmpf)) || (!avail[tmpf]->UseFont))
1582
                                        {
3650 cbradney 1583
                                                if ((!prefsManager->appPrefs.GFontSub.contains(tmpf)) || (!avail[prefsManager->appPrefs.GFontSub[tmpf]]->UseFont))
1468 fschmid 1584
                                                {
1585
                                                        newReplacement = true;
3650 cbradney 1586
                                                        ReplacedFonts.insert(tmpf, prefsManager->appPrefs.toolSettings.defFont);
1468 fschmid 1587
                                                }
1428 fschmid 1588
                                                else
3650 cbradney 1589
                                                        ReplacedFonts.insert(tmpf, prefsManager->appPrefs.GFontSub[tmpf]);
1428 fschmid 1590
                                        }
517 fschmid 1591
                                        else
1428 fschmid 1592
                                        {
1786 fschmid 1593
                                                if (!doc->UsedFonts.contains(tmpf))
1594
                                                {
3544 avox 1595
//                                                      QFont fo = avail[tmpf]->Font;
1596
//                                                      fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
1597
                                                        doc->AddFont(tmpf, qRound(doc->toolSettings.defSize / 10.0));
1786 fschmid 1598
                                                }
1428 fschmid 1599
                                        }
4073 cbradney 1600
                                        Neu->setFont(tmpf);
517 fschmid 1601
                                        QDomNode IT=pg.firstChild();
1602
                                        while(!IT.isNull())
1603
                                        {
1604
                                                QDomElement it=IT.toElement();
1605
                                                if (it.tagName()=="CSTOP")
1606
                                                {
1607
                                                        QString name = it.attribute("NAME");
4026 craig 1608
                                                        double ramp = it.attribute("RAMP", "0.0").toDouble();
1609
                                                        int shade = it.attribute("SHADE", "100").toInt();
1610
                                                        double opa = it.attribute("TRANS", "1").toDouble();
1779 fschmid 1611
                                                        Neu->fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
517 fschmid 1612
                                                }
1613
                                                if (it.tagName()=="ITEXT")
2834 cbradney 1614
                                                        GetItemText(&it, doc, Neu);
4546 subik 1615
 
1655 cbradney 1616
                                                //CB PageItemAttributes
1617
                                                if(it.tagName()=="PageItemAttributes")
1618
                                                {
1619
                                                        QDomNode PIA = it.firstChild();
1620
                                                        ObjAttrVector pageItemAttributes;
1621
                                                        while(!PIA.isNull())
1622
                                                        {
1623
                                                                QDomElement itemAttr = PIA.toElement();
1624
                                                                if(itemAttr.tagName() == "ItemAttribute")
1625
                                                                {
1626
                                                                        ObjectAttribute objattr;
1627
                                                                        objattr.name=itemAttr.attribute("Name");
1628
                                                                        objattr.type=itemAttr.attribute("Type");
1629
                                                                        objattr.value=itemAttr.attribute("Value");
1630
                                                                        objattr.parameter=itemAttr.attribute("Parameter");
1631
                                                                        objattr.relationship=itemAttr.attribute("Relationship");
1632
                                                                        objattr.relationshipto=itemAttr.attribute("RelationshipTo");
1633
                                                                        objattr.autoaddto=itemAttr.attribute("AutoAddTo");
1634
                                                                        pageItemAttributes.append(objattr);
1635
                                                                }
1636
                                                                PIA = PIA.nextSibling();
1637
                                                        }
1779 fschmid 1638
                                                        Neu->setObjectAttributes(&pageItemAttributes);
1655 cbradney 1639
                                                }
517 fschmid 1640
                                                IT=IT.nextSibling();
1641
                                        }
2179 fschmid 1642
                                        if (Neu->fill_gradient.Stops() == 0)
517 fschmid 1643
                                        {
2179 fschmid 1644
                                                Neu->fill_gradient.addStop(doc->PageColors[doc->toolSettings.dBrush].getRGBColor(), 0.0, 0.5, 1.0, doc->toolSettings.dBrush, 100);
1645
                                                Neu->fill_gradient.addStop(doc->PageColors[doc->toolSettings.dPen].getRGBColor(), 1.0, 0.5, 1.0, doc->toolSettings.dPen, 100);
517 fschmid 1646
                                        }
4026 craig 1647
                                        Neu->Language = ScMW->GetLang(pg.attribute("LANGUAGE", doc->Language));
1648
                                        Neu->isAutoText = static_cast<bool>(pg.attribute("AUTOTEXT").toInt());
1649
                                        Neu->isEmbedded = static_cast<bool>(pg.attribute("isInline", "0").toInt());
1650
                                        Neu->gXpos = pg.attribute("gXpos", "0.0").toDouble();
1651
                                        Neu->gYpos = pg.attribute("gYpos", "0.0").toDouble();
2955 fschmid 1652
                                        QString defaultVal;
3934 cbradney 1653
                                        defaultVal.setNum(Neu->width());
4026 craig 1654
                                        Neu->gWidth = pg.attribute("gWidth",defaultVal).toDouble();
3934 cbradney 1655
                                        defaultVal.setNum(Neu->height());
4026 craig 1656
                                        Neu->gHeight = pg.attribute("gHeight",defaultVal).toDouble();
4584 cbradney 1657
                                        if (Neu->lineSpacingMode() == 3)
2309 fschmid 1658
                                        {
1659
                                                doc->docParagraphStyles[0].BaseAdj = true;
4584 cbradney 1660
                                                Neu->setLineSpacing(doc->typographicSettings.valueBaseGrid-1);
2309 fschmid 1661
                                        }
517 fschmid 1662
                                        if (Neu->isAutoText)
1663
                                                doc->LastAuto = Neu;
4026 craig 1664
                                        Neu->NextIt = pg.attribute("NEXTITEM").toInt();
517 fschmid 1665
                                        if (Neu->isTableItem)
1666