Subversion Repositories Scribus

Rev

Rev 17744 | Rev 17747 | 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;
16943 fschmid 182
        isNewFormat = false;
16105 fschmid 183
        LayerToPaste = toLayer;
184
        Xp = Xp_in;
185
        Yp = Yp_in;
16159 fschmid 186
//      GrX = 0.0;
187
//      GrY = 0.0;
16105 fschmid 188
 
16943 fschmid 189
        QMap<int,PageItem*> TableID;
190
        QMap<int,PageItem*> TableIDM;
191
        QMap<int,PageItem*> TableIDF;
16105 fschmid 192
        QList<PageItem*> TableItems;
193
        QList<PageItem*> TableItemsM;
194
        QList<PageItem*> TableItemsF;
16931 fschmid 195
        QMap<int,PageItem*> WeldID;
16926 fschmid 196
        QList<PageItem*> WeldItems;
16105 fschmid 197
        QStack< QList<PageItem*> > groupStack;
198
        QStack< QList<PageItem*> > groupStackF;
199
        QStack< QList<PageItem*> > groupStackM;
200
        QStack< QList<PageItem*> > groupStackP;
201
        QStack<int> groupStack2;
202
 
203
        itemRemap.clear();
204
        itemNext.clear();
205
        itemCount = 0;
206
        itemRemapM.clear();
207
        itemNextM.clear();
208
        itemCountM = 0;
209
        itemRemapF.clear();
210
        itemNextF.clear();
211
 
212
        TableItems.clear();
213
        TableID.clear();
214
        TableItemsM.clear();
215
        TableIDM.clear();
216
        TableItemsF.clear();
217
        TableIDF.clear();
16926 fschmid 218
        WeldItems.clear();
219
        WeldID.clear();
16105 fschmid 220
 
221
        bool firstElement = true;
222
        bool success = true;
223
 
224
        ScXmlStreamReader reader(data);
225
        ScXmlStreamAttributes attrs;
226
        while(!reader.atEnd() && !reader.hasError())
227
        {
228
                QXmlStreamReader::TokenType tType = reader.readNext();
229
                if (tType != QXmlStreamReader::StartElement)
230
                        continue;
231
                QStringRef tagName = reader.name();
232
                attrs = reader.scAttributes();
233
 
234
                if (firstElement)
235
                {
236
                        if (tagName == "SCRIBUSELEM" || tagName == "SCRIBUSELEMUTF8")
237
                        {
238
                                if (!loc)
239
                                {
240
                                        GrX = attrs.valueAsDouble("XP");
241
                                        GrY = attrs.valueAsDouble("YP");
242
                                }
243
                        }
244
                        else
245
                        {
246
                                success = false;
247
                                break;
248
                        }
249
                        firstElement = false;
250
                }
251
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
252
                if (tagName == "COLOR" && attrs.valueAsString("NAME") != CommonStrings::None)
253
                {
254
                        success = readColor(m_Doc->PageColors, attrs);
255
                        if (!success) break;
256
                }
257
                if (tagName == "Gradient")
258
                {
259
                        VGradient gra;
260
                        QString grName = attrs.valueAsString("Name");
261
                        success = readGradient(m_Doc, gra, reader);
262
                        if (!success) break;
263
                        if (!grName.isEmpty())
264
                        {
265
                                m_Doc->docGradients.insert(grName, gra);
266
                        }
267
                }
268
                if (tagName == "STYLE")
269
                {
16531 jghali 270
                        readParagraphStyle(m_Doc, reader, vg);
16105 fschmid 271
                        StyleSet<ParagraphStyle>tmp;
272
                        tmp.create(vg);
273
                        m_Doc->redefineStyles(tmp, false);
274
                }
275
                if (tagName == "CHARSTYLE")
276
                {
16531 jghali 277
                        readParagraphStyle(m_Doc, reader, vg);
16105 fschmid 278
                        StyleSet<CharStyle> temp;
279
                        temp.create(vg.charStyle());
280
                        m_Doc->redefineCharStyles(temp, false);
281
                }
17318 fschmid 282
                if (tagName == "TableStyle")
283
                {
284
                        TableStyle tstyle;
285
                        readTableStyle(m_Doc, reader, tstyle);
286
                        StyleSet<TableStyle> temp;
287
                        temp.create(tstyle);
288
                        m_Doc->redefineTableStyles(temp, false);
289
                }
290
                if (tagName == "CellStyle")
291
                {
292
                        CellStyle tstyle;
293
                        readCellStyle(m_Doc, reader, tstyle);
294
                        StyleSet<CellStyle> temp;
295
                        temp.create(tstyle);
296
                        m_Doc->redefineCellStyles(temp, false);
297
                }
16105 fschmid 298
                if (tagName == "Arrows")
299
                {
300
                        success = readArrows(m_Doc, attrs);
301
                        if (!success) break;
302
                }
303
                if (tagName == "MultiLine")
304
                {
305
                        multiLine ml;
306
                        QString mlName = attrs.valueAsString("Name");
307
                        success = readMultiline(ml, reader);
308
                        if (!success) break;
309
                        if (!mlName.isEmpty())
310
                        {
311
                                m_Doc->MLineStyles.insert(mlName, ml);
312
                        }
313
                }
17147 fschmid 314
                if ((tagName == "ITEM") || (tagName == "FRAMEOBJECT"))
16105 fschmid 315
                {
316
                        ItemInfo itemInfo;
317
                        success = readObject(m_Doc, reader, itemInfo, fileDir, true);
318
                        if (!success)
319
                                break;
16943 fschmid 320
                        if (isNewFormat)
16105 fschmid 321
                        {
322
                                if (itemInfo.nextItem != -1)
16943 fschmid 323
                                        itemNext[itemInfo.itemID] = itemInfo.nextItem;
324
                                if (itemInfo.item->isTableItem)
325
                                        TableItems.append(itemInfo.item);
326
                                if (itemInfo.isWeldFlag)
327
                                        WeldItems.append(itemInfo.item);
16105 fschmid 328
                        }
16943 fschmid 329
                        else
16105 fschmid 330
                        {
16943 fschmid 331
                        // first of linked chain?
16105 fschmid 332
                                if (tagName == "ITEM")
333
                                {
16943 fschmid 334
                                        if (itemInfo.nextItem != -1)
335
                                                itemNext[itemInfo.ownNr] = itemInfo.nextItem;
16105 fschmid 336
                                }
16943 fschmid 337
                                if (itemInfo.item->isTableItem)
16926 fschmid 338
                                {
16943 fschmid 339
                                        if (tagName == "ITEM")
340
                                        {
341
                                                TableItems.append(itemInfo.item);
342
                                                TableID.insert(itemInfo.ownLink, itemInfo.item);
343
                                        }
16926 fschmid 344
                                }
16943 fschmid 345
                                if (itemInfo.isWeldFlag)
346
                                {
347
                                        if (tagName == "ITEM")
348
                                        {
349
                                                WeldItems.append(itemInfo.item);
350
                                                WeldID.insert(itemInfo.ownWeld, itemInfo.item);
351
                                        }
352
                                }
16926 fschmid 353
                        }
16105 fschmid 354
                        if (groupStack.count() > 0)
355
                        {
356
                                groupStack.top().append(itemInfo.item);
16943 fschmid 357
                                while (static_cast<int>(itemInfo.ownNr) == groupStack2.top())
16105 fschmid 358
                                {
359
                                        if ((tagName == "PAGEOBJECT") || (tagName == "ITEM"))
360
                                                groupStackP.push(groupStack.pop());
361
                                        else if (tagName == "FRAMEOBJECT")
362
                                                groupStackF.push(groupStack.pop());
363
                                        else
364
                                                groupStackM.push(groupStack.pop());
365
                                        groupStack2.pop();
16233 fschmid 366
                                        if (groupStack2.count() == 0)
367
                                                break;
16105 fschmid 368
                                }
369
                        }
16113 fschmid 370
                        if (itemInfo.isGroupFlag)
16105 fschmid 371
                        {
372
                                QList<PageItem*> GroupItems;
373
                                GroupItems.append(itemInfo.item);
374
                                groupStack.push(GroupItems);
16943 fschmid 375
                                groupStack2.push(itemInfo.groupLastItem + itemInfo.ownNr);
16105 fschmid 376
                        }
377
                }
378
                if (tagName == "Pattern")
379
                {
380
                        success = readPattern(m_Doc, reader, fileDir);
381
                        if (!success) break;
382
                }
383
        }
384
        if (reader.hasError())
385
        {
386
                setDomParsingError(reader.errorString(), reader.lineNumber(), reader.columnNumber());
387
                return false;
388
        }
16943 fschmid 389
        if (isNewFormat)
