Subversion Repositories Scribus

Rev

Rev 18203 | Rev 18346 | 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;
18289 fschmid 1519
        QString imageFit = "None";
17239 fschmid 1520
        PageItem::TextFlowMode textFlow = def_TextFlow;
17210 fschmid 1521
        if (itElem.hasAttribute("AppliedObjectStyle"))
17199 fschmid 1522
        {
17210 fschmid 1523
                QString os = itElem.attribute("AppliedObjectStyle");
17349 fschmid 1524
                if (os != "n")
17199 fschmid 1525
                {
17349 fschmid 1526
                        ObjectStyle nstyle;
1527
                        nstyle.fillColor = def_fillColor;
1528
                        nstyle.strokeColor = def_strokeColor;
1529
                        nstyle.fillGradient = "";
1530
                        nstyle.gradientFillStart = QPointF(def_gradientX, def_gradientY);
1531
                        nstyle.gradientFillLength = def_gradientLen;
1532
                        nstyle.gradientFillAngle = def_gradientAngle;
1533
                        nstyle.strokeGradient = "";
1534
                        nstyle.gradientStrokeStart = QPointF(def_gradientStrokeStartX, def_gradientStrokeStartY);
1535
                        nstyle.gradientStrokeAngle = def_gradientStrokeAngle;
1536
                        nstyle.gradientStrokeLength = def_gradientStrokeLength;
1537
                        nstyle.lineWidth = def_lineWidth;
1538
                        nstyle.fillTint = def_fillTint;
1539
                        nstyle.strokeTint = def_strokeTint;
1540
                        nstyle.Opacity = def_Opacity;
1541
                        nstyle.blendMode = def_Blendmode;
1542
                        nstyle.Extra = def_Extra;
1543
                        nstyle.TExtra = def_TExtra;
1544
                        nstyle.BExtra = def_BExtra;
1545
                        nstyle.RExtra = def_RExtra;
1546
                        nstyle.TextColumnCount = def_TextColumnCount;
1547
                        nstyle.TextColumnGutter = def_TextColumnGutter;
1548
                        nstyle.TextColumnFixedWidth = def_TextColumnFixedWidth;
1549
                        nstyle.TextFlow = def_TextFlow;
1550
                        nstyle.parentStyle = "";
1551
                        resolveObjectStyle(nstyle, os);
1552
                        fillColor = nstyle.fillColor;
1553
                        if (!nstyle.fillGradient.isEmpty())
1554
                        {
1555
                                fillGradient = nstyle.fillGradient;
1556
                                fillGradientTyp = gradientTypeMap[fillColor];
1557
                        }
1558
                        gstX = nstyle.gradientFillStart.x();
1559
                        gstY = nstyle.gradientFillStart.y();
1560
                        gLen = nstyle.gradientFillLength;
1561
                        gAngle = nstyle.gradientFillAngle;
1562
                        strokeColor = nstyle.strokeColor;
1563
                        if (!nstyle.strokeGradient.isEmpty())
1564
                        {
1565
                                strokeGradient = nstyle.strokeGradient;
1566
                                strokeGradientTyp = gradientTypeMap[strokeColor];
1567
                        }
1568
                        gstSX = nstyle.gradientStrokeStart.x();
1569
                        gstSY = nstyle.gradientStrokeStart.y();
1570
                        gSLen = nstyle.gradientStrokeLength;
1571
                        gSAngle = nstyle.gradientStrokeAngle;
1572
                        lineWidth = nstyle.lineWidth;
1573
                        fillShade = nstyle.fillTint;
1574
                        strokeShade = nstyle.strokeTint;
1575
                        Opacity = nstyle.Opacity;
1576
                        blendMode = nstyle.blendMode;
1577
                        Extra = nstyle.Extra;
1578
                        TExtra = nstyle.TExtra;
1579
                        BExtra = nstyle.BExtra;
1580
                        RExtra = nstyle.RExtra;
1581
                        TextColumnCount = nstyle.TextColumnCount;
1582
                        TextColumnGutter = nstyle.TextColumnGutter;
1583
                        TextColumnFixedWidth = nstyle.TextColumnFixedWidth;
1584
                        textFlow = nstyle.TextFlow;
17199 fschmid 1585
                }
17210 fschmid 1586
        }
1587
        if (itElem.hasAttribute("FillColor"))
