Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
13971 jghali 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
*/
7
#include "scribus150format.h"
8
#include "scribus150formatimpl.h"
9
 
10
#include "../../formatidlist.h"
11
#include "commonstrings.h"
12
#include "ui/missing.h"
13
#include "hyphenator.h"
14
#include "pageitem_latexframe.h"
15
#include "prefsmanager.h"
16
#include "scclocale.h"
17
#include "scconfig.h"
18
#include "sccolorengine.h"
19
#include "scpattern.h"
20
#include "scribuscore.h"
21
#include "scribusdoc.h"
22
#include "scribusview.h"
23
#include "sctextstream.h"
24
#include "scxmlstreamreader.h"
25
#include "undomanager.h"
26
#include "units.h"
27
#include "util.h"
28
#include "util_math.h"
29
#include "util_color.h"
30
#include "scgzfile.h"
31
#ifdef HAVE_OSG
32
        #include "pageitem_osgframe.h"
33
#endif
16863 craig 34
#include "pageitem_table.h"
16191 fschmid 35
#include "pageitem_regularpolygon.h"
16215 fschmid 36
#include "pageitem_arc.h"
16311 fschmid 37
#include "pageitem_spiral.h"
13971 jghali 38
#include <QCursor>
39
// #include <QDebug>
40
#include <QFileInfo>
41
#include <QList>
42
#include <QByteArray>
43
#include <QApplication>
44
 
45
 
46
// See scplugin.h and pluginmanager.{cpp,h} for detail on what these methods
47
// do. That documentatation is not duplicated here.
48
// Please don't implement the functionality of your plugin here; do that
49
// in scribus150formatimpl.h and scribus150formatimpl.cpp .
50
 
51
Scribus150Format::Scribus150Format() :
52
        LoadSavePlugin()
53
{
54
        // Set action info in languageChange, so we only have to do
55
        // it in one place. This includes registering file formats.
56
        languageChange();
57
}
58
 
59
Scribus150Format::~Scribus150Format()
60
{
61
        unregisterAll();
62
};
63
 
64
void Scribus150Format::languageChange()
65
{
66
        //(Re)register file formats.
67
        unregisterAll();
68
        registerFormats();
69
}
70
 
71
const QString Scribus150Format::fullTrName() const
72
{
16105 fschmid 73
        return QObject::tr("Scribus 1.5.0+ Support");
13971 jghali 74
}
75
 
76
const ScActionPlugin::AboutData* Scribus150Format::getAboutData() const
77
{
78
        AboutData* about = new AboutData;
79
        Q_CHECK_PTR(about);
80
        about->authors = QString::fromUtf8(
81
                        "Franz Schmid <franz@scribus.info>, "
82
                        "The Scribus Team");
16105 fschmid 83
        about->shortDescription = tr("Scribus 1.5.0+ File Format Support");
84
        about->description = tr("Allows Scribus to read Scribus 1.5.0 and higher formatted files.");
13971 jghali 85
        // about->version
86
        // about->releaseDate
87
        // about->copyright
88
        about->license = "GPL";
89
        return about;
90
}
91
 
92
void Scribus150Format::deleteAboutData(const AboutData* about) const
93
{
94
        Q_ASSERT(about);
95
        delete about;
96
}
97
 
98
void Scribus150Format::registerFormats()
99
{
100
        FileFormat fmt(this);
101
        fmt.trName = tr("Scribus 1.5.0+ Document");
102
        fmt.formatId = FORMATID_SLA150IMPORT;
103
        fmt.load = true;
104
        fmt.save = true;
14792 fschmid 105
        fmt.colorReading = true;
13971 jghali 106
        fmt.filter = fmt.trName + " (*.sla *.SLA *.sla.gz *.SLA.GZ *.scd *.SCD *.scd.gz *.SCD.GZ)";
107
        fmt.nameMatch = QRegExp("\\.(sla|scd)(\\.gz)?", Qt::CaseInsensitive);
108
        fmt.mimeTypes = QStringList();
109
        fmt.mimeTypes.append("application/x-scribus");
14792 fschmid 110
        fmt.fileExtensions = QStringList() << "sla" << "sla.gz" << "scd" << "scd.gz";
13971 jghali 111
        fmt.priority = 64;
112
        registerFormat(fmt);
113
}
114
 
115
bool Scribus150Format::fileSupported(QIODevice* /* file */, const QString & fileName) const
116
{
117
        QByteArray docBytes("");
118
        if(fileName.right(2) == "gz")
119
        {
120
                if (!ScGzFile::readFromFile(fileName, docBytes, 4096))
121
                {
122
                        // FIXME: Needs better error return
123
                        return false;
124
                }
125
        }
126
        else
127
        {
128
                // Not gzip encoded, just load it
129
                loadRawText(fileName, docBytes);
130
        }
16105 fschmid 131
        QRegExp regExp150("Version=\"1.5.[0-9]");
13971 jghali 132
        int startElemPos = docBytes.left(512).indexOf("<SCRIBUSUTF8NEW ");
16105 fschmid 133
        if (startElemPos >= 0)
134
        {
135
                bool is150 = ( regExp150.indexIn(docBytes.mid(startElemPos, 64)) >= 0 );
136
                return is150;
137
        }
138
        return false;
13971 jghali 139
}
140
 
141
QString Scribus150Format::readSLA(const QString & fileName)
142
{
143
        QByteArray docBytes("");
144
        if(fileName.right(2) == "gz")
145
        {
146
                if (!ScGzFile::readFromFile(fileName, docBytes))
147
                {
148
                        // FIXME: Needs better error return
15479 craig 149
                        return QString::null;
13971 jghali 150
                }
151
        }
152
        else
153
        {
154
                // Not gzip encoded, just load it
155
                loadRawText(fileName, docBytes);
156
        }
157
        QString docText("");
158
        int startElemPos = docBytes.left(512).indexOf("<SCRIBUSUTF8NEW ");
16105 fschmid 159
        if (startElemPos >= 0)
160
        {
161
                QRegExp regExp150("Version=\"1.5.[0-9]");
162
                bool is150 = ( regExp150.indexIn(docBytes.mid(startElemPos, 64)) >= 0 );
163
                if (is150)
164
                        docText = QString::fromUtf8(docBytes);
165
                if (docText.endsWith(QChar(10)) || docText.endsWith(QChar(13)))
166
                        docText.truncate(docText.length()-1);
167
        }
168
        if (docText.isEmpty())
13971 jghali 169
                return QString::null;
170
        return docText;
171
}
172
 
173
void Scribus150Format::getReplacedFontData(bool & getNewReplacement, QMap<QString,QString> &getReplacedFonts, QList<ScFace> &getDummyScFaces)
174
{
175
        getNewReplacement=false;
176
        getReplacedFonts.clear();
177
}
178
 
