Subversion Repositories Scribus

Rev

Rev 25248 | 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;
25188 craig 323
                QString tagName(reader.nameAsString());
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;
25195 jghali 342
                        continue;
16105 fschmid 343
                }
25195 jghali 344
 
16105 fschmid 345
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
24849 jghali 346
                if (tagName == QLatin1String("COLOR") && attrs.valueAsString("NAME") != CommonStrings::None)
24307 jghali 347
                {
348
                        QString colorName = attrs.valueAsString("NAME");
349
                        if (m_Doc->PageColors.contains(colorName))
350
                                continue;
21984 craig 351
                        readColor(m_Doc->PageColors, attrs);
24307 jghali 352
                }
25190 jghali 353
                else if (tagName == QLatin1String("Gradient"))
16105 fschmid 354
                {
355
                        VGradient gra;
356
                        QString grName = attrs.valueAsString("Name");
357
                        success = readGradient(m_Doc, gra, reader);
19103 fschmid 358
                        if (!success)
359
                                break;
360
                        gra.setRepeatMethod((VGradient::VGradientRepeatMethod)(attrs.valueAsInt("Ext", VGradient::pad)));
24307 jghali 361
                        if (!grName.isEmpty() && !m_Doc->docGradients.contains(grName))
16105 fschmid 362
                                m_Doc->docGradients.insert(grName, gra);
363
                }
25190 jghali 364
                else if (tagName == QLatin1String("STYLE"))
16105 fschmid 365
                {
24307 jghali 366
                        ParagraphStyle pstyle;
367
                        getStyle(pstyle, reader, nullptr, m_Doc, true);
16105 fschmid 368
                }
25190 jghali 369
                else if (tagName == QLatin1String("CHARSTYLE"))
16105 fschmid 370
                {
19544 jghali 371
                        CharStyle cstyle;
24307 jghali 372
                        getStyle(cstyle, reader, nullptr, m_Doc, true);
16105 fschmid 373
                }
25190 jghali 374
                else if (tagName == QLatin1String("TableStyle"))
17318 fschmid 375
                {
376
                        TableStyle tstyle;
377
                        readTableStyle(m_Doc, reader, tstyle);
24307 jghali 378
                        // FIXME: import style under new name if existing
379
                        // Do not break current doc for now
380
                        if (m_Doc->tableStyles().contains(tstyle.name()))
381
                                continue;
17318 fschmid 382
                        StyleSet<TableStyle> temp;
383
                        temp.create(tstyle);
384
                        m_Doc->redefineTableStyles(temp, false);
385
                }
25190 jghali 386
                else if (tagName == QLatin1String("CellStyle"))
17318 fschmid 387
                {
388
                        CellStyle tstyle;
389
                        readCellStyle(m_Doc, reader, tstyle);
24307 jghali 390
                        // FIXME: import style under new name if existing
391
                        // Do not break current doc for now
392
                        if (m_Doc->cellStyles().contains(tstyle.name()))
393
                                continue;
17318 fschmid 394
                        StyleSet<CellStyle> temp;
395
                        temp.create(tstyle);
396
                        m_Doc->redefineCellStyles(temp, false);
397
                }
25190 jghali 398
                else if (tagName == QLatin1String("Arrows"))
16105 fschmid 399
                {
400
                        success = readArrows(m_Doc, attrs);
401
                        if (!success) break;
402
                }
25190 jghali 403
                else if (tagName == QLatin1String("MultiLine"))
16105 fschmid 404
                {
405
                        multiLine ml;
406
                        QString mlName = attrs.valueAsString("Name");
407
                        success = readMultiline(ml, reader);
24307 jghali 408
                        if (!success)
409
                                break;
410
                        if (!mlName.isEmpty() && !m_Doc->docLineStyles.contains(mlName))
23707 jghali 411
                                m_Doc->docLineStyles.insert(mlName, ml);
16105 fschmid 412
                }
25190 jghali 413
                else if ((tagName == QLatin1String("ITEM")) || (tagName == QLatin1String("PAGEOBJECT")) || (tagName == QLatin1String("FRAMEOBJECT")))
16105 fschmid 414
                {
415
                        ItemInfo itemInfo;
23616 jghali 416
                        success = readObject(m_Doc, reader, readObjectParams, itemInfo);
16105 fschmid 417
                        if (!success)
418
                                break;
22832 craig 419
                        itemInfo.item->m_layerID = LayerToPaste;
16943 fschmid 420
                        if (isNewFormat)
16105 fschmid 421
                        {
422
                                if (itemInfo.nextItem != -1)
16943 fschmid 423
                                        itemNext[itemInfo.itemID] = itemInfo.nextItem;
424
                                if (itemInfo.item->isTableItem)
425
                                        TableItems.append(itemInfo.item);
426
                                if (itemInfo.isWeldFlag)
427
                                        WeldItems.append(itemInfo.item);
16105 fschmid 428
                        }
16943 fschmid 429
                        else
16105 fschmid 430
                        {
16943 fschmid 431
                        // first of linked chain?
24849 jghali 432
                                if (tagName == QLatin1String("ITEM"))
16105 fschmid 433
                                {
16943 fschmid 434
                                        if (itemInfo.nextItem != -1)
435
                                                itemNext[itemInfo.ownNr] = itemInfo.nextItem;
16105 fschmid 436
                                }
16943 fschmid 437
                                if (itemInfo.item->isTableItem)
16926 fschmid 438
                                {
24849 jghali 439
                                        if (tagName == QLatin1String("ITEM"))
16943 fschmid 440
                                        {
441
                                                TableItems.append(itemInfo.item);
442
                                                TableID.insert(itemInfo.ownLink, itemInfo.item);
443
                                        }
16926 fschmid 444
                                }
16943 fschmid 445
                                if (itemInfo.isWeldFlag)
446
                                {
24849 jghali 447
                                        if (tagName == QLatin1String("ITEM"))
16943 fschmid 448
                                        {
449
                                                WeldItems.append(itemInfo.item);
450
                                                WeldID.insert(itemInfo.ownWeld, itemInfo.item);
451
                                        }
452
                                }
16926 fschmid 453
                        }
23458 jghali 454
 
24849 jghali 455
                        if ((tagName == QLatin1String("PAGEOBJECT")) && (groupStackPI.count() > 0))
16105 fschmid 456
                        {
23458 jghali 457
                                groupStackPI.top().append(itemInfo.item);
458
                                while (itemInfo.ownNr == groupStackPI2.top())
16105 fschmid 459
                                {
23458 jghali 460
                                        groupStackP.push(groupStackPI.pop());
461
                                        groupStackPI2.pop();
462
                                        if (groupStackPI2.count() == 0)
16233 fschmid 463
                                                break;
16105 fschmid 464
                                }
465
                        }
24849 jghali 466
                        else if ((tagName == QLatin1String("FRAMEOBJECT")) && (groupStackFI.count() > 0))
23458 jghali 467
                        {
468
                                groupStackFI.top().append(itemInfo.item);
469
                                while (itemInfo.ownNr == groupStackFI2.top())
470
                                {
471
                                        groupStackF.push(groupStackFI.pop());
472
                                        groupStackFI2.pop();
473
                                        if (groupStackFI2.count() == 0)
474
                                                break;
475
                                }
476
                        }
24849 jghali 477
                        else if ((tagName == QLatin1String("MASTEROBJECT")) && (groupStackMI.count() > 0))
23458 jghali 478
                        {
479
                                groupStackMI.top().append(itemInfo.item);
480
                                while (itemInfo.ownNr == groupStackMI2.top())
481
                                {
482
                                        groupStackM.push(groupStackMI.pop());
483
                                        groupStackMI2.pop();
484
                                        if (groupStackMI2.count() == 0)
485
                                                break;
486
                                }
487
                        }
488
 
16113 fschmid 489
                        if (itemInfo.isGroupFlag)
16105 fschmid 490
                        {
23458 jghali 491
                                QList<PageItem*> groupItems;
492
                                groupItems.append(itemInfo.item);
24849 jghali 493
                                if (tagName == QLatin1String("PAGEOBJECT"))
23458 jghali 494
                                {
495
                                        groupStackPI.push(groupItems);
496
                                        groupStackPI2.push(itemInfo.groupLastItem + itemInfo.ownNr);
497
                                }
24849 jghali 498
                                else if (tagName == QLatin1String("FRAMEOBJECT"))
23458 jghali 499
                                {
500
                                        groupStackFI.push(groupItems);
501
                                        groupStackFI2.push(itemInfo.groupLastItem + itemInfo.ownNr);
502
                                }
503
                                else
504
                                {
505
                                        groupStackMI.push(groupItems);
506
                                        groupStackMI2.push(itemInfo.groupLastItem + itemInfo.ownNr);
507
                                }
16105 fschmid 508
                        }
509
                }
25190 jghali 510
                else if (tagName == QLatin1String("Pattern"))
16105 fschmid 511
                {
512
                        success = readPattern(m_Doc, reader, fileDir);
513
                        if (!success) break;
514
                }
25190 jghali 515
                else if (tagName == QLatin1String("NotesStyles"))
17826 craig 516
                {
517
                        success = readNotesStyles(m_Doc, reader);
518
                        if (!success) break;
519
                }
25190 jghali 520
                else if (tagName == QLatin1String("NotesFrames"))
17826 craig 521
                {
522
                        success = readNotesFrames(reader);
523
                        if (!success) break;
524
                }
25190 jghali 525
                else if (tagName == QLatin1String("Notes"))
17826 craig 526
                {
527
                        success = readNotes(m_Doc, reader);
528
                        if (!success) break;
529
                }
25190 jghali 530
                else if (tagName == QLatin1String("Marks"))
17826 craig 531
                {
532
                        success = readMarks(m_Doc, reader);
533
                        if (!success) break;
534
                }
25195 jghali 535
                else
536
                {
537
                        reader.skipCurrentElement();
538
                }
16105 fschmid 539
        }
540
        if (reader.hasError())