1588
        {
1589
                fillColor = itElem.attribute("FillColor");
1590
                if (colorTranslate.contains(fillColor))
1591
                        fillColor = colorTranslate[fillColor];
17199 fschmid 1592
                else
17210 fschmid 1593
                {
1594
                        if (gradientTranslate.contains(fillColor))
1595
                        {
1596
                                fillGradientTyp = gradientTypeMap[fillColor];
1597
                                fillGradient = gradientTranslate[fillColor];
1598
                        }
1599
                }
17199 fschmid 1600
        }
17210 fschmid 1601
        if (itElem.hasAttribute("GradientFillStart"))
1602
        {
1603
                QString fillGStart = itElem.attribute("GradientFillStart");
1604
                ScTextStream Code(&fillGStart, QIODevice::ReadOnly);
1605
                Code >> gstX >> gstY;
1606
                gLen = itElem.attribute("GradientFillLength").toDouble();
1607
                gAngle = itElem.attribute("GradientFillAngle").toDouble();
1608
        }
1609
        if (itElem.hasAttribute("StrokeColor"))
1610
        {
17232 fschmid 1611
                strokeColor = itElem.attribute("StrokeColor");
1612
                if (colorTranslate.contains(strokeColor))
1613
                        strokeColor = colorTranslate[strokeColor];
1614
                else
1615
                {
1616
                        if (gradientTranslate.contains(strokeColor))
1617
                        {
1618
                                strokeGradientTyp = gradientTypeMap[strokeColor];
1619
                                strokeGradient = gradientTranslate[strokeColor];
1620
                        }
1621
                }
17210 fschmid 1622
        }
17232 fschmid 1623
        if (itElem.hasAttribute("GradientStrokeStart"))
1624
        {
1625
                QString fillGStart = itElem.attribute("GradientStrokeStart");
1626
                ScTextStream Code(&fillGStart, QIODevice::ReadOnly);
1627
                Code >> gstSX >> gstSY;
1628
                gSLen = itElem.attribute("GradientStrokeLength").toDouble();
1629
                gSAngle = itElem.attribute("GradientStrokeAngle").toDouble();
1630
        }
17210 fschmid 1631
        if (itElem.hasAttribute("StrokeWeight"))
1632
                lineWidth = itElem.attribute("StrokeWeight").toDouble();
1633
        if (itElem.hasAttribute("FillTint"))
17349 fschmid 1634
        {
1635
                if (itElem.attribute("FillTint").toInt() != -1)
1636
                        fillShade = itElem.attribute("FillTint").toInt();
1637
        }
1638
        if (fillShade < 0)
1639
                fillShade = 100;
17210 fschmid 1640
        if (itElem.hasAttribute("StrokeTint"))
17349 fschmid 1641
        {
1642
                if (itElem.attribute("StrokeTint").toInt() != -1)
1643
                        strokeShade = itElem.attribute("StrokeTint").toInt();
1644
        }
1645
        if (strokeShade < 0)
1646
                strokeShade = 100;
17199 fschmid 1647
        QString forLayer = itElem.attribute("ItemLayer");
1648
        if (layerTranslate.contains(forLayer))
1649
                forLayer = layerTranslate[forLayer];
1650
        else
1651
                forLayer = m_Doc->layerName(0);
1652
        int layerNum = 0;
1653
        ScLayers::iterator itend = m_Doc->Layers.end();
1654
        ScLayers::iterator it;
1655
        for (it = m_Doc->Layers.begin(); it != itend; ++it)
1656
        {
1657
                if (it->Name == forLayer)
1658
                {
1659
                        layerNum = it->ID;
1660
                        break;
1661
                }
1662
        }
1663
        bool isOpen = false;
1664
        bool isGroup = false;
1665
        bool realGroup = false;
1666
        bool isImage = false;
17206 fschmid 1667
        bool isPathText = false;
17199 fschmid 1668
        if (itElem.tagName() == "Group")
1669
                realGroup = true;
1670
        QString imageType = "";
1671
        QByteArray imageData = "";
17209 fschmid 1672
        QString imageFileName = "";
17199 fschmid 1673
        QTransform imageTransform;
17206 fschmid 1674
        QString storyForPath = "";
1675
        int pathTextType = 0;
17262 fschmid 1676
        double pathTextStart = 0;
