Subversion Repositories Scribus

Rev

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

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