16105 fschmid 179
bool Scribus150Format::loadElements(const QString & data, QString fileDir, int toLayer, double Xp_in, double Yp_in, bool loc)
180
{
181
        ParagraphStyle vg;
182
        bool newVersion = false;
16943 fschmid 183
        isNewFormat = false;
16105 fschmid 184
        LayerToPaste = toLayer;
185
        Xp = Xp_in;
186
        Yp = Yp_in;
16159 fschmid 187
//      GrX = 0.0;
188
//      GrY = 0.0;
16105 fschmid 189
 
16943 fschmid 190
        QMap<int,PageItem*> TableID;
191
        QMap<int,PageItem*> TableIDM;
192
        QMap<int,PageItem*> TableIDF;
16105 fschmid 193
        QList<PageItem*> TableItems;
194
        QList<PageItem*> TableItemsM;
195
        QList<PageItem*> TableItemsF;
16931 fschmid 196
        QMap<int,PageItem*> WeldID;
16926 fschmid 197
        QList<PageItem*> WeldItems;
16105 fschmid 198
        QStack< QList<PageItem*> > groupStack;
199
        QStack< QList<PageItem*> > groupStackF;
200
        QStack< QList<PageItem*> > groupStackM;
201
        QStack< QList<PageItem*> > groupStackP;
202
        QStack<int> groupStack2;
203
 
204
        ScColor lf = ScColor();
205
 
206
        itemRemap.clear();
207
        itemNext.clear();
208
        itemCount = 0;
209
        itemRemapM.clear();
210
        itemNextM.clear();
211
        itemCountM = 0;
212
        itemRemapF.clear();
213
        itemNextF.clear();
214
 
215
        TableItems.clear();
216
        TableID.clear();
217
        TableItemsM.clear();
218
        TableIDM.clear();
219
        TableItemsF.clear();
220
        TableIDF.clear();
16926 fschmid 221
        WeldItems.clear();
222
        WeldID.clear();
16105 fschmid 223
 
224
        bool firstElement = true;
225
        bool success = true;
226
 
227
        ScXmlStreamReader reader(data);
228
        ScXmlStreamAttributes attrs;
229
        while(!reader.atEnd() && !reader.hasError())
230
        {
231
                QXmlStreamReader::TokenType tType = reader.readNext();
232
                if (tType != QXmlStreamReader::StartElement)
233
                        continue;
234
                QStringRef tagName = reader.name();
235
                attrs = reader.scAttributes();
236
 
237
                if (firstElement)
238
                {
239
                        if (tagName == "SCRIBUSELEM" || tagName == "SCRIBUSELEMUTF8")
240
                        {
241
                                if (!loc)
242
                                {
243
                                        GrX = attrs.valueAsDouble("XP");
244
                                        GrY = attrs.valueAsDouble("YP");
245
                                }
246
                                if (attrs.hasAttribute("Version"))
247
                                        newVersion = true;
248
                        }
249
                        else
250
                        {
251
                                success = false;
252
                                break;
253
                        }
254
                        firstElement = false;
255
                }
256
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
257
                if (tagName == "COLOR" && attrs.valueAsString("NAME") != CommonStrings::None)
258
                {
259
                        success = readColor(m_Doc->PageColors, attrs);
260
                        if (!success) break;
261
                }
262
                if (tagName == "Gradient")
263
                {
264
                        VGradient gra;
265
                        QString grName = attrs.valueAsString("Name");
266
                        success = readGradient(m_Doc, gra, reader);
267
                        if (!success) break;
268
                        if (!grName.isEmpty())
269
                        {
270
                                m_Doc->docGradients.insert(grName, gra);
271
                        }
272
                }
273
                if (tagName == "STYLE")
274
                {
16531 jghali 275
                        readParagraphStyle(m_Doc, reader, vg);
16105 fschmid 276
                        StyleSet<ParagraphStyle>tmp;
277
                        tmp.create(vg);
278
                        m_Doc->redefineStyles(tmp, false);
279
                }
280
                if (tagName == "CHARSTYLE")
281
                {
16531 jghali 282
                        readParagraphStyle(m_Doc, reader, vg);
16105 fschmid 283
                        StyleSet<CharStyle> temp;
284
                        temp.create(vg.charStyle());
285
                        m_Doc->redefineCharStyles(temp, false);
286
                }
17318 fschmid 287
                if (tagName == "TableStyle")
288
                {
289
                        TableStyle tstyle;
290
                        readTableStyle(m_Doc, reader, tstyle);
291
                        StyleSet<TableStyle> temp;
292
                        temp.create(tstyle);
293
                        m_Doc->redefineTableStyles(temp, false);
294
                }
295
                if (tagName == "CellStyle")
296
                {
297
                        CellStyle tstyle;
298
                        readCellStyle(m_Doc, reader, tstyle);
299
                        StyleSet<CellStyle> temp;
300
                        temp.create(tstyle);
301
                        m_Doc->redefineCellStyles(temp, false);
302
                }
16105 fschmid 303
                if (tagName == "Arrows")
304
                {
305
                        success = readArrows(m_Doc, attrs);
306
                        if (!success) break;
307
                }
308
                if (tagName == "MultiLine")
309
                {
310
                        multiLine ml;
311
                        QString mlName = attrs.valueAsString("Name");
312
                        success = readMultiline(ml, reader);
313
                        if (!success) break;
314
                        if (!mlName.isEmpty())
315
                        {
316
                                m_Doc->MLineStyles.insert(mlName, ml);
317
                        }
318
                }
17147 fschmid 319
                if ((tagName == "ITEM") || (tagName == "FRAMEOBJECT"))
16105 fschmid 320
                {
321
                        ItemInfo itemInfo;
322
                        success = readObject(m_Doc, reader, itemInfo, fileDir, true);
323
                        if (!success)
324
                                break;
16943 fschmid 325
                        if (isNewFormat)
16105 fschmid 326
                        {
327
                                if (itemInfo.nextItem != -1)
16943 fschmid 328
                                        itemNext[itemInfo.itemID] = itemInfo.nextItem;
329
                                if (itemInfo.item->isTableItem)
330
                                        TableItems.append(itemInfo.item);
331
                                if (itemInfo.isWeldFlag)
332
                                        WeldItems.append(itemInfo.item);
16105 fschmid 333
                        }
16943 fschmid 334
                        else
16105 fschmid 335
                        {
16943 fschmid 336
                        // first of linked chain?
16105 fschmid 337
                                if (tagName == "ITEM")
338
                                {
16943 fschmid 339
                                        if (itemInfo.nextItem != -1)
340
                                                itemNext[itemInfo.ownNr] = itemInfo.nextItem;
16105 fschmid 341
                                }
16943 fschmid 342
                                if (itemInfo.item->isTableItem)
16926 fschmid 343
                                {
16943 fschmid 344
                                        if (tagName == "ITEM")
345
                                        {
346
                                                TableItems.append(itemInfo.item);
347
                                                TableID.insert(itemInfo.ownLink, itemInfo.item);
348
                                        }
16926 fschmid 349
                                }
16943 fschmid 350
                                if (itemInfo.isWeldFlag)
351
                                {
352
                                        if (tagName == "ITEM")
353
                                        {
354
                                                WeldItems.append(itemInfo.item);
355
                                                WeldID.insert(itemInfo.ownWeld, itemInfo.item);
356
                                        }
357
                                }
16926 fschmid 358
                        }
16105 fschmid 359
                        if (groupStack.count() > 0)
360
                        {
361
                                groupStack.top().append(itemInfo.item);
16943 fschmid 362
                                while (static_cast<int>(itemInfo.ownNr) == groupStack2.top())
16105 fschmid 363
                                {
364
                                        if ((tagName == "PAGEOBJECT") || (tagName == "ITEM"))
365
                                                groupStackP.push(groupStack.pop());
366
                                        else if (tagName == "FRAMEOBJECT")
367
                                                groupStackF.push(groupStack.pop());
368
                                        else
369
                                                groupStackM.push(groupStack.pop());
370
                                        groupStack2.pop();
16233 fschmid 371
                                        if (groupStack2.count() == 0)
372
                                                break;
16105 fschmid 373
                                }
374
                        }
16113 fschmid 375
                        if (itemInfo.isGroupFlag)
16105 fschmid 376
                        {
377
                                QList<PageItem*> GroupItems;
378
                                GroupItems.append(itemInfo.item);
379
                                groupStack.push(GroupItems);
16943 fschmid 380
                                groupStack2.push(itemInfo.groupLastItem + itemInfo.ownNr);
16105 fschmid 381
                        }
382
                }
383
                if (tagName == "Pattern")
384
                {
385
                        success = readPattern(m_Doc, reader, fileDir);
386
                        if (!success) break;
387
                }
388
        }
389
        if (reader.hasError())
390
        {
391
                setDomParsingError(reader.errorString(), reader.lineNumber(), reader.columnNumber());
392
                return false;
393
        }
16943 fschmid 394
        if (isNewFormat)
16105 fschmid 395
        {
16943 fschmid 396
                if (TableItems.count() != 0)
16105 fschmid 397
                {
16943 fschmid 398
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
399
                        {
400
                                PageItem* ta = TableItems.at(ttc);
401
                                if (ta->TopLinkID != -1)
402
                                        ta->TopLink = LinkID[ta->TopLinkID];
403
                                else
404
                                        ta->TopLink = 0;
405
                                if (ta->LeftLinkID != -1)
406
                                        ta->LeftLink = LinkID[ta->LeftLinkID];
407
                                else
408
                                        ta->LeftLink = 0;
409
                                if (ta->RightLinkID != -1)
410
                                        ta->RightLink = LinkID[ta->RightLinkID];
411
                                else
412
                                        ta->RightLink = 0;
413
                                if (ta->BottomLinkID != -1)
414
                                        ta->BottomLink = LinkID[ta->BottomLinkID];
415
                                else
416
                                        ta->BottomLink = 0;
417
                        }
16105 fschmid 418
                }
16943 fschmid 419
                if (WeldItems.count() != 0)
16105 fschmid 420
                {
16943 fschmid 421
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
422
                        {
423
                                PageItem* ta = WeldItems.at(ttc);
424
                                for (int i = 0 ; i < ta->weldList.count(); i++)
425
                                {
426
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
427
                                        ta->weldList[i].weldItem = LinkID[wInf.weldID];
428
                                }
429
                        }
16105 fschmid 430
                }
16943 fschmid 431
                if (itemNext.count() != 0)
16105 fschmid 432
                {
16943 fschmid 433
                        QMap<int,int>::Iterator lc;
434
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
435
                        {
436
                                if (lc.value() >= 0)
437
                                {
438
                                        PageItem * Its = LinkID[lc.key()];
439
                                        PageItem * Itn = LinkID[lc.value()];
440
                                        if (!Its->testLinkCandidate(Itn))
441
                                        {
442
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
443
                                                continue;
444
                                        }
445
                                        Its->link(Itn);
446
                                }
447
                        }
16105 fschmid 448
                }
449
        }
16943 fschmid 450
        else
16926 fschmid 451
        {
16943 fschmid 452
                if (TableItemsF.count() != 0)
16926 fschmid 453
                {
16943 fschmid 454
                        for (int ttc = 0; ttc < TableItemsF.count(); ++ttc)
16926 fschmid 455
                        {
16943 fschmid 456
                                PageItem* ta = TableItemsF.at(ttc);
457
                                if (ta->TopLinkID != -1)
458
                                        ta->TopLink = TableIDF[ta->TopLinkID];
459
                                else
460
                                        ta->TopLink = 0;
461
                                if (ta->LeftLinkID != -1)
462
                                        ta->LeftLink = TableIDF[ta->LeftLinkID];
463
                                else
464
                                        ta->LeftLink = 0;
465
                                if (ta->RightLinkID != -1)
466
                                        ta->RightLink = TableIDF[ta->RightLinkID];
467
                                else
468
                                        ta->RightLink = 0;
469
                                if (ta->BottomLinkID != -1)
470
                                        ta->BottomLink = TableIDF[ta->BottomLinkID];
471
                                else
472
                                        ta->BottomLink = 0;
16926 fschmid 473
                        }
474
                }
16943 fschmid 475
                if (TableItemsM.count() != 0)
16105 fschmid 476
                {
16943 fschmid 477
                        for (int ttc = 0; ttc < TableItemsM.count(); ++ttc)
16105 fschmid 478
                        {
16943 fschmid 479
                                PageItem* ta = TableItemsM.at(ttc);
480
                                if (ta->TopLinkID != -1)
481
                                        ta->TopLink = TableIDM[ta->TopLinkID];
482
                                else
483
                                        ta->TopLink = 0;
484
                                if (ta->LeftLinkID != -1)
485
                                        ta->LeftLink = TableIDM[ta->LeftLinkID];
486
                                else
487
                                        ta->LeftLink = 0;
488
                                if (ta->RightLinkID != -1)
489
                                        ta->RightLink = TableIDM[ta->RightLinkID];
490
                                else
491
                                        ta->RightLink = 0;
492
                                if (ta->BottomLinkID != -1)
493
                                        ta->BottomLink = TableIDM[ta->BottomLinkID];
494
                                else
495
                                        ta->BottomLink = 0;
496
                        }
497
                }
498
                if (TableItems.count() != 0)
499
                {
500
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
501
                        {
502
                                PageItem* ta = TableItems.at(ttc);
503
                                if (ta->TopLinkID != -1)
504
                                        ta->TopLink = TableID[ta->TopLinkID];
505
                                else
506
                                        ta->TopLink = 0;
507
                                if (ta->LeftLinkID != -1)
508
                                        ta->LeftLink = TableID[ta->LeftLinkID];
509
                                else
510
                                        ta->LeftLink = 0;
511
                                if (ta->RightLinkID != -1)
512
                                        ta->RightLink = TableID[ta->RightLinkID];
513
                                else
514
                                        ta->RightLink = 0;
515
                                if (ta->BottomLinkID != -1)
516
                                        ta->BottomLink = TableID[ta->BottomLinkID];
517
                                else
518
                                        ta->BottomLink = 0;
519
                        }
520
                }
521
                if (WeldItems.count() != 0)
522
                {
523
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
524
                        {
525
                                PageItem* ta = WeldItems.at(ttc);
526
                                for (int i = 0 ; i < ta->weldList.count(); i++)
16105 fschmid 527
                                {
16943 fschmid 528
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
529
                                        ta->weldList[i].weldItem = WeldID[wInf.weldID];
16105 fschmid 530
                                }
531
                        }
532
                }
16943 fschmid 533
                // reestablish textframe links
534
                if (itemNext.count() != 0)
535
                {
536
                        QMap<int,int>::Iterator lc;
537
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
538
                        {
539
                                if (lc.value() >= 0)
540
                                {
541
                                        PageItem * Its = m_Doc->DocItems.at(lc.key());
542
                                        PageItem * Itn = m_Doc->DocItems.at(lc.value());
543
                                        if (!Its->testLinkCandidate(Itn))
544
                                        {
545
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
546
                                                continue;
547
                                        }
548
                                        Its->link(Itn);
549
                                }
550
                        }
551
                }
16105 fschmid 552
        }
553
        if (groupStackP.count() > 0)
554
        {
555
                while (groupStackP.count() > 0)
556
                {
17417 fschmid 557
                        bool isTableIt = false;
16105 fschmid 558
                        QList<PageItem*> gpL = groupStackP.pop();
559
                        PageItem* gItem = gpL.takeFirst();
560
                        for (int id = 0; id < gpL.count(); id++)
561
                        {
562
                                PageItem* cItem = gpL.at(id);
17417 fschmid 563
                                isTableIt = cItem->isTableItem;
16105 fschmid 564
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
565
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 566
                                cItem->Parent = gItem;
16105 fschmid 567
                                if (gItem->rotation() != 0)
568
                                {
569
                                        QTransform ma;
570
                                        ma.rotate(-gItem->rotation());
571
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
572
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
573
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
574
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
575
                                }
576
                                m_Doc->DocItems.removeOne(cItem);
577
                        }
17417 fschmid 578
                        if (isTableIt)
579
                                convertOldTable(m_Doc, gItem, gpL, &groupStackP, &m_Doc->DocItems);
580
                        else
581
                                gItem->groupItemList = gpL;
16105 fschmid 582
                }
583
        }
584
        if (groupStackF.count() > 0)
585
        {
586
                while (groupStackF.count() > 0)
587
                {
17417 fschmid 588
                        bool isTableIt = false;
16105 fschmid 589
                        QList<PageItem*> gpL = groupStackF.pop();
590
                        PageItem* gItem = gpL.takeFirst();
591
                        for (int id = 0; id < gpL.count(); id++)
592
                        {
593
                                PageItem* cItem = gpL.at(id);
17417 fschmid 594
                                isTableIt = cItem->isTableItem;
16105 fschmid 595
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
596
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 597
                                cItem->Parent = gItem;
16105 fschmid 598
                                if (gItem->rotation() != 0)
599
                                {
600
                                        QTransform ma;
601
                                        ma.rotate(-gItem->rotation());
602
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
603
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
604
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
605
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
606
                                }
17407 fschmid 607
                                m_Doc->FrameItems.remove(m_Doc->FrameItems.key(cItem));
16105 fschmid 608
                        }
17417 fschmid 609
                        if (isTableIt)
610
                                convertOldTable(m_Doc, gItem, gpL, &groupStackF, NULL);
611
                        else
612
                                gItem->groupItemList = gpL;
16105 fschmid 613
                }
614
        }
615
        if (groupStackM.count() > 0)
616
        {
617
                while (groupStackM.count() > 0)
618
                {
17417 fschmid 619
                        bool isTableIt = false;
16105 fschmid 620
                        QList<PageItem*> gpL = groupStackM.pop();
621
                        PageItem* gItem = gpL.takeFirst();
622
                        for (int id = 0; id < gpL.count(); id++)
623
                        {
624
                                PageItem* cItem = gpL.at(id);
17417 fschmid 625
                                isTableIt = cItem->isTableItem;
16105 fschmid 626
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
627
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 628
                                cItem->Parent = gItem;
16105 fschmid 629
                                if (gItem->rotation() != 0)
630
                                {
631
                                        QTransform ma;
632
                                        ma.rotate(-gItem->rotation());
633
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
634
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
635
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
636
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
637
                                }
638
                                m_Doc->MasterItems.removeOne(cItem);
639
                        }
17417 fschmid 640
                        if (isTableIt)
641
                                convertOldTable(m_Doc, gItem, gpL, &groupStackM, &m_Doc->MasterItems);
642
                        else
643
                                gItem->groupItemList = gpL;
16105 fschmid 644
                }
645
        }
646
        return true;
647
}
648
 
