Subversion Repositories Scribus

Rev

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

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