Subversion Repositories Scribus

Rev

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

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