Subversion Repositories Scribus

Rev

Rev 18181 | Rev 18227 | 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
*/
16546 jghali 7
 
10223 cbradney 8
#include <QCursor>
9
#include <QDir>
16546 jghali 10
#include <QDrag>
10223 cbradney 11
#include <QDomElement>
16546 jghali 12
#include <QFile>
13
#include <QMessageBox>
9764 jghali 14
#include <QMimeData>
16546 jghali 15
#include <QString>
16
#include <QRegExp>
17
#include <QWidget>
766 cbradney 18
 
541 fschmid 19
#include "oodrawimp.h"
766 cbradney 20
 
2688 craig 21
#include "scconfig.h"
22
 
10862 cbradney 23
#include "color.h"
24
#include "commonstrings.h"
25
#include "fileunzip.h"
26
#include "fpointarray.h"
14509 cbradney 27
#include "ui/scmwmenumanager.h"
766 cbradney 28
#include "pageitem.h"
10862 cbradney 29
#include "pluginmanager.h"
30
#include "prefscontext.h"
31
#include "prefsfile.h"
2856 cbradney 32
#include "prefsmanager.h"
541 fschmid 33
#include "prefstable.h"
13466 cbradney 34
#include "scclocale.h"
10862 cbradney 35
#include "sccolorengine.h"
12841 jghali 36
#include "scmimedata.h"
10862 cbradney 37
#include "scraction.h"
38
#include "scribusXml.h"
39
#include "scribuscore.h"
40
#include "scribusdoc.h"
3934 cbradney 41
#include "selection.h"
544 fschmid 42
#include "serializer.h"
10862 cbradney 43
#include "stylestack.h"
14170 jghali 44
#include "ui/customfdialog.h"
45
#include "ui/propertiespalette.h"
1436 tsoots 46
#include "undomanager.h"
2529 craig 47
#include "util.h"
10200 cbradney 48
#include "util_icon.h"
10203 cbradney 49
#include "util_math.h"
541 fschmid 50
 
10862 cbradney 51
 
541 fschmid 52
using namespace std;
53
 
3207 craig 54
int oodrawimp_getPluginAPIVersion()
541 fschmid 55
{
3207 craig 56
        return PLUGIN_API_VERSION;
541 fschmid 57
}
58
 
3207 craig 59
ScPlugin* oodrawimp_getPlugin()
541 fschmid 60
{
3207 craig 61
        OODrawImportPlugin* plug = new OODrawImportPlugin();
62
        Q_CHECK_PTR(plug);
63
        return plug;
541 fschmid 64
}
65
 
3207 craig 66
void oodrawimp_freePlugin(ScPlugin* plugin)
541 fschmid 67
{
3207 craig 68
        OODrawImportPlugin* plug = dynamic_cast<OODrawImportPlugin*>(plugin);
69
        Q_ASSERT(plug);
70
        delete plug;
541 fschmid 71
}
72
 
3207 craig 73
OODrawImportPlugin::OODrawImportPlugin() :
3696 craig 74
        LoadSavePlugin(),
17118 craig 75
        importAction(new ScrAction(ScrAction::DLL, "", QKeySequence(), this))
1208 cbradney 76
{
3207 craig 77
        // Set action info in languageChange, so we only have to do
3686 craig 78
        // it in one place. This includes registering file formats.
3207 craig 79
        languageChange();
5243 cbradney 80
}
12110 fschmid 81
/*
5243 cbradney 82
void OODrawImportPlugin::addToMainWindowMenu(ScribusMainWindow *mw)
83
{
3696 craig 84
        // Then hook up the action
85
        importAction->setEnabled(true);
10725 jghali 86
        connect( importAction, SIGNAL(triggered()), SLOT(import()) );
5246 cbradney 87
        mw->scrMenuMgr->addMenuItem(importAction, "FileImport");
1208 cbradney 88
}
12110 fschmid 89
*/
3686 craig 90
OODrawImportPlugin::~OODrawImportPlugin()
91
{
92
        unregisterAll();
3696 craig 93
        // note: importAction is automatically deleted by Qt
3686 craig 94
};
3207 craig 95
 
96
void OODrawImportPlugin::languageChange()
1208 cbradney 97
{
10427 cbradney 98
        importAction->setText( tr("Import &OpenOffice.org Draw..."));
3686 craig 99
        // (Re)register file formats
100
        unregisterAll();
101
        registerFormats();
1208 cbradney 102
}
103
 
3207 craig 104
const QString OODrawImportPlugin::fullTrName() const
1208 cbradney 105
{
3207 craig 106
        return QObject::tr("OpenOffice.org Draw Importer");
1208 cbradney 107
}
108
 
3207 craig 109
const ScActionPlugin::AboutData* OODrawImportPlugin::getAboutData() const
1208 cbradney 110
{
3241 craig 111
        AboutData* about = new AboutData;
3344 fschmid 112
        about->authors = "Franz Schmid <franz@scribus.info>";
3540 cbradney 113
        about->shortDescription = tr("Imports OpenOffice.org Draw Files");
114
        about->description = tr("Imports most OpenOffice.org Draw files into the current document, converting their vector data into Scribus objects.");
3344 fschmid 115
        about->license = "GPL";
3241 craig 116
        Q_CHECK_PTR(about);
117
        return about;
1208 cbradney 118
}
119
 
3241 craig 120
void OODrawImportPlugin::deleteAboutData(const AboutData* about) const
1208 cbradney 121
{
3241 craig 122
        Q_ASSERT(about);
123
        delete about;
1208 cbradney 124
}
125
 
3686 craig 126
void OODrawImportPlugin::registerFormats()
3487 craig 127
{
128
        QString odtName = tr("OpenDocument 1.0 Draw", "Import/export format name");
4024 craig 129
        FileFormat odtformat(this);
3643 craig 130
        odtformat.trName = odtName; // Human readable name
4024 craig 131
        odtformat.formatId = FORMATID_ODGIMPORT;
4309 craig 132
        odtformat.filter = odtName + " (*.odg *.ODG)"; // QFileDialog filter
10593 fschmid 133
        odtformat.nameMatch = QRegExp("\\.odg$", Qt::CaseInsensitive);
14665 fschmid 134
        odtformat.fileExtensions = QStringList() << "odg";
3686 craig 135
        odtformat.load = true;
136
        odtformat.save = false;
14719 fschmid 137
        odtformat.thumb = true;
3643 craig 138
        odtformat.mimeTypes = QStringList("application/vnd.oasis.opendocument.graphics"); // MIME types
139
        odtformat.priority = 64; // Priority
3686 craig 140
        registerFormat(odtformat);
141
 
3487 craig 142
        QString sxdName = tr("OpenOffice.org 1.x Draw", "Import/export format name");
4024 craig 143
        FileFormat sxdformat(this);
3643 craig 144
        sxdformat.trName = sxdName; // Human readable name
4024 craig 145
        sxdformat.formatId = FORMATID_SXDIMPORT;
4309 craig 146
        sxdformat.filter = sxdName + " (*.sxd *.SXD)"; // QFileDialog filter
10593 fschmid 147
        sxdformat.nameMatch = QRegExp("\\.sxd$", Qt::CaseInsensitive);
14665 fschmid 148
        sxdformat.fileExtensions = QStringList() << "sxd";
3686 craig 149
        sxdformat.load = true;
150
        sxdformat.save = false;
14719 fschmid 151
        sxdformat.thumb = true;
3643 craig 152
        sxdformat.mimeTypes = QStringList("application/vnd.sun.xml.draw"); // MIME types
153
        sxdformat.priority = 64; // Priority
3686 craig 154
        registerFormat(sxdformat);
3487 craig 155
}
156
 
5642 cbradney 157
bool OODrawImportPlugin::fileSupported(QIODevice* /* file */, const QString & fileName) const
3487 craig 158
{
159
        // TODO: try to identify .sxd / .odt files
160
        return true;
161
}
162
 
5539 mrdocs 163
bool OODrawImportPlugin::loadFile(const QString & fileName, const FileFormat &, int flags, int /*index*/)
541 fschmid 164
{
3696 craig 165
        // For this plugin, right now "load" and "import" are the same thing
5539 mrdocs 166
        return import(fileName, flags);
3696 craig 167
}
168
 
5539 mrdocs 169
bool OODrawImportPlugin::import(QString fileName, int flags)
3696 craig 170
{
5539 mrdocs 171
        if (!checkFlags(flags))
172
                return false;
3207 craig 173
        if (fileName.isEmpty())
541 fschmid 174
        {
5539 mrdocs 175
                flags |= lfInteractive;
2856 cbradney 176
                PrefsContext* prefs = PrefsManager::instance()->prefsFile->getPluginContext("OODrawImport");
541 fschmid 177
                QString wdir = prefs->get("wdir", ".");
5781 cbradney 178
                CustomFDialog diaf(ScCore->primaryMainWindow(), wdir, QObject::tr("Open"), QObject::tr("OpenOffice.org Draw (*.sxd *.odg);;All Files (*)"));
541 fschmid 179
                if (diaf.exec())
180
                {
181
                        fileName = diaf.selectedFile();
10427 cbradney 182
                        prefs->set("wdir", fileName.left(fileName.lastIndexOf("/")));
541 fschmid 183
                }
184
                else
3207 craig 185
                        return true;
541 fschmid 186
        }
5781 cbradney 187
        m_Doc=ScCore->primaryMainWindow()->doc;
11576 avox 188
        UndoTransaction* activeTransaction = NULL;
189
        bool emptyDoc = (m_Doc == NULL);
13378 jghali 190
        bool hasCurrentPage = (m_Doc && m_Doc->currentPage());
13371 jghali 191
        TransactionSettings trSettings;
13378 jghali 192
        trSettings.targetName   = hasCurrentPage ? m_Doc->currentPage()->getUName() : "";
13371 jghali 193
        trSettings.targetPixmap = Um::IImageFrame;
194
        trSettings.actionName   = Um::ImportOOoDraw;
195
        trSettings.description  = fileName;
196
        trSettings.actionPixmap = Um::IImportOOoDraw;
197
        OODPlug dia(m_Doc);
198
        if (emptyDoc || !(flags & lfInteractive) || !(flags & lfScripted))
1439 tsoots 199
                UndoManager::instance()->setUndoEnabled(false);
13371 jghali 200
        if (UndoManager::undoEnabled())
201
                activeTransaction = new UndoTransaction(UndoManager::instance()->beginTransaction(trSettings));
202
        bool importDone = dia.import(fileName, trSettings, flags);
11576 avox 203
        if (activeTransaction)
204
        {
205
                activeTransaction->commit();
206
                delete activeTransaction;
207
                activeTransaction = NULL;
208
        }
13371 jghali 209
        if (emptyDoc || !(flags & lfInteractive) || !(flags & lfScripted))
1439 tsoots 210
                UndoManager::instance()->setUndoEnabled(true);
7795 fschmid 211
        if (dia.importCanceled)
212
        {
213
                if ((!importDone) || (dia.importFailed))
214
                        QMessageBox::warning(ScCore->primaryMainWindow(), CommonStrings::trWarning, tr("The file could not be imported"), 1, 0, 0);
215
                else if (dia.unsupported)
216
                        QMessageBox::warning(ScCore->primaryMainWindow(), CommonStrings::trWarning, tr("This file contains some unsupported features"), 1, 0, 0);
217
        }
4463 cbradney 218
        return importDone;
541 fschmid 219
}
220
 
14719 fschmid 221
QImage OODrawImportPlugin::readThumbnail(const QString& fileName)
222
{
223
        if( fileName.isEmpty() )
224
                return QImage();
17747 craig 225
        UndoManager::instance()->setUndoEnabled(false);
14719 fschmid 226
        m_Doc = NULL;
227
        OODPlug *dia = new OODPlug(m_Doc);
228
        Q_CHECK_PTR(dia);
229
        QImage ret = dia->readThumbnail(fileName);
17747 craig 230
        UndoManager::instance()->setUndoEnabled(true);
14719 fschmid 231
        delete dia;
232
        return ret;
233
}
234
 
5781 cbradney 235
OODPlug::OODPlug(ScribusDoc* doc)
541 fschmid 236
{
5781 cbradney 237
        m_Doc=doc;
7271 jghali 238
        unsupported = false;
4463 cbradney 239
        interactive = false;
7794 fschmid 240
        importFailed = false;
7795 fschmid 241
        importCanceled = true;
7991 fschmid 242
        importedColors.clear();
7580 cbradney 243
        tmpSel=new Selection(this, false);
4463 cbradney 244
}
245
 
