Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
3 paul 1
/***************************************************************************
2
                        scribusXml.cpp the document xml library for scribus
3
                             -------------------
4
    begin                : Sam Jul 14 10:00:00 CEST 2001
167 Franz 5
    copyright            : (C) 2001 by Christian T�p
3 paul 6
    email                : christian.toepp@mr-ct@gmx.de
7
 ***************************************************************************/
75 Franz 8
 
3 paul 9
#include "scribusXml.h"
10
#include "scribusXml.moc"
11
#include <qfile.h>
12
#include <qtextstream.h>
13
#include <qapplication.h>
14
#include <qstylefactory.h>
15
#include <qtl.h>
16
#include <qcursor.h>
17
#include <qregexp.h>
18
#include <qdir.h>
19
#include <qtextcodec.h>
20
#include <cstdlib>
21
#include <cmath>
22
#include "missing.h"
456 fschmid 23
#include "pageitem.h"
1087 cbradney 24
#include "splash.h"
1525 cbradney 25
#include "units.h"
128 Franz 26
 
1542 cbradney 27
#include <iostream>
28
 
617 cbradney 29
#ifdef _MSC_VER
30
 #if (_MSC_VER >= 1200)
31
  #include "win-config.h"
32
 #endif
128 Franz 33
#else
34
 #include "config.h"
35
#endif
36
 
3 paul 37
#ifdef HAVE_LIBZ
38
#include <zlib.h>
39
#endif
325 Franz 40
 
504 cbradney 41
using namespace std;
42
 
80 Franz 43
extern double QStodouble(QString in);
3 paul 44
extern int QStoInt(QString in);
45
extern bool loadText(QString nam, QString *Buffer);
19 Franz 46
extern QString Path2Relative(QString Path);
1065 cbradney 47
extern void GetItemProps(bool newVersion, QDomElement *obj, struct CopyPasteBuffer *OB);
690 cbradney 48
extern QColor SetColor(ScribusDoc *currentDoc, QString color, int shad);
3 paul 49
 
383 Franz 50
/*!
51
        \fn ScriXmlDoc::IsScribus(QString fileName)
421 Franz 52
        \author Frederic Dubuy <effediwhy@gmail.com>, Petr Vanek
53
        \date august 17th 2004, 10/03/2004
54
        \brief Preliminary Scribus file validator. totally rewritten when fixing crash bug #1092. It's much simpler now.
383 Franz 55
        \param Qtring filename of file to test
56
        \retval true = Scribus format file, false : not Scribus
57
*/
58
bool ScriXmlDoc::IsScribus(QString fileName)
59
{
421 Franz 60
        QString fText = ReadDatei(fileName);
61
        if ((fText == "") || (!fText.startsWith("<SCRIBUS")) || (fText.contains("<PAGE ", TRUE) == 0))
456 fschmid 62
                return false;
421 Franz 63
        return true;
383 Franz 64
}
65
 
3 paul 66
QString ScriXmlDoc::ReadDatei(QString fileName)
67
{
456 fschmid 68
/**
69
  * added to support gz docs
70
  * 2.7.2002 C.Toepp
71
  * <c.toepp@gmx.de>
72
  */
167 Franz 73
        QString f = "";
3 paul 74
#ifdef HAVE_LIBZ
167 Franz 75
        if(fileName.right(2) == "gz")
3 paul 76
        {
167 Franz 77
                gzFile gzDoc;
78
                char buff[4097];
79
                int i;
80
                gzDoc = gzopen(fileName.latin1(),"rb");
81
                if(gzDoc == NULL)
82
                        return "";
83
                while((i = gzread(gzDoc,&buff,4096)) > 0)
3 paul 84
                {
167 Franz 85
                        buff[i] = '\0';
86
                        f.append(buff);
3 paul 87
                }
167 Franz 88
                gzclose(gzDoc);
3 paul 89
        }
167 Franz 90
        else
3 paul 91
// a normal document
167 Franz 92
                loadText(fileName, &f);
93
#else
3 paul 94
        loadText(fileName, &f);
95
#endif
167 Franz 96
        QString ff = "";
97
        if (f.startsWith("<SCRIBUSUTF8"))
98
                ff = QString::fromUtf8(f);
383 Franz 99
        else if (f.startsWith("<SCRIBUS"))
167 Franz 100
                ff = f;
1874 fschmid 101
        if (ff.endsWith(QChar(10)) || ff.endsWith(QChar(13)))
102
                ff.truncate(ff.length()-1);
167 Franz 103
        return ff;
3 paul 104
/** end changes */
105
}
106
 
1789 fschmid 107
QString ScriXmlDoc::GetItemText(QDomElement *it, ScribusDoc *doc, ApplicationPrefs *Prefs, bool VorLFound, bool impo, bool docreading, PageItem* obj)
332 Franz 108
{
517 fschmid 109
        QString tmp2, tmf, tmpf, tmp3, tmp;
332 Franz 110
        tmp = "";
517 fschmid 111
        tmp2 = it->attribute("CH");
112
        tmp2.replace(QRegExp("\r"), QChar(5));
113
        tmp2.replace(QRegExp("\n"), QChar(5));
114
        tmp2.replace(QRegExp("\t"), QChar(4));
1194 fschmid 115
        tmpf = it->attribute("CFONT", doc->toolSettings.defFont);
1428 fschmid 116
        if (docreading)
117
        {
1789 fschmid 118
                bool unknown = false;
119
                struct ScText *hg;
120
                Foi* dummy;
1428 fschmid 121
                if ((!Prefs->AvailFonts.find(tmpf)) || (!Prefs->AvailFonts[tmpf]->UseFont))
122
                {
1789 fschmid 123
                        bool isThere = false;
124
                        for (uint dl = 0; dl < dummyFois.count(); ++dl)
125
                        {
126
                                if (dummyFois.at(dl)->SCName == tmpf)
127
                                {
128
                                        isThere = true;
129
                                        dummy = dummyFois.at(dl);
130
                                        break;
131
                                }
132
                        }
133
                        if (!isThere)
134
                        {
135
                                dummy = new Foi(tmpf, "", false);
136
                                dummyFois.append(dummy);
137
                        }
138
                        unknown = true;
1428 fschmid 139
                        if ((!Prefs->GFontSub.contains(tmpf)) || (!Prefs->AvailFonts[Prefs->GFontSub[tmpf]]->UseFont))
1468 fschmid 140
                        {
141
                                newReplacement = true;
1428 fschmid 142
                                ReplacedFonts.insert(tmpf, Prefs->toolSettings.defFont);
1468 fschmid 143
                        }
1428 fschmid 144
                        else
145
                                ReplacedFonts.insert(tmpf, Prefs->GFontSub[tmpf]);
146
                }
147
                else
148
                {
1786 fschmid 149
                        if (!doc->UsedFonts.contains(tmpf))
150
                        {
151
                                QFont fo = Prefs->AvailFonts[tmpf]->Font;
152
                                fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
153
                                doc->AddFont(tmpf, fo);
154
                        }
1428 fschmid 155
                }
1789 fschmid 156
                int size = qRound(QStodouble(it->attribute("CSIZE")) * 10);
157
                QString fcolor = it->attribute("CCOLOR");
158
                double extra = QStodouble(it->attribute("CEXTRA"));
159
                int shade = QStoInt(it->attribute("CSHADE"));
2228 fschmid 160
                int style = QStoInt(it->attribute("CSTYLE")) & 255;
1789 fschmid 161
                int ab = QStoInt(it->attribute("CAB","0"));
162
                QString stroke = it->attribute("CSTROKE","None");
163
                int shade2 = QStoInt(it->attribute("CSHADE2","100"));
2242 fschmid 164
                int scale = qRound(QStodouble(it->attribute("CSCALE","100")) * 10);
165
                int scalev = qRound(QStodouble(it->attribute("CSCALEV","100")) * 10);
166
                int base = qRound(QStodouble(it->attribute("CBASE","0")) * 10);
2247 fschmid 167
                int shX = qRound(QStodouble(it->attribute("CSHX","5")) * 10);
168
                int shY = qRound(QStodouble(it->attribute("CSHY","-5")) * 10);
2257 fschmid 169
                int outL = qRound(QStodouble(it->attribute("COUT","1")) * 10);
2262 fschmid 170
                int ulp = qRound(QStodouble(it->attribute("CULP","-0.1")) * 10);
171
                int ulw = qRound(QStodouble(it->attribute("CULW","-0.1")) * 10);
1789 fschmid 172
                for (uint cxx=0; cxx<tmp2.length(); ++cxx)
173
                {
174
                        hg = new ScText;
175
                        hg->ch = tmp2.at(cxx);
176
                        if (hg->ch == QChar(5))
177
                                hg->ch = QChar(13);
178
                        if (hg->ch == QChar(4))
179
                                hg->ch = QChar(9);
180
                        if (unknown)
181
                                hg->cfont = dummy;
182
                        else
183
                                hg->cfont = (*doc->AllFonts)[tmpf];
184
                        hg->csize = size;
185
                        hg->ccolor = fcolor;
186
                        hg->cextra = extra;
187
                        hg->cshade = shade;
188
                        hg->cselect = false;
189
                        hg->cstyle = style;
190
                        hg->cab = ab;
191
                        hg->cstroke = stroke;
192
                        hg->cshade2 = shade2;
2242 fschmid 193
                        hg->cscale = QMIN(QMAX(scale, 100), 4000);
194
                        hg->cscalev = QMIN(QMAX(scalev, 100), 4000);
2234 fschmid 195
                        hg->cbase = base;
2247 fschmid 196
                        hg->cshadowx = shX;
197
                        hg->cshadowy = shY;
2257 fschmid 198
                        hg->coutline = outL;
2262 fschmid 199
                        hg->cunderpos = ulp;
200
                        hg->cunderwidth = ulw;
1789 fschmid 201
                        hg->xp = 0;
202
                        hg->yp = 0;
203
                        hg->PRot = 0;
204
                        hg->PtransX = 0;
205
                        hg->PtransY = 0;
206
                        obj->itemText.append(hg);
207
                }
208
                return "";
1428 fschmid 209
        }
332 Franz 210
        else
1428 fschmid 211
        {
212
                if (tmpf == "")
213
                        tmpf = doc->toolSettings.defFont;
214
                tmf = tmpf;
215
                if (!DoFonts.contains(tmpf))
216
                        tmpf = AskForFont(Prefs->AvailFonts, tmpf, Prefs, doc);
217
                else
218
                        tmpf = DoFonts[tmf];
219
        }
517 fschmid 220
        tmp3 = "\t" + tmpf + "\t";
221
        tmp3 += it->attribute("CSIZE") + "\t";
222
        tmp3 += it->attribute("CCOLOR") + "\t";
223
        tmp3 += it->attribute("CEXTRA") + "\t";
224
        tmp3 += it->attribute("CSHADE") + "\t";
2228 fschmid 225
        QString tmp4;
226
        tmp3 += tmp4.setNum(QStoInt(it->attribute("CSTYLE")) & 255) + "\t";
517 fschmid 227
        if (impo)
332 Franz 228
        {
517 fschmid 229
                if (VorLFound)
230
                        tmp3 += DoVorl[it->attribute("CAB","0").toUInt()] + "\t";
231
                else
332 Franz 232
                {
517 fschmid 233
                        if (it->attribute("CAB","0").toUInt() < 5)
234
                                tmp3 += it->attribute("CAB","0")+"\t";
235
                        else
236
                                tmp3 += "0\t";
332 Franz 237
                }
238
        }
239
        else
517 fschmid 240
                tmp3 += it->attribute("CAB","0") + "\t";
241
        tmp3 += it->attribute("CSTROKE","None") + "\t";
242
        tmp3 += it->attribute("CSHADE2","100") + "\t";
2242 fschmid 243
        int scale = qRound(QStodouble(it->attribute("CSCALE","100")) * 10);
244
        int scalev = qRound(QStodouble(it->attribute("CSCALEV","100")) * 10);
245
        int base = qRound(QStodouble(it->attribute("CBASE","0")) * 10);
2247 fschmid 246
        int shX = qRound(QStodouble(it->attribute("CSHX","5")) * 10);
247
        int shY = qRound(QStodouble(it->attribute("CSHY","-5")) * 10);
2257 fschmid 248
        int outL = qRound(QStodouble(it->attribute("COUT","1")) * 10);
2262 fschmid 249
        int ulp = qRound(QStodouble(it->attribute("CULP","-0.1")) * 10);
250
        int ulw = qRound(QStodouble(it->attribute("CULW","-0.1")) * 10);
2242 fschmid 251
        tmp3 += tmp4.setNum(scale) + "\t";
252
        tmp3 += tmp4.setNum(scalev) + "\t";
2247 fschmid 253
        tmp3 += tmp4.setNum(base) + "\t";
254
        tmp3 += tmp4.setNum(shX) + "\t";
2257 fschmid 255
        tmp3 += tmp4.setNum(shY) + "\t";
2262 fschmid 256
        tmp3 += tmp4.setNum(outL) + "\t";
257
        tmp3 += tmp4.setNum(ulp) + "\t";
258
        tmp3 += tmp4.setNum(ulw) + "\n";
517 fschmid 259
        for (uint cxx=0; cxx<tmp2.length(); ++cxx)
260
                tmp += tmp2.at(cxx)+tmp3;
261
        return tmp;
262
}
263
 