541
        {
542
                setDomParsingError(reader.errorString(), reader.lineNumber(), reader.columnNumber());
543
                return false;
544
        }
16943 fschmid 545
        if (isNewFormat)
16105 fschmid 546
        {
16943 fschmid 547
                if (TableItems.count() != 0)
16105 fschmid 548
                {
16943 fschmid 549
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
550
                        {
551
                                PageItem* ta = TableItems.at(ttc);
552
                                if (ta->TopLinkID != -1)
23049 craig 553
                                        ta->m_topLink = LinkID[ta->TopLinkID];
16943 fschmid 554
                                else
23049 craig 555
                                        ta->m_topLink = nullptr;
16943 fschmid 556
                                if (ta->LeftLinkID != -1)
23049 craig 557
                                        ta->m_leftLink = LinkID[ta->LeftLinkID];
16943 fschmid 558
                                else
23049 craig 559
                                        ta->m_leftLink = nullptr;
16943 fschmid 560
                                if (ta->RightLinkID != -1)
23049 craig 561
                                        ta->m_rightLink = LinkID[ta->RightLinkID];
16943 fschmid 562
                                else
23049 craig 563
                                        ta->m_rightLink = nullptr;
16943 fschmid 564
                                if (ta->BottomLinkID != -1)
23049 craig 565
                                        ta->m_bottomLink = LinkID[ta->BottomLinkID];
16943 fschmid 566
                                else
23049 craig 567
                                        ta->m_bottomLink = nullptr;
16943 fschmid 568
                        }
16105 fschmid 569
                }
16943 fschmid 570
                if (WeldItems.count() != 0)
16105 fschmid 571
                {
16943 fschmid 572
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
573
                        {
574
                                PageItem* ta = WeldItems.at(ttc);
17745 jghali 575
                                for (int i = 0; i < ta->weldList.count(); ++i)
16943 fschmid 576
                                {
19864 craig 577
                                        PageItem::WeldingInfo wInf = ta->weldList.at(i);
17745 jghali 578
                                        ta->weldList[i].weldItem   = LinkID.value(wInf.weldID, 0);
22534 craig 579
                                        if (ta->weldList[i].weldItem == nullptr)
17745 jghali 580
                                                ta->weldList.removeAt(i--);
16943 fschmid 581
                                }
582
                        }
16105 fschmid 583
                }
23675 jghali 584
 
585
                //update names to pointers
586
                updateNames2Ptr();
587
 
16943 fschmid 588
                if (itemNext.count() != 0)
16105 fschmid 589
                {
16943 fschmid 590
                        QMap<int,int>::Iterator lc;
591
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
592
                        {
593
                                if (lc.value() >= 0)
594
                                {
595
                                        PageItem * Its = LinkID[lc.key()];
596
                                        PageItem * Itn = LinkID[lc.value()];
22712 jghali 597
                                        if (!Its->canBeLinkedTo(Itn))
16943 fschmid 598
                                        {
599
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
600
                                                continue;
601
                                        }
602
                                        Its->link(Itn);
603
                                }
604
                        }
16105 fschmid 605
                }
606
        }
16943 fschmid 607
        else
16926 fschmid 608
        {
16943 fschmid 609
                if (TableItemsF.count() != 0)
16926 fschmid 610
                {
16943 fschmid 611
                        for (int ttc = 0; ttc < TableItemsF.count(); ++ttc)
16926 fschmid 612
                        {
16943 fschmid 613
                                PageItem* ta = TableItemsF.at(ttc);
614
                                if (ta->TopLinkID != -1)
23049 craig 615
                                        ta->m_topLink = TableIDF[ta->TopLinkID];
16943 fschmid 616
                                else
23049 craig 617
                                        ta->m_topLink = nullptr;
16943 fschmid 618
                                if (ta->LeftLinkID != -1)
23049 craig 619
                                        ta->m_leftLink = TableIDF[ta->LeftLinkID];
16943 fschmid 620
                                else
23049 craig 621
                                        ta->m_leftLink = nullptr;
16943 fschmid 622
                                if (ta->RightLinkID != -1)
23049 craig 623
                                        ta->m_rightLink = TableIDF[ta->RightLinkID];
16943 fschmid 624
                                else
23049 craig 625
                                        ta->m_rightLink = nullptr;
16943 fschmid 626
                                if (ta->BottomLinkID != -1)
23049 craig 627
                                        ta->m_bottomLink = TableIDF[ta->BottomLinkID];
16943 fschmid 628
                                else
23049 craig 629
                                        ta->m_bottomLink = nullptr;
16926 fschmid 630
                        }
631
                }
16943 fschmid 632
                if (TableItemsM.count() != 0)
16105 fschmid 633
                {
16943 fschmid 634
                        for (int ttc = 0; ttc < TableItemsM.count(); ++ttc)
16105 fschmid 635
                        {
16943 fschmid 636
                                PageItem* ta = TableItemsM.at(ttc);
637
                                if (ta->TopLinkID != -1)
23049 craig 638
                                        ta->m_topLink = TableIDM[ta->TopLinkID];
16943 fschmid 639
                                else
23049 craig 640
                                        ta->m_topLink = nullptr;
16943 fschmid 641
                                if (ta->LeftLinkID != -1)
23049 craig 642
                                        ta->m_leftLink = TableIDM[ta->LeftLinkID];
16943 fschmid 643
                                else
23049 craig 644
                                        ta->m_leftLink = nullptr;
16943 fschmid 645
                                if (ta->RightLinkID != -1)
23049 craig 646
                                        ta->m_rightLink = TableIDM[ta->RightLinkID];
16943 fschmid 647
                                else
23049 craig 648
                                        ta->m_rightLink = nullptr;
16943 fschmid 649
                                if (ta->BottomLinkID != -1)
23049 craig 650
                                        ta->m_bottomLink = TableIDM[ta->BottomLinkID];
16943 fschmid 651
                                else
23049 craig 652
                                        ta->m_bottomLink = nullptr;
16943 fschmid 653
                        }
654
                }
655
                if (TableItems.count() != 0)
656
                {
657
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
658
                        {
659
                                PageItem* ta = TableItems.at(ttc);
660
                                if (ta->TopLinkID != -1)
23049 craig 661
                                        ta->m_topLink = TableID[ta->TopLinkID];
16943 fschmid 662
                                else
23049 craig 663
                                        ta->m_topLink = nullptr;
16943 fschmid 664
                                if (ta->LeftLinkID != -1)
23049 craig 665
                                        ta->m_leftLink = TableID[ta->LeftLinkID];
16943 fschmid 666
                                else
23049 craig 667
                                        ta->m_leftLink = nullptr;
16943 fschmid 668
                                if (ta->RightLinkID != -1)
23049 craig 669
                                        ta->m_rightLink = TableID[ta->RightLinkID];
16943 fschmid 670
                                else
23049 craig 671
                                        ta->m_rightLink = nullptr;
16943 fschmid 672
                                if (ta->BottomLinkID != -1)
23049 craig 673
                                        ta->m_bottomLink = TableID[ta->BottomLinkID];
16943 fschmid 674
                                else
23049 craig 675
                                        ta->m_bottomLink = nullptr;
16943 fschmid 676
                        }
677
                }
678
                if (WeldItems.count() != 0)
679
                {
680
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
681
                        {
682
                                PageItem* ta = WeldItems.at(ttc);
17745 jghali 683
                                for (int i = 0 ; i < ta->weldList.count(); ++i)
16105 fschmid 684
                                {
19864 craig 685
                                        PageItem::WeldingInfo wInf = ta->weldList.at(i);
17745 jghali 686
                                        ta->weldList[i].weldItem = WeldID.value(wInf.weldID, 0);
22534 craig 687
                                        if (ta->weldList[i].weldItem == nullptr)
17745 jghali 688
                                                ta->weldList.removeAt(i--);
16105 fschmid 689
                                }
690
                        }
691
                }
23675 jghali 692
 
693
                //update names to pointers
694
                updateNames2Ptr();
695
 
16943 fschmid 696
                // reestablish textframe links
697
                if (itemNext.count() != 0)
698
                {
699
                        QMap<int,int>::Iterator lc;
700
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
701
                        {
702
                                if (lc.value() >= 0)
703
                                {
22608 craig 704
                                        PageItem *Its(nullptr), *Itn(nullptr);
20464 jghali 705
                                        if (lc.key() < m_Doc->DocItems.count())
706
                                                Its = m_Doc->DocItems.at(lc.key());
707
                                        if (lc.value() < m_Doc->DocItems.count())
708
                                                Itn = m_Doc->DocItems.at(lc.value());
22712 jghali 709
                                        if (!Its || !Itn || !Its->canBeLinkedTo(Itn))
16943 fschmid 710
                                        {
711
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
712
                                                continue;
713
                                        }
714
                                        Its->link(Itn);
715
                                }
716
                        }
717
                }
16105 fschmid 718
        }
20200 jghali 719
 
720
        while (groupStackP.count() > 0)
16105 fschmid 721
        {
20200 jghali 722
                bool isTableIt = false;
723
                QList<PageItem*> gpL = groupStackP.pop();
724
                PageItem* gItem = gpL.takeFirst();
725
                for (int id = 0; id < gpL.count(); id++)
16105 fschmid 726
                {
20200 jghali 727
                        PageItem* cItem = gpL.at(id);
728
                        isTableIt = cItem->isTableItem;
729
                        cItem->gXpos = cItem->xPos() - gItem->xPos();
730
                        cItem->gYpos = cItem->yPos() - gItem->yPos();
731
                        cItem->Parent = gItem;
732
                        if (gItem->rotation() != 0)
16105 fschmid 733
                        {
20200 jghali 734
                                QTransform ma;
735
                                ma.rotate(-gItem->rotation());
25199 jghali 736
                                FPoint n(cItem->gXpos, cItem->gYpos);
20200 jghali 737
                                cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
738
                                cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
739
                                cItem->setRotation(cItem->rotation() - gItem->rotation());
22919 jghali 740
                                cItem->oldRot = cItem->rotation();
16105 fschmid 741
                        }
20200 jghali 742
                        m_Doc->DocItems.removeOne(cItem);
16105 fschmid 743
                }
20200 jghali 744
                bool converted = false;
745
                if (isTableIt)
746
                        converted = convertOldTable(m_Doc, gItem, gpL, &groupStackP, &m_Doc->DocItems);
747
                if (!converted)
748
                        gItem->groupItemList = gpL;
16105 fschmid 749
        }
