Subversion Repositories Scribus

Rev

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

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