Subversion Repositories Scribus

Rev

Rev 2309 | Rev 2362 | 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);
2309 fschmid 355
        ob->setAttribute("LINESPMode", item->LineSpMode);
332 Franz 356
        ob->setAttribute("EXTRAV",item->ExtraV);
357
        ob->setAttribute("LOCALSCX",item->LocalScX);
358
        ob->setAttribute("LOCALSCY",item->LocalScY);
359
        ob->setAttribute("LOCALX",item->LocalX);
360
        ob->setAttribute("LOCALY",item->LocalY);
361
        ob->setAttribute("PICART", item->PicArt ? 1 : 0);
362
        ob->setAttribute("PLTSHOW", item->PoShow ? 1 : 0);
363
        ob->setAttribute("BASEOF", item->BaseOffs);
1392 cbradney 364
        ob->setAttribute("FLIPPEDH", item->imageFlippedH());
365
        ob->setAttribute("FLIPPEDV", item->imageFlippedV());
332 Franz 366
        ob->setAttribute("BBOXX",item->BBoxX);
367
        ob->setAttribute("BBOXH",item->BBoxH);
368
        ob->setAttribute("IFONT",item->IFont);
369
        ob->setAttribute("ISIZE",item->ISize / 10.0 );
370
        ob->setAttribute("SCALETYPE", item->ScaleType ? 1 : 0);
371
        ob->setAttribute("RATIO", item->AspectRatio ? 1 : 0);
372
        ob->setAttribute("PRINTABLE", item->isPrintable ? 1 : 0);
373
        if(item->isAnnotation)
374
        {
375
                ob->setAttribute("ANNOTATION",1);
376
                ob->setAttribute("ANTYPE", item->AnType);
377
                ob->setAttribute("ANACTION", item->AnAction);
378
                ob->setAttribute("ANEACT", item->An_E_act);
379
                ob->setAttribute("ANXACT", item->An_X_act);
380
                ob->setAttribute("ANDACT", item->An_D_act);
381
                ob->setAttribute("ANFOACT", item->An_Fo_act);
382
                ob->setAttribute("ANBLACT", item->An_Bl_act);
383
                ob->setAttribute("ANKACT", item->An_K_act);
384
                ob->setAttribute("ANFACT", item->An_F_act);
385
                ob->setAttribute("ANVACT", item->An_V_act);
386
                ob->setAttribute("ANCACT", item->An_C_act);
387
                if (item->AnActType == 8)
388
                        ob->setAttribute("ANEXTERN", item->An_Extern);
389
                else
390
                        ob->setAttribute("ANEXTERN", Path2Relative(item->An_Extern));
391
                ob->setAttribute("ANZIEL", item->AnZiel);
392
                ob->setAttribute("ANACTYP", item->AnActType);
393
                ob->setAttribute("ANTOOLTIP", item->AnToolTip);
394
                ob->setAttribute("ANBWID", item->AnBwid);
395
                ob->setAttribute("ANBSTY", item->AnBsty);
396
                ob->setAttribute("ANFEED", item->AnFeed);
397
                ob->setAttribute("ANFLAG", item->AnFlag);
398
                ob->setAttribute("ANFONT", item->AnFont);
399
                ob->setAttribute("ANFORMAT", item->AnFormat);
400
                ob->setAttribute("ANROLL", item->AnRollOver);
401
                ob->setAttribute("ANDOWN", item->AnDown);
402
                ob->setAttribute("ANVIS", item->AnVis);
403
                ob->setAttribute("ANMC", item->AnMaxChar);
404
                ob->setAttribute("ANCHK", item->AnIsChk);
405
                ob->setAttribute("ANAA", item->AnAAact);
406
                ob->setAttribute("ANCHKS", item->AnChkStil);
407
                ob->setAttribute("ANBCOL", item->AnBColor);
408
                ob->setAttribute("ANHTML", item->AnHTML);
409
                ob->setAttribute("ANICON", item->AnUseIcons);
410
                ob->setAttribute("ANPLACE", item->AnIPlace);
411
                ob->setAttribute("ANSCALE", item->AnScaleW);
412
        }
413
        else
414
                ob->setAttribute("ANNOTATION",0);
1361 tsoots 415
        ob->setAttribute("ANNAME", !item->AutoName ? item->itemName() : QString(""));
1653 craig 416
        ob->setAttribute("TEXTFLOW", item->textFlowsAroundFrame() ? 1 : 0);
417
        ob->setAttribute("TEXTFLOW2", item->textFlowUsesBoundingBox() ? 1 : 0);
1656 craig 418
        ob->setAttribute("TEXTFLOW3", item->textFlowUsesContourLine() ? 1 : 0);
332 Franz 419
        ob->setAttribute("AUTOTEXT", item->isAutoText ? 1 : 0);
420
        ob->setAttribute("EXTRA",item->Extra);
421
        ob->setAttribute("TEXTRA",item->TExtra);
422
        ob->setAttribute("BEXTRA",item->BExtra);
423
        ob->setAttribute("REXTRA",item->RExtra);
1460 cbradney 424
        if (((item->itemType() == PageItem::ImageFrame) || (item->itemType() == PageItem::TextFrame)) && (item->Pfile != ""))
332 Franz 425
                ob->setAttribute("PFILE",Path2Relative(item->Pfile));
426
        else
427
                ob->setAttribute("PFILE","");
428
        if (item->Pfile2 != "")
429
                ob->setAttribute("PFILE2",Path2Relative(item->Pfile2));
430
        else
431
                ob->setAttribute("PFILE2","");
432
        if (item->Pfile3 != "")
433
                ob->setAttribute("PFILE3",Path2Relative(item->Pfile3));
434
        else
435
                ob->setAttribute("PFILE3","");
436
        ob->setAttribute("PRFILE",item->IProfile);
437
        ob->setAttribute("EPROF", item->EmProfile);
438
        ob->setAttribute("IRENDER",item->IRender);
439
        ob->setAttribute("EMBEDDED", item->UseEmbedded ? 1 : 0);
1392 cbradney 440
        ob->setAttribute("LOCK", item->locked() ? 1 : 0);
441
        ob->setAttribute("LOCKR", item->sizeLocked() ? 1 : 0);
332 Franz 442
        ob->setAttribute("REVERS", item->Reverse ? 1 : 0);
1394 cbradney 443
        ob->setAttribute("TransValue", item->fillTransparency());
444
        ob->setAttribute("TransValueS", item->lineTransparency());
332 Franz 445
        ob->setAttribute("isTableItem", static_cast<int>(item->isTableItem));
446
        ob->setAttribute("TopLine", static_cast<int>(item->TopLine));
447
        ob->setAttribute("LeftLine", static_cast<int>(item->LeftLine));
448
        ob->setAttribute("RightLine", static_cast<int>(item->RightLine));
449
        ob->setAttribute("BottomLine", static_cast<int>(item->BottomLine));
450
        if (item->isTableItem)
451
        {
452
                if (item->TopLink != 0)
453
                        ob->setAttribute("TopLINK", item->TopLink->ItemNr);
454
                else
455
                        ob->setAttribute("TopLINK", -1);
456
                if (item->LeftLink != 0)
457
                        ob->setAttribute("LeftLINK", item->LeftLink->ItemNr);
458
                else
459
                        ob->setAttribute("LeftLINK", -1);
460
                if (item->RightLink != 0)
461
                        ob->setAttribute("RightLINK", item->RightLink->ItemNr);
462
                else
463
                        ob->setAttribute("RightLINK", -1);
464
                if (item->BottomLink != 0)
465
                        ob->setAttribute("BottomLINK", item->BottomLink->ItemNr);
466
                else
467
                        ob->setAttribute("BottomLINK", -1);
468
                ob->setAttribute("OwnLINK", item->ItemNr);
469
        }
470
        ob->setAttribute("NUMDASH", static_cast<int>(item->DashValues.count()));
471
        QString dlp = "";
472
        QValueList<double>::Iterator dax;
473
        for (dax = item->DashValues.begin(); dax != item->DashValues.end(); ++dax)
474
                dlp += tmp.setNum((*dax)) + " ";
475
        ob->setAttribute("DASHS", dlp);
476
        ob->setAttribute("DASHOFF", item->DashOffset);
477
        ob->setAttribute("NUMPO",item->PoLine.size());
478
        QString polp = "";
479
        for (uint nxx=0; nxx<item->PoLine.size(); ++nxx)
480
        {
481
                item->PoLine.point(nxx, &xf, &yf);
482
                polp += tmp.setNum(xf) + " " + tmpy.setNum(yf) + " ";
483
        }
484
        ob->setAttribute("POCOOR", polp);
340 Franz 485
        ob->setAttribute("NUMCO",item->ContourLine.size());
486
        QString colp = "";
487
        for (uint nxx=0; nxx<item->ContourLine.size(); ++nxx)
488
        {
489
                item->ContourLine.point(nxx, &xf, &yf);
490
                colp += tmp.setNum(xf) + " " + tmpy.setNum(yf) + " ";
491
        }
492
        ob->setAttribute("COCOOR", colp);
332 Franz 493
        ob->setAttribute("NUMGROUP", static_cast<int>(item->Groups.count()));
494
        QString glp = "";
495
        QValueStack<int>::Iterator nx;
496
        for (nx = item->Groups.begin(); nx != item->Groups.end(); ++nx)
497
                glp += tmp.setNum((*nx)) + " ";
498
        ob->setAttribute("GROUPS", glp);
499
        ob->setAttribute("LANGUAGE", item->Language);
741 fschmid 500
        ob->setAttribute("startArrowIndex", item->startArrowIndex);
501
        ob->setAttribute("endArrowIndex", item->endArrowIndex);
332 Franz 502
}
503
 