20200 jghali 750
 
751
        while (groupStackF.count() > 0)
16105 fschmid 752
        {
20200 jghali 753
                bool isTableIt = false;
754
                QList<PageItem*> gpL = groupStackF.pop();
755
                PageItem* gItem = gpL.takeFirst();
756
                for (int id = 0; id < gpL.count(); id++)
16105 fschmid 757
                {
20200 jghali 758
                        PageItem* cItem = gpL.at(id);
759
                        isTableIt = cItem->isTableItem;
760
                        cItem->gXpos = cItem->xPos() - gItem->xPos();
761
                        cItem->gYpos = cItem->yPos() - gItem->yPos();
762
                        cItem->Parent = gItem;
763
                        if (gItem->rotation() != 0)
16105 fschmid 764
                        {
20200 jghali 765
                                QTransform ma;
766
                                ma.rotate(-gItem->rotation());
25199 jghali 767
                                FPoint n(cItem->gXpos, cItem->gYpos);
20200 jghali 768
                                cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
769
                                cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
770
                                cItem->setRotation(cItem->rotation() - gItem->rotation());
22919 jghali 771
                                cItem->oldRot = cItem->rotation();
16105 fschmid 772
                        }
20200 jghali 773
                        m_Doc->FrameItems.remove(m_Doc->FrameItems.key(cItem));
16105 fschmid 774
                }
20200 jghali 775
                bool converted = false;
776
                if (isTableIt)
22534 craig 777
                        converted = convertOldTable(m_Doc, gItem, gpL, &groupStackF, nullptr);
20200 jghali 778
                if (!converted)
779
                        gItem->groupItemList = gpL;
16105 fschmid 780
        }
20200 jghali 781
 
782
        while (groupStackM.count() > 0)
16105 fschmid 783
        {
20200 jghali 784
                bool isTableIt = false;
785
                QList<PageItem*> gpL = groupStackM.pop();
786
                PageItem* gItem = gpL.takeFirst();
787
                for (int id = 0; id < gpL.count(); id++)
16105 fschmid 788
                {
20200 jghali 789
                        PageItem* cItem = gpL.at(id);
790
                        isTableIt = cItem->isTableItem;
791
                        cItem->gXpos = cItem->xPos() - gItem->xPos();
792
                        cItem->gYpos = cItem->yPos() - gItem->yPos();
793
                        cItem->Parent = gItem;
794
                        if (gItem->rotation() != 0)
16105 fschmid 795
                        {
20200 jghali 796
                                QTransform ma;
797
                                ma.rotate(-gItem->rotation());
25199 jghali 798
                                FPoint n(cItem->gXpos, cItem->gYpos);
20200 jghali 799
                                cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
800
                                cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
801
                                cItem->setRotation(cItem->rotation() - gItem->rotation());
22919 jghali 802
                                cItem->oldRot = cItem->rotation();
16105 fschmid 803
                        }
20200 jghali 804
                        m_Doc->MasterItems.removeOne(cItem);
16105 fschmid 805
                }
20200 jghali 806
                bool converted = false;
807
                if (isTableIt)
808
                        converted = convertOldTable(m_Doc, gItem, gpL, &groupStackM, &m_Doc->MasterItems);
809
                if (!converted)
810
                        gItem->groupItemList = gpL;
16105 fschmid 811
        }
20200 jghali 812
 
16105 fschmid 813
        return true;
814
}
815
 
24265 jghali 816
bool Scribus150Format::loadStory(const QByteArray& data, StoryText& story, PageItem* item)
817
{
818
        isNewFormat = false;
819
 
24307 jghali 820
        parStyleMap.clear();
821
        charStyleMap.clear();
24265 jghali 822
        itemRemap.clear();
823
        itemNext.clear();
824
        itemCount = 0;
825
        itemRemapM.clear();
826
        itemNextM.clear();
827
        itemCountM = 0;
828
        itemRemapF.clear();
829
        itemNextF.clear();
830
        FrameItems.clear();
831
        LinkID.clear();
832
 
833
        markeredItemsMap.clear();
834
        markeredMarksMap.clear();
835
        nsetRangeItemNamesMap.clear();
836
        notesFramesData.clear();
837
        notesMasterMarks.clear();
838
        notesNSets.clear();
839
 
840
        bool firstElement = true;
841
        bool success = true;
842
 
843
        ReadObjectParams readObjectParams;
844
        readObjectParams.baseDir = QString() /*fileDir*/; //FIXME
845
        readObjectParams.itemKind = PageItem::InlineItem;
846
        readObjectParams.loadingPage = true;
847
 
848
        ScXmlStreamReader reader(data);
849
        ScXmlStreamAttributes attrs;
850
        while (!reader.atEnd() && !reader.hasError())
851
        {
852
                QXmlStreamReader::TokenType tType = reader.readNext();
853
                if (tType != QXmlStreamReader::StartElement)
854
                        continue;
25188 craig 855
                QString tagName(reader.nameAsString());
24265 jghali 856
                attrs = reader.scAttributes();
857
 
858
                if (firstElement)
859
                {
24849 jghali 860
                        if (tagName != QLatin1String("ScribusStory"))
24265 jghali 861
                        {
862
                                success = false;
863
                                break;
864
                        }
865
                        firstElement = false;
866
                }
867
 
868
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
24849 jghali 869
                if (tagName == QLatin1String("COLOR") && attrs.valueAsString("NAME") != CommonStrings::None)
24265 jghali 870
                {
871
                        QString colorName = attrs.valueAsString("NAME");
872
                        if (m_Doc->PageColors.contains(colorName))
873
                                continue;
874
                        readColor(m_Doc->PageColors, attrs);
875
                }
24849 jghali 876
                if (tagName == QLatin1String("Gradient"))
24265 jghali 877
                {
878
                        VGradient gra;
879
                        QString grName = attrs.valueAsString("Name");
880
                        success = readGradient(m_Doc, gra, reader);
881
                        if (!success)
882
                                break;
883
                        gra.setRepeatMethod((VGradient::VGradientRepeatMethod)(attrs.valueAsInt("Ext", VGradient::pad)));
884
                        if (!grName.isEmpty() && !m_Doc->docGradients.contains(grName))
885
                                m_Doc->docGradients.insert(grName, gra);
886
                }
24849 jghali 887
                if (tagName == QLatin1String("STYLE"))
24265 jghali 888
                {
24307 jghali 889
                        ParagraphStyle pstyle;
890
                        readParagraphStyle(m_Doc, reader, pstyle);
24265 jghali 891
                        // FIXME: import style under new name if existing
892
                        // Do not break current doc for now
24307 jghali 893
                        if (m_Doc->paragraphStyles().contains(pstyle.name()))
24265 jghali 894
                                continue;
895
                        StyleSet<ParagraphStyle> tmp;
24307 jghali 896
                        tmp.create(pstyle);
24265 jghali 897
                        m_Doc->redefineStyles(tmp, false);
898
                }
24849 jghali 899
                if (tagName == QLatin1String("CHARSTYLE"))
24265 jghali 900
                {
901
                        CharStyle cstyle;
902
                        ScXmlStreamAttributes attrs = reader.scAttributes();
903
                        readNamedCharacterStyleAttrs(m_Doc, attrs, cstyle);
904
                        // FIXME: import style under new name if existing
905
                        // Do not break current doc for now
906
                        if (m_Doc->charStyles().contains(cstyle.name()))
907
                                continue;
908
                        StyleSet<CharStyle> temp;
909
                        temp.create(cstyle);
910
                        m_Doc->redefineCharStyles(temp, false);
911
                }
24849 jghali 912
                if (tagName == QLatin1String("TableStyle"))
24265 jghali 913
                {
914
                        TableStyle tstyle;
915
                        readTableStyle(m_Doc, reader, tstyle);
916
                        // FIXME: import style under new name if existing
917
                        // Do not break current doc for now
918
                        if (m_Doc->tableStyles().contains(tstyle.name()))
919
                                continue;
920
                        StyleSet<TableStyle> temp;
921
                        temp.create(tstyle);
922
                        m_Doc->redefineTableStyles(temp, false);
923
                }
24849 jghali 924
                if (tagName == QLatin1String("CellStyle"))
24265 jghali 925
                {
926
                        CellStyle tstyle;
927
                        readCellStyle(m_Doc, reader, tstyle);
928
                        // FIXME: import style under new name if existing
929
                        // Do not break current doc for now
930
                        if (m_Doc->cellStyles().contains(tstyle.name()))
931
                                continue;
932
                        StyleSet<CellStyle> temp;
933
                        temp.create(tstyle);
934
                        m_Doc->redefineCellStyles(temp, false);
935
                }
24849 jghali 936
                if (tagName == QLatin1String("Arrows"))
24265 jghali 937
                {
938
                        success = readArrows(m_Doc, attrs);
939
                        if (!success) break;
940
                }
24849 jghali 941
                if (tagName == QLatin1String("MultiLine"))
24265 jghali 942
                {
943
                        multiLine ml;
944
                        QString mlName = attrs.valueAsString("Name");
945
                        success = readMultiline(ml, reader);
946
                        if (!success)
947
                                break;
948
                        if (!mlName.isEmpty() && !m_Doc->docLineStyles.contains(mlName))
949
                                m_Doc->docLineStyles.insert(mlName, ml);
950
                }
24849 jghali 951
                if (tagName == QLatin1String("FRAMEOBJECT"))
24265 jghali 952
                {
953
                        ItemInfo itemInfo;
954
                        success = readObject(m_Doc, reader, readObjectParams, itemInfo);
955
                        if (!success)
956
                                break;
957
                        itemInfo.item->m_layerID = LayerToPaste;
958
                }
24849 jghali 959
                if (tagName == QLatin1String("StoryText"))
24265 jghali 960
                {
961
                        readStoryText(m_Doc, reader, story, item);
962
                }
24849 jghali 963
                if (tagName == QLatin1String("Pattern")) // FIXME
24265 jghali 964
                {
965
                        /*success = readPattern(m_Doc, reader, fileDir);
966
                        if (!success) break;*/
967
                }
24849 jghali 968
                if (tagName == QLatin1String("NotesStyles"))
24265 jghali 969
                {
970
                        success = readNotesStyles(m_Doc, reader);
971
                        if (!success) break;
972
                }
24849 jghali 973
                if (tagName == QLatin1String("Notes"))
24265 jghali 974
                {
975
                        success = readNotes(m_Doc, reader);
976
                        if (!success) break;
977
                }
24849 jghali 978
                if (tagName == QLatin1String("Marks"))
24265 jghali 979
                {
980
                        success = readMarks(m_Doc, reader);
981
                        if (!success) break;
982
                }
983
        }
984
 
985
        if (reader.hasError())
986
        {
987
                setDomParsingError(reader.errorString(), reader.lineNumber(), reader.columnNumber());
988
                return false;
989
        }
990
 
991
        //update names to pointers
992
        updateNames2Ptr();
993
 
994
        return true;
995
}
996
 