14719 fschmid 246
QImage OODPlug::readThumbnail(QString fileName )
247
{
248
        QByteArray f, f2, f3;
249
        if ( !QFile::exists(fileName) )
250
                return QImage();
251
        FileUnzip* fun = new FileUnzip(fileName);
252
        stylePath   = fun->getFile("styles.xml");
253
        contentPath = fun->getFile("content.xml");
254
        metaPath = fun->getFile("meta.xml");
255
        // Qt4 NULL -> isNull()
256
        if ((!stylePath.isNull()) && (!contentPath.isNull()))
257
        {
258
                HaveMeta = false;
259
                QString docname = fileName.right(fileName.length() - fileName.lastIndexOf("/") - 1);
260
                docname = docname.left(docname.lastIndexOf("."));
261
                loadRawText(stylePath, f);
262
                loadRawText(contentPath, f2);
263
                HaveMeta = false;
264
                if (!metaPath.isEmpty())
265
                {
266
                        loadRawText(metaPath, f3);
267
                        HaveMeta = inpMeta.setContent(f3);
268
                }
269
        }
17170 fschmid 270
        delete fun;
271
        if(!inpStyles.setContent(f))
272
                return QImage();
273
        if(!inpContents.setContent(f2))
274
                return QImage();
14719 fschmid 275
        QString CurDirP = QDir::currentPath();
276
        QFileInfo efp(fileName);
277
        QDir::setCurrent(efp.path());
278
        bool isOODraw2 = false;
279
        QDomNode drawPagePNode;
280
        QList<PageItem*> Elements;
281
        createStyleMap( inpStyles );
282
        QDomElement docElem = inpContents.documentElement();
283
        QDomNode automaticStyles = docElem.namedItem( "office:automatic-styles" );
284
        if( !automaticStyles.isNull() )
285
                insertStyles( automaticStyles.toElement() );
286
        QDomNode body = docElem.namedItem( "office:body" );
287
        QDomNode drawPage = body.namedItem( "draw:page" );
288
        if ( drawPage.isNull() )
289
        {
290
                QDomNode offDraw = body.namedItem( "office:drawing" );
291
                drawPage = offDraw.namedItem( "draw:page" );
292
                if (drawPage.isNull())
293
                        return QImage();
294
                else
295
                {
296
                        isOODraw2 = true;
297
                        drawPagePNode = body.namedItem( "office:drawing" );
298
                }
299
        }
300
        else
301
                drawPagePNode = body;
302
        StyleStack::Mode mode = isOODraw2 ? StyleStack::OODraw2x : StyleStack::OODraw1x;
303
        m_styleStack.setMode( mode );
304
        QDomElement dp = drawPage.toElement();
305
        QDomElement *master = m_styles[dp.attribute( "draw:master-page-name" )];
306
        QDomElement *style = NULL;
307
        QDomElement properties;
308
        if (isOODraw2)
309
        {
310
                style = m_styles.value(master->attribute( "style:page-layout-name" ), NULL);
311
                if (style)
312
                        properties = style->namedItem("style:page-layout-properties" ).toElement();
313
        }
314
        else
315
        {
316
                style = m_styles.value(master->attribute( "style:page-master-name" ), NULL);
317
                if (style)
318
                        properties = style->namedItem( "style:properties" ).toElement();
319
        }
320
        double width = !properties.attribute( "fo:page-width" ).isEmpty() ? parseUnit(properties.attribute( "fo:page-width" ) ) : 550.0;
321
        double height = !properties.attribute( "fo:page-height" ).isEmpty() ? parseUnit(properties.attribute( "fo:page-height" ) ) : 841.0;
322
        m_Doc = new ScribusDoc();
323
        m_Doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
324
        m_Doc->setPage(width, height, 0, 0, 0, 0, 0, 0, false, false);
325
        m_Doc->addPage(0);
326
        m_Doc->setGUI(false, ScCore->primaryMainWindow(), 0);
327
        Elements.clear();
328
        m_Doc->setLoading(true);
329
        m_Doc->DoDrawing = false;
14754 jghali 330
        m_Doc->scMW()->setScriptRunning(true);
14719 fschmid 331
        if (!m_Doc->PageColors.contains("Black"))
332
                m_Doc->PageColors.insert("Black", ScColor(0, 0, 0, 255));
333
        QDomNode drawPag = drawPagePNode.firstChild();
334
        QDomElement dpg = drawPag.toElement();
335
        m_styleStack.clear();
336
        fillStyleStack( dpg );
337
        QList<PageItem*> el = parseGroup( dpg );
338
        for (int ec = 0; ec < el.count(); ++ec)
339
                Elements.append(el.at(ec));
340
        tmpSel->clear();
341
        QImage tmpImage = QImage();
342
        if (Elements.count() > 0)
343
        {
16105 fschmid 344
                if (Elements.count() > 1)
345
                        m_Doc->groupObjectsList(Elements);
14719 fschmid 346
                m_Doc->DoDrawing = true;
347
                m_Doc->m_Selection->delaySignalsOn();
348
                for (int dre=0; dre<Elements.count(); ++dre)
349
                {
350
                        tmpSel->addItem(Elements.at(dre), true);
351
                }
352
                tmpSel->setGroupRect();
353
                double xs = tmpSel->width();
354
                double ys = tmpSel->height();
16504 fschmid 355
                tmpImage = Elements.at(0)->DrawObj_toImage(500);
14719 fschmid 356
                tmpImage.setText("XSize", QString("%1").arg(xs));
357
                tmpImage.setText("YSize", QString("%1").arg(ys));
358
                m_Doc->m_Selection->delaySignalsOff();
359
                m_Doc->setLoading(false);
360
        }
14754 jghali 361
        m_Doc->scMW()->setScriptRunning(false);
14719 fschmid 362
        delete m_Doc;
363
        QDir::setCurrent(CurDirP);
364
        return tmpImage;
365
}
366
 
13371 jghali 367
bool OODPlug::import(QString fileName, const TransactionSettings& trSettings, int flags )
4463 cbradney 368
{
369
        bool importDone = false;
5539 mrdocs 370
        interactive = (flags & LoadSavePlugin::lfInteractive);
12189 jghali 371
        QByteArray f, f2, f3;
4463 cbradney 372
        if ( !QFile::exists(fileName) )
373
                return false;
1578 tsoots 374
        FileUnzip* fun = new FileUnzip(fileName);
375
        stylePath   = fun->getFile("styles.xml");
376
        contentPath = fun->getFile("content.xml");
377
        metaPath = fun->getFile("meta.xml");
8622 subik 378
        // Qt4 NULL -> isNull()
379
        if ((!stylePath.isNull()) && (!contentPath.isNull()))
541 fschmid 380
        {
12189 jghali 381
                HaveMeta = false;
10427 cbradney 382
                QString docname = fileName.right(fileName.length() - fileName.lastIndexOf("/") - 1);
383
                docname = docname.left(docname.lastIndexOf("."));
12189 jghali 384
                loadRawText(stylePath, f);
385
                loadRawText(contentPath, f2);
386
                HaveMeta = false;
387
                if (!metaPath.isEmpty())
550 fschmid 388
                {
12189 jghali 389
                        loadRawText(metaPath, f3);
390
                        HaveMeta = inpMeta.setContent(f3);
550 fschmid 391
                }
541 fschmid 392
        }
17170 fschmid 393
        delete fun;
394
        if(!inpStyles.setContent(f))
395
                return false;
396
        if(!inpContents.setContent(f2))
397
                return false;
10398 cbradney 398
        QString CurDirP = QDir::currentPath();
541 fschmid 399
        QFileInfo efp(fileName);
10593 fschmid 400
        QDir::setCurrent(efp.path());
13371 jghali 401
        importDone = convert(trSettings, flags);
541 fschmid 402
        QDir::setCurrent(CurDirP);
4463 cbradney 403
        return importDone;
541 fschmid 404
}
405
 