17199 fschmid 1677
        for(QDomNode it = itElem.firstChild(); !it.isNull(); it = it.nextSibling() )
1678
        {
1679
                QDomElement ite = it.toElement();
1680
                if (ite.tagName() == "Properties")
1681
                {
1682
                        for(QDomNode itp = ite.firstChild(); !itp.isNull(); itp = itp.nextSibling() )
1683
                        {
1684
                                QDomElement itpg = itp.toElement();
1685
                                if (itpg.tagName() == "PathGeometry")
1686
                                {
1687
                                        for(QDomNode itg = itpg.firstChild(); !itg.isNull(); itg = itg.nextSibling() )
1688
                                        {
1689
                                                QDomElement itgg = itg.toElement();
1690
                                                if (itgg.tagName() == "GeometryPathType")
1691
                                                {
17206 fschmid 1692
                                                        isOpen = (itgg.attribute("PathOpen") == "true");
17199 fschmid 1693
                                                        for(QDomNode itpp = itgg.firstChild(); !itpp.isNull(); itpp = itpp.nextSibling() )
1694
                                                        {
1695
                                                                QDomElement itpa = itpp.toElement();
1696
                                                                if (itpa.tagName() == "PathPointArray")
1697
                                                                {
1698
                                                                        bool firstPoint = true;
1699
                                                                        QPointF firstBezPoint;
1700
                                                                        QPointF firstAncPoint;
1701
                                                                        QList<QPointF> pointList;
1702
                                                                        for(QDomNode itpap = itpa.firstChild(); !itpap.isNull(); itpap = itpap.nextSibling() )
1703
                                                                        {
1704
                                                                                QDomElement itpo = itpap.toElement();
1705
                                                                                if (itpo.tagName() == "PathPointType")
1706
                                                                                {
1707
                                                                                        double x1, y1, x2, y2, x3, y3;
1708
                                                                                        QString anchor = itpo.attribute("Anchor");
1709
                                                                                        QString lDir = itpo.attribute("LeftDirection");
1710
                                                                                        QString rDir = itpo.attribute("RightDirection");
1711
                                                                                        ScTextStream an(&anchor, QIODevice::ReadOnly);
1712
                                                                                        an >> x1 >> y1;
1713
                                                                                        QPointF aP = QPointF(x1, y1);
1714
                                                                                        ScTextStream lr(&lDir, QIODevice::ReadOnly);
1715
                                                                                        lr >> x2 >> y2;
1716
                                                                                        QPointF lP = QPointF(x2, y2);
1717
                                                                                        ScTextStream rr(&rDir, QIODevice::ReadOnly);
1718
                                                                                        rr >> x3 >> y3;
1719
                                                                                        QPointF rP = QPointF(x3, y3);
1720
 
1721
                                                                                        if (firstPoint)
1722
                                                                                        {
1723
                                                                                                firstBezPoint = lP;
1724
                                                                                                firstAncPoint = aP;
1725
                                                                                                pointList.append(aP);
1726
                                                                                                pointList.append(rP);
1727
                                                                                                firstPoint = false;
1728
                                                                                        }
1729
                                                                                        else
1730
                                                                                        {
1731
                                                                                                if (itElem.tagName() == "GraphicLine")
1732
                                                                                                {
1733
                                                                                                        pointList.append(lP);
1734
                                                                                                        pointList.append(aP);
1735
                                                                                                }
1736
                                                                                                else
1737
                                                                                                {
1738
                                                                                                        pointList.append(lP);
1739
                                                                                                        pointList.append(aP);
1740
                                                                                                        pointList.append(rP);
1741
                                                                                                }
1742
                                                                                        }
1743
                                                                                }
1744
                                                                        }
1745
                                                                        if (itElem.tagName() == "GraphicLine")
1746
                                                                        {
1747
                                                                                if (pointList.count() > 1)
1748
                                                                                {
1749
                                                                                        GCoords.svgMoveTo(pointList[0].x(), pointList[0].y());
1750
                                                                                        QPointF p1 = pointList[1];
1751
                                                                                        QPointF p2 = pointList[2];
1752
                                                                                        QPointF p3 = pointList[3];
1753
                                                                                        GCoords.svgCurveToCubic(p1.x(), p1.y(), p2.x(), p2.y(), p3.x(), p3.y());
1754
                                                                                }
1755
                                                                        }
1756
                                                                        else
1757
                                                                        {
1758
                                                                                if (isOpen)
17206 fschmid 1759
                                                                                {
17199 fschmid 1760
                                                                                        pointList.removeLast();
17206 fschmid 1761
                                                                                }
17199 fschmid 1762
                                                                                else
1763
                                                                                {
1764
                                                                                        pointList.append(firstBezPoint);
1765
                                                                                        pointList.append(firstAncPoint);
1766
                                                                                }
1767
                                                                                if (pointList.count() > 1)
1768
                                                                                {
1769
                                                                                        GCoords.svgMoveTo(pointList[0].x(), pointList[0].y());
1770
                                                                                        for (int a = 1; a < pointList.count(); a += 3)
1771
                                                                                        {
1772
                                                                                                QPointF p1 = pointList[a];
1773
                                                                                                QPointF p2 = pointList[a+1];
1774
                                                                                                QPointF p3 = pointList[a+2];
1775
                                                                                                GCoords.svgCurveToCubic(p1.x(), p1.y(), p2.x(), p2.y(), p3.x(), p3.y());
1776
                                                                                        }
1777
                                                                                }
1778
                                                                        }
1779
                                                                }
1780
                                                        }
17206 fschmid 1781
                                                        if (!isOpen)
1782
                                                                GCoords.svgClosePath();
17199 fschmid 1783
                                                }
1784
                                        }
1785
                                }
1786
                        }
1787
                }
1788
                else if ((ite.tagName() == "Rectangle") || (ite.tagName() == "Oval") || (ite.tagName() == "GraphicLine") || (ite.tagName() == "Polygon") || (ite.tagName() == "TextFrame") || (ite.tagName() == "Group") || (ite.tagName() == "Button"))
1789
                {
1790
                        isGroup = true;
1791
                        QList<PageItem*> el = parseItemXML(ite, transformation * pTrans);
1792
                        for (int ec = 0; ec < el.count(); ++ec)
1793
                        {
1794
                                GElements.append(el.at(ec));
1795
                        }
1796
                }
18289 fschmid 1797
                else if (ite.tagName() == "FrameFittingOption")
1798
                {
1799
                        if (ite.hasAttribute("FittingOnEmptyFrame"))
1800
                                imageFit = ite.attribute("FittingOnEmptyFrame");
1801
                }
17199 fschmid 1802
                else if (ite.tagName() == "TransparencySetting")
1803
                {
1804
                        for(QDomNode itp = ite.firstChild(); !itp.isNull(); itp = itp.nextSibling() )
1805
                        {
1806
                                QDomElement itpg = itp.toElement();
1807
                                if (itpg.tagName() == "BlendingSetting")
1808
                                {
1809
                                        Opacity = 1.0 - (itpg.attribute("Opacity", "100").toDouble() / 100.0);
1810
                                        blendMode = convertBlendMode(itpg.attribute("BlendMode", "Normal"));
1811
                                }
1812
                        }
1813
                }
17239 fschmid 1814
                else if (ite.tagName() == "TextWrapPreference")
17206 fschmid 1815
                {
1816
                        if (ite.attribute("TextWrapMode") == "None")
1817
                                textFlow = PageItem::TextFlowDisabled;
1818
                        else if (ite.attribute("TextWrapMode") == "BoundingBoxTextWrap")
1819
                                textFlow = PageItem::TextFlowUsesBoundingBox;
1820
                        else if (ite.attribute("TextWrapMode") == "Contour")
1821
                                textFlow = PageItem::TextFlowUsesFrameShape;
1822
                }
17239 fschmid 1823
                else if (ite.tagName() == "TextFramePreference")
1824
                {
1825
                        if (ite.hasAttribute("TextColumnCount"))
1826
                                TextColumnCount = ite.attribute("TextColumnCount").toInt();
1827
                        if (ite.hasAttribute("TextColumnGutter"))
1828
                                TextColumnGutter = ite.attribute("TextColumnGutter").toDouble();
1829
                        if (ite.hasAttribute("TextColumnFixedWidth"))
1830
                                TextColumnFixedWidth = ite.attribute("TextColumnFixedWidth").toDouble();
1831
                        for(QDomNode itpp = ite.firstChild(); !itpp.isNull(); itpp = itpp.nextSibling() )
1832
                        {
1833
                                QDomElement i = itpp.toElement();
1834
                                if (i.tagName() == "Properties")
1835
                                {
1836
                                        for(QDomNode it = i.firstChild(); !it.isNull(); it = it.nextSibling() )
1837
                                        {
1838
                                                QDomElement itx = it.toElement();
1839
                                                if (itx.tagName() == "InsetSpacing")
1840
                                                {
1841
                                                        if (itx.attribute("type") == "unit")
1842
                                                                Extra = TExtra = BExtra = RExtra = itx.text().toDouble();
1843
                                                        else if (itx.attribute("type") == "list")
1844
                                                        {
1845
                                                                int cc = 0;
1846
                                                                for(QDomNode ity = itx.firstChild(); !ity.isNull(); ity = ity.nextSibling() )
1847
                                                                {
1848
                                                                        QDomElement itxx = ity.toElement();
1849
                                                                        if (itxx.tagName() == "ListItem")
1850
                                                                        {
1851
                                                                                double val = itxx.text().toDouble();
1852
                                                                                if (cc == 0)
1853
                                                                                        Extra = val;
1854
                                                                                else if (cc == 1)
1855
                                                                                        TExtra = val;
1856
                                                                                else if (cc == 2)
1857
                                                                                        RExtra = val;
1858
                                                                                else if (cc == 3)
1859
                                                                                        BExtra = val;
1860
                                                                                cc++;
1861
                                                                        }
1862
                                                                }
1863
                                                        }
1864
                                                }
1865
                                        }
1866
                                }
1867
                        }
1868
                }
17199 fschmid 1869
                else if ((ite.tagName() == "Image") || (ite.tagName() == "EPS") || (ite.tagName() == "PDF") || (ite.tagName() == "PICT"))
1870
                {
1871
                        imageType = ite.attribute("ImageTypeName");
1872
                        isImage = true;
1873
                        QString imageTrans = ite.attribute("ItemTransform", "1 0 0 1 0 0");
1874
                        ScTextStream list(&imageTrans, QIODevice::ReadOnly);
1875
                        double a, b, c, d, e, f;
1876
                        list >> a >> b >> c >> d >> e >> f;
1877
                        imageTransform = QTransform(a, b, c, d, e, f);
1878
                        for(QDomNode itp = ite.firstChild(); !itp.isNull(); itp = itp.nextSibling() )
1879
                        {
1880
                                QDomElement itpg = itp.toElement();
1881
                                if (itpg.tagName() == "Properties")
1882
                                        imageData = QByteArray::fromBase64(getNodeValue(itpg, "Contents").toLatin1());
17209 fschmid 1883
                                if (itpg.tagName() == "Link")
1884
                                {
1885
                                        if (itpg.hasAttribute("LinkResourceURI"))
1886
                                                imageFileName = itpg.attribute("LinkResourceURI");
1887
                                }
17199 fschmid 1888
                        }
1889
                }
1890
                else if (ite.tagName() == "WMF")
1891
                {
1892
                        qDebug() << "WMF";
1893
                }
1894
                else if (ite.tagName() == "ImportedPage")
1895
                {
1896
                        qDebug() << "ImportedPage";
1897
                }
17206 fschmid 1898
                else if (ite.tagName() == "TextPath")
1899
                {
1900
                        isPathText = true;
1901
                        storyForPath = ite.attribute("ParentStory");
1902
                        if (ite.attribute("PathEffect") == "RainbowPathEffect")
1903
                                pathTextType = 0;
1904
                        else if (ite.attribute("PathEffect") == "StairStepPathEffect")
1905
                                pathTextType = 1;
1906
                        else if (ite.attribute("PathEffect") == "SkewPathEffect")
1907
                                pathTextType = 2;
1908
                        else if (ite.attribute("PathEffect") == "RibbonPathEffect")                     // not implemented in PathText yet
1909
                                pathTextType = 0;
1910
                        else if (ite.attribute("PathEffect") == "GravityPathEffect")            // not implemented in PathText yet
1911
                                pathTextType = 0;
17262 fschmid 1912
                        if (ite.hasAttribute("StartBracket"))
1913
                                pathTextStart = ite.attribute("StartBracket").toDouble();
17206 fschmid 1914
                }
17199 fschmid 1915
        }