16105 fschmid 390
        {
16943 fschmid 391
                if (TableItems.count() != 0)
16105 fschmid 392
                {
16943 fschmid 393
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
394
                        {
395
                                PageItem* ta = TableItems.at(ttc);
396
                                if (ta->TopLinkID != -1)
397
                                        ta->TopLink = LinkID[ta->TopLinkID];
398
                                else
399
                                        ta->TopLink = 0;
400
                                if (ta->LeftLinkID != -1)
401
                                        ta->LeftLink = LinkID[ta->LeftLinkID];
402
                                else
403
                                        ta->LeftLink = 0;
404
                                if (ta->RightLinkID != -1)
405
                                        ta->RightLink = LinkID[ta->RightLinkID];
406
                                else
407
                                        ta->RightLink = 0;
408
                                if (ta->BottomLinkID != -1)
409
                                        ta->BottomLink = LinkID[ta->BottomLinkID];
410
                                else
411
                                        ta->BottomLink = 0;
412
                        }
16105 fschmid 413
                }
16943 fschmid 414
                if (WeldItems.count() != 0)
16105 fschmid 415
                {
16943 fschmid 416
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
417
                        {
418
                                PageItem* ta = WeldItems.at(ttc);
17745 jghali 419
                                for (int i = 0; i < ta->weldList.count(); ++i)
16943 fschmid 420
                                {
421
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
17745 jghali 422
                                        ta->weldList[i].weldItem   = LinkID.value(wInf.weldID, 0);
423
                                        if (ta->weldList[i].weldItem == NULL)
424
                                                ta->weldList.removeAt(i--);
16943 fschmid 425
                                }
426
                        }
16105 fschmid 427
                }
16943 fschmid 428
                if (itemNext.count() != 0)
16105 fschmid 429
                {
16943 fschmid 430
                        QMap<int,int>::Iterator lc;
431
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
432
                        {
433
                                if (lc.value() >= 0)
434
                                {
435
                                        PageItem * Its = LinkID[lc.key()];
436
                                        PageItem * Itn = LinkID[lc.value()];
437
                                        if (!Its->testLinkCandidate(Itn))
438
                                        {
439
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
440
                                                continue;
441
                                        }
442
                                        Its->link(Itn);
443
                                }
444
                        }
16105 fschmid 445
                }
446
        }
16943 fschmid 447
        else
16926 fschmid 448
        {
16943 fschmid 449
                if (TableItemsF.count() != 0)
16926 fschmid 450
                {
16943 fschmid 451
                        for (int ttc = 0; ttc < TableItemsF.count(); ++ttc)
16926 fschmid 452
                        {
16943 fschmid 453
                                PageItem* ta = TableItemsF.at(ttc);
454
                                if (ta->TopLinkID != -1)
455
                                        ta->TopLink = TableIDF[ta->TopLinkID];
456
                                else
457
                                        ta->TopLink = 0;
458
                                if (ta->LeftLinkID != -1)
459
                                        ta->LeftLink = TableIDF[ta->LeftLinkID];
460
                                else
461
                                        ta->LeftLink = 0;
462
                                if (ta->RightLinkID != -1)
463
                                        ta->RightLink = TableIDF[ta->RightLinkID];
464
                                else
465
                                        ta->RightLink = 0;
466
                                if (ta->BottomLinkID != -1)
467
                                        ta->BottomLink = TableIDF[ta->BottomLinkID];
468
                                else
469
                                        ta->BottomLink = 0;
16926 fschmid 470
                        }
471
                }
16943 fschmid 472
                if (TableItemsM.count() != 0)
16105 fschmid 473
                {
16943 fschmid 474
                        for (int ttc = 0; ttc < TableItemsM.count(); ++ttc)
16105 fschmid 475
                        {
16943 fschmid 476
                                PageItem* ta = TableItemsM.at(ttc);
477
                                if (ta->TopLinkID != -1)
478
                                        ta->TopLink = TableIDM[ta->TopLinkID];
479
                                else
480
                                        ta->TopLink = 0;
481
                                if (ta->LeftLinkID != -1)
482
                                        ta->LeftLink = TableIDM[ta->LeftLinkID];
483
                                else
484
                                        ta->LeftLink = 0;
485
                                if (ta->RightLinkID != -1)
486
                                        ta->RightLink = TableIDM[ta->RightLinkID];
487
                                else
488
                                        ta->RightLink = 0;
489
                                if (ta->BottomLinkID != -1)
490
                                        ta->BottomLink = TableIDM[ta->BottomLinkID];
491
                                else
492
                                        ta->BottomLink = 0;
493
                        }
494
                }
495
                if (TableItems.count() != 0)
496
                {
497
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
498
                        {
499
                                PageItem* ta = TableItems.at(ttc);
500
                                if (ta->TopLinkID != -1)
501
                                        ta->TopLink = TableID[ta->TopLinkID];
502
                                else
503
                                        ta->TopLink = 0;
504
                                if (ta->LeftLinkID != -1)
505
                                        ta->LeftLink = TableID[ta->LeftLinkID];
506
                                else
507
                                        ta->LeftLink = 0;
508
                                if (ta->RightLinkID != -1)
509
                                        ta->RightLink = TableID[ta->RightLinkID];
510
                                else
511
                                        ta->RightLink = 0;
512
                                if (ta->BottomLinkID != -1)
513
                                        ta->BottomLink = TableID[ta->BottomLinkID];
514
                                else
515
                                        ta->BottomLink = 0;
516
                        }
517
                }
518
                if (WeldItems.count() != 0)
519
                {
520
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
521
                        {
522
                                PageItem* ta = WeldItems.at(ttc);
17745 jghali 523
                                for (int i = 0 ; i < ta->weldList.count(); ++i)
16105 fschmid 524
                                {
16943 fschmid 525
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
17745 jghali 526
                                        ta->weldList[i].weldItem = WeldID.value(wInf.weldID, 0);
527
                                        if (ta->weldList[i].weldItem == NULL)
528
                                                ta->weldList.removeAt(i--);
16105 fschmid 529
                                }
530
                        }
531
                }
16943 fschmid 532
                // reestablish textframe links
533
                if (itemNext.count() != 0)
534
                {
535
                        QMap<int,int>::Iterator lc;
536
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
537
                        {
538
                                if (lc.value() >= 0)
539
                                {
540
                                        PageItem * Its = m_Doc->DocItems.at(lc.key());
541
                                        PageItem * Itn = m_Doc->DocItems.at(lc.value());
542
                                        if (!Its->testLinkCandidate(Itn))
543
                                        {
544
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
545
                                                continue;
546
                                        }
547
                                        Its->link(Itn);
548
                                }
549
                        }
550
                }
16105 fschmid 551
        }
552
        if (groupStackP.count() > 0)
553
        {
554
                while (groupStackP.count() > 0)
555
                {
17417 fschmid 556
                        bool isTableIt = false;
16105 fschmid 557
                        QList<PageItem*> gpL = groupStackP.pop();
558
                        PageItem* gItem = gpL.takeFirst();
559
                        for (int id = 0; id < gpL.count(); id++)
560
                        {
561
                                PageItem* cItem = gpL.at(id);
17417 fschmid 562
                                isTableIt = cItem->isTableItem;
16105 fschmid 563
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
564
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 565
                                cItem->Parent = gItem;
16105 fschmid 566
                                if (gItem->rotation() != 0)
567
                                {
568
                                        QTransform ma;
569
                                        ma.rotate(-gItem->rotation());
570
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
571
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
572
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
573
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
574
                                }
575
                                m_Doc->DocItems.removeOne(cItem);
576
                        }
17417 fschmid 577
                        if (isTableIt)
578
                                convertOldTable(m_Doc, gItem, gpL, &groupStackP, &m_Doc->DocItems);
579
                        else
580
                                gItem->groupItemList = gpL;
16105 fschmid 581
                }
582
        }
583
        if (groupStackF.count() > 0)
584
        {
585
                while (groupStackF.count() > 0)
586
                {
17417 fschmid 587
                        bool isTableIt = false;
16105 fschmid 588
                        QList<PageItem*> gpL = groupStackF.pop();
589
                        PageItem* gItem = gpL.takeFirst();
590
                        for (int id = 0; id < gpL.count(); id++)
591
                        {
592
                                PageItem* cItem = gpL.at(id);
17417 fschmid 593
                                isTableIt = cItem->isTableItem;
16105 fschmid 594
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
595
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 596
                                cItem->Parent = gItem;
16105 fschmid 597
                                if (gItem->rotation() != 0)
598
                                {
599
                                        QTransform ma;
600
                                        ma.rotate(-gItem->rotation());
601
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
602
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
603
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
604
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
605
                                }
17407 fschmid 606
                                m_Doc->FrameItems.remove(m_Doc->FrameItems.key(cItem));
16105 fschmid 607
                        }
17417 fschmid 608
                        if (isTableIt)
609
                                convertOldTable(m_Doc, gItem, gpL, &groupStackF, NULL);
610
                        else
611
                                gItem->groupItemList = gpL;
16105 fschmid 612
                }
613
        }
614
        if (groupStackM.count() > 0)
615
        {
616
                while (groupStackM.count() > 0)
617
                {
17417 fschmid 618
                        bool isTableIt = false;
16105 fschmid 619
                        QList<PageItem*> gpL = groupStackM.pop();
620
                        PageItem* gItem = gpL.takeFirst();
621
                        for (int id = 0; id < gpL.count(); id++)
622
                        {
623
                                PageItem* cItem = gpL.at(id);
17417 fschmid 624
                                isTableIt = cItem->isTableItem;
16105 fschmid 625
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
626
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 627
                                cItem->Parent = gItem;
16105 fschmid 628
                                if (gItem->rotation() != 0)
629
                                {
630
                                        QTransform ma;
631
                                        ma.rotate(-gItem->rotation());
632
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
633
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
634
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
635
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
636
                                }
637
                                m_Doc->MasterItems.removeOne(cItem);
638
                        }
17417 fschmid 639
                        if (isTableIt)
640
                                convertOldTable(m_Doc, gItem, gpL, &groupStackM, &m_Doc->MasterItems);
641
                        else
642
                                gItem->groupItemList = gpL;
16105 fschmid 643
                }
644
        }