16016 fschmid 649
bool Scribus150Format::loadPalette(const QString & fileName)
650
{
651
        if (m_Doc==0 || m_AvailableFonts==0)
652
        {
653
                Q_ASSERT(m_Doc==0 || m_AvailableFonts==0);
654
                return false;
655
        }
656
        ParagraphStyle vg;
16105 fschmid 657
        Xp = 0.0;
658
        Yp = 0.0;
659
        GrX = 0.0;
660
        GrY = 0.0;
16943 fschmid 661
        isNewFormat = false;
16016 fschmid 662
 
16943 fschmid 663
        QMap<int,PageItem*> TableID;
664
        QMap<int,PageItem*> TableIDM;
665
        QMap<int,PageItem*> TableIDF;
16016 fschmid 666
        QList<PageItem*> TableItems;
667
        QList<PageItem*> TableItemsM;
668
        QList<PageItem*> TableItemsF;
16931 fschmid 669
        QMap<int,PageItem*> WeldID;
16926 fschmid 670
        QList<PageItem*> WeldItems;
16105 fschmid 671
        QStack< QList<PageItem*> > groupStack;
672
        QStack< QList<PageItem*> > groupStackF;
673
        QStack< QList<PageItem*> > groupStackM;
674
        QStack< QList<PageItem*> > groupStackP;
675
        QStack<int> groupStack2;
16016 fschmid 676
 
677
        QByteArray docBytes("");
678
        loadRawText(fileName, docBytes);
679
        QString f = QString::fromUtf8(docBytes);
680
        if (f.isEmpty())
681
        {
682
                setFileReadError();
683
                return false;
684
        }
685
        QString fileDir = QFileInfo(fileName).absolutePath();
686
        ScColor lf = ScColor();
687
 
688
        if (m_mwProgressBar!=0)
689
        {
690
                m_mwProgressBar->setMaximum(f.length());
691
                m_mwProgressBar->setValue(0);
692
        }
693
 
694
        itemRemap.clear();
695
        itemNext.clear();
696
        itemCount = 0;
697
        itemRemapM.clear();
698
        itemNextM.clear();
699
        itemCountM = 0;
700
        itemRemapF.clear();
701
        itemNextF.clear();
702
 
703
        TableItems.clear();
704
        TableID.clear();
705
        TableItemsM.clear();
706
        TableIDM.clear();
707
        TableItemsF.clear();
708
        TableIDF.clear();
16926 fschmid 709
        WeldItems.clear();
16016 fschmid 710
 
711
        m_Doc->GroupCounter = 1;
712
        m_Doc->LastAuto = 0;
16147 fschmid 713
//      m_Doc->PageColors.clear();
714
//      m_Doc->Layers.clear();
16016 fschmid 715
 
716
        bool firstElement = true;
717
        bool success = true;
718
        int  progress = 0;
719
 
720
        ScXmlStreamReader reader(f);
721
        ScXmlStreamAttributes attrs;
722
        while(!reader.atEnd() && !reader.hasError())
723
        {
724
                QXmlStreamReader::TokenType tType = reader.readNext();
725
                if (tType != QXmlStreamReader::StartElement)
726
                        continue;
727
                QStringRef tagName = reader.name();
728
                attrs = reader.scAttributes();
729
 
730
                if (m_mwProgressBar != 0)
731
                {
732
                        int newProgress = qRound(reader.characterOffset() / (double) f.length() * 100);
733
                        if (newProgress != progress)
734
                        {
735
                                m_mwProgressBar->setValue(reader.characterOffset());
736
                                progress = newProgress;
737
                        }
738
                }
739
 
740
                if (firstElement)
741
                {
742
                        if (tagName != "SCRIBUSCOLORS")
743
                        {
744
                                success = false;
745
                                break;
746
                        }
747
                        firstElement = false;
748
                }
749
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
750
                if (tagName == "COLOR" && attrs.valueAsString("NAME") != CommonStrings::None)
751
                {
752
                        success = readColor(m_Doc->PageColors, attrs);
753
                        if (!success) break;
754
                }
755
                if (tagName == "Gradient")
756
                {
757
                        VGradient gra;
758
                        QString grName = attrs.valueAsString("Name");
759
                        success = readGradient(m_Doc, gra, reader);
760
                        if (!success) break;
761
                        if (!grName.isEmpty())
762
                        {
763
                                m_Doc->docGradients.insert(grName, gra);
764
                        }
765
                }
766
                if (tagName == "Arrows")
767
                {
768
                        success = readArrows(m_Doc, attrs);
769
                        if (!success) break;
770
                }
771
                if (tagName == "MultiLine")
772
                {
773
                        multiLine ml;
774
                        QString mlName = attrs.valueAsString("Name");
775
                        success = readMultiline(ml, reader);
776
                        if (!success) break;
777
                        if (!mlName.isEmpty())
778
                        {
779
                                m_Doc->MLineStyles.insert(mlName, ml);
780
                        }
781
                }
782
                if (tagName == "PAGEOBJECT" || tagName == "MASTEROBJECT" || tagName == "FRAMEOBJECT")
783
                {
784
                        ItemInfo itemInfo;
785
                        success = readObject(m_Doc, reader, itemInfo, fileDir, false);
786
                        if (!success) break;
787
 
16943 fschmid 788
                        if (isNewFormat)
16016 fschmid 789
                        {
790
                                if (itemInfo.nextItem != -1)
16943 fschmid 791
                                        itemNext[itemInfo.itemID] = itemInfo.nextItem;
792
                                if (itemInfo.item->isTableItem)
793
                                        TableItems.append(itemInfo.item);
794
                                if (itemInfo.isWeldFlag)
795
                                        WeldItems.append(itemInfo.item);
16016 fschmid 796
                        }
16943 fschmid 797
                        else
16016 fschmid 798
                        {
16943 fschmid 799
                                // first of linked chain?
16016 fschmid 800
                                if (tagName == "PAGEOBJECT")
801
                                {
16943 fschmid 802
                                        if (itemInfo.nextItem != -1)
803
                                                itemNext[itemInfo.ownNr] = itemInfo.nextItem;
16016 fschmid 804
                                }
16943 fschmid 805
                                else if (tagName == "MASTEROBJECT")
16016 fschmid 806
                                {
16943 fschmid 807
                                        if (itemInfo.nextItem != -1)
808
                                                itemNextM[itemInfo.ownNr] = itemInfo.nextItem;
16016 fschmid 809
                                }
16943 fschmid 810
                                if (itemInfo.item->isTableItem)
16016 fschmid 811
                                {
16943 fschmid 812
                                        if (tagName == "PAGEOBJECT")
813
                                        {
814
                                                TableItems.append(itemInfo.item);
815
                                                TableID.insert(itemInfo.ownLink, itemInfo.item);
816
                                        }
817
                                        else if (tagName == "FRAMEOBJECT")
818
                                        {
819
                                                TableItemsF.append(itemInfo.item);
820
                                                TableIDF.insert(itemInfo.ownLink, itemInfo.item);
821
                                        }
822
                                        else
823
                                        {
824
                                                TableItemsM.append(itemInfo.item);
825
                                                TableIDM.insert(itemInfo.ownLink, itemInfo.item);
826
                                        }
16016 fschmid 827
                                }
16943 fschmid 828
                                if (itemInfo.isWeldFlag)
829
                                {
830
                                        WeldItems.append(itemInfo.item);
831
                                        WeldID.insert(itemInfo.ownWeld, itemInfo.item);
832
                                }
16016 fschmid 833
                        }
16105 fschmid 834
                        if (groupStack.count() > 0)
16016 fschmid 835
                        {
16105 fschmid 836
                                groupStack.top().append(itemInfo.item);
16943 fschmid 837
                                while (static_cast<int>(itemInfo.ownNr) == groupStack2.top())
16105 fschmid 838
                                {
839
                                        if (tagName == "PAGEOBJECT")
840
                                                groupStackP.push(groupStack.pop());
841
                                        else if (tagName == "FRAMEOBJECT")
842
                                                groupStackF.push(groupStack.pop());
843
                                        else
844
                                                groupStackM.push(groupStack.pop());
845
                                        groupStack2.pop();
16233 fschmid 846
                                        if (groupStack2.count() == 0)
847
                                                break;
16105 fschmid 848
                                }
16016 fschmid 849
                        }
16113 fschmid 850
                        if (itemInfo.isGroupFlag)
16105 fschmid 851
                        {
852
                                QList<PageItem*> GroupItems;
853
                                GroupItems.append(itemInfo.item);
854
                                groupStack.push(GroupItems);
16943 fschmid 855
                                groupStack2.push(itemInfo.groupLastItem + itemInfo.ownNr);
16105 fschmid 856
                        }
16016 fschmid 857
                }
858
                if (tagName == "Pattern")
859
                {
860
                        success = readPattern(m_Doc, reader, fileDir);
861
                        if (!success) break;
862
                }
863
        }
864
 
865
        if (reader.hasError())
866
        {
867
                setDomParsingError(reader.errorString(), reader.lineNumber(), reader.columnNumber());
868
                return false;
869
        }
16943 fschmid 870
        if (isNewFormat)
16016 fschmid 871
        {
16943 fschmid 872
                if (TableItems.count() != 0)
16016 fschmid 873
                {
16943 fschmid 874
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
875
                        {
876
                                PageItem* ta = TableItems.at(ttc);
877
                                if (ta->TopLinkID != -1)
878
                                        ta->TopLink = LinkID[ta->TopLinkID];
879
                                else
880
                                        ta->TopLink = 0;
881
                                if (ta->LeftLinkID != -1)
882
                                        ta->LeftLink = LinkID[ta->LeftLinkID];
883
                                else
884
                                        ta->LeftLink = 0;
885
                                if (ta->RightLinkID != -1)
886
                                        ta->RightLink = LinkID[ta->RightLinkID];
887
                                else
888
                                        ta->RightLink = 0;
889
                                if (ta->BottomLinkID != -1)
890
                                        ta->BottomLink = LinkID[ta->BottomLinkID];
891
                                else
892
                                        ta->BottomLink = 0;
893
                        }
16016 fschmid 894
                }
16943 fschmid 895
                if (WeldItems.count() != 0)
16016 fschmid 896
                {
16943 fschmid 897
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
898
                        {
899
                                PageItem* ta = WeldItems.at(ttc);
900
                                for (int i = 0 ; i < ta->weldList.count(); i++)
901
                                {
902
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
903
                                        ta->weldList[i].weldItem = LinkID[wInf.weldID];
904
                                }
905
                        }
16016 fschmid 906
                }
16943 fschmid 907
                if (itemNext.count() != 0)
16016 fschmid 908
                {
16943 fschmid 909
                        QMap<int,int>::Iterator lc;
910
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
911
                        {
912
                                if (lc.value() >= 0)
913
                                {
914
                                        PageItem * Its = LinkID[lc.key()];
915
                                        PageItem * Itn = LinkID[lc.value()];
916
                                        if (!Its->testLinkCandidate(Itn))
917
                                        {
918
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
919
                                                continue;
920
                                        }
921
                                        Its->link(Itn);
922
                                }
923
                        }
16016 fschmid 924
                }
925
        }
16943 fschmid 926
        else
16926 fschmid 927
        {
16943 fschmid 928
                if (TableItemsF.count() != 0)
16926 fschmid 929
                {
16943 fschmid 930
                        for (int ttc = 0; ttc < TableItemsF.count(); ++ttc)
16926 fschmid 931
                        {
16943 fschmid 932
                                PageItem* ta = TableItemsF.at(ttc);
933
                                if (ta->TopLinkID != -1)
934
                                        ta->TopLink = TableIDF[ta->TopLinkID];
935
                                else
936
                                        ta->TopLink = 0;
937
                                if (ta->LeftLinkID != -1)
938
                                        ta->LeftLink = TableIDF[ta->LeftLinkID];
939
                                else
940
                                        ta->LeftLink = 0;
941
                                if (ta->RightLinkID != -1)
942
                                        ta->RightLink = TableIDF[ta->RightLinkID];
943
                                else
944
                                        ta->RightLink = 0;
945
                                if (ta->BottomLinkID != -1)
946
                                        ta->BottomLink = TableIDF[ta->BottomLinkID];
947
                                else
948
                                        ta->BottomLink = 0;
16926 fschmid 949
                        }
950
                }
16943 fschmid 951
                if (TableItemsM.count() != 0)
16016 fschmid 952
                {
16943 fschmid 953
                        for (int ttc = 0; ttc < TableItemsM.count(); ++ttc)
16016 fschmid 954
                        {
16943 fschmid 955
                                PageItem* ta = TableItemsM.at(ttc);
956
                                if (ta->TopLinkID != -1)
957
                                        ta->TopLink = TableIDM[ta->TopLinkID];
958
                                else
959
                                        ta->TopLink = 0;
960
                                if (ta->LeftLinkID != -1)
961
                                        ta->LeftLink = TableIDM[ta->LeftLinkID];
962
                                else
963
                                        ta->LeftLink = 0;
964
                                if (ta->RightLinkID != -1)
965
                                        ta->RightLink = TableIDM[ta->RightLinkID];
966
                                else
967
                                        ta->RightLink = 0;
968
                                if (ta->BottomLinkID != -1)
969
                                        ta->BottomLink = TableIDM[ta->BottomLinkID];
970
                                else
971
                                        ta->BottomLink = 0;
972
                        }
973
                }
974
                if (TableItems.count() != 0)
975
                {
976
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
977
                        {
978
                                PageItem* ta = TableItems.at(ttc);
979
                                if (ta->TopLinkID != -1)
980
                                        ta->TopLink = TableID[ta->TopLinkID];
981
                                else
982
                                        ta->TopLink = 0;
983
                                if (ta->LeftLinkID != -1)
984
                                        ta->LeftLink = TableID[ta->LeftLinkID];
985
                                else
986
                                        ta->LeftLink = 0;
987
                                if (ta->RightLinkID != -1)
988
                                        ta->RightLink = TableID[ta->RightLinkID];
989
                                else
990
                                        ta->RightLink = 0;
991
                                if (ta->BottomLinkID != -1)
992
                                        ta->BottomLink = TableID[ta->BottomLinkID];
993
                                else
994
                                        ta->BottomLink = 0;
995
                        }
996
                }
997
                if (WeldItems.count() != 0)
998
                {
999
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
1000
                        {
1001
                                PageItem* ta = WeldItems.at(ttc);
1002
                                for (int i = 0 ; i < ta->weldList.count(); i++)
16016 fschmid 1003
                                {
16943 fschmid 1004
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
1005
                                        ta->weldList[i].weldItem = WeldID[wInf.weldID];
16016 fschmid 1006
                                }
1007
                        }
1008
                }
16943 fschmid 1009
                // reestablish textframe links
1010
                if (itemNext.count() != 0)
16016 fschmid 1011
                {
16943 fschmid 1012
                        QMap<int,int>::Iterator lc;
1013
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
16016 fschmid 1014
                        {
16943 fschmid 1015
                                if (lc.value() >= 0)
16016 fschmid 1016
                                {
16943 fschmid 1017
                                        PageItem * Its = m_Doc->DocItems.at(lc.key());
1018
                                        PageItem * Itn = m_Doc->DocItems.at(lc.value());
1019
                                        if (!Its->testLinkCandidate(Itn))
1020
                                        {
1021
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1022
                                                continue;
1023
                                        }
1024
                                        Its->link(Itn);
16016 fschmid 1025
                                }
1026
                        }
1027
                }
16943 fschmid 1028
                if (itemNextM.count() != 0)
1029
                {
1030
                        QMap<int,int>::Iterator lc;
1031
                        for (lc = itemNextM.begin(); lc != itemNextM.end(); ++lc)
1032
                        {
1033
                                if (lc.value() >= 0)
1034
                                {
1035
                                        PageItem * Its = m_Doc->MasterItems.at(lc.key());
1036
                                        PageItem * Itn = m_Doc->MasterItems.at(lc.value());
1037
                                        if (!Its->testLinkCandidate(Itn))
1038
                                        {
1039
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1040
                                                continue;
1041
                                        }
1042
                                        Its->link(Itn);
1043
                                }
1044
                        }
1045
                }
16016 fschmid 1046
        }
16105 fschmid 1047
        if (groupStackP.count() > 0)
1048
        {
1049
                while (groupStackP.count() > 0)
1050
                {
17417 fschmid 1051
                        bool isTableIt = false;
16105 fschmid 1052
                        QList<PageItem*> gpL = groupStackP.pop();
1053
                        PageItem* gItem = gpL.takeFirst();
1054
                        for (int id = 0; id < gpL.count(); id++)
1055
                        {
1056
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1057
                                isTableIt = cItem->isTableItem;
16105 fschmid 1058
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1059
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1060
                                cItem->Parent = gItem;
16105 fschmid 1061
                                if (gItem->rotation() != 0)
1062
                                {
1063
                                        QTransform ma;
1064
                                        ma.rotate(-gItem->rotation());
1065
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1066
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1067
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1068
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1069
                                }
1070
                                m_Doc->DocItems.removeOne(cItem);
1071
                        }
17417 fschmid 1072
                        if (isTableIt)
1073
                                convertOldTable(m_Doc, gItem, gpL, &groupStackP, &m_Doc->DocItems);
1074
                        else
1075
                                gItem->groupItemList = gpL;
16105 fschmid 1076
                }
1077
        }
1078
        if (groupStackF.count() > 0)
1079
        {
1080
                while (groupStackF.count() > 0)
1081
                {
17417 fschmid 1082
                        bool isTableIt = false;
16105 fschmid 1083
                        QList<PageItem*> gpL = groupStackF.pop();
1084
                        PageItem* gItem = gpL.takeFirst();
1085
                        for (int id = 0; id < gpL.count(); id++)
1086
                        {
1087
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1088
                                isTableIt = cItem->isTableItem;
16105 fschmid 1089
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1090
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1091
                                cItem->Parent = gItem;
16105 fschmid 1092
                                if (gItem->rotation() != 0)
1093
                                {
1094
                                        QTransform ma;
1095
                                        ma.rotate(-gItem->rotation());
1096
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1097
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1098
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1099
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1100
                                }
17407 fschmid 1101
                                m_Doc->FrameItems.remove(m_Doc->FrameItems.key(cItem));
16105 fschmid 1102
                        }
17417 fschmid 1103
                        if (isTableIt)
1104
                                convertOldTable(m_Doc, gItem, gpL, &groupStackF, NULL);
1105
                        else
1106
                                gItem->groupItemList = gpL;
16105 fschmid 1107
                }
1108
        }
1109
        if (groupStackM.count() > 0)
1110
        {
1111
                while (groupStackM.count() > 0)
1112
                {
17417 fschmid 1113
                        bool isTableIt = false;
16105 fschmid 1114
                        QList<PageItem*> gpL = groupStackM.pop();
1115
                        PageItem* gItem = gpL.takeFirst();
1116
                        for (int id = 0; id < gpL.count(); id++)
1117
                        {
1118
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1119
                                isTableIt = cItem->isTableItem;
16105 fschmid 1120
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1121
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1122
                                cItem->Parent = gItem;
16105 fschmid 1123
                                if (gItem->rotation() != 0)
1124
                                {
1125
                                        QTransform ma;
1126
                                        ma.rotate(-gItem->rotation());
1127
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1128
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1129
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1130
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1131
                                }
1132
                                m_Doc->MasterItems.removeOne(cItem);
1133
                        }
17417 fschmid 1134
                        if (isTableIt)
1135
                                convertOldTable(m_Doc, gItem, gpL, &groupStackM, &m_Doc->MasterItems);
1136
                        else
1137
                                gItem->groupItemList = gpL;
16105 fschmid 1138
                }
1139
        }
16016 fschmid 1140
 
1141
        if (m_Doc->Layers.count() == 0)
1142
                m_Doc->Layers.newLayer( QObject::tr("Background") );
1143
        if (m_mwProgressBar!=0)
1144
        {
1145
                m_mwProgressBar->setValue(reader.characterOffset());
1146
                m_mwProgressBar->reset();
1147
        }
1148
        return true;
1149
}
1150
 