1916
        if (GCoords.size() > 0)
1917
        {
1918
                int z;
1919
                QTransform finalMat = transformation * pTrans;
1920
                double scX, scY, rot, dx, dy;
1921
                getTransformValuesFromMatrix(finalMat, scX, scY, rot, dx, dy);
17222 fschmid 1922
                if ((finalMat.m11() < 0) && (finalMat.m12() == 0) && (finalMat.m21() == 0))
1923
                {
1924
                        QLineF line = QLineF(0.0, 0.0, 1.0, 0.0);
1925
                        line.setAngle(rot);
1926
                        QTransform matrix;
1927
                        matrix.scale(-1, 0);
1928
                        line = matrix.map(line);
1929
                        rot = line.angle();
1930
                        scX *= -1;
1931
                }
1932
                if ((finalMat.m22() < 0) && (finalMat.m12() == 0) && (finalMat.m21() == 0))
1933
                {
1934
                        scY *= -1;
1935
                }
17199 fschmid 1936
                FPoint grOffset(getMinClipF(&GCoords));
17222 fschmid 1937
                GCoords.map(finalMat);
17199 fschmid 1938
                if (isGroup)
1939
                {
1940
                        QString pre = "";
1941
                        FPointArray gClip;
1942
                        if (!realGroup)
1943
                        {
1944
                                pre = "Group_";
1945
                                if (!fillGradient.isEmpty())
1946
                                        fillColor = CommonStrings::None;
1947
                                if (itElem.tagName() == "TextFrame")
1948
                                {
1949
                                        z = m_Doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, baseX, baseY, 10, 10, lineWidth, fillColor, strokeColor, true);
17239 fschmid 1950
                                        PageItem* item = m_Doc->Items->at(z);
17199 fschmid 1951
                                        QString story = itElem.attribute("ParentStory");
1952
                                        if (!storyMap.contains(story))
17239 fschmid 1953
                                                storyMap.insert(story, item);
17209 fschmid 1954
                                        if (itElem.hasAttribute("NextTextFrame"))
1955
                                        {
1956
                                                if (itElem.attribute("NextTextFrame") != "n")
17239 fschmid 1957
                                                        frameLinks.insert(item, itElem.attribute("NextTextFrame"));
17209 fschmid 1958
                                        }
17239 fschmid 1959
                                        frameTargets.insert(itemName, item);
1960
                                        item->setTextToFrameDistLeft(Extra);
1961
                                        item->setTextToFrameDistTop(TExtra);
1962
                                        item->setTextToFrameDistRight(RExtra);
1963
                                        item->setTextToFrameDistBottom(BExtra);
1964
                                        item->setColumns(TextColumnCount);
1965
                                        item->setColumnGap(TextColumnGutter);
17199 fschmid 1966
                                }
17206 fschmid 1967
                                else if (isPathText)
1968
                                {
1969
                                        z = m_Doc->itemAdd(PageItem::PathText, PageItem::Unspecified, baseX, baseY, 10, 10, lineWidth, CommonStrings::None, strokeColor, true);
1970
                                        if (!storyMap.contains(storyForPath))
1971
                                                storyMap.insert(storyForPath, m_Doc->Items->at(z));
1972
                                        PageItem* item = m_Doc->Items->at(z);
1973
                                        item->setPathTextType(pathTextType);
17262 fschmid 1974
                                        item->setTextToFrameDistLeft(pathTextStart);
17206 fschmid 1975
                                }
17199 fschmid 1976
                                else if (isImage)
1977
                                {
1978
                                        z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, baseX, baseY, 10, 10, lineWidth, fillColor, strokeColor, true);
1979
                                }
1980
                                else
1981
                                {
1982
                                        if (isOpen)
1983
                                                z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, lineWidth, fillColor, strokeColor, true);
1984
                                        else
1985
                                                z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, lineWidth, fillColor, strokeColor, true);
