Subversion Repositories Scribus

Rev

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

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