Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
19235 fschmid 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
#include <QApplication>
8
#include <QByteArray>
9
#include <QCursor>
10
#include <QDrag>
11
#include <QFile>
12
#include <QList>
13
#include <QMimeData>
14
#include <QRegExp>
15
#include <QStack>
16
#include <QTextDocument>
17
#include <QDebug>
18
 
19
#include <cstdlib>
20
 
21
#include "color.h"
22
#include "commonstrings.h"
23
#include "fileloader.h"
24
#include "loadsaveplugin.h"
25
#include "pagesize.h"
26
#include "prefscontext.h"
27
#include "prefsfile.h"
28
#include "prefsmanager.h"
29
#include "prefstable.h"
30
#include "rawimage.h"
31
#include "scclocale.h"
32
#include "sccolorengine.h"
33
#include "scconfig.h"
34
#include "scmimedata.h"
35
#include "scpaths.h"
36
#include "scpattern.h"
37
#include "scribus.h"
38
#include "scribusXml.h"
39
#include "scribuscore.h"
40
#include "scribusdoc.h"
41
#include "scribusview.h"
42
#include "sctextstream.h"
43
#include "selection.h"
44
#include "ui/missing.h"
45
#include "undomanager.h"
46
#include "util.h"
47
#include "util_formats.h"
48
#include "util_icon.h"
49
#include "util_math.h"
50
#include "rawpainter.h"
51
 
52
 
53
extern SCRIBUS_API ScribusQApp * ScQApp;
54
 
55
#if HAVE_REVENGE
56
 
57
struct RawPainterPrivate
58
{
59
        RawPainterPrivate();
60
};
61
 
62
RawPainterPrivate::RawPainterPrivate()
63
{
64
}
65
 
66
RawPainter::RawPainter(ScribusDoc* Doc, double x, double y, double w, double h, int iflags, QList<PageItem*> *Elem, QStringList *iColors, QStringList *iPatterns, Selection* tSel, QString fTyp) : m_pImpl(new RawPainterPrivate())
67
{
68
        m_Doc = Doc;
69
        baseX = x;
70
        baseY = y;
71
        docWidth = w;
72
        docHeight = h;
73
        importerFlags = iflags;
74
        Elements = Elem;
75
        importedColors = iColors;
76
        importedPatterns = iPatterns;
77
        tmpSel = tSel;
78
        doProcessing = true;
79
        CurrColorFill = "Black";
80
        CurrFillShade = 100.0;
81
        CurrColorStroke = "Black";
82
        CurrStrokeShade = 100.0;
83
        CurrStrokeTrans = 0.0;
84
        CurrFillTrans = 0.0;
85
        Coords.resize(0);
86
        Coords.svgInit();
87
        LineW = 1.0;
88
        lineJoin = Qt::MiterJoin;
89
        lineEnd = Qt::FlatCap;
90
        fillrule = true;
91
        gradientAngle = 0.0;
92
        isGradient = false;
93
        lineSpSet = false;
94
        currentGradient = VGradient(VGradient::linear);
95
        currentGradient.clearStops();
96
        currentGradient.setRepeatMethod( VGradient::none );
97
        dashArray.clear();
98
        firstPage = true;
99
        actPage = 0;
100
        actTextItem = NULL;
101
        fileType = fTyp;
102
}
103
 
104
RawPainter::~RawPainter()
105
{
106
        delete m_pImpl;
107
}
108
 
109
void RawPainter::startDocument(const librevenge::RVNGPropertyList &propList)
110
{
111
}
112
 
113
void RawPainter::endDocument()
114
{
115
}
116
 
117
void RawPainter::setDocumentMetaData(const librevenge::RVNGPropertyList &propList)
118
{
119
        if (!doProcessing)
120
                return;
121
        qDebug() << "setDocumentMetaData";
122
}
123
 
124
void RawPainter::defineEmbeddedFont(const librevenge::RVNGPropertyList &propList)
125
{
126
        if (!doProcessing)
127
                return;
128
        qDebug() << "defineEmbeddedFont";
129
}
130
 
131
void RawPainter::startPage(const librevenge::RVNGPropertyList &propList)
132
{
133
        if (propList["svg:width"])
134
                docWidth = valueAsPoint(propList["svg:width"]);
135
        if (propList["svg:height"])
136
                docHeight = valueAsPoint(propList["svg:height"]);
137
        if (importerFlags & LoadSavePlugin::lfCreateDoc)
138
        {
139
                if (!firstPage)
140
                {
141
                        m_Doc->addPage(actPage);
142
                        m_Doc->setActiveLayer(baseLayer);
143
                }
144
                else
145
                        baseLayer = m_Doc->activeLayerName();
146
                m_Doc->setPageSize("Custom");
147
                m_Doc->currentPage()->setInitialWidth(docWidth);
148
                m_Doc->currentPage()->setInitialHeight(docHeight);
149
                m_Doc->currentPage()->setWidth(docWidth);
150
                m_Doc->currentPage()->setHeight(docHeight);
151
                m_Doc->currentPage()->MPageNam = CommonStrings::trMasterPageNormal;
152
                m_Doc->currentPage()->m_pageSize = "Custom";
153
                m_Doc->reformPages(true);
154
                baseX = m_Doc->currentPage()->xOffset();
155
                baseY = m_Doc->currentPage()->yOffset();
156
        }
157
        firstPage = false;
158
        actPage++;
159
}
160
 
161
void RawPainter::endPage()
162
{
19358 fschmid 163
        if ((importerFlags & LoadSavePlugin::lfCreateThumbnail) || (!(importerFlags & LoadSavePlugin::lfCreateDoc)))
19235 fschmid 164
                doProcessing = false;
165
}
166
 
167
void RawPainter::startMasterPage(const librevenge::RVNGPropertyList &propList)
168
{
169
        if (!doProcessing)
170
                return;
171
        qDebug() << "startMasterPage";
172
}
173
 
174
void RawPainter::endMasterPage()
175
{
176
        if (!doProcessing)
177
                return;
178
        qDebug() << "endMasterPage";
179
}
180
 
181
void RawPainter::startLayer(const librevenge::RVNGPropertyList &propList)
182
{
183
        if (!doProcessing)
184
                return;
185
        FPointArray clip;
186
        if (propList["svg:clip-path"])
187
        {
188
                QString svgString = QString(propList["svg:clip-path"]->getStr().cstr());
189
                clip.resize(0);
190
                clip.svgInit();
191
                svgString.replace(",", ".");
192
                clip.parseSVG(svgString);
193
                QTransform m;
194
                m.scale(72.0, 72.0);
195
                clip.map(m);
196
        }
197
        QList<PageItem*> gElements;
198
        groupEntry gr;
199
        gr.clip = clip.copy();
200
        gr.Items = gElements;
201
        groupStack.push(gr);
202
}
203
 
204
void RawPainter::endLayer()
205
{
206
        if (!doProcessing)
207
                return;
208
        if (groupStack.count() != 0)
209
        {
210
                PageItem *ite;
211
                groupEntry gr = groupStack.pop();
212
                QList<PageItem*> gElements = gr.Items;
213
                tmpSel->clear();
214
                if (gElements.count() > 0)
215
                {
216
                        bool groupClip = true;
217
                        for (int dre = 0; dre < gElements.count(); ++dre)
218
                        {
219
                                tmpSel->addItem(gElements.at(dre), true);
220
                                Elements->removeAll(gElements.at(dre));
221
                                if (gElements.at(dre)->hasSoftShadow())
222
                                        groupClip = false;
223
                        }
224
                        ite = m_Doc->groupObjectsSelection(tmpSel);
225
                        ite->setGroupClipping(groupClip);
226
                        ite->setTextFlowMode(PageItem::TextFlowUsesBoundingBox);
227
                        if (!gr.clip.isEmpty())
228
                        {
229
                                double oldX = ite->xPos();
230
                                double oldY = ite->yPos();
231
                                double oldW = ite->width();
232
                                double oldH = ite->height();
233
                                double oldgW = ite->groupWidth;
234
                                double oldgH = ite->groupHeight;
235
                                ite->PoLine = gr.clip.copy();
236
                                ite->PoLine.translate(baseX, baseY);
237
                                FPoint xy = getMinClipF(&ite->PoLine);
238
                                ite->setXYPos(xy.x(), xy.y(), true);
239
                                ite->PoLine.translate(-xy.x(), -xy.y());
240
                                FPoint wh = getMaxClipF(&ite->PoLine);
241
                                ite->setWidthHeight(wh.x(),wh.y());
242
                                ite->groupWidth = oldgW * (ite->width() / oldW);
243
                                ite->groupHeight = oldgH * (ite->height() / oldH);
244
                                double dx = (ite->xPos() - oldX) / (ite->width() / ite->groupWidth);
245
                                double dy = (ite->yPos() - oldY) / (ite->height() / ite->groupHeight);
246
                                for (int em = 0; em < ite->groupItemList.count(); ++em)
247
                                {
248
                                        PageItem* embedded = ite->groupItemList.at(em);
249
                                        embedded->moveBy(-dx, -dy, true);
250
                                        m_Doc->setRedrawBounding(embedded);
251
                                        embedded->OwnPage = m_Doc->OnPage(embedded);
252
                                }
253
                                ite->ClipEdited = true;
254
                                ite->OldB2 = ite->width();
255
                                ite->OldH2 = ite->height();
256
                                ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
257
                                ite->updateGradientVectors();
258
                        }
259
                        Elements->append(ite);
260
                        if (groupStack.count() != 0)
261
                                groupStack.top().Items.append(ite);
262
                }
263
                tmpSel->clear();
264
        }
265
}
266
 
267
void RawPainter::startEmbeddedGraphics(const librevenge::RVNGPropertyList &propList)
268
{
269
        if (!doProcessing)
270
                return;
271
        qDebug() << "startEmbeddedGraphics";
272
}
273
 
274
void RawPainter::endEmbeddedGraphics()
275
{
276
        if (!doProcessing)
277
                return;
278
        qDebug() << "endEmbeddedGraphics";
279
}
280
 
281
void RawPainter::openGroup(const librevenge::RVNGPropertyList &propList)
282
{
283
        if (!doProcessing)
284
                return;
285
        qDebug() << "openGroup";
286
}
287
 
288
void RawPainter::closeGroup()
289
{
290
        if (!doProcessing)
291
                return;
292
        qDebug() << "closeGroup";
293
}
294
 
295
void RawPainter::setStyle(const librevenge::RVNGPropertyList &propList)
296
{
297
        if (!doProcessing)
298
                return;
299
        m_style.clear();
300
        m_style = propList;
301
        isGradient = false;
302
        if(propList["draw:fill"] && propList["draw:fill"]->getStr() == "none")
303
                CurrColorFill = CommonStrings::None;
304
        else if(propList["draw:fill"] && propList["draw:fill"]->getStr() == "solid")
305
        {
306
                if (propList["draw:fill-color"])
307
                {
308
                        CurrColorFill = parseColor(QString(propList["draw:fill-color"]->getStr().cstr()));
309
                        if(propList["draw:opacity"])
310
                                CurrFillTrans = 1.0 - qMin(1.0, qMax(fromPercentage(QString(propList["draw:opacity"]->getStr().cstr())), 0.0));
311
                }
312
        }
313
        if(propList["draw:fill"] && propList["draw:fill"]->getStr() == "gradient")
314
        {
315
                double angle = 0;
316
                if (propList["draw:angle"])
317
                        angle = propList["draw:angle"]->getDouble();
318
                double opacity = 1.0;
319
                librevenge::RVNGPropertyListVector gradient;
320
                if (propList.child("svg:linearGradient"))
321
                {
322
                        currentGradient = VGradient(VGradient::linear);
323
                        gradient = *propList.child("svg:linearGradient");
324
                }
325
                else if (propList.child("svg:radialGradient"))
326
                {
327
                        currentGradient = VGradient(VGradient::radial);
328
                        gradient = *propList.child("svg:radialGradient");
329
                }
330
                if (gradient.count() > 1)
331
                {
332
                        currentGradient.clearStops();
333
                        currentGradient.setRepeatMethod( VGradient::pad );
334
                        double dr = 1.0 / static_cast<double>(gradient.count());
335
                        for (unsigned c = 0; c < gradient.count(); c++)
336
                        {
337
                                librevenge::RVNGPropertyList grad = gradient[c];
338
                                if (grad["svg:stop-color"])
339
                                {
340
                                        QString stopName = parseColor(QString(grad["svg:stop-color"]->getStr().cstr()));
341
                                        double rampPoint = dr * c;
342
                                        if(grad["svg:offset"])
343
                                                rampPoint = fromPercentage(QString(grad["svg:offset"]->getStr().cstr()));
344
                                        const ScColor& gradC = m_Doc->PageColors[stopName];
345
                                        if(grad["svg:stop-opacity"])
346
                                                opacity = qMin(1.0, qMax(fromPercentage(QString(grad["svg:stop-opacity"]->getStr().cstr())), 0.0));
347
                                        currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), rampPoint, 0.5, opacity, stopName, 100 );
348
                                        if (c == 0)
349
                                        {
350
                                                gradColor1Str = stopName;
351
                                                gradColor1 = ScColorEngine::getRGBColor(gradC, m_Doc);
352
                                                gradColor1Trans = opacity;
353
                                        }
354
                                        else
355
                                        {
356
                                                gradColor2Str = stopName;
357
                                                gradColor2 = ScColorEngine::getRGBColor(gradC, m_Doc);
358
                                                gradColor2Trans = opacity;
359
                                        }
360
                                }
361
                        }
362
                        if (currentGradient.Stops() > 1)
363
                                isGradient = true;
364
                }
