Subversion Repositories Scribus

Rev

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