1065 cbradney 264
QString ScriXmlDoc::AskForFont(SCFonts &avail, QString fStr, ApplicationPrefs *Prefs, ScribusDoc *doc)
517 fschmid 265
{
266
        QFont fo;
267
        QString tmpf = fStr;
268
        if ((!avail.find(tmpf)) || (!avail[tmpf]->UseFont))
340 Franz 269
        {
517 fschmid 270
                if ((!Prefs->GFontSub.contains(tmpf)) || (!avail[Prefs->GFontSub[tmpf]]->UseFont))
340 Franz 271
                {
517 fschmid 272
                        qApp->setOverrideCursor(QCursor(arrowCursor), true);
1143 fschmid 273
                        MissingFont *dia = new MissingFont(0, tmpf, Prefs, doc);
517 fschmid 274
                        dia->exec();
713 cbradney 275
                        tmpf = dia->getReplacementFont();
517 fschmid 276
                        delete dia;
277
                        qApp->setOverrideCursor(QCursor(waitCursor), true);
278
                        Prefs->GFontSub[fStr] = tmpf;
340 Franz 279
                }
517 fschmid 280
                else
281
                        tmpf = Prefs->GFontSub[tmpf];
1166 fschmid 282
                ReplacedFonts[fStr] = tmpf;
340 Franz 283
        }
1786 fschmid 284
        if (!doc->UsedFonts.contains(tmpf))
285
        {
286
                fo = avail[tmpf]->Font;
287
                fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
288
                doc->AddFont(tmpf, fo);
289
        }
517 fschmid 290
        DoFonts[fStr] = tmpf;
291
        return tmpf;
332 Franz 292
}
293
 
517 fschmid 294
void ScriXmlDoc::SetItemProps(QDomElement *ob, PageItem* item, bool newFormat)
332 Franz 295
{
456 fschmid 296
        double xf, yf, xo, yo;
332 Franz 297
        QString tmp, tmpy;
517 fschmid 298
        if ((item->OwnPage == -1) || (newFormat))
456 fschmid 299
        {
300
                xo = 0;
301
                yo = 0;
302
        }
303
        else
304
        {
305
                xo = item->Doc->Pages.at(item->OwnPage)->Xoffset;
306
                yo = item->Doc->Pages.at(item->OwnPage)->Yoffset;
307
        }
522 fschmid 308
        if (newFormat)
309
                ob->setAttribute("OwnPage", item->OwnPage);
1460 cbradney 310
        ob->setAttribute("PTYPE",item->itemType());
456 fschmid 311
        ob->setAttribute("XPOS",item->Xpos - xo);
312
        ob->setAttribute("YPOS",item->Ypos - yo);
332 Franz 313
        ob->setAttribute("WIDTH",item->Width);
314
        ob->setAttribute("HEIGHT",item->Height);
315
        ob->setAttribute("RADRECT",item->RadRect);
316
        ob->setAttribute("FRTYPE", item->FrameType);
317
        ob->setAttribute("CLIPEDIT", item->ClipEdited ? 1 : 0);
318
        ob->setAttribute("PWIDTH",item->Pwidth);
1394 cbradney 319
        ob->setAttribute("PCOLOR",item->fillColor());
320
        ob->setAttribute("PCOLOR2",item->lineColor());
332 Franz 321
        ob->setAttribute("TXTFILL",item->TxtFill);
322
        ob->setAttribute("TXTSTROKE",item->TxtStroke);
323
        ob->setAttribute("TXTSTRSH",item->ShTxtStroke);
324
        ob->setAttribute("TXTFILLSH",item->ShTxtFill);
2242 fschmid 325
        ob->setAttribute("TXTSCALE",item->TxtScale / 10.0);
326
        ob->setAttribute("TXTSCALEV",item->TxtScaleV / 10.0);
327
        ob->setAttribute("TXTBASE",item->TxtBase / 10.0);
2247 fschmid 328
        ob->setAttribute("TXTSHX",item->TxtShadowX / 10.0);
329
        ob->setAttribute("TXTSHY",item->TxtShadowY / 10.0);
2257 fschmid 330
        ob->setAttribute("TXTOUT",item->TxtOutline / 10.0);
2262 fschmid 331
        ob->setAttribute("TXTULP",item->TxtUnderPos / 10.0);
332
        ob->setAttribute("TXTULW",item->TxtUnderWidth / 10.0);
332 Franz 333
        ob->setAttribute("TXTSTYLE",item->TxTStyle);
334
        ob->setAttribute("COLUMNS", item->Cols);
335
        ob->setAttribute("COLGAP", item->ColGap);
336
        ob->setAttribute("NAMEDLST",item->NamedLStyle);
1394 cbradney 337
        ob->setAttribute("SHADE",item->fillShade());
338
        ob->setAttribute("SHADE2",item->lineShade());
332 Franz 339
        ob->setAttribute("GRTYP",item->GrType);
340
        ob->setAttribute("ROT",item->Rot);
341
        ob->setAttribute("PLINEART",item->PLineArt);
342
        ob->setAttribute("PLINEEND", item->PLineEnd);
343
        ob->setAttribute("PLINEJOIN", item->PLineJoin);
344
        ob->setAttribute("LINESP",item->LineSp);
345
        ob->setAttribute("EXTRAV",item->ExtraV);
346
        ob->setAttribute("LOCALSCX",item->LocalScX);
347
        ob->setAttribute("LOCALSCY",item->LocalScY);
348
        ob->setAttribute("LOCALX",item->LocalX);
349
        ob->setAttribute("LOCALY",item->LocalY);
350
        ob->setAttribute("PICART", item->PicArt ? 1 : 0);
351
        ob->setAttribute("PLTSHOW", item->PoShow ? 1 : 0);
352
        ob->setAttribute("BASEOF", item->BaseOffs);
1392 cbradney 353
        ob->setAttribute("FLIPPEDH", item->imageFlippedH());
354
        ob->setAttribute("FLIPPEDV", item->imageFlippedV());
332 Franz 355
        ob->setAttribute("BBOXX",item->BBoxX);
356
        ob->setAttribute("BBOXH",item->BBoxH);
357
        ob->setAttribute("IFONT",item->IFont);
358
        ob->setAttribute("ISIZE",item->ISize / 10.0 );
359
        ob->setAttribute("SCALETYPE", item->ScaleType ? 1 : 0);
360
        ob->setAttribute("RATIO", item->AspectRatio ? 1 : 0);
361
        ob->setAttribute("PRINTABLE", item->isPrintable ? 1 : 0);
362
        if(item->isAnnotation)
363
        {
364
                ob->setAttribute("ANNOTATION",1);
365
                ob->setAttribute("ANTYPE", item->AnType);
366
                ob->setAttribute("ANACTION", item->AnAction);
367
                ob->setAttribute("ANEACT", item->An_E_act);
368
                ob->setAttribute("ANXACT", item->An_X_act);
369
                ob->setAttribute("ANDACT", item->An_D_act);
370
                ob->setAttribute("ANFOACT", item->An_Fo_act);
371
                ob->setAttribute("ANBLACT", item->An_Bl_act);
372
                ob->setAttribute("ANKACT", item->An_K_act);
373
                ob->setAttribute("ANFACT", item->An_F_act);
374
                ob->setAttribute("ANVACT", item->An_V_act);
375
                ob->setAttribute("ANCACT", item->An_C_act);
376
                if (item->AnActType == 8)
377
                        ob->setAttribute("ANEXTERN", item->An_Extern);
378
                else
379
                        ob->setAttribute("ANEXTERN", Path2Relative(item->An_Extern));
380
                ob->setAttribute("ANZIEL", item->AnZiel);
381
                ob->setAttribute("ANACTYP", item->AnActType);
382
                ob->setAttribute("ANTOOLTIP", item->AnToolTip);
383
                ob->setAttribute("ANBWID", item->AnBwid);
384
                ob->setAttribute("ANBSTY", item->AnBsty);
385
                ob->setAttribute("ANFEED", item->AnFeed);
386
                ob->setAttribute("ANFLAG", item->AnFlag);
387
                ob->setAttribute("ANFONT", item->AnFont);
388
                ob->setAttribute("ANFORMAT", item->AnFormat);
389
                ob->setAttribute("ANROLL", item->AnRollOver);
390
                ob->setAttribute("ANDOWN", item->AnDown);
391
                ob->setAttribute("ANVIS", item->AnVis);
392
                ob->setAttribute("ANMC", item->AnMaxChar);
393
                ob->setAttribute("ANCHK", item->AnIsChk);
394
                ob->setAttribute("ANAA", item->AnAAact);
395
                ob->setAttribute("ANCHKS", item->AnChkStil);
396
                ob->setAttribute("ANBCOL", item->AnBColor);
397
                ob->setAttribute("ANHTML", item->AnHTML);
398
                ob->setAttribute("ANICON", item->AnUseIcons);
399
                ob->setAttribute("ANPLACE", item->AnIPlace);
400
                ob->setAttribute("ANSCALE", item->AnScaleW);
401
        }
402
        else
403
                ob->setAttribute("ANNOTATION",0);
1361 tsoots 404
        ob->setAttribute("ANNAME", !item->AutoName ? item->itemName() : QString(""));
1653 craig 405
        ob->setAttribute("TEXTFLOW", item->textFlowsAroundFrame() ? 1 : 0);
406
        ob->setAttribute("TEXTFLOW2", item->textFlowUsesBoundingBox() ? 1 : 0);
1656 craig 407
        ob->setAttribute("TEXTFLOW3", item->textFlowUsesContourLine() ? 1 : 0);
332 Franz 408
        ob->setAttribute("AUTOTEXT", item->isAutoText ? 1 : 0);
409
        ob->setAttribute("EXTRA",item->Extra);
410
        ob->setAttribute("TEXTRA",item->TExtra);
411
        ob->setAttribute("BEXTRA",item->BExtra);
412
        ob->setAttribute("REXTRA",item->RExtra);
1460 cbradney 413
        if (((item->itemType() == PageItem::ImageFrame) || (item->itemType() == PageItem::TextFrame)) && (item->Pfile != ""))
332 Franz 414
                ob->setAttribute("PFILE",Path2Relative(item->Pfile));
415
        else
416
                ob->setAttribute("PFILE","");
417
        if (item->Pfile2 != "")
418
                ob->setAttribute("PFILE2",Path2Relative(item->Pfile2));
419
        else
420
                ob->setAttribute("PFILE2","");
421
        if (item->Pfile3 != "")
422
                ob->setAttribute("PFILE3",Path2Relative(item->Pfile3));
423
        else
424
                ob->setAttribute("PFILE3","");
425
        ob->setAttribute("PRFILE",item->IProfile);
426
        ob->setAttribute("EPROF", item->EmProfile);
427
        ob->setAttribute("IRENDER",item->IRender);
428
        ob->setAttribute("EMBEDDED", item->UseEmbedded ? 1 : 0);
1392 cbradney 429
        ob->setAttribute("LOCK", item->locked() ? 1 : 0);
430
        ob->setAttribute("LOCKR", item->sizeLocked() ? 1 : 0);
332 Franz 431
        ob->setAttribute("REVERS", item->Reverse ? 1 : 0);
1394 cbradney 432
        ob->setAttribute("TransValue", item->fillTransparency());
433
        ob->setAttribute("TransValueS", item->lineTransparency());
332 Franz 434
        ob->setAttribute("isTableItem", static_cast<int>(item->isTableItem));
435
        ob->setAttribute("TopLine", static_cast<int>(item->TopLine));
436
        ob->setAttribute("LeftLine", static_cast<int>(item->LeftLine));
437
        ob->setAttribute("RightLine", static_cast<int>(item->RightLine));
438
        ob->setAttribute("BottomLine", static_cast<int>(item->BottomLine));
439
        if (item->isTableItem)
440
        {
441
                if (item->TopLink != 0)
442
                        ob->setAttribute("TopLINK", item->TopLink->ItemNr);
443
                else
444
                        ob->setAttribute("TopLINK", -1);
445
                if (item->LeftLink != 0)
446
                        ob->setAttribute("LeftLINK", item->LeftLink->ItemNr);
447
                else
448
                        ob->setAttribute("LeftLINK", -1);
449
                if (item->RightLink != 0)
450
                        ob->setAttribute("RightLINK", item->RightLink->ItemNr);
451
                else
452
                        ob->setAttribute("RightLINK", -1);
453
                if (item->BottomLink != 0)
454
                        ob->setAttribute("BottomLINK", item->BottomLink->ItemNr);
455
                else
456
                        ob->setAttribute("BottomLINK", -1);
457
                ob->setAttribute("OwnLINK", item->ItemNr);
458
        }
459
        ob->setAttribute("NUMDASH", static_cast<int>(item->DashValues.count()));
460
        QString dlp = "";
461
        QValueList<double>::Iterator dax;
462
        for (dax = item->DashValues.begin(); dax != item->DashValues.end(); ++dax)
463
                dlp += tmp.setNum((*dax)) + " ";
464
        ob->setAttribute("DASHS", dlp);
465
        ob->setAttribute("DASHOFF", item->DashOffset);
466
        ob->setAttribute("NUMPO",item->PoLine.size());
467
        QString polp = "";
468
        for (uint nxx=0; nxx<item->PoLine.size(); ++nxx)
469
        {
470
                item->PoLine.point(nxx, &xf, &yf);
471
                polp += tmp.setNum(xf) + " " + tmpy.setNum(yf) + " ";
472
        }
473
        ob->setAttribute("POCOOR", polp);
340 Franz 474
        ob->setAttribute("NUMCO",item->ContourLine.size());
475
        QString colp = "";
476
        for (uint nxx=0; nxx<item->ContourLine.size(); ++nxx)
477
        {
478
                item->ContourLine.point(nxx, &xf, &yf);
479
                colp += tmp.setNum(xf) + " " + tmpy.setNum(yf) + " ";
480
        }
481
        ob->setAttribute("COCOOR", colp);
332 Franz 482
        ob->setAttribute("NUMTAB", static_cast<int>(item->TabValues.count()));
483
        QString tlp = "";
484
        QValueList<double>::Iterator tax;
485
        for (tax = item->TabValues.begin(); tax != item->TabValues.end(); ++tax)
486
                tlp += tmp.setNum((*tax)) + " ";
487
        ob->setAttribute("TABS", tlp);
488
        ob->setAttribute("NUMGROUP", static_cast<int>(item->Groups.count()));
489
        QString glp = "";
490
        QValueStack<int>::Iterator nx;
491
        for (nx = item->Groups.begin(); nx != item->Groups.end(); ++nx)
492
                glp += tmp.setNum((*nx)) + " ";
493
        ob->setAttribute("GROUPS", glp);
494
        ob->setAttribute("LANGUAGE", item->Language);
741 fschmid 495
        ob->setAttribute("startArrowIndex", item->startArrowIndex);
496
        ob->setAttribute("endArrowIndex", item->endArrowIndex);
332 Franz 497
}
498
 