365
                else
366
                {
367
                        gradColor1Str = "Black";
368
                        gradColor2Str = "Black";
369
                        if (propList["draw:start-color"])
370
                                gradColor2Str = parseColor(QString(propList["draw:start-color"]->getStr().cstr()));
371
                        if (propList["draw:end-color"])
372
                                gradColor1Str = parseColor(QString(propList["draw:end-color"]->getStr().cstr()));
373
                        double opacity = 1.0;
374
                        currentGradient = VGradient(VGradient::linear);
375
                        currentGradient.clearStops();
376
                        currentGradient.setRepeatMethod( VGradient::none );
377
 
378
                        if (propList["draw:style"])
379
                        {
380
                                if (QString(propList["draw:style"]->getStr().cstr()) == "axial")
381
                                {
382
                                        currentGradient.addStop( ScColorEngine::getRGBColor(m_Doc->PageColors[gradColor1Str], m_Doc), 0.0, 0.5, opacity, gradColor1Str, 100 );
383
                                        currentGradient.addStop( ScColorEngine::getRGBColor(m_Doc->PageColors[gradColor2Str], m_Doc), 0.5, 0.5, opacity, gradColor2Str, 100 );
384
                                        currentGradient.addStop( ScColorEngine::getRGBColor(m_Doc->PageColors[gradColor1Str], m_Doc), 1.0, 0.5, opacity, gradColor1Str, 100 );
385
                                }
386
                                else
387
                                {
388
                                        currentGradient.addStop( ScColorEngine::getRGBColor(m_Doc->PageColors[gradColor1Str], m_Doc), 0.0, 0.5, opacity, gradColor1Str, 100 );
389
                                        currentGradient.addStop( ScColorEngine::getRGBColor(m_Doc->PageColors[gradColor2Str], m_Doc), 1.0, 0.5, opacity, gradColor2Str, 100 );
390
                                }
391
                                isGradient = true;
392
                        }
393
                }
394
        }
395
        if(propList["svg:fill-rule"])
396
        {
397
                if (QString(propList["svg:fill-rule"]->getStr().cstr()) == "nonzero")
398
                        fillrule = false;
399
                else
400
                        fillrule = true;
401
        }
402
        if (propList["svg:stroke-width"])
403
                LineW = valueAsPoint(propList["svg:stroke-width"]);
404
        if (propList["draw:stroke"])
405
        {
406
                if (propList["draw:stroke"]->getStr() == "none")
407
                        CurrColorStroke = CommonStrings::None;
408
                else if ((propList["draw:stroke"]->getStr() == "solid") || (propList["draw:stroke"]->getStr() == "dash"))
409
                {
410
                        if (propList["svg:stroke-color"])
411
                        {
412
                                CurrColorStroke = parseColor(QString(propList["svg:stroke-color"]->getStr().cstr()));
413
                                if(propList["svg:stroke-opacity"])
414
                                        CurrStrokeTrans = 1.0 - qMin(1.0, qMax(fromPercentage(QString(propList["svg:stroke-opacity"]->getStr().cstr())), 0.0));
415
                        }
416
                        if (propList["draw:stroke"]->getStr() == "dash")
417
                        {
418
                                dashArray.clear();
419
                                double gap = LineW;
420
                                if (propList["draw:distance"])
421
                                        gap = valueAsPoint(propList["draw:distance"]);
422
                                int dots1 = 0;
423
                                if (propList["draw:dots1"])
424
                                        dots1 = propList["draw:dots1"]->getInt();
425
                                double dots1len = LineW;
426
                                if (propList["draw:dots1-length"])
427
                                        dots1len = valueAsPoint(propList["draw:dots1-length"]);
428
                                int dots2 = 0;
429
                                if (propList["draw:dots2"])
430
                                        dots2 = propList["draw:dots2"]->getInt();
431
                                double dots2len = LineW;
432
                                if (propList["draw:dots2-length"])
433
                                        dots2len = valueAsPoint(propList["draw:dots2-length"]);
434
                                for (int i = 0; i < dots1; i++)
435
                                {
436
                                        dashArray << qMax(dots1len, 0.1) << qMax(gap, 0.1);
437
                                }
438
                                for (int j = 0; j < dots2; j++)
439
                                {
440
                                        dashArray << qMax(dots2len, 0.1) << qMax(gap, 0.1);
441
                                }
442
                        }
443
                        else
444
                                dashArray.clear();
445
                }
446
        }
447
        if (propList["svg:stroke-linecap"])
448
        {
449
                QString params = QString(propList["svg:stroke-linecap"]->getStr().cstr());
450
                if( params == "butt" )
451
                        lineEnd = Qt::FlatCap;
452
                else if( params == "round" )
453
                        lineEnd = Qt::RoundCap;
454
                else if( params == "square" )
455
                        lineEnd = Qt::SquareCap;
456
                else
457
                        lineEnd = Qt::FlatCap;
458
        }
459
        if (propList["svg:stroke-linejoin"])
460
        {
461
                QString params = QString(propList["svg:stroke-linejoin"]->getStr().cstr());
462
                if( params == "miter" )
463
                        lineJoin = Qt::MiterJoin;
464
                else if( params == "round" )
465
                        lineJoin = Qt::RoundJoin;
466
                else if( params == "bevel" )
467
                        lineJoin = Qt::BevelJoin;
468
                else
469
                        lineJoin = Qt::MiterJoin;
470
        }
471
}
472
 
473
void RawPainter::drawRectangle(const librevenge::RVNGPropertyList &propList)
474
{
475
        if (!doProcessing)
476
                return;
477
        if (propList["svg:x"] && propList["svg:y"] && propList["svg:width"] && propList["svg:height"])
478
        {
479
                double x = valueAsPoint(propList["svg:x"]);
480
                double y = valueAsPoint(propList["svg:y"]);
481
                double w = valueAsPoint(propList["svg:width"]);
482
                double h = valueAsPoint(propList["svg:height"]);
483
                int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, baseX + x, baseY + y, w, h, LineW, CurrColorFill, CurrColorStroke, true);
484
                PageItem *ite = m_Doc->Items->at(z);
485
                finishItem(ite);
486
                applyFill(ite);
487
                if (CurrColorFill != CommonStrings::None)
488
                        applyShadow(ite);
489
        }
490
}
491
 
492
void RawPainter::drawEllipse(const librevenge::RVNGPropertyList &propList)
493
{
494
        if (!doProcessing)
495
                return;
496
        if (propList["svg:x"] && propList["svg:y"] && propList["svg:width"] && propList["svg:height"])
497
        {
498
                double x = valueAsPoint(propList["svg:x"]);
499
                double y = valueAsPoint(propList["svg:y"]);
500
                double w = valueAsPoint(propList["svg:width"]);
501
                double h = valueAsPoint(propList["svg:height"]);
502
                int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Ellipse, baseX + x, baseY + y, w, h, LineW, CurrColorFill, CurrColorStroke, true);
503
                PageItem *ite = m_Doc->Items->at(z);
504
                finishItem(ite);
505
                applyFill(ite);
506
                if (CurrColorFill != CommonStrings::None)
507
                        applyShadow(ite);
508
        }
509
}
510
 
511
void RawPainter::drawPolyline(const librevenge::RVNGPropertyList &propList)
512
{
513
        if (!doProcessing)
514
                return;
515
        librevenge::RVNGPropertyListVector vertices = *propList.child("svg:points");
516
        if(vertices.count() < 2)
517
                return;
518
        Coords.resize(0);
519
        Coords.svgInit();
520
        PageItem *ite;
521
        Coords.svgMoveTo(valueAsPoint(vertices[0]["svg:x"]), valueAsPoint(vertices[0]["svg:y"]));
522
        for(unsigned i = 1; i < vertices.count(); i++)
523
        {
524
                Coords.svgLineTo(valueAsPoint(vertices[i]["svg:x"]), valueAsPoint(vertices[i]["svg:y"]));
525
        }
526
        if (Coords.size() > 0)
527
        {
528
                int z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColorStroke, true);
529
                ite = m_Doc->Items->at(z);
530
                ite->PoLine = Coords.copy();
531
                finishItem(ite);
532
                applyArrows(ite);
533
        }
534
}
535
 
