Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 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
*/
2688 craig 7
 
10223 cbradney 8
#include <QCursor>
13085 jghali 9
#include <QDebug>
9764 jghali 10
#include <QDrag>
10292 cbradney 11
#include <QFile>
12
#include <QList>
16546 jghali 13
#include <QMessageBox>
9764 jghali 14
#include <QMimeData>
10638 jghali 15
#include <QPainterPath>
10292 cbradney 16
#include <QRegExp>
12795 fschmid 17
#include <QTemporaryFile>
19093 craig 18
 
19
#include "svgplugin.h"
20
 
10292 cbradney 21
#include "color.h"
3934 cbradney 22
#include "commonstrings.h"
10292 cbradney 23
#include "fonts/scfontmetrics.h"
3934 cbradney 24
#include "fpointarray.h"
10292 cbradney 25
#include "loadsaveplugin.h"
26
#include "pageitem.h"
27
#include "prefsfile.h"
2834 cbradney 28
#include "prefsmanager.h"
18910 fschmid 29
#include "qtiocompressor.h"
19093 craig 30
#include "scclocale.h"
10292 cbradney 31
#include "sccolorengine.h"
32
#include "scconfig.h"
16171 fschmid 33
#include "sclimits.h"
12841 jghali 34
#include "scmimedata.h"
12785 fschmid 35
#include "scpaths.h"
12737 fschmid 36
#include "scpattern.h"
3934 cbradney 37
#include "scraction.h"
10292 cbradney 38
#include "scribusXml.h"
5781 cbradney 39
#include "scribuscore.h"
3207 craig 40
#include "scribusdoc.h"
19093 craig 41
#include "scribusdoc.h"
42
#include "scribusview.h"
3934 cbradney 43
#include "selection.h"
14170 jghali 44
#include "ui/customfdialog.h"
45
#include "ui/propertiespalette.h"
19605 jghali 46
#include "ui/scmessagebox.h"
19093 craig 47
#include "ui/scmwmenumanager.h"
3934 cbradney 48
#include "undomanager.h"
49
#include "util.h"
10292 cbradney 50
#include "util_formats.h"
10200 cbradney 51
#include "util_icon.h"
10203 cbradney 52
#include "util_math.h"
68 Franz 53
 
10862 cbradney 54
 
504 cbradney 55
using namespace std;
56
 
3207 craig 57
int svgimplugin_getPluginAPIVersion()
68 Franz 58
{
3207 craig 59
        return PLUGIN_API_VERSION;
68 Franz 60
}
61
 
3207 craig 62
ScPlugin* svgimplugin_getPlugin()
68 Franz 63
{
3207 craig 64
        SVGImportPlugin* plug = new SVGImportPlugin();
65
        Q_CHECK_PTR(plug);
66
        return plug;
68 Franz 67
}
68
 
3207 craig 69
void svgimplugin_freePlugin(ScPlugin* plugin)
512 fschmid 70
{
3207 craig 71
        SVGImportPlugin* plug = dynamic_cast<SVGImportPlugin*>(plugin);
72
        Q_ASSERT(plug);
73
        delete plug;
512 fschmid 74
}
75
 
3696 craig 76
SVGImportPlugin::SVGImportPlugin() : LoadSavePlugin(),
17118 craig 77
        importAction(new ScrAction(ScrAction::DLL, "", QKeySequence(), this))
1208 cbradney 78
{
3207 craig 79
        // Set action info in languageChange, so we only have to do
3686 craig 80
        // it in one place. This includes registering file format
81
        // support.
18254 fschmid 82
        registerFormats();
3207 craig 83
        languageChange();
5243 cbradney 84
}
12110 fschmid 85
/*
5243 cbradney 86
void SVGImportPlugin::addToMainWindowMenu(ScribusMainWindow *mw)
87
{
3696 craig 88
        importAction->setEnabled(true);
10725 jghali 89
        connect( importAction, SIGNAL(triggered()), SLOT(import()) );
5243 cbradney 90
        mw->scrMenuMgr->addMenuItem(importAction, "FileImport");
1208 cbradney 91
}
12110 fschmid 92
*/
3686 craig 93
SVGImportPlugin::~SVGImportPlugin()
94
{
95
        unregisterAll();
18254 fschmid 96
}
3207 craig 97
 
98
void SVGImportPlugin::languageChange()
1208 cbradney 99
{
10427 cbradney 100
        importAction->setText( tr("Import &SVG..."));
18254 fschmid 101
        FileFormat* fmt = getFormatByExt("svg");
102
        fmt->trName = FormatsManager::instance()->nameOfFormat(FormatsManager::SVG);
103
        fmt->filter = FormatsManager::instance()->extensionsForFormat(FormatsManager::SVG);
1208 cbradney 104
}
105
 
3207 craig 106
const QString SVGImportPlugin::fullTrName() const
1208 cbradney 107
{
3207 craig 108
        return QObject::tr("SVG Import");
1208 cbradney 109
}
110
 
3207 craig 111
const ScActionPlugin::AboutData* SVGImportPlugin::getAboutData() const
1208 cbradney 112
{
3241 craig 113
        AboutData* about = new AboutData;
3344 fschmid 114
        about->authors = "Franz Schmid <franz@scribus.info>";
3355 cbradney 115
        about->shortDescription = tr("Imports SVG Files");
3357 cbradney 116
        about->description = tr("Imports most SVG files into the current document,\nconverting their vector data into Scribus objects.");
3344 fschmid 117
        about->license = "GPL";
3241 craig 118
        Q_CHECK_PTR(about);
119
        return about;
1208 cbradney 120
}
121
 
3241 craig 122
void SVGImportPlugin::deleteAboutData(const AboutData* about) const
1208 cbradney 123
{
3241 craig 124
        Q_ASSERT(about);
125
        delete about;
1208 cbradney 126
}
127
 
3686 craig 128
void SVGImportPlugin::registerFormats()
3487 craig 129
{
4024 craig 130
        FileFormat fmt(this);
10292 cbradney 131
        fmt.trName = FormatsManager::instance()->nameOfFormat(FormatsManager::SVG);
18297 fschmid 132
        fmt.formatId = 0;
10292 cbradney 133
        fmt.filter = FormatsManager::instance()->extensionsForFormat(FormatsManager::SVG);
14665 fschmid 134
        fmt.fileExtensions = QStringList() << "svg" << "svgz";
3686 craig 135
        fmt.load = true;
136
        fmt.save = false;
14692 fschmid 137
        fmt.thumb = true;
10292 cbradney 138
        fmt.mimeTypes = FormatsManager::instance()->mimetypeOfFormat(FormatsManager::SVG);
3643 craig 139
        fmt.priority = 64;
3686 craig 140
        registerFormat(fmt);
3487 craig 141
}
142
 
5642 cbradney 143
bool SVGImportPlugin::fileSupported(QIODevice* /* file */, const QString & fileName) const
3487 craig 144
{
145
        // TODO: identify valid SVG
146
        return true;
147
}
148
 
5539 mrdocs 149
bool SVGImportPlugin::loadFile(const QString & fileName, const FileFormat & /* fmt */, int flags, int /*index*/)
4024 craig 150
{
151
        // For now, "load file" and import are the same thing for this plugin
5539 mrdocs 152
        return import(fileName, flags);
4024 craig 153
}
154
 
5539 mrdocs 155
bool SVGImportPlugin::import(QString filename, int flags)
68 Franz 156
{
5539 mrdocs 157
        if (!checkFlags(flags))
158
                return false;
14692 fschmid 159
        m_Doc = ScCore->primaryMainWindow()->doc;
5781 cbradney 160
        ScribusMainWindow* mw=(m_Doc==0) ? ScCore->primaryMainWindow() : m_Doc->scMW();
3207 craig 161
        if (filename.isEmpty())
506 fschmid 162
        {
5539 mrdocs 163
                flags |= lfInteractive;
2856 cbradney 164
                PrefsContext* prefs = PrefsManager::instance()->prefsFile->getPluginContext("SVGPlugin");
506 fschmid 165
                QString wdir = prefs->get("wdir", ".");
10292 cbradney 166
                CustomFDialog diaf(mw, wdir, QObject::tr("Open"), FormatsManager::instance()->fileDialogFormatList(FormatsManager::SVG));
506 fschmid 167
                if (diaf.exec())
168
                {
3207 craig 169
                        filename = diaf.selectedFile();
10427 cbradney 170
                        prefs->set("wdir", filename.left(filename.lastIndexOf("/")));
506 fschmid 171
                }
172
                else
3207 craig 173
                        return true;
415 Franz 174
        }
5781 cbradney 175
 
19420 jghali 176
        UndoTransaction activeTransaction;
11576 avox 177
        bool emptyDoc = (m_Doc == NULL);
13378 jghali 178
        bool hasCurrentPage = (m_Doc && m_Doc->currentPage());
13371 jghali 179
        TransactionSettings trSettings;
13378 jghali 180
        trSettings.targetName   = hasCurrentPage ? m_Doc->currentPage()->getUName() : "";
13371 jghali 181
        trSettings.targetPixmap = Um::IImageFrame;
182
        trSettings.actionName   = Um::ImportSVG;
183
        trSettings.description  = filename;
184
        trSettings.actionPixmap = Um::ISVG;
185
        if (emptyDoc || !(flags & lfInteractive) || !(flags & lfScripted))
1439 tsoots 186
                UndoManager::instance()->setUndoEnabled(false);
13371 jghali 187
        if (UndoManager::undoEnabled())
19420 jghali 188
                activeTransaction = UndoManager::instance()->beginTransaction(trSettings);
14692 fschmid 189
        SVGPlug *dia = new SVGPlug(m_Doc, flags);
3207 craig 190
        Q_CHECK_PTR(dia);
13371 jghali 191
        dia->import(filename, trSettings, flags);
11576 avox 192
        if (activeTransaction)
19420 jghali 193
                activeTransaction.commit();
13371 jghali 194
        if (emptyDoc || !(flags & lfInteractive) || !(flags & lfScripted))
1439 tsoots 195
                UndoManager::instance()->setUndoEnabled(true);
7795 fschmid 196
        if (dia->importCanceled)
3800 subik 197
        {
7795 fschmid 198
                if (dia->importFailed)
19605 jghali 199
                        ScMessageBox::warning(mw, CommonStrings::trWarning, tr("The file could not be imported"));
16230 fschmid 200
        //      else if (dia->unsupported)
19605 jghali 201
        //              ScMessageBox::warning(mw, CommonStrings::trWarning, tr("SVG file contains some unsupported features"));
3800 subik 202
        }
203
 
217 Franz 204
        delete dia;
3207 craig 205
        return true;
68 Franz 206
}
207
 
14692 fschmid 208
QImage SVGImportPlugin::readThumbnail(const QString& fileName)
209
{
210
        if( fileName.isEmpty() )
211
                return QImage();
17747 craig 212
        UndoManager::instance()->setUndoEnabled(false);
14692 fschmid 213
        m_Doc = NULL;
214
        SVGPlug *dia = new SVGPlug(m_Doc, lfCreateThumbnail);
215
        Q_CHECK_PTR(dia);
216
        QImage ret = dia->readThumbnail(fileName);
17747 craig 217
        UndoManager::instance()->setUndoEnabled(true);
14692 fschmid 218
        delete dia;
219
        return ret;
220
}
221
 
222
SVGPlug::SVGPlug( ScribusDoc* doc, int flags )
223
{
224
        tmpSel = new Selection(this, false);
225
        m_Doc = doc;
3800 subik 226
        unsupported = false;
7794 fschmid 227
        importFailed = false;
7795 fschmid 228
        importCanceled = true;
16230 fschmid 229
        firstLayer = true;
7991 fschmid 230
        importedColors.clear();
14151 fschmid 231
        importedGradients.clear();
12737 fschmid 232
        importedPatterns.clear();
7866 fschmid 233
        docDesc = "";
234
        docTitle = "";
235
        groupLevel = 0;
14692 fschmid 236
        importerFlags = flags;
5539 mrdocs 237
        interactive = (flags & LoadSavePlugin::lfInteractive);
9922 fschmid 238
//      m_gc.setAutoDelete( true );
8043 jghali 239
}
240
 
