Subversion Repositories Scribus

Rev

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