118 Franz 499
bool ScriXmlDoc::ReadLStyles(QString fileName, QMap<QString,multiLine> *Sty)
500
{
501
        QDomDocument docu("scridoc");
502
        QString f = "";
503
        f = ReadDatei(fileName);
504
        if (f == "")
505
                return false;
506
        if(!docu.setContent(f))
507
                return false;
508
        QDomElement elem=docu.documentElement();
509
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
510
                return false;
511
        QDomNode DOC=elem.firstChild();
512
        while(!DOC.isNull())
167 Franz 513
        {
118 Franz 514
                QDomElement dc=DOC.toElement();
515
                QDomNode PAGE=DOC.firstChild();
516
                while(!PAGE.isNull())
167 Franz 517
                {
118 Franz 518
                        QDomElement pg=PAGE.toElement();
519
                        if(pg.tagName()=="MultiLine")
167 Franz 520
                        {
118 Franz 521
                                multiLine ml;
522
                                QDomNode MuLn = PAGE.firstChild();
523
                                while(!MuLn.isNull())
167 Franz 524
                                {
118 Franz 525
                                        QDomElement MuL = MuLn.toElement();
1065 cbradney 526
                                        struct SingleLine sl;
118 Franz 527
                                        sl.Color = MuL.attribute("Color");
528
                                        sl.Dash = QStoInt(MuL.attribute("Dash"));
529
                                        sl.LineEnd = QStoInt(MuL.attribute("LineEnd"));
530
                                        sl.LineJoin = QStoInt(MuL.attribute("LineJoin"));
531
                                        sl.Shade = QStoInt(MuL.attribute("Shade"));
532
                                        sl.Width = QStodouble(MuL.attribute("Width"));
533
                                        ml.push_back(sl);
534
                                        MuLn = MuLn.nextSibling();
167 Franz 535
                                }
118 Franz 536
                                QString Nam = pg.attribute("Name");
537
                                QString Nam2 = Nam;
538
                                int copyC = 1;
539
                                while (Sty->contains(Nam2))
167 Franz 540
                                {
118 Franz 541
                                        Nam2 = tr("Copy #%1 of ").arg(copyC)+Nam;
542
                                        copyC++;
167 Franz 543
                                }
118 Franz 544
                                Sty->insert(Nam2, ml);
167 Franz 545
                        }
118 Franz 546
                        PAGE=PAGE.nextSibling();
167 Franz 547
                }
118 Franz 548
                DOC=DOC.nextSibling();
167 Franz 549
        }
118 Franz 550
        return true;
551
}
552
 
1065 cbradney 553
void ScriXmlDoc::GetStyle(QDomElement *pg, struct ParagraphStyle *vg, QValueList<ParagraphStyle> &docParagraphStyles, ScribusDoc* doc, ApplicationPrefs *Prefs, bool fl)
332 Franz 554
{
555
        bool fou;
556
        QString tmpf, tmf, tmV;
557
        double xf;
558
        fou = false;
559
        vg->Vname = pg->attribute("NAME");
560
        vg->LineSpa = QStodouble(pg->attribute("LINESP"));
561
        vg->Indent = QStodouble(pg->attribute("INDENT","0"));
562
        vg->First = QStodouble(pg->attribute("FIRST","0"));
1065 cbradney 563
        vg->textAlignment = QStoInt(pg->attribute("ALIGN"));
564
        vg->gapBefore = QStodouble(pg->attribute("VOR","0"));
565
        vg->gapAfter = QStodouble(pg->attribute("NACH","0"));
1194 fschmid 566
        tmpf = pg->attribute("FONT", doc->toolSettings.defFont);
332 Franz 567
        if (tmpf == "")
1194 fschmid 568
                tmpf = doc->toolSettings.defFont;
332 Franz 569
        tmf = tmpf;
570
        if (!DoFonts.contains(tmpf))
571
                tmpf = AskForFont(Prefs->AvailFonts, tmpf, Prefs, doc);
572
        else
573
                tmpf = DoFonts[tmf];
574
        vg->Font = tmpf;
575
        vg->FontSize = qRound(QStodouble(pg->attribute("FONTSIZE","12")) * 10.0);
576
        vg->Drop = static_cast<bool>(QStoInt(pg->attribute("DROP","0")));
577
        vg->DropLin = QStoInt(pg->attribute("DROPLIN","2"));
578
        vg->FontEffect = QStoInt(pg->attribute("EFFECT","0"));
1194 fschmid 579
        vg->FColor = pg->attribute("FCOLOR", doc->toolSettings.dBrush);
332 Franz 580
        vg->FShade = QStoInt(pg->attribute("FSHADE", "100"));
1194 fschmid 581
        vg->SColor = pg->attribute("SCOLOR", doc->toolSettings.dPen);
332 Franz 582
        vg->SShade = QStoInt(pg->attribute("SSHADE", "100"));
583
        vg->BaseAdj = static_cast<bool>(QStoInt(pg->attribute("BASE","0")));
584
        if ((pg->hasAttribute("NUMTAB")) && (QStoInt(pg->attribute("NUMTAB","0")) != 0))
585
        {
586
                QString tmp = pg->attribute("TABS");
587
                QTextStream tgv(&tmp, IO_ReadOnly);
588
                vg->TabValues.clear();
589
                for (int cxv = 0; cxv < QStoInt(pg->attribute("NUMTAB","0")); ++cxv)
590
                {
591
                        tgv >> xf;
592
                        vg->TabValues.append(xf);
593
                }
594
                tmp = "";
595
        }
596
        else
597
                vg->TabValues.clear();
2219 fschmid 598
        vg->tabFillChar = pg->attribute("TabFill", "");
1065 cbradney 599
        for (uint xx=0; xx<docParagraphStyles.count(); ++xx)
332 Franz 600
        {
1065 cbradney 601
                if (vg->Vname == docParagraphStyles[xx].Vname)
332 Franz 602
                {
1065 cbradney 603
                        if ((vg->LineSpa == docParagraphStyles[xx].LineSpa) &&
604
                                        (vg->Indent == docParagraphStyles[xx].Indent) &&
605
                                        (vg->First == docParagraphStyles[xx].First) &&
606
                                        (vg->textAlignment == docParagraphStyles[xx].textAlignment) &&
607
                                        (vg->gapBefore == docParagraphStyles[xx].gapBefore) &&
608
                                        (vg->gapAfter == docParagraphStyles[xx].gapAfter) &&
609
                                        (vg->Font == docParagraphStyles[xx].Font) &&
610
                                        (vg->TabValues == docParagraphStyles[xx].TabValues) &&
611
                                        (vg->Drop == docParagraphStyles[xx].Drop) &&
612
                                        (vg->DropLin == docParagraphStyles[xx].DropLin) &&
613
                                        (vg->FontEffect == docParagraphStyles[xx].FontEffect) &&
614
                                        (vg->FColor == docParagraphStyles[xx].FColor) &&
615
                                        (vg->FShade == docParagraphStyles[xx].FShade) &&
616
                                        (vg->SColor == docParagraphStyles[xx].SColor) &&
617
                                        (vg->SShade == docParagraphStyles[xx].SShade) &&
618
                                        (vg->BaseAdj == docParagraphStyles[xx].BaseAdj) &&
2219 fschmid 619
                                        (vg->tabFillChar == docParagraphStyles[xx].tabFillChar) &&
1065 cbradney 620
                                        (vg->FontSize == docParagraphStyles[xx].FontSize))
335 Franz 621
                        {
622
                                if (fl)
623
                                {
624
                                        DoVorl[VorlC] = tmV.setNum(xx);
625
                                        VorlC++;
626
                                }
332 Franz 627
                                fou = true;
335 Franz 628
                        }
332 Franz 629
                        else
630
                        {
1065 cbradney 631
                                vg->Vname = "Copy of "+docParagraphStyles[xx].Vname;
332 Franz 632
                                fou = false;
633
                        }
634
                        break;
635
                }
636
        }
637
        if (!fou)
638
        {
1065 cbradney 639
                for (uint xx=0; xx< docParagraphStyles.count(); ++xx)
332 Franz 640
                {
1065 cbradney 641
                        if ((vg->LineSpa == docParagraphStyles[xx].LineSpa) &&
642
                                (vg->Indent == docParagraphStyles[xx].Indent) &&
643
                                (vg->First == docParagraphStyles[xx].First) &&
644
                                (vg->textAlignment == docParagraphStyles[xx].textAlignment) &&
645
                                (vg->gapBefore == docParagraphStyles[xx].gapBefore) &&
646
                                (vg->gapAfter == docParagraphStyles[xx].gapAfter) &&
647
                                (vg->Font == docParagraphStyles[xx].Font) &&
648
                                (vg->TabValues == docParagraphStyles[xx].TabValues) &&
649
                                (vg->Drop == docParagraphStyles[xx].Drop) &&
650
                                (vg->DropLin == docParagraphStyles[xx].DropLin) &&
651
                                (vg->FontEffect == docParagraphStyles[xx].FontEffect) &&
652
                                (vg->FColor == docParagraphStyles[xx].FColor) &&
653
                                (vg->FShade == docParagraphStyles[xx].FShade) &&
654
                                (vg->SColor == docParagraphStyles[xx].SColor) &&
655
                                (vg->SShade == docParagraphStyles[xx].SShade) &&
656
                                (vg->BaseAdj == docParagraphStyles[xx].BaseAdj) &&
2219 fschmid 657
                                (vg->tabFillChar == docParagraphStyles[xx].tabFillChar) &&
1065 cbradney 658
                                (vg->FontSize == docParagraphStyles[xx].FontSize))
332 Franz 659
                        {
1065 cbradney 660
                                vg->Vname = docParagraphStyles[xx].Vname;
332 Franz 661
                                fou = true;
662
                                if (fl)
663
                                {
664
                                        DoVorl[VorlC] = tmV.setNum(xx);
665
                                        VorlC++;
666
                                }
667
                                break;
668
                        }
669
                }
670
        }
671
        if (!fou)
672
        {
1065 cbradney 673
                docParagraphStyles.append(*vg);
332 Franz 674
                if (fl)
675
                {
1065 cbradney 676
                        DoVorl[VorlC] = tmV.setNum(docParagraphStyles.count()-1);
332 Franz 677
                        VorlC++;
678
                }
679
        }
680
 
681
}
682
 