118 Franz 504
bool ScriXmlDoc::ReadLStyles(QString fileName, QMap<QString,multiLine> *Sty)
505
{
506
        QDomDocument docu("scridoc");
507
        QString f = "";
508
        f = ReadDatei(fileName);
509
        if (f == "")
510
                return false;
511
        if(!docu.setContent(f))
512
                return false;
513
        QDomElement elem=docu.documentElement();
514
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
515
                return false;
516
        QDomNode DOC=elem.firstChild();
517
        while(!DOC.isNull())
167 Franz 518
        {
118 Franz 519
                QDomElement dc=DOC.toElement();
520
                QDomNode PAGE=DOC.firstChild();
521
                while(!PAGE.isNull())
167 Franz 522
                {
118 Franz 523
                        QDomElement pg=PAGE.toElement();
524
                        if(pg.tagName()=="MultiLine")
167 Franz 525
                        {
118 Franz 526
                                multiLine ml;
527
                                QDomNode MuLn = PAGE.firstChild();
528
                                while(!MuLn.isNull())
167 Franz 529
                                {
118 Franz 530
                                        QDomElement MuL = MuLn.toElement();
1065 cbradney 531
                                        struct SingleLine sl;
118 Franz 532
                                        sl.Color = MuL.attribute("Color");
533
                                        sl.Dash = QStoInt(MuL.attribute("Dash"));
534
                                        sl.LineEnd = QStoInt(MuL.attribute("LineEnd"));
535
                                        sl.LineJoin = QStoInt(MuL.attribute("LineJoin"));
536
                                        sl.Shade = QStoInt(MuL.attribute("Shade"));
537
                                        sl.Width = QStodouble(MuL.attribute("Width"));
538
                                        ml.push_back(sl);
539
                                        MuLn = MuLn.nextSibling();
167 Franz 540
                                }
118 Franz 541
                                QString Nam = pg.attribute("Name");
542
                                QString Nam2 = Nam;
543
                                int copyC = 1;
544
                                while (Sty->contains(Nam2))
167 Franz 545
                                {
118 Franz 546
                                        Nam2 = tr("Copy #%1 of ").arg(copyC)+Nam;
547
                                        copyC++;
167 Franz 548
                                }
118 Franz 549
                                Sty->insert(Nam2, ml);
167 Franz 550
                        }
118 Franz 551
                        PAGE=PAGE.nextSibling();
167 Franz 552
                }
118 Franz 553
                DOC=DOC.nextSibling();
167 Franz 554
        }
118 Franz 555
        return true;
556
}
557
 
1065 cbradney 558
void ScriXmlDoc::GetStyle(QDomElement *pg, struct ParagraphStyle *vg, QValueList<ParagraphStyle> &docParagraphStyles, ScribusDoc* doc, ApplicationPrefs *Prefs, bool fl)
332 Franz 559
{
560
        bool fou;
561
        QString tmpf, tmf, tmV;
2282 fschmid 562
        double xf, xf2;
332 Franz 563
        fou = false;
2282 fschmid 564
        bool tabEQ = false;
332 Franz 565
        vg->Vname = pg->attribute("NAME");
2309 fschmid 566
        vg->LineSpaMode = QStoInt(pg->attribute("LINESPMode","0"));
332 Franz 567
        vg->LineSpa = QStodouble(pg->attribute("LINESP"));
568
        vg->Indent = QStodouble(pg->attribute("INDENT","0"));
569
        vg->First = QStodouble(pg->attribute("FIRST","0"));
1065 cbradney 570
        vg->textAlignment = QStoInt(pg->attribute("ALIGN"));
571
        vg->gapBefore = QStodouble(pg->attribute("VOR","0"));
572
        vg->gapAfter = QStodouble(pg->attribute("NACH","0"));
1194 fschmid 573
        tmpf = pg->attribute("FONT", doc->toolSettings.defFont);
332 Franz 574
        if (tmpf == "")
1194 fschmid 575
                tmpf = doc->toolSettings.defFont;
332 Franz 576
        tmf = tmpf;
577
        if (!DoFonts.contains(tmpf))
578
                tmpf = AskForFont(Prefs->AvailFonts, tmpf, Prefs, doc);
579
        else
580
                tmpf = DoFonts[tmf];
581
        vg->Font = tmpf;
582
        vg->FontSize = qRound(QStodouble(pg->attribute("FONTSIZE","12")) * 10.0);
583
        vg->Drop = static_cast<bool>(QStoInt(pg->attribute("DROP","0")));
584
        vg->DropLin = QStoInt(pg->attribute("DROPLIN","2"));
585
        vg->FontEffect = QStoInt(pg->attribute("EFFECT","0"));
1194 fschmid 586
        vg->FColor = pg->attribute("FCOLOR", doc->toolSettings.dBrush);
332 Franz 587
        vg->FShade = QStoInt(pg->attribute("FSHADE", "100"));
1194 fschmid 588
        vg->SColor = pg->attribute("SCOLOR", doc->toolSettings.dPen);
332 Franz 589
        vg->SShade = QStoInt(pg->attribute("SSHADE", "100"));
590
        vg->BaseAdj = static_cast<bool>(QStoInt(pg->attribute("BASE","0")));
2273 fschmid 591
        vg->txtShadowX=qRound(QStodouble(pg->attribute("TXTSHX", "5")) * 10);
592
        vg->txtShadowY=qRound(QStodouble(pg->attribute("TXTSHY", "-5")) * 10);
593
        vg->txtOutline=qRound(QStodouble(pg->attribute("TXTOUT", "1")) * 10);
594
        vg->txtUnderPos=qRound(QStodouble(pg->attribute("TXTULP", "-0.1")) * 10);
595
        vg->txtUnderWidth=qRound(QStodouble(pg->attribute("TXTULW", "-0.1")) * 10);
596
        vg->txtStrikePos=qRound(QStodouble(pg->attribute("TXTSTP", "-0.1")) * 10);
597
        vg->txtStrikeWidth=qRound(QStodouble(pg->attribute("TXTSTW", "-0.1")) * 10);
2282 fschmid 598
        vg->TabValues.clear();
332 Franz 599
        if ((pg->hasAttribute("NUMTAB")) && (QStoInt(pg->attribute("NUMTAB","0")) != 0))
600
        {
2282 fschmid 601
                struct PageItem::TabRecord tb;
332 Franz 602
                QString tmp = pg->attribute("TABS");
603
                QTextStream tgv(&tmp, IO_ReadOnly);
604
                vg->TabValues.clear();
2282 fschmid 605
                for (int cxv = 0; cxv < QStoInt(pg->attribute("NUMTAB","0")); cxv += 2)
332 Franz 606
                {
607
                        tgv >> xf;
2282 fschmid 608
                        tgv >> xf2;
609
                        tb.tabPosition = xf2;
610
                        tb.tabType = static_cast<int>(xf);
611
                        tb.tabFillChar = QChar();
612
                        vg->TabValues.append(tb);
332 Franz 613
                }
614
                tmp = "";
615
        }
616
        else
2282 fschmid 617
        {
618
                QDomNode IT = pg->firstChild();
619
                while(!IT.isNull())
620
                {
621
                        QDomElement it = IT.toElement();
622
                        if (it.tagName()=="Tabs")
623
                        {
624
                                struct PageItem::TabRecord tb;
625
                                tb.tabPosition = QStodouble(it.attribute("Pos"));
626
                                tb.tabType = QStoInt(it.attribute("Type"));
627
                                QString tbCh = "";
628
                                tbCh = it.attribute("Fill","");
629
                                if (tbCh == "")
630
                                        tb.tabFillChar = QChar();
631
                                else
632
                                        tb.tabFillChar = tbCh[0];
633
                                vg->TabValues.append(tb);
634
                        }
635
                        IT=IT.nextSibling();
636
                }
637
        }
1065 cbradney 638
        for (uint xx=0; xx<docParagraphStyles.count(); ++xx)
332 Franz 639
        {
1065 cbradney 640
                if (vg->Vname == docParagraphStyles[xx].Vname)
332 Franz 641
                {
2282 fschmid 642
                        struct PageItem::TabRecord tb;
643
                        tabEQ = false;
644
                        for (uint t1 = 0; t1 < docParagraphStyles[xx].TabValues.count(); t1++)
645
                        {
646
                                tb.tabPosition = docParagraphStyles[xx].TabValues[t1].tabPosition;
647
                                tb.tabType = docParagraphStyles[xx].TabValues[t1].tabType;
648
                                tb.tabFillChar = docParagraphStyles[xx].TabValues[t1].tabFillChar;
649
                                for (uint t2 = 0; t2 < vg->TabValues.count(); t2++)
650
                                {
651
                                        struct PageItem::TabRecord tb2;
652
                                        tb2.tabPosition = vg->TabValues[t2].tabPosition;
653
                                        tb2.tabType = vg->TabValues[t2].tabType;
654
                                        tb2.tabFillChar = vg->TabValues[t2].tabFillChar;
655
                                        if ((tb2.tabFillChar == tb.tabFillChar) && (tb2.tabPosition == tb.tabPosition) && (tb2.tabType == tb.tabType))
656
                                        {
657
                                                tabEQ = true;
658
                                                break;
659
                                        }
660
                                }
661
                                if (tabEQ)
662
                                        break;
663
                        }
1065 cbradney 664
                        if ((vg->LineSpa == docParagraphStyles[xx].LineSpa) &&
2309 fschmid 665
                                        (vg->LineSpaMode == docParagraphStyles[xx].LineSpaMode) &&
1065 cbradney 666
                                        (vg->Indent == docParagraphStyles[xx].Indent) &&
667
                                        (vg->First == docParagraphStyles[xx].First) &&
668
                                        (vg->textAlignment == docParagraphStyles[xx].textAlignment) &&
669
                                        (vg->gapBefore == docParagraphStyles[xx].gapBefore) &&
670
                                        (vg->gapAfter == docParagraphStyles[xx].gapAfter) &&
2282 fschmid 671
                                        (vg->Font == docParagraphStyles[xx].Font) && (tabEQ) &&
1065 cbradney 672
                                        (vg->Drop == docParagraphStyles[xx].Drop) &&
673
                                        (vg->DropLin == docParagraphStyles[xx].DropLin) &&
674
                                        (vg->FontEffect == docParagraphStyles[xx].FontEffect) &&
675
                                        (vg->FColor == docParagraphStyles[xx].FColor) &&
676
                                        (vg->FShade == docParagraphStyles[xx].FShade) &&
677
                                        (vg->SColor == docParagraphStyles[xx].SColor) &&
678
                                        (vg->SShade == docParagraphStyles[xx].SShade) &&
679
                                        (vg->BaseAdj == docParagraphStyles[xx].BaseAdj) &&
2273 fschmid 680
                                        (vg->txtShadowX == docParagraphStyles[xx].txtShadowX) &&
681
                                        (vg->txtShadowY == docParagraphStyles[xx].txtShadowY) &&
682
                                        (vg->txtOutline == docParagraphStyles[xx].txtOutline) &&
683
                                        (vg->txtUnderPos == docParagraphStyles[xx].txtUnderPos) &&
684
                                        (vg->txtUnderWidth == docParagraphStyles[xx].txtUnderWidth) &&
685
                                        (vg->txtStrikePos == docParagraphStyles[xx].txtStrikePos) &&
686
                                        (vg->txtStrikeWidth == docParagraphStyles[xx].txtStrikeWidth) &&
1065 cbradney 687
                                        (vg->FontSize == docParagraphStyles[xx].FontSize))
335 Franz 688
                        {
689
                                if (fl)
690
                                {
691
                                        DoVorl[VorlC] = tmV.setNum(xx);
692
                                        VorlC++;
693
                                }
332 Franz 694
                                fou = true;
335 Franz 695
                        }
332 Franz 696
                        else
697
                        {
1065 cbradney 698
                                vg->Vname = "Copy of "+docParagraphStyles[xx].Vname;
332 Franz 699
                                fou = false;
700
                        }
701
                        break;
702
                }
703
        }
704
        if (!fou)
705
        {
1065 cbradney 706
                for (uint xx=0; xx< docParagraphStyles.count(); ++xx)
332 Franz 707
                {
2282 fschmid 708
                        struct PageItem::TabRecord tb;
709
                        tabEQ = false;
710
                        for (uint t1 = 0; t1 < docParagraphStyles[xx].TabValues.count(); t1++)
711
                        {
712
                                tb.tabPosition = docParagraphStyles[xx].TabValues[t1].tabPosition;
713
                                tb.tabType = docParagraphStyles[xx].TabValues[t1].tabType;
714
                                tb.tabFillChar = docParagraphStyles[xx].TabValues[t1].tabFillChar;
715
                                for (uint t2 = 0; t2 < vg->TabValues.count(); t2++)
716
                                {
717
                                        struct PageItem::TabRecord tb2;
718
                                        tb2.tabPosition = vg->TabValues[t2].tabPosition;
719
                                        tb2.tabType = vg->TabValues[t2].tabType;
720
                                        tb2.tabFillChar = vg->TabValues[t2].tabFillChar;
721
                                        if ((tb2.tabFillChar == tb.tabFillChar) && (tb2.tabPosition == tb.tabPosition) && (tb2.tabType == tb.tabType))
722
                                        {
723
                                                tabEQ = true;
724
                                                break;
725
                                        }
726
                                }
727
                                if (tabEQ)
728
                                        break;
729
                        }
1065 cbradney 730
                        if ((vg->LineSpa == docParagraphStyles[xx].LineSpa) &&
2309 fschmid 731
                                (vg->LineSpaMode == docParagraphStyles[xx].LineSpaMode) &&
1065 cbradney 732
                                (vg->Indent == docParagraphStyles[xx].Indent) &&
733
                                (vg->First == docParagraphStyles[xx].First) &&
734
                                (vg->textAlignment == docParagraphStyles[xx].textAlignment) &&
735
                                (vg->gapBefore == docParagraphStyles[xx].gapBefore) &&
736
                                (vg->gapAfter == docParagraphStyles[xx].gapAfter) &&
2282 fschmid 737
                                (vg->Font == docParagraphStyles[xx].Font) && (tabEQ) &&
1065 cbradney 738
                                (vg->Drop == docParagraphStyles[xx].Drop) &&
739
                                (vg->DropLin == docParagraphStyles[xx].DropLin) &&
740
                                (vg->FontEffect == docParagraphStyles[xx].FontEffect) &&
741
                                (vg->FColor == docParagraphStyles[xx].FColor) &&
742
                                (vg->FShade == docParagraphStyles[xx].FShade) &&
743
                                (vg->SColor == docParagraphStyles[xx].SColor) &&
744
                                (vg->SShade == docParagraphStyles[xx].SShade) &&
745
                                (vg->BaseAdj == docParagraphStyles[xx].BaseAdj) &&
2273 fschmid 746
                                (vg->txtShadowX == docParagraphStyles[xx].txtShadowX) &&
747
                                (vg->txtShadowY == docParagraphStyles[xx].txtShadowY) &&
748
                                (vg->txtOutline == docParagraphStyles[xx].txtOutline) &&
749
                                (vg->txtUnderPos == docParagraphStyles[xx].txtUnderPos) &&
750
                                (vg->txtUnderWidth == docParagraphStyles[xx].txtUnderWidth) &&
751
                                (vg->txtStrikePos == docParagraphStyles[xx].txtStrikePos) &&
752
                                (vg->txtStrikeWidth == docParagraphStyles[xx].txtStrikeWidth) &&
1065 cbradney 753
                                (vg->FontSize == docParagraphStyles[xx].FontSize))
332 Franz 754
                        {
1065 cbradney 755
                                vg->Vname = docParagraphStyles[xx].Vname;
332 Franz 756
                                fou = true;
757
                                if (fl)
758
                                {
759
                                        DoVorl[VorlC] = tmV.setNum(xx);
760
                                        VorlC++;
761
                                }
762
                                break;
763
                        }
764
                }
765
        }
766
        if (!fou)
767
        {
1065 cbradney 768
                docParagraphStyles.append(*vg);
332 Franz 769
                if (fl)
770
                {
1065 cbradney 771
                        DoVorl[VorlC] = tmV.setNum(docParagraphStyles.count()-1);
332 Franz 772
                        VorlC++;
773
                }
774
        }
775
 
776
}
777
 
