Subversion Repositories Scribus

Rev

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

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