14692 fschmid 241
QImage SVGPlug::readThumbnail(QString fName)
242
{
243
        if (!loadData(fName))
244
                return QImage();
245
        QString CurDirP = QDir::currentPath();
246
        QFileInfo efp(fName);
247
        QDir::setCurrent(efp.path());
248
        SvgStyle *gc = new SvgStyle;
249
        QDomElement docElem = inpdoc.documentElement();
20005 jghali 250
        QSizeF wh = parseWidthHeight(docElem);
14692 fschmid 251
        m_Doc = new ScribusDoc();
252
        m_Doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
253
        m_Doc->setPage(wh.width(), wh.height(), 0, 0, 0, 0, 0, 0, false, false);
254
        m_Doc->addPage(0);
255
        m_Doc->setGUI(false, ScCore->primaryMainWindow(), 0);
256
        m_Doc->setLoading(true);
257
        m_Doc->DoDrawing = false;
14754 jghali 258
        m_Doc->scMW()->setScriptRunning(true);
14932 cbradney 259
        gc->FontFamily = m_Doc->itemToolPrefs().textFont;
14692 fschmid 260
        if (!m_Doc->PageColors.contains("Black"))
261
                m_Doc->PageColors.insert("Black", ScColor(0, 0, 0, 255));
262
        m_gc.push( gc );
263
        viewTransformX = 0;
264
        viewTransformY = 0;
265
        viewScaleX = 1;
266
        viewScaleY = 1;
267
        if( !docElem.attribute( "viewBox" ).isEmpty() )
268
        {
269
                QString viewbox( docElem.attribute( "viewBox" ) );
270
                QStringList points = viewbox.replace( QRegExp(","), " ").simplified().split( ' ', QString::SkipEmptyParts );
271
                if (points.size() > 3)
272
                {
273
                        QTransform matrix;
20005 jghali 274
                        QSizeF wh2 = parseWidthHeight(docElem);
14692 fschmid 275
                        double w2 = wh2.width();
276
                        double h2 = wh2.height();
277
                        addGraphicContext();
278
                        viewTransformX = ScCLocale::toDoubleC(points[0]);
279
                        viewTransformY = ScCLocale::toDoubleC(points[1]);
280
                        viewScaleX = w2 / ScCLocale::toDoubleC(points[2]);
281
                        viewScaleY = h2 / ScCLocale::toDoubleC(points[3]);
282
                        matrix.translate(-viewTransformX * viewScaleX, -viewTransformY * viewScaleY);
283
                        matrix.scale(viewScaleX, viewScaleY);
284
                        m_gc.top()->matrix = matrix;
285
                }
286
        }
287
        QList<PageItem*> Elements = parseGroup( docElem );
288
        tmpSel->clear();
289
        QImage tmpImage = QImage();
290
        if (Elements.count() > 0)
291
        {
16105 fschmid 292
                m_Doc->groupObjectsList(Elements);
14692 fschmid 293
                m_Doc->DoDrawing = true;
294
                m_Doc->m_Selection->delaySignalsOn();
295
                for (int dre=0; dre<Elements.count(); ++dre)
296
                {
297
                        tmpSel->addItem(Elements.at(dre), true);
298
                }
299
                tmpSel->setGroupRect();
300
                double xs = tmpSel->width();
301
                double ys = tmpSel->height();
16504 fschmid 302
                tmpImage = Elements.at(0)->DrawObj_toImage(500);
14692 fschmid 303
                tmpImage.setText("XSize", QString("%1").arg(xs));
304
                tmpImage.setText("YSize", QString("%1").arg(ys));
305
                m_Doc->m_Selection->delaySignalsOff();
306
        }
14754 jghali 307
        m_Doc->scMW()->setScriptRunning(false);
14692 fschmid 308
        m_Doc->setLoading(false);
309
        delete m_Doc;
310
        QDir::setCurrent(CurDirP);
311
        return tmpImage;
312
}
313
 
13371 jghali 314
bool SVGPlug::import(QString fname, const TransactionSettings& trSettings, int flags)
8043 jghali 315
{
316
        if (!loadData(fname))
13403 jghali 317
        {
318
                importFailed = true;
8043 jghali 319
                return false;
13403 jghali 320
        }
10398 cbradney 321
        QString CurDirP = QDir::currentPath();
8043 jghali 322
        QFileInfo efp(fname);
10600 fschmid 323
        QDir::setCurrent(efp.path());
13371 jghali 324
        convert(trSettings, flags);
8043 jghali 325
        QDir::setCurrent(CurDirP);
326
        return true;
327
}
328
 
329
bool SVGPlug::loadData(QString fName)
330
{
331
        QString f("");
11962 jghali 332
        bool isCompressed = false, success = false;
10600 fschmid 333
        QByteArray bb(3, ' ');
8424 fschmid 334
        QFile fi(fName);
8501 cbradney 335
        if (fi.open(QIODevice::ReadOnly))
217 Franz 336
        {
10600 fschmid 337
                fi.read(bb.data(), 2);
8424 fschmid 338
                fi.close();
8625 subik 339
                // Qt4 bb[0]->QChar(bb[0])
340
                if ((QChar(bb[0]) == QChar(0x1F)) && (QChar(bb[1]) == QChar(0x8B)))
8424 fschmid 341
                        isCompressed = true;
342
        }
343
        if ((fName.right(2) == "gz") || (isCompressed))
344
        {
18910 fschmid 345
                QFile file(fName);
346
                QtIOCompressor compressor(&file);
347
                compressor.setStreamFormat(QtIOCompressor::GzipFormat);
348
                if (!compressor.open(QIODevice::ReadOnly))
8043 jghali 349
                        return false;
18910 fschmid 350
                success = inpdoc.setContent(&compressor);
351
                compressor.close();
217 Franz 352
        }
68 Franz 353
        else
11962 jghali 354
        {
355
                QFile file(fName);
356
                if (!file.open(QIODevice::ReadOnly))
357
                        return false;
358
                success = inpdoc.setContent(&file);
359
                file.close();
360
        }
361
        return success;
68 Franz 362
}
363
 
13371 jghali 364
void SVGPlug::convert(const TransactionSettings& trSettings, int flags)
68 Franz 365
{
366
        bool ret = false;
367
        SvgStyle *gc = new SvgStyle;
368
        QDomElement docElem = inpdoc.documentElement();
20005 jghali 369
        QSizeF wh = parseWidthHeight(docElem);
7573 jghali 370
        double width = wh.width();
371
        double height = wh.height();
5539 mrdocs 372
        if (!interactive || (flags & LoadSavePlugin::lfInsertPage))
217 Franz 373
        {
5781 cbradney 374
                m_Doc->setPage(width, height, 0, 0, 0, 0, 0, 0, false, false);
19322 fschmid 375
                if (m_Doc->Pages->count() == 0)
376
                {
377
                        m_Doc->addPage(0);
378
                        m_Doc->view()->addPage(0);
379
                }
217 Franz 380
        }
506 fschmid 381
        else
382
        {
5781 cbradney 383
                if (!m_Doc || (flags & LoadSavePlugin::lfCreateDoc))
506 fschmid 384
                {
5798 jghali 385
                        m_Doc=ScCore->primaryMainWindow()->doFileNew(width, height, 0, 0, 0, 0, 0, 0, false, false, 0, false, 0, 1, "Custom", true);
5781 cbradney 386
                        ScCore->primaryMainWindow()->HaveNewDoc();
506 fschmid 387
                        ret = true;
388
                }
389
        }
3207 craig 390
        if ((ret) || (!interactive))
550 fschmid 391
        {
392
                if (width > height)
14991 cbradney 393
                        m_Doc->setPageOrientation(1);
550 fschmid 394
                else
14991 cbradney 395
                        m_Doc->setPageOrientation(0);
396
                m_Doc->setPageSize("Custom");
550 fschmid 397
        }
19856 fschmid 398
        if ((!(flags & LoadSavePlugin::lfLoadAsPattern)) && (m_Doc->view() != NULL))
16016 fschmid 399
                m_Doc->view()->Deselect();
5781 cbradney 400
        m_Doc->setLoading(true);
401
        m_Doc->DoDrawing = false;
19856 fschmid 402
        if ((!(flags & LoadSavePlugin::lfLoadAsPattern)) && (m_Doc->view() != NULL))
16016 fschmid 403
                m_Doc->view()->updatesOn(false);
14754 jghali 404
        m_Doc->scMW()->setScriptRunning(true);
18181 fschmid 405
        qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
14932 cbradney 406
        gc->FontFamily = m_Doc->itemToolPrefs().textFont;
5781 cbradney 407
        if (!m_Doc->PageColors.contains("Black"))
408
                m_Doc->PageColors.insert("Black", ScColor(0, 0, 0, 255));
68 Franz 409
        m_gc.push( gc );
1013 fschmid 410
        viewTransformX = 0;
411
        viewTransformY = 0;
412
        viewScaleX = 1;
413
        viewScaleY = 1;
414
        if( !docElem.attribute( "viewBox" ).isEmpty() )
415
        {
416
                QString viewbox( docElem.attribute( "viewBox" ) );
10603 fschmid 417
                QStringList points = viewbox.replace( QRegExp(","), " ").simplified().split( ' ', QString::SkipEmptyParts );
11080 fschmid 418
                if (points.size() > 3)
419
                {
13951 fschmid 420
                        QTransform matrix;
20005 jghali 421
                        QSizeF wh2 = parseWidthHeight(docElem);
11080 fschmid 422
                        double w2 = wh2.width();
423
                        double h2 = wh2.height();
424
                        addGraphicContext();
13460 jghali 425
                        viewTransformX = ScCLocale::toDoubleC(points[0]);
426
                        viewTransformY = ScCLocale::toDoubleC(points[1]);
427
                        viewScaleX = w2 / ScCLocale::toDoubleC(points[2]);
428
                        viewScaleY = h2 / ScCLocale::toDoubleC(points[3]);
12101 jghali 429
                        matrix.translate(-viewTransformX * viewScaleX, -viewTransformY * viewScaleY);
11080 fschmid 430
                        matrix.scale(viewScaleX, viewScaleY);
431
                        m_gc.top()->matrix = matrix;
432
                }
1013 fschmid 433
        }
17520 fschmid 434
        Elements += parseDoc( docElem );
7866 fschmid 435
        if (flags & LoadSavePlugin::lfCreateDoc)
436
        {
15037 cbradney 437
                m_Doc->documentInfo().setTitle(docTitle);
438
                m_Doc->documentInfo().setComments(docDesc);
7866 fschmid 439
        }
7578 cbradney 440
        tmpSel->clear();
7794 fschmid 441
        if (Elements.count() == 0)
7991 fschmid 442
        {
7794 fschmid 443
                importFailed = true;
14157 fschmid 444
                if ((importedColors.count() != 0) && ((flags & LoadSavePlugin::lfKeepGradients) || (flags & LoadSavePlugin::lfKeepColors) || (flags & LoadSavePlugin::lfKeepPatterns)))
445
                        importFailed = false;
446
                if ((importedGradients.count() != 0) && ((flags & LoadSavePlugin::lfKeepGradients) || (flags & LoadSavePlugin::lfKeepPatterns)))
447
                        importFailed = false;
448
                if ((importedPatterns.count() != 0) && (flags & LoadSavePlugin::lfKeepPatterns))
449
                        importFailed = false;
450
                if ((importedColors.count() != 0) && (!((flags & LoadSavePlugin::lfKeepGradients) || (flags & LoadSavePlugin::lfKeepColors) || (flags & LoadSavePlugin::lfKeepPatterns))))
7991 fschmid 451
                {
8625 subik 452
                        for (int cd = 0; cd < importedColors.count(); cd++)
7991 fschmid 453
                        {
454
                                m_Doc->PageColors.remove(importedColors[cd]);
455
                        }
456
                }
14157 fschmid 457
                if ((importedGradients.count() != 0) && (!((flags & LoadSavePlugin::lfKeepGradients || (flags & LoadSavePlugin::lfKeepPatterns)))))
14151 fschmid 458
                {
459
                        for (int cd = 0; cd < importedGradients.count(); cd++)
460
                        {
461
                                m_Doc->docGradients.remove(importedGradients[cd]);
462
                        }
463
                }
14157 fschmid 464
                if ((importedPatterns.count() != 0) && (!(flags & LoadSavePlugin::lfKeepPatterns)))
12737 fschmid 465
                {
466
                        for (int cd = 0; cd < importedPatterns.count(); cd++)
467
                        {
468
                                m_Doc->docPatterns.remove(importedPatterns[cd]);
469
                        }
470
                }
7991 fschmid 471
        }
16230 fschmid 472
        if ((Elements.count() > 1) && (!(flags & LoadSavePlugin::lfCreateDoc)))
217 Franz 473
        {
16105 fschmid 474
                m_Doc->groupObjectsList(Elements);
217 Franz 475
        }
5781 cbradney 476
        m_Doc->DoDrawing = true;
14754 jghali 477
        m_Doc->scMW()->setScriptRunning(false);
3207 craig 478
        if (interactive)
5781 cbradney 479
                m_Doc->setLoading(false);
9380 fschmid 480
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
3207 craig 481
        if ((Elements.count() > 0) && (!ret) && (interactive))
217 Franz 482
        {
8262 fschmid 483
                if (flags & LoadSavePlugin::lfScripted)
217 Franz 484
                {
8262 fschmid 485
                        bool loadF = m_Doc->isLoading();
486
                        m_Doc->setLoading(false);
487
                        m_Doc->changed();
488
                        m_Doc->setLoading(loadF);
16105 fschmid 489
                        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
8262 fschmid 490
                        {
16016 fschmid 491
                                m_Doc->m_Selection->delaySignalsOn();
492
                                for (int dre=0; dre<Elements.count(); ++dre)
493
                                {
494
                                        m_Doc->m_Selection->addItem(Elements.at(dre), true);
495
                                }
496
                                m_Doc->m_Selection->delaySignalsOff();
497
                                m_Doc->m_Selection->setGroupRect();
19856 fschmid 498
                                if (m_Doc->view() != NULL)
499
                                        m_Doc->view()->updatesOn(true);
8262 fschmid 500
                        }
501
                        importCanceled = false;
217 Franz 502
                }
8262 fschmid 503
                else
504
                {
505
                        m_Doc->DragP = true;
506
                        m_Doc->DraggedElem = 0;
507
                        m_Doc->DragElements.clear();
11835 fschmid 508
                        m_Doc->m_Selection->delaySignalsOn();
9856 fschmid 509
                        for (int dre=0; dre<Elements.count(); ++dre)
8262 fschmid 510
                        {
511
                                tmpSel->addItem(Elements.at(dre), true);
512
                        }
513
                        tmpSel->setGroupRect();
18028 jghali 514
                        ScElemMimeData* md = ScriXmlDoc::WriteToMimeData(m_Doc, tmpSel);
8262 fschmid 515
                        m_Doc->itemSelection_DeleteItem(tmpSel);
516
                        m_Doc->view()->updatesOn(true);
14157 fschmid 517
                        if ((importedColors.count() != 0) && (!((flags & LoadSavePlugin::lfKeepGradients) || (flags & LoadSavePlugin::lfKeepColors) || (flags & LoadSavePlugin::lfKeepPatterns))))
12737 fschmid 518
                        {
519
                                for (int cd = 0; cd < importedColors.count(); cd++)
520
                                {
521
                                        m_Doc->PageColors.remove(importedColors[cd]);
522
                                }
523
                        }
14157 fschmid 524
                        if ((importedGradients.count() != 0) && (!((flags & LoadSavePlugin::lfKeepGradients) || (flags & LoadSavePlugin::lfKeepPatterns))))
14151 fschmid 525
                        {
526
                                for (int cd = 0; cd < importedGradients.count(); cd++)
527
                                {
528
                                        m_Doc->docGradients.remove(importedGradients[cd]);
529
                                }
530
                        }
14157 fschmid 531
                        if ((importedPatterns.count() != 0) && (!(flags & LoadSavePlugin::lfKeepPatterns)))
12737 fschmid 532
                        {
533
                                for (int cd = 0; cd < importedPatterns.count(); cd++)
534
                                {
535
                                        m_Doc->docPatterns.remove(importedPatterns[cd]);
536
                                }
537
                        }
11835 fschmid 538
                        m_Doc->m_Selection->delaySignalsOff();
13371 jghali 539
                        // We must copy the TransationSettings object as it is owned
540
                        // by handleObjectImport method afterwards
541
                        TransactionSettings* transacSettings = new TransactionSettings(trSettings);
542
                        m_Doc->view()->handleObjectImport(md, transacSettings);
8262 fschmid 543
                        m_Doc->DragP = false;
544
                        m_Doc->DraggedElem = 0;
545
                        m_Doc->DragElements.clear();
7991 fschmid 546
                }
217 Franz 547
        }
68 Franz 548
        else
357 Franz 549
        {
7351 fschmid 550
                bool loadF = m_Doc->isLoading();
551
                m_Doc->setLoading(false);
5781 cbradney 552
                m_Doc->changed();
6556 fschmid 553
                m_Doc->reformPages();
16105 fschmid 554
                if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16016 fschmid 555
                        m_Doc->view()->updatesOn(true);
7351 fschmid 556
                m_Doc->setLoading(loadF);
357 Franz 557
        }
16105 fschmid 558
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16016 fschmid 559
        {
560
                if (interactive)
561
                        m_Doc->view()->DrawNew();
562
        }
18181 fschmid 563
        qApp->restoreOverrideCursor();
68 Franz 564
}
565
 