13371 jghali 406
bool OODPlug::convert(const TransactionSettings& trSettings, int flags)
541 fschmid 407
{
408
        bool ret = false;
4590 cbradney 409
        bool isOODraw2 = false;
410
        QDomNode drawPagePNode;
544 fschmid 411
        int PageCounter = 0;
9856 fschmid 412
        QList<PageItem*> Elements;
541 fschmid 413
        createStyleMap( inpStyles );
414
        QDomElement docElem = inpContents.documentElement();
415
        QDomNode automaticStyles = docElem.namedItem( "office:automatic-styles" );
416
        if( !automaticStyles.isNull() )
417
                insertStyles( automaticStyles.toElement() );
418
        QDomNode body = docElem.namedItem( "office:body" );
419
        QDomNode drawPage = body.namedItem( "draw:page" );
4590 cbradney 420
        if ( drawPage.isNull() )
4463 cbradney 421
        {
422
                QDomNode offDraw = body.namedItem( "office:drawing" );
423
                drawPage = offDraw.namedItem( "draw:page" );
424
                if (drawPage.isNull())
425
                {
5781 cbradney 426
                        QMessageBox::warning( m_Doc->scMW(), CommonStrings::trWarning, tr("This document does not seem to be an OpenOffice Draw file.") );
4463 cbradney 427
                        return false;
428
                }
429
                else
430
                {
4590 cbradney 431
                        isOODraw2 = true;
432
                        drawPagePNode = body.namedItem( "office:drawing" );
4463 cbradney 433
                }
434
        }
4590 cbradney 435
        else
436
                drawPagePNode = body;
437
        StyleStack::Mode mode = isOODraw2 ? StyleStack::OODraw2x : StyleStack::OODraw1x;
438
        m_styleStack.setMode( mode );
541 fschmid 439
        QDomElement dp = drawPage.toElement();
440
        QDomElement *master = m_styles[dp.attribute( "draw:master-page-name" )];
4590 cbradney 441
        QDomElement *style = NULL;
442
        QDomElement properties;
443
        if (isOODraw2)
444
        {
14017 jghali 445
                style = m_styles.value(master->attribute( "style:page-layout-name" ), NULL);
446
                if (style)
447
                        properties = style->namedItem("style:page-layout-properties" ).toElement();
4590 cbradney 448
        }
449
        else
450
        {
14017 jghali 451
                style = m_styles.value(master->attribute( "style:page-master-name" ), NULL);
452
                if (style)
453
                        properties = style->namedItem( "style:properties" ).toElement();
4590 cbradney 454
        }
541 fschmid 455
        double width = !properties.attribute( "fo:page-width" ).isEmpty() ? parseUnit(properties.attribute( "fo:page-width" ) ) : 550.0;
456
        double height = !properties.attribute( "fo:page-height" ).isEmpty() ? parseUnit(properties.attribute( "fo:page-height" ) ) : 841.0;
5539 mrdocs 457
        if (!interactive || (flags & LoadSavePlugin::lfInsertPage))
5781 cbradney 458
                m_Doc->setPage(width, height, 0, 0, 0, 0, 0, 0, false, false);
541 fschmid 459
        else
460
        {
5781 cbradney 461
                if (!m_Doc || (flags & LoadSavePlugin::lfCreateDoc))
541 fschmid 462
                {
5798 jghali 463
                        m_Doc=ScCore->primaryMainWindow()->doFileNew(width, height, 0, 0, 0, 0, 0, 0, false, false, 0, false, 0, 1, "Custom", true);
5781 cbradney 464
                        ScCore->primaryMainWindow()->HaveNewDoc();
541 fschmid 465
                        ret = true;
466
                }
467
        }
3207 craig 468
        if ((ret) || (!interactive))
550 fschmid 469
        {
470
                if (width > height)
14991 cbradney 471
                        m_Doc->setPageOrientation(1);
550 fschmid 472
                else
14991 cbradney 473
                        m_Doc->setPageOrientation(0);
474
                m_Doc->setPageSize("Custom");
550 fschmid 475
                QDomNode mpg;
476
                QDomElement metaElem = inpMeta.documentElement();
477
                QDomElement mp = metaElem.namedItem( "office:meta" ).toElement();
478
                mpg = mp.namedItem( "dc:title" );
479
                if (!mpg.isNull())
15037 cbradney 480
                        m_Doc->documentInfo().setTitle(mpg.toElement().text());
550 fschmid 481
                mpg = mp.namedItem( "meta:initial-creator" );
482
                if (!mpg.isNull())
15037 cbradney 483
                        m_Doc->documentInfo().setAuthor(mpg.toElement().text());
550 fschmid 484
                mpg = mp.namedItem( "dc:description" );
485
                if (!mpg.isNull())
15037 cbradney 486
                        m_Doc->documentInfo().setComments(mpg.toElement().text());
550 fschmid 487
                mpg = mp.namedItem( "dc:language" );
488
                if (!mpg.isNull())
15037 cbradney 489
                        m_Doc->documentInfo().setLangInfo(mpg.toElement().text());
550 fschmid 490
                mpg = mp.namedItem( "meta:creation-date" );
491
                if (!mpg.isNull())
15037 cbradney 492
                        m_Doc->documentInfo().setDate(mpg.toElement().text());
550 fschmid 493
                mpg = mp.namedItem( "dc:creator" );
494
                if (!mpg.isNull())
15037 cbradney 495
                        m_Doc->documentInfo().setContrib(mpg.toElement().text());
550 fschmid 496
                mpg = mp.namedItem( "meta:keywords" );
497
                if (!mpg.isNull())
498
                {
499
                        QString Keys = "";
500
                        for( QDomNode n = mpg.firstChild(); !n.isNull(); n = n.nextSibling() )
501
                        {
10593 fschmid 502
                                Keys += n.toElement().text()+", ";
550 fschmid 503
                        }
504
                        if (Keys.length() > 2)
15037 cbradney 505
                                m_Doc->documentInfo().setKeywords(Keys.left(Keys.length()-2));
550 fschmid 506
                }
507
        }
16105 fschmid 508
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16016 fschmid 509
                m_Doc->view()->Deselect();
541 fschmid 510
        Elements.clear();
5781 cbradney 511
        m_Doc->setLoading(true);
512
        m_Doc->DoDrawing = false;
16105 fschmid 513
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16016 fschmid 514
                m_Doc->view()->updatesOn(false);
14754 jghali 515
        m_Doc->scMW()->setScriptRunning(true);
18181 fschmid 516
        qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
5781 cbradney 517
        if (!m_Doc->PageColors.contains("Black"))
518
                m_Doc->PageColors.insert("Black", ScColor(0, 0, 0, 255));
4590 cbradney 519
        for( QDomNode drawPag = drawPagePNode.firstChild(); !drawPag.isNull(); drawPag = drawPag.nextSibling() )
541 fschmid 520
        {
521
                QDomElement dpg = drawPag.toElement();
3207 craig 522
                if (!interactive)
4025 cbradney 523
                {
5781 cbradney 524
                        m_Doc->addPage(PageCounter);
525
                        m_Doc->view()->addPage(PageCounter);
4025 cbradney 526
                }
545 fschmid 527
                PageCounter++;
541 fschmid 528
                m_styleStack.clear();
529
                fillStyleStack( dpg );
9856 fschmid 530
                QList<PageItem*> el = parseGroup( dpg );
531
                for (int ec = 0; ec < el.count(); ++ec)
8216 jghali 532
                        Elements.append(el.at(ec));
7234 fschmid 533
                if ((interactive) && (PageCounter == 1))
534
                        break;
541 fschmid 535
        }
7580 cbradney 536
        tmpSel->clear();
7691 fschmid 537
//      if ((Elements.count() > 1) && (interactive))
7794 fschmid 538
        if (Elements.count() == 0)
7991 fschmid 539
        {
7794 fschmid 540
                importFailed = true;
7991 fschmid 541
                if (importedColors.count() != 0)
542
                {
8613 cbradney 543
                        for (int cd = 0; cd < importedColors.count(); cd++)
7991 fschmid 544
                        {
545
                                m_Doc->PageColors.remove(importedColors[cd]);
546
                        }
547
                }
548
        }
7691 fschmid 549
        if (Elements.count() > 1)
16105 fschmid 550
                m_Doc->groupObjectsList(Elements);
5781 cbradney 551
        m_Doc->DoDrawing = true;
14754 jghali 552
        m_Doc->scMW()->setScriptRunning(false);
3207 craig 553
        if (interactive)
5781 cbradney 554
                m_Doc->setLoading(false);
9380 fschmid 555
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
3207 craig 556
        if ((Elements.count() > 0) && (!ret) && (interactive))
541 fschmid 557
        {
8262 fschmid 558
                if (flags & LoadSavePlugin::lfScripted)
541 fschmid 559
                {
8262 fschmid 560
                        bool loadF = m_Doc->isLoading();
561
                        m_Doc->setLoading(false);
562
                        m_Doc->changed();
563
                        m_Doc->setLoading(loadF);
16105 fschmid 564
                        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
8262 fschmid 565
                        {
16016 fschmid 566
                                m_Doc->m_Selection->delaySignalsOn();
567
                                for (int dre=0; dre<Elements.count(); ++dre)
568
                                {
569
                                        m_Doc->m_Selection->addItem(Elements.at(dre), true);
570
                                }
571
                                m_Doc->m_Selection->delaySignalsOff();
572
                                m_Doc->m_Selection->setGroupRect();
573
                                m_Doc->view()->updatesOn(true);
8262 fschmid 574
                        }
575
                        importCanceled = false;
541 fschmid 576
                }
8262 fschmid 577
                else
578
                {
579
                        m_Doc->DragP = true;
580
                        m_Doc->DraggedElem = 0;
581
                        m_Doc->DragElements.clear();
11835 fschmid 582
                        m_Doc->m_Selection->delaySignalsOn();
9856 fschmid 583
                        for (int dre=0; dre<Elements.count(); ++dre)
8262 fschmid 584
                        {
585
                                tmpSel->addItem(Elements.at(dre), true);
586
                        }
587
                        tmpSel->setGroupRect();
18028 jghali 588
                        ScElemMimeData* md = ScriXmlDoc::WriteToMimeData(m_Doc, tmpSel);
8262 fschmid 589
                        m_Doc->itemSelection_DeleteItem(tmpSel);
590
                        m_Doc->view()->updatesOn(true);
11835 fschmid 591
                        m_Doc->m_Selection->delaySignalsOff();
13371 jghali 592
                        // We must copy the TransationSettings object as it is owned
593
                        // by handleObjectImport method afterwards
594
                        TransactionSettings* transacSettings = new TransactionSettings(trSettings);
595
                        m_Doc->view()->handleObjectImport(md, transacSettings);
8262 fschmid 596
                        m_Doc->DragP = false;
597
                        m_Doc->DraggedElem = 0;
598
                        m_Doc->DragElements.clear();
7991 fschmid 599
                }
541 fschmid 600
        }
601
        else
602
        {
7351 fschmid 603
                bool loadF = m_Doc->isLoading();
604
                m_Doc->setLoading(false);
5781 cbradney 605
                m_Doc->changed();
6556 fschmid 606
                m_Doc->reformPages();
16105 fschmid 607
                if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16016 fschmid 608
                        m_Doc->view()->updatesOn(true);
7351 fschmid 609
                m_Doc->setLoading(loadF);
541 fschmid 610
        }
18181 fschmid 611
        qApp->restoreOverrideCursor();
4463 cbradney 612
        return true;
541 fschmid 613
}
614
 
9856 fschmid 615
QList<PageItem*> OODPlug::parseGroup(const QDomElement &e)
541 fschmid 616
{
8216 jghali 617
        OODrawStyle oostyle;
541 fschmid 618
        FPointArray ImgClip;
9856 fschmid 619
        QList<PageItem*> elements, cElements;
16105 fschmid 620
//      double BaseX = m_Doc->currentPage()->xOffset();
621
//      double BaseY = m_Doc->currentPage()->yOffset();
8216 jghali 622
        storeObjectStyles(e);
623
        parseStyle(oostyle, e);
624
        QString drawID = e.attribute("draw:name");
16105 fschmid 625
//      int zn = m_Doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, BaseX, BaseY, 1, 1, 0, CommonStrings::None, CommonStrings::None, true);
626
//      PageItem *neu = m_Doc->Items->at(zn);
541 fschmid 627
        for (QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling())
628
        {
629
                QDomElement b = n.toElement();
630
                if( b.isNull() )
631
                        continue;
9856 fschmid 632
                QList<PageItem*> el = parseElement(b);
633
                for (int ec = 0; ec < el.count(); ++ec)
8216 jghali 634
                        cElements.append(el.at(ec));
635
        }
636
        if (cElements.count() < 2)
637
        {
9856 fschmid 638
                for (int gr = 0; gr < cElements.count(); ++gr)
541 fschmid 639
                {
8216 jghali 640
                        elements.append(cElements.at(gr));
541 fschmid 641
                }
8216 jghali 642
        }
643
        else
644
        {
16105 fschmid 645
                PageItem *neu = m_Doc->groupObjectsList(cElements);
8216 jghali 646
                elements.append(neu);
647
                if( !e.attribute("id").isEmpty() )
648
                        neu->setItemName(e.attribute("id"));
649
                else
16105 fschmid 650
                        neu->setItemName( tr("Group%1").arg(m_Doc->GroupCounter));
8216 jghali 651
        }
652
        return elements;
653
}
654
 
9856 fschmid 655
QList<PageItem*> OODPlug::parseElement(const QDomElement &e)
8216 jghali 656
{
9856 fschmid 657
        QList<PageItem*> GElements;
8216 jghali 658
        QString STag = e.tagName();
659
        if ( STag == "draw:g" )
660
        {
661
                GElements = parseGroup(e);
662
                return GElements;
663
        }
664
        if ( STag == "draw:rect" )
665
                GElements = parseRect(e);
666
        else if ( STag == "draw:circle" || STag == "draw:ellipse" )
667
                GElements = parseEllipse(e);
668
        else if ( STag == "draw:line" )
669
                GElements = parseLine(e);
670
        else if ( STag == "draw:polygon" )
671
                GElements = parsePolygon(e);
672
        else if ( STag == "draw:polyline" )
673
                GElements = parsePolyline(e);
674
        else if( STag == "draw:path" )
675
                GElements = parsePath(e);
676
        else if ( STag == "draw:text-box" )
677
                GElements = parseTextBox(e);
678
        else if ( STag == "draw:frame" )
679
                GElements = parseFrame(e);
8222 jghali 680
        else if ( STag == "draw:connector" )
681
                GElements = parseConnector(e);
8216 jghali 682
        else
683
        {
684
                // warn if unsupported feature are encountered
685
                unsupported = true;
10493 fschmid 686
                qDebug("Not supported yet: %s", STag.toLocal8Bit().data());
8216 jghali 687
        }
688
        return GElements;
689
}
690
 
9856 fschmid 691
QList<PageItem*> OODPlug::parseRect(const QDomElement &e)
8216 jghali 692
{
693
        OODrawStyle style;
9856 fschmid 694
        QList<PageItem*> elements;
8216 jghali 695
        double BaseX = m_Doc->currentPage()->xOffset();
696
        double BaseY = m_Doc->currentPage()->yOffset();
697
        double x = parseUnit(e.attribute("svg:x"));
698
        double y = parseUnit(e.attribute("svg:y")) ;
699
        double w = parseUnit(e.attribute("svg:width"));
700
        double h = parseUnit(e.attribute("svg:height"));
701
        double corner = parseUnit(e.attribute("draw:corner-radius"));
702
        storeObjectStyles(e);
703
        parseStyle(style, e);
704
        int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, BaseX+x, BaseY+y, w, h, style.strokeWidth, style.fillColor, style.strokeColor, true);
705
        PageItem* ite = m_Doc->Items->at(z);
706
        if (corner != 0)
707
        {
708
                ite->setCornerRadius(corner);
709
                ite->SetFrameRound();
710
                m_Doc->setRedrawBounding(ite);
711
        }
8278 jghali 712
        ite = finishNodeParsing(e, ite, style);
8216 jghali 713
        elements.append(ite);
714
        return elements;
715
}
716
 
9856 fschmid 717
QList<PageItem*> OODPlug::parseEllipse(const QDomElement &e)
8216 jghali 718
{
719
        OODrawStyle style;
9856 fschmid 720
        QList<PageItem*> elements;
8216 jghali 721
        double BaseX = m_Doc->currentPage()->xOffset();
722
        double BaseY = m_Doc->currentPage()->yOffset();
723
        double x = parseUnit(e.attribute("svg:x"));
724
        double y = parseUnit(e.attribute("svg:y")) ;
725
        double w = parseUnit(e.attribute("svg:width"));
726
        double h = parseUnit(e.attribute("svg:height"));
727
        storeObjectStyles(e);
728
        parseStyle(style, e);
729
        int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Ellipse, BaseX+x, BaseY+y, w, h, style.strokeWidth, style.fillColor, style.strokeColor, true);
730
        PageItem* ite = m_Doc->Items->at(z);
8278 jghali 731
        ite = finishNodeParsing(e, ite, style);
8216 jghali 732
        elements.append(ite);
733
        return elements;
734
}
735
 
9856 fschmid 736
QList<PageItem*> OODPlug::parseLine(const QDomElement &e)
8216 jghali 737
{
738
        OODrawStyle style;
9856 fschmid 739
        QList<PageItem*> elements;
8216 jghali 740
        double BaseX = m_Doc->currentPage()->xOffset();
741
        double BaseY = m_Doc->currentPage()->yOffset();
742
        double x1 = e.attribute( "svg:x1" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "svg:x1" ) );
743
        double y1 = e.attribute( "svg:y1" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "svg:y1" ) );