645
        return true;
646
}
647
 
16016 fschmid 648
bool Scribus150Format::loadPalette(const QString & fileName)
649
{
650
        if (m_Doc==0 || m_AvailableFonts==0)
651
        {
652
                Q_ASSERT(m_Doc==0 || m_AvailableFonts==0);
653
                return false;
654
        }
655
        ParagraphStyle vg;
16105 fschmid 656
        Xp = 0.0;
657
        Yp = 0.0;
658
        GrX = 0.0;
659
        GrY = 0.0;
16943 fschmid 660
        isNewFormat = false;
16016 fschmid 661
 
16943 fschmid 662
        QMap<int,PageItem*> TableID;
663
        QMap<int,PageItem*> TableIDM;
664
        QMap<int,PageItem*> TableIDF;
16016 fschmid 665
        QList<PageItem*> TableItems;
666
        QList<PageItem*> TableItemsM;
667
        QList<PageItem*> TableItemsF;
16931 fschmid 668
        QMap<int,PageItem*> WeldID;
16926 fschmid 669
        QList<PageItem*> WeldItems;
16105 fschmid 670
        QStack< QList<PageItem*> > groupStack;
671
        QStack< QList<PageItem*> > groupStackF;
672
        QStack< QList<PageItem*> > groupStackM;
673
        QStack< QList<PageItem*> > groupStackP;
674
        QStack<int> groupStack2;
16016 fschmid 675
 
676
        QByteArray docBytes("");
677
        loadRawText(fileName, docBytes);
678
        QString f = QString::fromUtf8(docBytes);
679
        if (f.isEmpty())
680
        {
681
                setFileReadError();
682
                return false;
683
        }
684
        QString fileDir = QFileInfo(fileName).absolutePath();
685
 
686
        if (m_mwProgressBar!=0)
687
        {
688
                m_mwProgressBar->setMaximum(f.length());
689
                m_mwProgressBar->setValue(0);
690
        }
691
 
692
        itemRemap.clear();
693
        itemNext.clear();
694
        itemCount = 0;
695
        itemRemapM.clear();
696
        itemNextM.clear();
697
        itemCountM = 0;
698
        itemRemapF.clear();
699
        itemNextF.clear();
700
 
701
        TableItems.clear();
702
        TableID.clear();
703
        TableItemsM.clear();
704
        TableIDM.clear();
705
        TableItemsF.clear();
706
        TableIDF.clear();
16926 fschmid 707
        WeldItems.clear();
16016 fschmid 708
 
709
        m_Doc->GroupCounter = 1;
710
        m_Doc->LastAuto = 0;
16147 fschmid 711
//      m_Doc->PageColors.clear();
712
//      m_Doc->Layers.clear();
16016 fschmid 713
 
714
        bool firstElement = true;
715
        bool success = true;
716
        int  progress = 0;
717
 
718
        ScXmlStreamReader reader(f);
719
        ScXmlStreamAttributes attrs;
720
        while(!reader.atEnd() && !reader.hasError())
721
        {
722
                QXmlStreamReader::TokenType tType = reader.readNext();
723
                if (tType != QXmlStreamReader::StartElement)
724
                        continue;
725
                QStringRef tagName = reader.name();
726
                attrs = reader.scAttributes();
727
 
728
                if (m_mwProgressBar != 0)
729
                {
730
                        int newProgress = qRound(reader.characterOffset() / (double) f.length() * 100);
731
                        if (newProgress != progress)
732
                        {
733
                                m_mwProgressBar->setValue(reader.characterOffset());
734
                                progress = newProgress;
735
                        }
736
                }
737
 
738
                if (firstElement)
739
                {
740
                        if (tagName != "SCRIBUSCOLORS")
741
                        {
742
                                success = false;
743
                                break;
744
                        }
745
                        firstElement = false;
746
                }
747
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
748
                if (tagName == "COLOR" && attrs.valueAsString("NAME") != CommonStrings::None)
749
                {
750
                        success = readColor(m_Doc->PageColors, attrs);
751
                        if (!success) break;
752
                }
753
                if (tagName == "Gradient")
754
                {
755
                        VGradient gra;
756
                        QString grName = attrs.valueAsString("Name");
757
                        success = readGradient(m_Doc, gra, reader);
758
                        if (!success) break;
759
                        if (!grName.isEmpty())
760
                        {
761
                                m_Doc->docGradients.insert(grName, gra);
762
                        }
763
                }
764
                if (tagName == "Arrows")
765
                {
766
                        success = readArrows(m_Doc, attrs);
767
                        if (!success) break;
768
                }
769
                if (tagName == "MultiLine")
770
                {
771
                        multiLine ml;
772
                        QString mlName = attrs.valueAsString("Name");
773
                        success = readMultiline(ml, reader);
774
                        if (!success) break;
775
                        if (!mlName.isEmpty())
776
                        {
777
                                m_Doc->MLineStyles.insert(mlName, ml);
778
                        }
779
                }
780
                if (tagName == "PAGEOBJECT" || tagName == "MASTEROBJECT" || tagName == "FRAMEOBJECT")
781
                {
782
                        ItemInfo itemInfo;
783
                        success = readObject(m_Doc, reader, itemInfo, fileDir, false);
784
                        if (!success) break;
785
 
16943 fschmid 786
                        if (isNewFormat)
16016 fschmid 787
                        {
788
                                if (itemInfo.nextItem != -1)
16943 fschmid 789
                                        itemNext[itemInfo.itemID] = itemInfo.nextItem;
790
                                if (itemInfo.item->isTableItem)
791
                                        TableItems.append(itemInfo.item);
792
                                if (itemInfo.isWeldFlag)
793
                                        WeldItems.append(itemInfo.item);
16016 fschmid 794
                        }
16943 fschmid 795
                        else
16016 fschmid 796
                        {
16943 fschmid 797
                                // first of linked chain?
16016 fschmid 798
                                if (tagName == "PAGEOBJECT")
799
                                {
16943 fschmid 800
                                        if (itemInfo.nextItem != -1)
801
                                                itemNext[itemInfo.ownNr] = itemInfo.nextItem;
16016 fschmid 802
                                }
16943 fschmid 803
                                else if (tagName == "MASTEROBJECT")
16016 fschmid 804
                                {
16943 fschmid 805
                                        if (itemInfo.nextItem != -1)
806
                                                itemNextM[itemInfo.ownNr] = itemInfo.nextItem;
16016 fschmid 807
                                }
16943 fschmid 808
                                if (itemInfo.item->isTableItem)
16016 fschmid 809
                                {
16943 fschmid 810
                                        if (tagName == "PAGEOBJECT")
811
                                        {
812
                                                TableItems.append(itemInfo.item);
813
                                                TableID.insert(itemInfo.ownLink, itemInfo.item);
814
                                        }
815
                                        else if (tagName == "FRAMEOBJECT")
816
                                        {
817
                                                TableItemsF.append(itemInfo.item);
818
                                                TableIDF.insert(itemInfo.ownLink, itemInfo.item);
819
                                        }
820
                                        else
821
                                        {
822
                                                TableItemsM.append(itemInfo.item);
823
                                                TableIDM.insert(itemInfo.ownLink, itemInfo.item);
824
                                        }
16016 fschmid 825
                                }
16943 fschmid 826
                                if (itemInfo.isWeldFlag)
827
                                {
828
                                        WeldItems.append(itemInfo.item);
829
                                        WeldID.insert(itemInfo.ownWeld, itemInfo.item);
830
                                }
16016 fschmid 831
                        }
16105 fschmid 832
                        if (groupStack.count() > 0)
16016 fschmid 833
                        {
16105 fschmid 834
                                groupStack.top().append(itemInfo.item);
16943 fschmid 835
                                while (static_cast<int>(itemInfo.ownNr) == groupStack2.top())
16105 fschmid 836
                                {
837
                                        if (tagName == "PAGEOBJECT")
838
                                                groupStackP.push(groupStack.pop());
839
                                        else if (tagName == "FRAMEOBJECT")
840
                                                groupStackF.push(groupStack.pop());
841
                                        else
842
                                                groupStackM.push(groupStack.pop());
843
                                        groupStack2.pop();
16233 fschmid 844
                                        if (groupStack2.count() == 0)
845
                                                break;
16105 fschmid 846
                                }
16016 fschmid 847
                        }
16113 fschmid 848
                        if (itemInfo.isGroupFlag)
16105 fschmid 849
                        {
850
                                QList<PageItem*> GroupItems;
851
                                GroupItems.append(itemInfo.item);
852
                                groupStack.push(GroupItems);
16943 fschmid 853
                                groupStack2.push(itemInfo.groupLastItem + itemInfo.ownNr);
16105 fschmid 854
                        }
16016 fschmid 855
                }
856
                if (tagName == "Pattern")
857
                {
858
                        success = readPattern(m_Doc, reader, fileDir);
859
                        if (!success) break;
860
                }
861
        }
862
 
863
        if (reader.hasError())
864
        {
865
                setDomParsingError(reader.errorString(), reader.lineNumber(), reader.columnNumber());
866
                return false;
867
        }
16943 fschmid 868
        if (isNewFormat)
16016 fschmid 869
        {
16943 fschmid 870
                if (TableItems.count() != 0)
16016 fschmid 871
                {
16943 fschmid 872
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
873
                        {
874
                                PageItem* ta = TableItems.at(ttc);
875
                                if (ta->TopLinkID != -1)
876
                                        ta->TopLink = LinkID[ta->TopLinkID];
877
                                else
878
                                        ta->TopLink = 0;
879
                                if (ta->LeftLinkID != -1)
880
                                        ta->LeftLink = LinkID[ta->LeftLinkID];
881
                                else
882
                                        ta->LeftLink = 0;
883
                                if (ta->RightLinkID != -1)
884
                                        ta->RightLink = LinkID[ta->RightLinkID];
885
                                else
886
                                        ta->RightLink = 0;
887
                                if (ta->BottomLinkID != -1)
888
                                        ta->BottomLink = LinkID[ta->BottomLinkID];
889
                                else
890
                                        ta->BottomLink = 0;
891
                        }
16016 fschmid 892
                }
16943 fschmid 893
                if (WeldItems.count() != 0)
16016 fschmid 894
                {
16943 fschmid 895
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
896
                        {
897
                                PageItem* ta = WeldItems.at(ttc);
17745 jghali 898
                                for (int i = 0 ; i < ta->weldList.count(); ++i)
16943 fschmid 899
                                {
900
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
17745 jghali 901
                                        ta->weldList[i].weldItem = LinkID.value(wInf.weldID, 0);
902
                                        if (ta->weldList[i].weldItem == NULL)
903
                                                ta->weldList.removeAt(i--);
16943 fschmid 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);
17745 jghali 1002
                                for (int i = 0 ; i < ta->weldList.count(); ++i)
16016 fschmid 1003
                                {
16943 fschmid 1004
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
17745 jghali 1005
                                        ta->weldList[i].weldItem = WeldID.value(wInf.weldID, 0);
1006
                                        if (ta->weldList[i].weldItem == NULL)
1007
                                                ta->weldList.removeAt(i--);
16016 fschmid 1008
                                }
1009
                        }
1010
                }
16943 fschmid 1011
                // reestablish textframe links
1012
                if (itemNext.count() != 0)
16016 fschmid 1013
                {
16943 fschmid 1014
                        QMap<int,int>::Iterator lc;
1015
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
16016 fschmid 1016
                        {
16943 fschmid 1017
                                if (lc.value() >= 0)
16016 fschmid 1018
                                {
16943 fschmid 1019
                                        PageItem * Its = m_Doc->DocItems.at(lc.key());
1020
                                        PageItem * Itn = m_Doc->DocItems.at(lc.value());
1021
                                        if (!Its->testLinkCandidate(Itn))
1022
                                        {
1023
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1024
                                                continue;
1025
                                        }
1026
                                        Its->link(Itn);
16016 fschmid 1027
                                }
1028
                        }
1029
                }
16943 fschmid 1030
                if (itemNextM.count() != 0)
1031
                {
1032
                        QMap<int,int>::Iterator lc;
1033
                        for (lc = itemNextM.begin(); lc != itemNextM.end(); ++lc)
1034
                        {
1035
                                if (lc.value() >= 0)
1036
                                {
1037
                                        PageItem * Its = m_Doc->MasterItems.at(lc.key());
1038
                                        PageItem * Itn = m_Doc->MasterItems.at(lc.value());
1039
                                        if (!Its->testLinkCandidate(Itn))
1040
                                        {
1041
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1042
                                                continue;
1043
                                        }
1044
                                        Its->link(Itn);
1045
                                }
1046
                        }
1047
                }
16016 fschmid 1048
        }
16105 fschmid 1049
        if (groupStackP.count() > 0)
1050
        {
1051
                while (groupStackP.count() > 0)
1052
                {
17417 fschmid 1053
                        bool isTableIt = false;
16105 fschmid 1054
                        QList<PageItem*> gpL = groupStackP.pop();
1055
                        PageItem* gItem = gpL.takeFirst();
1056
                        for (int id = 0; id < gpL.count(); id++)
1057
                        {
1058
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1059
                                isTableIt = cItem->isTableItem;
16105 fschmid 1060
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1061
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1062
                                cItem->Parent = gItem;
16105 fschmid 1063
                                if (gItem->rotation() != 0)
1064
                                {
1065
                                        QTransform ma;
1066
                                        ma.rotate(-gItem->rotation());
1067
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1068
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1069
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1070
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1071
                                }
1072
                                m_Doc->DocItems.removeOne(cItem);
1073
                        }
17417 fschmid 1074
                        if (isTableIt)
1075
                                convertOldTable(m_Doc, gItem, gpL, &groupStackP, &m_Doc->DocItems);
1076
                        else
1077
                                gItem->groupItemList = gpL;
16105 fschmid 1078
                }
1079
        }
1080
        if (groupStackF.count() > 0)
1081
        {
1082
                while (groupStackF.count() > 0)
1083
                {
17417 fschmid 1084
                        bool isTableIt = false;
16105 fschmid 1085
                        QList<PageItem*> gpL = groupStackF.pop();
1086
                        PageItem* gItem = gpL.takeFirst();
1087
                        for (int id = 0; id < gpL.count(); id++)
1088
                        {
1089
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1090
                                isTableIt = cItem->isTableItem;
16105 fschmid 1091
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1092
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1093
                                cItem->Parent = gItem;
16105 fschmid 1094
                                if (gItem->rotation() != 0)
1095
                                {
1096
                                        QTransform ma;
1097
                                        ma.rotate(-gItem->rotation());
1098
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1099
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1100
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1101
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1102
                                }
17407 fschmid 1103
                                m_Doc->FrameItems.remove(m_Doc->FrameItems.key(cItem));
16105 fschmid 1104
                        }
17417 fschmid 1105
                        if (isTableIt)
1106
                                convertOldTable(m_Doc, gItem, gpL, &groupStackF, NULL);
1107
                        else
1108
                                gItem->groupItemList = gpL;
16105 fschmid 1109
                }
1110
        }
1111
        if (groupStackM.count() > 0)
1112
        {
1113
                while (groupStackM.count() > 0)
1114
                {
17417 fschmid 1115
                        bool isTableIt = false;
16105 fschmid 1116
                        QList<PageItem*> gpL = groupStackM.pop();
1117
                        PageItem* gItem = gpL.takeFirst();
1118
                        for (int id = 0; id < gpL.count(); id++)
1119
                        {
1120
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1121
                                isTableIt = cItem->isTableItem;
16105 fschmid 1122
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1123
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1124
                                cItem->Parent = gItem;
16105 fschmid 1125
                                if (gItem->rotation() != 0)
1126
                                {
1127
                                        QTransform ma;
1128
                                        ma.rotate(-gItem->rotation());
1129
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1130
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1131
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1132
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1133
                                }
1134
                                m_Doc->MasterItems.removeOne(cItem);
1135
                        }
17417 fschmid 1136
                        if (isTableIt)
1137
                                convertOldTable(m_Doc, gItem, gpL, &groupStackM, &m_Doc->MasterItems);
1138
                        else
1139
                                gItem->groupItemList = gpL;
16105 fschmid 1140
                }
1141
        }
16016 fschmid 1142
 
1143
        if (m_Doc->Layers.count() == 0)
1144
                m_Doc->Layers.newLayer( QObject::tr("Background") );
1145
        if (m_mwProgressBar!=0)
1146
        {
1147
                m_mwProgressBar->setValue(reader.characterOffset());
1148
                m_mwProgressBar->reset();
1149
        }
1150
        return true;
1151
}
1152
 
