Subversion Repositories Scribus

Rev

Rev 14087 | Details | Compare with Previous | Last modification | View Log | RSS feed

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