1065 cbradney 683
bool ScriXmlDoc::ReadStyles(QString fileName, ScribusDoc* doc, ApplicationPrefs *Prefs)
117 Franz 684
{
1065 cbradney 685
        struct ParagraphStyle vg;
117 Franz 686
        QDomDocument docu("scridoc");
687
        QString f = "";
332 Franz 688
        QString tmpf, tmf;
117 Franz 689
        DoFonts.clear();
690
        f = ReadDatei(fileName);
691
        if (f == "")
692
                return false;
693
        if(!docu.setContent(f))
694
                return false;
695
        QDomElement elem=docu.documentElement();
1884 fschmid 696
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8") && (elem.tagName() != "SCRIBUSUTF8NEW"))
117 Franz 697
                return false;
698
        QDomNode DOC=elem.firstChild();
699
        while(!DOC.isNull())
167 Franz 700
        {
117 Franz 701
                QDomElement dc=DOC.toElement();
702
                QDomNode PAGE=DOC.firstChild();
703
                while(!PAGE.isNull())
167 Franz 704
                {
117 Franz 705
                        QDomElement pg=PAGE.toElement();
706
                        if(pg.tagName()=="STYLE")
1065 cbradney 707
                                GetStyle(&pg, &vg, docParagraphStyles, doc, Prefs, false);
117 Franz 708
                        PAGE=PAGE.nextSibling();
167 Franz 709
                }
117 Franz 710
                DOC=DOC.nextSibling();
167 Franz 711
        }
117 Franz 712
        return true;
713
}
714
 
3 paul 715
bool ScriXmlDoc::ReadColors(QString fileName)
716
{
717
        QDomDocument docu("scridoc");
718
        QString f = "";
719
        f = ReadDatei(fileName);
720
        if (f == "")
721
                return false;
722
        if(!docu.setContent(f))
723
                return false;
724
        Farben.clear();
725
        CMYKColor lf = CMYKColor();
726
        QDomElement elem=docu.documentElement();
1884 fschmid 727
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8") && (elem.tagName() != "SCRIBUSUTF8NEW"))
3 paul 728
                return false;
729
        QDomNode DOC=elem.firstChild();
730
        while(!DOC.isNull())
167 Franz 731
        {
3 paul 732
                QDomElement dc=DOC.toElement();
733
                QDomNode PAGE=DOC.firstChild();
734
                while(!PAGE.isNull())
167 Franz 735
                {
3 paul 736
                        QDomElement pg=PAGE.toElement();
516 fschmid 737
                        // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
738
                        if(pg.tagName()=="COLOR" && pg.attribute("NAME")!="None")
167 Franz 739
                        {
516 fschmid 740
                                if(pg.tagName()=="COLOR")
741
                                {
742
                                        if (pg.hasAttribute("CMYK"))
743
                                                lf.setNamedColor(pg.attribute("CMYK"));
744
                                        else
745
                                                lf.fromQColor(QColor(pg.attribute("RGB")));
746
                                        Farben[pg.attribute("NAME")] = lf;
747
                                }
167 Franz 748
                        }
3 paul 749
                        PAGE=PAGE.nextSibling();
167 Franz 750
                }
3 paul 751
                DOC=DOC.nextSibling();
167 Franz 752
        }
3 paul 753
        return true;
754
}
755
 
118 Franz 756
bool ScriXmlDoc::ReadPageCount(QString fileName, int *num1, int *num2)
3 paul 757
{
167 Franz 758
        QString PgNam;
759
        int counter = 0;
760
        int counter2 = 0;
761
        MNames.clear();
762
        QDomDocument docu("scridoc");
763
        QString f = "";
764
        f = ReadDatei(fileName);
765
        if (f == "")
766
                return false;
767
        if(!docu.setContent(f))
768
                return false;
769
        QDomElement elem=docu.documentElement();
770
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
771
                return false;
772
        QDomNode DOC=elem.firstChild();
773
        while(!DOC.isNull())
3 paul 774
        {
167 Franz 775
                QDomNode PAGE=DOC.firstChild();
776
                while(!PAGE.isNull())
3 paul 777
                {
167 Franz 778
                        QDomElement pg=PAGE.toElement();
779
                        if(pg.tagName()=="PAGE")
3 paul 780
                        {
167 Franz 781
                                PgNam = pg.attribute("NAM", "");
782
                                if (PgNam == "")
783
                                        counter++;
784
                                else
118 Franz 785
                                {
167 Franz 786
                                        counter2++;
787
                                        MNames.append(PgNam);
118 Franz 788
                                }
3 paul 789
                        }
790
                PAGE=PAGE.nextSibling();
791
                }
792
        DOC=DOC.nextSibling();
793
        }
167 Franz 794
        *num1 = counter;
795
        *num2 = counter2;
796
        return true;
3 paul 797
}
798
 
