Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
17199 fschmid 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
/***************************************************************************
8
                                                         -------------------
9
        begin                : Sat Jan 14 2012
10
        copyright            : (C) 2012 by Franz Schmid
11
        email                : Franz.Schmid@altmuehlnet.de
12
 ***************************************************************************/
13
 
14
#include <QByteArray>
15
#include <QCursor>
16
#include <QDrag>
17
#include <QFile>
18
#include <QList>
19
#include <QMimeData>
20
#include <QRegExp>
21
#include <QStack>
17209 fschmid 22
#include <QUrl>
17199 fschmid 23
#include <QDebug>
24
 
17539 jghali 25
#if defined(_MSC_VER) && !defined(_USE_MATH_DEFINES)
17203 jghali 26
#define _USE_MATH_DEFINES
27
#endif
28
 
17199 fschmid 29
#include <cstdlib>
30
#include <climits>
31
#include <limits>
32
 
33
#include "commonstrings.h"
17203 jghali 34
 
17199 fschmid 35
#include "importidml.h"
36
#include "loadsaveplugin.h"
17349 fschmid 37
#include "pageitem_table.h"
17199 fschmid 38
#include "pagesize.h"
39
#include "prefscontext.h"
40
#include "prefsfile.h"
41
#include "prefsmanager.h"
42
#include "prefstable.h"
43
#include "rawimage.h"
44
#include "scclocale.h"
45
#include "sccolorengine.h"
46
#include "scconfig.h"
47
#include "scmimedata.h"
48
#include "scpaths.h"
49
#include "scribus.h"
50
#include "scribusXml.h"
51
#include "scribuscore.h"
52
#include "sctextstream.h"
53
#include "selection.h"
54
#include "undomanager.h"
55
#include "util.h"
56
#include "util_formats.h"
57
#include "util_icon.h"
58
#include "util_math.h"
59
 
17203 jghali 60
#include "ui/customfdialog.h"
61
#include "ui/missing.h"
62
#include "ui/multiprogressdialog.h"
63
#include "ui/propertiespalette.h"
64
 
17199 fschmid 65
extern SCRIBUS_API ScribusQApp * ScQApp;
66
 
67
IdmlPlug::IdmlPlug(ScribusDoc* doc, int flags)
68
{
69
        tmpSel = new Selection(this, false);
70
        m_Doc = doc;
71
        importerFlags = flags;
72
        interactive = (flags & LoadSavePlugin::lfInteractive);
73
        progressDialog = NULL;
17222 fschmid 74
        fun = NULL;
17199 fschmid 75
}
76
 
77
QString IdmlPlug::getNodeValue(QDomNode &baseNode, QString path)
78
{
79
        QString ret = "";
80
        QStringList pathParts = path.split("/", QString::SkipEmptyParts);
81
        QDomNode n = baseNode.namedItem(pathParts[0]);
82
        bool fail = false;
83
        if (!n.isNull())
84
        {
85
                for (int a = 1; a < pathParts.count(); a++)
86
                {
87
                        n = n.namedItem(pathParts[a]);
88
                        if (n.isNull())
89
                        {
90
                                fail = true;
91
                                break;
92
                        }
93
                }
94
                if (!fail)
95
                {
96
                        QDomElement e = n.toElement();
97
                        if (!e.isNull())
98
                                ret = e.text();
99
                }
100
        }
101
        return ret;
102
}
103
 
104
QImage IdmlPlug::readThumbnail(QString fName)
105
{
106
        QImage tmp;
17222 fschmid 107
        QByteArray f;
108
        QString designMap;
17199 fschmid 109
        if ( !QFile::exists(fName) )
110
                return QImage();
17222 fschmid 111
        QFileInfo fi = QFileInfo(fName);
112
        QString ext = fi.suffix().toLower();
113
        if (ext == "idml")
114
        {
115
                fun = new FileUnzip(fName);
116
                designMap = fun->getFile("designmap.xml");
117
        }
118
        else if (ext == "idms")
119
        {
120
                designMap = fName;
121
                fun = NULL;
122
        }
17199 fschmid 123
        if (!designMap.isNull())
124
        {
125
                loadRawText(designMap, f);
126
                delete fun;
127
                if(!designMapDom.setContent(f))
128
                        return QImage();
17267 fschmid 129
                bool found = false;
17199 fschmid 130
                QDomElement docElem = designMapDom.documentElement();
131
                QString metaD = getNodeValue(docElem, "MetadataPacketPreference/Properties/Contents");
132
                QDomDocument rdfD;
133
                rdfD.setContent(metaD);
134
                QDomElement docElemR = rdfD.documentElement();
135
                for(QDomNode drawPag = docElemR.firstChild(); !drawPag.isNull(); drawPag = drawPag.nextSibling() )
136
                {
137
                        QDomElement dpg = drawPag.toElement();
138
                        if (dpg.tagName() == "rdf:RDF")
139
                        {
140
                                for(QDomNode drawPag2 = dpg.firstChild(); !drawPag2.isNull(); drawPag2 = drawPag2.nextSibling() )
141
                                {
142
                                        QDomElement dpg2 = drawPag2.toElement();
143
                                        if (dpg2.hasAttribute("xmlns:xmpGImg"))
144
                                        {
145
                                                QByteArray imgD = getNodeValue(dpg2, "xmp:Thumbnails/rdf:Alt/rdf:li/xmpGImg:image").toLatin1();
146
                                                QByteArray inlineImageData = QByteArray::fromBase64(imgD);
147
                                                tmp.loadFromData(inlineImageData);
17267 fschmid 148
                                                found = true;
17199 fschmid 149
                                        }
150
                                }
151
                        }
152
                }
17267 fschmid 153
                if (!found)
17199 fschmid 154
                {
17267 fschmid 155
                        progressDialog = NULL;
156
                        QFileInfo fi = QFileInfo(fName);
157
                        baseFile = QDir::cleanPath(QDir::toNativeSeparators(fi.absolutePath()+"/"));
158
                        docWidth = PrefsManager::instance()->appPrefs.docSetupPrefs.pageWidth;
159
                        docHeight = PrefsManager::instance()->appPrefs.docSetupPrefs.pageHeight;
160
                        m_Doc = new ScribusDoc();
161
                        m_Doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
162
                        m_Doc->setPage(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, false);
163
                        m_Doc->addPage(0);
164
                        m_Doc->setGUI(false, ScCore->primaryMainWindow(), 0);
165
                        baseX = m_Doc->currentPage()->xOffset();
166
                        baseY = m_Doc->currentPage()->yOffset() + m_Doc->currentPage()->height() / 2.0;
167
                        Elements.clear();
168
                        m_Doc->setLoading(true);
169
                        m_Doc->DoDrawing = false;
170
                        m_Doc->scMW()->setScriptRunning(true);
171
                        QString CurDirP = QDir::currentPath();
172
                        QDir::setCurrent(fi.path());
173
                        if (convert(fName))
17199 fschmid 174
                        {
17267 fschmid 175
                                tmpSel->clear();
176
                                QDir::setCurrent(CurDirP);
177
                                if (Elements.count() > 1)
178
                                        m_Doc->groupObjectsList(Elements);
179
                                m_Doc->DoDrawing = true;
180
                                m_Doc->m_Selection->delaySignalsOn();
181
                                QImage tmpImage;
182
                                if (Elements.count() > 0)
183
                                {
184
                                        for (int dre=0; dre<Elements.count(); ++dre)
185
                                        {
186
                                                tmpSel->addItem(Elements.at(dre), true);
187
                                        }
188
                                        tmpSel->setGroupRect();
189
                                        double xs = tmpSel->width();
190
                                        double ys = tmpSel->height();
191
                                        tmpImage = Elements.at(0)->DrawObj_toImage(500);
192
                                        tmpImage.setText("XSize", QString("%1").arg(xs));
193
                                        tmpImage.setText("YSize", QString("%1").arg(ys));
194
                                }
195
                                m_Doc->scMW()->setScriptRunning(false);
196
                                m_Doc->setLoading(false);
197
                                m_Doc->m_Selection->delaySignalsOff();
198
                                delete m_Doc;
199
                                return tmpImage;
17199 fschmid 200
                        }
17267 fschmid 201
                        else
202
                        {
203
                                QDir::setCurrent(CurDirP);
204
                                m_Doc->DoDrawing = true;
205
                                m_Doc->scMW()->setScriptRunning(false);
206
                                delete m_Doc;
207
                        }
17199 fschmid 208
                }
209
        }
17267 fschmid 210
        return tmp;
17199 fschmid 211
}
212
 
213
bool IdmlPlug::readColors(const QString& fNameIn, ColorList & colors)
214
{
215
        bool success = false;
216
        importedColors.clear();
217
        m_Doc = new ScribusDoc();
218
        m_Doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
219
        m_Doc->setPage(1, 1, 0, 0, 0, 0, 0, 0, false, false);
220
        m_Doc->addPage(0);
221
        m_Doc->setGUI(false, ScCore->primaryMainWindow(), 0);
222
        QByteArray f;
17222 fschmid 223
        QString designMap;
224
        QFileInfo fi = QFileInfo(fNameIn);
225
        QString ext = fi.suffix().toLower();
226
        if (ext == "idml")
227
        {
228
                fun = new FileUnzip(fNameIn);
229
                designMap = fun->getFile("designmap.xml");
230
        }
231
        else if (ext == "idms")
232
        {
233
                designMap = fNameIn;
234
                fun = NULL;
235
        }
17199 fschmid 236
        if (!designMap.isNull())
237
        {
238
                loadRawText(designMap, f);
239
                if(designMapDom.setContent(f))
240
                {
241
                        QDomElement docElem = designMapDom.documentElement();
17222 fschmid 242
                        if (ext == "idms")
17199 fschmid 243
                        {
17222 fschmid 244
                                parseGraphicsXMLNode(docElem);
245
                        }
246
                        else
247
                        {
248
                                for(QDomNode drawPag = docElem.firstChild(); !drawPag.isNull(); drawPag = drawPag.nextSibling() )
17199 fschmid 249
                                {
17222 fschmid 250
                                        QDomElement dpg = drawPag.toElement();
251
                                        if (dpg.tagName() == "idPkg:Graphic")
17199 fschmid 252
                                        {
17222 fschmid 253
                                                if (!parseGraphicsXML(dpg))
254
                                                {
255
                                                        delete fun;
256
                                                        return false;
257
                                                }
17199 fschmid 258
                                        }
259
                                }
260
                        }
261
                }
262
        }
263
        delete fun;
264
        if (importedColors.count() != 0)
265
        {
266
                colors = m_Doc->PageColors;
267
                success = true;
268
        }
269
        delete m_Doc;
270
        return success;
271
}
272
 
