Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
16682 jghali 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
 
8
#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 <QDebug>
17
 
18
#include <cstdlib>
19
 
20
#include "commonstrings.h"
21
#include "ui/customfdialog.h"
22
#include "importwpg.h"
23
#include "loadsaveplugin.h"
24
#include "ui/missing.h"
25
#include "ui/multiprogressdialog.h"
26
#include "pagesize.h"
27
#include "prefscontext.h"
28
#include "prefsfile.h"
29
#include "prefsmanager.h"
30
#include "prefstable.h"
31
#include "ui/propertiespalette.h"
32
#include "rawimage.h"
33
#include "scclocale.h"
34
#include "sccolorengine.h"
35
#include "scconfig.h"
36
#include "scmimedata.h"
37
#include "scpaths.h"
38
#include "scpattern.h"
39
#include "scribus.h"
40
#include "scribusXml.h"
41
#include "scribuscore.h"
42
#include "sctextstream.h"
43
#include "selection.h"
44
#include "undomanager.h"
45
#include "util.h"
46
#include "util_formats.h"
47
#include "util_icon.h"
48
#include "util_math.h"
49
#include <stdio.h>
50
#include "third_party/wpg/WPGStreamImplementation.h"
51
 
52
extern SCRIBUS_API ScribusQApp * ScQApp;
53
 
54
ScrPainter::ScrPainter(): libwpg::WPGPaintInterface()
55
{
56
}
57
 
58
void ScrPainter::startGraphics(double width, double height)
59
{
60
        CurrColorFill = "Black";
61
        CurrFillShade = 100.0;
62
        CurrColorStroke = "Black";
63
        CurrStrokeShade = 100.0;
64
        CurrStrokeTrans = 0.0;
65
        CurrFillTrans = 0.0;
66
        Coords.resize(0);
67
        Coords.svgInit();
68
        LineW = 1.0;
69
        lineJoin = Qt::MiterJoin;
70
        lineEnd = Qt::FlatCap;
71
        fillrule = true;
72
        gradientAngle = 0.0;
73
        isGradient = false;
74
        fillSet = false;
75
        strokeSet = false;
76
        currentGradient = VGradient(VGradient::linear);
77
        currentGradient.clearStops();
78
        currentGradient.setRepeatMethod( VGradient::none );
79
        dashArray.clear();
80
        if (flags & LoadSavePlugin::lfCreateDoc)
81
        {
82
                m_Doc->setPage(72 * width, 72 * height, 0, 0, 0, 0, 0, 0, false, false);
83
                if (width > height)
84
                        m_Doc->setPageOrientation(1);
85
                else
86
                        m_Doc->setPageOrientation(0);
87
                m_Doc->setPageSize("Custom");
88
                m_Doc->changePageMargins(0, 0, 0, 0, 72 * height, 72 * width, 72 * height, 72 * width, m_Doc->pageOrientation(), m_Doc->pageSize(), m_Doc->currentPage()->pageNr(), 0);
89
        }
90
        firstLayer = true;
91
}
92
 
93
void ScrPainter::endGraphics()
94
{
95
}
96
 
97
void ScrPainter::startLayer(unsigned int id)
98
{
99
        if (flags & LoadSavePlugin::lfCreateDoc)
100
        {
101
                if (!firstLayer)
102
                        m_Doc->addLayer(QString("Layer %1").arg(id), true);
103
                firstLayer = false;
104
        }
105
}
106
 
107
void ScrPainter::endLayer(unsigned int id)
108
{
109
}
110
 
