Subversion Repositories Scribus

Rev

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

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