16016 fschmid 997
bool Scribus150Format::loadPalette(const QString & fileName)
998
{
24265 jghali 999
        if (m_Doc == nullptr || m_AvailableFonts == nullptr)
16016 fschmid 1000
        {
24265 jghali 1001
                Q_ASSERT(m_Doc == nullptr || m_AvailableFonts == nullptr);
16016 fschmid 1002
                return false;
1003
        }
24307 jghali 1004
 
16105 fschmid 1005
        Xp = 0.0;
1006
        Yp = 0.0;
1007
        GrX = 0.0;
1008
        GrY = 0.0;
16943 fschmid 1009
        isNewFormat = false;
16016 fschmid 1010
 
24307 jghali 1011
        QMap<int, PageItem*> TableID;
1012
        QMap<int, PageItem*> TableIDM;
1013
        QMap<int, PageItem*> TableIDF;
16016 fschmid 1014
        QList<PageItem*> TableItems;
1015
        QList<PageItem*> TableItemsM;
1016
        QList<PageItem*> TableItemsF;
24307 jghali 1017
        QMap<int, PageItem*> WeldID;
16926 fschmid 1018
        QList<PageItem*> WeldItems;
23458 jghali 1019
        QStack< QList<PageItem*> > groupStackFI;
1020
        QStack< QList<PageItem*> > groupStackMI;
1021
        QStack< QList<PageItem*> > groupStackPI;
16105 fschmid 1022
        QStack< QList<PageItem*> > groupStackF;
1023
        QStack< QList<PageItem*> > groupStackM;
1024
        QStack< QList<PageItem*> > groupStackP;
23458 jghali 1025
        QStack<int> groupStackFI2;
1026
        QStack<int> groupStackMI2;
1027
        QStack<int> groupStackPI2;
19104 jghali 1028
 
24500 jghali 1029
        QScopedPointer<QIODevice> ioDevice(paletteReader(fileName));
24498 jghali 1030
        if (ioDevice.isNull())
16016 fschmid 1031
        {
1032
                setFileReadError();
1033
                return false;
1034
        }
1035
        QString fileDir = QFileInfo(fileName).absolutePath();
19104 jghali 1036
 
24498 jghali 1037
        if (m_mwProgressBar != nullptr)
16016 fschmid 1038
        {
24498 jghali 1039
                m_mwProgressBar->setMaximum(ioDevice->size());
16016 fschmid 1040
                m_mwProgressBar->setValue(0);
1041
        }
19104 jghali 1042
 
16016 fschmid 1043
        itemRemap.clear();
1044
        itemNext.clear();
1045
        itemCount = 0;
1046
        itemRemapM.clear();
1047
        itemNextM.clear();
1048
        itemCountM = 0;
1049
        itemRemapF.clear();
1050
        itemNextF.clear();
1051
 
1052
        TableItems.clear();
1053
        TableID.clear();
1054
        TableItemsM.clear();
1055
        TableIDM.clear();
1056
        TableItemsF.clear();
1057
        TableIDF.clear();
16926 fschmid 1058
        WeldItems.clear();
16016 fschmid 1059
 
1060
        m_Doc->GroupCounter = 1;
22608 craig 1061
        m_Doc->LastAuto = nullptr;
16147 fschmid 1062
//      m_Doc->PageColors.clear();
1063
//      m_Doc->Layers.clear();
16016 fschmid 1064
 
1065
        bool firstElement = true;
1066
        bool success = true;
1067
        int  progress = 0;
1068
 
23616 jghali 1069
        ReadObjectParams readObjectParams;
1070
        readObjectParams.baseDir = fileDir;
1071
        readObjectParams.itemKind = PageItem::StandardItem;
1072
        readObjectParams.loadingPage = false;
1073
 
24498 jghali 1074
        ScXmlStreamReader reader(ioDevice.data());
16016 fschmid 1075
        ScXmlStreamAttributes attrs;
22403 jghali 1076
        while (!reader.atEnd() && !reader.hasError())
16016 fschmid 1077
        {
1078
                QXmlStreamReader::TokenType tType = reader.readNext();
1079
                if (tType != QXmlStreamReader::StartElement)
1080
                        continue;
25188 craig 1081
                QString tagName(reader.nameAsString());
16016 fschmid 1082
                attrs = reader.scAttributes();
1083
 
22608 craig 1084
                if (m_mwProgressBar != nullptr)
16016 fschmid 1085
                {
24498 jghali 1086
                        int newProgress = qRound(ioDevice->pos() / (double) ioDevice->size() * 100);
16016 fschmid 1087
                        if (newProgress != progress)
1088
                        {
1089
                                m_mwProgressBar->setValue(reader.characterOffset());
1090
                                progress = newProgress;
1091
                        }
1092
                }
1093
 
1094
                if (firstElement)
1095
                {
24849 jghali 1096
                        if (tagName != QLatin1String("SCRIBUSCOLORS"))
16016 fschmid 1097
                        {
1098
                                success = false;
1099
                                break;
1100
                        }
1101
                        firstElement = false;
1102
                }
1103
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
24849 jghali 1104
                if (tagName == QLatin1String("COLOR") && attrs.valueAsString("NAME") != CommonStrings::None)
21984 craig 1105
                        readColor(m_Doc->PageColors, attrs);
24849 jghali 1106
                if (tagName == QLatin1String("Gradient"))
16016 fschmid 1107
                {
1108
                        VGradient gra;
1109
                        QString grName = attrs.valueAsString("Name");
1110
                        success = readGradient(m_Doc, gra, reader);
19103 fschmid 1111
                        if (!success)
1112
                                break;
1113
                        gra.setRepeatMethod((VGradient::VGradientRepeatMethod)(attrs.valueAsInt("Ext", VGradient::pad)));
16016 fschmid 1114
                        if (!grName.isEmpty())
1115
                        {
1116
                                m_Doc->docGradients.insert(grName, gra);
1117
                        }
1118
                }
24849 jghali 1119
                if (tagName == QLatin1String("Arrows"))
16016 fschmid 1120
                {
1121
                        success = readArrows(m_Doc, attrs);
1122
                        if (!success) break;
1123
                }
24849 jghali 1124
                if (tagName == QLatin1String("MultiLine"))
16016 fschmid 1125
                {
1126
                        multiLine ml;
1127
                        QString mlName = attrs.valueAsString("Name");
1128
                        success = readMultiline(ml, reader);
1129
                        if (!success) break;
1130
                        if (!mlName.isEmpty())
1131
                        {
23707 jghali 1132
                                m_Doc->docLineStyles.insert(mlName, ml);
16016 fschmid 1133
                        }
1134
                }
24849 jghali 1135
                if (tagName == QLatin1String("PAGEOBJECT") || tagName == QLatin1String("MASTEROBJECT") || tagName == QLatin1String("FRAMEOBJECT"))
16016 fschmid 1136
                {
1137
                        ItemInfo itemInfo;
23616 jghali 1138
                        success = readObject(m_Doc, reader, readObjectParams, itemInfo);
16016 fschmid 1139
                        if (!success) break;
1140
 
16943 fschmid 1141
                        if (isNewFormat)
16016 fschmid 1142
                        {
1143
                                if (itemInfo.nextItem != -1)
16943 fschmid 1144
                                        itemNext[itemInfo.itemID] = itemInfo.nextItem;
1145
                                if (itemInfo.item->isTableItem)
1146
                                        TableItems.append(itemInfo.item);
1147
                                if (itemInfo.isWeldFlag)
1148
                                        WeldItems.append(itemInfo.item);
16016 fschmid 1149
                        }
16943 fschmid 1150
                        else
16016 fschmid 1151
                        {
16943 fschmid 1152
                                // first of linked chain?
24849 jghali 1153
                                if (tagName == QLatin1String("PAGEOBJECT"))
16016 fschmid 1154
                                {
16943 fschmid 1155
                                        if (itemInfo.nextItem != -1)
1156
                                                itemNext[itemInfo.ownNr] = itemInfo.nextItem;
16016 fschmid 1157
                                }
24849 jghali 1158
                                else if (tagName == QLatin1String("MASTEROBJECT"))
16016 fschmid 1159
                                {
16943 fschmid 1160
                                        if (itemInfo.nextItem != -1)
1161
                                                itemNextM[itemInfo.ownNr] = itemInfo.nextItem;
16016 fschmid 1162
                                }
16943 fschmid 1163
                                if (itemInfo.item->isTableItem)
16016 fschmid 1164
                                {
24849 jghali 1165
                                        if (tagName == QLatin1String("PAGEOBJECT"))
16943 fschmid 1166
                                        {
1167
                                                TableItems.append(itemInfo.item);
1168
                                                TableID.insert(itemInfo.ownLink, itemInfo.item);
1169
                                        }
24849 jghali 1170
                                        else if (tagName == QLatin1String("FRAMEOBJECT"))
16943 fschmid 1171
                                        {
1172
                                                TableItemsF.append(itemInfo.item);
1173
                                                TableIDF.insert(itemInfo.ownLink, itemInfo.item);
1174
                                        }
1175
                                        else
1176
                                        {
1177
                                                TableItemsM.append(itemInfo.item);
1178
                                                TableIDM.insert(itemInfo.ownLink, itemInfo.item);
1179
                                        }
16016 fschmid 1180
                                }
16943 fschmid 1181
                                if (itemInfo.isWeldFlag)
1182
                                {
1183
                                        WeldItems.append(itemInfo.item);
1184
                                        WeldID.insert(itemInfo.ownWeld, itemInfo.item);
1185
                                }
16016 fschmid 1186
                        }
23458 jghali 1187
 
24849 jghali 1188
                        if ((tagName == QLatin1String("PAGEOBJECT")) && (groupStackPI.count() > 0))
16016 fschmid 1189
                        {
23458 jghali 1190
                                groupStackPI.top().append(itemInfo.item);
1191
                                while (itemInfo.ownNr == groupStackPI2.top())
16105 fschmid 1192
                                {
23458 jghali 1193
                                        groupStackP.push(groupStackPI.pop());
1194
                                        groupStackPI2.pop();
1195
                                        if (groupStackPI2.count() == 0)
16233 fschmid 1196
                                                break;
16105 fschmid 1197
                                }
16016 fschmid 1198
                        }
24849 jghali 1199
                        else if ((tagName == QLatin1String("FRAMEOBJECT")) && (groupStackFI.count() > 0))
23458 jghali 1200
                        {
1201
                                groupStackFI.top().append(itemInfo.item);
1202
                                while (itemInfo.ownNr == groupStackFI2.top())
1203
                                {
1204
                                        groupStackF.push(groupStackFI.pop());
1205
                                        groupStackFI2.pop();
1206
                                        if (groupStackFI2.count() == 0)
1207
                                                break;
1208
                                }
1209
                        }
24849 jghali 1210
                        else if ((tagName == QLatin1String("MASTEROBJECT")) && (groupStackMI.count() > 0))
23458 jghali 1211
                        {
1212
                                groupStackMI.top().append(itemInfo.item);
1213
                                while (itemInfo.ownNr == groupStackMI2.top())
1214
                                {
1215
                                        groupStackM.push(groupStackMI.pop());
1216
                                        groupStackMI2.pop();
1217
                                        if (groupStackMI2.count() == 0)
1218
                                                break;
1219
                                }
1220
                        }
1221
 
16113 fschmid 1222
                        if (itemInfo.isGroupFlag)
16105 fschmid 1223
                        {
23458 jghali 1224
                                QList<PageItem*> groupItems;
1225
                                groupItems.append(itemInfo.item);
24849 jghali 1226
                                if (tagName == QLatin1String("PAGEOBJECT"))
23458 jghali 1227
                                {
1228
                                        groupStackPI.push(groupItems);
1229
                                        groupStackPI2.push(itemInfo.groupLastItem + itemInfo.ownNr);
1230
                                }
24849 jghali 1231
                                else if (tagName == QLatin1String("FRAMEOBJECT"))
23458 jghali 1232
                                {
1233
                                        groupStackFI.push(groupItems);
1234
                                        groupStackFI2.push(itemInfo.groupLastItem + itemInfo.ownNr);
1235
                                }
1236
                                else
1237
                                {
1238
                                        groupStackMI.push(groupItems);
1239
                                        groupStackMI2.push(itemInfo.groupLastItem + itemInfo.ownNr);
1240
                                }
16105 fschmid 1241
                        }
16016 fschmid 1242
                }
24849 jghali 1243
                if (tagName == QLatin1String("Pattern"))
16016 fschmid 1244
                {
1245
                        success = readPattern(m_Doc, reader, fileDir);
1246
                        if (!success) break;
1247
                }
24849 jghali 1248
                if (tagName == QLatin1String("NotesStyles"))
17826 craig 1249
                {
1250
                        success = readNotesStyles(m_Doc, reader);
1251
                        if (!success) break;
1252
                }
24849 jghali 1253
                if (tagName == QLatin1String("NotesFrames"))
17826 craig 1254
                {
1255
                        success = readNotesFrames(reader);
1256
                        if (!success) break;
1257
                }
24849 jghali 1258
                if (tagName == QLatin1String("Notes"))
17826 craig 1259
                {
1260
                        success = readNotes(m_Doc, reader);
1261
                        if (!success) break;
1262
                }
24849 jghali 1263
                if (tagName == QLatin1String("Marks"))
17826 craig 1264
                {
1265
                        success = readMarks(m_Doc, reader);
1266
                        if (!success) break;
1267
                }
16016 fschmid 1268
        }
1269
 
1270
        if (reader.hasError())
1271
        {
1272
                setDomParsingError(reader.errorString(), reader.lineNumber(), reader.columnNumber());
1273
                return false;
1274
        }
16943 fschmid 1275
        if (isNewFormat)
16016 fschmid 1276
        {
16943 fschmid 1277
                if (TableItems.count() != 0)
16016 fschmid 1278
                {
16943 fschmid 1279
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
1280
                        {
1281
                                PageItem* ta = TableItems.at(ttc);
1282
                                if (ta->TopLinkID != -1)
23049 craig 1283
                                        ta->m_topLink = LinkID[ta->TopLinkID];
16943 fschmid 1284
                                else
23049 craig 1285
                                        ta->m_topLink = nullptr;
16943 fschmid 1286
                                if (ta->LeftLinkID != -1)
23049 craig 1287
                                        ta->m_leftLink = LinkID[ta->LeftLinkID];
16943 fschmid 1288
                                else
23049 craig 1289
                                        ta->m_leftLink = nullptr;
16943 fschmid 1290
                                if (ta->RightLinkID != -1)
23049 craig 1291
                                        ta->m_rightLink = LinkID[ta->RightLinkID];
16943 fschmid 1292
                                else
23049 craig 1293
                                        ta->m_rightLink = nullptr;
16943 fschmid 1294
                                if (ta->BottomLinkID != -1)
23049 craig 1295
                                        ta->m_bottomLink = LinkID[ta->BottomLinkID];
16943 fschmid 1296
                                else
23049 craig 1297
                                        ta->m_bottomLink = nullptr;
16943 fschmid 1298
                        }
16016 fschmid 1299
                }
16943 fschmid 1300
                if (WeldItems.count() != 0)
16016 fschmid 1301
                {
16943 fschmid 1302
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
1303
                        {
1304
                                PageItem* ta = WeldItems.at(ttc);
17745 jghali 1305
                                for (int i = 0 ; i < ta->weldList.count(); ++i)
16943 fschmid 1306
                                {
19864 craig 1307
                                        PageItem::WeldingInfo wInf = ta->weldList.at(i);
17745 jghali 1308
                                        ta->weldList[i].weldItem = LinkID.value(wInf.weldID, 0);
22534 craig 1309
                                        if (ta->weldList[i].weldItem == nullptr)
17745 jghali 1310
                                                ta->weldList.removeAt(i--);
16943 fschmid 1311
                                }
1312
                        }
16016 fschmid 1313
                }
16943 fschmid 1314
                if (itemNext.count() != 0)
16016 fschmid 1315
                {
16943 fschmid 1316
                        QMap<int,int>::Iterator lc;
1317
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
1318
                        {
1319
                                if (lc.value() >= 0)
1320
                                {
1321
                                        PageItem * Its = LinkID[lc.key()];
1322
                                        PageItem * Itn = LinkID[lc.value()];
22712 jghali 1323
                                        if (!Its->canBeLinkedTo(Itn))
16943 fschmid 1324
                                        {
1325
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1326
                                                continue;
1327
                                        }
1328
                                        Its->link(Itn);
1329
                                }
1330
                        }
16016 fschmid 1331
                }
1332
        }
16943 fschmid 1333
        else
16926 fschmid 1334
        {
16943 fschmid 1335
                if (TableItemsF.count() != 0)
16926 fschmid 1336
                {
16943 fschmid 1337
                        for (int ttc = 0; ttc < TableItemsF.count(); ++ttc)
16926 fschmid 1338
                        {
16943 fschmid 1339
                                PageItem* ta = TableItemsF.at(ttc);
1340
                                if (ta->TopLinkID != -1)
23049 craig 1341
                                        ta->m_topLink = TableIDF[ta->TopLinkID];
16943 fschmid 1342
                                else
23049 craig 1343
                                        ta->m_topLink = nullptr;
16943 fschmid 1344
                                if (ta->LeftLinkID != -1)
23049 craig 1345
                                        ta->m_leftLink = TableIDF[ta->LeftLinkID];
16943 fschmid 1346
                                else
23049 craig 1347
                                        ta->m_leftLink = nullptr;
16943 fschmid 1348
                                if (ta->RightLinkID != -1)
23049 craig 1349
                                        ta->m_rightLink = TableIDF[ta->RightLinkID];
16943 fschmid 1350
                                else
23049 craig 1351
                                        ta->m_rightLink = nullptr;
16943 fschmid 1352
                                if (ta->BottomLinkID != -1)
23049 craig 1353
                                        ta->m_bottomLink = TableIDF[ta->BottomLinkID];
16943 fschmid 1354
                                else
23049 craig 1355
                                        ta->m_bottomLink = nullptr;
16926 fschmid 1356
                        }
1357
                }
16943 fschmid 1358
                if (TableItemsM.count() != 0)
16016 fschmid 1359
                {
16943 fschmid 1360
                        for (int ttc = 0; ttc < TableItemsM.count(); ++ttc)
16016 fschmid 1361
                        {
16943 fschmid 1362
                                PageItem* ta = TableItemsM.at(ttc);
1363
                                if (ta->TopLinkID != -1)
23049 craig 1364
                                        ta->m_topLink = TableIDM[ta->TopLinkID];
16943 fschmid 1365
                                else
23049 craig 1366
                                        ta->m_topLink = nullptr;
16943 fschmid 1367
                                if (ta->LeftLinkID != -1)
23049 craig 1368
                                        ta->m_leftLink = TableIDM[ta->LeftLinkID];
16943 fschmid 1369
                                else
23049 craig 1370
                                        ta->m_leftLink = nullptr;
16943 fschmid 1371
                                if (ta->RightLinkID != -1)
23049 craig 1372
                                        ta->m_rightLink = TableIDM[ta->RightLinkID];
16943 fschmid 1373
                                else
23049 craig 1374
                                        ta->m_rightLink = nullptr;
16943 fschmid 1375
                                if (ta->BottomLinkID != -1)
23049 craig 1376
                                        ta->m_bottomLink = TableIDM[ta->BottomLinkID];
16943 fschmid 1377
                                else
23049 craig 1378
                                        ta->m_bottomLink = nullptr;
16943 fschmid 1379
                        }
1380
                }
1381
                if (TableItems.count() != 0)
1382
                {
1383
                        for (int ttc = 0; ttc < TableItems.count(); ++ttc)
1384
                        {
1385
                                PageItem* ta = TableItems.at(ttc);
1386
                                if (ta->TopLinkID != -1)
23049 craig 1387
                                        ta->m_topLink = TableID[ta->TopLinkID];
16943 fschmid 1388
                                else
23049 craig 1389
                                        ta->m_topLink = nullptr;
16943 fschmid 1390
                                if (ta->LeftLinkID != -1)
23049 craig 1391
                                        ta->m_leftLink = TableID[ta->LeftLinkID];
16943 fschmid 1392
                                else
23049 craig 1393
                                        ta->m_leftLink = nullptr;
16943 fschmid 1394
                                if (ta->RightLinkID != -1)
23049 craig 1395
                                        ta->m_rightLink = TableID[ta->RightLinkID];
16943 fschmid 1396
                                else
23049 craig 1397
                                        ta->m_rightLink = nullptr;
16943 fschmid 1398
                                if (ta->BottomLinkID != -1)
23049 craig 1399
                                        ta->m_bottomLink = TableID[ta->BottomLinkID];
16943 fschmid 1400
                                else
23049 craig 1401
                                        ta->m_bottomLink = nullptr;
16943 fschmid 1402
                        }
1403
                }
1404
                if (WeldItems.count() != 0)
1405
                {
1406
                        for (int ttc = 0; ttc < WeldItems.count(); ++ttc)
1407
                        {
1408
                                PageItem* ta = WeldItems.at(ttc);
17745 jghali 1409
                                for (int i = 0 ; i < ta->weldList.count(); ++i)
16016 fschmid 1410
                                {
19864 craig 1411
                                        PageItem::WeldingInfo wInf = ta->weldList.at(i);
17745 jghali 1412
                                        ta->weldList[i].weldItem = WeldID.value(wInf.weldID, 0);
22534 craig 1413
                                        if (ta->weldList[i].weldItem == nullptr)
17745 jghali 1414
                                                ta->weldList.removeAt(i--);
16016 fschmid 1415
                                }
1416
                        }
1417
                }
16943 fschmid 1418
                // reestablish textframe links
1419
                if (itemNext.count() != 0)
16016 fschmid 1420
                {
16943 fschmid 1421
                        QMap<int,int>::Iterator lc;
1422
                        for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
16016 fschmid 1423
                        {
16943 fschmid 1424
                                if (lc.value() >= 0)
16016 fschmid 1425
                                {
22608 craig 1426
                                        PageItem *Its(nullptr), *Itn(nullptr);
20464 jghali 1427
                                        if (lc.key() < m_Doc->DocItems.count())
1428
                                                Its = m_Doc->DocItems.at(lc.key());
1429
                                        if (lc.value() < m_Doc->DocItems.count())
1430
                                                Itn = m_Doc->DocItems.at(lc.value());
22712 jghali 1431
                                        if (!Its || !Itn || !Its->canBeLinkedTo(Itn))
16943 fschmid 1432
                                        {
1433
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1434
                                                continue;
1435
                                        }
1436
                                        Its->link(Itn);
16016 fschmid 1437
                                }
1438
                        }
1439
                }
16943 fschmid 1440
                if (itemNextM.count() != 0)
1441
                {
1442
                        QMap<int,int>::Iterator lc;
1443
                        for (lc = itemNextM.begin(); lc != itemNextM.end(); ++lc)
1444
                        {
1445
                                if (lc.value() >= 0)
1446
                                {
22608 craig 1447
                                        PageItem *Its(nullptr), *Itn(nullptr);
20464 jghali 1448
                                        if (lc.key() < m_Doc->MasterItems.count())
1449
                                                Its = m_Doc->MasterItems.at(lc.key());
1450
                                        if (lc.value() < m_Doc->MasterItems.count())
1451
                                                Itn = m_Doc->MasterItems.at(lc.value());
22712 jghali 1452
                                        if (!Its || !Itn || !Its->canBeLinkedTo(Itn))
16943 fschmid 1453
                                        {
1454
                                                qDebug() << "scribus150format: corruption in linked textframes detected";
1455
                                                continue;
1456
                                        }
1457
                                        Its->link(Itn);
1458
                                }
1459
                        }
1460
                }
16016 fschmid 1461
        }
23457 jghali 1462
 
1463
        while (groupStackP.count() > 0)
16105 fschmid 1464
        {
23457 jghali 1465
                bool isTableIt = false;
1466
                QList<PageItem*> gpL = groupStackP.pop();
1467
                PageItem* gItem = gpL.takeFirst();
1468
                for (int id = 0; id < gpL.count(); id++)
16105 fschmid 1469
                {
23457 jghali 1470
                        PageItem* cItem = gpL.at(id);
1471
                        isTableIt = cItem->isTableItem;
1472
                        cItem->gXpos = cItem->xPos() - gItem->xPos();
1473
                        cItem->gYpos = cItem->yPos() - gItem->yPos();
1474
                        cItem->Parent = gItem;
1475
                        if (gItem->rotation() != 0)
16105 fschmid 1476
                        {
23457 jghali 1477
                                QTransform ma;
1478
                                ma.rotate(-gItem->rotation());
25199 jghali 1479
                                FPoint n(cItem->gXpos, cItem->gYpos);
23457 jghali 1480
                                cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1481
                                cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1482
                                cItem->setRotation(cItem->rotation() - gItem->rotation());
1483
                                cItem->oldRot = cItem->rotation();
16105 fschmid 1484
                        }
23457 jghali 1485
                        m_Doc->DocItems.removeOne(cItem);
16105 fschmid 1486
                }
23457 jghali 1487
                bool converted = false;
1488
                if (isTableIt)
1489
                        converted = convertOldTable(m_Doc, gItem, gpL, &groupStackP, &m_Doc->DocItems);
1490
                if (!converted)
1491
                        gItem->groupItemList = gpL;
16105 fschmid 1492
        }
23457 jghali 1493
 
1494
        while (groupStackF.count() > 0)
16105 fschmid 1495
        {
23457 jghali 1496
                bool isTableIt = false;
1497
                QList<PageItem*> gpL = groupStackF.pop();
1498
                PageItem* gItem = gpL.takeFirst();
1499
                for (int id = 0; id < gpL.count(); id++)
16105 fschmid 1500
                {
23457 jghali 1501
                        PageItem* cItem = gpL.at(id);
1502
                        isTableIt = cItem->isTableItem;
1503
                        cItem->gXpos = cItem->xPos() - gItem->xPos();
1504
                        cItem->gYpos = cItem->yPos() - gItem->yPos();
1505
                        cItem->Parent = gItem;
1506
                        if (gItem->rotation() != 0)
16105 fschmid 1507
                        {
23457 jghali 1508
                                QTransform ma;
1509
                                ma.rotate(-gItem->rotation());
25199 jghali 1510
                                FPoint n(cItem->gXpos, cItem->gYpos);
23457 jghali 1511
                                cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1512
                                cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1513
                                cItem->setRotation(cItem->rotation() - gItem->rotation());
1514
                                cItem->oldRot = cItem->rotation();
16105 fschmid 1515
                        }
23457 jghali 1516
                        m_Doc->FrameItems.remove(m_Doc->FrameItems.key(cItem));
16105 fschmid 1517
                }
23457 jghali 1518
                bool converted = false;
1519
                if (isTableIt)
1520
                        converted = convertOldTable(m_Doc, gItem, gpL, &groupStackF, nullptr);
1521
                if (!converted)
1522
                        gItem->groupItemList = gpL;
16105 fschmid 1523
        }
23457 jghali 1524
 
1525
        while (groupStackM.count() > 0)
16105 fschmid 1526
        {
23457 jghali 1527
                bool isTableIt = false;
1528
                QList<PageItem*> gpL = groupStackM.pop();
1529
                PageItem* gItem = gpL.takeFirst();
1530
                for (int id = 0; id < gpL.count(); id++)
16105 fschmid 1531
                {
23457 jghali 1532
                        PageItem* cItem = gpL.at(id);
1533
                        isTableIt = cItem->isTableItem;
1534
                        cItem->gXpos = cItem->xPos() - gItem->xPos();
1535
                        cItem->gYpos = cItem->yPos() - gItem->yPos();
1536
                        cItem->Parent = gItem;
1537
                        if (gItem->rotation() != 0)
16105 fschmid 1538
                        {
23457 jghali 1539
                                QTransform ma;
1540
                                ma.rotate(-gItem->rotation());
25199 jghali 1541
                                FPoint n(cItem->gXpos, cItem->gYpos);
23457 jghali 1542
                                cItem->gXpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1543
                                cItem->gYpos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
1544
                                cItem->setRotation(cItem->rotation() - gItem->rotation());
1545
                                cItem->oldRot = cItem->rotation();
16105 fschmid 1546
                        }
23457 jghali 1547
                        m_Doc->MasterItems.removeOne(cItem);
16105 fschmid 1548
                }
23457 jghali 1549
                bool converted = false;
1550
                if (isTableIt)
1551
                        converted = convertOldTable(m_Doc, gItem, gpL, &groupStackM, &m_Doc->MasterItems);
1552
                if (!converted)
1553
                        gItem->groupItemList = gpL;
16105 fschmid 1554
        }
16016 fschmid 1555
 
1556
        if (m_Doc->Layers.count() == 0)
1557
                m_Doc->Layers.newLayer( QObject::tr("Background") );
22608 craig 1558
        if (m_mwProgressBar!=nullptr)
16016 fschmid 1559
        {
1560
                m_mwProgressBar->setValue(reader.characterOffset());
1561
                m_mwProgressBar->reset();
1562
        }
1563
        return true;
1564
}
1565
 