111
void ScrPainter::setPen(const libwpg::WPGPen& pen)
112
{
113
        LineW = 72 * pen.width;
114
        ScColor tmp;
115
        ColorList::Iterator it;
116
        CurrColorStroke = "Black";
117
        CurrStrokeShade = 100.0;
118
        int Rc, Gc, Bc;
119
        Rc = pen.foreColor.red;
120
        Gc = pen.foreColor.green;
121
        Bc = pen.foreColor.blue;
122
        tmp.setColorRGB(Rc, Gc, Bc);
123
        tmp.setSpotColor(false);
124
        tmp.setRegistrationColor(false);
125
        QString newColorName = "FromWPG"+tmp.name();
126
        QString fNam = m_Doc->PageColors.tryAddColor(newColorName, tmp);
127
        if (fNam == newColorName)
128
                importedColors.append(newColorName);
129
        CurrColorStroke = fNam;
130
        CurrStrokeTrans = pen.foreColor.alpha / 255.0;
131
        if(!pen.solid)
132
        {
133
                dashArray.clear();
134
                for(unsigned i = 0; i < pen.dashArray.count(); i++)
135
                {
136
                        dashArray.append(pen.dashArray.at(i)*LineW);
137
                }
138
        }
139
        switch (pen.joinstyle)
140
        {
141
                case 1:
142
                        lineJoin = Qt::BevelJoin;
143
                        break;
144
                case 2:
145
                        lineJoin = Qt::MiterJoin;
146
                        break;
147
                case 3:
148
                        lineJoin = Qt::RoundJoin;
149
                        break;
150
                default:
151
                        lineJoin = Qt::MiterJoin;
152
                        break;
153
        }
154
        switch (pen.capstyle)
155
        {
156
                case 0:
157
                        lineEnd = Qt::FlatCap;
158
                        break;
159
                case 1:
160
                        lineEnd = Qt::RoundCap;
161
                        break;
162
                case 2:
163
                        lineEnd = Qt::SquareCap;
164
                        break;
165
                default:
166
                        lineEnd = Qt::FlatCap;
167
                        break;
168
        }
169
        strokeSet = true;
170
}
171
 
172
void ScrPainter::setBrush(const libwpg::WPGBrush& brush)
173
{
174
        ScColor tmp;
175
        ColorList::Iterator it;
176
        CurrColorFill = "Black";
177
        CurrFillShade = 100.0;
178
        int Rc, Gc, Bc;
179
        if(brush.style == libwpg::WPGBrush::Solid)
180
        {
181
                Rc = brush.foreColor.red;
182
                Gc = brush.foreColor.green;
183
                Bc = brush.foreColor.blue;
184
                tmp.setColorRGB(Rc, Gc, Bc);
185
                tmp.setSpotColor(false);
186
                tmp.setRegistrationColor(false);
187
                QString newColorName = "FromWPG"+tmp.name();
188
                QString fNam = m_Doc->PageColors.tryAddColor(newColorName, tmp);
189
                if (fNam == newColorName)
190
                        importedColors.append(newColorName);
191
                CurrColorFill = fNam;
192
                CurrFillTrans = brush.foreColor.alpha / 255.0;
193
        }
194
        else if (brush.style == libwpg::WPGBrush::Gradient)
195
        {
196
                gradientAngle = brush.gradient.angle();
197
                isGradient = true;
198
                currentGradient = VGradient(VGradient::linear);
199
                currentGradient.clearStops();
200
                for(unsigned c = 0; c < brush.gradient.count(); c++)
201
                {
202
                        QString currStopColor = CommonStrings::None;
203
                        Rc = brush.gradient.stopColor(c).red;
204
                        Gc = brush.gradient.stopColor(c).green;
205
                        Bc = brush.gradient.stopColor(c).blue;
206
                        tmp.setColorRGB(Rc, Gc, Bc);
207
                        tmp.setSpotColor(false);
208
                        tmp.setRegistrationColor(false);
209
                        QString newColorName = "FromWPG"+tmp.name();
210
                        QString fNam = m_Doc->PageColors.tryAddColor(newColorName, tmp);
211
                        if (fNam == newColorName)
212
                                importedColors.append(newColorName);
213
                        currStopColor = fNam;
214
                        const ScColor& gradC = m_Doc->PageColors[currStopColor];
215
                        double pos = qBound(0.0, fabs(brush.gradient.stopOffset(c)), 1.0);
216
                        currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), pos, 0.5, 1.0, currStopColor, 100 );
217
                }
218
        }
219
        else if (brush.style == libwpg::WPGBrush::NoBrush)
220
                CurrColorFill = CommonStrings::None;
221
        fillSet = true;
222
}
223
 