1986
                                }
1987
                                PageItem* item = m_Doc->Items->at(z);
1988
                                item->PoLine = GCoords.copy();
17222 fschmid 1989
                                double dx = 0;
1990
                                double dy = 0;
1991
                                if (rot != 0)
1992
                                {
1993
                                        QTransform mr;
1994
                                        FPoint grOffset2(getMinClipF(&item->PoLine));
1995
                                        mr.translate(-grOffset2.x(), -grOffset2.y());
1996
                                        mr.rotate(rot);
1997
                                        mr.translate(grOffset2.x(), grOffset2.y());
1998
                                        item->PoLine.map(mr);
1999
                                        FPoint grOffset3(getMinClipF(&item->PoLine));
2000
                                        dx = grOffset2.x() - grOffset3.x();
2001
                                        dy = grOffset2.y() - grOffset3.y();
2002
                                }
17199 fschmid 2003
                                item->ClipEdited = true;
2004
                                item->FrameType = 3;
17246 fschmid 2005
                                item->setFillColor(fillColor);
2006
                                item->setLineColor(strokeColor);
17199 fschmid 2007
                                item->setFillShade(fillShade);
2008
                                item->setLineShade(strokeShade);
2009
                                item->setFillEvenOdd(false);
2010
                                if (!fillGradient.isEmpty())