744
        double x2 = e.attribute( "svg:x2" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "svg:x2" ) );
745
        double y2 = e.attribute( "svg:y2" ).isEmpty() ? 0.0 : parseUnit( e.attribute( "svg:y2" ) );
746
        storeObjectStyles(e);
747
        parseStyle(style, e);
748
        int z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, BaseX, BaseY, 10, 10, style.strokeWidth, CommonStrings::None, style.strokeColor, true);
749
        PageItem* ite = m_Doc->Items->at(z);
750
        ite->PoLine.resize(4);
751
        ite->PoLine.setPoint(0, FPoint(x1, y1));
752
        ite->PoLine.setPoint(1, FPoint(x1, y1));
753
        ite->PoLine.setPoint(2, FPoint(x2, y2));
754
        ite->PoLine.setPoint(3, FPoint(x2, y2));
755
        FPoint wh = getMaxClipF(&ite->PoLine);
756
        ite->setWidthHeight(wh.x(), wh.y());
757
        ite->ClipEdited = true;
758
        ite->FrameType = 3;
759
        if (!e.hasAttribute("draw:transform"))
760
        {
761
                ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
762
                m_Doc->AdjustItemSize(ite);
763
        }
8278 jghali 764
        ite = finishNodeParsing(e, ite, style);
8216 jghali 765
        elements.append(ite);
766
        return elements;
767
}
768
 
9856 fschmid 769
QList<PageItem*> OODPlug::parsePolygon(const QDomElement &e)
8216 jghali 770
{
771
        OODrawStyle style;
9856 fschmid 772
        QList<PageItem*> elements;
8216 jghali 773
        double BaseX = m_Doc->currentPage()->xOffset();
774
        double BaseY = m_Doc->currentPage()->yOffset();
775
        storeObjectStyles(e);
776
        parseStyle(style, e);
777
        int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, BaseX, BaseY, 10, 10, style.strokeWidth, style.fillColor, style.strokeColor, true);
778
        PageItem* ite = m_Doc->Items->at(z);
779
        ite->PoLine.resize(0);
10414 jghali 780
        appendPoints(&ite->PoLine, e, true);
8216 jghali 781
        FPoint wh = getMaxClipF(&ite->PoLine);
782
        ite->setWidthHeight(wh.x(), wh.y());
783
        ite->ClipEdited = true;
784
        ite->FrameType = 3;
785
        if (!e.hasAttribute("draw:transform"))
786
        {
787
                ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
788
                m_Doc->AdjustItemSize(ite);
789
        }
8278 jghali 790
        ite = finishNodeParsing(e, ite, style);
8216 jghali 791
        elements.append(ite);
792
        return elements;
793
}
794
 
9856 fschmid 795
QList<PageItem*> OODPlug::parsePolyline(const QDomElement &e)
8216 jghali 796
{
797
        OODrawStyle style;
9856 fschmid 798
        QList<PageItem*> elements;
8216 jghali 799
        double BaseX = m_Doc->currentPage()->xOffset();
800
        double BaseY = m_Doc->currentPage()->yOffset();
801
        storeObjectStyles(e);
802
        parseStyle(style, e);
803
        int z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, BaseX, BaseY, 10, 10, style.strokeWidth, CommonStrings::None, style.strokeColor, true);
804
        PageItem* ite = m_Doc->Items->at(z);
805
        ite->PoLine.resize(0);
10414 jghali 806
        appendPoints(&ite->PoLine, e, false);
8216 jghali 807
        FPoint wh = getMaxClipF(&ite->PoLine);
808
        ite->setWidthHeight(wh.x(), wh.y());
809
        ite->ClipEdited = true;
810
        ite->FrameType = 3;
811
        if (!e.hasAttribute("draw:transform"))
812
        {
813
                ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
814
                m_Doc->AdjustItemSize(ite);
815
        }
8278 jghali 816
        ite = finishNodeParsing(e, ite, style);
8216 jghali 817
        elements.append(ite);
818
        return elements;
819
}
820
 
9856 fschmid 821
QList<PageItem*> OODPlug::parsePath(const QDomElement &e)
8216 jghali 822
{
823
        OODrawStyle style;
824
        FPointArray pArray;
9856 fschmid 825
        QList<PageItem*> elements;
8216 jghali 826
        double BaseX = m_Doc->currentPage()->xOffset();
827
        double BaseY = m_Doc->currentPage()->yOffset();
828
        storeObjectStyles(e);
829
        parseStyle(style, e);
830
        PageItem::ItemType itype = parseSVG(e.attribute("svg:d"), &pArray) ? PageItem::PolyLine : PageItem::Polygon;
831
        int z = m_Doc->itemAdd(itype, PageItem::Unspecified, BaseX, BaseY, 10, 10, style.strokeWidth, style.fillColor, style.strokeColor, true);
832
        PageItem* ite = m_Doc->Items->at(z);
833
        ite->PoLine.resize(0);
834
        ite->PoLine = pArray;
835
        if (ite->PoLine.size() < 4)
836
        {
837
//              m_Doc->m_Selection->addItem(ite);
838
                tmpSel->addItem(ite);
839
//              m_Doc->itemSelection_DeleteItem();
840
                m_Doc->itemSelection_DeleteItem(tmpSel);
841
        }
842
        else
843
        {
13951 fschmid 844
                QTransform mat;
8216 jghali 845
                double x = parseUnit(e.attribute("svg:x"));
846
                double y = parseUnit(e.attribute("svg:y")) ;
847
                double w = parseUnit(e.attribute("svg:width"));
848
                double h = parseUnit(e.attribute("svg:height"));
849
                double vx = 0;
850
                double vy = 0;
851
                double vw = 1;
852
                double vh = 1;
853
                parseViewBox(e, &vx, &vy, &vw, &vh);
10938 jghali 854
                double sx = (vw != 0.0) ? (w / vw) : w;
855
                double sy = (vh != 0.0) ? (h / vh) : h;
8216 jghali 856
                mat.translate(x, y);
10938 jghali 857
                mat.scale(sx, sy);
8216 jghali 858
                ite->PoLine.map(mat);
859
                FPoint wh = getMaxClipF(&ite->PoLine);
860
                ite->setWidthHeight(wh.x(), wh.y());
861
                ite->ClipEdited = true;
862
                ite->FrameType = 3;
863
                if (!e.hasAttribute("draw:transform"))
544 fschmid 864
                {
8216 jghali 865
                        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
866
                        m_Doc->AdjustItemSize(ite);
544 fschmid 867
                }
8278 jghali 868
                ite = finishNodeParsing(e, ite, style);
8216 jghali 869
                elements.append(ite);
870
        }
871
        return elements;
872
}
873
 
9856 fschmid 874
QList<PageItem*> OODPlug::parseTextBox(const QDomElement &e)
8216 jghali 875
{
876
        OODrawStyle style;
9856 fschmid 877
        QList<PageItem*> elements;
8216 jghali 878
        double BaseX = m_Doc->currentPage()->xOffset();
879
        double BaseY = m_Doc->currentPage()->yOffset();
880
        double x = parseUnit(e.attribute("svg:x"));
881
        double y = parseUnit(e.attribute("svg:y")) ;
882
        double w = parseUnit(e.attribute("svg:width"));
883
        double h = parseUnit(e.attribute("svg:height"));
884
        storeObjectStyles(e);
885
        parseStyle(style, e);
886
        int z = m_Doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, BaseX+x, BaseY+y, w, h+(h*0.1), style.strokeWidth, CommonStrings::None, style.strokeColor, true);
887
        PageItem* ite = m_Doc->Items->at(z);
888
        ite->setFillColor(style.fillColor);
889
        ite->setLineColor(style.strokeColor);
8278 jghali 890
        ite = finishNodeParsing(e, ite, style);
8216 jghali 891
        elements.append(ite);
892
        return elements;
893
}
894
 
9856 fschmid 895
QList<PageItem*> OODPlug::parseFrame(const QDomElement &e)
8216 jghali 896
{
897
        OODrawStyle oostyle;
9856 fschmid 898
        QList<PageItem*> elements;
8216 jghali 899
        QString drawID = e.attribute("draw:name");
900
        double BaseX = m_Doc->currentPage()->xOffset();
901
        double BaseY = m_Doc->currentPage()->yOffset();
902
        double x = parseUnit(e.attribute("svg:x"));
903
        double y = parseUnit(e.attribute("svg:y")) ;
904
        double w = parseUnit(e.attribute("svg:width"));
905
        double h = parseUnit(e.attribute("svg:height"));
906
        storeObjectStyles(e);
907
        parseStyle(oostyle, e);
908
        QDomNode n = e.firstChild();
909
        QString STag2 = n.toElement().tagName();
910
        if ( STag2 == "draw:text-box" )
911
        {
912
                int z = m_Doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, BaseX+x, BaseY+y, w, h+(h*0.1), oostyle.strokeWidth, CommonStrings::None, oostyle.strokeColor, true);
913
                PageItem* ite = m_Doc->Items->at(z);
914
                ite->setTextToFrameDist(0.0, 0.0, 0.0, 0.0);
915
                ite->setFillTransparency(oostyle.fillTrans);
916
                ite->setLineTransparency(oostyle.strokeTrans);
11705 fschmid 917
                ite->setTextFlowMode(PageItem::TextFlowDisabled);
8216 jghali 918
                if (!drawID.isEmpty())
919
                        ite->setItemName(drawID);
8387 jghali 920
                ite = parseTextP(n.toElement(), ite);
8216 jghali 921
                elements.append(ite);
922
        }
923
        return elements;
924
}
925
 
9856 fschmid 926
QList<PageItem*> OODPlug::parseConnector(const QDomElement &e)
8222 jghali 927
{
9856 fschmid 928
        QList<PageItem*> elements;
8222 jghali 929
        if (e.hasAttribute("svg:x1") && e.hasAttribute("svg:x2") && e.hasAttribute("svg:y1") && e.hasAttribute("svg:y2"))
930
        {
931
                elements = parseLine(e);
932
        }
933
        else
934
        {
935
                unsupported = true;
936
                qDebug("an unsupported form of connector was found");
937
        }
938
        return elements;
939
}
940
 