13971 jghali 1151
bool Scribus150Format::loadFile(const QString & fileName, const FileFormat & /* fmt */, int /* flags */, int /* index */)
1152
{
1153
        if (m_Doc==0 || m_AvailableFonts==0)
1154
        {
1155
                Q_ASSERT(m_Doc==0 || m_AvailableFonts==0);
1156
                return false;
1157
        }
1158
        ParagraphStyle vg;
16105 fschmid 1159
        Xp = 0.0;
1160
        Yp = 0.0;
1161
        GrX = 0.0;
1162
        GrY = 0.0;
13971 jghali 1163
        struct ScribusDoc::BookMa bok;
1164
        QMap<int, ScribusDoc::BookMa> bookmarks;
1165
 
1166
        bool newVersion = false;
16943 fschmid 1167
        isNewFormat = false;
13971 jghali 1168
 
16943 fschmid 1169
        QMap<int,PageItem*> TableID;
1170
        QMap<int,PageItem*> TableIDM;
1171
        QMap<int,PageItem*> TableIDF;
13971 jghali 1172
        QList<PageItem*> TableItems;
1173
        QList<PageItem*> TableItemsM;
1174
        QList<PageItem*> TableItemsF;
16931 fschmid 1175
        QMap<int,PageItem*> WeldID;
16926 fschmid 1176
        QList<PageItem*> WeldItems;
16105 fschmid 1177
        QStack< QList<PageItem*> > groupStack;
1178
        QStack< QList<PageItem*> > groupStackF;
1179
        QStack< QList<PageItem*> > groupStackM;
1180
        QStack< QList<PageItem*> > groupStackP;
1181
        QStack<int> groupStack2;
13971 jghali 1182
 
1183
        QString f(readSLA(fileName));
1184
        if (f.isEmpty())
14395 jghali 1185
        {
1186
                setFileReadError();
13971 jghali 1187
                return false;
14395 jghali 1188
        }
13971 jghali 1189
        QString fileDir = QFileInfo(fileName).absolutePath();
1190
        int firstPage = 0;
1191
        int layerToSetActive = 0;
1192
        ScColor lf = ScColor();
1193
 
1194
        if (m_mwProgressBar!=0)
1195
        {
1196
                m_mwProgressBar->setMaximum(f.length());
1197
                m_mwProgressBar->setValue(0);
1198
        }
1199
        // Stop autosave timer,it will be restarted only if doc has autosave feature is enabled
1200
        if (m_Doc->autoSaveTimer->isActive())
1201
                m_Doc->autoSaveTimer->stop();
16105 fschmid 1202
 
13971 jghali 1203
        itemRemap.clear();
1204
        itemNext.clear();
1205
        itemCount = 0;
1206
        itemRemapM.clear();
1207
        itemNextM.clear();
1208
        itemCountM = 0;
1209
        itemRemapF.clear();
1210
        itemNextF.clear();
1211
 
1212
        TableItems.clear();
1213
        TableID.clear();
1214
        TableItemsM.clear();
1215
        TableIDM.clear();
1216
        TableItemsF.clear();
1217
        TableIDF.clear();
16926 fschmid 1218
        WeldItems.clear();
1219
        WeldID.clear();
16943 fschmid 1220
        LinkID.clear();
13971 jghali 1221
 
1222
        m_Doc->GroupCounter = 1;
1223
        m_Doc->LastAuto = 0;
1224
        m_Doc->PageColors.clear();
1225
        m_Doc->Layers.clear();
1226
 
1227
        bool firstElement = true;
1228
        bool success = true;
1229
        bool hasPageSets = false;
1230
        int  progress = 0;
1231
 
1232
        ScXmlStreamReader reader(f);
1233
        ScXmlStreamAttributes attrs;
1234
        while(!reader.atEnd() && !reader.hasError())
1235
        {
1236
                QXmlStreamReader::TokenType tType = reader.readNext();
1237
                if (tType != QXmlStreamReader::StartElement)
1238
                        continue;
1239
                QStringRef tagName = reader.name();
1240
                attrs = reader.scAttributes();
1241
 
1242
                if (m_mwProgressBar != 0)
1243
                {
1244
                        int newProgress = qRound(reader.characterOffset() / (double) f.length() * 100);
1245
                        if (newProgress != progress)
1246
                        {
1247
                                m_mwProgressBar->setValue(reader.characterOffset());
1248
                                progress = newProgress;
1249
                        }
1250
                }
1251
 
1252
                if (firstElement)
1253
                {
1254
                        if (tagName != "SCRIBUSUTF8NEW")
1255
                        {
1256
                                success = false;
1257
                                break;
1258
                        }
1259
                        if (attrs.hasAttribute("Version"))
1260
                                newVersion = true;
1261
                        firstElement = false;
1262
                }
1263
                if (tagName == "DOCUMENT")
1264
                {
1265
                        readDocAttributes(m_Doc, attrs);
1266
                        layerToSetActive = attrs.valueAsInt("ALAYER", 0);
15407 craig 1267
                        if (m_Doc->pagePositioning() == 0)
13971 jghali 1268
                                firstPage = 0;
1269
                        else
1270
                        {
1271
                                if (attrs.valueAsInt("FIRSTLEFT", 0) == 1)
1272
                                        firstPage = 0;
1273
                                else
1274
                                        firstPage = 1;
1275
                        }
1276
                        if (attrs.hasAttribute("currentProfile"))
1277
                        {
14971 cbradney 1278
                                m_Doc->clearCheckerProfiles();
1279
                                m_Doc->setCurCheckProfile(attrs.valueAsString("currentProfile"));
13971 jghali 1280
                        }
1281
                }
1282
                if (tagName == "CheckProfile")
1283
                {
1284
                        success = readCheckProfile(m_Doc, attrs);
1285
                        if (!success) break;
1286
                }
1287
                if (tagName == "PageSets")
1288
                {
1289
                        success = readPageSets(m_Doc, reader);
1290
                        if (!success) break;
1291
                        hasPageSets = true;
1292
                }
1293
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
1294
                if (tagName == "COLOR" && attrs.valueAsString("NAME") != CommonStrings::None)
1295
                {
1296
                        success = readColor(m_Doc->PageColors, attrs);
1297
                        if (!success) break;
1298
                }
14150 fschmid 1299
                if (tagName == "Gradient")
1300
                {
1301
                        VGradient gra;
1302
                        QString grName = attrs.valueAsString("Name");
1303
                        success = readGradient(m_Doc, gra, reader);
1304
                        if (!success) break;
1305
                        if (!grName.isEmpty())
1306
                        {
1307
                                m_Doc->docGradients.insert(grName, gra);
1308
                        }
1309
                }
13971 jghali 1310
                if (tagName == "STYLE")
1311
                {
16531 jghali 1312
                        readParagraphStyle(m_Doc, reader, vg);
13971 jghali 1313
                        StyleSet<ParagraphStyle>tmp;
1314
                        tmp.create(vg);
1315
                        m_Doc->redefineStyles(tmp, false);
1316
                }
1317
                if (tagName == "CHARSTYLE")
1318
                {
16531 jghali 1319
                        CharStyle cstyle;
16533 jghali 1320
                        ScXmlStreamAttributes attrs = reader.scAttributes();
1321
                        readNamedCharacterStyleAttrs(m_Doc, attrs, cstyle);
13971 jghali 1322
                        StyleSet<CharStyle> temp;
16531 jghali 1323
                        temp.create(cstyle);
13971 jghali 1324
                        m_Doc->redefineCharStyles(temp, false);
1325
                }
17318 fschmid 1326
                if (tagName == "TableStyle")
1327
                {
1328
                        TableStyle tstyle;
1329
                        readTableStyle(m_Doc, reader, tstyle);
1330
                        StyleSet<TableStyle> temp;
1331
                        temp.create(tstyle);
1332
                        m_Doc->redefineTableStyles(temp, false);
1333
                }
1334
                if (tagName == "CellStyle")
1335
                {
1336
                        CellStyle tstyle;
1337
                        readCellStyle(m_Doc, reader, tstyle);
1338
                        StyleSet<CellStyle> temp;
1339
                        temp.create(tstyle);
1340
                        m_Doc->redefineCellStyles(temp, false);
1341
                }
13971 jghali 1342
                if (tagName == "JAVA")
1343
                {
1344
                        QString name = attrs.valueAsString("NAME");
1345
                        if (!name.isEmpty())
1346
                                m_Doc->JavaScripts[name] = attrs.valueAsString("SCRIPT");
1347
                }
1348
                if (tagName == "LAYERS")
1349
                {
1350
                        ScLayer newLayer;
1351
                        readLayers(newLayer, attrs);
1352
                        m_Doc->Layers.append(newLayer);
1353
                }
1354
                if (tagName == "Arrows")
1355
                {
1356
                        success = readArrows(m_Doc, attrs);
1357
                        if (!success) break;
1358
                }
1359
                if (tagName == "MultiLine")
1360
                {
1361
                        multiLine ml;
1362
                        QString mlName = attrs.valueAsString("Name");
1363
                        success = readMultiline(ml, reader);
1364
                        if (!success) break;
1365
                        if (!mlName.isEmpty())
1366
                        {
1367
                                m_Doc->MLineStyles.insert(mlName, ml);
1368
                        }
1369
                }
1370
                if (tagName == "Bookmark")
1371
                {
1372
                        int bmElem = 0;
1373
                        struct ScribusDoc::BookMa bookmark;
1374
                        success = readBookMark(bookmark, bmElem, attrs);
1375
                        if (!success) break;
1376
                        bookmarks.insert(bmElem, bookmark);
1377
                }
1378
                if (tagName == "PDF")
1379
                {
1380
                        success = readPDFOptions(m_Doc, reader);
1381
                        if (!success) break;
1382
                }
1383
                if (tagName == "Printer")
1384
                {
1385
                        success = readPrinterOptions(m_Doc, reader);
1386
                        if (!success) break;
1387
                }
1388
                if (tagName == "DocItemAttributes")
1389
                {
1390
                        success = readDocItemAttributes(m_Doc, reader);
1391
                        if (!success) break;
1392
                }
1393
                if (tagName == "TablesOfContents")
1394
                {
1395
                        success = readTableOfContents(m_Doc, reader);
1396
                        if (!success) break;
1397
                }
1398
                if (tagName == "Sections")
1399
                {
1400
                        success = readSections(m_Doc, reader);
1401
                        if (!success) break;
1402
                }
1403
                if (tagName == "HYPHEN")
1404
                {
1405
                        success = readHyphen(m_Doc, reader);
1406
                        if (!success) break;
1407
                }
1408
                if (tagName == "PAGE" || tagName == "MASTERPAGE")
1409
                {
1410
                        success = readPage(m_Doc, reader);
16105 fschmid 1411
                        if (!success)
1412
                                break;
13971 jghali 1413
                }
1414
                if (tagName == "PAGEOBJECT" || tagName == "MASTEROBJECT" || tagName == "FRAMEOBJECT")
1415
                {
1416
                        ItemInfo itemInfo;
1417
                        success = readObject(m_Doc, reader, itemInfo, fileDir, false);
16105 fschmid 1418
                        if (!success)
1419
                                break;
13971 jghali 1420
 
1421
                        // first of linked chain?
16943 fschmid 1422
                        if (isNewFormat)
13971 jghali 1423
                        {
1424
                                if (itemInfo.nextItem != -1)
16943 fschmid 1425
                                        itemNext[itemInfo.itemID] = itemInfo.nextItem;
1426
                                if (itemInfo.item->isTableItem)
1427
                                        TableItems.append(itemInfo.item);
1428
                                if (itemInfo.isWeldFlag)
1429
                                        WeldItems.append(itemInfo.item);
13971 jghali 1430
                        }
16943 fschmid 1431
                        else
13971 jghali 1432
                        {
1433
                                if (tagName == "PAGEOBJECT")
1434
                                {
16943 fschmid 1435
                                        if (itemInfo.nextItem != -1)
1436
                                                itemNext[itemInfo.ownNr] = itemInfo.nextItem;
13971 jghali 1437
                                }
16943 fschmid 1438
                                else if (tagName == "MASTEROBJECT")
13971 jghali 1439
                                {
16943 fschmid 1440
                                        if (itemInfo.nextItem != -1)
1441
                                                itemNextM[itemInfo.ownNr] = itemInfo.nextItem;
13971 jghali 1442
                                }
16943 fschmid 1443
                                if (itemInfo.item->isTableItem)
13971 jghali 1444
                                {
16943 fschmid 1445
                                        if (tagName == "PAGEOBJECT")
1446
                                        {
1447
                                                TableItems.append(itemInfo.item);
1448
                                                TableID.insert(itemInfo.ownLink, itemInfo.item);
1449
                                        }
1450
                                        else if (tagName == "FRAMEOBJECT")
1451
                                        {
1452
                                                TableItemsF.append(itemInfo.item);
1453
                                                TableIDF.insert(itemInfo.ownLink, itemInfo.item);
1454
                                        }
1455
                                        else
1456
                                        {
1457
                                                TableItemsM.append(itemInfo.item);
1458
                                                TableIDM.insert(itemInfo.ownLink, itemInfo.item);
1459
                                        }
13971 jghali 1460
                                }
16943 fschmid 1461
 
1462
                                if (itemInfo.isWeldFlag)
1463
                                {
1464
                                        WeldItems.append(itemInfo.item);
1465
                                        WeldID.insert(itemInfo.ownWeld, itemInfo.item);
1466
                                }
13971 jghali 1467
                        }
16105 fschmid 1468
                        if (groupStack.count() > 0)
13971 jghali 1469
                        {
16105 fschmid 1470
                                groupStack.top().append(itemInfo.item);
16943 fschmid 1471
                                while (static_cast<int>(itemInfo.ownNr) == groupStack2.top())
16105 fschmid 1472
                                {
1473
                                        if (tagName == "PAGEOBJECT")
1474
                                                groupStackP.push(groupStack.pop());
1475
                                        else if (tagName == "FRAMEOBJECT")
1476
                                                groupStackF.push(groupStack.pop());
1477
                                        else
1478
                                                groupStackM.push(groupStack.pop());
1479
                                        groupStack2.pop();
16233 fschmid 1480
                                        if (groupStack2.count() == 0)
1481
                                                break;
16105 fschmid 1482
                                }
13971 jghali 1483
                        }
16113 fschmid 1484
                        if (itemInfo.isGroupFlag)
16105 fschmid 1485
                        {
1486
                                QList<PageItem*> GroupItems;
1487
                                GroupItems.append(itemInfo.item);
1488
                                groupStack.push(GroupItems);
16943 fschmid 1489
                                groupStack2.push(itemInfo.groupLastItem + itemInfo.ownNr);
16105 fschmid 1490
                        }
13971 jghali 1491
                }
1492
                if (tagName == "Pattern")
1493
                {
1494
                        success = readPattern(m_Doc, reader, fileDir);
16105 fschmid 1495
                        if (!success)
1496
                                break;
13971 jghali 1497
                }
1498
        }
1499
 
1500
        if (reader.hasError())
14392 jghali 1501
        {
1502
                setDomParsingError(reader.errorString(), reader.lineNumber(), reader.columnNumber());
13971 jghali 1503
                return false;
14392 jghali 1504
        }
13971 jghali 1505
 
1506
        QMap<int, ScribusDoc::BookMa>::Iterator it;
1507
        for (it = bookmarks.begin(); it != bookmarks.end(); ++it)
1508
        {
1509
                int elem = it.key();
1510
                if (elem < m_Doc->Items->count())
1511
                {
1512
                        ScribusDoc::BookMa bookmark = it.value();
1513
                        bookmark.PageObject = m_Doc->Items->at(elem);
1514
                        m_Doc->BookMarks.append( bookmark );
1515
                }
1516
        }
1517
 
16943 fschmid 1518
        if (isNewFormat)
13971 jghali 1519
        {
16943 fschmid 1520
                if (TableItems.count() != 0)
13971 jghali 1521
                {
16943 fschmid 1522
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
1523
                        {
1524
                                PageItem* ta = TableItems.at(ttc);
1525
                                if (ta->TopLinkID != -1)
1526
                                        ta->TopLink = LinkID[ta->TopLinkID];
1527
                                else
1528
                                        ta->TopLink = 0;
1529
                                if (ta->LeftLinkID != -1)
1530
                                        ta->LeftLink = LinkID[ta->LeftLinkID];
1531
                                else
1532
                                        ta->LeftLink = 0;
1533
                                if (ta->RightLinkID != -1)
1534
                                        ta->RightLink = LinkID[ta->RightLinkID];
1535
                                else
1536
                                        ta->RightLink = 0;
1537
                                if (ta->BottomLinkID != -1)
1538
                                        ta->BottomLink = LinkID[ta->BottomLinkID];
1539
                                else
1540
                                        ta->BottomLink = 0;
1541
                        }
13971 jghali 1542
                }
16943 fschmid 1543
                if (WeldItems.count() != 0)
13971 jghali 1544
                {
16943 fschmid 1545
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
1546
                        {
1547
                                PageItem* ta = WeldItems.at(ttc);
1548
                                for (int i = 0 ; i < ta->weldList.count(); i++)
1549
                                {
1550
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
1551
                                        ta->weldList[i].weldItem = LinkID[wInf.weldID];
1552
                                }
1553
                        }
13971 jghali 1554
                }
16943 fschmid 1555
                if (itemNext.count() != 0)
13971 jghali 1556
                {
16943 fschmid 1557
                        QMap<int,int>::Iterator lc;
1558
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
1559
                        {
1560
                                if (lc.value() >= 0)
1561
                                {
1562
                                        PageItem * Its = LinkID[lc.key()];
1563
                                        PageItem * Itn = LinkID[lc.value()];
1564
                                        if (!Its->testLinkCandidate(Itn))
1565
                                        {
1566
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1567
                                                continue;
1568
                                        }
1569
                                        Its->link(Itn);
1570
                                }
1571
                        }
13971 jghali 1572
                }
1573
        }
16943 fschmid 1574
        else
16926 fschmid 1575
        {
16943 fschmid 1576
                if (TableItemsF.count() != 0)
16926 fschmid 1577
                {
16943 fschmid 1578
                        for (int ttc = 0; ttc < TableItemsF.count(); ++ttc)
16926 fschmid 1579
                        {
16943 fschmid 1580
                                PageItem* ta = TableItemsF.at(ttc);
1581
                                if (ta->TopLinkID != -1)
1582
                                        ta->TopLink = TableIDF[ta->TopLinkID];
1583
                                else
1584
                                        ta->TopLink = 0;
1585
                                if (ta->LeftLinkID != -1)
1586
                                        ta->LeftLink = TableIDF[ta->LeftLinkID];
1587
                                else
1588
                                        ta->LeftLink = 0;
1589
                                if (ta->RightLinkID != -1)
1590
                                        ta->RightLink = TableIDF[ta->RightLinkID];
1591
                                else
1592
                                        ta->RightLink = 0;
1593
                                if (ta->BottomLinkID != -1)
1594
                                        ta->BottomLink = TableIDF[ta->BottomLinkID];
1595
                                else
1596
                                        ta->BottomLink = 0;
16926 fschmid 1597
                        }
1598
                }
16943 fschmid 1599
                if (TableItemsM.count() != 0)
1600
                {
1601
                        for (int ttc = 0; ttc < TableItemsM.count(); ++ttc)
1602
                        {
1603
                                PageItem* ta = TableItemsM.at(ttc);
1604
                                if (ta->TopLinkID != -1)
1605
                                        ta->TopLink = TableIDM[ta->TopLinkID];
1606
                                else
1607
                                        ta->TopLink = 0;
1608
                                if (ta->LeftLinkID != -1)
1609
                                        ta->LeftLink = TableIDM[ta->LeftLinkID];
1610
                                else
1611
                                        ta->LeftLink = 0;
1612
                                if (ta->RightLinkID != -1)
1613
                                        ta->RightLink = TableIDM[ta->RightLinkID];
1614
                                else
1615
                                        ta->RightLink = 0;
1616
                                if (ta->BottomLinkID != -1)
1617
                                        ta->BottomLink = TableIDM[ta->BottomLinkID];
1618
                                else
1619
                                        ta->BottomLink = 0;
1620
                        }
1621
                }
1622
                if (TableItems.count() != 0)
1623
                {
1624
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
1625
                        {
1626
                                PageItem* ta = TableItems.at(ttc);
1627
                                if (ta->TopLinkID != -1)
1628
                                        ta->TopLink = TableID[ta->TopLinkID];
1629
                                else
1630
                                        ta->TopLink = 0;
1631
                                if (ta->LeftLinkID != -1)
1632
                                        ta->LeftLink = TableID[ta->LeftLinkID];
1633
                                else
1634
                                        ta->LeftLink = 0;
1635
                                if (ta->RightLinkID != -1)
1636
                                        ta->RightLink = TableID[ta->RightLinkID];
1637
                                else
1638
                                        ta->RightLink = 0;
1639
                                if (ta->BottomLinkID != -1)
1640
                                        ta->BottomLink = TableID[ta->BottomLinkID];
1641
                                else
1642
                                        ta->BottomLink = 0;
1643
                        }
1644
                }
1645
                if (WeldItems.count() != 0)
1646
                {
1647
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
1648
                        {
1649
                                PageItem* ta = WeldItems.at(ttc);
1650
                                for (int i = 0 ; i < ta->weldList.count(); i++)
1651
                                {
1652
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
1653
                                        ta->weldList[i].weldItem = WeldID[wInf.weldID];
1654
                                }
1655
                        }
1656
                }
1657
                if (itemNext.count() != 0)
1658
                {
1659
                        QMap<int,int>::Iterator lc;
1660
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
1661
                        {
1662
                                if (lc.value() >= 0)
1663
                                {
1664
                                        PageItem * Its = m_Doc->DocItems.at(lc.key());
1665
                                        PageItem * Itn = m_Doc->DocItems.at(lc.value());
1666
                                        if (!Its->testLinkCandidate(Itn))
1667
                                        {
1668
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1669
                                                continue;
1670
                                        }
1671
                                        Its->link(Itn);
1672
                                }
1673
                        }
1674
                }
1675
                if (itemNextM.count() != 0)
1676
                {
1677
                        QMap<int,int>::Iterator lc;
1678
                        for (lc = itemNextM.begin(); lc != itemNextM.end(); ++lc)
1679
                        {
1680
                                if (lc.value() >= 0)
1681
                                {
1682
                                        PageItem * Its = m_Doc->MasterItems.at(lc.key());
1683
                                        PageItem * Itn = m_Doc->MasterItems.at(lc.value());
1684
                                        if (!Its->testLinkCandidate(Itn))
1685
                                        {
1686
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1687
                                                continue;
1688
                                        }
1689
                                        Its->link(Itn);
1690
                                }
1691
                        }
1692
                }
16926 fschmid 1693
        }
13971 jghali 1694
        //CB Add this in to set this in the file in memory. Its saved, why not load it.
1695
        //Will of course be replaced by per page settings although we still probably need a document default
1696
        if (!hasPageSets)
1697
        {
15407 craig 1698
                m_Doc->setPageSetFirstPage(m_Doc->pagePositioning(), firstPage);
14924 cbradney 1699
//->Prefs               m_Doc->pageSets[m_Doc->currentPageLayout].FirstPage = firstPage;
13971 jghali 1700
//              m_Doc->pageSets[m_Doc->currentPageLayout].GapHorizontal = dc.attribute("GapHorizontal", "0").toDouble();
1701
//              m_Doc->pageSets[m_Doc->currentPageLayout].GapVertical = 0.0;
1702
//              m_Doc->pageSets[m_Doc->currentPageLayout].GapBelow = dc.attribute("GapVertical", "40").toDouble();
1703
        }
1704
        m_Doc->setActiveLayer(layerToSetActive);
1705
        m_Doc->setMasterPageMode(false);
1706
        m_Doc->reformPages();
17338 jghali 1707
        m_Doc->refreshGuides();
13971 jghali 1708
 
1709
        if (m_Doc->Layers.count() == 0)
1710
                m_Doc->Layers.newLayer( QObject::tr("Background") );
1711
 
16105 fschmid 1712
        if (groupStackP.count() > 0)
1713
        {
1714
                while (groupStackP.count() > 0)
1715
                {
17417 fschmid 1716
                        bool isTableIt = false;
16105 fschmid 1717
                        QList<PageItem*> gpL = groupStackP.pop();
1718
                        PageItem* gItem = gpL.takeFirst();
1719
                        for (int id = 0; id < gpL.count(); id++)
1720
                        {
1721
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1722
                                isTableIt = cItem->isTableItem;
16105 fschmid 1723
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1724
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1725
                                cItem->Parent = gItem;
16105 fschmid 1726
                                if (gItem->rotation() != 0)
1727
                                {
1728
                                        QTransform ma;
1729
                                        ma.rotate(-gItem->rotation());
1730
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1731
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1732
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1733
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1734
                                }
1735
                                m_Doc->DocItems.removeOne(cItem);
1736
                        }
17417 fschmid 1737
                        if (isTableIt)
1738
                                convertOldTable(m_Doc, gItem, gpL, &groupStackP, &m_Doc->DocItems);
1739
                        else
1740
                                gItem->groupItemList = gpL;
16105 fschmid 1741
                }
1742
        }
1743
        if (groupStackF.count() > 0)
1744
        {
1745
                while (groupStackF.count() > 0)
1746
                {
17417 fschmid 1747
                        bool isTableIt = false;
16105 fschmid 1748
                        QList<PageItem*> gpL = groupStackF.pop();
1749
                        PageItem* gItem = gpL.takeFirst();
1750
                        for (int id = 0; id < gpL.count(); id++)
1751
                        {
1752
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1753
                                isTableIt = cItem->isTableItem;
16105 fschmid 1754
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1755
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1756
                                cItem->Parent = gItem;
16105 fschmid 1757
                                if (gItem->rotation() != 0)
1758
                                {
1759
                                        QTransform ma;
1760
                                        ma.rotate(-gItem->rotation());
1761
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1762
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1763
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1764
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1765
                                }
17407 fschmid 1766
                                m_Doc->FrameItems.remove(m_Doc->FrameItems.key(cItem));
16105 fschmid 1767
                        }
17417 fschmid 1768
                        if (isTableIt)
1769
                                convertOldTable(m_Doc, gItem, gpL, &groupStackF, NULL);
1770
                        else
1771
                                gItem->groupItemList = gpL;
16105 fschmid 1772
                }
1773
        }
1774
        if (groupStackM.count() > 0)
1775
        {
1776
                while (groupStackM.count() > 0)
1777
                {
17417 fschmid 1778
                        bool isTableIt = false;
16105 fschmid 1779
                        QList<PageItem*> gpL = groupStackM.pop();
1780
                        PageItem* gItem = gpL.takeFirst();
1781
                        for (int id = 0; id < gpL.count(); id++)
1782
                        {
1783
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1784
                                isTableIt = cItem->isTableItem;
16105 fschmid 1785
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1786
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1787
                                cItem->Parent = gItem;
16105 fschmid 1788
                                if (gItem->rotation() != 0)
1789
                                {
1790
                                        QTransform ma;
1791
                                        ma.rotate(-gItem->rotation());
1792
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1793
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1794
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1795
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1796
                                }
1797
                                m_Doc->MasterItems.removeOne(cItem);
1798
                        }
17417 fschmid 1799
                        if (isTableIt)
1800
                                convertOldTable(m_Doc, gItem, gpL, &groupStackM, &m_Doc->MasterItems);
1801
                        else
1802
                                gItem->groupItemList = gpL;
16105 fschmid 1803
                }
1804
        }
13971 jghali 1805
 
1806
        // reestablish first/lastAuto
1807
        m_Doc->FirstAuto = m_Doc->LastAuto;
1808
        if (m_Doc->LastAuto)
1809
        {
1810
                while (m_Doc->LastAuto->nextInChain())
1811
                        m_Doc->LastAuto = m_Doc->LastAuto->nextInChain();
1812
                while (m_Doc->FirstAuto->prevInChain())
1813
                        m_Doc->FirstAuto = m_Doc->FirstAuto->prevInChain();
1814
        }
1815
 
1816
        // start auto save timer if needed
14925 cbradney 1817
        if (m_Doc->autoSave()  && ScCore->usingGUI())
1818
                m_Doc->autoSaveTimer->start(m_Doc->autoSaveTime());
13971 jghali 1819
 
1820
        if (m_mwProgressBar!=0)
1821
                m_mwProgressBar->setValue(reader.characterOffset());
1822
        return true;
1823
}
1824
 
