Subversion Repositories Scribus

Rev

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