273
bool IdmlPlug::import(QString fNameIn, const TransactionSettings& trSettings, int flags, bool showProgress)
274
{
275
        QString fName = fNameIn;
276
        bool success = false;
277
        interactive = (flags & LoadSavePlugin::lfInteractive);
278
        importerFlags = flags;
279
        cancel = false;
280
        bool ret = false;
281
        firstLayer = true;
282
        firstPage = true;
283
        pagecount = 1;
17222 fschmid 284
        mpagecount = 0;
17199 fschmid 285
        QFileInfo fi = QFileInfo(fName);
286
        if ( !ScCore->usingGUI() )
287
        {
288
                interactive = false;
289
                showProgress = false;
290
        }
291
        baseFile = QDir::cleanPath(QDir::toNativeSeparators(fi.absolutePath()+"/"));
292
        if ( showProgress )
293
        {
294
                ScribusMainWindow* mw=(m_Doc==0) ? ScCore->primaryMainWindow() : m_Doc->scMW();
295
                progressDialog = new MultiProgressDialog( tr("Importing: %1").arg(fi.fileName()), CommonStrings::tr_Cancel, mw );
296
                QStringList barNames, barTexts;
297
                barNames << "GI";
298
                barTexts << tr("Analyzing File:");
299
                QList<bool> barsNumeric;
300
                barsNumeric << false;
301
                progressDialog->addExtraProgressBars(barNames, barTexts, barsNumeric);
302
                progressDialog->setOverallTotalSteps(3);
303
                progressDialog->setOverallProgress(0);
304
                progressDialog->setProgress("GI", 0);
305
                progressDialog->show();
306
                connect(progressDialog, SIGNAL(canceled()), this, SLOT(cancelRequested()));
307
                qApp->processEvents();
308
        }
309
        else
310
                progressDialog = NULL;
311
        if (progressDialog)
312
        {
313
                progressDialog->setOverallProgress(1);
314
                qApp->processEvents();
315
        }
316
        /* Set default Page to size defined in Preferences */
317
        docWidth = PrefsManager::instance()->appPrefs.docSetupPrefs.pageWidth;
318
        docHeight = PrefsManager::instance()->appPrefs.docSetupPrefs.pageHeight;
319
        baseX = 0;
320
        baseY = 0;
321
        if (!interactive || (flags & LoadSavePlugin::lfInsertPage))
322
        {
323
                m_Doc->setPage(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, false);
324
                m_Doc->addPage(0);
325
                m_Doc->view()->addPage(0, true);
326
                baseX = 0;
327
                baseY = 0;
328
        }
329
        else
330
        {
331
                if (!m_Doc || (flags & LoadSavePlugin::lfCreateDoc))
332
                {
333
                        m_Doc=ScCore->primaryMainWindow()->doFileNew(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, false, 0, false, 0, 1, "Custom", true);
334
                        ScCore->primaryMainWindow()->HaveNewDoc();
335
                        ret = true;
336
                        baseX = 0;
337
                        baseY = 0;
338
                        baseX = m_Doc->currentPage()->xOffset();
339
                        baseY = m_Doc->currentPage()->yOffset() + m_Doc->currentPage()->height() / 2.0;
340
                }
341
        }
342
        if ((!ret) && (interactive))
343
        {
344
                baseX = m_Doc->currentPage()->xOffset();
345
                baseY = m_Doc->currentPage()->yOffset() + m_Doc->currentPage()->height() / 2.0;
346
        }
347
        if ((ret) || (!interactive))
348
        {
349
                if (docWidth > docHeight)
350
                        m_Doc->setPageOrientation(1);
351
                else
352
                        m_Doc->setPageOrientation(0);
353
                m_Doc->setPageSize("Custom");
354
        }
355
        Elements.clear();
356
        m_Doc->setLoading(true);
357
        m_Doc->DoDrawing = false;
358
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
359
                m_Doc->view()->updatesOn(false);
360
        m_Doc->scMW()->setScriptRunning(true);
361
        qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
362
        QString CurDirP = QDir::currentPath();
363
        QDir::setCurrent(fi.path());
364
        if (convert(fName))
365
        {
366
                tmpSel->clear();
367
                QDir::setCurrent(CurDirP);
368
                if ((Elements.count() > 1) && (!(importerFlags & LoadSavePlugin::lfCreateDoc)))
369
                        m_Doc->groupObjectsList(Elements);
370
                m_Doc->DoDrawing = true;
371
                m_Doc->scMW()->setScriptRunning(false);
372
                m_Doc->setLoading(false);
373
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
374
                if ((Elements.count() > 0) && (!ret) && (interactive))
375
                {
376
                        if (flags & LoadSavePlugin::lfScripted)
377
                        {
378
                                bool loadF = m_Doc->isLoading();
379
                                m_Doc->setLoading(false);
380
                                m_Doc->changed();
381
                                m_Doc->setLoading(loadF);
382
                                if (!(flags & LoadSavePlugin::lfLoadAsPattern))
383
                                {
384
                                        m_Doc->m_Selection->delaySignalsOn();
385
                                        for (int dre=0; dre<Elements.count(); ++dre)
386
                                        {
387
                                                m_Doc->m_Selection->addItem(Elements.at(dre), true);
388
                                        }
389
                                        m_Doc->m_Selection->delaySignalsOff();
390
                                        m_Doc->m_Selection->setGroupRect();
391
                                        m_Doc->view()->updatesOn(true);
392
                                }
393
                        }
394
                        else
395
                        {
396
                                m_Doc->DragP = true;
397
                                m_Doc->DraggedElem = 0;
398
                                m_Doc->DragElements.clear();
399
                                m_Doc->m_Selection->delaySignalsOn();
400
                                for (int dre=0; dre<Elements.count(); ++dre)
401
                                {
402
                                        tmpSel->addItem(Elements.at(dre), true);
403
                                }
404
                                tmpSel->setGroupRect();
18028 jghali 405
                                ScElemMimeData* md = ScriXmlDoc::WriteToMimeData(m_Doc, tmpSel);
17199 fschmid 406
                                m_Doc->itemSelection_DeleteItem(tmpSel);
407
                                m_Doc->view()->updatesOn(true);
408
                                m_Doc->m_Selection->delaySignalsOff();
409
                                // We must copy the TransationSettings object as it is owned
410
                                // by handleObjectImport method afterwards
411
                                TransactionSettings* transacSettings = new TransactionSettings(trSettings);
412
                                m_Doc->view()->handleObjectImport(md, transacSettings);
413
                                m_Doc->DragP = false;
414
                                m_Doc->DraggedElem = 0;
415
                                m_Doc->DragElements.clear();
416
                        }
417
                }
418
                else
419
                {
420
                        m_Doc->changed();
421
                        m_Doc->reformPages();
422
                        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
423
                                m_Doc->view()->updatesOn(true);
424
                }
425
                success = true;
426
        }
427
        else
428
        {
429
                QDir::setCurrent(CurDirP);
430
                m_Doc->DoDrawing = true;
431
                m_Doc->scMW()->setScriptRunning(false);
432
                if (!(flags & LoadSavePlugin::lfLoadAsPattern))
433
                        m_Doc->view()->updatesOn(true);
434
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
435
        }
436
        if (interactive)
437
                m_Doc->setLoading(false);
438
        //CB If we have a gui we must refresh it if we have used the progressbar
439
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
440
        {
441
                if ((showProgress) && (!interactive))
442
                        m_Doc->view()->DrawNew();
443
        }
444
        return success;
445
}
446
 
447
IdmlPlug::~IdmlPlug()
448
{
449
        if (progressDialog)
450
                delete progressDialog;
451
        delete tmpSel;
452
}
453
 
454
bool IdmlPlug::convert(QString fn)
455
{
456
        Coords.resize(0);
457
        Coords.svgInit();
458
        importedColors.clear();
459
        def_fillColor = CommonStrings::None;
460
        def_strokeColor = CommonStrings::None;
461
        def_fillGradient = "";
17232 fschmid 462
        def_strokeGradient = "";
17199 fschmid 463
        def_Blendmode = 0;
464
        def_fillBlendmode = 0;
465
        def_strokeBlendmode = 0;
466
        def_fillTint = 100;
467
        def_strokeTint = 100;
468
        def_lineWidth = 0;
469
        def_Opacity = 0.0;
470
        def_fillOpacity = 0.0;
471
        def_strokeOpacity = 0.0;
472
        def_gradientAngle = 0.0;
473
        def_gradientLen = 0.0;
474
        def_gradientX = 0.0;
475
        def_gradientY = 0.0;
17232 fschmid 476
        def_gradientStrokeStartX = 0;
477
        def_gradientStrokeStartY = 0;
478
        def_gradientStrokeLength = 0;
479
        def_gradientStrokeAngle = 0;
17239 fschmid 480
        def_Extra = 0;
481
        def_TExtra = 0;
482
        def_BExtra = 0;
483
        def_RExtra = 0;
17206 fschmid 484
        def_TextFlow = PageItem::TextFlowDisabled;
17239 fschmid 485
        def_TextColumnCount = 1;
486
        def_TextColumnGutter = 0;
487
        def_TextColumnFixedWidth = 0;
17209 fschmid 488
        frameLinks.clear();
489
        frameTargets.clear();
490
        importedColors.clear();
491
        colorTranslate.clear();
492
        importedGradients.clear();
493
        gradientTranslate.clear();
494
        gradientTypeMap.clear();
495
        layerTranslate.clear();
496
        storyMap.clear();
497
        styleTranslate.clear();
498
        charStyleTranslate.clear();
17210 fschmid 499
        ObjectStyles.clear();
17199 fschmid 500
        if(progressDialog)
501
        {
502
                progressDialog->setOverallProgress(2);
503
                progressDialog->setLabel("GI", tr("Generating Items"));
504
                qApp->processEvents();
505
        }
506
        colorTranslate.insert("Swatch/None", CommonStrings::None);
507
        bool retVal = true;
508
        bool firstSpread = true;
509
        QByteArray f;
17222 fschmid 510
        QString designMap;
511
        QFileInfo fi = QFileInfo(fn);
512
        QString ext = fi.suffix().toLower();
513
        if (ext == "idml")
514
        {
515
                fun = new FileUnzip(fn);
516
                designMap = fun->getFile("designmap.xml");
517
        }
518
        else if (ext == "idms")
519
        {
520
                designMap = fn;
521
                fun = NULL;
522
        }
17199 fschmid 523
        if (!designMap.isNull())
524
        {
525
                loadRawText(designMap, f);
526
                if(designMapDom.setContent(f))
527
                {
528
                        QDomElement docElem = designMapDom.documentElement();
529
                        QString activeLayer = docElem.attribute("ActiveLayer");
17222 fschmid 530
                        if (ext == "idms")
17199 fschmid 531
                        {
17222 fschmid 532
                                for(QDomNode drawPag = docElem.firstChild(); !drawPag.isNull(); drawPag = drawPag.nextSibling() )
17199 fschmid 533
                                {
17222 fschmid 534
                                        QDomElement dpg = drawPag.toElement();
535
                                        if (dpg.tagName() == "Layer")
17199 fschmid 536
                                        {
17222 fschmid 537
                                                QString layerSelf = dpg.attribute("Self");
538
                                                QString layerName = dpg.attribute("Name");
539
                                                if (importerFlags & LoadSavePlugin::lfCreateDoc)
540
                                                {
541
                                                        int currentLayer = 0;
542
                                                        if (!firstLayer)
543
                                                                currentLayer = m_Doc->addLayer(layerName);
544
                                                        else
545
                                                                m_Doc->changeLayerName(currentLayer, layerName);
546
                                                        m_Doc->setLayerVisible(currentLayer, (dpg.attribute("Visible") == "true"));
547
                                                        m_Doc->setLayerLocked(currentLayer, (dpg.attribute("Locked") == "true"));
548
                                                        m_Doc->setLayerPrintable(currentLayer, (dpg.attribute("Printable") == "true"));
549
                                                        m_Doc->setLayerFlow(currentLayer, (dpg.attribute("IgnoreWrap","") == "true"));
550
                                                }
551
                                                layerTranslate.insert(layerSelf, layerName);
552
                                                firstLayer = false;
17199 fschmid 553
                                        }
554
                                }
17222 fschmid 555
                                parseGraphicsXMLNode(docElem);
556
                                parseStylesXMLNode(docElem);
557
                                parsePreferencesXMLNode(docElem);
558
                                parseSpreadXMLNode(docElem);
559
                                parseStoryXMLNode(docElem);
560
                        }
561
                        else
562
                        {
563
                                for(QDomNode drawPag = docElem.firstChild(); !drawPag.isNull(); drawPag = drawPag.nextSibling() )
17199 fschmid 564
                                {
17222 fschmid 565
                                        QDomElement dpg = drawPag.toElement();
566
                                        if (dpg.tagName() == "Layer")
17199 fschmid 567
                                        {
17222 fschmid 568
                                                QString layerSelf = dpg.attribute("Self");
569
                                                QString layerName = dpg.attribute("Name");
570
                                                if (importerFlags & LoadSavePlugin::lfCreateDoc)
571
                                                {
572
                                                        int currentLayer = 0;
573
                                                        if (!firstLayer)
574
                                                                currentLayer = m_Doc->addLayer(layerName);
575
                                                        else
576
                                                                m_Doc->changeLayerName(currentLayer, layerName);
577
                                                        m_Doc->setLayerVisible(currentLayer, (dpg.attribute("Visible") == "true"));
578
                                                        m_Doc->setLayerLocked(currentLayer, (dpg.attribute("Locked") == "true"));
579
                                                        m_Doc->setLayerPrintable(currentLayer, (dpg.attribute("Printable") == "true"));
580
                                                        m_Doc->setLayerFlow(currentLayer, (dpg.attribute("IgnoreWrap","") == "true"));
581
                                                }
582
                                                layerTranslate.insert(layerSelf, layerName);
583
                                                firstLayer = false;
17199 fschmid 584
                                        }
17222 fschmid 585
                                        if (dpg.tagName() == "idPkg:Graphic")
17199 fschmid 586
                                        {
17222 fschmid 587
                                                if (!parseGraphicsXML(dpg))
588
                                                {
589
                                                        retVal = false;
590
                                                        break;
591
                                                }
17199 fschmid 592
                                        }
17222 fschmid 593
                                        if (dpg.tagName() == "idPkg:Styles")
17199 fschmid 594
                                        {
17222 fschmid 595
                                                if (!parseStylesXML(dpg))
596
                                                {
597
                                                        retVal = false;
598
                                                        break;
599
                                                }
17199 fschmid 600
                                        }
17222 fschmid 601
                                        if (dpg.tagName() == "idPkg:Preferences")
17199 fschmid 602
                                        {
17222 fschmid 603
                                                if (!parsePreferencesXML(dpg))
17199 fschmid 604
                                                {
17222 fschmid 605
                                                        retVal = false;
606
                                                        break;
17199 fschmid 607
                                                }
608
                                        }
17222 fschmid 609
                                        if (dpg.tagName() == "idPkg:MasterSpread")
17199 fschmid 610
                                        {
17222 fschmid 611
                                                if (importerFlags & LoadSavePlugin::lfCreateDoc)
612
                                                {
613
                                                        if (!parseSpreadXML(dpg))
614
                                                        {
615
                                                                retVal = false;
616
                                                                break;
617
                                                        }
618
                                                }
17199 fschmid 619
                                        }
17222 fschmid 620
                                        if (dpg.tagName() == "idPkg:Spread")
17199 fschmid 621
                                        {
17222 fschmid 622
                                                if (!(importerFlags & LoadSavePlugin::lfCreateDoc))
623
                                                {
624
                                                        if (firstSpread)
625
                                                        {
626
                                                                parseSpreadXML(dpg);
627
                                                                firstSpread = false;
628
                                                        }
629
                                                }
630
                                                else if (!parseSpreadXML(dpg))
631
                                                {
632
                                                        retVal = false;
633
                                                        break;
634
                                                }
17199 fschmid 635
                                        }
17222 fschmid 636
                                        if (dpg.tagName() == "idPkg:Story")
637
                                        {
638
                                                if (!parseStoryXML(dpg))
639
                                                {
640
                                                        retVal = false;
641
                                                        break;
642
                                                }
643
                                        }
17199 fschmid 644
                                }
645
                        }
17209 fschmid 646
                        if (!frameLinks.isEmpty())
647
                        {
648
                                QMap<PageItem*, QString>::Iterator lc;
649
                                for (lc = frameLinks.begin(); lc != frameLinks.end(); ++lc)
650
                                {
651
                                        PageItem *Its = lc.key();
652
                                        PageItem *Itn = frameTargets[lc.value()];
653
                                        if (Its->testLinkCandidate(Itn))
654
                                                Its->link(Itn);
655
                                }
656
                        }
17199 fschmid 657
                        if (importerFlags & LoadSavePlugin::lfCreateDoc)
658
                        {
659
                                if (layerTranslate.contains(activeLayer))
660
                                        activeLayer = layerTranslate[activeLayer];
661
                                else
662
                                        activeLayer = m_Doc->layerName(0);
663
                                m_Doc->setActiveLayer(activeLayer);
664
                        }
665
                }
666
        }
17222 fschmid 667
        if (fun != NULL)
668
                delete fun;
17199 fschmid 669
        if (progressDialog)
670
                progressDialog->close();
671
        return retVal;
672
}
673
 