536
void RawPainter::drawPolygon(const librevenge::RVNGPropertyList &propList)
537
{
538
        if (!doProcessing)
539
                return;
540
        librevenge::RVNGPropertyListVector vertices = *propList.child("svg:points");
541
        if(vertices.count() < 2)
542
                return;
543
        Coords.resize(0);
544
        Coords.svgInit();
545
        PageItem *ite;
546
        int z;
547
        Coords.svgMoveTo(valueAsPoint(vertices[0]["svg:x"]), valueAsPoint(vertices[0]["svg:y"]));
548
        for(unsigned i = 1; i < vertices.count(); i++)
549
        {
550
                Coords.svgLineTo(valueAsPoint(vertices[i]["svg:x"]), valueAsPoint(vertices[i]["svg:y"]));
551
        }
552
        Coords.svgClosePath();
553
        if (Coords.size() > 0)
554
        {
555
                if(m_style["draw:fill"] && m_style["draw:fill"]->getStr() == "bitmap" && m_style["style:repeat"] && m_style["style:repeat"]->getStr() == "stretch")
556
                {
557
                  if (m_style["draw:fill-image"] && m_style["librevenge:mime-type"])
558
                  {
559
                          QByteArray ba(m_style["draw:fill-image"]->getStr().cstr());
560
                          QByteArray imageData = QByteArray::fromBase64(ba);
561
                          QString imgExt = "";
562
                          if (m_style["librevenge:mime-type"]->getStr() == "image/png")
563
                                  imgExt = "png";
564
                          else if (m_style["librevenge:mime-type"]->getStr() == "image/jpeg")
565
                                  imgExt = "jpg";
566
                          else if (m_style["librevenge:mime-type"]->getStr() == "image/bmp")
567
                                  imgExt = "bmp";
568
                          else if (m_style["librevenge:mime-type"]->getStr() == "image/pict")
569
                                  imgExt = "pict";
570
                          else if (m_style["librevenge:mime-type"]->getStr() == "image/tiff")
571
                                  imgExt = "tif";
572
                          if (!imgExt.isEmpty())
573
                          {
574
                                  z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
575
                                  ite = m_Doc->Items->at(z);
576
                                  ite->PoLine = Coords.copy();
577
                                  finishItem(ite);
578
                                  insertImage(ite, imgExt, imageData);
579
                          }
580
                          else if (m_style["librevenge:mime-type"]->getStr() == "image/wmf")
581
                          {
582
                                  imgExt = "wmf";
583
                                  QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + QString("/scribus_temp_%1_XXXXXX.").arg(fileType) + imgExt);
584
                                  if (tempFile->open())
585
                                  {
586
                                          tempFile->write(imageData);
587
                                          QString fileName = getLongPathName(tempFile->fileName());
588
                                          tempFile->close();
589
                                          FileLoader *fileLoader = new FileLoader(fileName);
590
                                          int testResult = fileLoader->testFile();
591
                                          delete fileLoader;
592
                                          if (testResult != -1)
593
                                          {
594
                                                  const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
595
                                                  if( fmt )
596
                                                  {
597
                                                          fmt->setupTargets(m_Doc, 0, 0, 0, &(PrefsManager::instance()->appPrefs.fontPrefs.AvailFonts));
598
                                                          fmt->loadFile(fileName, LoadSavePlugin::lfUseCurrentPage|LoadSavePlugin::lfInteractive|LoadSavePlugin::lfScripted);
599
                                                          if (m_Doc->m_Selection->count() > 0)
600
                                                          {
601
                                                                  ite = m_Doc->groupObjectsSelection();
602
                                                                  double rot = 0;
603
                                                                  if (m_style["librevenge:rotate"])
604
                                                                          rot = m_style["librevenge:rotate"]->getDouble();
605
                                                                  QPainterPath ba = Coords.toQPainterPath(true);
606
                                                                  QRectF baR = ba.boundingRect();
607
                                                                  if (rot != 0)
608
                                                                  {
609
                                                                          QTransform mm;
610
                                                                          mm.translate(baR.x(), baR.y());
611
                                                                          mm.translate(baR.width() / 2.0, baR.height() / 2.0);
612
                                                                          mm.rotate(rot);
613
                                                                          mm.translate(-baR.width() / 2.0, -baR.height() / 2.0);
614
                                                                          mm.translate(-baR.x(), -baR.y());
615
                                                                          ba = mm.map(ba);
616
                                                                          baR = ba.boundingRect();
617
                                                                          ite->setXYPos(baseX + baR.x(), baseY + baR.y(), true);
618
                                                                          ite->setWidthHeight(baR.width(), baR.height(), true);
619
                                                                          Coords.fromQPainterPath(ba, true);
620
                                                                          FPoint tp2(getMinClipF(&Coords));
621
                                                                          Coords.translate(-tp2.x(), -tp2.y());
622
                                                                          ite->PoLine = Coords.copy();
623
                                                                          int rm = m_Doc->RotMode();
624
                                                                          m_Doc->RotMode(2);
625
                                                                          m_Doc->RotateItem(-rot, ite);
626
                                                                          m_Doc->RotMode(rm);
627
                                                                  }
628
                                                                  else
629
                                                                  {
630
                                                                          ite->setXYPos(baseX + baR.x(), baseY + baR.y(), true);
631
                                                                          ite->setWidthHeight(baR.width(), baR.height(), true);
632
                                                                          FPoint tp2(getMinClipF(&Coords));
633
                                                                          Coords.translate(-tp2.x(), -tp2.y());
634
                                                                          ite->PoLine = Coords.copy();
635
                                                                  }
636
                                                                  finishItem(ite);
637
                                                                  if (m_style["draw:red"] && m_style["draw:green"] && m_style["draw:blue"])
638
                                                                  {
639
                                                                          int r = qRound(m_style["draw:red"]->getDouble() * 255);
640
                                                                          int g = qRound(m_style["draw:green"]->getDouble() * 255);
641
                                                                          int b = qRound(m_style["draw:blue"]->getDouble() * 255);
642
                                                                          QString colVal = QString("#%1%2%3").arg(r, 2, 16, QLatin1Char('0')).arg(g, 2, 16, QLatin1Char('0')).arg(b, 2, 16, QLatin1Char('0'));
643
                                                                          QString efVal = parseColor(colVal);
644
                                                                          recolorItem(ite, efVal);
645
                                                                  }
646
                                                          }
647
                                                  }
648
                                          }
649
                                  }
650
                                  delete tempFile;
651
                          }
652
                  }
653
                }
654
                else
655
                {
656
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
657
                        ite = m_Doc->Items->at(z);
658
                        ite->PoLine = Coords.copy();
659
                        finishItem(ite);
660
                        applyFill(ite);
661
                }
662
                applyFlip(ite);
663
                if (CurrColorFill != CommonStrings::None)
664
                        applyShadow(ite);
665
        }
666
}
667
 
668
void RawPainter::drawPath(const librevenge::RVNGPropertyList &propList)
669
{
670
        if (!doProcessing)
671
                return;
672
        librevenge::RVNGPropertyListVector path = *propList.child("svg:d");
673
        bool isClosed = false;
674
        QString svgString = "";
675
        for(unsigned i=0; i < path.count(); i++)
676
        {
677
                librevenge::RVNGPropertyList pList = path[i];
678
                if (pList["librevenge:path-action"] && pList["librevenge:path-action"]->getStr() == "M")
679
                        svgString += QString("M %1 %2 ").arg(valueAsPoint(pList["svg:x"])).arg(valueAsPoint(pList["svg:y"]));
680
                else if (pList["librevenge:path-action"] && pList["librevenge:path-action"]->getStr() == "L")
681
                        svgString += QString("L %1 %2 ").arg(valueAsPoint(pList["svg:x"])).arg(valueAsPoint(pList["svg:y"]));
682
                else if (pList["librevenge:path-action"] && pList["librevenge:path-action"]->getStr() == "C")
683
                        svgString += QString("C %1 %2 %3 %4 %5 %6 ").arg(valueAsPoint(pList["svg:x1"])).arg(valueAsPoint(pList["svg:y1"])).arg(valueAsPoint(pList["svg:x2"])).arg(valueAsPoint(pList["svg:y2"])).arg(valueAsPoint(pList["svg:x"])).arg(valueAsPoint(pList["svg:y"]));
684
                else if (propList["librevenge:path-action"] && propList["librevenge:path-action"]->getStr() == "Q")
685
                        svgString += QString("Q %1 %2 %3 %4 ").arg(valueAsPoint(pList["svg:x1"])).arg(valueAsPoint(pList["svg:y1"])).arg(valueAsPoint(pList["svg:x"])).arg(valueAsPoint(pList["svg:y"]));
686
                else if (pList["librevenge:path-action"] && pList["librevenge:path-action"]->getStr() == "A")
687
                        svgString += QString("A %1 %2 %3 %4 %5 %6 %7") .arg(valueAsPoint(pList["svg:rx"])) .arg(valueAsPoint(pList["svg:ry"])).arg(pList["librevenge:rotate"] ? pList["librevenge:rotate"]->getDouble() : 0).arg(pList["librevenge:large-arc"] ? pList["librevenge:large-arc"]->getInt() : 1).arg(pList["librevenge:sweep"] ? pList["librevenge:sweep"]->getInt() : 1).arg(valueAsPoint(pList["svg:x"])).arg(valueAsPoint(pList["svg:y"]));
688
                else if ((i >= path.count()-1 && i > 2) && pList["librevenge:path-action"] && pList["librevenge:path-action"]->getStr() == "Z" )
689
                {
690
                        isClosed = true;
691
                        svgString += "Z";
692
                }
693
        }
694
        Coords.resize(0);
695
        Coords.svgInit();
696
        Coords.parseSVG(svgString);
697
        PageItem *ite;
698
        int z;
699
        if (isClosed)
700
        {
701
                if(m_style["draw:fill"] && m_style["draw:fill"]->getStr() == "bitmap" && m_style["style:repeat"] && m_style["style:repeat"]->getStr() == "stretch")
702
                {
703
                  if (m_style["draw:fill-image"] && m_style["librevenge:mime-type"])
704
                  {
705
                          QByteArray ba(m_style["draw:fill-image"]->getStr().cstr());
706
                          QByteArray imageData = QByteArray::fromBase64(ba);
707
                          QString imgExt = "";
708
                          if (m_style["librevenge:mime-type"]->getStr() == "image/png")
709
                                  imgExt = "png";
710
                          else if (m_style["librevenge:mime-type"]->getStr() == "image/jpeg")
711
                                  imgExt = "jpg";
712
                          else if (m_style["librevenge:mime-type"]->getStr() == "image/bmp")
713
                                  imgExt = "bmp";
714
                          else if (m_style["librevenge:mime-type"]->getStr() == "image/pict")
715
                                  imgExt = "pict";
716
                          else if (m_style["librevenge:mime-type"]->getStr() == "image/tiff")
717
                                  imgExt = "tif";
718
                          if (!imgExt.isEmpty())
719
                          {
720
                                  z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
721
                                  ite = m_Doc->Items->at(z);
722
                                  ite->PoLine = Coords.copy();
723
                                  finishItem(ite);
724
                                  insertImage(ite, imgExt, imageData);
725
                          }
726
                          else if (m_style["librevenge:mime-type"]->getStr() == "image/wmf")
727
                          {
728
                                  imgExt = "wmf";
729
                                  QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + QString("/scribus_temp_%1_XXXXXX.").arg(fileType) + imgExt);
730
                                  if (tempFile->open())
731
                                  {
732
                                          tempFile->write(imageData);
733
                                          QString fileName = getLongPathName(tempFile->fileName());
734
                                          tempFile->close();
735
                                          FileLoader *fileLoader = new FileLoader(fileName);
736
                                          int testResult = fileLoader->testFile();
737
                                          delete fileLoader;
738
                                          if (testResult != -1)
739
                                          {
740
                                                  const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
741
                                                  if( fmt )
742
                                                  {
743
                                                          fmt->setupTargets(m_Doc, 0, 0, 0, &(PrefsManager::instance()->appPrefs.fontPrefs.AvailFonts));
744
                                                          fmt->loadFile(fileName, LoadSavePlugin::lfUseCurrentPage|LoadSavePlugin::lfInteractive|LoadSavePlugin::lfScripted);
745
                                                          if (m_Doc->m_Selection->count() > 0)
746
                                                          {
747
                                                                  ite = m_Doc->groupObjectsSelection();
748
                                                                  double rot = 0;
749
                                                                  if (m_style["librevenge:rotate"])
750
                                                                          rot = m_style["librevenge:rotate"]->getDouble();
751
                                                                  QPainterPath ba = Coords.toQPainterPath(true);
752
                                                                  QRectF baR = ba.boundingRect();
753
                                                                  if (rot != 0)
754
                                                                  {
755
                                                                          QTransform mm;
756
                                                                          mm.translate(baR.x(), baR.y());
757
                                                                          mm.translate(baR.width() / 2.0, baR.height() / 2.0);
758
                                                                          mm.rotate(rot);
759
                                                                          mm.translate(-baR.width() / 2.0, -baR.height() / 2.0);
760
                                                                          mm.translate(-baR.x(), -baR.y());
761
                                                                          ba = mm.map(ba);
762
                                                                          baR = ba.boundingRect();
763
                                                                          ite->setXYPos(baseX + baR.x(), baseY + baR.y(), true);
764
                                                                          ite->setWidthHeight(baR.width(), baR.height(), true);
765
                                                                          Coords.fromQPainterPath(ba, true);
766
                                                                          FPoint tp2(getMinClipF(&Coords));
767
                                                                          Coords.translate(-tp2.x(), -tp2.y());
768
                                                                          ite->PoLine = Coords.copy();
769
                                                                          int rm = m_Doc->RotMode();
770
                                                                          m_Doc->RotMode(2);
771
                                                                          m_Doc->RotateItem(-rot, ite);
772
                                                                          m_Doc->RotMode(rm);
773
                                                                  }
774
                                                                  else
775
                                                                  {
776
                                                                          ite->setXYPos(baseX + baR.x(), baseY + baR.y(), true);
777
                                                                          ite->setWidthHeight(baR.width(), baR.height(), true);
778
                                                                          FPoint tp2(getMinClipF(&Coords));
779
                                                                          Coords.translate(-tp2.x(), -tp2.y());
780
                                                                          ite->PoLine = Coords.copy();
781
                                                                  }
782
                                                                  finishItem(ite);
783
                                                                  if (m_style["draw:red"] && m_style["draw:green"] && m_style["draw:blue"])
784
                                                                  {
785
                                                                          int r = qRound(m_style["draw:red"]->getDouble() * 255);
786
                                                                          int g = qRound(m_style["draw:green"]->getDouble() * 255);
787
                                                                          int b = qRound(m_style["draw:blue"]->getDouble() * 255);
788
                                                                          QString colVal = QString("#%1%2%3").arg(r, 2, 16, QLatin1Char('0')).arg(g, 2, 16, QLatin1Char('0')).arg(b, 2, 16, QLatin1Char('0'));
789
                                                                          QString efVal = parseColor(colVal);
790
                                                                          recolorItem(ite, efVal);
791
                                                                  }
792
                                                          }
793
                                                  }
794
                                          }
795
                                  }
796
                                  delete tempFile;
797
                          }
798
                  }
799
                }
800
                else
801
                {
802
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
803
                        ite = m_Doc->Items->at(z);
804
                        ite->PoLine = Coords.copy();
805
                        finishItem(ite);
806
                        applyFill(ite);
807
                }
808
                applyFlip(ite);
809
                if (CurrColorFill != CommonStrings::None)
810
                        applyShadow(ite);
811
        }