13971 jghali 1153
bool Scribus150Format::loadFile(const QString & fileName, const FileFormat & /* fmt */, int /* flags */, int /* index */)
1154
{
1155
        if (m_Doc==0 || m_AvailableFonts==0)
1156
        {
1157
                Q_ASSERT(m_Doc==0 || m_AvailableFonts==0);
1158
                return false;
1159
        }
1160
        ParagraphStyle vg;
16105 fschmid 1161
        Xp = 0.0;
1162
        Yp = 0.0;
1163
        GrX = 0.0;
1164
        GrY = 0.0;
13971 jghali 1165
        struct ScribusDoc::BookMa bok;
1166
        QMap<int, ScribusDoc::BookMa> bookmarks;
1167
 
16943 fschmid 1168
        isNewFormat = false;
13971 jghali 1169
 
16943 fschmid 1170
        QMap<int,PageItem*> TableID;
1171
        QMap<int,PageItem*> TableIDM;
1172
        QMap<int,PageItem*> TableIDF;
13971 jghali 1173
        QList<PageItem*> TableItems;
1174
        QList<PageItem*> TableItemsM;
1175
        QList<PageItem*> TableItemsF;
16931 fschmid 1176
        QMap<int,PageItem*> WeldID;
16926 fschmid 1177
        QList<PageItem*> WeldItems;
16105 fschmid 1178
        QStack< QList<PageItem*> > groupStack;
1179
        QStack< QList<PageItem*> > groupStackF;
1180
        QStack< QList<PageItem*> > groupStackM;
1181
        QStack< QList<PageItem*> > groupStackP;
1182
        QStack<int> groupStack2;
13971 jghali 1183
 
1184
        QString f(readSLA(fileName));
1185
        if (f.isEmpty())
14395 jghali 1186
        {
1187
                setFileReadError();
13971 jghali 1188
                return false;
14395 jghali 1189
        }
13971 jghali 1190
        QString fileDir = QFileInfo(fileName).absolutePath();
1191
        int firstPage = 0;
1192
        int layerToSetActive = 0;
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
                        firstElement = false;
1260
                }
