Subversion Repositories Scribus

Rev

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