2011
                                {
2012
                                        QLineF gradientVector = QLineF(gstX, gstY, gstX+1, gstY);
2013
                                        gradientVector.setLength(gLen);
2014
                                        gradientVector.setAngle(gAngle);
2015
                                        gradientVector.translate(-grOffset.x(), -grOffset.y());
17232 fschmid 2016
                                        item->fill_gradient = m_Doc->docGradients[fillGradient];
17199 fschmid 2017
                                        item->setGradientVector(gradientVector.x1(), gradientVector.y1(), gradientVector.x2(), gradientVector.y2(), gradientVector.x1(), gradientVector.y1(), 1, 0);
2018
                                        item->setGradient(fillGradient);
2019
                                        item->setGradientType(fillGradientTyp);
2020
                                }
17232 fschmid 2021
                                if (!strokeGradient.isEmpty())
2022
                                {
2023
                                        QLineF gradientVector = QLineF(gstSX, gstSY, gstSX+1, gstSY);
2024
                                        gradientVector.setLength(gSLen);
2025
                                        gradientVector.setAngle(gSAngle);
2026
                                        gradientVector.translate(-grOffset.x(), -grOffset.y());
2027
                                        item->stroke_gradient = m_Doc->docGradients[strokeGradient];
2028
                                        item->setStrokeGradientVector(gradientVector.x1(), gradientVector.y1(), gradientVector.x2(), gradientVector.y2(), gradientVector.x1(), gradientVector.y1(), 1, 0);
2029
                                        item->setStrokeGradient(strokeGradient);
2030
                                        item->setStrokeGradientType(strokeGradientTyp);
2031
                                }