812
        else
813
        {
814
                z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColorStroke, true);
815
                ite = m_Doc->Items->at(z);
816
                ite->PoLine = Coords.copy();
817
                finishItem(ite);
818
                applyArrows(ite);
819
        }
820
}
821
 
822
void RawPainter::drawGraphicObject(const librevenge::RVNGPropertyList &propList)
823
{
824
        if (!doProcessing)
825
                return;
826
        if (!propList["librevenge:mime-type"] || propList["librevenge:mime-type"]->getStr().len() <= 0)
827
                return;
828
        if (!propList["office:binary-data"])
829
                return;
830
        if (propList["svg:x"] && propList["svg:y"] && propList["svg:width"] && propList["svg:height"])
831
        {
832
                PageItem *ite;
833
                double x = valueAsPoint(propList["svg:x"]);
834
                double y = valueAsPoint(propList["svg:y"]);
835
                double w = valueAsPoint(propList["svg:width"]);
836
                double h = valueAsPoint(propList["svg:height"]);
837
                QByteArray ba(propList["office:binary-data"]->getStr().cstr());
838
                QByteArray imageData = QByteArray::fromBase64(ba);
839
                QString imgExt = "";
840
                if (propList["librevenge:mime-type"]->getStr() == "image/png")
841
                        imgExt = "png";
842
                else if (propList["librevenge:mime-type"]->getStr() == "image/jpeg")
843
                        imgExt = "jpg";
844
                else if (propList["librevenge:mime-type"]->getStr() == "image/bmp")
845
                        imgExt = "bmp";
846
                else if (propList["librevenge:mime-type"]->getStr() == "image/pict")
847
                        imgExt = "pict";
848
                else if (propList["librevenge:mime-type"]->getStr() == "image/tiff")
849
                        imgExt = "tif";
850
                if (!imgExt.isEmpty())
851
                {
852
                        int z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Rectangle, baseX + x, baseY + y, w, h, 0, CurrColorFill, CurrColorStroke, true);
853
                        ite = m_Doc->Items->at(z);
854
                        finishItem(ite);
855
                        insertImage(ite, imgExt, imageData);
856
                }
857
                else
858
                {
859
                        if (propList["librevenge:mime-type"]->getStr() == "image/wmf")
860
                        {
861
                                imgExt = "wmf";
862
                                QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + QString("/scribus_temp_%1_XXXXXX.").arg(fileType) + imgExt);
863
                                if (tempFile->open())
864
                                {
865
                                        tempFile->write(imageData);
866
                                        QString fileName = getLongPathName(tempFile->fileName());
867
                                        tempFile->close();
868
                                        FileLoader *fileLoader = new FileLoader(fileName);
869
                                        int testResult = fileLoader->testFile();
870
                                        delete fileLoader;
871
                                        if (testResult != -1)
872
                                        {
873
                                                const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
874
                                                if( fmt )
875
                                                {
876
                                                        fmt->setupTargets(m_Doc, 0, 0, 0, &(PrefsManager::instance()->appPrefs.fontPrefs.AvailFonts));
877
                                                        fmt->loadFile(fileName, LoadSavePlugin::lfUseCurrentPage|LoadSavePlugin::lfInteractive|LoadSavePlugin::lfScripted);
878
                                                        if (m_Doc->m_Selection->count() > 0)
879
                                                        {
880
                                                                ite = m_Doc->groupObjectsSelection();
881
                                                                double rot = 0;
882
                                                                if (m_style["librevenge:rotate"])
883
                                                                        rot = m_style["librevenge:rotate"]->getDouble();
884
                                                                QPainterPath ba;
885
                                                                ba.addRect(QRectF(x, y, w, h));
886
                                                                QRectF baR = QRectF(x, y, w, h);
887
                                                                if (rot != 0)
888
                                                                {
889
                                                                        QTransform mm;
890
                                                                        mm.translate(baR.x(), baR.y());
891
                                                                        mm.translate(baR.width() / 2.0, baR.height() / 2.0);
892
                                                                        mm.rotate(rot);
893
                                                                        mm.translate(-baR.width() / 2.0, -baR.height() / 2.0);
894
                                                                        mm.translate(-baR.x(), -baR.y());
895
                                                                        ba = mm.map(ba);
896
                                                                        baR = ba.boundingRect();
897
                                                                        ite->setXYPos(baseX + baR.x(), baseY + baR.y(), true);
898
                                                                        ite->setWidthHeight(baR.width(), baR.height(), true);
899
                                                                        ite->updateClip();
900
                                                                        int rm = m_Doc->RotMode();
901
                                                                        m_Doc->RotMode(2);
902
                                                                        m_Doc->RotateItem(-rot, ite);
903
                                                                        m_Doc->RotMode(rm);
904
                                                                }
905
                                                                else
906
                                                                {
907
                                                                        ite->setXYPos(baseX + baR.x(), baseY + baR.y(), true);
908
                                                                        ite->setWidthHeight(baR.width(), baR.height(), true);
909
                                                                        ite->updateClip();
910
                                                                }
911
                                                                finishItem(ite);
912
                                                                if (m_style["draw:red"] && m_style["draw:green"] && m_style["draw:blue"])
913
                                                                {
914
                                                                        int r = qRound(m_style["draw:red"]->getDouble() * 255);
915
                                                                        int g = qRound(m_style["draw:green"]->getDouble() * 255);
916
                                                                        int b = qRound(m_style["draw:blue"]->getDouble() * 255);
917
                                                                        QString colVal = QString("#%1%2%3").arg(r, 2, 16, QLatin1Char('0')).arg(g, 2, 16, QLatin1Char('0')).arg(b, 2, 16, QLatin1Char('0'));
918
                                                                        QString efVal = parseColor(colVal);
919
                                                                        recolorItem(ite, efVal);
920
                                                                }
921
                                                        }
922
                                                }
923
                                        }
924
                                }
925
                                delete tempFile;
926
                        }
927
                }
928
                applyFlip(ite);
929
                if (CurrColorFill != CommonStrings::None)
930
                        applyShadow(ite);
931
        }
932
}
933
 
934
void RawPainter::drawConnector(const librevenge::RVNGPropertyList &propList)
935
{
936
        if (!doProcessing)
937
                return;
938
        qDebug() << "drawConnector";
939
}
940
 
941
void RawPainter::startTextObject(const librevenge::RVNGPropertyList &propList)
942
{
943
        if (!doProcessing)
944
                return;
945
        actTextItem = NULL;
946
        lineSpSet = false;
947
        lineSpIsPT = false;
948
        if (propList["svg:x"] && propList["svg:y"] && propList["svg:width"] && propList["svg:height"])
949
        {
950
                double x = valueAsPoint(propList["svg:x"]);
951
                double y = valueAsPoint(propList["svg:y"]);
952
                double w = valueAsPoint(propList["svg:width"]);
953
                double h = valueAsPoint(propList["svg:height"]);
19251 fschmid 954
                double minTxtH = 1;
955
                double minTxtW = 1;
19235 fschmid 956
                double rot = 0;
957
                if (propList["librevenge:rotate"])
958
                        rot = propList["librevenge:rotate"]->getDouble();
19251 fschmid 959
                int z = m_Doc->itemAdd(PageItem::TextFrame, PageItem::Rectangle, baseX + x, baseY + y, w, qMax(h, 2.0), 0, CurrColorFill, CurrColorStroke, true);
19235 fschmid 960
                PageItem *ite = m_Doc->Items->at(z);
961
                finishItem(ite);
962
                applyShadow(ite);
963
                if (rot != 0)
964
                {
965
                        int rm = m_Doc->RotMode();
966
                        m_Doc->RotMode(2);
967
                        m_Doc->RotateItem(rot, ite);
968
                        m_Doc->RotMode(rm);
969
                }
970
                if (propList["draw-mirror-horizontal"])
971
                        ite->flipImageH();
972
                if (propList["draw-mirror-vertical"])
973
                        ite->flipImageV();
974
                if (propList["fo:padding-left"])
19251 fschmid 975
                {
19235 fschmid 976
                        ite->setTextToFrameDistLeft(valueAsPoint(propList["fo:padding-left"]));
19251 fschmid 977
                        minTxtW += valueAsPoint(propList["fo:padding-left"]);
978
                }
19235 fschmid 979
                if (propList["fo:padding-right"])
19251 fschmid 980
                {
19235 fschmid 981
                        ite->setTextToFrameDistRight(valueAsPoint(propList["fo:padding-right"]));
19251 fschmid 982
                        minTxtW += valueAsPoint(propList["fo:padding-right"]);
983
                }
19235 fschmid 984
                if (propList["fo:padding-top"])
19251 fschmid 985
                {
19235 fschmid 986
                        ite->setTextToFrameDistTop(valueAsPoint(propList["fo:padding-top"]));
19251 fschmid 987
                        minTxtH += valueAsPoint(propList["fo:padding-top"]);
988
                }
19235 fschmid 989
                if (propList["fo:padding-bottom"])
19251 fschmid 990
                {
19235 fschmid 991
                        ite->setTextToFrameDistBottom(valueAsPoint(propList["fo:padding-bottom"]));
19251 fschmid 992
                        minTxtH += valueAsPoint(propList["fo:padding-bottom"]);
993
                }
19235 fschmid 994
                if (propList["fo:column-count"])
995
                        ite->setColumns(propList["fo:column-count"]->getInt());
996
                if (propList["fo:column-gap"])
19251 fschmid 997
                {
19235 fschmid 998
                        ite->setColumnGap(valueAsPoint(propList["fo:column-gap"]));
19251 fschmid 999
                        minTxtW += valueAsPoint(propList["fo:column-gap"]);
1000
                }
19321 fschmid 1001
                if (propList["draw:textarea-vertical-align"])
1002
                {
1003
                        QString align = QString(propList["draw:textarea-vertical-align"]->getStr().cstr());
1004
                        if (align == "middle")
1005
                                ite->setVerticalAlignment(1);
1006
                        else if (align == "bottom")
1007
                                ite->setVerticalAlignment(2);
1008
                }
19235 fschmid 1009
                ite->setFirstLineOffset(FLOPFontAscent);
1010
                actTextItem = ite;
1011
                QString pStyle = CommonStrings::DefaultParagraphStyle;
1012
                ParagraphStyle newStyle;
1013
                newStyle.setParent(pStyle);
1014
                textStyle = newStyle;
19251 fschmid 1015
                if (h == 0)
1016
                {
1017
                        minTxtH += textStyle.charStyle().fontSize() / 10.0;
1018
                        ite->setHeight(minTxtH);
1019
                }
1020
                if (w == 0)
1021
                        ite->setWidth(minTxtW);
19235 fschmid 1022
        }
1023
}
1024
 
1025
void RawPainter::endTextObject()
1026
{
1027
        if (!doProcessing)
1028
                return;
1029
        if (actTextItem)
1030
                actTextItem->itemText.trim();
1031
        actTextItem = NULL;
1032
        lineSpSet = false;
1033
        lineSpIsPT = false;
1034
}
1035
 
1036
void RawPainter::startTableObject(const librevenge::RVNGPropertyList &propList)
1037
{
1038
        if (!doProcessing)
1039
                return;
1040
        qDebug() << "startTableObject";
1041
}
1042
 
1043
void RawPainter::openTableRow(const librevenge::RVNGPropertyList &propList)
1044
{
1045
        if (!doProcessing)
1046
                return;
1047
        qDebug() << "openTableRow";
1048
}
1049
 
1050
void RawPainter::closeTableRow()
1051
{
1052
        if (!doProcessing)
1053
                return;
1054
        qDebug() << "closeTableRow";
1055
}
1056
 
1057
void RawPainter::openTableCell(const librevenge::RVNGPropertyList &propList)
1058
{
1059
        if (!doProcessing)
1060
                return;
1061
        qDebug() << "openTableCell";
1062
}
1063
 
1064
void RawPainter::closeTableCell()
1065
{
1066
        if (!doProcessing)
1067
                return;
1068
        qDebug() << "closeTableCell";
1069
}
1070
 
