Subversion Repositories Scribus

Rev

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