Subversion Repositories Scribus

Rev

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