1825
// Low level plugin API
1826
int scribus150format_getPluginAPIVersion()
1827
{
1828
        return PLUGIN_API_VERSION;
1829
}
1830
 
1831
ScPlugin* scribus150format_getPlugin()
1832
{
1833
        Scribus150Format* plug = new Scribus150Format();
1834
        Q_CHECK_PTR(plug);
1835
        return plug;
1836
}
1837
 
1838
void scribus150format_freePlugin(ScPlugin* plugin)
1839
{
1840
        Scribus150Format* plug = dynamic_cast<Scribus150Format*>(plugin);
1841
        Q_ASSERT(plug);
1842
        delete plug;
1843
}
1844
 
1845
 
1846
namespace {
1847
        const int NOVALUE = -16000;
1848
 
1849
        void fixLegacyCharStyle(CharStyle& cstyle)
1850
        {
1851
                if (! cstyle.font().usable())
1852
                        cstyle.resetFont();
1853
                if (cstyle.fontSize() <= -16000 / 10)
1854
                        cstyle.resetFontSize();
1855
//              if (cstyle.effects() == 65535)
1856
//                      cstyle.resetEffects();
1857
                if (cstyle.fillColor().isEmpty())
1858
                        cstyle.resetFillColor();
1859
                if (cstyle.fillShade() <= -16000)
1860
                        cstyle.resetFillShade();
1861
                if (cstyle.strokeColor().isEmpty())
1862
                        cstyle.resetStrokeColor();
1863
                if (cstyle.strokeShade() <= -16000)
1864
                        cstyle.resetStrokeShade();
1865
                if (cstyle.shadowXOffset() <= -16000 / 10)
1866
                        cstyle.resetShadowXOffset();
1867
                if (cstyle.shadowYOffset() <= -16000 / 10)
1868
                        cstyle.resetShadowYOffset();
1869
                if (cstyle.outlineWidth() <= -16000 / 10)
1870
                        cstyle.resetOutlineWidth();
1871
                if (cstyle.underlineOffset() <= -16000 / 10)
1872
                        cstyle.resetUnderlineOffset();
1873
                if (cstyle.underlineWidth() <= -16000 / 10)
1874
                        cstyle.resetUnderlineWidth();
1875
                if (cstyle.strikethruOffset() <= -16000 / 10)
1876
                        cstyle.resetStrikethruOffset();
1877
                if (cstyle.strikethruWidth() <= -16000 / 10)
1878
                        cstyle.resetStrikethruWidth();
1879
                if (cstyle.scaleH() <= -16000 / 10)
1880
                        cstyle.resetScaleH();
1881
                if (cstyle.scaleV() <= -16000 / 10)
1882
                        cstyle.resetScaleV();
1883
                if (cstyle.baselineOffset() <= -16000 / 10)
1884
                        cstyle.resetBaselineOffset();
1885
                if (cstyle.tracking() <= -16000 / 10)
1886
                        cstyle.resetTracking();
1887
        }
1888
 
1889
        void fixLegacyParStyle(ParagraphStyle& pstyle)
1890
        {
1891
                if (pstyle.lineSpacing() <= -16000)
1892
                        pstyle.resetLineSpacing();
1893
                if (pstyle.leftMargin() <= -16000)
1894
                        pstyle.resetLeftMargin();
1895
                if (pstyle.rightMargin() <= -16000)
1896
                        pstyle.resetRightMargin();
1897
                if (pstyle.firstIndent() <= -16000)
1898
                        pstyle.resetFirstIndent();
1899
                if (pstyle.alignment() < 0)
1900
                        pstyle.resetAlignment();
1901
                if (pstyle.gapBefore() <= -16000)
1902
                        pstyle.resetGapBefore();
1903
                if (pstyle.gapAfter() <= -16000)
1904
                        pstyle.resetGapAfter();
1905
                if (pstyle.dropCapLines() < 0)
1906
                        pstyle.resetDropCapLines();
1907
                if (pstyle.dropCapOffset() <= -16000)
1908
                        pstyle.resetDropCapOffset();
1909
                fixLegacyCharStyle(pstyle.charStyle());
1910
        }
1911
 
1912
}// namespace
1913
 
