Subversion Repositories Scribus

Rev

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

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