8216 jghali 941
void OODPlug::parseStyle(OODrawStyle& oostyle, const QDomElement &e)
942
{
943
        oostyle.haveGradient = false;
944
        oostyle.gradient.clearStops();
945
        if( m_styleStack.hasAttribute("draw:stroke") )
946
        {
947
                if( m_styleStack.attribute( "draw:stroke" ) == "none" )
948
                        oostyle.strokeWidth = 0.0;
949
                else
544 fschmid 950
                {
8216 jghali 951
                        if( m_styleStack.hasAttribute("svg:stroke-width"))
548 fschmid 952
                        {
8216 jghali 953
                                oostyle.strokeWidth = parseUnit(m_styleStack.attribute("svg:stroke-width"));
954
                                if (oostyle.strokeWidth == 0)
955
                                        oostyle.strokeWidth = 1;
548 fschmid 956
                        }
8216 jghali 957
                        if( m_styleStack.hasAttribute("svg:stroke-color"))
958
                                oostyle.strokeColor = parseColor(m_styleStack.attribute("svg:stroke-color"));
959
                        if( m_styleStack.hasAttribute( "svg:stroke-opacity" ) )
13466 cbradney 960
                                oostyle.strokeTrans = ScCLocale::toDoubleC(m_styleStack.attribute( "svg:stroke-opacity" ).remove( '%' )) / 100.0;
8216 jghali 961
                        if( m_styleStack.attribute( "draw:stroke" ) == "dash" )
548 fschmid 962
                        {
8216 jghali 963
                                QString style = m_styleStack.attribute( "draw:stroke-dash" );
964
                                if( style == "Ultrafine Dashed")
965
                                        oostyle.dashes << 1.4 << 1.4;
966
                                else if( style == "Fine Dashed" )
967
                                        oostyle.dashes << 14.4 << 14.4;
968
                                else if( style == "Fine Dotted")
969
                                        oostyle.dashes << 13 << 13;
970
                                else if( style == "Ultrafine 2 Dots 3 Dashes")
971
                                        oostyle.dashes << 1.45 << 3.6 << 1.45 << 3.6 << 7.2 << 3.6 << 7.2 << 3.6 << 7.2 << 3.6;
972
                                else if( style == "Line with Fine Dots")
548 fschmid 973
                                {
8216 jghali 974
                                        oostyle.dashes << 56.9 << 4.31;
975
                                        for (int dd = 0; dd < 10; ++ dd)
976
                                        {
977
                                                oostyle.dashes << 8.6 << 4.31;
978
                                        }
548 fschmid 979
                                }
8216 jghali 980
                                else if( style == "2 Dots 1 Dash" )
981
                                        oostyle.dashes << 2.8 << 5.75 << 2.8 << 5.75 << 5.75 << 5.75;
544 fschmid 982
                        }
983
                }
8216 jghali 984
        }
985
        if( m_styleStack.hasAttribute( "draw:fill" ) )
986
        {
987
                QString fill = m_styleStack.attribute( "draw:fill" );
988
                if( fill == "solid" )
544 fschmid 989
                {
8216 jghali 990
                        if( m_styleStack.hasAttribute( "draw:fill-color" ) )
991
                                oostyle.fillColor = parseColor( m_styleStack.attribute("draw:fill-color"));
992
                        if( m_styleStack.hasAttribute( "draw:transparency" ) )
13466 cbradney 993
                                oostyle.fillTrans = ScCLocale::toDoubleC(m_styleStack.attribute( "draw:transparency" ).remove( '%' )) / 100.0;
592 fschmid 994
                }
8216 jghali 995
                else if( fill == "gradient" )
7293 fschmid 996
                {
8216 jghali 997
                        oostyle.haveGradient = true;
998
                        oostyle.gradientAngle = 0;
999
                        oostyle.gradient.clearStops();
1000
                        oostyle.gradient.setRepeatMethod( VGradient::none );
1001
                        QString style = m_styleStack.attribute( "draw:fill-gradient-name" );
1002
                        QDomElement* draw = m_draws[style];
1003
                        if( draw )
7293 fschmid 1004
                        {
8216 jghali 1005
                                double border = 0.0;
1006
                                int shadeS = 100;
1007
                                int shadeE = 100;
1008
                                if( draw->hasAttribute( "draw:border" ) )
13466 cbradney 1009
                                        border += ScCLocale::toDoubleC(draw->attribute( "draw:border" ).remove( '%' )) / 100.0;
8216 jghali 1010
                                if( draw->hasAttribute( "draw:start-intensity" ) )
1011
                                        shadeS = draw->attribute( "draw:start-intensity" ).remove( '%' ).toInt();
1012
                                if( draw->hasAttribute( "draw:end-intensity" ) )
1013
                                        shadeE = draw->attribute( "draw:end-intensity" ).remove( '%' ).toInt();
1014
                                QString type = draw->attribute( "draw:style" );
1015
                                if( type == "linear" || type == "axial" )
7293 fschmid 1016
                                {
8216 jghali 1017
                                        oostyle.gradient.setType( VGradient::linear );
13466 cbradney 1018
                                        oostyle.gradientAngle = ScCLocale::toDoubleC(draw->attribute( "draw:angle" )) / 10;
8216 jghali 1019
                                        oostyle.gradientType = 1;
7293 fschmid 1020
                                }
8216 jghali 1021
                                else if( type == "radial" || type == "ellipsoid" )
1022
                                {
1023
                                        if( draw->hasAttribute( "draw:cx" ) )
13466 cbradney 1024
                                                oostyle.gradientPointX = ScCLocale::toDoubleC(draw->attribute( "draw:cx" ).remove( '%' )) / 100.0;
8216 jghali 1025
                                        else
1026
                                                oostyle.gradientPointX = 0.5;
1027
                                        if( draw->hasAttribute( "draw:cy" ) )
13466 cbradney 1028
                                                oostyle.gradientPointY = ScCLocale::toDoubleC(draw->attribute( "draw:cy" ).remove( '%' )) / 100.0;
8216 jghali 1029
                                        else
1030
                                                oostyle.gradientPointY = 0.5;
1031
                                        oostyle.gradientType = 2;
1032
                                }
1033
                                QString c, c2;
1034
                                c = parseColor( draw->attribute( "draw:start-color" ) );
1035
                                c2 = parseColor( draw->attribute( "draw:end-color" ) );
1036
                                const ScColor& col1 = m_Doc->PageColors[c];
1037
                                const ScColor& col2 = m_Doc->PageColors[c2];
1038
                                if (((oostyle.gradientAngle > 90) && (oostyle.gradientAngle < 271)) || (oostyle.gradientType == 2))
1039
                                {
1040
                                        const ScColor& col1 = m_Doc->PageColors[c];
1041
                                        const ScColor& col2 = m_Doc->PageColors[c2];
18128 jghali 1042
                                        oostyle.gradient.addStop( ScColorEngine::getShadeColor(col2, m_Doc, shadeE), 0.0, 0.5, 1, c2, shadeE );
1043
                                        oostyle.gradient.addStop( ScColorEngine::getShadeColor(col1, m_Doc, shadeS), 1.0 - border, 0.5, 1, c, shadeS );
8216 jghali 1044
                                }
1045
                                else
1046
                                {
18128 jghali 1047
                                        oostyle.gradient.addStop( ScColorEngine::getShadeColor(col1, m_Doc, shadeS), border, 0.5, 1, c, shadeS );
1048
                                        oostyle.gradient.addStop( ScColorEngine::getShadeColor(col2, m_Doc, shadeE), 1.0, 0.5, 1, c2, shadeE );
8216 jghali 1049
                                }
7293 fschmid 1050
                        }
1051
                }
8216 jghali 1052
        }
1053
}
1054
 
8368 jghali 1055
void OODPlug::parseCharStyle(CharStyle& style, const QDomElement &e)
8216 jghali 1056
{
8368 jghali 1057
        if ( m_styleStack.hasAttribute("fo:font-size") )
1058
        {
1059
                QString fs = m_styleStack.attribute("fo:font-size").remove( "pt" );
13469 cbradney 1060
                int FontSize = (int) (ScCLocale::toFloatC(fs) * 10.0);
8368 jghali 1061
                style.setFontSize(FontSize);
1062
        }
1063
}
1064
 
1065
void OODPlug::parseParagraphStyle(ParagraphStyle& style, const QDomElement &e)
1066
{
1067
        if ( m_styleStack.hasAttribute("fo:text-align") )
1068
        {
1069
                QString attValue = m_styleStack.attribute("fo:text-align");
1070
                if (attValue == "left")
1071
                        style.setAlignment(ParagraphStyle::Leftaligned);
1072
                if (attValue == "center")
1073
                        style.setAlignment(ParagraphStyle::Centered);
1074
                if (attValue == "right")
1075
                        style.setAlignment(ParagraphStyle::Rightaligned);
1076
        }
1077
        if ( m_styleStack.hasAttribute("fo:font-size") )
1078
        {
1079
                QString fs = m_styleStack.attribute("fo:font-size").remove( "pt" );
13469 cbradney 1080
                int FontSize = (int) (ScCLocale::toFloatC(fs) * 10.0);
8368 jghali 1081
                style.charStyle().setFontSize(FontSize);
1082
                style.setLineSpacing((FontSize + FontSize * 0.2) / 10.0);
1083
        }
1084
}
1085
 
1086
PageItem* OODPlug::parseTextP (const QDomElement& elm, PageItem* item)
1087
{
8216 jghali 1088
        for ( QDomNode n = elm.firstChild(); !n.isNull(); n = n.nextSibling() )
1089
        {
1090
                if ( !n.hasAttributes() && !n.hasChildNodes() )
1091
                        continue;
1092
                QDomElement e = n.toElement();
1093
                if ( e.text().isEmpty() )
1094
                        continue;
8368 jghali 1095
                storeObjectStyles(e);
8278 jghali 1096
                item->itemText.insertChars(-1, SpecialChars::PARSEP);
12189 jghali 1097
                item = parseTextSpans(e, item);
8368 jghali 1098
        }
1099
        return item;
1100
}
1101
 
1102
PageItem* OODPlug::parseTextSpans(const QDomElement& elm, PageItem* item)
1103
{
1104
        bool firstSpan = true;
1105
        for ( QDomNode n = elm.firstChild(); !n.isNull(); n = n.nextSibling() )
1106
        {
12189 jghali 1107
                QString chars;
8368 jghali 1108
                QDomElement e = n.toElement();
12189 jghali 1109
                if (n.isElement() && (e.tagName() == "text:span"))
1110
                {
1111
                        chars = e.text().simplified();
1112
                        storeObjectStyles(e);
1113
                }
1114
                if (n.isText())
1115
                {
1116
                        QDomText t = n.toText();
1117
                        chars = t.data().simplified();
1118
                }
1119
                if (chars.isEmpty())
8368 jghali 1120
                        continue;
1121
                int pos = item->itemText.length();
1122
                if ( firstSpan && (m_styleStack.hasAttribute("fo:text-align") || m_styleStack.hasAttribute("fo:font-size")) )
1123
                {
1124
                        ParagraphStyle newStyle;
12189 jghali 1125
                        parseParagraphStyle(newStyle, n.isElement() ? e : elm);
8278 jghali 1126
                        item->itemText.applyStyle(-1, newStyle);
592 fschmid 1127
                }
8368 jghali 1128
                item->itemText.insertChars( -2, chars);
1129
                if ( !firstSpan && m_styleStack.hasAttribute("fo:font-size") )
1130
                {
1131
                        CharStyle newStyle;
12189 jghali 1132
                        parseCharStyle(newStyle, n.isElement() ? e : elm);
8368 jghali 1133
                        item->itemText.applyCharStyle(pos, chars.length(), newStyle);
1134
                }
8278 jghali 1135
                if (!item->asPolyLine() && !item->asTextFrame())
1136
                        item = m_Doc->convertItemTo(item, PageItem::TextFrame);
8368 jghali 1137
                firstSpan = false;
8216 jghali 1138
        }
8368 jghali 1139
        return item;
1140
}
1141
 