1065 cbradney 778
bool ScriXmlDoc::ReadStyles(QString fileName, ScribusDoc* doc, ApplicationPrefs *Prefs)
117 Franz 779
{
1065 cbradney 780
        struct ParagraphStyle vg;
117 Franz 781
        QDomDocument docu("scridoc");
782
        QString f = "";
332 Franz 783
        QString tmpf, tmf;
117 Franz 784
        DoFonts.clear();
785
        f = ReadDatei(fileName);
786
        if (f == "")
787
                return false;
788
        if(!docu.setContent(f))
789
                return false;
790
        QDomElement elem=docu.documentElement();
1884 fschmid 791
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8") && (elem.tagName() != "SCRIBUSUTF8NEW"))
117 Franz 792
                return false;
793
        QDomNode DOC=elem.firstChild();
794
        while(!DOC.isNull())
167 Franz 795
        {
117 Franz 796
                QDomElement dc=DOC.toElement();
797
                QDomNode PAGE=DOC.firstChild();
798
                while(!PAGE.isNull())
167 Franz 799
                {
117 Franz 800
                        QDomElement pg=PAGE.toElement();
801
                        if(pg.tagName()=="STYLE")
1065 cbradney 802
                                GetStyle(&pg, &vg, docParagraphStyles, doc, Prefs, false);
117 Franz 803
                        PAGE=PAGE.nextSibling();
167 Franz 804
                }
117 Franz 805
                DOC=DOC.nextSibling();
167 Franz 806
        }
117 Franz 807
        return true;
808
}
809
 
3 paul 810
bool ScriXmlDoc::ReadColors(QString fileName)
811
{
812
        QDomDocument docu("scridoc");
813
        QString f = "";
814
        f = ReadDatei(fileName);
815
        if (f == "")
816
                return false;
817
        if(!docu.setContent(f))
818
                return false;
819
        Farben.clear();
820
        CMYKColor lf = CMYKColor();
821
        QDomElement elem=docu.documentElement();
1884 fschmid 822
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8") && (elem.tagName() != "SCRIBUSUTF8NEW"))
3 paul 823
                return false;
824
        QDomNode DOC=elem.firstChild();
825
        while(!DOC.isNull())
167 Franz 826
        {
3 paul 827
                QDomElement dc=DOC.toElement();
828
                QDomNode PAGE=DOC.firstChild();
829
                while(!PAGE.isNull())
167 Franz 830
                {
3 paul 831
                        QDomElement pg=PAGE.toElement();
516 fschmid 832
                        // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
833
                        if(pg.tagName()=="COLOR" && pg.attribute("NAME")!="None")
167 Franz 834
                        {
516 fschmid 835
                                if(pg.tagName()=="COLOR")
836
                                {
837
                                        if (pg.hasAttribute("CMYK"))
838
                                                lf.setNamedColor(pg.attribute("CMYK"));
839
                                        else
840
                                                lf.fromQColor(QColor(pg.attribute("RGB")));
841
                                        Farben[pg.attribute("NAME")] = lf;
842
                                }
167 Franz 843
                        }
3 paul 844
                        PAGE=PAGE.nextSibling();
167 Franz 845
                }
3 paul 846
                DOC=DOC.nextSibling();
167 Franz 847
        }
3 paul 848
        return true;
849
}
850
 
118 Franz 851
bool ScriXmlDoc::ReadPageCount(QString fileName, int *num1, int *num2)
3 paul 852
{
167 Franz 853
        QString PgNam;
854
        int counter = 0;
855
        int counter2 = 0;
856
        MNames.clear();
857
        QDomDocument docu("scridoc");
858
        QString f = "";
859
        f = ReadDatei(fileName);
860
        if (f == "")
861
                return false;
862
        if(!docu.setContent(f))
863
                return false;
864
        QDomElement elem=docu.documentElement();
865
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
866
                return false;
867
        QDomNode DOC=elem.firstChild();
868
        while(!DOC.isNull())
3 paul 869
        {
167 Franz 870
                QDomNode PAGE=DOC.firstChild();
871
                while(!PAGE.isNull())
3 paul 872
                {
167 Franz 873
                        QDomElement pg=PAGE.toElement();
874
                        if(pg.tagName()=="PAGE")
3 paul 875
                        {
167 Franz 876
                                PgNam = pg.attribute("NAM", "");
877
                                if (PgNam == "")
878
                                        counter++;
879
                                else
118 Franz 880
                                {
167 Franz 881
                                        counter2++;
882
                                        MNames.append(PgNam);
118 Franz 883
                                }
3 paul 884
                        }
885
                PAGE=PAGE.nextSibling();
886
                }
887
        DOC=DOC.nextSibling();
888
        }
167 Franz 889
        *num1 = counter;
890
        *num2 = counter2;
891
        return true;
3 paul 892
}
893
 