1914
void Scribus150Format::readDocAttributes(ScribusDoc* doc, ScXmlStreamAttributes& attrs)
1915
{
14991 cbradney 1916
        m_Doc->setPageSize(attrs.valueAsString("PAGESIZE"));
1917
        m_Doc->setPageOrientation(attrs.valueAsInt("ORIENTATION", 0));
13971 jghali 1918
        m_Doc->FirstPnum  = attrs.valueAsInt("FIRSTNUM", 1);
15407 craig 1919
        m_Doc->setPagePositioning(attrs.valueAsInt("BOOK", 0));
13971 jghali 1920
 
1921
        m_Doc->setUsesAutomaticTextFrames( attrs.valueAsInt("AUTOTEXT") );
1922
        m_Doc->PageSp  = attrs.valueAsInt("AUTOSPALTEN");
1923
        m_Doc->PageSpa = attrs.valueAsDouble("ABSTSPALTEN");
1924
        m_Doc->setUnitIndex( attrs.valueAsInt("UNITS", 0) );
1925
 
17501 craig 1926
        m_Doc->setHyphLanguage(attrs.valueAsString("LANGUAGE", "en_US"));
14924 cbradney 1927
        m_Doc->setHyphMinimumWordLength(attrs.valueAsInt("MINWORDLEN", 3));
1928
        m_Doc->setHyphConsecutiveLines(attrs.valueAsInt("HYCOUNT", 2));
13971 jghali 1929
 
1930
        if (attrs.hasAttribute("PAGEWIDTH"))
14991 cbradney 1931
                m_Doc->setPageWidth(attrs.valueAsDouble("PAGEWIDTH"));
13971 jghali 1932
        else
14991 cbradney 1933
                m_Doc->setPageWidth(attrs.valueAsDouble("PAGEWITH"));
1934
        m_Doc->setPageHeight(attrs.valueAsDouble("PAGEHEIGHT"));
14994 cbradney 1935
        m_Doc->margins()->Left  = qMax(0.0, attrs.valueAsDouble("BORDERLEFT"));
1936
        m_Doc->margins()->Right = qMax(0.0, attrs.valueAsDouble("BORDERRIGHT"));
1937
        m_Doc->margins()->Top   = qMax(0.0, attrs.valueAsDouble("BORDERTOP"));
1938
        m_Doc->margins()->Bottom= qMax(0.0, attrs.valueAsDouble("BORDERBOTTOM"));
14992 cbradney 1939
        m_Doc->setMarginPreset(attrs.valueAsInt("PRESET", 0));
1940
        m_Doc->bleeds()->Top    = attrs.valueAsDouble("BleedTop", 0.0);
1941
        m_Doc->bleeds()->Left   = attrs.valueAsDouble("BleedLeft", 0.0);
1942
        m_Doc->bleeds()->Right  = attrs.valueAsDouble("BleedRight", 0.0);
1943
        m_Doc->bleeds()->Bottom = attrs.valueAsDouble("BleedBottom", 0.0);
14924 cbradney 1944
        m_Doc->setHyphAutomatic(attrs.valueAsBool("AUTOMATIC", true));
1945
        m_Doc->setHyphAutoCheck(attrs.valueAsBool("AUTOCHECK", false));
13971 jghali 1946
        m_Doc->GuideLock = attrs.valueAsBool("GUIDELOCK", false);
1947
 
1948
        m_Doc->rulerXoffset = attrs.valueAsDouble("rulerXoffset", 0.0);
1949
        m_Doc->rulerYoffset = attrs.valueAsDouble("rulerYoffset", 0.0);
1950
        m_Doc->SnapGuides   = attrs.valueAsBool("SnapToGuides", false);
1951
        m_Doc->useRaster    = attrs.valueAsBool("SnapToGrid", false);
1952
 
14925 cbradney 1953
        m_Doc->setAutoSave(attrs.valueAsBool("AutoSave", false));
1954
        m_Doc->setAutoSaveTime(attrs.valueAsInt("AutoSaveTime", 600000));
14924 cbradney 1955
        double leftScratch;
13971 jghali 1956
        // FIXME A typo in early 1.3cvs (MAR 05) means we must support loading of
1957
        // FIXME 'ScatchLeft' for a while too. This can be removed in a few months.
1958
        if (attrs.hasAttribute("ScatchLeft"))
14924 cbradney 1959
                leftScratch = attrs.valueAsDouble("ScatchLeft", 100.0);
13971 jghali 1960
        else
14924 cbradney 1961
                leftScratch = attrs.valueAsDouble("ScratchLeft", 100.0);
1962
        m_Doc->scratch()->set(attrs.valueAsDouble("ScratchTop", 20.0), leftScratch,
1963
                                                  attrs.valueAsDouble("ScratchBottom", 20.0),attrs.valueAsDouble("ScratchRight", 100.0));
1964
        m_Doc->setPageGapHorizontal(attrs.valueAsDouble("GapHorizontal", -1.0));
1965
        m_Doc->setPageGapVertical(attrs.valueAsDouble("GapVertical", -1.0));
13971 jghali 1966
 
1967
        if (attrs.hasAttribute("PAGEC"))
14924 cbradney 1968
                m_Doc->setPaperColor(QColor(attrs.valueAsString("PAGEC")));
1969
                //->Prefs m_Doc->papColor = QColor(attrs.valueAsString("PAGEC"));
13971 jghali 1970
 
14971 cbradney 1971
        m_Doc->setMarginColored(attrs.valueAsBool("RANDF", false));
13971 jghali 1972
 
1973
        readCMSSettings(doc, attrs);
1974
        readDocumentInfo(doc, attrs);
1975
        readGuideSettings(doc, attrs);
1976
        readToolSettings(doc, attrs);
1977
        readTypographicSettings(doc, attrs);
1978
}
1979
 