13971 jghali 1566
bool Scribus150Format::loadFile(const QString & fileName, const FileFormat & /* fmt */, int /* flags */, int /* index */)
1567
{
22608 craig 1568
        if (m_Doc==nullptr || m_AvailableFonts==nullptr)
13971 jghali 1569
        {
22608 craig 1570
                Q_ASSERT(m_Doc==nullptr || m_AvailableFonts==nullptr);
13971 jghali 1571
                return false;
1572
        }
24307 jghali 1573
 
16105 fschmid 1574
        Xp = 0.0;
1575
        Yp = 0.0;
1576
        GrX = 0.0;
1577
        GrY = 0.0;
13971 jghali 1578
        struct ScribusDoc::BookMa bok;
1579
        QMap<int, ScribusDoc::BookMa> bookmarks;
1580
 
16943 fschmid 1581
        isNewFormat = false;
13971 jghali 1582
 
24307 jghali 1583
        QMap<int, PageItem*> TableID;
1584
        QMap<int, PageItem*> TableIDM;
1585
        QMap<int, PageItem*> TableIDF;
13971 jghali 1586
        QList<PageItem*> TableItems;
1587
        QList<PageItem*> TableItemsM;
1588
        QList<PageItem*> TableItemsF;
24307 jghali 1589
        QMap<int, PageItem*> WeldID;
16926 fschmid 1590
        QList<PageItem*> WeldItems;
23458 jghali 1591
        QStack< QList<PageItem*> > groupStackFI;
1592
        QStack< QList<PageItem*> > groupStackMI;
1593
        QStack< QList<PageItem*> > groupStackPI;
16105 fschmid 1594
        QStack< QList<PageItem*> > groupStackF;
1595
        QStack< QList<PageItem*> > groupStackM;
1596
        QStack< QList<PageItem*> > groupStackP;
23458 jghali 1597
        QStack<int> groupStackFI2;
1598
        QStack<int> groupStackMI2;
1599
        QStack<int> groupStackPI2;
13971 jghali 1600
 
17826 craig 1601
        markeredItemsMap.clear();
1602
        markeredMarksMap.clear();
1603
        nsetRangeItemNamesMap.clear();
1604
        notesFramesData.clear();
1605
        notesMasterMarks.clear();
1606
        notesNSets.clear();
1607
 
17982 jghali 1608
        QScopedPointer<QIODevice> ioDevice(slaReader(fileName));
1609
        if (ioDevice.isNull())
14395 jghali 1610
        {
1611
                setFileReadError();
13971 jghali 1612
                return false;
14395 jghali 1613
        }
13971 jghali 1614
        QString fileDir = QFileInfo(fileName).absolutePath();
1615
        int firstPage = 0;
1616
        int layerToSetActive = 0;
1617
 
24498 jghali 1618
        if (m_mwProgressBar != nullptr)
13971 jghali 1619
        {
17982 jghali 1620
                m_mwProgressBar->setMaximum(ioDevice->size());
13971 jghali 1621
                m_mwProgressBar->setValue(0);
1622
        }
1623
        // Stop autosave timer,it will be restarted only if doc has autosave feature is enabled
1624
        if (m_Doc->autoSaveTimer->isActive())
1625
                m_Doc->autoSaveTimer->stop();
16105 fschmid 1626
 
24307 jghali 1627
        parStyleMap.clear();
1628
        charStyleMap.clear();
13971 jghali 1629
        itemRemap.clear();
1630
        itemNext.clear();
1631
        itemCount = 0;
1632
        itemRemapM.clear();
1633
        itemNextM.clear();
1634
        itemCountM = 0;
1635
        itemRemapF.clear();
1636
        itemNextF.clear();
1637
 
19742 jghali 1638
        FrameItems.clear();
13971 jghali 1639
        TableItems.clear();
1640
        TableID.clear();
1641
        TableItemsM.clear();
1642
        TableIDM.clear();
1643
        TableItemsF.clear();
1644
        TableIDF.clear();
16926 fschmid 1645
        WeldItems.clear();
1646
        WeldID.clear();
16943 fschmid 1647
        LinkID.clear();
13971 jghali 1648
 
1649
        m_Doc->GroupCounter = 1;
22608 craig 1650
        m_Doc->LastAuto = nullptr;
13971 jghali 1651
        m_Doc->PageColors.clear();
1652
        m_Doc->Layers.clear();
1653
 
23616 jghali 1654
        ReadObjectParams readObjectParams;
1655
        readObjectParams.baseDir = fileDir;
1656
        readObjectParams.itemKind = PageItem::StandardItem;
1657
        readObjectParams.loadingPage = false;
1658
 
13971 jghali 1659
        bool firstElement = true;
1660
        bool success = true;
1661
        bool hasPageSets = false;
1662
        int  progress = 0;
1663
 
17982 jghali 1664
        ScXmlStreamReader reader(ioDevice.data());
13971 jghali 1665
        ScXmlStreamAttributes attrs;
22403 jghali 1666
        while (!reader.atEnd() && !reader.hasError())
13971 jghali 1667
        {
1668
                QXmlStreamReader::TokenType tType = reader.readNext();
1669
                if (tType != QXmlStreamReader::StartElement)
1670
                        continue;
25188 craig 1671
                QString tagName(reader.nameAsString());
13971 jghali 1672
                attrs = reader.scAttributes();
1673
 
22608 craig 1674
                if (m_mwProgressBar != nullptr)
13971 jghali 1675
                {
17982 jghali 1676
                        int newProgress = qRound(ioDevice->pos() / (double) ioDevice->size() * 100);
13971 jghali 1677
                        if (newProgress != progress)
1678
                        {
1679
                                m_mwProgressBar->setValue(reader.characterOffset());
1680
                                progress = newProgress;
1681
                        }
1682
                }
1683
 
1684
                if (firstElement)
1685
                {
24849 jghali 1686
                        if (tagName != QLatin1String("SCRIBUSUTF8NEW"))
13971 jghali 1687
                        {
1688
                                success = false;
1689
                                break;
1690
                        }
1691
                        firstElement = false;
25195 jghali 1692
                        continue;
13971 jghali 1693
                }
25195 jghali 1694
 
24849 jghali 1695
                if (tagName == QLatin1String("DOCUMENT"))
13971 jghali 1696
                {
1697
                        readDocAttributes(m_Doc, attrs);
1698
                        layerToSetActive = attrs.valueAsInt("ALAYER", 0);
15407 craig 1699
                        if (m_Doc->pagePositioning() == 0)
13971 jghali 1700
                                firstPage = 0;
1701
                        else
1702
                        {
1703
                                if (attrs.valueAsInt("FIRSTLEFT", 0) == 1)
1704
                                        firstPage = 0;
1705
                                else
1706
                                        firstPage = 1;
1707
                        }
1708
                        if (attrs.hasAttribute("currentProfile"))
1709
                        {
14971 cbradney 1710
                                m_Doc->clearCheckerProfiles();
1711
                                m_Doc->setCurCheckProfile(attrs.valueAsString("currentProfile"));
13971 jghali 1712
                        }
1713
                }
25190 jghali 1714
                else if (tagName == QLatin1String("CheckProfile"))
13971 jghali 1715
                {
1716
                        success = readCheckProfile(m_Doc, attrs);
1717
                        if (!success) break;
1718
                }
25190 jghali 1719
                else if (tagName == QLatin1String("PageSets"))
13971 jghali 1720
                {
1721
                        success = readPageSets(m_Doc, reader);
1722
                        if (!success) break;
1723
                        hasPageSets = true;
1724
                }
1725
                // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
25190 jghali 1726
                else if (tagName == QLatin1String("COLOR") && attrs.valueAsString("NAME") != CommonStrings::None)
21984 craig 1727
                        readColor(m_Doc->PageColors, attrs);
25190 jghali 1728
                else if (tagName == QLatin1String("Gradient"))
14150 fschmid 1729
                {
1730
                        VGradient gra;
1731
                        QString grName = attrs.valueAsString("Name");
1732
                        success = readGradient(m_Doc, gra, reader);
19103 fschmid 1733
                        if (!success)
1734
                                break;
1735
                        gra.setRepeatMethod((VGradient::VGradientRepeatMethod)(attrs.valueAsInt("Ext", VGradient::pad)));
14150 fschmid 1736
                        if (!grName.isEmpty())
1737
                                m_Doc->docGradients.insert(grName, gra);
1738
                }
25190 jghali 1739
                else if (tagName == QLatin1String("STYLE"))
13971 jghali 1740
                {
24307 jghali 1741
                        ParagraphStyle pstyle;
1742
                        readParagraphStyle(m_Doc, reader, pstyle);
13971 jghali 1743
                        StyleSet<ParagraphStyle>tmp;
24307 jghali 1744
                        tmp.create(pstyle);
13971 jghali 1745
                        m_Doc->redefineStyles(tmp, false);
1746
                }
25190 jghali 1747
                else if (tagName == QLatin1String("CHARSTYLE"))
13971 jghali 1748
                {
16531 jghali 1749
                        CharStyle cstyle;
16533 jghali 1750
                        ScXmlStreamAttributes attrs = reader.scAttributes();
1751
                        readNamedCharacterStyleAttrs(m_Doc, attrs, cstyle);
13971 jghali 1752
                        StyleSet<CharStyle> temp;
16531 jghali 1753
                        temp.create(cstyle);
13971 jghali 1754
                        m_Doc->redefineCharStyles(temp, false);
1755
                }
25190 jghali 1756
                else if (tagName == QLatin1String("TableStyle"))
17318 fschmid 1757
                {
1758
                        TableStyle tstyle;
1759
                        readTableStyle(m_Doc, reader, tstyle);
1760
                        StyleSet<TableStyle> temp;
1761
                        temp.create(tstyle);
1762
                        m_Doc->redefineTableStyles(temp, false);
1763
                }
25190 jghali 1764
                else if (tagName == QLatin1String("CellStyle"))
17318 fschmid 1765
                {
1766
                        CellStyle tstyle;
1767
                        readCellStyle(m_Doc, reader, tstyle);
1768
                        StyleSet<CellStyle> temp;
1769
                        temp.create(tstyle);
1770
                        m_Doc->redefineCellStyles(temp, false);
1771
                }
25190 jghali 1772
                else if (tagName == QLatin1String("JAVA"))
13971 jghali 1773
                {
1774
                        QString name = attrs.valueAsString("NAME");
1775
                        if (!name.isEmpty())
1776
                                m_Doc->JavaScripts[name] = attrs.valueAsString("SCRIPT");
1777
                }
25190 jghali 1778
                else if (tagName == QLatin1String("LAYERS"))
13971 jghali 1779
                {
1780
                        ScLayer newLayer;
1781
                        readLayers(newLayer, attrs);
1782
                        m_Doc->Layers.append(newLayer);
1783
                }
25190 jghali 1784
                else if (tagName == QLatin1String("Arrows"))
13971 jghali 1785
                {
1786
                        success = readArrows(m_Doc, attrs);
1787
                        if (!success) break;
1788
                }
25190 jghali 1789
                else if (tagName == QLatin1String("MultiLine"))
13971 jghali 1790
                {
1791
                        multiLine ml;
1792
                        QString mlName = attrs.valueAsString("Name");
1793
                        success = readMultiline(ml, reader);
1794
                        if (!success) break;
1795
                        if (!mlName.isEmpty())
1796
                        {
23707 jghali 1797
                                m_Doc->docLineStyles.insert(mlName, ml);
13971 jghali 1798
                        }
1799
                }
25190 jghali 1800
                else if (tagName == QLatin1String("Bookmark"))
13971 jghali 1801
                {
1802
                        int bmElem = 0;
1803
                        struct ScribusDoc::BookMa bookmark;
1804
                        success = readBookMark(bookmark, bmElem, attrs);
1805
                        if (!success) break;
1806
                        bookmarks.insert(bmElem, bookmark);
1807
                }
25190 jghali 1808
                else if (tagName == QLatin1String("PDF"))
13971 jghali 1809
                {
1810
                        success = readPDFOptions(m_Doc, reader);
1811
                        if (!success) break;
1812
                }
25190 jghali 1813
                else if (tagName == QLatin1String("Printer"))
13971 jghali 1814
                {
1815
                        success = readPrinterOptions(m_Doc, reader);
1816
                        if (!success) break;
1817
                }
25190 jghali 1818
                else if (tagName == QLatin1String("DocItemAttributes"))
13971 jghali 1819
                {
1820
                        success = readDocItemAttributes(m_Doc, reader);
1821
                        if (!success) break;
1822
                }
25190 jghali 1823
                else if (tagName == QLatin1String("TablesOfContents"))
13971 jghali 1824
                {
1825
                        success = readTableOfContents(m_Doc, reader);
1826
                        if (!success) break;
1827
                }
25190 jghali 1828
                else if (tagName == QLatin1String("Sections"))
13971 jghali 1829
                {
1830
                        success = readSections(m_Doc, reader);
1831
                        if (!success) break;
1832
                }
25190 jghali 1833
                else if (tagName == QLatin1String("HYPHEN"))
13971 jghali 1834
                {
1835
                        success = readHyphen(m_Doc, reader);
1836
                        if (!success) break;
1837
                }
25190 jghali 1838
                else if (tagName == QLatin1String("PAGE") || tagName == QLatin1String("MASTERPAGE"))
13971 jghali 1839
                {
1840
                        success = readPage(m_Doc, reader);
16105 fschmid 1841
                        if (!success)
1842
                                break;
13971 jghali 1843
                }
25190 jghali 1844
                else if (tagName == QLatin1String("PAGEOBJECT") || tagName == QLatin1String("MASTEROBJECT") || tagName == QLatin1String("FRAMEOBJECT"))
13971 jghali 1845
                {
1846
                        ItemInfo itemInfo;
23616 jghali 1847
                        success = readObject(m_Doc, reader, readObjectParams, itemInfo);
16105 fschmid 1848
                        if (!success)
1849
                                break;
13971 jghali 1850
 
1851
                        // first of linked chain?
16943 fschmid 1852
                        if (isNewFormat)
13971 jghali 1853
                        {
1854
                                if (itemInfo.nextItem != -1)
16943 fschmid 1855
                                        itemNext[itemInfo.itemID] = itemInfo.nextItem;
1856
                                if (itemInfo.item->isTableItem)
1857
                                        TableItems.append(itemInfo.item);
1858
                                if (itemInfo.isWeldFlag)
1859
                                        WeldItems.append(itemInfo.item);
13971 jghali 1860
                        }
16943 fschmid 1861
                        else
13971 jghali 1862
                        {
24849 jghali 1863
                                if (tagName == QLatin1String("PAGEOBJECT"))
13971 jghali 1864
                                {
16943 fschmid 1865
                                        if (itemInfo.nextItem != -1)
1866
                                                itemNext[itemInfo.ownNr] = itemInfo.nextItem;
13971 jghali 1867
                                }
24849 jghali 1868
                                else if (tagName == QLatin1String("MASTEROBJECT"))
13971 jghali 1869
                                {
16943 fschmid 1870
                                        if (itemInfo.nextItem != -1)
1871
                                                itemNextM[itemInfo.ownNr] = itemInfo.nextItem;
13971 jghali 1872
                                }
16943 fschmid 1873
                                if (itemInfo.item->isTableItem)
13971 jghali 1874
                                {
24849 jghali 1875
                                        if (tagName == QLatin1String("PAGEOBJECT"))
16943 fschmid 1876
                                        {
1877
                                                TableItems.append(itemInfo.item);
1878
                                                TableID.insert(itemInfo.ownLink, itemInfo.item);
1879
                                        }
24849 jghali 1880
                                        else if (tagName == QLatin1String("FRAMEOBJECT"))
16943 fschmid 1881
                                        {
1882
                                                TableItemsF.append(itemInfo.item);
1883
                                                TableIDF.insert(itemInfo.ownLink, itemInfo.item);
1884
                                        }
1885
                                        else
1886
                                        {
1887
                                                TableItemsM.append(itemInfo.item);
1888
                                                TableIDM.insert(itemInfo.ownLink, itemInfo.item);
1889
                                        }
13971 jghali 1890
                                }
16943 fschmid 1891
 
1892
                                if (itemInfo.isWeldFlag)
1893
                                {
1894
                                        WeldItems.append(itemInfo.item);
1895
                                        WeldID.insert(itemInfo.ownWeld, itemInfo.item);
1896
                                }
13971 jghali 1897
                        }
23458 jghali 1898
 
24849 jghali 1899
                        if ((tagName == QLatin1String("PAGEOBJECT")) && (groupStackPI.count() > 0))
13971 jghali 1900
                        {
23458 jghali 1901
                                groupStackPI.top().append(itemInfo.item);
1902
                                while (itemInfo.ownNr == groupStackPI2.top())
16105 fschmid 1903
                                {
23458 jghali 1904
                                        groupStackP.push(groupStackPI.pop());
1905
                                        groupStackPI2.pop();
1906
                                        if (groupStackPI2.count() == 0)
16233 fschmid 1907
                                                break;
16105 fschmid 1908
                                }
13971 jghali 1909
                        }
24849 jghali 1910
                        else if ((tagName == QLatin1String("FRAMEOBJECT")) && (groupStackFI.count() > 0))
23458 jghali 1911
                        {
1912
                                groupStackFI.top().append(itemInfo.item);
1913
                                while (itemInfo.ownNr == groupStackFI2.top())
1914
                                {
1915
                                        groupStackF.push(groupStackFI.pop());
1916
                                        groupStackFI2.pop();
1917
                                        if (groupStackFI2.count() == 0)
1918
                                                break;
1919
                                }
1920
                        }
24849 jghali 1921
                        else if ((tagName == QLatin1String("MASTEROBJECT")) && (groupStackMI.count() > 0))
23458 jghali 1922
                        {
1923
                                groupStackMI.top().append(itemInfo.item);
1924
                                while (itemInfo.ownNr == groupStackMI2.top())
1925
                                {
1926
                                        groupStackM.push(groupStackMI.pop());
1927
                                        groupStackMI2.pop();
1928
                                        if (groupStackMI2.count() == 0)
1929
                                                break;
1930
                                }
1931
                        }
1932
 
16113 fschmid 1933
                        if (itemInfo.isGroupFlag)
16105 fschmid 1934
                        {
23458 jghali 1935
                                QList<PageItem*> groupItems;
1936
                                groupItems.append(itemInfo.item);
24849 jghali 1937
                                if (tagName == QLatin1String("PAGEOBJECT"))
23458 jghali 1938
                                {
1939
                                        groupStackPI.push(groupItems);
1940
                                        groupStackPI2.push(itemInfo.groupLastItem + itemInfo.ownNr);
1941
                                }
24849 jghali 1942
                                else if (tagName == QLatin1String("FRAMEOBJECT"))
23458 jghali 1943
                                {
1944
                                        groupStackFI.push(groupItems);
1945
                                        groupStackFI2.push(itemInfo.groupLastItem + itemInfo.ownNr);
1946
                                }
1947
                                else
1948