Subversion Repositories Scribus

Rev

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