118 Franz 799
bool ScriXmlDoc::ReadPage(QString fileName, SCFonts &avail, ScribusDoc *doc, ScribusView *view, int PageToLoad, bool Mpage)
3 paul 800
{
1065 cbradney 801
        struct CopyPasteBuffer OB;
802
        struct ParagraphStyle vg;
167 Franz 803
        struct Layer la;
804
        struct ScribusDoc::BookMa bok;
805
        struct Linked Link;
806
        PageItem *Neu;
807
        LFrames.clear();
808
        QString tmV, tmp, tmpf, tmp2, tmp3, tmp4, PgNam, f, Defont, tmf;
809
        QFont fo;
234 Franz 810
        QMap<int,int> TableID;
811
        QPtrList<PageItem> TableItems;
332 Franz 812
        int x, a, counter, baseobj;
813
        double xf;
167 Franz 814
        bool newVersion = false;
815
        bool VorLFound = false;
1119 fschmid 816
        QMap<int,int> layerTrans;
817
        int maxLayer = 0;
818
        int maxLevel = 0;
819
        layerTrans.clear();
820
        for (uint la2 = 0; la2 < doc->Layers.count(); ++la2)
821
        {
822
                maxLayer = QMAX(doc->Layers[la2].LNr, maxLayer);
823
                maxLevel = QMAX(doc->Layers[la2].Level, maxLevel);
824
        }
167 Franz 825
        DoVorl.clear();
826
        DoFonts.clear();
1194 fschmid 827
        DoFonts[doc->toolSettings.defFont] = doc->toolSettings.defFont;
167 Franz 828
        DoVorl[0] = "0";
829
        DoVorl[1] = "1";
830
        DoVorl[2] = "2";
831
        DoVorl[3] = "3";
832
        DoVorl[4] = "4";
833
        VorlC = 5;
834
        QDomDocument docu("scridoc");
835
        f = "";
836
        f = ReadDatei(fileName);
837
        if (f == "")
838
                return false;
839
        if(!docu.setContent(f))
840
                return false;
841
        CMYKColor lf = CMYKColor();
842
        QDomElement elem=docu.documentElement();
843
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
844
                return false;
845
        if (elem.hasAttribute("Version"))
846
                newVersion = true;
847
        QDomNode DOC=elem.firstChild();
848
        while(!DOC.isNull())
114 Franz 849
        {
167 Franz 850
                QDomElement dc=DOC.toElement();
3 paul 851
        /*
852
        * Attribute von DOCUMENT auslesen
853
        */
167 Franz 854
                QDomNode PAGE=DOC.firstChild();
855
                while(!PAGE.isNull())
114 Franz 856
                {
167 Franz 857
                        QDomElement pg=PAGE.toElement();
516 fschmid 858
                        // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
859
                        if(pg.tagName()=="COLOR" && pg.attribute("NAME")!="None")
3 paul 860
                        {
167 Franz 861
                                if (pg.hasAttribute("CMYK"))
862
                                        lf.setNamedColor(pg.attribute("CMYK"));
863
                                else
864
                                        lf.fromQColor(QColor(pg.attribute("RGB")));
865
                                doc->PageColors[pg.attribute("NAME")] = lf;
3 paul 866
                        }
167 Franz 867
                        if(pg.tagName()=="STYLE")
3 paul 868
                        {
1065 cbradney 869
                                GetStyle(&pg, &vg, doc->docParagraphStyles, doc, view->Prefs, true);
167 Franz 870
                                VorLFound = true;
3 paul 871
                        }
167 Franz 872
                        if(pg.tagName()=="JAVA")
873
                                doc->JavaScripts[pg.attribute("NAME")] = pg.attribute("SCRIPT");
874
                        if(pg.tagName()=="LAYERS")
3 paul 875
                        {
167 Franz 876
                                la.LNr = QStoInt(pg.attribute("NUMMER"));
877
                                la.Level = QStoInt(pg.attribute("LEVEL"));
878
                                la.Name = pg.attribute("NAME");
1065 cbradney 879
                                la.isViewable = QStoInt(pg.attribute("SICHTBAR"));
880
                                la.isPrintable = QStoInt(pg.attribute("DRUCKEN"));
167 Franz 881
                                bool laex = false;
882
                                for (uint la2 = 0; la2 < doc->Layers.count(); ++la2)
3 paul 883
                                {
167 Franz 884
                                        if (doc->Layers[la2].Name == la.Name)
1119 fschmid 885
                                        {
167 Franz 886
                                                laex = true;
1119 fschmid 887
                                                layerTrans.insert(la.LNr, doc->Layers[la2].LNr);
888
                                        }
3 paul 889
                                }
167 Franz 890
                                if (!laex)
1119 fschmid 891
                                {
892
                                        maxLayer++;
893
                                        maxLevel++;
894
                                        layerTrans.insert(la.LNr, maxLayer);
895
                                        la.LNr = maxLayer;
896
                                        la.Level = maxLevel;
167 Franz 897
                                        doc->Layers.append(la);
1119 fschmid 898
                                }
3 paul 899
                        }
167 Franz 900
                        if(pg.tagName()=="Bookmark")
3 paul 901
                        {
167 Franz 902
                                bok.Title = pg.attribute("Title");
903
                                bok.Text = pg.attribute("Text");
904
                                bok.Aktion = pg.attribute("Aktion");
905
                                bok.ItemNr = QStoInt(pg.attribute("ItemNr"));
906
                                bok.Seite = QStoInt(pg.attribute("Seite"));
907
                                bok.Element = QStoInt(pg.attribute("Element"));
908
                                bok.First = QStoInt(pg.attribute("First"));
909
                                bok.Last = QStoInt(pg.attribute("Last"));
910
                                bok.Prev = QStoInt(pg.attribute("Prev"));
911
                                bok.Next = QStoInt(pg.attribute("Next"));
912
                                bok.Parent = QStoInt(pg.attribute("Parent"));
913
                                doc->BookMarks.append(bok);
3 paul 914
                        }
167 Franz 915
                        if(pg.tagName()=="MultiLine")
31 Franz 916
                        {
167 Franz 917
                                multiLine ml;
918
                                QDomNode MuLn = PAGE.firstChild();
919
                                while(!MuLn.isNull())
31 Franz 920
                                {
167 Franz 921
                                        QDomElement MuL = MuLn.toElement();
1065 cbradney 922
                                        struct SingleLine sl;
167 Franz 923
                                        sl.Color = MuL.attribute("Color");
924
                                        sl.Dash = QStoInt(MuL.attribute("Dash"));
925
                                        sl.LineEnd = QStoInt(MuL.attribute("LineEnd"));
926
                                        sl.LineJoin = QStoInt(MuL.attribute("LineJoin"));
927
                                        sl.Shade = QStoInt(MuL.attribute("Shade"));
928
                                        sl.Width = QStodouble(MuL.attribute("Width"));
929
                                        ml.push_back(sl);
930
                                        MuLn = MuLn.nextSibling();
31 Franz 931
                                }
167 Franz 932
                                QString Nam = pg.attribute("Name");
933
                                QString Nam2 = Nam;
934
                                int copyC = 1;
935
                                while (doc->MLineStyles.contains(Nam2))
118 Franz 936
                                {
167 Franz 937
                                        Nam2 = tr("Copy #%1 of ").arg(copyC)+Nam;
938
                                        copyC++;
118 Franz 939
                                }
167 Franz 940
                                doc->MLineStyles.insert(Nam2, ml);
31 Franz 941
                        }
167 Franz 942
                        if ((pg.tagName()=="PAGE") && (QStoInt(pg.attribute("NUM")) == PageToLoad))
114 Franz 943
                        {
1065 cbradney 944
                                a = doc->currentPage->PageNr;
167 Franz 945
                                if ((pg.attribute("NAM", "") == "") && (Mpage))
118 Franz 946
                                {
167 Franz 947
                                        PAGE=PAGE.nextSibling();
948
                                        continue;
118 Franz 949
                                }
167 Franz 950
                                if (Mpage)
118 Franz 951
                                {
456 fschmid 952
                                        doc->Pages.at(a)->LeftPg=QStoInt(pg.attribute("LEFT","0"));
1199 tsoots 953
                                        doc->Pages.at(a)->setPageName(pg.attribute("NAM",""));
118 Franz 954
                                }
234 Franz 955
                                TableItems.clear();
956
                                TableID.clear();
3 paul 957
                        /*
958
                        * Attribute von PAGE auslesen
959
                        */
167 Franz 960
                                if ((pg.hasAttribute("NumVGuides")) && (QStoInt(pg.attribute("NumVGuides","0")) != 0))
3 paul 961
                                {
167 Franz 962
                                        tmp = pg.attribute("VerticalGuides");
963
                                        QTextStream fgv(&tmp, IO_ReadOnly);
456 fschmid 964
                                        doc->Pages.at(a)->YGuides.clear();
167 Franz 965
                                        for (int cxv = 0; cxv < QStoInt(pg.attribute("NumVGuides","0")); ++cxv)
3 paul 966
                                        {
167 Franz 967
                                                fgv >> xf;
456 fschmid 968
                                                doc->Pages.at(a)->YGuides.append(xf);
3 paul 969
                                        }
456 fschmid 970
                                        qHeapSort(doc->Pages.at(a)->YGuides);
167 Franz 971
                                        tmp = "";
3 paul 972
                                }
167 Franz 973
                                else
456 fschmid 974
                                        doc->Pages.at(a)->YGuides.clear();
167 Franz 975
                                if ((pg.hasAttribute("NumHGuides")) && (QStoInt(pg.attribute("NumHGuides","0")) != 0))
3 paul 976
                                {
167 Franz 977
                                        tmp = pg.attribute("HorizontalGuides");
978
                                        QTextStream fgh(&tmp, IO_ReadOnly);
456 fschmid 979
                                        doc->Pages.at(a)->XGuides.clear();
167 Franz 980
                                        for (int cxh = 0; cxh < QStoInt(pg.attribute("NumHGuides","0")); ++cxh)
3 paul 981
                                        {
167 Franz 982
                                                fgh >> xf;
456 fschmid 983
                                                doc->Pages.at(a)->XGuides.append(xf);
3 paul 984
                                        }
456 fschmid 985
                                        qHeapSort(doc->Pages.at(a)->XGuides);
167 Franz 986
                                        tmp = "";
3 paul 987
                                }
167 Franz 988
                                else
456 fschmid 989
                                        doc->Pages.at(a)->XGuides.clear();
167 Franz 990
                                QDomNode OBJ=PAGE.firstChild();
456 fschmid 991
                                counter = doc->Items.count();
167 Franz 992
                                baseobj = counter;
993
                                while(!OBJ.isNull())
114 Franz 994
                                {
167 Franz 995
                                        QDomElement obj=OBJ.toElement();
3 paul 996
                                /*
997
                                * Attribute von OBJECT auslesen
998
                                */
167 Franz 999
                                        if ((QStoInt(obj.attribute("NEXTITEM")) != -1) &&
1000
                                                        (QStoInt(obj.attribute("NEXTPAGE")) == PageToLoad))
31 Franz 1001
                                        {
167 Franz 1002
                                                if (QStoInt(obj.attribute("BACKITEM")) == -1)
31 Franz 1003
                                                {
167 Franz 1004
                                                        Link.Start = counter;
1005
                                                        Link.StPag = a;
1006
                                                        LFrames.append(Link);
31 Franz 1007
                                                }
1008
                                        }
332 Franz 1009
                                        GetItemProps(newVersion, &obj, &OB);
456 fschmid 1010
                                        OB.Xpos = QStodouble(obj.attribute("XPOS"))+doc->Pages.at(a)->Xoffset;
1011
                                        OB.Ypos=QStodouble(obj.attribute("YPOS"))+doc->Pages.at(a)->Yoffset;
167 Franz 1012
                                        OB.NamedLStyle = obj.attribute("NAMEDLST", "");
1013
                                        if (!doc->MLineStyles.contains(OB.NamedLStyle))
1014
                                                OB.NamedLStyle = "";
1015
                                        OB.isBookmark=QStoInt(obj.attribute("BOOKMARK"));
1016
                                        if ((OB.isBookmark) && (doc->BookMarks.count() == 0))
1017
                                                doc->OldBM = true;
1018
                                        OB.BMnr = QStoInt(obj.attribute("BookNr","0"));
1065 cbradney 1019
                                        OB.textAlignment = DoVorl[QStoInt(obj.attribute("ALIGN","0"))].toUInt();
1194 fschmid 1020
                                        tmpf = obj.attribute("IFONT", doc->toolSettings.defFont);
323 Franz 1021
                                        if (tmpf == "")
1194 fschmid 1022
                                                tmpf = doc->toolSettings.defFont;
323 Franz 1023
                                        tmf = tmpf;
1024
                                        if (!DoFonts.contains(tmpf))
332 Franz 1025
                                                tmpf = AskForFont(avail, tmpf, view->Prefs, doc);
323 Franz 1026
                                        else
1027
                                                tmpf = DoFonts[tmf];
1028
                                        OB.IFont = tmpf;
1119 fschmid 1029
                                        OB.LayerNr = layerTrans[QStoInt(obj.attribute("LAYER","0"))];
167 Franz 1030
                                        OB.Language = obj.attribute("LANGUAGE", doc->Language);
1031
                                        tmp = "";
1032
                                        if ((obj.hasAttribute("GROUPS")) && (QStoInt(obj.attribute("NUMGROUP","0")) != 0))
3 paul 1033
                                        {
167 Franz 1034
                                                tmp = obj.attribute("GROUPS");
1035
                                                QTextStream fg(&tmp, IO_ReadOnly);
1036
                                                OB.Groups.clear();
1037
                                                for (int cx = 0; cx < QStoInt(obj.attribute("NUMGROUP","0")); ++cx)
3 paul 1038
                                                {
167 Franz 1039
                                                        fg >> x;
1040
                                                        OB.Groups.push(x);
3 paul 1041
                                                }
1042
                                        tmp = "";
1043
                                        }
167 Franz 1044
                                        else
1045
                                                OB.Groups.clear();
3 paul 1046
                                QDomNode IT=OBJ.firstChild();
1047
                                while(!IT.isNull())
167 Franz 1048
                                {
3 paul 1049
                                        QDomElement it=IT.toElement();
295 Franz 1050
                                        if (it.tagName()=="CSTOP")
1051
                                        {
1052
                                                QString name = it.attribute("NAME");
1053
                                                double ramp = QStodouble(it.attribute("RAMP","0.0"));
1054
                                                int shade = QStoInt(it.attribute("SHADE","100"));
296 Franz 1055
                                                double opa = QStodouble(it.attribute("TRANS","1"));
690 cbradney 1056
                                                OB.fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
2180 fschmid 1057
                                                OB.GrColor = "";
1058
                                                OB.GrColor2 = "";
295 Franz 1059
                                        }
3 paul 1060
                                        if (it.tagName()=="ITEXT")
1428 fschmid 1061
                                                tmp += GetItemText(&it, doc, view->Prefs, VorLFound, true, false);
332 Franz 1062
                                        IT=IT.nextSibling();
114 Franz 1063
                                        }
1065 cbradney 1064
                                        OB.itemText = tmp;
456 fschmid 1065
                                        view->PasteItem(&OB, true);
1066
                                        Neu = doc->Items.at(counter);
167 Franz 1067
                                        if (QStoInt(obj.attribute("NEXTPAGE")) == PageToLoad)
31 Franz 1068
                                        {
167 Franz 1069
                                                Neu->NextIt = baseobj + QStoInt(obj.attribute("NEXTITEM"));
1070
                                                Neu->NextPg = a; // QStoInt(obj.attribute("NEXTPAGE"));
31 Franz 1071
                                        }
234 Franz 1072
                                        if (Neu->isTableItem)
1073
                                        {
1074
                                                TableItems.append(Neu);
1075
                                                TableID.insert(QStoInt(obj.attribute("OwnLINK","0")), Neu->ItemNr);
1076
                                        }
167 Franz 1077
                                        counter++;
1078
                                        OBJ=OBJ.nextSibling();
114 Franz 1079
                                }
234 Franz 1080
                                if (TableItems.count() != 0)
1081
                                {
1082
                                        for (uint ttc = 0; ttc < TableItems.count(); ++ttc)
1083
                                        {
1084
                                                PageItem* ta = TableItems.at(ttc);
1085
                                                if (ta->TopLinkID != -1)
456 fschmid 1086
                                                        ta->TopLink = doc->Items.at(TableID[ta->TopLinkID]);
234 Franz 1087
                                                else
1088
                                                        ta->TopLink = 0;
1089
                                                if (ta->LeftLinkID != -1)
456 fschmid 1090
                                                        ta->LeftLink = doc->Items.at(TableID[ta->LeftLinkID]);
234 Franz 1091
                                                else
1092
                                                        ta->LeftLink = 0;
1093
                                                if (ta->RightLinkID != -1)
456 fschmid 1094
                                                        ta->RightLink = doc->Items.at(TableID[ta->RightLinkID]);
234 Franz 1095
                                                else
1096
                                                        ta->RightLink = 0;
1097
                                                if (ta->BottomLinkID != -1)
456 fschmid 1098
                                                        ta->BottomLink = doc->Items.at(TableID[ta->BottomLinkID]);
234 Franz 1099
                                                else
1100
                                                        ta->BottomLink = 0;
1101
                                        }
1102
                                }
167 Franz 1103
                                if (LFrames.count() != 0)
31 Franz 1104
                                {
167 Franz 1105
                                        PageItem *Its;
1106
                                        PageItem *Itn;
1107
                                        PageItem *Itr;
1108
                                        QValueList<Linked>::Iterator lc;
1109
                                        for (lc = LFrames.begin(); lc != LFrames.end(); ++lc)
31 Franz 1110
                                        {
456 fschmid 1111
                                                Its = doc->Items.at((*lc).Start);
167 Franz 1112
                                                Itr = Its;
1113
                                                Its->BackBox = 0;
1114
                                                while (Its->NextIt != -1)
31 Franz 1115
                                                {
167 Franz 1116
                                                        if (Its->NextPg == a)
114 Franz 1117
                                                        {
456 fschmid 1118
                                                                Itn = doc->Items.at(Its->NextIt);
167 Franz 1119
                                                                Its->NextBox = Itn;
1120
                                                                Itn->BackBox = Its;
1121
                                                                Its = Itn;
114 Franz 1122
                                                        }
167 Franz 1123
                                                        else
1124
                                                                break;
31 Franz 1125
                                                }
167 Franz 1126
                                                Its->NextBox = 0;
31 Franz 1127
                                        }
1128
                                }
167 Franz 1129
                                if (!Mpage)
1130
                                        view->reformPages();
1131
                                return true;
114 Franz 1132
                        }
3 paul 1133
                PAGE=PAGE.nextSibling();
114 Franz 1134
                }      
3 paul 1135
        DOC=DOC.nextSibling();
167 Franz 1136
        }
1137
        return false;
3 paul 1138
}
1139
 