224
void ScrPainter::setFillRule(FillRule rule)
225
{
226
        if(rule == libwpg::WPGPaintInterface::WindingFill)
227
                fillrule = false;
228
        else
229
                fillrule = true;
230
//      qDebug() << "Fill Rule " << fillrule;
231
}
232
 
233
void ScrPainter::drawRectangle(const libwpg::WPGRect& rect, double rx, double ry)
234
{
235
        int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, baseX, baseY, rect.width() * 72.0, rect.height() * 72.0, LineW, CurrColorFill, CurrColorStroke, true);
236
        PageItem *ite = m_Doc->Items->at(z);
237
        if ((rx > 0) && (ry > 0))
238
        {
239
                ite->setCornerRadius(qMax(72*rx, 72*ry));
240
                ite->SetFrameRound();
241
                m_Doc->setRedrawBounding(ite);
242
        }
243
        QTransform mm = QTransform();
244
        mm.translate(72*rect.x1, 72*rect.y1);
245
        ite->PoLine.map(mm);
246
        ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
247
        finishItem(ite);
248
//      qDebug() << "draw Rect";
249
}
250
 
251
void ScrPainter::drawEllipse(const libwpg::WPGPoint& center, double rx, double ry)
252
{
253
        int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Ellipse, baseX, baseY, rx * 144.0, ry * 144.0, LineW, CurrColorFill, CurrColorStroke, true);
254
        PageItem *ite = m_Doc->Items->at(z);
255
        QTransform mm = QTransform();
256
        mm.translate(72*(center.x - rx), 72*(center.y - ry));
257
        ite->PoLine.map(mm);
258
        ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
259
        finishItem(ite);
260
//      qDebug() << "draw Ellipse";
261
}
262
 
263
void ScrPainter::drawPolygon(const libwpg::WPGPointArray& vertices, bool closed)
264
{
265
        if(vertices.count() < 2)
266
                return;
267
        Coords.resize(0);
268
        Coords.svgInit();
269
        PageItem *ite;
270
        Coords.svgMoveTo(72 * vertices[0].x, 72 * vertices[0].y);
271
        for(unsigned i = 1; i < vertices.count(); i++)
272
        {
273
                Coords.svgLineTo(72 * vertices[i].x, 72 * vertices[i].y);
274
        }
275
        if (closed)
276
                Coords.svgClosePath();
277
        if (Coords.size() > 0)
278
        {
279
                int z;
280
                if (closed)
281
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
282
                else
283
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColorStroke, true);
284
                ite = m_Doc->Items->at(z);
285
                ite->PoLine = Coords.copy();
286
                ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
287
                finishItem(ite);
288
        }
289
//      qDebug() << "draw Polygon";
290
}
291
 
292
void ScrPainter::drawPath(const libwpg::WPGPath& path)
293
{
294
        Coords.resize(0);
295
        Coords.svgInit();
296
        PageItem *ite;
297
        for(unsigned i = 0; i < path.count(); i++)
298
        {
299
                libwpg::WPGPathElement element = path.element(i);
300
                libwpg::WPGPoint point = element.point;
301
                switch(element.type)
302
                {
303
                        case libwpg::WPGPathElement::MoveToElement:
304
                                Coords.svgMoveTo(72 * point.x, 72 * point.y);
305
                                break;
306
                        case libwpg::WPGPathElement::LineToElement:
307
                                Coords.svgLineTo(72 * point.x, 72 * point.y);
308
                                break;
309
                        case libwpg::WPGPathElement::CurveToElement:
310
                                Coords.svgCurveToCubic(72*element.extra1.x, 72*element.extra1.y, 72*element.extra2.x, 72*element.extra2.y, 72 * point.x, 72 * point.y);
311
                                break;
312
                        default:
313
                                break;
314
                }
315
        }
316
        if (Coords.size() > 0)
317
        {
318
                int z;
319
                if (fillSet)
320
                {
321
                        if (!path.filled)
322
                                CurrColorFill = CommonStrings::None;
323
                }
324
                if (strokeSet)
325
                {
326
                        if (!path.framed)
327
                                CurrColorStroke = CommonStrings::None;
328
                }
329
                if(path.closed)
330
                {
331
                        Coords.svgClosePath();
332
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
333
                }
334
                else
335
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
336
                ite = m_Doc->Items->at(z);
337
                ite->PoLine = Coords.copy();
338
                ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
339
                finishItem(ite);
340
        }
341
//      qDebug() << "draw Path" << CurrFillTrans;
342
}
343
 