118 Franz 894
bool ScriXmlDoc::ReadPage(QString fileName, SCFonts &avail, ScribusDoc *doc, ScribusView *view, int PageToLoad, bool Mpage)
3 paul 895
{
1065 cbradney 896
        struct CopyPasteBuffer OB;
897
        struct ParagraphStyle vg;
167 Franz 898
        struct Layer la;
899
        struct ScribusDoc::BookMa bok;
900
        struct Linked Link;
901
        PageItem *Neu;
902
        LFrames.clear();
903
        QString tmV, tmp, tmpf, tmp2, tmp3, tmp4, PgNam, f, Defont, tmf;
904
        QFont fo;
234 Franz 905
        QMap<int,int> TableID;
906
        QPtrList<PageItem> TableItems;
332 Franz 907
        int x, a, counter, baseobj;
908
        double xf;
167 Franz 909
        bool newVersion = false;
910
        bool VorLFound = false;
1119 fschmid 911
        QMap<int,int> layerTrans;
912
        int maxLayer = 0;
913
        int maxLevel = 0;
914
        layerTrans.clear();
915
        for (uint la2 = 0; la2 < doc->Layers.count(); ++la2)
916
        {
917
                maxLayer = QMAX(doc->Layers[la2].LNr, maxLayer);
918
                maxLevel = QMAX(doc->Layers[la2].Level, maxLevel);
919
        }
167 Franz 920
        DoVorl.clear();
921
        DoFonts.clear();
1194 fschmid 922
        DoFonts[doc->toolSettings.defFont] = doc->toolSettings.defFont;
167 Franz 923
        DoVorl[0] = "0";
924
        DoVorl[1] = "1";
925
        DoVorl[2] = "2";
926
        DoVorl[3] = "3";
927
        DoVorl[4] = "4";
928
        VorlC = 5;
929
        QDomDocument docu("scridoc");
930
        f = "";
931
        f = ReadDatei(fileName);
932
        if (f == "")
933
                return false;
934
        if(!docu.setContent(f))
935
                return false;
936
        CMYKColor lf = CMYKColor();
937
        QDomElement elem=docu.documentElement();
938
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
939
                return false;
940
        if (elem.hasAttribute("Version"))
941
                newVersion = true;
942
        QDomNode DOC=elem.firstChild();
943
        while(!DOC.isNull())
114 Franz 944
        {
167 Franz 945
                QDomElement dc=DOC.toElement();
3 paul 946
        /*
947
        * Attribute von DOCUMENT auslesen
948
        */
167 Franz 949
                QDomNode PAGE=DOC.firstChild();
950
                while(!PAGE.isNull())
114 Franz 951
                {
167 Franz 952
                        QDomElement pg=PAGE.toElement();
516 fschmid 953
                        // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
954
                        if(pg.tagName()=="COLOR" && pg.attribute("NAME")!="None")
3 paul 955
                        {
167 Franz 956
                                if (pg.hasAttribute("CMYK"))
957
                                        lf.setNamedColor(pg.attribute("CMYK"));
958
                                else
959
                                        lf.fromQColor(QColor(pg.attribute("RGB")));
960
                                doc->PageColors[pg.attribute("NAME")] = lf;
3 paul 961
                        }
167 Franz 962
                        if(pg.tagName()=="STYLE")
3 paul 963
                        {
1065 cbradney 964
                                GetStyle(&pg, &vg, doc->docParagraphStyles, doc, view->Prefs, true);
167 Franz 965
                                VorLFound = true;
3 paul 966
                        }
167 Franz 967
                        if(pg.tagName()=="JAVA")
968
                                doc->JavaScripts[pg.attribute("NAME")] = pg.attribute("SCRIPT");
969
                        if(pg.tagName()=="LAYERS")
3 paul 970
                        {
167 Franz 971
                                la.LNr = QStoInt(pg.attribute("NUMMER"));
972
                                la.Level = QStoInt(pg.attribute("LEVEL"));
973
                                la.Name = pg.attribute("NAME");
1065 cbradney 974
                                la.isViewable = QStoInt(pg.attribute("SICHTBAR"));
975
                                la.isPrintable = QStoInt(pg.attribute("DRUCKEN"));
167 Franz 976
                                bool laex = false;
977
                                for (uint la2 = 0; la2 < doc->Layers.count(); ++la2)
3 paul 978
                                {
167 Franz 979
                                        if (doc->Layers[la2].Name == la.Name)
1119 fschmid 980
                                        {
167 Franz 981
                                                laex = true;
1119 fschmid 982
                                                layerTrans.insert(la.LNr, doc->Layers[la2].LNr);
983
                                        }
3 paul 984
                                }
167 Franz 985
                                if (!laex)
1119 fschmid 986
                                {
987
                                        maxLayer++;
988
                                        maxLevel++;
989
                                        layerTrans.insert(la.LNr, maxLayer);
990
                                        la.LNr = maxLayer;
991
                                        la.Level = maxLevel;
167 Franz 992
                                        doc->Layers.append(la);
1119 fschmid 993
                                }
3 paul 994
                        }
167 Franz 995
                        if(pg.tagName()=="Bookmark")
3 paul 996
                        {
167 Franz 997
                                bok.Title = pg.attribute("Title");
998
                                bok.Text = pg.attribute("Text");
999
                                bok.Aktion = pg.attribute("Aktion");
1000
                                bok.ItemNr = QStoInt(pg.attribute("ItemNr"));
1001
                                bok.Seite = QStoInt(pg.attribute("Seite"));
1002
                                bok.Element = QStoInt(pg.attribute("Element"));
1003
                                bok.First = QStoInt(pg.attribute("First"));
1004
                                bok.Last = QStoInt(pg.attribute("Last"));
1005
                                bok.Prev = QStoInt(pg.attribute("Prev"));
1006
                                bok.Next = QStoInt(pg.attribute("Next"));
1007
                                bok.Parent = QStoInt(pg.attribute("Parent"));
1008
                                doc->BookMarks.append(bok);
3 paul 1009
                        }
167 Franz 1010
                        if(pg.tagName()=="MultiLine")
31 Franz 1011
                        {
167 Franz 1012
                                multiLine ml;
1013
                                QDomNode MuLn = PAGE.firstChild();
1014
                                while(!MuLn.isNull())
31 Franz 1015
                                {
167 Franz 1016
                                        QDomElement MuL = MuLn.toElement();
1065 cbradney 1017
                                        struct SingleLine sl;
167 Franz 1018
                                        sl.Color = MuL.attribute("Color");
1019
                                        sl.Dash = QStoInt(MuL.attribute("Dash"));
1020
                                        sl.LineEnd = QStoInt(MuL.attribute("LineEnd"));
1021
                                        sl.LineJoin = QStoInt(MuL.attribute("LineJoin"));
1022
                                        sl.Shade = QStoInt(MuL.attribute("Shade"));
1023
                                        sl.Width = QStodouble(MuL.attribute("Width"));
1024
                                        ml.push_back(sl);
1025
                                        MuLn = MuLn.nextSibling();
31 Franz 1026
                                }
167 Franz 1027
                                QString Nam = pg.attribute("Name");
1028
                                QString Nam2 = Nam;
1029
                                int copyC = 1;
1030
                                while (doc->MLineStyles.contains(Nam2))
118 Franz 1031
                                {
167 Franz 1032
                                        Nam2 = tr("Copy #%1 of ").arg(copyC)+Nam;
1033
                                        copyC++;
118 Franz 1034
                                }
167 Franz 1035
                                doc->MLineStyles.insert(Nam2, ml);
31 Franz 1036
                        }
167 Franz 1037
                        if ((pg.tagName()=="PAGE") && (QStoInt(pg.attribute("NUM")) == PageToLoad))
114 Franz 1038
                        {
1065 cbradney 1039
                                a = doc->currentPage->PageNr;
167 Franz 1040
                                if ((pg.attribute("NAM", "") == "") && (Mpage))
118 Franz 1041
                                {
167 Franz 1042
                                        PAGE=PAGE.nextSibling();
1043
                                        continue;
118 Franz 1044
                                }
167 Franz 1045
                                if (Mpage)
118 Franz 1046
                                {
456 fschmid 1047
                                        doc->Pages.at(a)->LeftPg=QStoInt(pg.attribute("LEFT","0"));
1199 tsoots 1048
                                        doc->Pages.at(a)->setPageName(pg.attribute("NAM",""));
118 Franz 1049
                                }
234 Franz 1050
                                TableItems.clear();
1051
                                TableID.clear();
3 paul 1052
                        /*
1053
                        * Attribute von PAGE auslesen
1054
                        */
167 Franz 1055
                                if ((pg.hasAttribute("NumVGuides")) && (QStoInt(pg.attribute("NumVGuides","0")) != 0))
3 paul 1056
                                {
167 Franz 1057
                                        tmp = pg.attribute("VerticalGuides");
1058
                                        QTextStream fgv(&tmp, IO_ReadOnly);
456 fschmid 1059
                                        doc->Pages.at(a)->YGuides.clear();
167 Franz 1060
                                        for (int cxv = 0; cxv < QStoInt(pg.attribute("NumVGuides","0")); ++cxv)
3 paul 1061
                                        {
167 Franz 1062
                                                fgv >> xf;
456 fschmid 1063
                                                doc->Pages.at(a)->YGuides.append(xf);
3 paul 1064
                                        }
456 fschmid 1065
                                        qHeapSort(doc->Pages.at(a)->YGuides);
167 Franz 1066
                                        tmp = "";
3 paul 1067
                                }
167 Franz 1068
                                else
456 fschmid 1069
                                        doc->Pages.at(a)->YGuides.clear();
167 Franz 1070
                                if ((pg.hasAttribute("NumHGuides")) && (QStoInt(pg.attribute("NumHGuides","0")) != 0))
3 paul 1071
                                {
167 Franz 1072
                                        tmp = pg.attribute("HorizontalGuides");
1073
                                        QTextStream fgh(&tmp, IO_ReadOnly);
456 fschmid 1074
                                        doc->Pages.at(a)->XGuides.clear();
167 Franz 1075
                                        for (int cxh = 0; cxh < QStoInt(pg.attribute("NumHGuides","0")); ++cxh)
3 paul 1076
                                        {
167 Franz 1077
                                                fgh >> xf;
456 fschmid 1078
                                                doc->Pages.at(a)->XGuides.append(xf);
3 paul 1079
                                        }
456 fschmid 1080
                                        qHeapSort(doc->Pages.at(a)->XGuides);
167 Franz 1081
                                        tmp = "";
3 paul 1082
                                }
167 Franz 1083
                                else
456 fschmid 1084
                                        doc->Pages.at(a)->XGuides.clear();
167 Franz 1085
                                QDomNode OBJ=PAGE.firstChild();
456 fschmid 1086
                                counter = doc->Items.count();
167 Franz 1087
                                baseobj = counter;
1088
                                while(!OBJ.isNull())
114 Franz 1089
                                {
167 Franz 1090
                                        QDomElement obj=OBJ.toElement();
3 paul 1091
                                /*
1092
                                * Attribute von OBJECT auslesen
1093
                                */
167 Franz 1094
                                        if ((QStoInt(obj.attribute("NEXTITEM")) != -1) &&
1095
                                                        (QStoInt(obj.attribute("NEXTPAGE")) == PageToLoad))
31 Franz 1096
                                        {
167 Franz 1097
                                                if (QStoInt(obj.attribute("BACKITEM")) == -1)
31 Franz 1098
                                                {
167 Franz 1099
                                                        Link.Start = counter;
1100
                                                        Link.StPag = a;
1101
                                                        LFrames.append(Link);
31 Franz 1102
                                                }
1103
                                        }
332 Franz 1104
                                        GetItemProps(newVersion, &obj, &OB);
456 fschmid 1105
                                        OB.Xpos = QStodouble(obj.attribute("XPOS"))+doc->Pages.at(a)->Xoffset;
1106
                                        OB.Ypos=QStodouble(obj.attribute("YPOS"))+doc->Pages.at(a)->Yoffset;
167 Franz 1107
                                        OB.NamedLStyle = obj.attribute("NAMEDLST", "");
1108
                                        if (!doc->MLineStyles.contains(OB.NamedLStyle))
1109
                                                OB.NamedLStyle = "";
1110
                                        OB.isBookmark=QStoInt(obj.attribute("BOOKMARK"));
1111
                                        if ((OB.isBookmark) && (doc->BookMarks.count() == 0))
1112
                                                doc->OldBM = true;
1113
                                        OB.BMnr = QStoInt(obj.attribute("BookNr","0"));
1065 cbradney 1114
                                        OB.textAlignment = DoVorl[QStoInt(obj.attribute("ALIGN","0"))].toUInt();
1194 fschmid 1115
                                        tmpf = obj.attribute("IFONT", doc->toolSettings.defFont);
323 Franz 1116
                                        if (tmpf == "")
1194 fschmid 1117
                                                tmpf = doc->toolSettings.defFont;
323 Franz 1118
                                        tmf = tmpf;
1119
                                        if (!DoFonts.contains(tmpf))
332 Franz 1120
                                                tmpf = AskForFont(avail, tmpf, view->Prefs, doc);
323 Franz 1121
                                        else
1122
                                                tmpf = DoFonts[tmf];
1123
                                        OB.IFont = tmpf;
1119 fschmid 1124
                                        OB.LayerNr = layerTrans[QStoInt(obj.attribute("LAYER","0"))];
167 Franz 1125
                                        OB.Language = obj.attribute("LANGUAGE", doc->Language);
1126
                                        tmp = "";
1127
                                        if ((obj.hasAttribute("GROUPS")) && (QStoInt(obj.attribute("NUMGROUP","0")) != 0))
3 paul 1128
                                        {
167 Franz 1129
                                                tmp = obj.attribute("GROUPS");
1130
                                                QTextStream fg(&tmp, IO_ReadOnly);
1131
                                                OB.Groups.clear();
1132
                                                for (int cx = 0; cx < QStoInt(obj.attribute("NUMGROUP","0")); ++cx)
3 paul 1133
                                                {
167 Franz 1134
                                                        fg >> x;
1135
                                                        OB.Groups.push(x);
3 paul 1136
                                                }
1137
                                        tmp = "";
1138
                                        }
167 Franz 1139
                                        else
1140
                                                OB.Groups.clear();
3 paul 1141
                                QDomNode IT=OBJ.firstChild();
1142
                                while(!IT.isNull())
167 Franz 1143
                                {
3 paul 1144
                                        QDomElement it=IT.toElement();
295 Franz 1145
                                        if (it.tagName()=="CSTOP")
1146
                                        {
1147
                                                QString name = it.attribute("NAME");
1148
                                                double ramp = QStodouble(it.attribute("RAMP","0.0"));
1149
                                                int shade = QStoInt(it.attribute("SHADE","100"));
296 Franz 1150
                                                double opa = QStodouble(it.attribute("TRANS","1"));
690 cbradney 1151
                                                OB.fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
2180 fschmid 1152
                                                OB.GrColor = "";
1153
                                                OB.GrColor2 = "";
295 Franz 1154
                                        }
3 paul 1155
                                        if (it.tagName()=="ITEXT")
1428 fschmid 1156
                                                tmp += GetItemText(&it, doc, view->Prefs, VorLFound, true, false);
332 Franz 1157
                                        IT=IT.nextSibling();
114 Franz 1158
                                        }
1065 cbradney 1159
                                        OB.itemText = tmp;
456 fschmid 1160
                                        view->PasteItem(&OB, true);
1161
                                        Neu = doc->Items.at(counter);
167 Franz 1162
                                        if (QStoInt(obj.attribute("NEXTPAGE")) == PageToLoad)
31 Franz 1163
                                        {
167 Franz 1164
                                                Neu->NextIt = baseobj + QStoInt(obj.attribute("NEXTITEM"));
1165
                                                Neu->NextPg = a; // QStoInt(obj.attribute("NEXTPAGE"));
31 Franz 1166
                                        }
234 Franz 1167
                                        if (Neu->isTableItem)
1168
                                        {
1169
                                                TableItems.append(Neu);
1170
                                                TableID.insert(QStoInt(obj.attribute("OwnLINK","0")), Neu->ItemNr);
1171
                                        }
167 Franz 1172
                                        counter++;
1173
                                        OBJ=OBJ.nextSibling();
114 Franz 1174
                                }
234 Franz 1175
                                if (TableItems.count() != 0)
1176
                                {
1177
                                        for (uint ttc = 0; ttc < TableItems.count(); ++ttc)
1178
                                        {
1179
                                                PageItem* ta = TableItems.at(ttc);
1180
                                                if (ta->TopLinkID != -1)
456 fschmid 1181
                                                        ta->TopLink = doc->Items.at(TableID[ta->TopLinkID]);
234 Franz 1182
                                                else
1183
                                                        ta->TopLink = 0;
1184
                                                if (ta->LeftLinkID != -1)
456 fschmid 1185
                                                        ta->LeftLink = doc->Items.at(TableID[ta->LeftLinkID]);
234 Franz 1186
                                                else
1187
                                                        ta->LeftLink = 0;
1188
                                                if (ta->RightLinkID != -1)
456 fschmid 1189
                                                        ta->RightLink = doc->Items.at(TableID[ta->RightLinkID]);
234 Franz 1190
                                                else
1191
                                                        ta->RightLink = 0;
1192
                                                if (ta->BottomLinkID != -1)
456 fschmid 1193
                                                        ta->BottomLink = doc->Items.at(TableID[ta->BottomLinkID]);
234 Franz 1194
                                                else
1195
                                                        ta->BottomLink = 0;
1196
                                        }
1197
                                }
167 Franz 1198
                                if (LFrames.count() != 0)
31 Franz 1199
                                {
167 Franz 1200
                                        PageItem *Its;
1201
                                        PageItem *Itn;
1202
                                        PageItem *Itr;
1203
                                        QValueList<Linked>::Iterator lc;
1204
                                        for (lc = LFrames.begin(); lc != LFrames.end(); ++lc)
31 Franz 1205
                                        {
456 fschmid 1206
                                                Its = doc->Items.at((*lc).Start);
167 Franz 1207
                                                Itr = Its;
1208
                                                Its->BackBox = 0;
1209
                                                while (Its->NextIt != -1)
31 Franz 1210
                                                {
167 Franz 1211
                                                        if (Its->NextPg == a)
114 Franz 1212
                                                        {
456 fschmid 1213
                                                                Itn = doc->Items.at(Its->NextIt);
167 Franz 1214
                                                                Its->NextBox = Itn;
1215
                                                                Itn->BackBox = Its;
1216
                                                                Its = Itn;
114 Franz 1217
                                                        }
167 Franz 1218
                                                        else
1219
                                                                break;
31 Franz 1220
                                                }
167 Franz 1221
                                                Its->NextBox = 0;
31 Franz 1222
                                        }
1223
                                }
167 Franz 1224
                                if (!Mpage)
1225
                                        view->reformPages();
1226
                                return true;
114 Franz 1227
                        }
3 paul 1228
                PAGE=PAGE.nextSibling();
114 Franz 1229
                }      
3 paul 1230
        DOC=DOC.nextSibling();
167 Franz 1231
        }
1232
        return false;
3 paul 1233
}
1234
 