1142
PageItem* OODPlug::finishNodeParsing(const QDomElement &elm, PageItem* item, OODrawStyle& oostyle)
1143
{
1144
        item->setTextToFrameDist(0.0, 0.0, 0.0, 0.0);
8405 fschmid 1145
//      bool firstPa = false;
8368 jghali 1146
        QString drawID = elm.attribute("draw:name");
1147
        item = parseTextP(elm, item);
8278 jghali 1148
        item->setFillTransparency(oostyle.fillTrans);
1149
        item->setLineTransparency(oostyle.strokeTrans);
8216 jghali 1150
        if (oostyle.dashes.count() != 0)
8278 jghali 1151
                item->DashValues = oostyle.dashes;
8216 jghali 1152
        if (!drawID.isEmpty())
8278 jghali 1153
                item->setItemName(drawID);
8216 jghali 1154
        if (elm.hasAttribute("draw:transform"))
1155
        {
8278 jghali 1156
                parseTransform(&item->PoLine, elm.attribute("draw:transform"));
1157
                item->ClipEdited = true;
1158
                item->FrameType = 3;
1159
                FPoint wh = getMaxClipF(&item->PoLine);
1160
                item->setWidthHeight(wh.x(), wh.y());
1161
                item->Clip = FlattenPath(item->PoLine, item->Segments);
1162
                m_Doc->AdjustItemSize(item);
8216 jghali 1163
        }
8278 jghali 1164
        item->OwnPage = m_Doc->OnPage(item);
8216 jghali 1165
        //ite->setTextFlowMode(PageItem::TextFlowUsesFrameShape);
8278 jghali 1166
        item->setTextFlowMode(PageItem::TextFlowDisabled);
8216 jghali 1167
        if (oostyle.haveGradient)
1168
        {
8278 jghali 1169
                item->GrType = 0;
8216 jghali 1170
                if (oostyle.gradient.Stops() > 1)
592 fschmid 1171
                {
8278 jghali 1172
                        item->fill_gradient = oostyle.gradient;
8216 jghali 1173
                        if (oostyle.gradientType == 1)
544 fschmid 1174
                        {
8216 jghali 1175
                                bool flipped = false;
1176
                                double gradientAngle(oostyle.gradientAngle);
1177
                                if ((gradientAngle == 0) || (gradientAngle == 180) || (gradientAngle == 90) || (gradientAngle == 270))
592 fschmid 1178
                                {
8216 jghali 1179
                                        if ((gradientAngle == 0) || (gradientAngle == 180))
8048 avox 1180
                                        {
14168 fschmid 1181
                                                item->GrType = 6;
8278 jghali 1182
                                                item->GrStartX = item->width() / 2.0;
1183
                                                item->GrStartY = 0;
1184
                                                item->GrEndX = item->width() / 2.0;
1185
                                                item->GrEndY = item->height();
8048 avox 1186
                                        }
8216 jghali 1187
                                        else if ((gradientAngle == 90) || (gradientAngle == 270))
1188
                                        {
14168 fschmid 1189
                                                item->GrType = 6;
8278 jghali 1190
                                                item->GrStartX = 0;
1191
                                                item->GrStartY = item->height() / 2.0;
1192
                                                item->GrEndX = item->width();
1193
                                                item->GrEndY = item->height() / 2.0;
8216 jghali 1194
                                        }
547 fschmid 1195
                                }
8216 jghali 1196
                                else
545 fschmid 1197
                                {
8216 jghali 1198
                                        if ((gradientAngle > 90) && (gradientAngle < 270))
1199
                                                gradientAngle -= 180;
1200
                                        else if ((gradientAngle > 270) && (gradientAngle < 360))
546 fschmid 1201
                                        {
8216 jghali 1202
                                                gradientAngle = 360 - gradientAngle;
1203
                                                flipped = true;
7351 fschmid 1204
                                        }
8216 jghali 1205
                                        double xpos;
8278 jghali 1206
                                        xpos = (item->width() / 2) * tan(gradientAngle* M_PI / 180.0) * (item->height() / item->width()) + (item->width() / 2);
1207
                                        if ((xpos < 0) || (xpos > item->width()))
7351 fschmid 1208
                                        {
8278 jghali 1209
                                                xpos = (item->height() / 2)- (item->height() / 2) * tan(gradientAngle* M_PI / 180.0) * (item->height() / item->width());
8216 jghali 1210
                                                if (flipped)
546 fschmid 1211
                                                {
8278 jghali 1212
                                                        item->GrEndX = item->width();
1213
                                                        item->GrEndY = item->height() - xpos;
1214
                                                        item->GrStartX = 0;
1215
                                                        item->GrStartY = xpos;
546 fschmid 1216
                                                }
7351 fschmid 1217
                                                else
546 fschmid 1218
                                                {
8278 jghali 1219
                                                        item->GrEndY = xpos;
1220
                                                        item->GrEndX = item->width();
1221
                                                        item->GrStartX = 0;
1222
                                                        item->GrStartY = item->height() - xpos;
546 fschmid 1223
                                                }
1224
                                        }
8216 jghali 1225
                                        else
1226
                                        {
8278 jghali 1227
                                                item->GrEndX = xpos;
1228
                                                item->GrEndY = item->height();
1229
                                                item->GrStartX = item->width() - xpos;
1230
                                                item->GrStartY = 0;
8216 jghali 1231
                                        }
1232
                                        if (flipped)
1233
                                        {
8278 jghali 1234
                                                item->GrEndX = item->width() - xpos;
1235
                                                item->GrEndY = item->height();
1236
                                                item->GrStartX = xpos;
1237
                                                item->GrStartY = 0;
8216 jghali 1238
                                        }
8278 jghali 1239
                                        item->GrType = 6;
545 fschmid 1240
                                }
8216 jghali 1241
                        }
1242
                        if (oostyle.gradientType == 2)
1243
                        {
8278 jghali 1244
                                item->GrType = 7;
1245
                                item->GrStartX = item->width() * oostyle.gradientPointX;
1246
                                item->GrStartY = item->height()* oostyle.gradientPointY;
1247
                                if (item->width() >= item->height())
8216 jghali 1248
                                {
8278 jghali 1249
                                        item->GrEndX = item->width();
1250
                                        item->GrEndY = item->height() / 2.0;
8216 jghali 1251
                                }
7351 fschmid 1252
                                else
592 fschmid 1253
                                {
8278 jghali 1254
                                        item->GrEndX = item->width() / 2.0;
1255
                                        item->GrEndY = item->height();
592 fschmid 1256
                                }
8216 jghali 1257
                                //m_Doc->view()->updateGradientVectors(ite);
8278 jghali 1258
                                item->updateGradientVectors();
545 fschmid 1259
                        }
541 fschmid 1260
                }
8216 jghali 1261
                else
1262
                {
10009 jghali 1263
                        QList<VColorStop*> cstops = oostyle.gradient.colorStops();
8278 jghali 1264
                        item->setFillColor(cstops.at(0)->name);
1265
                        item->setFillShade(cstops.at(0)->shade);
8216 jghali 1266
                }
541 fschmid 1267
        }
8278 jghali 1268
        return item;
541 fschmid 1269
}
1270
 
1271
void OODPlug::createStyleMap( QDomDocument &docstyles )
1272
{
1273
        QDomElement styles = docstyles.documentElement();
1274
        if( styles.isNull() )
1275
                return;
1276
 
1277
        QDomNode fixedStyles = styles.namedItem( "office:styles" );
1278
        if( !fixedStyles.isNull() )
1279
        {
545 fschmid 1280
                insertDraws( fixedStyles.toElement() );
541 fschmid 1281
                insertStyles( fixedStyles.toElement() );
1282
        }
1283
        QDomNode automaticStyles = styles.namedItem( "office:automatic-styles" );
1284
        if( !automaticStyles.isNull() )
1285
                insertStyles( automaticStyles.toElement() );
1286
 
1287
        QDomNode masterStyles = styles.namedItem( "office:master-styles" );
1288
        if( !masterStyles.isNull() )
1289
                insertStyles( masterStyles.toElement() );
1290
}
1291
 
545 fschmid 1292
void OODPlug::insertDraws( const QDomElement& styles )
1293
{
1294
        for( QDomNode n = styles.firstChild(); !n.isNull(); n = n.nextSibling() )
1295
        {
1296
                QDomElement e = n.toElement();
1297
                if( !e.hasAttribute( "draw:name" ) )
1298
                        continue;
1299
                QString name = e.attribute( "draw:name" );
1300
                m_draws.insert( name, new QDomElement( e ) );
1301
        }
1302
}
1303
 
541 fschmid 1304
void OODPlug::insertStyles( const QDomElement& styles )
1305
{
1306
        for ( QDomNode n = styles.firstChild(); !n.isNull(); n = n.nextSibling() )
1307
        {
1308
                QDomElement e = n.toElement();
1309
                if( !e.hasAttribute( "style:name" ) )
1310
                        continue;
1311
                QString name = e.attribute( "style:name" );
1312
                m_styles.insert( name, new QDomElement( e ) );
1313
        }
1314
}
1315
 
1316
void OODPlug::fillStyleStack( const QDomElement& object )
1317
{
1318
        if( object.hasAttribute( "presentation:style-name" ) )
14017 jghali 1319
                addStyles( m_styles.value(object.attribute( "presentation:style-name" ), NULL) );
541 fschmid 1320
        if( object.hasAttribute( "draw:style-name" ) )
14017 jghali 1321
                addStyles( m_styles.value(object.attribute( "draw:style-name" ), NULL) );
541 fschmid 1322
        if( object.hasAttribute( "draw:text-style-name" ) )
14017 jghali 1323
                addStyles( m_styles.value(object.attribute( "draw:text-style-name" ), NULL) );
541 fschmid 1324
        if( object.hasAttribute( "text:style-name" ) )
14017 jghali 1325
                addStyles( m_styles.value(object.attribute( "text:style-name" ), NULL) );
541 fschmid 1326
}
1327
 
1328
void OODPlug::addStyles( const QDomElement* style )
1329
{
14017 jghali 1330
        if (style)
1331
        {
1332
                if( style->hasAttribute( "style:parent-style-name" ) )
1333
                        addStyles( m_styles.value(style->attribute( "style:parent-style-name" ), NULL) );
1334
                m_styleStack.push( *style );
1335
        }
541 fschmid 1336
}
1337
 
1338
void OODPlug::storeObjectStyles( const QDomElement& object )
1339
{
1340
        fillStyleStack( object );
1341
}
1342
 
1343
double OODPlug::parseUnit(const QString &unit)
1344
{
1345
        QString unitval=unit;
2877 cbradney 1346
        if (unit.isEmpty())
541 fschmid 1347
                return 0.0;
1348
        if( unit.right( 2 ) == "pt" )
1349
                unitval.replace( "pt", "" );
1350
        else if( unit.right( 2 ) == "cm" )
1351
                unitval.replace( "cm", "" );
1352
        else if( unit.right( 2 ) == "mm" )
1353
                unitval.replace( "mm" , "" );
1354
        else if( unit.right( 2 ) == "in" )
1355
                unitval.replace( "in", "" );
1356
        else if( unit.right( 2 ) == "px" )
1357
                unitval.replace( "px", "" );
13466 cbradney 1358
        double value = ScCLocale::toDoubleC(unitval);
541 fschmid 1359
        if( unit.right( 2 ) == "pt" )
1360
                value = value;
1361
        else if( unit.right( 2 ) == "cm" )
1362
                value = ( value / 2.54 ) * 72;
1363
        else if( unit.right( 2 ) == "mm" )
1364
                value = ( value / 25.4 ) * 72;
1365
        else if( unit.right( 2 ) == "in" )
1366
                value = value * 72;
1367
        else if( unit.right( 2 ) == "px" )
1368
                value = value;
1369
        return value;
1370
}
1371
 
1372
QColor OODPlug::parseColorN( const QString &rgbColor )
1373
{
1374
        int r, g, b;
1375
        keywordToRGB( rgbColor, r, g, b );
1376
        return QColor( r, g, b );
1377
}
1378
 
1379
QString OODPlug::parseColor( const QString &s )
1380
{
1381
        QColor c;
4546 subik 1382
        QString ret = CommonStrings::None;
541 fschmid 1383
        if( s.startsWith( "rgb(" ) )
1384
        {
10394 cbradney 1385
                QString parse = s.trimmed();
10603 fschmid 1386
                QStringList colors = parse.split( ',', QString::SkipEmptyParts );
541 fschmid 1387
                QString r = colors[0].right( ( colors[0].length() - 4 ) );
1388
                QString g = colors[1];
1389
                QString b = colors[2].left( ( colors[2].length() - 1 ) );
1390
                if( r.contains( "%" ) )
1391
                {
15498 jghali 1392
                        r.chop(1);
13466 cbradney 1393
                        r = QString::number( static_cast<int>( ( static_cast<double>( 255 * ScCLocale::toDoubleC(r) ) / 100.0 ) ) );
541 fschmid 1394
                }
1395
                if( g.contains( "%" ) )
1396
                {
15498 jghali 1397
                        g.chop(1);
13466 cbradney 1398
                        g = QString::number( static_cast<int>( ( static_cast<double>( 255 * ScCLocale::toDoubleC(g) ) / 100.0 ) ) );
541 fschmid 1399
                }
1400
                if( b.contains( "%" ) )
1401
                {
15498 jghali 1402
                        b.chop(1);
13466 cbradney 1403
                        b = QString::number( static_cast<int>( ( static_cast<double>( 255 * ScCLocale::toDoubleC(b) ) / 100.0 ) ) );
541 fschmid 1404
                }
1405
                c = QColor(r.toInt(), g.toInt(), b.toInt());
1406
        }
1407
        else
1408
        {
10394 cbradney 1409
                QString rgbColor = s.trimmed();
541 fschmid 1410
                if( rgbColor.startsWith( "#" ) )
1411
                        c.setNamedColor( rgbColor );
1412
                else
1413
                        c = parseColorN( rgbColor );
1414
        }
15771 fschmid 1415
        ScColor tmp;
1416
        tmp.fromQColor(c);
1417
        tmp.setSpotColor(false);
1418
        tmp.setRegistrationColor(false);
1419
        QString fNam = m_Doc->PageColors.tryAddColor("FromOODraw"+c.name(), tmp);
1420
        if (fNam == "FromOODraw"+c.name())
1421
                importedColors.append(fNam);
1422
        ret = fNam;
541 fschmid 1423
        return ret;
1424
}
1425
 
546 fschmid 1426
void OODPlug::parseTransform(FPointArray *composite, const QString &transform)
541 fschmid 1427
{
545 fschmid 1428
        double dx, dy;
13951 fschmid 1429
        QTransform result;
10603 fschmid 1430
        QStringList subtransforms = transform.split(')', QString::SkipEmptyParts);
541 fschmid 1431
        QStringList::ConstIterator it = subtransforms.begin();
1432
        QStringList::ConstIterator end = subtransforms.end();
546 fschmid 1433
        for (; it != end; ++it)
541 fschmid 1434
        {
10603 fschmid 1435
                QStringList subtransform = (*it).split('(', QString::SkipEmptyParts);
10398 cbradney 1436
                subtransform[0] = subtransform[0].trimmed().toLower();
10394 cbradney 1437
                subtransform[1] = subtransform[1].simplified();
541 fschmid 1438
                QRegExp reg("[,( ]");
10603 fschmid 1439
                QStringList params = subtransform[1].split(reg, QString::SkipEmptyParts);
541 fschmid 1440
                if(subtransform[0].startsWith(";") || subtransform[0].startsWith(","))
1441
                        subtransform[0] = subtransform[0].right(subtransform[0].length() - 1);
1442
                if(subtransform[0] == "rotate")
546 fschmid 1443
                {
13951 fschmid 1444
                        result = QTransform();
1795 cbradney 1445
                        result.rotate(-parseUnit(params[0]) * 180 / M_PI);
546 fschmid 1446
                        composite->map(result);
1447
                }
541 fschmid 1448
                else if(subtransform[0] == "translate")
1449
                {
1450
                        if(params.count() == 2)
1451
                        {
545 fschmid 1452
                                dx = parseUnit(params[0]);
1453
                                dy = parseUnit(params[1]);
541 fschmid 1454
                        }
1455
                        else
1456
                        {
545 fschmid 1457
                                dx = parseUnit(params[0]);
1458
                                dy =0.0;
541 fschmid 1459
                        }
13951 fschmid 1460
                        result = QTransform();
545 fschmid 1461
                        result.translate(dx, dy);
546 fschmid 1462
                        composite->map(result);
541 fschmid 1463
                }
545 fschmid 1464
                else if(subtransform[0] == "skewx")
546 fschmid 1465
                {
13951 fschmid 1466
                        result = QTransform();
13466 cbradney 1467
                        result.shear(-tan(ScCLocale::toDoubleC(params[0])), 0.0);
546 fschmid 1468
                        composite->map(result);
1469
                }
545 fschmid 1470
                else if(subtransform[0] == "skewy")
546 fschmid 1471
                {
13951 fschmid 1472
                        result = QTransform();
13466 cbradney 1473
                        result.shear(0.0, -tan(ScCLocale::toDoubleC(params[0])));
546 fschmid 1474
                        composite->map(result);
1475
                }
541 fschmid 1476
        }
1477
}
1478
 