674
bool IdmlPlug::parseGraphicsXML(const QDomElement& grElem)
675
{
676
        QDomElement grNode;
677
        QDomDocument grMapDom;
678
        if (grElem.hasAttribute("src"))
679
        {
680
                QByteArray f2;
681
                loadRawText(fun->getFile(grElem.attribute("src")), f2);
682
                if(grMapDom.setContent(f2))
683
                        grNode = grMapDom.documentElement();
684
                else
685
                        return false;
686
        }
687
        else
688
        {
689
                if (grElem.hasChildNodes())
690
                        grNode = grElem;
691
                else
692
                        return false;
693
        }
17222 fschmid 694
        parseGraphicsXMLNode(grNode);
695
        return true;
696
}
697
 
698
void IdmlPlug::parseGraphicsXMLNode(const QDomElement& grNode)
699
        {
17199 fschmid 700
        for (QDomNode n = grNode.firstChild(); !n.isNull(); n = n.nextSibling() )
701
        {
702
                QDomElement e = n.toElement();
703
                if (e.tagName() == "Color")
704
                {
705
                        QString colorSelf = e.attribute("Self");
706
                        QString colorName = e.attribute("Self").remove(0, 6);
707
                        QString colorData = e.attribute("ColorValue");
708
                        QString colorSpace = e.attribute("Space");
709
                        QString colorModel = e.attribute("Model");
710
                        if (colorSpace == "CMYK")
711
                        {
712
                                double c, m, y, k;
713
                                ScColor tmp;
714
                                ScTextStream Code(&colorData, QIODevice::ReadOnly);
715
                                Code >> c >> m >> y >> k;
716
                                tmp.setColor(qRound(c * 2.55), qRound(m * 2.55), qRound(y * 2.55), qRound(k * 2.55));
717
                                tmp.setSpotColor(colorModel == "Spot");
718
                                tmp.setRegistrationColor(colorModel == "Registration");
719
                                QString fNam = m_Doc->PageColors.tryAddColor(colorName, tmp);
720
                                if (fNam == colorName)
721
                                        importedColors.append(fNam);
722
                                colorTranslate.insert(colorSelf, fNam);
723
                        }
724
                        else if (colorSpace == "RGB")
725
                        {
726
                                int r, g, b;
727
                                ScColor tmp;
728
                                ScTextStream Code(&colorData, QIODevice::ReadOnly);
729
                                Code >> r >> g >> b;
730
                                tmp.setColorRGB(r, g, b);
731
                                tmp.setSpotColor(false);
732
                                tmp.setRegistrationColor(false);
733
                                QString fNam = m_Doc->PageColors.tryAddColor(colorName, tmp);
734
                                if (fNam == colorName)
735
                                        importedColors.append(fNam);
736
                                colorTranslate.insert(colorSelf, fNam);
737
                        }
738
                }
17232 fschmid 739
                else if (e.tagName() == "Gradient")
17199 fschmid 740
                {
741
                        QString grSelf = e.attribute("Self");
742
                        QString grName = e.attribute("Self").remove(0, 9);
743
                        int grTyp = (e.attribute("Type") == "Linear") ? 6 : 7;
744
                        VGradient currentGradient = VGradient(VGradient::linear);
745
                        currentGradient.clearStops();
746
                        for(QDomNode gr = e.firstChild(); !gr.isNull(); gr = gr.nextSibling() )
747
                        {
748
                                QDomElement grs = gr.toElement();
749
                                if (grs.tagName() == "GradientStop")
750
                                {
751
                                        QString stopName = grs.attribute("StopColor");
752
                                        double stop = grs.attribute("Location", "0.0").toDouble();
753
                                        if (colorTranslate.contains(stopName))
754
                                                stopName = colorTranslate[stopName];
755
                                        else
756
                                                stopName = "Black";
757
                                        const ScColor& gradC = m_Doc->PageColors[stopName];
758
                                        currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), stop / 100.0, 0.5, 1.0, stopName, 100 );
759
                                }
760
                        }
761
                        if (m_Doc->addGradient(grName, currentGradient))
762
                                importedGradients.append(grName);
763
                        gradientTranslate.insert(grSelf, grName);
764
                        gradientTypeMap.insert(grSelf, grTyp);
765
                }
17232 fschmid 766
                else if (e.tagName() == "Tint")
767
                {
768
                        QString colorSelf = e.attribute("Self");
769
                        QString colorName = e.attribute("Self").remove(0, 5);
770
                        QString baseName = e.attribute("BaseColor", "Black");
771
                        double tint = e.attribute("TintValue", "100").toDouble() / 100.0;
772
                        if (colorTranslate.contains(baseName))
773
                        {
774
                                ScColor tmp = m_Doc->PageColors[colorTranslate[baseName]];
775
                                ScColor res;
776
                                if (tmp.getColorModel() == colorModelCMYK)
777
                                {
778
                                        int c, m, y, k;
779
                                        tmp.getCMYK(&c, &m, &y, &k);
780
                                        res.setColor(qRound(c * tint), qRound(m * tint), qRound(y * tint), qRound(k * tint));
781
                                }
782
                                else
783
                                {
784
                                        int r, g, b;
785
                                        tmp.getRGB(&r, &g, &b);
786
                                        res.setColorRGB(qRound(r * tint), qRound(g * tint), qRound(b * tint));
787
                                }
788
                                res.setSpotColor(false);
789
                                res.setRegistrationColor(false);
790
                                QString fNam = m_Doc->PageColors.tryAddColor(colorName, res);
791
                                if (fNam == colorName)
792
                                        importedColors.append(fNam);
793
                                colorTranslate.insert(colorSelf, fNam);
794
                        }
795
                }
17199 fschmid 796
        }
17222 fschmid 797
        return;
17199 fschmid 798
}
799
 
800
bool IdmlPlug::parseStylesXML(const QDomElement& sElem)
801
{
802
        QDomElement sNode;
803
        QDomDocument sMapDom;
804
        if (sElem.hasAttribute("src"))
805
        {
806
                QByteArray f2;
807
                loadRawText(fun->getFile(sElem.attribute("src")), f2);
808
                if(sMapDom.setContent(f2))
809
                        sNode = sMapDom.documentElement();
810
                else
811
                        return false;
812
        }
813
        else
814
        {
815
                if (sElem.hasChildNodes())
816
                        sNode = sElem;
817
                else
818
                        return false;
819
        }
17222 fschmid 820
        parseStylesXMLNode(sNode);
821
        return true;
822
}
823
 
824
void IdmlPlug::parseStylesXMLNode(const QDomElement& sNode)
825
{
17199 fschmid 826
        for (QDomNode n = sNode.firstChild(); !n.isNull(); n = n.nextSibling() )
827
        {
828
                QDomElement e = n.toElement();
17208 fschmid 829
                if (e.tagName() == "RootCharacterStyleGroup")
830
                {
831
                        for(QDomNode it = e.firstChild(); !it.isNull(); it = it.nextSibling() )
832
                        {
833
                                QDomElement itpg = it.toElement();
834
                                if (itpg.tagName() == "CharacterStyle")
835
                                        parseCharacterStyle(itpg);
836
                                else if (itpg.tagName() == "CharacterStyleGroup")
837
                                {
838
                                        for(QDomNode its = itpg.firstChild(); !its.isNull(); its = its.nextSibling() )
839
                                        {
840
                                                QDomElement itp = its.toElement();
841
                                                if (itp.tagName() == "CharacterStyle")
842
                                                        parseCharacterStyle(itp);
843
                                        }
844
                                }
845
                        }
846
                }
17199 fschmid 847
                if (e.tagName() == "RootParagraphStyleGroup")
848
                {
849
                        for(QDomNode it = e.firstChild(); !it.isNull(); it = it.nextSibling() )
850
                        {
851
                                QDomElement itpg = it.toElement();
852
                                if (itpg.tagName() == "ParagraphStyle")
853
                                        parseParagraphStyle(itpg);
854
                                else if (itpg.tagName() == "ParagraphStyleGroup")
855
                                {
856
                                        for(QDomNode its = itpg.firstChild(); !its.isNull(); its = its.nextSibling() )
857
                                        {
858
                                                QDomElement itp = its.toElement();
859
                                                if (itp.tagName() == "ParagraphStyle")
860
                                                        parseParagraphStyle(itp);
861
                                        }
862
                                }
863
                        }
864
                }
17210 fschmid 865
                if (e.tagName() == "RootObjectStyleGroup")
866
                {
867
                        for(QDomNode it = e.firstChild(); !it.isNull(); it = it.nextSibling() )
868
                        {
869
                                QDomElement itpg = it.toElement();
870
                                if (itpg.tagName() == "ObjectStyle")
871
                                        parseObjectStyle(itpg);
872
                                else if (itpg.tagName() == "ObjectStyleGroup")
873
                                {
874
                                        for(QDomNode its = itpg.firstChild(); !its.isNull(); its = its.nextSibling() )
875
                                        {
876
                                                QDomElement itp = its.toElement();
877
                                                if (itp.tagName() == "ObjectStyle")
878
                                                        parseObjectStyle(itp);
879
                                        }
880
                                }
881
                        }
882
                }
17199 fschmid 883
        }
17222 fschmid 884
        return;
17199 fschmid 885
}
886
 