344
void ScrPainter::finishItem(PageItem* ite)
345
{
346
        ite->ClipEdited = true;
347
        ite->FrameType = 3;
348
        ite->setFillShade(CurrFillShade);
349
        ite->setFillEvenOdd(fillrule);
350
        ite->setLineShade(CurrStrokeShade);
351
        ite->setLineJoin(lineJoin);
352
        ite->setLineEnd(lineEnd);
353
        ite->DashValues = dashArray;
354
        FPoint wh = getMaxClipF(&ite->PoLine);
355
        ite->setWidthHeight(wh.x(),wh.y());
356
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
357
        m_Doc->AdjustItemSize(ite);
358
        ite->OldB2 = ite->width();
359
        ite->OldH2 = ite->height();
360
        if (isGradient)
361
        {
362
                ite->fill_gradient = currentGradient;
363
                ite->GrType = 6;
364
                QTransform m1;
365
                m1.rotate(-gradientAngle);
366
                ite->GrStartX = 0;
367
                ite->GrStartY = 0;
368
                QPointF target = m1.map(QPointF(0.0, ite->height()));
369
                ite->GrEndX = target.x();
370
                ite->GrEndY = target.y();
371
        }
372
        else
373
        {
374
                ite->setFillTransparency(CurrFillTrans);
375
                ite->setLineTransparency(CurrStrokeTrans);
376
        }
377
        ite->updateClip();
378
        Elements.append(ite);
379
        Coords.resize(0);
380
        Coords.svgInit();
381
}
382
 
383
void ScrPainter::drawBitmap(const libwpg::WPGBitmap& bitmap, double hres, double vres)
384
{
385
        QImage image = QImage(bitmap.width(), bitmap.height(), QImage::Format_RGB32);
386
        for(int x = 0; x < bitmap.width(); x++)
387
        {
388
                for(int y = 0; y < bitmap.height(); y++)
389
                {
390
                        libwpg::WPGColor color = bitmap.pixel(x, y);
391
                        image.setPixel(x, y, qRgb(color.red, color.green, color.blue));
392
                }
393
        }
394
        double w = (bitmap.rect.x2 - bitmap.rect.x1) * 72.0;
395
        double h = (bitmap.rect.y2 - bitmap.rect.y1) * 72.0;
17054 fschmid 396
        int z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, bitmap.rect.x1 * 72 + baseX, bitmap.rect.y1 * 72 + baseY, w, h, 1, m_Doc->itemToolPrefs().imageFillColor, m_Doc->itemToolPrefs().imageStrokeColor, true);
16682 jghali 397
        PageItem *ite = m_Doc->Items->at(z);
18203 fschmid 398
        QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_wpg_XXXXXX.png");
399
        tempFile->setAutoRemove(false);
400
        tempFile->open();
401
        QString fileName = getLongPathName(tempFile->fileName());
402
        tempFile->close();
403
        delete tempFile;
404
        ite->isTempFile = true;
16682 jghali 405
        ite->isInlineImage = true;
406
        image.setDotsPerMeterX ((int) (hres / 0.0254));
407
        image.setDotsPerMeterY ((int) (vres / 0.0254));
408
        image.save(fileName, "PNG");
16943 fschmid 409
        m_Doc->loadPict(fileName, ite);
16682 jghali 410
        ite->setImageScalingMode(false, false);
411
        ite->moveBy(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
412
        finishItem(ite);
413
//      qDebug() << "drawBitmap";
414
}
415
 
416
void ScrPainter::drawImageObject(const libwpg::WPGBinaryData& /*binaryData*/)
417
{
418
//      qDebug() << "drawBinaryData";
419
}
420
 
421
 