544 fschmid 1479
void OODPlug::parseViewBox( const QDomElement& object, double *x, double *y, double *w, double *h )
541 fschmid 1480
{
544 fschmid 1481
        if( !object.attribute( "svg:viewBox" ).isEmpty() )
1482
        {
1483
                QString viewbox( object.attribute( "svg:viewBox" ) );
10603 fschmid 1484
                QStringList points = viewbox.replace( QRegExp(","), " ").simplified().split( ' ', QString::SkipEmptyParts );
13466 cbradney 1485
                *x = ScCLocale::toDoubleC(points[0]);
1486
                *y = ScCLocale::toDoubleC(points[1]);
1487
                *w = ScCLocale::toDoubleC(points[2]);
1488
                *h = ScCLocale::toDoubleC(points[3]);
544 fschmid 1489
        }
541 fschmid 1490
}
1491
 
10414 jghali 1492
void OODPlug::appendPoints(FPointArray *composite, const QDomElement& object, bool closePath)
541 fschmid 1493
{
544 fschmid 1494
        double x = parseUnit(object.attribute("svg:x"));
1495
        double y = parseUnit(object.attribute("svg:y")) ;
1496
        double w = parseUnit(object.attribute("svg:width"));
1497
        double h = parseUnit(object.attribute("svg:height"));
1498
        double vx = 0;
1499
        double vy = 0;
1500
        double vw = 1;
1501
        double vh = 1;
1502
        parseViewBox(object, &vx, &vy, &vw, &vh);
10938 jghali 1503
        double sx = (vw != 0.0) ? (w / vw) : w;
1504
        double sy = (vh != 0.0) ? (h / vh) : h;
10603 fschmid 1505
        QStringList ptList = object.attribute( "draw:points" ).split( ' ', QString::SkipEmptyParts );
544 fschmid 1506
        FPoint point, firstP;
1507
        bool bFirst = true;
1508
        for( QStringList::Iterator it = ptList.begin(); it != ptList.end(); ++it )
1509
        {
13466 cbradney 1510
                point = FPoint(ScCLocale::toDoubleC((*it).section( ',', 0, 0 )), ScCLocale::toDoubleC((*it).section( ',', 1, 1 )));
544 fschmid 1511
                if (bFirst)
1512
                {
1513
                        composite->addPoint(point);
1514
                        composite->addPoint(point);
1515
                        firstP = point;
1516
                        bFirst = false;
1517
                }
1518
                else
1519
                {
1520
                        composite->addPoint(point);
1521
                        composite->addPoint(point);
1522
                        composite->addPoint(point);
1523
                        composite->addPoint(point);
1524
                }
1525
    }
10414 jghali 1526
        if (closePath)
1527
        {
1528
                composite->addPoint(firstP);
1529
                composite->addPoint(firstP);
1530
        }
13951 fschmid 1531
        QTransform mat;
544 fschmid 1532
        mat.translate(x, y);
10938 jghali 1533
        mat.scale(sx, sy);
544 fschmid 1534
        composite->map(mat);
541 fschmid 1535
}
1536
 
544 fschmid 1537
const char * OODPlug::getCoord( const char *ptr, double &number )
541 fschmid 1538
{
1539
        int integer, exponent;
1540
        double decimal, frac;
1541
        int sign, expsign;
1542
 
1543
        exponent = 0;
1544
        integer = 0;
1545
        frac = 1.0;
1546
        decimal = 0;
1547
        sign = 1;
1548
        expsign = 1;
1549
 
544 fschmid 1550
        // read the sign
541 fschmid 1551
        if(*ptr == '+')
1552
                ptr++;
1553
        else if(*ptr == '-')
1554
        {
1555
                ptr++;
1556
                sign = -1;
1557
        }
1558
 
544 fschmid 1559
        // read the integer part
541 fschmid 1560
        while(*ptr != '\0' && *ptr >= '0' && *ptr <= '9')
1561
                integer = (integer * 10) + *(ptr++) - '0';
544 fschmid 1562
        if(*ptr == '.') // read the decimals
541 fschmid 1563
        {
1564
                ptr++;
1565
                while(*ptr != '\0' && *ptr >= '0' && *ptr <= '9')
1566
                        decimal += (*(ptr++) - '0') * (frac *= 0.1);
1567
        }
1568
 
544 fschmid 1569
        if(*ptr == 'e' || *ptr == 'E') // read the exponent part
541 fschmid 1570
        {
1571
                ptr++;
1572
 
544 fschmid 1573
                // read the sign of the exponent
541 fschmid 1574
                if(*ptr == '+')
1575
                        ptr++;
1576
                else if(*ptr == '-')
1577
                {
1578
                        ptr++;
1579
                        expsign = -1;
1580
                }
1581
 
1582
                exponent = 0;
1583
                while(*ptr != '\0' && *ptr >= '0' && *ptr <= '9')
1584
                {
1585
                        exponent *= 10;
1586
                        exponent += *ptr - '0';
1587
                        ptr++;
1588
                }
1589
        }
1590
        number = integer + decimal;
1591
        number *= sign * pow( static_cast<double>(10), static_cast<double>( expsign * exponent ) );
1592
 
544 fschmid 1593
        // skip the following space
541 fschmid 1594
        if(*ptr == ' ')
1595
                ptr++;
1596
 
1597
        return ptr;
1598
}
1599
 
544 fschmid 1600
bool OODPlug::parseSVG( const QString &s, FPointArray *ite )
541 fschmid 1601
{
1602
        QString d = s;
1603
        d = d.replace( QRegExp( "," ), " ");
1604
        bool ret = false;
1605
        if( !d.isEmpty() )
1606
        {
10394 cbradney 1607
                d = d.simplified();
10868 jghali 1608
                QByteArray data = d.toLatin1();
1609
                const char *ptr = data.constData();
1610
                const char *end = data.constData() + data.length() + 1;
17034 jghali 1611
                double contrlx, contrly, curx, cury, tox, toy, x1, y1, x2, y2, xc, yc;
541 fschmid 1612
                double px1, py1, px2, py2, px3, py3;
1613
                bool relative;
1614
                FirstM = true;
1615
                char command = *(ptr++), lastCommand = ' ';
17034 jghali 1616
                curx = cury = contrlx = contrly = 0.0;
541 fschmid 1617
                while( ptr < end )
1618
                {
1619
                        if( *ptr == ' ' )
1620
                                ptr++;
1621
                        relative = false;
1622
                        switch( command )
1623
                        {
1624
                        case 'm':
1625
                                relative = true;
1626
                        case 'M':
1627
                                {
1628
                                        ptr = getCoord( ptr, tox );
1629
                                        ptr = getCoord( ptr, toy );
1630
                                        WasM = true;
17034 jghali 1631
                                        curx = relative ? curx + tox : tox;
1632
                                        cury = relative ? cury + toy : toy;
541 fschmid 1633
                                        svgMoveTo(curx, cury );
1634
                                        break;
1635
                                }
1636
                        case 'l':
1637
                                relative = true;
1638
                        case 'L':
1639
                                {
1640
                                        ptr = getCoord( ptr, tox );
1641
                                        ptr = getCoord( ptr, toy );
1642
                                        curx = relative ? curx + tox : tox;
1643
                                        cury = relative ? cury + toy : toy;
1644
                                        svgLineTo(ite, curx, cury );
1645
                                        break;
1646
                                }
1647
                        case 'h':
1648
                                {
1649
                                        ptr = getCoord( ptr, tox );
1650
                                        curx = curx + tox;
1651
                                        svgLineTo(ite, curx, cury );
1652
                                        break;
1653
                                }
1654
                        case 'H':
1655
                                {
1656
                                        ptr = getCoord( ptr, tox );
1657
                                        curx = tox;
1658
                                        svgLineTo(ite, curx, cury );
1659
                                        break;
1660
                                }
1661
                        case 'v':
1662
                                {
1663
                                        ptr = getCoord( ptr, toy );
1664
                                        cury = cury + toy;
1665
                                        svgLineTo(ite, curx, cury );
1666
                                        break;
1667
                                }
1668
                        case 'V':
1669
                                {
1670
                                        ptr = getCoord( ptr, toy );
1671
                                        cury = toy;
1672
                                        svgLineTo(ite,  curx, cury );
1673
                                        break;
1674
                                }
1675
                        case 'z':
1676
                        case 'Z':
1677
                                {
1678
                                        svgClosePath(ite);
1679
                                        break;
1680
                                }
1681
                        case 'c':
1682
                                relative = true;
1683
                        case 'C':
1684
                                {
1685
                                        ptr = getCoord( ptr, x1 );
1686
                                        ptr = getCoord( ptr, y1 );
1687
                                        ptr = getCoord( ptr, x2 );
1688
                                        ptr = getCoord( ptr, y2 );
1689
                                        ptr = getCoord( ptr, tox );
1690
                                        ptr = getCoord( ptr, toy );
1691
                                        px1 = relative ? curx + x1 : x1;
1692
                                        py1 = relative ? cury + y1 : y1;
1693
                                        px2 = relative ? curx + x2 : x2;
1694
                                        py2 = relative ? cury + y2 : y2;
1695
                                        px3 = relative ? curx + tox : tox;
1696
                                        py3 = relative ? cury + toy : toy;
1697
                                        svgCurveToCubic(ite, px1, py1, px2, py2, px3, py3 );
1698
                                        contrlx = relative ? curx + x2 : x2;
1699
                                        contrly = relative ? cury + y2 : y2;
1700
                                        curx = relative ? curx + tox : tox;
1701
                                        cury = relative ? cury + toy : toy;
1702
                                        break;
1703
                                }
1704
                        case 's':
1705
                                relative = true;
1706
                        case 'S':
1707
                                {
1708
                                        ptr = getCoord( ptr, x2 );
1709
                                        ptr = getCoord( ptr, y2 );
1710
                                        ptr = getCoord( ptr, tox );
1711
                                        ptr = getCoord( ptr, toy );
1712
                                        px1 = 2 * curx - contrlx;
1713
                                        py1 = 2 * cury - contrly;
1714
                                        px2 = relative ? curx + x2 : x2;
1715
                                        py2 = relative ? cury + y2 : y2;
1716
                                        px3 = relative ? curx + tox : tox;
1717
                                        py3 = relative ? cury + toy : toy;
1718
                                        svgCurveToCubic(ite, px1, py1, px2, py2, px3, py3 );
1719
                                        contrlx = relative ? curx + x2 : x2;
1720
                                        contrly = relative ? cury + y2 : y2;
1721
                                        curx = relative ? curx + tox : tox;
1722
                                        cury = relative ? cury + toy : toy;
1723
                                        break;
1724
                                }
1725
                        case 'q':
1726
                                relative = true;
1727
                        case 'Q':
1728
                                {
1729
                                        ptr = getCoord( ptr, x1 );
1730
                                        ptr = getCoord( ptr, y1 );
1731
                                        ptr = getCoord( ptr, tox );
1732
                                        ptr = getCoord( ptr, toy );
1733
                                        px1 = relative ? (curx + 2 * (x1 + curx)) * (1.0 / 3.0) : (curx + 2 * x1) * (1.0 / 3.0);
1734
                                        py1 = relative ? (cury + 2 * (y1 + cury)) * (1.0 / 3.0) : (cury + 2 * y1) * (1.0 / 3.0);
1735
                                        px2 = relative ? ((curx + tox) + 2 * (x1 + curx)) * (1.0 / 3.0) : (tox + 2 * x1) * (1.0 / 3.0);
1736
                                        py2 = relative ? ((cury + toy) + 2 * (y1 + cury)) * (1.0 / 3.0) : (toy + 2 * y1) * (1.0 / 3.0);
1737
                                        px3 = relative ? curx + tox : tox;
1738
                                        py3 = relative ? cury + toy : toy;
1739
                                        svgCurveToCubic(ite, px1, py1, px2, py2, px3, py3 );
1740
                                        contrlx = relative ? curx + x1 : (tox + 2 * x1) * (1.0 / 3.0);
1741
                                        contrly = relative ? cury + y1 : (toy + 2 * y1) * (1.0 / 3.0);
1742
                                        curx = relative ? curx + tox : tox;
1743
                                        cury = relative ? cury + toy : toy;
1744
                                        break;
1745
                                }
1746
                        case 't':
1747
                                relative = true;
1748
                        case 'T':
1749
                                {
1750
                                        ptr = getCoord(ptr, tox);
1751
                                        ptr = getCoord(ptr, toy);
1752
                                        xc = 2 * curx - contrlx;
1753
                                        yc = 2 * cury - contrly;
1754
                                        px1 = relative ? (curx + 2 * xc) * (1.0 / 3.0) : (curx + 2 * xc) * (1.0 / 3.0);
1755
                                        py1 = relative ? (cury + 2 * yc) * (1.0 / 3.0) : (cury + 2 * yc) * (1.0 / 3.0);
1756
                                        px2 = relative ? ((curx + tox) + 2 * xc) * (1.0 / 3.0) : (tox + 2 * xc) * (1.0 / 3.0);
1757
                                        py2 = relative ? ((cury + toy) + 2 * yc) * (1.0 / 3.0) : (toy + 2 * yc) * (1.0 / 3.0);
1758
                                        px3 = relative ? curx + tox : tox;
1759
                                        py3 = relative ? cury + toy : toy;
1760
                                        svgCurveToCubic(ite, px1, py1, px2, py2, px3, py3 );
1761
                                        contrlx = xc;
1762
                                        contrly = yc;
1763
                                        curx = relative ? curx + tox : tox;
1764
                                        cury = relative ? cury + toy : toy;
1765
                                        break;
1766
                                }
1767
                        case 'a':
1768
                                relative = true;
1769
                        case 'A':
1770
                                {
1771
                                        bool largeArc, sweep;
1772
                                        double angle, rx, ry;
1773
                                        ptr = getCoord( ptr, rx );
1774
                                        ptr = getCoord( ptr, ry );
1775
                                        ptr = getCoord( ptr, angle );
1776
                                        ptr = getCoord( ptr, tox );
1777
                                        largeArc = tox == 1;
1778
                                        ptr = getCoord( ptr, tox );
1779
                                        sweep = tox == 1;
1780
                                        ptr = getCoord( ptr, tox );
1781
                                        ptr = getCoord( ptr, toy );
1782
                                        calculateArc(ite, relative, curx, cury, angle, tox, toy, rx, ry, largeArc, sweep );
1783
                                }
1784
                        }
1785
                        lastCommand = command;
1786
                        if(*ptr == '+' || *ptr == '-' || (*ptr >= '0' && *ptr <= '9'))
1787
                        {
1788
                                // there are still coords in this command
1789
                                if(command == 'M')
1790
                                        command = 'L';
1791
                                else if(command == 'm')
1792
                                        command = 'l';
1793
                        }
1794
                        else
1795
                                command = *(ptr++);
1796
 
1797
                        if( lastCommand != 'C' && lastCommand != 'c' &&
1798
                                lastCommand != 'S' && lastCommand != 's' &&
1799
                                lastCommand != 'Q' && lastCommand != 'q' &&
1800
                                lastCommand != 'T' && lastCommand != 't')
1801
                        {
1802
                                contrlx = curx;
1803
                                contrly = cury;
1804
                        }
1805
                }
1806
                if ((lastCommand != 'z') && (lastCommand != 'Z'))
1807
                        ret = true;
1808
                if (ite->size() > 2)
1809
                {
1810
                        if ((ite->point(0).x() == ite->point(ite->size()-2).x()) && (ite->point(0).y() == ite->point(ite->size()-2).y()))
1811
                                ret = false;
1812
                }
1813
        }
1814
        return ret;
1815
}
1816
 