1140
bool ScriXmlDoc::ReadDoc(QString fileName, SCFonts &avail, ScribusDoc *doc, ScribusView *view, QProgressBar *dia2)
1141
{
1542 cbradney 1142
        //Scribus 1.2 docs, see fileloader.cpp for 1.3 docs
1065 cbradney 1143
        struct CopyPasteBuffer OB;
1144
        struct ParagraphStyle vg;
167 Franz 1145
        struct Layer la;
1146
        struct ScribusDoc::BookMa bok;
517 fschmid 1147
        int counter, Pgc;
167 Franz 1148
        bool AtFl;
1149
        bool newVersion = false;
1150
        struct Linked Link;
1151
        QString tmp, tmpf, tmp2, tmp3, tmp4, PgNam, Defont, tmf;
1152
        QFont fo;
234 Franz 1153
        QMap<int,int> TableID;
1154
        QPtrList<PageItem> TableItems;
332 Franz 1155
        int x, a;
1156
        double xf;
167 Franz 1157
        PageItem *Neu;
1158
        LFrames.clear();
1159
        QDomDocument docu("scridoc");
1160
        QString f = "";
1746 fschmid 1161
        QFile fi(fileName);
421 Franz 1162
        /* 2004/10/02 - petr vanek - bug #1092 - missing <PAGE> crash Scribus. The check constraint moved into IsScribus()
1163
        FIXME: I've add test on containig tag PAGE but returning FALSE freezes S. in scribus.cpp need some hack too...  */
1746 fschmid 1164
        if (fileName.right(2) == "gz")
1165
        {
1166
                f = ReadDatei(fileName);
1167
                if (!docu.setContent(f))
1168
                        return false;
1169
        }
1170
        else
1171
        {
1172
                if ( !fi.open( IO_ReadOnly ) )
1173
                {
1174
                        fi.close();
1175
                        return false;
1176
                }
1177
                if (!docu.setContent(&fi))
1178
                {
1179
                        fi.close();
1180
                        return false;
1181
                }
1182
                fi.close();
1183
        }
167 Franz 1184
        doc->PageColors.clear();       
1185
        doc->Layers.clear();
1186
        CMYKColor lf = CMYKColor();
1187
        QDomElement elem=docu.documentElement();
1188
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
1189
                return false;
1190
        if (elem.hasAttribute("Version"))
1191
                newVersion = true;
1192
        QDomNode DOC=elem.firstChild();
1193
        dia2->setTotalSteps(DOC.childNodes().count());
1194
        dia2->setProgress(0);
1195
        int ObCount = 0;
1196
        while(!DOC.isNull())
1197
        {
1198
                QDomElement dc=DOC.toElement();
3 paul 1199
        /*
1200
        * Attribute von DOCUMENT auslesen
1201
        */
2142 cbradney 1202
                doc->pageWidth=QStodouble(dc.attribute("PAGEWITH"));
1203
                doc->pageHeight=QStodouble(dc.attribute("PAGEHEIGHT"));
1204
                doc->pageMargins.Left=QStodouble(dc.attribute("BORDERLEFT"));
1205
                doc->pageMargins.Right=QStodouble(dc.attribute("BORDERRIGHT"));
1206
                doc->pageMargins.Top=QStodouble(dc.attribute("BORDERTOP"));
1207
                doc->pageMargins.Bottom=QStodouble(dc.attribute("BORDERBOTTOM"));
167 Franz 1208
                doc->PageOri = QStoInt(dc.attribute("ORIENTATION","0"));
519 cbradney 1209
                doc->PageSize = dc.attribute("PAGESIZE");
167 Franz 1210
                doc->FirstPnum = QStoInt(dc.attribute("FIRSTNUM","1"));
317 Franz 1211
                doc->PageFP=QStoInt(dc.attribute("BOOK", "0"));
1212
                doc->FirstPageLeft=QStoInt(dc.attribute("FIRSTLEFT","0"));
167 Franz 1213
                doc->PageAT=QStoInt(dc.attribute("AUTOTEXT"));
1214
                doc->PageSp=QStoInt(dc.attribute("AUTOSPALTEN"));
1215
                doc->PageSpa=QStodouble(dc.attribute("ABSTSPALTEN"));
1065 cbradney 1216
                doc->docUnitIndex = QStoInt(dc.attribute("UNITS","0"));
879 fschmid 1217
                doc->guidesSettings.gridShown = view->Prefs->guidesSettings.gridShown;
1218
                doc->guidesSettings.guidesShown = view->Prefs->guidesSettings.guidesShown;
1219
                doc->guidesSettings.framesShown = view->Prefs->guidesSettings.framesShown;
1220
                doc->guidesSettings.marginsShown = view->Prefs->guidesSettings.marginsShown;
1221
                doc->guidesSettings.baseShown = view->Prefs->guidesSettings.baseShown;
1222
                doc->guidesSettings.linkShown = view->Prefs->guidesSettings.linkShown;
1223
                doc->guidesSettings.showPic = true;
167 Franz 1224
                DoFonts.clear();
1194 fschmid 1225
                doc->toolSettings.defSize=qRound(QStodouble(dc.attribute("DSIZE")) * 10);
167 Franz 1226
                Defont=dc.attribute("DFONT");
1428 fschmid 1227
                if ((!avail.find(Defont)) || (!avail[Defont]->UseFont))
121 Franz 1228
                {
1428 fschmid 1229
                        ReplacedFonts.insert(Defont, view->Prefs->toolSettings.defFont);
1230
                        Defont = view->Prefs->toolSettings.defFont;
121 Franz 1231
                }
325 Franz 1232
                else
1428 fschmid 1233
                {
1786 fschmid 1234
                        if (!doc->UsedFonts.contains(tmpf))
1235
                        {
1236
                                QFont fo = avail[Defont]->Font;
1237
                                fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
1238
                                doc->AddFont(Defont, fo);
1239
                        }
1428 fschmid 1240
                }
1194 fschmid 1241
                doc->toolSettings.defFont = Defont;
1242
                doc->toolSettings.dCols=QStoInt(dc.attribute("DCOL", "1"));
1243
                doc->toolSettings.dGap=QStodouble(dc.attribute("DGAP", "0.0"));
2024 cbradney 1244
                doc->documentInfo.setAuthor(dc.attribute("AUTHOR"));
1245
                doc->documentInfo.setComments(dc.attribute("COMMENTS"));
1246
                doc->documentInfo.setKeywords(dc.attribute("KEYWORDS",""));
1247
                doc->documentInfo.setTitle(dc.attribute("TITLE"));
1248
                doc->documentInfo.setPublisher(dc.attribute("PUBLISHER", ""));
1249
                doc->documentInfo.setDate(dc.attribute("DOCDATE", ""));
1250
                doc->documentInfo.setType(dc.attribute("DOCTYPE", ""));
1251
                doc->documentInfo.setFormat(dc.attribute("DOCFORMAT", ""));
1252
                doc->documentInfo.setIdent(dc.attribute("DOCIDENT", ""));
1253
                doc->documentInfo.setSource(dc.attribute("DOCSOURCE", ""));
1254
                doc->documentInfo.setLangInfo(dc.attribute("DOCLANGINFO", ""));
1255
                doc->documentInfo.setRelation(dc.attribute("DOCRELATION", ""));
1256
                doc->documentInfo.setCover(dc.attribute("DOCCOVER", ""));
1257
                doc->documentInfo.setRights(dc.attribute("DOCRIGHTS", ""));
1258
                doc->documentInfo.setContrib(dc.attribute("DOCCONTRIB", ""));
823 fschmid 1259
                doc->typographicSetttings.valueSuperScript = QStoInt(dc.attribute("VHOCH"));
1260
                doc->typographicSetttings.scalingSuperScript = QStoInt(dc.attribute("VHOCHSC"));
1261
                doc->typographicSetttings.valueSubScript = QStoInt(dc.attribute("VTIEF"));
1262
                doc->typographicSetttings.scalingSubScript = QStoInt(dc.attribute("VTIEFSC"));
1263
                doc->typographicSetttings.valueSmallCaps = QStoInt(dc.attribute("VKAPIT"));
1264
                doc->typographicSetttings.valueBaseGrid = QStodouble(dc.attribute("BASEGRID", "12"));
1265
                doc->typographicSetttings.offsetBaseGrid = QStodouble(dc.attribute("BASEO", "0"));
1266
                doc->typographicSetttings.autoLineSpacing = QStoInt(dc.attribute("AUTOL","20"));
167 Franz 1267
                doc->GroupCounter=QStoInt(dc.attribute("GROUPC","1"));
1268
                doc->HasCMS = static_cast<bool>(QStoInt(dc.attribute("HCMS","0")));
1269
                doc->CMSSettings.SoftProofOn = static_cast<bool>(QStoInt(dc.attribute("DPSo","0")));
1270
                doc->CMSSettings.CMSinUse = static_cast<bool>(QStoInt(dc.attribute("DPuse","0")));
1271
                doc->CMSSettings.GamutCheck = static_cast<bool>(QStoInt(dc.attribute("DPgam","0")));
1272
                doc->CMSSettings.BlackPoint = static_cast<bool>(QStoInt(dc.attribute("DPbla","1")));
1273
                doc->CMSSettings.DefaultMonitorProfile = dc.attribute("DPMo","");
1274
                doc->CMSSettings.DefaultPrinterProfile = dc.attribute("DPPr","");
1275
                doc->CMSSettings.DefaultInputProfile = dc.attribute("DPIn","");
1276
                doc->CMSSettings.DefaultInputProfile2 = dc.attribute("DPIn2","");
1277
                doc->CMSSettings.DefaultIntentPrinter = QStoInt(dc.attribute("DIPr","0"));
1278
                doc->CMSSettings.DefaultIntentMonitor = QStoInt(dc.attribute("DIMo","1"));
1279
                doc->CMSSettings.DefaultIntentMonitor2 = QStoInt(dc.attribute("DIMo2","1"));
1280
                doc->ActiveLayer = QStoInt(dc.attribute("ALAYER","0"));
1281
                doc->Language = dc.attribute("LANGUAGE", "");
1282
                doc->MinWordLen = QStoInt(dc.attribute("MINWORDLEN", "3"));
249 Franz 1283
                doc->HyCount = QStoInt(dc.attribute("HYCOUNT", "2"));
167 Franz 1284
                doc->Automatic = static_cast<bool>(QStoInt(dc.attribute("AUTOMATIC", "1")));
1285
                doc->AutoCheck = static_cast<bool>(QStoInt(dc.attribute("AUTOCHECK", "0")));
1286
                doc->GuideLock = static_cast<bool>(QStoInt(dc.attribute("GUIDELOCK", "0")));
879 fschmid 1287
                doc->guidesSettings.minorGrid = QStodouble(dc.attribute("MINGRID", tmp.setNum(view->Prefs->guidesSettings.minorGrid)));
1288
                doc->guidesSettings.majorGrid = QStodouble(dc.attribute("MAJGRID", tmp.setNum(view->Prefs->guidesSettings.majorGrid)));
1194 fschmid 1289
                doc->toolSettings.dStartArrow = 0;
1290
                doc->toolSettings.dEndArrow = 0;
1016 fschmid 1291
                doc->LastAuto = 0;
167 Franz 1292
                QDomNode PAGE=DOC.firstChild();
456 fschmid 1293
                counter = 0;
167 Franz 1294
                while(!PAGE.isNull())
3 paul 1295
                {
167 Franz 1296
                        ObCount++;
1297
                        dia2->setProgress(ObCount);
1298
                        QDomElement pg=PAGE.toElement();
516 fschmid 1299
                        // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
1300
                        if(pg.tagName()=="COLOR" && pg.attribute("NAME")!="None")
3 paul 1301
                        {
167 Franz 1302
                                if (pg.hasAttribute("CMYK"))
1303
                                        lf.setNamedColor(pg.attribute("CMYK"));
1304
                                else
1305
                                        lf.fromQColor(QColor(pg.attribute("RGB")));
1306
                          doc->PageColors[pg.attribute("NAME")] = lf;
3 paul 1307
                        }
167 Franz 1308
                        if(pg.tagName()=="STYLE")
3 paul 1309
                        {
167 Franz 1310
                                vg.Vname = pg.attribute("NAME");
1311
                                vg.LineSpa = QStodouble(pg.attribute("LINESP"));
1312
                                vg.Indent = QStodouble(pg.attribute("INDENT","0"));
1313
                                vg.First = QStodouble(pg.attribute("FIRST","0"));
1065 cbradney 1314
                                vg.textAlignment = QStoInt(pg.attribute("ALIGN"));
1315
                                vg.gapBefore = QStodouble(pg.attribute("VOR","0"));
1316
                                vg.gapAfter = QStodouble(pg.attribute("NACH","0"));
1194 fschmid 1317
                                tmpf = pg.attribute("FONT", doc->toolSettings.defFont);
1428 fschmid 1318
                                if ((!avail.find(tmpf)) || (!avail[tmpf]->UseFont))
1319
                                {
1320
                                        if ((!view->Prefs->GFontSub.contains(tmpf)) || (!avail[view->Prefs->GFontSub[tmpf]]->UseFont))
1468 fschmid 1321
                                        {
1322
                                                newReplacement = true;
1428 fschmid 1323
                                                ReplacedFonts.insert(tmpf, view->Prefs->toolSettings.defFont);
1468 fschmid 1324
                                        }
1428 fschmid 1325
                                        else
1326
                                                ReplacedFonts.insert(tmpf, view->Prefs->GFontSub[tmpf]);
1327
                                }
167 Franz 1328
                                else
1428 fschmid 1329
                                {
1786 fschmid 1330
                                        if (!doc->UsedFonts.contains(tmpf))
1331
                                        {
1332
                                                QFont fo = avail[tmpf]->Font;
1333
                                                fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
1334
                                                doc->AddFont(tmpf, fo);
1335
                                        }
1428 fschmid 1336
                                }
323 Franz 1337
                                vg.Font = tmpf;
167 Franz 1338
                                vg.FontSize = qRound(QStodouble(pg.attribute("FONTSIZE","12")) * 10.0);
1339
                                vg.Drop = static_cast<bool>(QStoInt(pg.attribute("DROP","0")));
1340
                                vg.DropLin = QStoInt(pg.attribute("DROPLIN","2"));
173 Franz 1341
                                vg.FontEffect = QStoInt(pg.attribute("EFFECT","0"));
1194 fschmid 1342
                                vg.FColor = pg.attribute("FCOLOR", doc->toolSettings.dBrush);
173 Franz 1343
                                vg.FShade = QStoInt(pg.attribute("FSHADE","100"));
1194 fschmid 1344
                                vg.SColor = pg.attribute("SCOLOR", doc->toolSettings.dPen);
173 Franz 1345
                                vg.SShade = QStoInt(pg.attribute("SSHADE","100"));
241 Franz 1346
                                vg.BaseAdj = static_cast<bool>(QStoInt(pg.attribute("BASE","0")));
167 Franz 1347
                                if ((pg.hasAttribute("NUMTAB")) && (QStoInt(pg.attribute("NUMTAB","0")) != 0))
140 Franz 1348
                                {
167 Franz 1349
                                        tmp = pg.attribute("TABS");
1350
                                        QTextStream tgv(&tmp, IO_ReadOnly);
1351
                                        vg.TabValues.clear();
1352
                                        for (int cxv = 0; cxv < QStoInt(pg.attribute("NUMTAB","0")); ++cxv)
140 Franz 1353
                                        {
167 Franz 1354
                                                tgv >> xf;
1355
                                                vg.TabValues.append(xf);
140 Franz 1356
                                        }
167 Franz 1357
                                        tmp = "";
140 Franz 1358
                                }
167 Franz 1359
                                else
1360
                                        vg.TabValues.clear();
2219 fschmid 1361
                                vg.tabFillChar = "";
1065 cbradney 1362
                                doc->docParagraphStyles.append(vg);
3 paul 1363
                        }
167 Franz 1364
                        if(pg.tagName()=="JAVA")
1365
                                doc->JavaScripts[pg.attribute("NAME")] = pg.attribute("SCRIPT");
1366
                        if(pg.tagName()=="LAYERS")
3 paul 1367
                        {
167 Franz 1368
                                la.LNr = QStoInt(pg.attribute("NUMMER"));
1369
                                la.Level = QStoInt(pg.attribute("LEVEL"));
1370
                                la.Name = pg.attribute("NAME");
1065 cbradney 1371
                                la.isViewable = QStoInt(pg.attribute("SICHTBAR"));
1372
                                la.isPrintable = QStoInt(pg.attribute("DRUCKEN"));
167 Franz 1373
                                doc->Layers.append(la);
3 paul 1374
                        }
167 Franz 1375
                        if(pg.tagName()=="Bookmark")
3 paul 1376
                        {
167 Franz 1377
                                bok.Title = pg.attribute("Title");
1378
                                bok.Text = pg.attribute("Text");
1379
                                bok.Aktion = pg.attribute("Aktion");
1380
                                bok.ItemNr = QStoInt(pg.attribute("ItemNr"));
1381
                                bok.Seite = QStoInt(pg.attribute("Seite"));
1382
                                bok.Element = QStoInt(pg.attribute("Element"));
1383
                                bok.First = QStoInt(pg.attribute("First"));
1384
                                bok.Last = QStoInt(pg.attribute("Last"));
1385
                                bok.Prev = QStoInt(pg.attribute("Prev"));
1386
                                bok.Next = QStoInt(pg.attribute("Next"));
1387
                                bok.Parent = QStoInt(pg.attribute("Parent"));
1388
                                doc->BookMarks.append(bok);
3 paul 1389
                        }
167 Franz 1390
                        if(pg.tagName()=="MultiLine")
27 Franz 1391
                        {
167 Franz 1392
                                multiLine ml;
1393
                                QDomNode MuLn = PAGE.firstChild();
1394
                                while(!MuLn.isNull())
27 Franz 1395
                                {
167 Franz 1396
                                        QDomElement MuL = MuLn.toElement();
1065 cbradney 1397
                                        struct SingleLine sl;
167 Franz 1398
                                        sl.Color = MuL.attribute("Color");
1399
                                        sl.Dash = QStoInt(MuL.attribute("Dash"));
1400
                                        sl.LineEnd = QStoInt(MuL.attribute("LineEnd"));
1401
                                        sl.LineJoin = QStoInt(MuL.attribute("LineJoin"));
1402
                                        sl.Shade = QStoInt(MuL.attribute("Shade"));
1403
                                        sl.Width = QStodouble(MuL.attribute("Width"));
1404
                                        ml.push_back(sl);
1405
                                        MuLn = MuLn.nextSibling();
27 Franz 1406
                                }
167 Franz 1407
                                doc->MLineStyles.insert(pg.attribute("Name"), ml);
27 Franz 1408
                        }
167 Franz 1409
                        if(pg.tagName()=="PAGE")
114 Franz 1410
                        {
234 Franz 1411
                                TableItems.clear();
1412
                                TableID.clear();
3 paul 1413
                        /*
1414
                        * Attribute von PAGE auslesen
1415
                        */
167 Franz 1416
                                a = QStoInt(pg.attribute("NUM"));
1417
                                PgNam = "";
1418
                                PgNam = pg.attribute("NAM", "");
2142 cbradney 1419
                                Pgc = doc->pageCount;
167 Franz 1420
                                AtFl = doc->PageAT;
1421
                                if (PgNam == "")
3 paul 1422
                                {
2142 cbradney 1423
                                        doc->pageCount = Pgc;
456 fschmid 1424
                                        doc->Pages = doc->DocPages;
167 Franz 1425
                                        doc->PageAT = AtFl;
1426
                                        doc->MasterP = false;
456 fschmid 1427
                                        doc->Items = doc->DocItems;
3 paul 1428
                                }
167 Franz 1429
                                else
3 paul 1430
                                {
2142 cbradney 1431
                                        doc->pageCount = 0;
167 Franz 1432
                                        doc->PageAT = false;
456 fschmid 1433
                                        doc->Pages = doc->MasterPages;
167 Franz 1434
                                        doc->MasterP = true;
456 fschmid 1435
                                        doc->Items = doc->MasterItems;
3 paul 1436
                                }
167 Franz 1437
                                emit NewPage(a);
456 fschmid 1438
                                doc->Pages.at(a)->LeftPg=QStoInt(pg.attribute("LEFT","0"));
167 Franz 1439
                                QString Mus = "";
1440
                                Mus = pg.attribute("MNAM","Normal");
1441
                                if (!doc->MasterP)
456 fschmid 1442
                                        doc->Pages.at(a)->MPageNam = Mus;
167 Franz 1443
                                else
456 fschmid 1444
                                        doc->Pages.at(a)->MPageNam = "";
167 Franz 1445
                                if ((pg.hasAttribute("NumVGuides")) && (QStoInt(pg.attribute("NumVGuides","0")) != 0))
3 paul 1446
                                {
167 Franz 1447
                                        tmp = pg.attribute("VerticalGuides");
1448
                                        QTextStream fgv(&tmp, IO_ReadOnly);
456 fschmid 1449
                                        doc->Pages.at(a)->YGuides.clear();
167 Franz 1450
                                        for (int cxv = 0; cxv < QStoInt(pg.attribute("NumVGuides","0")); ++cxv)
3 paul 1451
                                        {
167 Franz 1452
                                                fgv >> xf;
456 fschmid 1453
                                                doc->Pages.at(a)->YGuides.append(xf);
3 paul 1454
                                        }
456 fschmid 1455
                                        qHeapSort(doc->Pages.at(a)->YGuides);
167 Franz 1456
                                        tmp = "";
3 paul 1457
                                }
167 Franz 1458
                                else
456 fschmid 1459
                                        doc->Pages.at(a)->YGuides.clear();
167 Franz 1460
                                if ((pg.hasAttribute("NumHGuides")) && (QStoInt(pg.attribute("NumHGuides","0")) != 0))
3 paul 1461
                                {
167 Franz 1462
                                        tmp = pg.attribute("HorizontalGuides");
1463
                                        QTextStream fgh(&tmp, IO_ReadOnly);
456 fschmid 1464
                                        doc->Pages.at(a)->XGuides.clear();
167 Franz 1465
                                        for (int cxh = 0; cxh < QStoInt(pg.attribute("NumHGuides","0")); ++cxh)
3 paul 1466
                                        {
167 Franz 1467
                                                fgh >> xf;
456 fschmid 1468
                                                doc->Pages.at(a)->XGuides.append(xf);
3 paul 1469
                                        }
456 fschmid 1470
                                        qHeapSort(doc->Pages.at(a)->XGuides);
167 Franz 1471
                                        tmp = "";
3 paul 1472
                                }
167 Franz 1473
                                else
456 fschmid 1474
                                        doc->Pages.at(a)->XGuides.clear();
167 Franz 1475
                                QDomNode OBJ=PAGE.firstChild();
1476
                                while(!OBJ.isNull())
1477
                                {
1478
                                        QDomElement obj=OBJ.toElement();
3 paul 1479
                                /*
1480
                                * Attribute von OBJECT auslesen
1481
                                */
267 Franz 1482
                                        if ((QStoInt(obj.attribute("NEXTITEM")) != -1) || (static_cast<bool>(QStoInt(obj.attribute("AUTOTEXT")))))
3 paul 1483
                                        {
167 Franz 1484
                                                if (QStoInt(obj.attribute("BACKITEM")) == -1)
3 paul 1485
                                                {
167 Franz 1486
                                                        Link.Start = counter;
1487
                                                        Link.StPag = a;
1488
                                                        LFrames.append(Link);
3 paul 1489
                                                }
1490
                                        }
332 Franz 1491
                                        GetItemProps(newVersion, &obj, &OB);
456 fschmid 1492
                                        OB.Xpos = QStodouble(obj.attribute("XPOS"))+doc->Pages.at(a)->Xoffset;
1493
                                        OB.Ypos=QStodouble(obj.attribute("YPOS"))+doc->Pages.at(a)->Yoffset;
167 Franz 1494
                                        OB.NamedLStyle = obj.attribute("NAMEDLST", "");
1495
                                        OB.isBookmark=QStoInt(obj.attribute("BOOKMARK"));
1496
                                        if ((OB.isBookmark) && (doc->BookMarks.count() == 0))
1497
                                                doc->OldBM = true;
1498
                                        OB.BMnr = QStoInt(obj.attribute("BookNr","0"));
1065 cbradney 1499
                                        OB.textAlignment = QStoInt(obj.attribute("ALIGN","0"));
745 fschmid 1500
                                        OB.startArrowIndex =  0;
1501
                                        OB.endArrowIndex =  0;
1194 fschmid 1502
                                        tmpf = obj.attribute("IFONT", doc->toolSettings.defFont);
1428 fschmid 1503
                                        if ((!avail.find(tmpf)) || (!avail[tmpf]->UseFont))
1504
                                        {
1505
                                                if ((!view->Prefs->GFontSub.contains(tmpf)) || (!avail[view->Prefs->GFontSub[tmpf]]->UseFont))
1468 fschmid 1506
                                                {
1507
                                                        newReplacement = true;
1428 fschmid 1508
                                                        ReplacedFonts.insert(tmpf, view->Prefs->toolSettings.defFont);
1468 fschmid 1509
                                                }
1428 fschmid 1510
                                                else
1511
                                                        ReplacedFonts.insert(tmpf, view->Prefs->GFontSub[tmpf]);
1512
                                        }
204 Franz 1513
                                        else
1428 fschmid 1514
                                        {
1786 fschmid 1515
                                                if (!doc->UsedFonts.contains(tmpf))
1516
                                                {
1517
                                                        QFont fo = avail[tmpf]->Font;
1518
                                                        fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
1519
                                                        doc->AddFont(tmpf, fo);
1520
                                                }
1428 fschmid 1521
                                        }
323 Franz 1522
                                        OB.IFont = tmpf;
167 Franz 1523
                                        OB.LayerNr = QStoInt(obj.attribute("LAYER","0"));
1524
                                        OB.Language = obj.attribute("LANGUAGE", doc->Language);
1525
                                        tmp = "";
1526
                                        if ((obj.hasAttribute("GROUPS")) && (QStoInt(obj.attribute("NUMGROUP","0")) != 0))
3 paul 1527
                                        {
167 Franz 1528
                                                tmp = obj.attribute("GROUPS");
1529
                                                QTextStream fg(&tmp, IO_ReadOnly);
1530
                                                OB.Groups.clear();
1531
                                                for (int cx = 0; cx < QStoInt(obj.attribute("NUMGROUP","0")); ++cx)
3 paul 1532
                                                {
167 Franz 1533
                                                        fg >> x;
1534
                                                        OB.Groups.push(x);
3 paul 1535
                                                }
167 Franz 1536
                                                tmp = "";
3 paul 1537
                                        }
167 Franz 1538
                                        else
1539
                                                OB.Groups.clear();
1540
                                        QDomNode IT=OBJ.firstChild();
1541
                                        while(!IT.isNull())
1542
                                        {
1543
                                                QDomElement it=IT.toElement();
295 Franz 1544
                                                if (it.tagName()=="CSTOP")
1545
                                                {
1546
                                                        QString name = it.attribute("NAME");
1547
                                                        double ramp = QStodouble(it.attribute("RAMP","0.0"));
1548
                                                        int shade = QStoInt(it.attribute("SHADE","100"));
296 Franz 1549
                                                        double opa = QStodouble(it.attribute("TRANS","1"));
690 cbradney 1550
                                                        OB.fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
2180 fschmid 1551
                                                        OB.GrColor = "";
1552
                                                        OB.GrColor2 = "";
295 Franz 1553
                                                }
167 Franz 1554
                                                IT=IT.nextSibling();
1555
                                        }
1789 fschmid 1556
                                        OB.itemText = "";
167 Franz 1557
                                        int docGc = doc->GroupCounter;
1558
                                        doc->GroupCounter = 0;
456 fschmid 1559
                                        uint last = doc->Items.count();
1560
                                        view->PasteItem(&OB, true);
167 Franz 1561
                                        doc->GroupCounter = docGc;
456 fschmid 1562
                                        Neu = doc->Items.at(last);
1866 fschmid 1563
                                        Neu->OnMasterPage = PgNam;
1789 fschmid 1564
                                        IT=OBJ.firstChild();
1565
                                        while(!IT.isNull())
1566
                                        {
1567
                                                QDomElement it=IT.toElement();
1568
                                                if (it.tagName()=="ITEXT")
1569
                                                        GetItemText(&it, doc, view->Prefs, false, false, true, Neu);
1570
                                                IT=IT.nextSibling();
1571
                                        }
267 Franz 1572
                                        Neu->isAutoText=static_cast<bool>(QStoInt(obj.attribute("AUTOTEXT")));
167 Franz 1573
                                        if (Neu->isAutoText)
1574
                                                doc->LastAuto = Neu;
1575
                                        Neu->NextIt = QStoInt(obj.attribute("NEXTITEM"));
1576
                                        Neu->NextPg = QStoInt(obj.attribute("NEXTPAGE"));
234 Franz 1577
                                        if (Neu->isTableItem)
1578
                                        {
1579
                                                TableItems.append(Neu);
1580
                                                TableID.insert(QStoInt(obj.attribute("OwnLINK","0")), Neu->ItemNr);
1581
                                        }
167 Franz 1582
                                        counter++;
1583
                                        OBJ=OBJ.nextSibling();
114 Franz 1584
                                }
234 Franz 1585
                                if (TableItems.count() != 0)
1586
                                {
1587
                                        for (uint ttc = 0; ttc < TableItems.count(); ++ttc)
1588
                                        {
1589
                                                PageItem* ta = TableItems.at(ttc);
1590
                                                if (ta->TopLinkID != -1)
456 fschmid 1591
                                                        ta->TopLink = doc->Items.at(TableID[ta->TopLinkID]);
234 Franz 1592
                                                else
1593
                                                        ta->TopLink = 0;
1594
                                                if (ta->LeftLinkID != -1)
456 fschmid 1595
                                                        ta->LeftLink = doc->Items.at(TableID[ta->LeftLinkID]);
234 Franz 1596
                                                else
1597
                                                        ta->LeftLink = 0;
1598
                                                if (ta->RightLinkID != -1)
456 fschmid 1599
                                                        ta->RightLink = doc->Items.at(TableID[ta->RightLinkID]);
234 Franz 1600
                                                else
1601
                                                        ta->RightLink = 0;
1602
                                                if (ta->BottomLinkID != -1)
456 fschmid 1603
                                                        ta->BottomLink = doc->Items.at(TableID[ta->BottomLinkID]);
234 Franz 1604
                                                else
1605
                                                        ta->BottomLink = 0;
1606
                                        }
1607
                                }
167 Franz 1608
                                if (PgNam == "")
456 fschmid 1609
                                {
1610
                                        doc->DocPages = doc->Pages;
1611
                                        doc->DocItems = doc->Items;
1612
                                }
167 Franz 1613
                                else
3 paul 1614
                                {
1199 tsoots 1615
                                  doc->Pages.at(a)->setPageName(PgNam);
456 fschmid 1616
                                        doc->MasterNames[PgNam] = a;
1617
                                        doc->MasterPages = doc->Pages;
1618
                                        doc->MasterItems = doc->Items;
3 paul 1619
                                }
167 Franz 1620
                                doc->MasterP = false;
2142 cbradney 1621
                                doc->pageCount = Pgc+1;
167 Franz 1622
                                doc->PageAT = AtFl;
1623
                        }
1624
                        PAGE=PAGE.nextSibling();
3 paul 1625
                }
337 Franz 1626
                PAGE=DOC.firstChild();
325 Franz 1627
                while(!PAGE.isNull())
1628
                {
1629
                        QDomElement pg=PAGE.toElement();
1630
                        if(pg.tagName()=="PDF")
1631
                        {
1545 cbradney 1632
                                doc->PDF_Options.Articles = static_cast<bool>(QStoInt(pg.attribute("Articles")));
1633
                                doc->PDF_Options.Thumbnails = static_cast<bool>(QStoInt(pg.attribute("Thumbnails")));
1634
                                doc->PDF_Options.Compress = static_cast<bool>(QStoInt(pg.attribute("Compress")));
1635
                                doc->PDF_Options.CompressMethod = QStoInt(pg.attribute("CMethod","0"));
1636
                                doc->PDF_Options.Quality = QStoInt(pg.attribute("Quality","0"));
1637
                                doc->PDF_Options.RecalcPic = static_cast<bool>(QStoInt(pg.attribute("RecalcPic")));
1638
                                doc->PDF_Options.Bookmarks = static_cast<bool>(QStoInt(pg.attribute("Bookmarks")));
476 fschmid 1639
                                if (pg.hasAttribute("MirrorH"))
1545 cbradney 1640
                                        doc->PDF_Options.MirrorH = static_cast<bool>(QStoInt(pg.attribute("MirrorH")));
476 fschmid 1641
                                else
1545 cbradney 1642
                                        doc->PDF_Options.MirrorH = false;
476 fschmid 1643
                                if (pg.hasAttribute("MirrorV"))
1545 cbradney 1644
                                        doc->PDF_Options.MirrorV = static_cast<bool>(QStoInt(pg.attribute("MirrorV")));
476 fschmid 1645
                                else
1545 cbradney 1646
                                        doc->PDF_Options.MirrorV = false;
476 fschmid 1647
                                if (pg.hasAttribute("RotateDeg"))
1545 cbradney 1648
                                        doc->PDF_Options.RotateDeg = QStoInt(pg.attribute("RotateDeg","0"));
476 fschmid 1649
                                else
1545 cbradney 1650
                                        doc->PDF_Options.RotateDeg = 0;
1651
                                doc->PDF_Options.PresentMode = static_cast<bool>(QStoInt(pg.attribute("PresentMode")));
1652
                                doc->PDF_Options.PicRes = QStoInt(pg.attribute("PicRes"));
1973 craig 1653
                                doc->PDF_Options.Version = (PDFOptions::PDFVersion)QStoInt(pg.attribute("Version"));
1545 cbradney 1654
                                doc->PDF_Options.Resolution = QStoInt(pg.attribute("Resolution"));
1655
                                doc->PDF_Options.Binding = QStoInt(pg.attribute("Binding"));
1656
                                doc->PDF_Options.Datei = "";
1657
                                doc->PDF_Options.isGrayscale = false;
1658
                                doc->PDF_Options.UseRGB = static_cast<bool>(QStoInt(pg.attribute("RGBMode","0")));
1659
                                doc->PDF_Options.UseProfiles = static_cast<bool>(QStoInt(pg.attribute("UseProfiles","0")));
1660
                                doc->PDF_Options.UseProfiles2 = static_cast<bool>(QStoInt(pg.attribute("UseProfiles2","0")));
1661
                                doc->PDF_Options.Intent = QStoInt(pg.attribute("Intent","1"));
1662
                                doc->PDF_Options.Intent2 = QStoInt(pg.attribute("Intent2","1"));
1663
                                doc->PDF_Options.SolidProf = pg.attribute("SolidP", "");
1664
                                doc->PDF_Options.ImageProf = pg.attribute("ImageP", "");
1665
                                doc->PDF_Options.PrintProf = pg.attribute("PrintP", "");
1666
                                doc->PDF_Options.Info = pg.attribute("InfoString", "");
1667
                                doc->PDF_Options.BleedTop = QStodouble(pg.attribute("BTop","0"));
1668
                                doc->PDF_Options.BleedLeft = QStodouble(pg.attribute("BLeft","0"));
1669
                                doc->PDF_Options.BleedRight = QStodouble(pg.attribute("BRight","0"));
1670
                                doc->PDF_Options.BleedBottom = QStodouble(pg.attribute("BBottom","0"));
1671
                                doc->PDF_Options.EmbeddedI = static_cast<bool>(QStoInt(pg.attribute("ImagePr","0")));
1672
                                doc->PDF_Options.PassOwner = pg.attribute("PassOwner", "");
1673
                                doc->PDF_Options.PassUser = pg.attribute("PassUser", "");
1674
                                doc->PDF_Options.Permissions = QStoInt(pg.attribute("Permissions","-4"));
1675
                                doc->PDF_Options.Encrypt = static_cast<bool>(QStoInt(pg.attribute("Encrypt","0")));
1738 fschmid 1676
                                doc->PDF_Options.useLayers = static_cast<bool>(QStoInt(pg.attribute("UseLayers","0")));
1545 cbradney 1677
                                doc->PDF_Options.UseLPI = static_cast<bool>(QStoInt(pg.attribute("UseLpi","0")));
325 Franz 1678
                                QDomNode PFO = PAGE.firstChild();
1679
                                while(!PFO.isNull())
1680
                                {
1681
                                        QDomElement pdfF = PFO.toElement();
337 Franz 1682
                                        if(pdfF.tagName() == "LPI")
1683
                                        {
1065 cbradney 1684
                                                struct LPIData lpo;
337 Franz 1685
                                                lpo.Angle = QStoInt(pdfF.attribute("Angle"));
1686
                                                lpo.Frequency = QStoInt(pdfF.attribute("Frequency"));
1687
                                                lpo.SpotFunc = QStoInt(pdfF.attribute("SpotFunction"));
1545 cbradney 1688
                                                doc->PDF_Options.LPISettings[pdfF.attribute("Color")] = lpo;
337 Franz 1689
                                        }
325 Franz 1690
                                        if(pdfF.tagName() == "Fonts")
1691
                                        {
1545 cbradney 1692
                                                if (!doc->PDF_Options.EmbedList.contains(pdfF.attribute("Name")))
1693
                                                        doc->PDF_Options.EmbedList.append(pdfF.attribute("Name"));
325 Franz 1694
                                        }
476 fschmid 1695
                                        if(pdfF.tagName() == "Subset")
1696
                                        {
1545 cbradney 1697
                                                if (!doc->PDF_Options.SubsetList.contains(pdfF.attribute("Name")))
1698
                                                        doc->PDF_Options.SubsetList.append(pdfF.attribute("Name"));
476 fschmid 1699
                                        }
325 Franz 1700
                                        if(pdfF.tagName() == "Effekte")
1701
                                        {
1065 cbradney 1702
                                        struct PDFPresentationData ef;
1703
                                        ef.pageEffectDuration = QStoInt(pdfF.attribute("pageEffectDuration"));
1704
                                        ef.pageViewDuration = QStoInt(pdfF.attribute("pageViewDuration"));
1705
                                        ef.effectType = QStoInt(pdfF.attribute("effectType"));
325 Franz 1706
                                        ef.Dm = QStoInt(pdfF.attribute("Dm"));
1707
                                        ef.M = QStoInt(pdfF.attribute("M"));
1708
                                        ef.Di = QStoInt(pdfF.attribute("Di"));
1545 cbradney 1709
                                                doc->PDF_Options.PresentVals.append(ef);
325 Franz 1710
                                        }
1711
                                        PFO = PFO.nextSibling();
1712
                                }
1713
                        }
337 Franz 1714
                        PAGE=PAGE.nextSibling();
325 Franz 1715
                }
167 Franz 1716
                DOC=DOC.nextSibling();