Subversion Repositories Scribus

Rev

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