422
WpgPlug::WpgPlug(ScribusDoc* doc, int flags)
423
{
424
        tmpSel=new Selection(this, false);
425
        m_Doc=doc;
426
        importerFlags = flags;
427
        interactive = (flags & LoadSavePlugin::lfInteractive);
16773 fschmid 428
        progressDialog = NULL;
16682 jghali 429
}
430
 
431
QImage WpgPlug::readThumbnail(QString fName)
432
{
433
        QFileInfo fi = QFileInfo(fName);
434
        double b, h;
435
        b = PrefsManager::instance()->appPrefs.docSetupPrefs.pageWidth;
436
        h = PrefsManager::instance()->appPrefs.docSetupPrefs.pageHeight;
437
        docWidth = b;
438
        docHeight = h;
439
        progressDialog = NULL;
440
        m_Doc = new ScribusDoc();
441
        m_Doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
442
        m_Doc->setPage(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, false);
443
        m_Doc->addPage(0);
444
        m_Doc->setGUI(false, ScCore->primaryMainWindow(), 0);
445
        baseX = m_Doc->currentPage()->xOffset();
446
        baseY = m_Doc->currentPage()->yOffset();
447
        Elements.clear();
448
        m_Doc->setLoading(true);
449
        m_Doc->DoDrawing = false;
450
        m_Doc->scMW()->setScriptRunning(true);
451
        QString CurDirP = QDir::currentPath();
452
        QDir::setCurrent(fi.path());
453
        if (convert(fName))
454
        {
455
                tmpSel->clear();
456
                QDir::setCurrent(CurDirP);
457
                if (Elements.count() > 1)
458
                        m_Doc->groupObjectsList(Elements);
459
                m_Doc->DoDrawing = true;
460
                m_Doc->m_Selection->delaySignalsOn();
461
                QImage tmpImage;
462
                if (Elements.count() > 0)
463
                {
464
                        for (int dre=0; dre<Elements.count(); ++dre)
465
                        {
466
                                tmpSel->addItem(Elements.at(dre), true);
467
                        }
468
                        tmpSel->setGroupRect();
469
                        double xs = tmpSel->width();
470
                        double ys = tmpSel->height();
471
                        tmpImage = Elements.at(0)->DrawObj_toImage(500);
472
                        tmpImage.setText("XSize", QString("%1").arg(xs));
473
                        tmpImage.setText("YSize", QString("%1").arg(ys));
474
                }
475
                m_Doc->scMW()->setScriptRunning(false);
476
                m_Doc->setLoading(false);
477
                m_Doc->m_Selection->delaySignalsOff();
478
                delete m_Doc;
479
                return tmpImage;
480
        }
481
        else
482
        {
483
                QDir::setCurrent(CurDirP);
484
                m_Doc->DoDrawing = true;
485
                m_Doc->scMW()->setScriptRunning(false);
486
                delete m_Doc;
487
        }
488
        return QImage();
489
}
490
 
