Subversion Repositories Scribus

Rev

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