1071
void RawPainter::insertCoveredTableCell(const librevenge::RVNGPropertyList &propList)
1072
{
1073
        if (!doProcessing)
1074
                return;
1075
        qDebug() << "insertCoveredTableCell";
1076
}
1077
 
1078
void RawPainter::endTableObject()
1079
{
1080
        if (!doProcessing)
1081
                return;
1082
        qDebug() << "endTableObject";
1083
}
1084
 
1085
void RawPainter::openOrderedListLevel(const librevenge::RVNGPropertyList &propList)
1086
{
1087
        if (!doProcessing)
1088
                return;
1089
        qDebug() << "openOrderedListLevel";
1090
}
1091
 
1092
void RawPainter::closeOrderedListLevel()
1093
{
1094
        if (!doProcessing)
1095
                return;
1096
        qDebug() << "closeOrderedListLevel";
1097
}
1098
 
1099
void RawPainter::openUnorderedListLevel(const librevenge::RVNGPropertyList &propList)
1100
{
1101
        if (!doProcessing)
1102
                return;
1103
        qDebug() << "openUnorderedListLevel";
1104
}
1105
 
1106
void RawPainter::closeUnorderedListLevel()
1107
{
1108
        if (!doProcessing)
1109
                return;
1110
        qDebug() << "closeUnorderedListLevel";
1111
}
1112
 
1113
void RawPainter::openListElement(const librevenge::RVNGPropertyList &propList)
1114
{
1115
        if (!doProcessing)
1116
                return;
1117
        qDebug() << "openListElement";
1118
}
1119
 
1120
void RawPainter::closeListElement()
1121
{
1122
        if (!doProcessing)
1123
                return;
1124
        qDebug() << "closeListElement";
1125
}
1126
 
1127
void RawPainter::defineParagraphStyle(const librevenge::RVNGPropertyList &propList)
1128
{
1129
        if (!doProcessing)
1130
                return;
1131
        qDebug() << "defineParagraphStyle";
1132
}
1133
 
1134
void RawPainter::openParagraph(const librevenge::RVNGPropertyList &propList)
1135
{
1136
        if (!doProcessing)
1137
                return;
1138
        QString pStyle = CommonStrings::DefaultParagraphStyle;
1139
        ParagraphStyle newStyle;
1140
        newStyle.setParent(pStyle);
1141
        textStyle = newStyle;
1142
        if (propList["fo:text-align"])
1143
        {
1144
                QString align = QString(propList["fo:text-align"]->getStr().cstr());
1145
                if (align == "left")
1146
                        textStyle.setAlignment(ParagraphStyle::Leftaligned);
1147
                else if (align == "center")
1148
                        textStyle.setAlignment(ParagraphStyle::Centered);
1149
                else if (align == "right")
1150
                        textStyle.setAlignment(ParagraphStyle::Rightaligned);
1151
                else if (align == "justify")
1152
                        textStyle.setAlignment(ParagraphStyle::Justified);
1153
        }
1154
        if (propList["fo:margin-left"])
1155
                textStyle.setLeftMargin(valueAsPoint(propList["fo:margin-left"]));
1156
        if (propList["fo:margin-right"])
1157
                textStyle.setRightMargin(valueAsPoint(propList["fo:margin-right"]));
1158
        if (propList["fo:text-indent"])
1159
                textStyle.setFirstIndent(valueAsPoint(propList["fo:text-indent"]));
1160
        if (propList["style:drop-cap"])
1161
        {
1162
                textStyle.setDropCapLines(propList["style:drop-cap"]->getInt());
1163
                textStyle.setHasDropCap(true);
1164
        }
1165
        if (propList["fo:margin-bottom"])
1166
                textStyle.setGapAfter(valueAsPoint(propList["fo:margin-bottom"]));
1167
        if (propList["fo:margin-top"])
1168
                textStyle.setGapBefore(valueAsPoint(propList["fo:margin-top"]));
1169
//      m_maxFontSize = textStyle.charStyle().fontSize() / 10.0;
1170
        m_maxFontSize = 1.0;
1171
        if (propList["fo:line-height"])
1172
        {
1173
                m_linespace = propList["fo:line-height"]->getDouble();
1174
                QString lsp = QString(propList["fo:line-height"]->getStr().cstr());
1175
                lineSpIsPT = lsp.endsWith("pt");
1176
                lineSpSet = true;
1177
        }
1178
}
1179
 
1180
void RawPainter::closeParagraph()
1181
{
1182
        if (!doProcessing)
1183
                return;
1184
        if (actTextItem == NULL)
1185
                return;
1186
        int posT = actTextItem->itemText.length();
1187
        if (posT > 0)
1188
        {
1189
                if ((actTextItem->itemText.text(posT - 1) != SpecialChars::PARSEP))
1190
                {
1191
                        actTextItem->itemText.insertChars(posT, SpecialChars::PARSEP);
1192
                        actTextItem->itemText.applyStyle(posT, textStyle);
1193
                }
1194
        }
1195
}
1196
 
1197
void RawPainter::defineCharacterStyle(const librevenge::RVNGPropertyList &propList)
1198
{
1199
        if (!doProcessing)
1200
                return;
1201
        qDebug() << "defineCharacterStyle";
1202
}
1203
 
1204
void RawPainter::openSpan(const librevenge::RVNGPropertyList &propList)
1205
{
1206
        if (!doProcessing)
1207
                return;
1208
        textCharStyle = textStyle.charStyle();
1209
        if (propList["fo:font-size"])
1210
        {
1211
                textCharStyle.setFontSize(valueAsPoint(propList["fo:font-size"]) * 10.0);
1212
                m_maxFontSize = qMax(m_maxFontSize, valueAsPoint(propList["fo:font-size"]));
1213
        }
1214
        if (propList["fo:color"])
1215
                textCharStyle.setFillColor(parseColor(QString(propList["fo:color"]->getStr().cstr())));
1216
        if (propList["style:font-name"])
1217
        {
1218
                QString fontVari = "";
1219
                if (propList["fo:font-weight"])
1220
                        fontVari = QString(propList["fo:font-weight"]->getStr().cstr());
1221
                QString fontName = QString(propList["style:font-name"]->getStr().cstr());
1222
                QString realFontName = constructFontName(fontName, fontVari);
1223
                textCharStyle.setFont((*m_Doc->AllFonts)[realFontName]);
1224
        }
1225
        StyleFlag styleEffects = textCharStyle.effects();
1226
        if (propList["style:text-underline-type"])
1227
                styleEffects |= ScStyle_Underline;
1228
        if (propList["style:text-position"])
1229
        {
1230
                if (propList["style:text-position"]->getStr() == "50% 67%")
1231
                        styleEffects |= ScStyle_Superscript;
1232
                else
1233
                        styleEffects |= ScStyle_Subscript;
1234
        }
1235
        textCharStyle.setFeatures(styleEffects.featureList());
1236
}
1237
 
1238
void RawPainter::closeSpan()
1239
{
1240
}
1241
 
1242
void RawPainter::openLink(const librevenge::RVNGPropertyList &propList)
1243
{
1244
        if (!doProcessing)
1245
                return;
1246
        qDebug() << "openLink";
1247
}
1248
 
1249
void RawPainter::closeLink()
1250
{
1251
        if (!doProcessing)
1252
                return;
1253
        qDebug() << "closeLink";
1254
}
1255
 
1256
void RawPainter::insertTab()
1257
{
1258
        if (!doProcessing)
1259
                return;
1260
        if (actTextItem == NULL)
1261
                return;
1262
        int posT = actTextItem->itemText.length();
1263
        actTextItem->itemText.insertChars(posT, SpecialChars::TAB);
1264
        actTextItem->itemText.applyStyle(posT, textStyle);
1265
}
1266
 
1267
void RawPainter::insertSpace()
1268
{
1269
        if (!doProcessing)
1270
                return;
1271
        if (actTextItem == NULL)
1272
                return;
1273
        int posT = actTextItem->itemText.length();
1274
        actTextItem->itemText.insertChars(posT, SpecialChars::BLANK);
1275
        actTextItem->itemText.applyStyle(posT, textStyle);
1276
}
1277
 
1278
void RawPainter::insertText(const librevenge::RVNGString &text)
1279
{
1280
        if (!doProcessing)
1281
                return;
1282
        if (actTextItem == NULL)
1283
                return;
1284
        if (lineSpSet)
1285
        {
1286
                textStyle.setLineSpacingMode(ParagraphStyle::FixedLineSpacing);
1287
                if (lineSpIsPT)
1288
                        textStyle.setLineSpacing(m_linespace);
1289
                else
1290
                        textStyle.setLineSpacing(m_maxFontSize * m_linespace);
1291
        }
1292
        else
1293
                textStyle.setLineSpacingMode(ParagraphStyle::AutomaticLineSpacing);
1294
        librevenge::RVNGString tempUTF8(text);
1295
        QString actText = QString(tempUTF8.cstr());
1296
        if (actTextItem)
1297
        {
1298
                int posC = actTextItem->itemText.length();
1299
                if (actText.count() > 0)
1300
                {
1301
                        actText.replace(QChar(10), SpecialChars::LINEBREAK);
1302
                        actText.replace(QChar(12), SpecialChars::FRAMEBREAK);
1303
                        actText.replace(QChar(30), SpecialChars::NBHYPHEN);
1304
                        actText.replace(QChar(160), SpecialChars::NBSPACE);
1305
                        QTextDocument texDoc;
1306
                        texDoc.setHtml(actText);
1307
                        actText = texDoc.toPlainText();
1308
                        actText = actText.trimmed();
1309
                        actTextItem->itemText.insertChars(posC, actText);
1310
                        actTextItem->itemText.applyStyle(posC, textStyle);
1311
                        actTextItem->itemText.applyCharStyle(posC, actText.length(), textCharStyle);
1312
                }
1313
        }
1314
}
1315
 
1316
void RawPainter::insertLineBreak()
1317
{
1318
        if (!doProcessing)
1319
                return;
1320
        if (actTextItem == NULL)
1321
                return;
1322
        int posT = actTextItem->itemText.length();
1323
        actTextItem->itemText.insertChars(posT, SpecialChars::LINEBREAK);
1324
        actTextItem->itemText.applyStyle(posT, textStyle);
1325
}
1326
 
1327
void RawPainter::insertField(const librevenge::RVNGPropertyList &propList)
1328
{
1329
        if (!doProcessing)
1330
                return;
1331
        qDebug() << "insertField";
1332
}
1333
 
1334
double RawPainter::valueAsPoint(const librevenge::RVNGProperty *prop)
1335
{
1336
        double value = 0.0;
1337
        QString str = QString(prop->getStr().cstr()).toLower();
1338
        if (str.endsWith("in"))
1339
                value = prop->getDouble() * 72.0;
1340
        else
1341
                value = prop->getDouble();
1342
        return value;
1343
}
1344
 
