Subversion Repositories Scribus

Rev

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