1261
                if (tagName == "DOCUMENT")
1262
                {
1263
                        readDocAttributes(m_Doc, attrs);
1264
                        layerToSetActive = attrs.valueAsInt("ALAYER", 0);
15407 craig 1265
                        if (m_Doc->pagePositioning() == 0)
13971 jghali 1266
                                firstPage = 0;
1267
                        else
1268
                        {
1269
                                if (attrs.valueAsInt("FIRSTLEFT", 0) == 1)
1270
                                        firstPage = 0;
1271
                                else
1272
                                        firstPage = 1;
1273
                        }
1274
                        if (attrs.hasAttribute("currentProfile"))
1275
                        {
14971 cbradney 1276
                                m_Doc->clearCheckerProfiles();
1277
                                m_Doc->setCurCheckProfile(attrs.valueAsString("currentProfile"));
13971 jghali 1278
                        }
1279
                }
1280
                if (tagName == "CheckProfile")
1281
                {
1282
                        success = readCheckProfile(m_Doc, attrs);
1283
                        if (!success) break;
1284
                }
1285
                if (tagName == "PageSets")
1286
                {
1287
                        success = readPageSets(m_Doc, reader);
1288
                        if (!success) break;
1289
                        hasPageSets = true;
1290
                }
1291
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
1292
                if (tagName == "COLOR" && attrs.valueAsString("NAME") != CommonStrings::None)
1293
                {
1294
                        success = readColor(m_Doc->PageColors, attrs);
1295
                        if (!success) break;
1296
                }
14150 fschmid 1297
                if (tagName == "Gradient")
1298
                {
1299
                        VGradient gra;
1300
                        QString grName = attrs.valueAsString("Name");
1301
                        success = readGradient(m_Doc, gra, reader);
1302
                        if (!success) break;
1303
                        if (!grName.isEmpty())
1304
                        {
1305
                                m_Doc->docGradients.insert(grName, gra);
1306
                        }
1307
                }
13971 jghali 1308
                if (tagName == "STYLE")
1309
                {
16531 jghali 1310
                        readParagraphStyle(m_Doc, reader, vg);
13971 jghali 1311
                        StyleSet<ParagraphStyle>tmp;
1312
                        tmp.create(vg);
1313
                        m_Doc->redefineStyles(tmp, false);
1314
                }
1315
                if (tagName == "CHARSTYLE")
1316
                {
16531 jghali 1317
                        CharStyle cstyle;
16533 jghali 1318
                        ScXmlStreamAttributes attrs = reader.scAttributes();
1319
                        readNamedCharacterStyleAttrs(m_Doc, attrs, cstyle);
13971 jghali 1320
                        StyleSet<CharStyle> temp;
16531 jghali 1321
                        temp.create(cstyle);
13971 jghali 1322
                        m_Doc->redefineCharStyles(temp, false);
1323
                }
17318 fschmid 1324
                if (tagName == "TableStyle")
1325
                {
1326
                        TableStyle tstyle;
1327
                        readTableStyle(m_Doc, reader, tstyle);
1328
                        StyleSet<TableStyle> temp;
1329
                        temp.create(tstyle);
1330
                        m_Doc->redefineTableStyles(temp, false);
1331
                }
1332
                if (tagName == "CellStyle")
1333
                {
1334
                        CellStyle tstyle;
1335
                        readCellStyle(m_Doc, reader, tstyle);
1336
                        StyleSet<CellStyle> temp;
1337
                        temp.create(tstyle);
1338
                        m_Doc->redefineCellStyles(temp, false);
1339
                }
13971 jghali 1340
                if (tagName == "JAVA")
1341
                {
1342
                        QString name = attrs.valueAsString("NAME");
1343
                        if (!name.isEmpty())
1344
                                m_Doc->JavaScripts[name] = attrs.valueAsString("SCRIPT");
1345
                }
1346
                if (tagName == "LAYERS")
1347
                {
1348
                        ScLayer newLayer;
1349
                        readLayers(newLayer, attrs);
1350
                        m_Doc->Layers.append(newLayer);
1351
                }
1352
                if (tagName == "Arrows")
1353
                {
1354
                        success = readArrows(m_Doc, attrs);
1355
                        if (!success) break;
1356
                }
1357
                if (tagName == "MultiLine")
1358
                {
1359
                        multiLine ml;
1360
                        QString mlName = attrs.valueAsString("Name");
1361
                        success = readMultiline(ml, reader);
1362
                        if (!success) break;
1363
                        if (!mlName.isEmpty())
1364
                        {
1365
                                m_Doc->MLineStyles.insert(mlName, ml);
1366
                        }
1367
                }
1368
                if (tagName == "Bookmark")
1369
                {
1370
                        int bmElem = 0;
1371
                        struct ScribusDoc::BookMa bookmark;
1372
                        success = readBookMark(bookmark, bmElem, attrs);
1373
                        if (!success) break;
1374
                        bookmarks.insert(bmElem, bookmark);
1375
                }
1376
                if (tagName == "PDF")
1377
                {
1378
                        success = readPDFOptions(m_Doc, reader);
1379
                        if (!success) break;
1380
                }
1381
                if (tagName == "Printer")
1382
                {
1383
                        success = readPrinterOptions(m_Doc, reader);
1384
                        if (!success) break;
1385
                }
1386
                if (tagName == "DocItemAttributes")
1387
                {
1388
                        success = readDocItemAttributes(m_Doc, reader);
1389
                        if (!success) break;
1390
                }
1391
                if (tagName == "TablesOfContents")
1392
                {
1393
                        success = readTableOfContents(m_Doc, reader);
1394
                        if (!success) break;
1395
                }
1396
                if (tagName == "Sections")
1397
                {
1398
                        success = readSections(m_Doc, reader);
1399
                        if (!success) break;
1400
                }
1401
                if (tagName == "HYPHEN")
1402
                {
1403
                        success = readHyphen(m_Doc, reader);
1404
                        if (!success) break;
1405
                }
1406
                if (tagName == "PAGE" || tagName == "MASTERPAGE")
1407
                {
1408
                        success = readPage(m_Doc, reader);
16105 fschmid 1409
                        if (!success)
1410
                                break;
13971 jghali 1411
                }
1412
                if (tagName == "PAGEOBJECT" || tagName == "MASTEROBJECT" || tagName == "FRAMEOBJECT")
1413
                {
1414
                        ItemInfo itemInfo;
1415
                        success = readObject(m_Doc, reader, itemInfo, fileDir, false);
16105 fschmid 1416
                        if (!success)
1417
                                break;
13971 jghali 1418
 
1419
                        // first of linked chain?
16943 fschmid 1420
                        if (isNewFormat)
13971 jghali 1421
                        {
1422
                                if (itemInfo.nextItem != -1)
16943 fschmid 1423
                                        itemNext[itemInfo.itemID] = itemInfo.nextItem;
1424
                                if (itemInfo.item->isTableItem)
1425
                                        TableItems.append(itemInfo.item);
1426
                                if (itemInfo.isWeldFlag)
1427
                                        WeldItems.append(itemInfo.item);
13971 jghali 1428
                        }
16943 fschmid 1429
                        else
13971 jghali 1430
                        {
1431
                                if (tagName == "PAGEOBJECT")
1432
                                {
16943 fschmid 1433
                                        if (itemInfo.nextItem != -1)
1434
                                                itemNext[itemInfo.ownNr] = itemInfo.nextItem;
13971 jghali 1435
                                }
16943 fschmid 1436
                                else if (tagName == "MASTEROBJECT")
13971 jghali 1437
                                {
16943 fschmid 1438
                                        if (itemInfo.nextItem != -1)
1439
                                                itemNextM[itemInfo.ownNr] = itemInfo.nextItem;
13971 jghali 1440
                                }
16943 fschmid 1441
                                if (itemInfo.item->isTableItem)
13971 jghali 1442
                                {
16943 fschmid 1443
                                        if (tagName == "PAGEOBJECT")
1444
                                        {
1445
                                                TableItems.append(itemInfo.item);
1446
                                                TableID.insert(itemInfo.ownLink, itemInfo.item);
1447
                                        }
1448
                                        else if (tagName == "FRAMEOBJECT")
1449
                                        {
1450
                                                TableItemsF.append(itemInfo.item);
1451
                                                TableIDF.insert(itemInfo.ownLink, itemInfo.item);
1452
                                        }
1453
                                        else
1454
                                        {
1455
                                                TableItemsM.append(itemInfo.item);
1456
                                                TableIDM.insert(itemInfo.ownLink, itemInfo.item);
1457
                                        }
13971 jghali 1458
                                }
16943 fschmid 1459
 
1460
                                if (itemInfo.isWeldFlag)
1461
                                {
1462
                                        WeldItems.append(itemInfo.item);
1463
                                        WeldID.insert(itemInfo.ownWeld, itemInfo.item);
1464
                                }
13971 jghali 1465
                        }
16105 fschmid 1466
                        if (groupStack.count() > 0)
13971 jghali 1467
                        {
16105 fschmid 1468
                                groupStack.top().append(itemInfo.item);
16943 fschmid 1469
                                while (static_cast<int>(itemInfo.ownNr) == groupStack2.top())
16105 fschmid 1470
                                {
1471
                                        if (tagName == "PAGEOBJECT")
1472
                                                groupStackP.push(groupStack.pop());
1473
                                        else if (tagName == "FRAMEOBJECT")
1474
                                                groupStackF.push(groupStack.pop());
1475
                                        else
1476
                                                groupStackM.push(groupStack.pop());
1477
                                        groupStack2.pop();
16233 fschmid 1478
                                        if (groupStack2.count() == 0)
1479
                                                break;
16105 fschmid 1480
                                }
13971 jghali 1481
                        }
16113 fschmid 1482
                        if (itemInfo.isGroupFlag)
16105 fschmid 1483
                        {
1484
                                QList<PageItem*> GroupItems;
1485
                                GroupItems.append(itemInfo.item);
1486
                                groupStack.push(GroupItems);
16943 fschmid 1487
                                groupStack2.push(itemInfo.groupLastItem + itemInfo.ownNr);
16105 fschmid 1488
                        }
13971 jghali 1489
                }