17210 fschmid 887
void IdmlPlug::parseObjectStyle(const QDomElement& styleElem)
888
{
889
        ObjectStyle nstyle;
890
        nstyle.fillColor = def_fillColor;
891
        nstyle.strokeColor = def_strokeColor;
892
        nstyle.fillGradient = "";
893
        nstyle.gradientFillStart = QPointF(def_gradientX, def_gradientY);
894
        nstyle.gradientFillLength = def_gradientLen;
895
        nstyle.gradientFillAngle = def_gradientAngle;
17232 fschmid 896
        nstyle.strokeGradient = "";
897
        nstyle.gradientStrokeStart = QPointF(def_gradientStrokeStartX, def_gradientStrokeStartY);
898
        nstyle.gradientStrokeLength = def_gradientStrokeLength;
899
        nstyle.gradientStrokeAngle = def_gradientStrokeAngle;
17210 fschmid 900
        nstyle.lineWidth = def_lineWidth;
901
        nstyle.fillTint = def_fillTint;
902
        nstyle.strokeTint = def_strokeTint;
903
        nstyle.Opacity = def_Opacity;
904
        nstyle.blendMode = def_Blendmode;
905
        nstyle.parentStyle = "";
17239 fschmid 906
        nstyle.Extra = def_Extra;
907
        nstyle.TExtra = def_TExtra;
908
        nstyle.BExtra = def_BExtra;
909
        nstyle.RExtra = def_RExtra;
910
        nstyle.TextColumnCount = def_TextColumnCount;
911
        nstyle.TextColumnGutter = def_TextColumnGutter;
912
        nstyle.TextFlow = def_TextFlow;
17210 fschmid 913
        for(QDomNode itp = styleElem.firstChild(); !itp.isNull(); itp = itp.nextSibling() )
914
        {
915
                QDomElement itpr = itp.toElement();
916
                if (itpr.tagName() == "Properties")
917
                {
918
                        for(QDomNode itpp = itpr.firstChild(); !itpp.isNull(); itpp = itpp.nextSibling() )
919
                        {
920
                                QDomElement i = itpp.toElement();
921
                                if (i.tagName() == "BasedOn")
922
                                {
923
                                        QString ps = i.text();
924
                                        if (ps != "$ID/[None]")
925
                                                nstyle.parentStyle = ps;
926
                                }
927
                        }
928
                }
17239 fschmid 929
                if (itpr.tagName() == "TextWrapPreference")
930
                {
931
                        if (itpr.hasAttribute("TextWrapMode"))
932
                        {
933
                                if (itpr.attribute("TextWrapMode") == "None")
934
                                        nstyle.TextFlow = PageItem::TextFlowDisabled;
935
                                else if (itpr.attribute("TextWrapMode") == "BoundingBoxTextWrap")
936
                                        nstyle.TextFlow = PageItem::TextFlowUsesBoundingBox;
937
                                else if (itpr.attribute("TextWrapMode") == "Contour")
938
                                        nstyle.TextFlow = PageItem::TextFlowUsesFrameShape;
939
                        }
940
                }
941
                else if (itpr.tagName() == "TextFramePreference")
942
                {
943
                        if (itpr.hasAttribute("TextColumnCount"))
944
                                nstyle.TextColumnCount = itpr.attribute("TextColumnCount").toInt();
945
                        if (itpr.hasAttribute("TextColumnGutter"))
946
                                nstyle.TextColumnGutter = itpr.attribute("TextColumnGutter").toDouble();
947
                        if (itpr.hasAttribute("TextColumnFixedWidth"))
948
                                nstyle.TextColumnFixedWidth = itpr.attribute("TextColumnFixedWidth").toDouble();
949
                        for(QDomNode itpp = itpr.firstChild(); !itpp.isNull(); itpp = itpp.nextSibling() )
950
                        {
951
                                QDomElement i = itpp.toElement();
952
                                if (i.tagName() == "Properties")
953
                                {
954
                                        for(QDomNode it = i.firstChild(); !it.isNull(); it = it.nextSibling() )
955
                                        {
956
                                                QDomElement itx = it.toElement();
957
                                                if (itx.tagName() == "InsetSpacing")
958
                                                {
959
                                                        if (itx.attribute("type") == "unit")
960
                                                                nstyle.Extra = nstyle.TExtra = nstyle.BExtra = nstyle.RExtra = itx.text().toDouble();
961
                                                        else if (itx.attribute("type") == "list")
962
                                                        {
963
                                                                int cc = 0;
964
                                                                for(QDomNode ity = itx.firstChild(); !ity.isNull(); ity = ity.nextSibling() )
965
                                                                {
966
                                                                        QDomElement itxx = ity.toElement();
967
                                                                        if (itxx.tagName() == "ListItem")
968
                                                                        {
969
                                                                                double val = itxx.text().toDouble();
970
                                                                                if (cc == 0)
971
                                                                                        nstyle.Extra = val;
972
                                                                                else if (cc == 1)
973
                                                                                        nstyle.TExtra = val;
974
                                                                                else if (cc == 2)
975
                                                                                        nstyle.RExtra = val;
976
                                                                                else if (cc == 3)
977
                                                                                        nstyle.BExtra = val;
978
                                                                                cc++;
979
                                                                        }
980
                                                                }
981
                                                        }
982
                                                }
983
                                        }
984
                                }
985
                        }
986
                }
17210 fschmid 987
        }
988
        if (styleElem.hasAttribute("StrokeColor"))
989
        {
17232 fschmid 990
                QString strokeColor = styleElem.attribute("StrokeColor");
991
                if (colorTranslate.contains(strokeColor))
992
                        nstyle.strokeColor = colorTranslate[strokeColor];
993
                else
994
                {
995
                        if (gradientTranslate.contains(strokeColor))
996
                                nstyle.strokeGradient = gradientTranslate[strokeColor];
997
                }
17210 fschmid 998
        }
999
        if (styleElem.hasAttribute("FillColor"))
1000
        {
1001
                QString fillColor = styleElem.attribute("FillColor");
1002
                if (colorTranslate.contains(fillColor))
1003
                        nstyle.fillColor = colorTranslate[fillColor];
1004
                else
1005
                {
1006
                        if (gradientTranslate.contains(fillColor))
1007
                                nstyle.fillGradient = gradientTranslate[fillColor];
1008
                }
1009
        }
1010
        if (styleElem.hasAttribute("FillTint"))
1011
        {
1012
                int fillShade = styleElem.attribute("FillTint").toInt();
1013
                if (fillShade != -1)
1014
                        nstyle.fillTint = fillShade;
1015
        }
1016
        if (styleElem.hasAttribute("StrokeTint"))
1017
        {
1018
                int strokeShade = styleElem.attribute("StrokeTint").toInt();
1019
                if (strokeShade != -1)
1020
                        nstyle.strokeTint = strokeShade;
1021
        }
1022
        if (styleElem.hasAttribute("StrokeWeight"))
1023
                nstyle.lineWidth = styleElem.attribute("StrokeWeight", "0").toDouble();
1024
        if (styleElem.hasAttribute("GradientFillStart"))
1025
        {
1026
                QString fillGStart = styleElem.attribute("GradientFillStart");
1027
                ScTextStream Code(&fillGStart, QIODevice::ReadOnly);
1028
                double gstX, gstY;
1029
                Code >> gstX >> gstY;
1030
                nstyle.gradientFillStart = QPointF(gstX, gstY);
1031
        }
1032
        if (styleElem.hasAttribute("GradientFillLength"))
1033
                nstyle.gradientFillLength = styleElem.attribute("GradientFillLength").toDouble();
1034
        if (styleElem.hasAttribute("GradientFillAngle"))
1035
                nstyle.gradientFillAngle = styleElem.attribute("GradientFillAngle").toDouble();
17232 fschmid 1036
        if (styleElem.hasAttribute("GradientStrokeStart"))
1037
        {
1038
                QString fillGStart = styleElem.attribute("GradientStrokeStart");
1039
                ScTextStream Code(&fillGStart, QIODevice::ReadOnly);
1040
                double gstX, gstY;
1041
                Code >> gstX >> gstY;
1042
                nstyle.gradientStrokeStart = QPointF(gstX, gstY);
1043
        }
1044
        if (styleElem.hasAttribute("GradientStrokeLength"))
1045
                nstyle.gradientStrokeLength = styleElem.attribute("GradientStrokeLength").toDouble();
1046
        if (styleElem.hasAttribute("GradientStrokeAngle"))
1047
                nstyle.gradientStrokeAngle = styleElem.attribute("GradientStrokeAngle").toDouble();
17210 fschmid 1048
        QString itemName = styleElem.attribute("Self");
1049
        ObjectStyles.insert(itemName, nstyle);
1050
}
1051
 
17208 fschmid 1052
void IdmlPlug::parseCharacterStyle(const QDomElement& styleElem)
1053
{
1054
        CharStyle newStyle;
1055
        newStyle.setDefaultStyle(false);
17268 fschmid 1056
        newStyle.setName(styleElem.attribute("Name").remove("$ID/"));
17208 fschmid 1057
        newStyle.setParent(CommonStrings::DefaultCharacterStyle);
1058
        QString fontName = m_Doc->itemToolPrefs().textFont;
1059
        QString fontBaseName = "";
1060
        QString fontStyle = styleElem.attribute("FontStyle", "");
1061
        for(QDomNode itp = styleElem.firstChild(); !itp.isNull(); itp = itp.nextSibling() )
1062
        {
1063
                QDomElement itpr = itp.toElement();
1064
                if (itpr.tagName() == "Properties")
1065
                {
1066
                        for(QDomNode itpp = itpr.firstChild(); !itpp.isNull(); itpp = itpp.nextSibling() )
1067
                        {
1068
                                QDomElement i = itpp.toElement();
1069
                                if (i.tagName() == "AppliedFont")
1070
                                        fontBaseName = i.text();
1071
                                else if (i.tagName() == "BasedOn")
1072
                                {
17268 fschmid 1073
                                        QString parentStyle = i.text().remove("$ID/");
17208 fschmid 1074
                                        if (charStyleTranslate.contains(parentStyle))
1075
                                                parentStyle = charStyleTranslate[parentStyle];
1076
                                        if (m_Doc->styleExists(parentStyle))
1077
                                                newStyle.setParent(parentStyle);
1078
                                }
1079
                        }
1080
                }
1081
        }
1082
        if ((!fontBaseName.isEmpty()) && (!fontStyle.isEmpty()))
1083
                fontName = constructFontName(fontBaseName, fontStyle);
1084
        newStyle.setFont((*m_Doc->AllFonts)[fontName]);
1085
        readCharStyleAttributes(newStyle, styleElem);
1086
        StyleSet<CharStyle> temp;
1087
        temp.create(newStyle);
1088
        m_Doc->redefineCharStyles(temp, false);
17268 fschmid 1089
        charStyleTranslate.insert(styleElem.attribute("Self").remove("$ID/"), styleElem.attribute("Name").remove("$ID/"));
17208 fschmid 1090
}
1091
 
17199 fschmid 1092
void IdmlPlug::parseParagraphStyle(const QDomElement& styleElem)
1093
{
1094
        ParagraphStyle newStyle;
1095
        newStyle.erase();
17208 fschmid 1096
        newStyle.setDefaultStyle(false);
17268 fschmid 1097
        newStyle.setName(styleElem.attribute("Name").remove("$ID/"));
17199 fschmid 1098
        newStyle.setParent(CommonStrings::DefaultParagraphStyle);
1099
        QString fontName = m_Doc->itemToolPrefs().textFont;
1100
        QString fontBaseName = "";
1101
        QString fontStyle = styleElem.attribute("FontStyle", "");
17208 fschmid 1102
        newStyle.setLineSpacingMode(ParagraphStyle::AutomaticLineSpacing);
17199 fschmid 1103
        for(QDomNode itp = styleElem.firstChild(); !itp.isNull(); itp = itp.nextSibling() )
1104
        {
1105
                QDomElement itpr = itp.toElement();
1106
                if (itpr.tagName() == "Properties")
1107
                {
1108
                        for(QDomNode itpp = itpr.firstChild(); !itpp.isNull(); itpp = itpp.nextSibling() )
1109
                        {
1110
                                QDomElement i = itpp.toElement();
1111
                                if (i.tagName() == "AppliedFont")
1112
                                        fontBaseName = i.text();
1113
                                else if (i.tagName() == "BasedOn")
1114
                                {
17268 fschmid 1115
                                        QString parentStyle = i.text().remove("$ID/");
17199 fschmid 1116
                                        if (styleTranslate.contains(parentStyle))
1117
                                                parentStyle = styleTranslate[parentStyle];
1118
                                        if (m_Doc->styleExists(parentStyle))
1119
                                                newStyle.setParent(parentStyle);
1120
                                }
17208 fschmid 1121
                                else if (i.tagName() == "Leading")
1122
                                {
1123
                                        if (i.attribute("type") == "unit")
1124
                                        {
1125
                                                int lead = i.text().toDouble();
1126
                                                if (lead != 0)
1127
                                                {
1128
                                                        newStyle.setLineSpacingMode(ParagraphStyle::FixedLineSpacing);
1129
                                                        newStyle.setLineSpacing(lead);
1130
                                                }
1131
                                        }
1132
                                }
17199 fschmid 1133
                        }
1134
                }
1135
        }
1136
        if ((!fontBaseName.isEmpty()) && (!fontStyle.isEmpty()))
1137
                fontName = constructFontName(fontBaseName, fontStyle);
1138
        newStyle.charStyle().setFont((*m_Doc->AllFonts)[fontName]);
17208 fschmid 1139
        readCharStyleAttributes(newStyle.charStyle(), styleElem);
1140
        readParagraphStyleAttributes(newStyle, styleElem);
17199 fschmid 1141
        StyleSet<ParagraphStyle>tmp;
1142
        tmp.create(newStyle);
1143
        m_Doc->redefineStyles(tmp, false);
17268 fschmid 1144
        styleTranslate.insert(styleElem.attribute("Self").remove("$ID/"), styleElem.attribute("Name").remove("$ID/"));
17199 fschmid 1145
}
1146
 