1345
void RawPainter::applyFill(PageItem* ite)
1346
{
1347
        if(isGradient)
1348
        {
1349
                QString gradMode = "normal";
1350
                if (m_style["libmspub:shade"])
1351
                        gradMode = QString(m_style["libmspub:shade"]->getStr().cstr());
1352
                else if (m_style["draw:style"])
1353
                        gradMode = QString(m_style["draw:style"]->getStr().cstr());
1354
                if ((gradMode == "normal") || (gradMode == "linear"))
1355
                {
1356
                        int angle = 0;
1357
                        if (m_style["draw:angle"])
1358
                                angle = qRound(m_style["draw:angle"]->getDouble());
1359
                        double h = ite->height();
1360
                        double w = ite->width();
1361
                        if (angle == 0)
1362
                                ite->setGradientVector(w / 2.0, h, w / 2.0, 0, 0, 0, 1, 0);
1363
                        else if (angle == -225)
1364
                                ite->setGradientVector(w, 0, 0, h, 0, 0, 1, 0);
1365
                        else if (angle == 45)
1366
                                ite->setGradientVector(w, h, 0, 0, 0, 0, 1, 0);
1367
                        else if (angle == 90)
1368
                                ite->setGradientVector(w, h / 2.0, 0, h / 2.0, 0, 0, 1, 0);
1369
                        else if (angle == 180)
1370
                                ite->setGradientVector(w / 2.0, 0, w / 2.0, h, 0, 0, 1, 0);
1371
                        else if (angle == 270)
1372
                                ite->setGradientVector(0, h / 2.0, w, h / 2.0, 0, 0, 1, 0);
1373
                        ite->fill_gradient = currentGradient;
1374
                        ite->GrType = 6;
1375
                }
1376
                else if (gradMode == "radial")
1377
                {
1378
                        double h = ite->height();
1379
                        double w = ite->width();
1380
                        double cx = 0.0;
1381
                        double cy = 0.0;
1382
                        if (m_style["svg:cx"])
1383
                                cx = m_style["svg:cx"]->getDouble();
1384
                        if (m_style["svg:cy"])
1385
                                cy = m_style["svg:cy"]->getDouble();
1386
                        ite->setGradientVector(cx, cy, w, h / 2.0, cx, cy, 1, 0);
1387
                        ite->fill_gradient = currentGradient;
1388
                        ite->GrType = 7;
1389
                }
1390
                else if (gradMode == "square")
1391
                {
1392
                        double cx = 0.0;
1393
                        double cy = 0.0;
1394
                        if (m_style["svg:cx"])
1395
                                cx = m_style["svg:cx"]->getDouble();
1396
                        if (m_style["svg:cy"])
1397
                                cy = m_style["svg:cy"]->getDouble();
1398
                        FPoint cp = FPoint(cx, cy);
1399
                        ite->setDiamondGeometry(FPoint(0, 0), FPoint(ite->width(), 0), FPoint(ite->width(), ite->height()), FPoint(0, ite->height()), cp);
1400
                        ite->fill_gradient.clearStops();
1401
                        QList<VColorStop*> colorStops = currentGradient.colorStops();
1402
                        for( int a = 0; a < colorStops.count() ; a++ )
1403
                        {
1404
                                ite->fill_gradient.addStop(colorStops[a]->color, 1.0 - colorStops[a]->rampPoint, colorStops[a]->midPoint, colorStops[a]->opacity, colorStops[a]->name, colorStops[a]->shade);
1405
                        }
1406
                        ite->GrType = 10;
1407
                }
1408
                else if (gradMode == "center")
1409
                {
1410
                        QString center = "top-left";
1411
                        FPoint cp = FPoint(0, 0);
1412
                        if (m_style["libmspub:shade-ref-point"])
1413
                                center = QString(m_style["libmspub:shade-ref-point"]->getStr().cstr());
1414
                        if (center == "top-left")
1415
                                cp = FPoint(0, 0);
1416
                        else if (center == "top-right")
1417
                                cp = FPoint(ite->width(), 0);
1418
                        else if (center == "bottom-left")
1419
                                cp = FPoint(0, ite->height());
1420
                        else if (center == "bottom-right")
1421
                                cp = FPoint(ite->width(), ite->height());
1422
                        ite->setDiamondGeometry(FPoint(0, 0), FPoint(ite->width(), 0), FPoint(ite->width(), ite->height()), FPoint(0, ite->height()), cp);
1423
                        ite->fill_gradient.clearStops();
1424
                        QList<VColorStop*> colorStops = currentGradient.colorStops();
1425
                        for( int a = 0; a < colorStops.count() ; a++ )
1426
                        {
1427
                                ite->fill_gradient.addStop(colorStops[a]->color, 1.0 - colorStops[a]->rampPoint, colorStops[a]->midPoint, colorStops[a]->opacity, colorStops[a]->name, colorStops[a]->shade);
1428
                        }
1429
                        ite->GrType = 10;
1430
                }
1431
                else if (gradMode == "shape")
1432
                {
1433
                        ite->meshGradientPatches.clear();
1434
                        FPoint center = FPoint(ite->width() / 2.0, ite->height() / 2.0);
1435
                        meshPoint cP;
1436
                        cP.resetTo(center);
1437
                        cP.transparency = gradColor2Trans;
1438
                        cP.shade = 100;
1439
                        cP.colorName = gradColor2Str;
1440
                        cP.color = gradColor2;
1441
                        for (int poi = 0; poi < ite->PoLine.size()-3; poi += 4)
1442
                        {
1443
                                meshGradientPatch patch;
1444
                                patch.BL = cP;
1445
                                patch.BR = cP;
1446
                                if (ite->PoLine.isMarker(poi))
1447
                                        continue;
1448
                                meshPoint tL;
1449
                                tL.resetTo(ite->PoLine.point(poi));
1450
                                tL.controlRight = ite->PoLine.point(poi + 1);
1451
                                tL.transparency = gradColor1Trans;
1452
                                tL.shade = 100;
1453
                                tL.colorName = gradColor1Str;
1454
                                tL.color = gradColor1;
1455
                                meshPoint tR;
1456
                                tR.resetTo(ite->PoLine.point(poi + 2));
1457
                                tR.controlLeft = ite->PoLine.point(poi + 3);
1458
                                tR.transparency = gradColor1Trans;
1459
                                tR.shade = 100;
1460
                                tR.colorName = gradColor1Str;
1461
                                tR.color = gradColor1;
1462
                                patch.TL = tL;
1463
                                patch.TR = tR;
1464
                                ite->meshGradientPatches.append(patch);
1465
                        }
1466
                        ite->GrType = 12;
1467
                }
1468
        }
1469
        if(m_style["draw:fill"] && m_style["draw:fill"]->getStr() == "bitmap")
1470
        {
1471
                QByteArray ba(m_style["draw:fill-image"]->getStr().cstr());
1472
                QByteArray imageData = QByteArray::fromBase64(ba);
1473
                QString imgExt = "";
1474
                if (m_style["librevenge:mime-type"]->getStr() == "image/png")
1475
                        imgExt = "png";
1476
                else if (m_style["librevenge:mime-type"]->getStr() == "image/jpeg")
1477
                        imgExt = "jpg";
1478
                else if (m_style["librevenge:mime-type"]->getStr() == "image/bmp")
1479
                        imgExt = "bmp";
1480
                else if (m_style["librevenge:mime-type"]->getStr() == "image/pict")
1481
                        imgExt = "pict";
1482
                else if (m_style["librevenge:mime-type"]->getStr() == "image/tiff")
1483
                        imgExt = "tif";
1484
                if (!imgExt.isEmpty())
1485
                {
1486
                        QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + QString("/scribus_temp_%1_XXXXXX.").arg(fileType) + imgExt);
1487
                        tempFile->setAutoRemove(false);
1488
                        if (tempFile->open())
1489
                        {
1490
                                tempFile->write(imageData);
1491
                                QString fileName = getLongPathName(tempFile->fileName());
1492
                                tempFile->close();
1493
                                ScPattern pat = ScPattern();
1494
                                pat.setDoc(m_Doc);
1495
                                int z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, 0, 0, 1, 1, 0, CommonStrings::None, CommonStrings::None, true);
1496
                                PageItem* newItem = m_Doc->Items->at(z);
1497
                                if (m_style["draw:red"] && m_style["draw:green"] && m_style["draw:blue"])
1498
                                {
1499
                                        int r = qRound(m_style["draw:red"]->getDouble() * 255);
1500
                                        int g = qRound(m_style["draw:green"]->getDouble() * 255);
1501
                                        int b = qRound(m_style["draw:blue"]->getDouble() * 255);
1502
                                        QString colVal = QString("#%1%2%3").arg(r, 2, 16, QLatin1Char('0')).arg(g, 2, 16, QLatin1Char('0')).arg(b, 2, 16, QLatin1Char('0'));
1503
                                        QString efVal = parseColor(colVal);
1504
                                        efVal += "\n";
1505
                                        struct ImageEffect ef;
1506
                                        efVal += "100";
1507
                                        ef.effectCode = ScImage::EF_COLORIZE;
1508
                                        ef.effectParameters = efVal;
1509
                                        ite->effectsInUse.append(ef);
1510
                                }
1511
                                m_Doc->loadPict(fileName, newItem);
1512
                                m_Doc->Items->takeAt(z);
1513
                                newItem->isInlineImage = true;
1514
                                newItem->isTempFile = true;
1515
                                pat.width = newItem->pixm.qImage().width();
1516
                                pat.height = newItem->pixm.qImage().height();
1517
                                pat.scaleX = (72.0 / newItem->pixm.imgInfo.xres) * newItem->pixm.imgInfo.lowResScale;
1518
                                pat.scaleY = (72.0 / newItem->pixm.imgInfo.xres) * newItem->pixm.imgInfo.lowResScale;
1519
                                pat.pattern = newItem->pixm.qImage().copy();
1520
                                newItem->setWidth(pat.pattern.width());
1521
                                newItem->setHeight(pat.pattern.height());
1522
                                newItem->SetRectFrame();
1523
                                newItem->gXpos = 0.0;
1524
                                newItem->gYpos = 0.0;
1525
                                newItem->gWidth = pat.pattern.width();
1526
                                newItem->gHeight = pat.pattern.height();
1527
                                pat.items.append(newItem);
1528
                                QString patternName = "Pattern_"+ite->itemName();
1529
                                patternName = patternName.trimmed().simplified().replace(" ", "_");
1530
                                m_Doc->addPattern(patternName, pat);
1531
                                importedPatterns->append(patternName);
1532
                                ite->setPattern(patternName);
1533
                                ite->GrType = 8;
1534
                        }
1535
                        delete tempFile;
1536
                }
1537
        }
1538
}
1539
 
1540
#else
1541
RawPainter::RawPainter(ScribusDoc* Doc, double x, double y, double w, double h, int iflags, QList<PageItem*> *Elem, QStringList *iColors, QStringList *iPatterns, Selection* tSel, QString fTyp): libwpg::WPGPaintInterface()
1542
{
1543
        m_Doc = Doc;
1544
        baseX = x;
1545
        baseY = y;
1546
        docWidth = w;
1547
        docHeight = h;
1548
        importerFlags = iflags;
1549
        Elements = Elem;
1550
        importedColors = iColors;
1551
        importedPatterns = iPatterns;
1552
        tmpSel = tSel;
1553
        CurrColorFill = "Black";
1554
        CurrFillShade = 100.0;
1555
        CurrColorStroke = "Black";
1556
        CurrStrokeShade = 100.0;
1557
        CurrStrokeTrans = 0.0;
1558
        CurrFillTrans = 0.0;
1559
        Coords.resize(0);
1560
        Coords.svgInit();
1561
        LineW = 1.0;
1562
        lineJoin = Qt::MiterJoin;
1563
        lineEnd = Qt::FlatCap;
1564
        fillrule = true;
1565
        gradientAngle = 0.0;
1566
        isGradient = false;
1567
        lineSpSet = false;
1568
        currentGradient = VGradient(VGradient::linear);
1569
        currentGradient.clearStops();
1570
        currentGradient.setRepeatMethod( VGradient::none );
1571
        dashArray.clear();
1572
        firstPage = true;
1573
        actPage = 0;
1574
        actTextItem = NULL;
1575
        doProcessing = true;
1576
        fileType = fTyp;
1577
}
1578
 
1579
void RawPainter::startGraphics(const ::WPXPropertyList &propList)
1580
{
1581
        if (propList["svg:width"])
1582
                docWidth = valueAsPoint(propList["svg:width"]);
1583
        if (propList["svg:height"])
1584
                docHeight = valueAsPoint(propList["svg:height"]);
1585
        if (importerFlags & LoadSavePlugin::lfCreateDoc)
1586
        {
1587
                if (!firstPage)
1588
                {
1589
                        m_Doc->addPage(actPage);
1590
                        m_Doc->setActiveLayer(baseLayer);
1591
                }
1592
                else
1593
                        baseLayer = m_Doc->activeLayerName();
1594
                m_Doc->setPageSize("Custom");
1595
                m_Doc->currentPage()->setInitialWidth(docWidth);
1596
                m_Doc->currentPage()->setInitialHeight(docHeight);
1597
                m_Doc->currentPage()->setWidth(docWidth);
1598
                m_Doc->currentPage()->setHeight(docHeight);
1599
                m_Doc->currentPage()->MPageNam = CommonStrings::trMasterPageNormal;
1600
                m_Doc->currentPage()->m_pageSize = "Custom";
1601
                m_Doc->reformPages(true);
1602
                baseX = m_Doc->currentPage()->xOffset();
1603
                baseY = m_Doc->currentPage()->yOffset();
1604
        }
1605
        firstPage = false;
1606
        actPage++;
1607
}
1608
 
1609
void RawPainter::endGraphics()
1610
{
1611
        if (importerFlags & LoadSavePlugin::lfCreateThumbnail)
1612
                doProcessing = false;
1613
//      qDebug() << "endGraphics";
1614
//  printf("RawPainter::endGraphics\n");
1615
}
1616
 