566
void SVGPlug::addGraphicContext()
567
{
568
        SvgStyle *gc = new SvgStyle;
9922 fschmid 569
        if ( m_gc.top() )
16220 fschmid 570
        {
9922 fschmid 571
                *gc = *( m_gc.top() );
16220 fschmid 572
                if (m_gc.top()->forGroup)
573
                {
574
                        gc->forGroup = false;
575
                        gc->Opacity = 1.0;
576
                        gc->FillOpacity = 1.0;
577
                        gc->StrokeOpacity = 1.0;
578
                }
579
        }
68 Franz 580
        m_gc.push( gc );
581
}
582
 
7612 jghali 583
void SVGPlug::setupNode( const QDomElement &e )
584
{
585
        addGraphicContext();
586
        setupTransform( e );
9922 fschmid 587
        parseStyle(m_gc.top(), e);
7612 jghali 588
}
589
 
68 Franz 590
void SVGPlug::setupTransform( const QDomElement &e )
591
{
9922 fschmid 592
        SvgStyle *gc = m_gc.top();
13951 fschmid 593
        QTransform mat = parseTransform( e.attribute( "transform" ) );
68 Franz 594
        if (!e.attribute("transform").isEmpty())
595
                gc->matrix = mat * gc->matrix;
596
}
597
 
