Subversion Repositories Scribus

Rev

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