Subversion Repositories Scribus

Rev

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

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