10785 jghali 598
void SVGPlug::finishNode( const QDomNode &e, PageItem* item)
7612 jghali 599
{
9922 fschmid 600
        SvgStyle *gc = m_gc.top();
13951 fschmid 601
        QTransform gcm = gc->matrix;
7612 jghali 602
        double BaseX = m_Doc->currentPage()->xOffset();
603
        double BaseY = m_Doc->currentPage()->yOffset();
604
        double coeff1 = sqrt(gcm.m11() * gcm.m11() + gcm.m12() * gcm.m12());
605
        double coeff2 = sqrt(gcm.m21() * gcm.m21() + gcm.m22() * gcm.m22());
606
        switch (item->itemType())
607
        {
608
        case PageItem::ImageFrame:
609
                {
12785 fschmid 610
                        item->ClipEdited = true;
611
                        item->FrameType = 3;
13951 fschmid 612
                        QTransform mm = gc->matrix;
12785 fschmid 613
                        item->PoLine.map(mm);
7612 jghali 614
                        item->setLineWidth(item->lineWidth() * (coeff1 + coeff2) / 2.0);
12785 fschmid 615
                        FPoint wh = getMaxClipF(&item->PoLine);
616
                        item->setWidthHeight(wh.x(), wh.y());
617
                        m_Doc->AdjustItemSize(item);
618
//                      item->moveBy(mm.dx(), mm.dy());
619
//                      item->setWidthHeight(item->width() * mm.m11(), item->height() * mm.m22());
620
//                      item->setLineWidth(item->lineWidth() * (coeff1 + coeff2) / 2.0);
19834 craig 621
                        if (item->imageIsAvailable)
12785 fschmid 622
                        {
623
                                item->setImageXYOffset(0.0, 0.0);
624
                                item->setImageXYScale(item->width() / (item->pixm.width() * (item->pixm.imgInfo.xres / 72.0)),
625
                                                                          item->height() / (item->pixm.height() * (item->pixm.imgInfo.yres / 72.0)));
626
                                item->setImageScalingMode(false, false); // fit to frame
627
                        }
7612 jghali 628
                        break;
629
                }
630
        case PageItem::TextFrame:
631
                {
17635 jghali 632
                        //QTransform mm = gc->matrix;
7612 jghali 633
                        item->setLineWidth(item->lineWidth() * (coeff1 + coeff2) / 2.0);
18843 fschmid 634
                        item->itemText.trim();
7612 jghali 635
                }
636
                break;
637
        default:
638
                {
639
                        item->ClipEdited = true;
640
                        item->FrameType = 3;
13951 fschmid 641
                        QTransform mm = gc->matrix;
7612 jghali 642
                        item->PoLine.map(mm);
643
                        /*if (haveViewBox)
644
                        {
13951 fschmid 645
                                QTransform mv;
7612 jghali 646
                                mv.translate(viewTransformX, viewTransformY);
647
                                mv.scale(viewScaleX, viewScaleY);
648
                                ite->PoLine.map(mv);
649
                        }*/
650
                        item->setLineWidth(item->lineWidth() * (coeff1 + coeff2) / 2.0);
651
                        FPoint wh = getMaxClipF(&item->PoLine);
652
                        item->setWidthHeight(wh.x(), wh.y());
7672 fschmid 653
//                      if (item->asPolyLine())
8562 jghali 654
//                              item->setPolyClip(qRound(qMax(item->lineWidth() / 2.0, 1)));
7672 fschmid 655
//                      else
656
//                              item->Clip = FlattenPath(item->PoLine, item->Segments);
12745 fschmid 657
                        FPoint wx = getMinClipF(&item->PoLine);
658
                        inGroupXOrigin = qMin(inGroupXOrigin, wx.x());
659
                        inGroupYOrigin = qMin(inGroupYOrigin, wx.y());
7736 cbradney 660
                        m_Doc->AdjustItemSize(item);
7612 jghali 661
                        break;
662
                }
663
        }
7620 fschmid 664
        item->setRedrawBounding();
7612 jghali 665
        item->OwnPage = m_Doc->OnPage(item);
10785 jghali 666
        if (e.isElement())
667
        {
17156 fschmid 668
                if (!(importerFlags & LoadSavePlugin::lfCreateDoc))
669
                {
670
                        QString nodeId = e.toElement().attribute("id");
671
                        if( !nodeId.isEmpty() )
672
                                item->setItemName(" "+nodeId);
673
                }
10785 jghali 674
        }
7612 jghali 675
        item->setFillTransparency( 1 - gc->FillOpacity * gc->Opacity );
676
        item->setLineTransparency( 1 - gc->StrokeOpacity * gc->Opacity );
677
        item->PLineEnd = gc->PLineEnd;
678
        item->PLineJoin = gc->PLineJoin;
7865 fschmid 679
        if (item->fillColor() == CommonStrings::None)
680
                item->setTextFlowMode(PageItem::TextFlowDisabled);
681
        else
682
                item->setTextFlowMode(PageItem::TextFlowUsesFrameShape);
7678 fschmid 683
        item->DashOffset = gc->dashOffset;
684
        item->DashValues = gc->dashArray;
14232 jghali 685
        if (gc->FillGradientType != 0)
7612 jghali 686
        {
14232 jghali 687
                if (gc->FillGradientType == 8)
7612 jghali 688
                {
14232 jghali 689
                        item->GrType = gc->FillGradientType;
690
                        item->setPattern(importedPattTrans[gc->GFillCol1]);
691
                        QTransform mm = gc->matrixgf;
12751 fschmid 692
                        double rot = getRotationFromMatrix(mm, 0.0) * 180 / M_PI;
693
                        mm.rotate(rot);
694
                        double patDx = (item->xPos() - BaseX) - mm.dx();
695
                        double patDy = (item->yPos() - BaseY) - mm.dy();
14260 fschmid 696
                        item->setPatternTransform(mm.m11() * 100.0, mm.m22() * 100.0, patDx, patDy, -rot, 0, 0);
12737 fschmid 697
                }
698
                else
699
                {
14232 jghali 700
                        if (gc->FillGradient.Stops() > 1)
7612 jghali 701
                        {
14232 jghali 702
                                item->fill_gradient = gc->FillGradient;
703
                                item->setGradient(importedGradTrans[gc->GFillCol1]);
19163 fschmid 704
                                item->setGradientExtend(VGradient::pad);
14232 jghali 705
                                if (!gc->FillCSpace)
7612 jghali 706
                                {
14232 jghali 707
                                        item->GrStartX = gc->GradFillX1 * item->width();
708
                                        item->GrStartY = gc->GradFillY1 * item->height();
709
                                        item->GrEndX   = gc->GradFillX2 * item->width();
710
                                        item->GrEndY   = gc->GradFillY2 * item->height();
14289 jghali 711
                                        item->GrFocalX = gc->GradFillFX * item->width();
712
                                        item->GrFocalY = gc->GradFillFY * item->height();
14232 jghali 713
                                        double angle1 = atan2(gc->GradFillY2-gc->GradFillY1,gc->GradFillX2-gc->GradFillX1)*(180.0/M_PI);
12737 fschmid 714
                                        double angle2 = atan2(item->GrEndY - item->GrStartX, item->GrEndX - item->GrStartX)*(180.0/M_PI);
715
                                        double dx = item->GrStartX + (item->GrEndX - item->GrStartX) / 2.0;
716
                                        double dy = item->GrStartY + (item->GrEndY - item->GrStartY) / 2.0;
13951 fschmid 717
                                        QTransform mm, mm2;
14232 jghali 718
                                        if ((gc->GradFillY1 < gc->GradFillY2) && (gc->GradFillX1 < gc->GradFillX2))
12737 fschmid 719
                                        {
720
                                                mm.rotate(-angle2);
721
                                                mm2.rotate(angle1);
722
                                        }
723
                                        FPointArray gra;
14289 jghali 724
                                        gra.setPoints(3, item->GrStartX-dx, item->GrStartY-dy, item->GrEndX-dx, item->GrEndY-dy, item->GrFocalX-dx, item->GrFocalY-dy);
12737 fschmid 725
                                        gra.map(mm*mm2);
726
                                        gra.translate(dx, dy);
727
                                        item->GrStartX = gra.point(0).x();
728
                                        item->GrStartY = gra.point(0).y();
14232 jghali 729
                                        item->GrEndX   = gra.point(1).x();
730
                                        item->GrEndY   = gra.point(1).y();
14289 jghali 731
                                        item->GrFocalX = gra.point(2).x();
732
                                        item->GrFocalY = gra.point(2).y();
7612 jghali 733
                                }
12737 fschmid 734
                                else
735
                                {
13951 fschmid 736
                                        QTransform mm = gc->matrix;
14232 jghali 737
                                        mm = gc->matrixgf * mm;
12737 fschmid 738
                                        FPointArray gra;
14289 jghali 739
                                        gra.setPoints(3, gc->GradFillX1, gc->GradFillY1, gc->GradFillX2, gc->GradFillY2, gc->GradFillFX, gc->GradFillFY);
12737 fschmid 740
                                        gra.map(mm);
14289 jghali 741
                                        item->GrStartX = gra.point(0).x() - item->xPos() + BaseX;
742
                                        item->GrStartY = gra.point(0).y() - item->yPos() + BaseY;
743
                                        item->GrEndX   = gra.point(1).x() - item->xPos() + BaseX;
744
                                        item->GrEndY   = gra.point(1).y() - item->yPos() + BaseY;
745
                                        item->GrFocalX = gra.point(2).x() - item->xPos() + BaseX;
746
                                        item->GrFocalY = gra.point(2).y() - item->yPos() + BaseY;
12737 fschmid 747
                                }
14232 jghali 748
                                item->GrType = gc->FillGradientType;
7612 jghali 749
                        }
750
                        else
751
                        {
12737 fschmid 752
                                item->GrType = 0;
14232 jghali 753
                                QList<VColorStop*> cstops = gc->FillGradient.colorStops();
12737 fschmid 754
                                item->setFillColor(cstops.at(0)->name);
755
                                item->setFillShade(cstops.at(0)->shade);
7612 jghali 756
                        }
757
                }
758
        }
14232 jghali 759
        if (gc->StrokeGradientType != 0)
760
        {
761
                if (gc->StrokeGradientType == 8)
762
                {
763
                        item->GrTypeStroke = gc->StrokeGradientType;
764
                        item->setPattern(importedPattTrans[gc->GStrokeCol1]);
765
                        QTransform mm = gc->matrixgs;
766
                        double rot = getRotationFromMatrix(mm, 0.0) * 180 / M_PI;
767
                        mm.rotate(rot);
768
                        double patDx = (item->xPos() - BaseX) - mm.dx();
769
                        double patDy = (item->yPos() - BaseY) - mm.dy();
14398 fschmid 770
                        item->setStrokePatternTransform(mm.m11() * 100.0, mm.m22() * 100.0, patDx, patDy, -rot, 0, 0, 1);
14232 jghali 771
                }
772
                else
773
                {
774
                        if (gc->StrokeGradient.Stops() > 1)
775
                        {
776
                                item->stroke_gradient = gc->StrokeGradient;
777
                                item->setStrokeGradient(importedGradTrans[gc->GStrokeCol1]);
19163 fschmid 778
                                item->setStrokeGradientExtend(VGradient::pad);
14232 jghali 779
                                if (!gc->StrokeCSpace)
780
                                {
781
                                        item->GrStrokeStartX = gc->GradStrokeX1 * item->width();
782
                                        item->GrStrokeStartY = gc->GradStrokeY1 * item->height();
783
                                        item->GrStrokeEndX   = gc->GradStrokeX2 * item->width();
784
                                        item->GrStrokeEndY   = gc->GradStrokeY2 * item->height();
14289 jghali 785
                                        item->GrStrokeFocalX = gc->GradStrokeFX * item->width();
786
                                        item->GrStrokeFocalY = gc->GradStrokeFY * item->height();
14232 jghali 787
                                        double angle1 = atan2(gc->GradStrokeY2 - gc->GradStrokeY1, gc->GradStrokeX2 - gc->GradStrokeX1)*(180.0/M_PI);
788
                                        double angle2 = atan2(item->GrStrokeEndY - item->GrStrokeStartX, item->GrStrokeEndX - item->GrStrokeStartX)*(180.0/M_PI);
789
                                        double dx = item->GrStrokeStartX + (item->GrStrokeEndX - item->GrStrokeStartX) / 2.0;
790
                                        double dy = item->GrStrokeStartY + (item->GrStrokeEndY - item->GrStrokeStartY) / 2.0;
791
                                        QTransform mm, mm2;
792
                                        if ((gc->GradStrokeY1 < gc->GradStrokeY2) && (gc->GradStrokeX1 < gc->GradStrokeX2))
793
                                        {
794
                                                mm.rotate(-angle2);
795
                                                mm2.rotate(angle1);
796
                                        }
797
                                        FPointArray gra;
14289 jghali 798
                                        gra.setPoints(3, item->GrStrokeStartX - dx, item->GrStrokeStartY - dy, item->GrStrokeEndX-dx, item->GrStrokeEndY-dy, item->GrStrokeFocalX-dx, item->GrStrokeFocalY-dy);
14232 jghali 799
                                        gra.map(mm*mm2);
800
                                        gra.translate(dx, dy);
801
                                        item->GrStrokeStartX = gra.point(0).x();
802
                                        item->GrStrokeStartY = gra.point(0).y();
803
                                        item->GrStrokeEndX   = gra.point(1).x();
804
                                        item->GrStrokeEndY   = gra.point(1).y();
14289 jghali 805
                                        item->GrStrokeFocalX = gra.point(2).x();
806
                                        item->GrStrokeFocalY = gra.point(2).y();
14232 jghali 807
                                }
808
                                else
809
                                {
810
                                        QTransform mm = gc->matrix;
811
                                        mm = gc->matrixgs * mm;
812
                                        FPointArray gra;
14289 jghali 813
                                        gra.setPoints(3, gc->GradStrokeX1, gc->GradStrokeY1, gc->GradStrokeX2, gc->GradStrokeY2, gc->GradStrokeFX, gc->GradStrokeFY);
14232 jghali 814
                                        gra.map(mm);
14289 jghali 815
                                        item->GrStrokeStartX = gra.point(0).x() - item->xPos() + BaseX;
816
                                        item->GrStrokeStartY = gra.point(0).y() - item->yPos() + BaseY;
817
                                        item->GrStrokeEndX   = gra.point(1).x() - item->xPos() + BaseX;
818
                                        item->GrStrokeEndY   = gra.point(1).y() - item->yPos() + BaseY;
819
                                        item->GrStrokeFocalX = gra.point(2).x() - item->xPos() + BaseX;
820
                                        item->GrStrokeFocalY = gra.point(2).y() - item->yPos() + BaseY;
14232 jghali 821
                                }
822
                                item->GrTypeStroke = gc->StrokeGradientType;
823
                        }
824
                        else
825
                        {
826
                                item->GrTypeStroke = 0;
827
                                QList<VColorStop*> cstops = gc->StrokeGradient.colorStops();
828
                                item->setLineColor(cstops.at(0)->name);
829
                                item->setLineShade(cstops.at(0)->shade);
830
                        }
831
                }
832
        }
17520 fschmid 833
        if (!gc->endMarker.isEmpty())
834
        {
835
                if (markers.contains(gc->endMarker))
836
                {
837
                        FPoint End = item->PoLine.point(item->PoLine.size()-2);
838
                        for (uint xx = item->PoLine.size()-1; xx > 0; xx -= 2)
839
                        {
840
                                FPoint Vector = item->PoLine.point(xx);
841
                                if ((End.x() != Vector.x()) || (End.y() != Vector.y()))
842
                                {
843
                                        double r = atan2(End.y()-Vector.y(),End.x()-Vector.x())*(180.0/M_PI);
844
                                        QTransform arrowTrans;
845
                                        double bX = item->xPos() + End.x();
846
                                        double bY = item->yPos() + End.y();
847
                                        ScPattern pat = m_Doc->docPatterns[gc->endMarker];
17521 fschmid 848
                                        double dX = (pat.width * item->lineWidth()) / 2.0;
849
                                        double dY = (pat.height * item->lineWidth()) / 2.0;
17520 fschmid 850
                                        arrowTrans.translate(bX, bY);
851
                                        arrowTrans.rotate(r);
852
                                        arrowTrans.translate(-dX, -dY);
853
                                        FPoint ba = FPoint(0.0, 0.0).transformPoint(arrowTrans, false);
17521 fschmid 854
                                        int z = m_Doc->itemAdd(PageItem::Symbol, PageItem::Unspecified, ba.x(), ba.y(), dX * 2.0, dY * 2.0, 0, CommonStrings::None, CommonStrings::None, true);
17520 fschmid 855
                                        PageItem* ite = m_Doc->Items->at(z);
856
                                        ite->setPattern(importedPattTrans[gc->endMarker]);
857
                                        ite->setRotation(r, true);
858
                                        Elements.append(ite);
859
                                        break;
860
                                }
861
                        }
862
                }
863
        }
864
        if (!gc->startMarker.isEmpty())
865
        {
866
                if (markers.contains(gc->startMarker))
867
                {
868
                        FPoint End = item->PoLine.point(0);
18114 jghali 869
                        for (int xx = 1; xx < item->PoLine.size(); xx += 2)
17520 fschmid 870
                        {
871
                                FPoint Vector = item->PoLine.point(xx);
872
                                if ((End.x() != Vector.x()) || (End.y() != Vector.y()))
873
                                {
874
                                        double r = atan2(End.y()-Vector.y(),End.x()-Vector.x())*(180.0/M_PI) - 180.0;
875
                                        QTransform arrowTrans;
876
                                        double bX = item->xPos() + End.x();
877
                                        double bY = item->yPos() + End.y();
878
                                        ScPattern pat = m_Doc->docPatterns[gc->startMarker];
17521 fschmid 879
                                        double dX = (pat.width * item->lineWidth()) / 2.0;
880
                                        double dY = (pat.height * item->lineWidth()) / 2.0;
17520 fschmid 881
                                        arrowTrans.translate(bX, bY);
882
                                        arrowTrans.rotate(r);
883
                                        arrowTrans.translate(-dX, -dY);
884
                                        FPoint ba = FPoint(0.0, 0.0).transformPoint(arrowTrans, false);
17521 fschmid 885
                                        int z = m_Doc->itemAdd(PageItem::Symbol, PageItem::Unspecified, ba.x(), ba.y(), dX * 2.0, dY * 2.0, 0, CommonStrings::None, CommonStrings::None, true);
17520 fschmid 886
                                        PageItem* ite = m_Doc->Items->at(z);
887
                                        ite->setPattern(importedPattTrans[gc->startMarker]);
888
                                        ite->setRotation(r, true);
889
                                        Elements.append(ite);
890
                                        break;
891
                                }
892
                        }
893
                }
894
        }
7612 jghali 895
}
896
 
7605 jghali 897
bool SVGPlug::isIgnorableNode( const QDomElement &e )
898
{
899
        QString nodeName(e.tagName());
10021 jghali 900
        return isIgnorableNodeName(nodeName);
901
}
902
 
903
bool SVGPlug::isIgnorableNodeName( const QString &n )
904
{
905
        if (n.startsWith("sodipodi") || n.startsWith("inkscape") || n == "metadata")
7605 jghali 906
                return true;
907
        return false;
908
}
909
 