1617
void RawPainter::startLayer(const ::WPXPropertyList &propList)
1618
{
1619
        if (!doProcessing)
1620
                return;
1621
        FPointArray clip;
1622
        if (propList["svg:clip-path"])
1623
        {
1624
                QString svgString = QString(propList["svg:clip-path"]->getStr().cstr());
1625
                clip.resize(0);
1626
                clip.svgInit();
1627
                svgString.replace(",", ".");
1628
                clip.parseSVG(svgString);
1629
                QTransform m;
1630
                m.scale(72.0, 72.0);
1631
                clip.map(m);
1632
        }
1633
        QList<PageItem*> gElements;
1634
        groupEntry gr;
1635
        gr.clip = clip.copy();
1636
        gr.Items = gElements;
1637
        groupStack.push(gr);
1638
}
1639
 
1640
void RawPainter::endLayer()
1641
{
1642
        if (!doProcessing)
1643
                return;
1644
        if (groupStack.count() != 0)
1645
        {
1646
                PageItem *ite;
1647
                groupEntry gr = groupStack.pop();
1648
                QList<PageItem*> gElements = gr.Items;
1649
                tmpSel->clear();
1650
                if (gElements.count() > 0)
1651
                {
1652
                        bool groupClip = true;
1653
                        for (int dre = 0; dre < gElements.count(); ++dre)
1654
                        {
1655
                                tmpSel->addItem(gElements.at(dre), true);
1656
                                Elements->removeAll(gElements.at(dre));
1657
                                if (gElements.at(dre)->hasSoftShadow())
1658
                                        groupClip = false;
1659
                        }
1660
                        ite = m_Doc->groupObjectsSelection(tmpSel);
1661
                        ite->setGroupClipping(groupClip);
1662
                        ite->setTextFlowMode(PageItem::TextFlowUsesBoundingBox);
1663
                        if (!gr.clip.isEmpty())
1664
                        {
1665
                                double oldX = ite->xPos();
1666
                                double oldY = ite->yPos();
1667
                                double oldW = ite->width();
1668
                                double oldH = ite->height();
1669
                                double oldgW = ite->groupWidth;
1670
                                double oldgH = ite->groupHeight;
1671
                                ite->PoLine = gr.clip.copy();
1672
                                ite->PoLine.translate(baseX, baseY);
1673
                                FPoint xy = getMinClipF(&ite->PoLine);
1674
                                ite->setXYPos(xy.x(), xy.y(), true);
1675
                                ite->PoLine.translate(-xy.x(), -xy.y());
1676
                                FPoint wh = getMaxClipF(&ite->PoLine);
1677
                                ite->setWidthHeight(wh.x(),wh.y());
1678
                                ite->groupWidth = oldgW * (ite->width() / oldW);
1679
                                ite->groupHeight = oldgH * (ite->height() / oldH);
1680
                                double dx = (ite->xPos() - oldX) / (ite->width() / ite->groupWidth);
1681
                                double dy = (ite->yPos() - oldY) / (ite->height() / ite->groupHeight);
1682
                                for (int em = 0; em < ite->groupItemList.count(); ++em)
1683
                                {
1684
                                        PageItem* embedded = ite->groupItemList.at(em);
1685
                                        embedded->moveBy(-dx, -dy, true);
1686
                                        m_Doc->setRedrawBounding(embedded);
1687
                                        embedded->OwnPage = m_Doc->OnPage(embedded);
1688
                                }
1689
                                ite->ClipEdited = true;
1690
                                ite->OldB2 = ite->width();
1691
                                ite->OldH2 = ite->height();
1692
                                ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
1693
                                ite->updateGradientVectors();
1694
                        }
1695
                        Elements->append(ite);
1696
                        if (groupStack.count() != 0)
1697
                                groupStack.top().Items.append(ite);
1698
                }
1699
                tmpSel->clear();
1700
        }
1701
}
1702
 
1703
void RawPainter::startEmbeddedGraphics(const ::WPXPropertyList &propList)
1704
{
1705
        if (!doProcessing)
1706
                return;
1707
        qDebug() << "startEmbeddedGraphics";
1708
//  printf("RawPainter::startEmbeddedGraphics (%s)\n", getPropString(propList).cstr());
1709
}
1710
 
1711
void RawPainter::endEmbeddedGraphics()
1712
{
1713
        if (!doProcessing)
1714
                return;
1715
//      qDebug() << "endEmbeddedGraphics";
1716
//  printf("RawPainter::endEmbeddedGraphics \n");
1717
}
1718
 
1719
void RawPainter::setStyle(const ::WPXPropertyList &propList, const ::WPXPropertyListVector &gradient)
1720
{
1721
        if (!doProcessing)
1722
                return;
1723
        m_style.clear();
1724
        m_style = propList;
1725
        isGradient = false;
1726
        if(propList["draw:fill"] && propList["draw:fill"]->getStr() == "none")
1727
                CurrColorFill = CommonStrings::None;
1728
        else if(propList["draw:fill"] && propList["draw:fill"]->getStr() == "solid")
1729
        {
1730
                if (propList["draw:fill-color"])
1731
                {
1732
                        CurrColorFill = parseColor(QString(propList["draw:fill-color"]->getStr().cstr()));
1733
                        if(propList["draw:opacity"])
1734
                                CurrFillTrans = 1.0 - qMin(1.0, qMax(fromPercentage(QString(propList["draw:opacity"]->getStr().cstr())), 0.0));
1735
                }
1736
        }
1737
        if(propList["draw:fill"] && propList["draw:fill"]->getStr() == "gradient")
1738
        {
1739
                double angle = 0;
1740
                if (propList["draw:angle"])
1741
                        angle = propList["draw:angle"]->getDouble();
1742
                if (gradient.count() > 1)
1743
                {
1744
                        double opacity = 1.0;
1745
                        currentGradient = VGradient(VGradient::linear);
1746
                        currentGradient.clearStops();
1747
                        currentGradient.setRepeatMethod( VGradient::none );
1748
                        double dr = 1.0 / static_cast<double>(gradient.count());
1749
                        for (unsigned c = 0; c < gradient.count(); c++)
1750
                        {
1751
                                WPXPropertyList grad = gradient[c];
1752
                                if (grad["svg:stop-color"])
1753
                                {
1754
                                        QString stopName = parseColor(QString(grad["svg:stop-color"]->getStr().cstr()));
1755
                                        double rampPoint = dr * c;
1756
                                        if(grad["svg:offset"])
1757
                                                rampPoint = fromPercentage(QString(grad["svg:offset"]->getStr().cstr()));
1758
                                        const ScColor& gradC = m_Doc->PageColors[stopName];
1759
                                        if(grad["svg:stop-opacity"])
1760
                                                opacity = qMin(1.0, qMax(fromPercentage(QString(grad["svg:stop-opacity"]->getStr().cstr())), 0.0));
1761
                                        currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), rampPoint, 0.5, opacity, stopName, 100 );
1762
                                        if (c == 0)
1763
                                        {
1764
                                                gradColor1Str = stopName;
1765
                                                gradColor1 = ScColorEngine::getRGBColor(gradC, m_Doc);
1766
                                                gradColor1Trans = opacity;
1767
                                        }
1768
                                        else
1769
                                        {
1770
                                                gradColor2Str = stopName;
1771
                                                gradColor2 = ScColorEngine::getRGBColor(gradC, m_Doc);
1772
                                                gradColor2Trans = opacity;
1773
                                        }
1774
                                }
1775
                        }
1776
                        if (currentGradient.Stops() > 1)
1777
                                isGradient = true;
1778
                }
1779
                else
1780
                {
1781
                        gradColor1Str = "Black";
1782
                        gradColor2Str = "Black";
1783
                        if (propList["draw:start-color"])
1784
                                gradColor2Str = parseColor(QString(propList["draw:start-color"]->getStr().cstr()));
1785
                        if (propList["draw:end-color"])
1786
                                gradColor1Str = parseColor(QString(propList["draw:end-color"]->getStr().cstr()));
1787
                        double opacity = 1.0;
1788
                        currentGradient = VGradient(VGradient::linear);
1789
                        currentGradient.clearStops();
1790
                        currentGradient.setRepeatMethod( VGradient::none );
1791
 
1792
                        if (propList["draw:style"])
1793
                        {
1794
                                if (QString(propList["draw:style"]->getStr().cstr()) == "axial")
1795
                                {
1796
                                        currentGradient.addStop( ScColorEngine::getRGBColor(m_Doc->PageColors[gradColor1Str], m_Doc), 0.0, 0.5, opacity, gradColor1Str, 100 );
1797
                                        currentGradient.addStop( ScColorEngine::getRGBColor(m_Doc->PageColors[gradColor2Str], m_Doc), 0.5, 0.5, opacity, gradColor2Str, 100 );
1798
                                        currentGradient.addStop( ScColorEngine::getRGBColor(m_Doc->PageColors[gradColor1Str], m_Doc), 1.0, 0.5, opacity, gradColor1Str, 100 );
1799
                                }
1800
                                else
1801
                                {
1802
                                        currentGradient.addStop( ScColorEngine::getRGBColor(m_Doc->PageColors[gradColor1Str], m_Doc), 0.0, 0.5, opacity, gradColor1Str, 100 );
1803
                                        currentGradient.addStop( ScColorEngine::getRGBColor(m_Doc->PageColors[gradColor2Str], m_Doc), 1.0, 0.5, opacity, gradColor2Str, 100 );
1804
                                }
1805
                                isGradient = true;
1806
                        }
1807
                }
1808
        }
1809
        if(propList["svg:fill-rule"])
1810
        {
1811
                if (QString(propList["svg:fill-rule"]->getStr().cstr()) == "nonzero")
1812
                        fillrule = false;
1813
                else
1814
                        fillrule = true;
1815
        }
1816
        if (propList["svg:stroke-width"])
1817
                LineW = valueAsPoint(propList["svg:stroke-width"]);
1818
        if (propList["draw:stroke"])
1819
        {
1820
                if (propList["draw:stroke"]->getStr() == "none")
1821
                        CurrColorStroke = CommonStrings::None;
1822
                else if ((propList["draw:stroke"]->getStr() == "solid") || (propList["draw:stroke"]->getStr() == "dash"))
1823
                {
1824
                        if (propList["svg:stroke-color"])
1825
                        {
1826
                                CurrColorStroke = parseColor(QString(propList["svg:stroke-color"]->getStr().cstr()));
1827
                                if(propList["svg:stroke-opacity"])
1828
                                        CurrStrokeTrans = 1.0 - qMin(1.0, qMax(fromPercentage(QString(propList["svg:stroke-opacity"]->getStr().cstr())), 0.0));
1829
                        }
1830
                        if (propList["draw:stroke"]->getStr() == "dash")
1831
                        {
1832
                                dashArray.clear();
1833
                                double gap = LineW;
1834
                                if (propList["draw:distance"])
1835
                                        gap = valueAsPoint(propList["draw:distance"]);
1836
                                int dots1 = 0;
1837
                                if (propList["draw:dots1"])
1838
                                        dots1 = propList["draw:dots1"]->getInt();
1839
                                double dots1len = LineW;
1840
                                if (propList["draw:dots1-length"])
1841
                                        dots1len = valueAsPoint(propList["draw:dots1-length"]);
1842
                                int dots2 = 0;
1843
                                if (propList["draw:dots2"])
1844
                                        dots2 = propList["draw:dots2"]->getInt();
1845
                                double dots2len = LineW;
1846
                                if (propList["draw:dots2-length"])
1847
                                        dots2len = valueAsPoint(propList["draw:dots2-length"]);
1848
                                for (int i = 0; i < dots1; i++)
1849
                                {
1850
                                        dashArray << qMax(dots1len, 0.1) << qMax(gap, 0.1);
1851
                                }
1852
                                for (int j = 0; j < dots2; j++)
1853
                                {
1854
                                        dashArray << qMax(dots2len, 0.1) << qMax(gap, 0.1);
1855
                                }
1856
                        }
1857
                        else
1858
                                dashArray.clear();
1859
                }
1860
        }
1861
        if (propList["svg:stroke-linecap"])