1490
                if (tagName == "Pattern")
1491
                {
1492
                        success = readPattern(m_Doc, reader, fileDir);
16105 fschmid 1493
                        if (!success)
1494
                                break;
13971 jghali 1495
                }
1496
        }
1497
 
1498
        if (reader.hasError())
14392 jghali 1499
        {
1500
                setDomParsingError(reader.errorString(), reader.lineNumber(), reader.columnNumber());
13971 jghali 1501
                return false;
14392 jghali 1502
        }
13971 jghali 1503
 
1504
        QMap<int, ScribusDoc::BookMa>::Iterator it;
1505
        for (it = bookmarks.begin(); it != bookmarks.end(); ++it)
1506
        {
1507
                int elem = it.key();
1508
                if (elem < m_Doc->Items->count())
1509
                {
1510
                        ScribusDoc::BookMa bookmark = it.value();
1511
                        bookmark.PageObject = m_Doc->Items->at(elem);
1512
                        m_Doc->BookMarks.append( bookmark );
1513
                }
1514
        }
1515
 
16943 fschmid 1516
        if (isNewFormat)
13971 jghali 1517
        {
16943 fschmid 1518
                if (TableItems.count() != 0)
13971 jghali 1519
                {
16943 fschmid 1520
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
1521
                        {
1522
                                PageItem* ta = TableItems.at(ttc);
1523
                                if (ta->TopLinkID != -1)
1524
                                        ta->TopLink = LinkID[ta->TopLinkID];
1525
                                else
1526
                                        ta->TopLink = 0;
1527
                                if (ta->LeftLinkID != -1)
1528
                                        ta->LeftLink = LinkID[ta->LeftLinkID];
1529
                                else
1530
                                        ta->LeftLink = 0;
1531
                                if (ta->RightLinkID != -1)
1532
                                        ta->RightLink = LinkID[ta->RightLinkID];
1533
                                else
1534
                                        ta->RightLink = 0;
1535
                                if (ta->BottomLinkID != -1)
1536
                                        ta->BottomLink = LinkID[ta->BottomLinkID];
1537
                                else
1538
                                        ta->BottomLink = 0;
1539
                        }
13971 jghali 1540
                }
16943 fschmid 1541
                if (WeldItems.count() != 0)
13971 jghali 1542
                {
16943 fschmid 1543
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
1544
                        {
1545
                                PageItem* ta = WeldItems.at(ttc);
17745 jghali 1546
                                for (int i = 0 ; i < ta->weldList.count(); ++i)
16943 fschmid 1547
                                {
1548
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
17745 jghali 1549
                                        ta->weldList[i].weldItem = LinkID.value(wInf.weldID, 0);
1550
                                        if (ta->weldList[i].weldItem == NULL)
1551
                                                ta->weldList.removeAt(i--);
16943 fschmid 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);
17745 jghali 1650
                                for (int i = 0 ; i < ta->weldList.count(); ++i)
16943 fschmid 1651
                                {
1652
                                        PageItem::weldingInfo wInf = ta->weldList.at(i);
17745 jghali 1653
                                        ta->weldList[i].weldItem = WeldID.value(wInf.weldID, 0);
1654
                                        if (ta->weldList[i].weldItem == NULL)
1655
                                                ta->weldList.removeAt(i--);
16943 fschmid 1656
                                }
1657
                        }
1658
                }
1659
                if (itemNext.count() != 0)
1660
                {
1661
                        QMap<int,int>::Iterator lc;
1662
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
1663
                        {
1664
                                if (lc.value() >= 0)
1665
                                {
1666
                                        PageItem * Its = m_Doc->DocItems.at(lc.key());
1667
                                        PageItem * Itn = m_Doc->DocItems.at(lc.value());
1668
                                        if (!Its->testLinkCandidate(Itn))
1669
                                        {
1670
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1671
                                                continue;
1672
                                        }
1673
                                        Its->link(Itn);
1674
                                }
1675
                        }
1676
                }
1677
                if (itemNextM.count() != 0)
1678
                {
1679
                        QMap<int,int>::Iterator lc;
1680
                        for (lc = itemNextM.begin(); lc != itemNextM.end(); ++lc)
1681
                        {
1682
                                if (lc.value() >= 0)
1683
                                {
1684
                                        PageItem * Its = m_Doc->MasterItems.at(lc.key());
1685
                                        PageItem * Itn = m_Doc->MasterItems.at(lc.value());
1686
                                        if (!Its->testLinkCandidate(Itn))
1687
                                        {
1688
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1689
                                                continue;
1690
                                        }
1691
                                        Its->link(Itn);
1692
                                }
1693
                        }
1694
                }
16926 fschmid 1695
        }
13971 jghali 1696
        //CB Add this in to set this in the file in memory. Its saved, why not load it.
1697
        //Will of course be replaced by per page settings although we still probably need a document default
1698
        if (!hasPageSets)
1699
        {
15407 craig 1700
                m_Doc->setPageSetFirstPage(m_Doc->pagePositioning(), firstPage);
14924 cbradney 1701
//->Prefs               m_Doc->pageSets[m_Doc->currentPageLayout].FirstPage = firstPage;
13971 jghali 1702
//              m_Doc->pageSets[m_Doc->currentPageLayout].GapHorizontal = dc.attribute("GapHorizontal", "0").toDouble();
1703
//              m_Doc->pageSets[m_Doc->currentPageLayout].GapVertical = 0.0;
1704
//              m_Doc->pageSets[m_Doc->currentPageLayout].GapBelow = dc.attribute("GapVertical", "40").toDouble();
1705
        }
1706
        m_Doc->setActiveLayer(layerToSetActive);
1707
        m_Doc->setMasterPageMode(false);
1708
        m_Doc->reformPages();
17338 jghali 1709
        m_Doc->refreshGuides();
13971 jghali 1710
 
1711
        if (m_Doc->Layers.count() == 0)
1712
                m_Doc->Layers.newLayer( QObject::tr("Background") );
1713
 
16105 fschmid 1714
        if (groupStackP.count() > 0)
1715
        {
1716
                while (groupStackP.count() > 0)
1717
                {
17417 fschmid 1718
                        bool isTableIt = false;
16105 fschmid 1719
                        QList<PageItem*> gpL = groupStackP.pop();
1720
                        PageItem* gItem = gpL.takeFirst();
1721
                        for (int id = 0; id < gpL.count(); id++)
1722
                        {
1723
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1724
                                isTableIt = cItem->isTableItem;
16105 fschmid 1725
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1726
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1727
                                cItem->Parent = gItem;
16105 fschmid 1728
                                if (gItem->rotation() != 0)
1729
                                {
1730
                                        QTransform ma;
1731
                                        ma.rotate(-gItem->rotation());
1732
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1733
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1734
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1735
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1736
                                }
1737
                                m_Doc->DocItems.removeOne(cItem);
1738
                        }
17417 fschmid 1739
                        if (isTableIt)
1740
                                convertOldTable(m_Doc, gItem, gpL, &groupStackP, &m_Doc->DocItems);
1741
                        else
1742
                                gItem->groupItemList = gpL;
16105 fschmid 1743
                }
1744
        }
1745
        if (groupStackF.count() > 0)
1746
        {
1747
                while (groupStackF.count() > 0)
1748
                {
17417 fschmid 1749
                        bool isTableIt = false;
16105 fschmid 1750
                        QList<PageItem*> gpL = groupStackF.pop();
1751
                        PageItem* gItem = gpL.takeFirst();
1752
                        for (int id = 0; id < gpL.count(); id++)
1753
                        {
1754
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1755
                                isTableIt = cItem->isTableItem;
16105 fschmid 1756
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1757
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1758
                                cItem->Parent = gItem;
16105 fschmid 1759
                                if (gItem->rotation() != 0)
1760
                                {
1761
                                        QTransform ma;
1762
                                        ma.rotate(-gItem->rotation());
1763
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1764
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1765
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1766
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1767
                                }
17407 fschmid 1768
                                m_Doc->FrameItems.remove(m_Doc->FrameItems.key(cItem));
16105 fschmid 1769
                        }
17417 fschmid 1770
                        if (isTableIt)
1771
                                convertOldTable(m_Doc, gItem, gpL, &groupStackF, NULL);
1772
                        else
1773
                                gItem->groupItemList = gpL;
16105 fschmid 1774
                }
1775
        }
1776
        if (groupStackM.count() > 0)