12725 jghali 910
FPoint SVGPlug::parseTextPosition(const QDomElement &e, const FPoint* pos)
8230 jghali 911
{
12725 jghali 912
        // FIXME According to spec, we should in fact return a point list
913
        double  x = pos ? pos->x() : 0.0;
914
        double  y = pos ? pos->y() : 0.0;
915
 
916
        if (e.hasAttribute( "x" ))
8230 jghali 917
        {
12725 jghali 918
                QString xatt =  e.attribute( "x" , "0" );
919
                if ( xatt.contains(',') || xatt.contains(' ') )
920
                {
921
                        xatt.replace(QChar(','), QChar(' '));
922
                        QStringList xl(xatt.split(QChar(' '), QString::SkipEmptyParts));
923
                        xatt = xl.first();
924
                }
925
                x = parseUnit( xatt );
8230 jghali 926
        }
12725 jghali 927
 
928
        if (e.hasAttribute( "y" ))
8230 jghali 929
        {
12725 jghali 930
                QString yatt =  e.attribute( "y" , "0" );
931
                if ( yatt.contains(',') || yatt.contains(' ') )
932
                {
933
                        yatt.replace(QChar(','), QChar(' '));
934
                        QStringList yl(yatt.split(QChar(' '), QString::SkipEmptyParts));
935
                        yatt = yl.first();
936
                }
937
                y = parseUnit( yatt );
8230 jghali 938
        }
12725 jghali 939
 
940
        if (e.hasAttribute( "dx" ))
941
        {
942
                QString dxatt =  e.attribute( "dx" , "0" );
943
                if ( dxatt.contains(',') || dxatt.contains(' ') )
944
                {
945
                        dxatt.replace(QChar(','), QChar(' '));
946
                        QStringList xl(dxatt.split(QChar(' '), QString::SkipEmptyParts));
947
                        dxatt = xl.first();
948
                }
949
                x += parseUnit( dxatt );
950
        }
951
 
952
        if (e.hasAttribute( "dy" ))
953
        {
954
                QString dyatt =  e.attribute( "dy" , "0" );
955
                if ( dyatt.contains(',') || dyatt.contains(' ') )
956
                {
957
                        dyatt.replace(QChar(','), QChar(' '));
958
                        QStringList xl(dyatt.split(QChar(' '), QString::SkipEmptyParts));
959
                        dyatt = xl.first();
960
                }
961
                y += parseUnit( dyatt );
962
        }
963
 
8230 jghali 964
        return FPoint(x, y);
965
}
966
 
20005 jghali 967
QSizeF SVGPlug::parseWidthHeight(const QDomElement &e)
7573 jghali 968
{
20005 jghali 969
        QSizeF size(550, 841);
7573 jghali 970
        QString sw = e.attribute("width", "100%");
971
        QString sh = e.attribute("height", "100%");
972
        double w =  550, h = 841;
973
        if (!sw.isEmpty())
974
                w = sw.endsWith("%") ? fromPercentage(sw) : parseUnit(sw);
975
        if (!sh.isEmpty())
976
                h = sh.endsWith("%") ? fromPercentage(sh) : parseUnit(sh);
977
        if (!e.attribute("viewBox").isEmpty())
978
        {
20005 jghali 979
                QRectF viewBox = parseViewBox(e);
7573 jghali 980
                double scw = (viewBox.width() > 0 && viewBox.height() > 0) ? viewBox.width()  : size.width();
981
                double sch = (viewBox.width() > 0 && viewBox.height() > 0) ? viewBox.height() : size.height();
982
                w *= (sw.endsWith("%") ? scw : 1.0);
983
                h *= (sh.endsWith("%") ? sch : 1.0);
984
        }
985
        else
986
        {
987
                w *= (sw.endsWith("%") ? size.width() : 1.0);
988
                h *= (sh.endsWith("%") ? size.height() : 1.0);
989
        }
8230 jghali 990
        // OpenOffice files may not have width and height attributes, so avoid unnecessary large dimensions
991
        if (w > 10000 || h > 10000)
992
        {
993
                double m = max(w, h);
994
                w = w / m * 842;
995
                h = h / m * 842;
996
        }
20005 jghali 997
        size.setWidth(w);
998
        size.setHeight(h);
7573 jghali 999
        return size;
1000
}
1001
 
20005 jghali 1002
QRectF SVGPlug::parseViewBox(const QDomElement &e)
7573 jghali 1003
{
20005 jghali 1004
        QRectF box(0, 0, 0, 0);
7573 jghali 1005
        if ( !e.attribute( "viewBox" ).isEmpty() )
1006
        {
1007
                QString viewbox( e.attribute( "viewBox" ) );
10603 fschmid 1008
                QStringList points = viewbox.replace( QRegExp(","), " ").simplified().split( ' ', QString::SkipEmptyParts );
11080 fschmid 1009
                if (points.size() > 3)
1010
                {
13460 jghali 1011
                        double left   = ScCLocale::toDoubleC(points[0]);
1012
                        double bottom = ScCLocale::toDoubleC(points[1]);
1013
                        double width  = ScCLocale::toDoubleC(points[2]);
1014
                        double height = ScCLocale::toDoubleC(points[3]);
11080 fschmid 1015
                        box.setCoords((int) left, (int) bottom, (int) (left + width), (int) (bottom + height));
1016
                }
7573 jghali 1017
        }
1018
        return box;
1019
}
1020
 
7556 jghali 1021
void SVGPlug::parseDefs(const QDomElement &e)
1022
{
1023
        for ( QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling() )
1024
        {
1025
                QDomElement b = n.toElement();
7612 jghali 1026
                if ( b.isNull() )
7556 jghali 1027
                        continue;
1028
                SvgStyle svgStyle;
1029
                parseStyle( &svgStyle, b );
7605 jghali 1030
                if ( !svgStyle.Display)
7556 jghali 1031
                        continue;
16888 jghali 1032
                QString STag2 = parseTagName(b);
8507 jghali 1033
                if ( STag2 == "g" )
10854 jghali 1034
                {
1035
                        QString id = b.attribute("id", "");
1036
                        if (!id.isEmpty())
1037
                                m_nodeMap.insert(id, b);
8507 jghali 1038
                        parseDefs(b);
10854 jghali 1039
                }
8507 jghali 1040
                else if ( STag2 == "linearGradient" || STag2 == "radialGradient" )
7556 jghali 1041
                        parseGradient( b );
7607 fschmid 1042
                else if (STag2 == "clipPath")
1043
                        parseClipPath(b);
12737 fschmid 1044
                else if (STag2 == "pattern")
1045
                        parsePattern(b);
17520 fschmid 1046
                else if (STag2 == "marker")
1047
                        parseMarker(b);
7556 jghali 1048
                else if ( b.hasAttribute("id") )
1049
                {
1050
                        QString id = b.attribute("id");
1051
                        if (!id.isEmpty())
1052
                                m_nodeMap.insert(id, b);
1053
                }
1054
        }
1055
}
1056
 
7605 jghali 1057
void SVGPlug::parseClipPath(const QDomElement &e)
1058
{
1059
        QString id(e.attribute("id"));
1060
        if (!id.isEmpty())
1061
        {
1062
                FPointArray clip;
1063
                QDomNode n2 = e.firstChild();
1064
                QDomElement b2 = n2.toElement();
1065
                while (b2.nodeName() == "use")
8604 jghali 1066
                        b2 = getReferencedNode(b2);
7607 fschmid 1067
                if (b2.nodeName() == "path")
1068
                        parseSVG( b2.attribute( "d" ), &clip );
1069
                else if (b2.nodeName() == "rect")
1070
                {
12101 jghali 1071
                        double x = parseUnit( b2.attribute( "x", "0.0" ));
1072
                        double y = parseUnit( b2.attribute( "y", "0.0" ));
1073
                        double width  = parseUnit( b2.attribute( "width" ));
7607 fschmid 1074
                        double height = parseUnit( b2.attribute( "height" ) );
12101 jghali 1075
                        clip.addQuadPoint(x, y, x, y, width+x, y, width+x, y);
1076
                        clip.addQuadPoint(width+x, y, width+x, y, width+x, height+y, width+x, height+y);
1077
                        clip.addQuadPoint(width+x, height+y, width+x, height+y, x, height+y, x, height+y);
1078
                        clip.addQuadPoint(x, height+y, x, height+y, x, y, x, y);
7607 fschmid 1079
                }
17344 jghali 1080
                if (b2.hasAttribute("transform"))
1081
                {
1082
                        QTransform transform = parseTransform(b2.attribute("transform"));
1083
                        clip.map(transform);
1084
                }
7605 jghali 1085
                if (clip.size() >= 2)
1086
                        m_clipPaths.insert(id, clip);
1087
        }
1088
}
1089
 
1090
void SVGPlug::parseClipPathAttr(const QDomElement &e, FPointArray& clipPath)
1091
{
1092
        clipPath.resize(0);
12802 fschmid 1093
/*      if (e.hasAttribute("style"))
12785 fschmid 1094
        {
1095
                QString style = e.attribute( "style" ).simplified();
1096
                QStringList substyles = style.split(';', QString::SkipEmptyParts);
1097
                for( QStringList::Iterator it = substyles.begin(); it != substyles.end(); ++it )
1098
                {
1099
                        QStringList substyle = (*it).split(':', QString::SkipEmptyParts);
1100
                        QString command(substyle[0].trimmed());
1101
                        QString params(substyle[1].trimmed());
1102
                        if (command == "clip-path")
1103
                        {
1104
                                if (params.startsWith( "url("))
1105
                                {
1106
                                        unsigned int start = params.indexOf("#") + 1;
1107
                                        unsigned int end = params.lastIndexOf(")");
1108
                                        QString key = params.mid(start, end - start);
1109
                                        QMap<QString, FPointArray>::iterator it = m_clipPaths.find(key);
1110
                                        if (it != m_clipPaths.end())
1111
                                                clipPath = it.value().copy();
1112
                                }
1113
                        }
1114
                }
12802 fschmid 1115
        } */
7605 jghali 1116
        if (e.hasAttribute("clip-path"))
1117
        {
1118
                QString attr = e.attribute("clip-path");
1119
                if (attr.startsWith( "url("))
1120
                {
10517 cbradney 1121
                        unsigned int start = attr.indexOf("#") + 1;
10427 cbradney 1122
                        unsigned int end = attr.lastIndexOf(")");
7605 jghali 1123
                        QString key = attr.mid(start, end - start);
1124
                        QMap<QString, FPointArray>::iterator it = m_clipPaths.find(key);
1125
                        if (it != m_clipPaths.end())
10516 cbradney 1126
                                clipPath = it.value().copy();
7605 jghali 1127
                }
1128
        }
1129
}
1130
 
15172 jghali 1131
QList<PageItem*> SVGPlug::parseA(const QDomElement &e)
1132
{
1133
        QList<PageItem*> aElements;
1134
        for ( QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling() )
1135
        {
1136
                QDomElement b = n.toElement();
1137
                if( b.isNull() || isIgnorableNode(b) )
1138
                        continue;
1139
                SvgStyle svgStyle;
1140
                parseStyle( &svgStyle, b);
1141
                if (!svgStyle.Display)
1142
                        continue;
1143
                QList<PageItem*> el = parseElement(b);
1144
                for (int ec = 0; ec < el.count(); ++ec)
1145
                        aElements.append(el.at(ec));
1146
        }
1147
        return aElements;
1148
}
1149
 