544 fschmid 1817
void OODPlug::calculateArc(FPointArray *ite, bool relative, double &curx, double &cury, double angle, double x, double y, double r1, double r2, bool largeArcFlag, bool sweepFlag)
541 fschmid 1818
{
1819
        double sin_th, cos_th;
1820
        double a00, a01, a10, a11;
1821
        double x0, y0, x1, y1, xc, yc;
1822
        double d, sfactor, sfactor_sq;
1823
        double th0, th1, th_arc;
1824
        int i, n_segs;
1825
        sin_th = sin(angle * (M_PI / 180.0));
1826
        cos_th = cos(angle * (M_PI / 180.0));
1827
        double dx;
1828
        if(!relative)
1829
                dx = (curx - x) / 2.0;
1830
        else
1831
                dx = -x / 2.0;
1832
        double dy;
1833
        if(!relative)
1834
                dy = (cury - y) / 2.0;
1835
        else
1836
                dy = -y / 2.0;
1837
        double _x1 =  cos_th * dx + sin_th * dy;
1838
        double _y1 = -sin_th * dx + cos_th * dy;
1839
        double Pr1 = r1 * r1;
1840
        double Pr2 = r2 * r2;
1841
        double Px = _x1 * _x1;
1842
        double Py = _y1 * _y1;
1843
        double check = Px / Pr1 + Py / Pr2;
1844
        if(check > 1)
1845
        {
1846
                r1 = r1 * sqrt(check);
1847
                r2 = r2 * sqrt(check);
1848
        }
1849
        a00 = cos_th / r1;
1850
        a01 = sin_th / r1;
1851
        a10 = -sin_th / r2;
1852
        a11 = cos_th / r2;
1853
        x0 = a00 * curx + a01 * cury;
1854
        y0 = a10 * curx + a11 * cury;
1855
        if(!relative)
1856
                x1 = a00 * x + a01 * y;
1857
        else
1858
                x1 = a00 * (curx + x) + a01 * (cury + y);
1859
        if(!relative)
1860
                y1 = a10 * x + a11 * y;
1861
        else
1862
                y1 = a10 * (curx + x) + a11 * (cury + y);
1863
        d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0);
1864
        sfactor_sq = 1.0 / d - 0.25;
1865
        if(sfactor_sq < 0)
1866
                sfactor_sq = 0;
1867
        sfactor = sqrt(sfactor_sq);
1868
        if(sweepFlag == largeArcFlag)
1869
                sfactor = -sfactor;
1870
        xc = 0.5 * (x0 + x1) - sfactor * (y1 - y0);
1871
        yc = 0.5 * (y0 + y1) + sfactor * (x1 - x0);
1872
 
1873
        th0 = atan2(y0 - yc, x0 - xc);
1874
        th1 = atan2(y1 - yc, x1 - xc);
1875
        th_arc = th1 - th0;
1876
        if(th_arc < 0 && sweepFlag)
1877
                th_arc += 2 * M_PI;
1878
        else if(th_arc > 0 && !sweepFlag)
1879
                th_arc -= 2 * M_PI;
1880
        n_segs = static_cast<int>(ceil(fabs(th_arc / (M_PI * 0.5 + 0.001))));
1881
        for(i = 0; i < n_segs; i++)
1882
        {
1883
                {
1884
                        double sin_th, cos_th;
1885
                        double a00, a01, a10, a11;
1886
                        double x1, y1, x2, y2, x3, y3;
1887
                        double t;
1888
                        double th_half;
1889
                        double _th0 = th0 + i * th_arc / n_segs;
1890
                        double _th1 = th0 + (i + 1) * th_arc / n_segs;
1891
                        sin_th = sin(angle * (M_PI / 180.0));
1892
                        cos_th = cos(angle * (M_PI / 180.0));
1893
                        a00 = cos_th * r1;
1894
                        a01 = -sin_th * r2;
1895
                        a10 = sin_th * r1;
1896
                        a11 = cos_th * r2;
1897
                        th_half = 0.5 * (_th1 - _th0);
1898
                        t = (8.0 / 3.0) * sin(th_half * 0.5) * sin(th_half * 0.5) / sin(th_half);
1899
                        x1 = xc + cos(_th0) - t * sin(_th0);
1900
                        y1 = yc + sin(_th0) + t * cos(_th0);
1901
                        x3 = xc + cos(_th1);
1902
                        y3 = yc + sin(_th1);
1903
                        x2 = x3 + t * sin(_th1);
1904
                        y2 = y3 - t * cos(_th1);
1905
                        svgCurveToCubic(ite, a00 * x1 + a01 * y1, a10 * x1 + a11 * y1, a00 * x2 + a01 * y2, a10 * x2 + a11 * y2, a00 * x3 + a01 * y3, a10 * x3 + a11 * y3 );
1906
                }
1907
        }
1908
        if(!relative)
1909
                curx = x;
1910
        else
1911
                curx += x;
1912
        if(!relative)
1913
                cury = y;
1914
        else
1915
                cury += y;
1916
}
1917
 
544 fschmid 1918
void OODPlug::svgMoveTo(double x1, double y1)
541 fschmid 1919
{
1920
        CurrX = x1;
1921
        CurrY = y1;
1922
        StartX = x1;
1923
        StartY = y1;
1924
        PathLen = 0;
1925
}
1926
 
544 fschmid 1927
void OODPlug::svgLineTo(FPointArray *i, double x1, double y1)
541 fschmid 1928
{
1929
        if ((!FirstM) && (WasM))
1930
        {
1931
                i->setMarker();
1932
                PathLen += 4;
1933
        }
1934
        FirstM = false;
1935
        WasM = false;
1936
        if (i->size() > 3)
1937
        {
1938
                FPoint b1 = i->point(i->size()-4);
1939
                FPoint b2 = i->point(i->size()-3);
1940
                FPoint b3 = i->point(i->size()-2);
1941
                FPoint b4 = i->point(i->size()-1);
1942
                FPoint n1 = FPoint(CurrX, CurrY);
1943
                FPoint n2 = FPoint(x1, y1);
1944
                if ((b1 == n1) && (b2 == n1) && (b3 == n2) && (b4 == n2))
1945
                        return;
1946
        }
1947
        i->addPoint(FPoint(CurrX, CurrY));
1948
        i->addPoint(FPoint(CurrX, CurrY));
1949
        i->addPoint(FPoint(x1, y1));
1950
        i->addPoint(FPoint(x1, y1));
1951
        CurrX = x1;
1952
        CurrY = y1;
1953
        PathLen += 4;
1954
}
1955
 
544 fschmid 1956
void OODPlug::svgCurveToCubic(FPointArray *i, double x1, double y1, double x2, double y2, double x3, double y3)
541 fschmid 1957
{
1958
        if ((!FirstM) && (WasM))
1959
        {
1960
                i->setMarker();
1961
                PathLen += 4;
1962
        }
1963
        FirstM = false;
1964
        WasM = false;
1965
        if (PathLen > 3)
1966
        {
1967
                FPoint b1 = i->point(i->size()-4);
1968
                FPoint b2 = i->point(i->size()-3);
1969
                FPoint b3 = i->point(i->size()-2);
1970
                FPoint b4 = i->point(i->size()-1);
1971
                FPoint n1 = FPoint(CurrX, CurrY);
1972
                FPoint n2 = FPoint(x1, y1);
1973
                FPoint n3 = FPoint(x3, y3);
1974
                FPoint n4 = FPoint(x2, y2);
1975
                if ((b1 == n1) && (b2 == n2) && (b3 == n3) && (b4 == n4))
1976
                        return;
1977
        }
1978
        i->addPoint(FPoint(CurrX, CurrY));
1979
        i->addPoint(FPoint(x1, y1));
1980
        i->addPoint(FPoint(x3, y3));
1981
        i->addPoint(FPoint(x2, y2));
1982
        CurrX = x3;
1983
        CurrY = y3;
1984
        PathLen += 4;
1985
}
1986
 
544 fschmid 1987
void OODPlug::svgClosePath(FPointArray *i)
541 fschmid 1988
{
1989
        if (PathLen > 2)
1990
        {
1991
                if ((PathLen == 4) || (i->point(i->size()-2).x() != StartX) || (i->point(i->size()-2).y() != StartY))
1992
                {
1993
                        i->addPoint(i->point(i->size()-2));
1994
                        i->addPoint(i->point(i->size()-3));
1995
                        i->addPoint(FPoint(StartX, StartY));
1996
                        i->addPoint(FPoint(StartX, StartY));
1997
                }