1777
        {
1778
                while (groupStackM.count() > 0)
1779
                {
17417 fschmid 1780
                        bool isTableIt = false;
16105 fschmid 1781
                        QList<PageItem*> gpL = groupStackM.pop();
1782
                        PageItem* gItem = gpL.takeFirst();
1783
                        for (int id = 0; id < gpL.count(); id++)
1784
                        {
1785
                                PageItem* cItem = gpL.at(id);
17417 fschmid 1786
                                isTableIt = cItem->isTableItem;
16105 fschmid 1787
                                cItem->gXpos = cItem->xPos() - gItem->xPos();
1788
                                cItem->gYpos = cItem->yPos() - gItem->yPos();
16943 fschmid 1789
                                cItem->Parent = gItem;
16105 fschmid 1790
                                if (gItem->rotation() != 0)
1791
                                {
1792
                                        QTransform ma;
1793
                                        ma.rotate(-gItem->rotation());
1794
                                        FPoint n = FPoint(cItem->gXpos, cItem->gYpos);
1795
                                        cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1796
                                        cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1797
                                        cItem->setRotation(cItem->rotation() - gItem->rotation());
1798
                                }
1799
                                m_Doc->MasterItems.removeOne(cItem);
1800
                        }
17417 fschmid 1801
                        if (isTableIt)
1802
                                convertOldTable(m_Doc, gItem, gpL, &groupStackM, &m_Doc->MasterItems);
1803
                        else
1804
                                gItem->groupItemList = gpL;
16105 fschmid 1805
                }
1806
        }
13971 jghali 1807
 
1808
        // reestablish first/lastAuto
1809
        m_Doc->FirstAuto = m_Doc->LastAuto;
1810
        if (m_Doc->LastAuto)
1811
        {
1812
                while (m_Doc->LastAuto->nextInChain())
1813
                        m_Doc->LastAuto = m_Doc->LastAuto->nextInChain();
1814
                while (m_Doc->FirstAuto->prevInChain())
1815
                        m_Doc->FirstAuto = m_Doc->FirstAuto->prevInChain();
1816
        }
1817
 
1818
        // start auto save timer if needed
14925 cbradney 1819
        if (m_Doc->autoSave()  && ScCore->usingGUI())
1820
                m_Doc->autoSaveTimer->start(m_Doc->autoSaveTime());
13971 jghali 1821
 
1822
        if (m_mwProgressBar!=0)
1823
                m_mwProgressBar->setValue(reader.characterOffset());
1824
        return true;
1825
}
1826
 
1827
// Low level plugin API
1828
int scribus150format_getPluginAPIVersion()
1829
{
1830
        return PLUGIN_API_VERSION;
1831
}
1832
 
1833
ScPlugin* scribus150format_getPlugin()
1834
{
1835
        Scribus150Format* plug = new Scribus150Format();
1836
        Q_CHECK_PTR(plug);
1837
        return plug;
1838
}
1839
 
1840
void scribus150format_freePlugin(ScPlugin* plugin)
1841
{
1842
        Scribus150Format* plug = dynamic_cast<Scribus150Format*>(plugin);
1843
        Q_ASSERT(plug);
1844
        delete plug;
1845
}
1846
 
1847
 
1848
namespace {
1849
        const int NOVALUE = -16000;
1850
 
1851
        void fixLegacyCharStyle(CharStyle& cstyle)
1852
        {
1853
                if (! cstyle.font().usable())
1854
                        cstyle.resetFont();
1855
                if (cstyle.fontSize() <= -16000 / 10)
1856
                        cstyle.resetFontSize();
1857
//              if (cstyle.effects() == 65535)
1858
//                      cstyle.resetEffects();
1859
                if (cstyle.fillColor().isEmpty())
1860
                        cstyle.resetFillColor();
1861
                if (cstyle.fillShade() <= -16000)
1862
                        cstyle.resetFillShade();
1863
                if (cstyle.strokeColor().isEmpty())
1864
                        cstyle.resetStrokeColor();
1865
                if (cstyle.strokeShade() <= -16000)
1866
                        cstyle.resetStrokeShade();
1867
                if (cstyle.shadowXOffset() <= -16000 / 10)
1868
                        cstyle.resetShadowXOffset();
1869
                if (cstyle.shadowYOffset() <= -16000 / 10)
1870
                        cstyle.resetShadowYOffset();
1871
                if (cstyle.outlineWidth() <= -16000 / 10)
1872
                        cstyle.resetOutlineWidth();
1873
                if (cstyle.underlineOffset() <= -16000 / 10)
1874
                        cstyle.resetUnderlineOffset();
1875
                if (cstyle.underlineWidth() <= -16000 / 10)
1876
                        cstyle.resetUnderlineWidth();
1877
                if (cstyle.strikethruOffset() <= -16000 / 10)
1878
                        cstyle.resetStrikethruOffset();
1879
                if (cstyle.strikethruWidth() <= -16000 / 10)
1880
                        cstyle.resetStrikethruWidth();
1881
                if (cstyle.scaleH() <= -16000 / 10)
1882
                        cstyle.resetScaleH();
1883
                if (cstyle.scaleV() <= -16000 / 10)
1884
                        cstyle.resetScaleV();
1885
                if (cstyle.baselineOffset() <= -16000 / 10)
1886
                        cstyle.resetBaselineOffset();
1887
                if (cstyle.tracking() <= -16000 / 10)
1888
                        cstyle.resetTracking();
1889
        }
1890
 
1891
        void fixLegacyParStyle(ParagraphStyle& pstyle)
1892
        {
1893
                if (pstyle.lineSpacing() <= -16000)
1894
                        pstyle.resetLineSpacing();
1895
                if (pstyle.leftMargin() <= -16000)
1896
                        pstyle.resetLeftMargin();
1897
                if (pstyle.rightMargin() <= -16000)
1898
                        pstyle.resetRightMargin();
1899
                if (pstyle.firstIndent() <= -16000)
1900
                        pstyle.resetFirstIndent();
1901
                if (pstyle.alignment() < 0)
1902
                        pstyle.resetAlignment();
1903
                if (pstyle.gapBefore() <= -16000)
1904
                        pstyle.resetGapBefore();
1905
                if (pstyle.gapAfter() <= -16000)
1906
                        pstyle.resetGapAfter();
1907
                if (pstyle.dropCapLines() < 0)
1908
                        pstyle.resetDropCapLines();
1909
                if (pstyle.dropCapOffset() <= -16000)
1910
                        pstyle.resetDropCapOffset();
1911
                fixLegacyCharStyle(pstyle.charStyle());
1912
        }
1913
 
1914
}// namespace
1915
 
1916
void Scribus150Format::readDocAttributes(ScribusDoc* doc, ScXmlStreamAttributes& attrs)
1917
{
14991 cbradney 1918
        m_Doc->setPageSize(attrs.valueAsString("PAGESIZE"));
1919
        m_Doc->setPageOrientation(attrs.valueAsInt("ORIENTATION", 0));
13971 jghali 1920
        m_Doc->FirstPnum  = attrs.valueAsInt("FIRSTNUM", 1);
15407 craig 1921
        m_Doc->setPagePositioning(attrs.valueAsInt("BOOK", 0));
13971 jghali 1922
 
1923
        m_Doc->setUsesAutomaticTextFrames( attrs.valueAsInt("AUTOTEXT") );
1924
        m_Doc->PageSp  = attrs.valueAsInt("AUTOSPALTEN");
1925
        m_Doc->PageSpa = attrs.valueAsDouble("ABSTSPALTEN");
1926
        m_Doc->setUnitIndex( attrs.valueAsInt("UNITS", 0) );
1927
 
17501 craig 1928
        m_Doc->setHyphLanguage(attrs.valueAsString("LANGUAGE", "en_US"));
14924 cbradney 1929
        m_Doc->setHyphMinimumWordLength(attrs.valueAsInt("MINWORDLEN", 3));
1930
        m_Doc->setHyphConsecutiveLines(attrs.valueAsInt("HYCOUNT", 2));
13971 jghali 1931
 
1932
        if (attrs.hasAttribute("PAGEWIDTH"))
14991 cbradney 1933
                m_Doc->setPageWidth(attrs.valueAsDouble("PAGEWIDTH"));
13971 jghali 1934
        else
14991 cbradney 1935
                m_Doc->setPageWidth(attrs.valueAsDouble("PAGEWITH"));
1936
        m_Doc->setPageHeight(attrs.valueAsDouble("PAGEHEIGHT"));
14994 cbradney 1937
        m_Doc->margins()->Left  = qMax(0.0, attrs.valueAsDouble("BORDERLEFT"));
1938
        m_Doc->margins()->Right = qMax(0.0, attrs.valueAsDouble("BORDERRIGHT"));
1939
        m_Doc->margins()->Top   = qMax(0.0, attrs.valueAsDouble("BORDERTOP"));
1940
        m_Doc->margins()->Bottom= qMax(0.0, attrs.valueAsDouble("BORDERBOTTOM"));
14992 cbradney 1941
        m_Doc->setMarginPreset(attrs.valueAsInt("PRESET", 0));
1942
        m_Doc->bleeds()->Top    = attrs.valueAsDouble("BleedTop", 0.0);
1943
        m_Doc->bleeds()->Left   = attrs.valueAsDouble("BleedLeft", 0.0);
1944
        m_Doc->bleeds()->Right  = attrs.valueAsDouble("BleedRight", 0.0);
1945
        m_Doc->bleeds()->Bottom = attrs.valueAsDouble("BleedBottom", 0.0);
14924 cbradney 1946
        m_Doc->setHyphAutomatic(attrs.valueAsBool("AUTOMATIC", true));
1947
        m_Doc->setHyphAutoCheck(attrs.valueAsBool("AUTOCHECK", false));
13971 jghali 1948
        m_Doc->GuideLock = attrs.valueAsBool("GUIDELOCK", false);
1949
 
1950
        m_Doc->rulerXoffset = attrs.valueAsDouble("rulerXoffset", 0.0);
1951
        m_Doc->rulerYoffset = attrs.valueAsDouble("rulerYoffset", 0.0);
1952
        m_Doc->SnapGuides   = attrs.valueAsBool("SnapToGuides", false);
17744 craig 1953
        m_Doc->SnapElement  = attrs.valueAsBool("SnapToElement", false);
13971 jghali 1954
        m_Doc->useRaster    = attrs.valueAsBool("SnapToGrid", false);
1955
 
14925 cbradney 1956
        m_Doc->setAutoSave(attrs.valueAsBool("AutoSave", false));
1957
        m_Doc->setAutoSaveTime(attrs.valueAsInt("AutoSaveTime", 600000));
14924 cbradney 1958
        double leftScratch;
13971 jghali 1959
        // FIXME A typo in early 1.3cvs (MAR 05) means we must support loading of
1960
        // FIXME 'ScatchLeft' for a while too. This can be removed in a few months.
1961
        if (attrs.hasAttribute("ScatchLeft"))
14924 cbradney 1962
                leftScratch = attrs.valueAsDouble("ScatchLeft", 100.0);
13971 jghali 1963
        else
14924 cbradney 1964
                leftScratch = attrs.valueAsDouble("ScratchLeft", 100.0);
1965
        m_Doc->scratch()->set(attrs.valueAsDouble("ScratchTop", 20.0), leftScratch,
1966
                                                  attrs.valueAsDouble("ScratchBottom", 20.0),attrs.valueAsDouble("ScratchRight", 100.0));
1967
        m_Doc->setPageGapHorizontal(attrs.valueAsDouble("GapHorizontal", -1.0));
1968
        m_Doc->setPageGapVertical(attrs.valueAsDouble("GapVertical", -1.0));
13971 jghali 1969
 
1970
        if (attrs.hasAttribute("PAGEC"))
14924 cbradney 1971
                m_Doc->setPaperColor(QColor(attrs.valueAsString("PAGEC")));
1972
                //->Prefs m_Doc->papColor = QColor(attrs.valueAsString("PAGEC"));
13971 jghali 1973
 
14971 cbradney 1974
        m_Doc->setMarginColored(attrs.valueAsBool("RANDF", false));
13971 jghali 1975
 
1976
        readCMSSettings(doc, attrs);
1977
        readDocumentInfo(doc, attrs);
1978
        readGuideSettings(doc, attrs);
1979
        readToolSettings(doc, attrs);
1980
        readTypographicSettings(doc, attrs);
1981
}
1982
 