9856 fschmid 1150
QList<PageItem*> SVGPlug::parseGroup(const QDomElement &e)
68 Franz 1151
{
7612 jghali 1152
        FPointArray clipPath;
9856 fschmid 1153
        QList<PageItem*> GElements, gElements;
16230 fschmid 1154
        if ((importerFlags & LoadSavePlugin::lfCreateDoc) && (e.hasAttribute("inkscape:groupmode")) && (e.attribute("inkscape:groupmode") == "layer"))
217 Franz 1155
        {
16230 fschmid 1156
                setupNode(e);
1157
                QString LayerName = e.attribute("inkscape:label", "Layer");
1158
                double trans = m_gc.top()->Opacity;
1159
                int currentLayer = 0;
1160
                if (!firstLayer)
1161
                        currentLayer = m_Doc->addLayer(LayerName, true);
1162
                else
1163
                        m_Doc->changeLayerName(currentLayer, LayerName);
1164
                m_Doc->setLayerVisible(currentLayer, true);
1165
                m_Doc->setLayerLocked(currentLayer, false);
1166
                m_Doc->setLayerPrintable(currentLayer, true);
1167
                m_Doc->setLayerTransparency(currentLayer, trans);
1168
                firstLayer = false;
1169
                for ( QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling() )
7640 fschmid 1170
                {
16230 fschmid 1171
                        QDomElement b = n.toElement();
1172
                        if( b.isNull() || isIgnorableNode(b) )
1173
                                continue;
1174
                        SvgStyle svgStyle;
1175
                        parseStyle( &svgStyle, b);
1176
                        if (!svgStyle.Display)
1177
                                continue;
1178
                        QList<PageItem*> el = parseElement(b);
1179
                        for (int ec = 0; ec < el.count(); ++ec)
1180
                                GElements.append(el.at(ec));
7640 fschmid 1181
                }
16230 fschmid 1182
                delete( m_gc.pop() );
7612 jghali 1183
        }
1184
        else
1185
        {
16230 fschmid 1186
                double BaseX = m_Doc->currentPage()->xOffset();
1187
                double BaseY = m_Doc->currentPage()->yOffset();
1188
                groupLevel++;
1189
                setupNode(e);
1190
                parseClipPathAttr(e, clipPath);
1191
                m_gc.top()->forGroup = true;
1192
                int z = m_Doc->itemAdd(PageItem::Group, PageItem::Rectangle, BaseX, BaseY, 1, 1, 0, CommonStrings::None, CommonStrings::None, true);
1193
                PageItem *neu = m_Doc->Items->at(z);
1194
                for ( QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling() )
7612 jghali 1195
                {
16230 fschmid 1196
                        QDomElement b = n.toElement();
1197
                        if( b.isNull() || isIgnorableNode(b) )
1198
                                continue;
1199
                        SvgStyle svgStyle;
1200
                        parseStyle( &svgStyle, b);
1201
                        if (!svgStyle.Display)
1202
                                continue;
1203
                        QList<PageItem*> el = parseElement(b);
1204
                        for (int ec = 0; ec < el.count(); ++ec)
1205
                                gElements.append(el.at(ec));
7612 jghali 1206
                }
16230 fschmid 1207
                groupLevel--;
1208
                SvgStyle *gc = m_gc.top();
1209
                if (clipPath.size() == 0)
7612 jghali 1210
                {
16230 fschmid 1211
                        if (gc->clipPath.size() != 0)
1212
                                clipPath = gc->clipPath.copy();
7612 jghali 1213
                }
16230 fschmid 1214
                if (gElements.count() == 0 || (gElements.count() < 2 && (clipPath.size() == 0) && (gc->Opacity == 1.0)))
1215
                {
1216
                        // Unfortunately we have to take the long route here, or we risk crash on undo/redo
1217
                        // FIXME : create group object after parsing grouped objects
1218
                        /*m_Doc->Items->takeAt(z);
1219
                        delete neu;*/
1220
                        Selection tmpSelection(m_Doc, false);
1221
                        tmpSelection.addItem(neu);
1222
                        m_Doc->itemSelection_DeleteItem(&tmpSelection);
1223
                        for (int gr = 0; gr < gElements.count(); ++gr)
1224
                        {
1225
                                GElements.append(gElements.at(gr));
1226
                        }
1227
                }
7612 jghali 1228
                else
1229
                {
16230 fschmid 1230
                        double minx =  std::numeric_limits<double>::max();
1231
                        double miny =  std::numeric_limits<double>::max();
1232
                        double maxx = -std::numeric_limits<double>::max();
1233
                        double maxy = -std::numeric_limits<double>::max();
1234
                        GElements.append(neu);
1235
                        for (int gr = 0; gr < gElements.count(); ++gr)
1236
                        {
1237
                                PageItem* currItem = gElements.at(gr);
1238
                                double x1, x2, y1, y2;
1239
                                currItem->getVisualBoundingRect(&x1, &y1, &x2, &y2);
1240
                                minx = qMin(minx, x1);
1241
                                miny = qMin(miny, y1);
1242
                                maxx = qMax(maxx, x2);
1243
                                maxy = qMax(maxy, y2);
1244
                        }
1245
                        double gx = minx;
1246
                        double gy = miny;
1247
                        double gw = maxx - minx;
1248
                        double gh = maxy - miny;
16466 fschmid 1249
                        if (((gx > -9999999) && (gx < 9999999)) && ((gy > -9999999) && (gy < 9999999)) && ((gw > 0) && (gw < 9999999)) && ((gh > 0) && (gh < 9999999)))
16230 fschmid 1250
                        {
16466 fschmid 1251
                                neu->setXYPos(gx, gy);
1252
                                neu->setWidthHeight(gw, gh);
1253
                                if (clipPath.size() != 0)
1254
                                {
1255
                                        QTransform mm = gc->matrix;
1256
                                        neu->PoLine = clipPath.copy();
1257
                                        neu->PoLine.map(mm);
1258
                                        neu->PoLine.translate(-gx + BaseX, -gy + BaseY);
1259
                                        clipPath.resize(0);
1260
                                        neu->Clip = FlattenPath(neu->PoLine, neu->Segments);
1261
                                }
1262
                                else
1263
                                        neu->SetRectFrame();
1264
                                if( !e.attribute("id").isEmpty() )
1265
                                        neu->setItemName(e.attribute("id"));
1266
                                else
1267
                                        neu->setItemName( tr("Group%1").arg(m_Doc->GroupCounter));
1268
                                neu->setFillTransparency(1 - gc->Opacity);
1269
                                neu->gXpos = neu->xPos() - gx;
1270
                                neu->gYpos = neu->yPos() - gy;
1271
                                neu->groupWidth = gw;
1272
                                neu->groupHeight = gh;
1273
                                for (int gr = 0; gr < gElements.count(); ++gr)
1274
                                {
1275
                                        PageItem* currItem = gElements.at(gr);
1276
                                        currItem->gXpos = currItem->xPos() - gx;
1277
                                        currItem->gYpos = currItem->yPos() - gy;
1278
                                        currItem->gWidth = gw;
1279
                                        currItem->gHeight = gh;
16943 fschmid 1280
                                        currItem->Parent = neu;
16466 fschmid 1281
                                        neu->groupItemList.append(currItem);
1282
                                        m_Doc->Items->removeAll(currItem);
1283
                                }
1284
                                neu->setRedrawBounding();
1285
                                neu->setTextFlowMode(PageItem::TextFlowDisabled);
1286
                                m_Doc->GroupCounter++;
16230 fschmid 1287
                        }
1288
                        else
1289
                        {
16466 fschmid 1290
                                // Group is out of valid coordinates, remove it
1291
                                GElements.removeAll(neu);
1292
                                Selection tmpSelection(m_Doc, false);
1293
                                tmpSelection.addItem(neu);
1294
                                for (int gr = 0; gr < gElements.count(); ++gr)
1295
                                {
1296
                                        tmpSelection.addItem(gElements.at(gr));
1297
                                }
1298
                                m_Doc->itemSelection_DeleteItem(&tmpSelection);
16230 fschmid 1299
                        }
7612 jghali 1300
                }
16230 fschmid 1301
                delete( m_gc.pop() );
7612 jghali 1302
        }
7315 jghali 1303
        return GElements;
1304
}
1305
 
16230 fschmid 1306
QList<PageItem*> SVGPlug::parseDoc(const QDomElement &e)
1307
{
1308
        QList<PageItem*> GElements;
1309
        for ( QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling() )
1310
        {
1311
                QDomElement b = n.toElement();
1312
                if( b.isNull() || isIgnorableNode(b) )
1313
                        continue;
1314
                SvgStyle svgStyle;
1315
                parseStyle( &svgStyle, b);
1316
                if (!svgStyle.Display)
1317
                        continue;
1318
                QList<PageItem*> el = parseElement(b);
1319
                for (int ec = 0; ec < el.count(); ++ec)
1320
                        GElements.append(el.at(ec));
1321
        }
1322
        return GElements;
1323
}
1324
 
9856 fschmid 1325
QList<PageItem*> SVGPlug::parseElement(const QDomElement &e)
7315 jghali 1326
{
9856 fschmid 1327
        QList<PageItem*> GElements;
7556 jghali 1328
        if (e.hasAttribute("id"))
1329
                m_nodeMap.insert(e.attribute("id"), e);
16888 jghali 1330
        QString STag = parseTagName(e);
1331
        if (STag.startsWith("svg:"))
1332
                STag = STag.mid(4, - 1);
1333
        if (STag == "g" )
7315 jghali 1334
        {
7612 jghali 1335
                GElements = parseGroup( e );
7315 jghali 1336
                return GElements;
1337
        }
16888 jghali 1338
        if (STag == "defs")
7556 jghali 1339
                parseDefs(e);
16888 jghali 1340
        else if (STag == "a")
15172 jghali 1341
                GElements = parseA(e);
16888 jghali 1342
        else if ( STag == "switch")
7315 jghali 1343
                GElements = parseSwitch(e);
16888 jghali 1344
        else if ( STag == "symbol")
8507 jghali 1345
                GElements = parseSymbol(e);
16888 jghali 1346
        else if ( STag == "use")
7556 jghali 1347
                GElements = parseUse(e);
16888 jghali 1348
        else if ( STag == "linearGradient" || STag == "radialGradient")
7315 jghali 1349
                parseGradient( e );
16888 jghali 1350
        else if (STag == "rect")
7612 jghali 1351
                GElements = parseRect(e);
16888 jghali 1352
        else if (STag == "ellipse")
7612 jghali 1353
                GElements = parseEllipse(e);
16888 jghali 1354
        else if (STag == "circle")
7612 jghali 1355
                GElements = parseCircle(e);
16888 jghali 1356
        else if (STag == "line")
7612 jghali 1357
                GElements = parseLine(e);
16888 jghali 1358
        else if (STag == "path")
7612 jghali 1359
                GElements = parsePath(e);
16888 jghali 1360
        else if (STag == "polyline" || STag == "polygon")
7612 jghali 1361
                GElements = parsePolyline(e);
16888 jghali 1362
        else if (STag == "text")
7612 jghali 1363
                GElements = parseText(e);
16888 jghali 1364
        else if (STag == "clipPath")
7605 jghali 1365
                parseClipPath(e);
16888 jghali 1366
        else if (STag == "desc")
7866 fschmid 1367
        {
1368
                if (groupLevel == 1)
1369
                        docDesc = e.text();
1370
        }
16888 jghali 1371
        else if (STag == "title")
7866 fschmid 1372
        {
1373
                if (groupLevel == 1)
1374
                        docTitle = e.text();
1375
        }
16888 jghali 1376
        else if (STag == "image")
12785 fschmid 1377
                GElements = parseImage(e);
16888 jghali 1378
/*      else if (STag == "i:pgf")
10493 fschmid 1379
        {
1380
                QByteArray cdat;
1381
                QByteArray ddat;
1382
                cdat = e.text().simplified();
1383
                QList<QByteArray> cdlist = cdat.split(' ');
1384
                for (int cd = 0; cd < cdlist.count(); cd++)
1385
                {
1386
                        ddat += QByteArray::fromBase64(cdlist[cd]);
1387
                }
1388
                QFile outf("/home/franz/testdata.txt");
1389
                outf.open(QIODevice::WriteOnly);
1390
                outf.write(ddat);
1391
                outf.close();
1392
                QString f2 = "/home/franz/testdata_decom.ai";
1393
                FILE *source = fopen("/home/franz/testdata.txt", "rb");
1394
                FILE *dest = fopen(f2, "wb");
1395
                int ret;
1396
                unsigned have;
1397
                z_stream strm;
1398
                char in[4096];
1399
                char out[4096];
1400
                strm.zalloc = Z_NULL;
1401
                strm.zfree = Z_NULL;
1402
                strm.opaque = Z_NULL;
1403
                strm.avail_in = 0;
1404
                strm.next_in = Z_NULL;
1405
                ret = inflateInit(&strm);
1406
                if (ret != Z_OK)
1407
                        return GElements;
1408
                do
1409
                {
1410
                        strm.avail_in = fread(in, 1, 4096, source);
1411
                        if (ferror(source))
1412
                        {
1413
                                (void)inflateEnd(&strm);
1414
                                return GElements;
1415
                        }
1416
                        if (strm.avail_in == 0)
1417
                                break;
1418
                        strm.next_in = (Bytef*)in;
1419
                        do
1420
                        {
1421
                                strm.avail_out = 4096;
1422
                                strm.next_out = (Bytef*)out;
1423
                                ret = inflate(&strm, Z_NO_FLUSH);
1424
                                assert(ret != Z_STREAM_ERROR);
1425
                                switch (ret)
1426
                                {
1427
                                        case Z_NEED_DICT:
1428
                                                ret = Z_DATA_ERROR;
1429
                                        case Z_DATA_ERROR:
1430
                                        case Z_MEM_ERROR:
1431
                                                (void)inflateEnd(&strm);
1432
                                                return GElements;
1433
                                }
1434
                                have = 4096 - strm.avail_out;
1435
                                if (fwrite(out, 1, have, dest) != have || ferror(dest))
1436
                                {
1437
                                        (void)inflateEnd(&strm);
1438
                                        return GElements;
1439
                                }
1440
                        }
1441
                        while (strm.avail_out == 0);
1442
                }
1443
                while (ret != Z_STREAM_END);
1444
                (void)inflateEnd(&strm);
1445
                fclose(source);
1446
                fclose(dest);
1447
        } */
7605 jghali 1448
/*      else if( STag == "image" )
7612 jghali 1449
                GElements = parseImage(e);
7504 fschmid 1450
        } */
16888 jghali 1451
        else if (!isIgnorableNodeName(STag))
7315 jghali 1452
        {
1453
                // warn if unsupported SVG feature are encountered
13385 jghali 1454
                if (!m_unsupportedFeatures.contains(STag))
1455
                {
1456
                        m_unsupportedFeatures.insert(STag, STag);
17010 fschmid 1457
        //              qDebug() << QString("unsupported SVG feature: %1").arg(STag);
13385 jghali 1458
                        unsupported = true;
1459
                }
7315 jghali 1460
        }
7612 jghali 1461
        return GElements;
1462
}
1463
 