1980
void Scribus150Format::readCMSSettings(ScribusDoc* doc, ScXmlStreamAttributes& attrs)
1981
{
15001 cbradney 1982
        doc->cmsSettings().SoftProofOn     = attrs.valueAsBool("DPSo", false);
1983
        doc->cmsSettings().SoftProofFullOn = attrs.valueAsBool("DPSFo", false);
1984
        doc->cmsSettings().CMSinUse   = attrs.valueAsBool("DPuse", false);
1985
        doc->cmsSettings().GamutCheck = attrs.valueAsBool("DPgam", false);
1986
        doc->cmsSettings().BlackPoint = attrs.valueAsBool("DPbla", true);
1987
        doc->cmsSettings().DefaultMonitorProfile   = attrs.valueAsString("DPMo","");
1988
        doc->cmsSettings().DefaultPrinterProfile   = attrs.valueAsString("DPPr","");
1989
        doc->cmsSettings().DefaultImageRGBProfile  = attrs.valueAsString("DPIn","");
1990
        doc->cmsSettings().DefaultImageCMYKProfile = attrs.valueAsString("DPInCMYK","");
1991
        doc->cmsSettings().DefaultSolidColorRGBProfile = attrs.valueAsString("DPIn2","");
13971 jghali 1992
        if (attrs.hasAttribute("DPIn3"))
15001 cbradney 1993
                doc->cmsSettings().DefaultSolidColorCMYKProfile = attrs.valueAsString("DPIn3","");
13971 jghali 1994
        else
15001 cbradney 1995
                doc->cmsSettings().DefaultSolidColorCMYKProfile = attrs.valueAsString("DPPr","");
1996
        doc->cmsSettings().DefaultIntentColors = (eRenderIntent) attrs.valueAsInt("DISc", 1);
1997
        doc->cmsSettings().DefaultIntentImages = (eRenderIntent) attrs.valueAsInt("DIIm", 0);
13971 jghali 1998
}
1999
 
