Subversion Repositories Scribus

Rev

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