9856 fschmid 1464
QList<PageItem*> SVGPlug::parseCircle(const QDomElement &e)
7612 jghali 1465
{
9856 fschmid 1466
        QList<PageItem*> CElements;
7612 jghali 1467
        double BaseX = m_Doc->currentPage()->xOffset();
1468
        double BaseY = m_Doc->currentPage()->yOffset();
1469
        double r = parseUnit( e.attribute( "r" ) );
1470
        double x = parseUnit( e.attribute( "cx" ) ) - r;
1471
        double y = parseUnit( e.attribute( "cy" ) ) - r;
1472
        setupNode(e);
9922 fschmid 1473
        SvgStyle *gc = m_gc.top();
7612 jghali 1474
        int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Ellipse, BaseX, BaseY, r * 2.0, r * 2.0, gc->LWidth, gc->FillCol, gc->StrokeCol, true);
1475
        PageItem* ite = m_Doc->Items->at(z);
13951 fschmid 1476
        QTransform mm = QTransform();
7612 jghali 1477
        mm.translate(x, y);
1478
        ite->PoLine.map(mm);
1479
        FPoint wh = getMaxClipF(&ite->PoLine);
1480
        ite->setWidthHeight(wh.x(), wh.y());
1481
        finishNode(e, ite);
1482
        CElements.append(ite);
1483
        delete( m_gc.pop() );
1484
        return CElements;
1485
}
1486
 
9856 fschmid 1487
QList<PageItem*> SVGPlug::parseEllipse(const QDomElement &e)
7612 jghali 1488
{
9856 fschmid 1489
        QList<PageItem*> EElements;
7612 jghali 1490
        double BaseX = m_Doc->currentPage()->xOffset();
1491
        double BaseY = m_Doc->currentPage()->yOffset();
1492
        double rx = parseUnit( e.attribute( "rx" ) );
1493
        double ry = parseUnit( e.attribute( "ry" ) );
1494
        double x = parseUnit( e.attribute( "cx" ) ) - rx;
1495
        double y = parseUnit( e.attribute( "cy" ) ) - ry;
1496
        setupNode(e);
9922 fschmid 1497
        SvgStyle *gc = m_gc.top();
7612 jghali 1498
        int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Ellipse, BaseX, BaseY, rx * 2.0, ry * 2.0, gc->LWidth, gc->FillCol, gc->StrokeCol, true);
1499
        PageItem* ite = m_Doc->Items->at(z);
13951 fschmid 1500
        QTransform mm = QTransform();
7612 jghali 1501
        mm.translate(x, y);
1502
        ite->PoLine.map(mm);
1503
        FPoint wh = getMaxClipF(&ite->PoLine);
1504
        ite->setWidthHeight(wh.x(), wh.y());
1505
        finishNode(e, ite);
1506
        EElements.append(ite);
1507
        delete( m_gc.pop() );
1508
        return EElements;
1509
}
1510
 
9856 fschmid 1511
QList<PageItem*> SVGPlug::parseImage(const QDomElement &e)
7612 jghali 1512
{
1513
        FPointArray clipPath;
9856 fschmid 1514
        QList<PageItem*> IElements;
7612 jghali 1515
        QString fname = e.attribute("xlink:href");
1516
        double BaseX = m_Doc->currentPage()->xOffset();
1517
        double BaseY = m_Doc->currentPage()->yOffset();
1518
        double x = e.attribute( "x" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "x" ) );
1519
        double y = e.attribute( "y" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "y" ) );
1520
        double w = e.attribute( "width" ).isEmpty() ? 1.0 : parseUnit( e.attribute( "width" ) );
1521
        double h = e.attribute( "height" ).isEmpty() ? 1.0 : parseUnit( e.attribute( "height" ) );
1522
        setupNode(e);
1523
        parseClipPathAttr(e, clipPath);
17054 fschmid 1524
        int z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, x+BaseX, y+BaseY, w, h, 1, m_Doc->itemToolPrefs().imageFillColor, m_Doc->itemToolPrefs().imageStrokeColor, true);
12795 fschmid 1525
        PageItem* ite = m_Doc->Items->at(z);
7612 jghali 1526
        if (!fname.isEmpty())
12785 fschmid 1527
        {
1528
                if (!fname.startsWith("data:"))
16943 fschmid 1529
                        m_Doc->loadPict(fname, ite);
12785 fschmid 1530
                else
1531
                {
1532
                        int startData = fname.indexOf(",");
1533
                        QString dataType = fname.left(startData);
1534
                        fname.remove(0, startData+1);
1535
                        QByteArray ba;
1536
                        ba.append(fname);
1537
                        if (dataType.contains("base64"))
1538
                                ba = QByteArray::fromBase64(ba);
18203 fschmid 1539
                        QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_svg_XXXXXX.png");
1540
                        tempFile->setAutoRemove(false);
1541
                        tempFile->open();
1542
                        QString fileName = getLongPathName(tempFile->fileName());
1543
                        tempFile->close();
1544
                        delete tempFile;
1545
                        ite->isTempFile = true;
12795 fschmid 1546
                        ite->isInlineImage = true;
12785 fschmid 1547
                        QImage img;
1548
                        img.loadFromData(ba);
12795 fschmid 1549
                        img.save(fileName, "PNG");
16943 fschmid 1550
                        m_Doc->loadPict(fileName, ite);
12785 fschmid 1551
                }
1552
        }
7612 jghali 1553
        if (clipPath.size() != 0)
1554
                ite->PoLine = clipPath.copy();
1555
        clipPath.resize(0);
1556
        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
1557
        finishNode(e, ite);
1558
        IElements.append(ite);
1559
        delete( m_gc.pop() );
1560
        return IElements;
1561
}
1562
 
9856 fschmid 1563
QList<PageItem*> SVGPlug::parseLine(const QDomElement &e)
7612 jghali 1564
{
9856 fschmid 1565
        QList<PageItem*> LElements;
7612 jghali 1566
        double BaseX = m_Doc->currentPage()->xOffset();
1567
        double BaseY = m_Doc->currentPage()->yOffset();
1568
        double x1 = e.attribute( "x1" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "x1" ) );
1569
        double y1 = e.attribute( "y1" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "y1" ) );
1570
        double x2 = e.attribute( "x2" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "x2" ) );
1571
        double y2 = e.attribute( "y2" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "y2" ) );
1572
        setupNode(e);
9922 fschmid 1573
        SvgStyle *gc = m_gc.top();
11263 jghali 1574
        int z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, BaseX, BaseY, 10, 10, gc->LWidth, gc->FillCol, gc->StrokeCol, true);
7612 jghali 1575
        PageItem* ite = m_Doc->Items->at(z);
1576
        ite->PoLine.resize(4);
1577
        ite->PoLine.setPoint(0, FPoint(x1, y1));
1578
        ite->PoLine.setPoint(1, FPoint(x1, y1));
1579
        ite->PoLine.setPoint(2, FPoint(x2, y2));
1580
        ite->PoLine.setPoint(3, FPoint(x2, y2));
1581
        finishNode(e, ite);
1582
        LElements.append(ite);
1583
        delete( m_gc.pop() );
1584
        return LElements;
1585
}
1586
 
9856 fschmid 1587
QList<PageItem*> SVGPlug::parsePath(const QDomElement &e)
7612 jghali 1588
{
1589
        FPointArray pArray;
9856 fschmid 1590
        QList<PageItem*> PElements;
7612 jghali 1591
        double BaseX = m_Doc->currentPage()->xOffset();
1592
        double BaseY = m_Doc->currentPage()->yOffset();
1593
        setupNode(e);
9922 fschmid 1594
        SvgStyle *gc = m_gc.top();
7612 jghali 1595
        PageItem::ItemType itype = parseSVG(e.attribute("d"), &pArray) ? PageItem::PolyLine : PageItem::Polygon;
1596
        int z = m_Doc->itemAdd(itype, PageItem::Unspecified, BaseX, BaseY, 10, 10, gc->LWidth, gc->FillCol, gc->StrokeCol, true);
1597
        PageItem* ite = m_Doc->Items->at(z);
7678 fschmid 1598
        ite->fillRule = (gc->fillRule != "nonzero");
7612 jghali 1599
        ite->PoLine = pArray;
1600
        if (ite->PoLine.size() < 4)
7315 jghali 1601
        {
7612 jghali 1602
//                      m_Doc->m_Selection->addItem(ite);
1603
                tmpSel->addItem(ite);
1604
//                      m_Doc->itemSelection_DeleteItem();
1605
                m_Doc->itemSelection_DeleteItem(tmpSel);
1606
//                      m_Doc->m_Selection->clear();
1607
        }
1608
        else
1609
        {
1610
                finishNode(e, ite);
1611
                PElements.append(ite);
1612
        }
1613
        delete( m_gc.pop() );
1614
        return PElements;
1615
}
1616
 
9856 fschmid 1617
QList<PageItem*> SVGPlug::parsePolyline(const QDomElement &e)
7612 jghali 1618
{
1619
        int z;
9856 fschmid 1620
        QList<PageItem*> PElements;
7612 jghali 1621
        double BaseX = m_Doc->currentPage()->xOffset();
1622
        double BaseY = m_Doc->currentPage()->yOffset();
1623
        setupNode(e);
9922 fschmid 1624
        SvgStyle *gc = m_gc.top();
7612 jghali 1625
        QString points = e.attribute( "points" );
1626
        if (!points.isEmpty())
1627
        {
16888 jghali 1628
                QString STag = parseTagName(e);
10394 cbradney 1629
                points = points.simplified().replace(',', " ");
10603 fschmid 1630
                QStringList pointList = points.split( ' ', QString::SkipEmptyParts );
16888 jghali 1631
                if ((STag == "polygon" ) && (pointList.count() > 4))
7612 jghali 1632
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, BaseX, BaseY, 10, 10, gc->LWidth, gc->FillCol, gc->StrokeCol, true);
1633
                else
1634
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, BaseX, BaseY, 10, 10, gc->LWidth, gc->FillCol, gc->StrokeCol, true);
7315 jghali 1635
                PageItem* ite = m_Doc->Items->at(z);
7612 jghali 1636
                ite->fillRule = (gc->fillRule != "nonzero");
1637
                ite->PoLine.resize(0);
8237 avox 1638
                ite->PoLine.svgInit();
7612 jghali 1639
                bool bFirst = true;
1640
                double x = 0.0;
1641
                double y = 0.0;
1642
                for( QStringList::Iterator it = pointList.begin(); it != pointList.end(); it++ )
217 Franz 1643
                {
17526 jghali 1644
                        x = ScCLocale::toDoubleC(*(it++));
1645
                        y = ScCLocale::toDoubleC(*it);
7612 jghali 1646
                        if( bFirst )
217 Franz 1647
                        {
8252 jghali 1648
                                ite->PoLine.svgMoveTo(x, y);
7612 jghali 1649
                                bFirst = false;
68 Franz 1650
                        }
1651
                        else
7315 jghali 1652
                        {
8252 jghali 1653
                                ite->PoLine.svgLineTo(x, y);
7315 jghali 1654
                        }
217 Franz 1655
                }
7612 jghali 1656
                if (( STag == "polygon" ) && (pointList.count() > 4))