17199 fschmid 2032
                                FPoint wh = getMaxClipF(&item->PoLine);
2033
                                item->setWidthHeight(wh.x(),wh.y());
17206 fschmid 2034
                                item->setTextFlowMode(textFlow);
17199 fschmid 2035
                                m_Doc->AdjustItemSize(item);
17222 fschmid 2036
                                item->setRotation(-rot, true);
17199 fschmid 2037
                                item->moveBy(dx, dy, true);
17259 fschmid 2038
                                if (isPathText)
2039
                                {
2040
                                        if (isOpen)
2041
                                        {
2042
                                                if (scX < 0)
17262 fschmid 2043
                                                {
17259 fschmid 2044
                                                        item->PoLine.reverse();
17262 fschmid 2045
                                                }
17259 fschmid 2046
                                        }
2047
                                        else
2048
                                        {
2049
                                                if (scX > 0)
17262 fschmid 2050
                                                {
2051
                                                        double totalCurveLen = 0;
18114 jghali 2052
                                                        for (int segs = 0; segs < item->PoLine.size()-3; segs += 4)
17262 fschmid 2053
                                                        {
2054
                                                                totalCurveLen += item->PoLine.lenPathSeg(segs);
2055
                                                        }
2056
                                                        item->setTextToFrameDistLeft(totalCurveLen - pathTextStart);
17259 fschmid 2057
                                                        item->PoLine.reverse();
17262 fschmid 2058
                                                }
17259 fschmid 2059
                                        }
2060
                                }
17199 fschmid 2061
                                item->OldB2 = item->width();
2062
                                item->OldH2 = item->height();
2063
                                item->updateClip();
2064
                                item->setItemName(itemName);
2065
                                if (importerFlags & LoadSavePlugin::lfCreateDoc)
2066
                                        item->setLayer(layerNum);
2067
                                if ((itElem.tagName() == "Rectangle") && (itElem.attribute("CornerOption") == "RoundedCorner"))
2068
                                {
2069
                                        item->SetRectFrame();
2070
                                        item-