1983
void Scribus150Format::readCMSSettings(ScribusDoc* doc, ScXmlStreamAttributes& attrs)
1984
{
15001 cbradney 1985
        doc->cmsSettings().SoftProofOn     = attrs.valueAsBool("DPSo", false);
1986
        doc->cmsSettings().SoftProofFullOn = attrs.valueAsBool("DPSFo", false);
1987
        doc->cmsSettings().CMSinUse   = attrs.valueAsBool("DPuse", false);
1988
        doc->cmsSettings().GamutCheck = attrs.valueAsBool("DPgam", false);
1989
        doc->cmsSettings().BlackPoint = attrs.valueAsBool("DPbla", true);
1990
        doc->cmsSettings().DefaultMonitorProfile   = attrs.valueAsString("DPMo","");
1991
        doc->cmsSettings().DefaultPrinterProfile   = attrs.valueAsString("DPPr","");
1992
        doc->cmsSettings().DefaultImageRGBProfile  = attrs.valueAsString("DPIn","");
1993
        doc->cmsSettings().DefaultImageCMYKProfile = attrs.valueAsString("DPInCMYK","");
1994
        doc->cmsSettings().DefaultSolidColorRGBProfile = attrs.valueAsString("DPIn2","");
13971 jghali 1995
        if (attrs.hasAttribute("DPIn3"))
15001 cbradney 1996
                doc->cmsSettings().DefaultSolidColorCMYKProfile = attrs.valueAsString("DPIn3","");
13971 jghali 1997
        else
15001 cbradney 1998
                doc->cmsSettings().DefaultSolidColorCMYKProfile = attrs.valueAsString("DPPr","");
1999
        doc->cmsSettings().DefaultIntentColors = (eRenderIntent) attrs.valueAsInt("DISc", 1);
2000
        doc->cmsSettings().DefaultIntentImages = (eRenderIntent) attrs.valueAsInt("DIIm", 0);
13971 jghali 2001
}
2002
 
2003
void Scribus150Format::readDocumentInfo(ScribusDoc* doc, ScXmlStreamAttributes& attrs)
2004
{
15037 cbradney 2005
        DocumentInformation di;
2006
        di.setAuthor(attrs.valueAsString("AUTHOR"));
2007
        di.setComments(attrs.valueAsString("COMMENTS"));
2008
        di.setKeywords(attrs.valueAsString("KEYWORDS",""));
2009
        di.setTitle(attrs.valueAsString("TITLE"));
2010
        di.setSubject(attrs.valueAsString("SUBJECT"));
2011
        di.setPublisher(attrs.valueAsString("PUBLISHER", ""));
2012
        di.setDate(attrs.valueAsString("DOCDATE", ""));
2013
        di.setType(attrs.valueAsString("DOCTYPE", ""));
2014
        di.setFormat(attrs.valueAsString("DOCFORMAT", ""));
2015
        di.setIdent(attrs.valueAsString("DOCIDENT", ""));
2016
        di.setSource(attrs.valueAsString("DOCSOURCE", ""));
2017
        di.setLangInfo(attrs.valueAsString("DOCLANGINFO", ""));
2018
        di.setRelation(attrs.valueAsString("DOCRELATION", ""));
2019
        di.setCover(attrs.valueAsString("DOCCOVER", ""));
2020
        di.setRights(attrs.valueAsString("DOCRIGHTS", ""));
2021
        di.setContrib(attrs.valueAsString("DOCCONTRIB", ""));
2022
        doc->setDocumentInfo(di);
13971 jghali 2023
}
2024
 
2025
void Scribus150Format::readGuideSettings(ScribusDoc* doc, ScXmlStreamAttributes& attrs)
2026
{
2027
        PrefsManager* prefsManager = PrefsManager::instance();
14932 cbradney 2028
        doc->guidesPrefs().minorGridSpacing = attrs.valueAsDouble("MINGRID", prefsManager->appPrefs.guidesPrefs.minorGridSpacing);
2029
        doc->guidesPrefs().majorGridSpacing = attrs.valueAsDouble("MAJGRID", prefsManager->appPrefs.guidesPrefs.majorGridSpacing);
2030
        doc->guidesPrefs().gridShown    = attrs.valueAsBool("SHOWGRID", false);
2031
        doc->guidesPrefs().guidesShown  =attrs.valueAsBool("SHOWGUIDES", true);
2032
        doc->guidesPrefs().colBordersShown  = attrs.valueAsBool("showcolborders", false);
2033
        doc->guidesPrefs().framesShown  = attrs.valueAsBool("SHOWFRAME", true);
2034
        doc->guidesPrefs().layerMarkersShown = attrs.valueAsBool("SHOWLAYERM", false);
2035
        doc->guidesPrefs().marginsShown = attrs.valueAsBool("SHOWMARGIN", true);
2036
        doc->guidesPrefs().baselineGridShown    = attrs.valueAsBool("SHOWBASE", false);
2037
        doc->guidesPrefs().showPic      = attrs.valueAsBool("SHOWPICT", true);
2038
        doc->guidesPrefs().linkShown    = attrs.valueAsBool("SHOWLINK", false);
2039
        doc->guidesPrefs().showControls = attrs.valueAsBool("SHOWControl", false);
2040
        doc->guidesPrefs().rulerMode    = attrs.valueAsBool("rulerMode", true);
2041
        doc->guidesPrefs().rulersShown  = attrs.valueAsBool("showrulers", true);
2042
        doc->guidesPrefs().showBleed    = attrs.valueAsBool("showBleed", true);
13971 jghali 2043
        if (attrs.hasAttribute("MARGC"))
14932 cbradney 2044
                doc->guidesPrefs().marginColor  = QColor(attrs.valueAsString("MARGC"));
13971 jghali 2045
        if (attrs.hasAttribute("MINORC"))
14932 cbradney 2046
                doc->guidesPrefs().minorGridColor = QColor(attrs.valueAsString("MINORC"));
13971 jghali 2047
        if (attrs.hasAttribute("MAJORC"))
14932 cbradney 2048
                doc->guidesPrefs().majorGridColor = QColor(attrs.valueAsString("MAJORC"));
13971 jghali 2049
        if (attrs.hasAttribute("GuideC"))
14932 cbradney 2050
                doc->guidesPrefs().guideColor = QColor(attrs.valueAsString("GuideC"));
13971 jghali 2051
        if (attrs.hasAttribute("BaseC"))
14932 cbradney 2052
                doc->guidesPrefs().baselineGridColor  = QColor(attrs.valueAsString("BaseC"));
16990 fschmid 2053
        if (attrs.hasAttribute("BACKG"))
2054
        {
2055