8237 avox 1657
                        ite->PoLine.svgClosePath();
7612 jghali 1658
                else
1659
                        ite->convertTo(PageItem::PolyLine);
18801 fschmid 1660
                if (ite->PoLine.size() < 4)
1661
                {
1662
                        tmpSel->addItem(ite);
1663
                        m_Doc->itemSelection_DeleteItem(tmpSel);
1664
                }
1665
                else
1666
                {
1667
                        finishNode(e, ite);
1668
                        PElements.append(ite);
1669
                }
7315 jghali 1670
        }
1671
        delete( m_gc.pop() );
7612 jghali 1672
        return PElements;
7315 jghali 1673
}
1674
 
9856 fschmid 1675
QList<PageItem*> SVGPlug::parseRect(const QDomElement &e)
7612 jghali 1676
{
9856 fschmid 1677
        QList<PageItem*> RElements;
7612 jghali 1678
        double BaseX = m_Doc->currentPage()->xOffset();
1679
        double BaseY = m_Doc->currentPage()->yOffset();
1680
        double x = parseUnit( e.attribute( "x" ) );
1681
        double y = parseUnit( e.attribute( "y" ) );
1682
        double width = parseUnit( e.attribute( "width" ));
1683
        double height = parseUnit( e.attribute( "height" ) );
1684
        double rx = e.attribute( "rx" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "rx" ) );
1685
        double ry = e.attribute( "ry" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "ry" ) );
1686
        setupNode(e);
9922 fschmid 1687
        SvgStyle *gc = m_gc.top();
7612 jghali 1688
        int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, BaseX, BaseY, width, height, gc->LWidth, gc->FillCol, gc->StrokeCol, true);
1689
        PageItem* ite = m_Doc->Items->at(z);
1690
        if ((rx != 0) || (ry != 0))
1691
        {
8562 jghali 1692
                ite->setCornerRadius(qMax(rx, ry));
7612 jghali 1693
                ite->SetFrameRound();
1694
                m_Doc->setRedrawBounding(ite);
1695
        }
13951 fschmid 1696
        QTransform mm = QTransform();
7612 jghali 1697
        mm.translate(x, y);
1698
        ite->PoLine.map(mm);
1699
        FPoint wh = getMaxClipF(&ite->PoLine);
1700
        ite->setWidthHeight(wh.x(), wh.y());
1701
        finishNode(e, ite);
1702
        RElements.append(ite);
1703
        delete( m_gc.pop() );
1704
        return RElements;
1705
}
1706
 
9856 fschmid 1707
QList<PageItem*> SVGPlug::parseText(const QDomElement &e)
7315 jghali 1708
{
9856 fschmid 1709
        QList<PageItem*> GElements;
7612 jghali 1710
        setupNode(e);
12725 jghali 1711
        double chunkWidth = 0;
10785 jghali 1712
        FPoint currentPos = parseTextPosition(e);
12725 jghali 1713
        SvgStyle *gc      = m_gc.top();
1714
        if (gc->textAnchor != "start")
1715
                getTextChunkWidth(e, chunkWidth);
12719 fschmid 1716
        for(QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling())
7315 jghali 1717
        {
16888 jghali 1718
                if (n.isElement() && (parseTagName(n.toElement()) == "tspan"))
217 Franz 1719
                {
12725 jghali 1720
                        QList<PageItem*> el = parseTextSpan(n.toElement(), currentPos, chunkWidth);
9856 fschmid 1721
                        for (int ec = 0; ec < el.count(); ++ec)
215 Franz 1722
                                GElements.append(el.at(ec));
217 Franz 1723
                }
10785 jghali 1724
                if (n.isText())
1725
                {
12725 jghali 1726
                        QList<PageItem*> el = parseTextNode(n.toText(), currentPos, chunkWidth);
10785 jghali 1727
                        for (int ec = 0; ec < el.count(); ++ec)
1728
                                GElements.append(el.at(ec));
1729
                }
12719 fschmid 1730
        }
7612 jghali 1731
        delete( m_gc.pop() );
7315 jghali 1732
        return GElements;
1733
}
12725 jghali 1734
 
1735
QList<PageItem*> SVGPlug::parseTextSpan(const QDomElement& e, FPoint& currentPos, double chunkW)
7315 jghali 1736
{
9856 fschmid 1737
        QList<PageItem*> GElements;
12725 jghali 1738
        setupNode(e);
1739
        currentPos   = parseTextPosition(e, &currentPos);
1740
        SvgStyle *gc = m_gc.top();
1741
        if ((e.hasAttribute("x") || e.hasAttribute("y")) && (gc->textAnchor != "start"))
12718 fschmid 1742
        {
12725 jghali 1743
                chunkW = 0;
1744
                getTextChunkWidth(e, chunkW);
12718 fschmid 1745
        }
12725 jghali 1746
        for(QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling())
12718 fschmid 1747
        {
16888 jghali 1748
                if (n.isElement() && (parseTagName(n.toElement()) == "tspan"))
12718 fschmid 1749
                {
12725 jghali 1750
                        QList<PageItem*> el = parseTextSpan(n.toElement(), currentPos, chunkW);
1751
                        for (int ec = 0; ec < el.count(); ++ec)
1752
                                GElements.append(el.at(ec));
12718 fschmid 1753
                }
12725 jghali 1754
                if (n.isText())
12718 fschmid 1755
                {
12725 jghali 1756
                        QList<PageItem*> el = parseTextNode(n.toText(), currentPos, chunkW);
1757
                        for (int ec = 0; ec < el.count(); ++ec)
1758
                                GElements.append(el.at(ec));
12718 fschmid 1759
                }
1760
        }
12725 jghali 1761
        delete( m_gc.pop() );
12718 fschmid 1762
        return GElements;
1763
}
12725 jghali 1764
 
1765
QList<PageItem*> SVGPlug::parseTextNode(const QDomText& e, FPoint& currentPos, double chunkW)
12718 fschmid 1766
{
1767
        QList<PageItem*> GElements;
1768
        double BaseX  = m_Doc->currentPage()->xOffset();
1769
        double BaseY  = m_Doc->currentPage()->yOffset();
1770
        double StartX = currentPos.x(), StartY = currentPos.y();
12725 jghali 1771
 
1772
        QString textString = e.data().simplified();
10785 jghali 1773
        if ( textString.isEmpty() )
1774
                return GElements;
1775
 
10638 jghali 1776
        SvgStyle *gc   = m_gc.top();
1777
        QFont textFont = getFontFromStyle(*gc);
1778
        QFontMetrics fm(textFont);
1779
    double width   = fm.width(textString);
1780
 
1781
        if( gc->textAnchor == "middle" )
12725 jghali 1782
                StartX -= chunkW / 2.0;
10638 jghali 1783
        else if( gc->textAnchor == "end")
12725 jghali 1784
                StartX -= chunkW;
10638 jghali 1785
 
1786
        FPointArray textPath;
1787
        QString textFillColor   = gc->FillCol;
1788
        QString textStrokeColor = gc->StrokeCol;
1789
        QPainterPath painterPath;
1790
        painterPath.addText( StartX, StartY, textFont, textString );
1791
        textPath.fromQPainterPath(painterPath);
1792
        if (textPath.size() > 0)
1793
        {
12725 jghali 1794
//              double  lineWidth = 0.0;
10638 jghali 1795
                int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, BaseX, BaseY, 10, 10, gc->LWidth, textFillColor, textStrokeColor, true);
1796
                PageItem* ite = m_Doc->Items->at(z);
1797
                ite->PoLine = textPath;
1798
                finishNode(e, ite);
1799
                GElements.append(ite);
1800
        }
10785 jghali 1801
        currentPos.setX( currentPos.x() + width );
10638 jghali 1802
        return GElements;
7315 jghali 1803
}
12725 jghali 1804
 
9856 fschmid 1805
QList<PageItem*> SVGPlug::parseSwitch(const QDomElement &e)
7315 jghali 1806
{
1807
        QString href;
1808
        QStringList hrefs;
9856 fschmid 1809
        QList<PageItem*> SElements;
7315 jghali 1810
        for (QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling())
1811
        {
1812
                QDomElement de = n.toElement();
16888 jghali 1813
                QString STag = parseTagName(de);
7315 jghali 1814
                if (STag == "foreignObject")
217 Franz 1815
                {
7315 jghali 1816
                        if (de.hasAttribute("xlink:href"))
217 Franz 1817
                        {
7315 jghali 1818
                                href = de.attribute("xlink:href").mid(1);
1819
                                if (!href.isEmpty())
1820
                                        hrefs.append(href);
217 Franz 1821
                        }
7315 jghali 1822
                        for (QDomNode n1 = de.firstChild(); !n1.isNull(); n1 = n1.nextSibling())
217 Franz 1823
                        {
7315 jghali 1824
                                QDomElement de1 = n1.toElement();
1825
                                if (de1.hasAttribute("xlink:href"))
296 Franz 1826
                                {
7315 jghali 1827
                                        href = de1.attribute("xlink:href").mid(1);
1828
                                        if (!href.isEmpty())
1829
                                                hrefs.append(href);
298 Franz 1830
                                }
217 Franz 1831
                        }
1832
                }
7315 jghali 1833
                else
1834
                {
1835
                        if (de.hasAttribute("requiredExtensions") || de.hasAttribute("requiredFeatures"))
1836
                                continue;
1837
                        else if (de.hasAttribute("id") && hrefs.contains(de.attribute("id")))
1838
                                continue;
1839
                        else
1840
                        {
1841
                                SElements = parseElement(de);
1842
                                if (SElements.count() > 0)
1843
                                        break;
1844
                        }
1845
                }
217 Franz 1846
        }
7315 jghali 1847
        return SElements;
68 Franz 1848
}
1849
 
9856 fschmid 1850
QList<PageItem*> SVGPlug::parseSymbol(const QDomElement &e)
8507 jghali 1851
{
9856 fschmid 1852
        QList<PageItem*> SElements;
12266 jghali 1853
        QString id = e.attribute("id");
8507 jghali 1854
        if( !id.isEmpty() )
1855
                m_nodeMap.insert(id, e);
1856
        return SElements;
1857
}
1858
 
9856 fschmid 1859
QList<PageItem*> SVGPlug::parseUse(const QDomElement &e)
7556 jghali 1860
{
9856 fschmid 1861
        QList<PageItem*> UElements;
12266 jghali 1862
        setupNode(e);
1863
        if( e.hasAttribute("x") || e.hasAttribute("y") )
1864
        {
13951 fschmid 1865
                QTransform matrix;
13460 jghali 1866
                double  xAtt = ScCLocale::toDoubleC(e.attribute("x", "0.0"));
1867
                double  yAtt = ScCLocale::toDoubleC(e.attribute("y", "0.0"));
12266 jghali 1868
                SvgStyle *gc = m_gc.top();
13951 fschmid 1869
                gc->matrix   = QTransform(1.0, 0.0, 0.0, 1.0, xAtt, yAtt) * gc->matrix;
12266 jghali 1870
        }
1871
        QString href = e.attribute("xlink:href").mid(1);
1872
        QMap<QString, QDomElement>::Iterator it = m_nodeMap.find(href);
1873
        if (it != m_nodeMap.end())
1874
        {
1875
                QDomElement elem = it.value().toElement();
16888 jghali 1876
                if (parseTagName(elem) == "symbol")
12266 jghali 1877
                        UElements = parseGroup(elem);
1878
                else
1879
                        UElements = parseElement(elem);
1880
        }
1881
        delete (m_gc.pop());
7556 jghali 1882
        return UElements;
1883
}
1884
 
10638 jghali 1885
QFont SVGPlug::getFontFromStyle(SvgStyle& style)
1886
{
1887
        QFont font(QApplication::font());
1888
        font.setStyleStrategy( QFont::PreferOutline );
1889
 
1890
        if (!style.FontFamily.isEmpty())
1891
                font.setFamily(style.FontFamily);
1892
 
1893
        if (!style.FontStyle.isEmpty())
1894
        {
1895
                if (style.FontStyle == "normal")
1896
                        font.setStyle(QFont::StyleNormal);
1897
                else if (style.FontStyle == "italic")
1898
                        font.setStyle(QFont::StyleItalic);
1899
                else if (style.FontStyle == "oblique")
1900
                        font.setStyle(QFont::StyleOblique);
1901
        }
1902
 
1903
        if (!style.FontWeight.isEmpty())
1904
        {
1905
                if (style.FontWeight == "normal")
1906
                        font.setWeight(QFont::Normal);
1907
                else if (style.FontWeight == "bold")
1908
                        font.setWeight(QFont::Bold);
1909
                else if (style.FontWeight ==