Subversion Repositories Scribus

Rev

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