1147
bool IdmlPlug::parsePreferencesXML(const QDomElement& prElem)
1148
{
1149
        QDomElement prNode;
1150
        QDomDocument prMapDom;
1151
        if (prElem.hasAttribute("src"))
1152
        {
1153
                QByteArray f2;
1154
                loadRawText(fun->getFile(prElem.attribute("src")), f2);
1155
                if(prMapDom.setContent(f2))
1156
                        prNode = prMapDom.documentElement();
1157
                else
1158
                        return false;
1159
        }
1160
        else
1161
        {
1162
                if (prElem.hasChildNodes())
1163
                        prNode = prElem;
1164
                else
1165
                        return false;
1166
        }
17222 fschmid 1167
        parsePreferencesXMLNode(prNode);
1168
        return true;
1169
}
1170
 
1171
void IdmlPlug::parsePreferencesXMLNode(const QDomElement& prNode)
1172
{
17199 fschmid 1173
        double topMargin = m_Doc->marginsVal().Top;
1174
        double leftMargin = m_Doc->marginsVal().Left;
1175
        double rightMargin = m_Doc->marginsVal().Right;
1176
        double bottomMargin = m_Doc->marginsVal().Bottom;
1177
        double pgCols = m_Doc->PageSp;
1178
        double pgGap = m_Doc->PageSpa;
1179
        double bleedTop = m_Doc->bleeds()->Top;
1180
        double bleedLeft = m_Doc->bleeds()->Left;
1181
        double bleedRight = m_Doc->bleeds()->Right;
1182
        double bleedBottom = m_Doc->bleeds()->Bottom;
1183
        facingPages = false;
1184
        for (QDomNode n = prNode.firstChild(); !n.isNull(); n = n.nextSibling() )
1185
        {
1186
                QDomElement e = n.toElement();
1187
                if (e.tagName() == "DocumentPreference")
1188
                {
1189
                        if (importerFlags & LoadSavePlugin::lfCreateDoc)
1190
                        {
1191
                                docWidth = e.attribute("PageWidth").toDouble();
1192
                                docHeight = e.attribute("PageHeight").toDouble();
1193
                                bleedTop = e.attribute("DocumentBleedTopOffset").toDouble();
1194
                                bleedLeft = e.attribute("DocumentBleedInsideOrLeftOffset").toDouble();
1195
                                bleedRight = e.attribute("DocumentBleedOutsideOrRightOffset").toDouble();
1196
                                bleedBottom = e.attribute("DocumentBleedBottomOffset").toDouble();
1197
                                facingPages = (e.attribute("FacingPages","") == "true") ? 1 : 0;
1198
                        }
1199
                }
1200
                if (e.tagName() == "MarginPreference")
1201
                {
1202
                        topMargin = e.attribute("Top").toDouble();
1203
                        leftMargin = e.attribute("Left").toDouble();
1204
                        rightMargin = e.attribute("Right").toDouble();
1205
                        bottomMargin = e.attribute("Bottom").toDouble();
1206
                        pgCols = e.attribute("ColumnCount").toDouble();
1207
                        pgGap = e.attribute("ColumnGutter").toDouble();
1208
                }
1209
                if (e.tagName() == "TransparencyDefaultContainerObject")
1210
                {
1211
                        for(QDomNode it = e.firstChild(); !it.isNull(); it = it.nextSibling() )
1212
                        {
1213
                                QDomElement itpg = it.toElement();
1214
                                for(QDomNode itp = itpg.firstChild(); !itp.isNull(); itp = itp.nextSibling() )
1215
                                {
1216
                                        QDomElement itpr = itp.toElement();
1217
                                        if (itpr.tagName() == "TransparencySetting")
1218
                                        {
1219
                                                def_Opacity = 1.0 - (itpr.attribute("Opacity", "100").toDouble() / 100.0);
1220
                                                def_Blendmode = convertBlendMode(itpr.attribute("BlendMode", "Normal"));
1221
                                        }
1222
                                        if (itpr.tagName() == "StrokeTransparencySetting")
1223
                                        {
1224
                                                def_strokeOpacity = 1.0 - (itpr.attribute("Opacity", "100").toDouble() / 100.0);
1225
                                                def_strokeBlendmode = convertBlendMode(itpr.attribute("BlendMode", "Normal"));
1226
                                        }
1227
                                        if (itpr.tagName() == "FillTransparencySetting")
1228
                                        {
1229
                                                def_fillOpacity = 1.0 - (itpr.attribute("Opacity", "100").toDouble() / 100.0);
1230
                                                def_fillBlendmode = convertBlendMode(itpr.attribute("BlendMode", "Normal"));
1231
                                        }
1232
                                }
1233
                        }
1234
                }
1235
                if (e.tagName() == "PageItemDefault")
1236
                {
1237
                        QString strokeColor = e.attribute("StrokeColor");
1238
                        if (colorTranslate.contains(strokeColor))
1239
                                def_strokeColor = colorTranslate[strokeColor];
17232 fschmid 1240
                        else
1241
                        {
1242
                                if (gradientTranslate.contains(strokeColor))
1243
                                {
1244
                                        def_strokeGradient = gradientTranslate[strokeColor];
1245
                                }
1246
                        }
1247
                        QString strokeGStart = e.attribute("GradientStrokeStart", "0 0");
1248
                        ScTextStream Code2(&strokeGStart, QIODevice::ReadOnly);
1249
                        Code2 >> def_gradientStrokeStartX >> def_gradientStrokeStartY;
1250
                        def_gradientStrokeLength = e.attribute("GradientStrokeLength", "0").toDouble();
1251
                        def_gradientStrokeAngle = e.attribute("GradientStrokeAngle", "0").toDouble();
1252
                        int strokeShade = e.attribute("StrokeTint", "100").toInt();
1253
                        if (strokeShade != -1)
1254
                                def_strokeTint = strokeShade;
1255
                        else
1256
                                def_strokeTint = 100;
17199 fschmid 1257
                        QString fillColor = e.attribute("FillColor");
1258
                        if (colorTranslate.contains(fillColor))
1259
                                def_fillColor = colorTranslate[fillColor];
1260
                        else
1261
                        {
1262
                                if (gradientTranslate.contains(fillColor))
1263
                                {
1264
                                        def_fillGradient = gradientTranslate[fillColor];
1265
                                }
1266
                        }
17232 fschmid 1267
                        QString fillGStart = e.attribute("GradientFillStart", "0 0");
1268
                        ScTextStream Code(&fillGStart, QIODevice::ReadOnly);
1269
                        Code >> def_gradientX >> def_gradientY;
1270
                        def_gradientLen = e.attribute("GradientFillLength", "0").toDouble();
1271
                        def_gradientAngle = e.attribute("GradientFillAngle", "0").toDouble();
17199 fschmid 1272
                        int fillShade = e.attribute("FillTint", "100").toInt();
1273
                        if (fillShade != -1)
1274
                                def_fillTint = fillShade;
1275
                        else
1276
                                def_fillTint = 100;
1277
                        def_lineWidth = e.attribute("StrokeWeight", "0").toDouble();
1278
                }
17206 fschmid 1279
                if (e.tagName() == "TextWrapPreference")
1280
                {
1281
                        if (e.attribute("TextWrapMode") == "None")
1282
                                def_TextFlow = PageItem::TextFlowDisabled;
1283
                        else if (e.attribute("TextWrapMode") == "BoundingBoxTextWrap")
1284
                                def_TextFlow = PageItem::TextFlowUsesBoundingBox;
1285
                        else if (e.attribute("TextWrapMode") == "Contour")
1286
                                def_TextFlow = PageItem::TextFlowUsesFrameShape;
1287
                }
17239 fschmid 1288
                if (e.tagName() == "TextFramePreference")
1289
                {
1290
                        if (e.hasAttribute("TextColumnCount"))
1291
                                def_TextColumnCount = e.attribute("TextColumnCount").toInt();
1292
                        if (e.hasAttribute("TextColumnGutter"))
1293
                                def_TextColumnGutter = e.attribute("TextColumnGutter").toDouble();
1294
                        if (e.hasAttribute("TextColumnFixedWidth"))
1295
                                def_TextColumnFixedWidth = e.attribute("TextColumnFixedWidth").toDouble();
1296
                        for(QDomNode itpp = e.firstChild(); !itpp.isNull(); itpp = itpp.nextSibling() )
1297
                        {
1298
                                QDomElement i = itpp.toElement();
1299
                                if (i.tagName() == "Properties")
1300
                                {
1301
                                        for(QDomNode it = i.firstChild(); !it.isNull(); it = it.nextSibling() )
1302
                                        {
1303
                                                QDomElement itx = it.toElement();
1304
                                                if (itx.tagName() == "InsetSpacing")
1305
                                                {
1306
                                                        if (itx.attribute("type") == "unit")
1307
                                                                def_Extra = def_TExtra = def_BExtra = def_RExtra = itx.text().toDouble();
1308
                                                        else if (itx.attribute("type") == "list")
1309
                                                        {
1310
                                                                int cc = 0;
1311
                                                                for(QDomNode ity = itx.firstChild(); !ity.isNull(); ity = ity.nextSibling() )
1312
                                                                {
1313
                                                                        QDomElement itxx = ity.toElement();
1314
                                                                        if (itxx.tagName() == "ListItem")
1315
                                                                        {
1316
                                                                                double val = itxx.text().toDouble();
1317
                                                                                if (cc == 0)
1318
                                                                                        def_Extra = val;
1319
                                                                                else if (cc == 1)
1320
                                                                                        def_TExtra = val;
1321
                                                                                else if (cc == 2)
1322
                                                                                        def_RExtra = val;
1323
                                                                                else if (cc == 3)
1324
                                                                                        def_BExtra = val;
1325
                                                                                cc++;
1326
                                                                        }
1327
                                                                }
1328
                                                        }
1329
                                                }
1330
                                        }
1331
                                }
1332
                        }
1333
                }
17199 fschmid 1334
        }
1335
        if (importerFlags & LoadSavePlugin::lfCreateDoc)
1336
        {
1337
                m_Doc->setPage(docWidth, docHeight, topMargin, leftMargin, rightMargin, bottomMargin, pgCols, pgGap, false, facingPages);
1338
                m_Doc->setPageSize("Custom");
1339
                m_Doc->bleeds()->set(bleedTop, bleedLeft, bleedBottom, bleedRight);
1340
                m_Doc->currentPage()->m_pageSize = "Custom";
1341
                m_Doc->currentPage()->setInitialHeight(docHeight);
1342
                m_Doc->currentPage()->setInitialWidth(docWidth);
1343
                m_Doc->currentPage()->setHeight(docHeight);
1344
                m_Doc->currentPage()->setWidth(docWidth);
1345
                m_Doc->currentPage()->initialMargins.Top = topMargin;
1346
                m_Doc->currentPage()->initialMargins.Bottom = bottomMargin;
1347
                m_Doc->currentPage()->initialMargins.Left = leftMargin;
1348
                m_Doc->currentPage()->initialMargins.Right = rightMargin;
1349
                m_Doc->reformPages(true);
1350
                baseX = m_Doc->currentPage()->xOffset();
1351
                baseY = m_Doc->currentPage()->yOffset() + m_Doc->currentPage()->height() / 2.0;
1352
        }
17222 fschmid 1353
        return;
17199 fschmid 1354
}
1355
 
1356
bool IdmlPlug::parseSpreadXML(const QDomElement& spElem)
1357
{
1358
        QDomElement spNode;
1359
        QDomDocument spMapDom;
1360
        if (spElem.hasAttribute("src"))
1361
        {
1362
                QByteArray f2;
1363
                loadRawText(fun->getFile(spElem.attribute("src")), f2);
1364
                if(spMapDom.setContent(f2))
1365
                        spNode = spMapDom.documentElement();
1366
                else
1367
                        return false;
1368
        }
1369
        else
1370
        {
1371
                if (spElem.hasChildNodes())
1372
                        spNode = spElem;
1373
                else
1374
                        return false;
1375
        }
17222 fschmid 1376
        parseSpreadXMLNode(spNode);
1377
        return true;
1378
}
1379
 
