Subversion Repositories Scribus

Rev

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

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