1235
bool ScriXmlDoc::ReadDoc(QString fileName, SCFonts &avail, ScribusDoc *doc, ScribusView *view, QProgressBar *dia2)
1236
{
1542 cbradney 1237
        //Scribus 1.2 docs, see fileloader.cpp for 1.3 docs
1065 cbradney 1238
        struct CopyPasteBuffer OB;
1239
        struct ParagraphStyle vg;
167 Franz 1240
        struct Layer la;
1241
        struct ScribusDoc::BookMa bok;
517 fschmid 1242
        int counter, Pgc;
167 Franz 1243
        bool AtFl;
1244
        bool newVersion = false;
1245
        struct Linked Link;
1246
        QString tmp, tmpf, tmp2, tmp3, tmp4, PgNam, Defont, tmf;
1247
        QFont fo;
234 Franz 1248
        QMap<int,int> TableID;
1249
        QPtrList<PageItem> TableItems;
332 Franz 1250
        int x, a;
2282 fschmid 1251
        double xf, xf2;
167 Franz 1252
        PageItem *Neu;
1253
        LFrames.clear();
1254
        QDomDocument docu("scridoc");
1255
        QString f = "";
1746 fschmid 1256
        QFile fi(fileName);
421 Franz 1257
        /* 2004/10/02 - petr vanek - bug #1092 - missing <PAGE> crash Scribus. The check constraint moved into IsScribus()
1258
        FIXME: I've add test on containig tag PAGE but returning FALSE freezes S. in scribus.cpp need some hack too...  */
1746 fschmid 1259
        if (fileName.right(2) == "gz")
1260
        {
1261
                f = ReadDatei(fileName);
1262
                if (!docu.setContent(f))
1263
                        return false;
1264
        }
1265
        else
1266
        {
1267
                if ( !fi.open( IO_ReadOnly ) )
1268
                {
1269
                        fi.close();
1270
                        return false;
1271
                }
1272
                if (!docu.setContent(&fi))
1273
                {
1274
                        fi.close();
1275
                        return false;
1276
                }
1277
                fi.close();
1278
        }
167 Franz 1279
        doc->PageColors.clear();       
1280
        doc->Layers.clear();
1281
        CMYKColor lf = CMYKColor();
1282
        QDomElement elem=docu.documentElement();
1283
        if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
1284
                return false;
1285
        if (elem.hasAttribute("Version"))
1286
                newVersion = true;
1287
        QDomNode DOC=elem.firstChild();
1288
        dia2->setTotalSteps(DOC.childNodes().count());
1289
        dia2->setProgress(0);
1290
        int ObCount = 0;
1291
        while(!DOC.isNull())
1292
        {
1293
                QDomElement dc=DOC.toElement();
3 paul 1294
        /*
1295
        * Attribute von DOCUMENT auslesen
1296
        */
2305 cbradney 1297
                if (dc.hasAttribute("PAGEWIDTH"))
1298
                        doc->pageWidth=QStodouble(dc.attribute("PAGEWIDTH"));
1299
                else
1300
                        doc->pageWidth=QStodouble(dc.attribute("PAGEWITH"));
2142 cbradney 1301
                doc->pageHeight=QStodouble(dc.attribute("PAGEHEIGHT"));
1302
                doc->pageMargins.Left=QStodouble(dc.attribute("BORDERLEFT"));
1303
                doc->pageMargins.Right=QStodouble(dc.attribute("BORDERRIGHT"));
1304
                doc->pageMargins.Top=QStodouble(dc.attribute("BORDERTOP"));
1305
                doc->pageMargins.Bottom=QStodouble(dc.attribute("BORDERBOTTOM"));
167 Franz 1306
                doc->PageOri = QStoInt(dc.attribute("ORIENTATION","0"));
519 cbradney 1307
                doc->PageSize = dc.attribute("PAGESIZE");
167 Franz 1308
                doc->FirstPnum = QStoInt(dc.attribute("FIRSTNUM","1"));
317 Franz 1309
                doc->PageFP=QStoInt(dc.attribute("BOOK", "0"));
1310
                doc->FirstPageLeft=QStoInt(dc.attribute("FIRSTLEFT","0"));
167 Franz 1311
                doc->PageAT=QStoInt(dc.attribute("AUTOTEXT"));
1312
                doc->PageSp=QStoInt(dc.attribute("AUTOSPALTEN"));
1313
                doc->PageSpa=QStodouble(dc.attribute("ABSTSPALTEN"));
1065 cbradney 1314
                doc->docUnitIndex = QStoInt(dc.attribute("UNITS","0"));
879 fschmid 1315
                doc->guidesSettings.gridShown = view->Prefs->guidesSettings.gridShown;
1316
                doc->guidesSettings.guidesShown = view->Prefs->guidesSettings.guidesShown;
1317
                doc->guidesSettings.framesShown = view->Prefs->guidesSettings.framesShown;
1318
                doc->guidesSettings.marginsShown = view->Prefs->guidesSettings.marginsShown;
1319
                doc->guidesSettings.baseShown = view->Prefs->guidesSettings.baseShown;
1320
                doc->guidesSettings.linkShown = view->Prefs->guidesSettings.linkShown;
1321
                doc->guidesSettings.showPic = true;
2353 fschmid 1322
                doc->guidesSettings.showControls = false;
167 Franz 1323
                DoFonts.clear();
1194 fschmid 1324
                doc->toolSettings.defSize=qRound(QStodouble(dc.attribute("DSIZE")) * 10);
167 Franz 1325
                Defont=dc.attribute("DFONT");
1428 fschmid 1326
                if ((!avail.find(Defont)) || (!avail[Defont]->UseFont))
121 Franz 1327
                {
1428 fschmid 1328
                        ReplacedFonts.insert(Defont, view->Prefs->toolSettings.defFont);
1329
                        Defont = view->Prefs->toolSettings.defFont;
121 Franz 1330
                }
325 Franz 1331
                else
1428 fschmid 1332
                {
1786 fschmid 1333
                        if (!doc->UsedFonts.contains(tmpf))
1334
                        {
1335
                                QFont fo = avail[Defont]->Font;
1336
                                fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
1337
                                doc->AddFont(Defont, fo);
1338
                        }
1428 fschmid 1339
                }
1194 fschmid 1340
                doc->toolSettings.defFont = Defont;
1341
                doc->toolSettings.dCols=QStoInt(dc.attribute("DCOL", "1"));
1342
                doc->toolSettings.dGap=QStodouble(dc.attribute("DGAP", "0.0"));
2024 cbradney 1343
                doc->documentInfo.setAuthor(dc.attribute("AUTHOR"));
1344
                doc->documentInfo.setComments(dc.attribute("COMMENTS"));
1345
                doc->documentInfo.setKeywords(dc.attribute("KEYWORDS",""));
1346
                doc->documentInfo.setTitle(dc.attribute("TITLE"));
1347
                doc->documentInfo.setPublisher(dc.attribute("PUBLISHER", ""));
1348
                doc->documentInfo.setDate(dc.attribute("DOCDATE", ""));
1349
                doc->documentInfo.setType(dc.attribute("DOCTYPE", ""));
1350
                doc->documentInfo.setFormat(dc.attribute("DOCFORMAT", ""));
1351
                doc->documentInfo.setIdent(dc.attribute("DOCIDENT", ""));
1352
                doc->documentInfo.setSource(dc.attribute("DOCSOURCE", ""));
1353
                doc->documentInfo.setLangInfo(dc.attribute("DOCLANGINFO", ""));
1354
                doc->documentInfo.setRelation(dc.attribute("DOCRELATION", ""));
1355
                doc->documentInfo.setCover(dc.attribute("DOCCOVER", ""));
1356
                doc->documentInfo.setRights(dc.attribute("DOCRIGHTS", ""));
1357
                doc->documentInfo.setContrib(dc.attribute("DOCCONTRIB", ""));
823 fschmid 1358
                doc->typographicSetttings.valueSuperScript = QStoInt(dc.attribute("VHOCH"));
1359
                doc->typographicSetttings.scalingSuperScript = QStoInt(dc.attribute("VHOCHSC"));
1360
                doc->typographicSetttings.valueSubScript = QStoInt(dc.attribute("VTIEF"));
1361
                doc->typographicSetttings.scalingSubScript = QStoInt(dc.attribute("VTIEFSC"));
1362
                doc->typographicSetttings.valueSmallCaps = QStoInt(dc.attribute("VKAPIT"));
1363
                doc->typographicSetttings.valueBaseGrid = QStodouble(dc.attribute("BASEGRID", "12"));
1364
                doc->typographicSetttings.offsetBaseGrid = QStodouble(dc.attribute("BASEO", "0"));
1365
                doc->typographicSetttings.autoLineSpacing = QStoInt(dc.attribute("AUTOL","20"));
167 Franz 1366
                doc->GroupCounter=QStoInt(dc.attribute("GROUPC","1"));
1367
                doc->HasCMS = static_cast<bool>(QStoInt(dc.attribute("HCMS","0")));
1368
                doc->CMSSettings.SoftProofOn = static_cast<bool>(QStoInt(dc.attribute("DPSo","0")));
1369
                doc->CMSSettings.CMSinUse = static_cast<bool>(QStoInt(dc.attribute("DPuse","0")));
1370
                doc->CMSSettings.GamutCheck = static_cast<bool>(QStoInt(dc.attribute("DPgam","0")));
1371
                doc->CMSSettings.BlackPoint = static_cast<bool>(QStoInt(dc.attribute("DPbla","1")));
1372
                doc->CMSSettings.DefaultMonitorProfile = dc.attribute("DPMo","");
1373
                doc->CMSSettings.DefaultPrinterProfile = dc.attribute("DPPr","");
1374
                doc->CMSSettings.DefaultInputProfile = dc.attribute("DPIn","");
1375
                doc->CMSSettings.DefaultInputProfile2 = dc.attribute("DPIn2","");
1376
                doc->CMSSettings.DefaultIntentPrinter = QStoInt(dc.attribute("DIPr","0"));
1377
                doc->CMSSettings.DefaultIntentMonitor = QStoInt(dc.attribute("DIMo","1"));
1378
                doc->CMSSettings.DefaultIntentMonitor2 = QStoInt(dc.attribute("DIMo2","1"));
1379
                doc->ActiveLayer = QStoInt(dc.attribute("ALAYER","0"));
1380
                doc->Language = dc.attribute("LANGUAGE", "");
1381
                doc->MinWordLen = QStoInt(dc.attribute("MINWORDLEN", "3"));
249 Franz 1382
                doc->HyCount = QStoInt(dc.attribute("HYCOUNT", "2"));
167 Franz 1383
                doc->Automatic = static_cast<bool>(QStoInt(dc.attribute("AUTOMATIC", "1")));
1384
                doc->AutoCheck = static_cast<bool>(QStoInt(dc.attribute("AUTOCHECK", "0")));
1385
                doc->GuideLock = static_cast<bool>(QStoInt(dc.attribute("GUIDELOCK", "0")));
879 fschmid 1386
                doc->guidesSettings.minorGrid = QStodouble(dc.attribute("MINGRID", tmp.setNum(view->Prefs->guidesSettings.minorGrid)));
1387
                doc->guidesSettings.majorGrid = QStodouble(dc.attribute("MAJGRID", tmp.setNum(view->Prefs->guidesSettings.majorGrid)));
1194 fschmid 1388
                doc->toolSettings.dStartArrow = 0;
1389
                doc->toolSettings.dEndArrow = 0;
1016 fschmid 1390
                doc->LastAuto = 0;
167 Franz 1391
                QDomNode PAGE=DOC.firstChild();
456 fschmid 1392
                counter = 0;
167 Franz 1393
                while(!PAGE.isNull())
3 paul 1394
                {
167 Franz 1395
                        ObCount++;
1396
                        dia2->setProgress(ObCount);
1397
                        QDomElement pg=PAGE.toElement();
516 fschmid 1398
                        // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
1399
                        if(pg.tagName()=="COLOR" && pg.attribute("NAME")!="None")
3 paul 1400
                        {
167 Franz 1401
                                if (pg.hasAttribute("CMYK"))
1402
                                        lf.setNamedColor(pg.attribute("CMYK"));
1403
                                else
1404
                                        lf.fromQColor(QColor(pg.attribute("RGB")));
1405
                          doc->PageColors[pg.attribute("NAME")] = lf;
3 paul 1406
                        }
167 Franz 1407
                        if(pg.tagName()=="STYLE")
3 paul 1408
                        {
167 Franz 1409
                                vg.Vname = pg.attribute("NAME");
2309 fschmid 1410
                                vg.LineSpaMode = QStoInt(pg.attribute("LINESPMode","0"));
167 Franz 1411
                                vg.LineSpa = QStodouble(pg.attribute("LINESP"));
1412
                                vg.Indent = QStodouble(pg.attribute("INDENT","0"));
1413
                                vg.First = QStodouble(pg.attribute("FIRST","0"));
1065 cbradney 1414
                                vg.textAlignment = QStoInt(pg.attribute("ALIGN"));
1415
                                vg.gapBefore = QStodouble(pg.attribute("VOR","0"));
1416
                                vg.gapAfter = QStodouble(pg.attribute("NACH","0"));
1194 fschmid 1417
                                tmpf = pg.attribute("FONT", doc->toolSettings.defFont);
1428 fschmid 1418
                                if ((!avail.find(tmpf)) || (!avail[tmpf]->UseFont))
1419
                                {
1420
                                        if ((!view->Prefs->GFontSub.contains(tmpf)) || (!avail[view->Prefs->GFontSub[tmpf]]->UseFont))
1468 fschmid 1421
                                        {
1422
                                                newReplacement = true;
1428 fschmid 1423
                                                ReplacedFonts.insert(tmpf, view->Prefs->toolSettings.defFont);
1468 fschmid 1424
                                        }
1428 fschmid 1425
                                        else
1426
                                                ReplacedFonts.insert(tmpf, view->Prefs->GFontSub[tmpf]);
1427
                                }
167 Franz 1428
                                else
1428 fschmid 1429
                                {
1786 fschmid 1430
                                        if (!doc->UsedFonts.contains(tmpf))
1431
                                        {
1432
                                                QFont fo = avail[tmpf]->Font;
1433
                                                fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
1434
                                                doc->AddFont(tmpf, fo);
1435
                                        }
1428 fschmid 1436
                                }
323 Franz 1437
                                vg.Font = tmpf;
167 Franz 1438
                                vg.FontSize = qRound(QStodouble(pg.attribute("FONTSIZE","12")) * 10.0);
1439
                                vg.Drop = static_cast<bool>(QStoInt(pg.attribute("DROP","0")));
1440
                                vg.DropLin = QStoInt(pg.attribute("DROPLIN","2"));
173 Franz 1441
                                vg.FontEffect = QStoInt(pg.attribute("EFFECT","0"));
1194 fschmid 1442
                                vg.FColor = pg.attribute("FCOLOR", doc->toolSettings.dBrush);
173 Franz 1443
                                vg.FShade = QStoInt(pg.attribute("FSHADE","100"));
1194 fschmid 1444
                                vg.SColor = pg.attribute("SCOLOR", doc->toolSettings.dPen);
173 Franz 1445
                                vg.SShade = QStoInt(pg.attribute("SSHADE","100"));
241 Franz 1446
                                vg.BaseAdj = static_cast<bool>(QStoInt(pg.attribute("BASE","0")));
2273 fschmid 1447
                                vg.txtShadowX = 50;
1448
                                vg.txtShadowY = -50;
1449
                                vg.txtOutline = 10;
1450
                                vg.txtUnderPos = doc->typographicSetttings.valueUnderlinePos;
1451
                                vg.txtUnderWidth = doc->typographicSetttings.valueUnderlineWidth;
1452
                                vg.txtStrikePos = doc->typographicSetttings.valueStrikeThruPos;
1453
                                vg.txtStrikeWidth = doc->typographicSetttings.valueStrikeThruPos;
167 Franz 1454
                                if ((pg.hasAttribute("NUMTAB")) && (QStoInt(pg.attribute("NUMTAB","0")) != 0))
140 Franz 1455
                                {
167 Franz 1456
                                        tmp = pg.attribute("TABS");
1457
                                        QTextStream tgv(&tmp, IO_ReadOnly);
1458
                                        vg.TabValues.clear();
2282 fschmid 1459
                                        struct PageItem::TabRecord tb;
1460
                                        for (int cxv = 0; cxv < QStoInt(pg.attribute("NUMTAB","0")); cxv += 2)
140 Franz 1461
                                        {
167 Franz 1462
                                                tgv >> xf;
2282 fschmid 1463
                                                tgv >> xf2;
1464
                                                tb.tabPosition = xf2;
1465
                                                tb.tabType = static_cast<int>(xf);
1466
                                                tb.tabFillChar = QChar();
1467
                                                vg.TabValues.append(tb);
140 Franz 1468
                                        }
167 Franz 1469
                                        tmp = "";
140 Franz 1470
                                }
167 Franz 1471
                                else
1472
                                        vg.TabValues.clear();
1065 cbradney 1473
                                doc->docParagraphStyles.append(vg);
3 paul 1474
                        }
167 Franz 1475
                        if(pg.tagName()=="JAVA")
1476
                                doc->JavaScripts[pg.attribute("NAME")] = pg.attribute("SCRIPT");
1477
                        if(pg.tagName()=="LAYERS")
3 paul 1478
                        {
167 Franz 1479
                                la.LNr = QStoInt(pg.attribute("NUMMER"));
1480
                                la.Level = QStoInt(pg.attribute("LEVEL"));
1481
                                la.Name = pg.attribute("NAME");
1065 cbradney 1482
                                la.isViewable = QStoInt(pg.attribute("SICHTBAR"));
1483
                                la.isPrintable = QStoInt(pg.attribute("DRUCKEN"));
167 Franz 1484
                                doc->Layers.append(la);
3 paul 1485
                        }
167 Franz 1486
                        if(pg.tagName()=="Bookmark")
3 paul 1487
                        {
167 Franz 1488
                                bok.Title = pg.attribute("Title");
1489
                                bok.Text = pg.attribute("Text");
1490
                                bok.Aktion = pg.attribute("Aktion");
1491
                                bok.ItemNr = QStoInt(pg.attribute("ItemNr"));
1492
                                bok.Seite = QStoInt(pg.attribute("Seite"));
1493
                                bok.Element = QStoInt(pg.attribute("Element"));
1494
                                bok.First = QStoInt(pg.attribute("First"));
1495
                                bok.Last = QStoInt(pg.attribute("Last"));
1496
                                bok.Prev = QStoInt(pg.attribute("Prev"));
1497
                                bok.Next = QStoInt(pg.attribute("Next"));
1498
                                bok.Parent = QStoInt(pg.attribute("Parent"));
1499
                                doc->BookMarks.append(bok);
3 paul 1500
                        }
167 Franz 1501
                        if(pg.tagName()=="MultiLine")
27 Franz 1502
                        {
167 Franz 1503
                                multiLine ml;
1504
                                QDomNode MuLn = PAGE.firstChild();
1505
                                while(!MuLn.isNull())
27 Franz 1506
                                {
167 Franz 1507
                                        QDomElement MuL = MuLn.toElement();
1065 cbradney 1508
                                        struct SingleLine sl;
167 Franz 1509
                                        sl.Color = MuL.attribute("Color");
1510
                                        sl.Dash = QStoInt(MuL.attribute("Dash"));
1511
                                        sl.LineEnd = QStoInt(MuL.attribute("LineEnd"));
1512
                                        sl.LineJoin = QStoInt(MuL.attribute("LineJoin"));
1513
                                        sl.Shade = QStoInt(MuL.attribute("Shade"));
1514
                                        sl.Width = QStodouble(MuL.attribute("Width"));
1515
                                        ml.push_back(sl);
1516
                                        MuLn = MuLn.nextSibling();
27 Franz 1517
                                }
167 Franz 1518
                                doc->MLineStyles.insert(pg.attribute("Name"), ml);
27 Franz 1519
                        }
167 Franz 1520
                        if(pg.tagName()=="PAGE")
114 Franz 1521
                        {
234 Franz 1522
                                TableItems.clear();
1523
                                TableID.clear();
3 paul 1524
                        /*
1525
                        * Attribute von PAGE auslesen
1526
                        */
167 Franz 1527
                                a = QStoInt(pg.attribute("NUM"));
1528
                                PgNam = "";
1529
                                PgNam = pg.attribute("NAM", "");
2142 cbradney 1530
                                Pgc = doc->pageCount;
167 Franz 1531
                                AtFl = doc->PageAT;
1532
                                if (PgNam == "")
3 paul 1533
                                {
2142 cbradney 1534
                                        doc->pageCount = Pgc;
456 fschmid 1535
                                        doc->Pages = doc->DocPages;
167 Franz 1536
                                        doc->PageAT = AtFl;
1537
                                        doc->MasterP = false;
456 fschmid 1538
                                        doc->Items = doc->DocItems;
3 paul 1539
                                }
167 Franz 1540
                                else
3 paul 1541
                                {
2142 cbradney 1542
                                        doc->pageCount = 0;
167 Franz 1543
                                        doc->PageAT = false;
456 fschmid 1544
                                        doc->Pages = doc->MasterPages;
167 Franz 1545
                                        doc->MasterP = true;
456 fschmid 1546
                                        doc->Items = doc->MasterItems;
3 paul 1547
                                }
167 Franz 1548
                                emit NewPage(a);
456 fschmid 1549
                                doc->Pages.at(a)->LeftPg=QStoInt(pg.attribute("LEFT","0"));
167 Franz 1550
                                QString Mus = "";
1551
                                Mus = pg.attribute("MNAM","Normal");
1552
                                if (!doc->MasterP)
456 fschmid 1553
                                        doc->Pages.at(a)->MPageNam = Mus;
167 Franz 1554
                                else
456 fschmid 1555
                                        doc->Pages.at(a)->MPageNam = "";
167 Franz 1556
                                if ((pg.hasAttribute("NumVGuides")) && (QStoInt(pg.attribute("NumVGuides","0")) != 0))
3 paul 1557
                                {
167 Franz 1558
                                        tmp = pg.attribute("VerticalGuides");
1559
                                        QTextStream fgv(&tmp, IO_ReadOnly);
456 fschmid 1560
                                        doc->Pages.at(a)->YGuides.clear();
167 Franz 1561
                                        for (int cxv = 0; cxv < QStoInt(pg.attribute("NumVGuides","0")); ++cxv)
3 paul 1562
                                        {
167 Franz 1563
                                                fgv >> xf;
456 fschmid 1564
                                                doc->Pages.at(a)->YGuides.append(xf);
3 paul 1565
                                        }
456 fschmid 1566
                                        qHeapSort(doc->Pages.at(a)->YGuides);
167 Franz 1567
                                        tmp = "";
3 paul 1568
                                }
167 Franz 1569
                                else
456 fschmid 1570
                                        doc->Pages.at(a)->YGuides.clear();
167 Franz 1571
                                if ((pg.hasAttribute("NumHGuides")) && (QStoInt(pg.attribute("NumHGuides","0")) != 0))
3 paul 1572
                                {
167 Franz 1573
                                        tmp = pg.attribute("HorizontalGuides");
1574
                                        QTextStream fgh(&tmp, IO_ReadOnly);
456 fschmid 1575
                                        doc->Pages.at(a)->XGuides.clear();
167 Franz 1576
                                        for (int cxh = 0; cxh < QStoInt(pg.attribute("NumHGuides","0")); ++cxh)
3 paul 1577
                                        {
167 Franz 1578
                                                fgh >> xf;
456 fschmid 1579
                                                doc->Pages.at(a)->XGuides.append(xf);
3 paul 1580
                                        }
456 fschmid 1581
                                        qHeapSort(doc->Pages.at(a)->XGuides);
167 Franz 1582
                                        tmp = "";
3 paul 1583
                                }
167 Franz 1584
                                else
456 fschmid 1585
                                        doc->Pages.at(a)->XGuides.clear();
167 Franz 1586
                                QDomNode OBJ=PAGE.firstChild();
1587
                                while(!OBJ.isNull())
1588
                                {
1589
                                        QDomElement obj=OBJ.toElement();
3 paul 1590
                                /*
1591
                                * Attribute von OBJECT auslesen
1592
                                */
267 Franz 1593
                                        if ((QStoInt(obj.attribute("NEXTITEM")) != -1) || (static_cast<bool>(QStoInt(obj.attribute("AUTOTEXT")))))
3 paul 1594
                                        {
167 Franz 1595
                                                if (QStoInt(obj.attribute("BACKITEM")) == -1)
3 paul 1596
                                                {
167 Franz 1597
                                                        Link.Start = counter;
1598
                                                        Link.StPag = a;
1599
                                                        LFrames.append(Link);
3 paul 1600
                                                }
1601
                                        }
332 Franz 1602
                                        GetItemProps(newVersion, &obj, &OB);
456 fschmid 1603
                                        OB.Xpos = QStodouble(obj.attribute("XPOS"))+doc->Pages.at(a)->Xoffset;
1604
                                        OB.Ypos=QStodouble(obj.attribute("YPOS"))+doc->Pages.at(a)->Yoffset;
167 Franz 1605
                                        OB.NamedLStyle = obj.attribute("NAMEDLST", "");
1606
                                        OB.isBookmark=QStoInt(obj.attribute("BOOKMARK"));
1607
                                        if ((OB.isBookmark) && (doc->BookMarks.count() == 0))
1608
                                                doc->OldBM = true;
1609
                                        OB.BMnr = QStoInt(obj.attribute("BookNr","0"));
1065 cbradney 1610
                                        OB.textAlignment = QStoInt(obj.attribute("ALIGN","0"));
745 fschmid 1611
                                        OB.startArrowIndex =  0;
1612
                                        OB.endArrowIndex =  0;
1194 fschmid 1613
                                        tmpf = obj.attribute("IFONT", doc->toolSettings.defFont);
1428 fschmid 1614
                                        if ((!avail.find(tmpf)) || (!avail[tmpf]->UseFont))
1615
                                        {
1616
                                                if ((!view->Prefs->GFontSub.contains(tmpf)) || (!avail[view->Prefs->GFontSub[tmpf]]->UseFont))
1468 fschmid 1617
                                                {
1618
                                                        newReplacement = true;
1428 fschmid 1619
                                                        ReplacedFonts.insert(tmpf, view->Prefs->toolSettings.defFont);
1468 fschmid 1620
                                                }
1428 fschmid 1621
                                                else
1622
                                                        ReplacedFonts.insert(tmpf, view->Prefs->GFontSub[tmpf]);
1623
                                        }
204 Franz 1624
                                        else
1428 fschmid 1625
                                        {
1786 fschmid 1626
                                                if (!doc->UsedFonts.contains(tmpf))
1627
                                                {
1628
                                                        QFont fo = avail[tmpf]->Font;
1629
                                                        fo.setPointSize(qRound(doc->toolSettings.defSize / 10.0));
1630
                                                        doc->AddFont(tmpf, fo);
1631
                                                }
1428 fschmid 1632
                                        }
323 Franz 1633
                                        OB.IFont = tmpf;
167 Franz 1634
                                        OB.LayerNr = QStoInt(obj.attribute("LAYER","0"));
1635
                                        OB.Language = obj.attribute("LANGUAGE", doc->Language);
1636
                                        tmp = "";
1637
                                        if ((obj.hasAttribute("GROUPS")) && (QStoInt(obj.attribute("NUMGROUP","0")) != 0))
3 paul 1638
                                        {
167 Franz 1639
                                                tmp = obj.attribute("GROUPS");
1640
                                                QTextStream fg(&tmp, IO_ReadOnly);
1641
                                                OB.Groups.clear();
1642
                                                for (int cx = 0; cx < QStoInt(obj.attribute("NUMGROUP","0")); ++cx)
3 paul 1643
                                                {
167 Franz 1644
                                                        fg >> x;
1645
                                                        OB.Groups.push(x);
3 paul 1646
                                                }
167 Franz 1647
                                                tmp = "";
3 paul 1648
                                        }
167 Franz 1649
                                        else
1650
                                                OB.Groups.clear();
1651
                                        QDomNode IT=OBJ.firstChild();
1652
                                        while(!IT.isNull())
1653
                                        {
1654
                                                QDomElement it=IT.toElement();
295 Franz 1655
                                                if (it.tagName()=="CSTOP")
1656
                                                {
1657
                                                        QString name = it.attribute("NAME");
1658
                                                        double ramp = QStodouble(it.attribute("RAMP","0.0"));
1659
                                                        int shade = QStoInt(it.attribute("SHADE","100"));
296 Franz 1660
                                                        double opa = QStodouble(it.attribute("TRANS","1"));
690 cbradney 1661
                                                        OB.fill_gradient.addStop(SetColor(doc, name, shade), ramp, 0.5, opa, name, shade);
2180 fschmid 1662
                                                        OB.GrColor = "";
1663
                                                        OB.GrColor2 = "";
295 Franz 1664
                                                }
167 Franz 1665
                                                IT=IT.nextSibling();
1666
                                        }
1789 fschmid 1667
                                        OB.itemText = "";
167 Franz 1668
                                        int docGc = doc->GroupCounter;
1669
                                        doc->GroupCounter = 0;
456 fschmid 1670
                                        uint last = doc->Items.count();
1671
                                        view->PasteItem(&OB, true);
167 Franz 1672
                                        doc->GroupCounter = docGc;
456 fschmid 1673
                                        Neu = doc->Items.at(last);
1866 fschmid 1674
                                        Neu->OnMasterPage = PgNam;
1789 fschmid 1675
                                        IT=OBJ.firstChild();
1676
                                        while(!IT.isNull())
1677
                                        {
1678
                                                QDomElement it=IT.toElement();
1679
                                                if (it.tagName()=="ITEXT")
1680
                                                        GetItemText(&it, doc, view->Prefs, false, false, true, Neu);
1681
                                                IT=IT.nextSibling();
1682
                                        }
267 Franz 1683
                                        Neu->isAutoText=static_cast<bool>(QStoInt(obj.attribute("AUTOTEXT")));
167 Franz 1684
                                        if (Neu->isAutoText)
1685
                                                doc->LastAuto = Neu;
1686
                                        Neu->NextIt = QStoInt(obj.attribute("NEXTITEM"));
1687
                                        Neu->NextPg = QStoInt(obj.attribute("NEXTPAGE"));
234 Franz 1688
                                        if (Neu->isTableItem)
1689
                                        {
1690
                                                TableItems.append(Neu);
1691
                                                TableID.insert(QStoInt(obj.attribute("OwnLINK","0")), Neu->ItemNr);
1692
                                        }
167 Franz 1693
                                        counter++;
1694
                                        OBJ=OBJ.nextSibling();
114 Franz 1695
                                }
234 Franz 1696
                                if (TableItems.count() != 0)
1697
                                {
1698
                                        for (uint ttc = 0; ttc < TableItems.count(); ++ttc)
1699
                                        {
1700
                                                PageItem* ta = TableItems.at(ttc);
1701
                                                if (ta->TopLinkID != -1)
456 fschmid 1702
                                                        ta->TopLink = doc->Items.at(TableID[ta->TopLinkID]);
234 Franz 1703
                                                else
1704
                                                        ta->TopLink = 0;
1705
                                                if (ta->LeftLinkID != -1)
456 fschmid 1706
                                                        ta->LeftLink = doc->Items.at(TableID[ta->LeftLinkID]);
234 Franz 1707
                                                else
1708
                                                        ta->LeftLink = 0;
1709
                                                if (ta->RightLinkID != -1)
456 fschmid 1710
                                                        ta->RightLink = doc->Items.at(TableID[ta->RightLinkID]);
234 Franz 1711
                                                else
1712
                                                        ta->RightLink = 0;
1713
                                                if (ta->BottomLinkID != -1)
456 fschmid 1714
                                                        ta->BottomLink = doc->Items.at(TableID[ta->BottomLinkID]);
234 Franz 1715
                                                else
1716
                                                        ta->BottomLink = 0;
1717
                                        }
1718
                                }
167 Franz 1719
                                if (PgNam == "")
456 fschmid 1720
                                {
1721
                                        doc->DocPages = doc->Pages;
1722
                                        doc->DocItems = doc->Items;
1723
                                }
167 Franz 1724
                                else
3 paul 1725
                                {
1199 tsoots 1726
                                  doc->Pages.at(a)->setPageName(PgNam);
456 fschmid 1727
                                        doc->MasterNames[PgNam] = a;
1728
                                        doc->MasterPages = doc->Pages;
1729
                                        doc->MasterItems = doc->Items;
3 paul 1730
                                }
167 Franz 1731
                                doc->MasterP = false;
2142 cbradney 1732
                                doc->pageCount = Pgc+1;
167 Franz 1733
                                doc->PageAT = AtFl;
1734