Subversion Repositories Scribus

Rev

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