491
bool WpgPlug::import(QString fNameIn, const TransactionSettings& trSettings, int flags, bool showProgress)
492
{
493
        QString fName = fNameIn;
494
        bool success = false;
495
        interactive = (flags & LoadSavePlugin::lfInteractive);
496
        importerFlags = flags;
497
        cancel = false;
17034 jghali 498
        double b, h;
16682 jghali 499
        bool ret = false;
500
        QFileInfo fi = QFileInfo(fName);
501
        if ( !ScCore->usingGUI() )
502
        {
503
                interactive = false;
504
                showProgress = false;
505
        }
506
        if ( showProgress )
507
        {
508
                ScribusMainWindow* mw=(m_Doc==0) ? ScCore->primaryMainWindow() : m_Doc->scMW();
509
                progressDialog = new MultiProgressDialog( tr("Importing: %1").arg(fi.fileName()), CommonStrings::tr_Cancel, mw );
510
                QStringList barNames, barTexts;
511
                barNames << "GI";
512
                barTexts << tr("Analyzing File:");
513
                QList<bool> barsNumeric;
514
                barsNumeric << false;
515
                progressDialog->addExtraProgressBars(barNames, barTexts, barsNumeric);
516
                progressDialog->setOverallTotalSteps(3);
517
                progressDialog->setOverallProgress(0);
518
                progressDialog->setProgress("GI", 0);
519
                progressDialog->show();
520
                connect(progressDialog, SIGNAL(canceled()), this, SLOT(cancelRequested()));
521
                qApp->processEvents();
522
        }
523
        else
524
                progressDialog = NULL;
525
/* Set default Page to size defined in Preferences */
526
        b = 0.0;
527
        h = 0.0;
528
        if (progressDialog)
529
        {
530
                progressDialog->setOverallProgress(1);
531
                qApp->processEvents();
532
        }
533
        if (b == 0.0)
534
                b = PrefsManager::instance()->appPrefs.docSetupPrefs.pageWidth;
535
        if (h == 0.0)
536
                h = PrefsManager::instance()->appPrefs.docSetupPrefs.pageHeight;
537
        docWidth = b;
538
        docHeight = h;
539
        baseX = 0;
540
        baseY = 0;
541
        if (!interactive || (flags & LoadSavePlugin::lfInsertPage))
542
        {
543
                m_Doc->setPage(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, false);
544
                m_Doc->addPage(0);
545
                m_Doc->view()->addPage(0, true);
546
                baseX = 0;
547
                baseY = 0;
548
        }
549
        else
550
        {
551
                if (!m_Doc || (flags & LoadSavePlugin::lfCreateDoc))
552
                {
553
                        m_Doc=ScCore->primaryMainWindow()->doFileNew(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, false, 0, false, 0, 1, "Custom", true);
554
                        ScCore->primaryMainWindow()->HaveNewDoc();
555
                        ret = true;
556
                        baseX = 0;
557
                        baseY = 0;
558
                        baseX = m_Doc->currentPage()->xOffset();
559
                        baseY = m_Doc->currentPage()->yOffset();
560
                }
561
        }
562
        if ((!ret) && (interactive))
563
        {
564
                baseX = m_Doc->currentPage()->xOffset();
565
                baseY = m_Doc->currentPage()->yOffset();
566
        }
567
        if ((ret) || (!interactive))
568
        {
569
                if (docWidth > docHeight)
570
                        m_Doc->setPageOrientation(1);
571
                else
572
                        m_Doc->setPageOrientation(0);
573
                m_Doc->setPageSize("Custom");
574
        }
16645 jghali 575
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16682 jghali 576
                m_Doc->view()->Deselect();
577
        Elements.clear();
578
        m_Doc->setLoading(true);
579
        m_Doc->DoDrawing = false;
580
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
581
                m_Doc->view()->updatesOn(false);
582
        m_Doc->scMW()->setScriptRunning(true);
18181 fschmid 583
        qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
16682 jghali 584
        QString CurDirP = QDir::currentPath();
585
        QDir::setCurrent(fi.path());
586
        if (convert(fName))
587
        {
588
                tmpSel->clear();
589
                QDir::setCurrent(CurDirP);
590
                if ((Elements.count() > 1) && (!(importerFlags & LoadSavePlugin::lfCreateDoc)))
591
                        m_Doc->groupObjectsList(Elements);
592
                m_Doc->DoDrawing = true;
593
                m_Doc->scMW()->setScriptRunning(false);
594
                m_Doc->setLoading(false);
595
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
596
                if ((Elements.count() > 0) && (!ret) && (interactive))
597
                {
598
                        if (flags & LoadSavePlugin::lfScripted)
599
                        {
600
                                bool loadF = m_Doc->isLoading();
601
                                m_Doc->setLoading(false);
602
                                m_Doc->changed();
603
                                m_Doc->setLoading(loadF);
604
                                if (!(flags & LoadSavePlugin::lfLoadAsPattern))
605
                                {
606
                                        m_Doc->m_Selection->delaySignalsOn();
607
                                        for (int dre=0; dre<Elements.count(); ++dre)
608
                                        {
609
                                                m_Doc->m_Selection->addItem(Elements.at(dre), true);
610
                                        }
611
                                        m_Doc->m_Selection->delaySignalsOff();
612
                                        m_Doc->m_Selection->setGroupRect();
613
                                        m_Doc->view()->updatesOn(true);
614
                                }
615
                        }
616
                        else
617
                        {
618
                                m_Doc->DragP = true;
619
                                m_Doc->DraggedElem = 0;
620
                                m_Doc->DragElements.clear();
621
                                m_Doc->m_Selection->delaySignalsOn();
622
                                for (int dre=0; dre<Elements.count(); ++dre)
623
                                {
624
                                        tmpSel->addItem(Elements.at(dre), true);
625
                                }
626
                                tmpSel->setGroupRect();
18028 jghali 627
                                ScElemMimeData* md = ScriXmlDoc::WriteToMimeData(m_Doc, tmpSel);
16682 jghali 628
                                m_Doc->itemSelection_DeleteItem(tmpSel);
629
                                m_Doc->view()->updatesOn(true);
630
                                m_Doc->m_Selection->delaySignalsOff();
631
                                // We must copy the TransationSettings object as it is owned
632
                                // by handleObjectImport method afterwards
633
                                TransactionSettings* transacSettings = new TransactionSettings(trSettings);
634
                                m_Doc->view()->handleObjectImport(md, transacSettings);
635
                                m_Doc->DragP = false;
636
                                m_Doc->DraggedElem = 0;
637
                                m_Doc->DragElements.clear();
638
                        }
639
                }
640
                else
641
                {
642
                        m_Doc->changed();
643
                        m_Doc->reformPages();
644
                        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
645
                                m_Doc->view()->updatesOn(true);
646
                }
647
                success = true;
648
        }
649
        else
650
        {
651
                QDir::setCurrent(CurDirP);
652
                m_Doc->DoDrawing = true;
653
                m_Doc->scMW()->setScriptRunning(false);
654
                m_Doc->view()->updatesOn(true);
655
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
656
        }
657
        if (interactive)
658
                m_Doc->setLoading(false);
659
        //CB If we have a gui we must refresh it if we have used the progressbar
660
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
661
        {
662
                if ((showProgress) && (!interactive))
663
                        m_Doc->view()->DrawNew();
664
        }
18181 fschmid 665
        qApp->restoreOverrideCursor();
16682 jghali 666
        return success;
667
}
668
 