1380
void IdmlPlug::parseSpreadXMLNode(const QDomElement& spNode)
1381
{
17199 fschmid 1382
        for (QDomNode n = spNode.firstChild(); !n.isNull(); n = n.nextSibling() )
1383
        {
1384
                QDomElement e = n.toElement();
1385
                if (e.tagName() == "Spread")
1386
                {
1387
                        for(QDomNode sp = e.firstChild(); !sp.isNull(); sp = sp.nextSibling() )
1388
                        {
1389
                                QDomElement spe = sp.toElement();
1390
                                if (spe.tagName() == "Page")
1391
                                {
1392
                                        if ((importerFlags & LoadSavePlugin::lfCreateDoc) && (!firstPage))
1393
                                        {
1394
                                                m_Doc->addPage(pagecount);
1395
                                                m_Doc->currentPage()->MPageNam = CommonStrings::trMasterPageNormal;
17262 fschmid 1396
                                                m_Doc->currentPage()->m_pageSize = "Custom";
1397
                                                m_Doc->currentPage()->setInitialHeight(docHeight);
1398
                                                m_Doc->currentPage()->setInitialWidth(docWidth);
1399
                                                m_Doc->currentPage()->setHeight(docHeight);
1400
                                                m_Doc->currentPage()->setWidth(docWidth);
17199 fschmid 1401
                                                m_Doc->view()->addPage(pagecount, true);
1402
                                                pagecount++;
1403
                                        }
1404
                                        baseX = m_Doc->currentPage()->xOffset();
1405
                                        baseY = m_Doc->currentPage()->yOffset() + m_Doc->currentPage()->height() / 2.0;
1406
                                        firstPage = false;
1407
                                }
1408
                        }
1409
                        if ((facingPages) && (pagecount % 2 == 0))
1410
                        {
1411
                                baseX = m_Doc->currentPage()->xOffset() + m_Doc->currentPage()->width();
1412
                                baseY = m_Doc->currentPage()->yOffset() + m_Doc->currentPage()->height() / 2.0;
1413
                        }
1414
                        if (!facingPages)
1415
                        {
1416
                                baseX = m_Doc->currentPage()->xOffset() + m_Doc->currentPage()->width() / 2.0;
1417
                                baseY = m_Doc->currentPage()->yOffset() + m_Doc->currentPage()->height() / 2.0;
1418
                        }
1419
                        for(QDomNode sp = e.firstChild(); !sp.isNull(); sp = sp.nextSibling() )
1420
                        {
1421
                                QDomElement spe = sp.toElement();
1422
                                if ((spe.tagName() == "Rectangle") || (spe.tagName() == "Oval") || (spe.tagName() == "GraphicLine") || (spe.tagName() == "Polygon") || (spe.tagName() == "TextFrame") || (spe.tagName() == "Group") || (spe.tagName() == "Button"))
1423
                                {
1424
                                        QList<PageItem*> el = parseItemXML(spe);
1425
                                        for (int ec = 0; ec < el.count(); ++ec)
1426
                                        {
1427
                                                m_Doc->Items->append(el.at(ec));
1428
                                                Elements.append(el.at(ec));
1429
                                        }
1430
                                }
1431
                        }
1432
                }
17222 fschmid 1433
/*              else if (e.tagName() == "MasterSpread")
1434
                {
1435
                        m_Doc->setMasterPageMode(true);
1436
                        for(QDomNode sp = e.firstChild(); !sp.isNull(); sp = sp.nextSibling() )
1437
                        {
1438
                                QDomElement spe = sp.toElement();
1439
                                if (spe.tagName() == "Page")
1440
                                {
1441
                                        QString pageNam = spe.attribute("Name") + "_" + spe.attribute("Self");
1442
                                        m_Doc->addMasterPage(mpagecount, pageNam);
1443
                                        m_Doc->currentPage()->MPageNam = "";
1444
                                        m_Doc->view()->addPage(mpagecount, true);
1445
                                        mpagecount++;
1446
                                        baseX = m_Doc->currentPage()->xOffset();
1447
                                        baseY = m_Doc->currentPage()->yOffset() + m_Doc->currentPage()->height() / 2.0;
1448
                                }
1449
                        }
1450
                        if ((facingPages) && (mpagecount % 2 == 0))
1451
                        {
1452
                                baseX = m_Doc->currentPage()->xOffset() + m_Doc->currentPage()->width();
1453
                                baseY = m_Doc->currentPage()->yOffset() + m_Doc->currentPage()->height() / 2.0;
1454
                        }
1455
                        if (!facingPages)
1456
                        {
1457
                                baseX = m_Doc->currentPage()->xOffset() + m_Doc->currentPage()->width() / 2.0;
1458
                                baseY = m_Doc->currentPage()->yOffset() + m_Doc->currentPage()->height() / 2.0;
1459
                        }
1460
                        for(QDomNode sp = e.firstChild(); !sp.isNull(); sp = sp.nextSibling() )
1461
                        {
1462
                                QDomElement spe = sp.toElement();
1463
                                if ((spe.tagName() == "Rectangle") || (spe.tagName() == "Oval") || (spe.tagName() == "GraphicLine") || (spe.tagName() == "Polygon") || (spe.tagName() == "TextFrame") || (spe.tagName() == "Group") || (spe.tagName() == "Button"))
1464
                                {
1465
                                        QList<PageItem*> el = parseItemXML(spe);
1466
                                        for (int ec = 0; ec < el.count(); ++ec)
1467
                                        {
1468
                                                m_Doc->Items->append(el.at(ec));
1469
                                                Elements.append(el.at(ec));
1470
                                        }
1471
                                }
1472
                        }
1473
                        m_Doc->setMasterPageMode(false);
1474
                } */
17199 fschmid 1475
        }
17222 fschmid 1476
        return;
17199 fschmid 1477
}
1478
 