1862
        {
1863
                QString params = QString(propList["svg:stroke-linecap"]->getStr().cstr());
1864
                if( params == "butt" )
1865
                        lineEnd = Qt::FlatCap;
1866
                else if( params == "round" )
1867
                        lineEnd = Qt::RoundCap;
1868
                else if( params == "square" )
1869
                        lineEnd = Qt::SquareCap;
1870
                else
1871
                        lineEnd = Qt::FlatCap;
1872
        }
1873
        if (propList["svg:stroke-linejoin"])
1874
        {
1875
                QString params = QString(propList["svg:stroke-linejoin"]->getStr().cstr());
1876
                if( params == "miter" )
1877
                        lineJoin = Qt::MiterJoin;
1878
                else if( params == "round" )
1879
                        lineJoin = Qt::RoundJoin;
1880
                else if( params == "bevel" )
1881
                        lineJoin = Qt::BevelJoin;
1882
                else
1883
                        lineJoin = Qt::MiterJoin;
1884
        }
1885
//      qDebug() << "setStyle";
1886
//  printf("RawPainter::setStyle(%s, gradient: (%s))\n", getPropString(propList).cstr(), getPropString(gradient).cstr());
1887
}
1888
 
1889
void RawPainter::drawRectangle(const ::WPXPropertyList &propList)
1890
{
1891
        if (!doProcessing)
1892
                return;
1893
        if (propList["svg:x"] && propList["svg:y"] && propList["svg:width"] && propList["svg:height"])
1894
        {
1895
                double x = valueAsPoint(propList["svg:x"]);
1896
                double y = valueAsPoint(propList["svg:y"]);
1897
                double w = valueAsPoint(propList["svg:width"]);
1898
                double h = valueAsPoint(propList["svg:height"]);
1899
                int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, baseX + x, baseY + y, w, h, LineW, CurrColorFill, CurrColorStroke, true);
1900
                PageItem *ite = m_Doc->Items->at(z);
1901
                finishItem(ite);
1902
                applyFill(ite);
1903
                if (CurrColorFill != CommonStrings::None)
1904
                        applyShadow(ite);
1905
        }
1906
//      qDebug() << "drawRectangle";
1907
//  printf("RawPainter::drawRectangle (%s)\n", getPropString(propList).cstr());
1908
}
1909
 
1910
void RawPainter::drawEllipse(const ::WPXPropertyList &propList)
1911
{
1912
        if (!doProcessing)
1913
                return;
1914
        if (propList["svg:x"] && propList["svg:y"] && propList["svg:width"] && propList["svg:height"])
1915
        {
1916
                double x = valueAsPoint(propList["svg:x"]);
1917
                double y = valueAsPoint(propList["svg:y"]);
1918
                double w = valueAsPoint(propList["svg:width"]);
1919
                double h = valueAsPoint(propList["svg:height"]);
1920
                int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Ellipse, baseX + x, baseY + y, w, h, LineW, CurrColorFill, CurrColorStroke, true);
1921
                PageItem *ite = m_Doc->Items->at(z);
1922
                finishItem(ite);
1923
                applyFill(ite);
1924
                if (CurrColorFill != CommonStrings::None)
1925
                        applyShadow(ite);
1926
        }
1927
//      qDebug() << "drawEllipse";
1928
//  printf("RawPainter::drawEllipse (%s)\n", getPropString(propList).cstr());
1929
}
1930
 
1931
void RawPainter::drawPolyline(const ::WPXPropertyListVector &vertices)
1932
{
1933
        if (!doProcessing)
1934
                return;
1935
        Coords.resize(0);
1936
        Coords.svgInit();
1937
        PageItem *ite;
1938
        Coords.svgMoveTo(valueAsPoint(vertices[0]["svg:x"]), valueAsPoint(vertices[0]["svg:y"]));
1939
        for(unsigned i = 1; i < vertices.count(); i++)
1940
        {
1941
                Coords.svgLineTo(valueAsPoint(vertices[i]["svg:x"]), valueAsPoint(vertices[i]["svg:y"]));
1942
        }
1943
        if (Coords.size() > 0)
1944
        {
1945
                int z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColorStroke, true);
1946
                ite = m_Doc->Items->at(z);
1947
                ite->PoLine = Coords.copy();
1948
                finishItem(ite);
1949
                applyArrows(ite);
1950
        }
1951
}
1952
 
1953
void RawPainter::drawPolygon(const ::WPXPropertyListVector &vertices)
1954
{
1955
        if (!doProcessing)
1956
                return;
1957
        if(vertices.count() < 2)
1958
                return;
1959
        Coords.resize(0);
1960
        Coords.svgInit();
1961
        PageItem *ite;
1962
        int z;
1963
        Coords.svgMoveTo(valueAsPoint(vertices[0]["svg:x"]), valueAsPoint(vertices[0]["svg:y"]));
1964
        for(unsigned i = 1; i < vertices.count(); i++)
1965
        {
1966
                Coords.svgLineTo(valueAsPoint(vertices[i]["svg:x"]), valueAsPoint(vertices[i]["svg:y"]));
1967
        }
1968
        Coords.svgClosePath();
1969
        if (Coords.size() > 0)
1970
        {
1971
                if(m_style["draw:fill"] && m_style["draw:fill"]->getStr() == "bitmap" && m_style["style:repeat"] && m_style["style:repeat"]->getStr() == "stretch")
1972
                {
1973
                  if (m_style["draw:fill-image"] && m_style["libwpg:mime-type"])
1974
                  {
1975
                          QByteArray ba(m_style["draw:fill-image"]->getStr().cstr());
1976
                          QByteArray imageData = QByteArray::fromBase64(ba);
1977
                          QString imgExt = "";
1978
                          if (m_style["libwpg:mime-type"]->getStr() == "image/png")
1979
                                  imgExt = "png";
1980
                          else if (m_style["libwpg:mime-type"]->getStr() == "image/jpeg")
1981
                                  imgExt = "jpg";
1982
                          else if (m_style["libwpg:mime-type"]->getStr() == "image/bmp")
1983
                                  imgExt = "bmp";
1984
                          else if (m_style["libwpg:mime-type"]->getStr() == "image/pict")
1985
                                  imgExt = "pict";
1986
                          else if (m_style["libwpg:mime-type"]->getStr() == "image/tiff")
1987
                                  imgExt = "tif";
1988
                          if (!imgExt.isEmpty())
1989
                          {
1990
                                  z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
1991
                                  ite = m_Doc->Items->at(z);
1992
                                  ite->PoLine = Coords.copy();
1993
                                  finishItem(ite);
1994
                                  insertImage(ite, imgExt, imageData);
1995
                          }
1996
                          else if (m_style["libwpg:mime-type"]->getStr() == "image/wmf")
1997
                          {
1998
                                  imgExt = "wmf";
1999
                                  QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + QString("/scribus_temp_%1_XXXXXX.").arg(fileType) + imgExt);
2000
                                  if (tempFile->open())
2001
                                  {
2002
                                          tempFile->write(imageData);
2003
                                          QString fileName = getLongPathName(tempFile->fileName());
2004
                                          tempFile->close();
2005
                                          FileLoader *fileLoader = new FileLoader(fileName);
2006
                                          int testResult = fileLoader->testFile();
2007
                                          delete fileLoader;
2008
                                          if (testResult != -1)
2009
                                          {
2010
                                                  const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
2011
                                                  if( fmt )
2012
                                                  {
2013
                                                          fmt->setupTargets(m_Doc, 0, 0, 0, &(PrefsManager::instance()->appPrefs.fontPrefs.AvailFonts));
2014
                                                          fmt->loadFile(fileName, LoadSavePlugin::lfUseCurrentPage|LoadSavePlugin::lfInteractive|LoadSavePlugin::lfScripted);
2015
                                                          if (m_Doc->m_Selection->count() > 0)
2016
                                                          {
2017
                                                                  ite = m_Doc->groupObjectsSelection();
2018
                                                                  double rot = 0;
2019
                                                                  if (m_style["libwpg:rotate"])
2020
                                                                          rot = m_style["libwpg:rotate"]->getDouble();
2021
                                                                  QPainterPath ba = Coords.toQPainterPath(true);
2022
                                                                  QRectF baR = ba.boundingRect();
2023
                                                                  if (rot != 0)
2024
                                                                  {
2025
                                                                          QTransform mm;
2026
                                                                          mm.translate(baR.x(), baR.y());
2027
                                                                          mm.translate(baR.width() / 2.0, baR.height() / 2.0);
2028
                                                                          mm.rotate(rot);
2029
                                                                          mm.translate(-baR.width() / 2.0, -baR.height() / 2.0);
2030
                                                                          mm.translate(-baR.x(), -baR.y());
2031
                                                                          ba = mm.map(ba);
2032
                                                                          baR = ba.boundingRect();
2033
                                                                          ite->setXYPos(baseX + baR.x(), baseY + baR.y(), true);
2034
                                                                          ite->setWidthHeight(baR.width(), baR.height(), true);
2035
                                                                          Coords.fromQPainterPath(ba, true);
2036
                                                                          FPoint tp2(getMinClipF(&Coords));
2037
                                                                          Coords.translate(-tp2.x(), -tp2.y());
2038
                                                                          ite->PoLine = Coords.copy();
2039
                                                                          int rm = m_Doc->RotMode();
2040
                                                                          m_Doc->RotMode(2);
2041
                                                                          m_Doc->RotateItem(-rot, ite);
2042
                                                                          m_Doc->RotMode(rm);
2043
                                                                  }
2044
                                                                  else
2045
                                                                  {
2046
                                                                          ite->setXYPos(baseX + baR.x(), baseY + baR.y(), true);
2047
                                                                          ite->setWidthHeight(baR.width(), baR.height(), true);
2048
                                                                          FPoint tp2(getMinClipF(&Coords));
2049
                                                                          Coords.translate(-tp2.x(), -tp2.y());
2050
                                                                          ite->PoLine = Coords.copy();
2051
                                                                  }
2052
                                                                  finishItem(ite);
2053
                                                                  if (m_style["draw:red"] && m_style["draw:green"] && m_style["draw:blue"])
2054
                                                                  {
2055
                                                                          int r = qRound(m_style["draw:red"]->getDouble() * 255);
2056
                                                                          int g = qRound(m_style["draw:green"]->getDouble() * 255);
2057
                                                                          int b = qRound(m_style["draw:blue"]->getDouble() * 255);
2058
                                                                          QString colVal = QString("#%1%2%3").arg(r, 2, 16, QLatin1Char('0')).arg(g, 2, 16, QLatin1Char('0')).arg(b, 2, 16, QLatin1Char('0'));
2059
                                                                          QString efVal = parseColor(colVal);
2060
                                                                          recolorItem(ite, efVal);
2061
                                                                  }
2062
                                                          }
2063
                                                  }
2064
                                          }
2065
                                  }
2066
                                  delete tempFile;
2067
                          }
2068
                  }
2069
                }
2070
                else
2071
                {
2072
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
2073
                        ite = m_Doc->Items->at(z);
2074
                        ite->PoLine = Coords.copy();
2075
                        finishItem(ite);
2076
                        applyFill(ite);
2077
                }
2078
                applyFlip(ite);
2079
                if (CurrColorFill != CommonStrings::None)
2080
                        applyShadow(ite);
2081
        }
2082
}
2083
 
2084
void RawPainter::drawPath(const ::WPXPropertyListVector &path)
2085
{
2086
        if (!doProcessing)
2087
                return;
2088
        bool isClosed = false;
2089
        QString svgString = "";
2090
        for(unsigned i=0; i < path.count(); i++)
2091
        {
2092
                WPXPropertyList propList = path[i];
2093
                if (propList["libwpg:path-action"] && propList["libwpg:path-action"]->getStr() == "M")
2094
                        svgString += QString("M %1 %2 ").arg(valueAsPoint(propList["svg:x"])).arg(valueAsPoint(propList["svg:y"]));
2095
                else if (propList["libwpg:path-action"] && propList["libwpg:path-action"]->getStr() == "L")
2096
                        svgString += QString("L %1 %2 ").arg(valueAsPoint(propList["svg:x"])).arg(valueAsPoint(propList["svg:y"]));
2097
                else if (propList["libwpg:path-action"] && propList["libwpg:path-action"]->getStr() == "C")
2098
                        svgString += QString("C %1 %2 %3 %4 %5 %6 ").arg(valueAsPoint(propList["svg:x1"])).arg(valueAsPoint(propList["svg:y1"])).arg(valueAsPoint(propList["svg:x2"])).arg(valueAsPoint(propList[