669
WpgPlug::~WpgPlug()
670
{
671
        if (progressDialog)
672
                delete progressDialog;
673
        delete tmpSel;
674
}
675
 
676
bool WpgPlug::convert(QString fn)
677
{
678
        QString tmp;
679
        importedColors.clear();
680
 
681
        QFile file(fn);
682
        if ( !file.exists() )
683
        {
684
                qDebug() << "File " << QFile::encodeName(fn).data() << " does not exist" << endl;
685
                return false;
686
        }
687
        if ( !file.open( QIODevice::ReadOnly ) )
688
        {
689
                qDebug() << "Cannot open file " << QFile::encodeName(fn).data() << endl;
690
                return false;
691
        }
692
        QByteArray ba = file.readAll();
693
        file.close();
694
 
695
        libwpg::WPGMemoryStream input(ba.constData(), ba.size());
696
        if (!libwpg::WPGraphics::isSupported(&input))
697
        {
698
                fprintf(stderr, "ERROR: Unsupported file format (unsupported version) or file is encrypted!\n");
699
                return false;
700
        }
701
        ScrPainter painter;
702
        painter.m_Doc = m_Doc;
703
        painter.baseX = baseX;
704
        painter.baseY = baseY;
705
        painter.flags = importerFlags;
706
        libwpg::WPGraphics::parse(&input, &painter);
707
        Elements = painter.Elements;
708
        importedColors = painter.importedColors;
709
        if (Elements.count() == 0)
710
        {
711
                if (importedColors.count() != 0)
712
                {
713
                        for (int cd = 0; cd < importedColors.count(); cd++)
714
                        {
715
                                m_Doc->PageColors.remove(importedColors[cd]);
716
                        }
717
                }
718
        }
719
        if (progressDialog)
720
                progressDialog->close();
721
        return true;
722
}