1479
QList<PageItem*> IdmlPlug::parseItemXML(const QDomElement& itElem, QTransform pTrans)
1480
{
1481
        QList<PageItem*> GElements;
1482
        FPointArray GCoords;
1483
        GCoords.resize(0);
1484
        GCoords.svgInit();
1485
        QString itemTrans = itElem.attribute("ItemTransform");
1486
        ScTextStream list(&itemTrans, QIODevice::ReadOnly);
1487
        double a, b, c, d, e, f;
1488
        list >> a >> b >> c >> d >> e >> f;
1489
        /* Adding the values directly */
1490
        QTransform transformation(a, b, c, d, e, f);
1491
        QString itemName = itElem.attribute("Self");
17210 fschmid 1492
        QString fillColor = def_fillColor;
17199 fschmid 1493
        QString fillGradient = "";
17210 fschmid 1494
        double gstX = def_gradientX;
1495
        double gstY = def_gradientY;
1496
        double gLen = def_gradientLen;
1497
        double gAngle = def_gradientAngle;
17199 fschmid 1498
        int fillGradientTyp = 6;
17210 fschmid 1499
        QString strokeColor = def_strokeColor;
17232 fschmid 1500
        QString strokeGradient = "";
1501
        double gstSX = def_gradientStrokeStartX;
1502
        double gstSY = def_gradientStrokeStartY;
1503
        double gSLen = def_gradientStrokeLength;
1504
        double gSAngle = def_gradientStrokeAngle;
1505
        int strokeGradientTyp = 6;
17210 fschmid 1506
        double lineWidth = def_lineWidth;
1507
        int fillShade = def_fillTint;
1508
        int strokeShade = def_strokeTint;
1509
        double Opacity = def_Opacity;
1510
        int blendMode = def_Blendmode;
17239 fschmid 1511
        double Extra = def_Extra;
1512
        double TExtra = def_TExtra;
1513
        double BExtra = def_BExtra;
1514
        double RExtra = def_RExtra;
1515
        int TextColumnCount = def_TextColumnCount;
1516
        double TextColumnGutter = def_TextColumnGutter;
1517
        double TextColumnFixedWidth = def_TextColumnFixedWidth;
1518
        PageItem::TextFlowMode textFlow = def_TextFlow;
17210 fschmid 1519
        if (itElem.hasAttribute("AppliedObjectStyle"))
17199 fschmid 1520
        {
17210 fschmid 1521
                QString os = itElem.attribute("AppliedObjectStyle");
17349 fschmid 1522
                if (os != "n")
17199 fschmid 1523
                {
17349 fschmid 1524
                        ObjectStyle nstyle;
1525
                        nstyle.fillColor = def_fillColor;
1526
                        nstyle.strokeColor = def_strokeColor;
1527
                        nstyle.fillGradient = "";
1528
                        nstyle.gradientFillStart = QPointF(def_gradientX, def_gradientY);
1529
                        nstyle.gradientFillLength = def_gradientLen;
1530
                        nstyle.gradientFillAngle = def_gradientAngle;
1531
                        nstyle.strokeGradient = "";
1532
                        nstyle.gradientStrokeStart = QPointF(def_gradientStrokeStartX, def_gradientStrokeStartY);
1533
                        nstyle.gradientStrokeAngle = def_gradientStrokeAngle;
1534
                        nstyle.gradientStrokeLength = def_gradientStrokeLength;
1535
                        nstyle.lineWidth = def_lineWidth;
1536
                        nstyle.fillTint = def_fillTint;
1537
                        nstyle.strokeTint = def_strokeTint;
1538
                        nstyle.Opacity = def_Opacity;
1539
                        nstyle.blendMode = def_Blendmode;
1540
                        nstyle.Extra = def_Extra;
1541
                        nstyle.TExtra = def_TExtra;
1542
                        nstyle.BExtra = def_BExtra;
1543
                        nstyle.RExtra = def_RExtra;
1544
                        nstyle.TextColumnCount = def_TextColumnCount;
1545
                        nstyle.TextColumnGutter = def_TextColumnGutter;
1546
                        nstyle.TextColumnFixedWidth = def_TextColumnFixedWidth;
1547
                        nstyle.TextFlow = def_TextFlow;
1548
                        nstyle.parentStyle = "";
1549
                        resolveObjectStyle(nstyle, os);
1550
                        fillColor = nstyle.fillColor;
1551
                        if (!nstyle.fillGradient.isEmpty())
1552
                        {
1553
                                fillGradient = nstyle.fillGradient;
1554
                                fillGradientTyp = gradientTypeMap[fillColor];
1555
                        }
1556
                        gstX = nstyle.gradientFillStart.x();
1557
                        gstY = nstyle.gradientFillStart.y();
1558
                        gLen = nstyle.gradientFillLength;
1559
                        gAngle = nstyle.gradientFillAngle;
1560
                        strokeColor = nstyle.strokeColor;
1561
                        if (!nstyle.strokeGradient.isEmpty())
1562
                        {
1563
                                strokeGradient = nstyle.strokeGradient;
1564
                                strokeGradientTyp = gradientTypeMap[strokeColor];
1565
                        }
1566
                        gstSX = nstyle.gradientStrokeStart.x();
1567
                        gstSY = nstyle.gradientStrokeStart.y();
1568
                        gSLen = nstyle.gradientStrokeLength;
1569
                        gSAngle = nstyle.gradientStrokeAngle;
1570
                        lineWidth = nstyle.lineWidth;
1571
                        fillShade = nstyle.fillTint;
1572
                        strokeShade = nstyle.strokeTint;
1573
                        Opacity = nstyle.Opacity;
1574
                        blendMode = nstyle.blendMode;
1575
                        Extra = nstyle.Extra;
1576
                        TExtra = nstyle.TExtra;
1577
                        BExtra = nstyle.BExtra;
1578
                        RExtra = nstyle.RExtra;
1579
                        TextColumnCount = nstyle.TextColumnCount;
1580
                        TextColumnGutter = nstyle.TextColumnGutter;
1581
                        TextColumnFixedWidth = nstyle.TextColumnFixedWidth;
1582
                        textFlow = nstyle.TextFlow;
17199 fschmid 1583
                }
17210 fschmid 1584
        }
1585
        if (itElem.hasAttribute("FillColor"))
1586
        {
1587
                fillColor = itElem.attribute("FillColor");
1588
                if (colorTranslate.contains(fillColor))
1589
                        fillColor = colorTranslate[fillColor];
17199 fschmid 1590
                else
17210 fschmid 1591
                {
1592
                        if (gradientTranslate.contains(fillColor))
1593
                        {
1594
                                fillGradientTyp = gradientTypeMap[fillColor];
1595
                                fillGradient = gradientTranslate[fillColor];
1596
                        }
1597
                }
17199 fschmid 1598
        }
17210 fschmid 1599
        if (itElem.hasAttribute("GradientFillStart"))
1600
        {
1601
                QString fillGStart = itElem.attribute("GradientFillStart");
1602
                ScTextStream Code(&fillGStart, QIODevice::ReadOnly);
1603
                Code >> gstX >> gstY;
1604
                gLen = itElem.attribute("GradientFillLength").toDouble();
1605
                gAngle = itElem.attribute("GradientFillAngle").toDouble();
1606
        }
1607
        if (itElem.hasAttribute("StrokeColor"))
1608
        {
17232 fschmid 1609
                strokeColor = itElem.attribute("StrokeColor");
1610
                if (colorTranslate.contains(strokeColor))
1611
                        strokeColor = colorTranslate[strokeColor];
1612
                else
1613
                {
1614
                        if (gradientTranslate.contains(strokeColor))
1615
                        {
1616
                                strokeGradientTyp = gradientTypeMap[strokeColor];
1617
                                strokeGradient = gradientTranslate[strokeColor];
1618
                        }
1619
                }
17210 fschmid 1620
        }
17232 fschmid 1621
        if (itElem.hasAttribute("GradientStrokeStart"))
1622
        {
1623
                QString fillGStart = itElem.attribute("GradientStrokeStart");
1624
                ScTextStream Code(&fillGStart, QIODevice::ReadOnly);
1625
                Code >> gstSX >> gstSY;
1626
                gSLen = itElem.attribute("GradientStrokeLength").toDouble();
1627
                gSAngle = itElem.attribute("GradientStrokeAngle").toDouble();
1628
        }
17210 fschmid 1629
        if (itElem.hasAttribute("StrokeWeight"))
1630
                lineWidth = itElem.attribute("StrokeWeight").toDouble();
1631
        if (itElem.hasAttribute("FillTint"))
17349 fschmid 1632
        {
1633
                if (itElem.attribute("FillTint").toInt() != -1)
1634
                        fillShade = itElem.attribute("FillTint").toInt();
1635
        }
1636
        if (fillShade < 0)
1637
                fillShade = 100;
17210 fschmid 1638
        if (itElem.hasAttribute("StrokeTint"))
17349 fschmid 1639
        {
1640
                if (itElem.attribute("StrokeTint").toInt() != -1)
1641
                        strokeShade = itElem.attribute("StrokeTint").toInt();
1642
        }
1643
        if (strokeShade < 0)
1644
                strokeShade = 100;
17199 fschmid 1645
        QString forLayer = itElem.attribute("ItemLayer");
1646
        if (layerTranslate.contains(forLayer))
1647
                forLayer = layerTranslate[forLayer];
1648
        else
1649
                forLayer = m_Doc->layerName(0);
1650
        int layerNum = 0;
1651
        ScLayers::iterator itend = m_Doc->Layers.end();
1652
        ScLayers::iterator it;
1653
        for (it = m_Doc->Layers.begin(); it != itend; ++it)
1654
        {
1655
                if (it->Name == forLayer)
1656
                {
1657
                        layerNum = it->ID;
1658
                        break;
1659
                }
1660
        }
1661
        bool isOpen = false;
1662
        bool isGroup = false;
1663
        bool realGroup = false;
1664
        bool isImage = false;
17206 fschmid 1665
        bool isPathText = false;
17199 fschmid 1666
        if (itElem.tagName() == "Group")
1667
                realGroup = true;
1668
        QString imageType = "";
1669
        QByteArray imageData = "";
17209 fschmid 1670
        QString imageFileName = "";
17199 fschmid 1671
        QTransform imageTransform;
17206 fschmid 1672
        QString storyForPath = "";
1673
        int pathTextType = 0;
17262 fschmid 1674
        double pathTextStart = 0;
17199 fschmid 1675
        for(QDomNode it = itElem.firstChild(); !it.isNull(); it = it.nextSibling() )
1676
        {
1677
                QDomElement ite = it.toElement();
1678
                if (ite.tagName() == "Properties")
1679
                {
1680
                        for(QDomNode itp = ite.firstChild(); !itp.isNull(); itp = itp.nextSibling() )
1681
                        {
1682
                                QDomElement itpg = itp.toElement();
1683
                                if (itpg.tagName() == "PathGeometry")
1684
                                {
1685
                                        for(QDomNode itg = itpg.firstChild(); !itg.isNull(); itg = itg.nextSibling() )
1686
                                        {
1687
                                                QDomElement itgg = itg.toElement();
1688
                                                if (itgg.tagName() == "GeometryPathType")
1689
                                                {
17206 fschmid 1690
                                                        isOpen = (itgg.attribute("PathOpen") == "true");
17199 fschmid 1691
                                                        for(QDomNode itpp = itgg.firstChild(); !itpp.isNull(); itpp = itpp.nextSibling() )
1692
                                                        {
1693
                                                                QDomElement itpa = itpp.toElement();
1694
                                                                if (itpa.tagName() == "PathPointArray")
1695
                                                                {
1696
                                                                        bool firstPoint = true;
1697
                                                                        QPointF firstBezPoint;
1698
                                                                        QPointF firstAncPoint;
1699
                                                                        QList<QPointF> pointList;
1700
                                                                        for(QDomNode itpap = itpa.firstChild(); !itpap.isNull(); itpap = itpap.nextSibling() )
1701
                                                                        {
1702
                                                                                QDomElement itpo = itpap.toElement();
1703
                                                                                if (itpo.tagName() == "PathPointType")
1704
                                                                                {
1705
                                                                                        double x1, y1, x2, y2, x3, y3;
1706
                                                                                        QString anchor = itpo.attribute("Anchor");
1707
                                                                                        QString lDir = itpo.attribute("LeftDirection");
1708
                                                                                        QString rDir = itpo.attribute("RightDirection");
1709
                                                                                        ScTextStream an(&anchor, QIODevice::ReadOnly);
1710
                                                                                        an >> x1 >> y1;
1711
                                                                                        QPointF aP = QPointF(x1, y1);
1712
                                                                                        ScTextStream lr(&lDir, QIODevice::ReadOnly);
1713
                                                                                        lr >> x2 >> y2;
1714
                                                                                        QPointF lP = QPointF(x2, y2);
1715
                                                                                        ScTextStream rr(&rDir, QIODevice::ReadOnly);
1716
                                                                                        rr >> x3 >> y3;
1717
                                                                                        QPointF rP = QPointF(x3, y3);
1718
 
1719
                                                                                        if (firstPoint)
1720
                                                                                        {
1721
                                                                                                firstBezPoint = lP;
1722
                                                                                                firstAncPoint = aP;
1723
                                                                                                pointList.append(aP);
1724
                                                                                                pointList.append(rP);
1725
                                                                                                firstPoint = false;
1726
                                                                                        }
1727
                                                                                        else
1728
                                                                                        {
1729
                                                                                                if (itElem.tagName() == "GraphicLine")
1730
                                                                                                {
1731
                                                                                                        pointList.append(lP);
1732
                                                                                                        pointList.append(aP);
1733
                                                                                                }
1734
                                                                                                else
1735
                                                                                                {
1736
                                                                                                        pointList.append(lP);
1737
                                                                                                        pointList.append(aP);
1738
                                                                                                        pointList.append(rP);
1739
                                                                                                }
1740
                                                                                        }
1741
                                                                                }
1742
                                                                        }
1743
                                                                        if (itElem.tagName() == "GraphicLine")
1744
                                                                        {
1745
                                                                                if (pointList.count() > 1)
1746
                                                                                {
1747
                                                                                        GCoords.svgMoveTo(pointList[0].x(), pointList[0].y());
1748
                                                                                        QPointF p1 = pointList[1];
1749
                                                                                        QPointF p2 = pointList[2];
1750
                                                                                        QPointF p3 = pointList[3];
1751
                                                                                        GCoords.svgCurveToCubic(p1.x(), p1.y(), p2.x(), p2.y(), p3.x(), p3.y());
1752
                                                                                }
1753
                                                                        }
1754
                                                                        else
1755
                                                                        {
1756
                                                                                if (isOpen)
17206 fschmid 1757
                                                                                {
17199 fschmid 1758
                                                                                        pointList.removeLast();
17206 fschmid 1759
                                                                                }
17199 fschmid 1760
                                                                                else
1761
                                                                                {
1762
                                                                                        pointList.append(firstBezPoint);
1763
                                                                                        pointList.append(firstAncPoint);
1764
                                                                                }
1765
                                                                                if (pointList.count() > 1)
1766
                                                                                {
1767
                                                                                        GCoords.svgMoveTo(pointList[0].x(), pointList[0].y());
1768
                                                                                        for (int a = 1; a < pointList.count(); a += 3)
1769
                                                                                        {
1770
                                                                                                QPointF p1 = pointList[a];
1771
                                                                                                QPointF p2 = pointList[a+1];
1772
                                                                                                QPointF p3 = pointList[a+2];
1773
                                                                                                GCoords.svgCurveToCubic(p1.x(), p1.y(), p2.x(), p2.y(), p3.x(), p3.y());
1774
                                                                                        }
1775
                                                                                }
1776
                                                                        }
1777
                                                                }
1778
                                                        }
17206 fschmid 1779
                                                        if (!isOpen)
1780
                                                                GCoords.svgClosePath();
17199 fschmid 1781
                                                }
1782
                                        }
1783
                                }
1784
                        }
1785
                }
1786
                else if ((ite.tagName() == "Rectangle") || (ite.tagName() == "Oval") || (ite.tagName() == "GraphicLine") || (ite.tagName() == "Polygon") || (ite.tagName() == "TextFrame") || (ite.tagName() == "Group") || (ite.tagName() == "Button"))
1787
                {
1788
                        isGroup = true;
1789
                        QList<PageItem*> el = parseItemXML(ite, transformation * pTrans);
1790
                        for (int ec = 0; ec < el.count(); ++ec)
1791
                        {
1792
                                GElements.append(el.at(ec));
1793
                        }
1794
                }
1795
                else if (ite.tagName() == "TransparencySetting")
1796
                {
1797
                        for(QDomNode itp = ite.firstChild(); !itp.isNull(); itp = itp.nextSibling() )
1798
                        {
1799
                                QDomElement itpg = itp.toElement();
1800
                                if (itpg.tagName() == "BlendingSetting")
1801
                                {
1802
                                        Opacity = 1.0 - (itpg.attribute("Opacity", "100").toDouble() / 100.0);
1803
                                        blendMode = convertBlendMode(itpg.attribute("BlendMode", "Normal"));
1804
                                }
1805
                        }
1806
                }
17239 fschmid 1807
                else if (ite.tagName() == "TextWrapPreference")
17206 fschmid 1808
                {
1809
                        if (ite.attribute("TextWrapMode") == "None")
1810
                                textFlow = PageItem::TextFlowDisabled;
1811
                        else if (ite.attribute("TextWrapMode") == "BoundingBoxTextWrap")
1812
                                textFlow = PageItem::TextFlowUsesBoundingBox;
1813
                        else if (ite.attribute("TextWrapMode") == "Contour")
1814
                                textFlow = PageItem::TextFlowUsesFrameShape;
1815
                }
17239 fschmid 1816
                else if (ite.tagName() == "TextFramePreference")
1817
                {
1818
                        if (ite.hasAttribute("TextColumnCount"))
1819
                                TextColumnCount = ite.attribute("TextColumnCount").toInt();
1820
                        if (ite.hasAttribute("TextColumnGutter"))
1821
                                TextColumnGutter = ite.attribute("TextColumnGutter").toDouble();
1822
                        if (ite.hasAttribute("TextColumnFixedWidth"))
1823
                                TextColumnFixedWidth = ite.attribute("TextColumnFixedWidth").toDouble();
1824
                        for(QDomNode itpp = ite.firstChild(); !itpp.isNull(); itpp = itpp.nextSibling() )
1825
                        {
1826
                                QDomElement i = itpp.toElement();
1827
                                if (i.tagName() == "Properties")
1828
                                {
1829
                                        for(QDomNode it = i.firstChild(); !it.isNull(); it = it.nextSibling() )
1830
                                        {
1831
                                                QDomElement itx = it.toElement();
1832
                                                if (itx.tagName() == "InsetSpacing")
1833
                                                {
1834
                                                        if (itx.attribute("type") == "unit")
1835
                                                                Extra = TExtra = BExtra = RExtra = itx.text().toDouble();
1836
                                                        else if (itx.attribute("type") == "list")
1837
                                                        {
1838
                                                                int cc = 0;
1839
                                                                for(QDomNode ity = itx.firstChild(); !ity.isNull(); ity = ity.nextSibling() )
1840
                                                                {
1841
                                                                        QDomElement itxx = ity.toElement();
1842
                                                                        if (itxx.tagName() == "ListItem")
1843
                                                                        {
1844
                                                                                double val = itxx.text().toDouble();
1845
                                                                                if (cc == 0)
1846
                                                                                        Extra = val;
1847
                                                                                else if (cc == 1)
1848
                                                                                        TExtra = val;
1849
                                                                                else if (cc == 2)
1850
                                                                                        RExtra = val;
1851
                                                                                else if (cc == 3)
1852
                                                                                        BExtra = val;
1853
                                                                                cc++;
1854
                                                                        }
1855
                                                                }
1856
                                                        }
1857
                                                }
1858
                                        }
1859
                                }
1860
                        }
1861
                }
17199 fschmid 1862
                else if ((ite.tagName() == "Image") || (ite.tagName() == "EPS") || (ite.tagName() == "PDF") || (ite.tagName() == "PICT"))
1863
                {
1864
                        imageType = ite.attribute("ImageTypeName");
1865
                        isImage = true;
1866
                        QString imageTrans = ite.attribute("ItemTransform", "1 0 0 1 0 0");
1867
                        ScTextStream list(&imageTrans, QIODevice::ReadOnly);
1868
                        double a, b, c, d, e, f;
1869
                        list >> a >> b >> c >> d >> e >> f;
1870
                        imageTransform = QTransform(a, b, c, d, e, f);
1871
                        for(QDomNode itp = ite.firstChild(); !itp.isNull(); itp = itp.nextSibling() )
1872
                        {
1873
                                QDomElement itpg = itp.toElement();
1874
                                if (itpg.tagName() == "Properties")
1875
                                        imageData = QByteArray::fromBase64(getNodeValue(itpg, "Contents").toLatin1());
17209 fschmid 1876
                                if (itpg.tagName() == "Link")
1877
                                {
1878
                                        if (itpg.hasAttribute("LinkResourceURI"))
1879
                                                imageFileName = itpg.attribute("LinkResourceURI");
1880
                                }
17199 fschmid 1881
                        }
1882
                }
1883
                else if (ite.tagName() == "WMF")
1884
                {
1885
                        qDebug() << "WMF";
1886
                }
1887
                else if (ite.tagName() == "ImportedPage")
1888
                {
1889
                        qDebug() << "ImportedPage";
1890
                }
17206 fschmid 1891
                else if (ite.tagName() == "TextPath")
1892
                {
1893
                        isPathText = true;
1894
                        storyForPath = ite.attribute("ParentStory");
1895
                        if (ite.attribute("PathEffect") == "RainbowPathEffect")
1896
                                pathTextType = 0;
1897
                        else if (ite.attribute("PathEffect") == "StairStepPathEffect")
1898
                                pathTextType = 1;
1899
                        else if (ite.attribute("PathEffect") == "SkewPathEffect")
1900
                                pathTextType = 2;
1901
                        else if (ite.attribute("PathEffect") == "RibbonPathEffect")                     // not implemented in PathText yet
1902
                                pathTextType = 0;
1903
                        else if (ite.attribute("PathEffect") == "GravityPathEffect")            // not implemented in PathText yet
1904
                                pathTextType = 0;
17262 fschmid 1905
                        if (ite.hasAttribute("StartBracket"))
1906
                                pathTextStart = ite.attribute("StartBracket").toDouble();
17206 fschmid 1907
                }
17199 fschmid 1908
        }
1909
        if (GCoords.size() > 0)
1910
        {
1911
                int z;
1912
                QTransform finalMat = transformation * pTrans;
1913
                double scX, scY, rot, dx, dy;
1914
                getTransformValuesFromMatrix(finalMat, scX, scY, rot, dx, dy);
17222 fschmid 1915
                if ((finalMat.m11() < 0) && (finalMat.m12() == 0) && (finalMat.m21() == 0))
1916
                {
1917
                        QLineF line = QLineF(0.0, 0.0, 1.0, 0.0);
1918
                        line.setAngle(rot);
1919
                        QTransform matrix;
1920
                        matrix.scale(-1, 0);
1921
                        line = matrix.map(line);
1922
                        rot = line.angle();
1923
                        scX *= -1;
1924
                }
1925
                if ((finalMat.m22() < 0) && (finalMat.m12() == 0) && (finalMat.m21() == 0))
1926
                {
1927
                        scY *= -1;
1928
                }
17199 fschmid 1929
                FPoint grOffset(getMinClipF(&GCoords));
17222 fschmid 1930
                GCoords.map(finalMat);
17199 fschmid 1931
                if (isGroup)
1932
                {
1933
                        QString pre = "";
1934
                        FPointArray gClip;
1935
                        if (!realGroup)
1936
                        {
1937
                                pre = "Group_";
1938
                                if (!fillGradient.isEmpty())
1939
                                        fillColor = CommonStrings::None;
1940
                                if (itElem.tagName() == "TextFrame")
1941
                                {
1942
                                        z = m_Doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, baseX, baseY, 10, 10, lineWidth, fillColor, strokeColor, true);
17239 fschmid 1943
                                        PageItem* item = m_Doc->Items->at(z);
17199 fschmid 1944
                                        QString story = itElem.attribute("ParentStory");
1945
                                        if (!storyMap.contains(story))
17239 fschmid 1946
                                                storyMap.insert(story, item);
17209 fschmid 1947
                                        if (itElem.hasAttribute("NextTextFrame"))
1948
                                        {
1949
                                                if (itElem.attribute("NextTextFrame") != "n")
17239 fschmid 1950
                                                        frameLinks.insert(item, itElem.attribute("NextTextFrame"));
17209 fschmid 1951
                                        }
17239 fschmid 1952
                                        frameTargets.insert(itemName, item);
1953
                                        item->setTextToFrameDistLeft(Extra);
1954
                                        item->setTextToFrameDistTop(TExtra);
1955
                                        item->setTextToFrameDistRight(RExtra);
1956
                                        item->setTextToFrameDistBottom(BExtra);
1957
                                        item->setColumns(TextColumnCount);
1958
                                        item->setColumnGap(TextColumnGutter);
17199 fschmid 1959
                                }
17206 fschmid 1960
                                else if (isPathText)
1961
                                {
1962
                                        z = m_Doc->itemAdd(PageItem::PathText, PageItem::Unspecified, baseX, baseY, 10, 10, lineWidth, CommonStrings::None, strokeColor, true);
1963
                                        if (!storyMap.contains(storyForPath))
1964
                                                storyMap.insert(storyForPath, m_Doc->Items->at(z));
1965
                                        PageItem* item = m_Doc->Items->at(z);
1966
                                        item->setPathTextType(pathTextType);
17262 fschmid 1967
                                        item->setTextToFrameDistLeft(pathTextStart);
17206 fschmid 1968
                                }
17199 fschmid 1969
                                else if (isImage)
1970
                                {
1971
                                        z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, baseX, baseY, 10, 10, lineWidth, fillColor, strokeColor, true);
1972
                                }
1973
                                else
1974
                                {
1975
                                        if (isOpen)
1976
                                                z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, lineWidth, fillColor, strokeColor, true);
1977
                                        else
1978
                                                z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, lineWidth, fillColor, strokeColor, true);
1979
                                }