2000
void Scribus150Format::readDocumentInfo(ScribusDoc* doc, ScXmlStreamAttributes& attrs)
2001
{
15037 cbradney 2002
        DocumentInformation di;
2003
        di.setAuthor(attrs.valueAsString("AUTHOR"));
2004
        di.setComments(attrs.valueAsString("COMMENTS"));
2005
        di.setKeywords(attrs.valueAsString("KEYWORDS",""));
2006
        di.setTitle(attrs.valueAsString("TITLE"));
2007
        di.setSubject(attrs.valueAsString("SUBJECT"));
2008
        di.setPublisher(attrs.valueAsString("PUBLISHER", ""));
2009
        di.setDate(attrs.valueAsString("DOCDATE", ""));
2010
        di.setType(attrs.valueAsString("DOCTYPE", ""));
2011
        di.setFormat(attrs.valueAsString("DOCFORMAT", ""));
2012
        di.setIdent(attrs.valueAsString("DOCIDENT", ""));
2013
        di.setSource(attrs.valueAsString("DOCSOURCE", ""));
2014
        di.setLangInfo(attrs.valueAsString("DOCLANGINFO", ""));
2015
        di.setRelation(attrs.valueAsString("DOCRELATION", ""));
2016
        di.setCover(attrs.valueAsString("DOCCOVER", ""));
2017
        di.setRights(attrs.valueAsString("DOCRIGHTS", ""));
2018
        di.setContrib(attrs.valueAsString("DOCCONTRIB", ""));
2019
        doc->setDocumentInfo(di);
13971 jghali 2020
}
2021
 
2022
void Scribus150Format::readGuideSettings(ScribusDoc* doc, ScXmlStreamAttributes& attrs)
2023
{
2024
        PrefsManager* prefsManager = PrefsManager::instance();
14932 cbradney 2025
        doc->guidesPrefs().minorGridSpacing = attrs.valueAsDouble("MINGRID", prefsManager->appPrefs.guidesPrefs.minorGridSpacing);
2026
        doc->guidesPrefs().majorGridSpacing = attrs.valueAsDouble("MAJGRID", prefsManager->appPrefs.guidesPrefs.majorGridSpacing);
2027
        doc->guidesPrefs().gridShown    = attrs.valueAsBool("SHOWGRID", false);
2028
        doc->guidesPrefs().guidesShown  =attrs.valueAsBool("SHOWGUIDES", true);
2029
        doc->guidesPrefs().colBordersShown  = attrs.valueAsBool("showcolborders", false);
2030
        doc->guidesPrefs().framesShown  = attrs.valueAsBool("SHOWFRAME", true);
2031
        doc->guidesPrefs().layerMarkersShown = attrs.valueAsBool("SHOWLAYERM", false);
2032
        doc->guidesPrefs().marginsShown = attrs.valueAsBool("SHOWMARGIN", true);
2033
        doc->guidesPrefs().baselineGridShown    = attrs.valueAsBool("SHOWBASE", false);
2034
        doc->guidesPrefs().showPic      = attrs.valueAsBool("SHOWPICT", true);
2035
        doc->guidesPrefs().linkShown    = attrs.valueAsBool("SHOWLINK", false);
2036
        doc->guidesPrefs().showControls = attrs.valueAsBool("SHOWControl", false);
2037
        doc->guidesPrefs().rulerMode    = attrs.valueAsBool("rulerMode", true);
2038
        doc->guidesPrefs().rulersShown  = attrs.valueAsBool("showrulers", true);
2039
        doc->guidesPrefs().showBleed    = attrs.valueAsBool("showBleed", true);
13971 jghali 2040
        if (attrs.hasAttribute("MARGC"))
14932 cbradney 2041
                doc->guidesPrefs().marginColor  = QColor(attrs.valueAsString("MARGC"));
13971 jghali 2042
        if (attrs.hasAttribute("MINORC"))
14932 cbradney 2043
                doc->guidesPrefs().minorGridColor = QColor(attrs.valueAsString("MINORC"));
13971 jghali 2044
        if (attrs.hasAttribute("MAJORC"))
14932 cbradney 2045
                doc->guidesPrefs().majorGridColor = QColor(attrs.valueAsString("MAJORC"));
13971 jghali 2046
        if (attrs.hasAttribute("GuideC"))
14932 cbradney 2047
                doc->guidesPrefs().guideColor = QColor(attrs.valueAsString("GuideC"));
13971 jghali 2048
        if (attrs.hasAttribute("BaseC"))
14932 cbradney 2049
                doc->guidesPrefs().baselineGridColor  = QColor(attrs.valueAsString("BaseC"));
16990 fschmid 2050
        if (attrs.hasAttribute("BACKG"))
2051
        {
2052
                doc->guidesPrefs().renderStackOrder.clear();
2053
                if (attrs.valueAsBool("BACKG", true))
2054
                        doc->guidesPrefs().renderStackOrder << 0 << 1 << 2 << 3 << 4;
2055
                else
2056
                        doc->guidesPrefs().renderStackOrder << 4 << 0 << 1 << 2 << 3;
2057
        }
2058
        if (attrs.hasAttribute("renderStack"))
2059
        {
2060
                doc->guidesPrefs().renderStackOrder.clear();
2061
                QString renderStack = attrs.valueAsString("renderStack", "0 1 2 3 4");
2062
                ScTextStream fp(&renderStack, QIODevice::ReadOnly);
2063
                QString val;
2064
                while (!fp.atEnd())
2065
                {
2066
                        fp >> val;
2067
                        doc->guidesPrefs().renderStackOrder << val.toInt();
2068
                }
2069
        }
16992 fschmid 2070
        doc->guidesPrefs().gridType = attrs.valueAsInt("GridType", 0);
14932 cbradney 2071
        doc->guidesPrefs(