1980
                                PageItem* item = m_Doc->Items->at(z);
1981
                                item->PoLine = GCoords.copy();
17222 fschmid 1982
                                double dx = 0;
1983
                                double dy = 0;
1984
                                if (rot != 0)
1985
                                {
1986
                                        QTransform mr;
1987
                                        FPoint grOffset2(getMinClipF(&item->PoLine));
1988
                                        mr.translate(-grOffset2.x(), -grOffset2.y());
1989
                                        mr.rotate(rot);
1990
                                        mr.translate(grOffset2.x(), grOffset2.y());
1991
                                        item->PoLine.map(mr);
1992
                                        FPoint grOffset3(getMinClipF(&item->PoLine));
1993
                                        dx = grOffset2.x() - grOffset3.x();
1994
                                        dy = grOffset2.y() - grOffset3.y();
1995
                                }
17199 fschmid 1996
                                item->ClipEdited = true;
1997
                                item->FrameType = 3;
17246 fschmid 1998
                                item->setFillColor(fillColor);
1999
                                item->setLineColor(strokeColor);
17199 fschmid 2000
                                item->setFillShade(fillShade);
2001
                                item->setLineShade(strokeShade);
2002
                                item->setFillEvenOdd(false);
2003
                                if (!fillGradient.isEmpty())
2004
                                {
2005
                                        QLineF gradientVector = QLineF(gstX, gstY, gstX+1, gstY);
2006
                                        gradientVector.setLength(gLen);
2007
                                        gradientVector.setAngle(gAngle);
2008
                                        gradientVector.translate(-grOffset.x(), -grOffset.y());
17232 fschmid 2009
                                        item->fill_gradient = m_Doc->docGradients[fillGradient];
17199 fschmid 2010
                                        item->setGradientVector(gradientVector.x1(), gradientVector.y1(), gradientVector.x2(), gradientVector.y2(), gradientVector.x1(), gradientVector.y1(), 1, 0);
2011
                                        item->setGradient(fillGradient);
2012
                                        item->setGradientType(fillGradientTyp);
2013
                                }
17232 fschmid 2014
                                if (!strokeGradient.isEmpty())
2015
                                {
2016
                                        QLineF gradientVector = QLineF(gstSX, gstSY, gstSX+1, gstSY);
2017
                                        gradientVector.setLength(gSLen);
2018
                                        gradientVector.setAngle(gSAngle);
2019
                                        gradientVector.translate(-grOffset.x(), -grOffset.y());
2020
                                        item->stroke_gradient = m_Doc->docGradients[strokeGradient];
2021
                                        item->setStrokeGradientVector(gradientVector.x1(), gradientVector.y1(), gradientVector.x2(), gradientVector.y2(), gradientVector.x1(), gradientVector.y1(), 1, 0);
2022
                                        item->setStrokeGradient(strokeGradient);
2023
                                        item->setStrokeGradientType(strokeGradientTyp);
2024
                                }
17199 fschmid 2025
                                FPoint wh = getMaxClipF(&item->PoLine);
2026
                                item->setWidthHeight(wh.x(),wh.y());
17206 fschmid 2027
                                item->setTextFlowMode(textFlow);
17199 fschmid 2028
                                m_Doc->AdjustItemSize(item);
17222 fschmid 2029
                                item->setRotation(-rot, true);
17199 fschmid 2030
                                item->moveBy(dx, dy, true);
17259 fschmid 2031
                                if (isPathText)
2032
                                {
2033
                                        if (isOpen)
2034
                                        {
2035
                                                if (scX < 0)
17262 fschmid 2036
                                                {
17259 fschmid 2037
                                                        item->PoLine.reverse();
17262 fschmid 2038
                                                }
17259 fschmid 2039
                                        }
2040
                                        else
2041
                                        {
2042
                                                if (scX > 0)
17262 fschmid 2043
                                                {
2044
                                                        double totalCurveLen = 0;
18114 jghali 2045
                                                        for (int segs = 0; segs < item->PoLine.size()-3; segs += 4)
17262 fschmid 2046
                                                        {
2047
                                                                totalCurveLen += item->PoLine.lenPathSeg(segs);
2048
                                                        }
2049
                                                        item->setTextToFrameDistLeft(totalCurveLen - pathTextStart);
17259 fschmid 2050
                                                        item->PoLine.reverse();
17262 fschmid 2051
                                                }
17259 fschmid 2052
                                        }
2053
                                }
17199 fschmid 2054
                                item->OldB2 = item->width();
2055
                                item->OldH2 = item->height();
2056
                                item->updateClip();
2057
                                item->setItemName(itemName);
2058
                                if (importerFlags & LoadSavePlugin::lfCreateDoc)
2059
                                        item->setLayer(layerNum);
2060
                                if ((itElem.tagName() == "Rectangle") && (itElem.attribute("CornerOption") == "RoundedCorner"))
2061
                                {
2062
                                        item->SetRectFrame();
2063
                                        item->setCornerRadius(itElem.attribute("CornerRadius", "0").toDouble());
2064
                                        item->SetFrameRound();
2065
                                        gClip = item->PoLine.copy();
2066
                                }
2067
                                item->OwnPage = m_Doc->OnPage(item);
17239 fschmid 2068
                                item->ContourLine = item->PoLine.copy();
17199 fschmid 2069
                                GElements.prepend(m_Doc->Items-><