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
14536 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
                          importdrw.cpp  -  description
9
                             -------------------
10
    begin                : Mon Jan 11 2010
11
    copyright            : (C) 2010 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
#include <QByteArray>
16
#include <QCursor>
17
#include <QDrag>
18
#include <QFile>
19
#include <QList>
20
#include <QMimeData>
21
#include <QRegExp>
22
#include <QStack>
23
#include <QDebug>
24
 
25
#include <cstdlib>
26
 
27
#include "commonstrings.h"
28
#include "ui/customfdialog.h"
29
#include "importdrw.h"
30
#include "loadsaveplugin.h"
31
#include "ui/missing.h"
32
#include "ui/multiprogressdialog.h"
14586 fschmid 33
#include "pageitem_imageframe.h"
14536 fschmid 34
#include "pagesize.h"
35
#include "prefscontext.h"
36
#include "prefsfile.h"
37
#include "prefsmanager.h"
38
#include "prefstable.h"
39
#include "ui/propertiespalette.h"
40
#include "rawimage.h"
41
#include "scclocale.h"
42
#include "sccolorengine.h"
43
#include "scconfig.h"
44
#include "scmimedata.h"
45
#include "scpaths.h"
14586 fschmid 46
#include "scpattern.h"
14536 fschmid 47
#include "scribus.h"
48
#include "scribusXml.h"
49
#include "scribuscore.h"
50
#include "sctextstream.h"
51
#include "selection.h"
52
#include "undomanager.h"
53
#include "util.h"
54
#include "util_formats.h"
55
#include "util_icon.h"
56
#include "util_math.h"
57
 
58
extern SCRIBUS_API ScribusQApp * ScQApp;
59
 
60
DrwPlug::DrwPlug(ScribusDoc* doc, int flags)
61
{
62
        tmpSel=new Selection(this, false);
63
        m_Doc=doc;
14659 fschmid 64
        importerFlags = flags;
14536 fschmid 65
        interactive = (flags & LoadSavePlugin::lfInteractive);
16772 fschmid 66
        progressDialog = NULL;
14536 fschmid 67
}
68
 
14659 fschmid 69
QImage DrwPlug::readThumbnail(QString fName)
70
{
71
        QFileInfo fi = QFileInfo(fName);
72
        baseFile = QDir::cleanPath(QDir::toNativeSeparators(fi.absolutePath()+"/"));
73
        double b = PrefsManager::instance()->appPrefs.docSetupPrefs.pageWidth;
74
        double h = PrefsManager::instance()->appPrefs.docSetupPrefs.pageHeight;
75
        docWidth = b;
76
        docHeight = h;
77
        progressDialog = NULL;
14665 fschmid 78
        m_Doc = new ScribusDoc();
79
        m_Doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
80
        m_Doc->setPage(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, false);
81
        m_Doc->addPage(0);
14681 fschmid 82
        m_Doc->setGUI(false, ScCore->primaryMainWindow(), 0);
14659 fschmid 83
        baseX = m_Doc->currentPage()->xOffset();
84
        baseY = m_Doc->currentPage()->yOffset();
85
        Elements.clear();
86
        m_Doc->setLoading(true);
87
        m_Doc->DoDrawing = false;
14754 jghali 88
        m_Doc->scMW()->setScriptRunning(true);
14659 fschmid 89
        QString CurDirP = QDir::currentPath();
90
        QDir::setCurrent(fi.path());
91
        if (convert(fName))
92
        {
93
                if (!thumbRead)
94
                {
95
                        tmpSel->clear();
96
                        QDir::setCurrent(CurDirP);
16105 fschmid 97
                        if (Elements.count() > 1)
98
                                m_Doc->groupObjectsList(Elements);
14659 fschmid 99
                }
100
                m_Doc->DoDrawing = true;
101
                m_Doc->m_Selection->delaySignalsOn();
102
                QImage tmpImage;
103
                if (thumbRead)
14665 fschmid 104
                {
14659 fschmid 105
                        tmpImage = thumbnailImage;
14665 fschmid 106
                        tmpImage.setText("XSize", QString("%1").arg(docWidth));
107
                        tmpImage.setText("YSize", QString("%1").arg(docHeight));
108
                }
14659 fschmid 109
                else
110
                {
111
                        if (Elements.count() > 0)
112
                        {
113
                                for (int dre=0; dre<Elements.count(); ++dre)
114
                                {
115
                                        tmpSel->addItem(Elements.at(dre), true);
116
                                }
117
                                tmpSel->setGroupRect();
14665 fschmid 118
                                double xs = tmpSel->width();
119
                                double ys = tmpSel->height();
16504 fschmid 120
                                tmpImage = Elements.at(0)->DrawObj_toImage(500);
14665 fschmid 121
                                tmpImage.setText("XSize", QString("%1").arg(xs));
122
                                tmpImage.setText("YSize", QString("%1").arg(ys));
14659 fschmid 123
                        }
124
                }
14754 jghali 125
                m_Doc->scMW()->setScriptRunning(false);
14659 fschmid 126
                m_Doc->setLoading(false);
127
                m_Doc->m_Selection->delaySignalsOff();
14681 fschmid 128
                delete m_Doc;
14659 fschmid 129
                return tmpImage;
130
        }
131
        else
132
        {
133
                QDir::setCurrent(CurDirP);
134
                m_Doc->DoDrawing = true;
14754 jghali 135
                m_Doc->scMW()->setScriptRunning(false);
14681 fschmid 136
                delete m_Doc;
14659 fschmid 137
        }
138
        return QImage();
139
}
140
 
14536 fschmid 141
bool DrwPlug::import(QString fNameIn, const TransactionSettings& trSettings, int flags, bool showProgress)
142
{
143
        QString fName = fNameIn;
144
        bool success = false;
145
        interactive = (flags & LoadSavePlugin::lfInteractive);
146
        importerFlags = flags;
147
        cancel = false;
17031 jghali 148
        double b, h;
14536 fschmid 149
        bool ret = false;
150
        QFileInfo fi = QFileInfo(fName);
151
        if ( !ScCore->usingGUI() )
152
        {
153
                interactive = false;
154
                showProgress = false;
155
        }
156
        baseFile = QDir::cleanPath(QDir::toNativeSeparators(fi.absolutePath()+"/"));
157
        if ( showProgress )
158
        {
159
                ScribusMainWindow* mw=(m_Doc==0) ? ScCore->primaryMainWindow() : m_Doc->scMW();
160
                progressDialog = new MultiProgressDialog( tr("Importing: %1").arg(fi.fileName()), CommonStrings::tr_Cancel, mw );
161
                QStringList barNames, barTexts;
162
                barNames << "GI";
163
                barTexts << tr("Analyzing File:");
164
                QList<bool> barsNumeric;
165
                barsNumeric << false;
166
                progressDialog->addExtraProgressBars(barNames, barTexts, barsNumeric);
167
                progressDialog->setOverallTotalSteps(3);
168
                progressDialog->setOverallProgress(0);
169
                progressDialog->setProgress("GI", 0);
170
                progressDialog->show();
171
                connect(progressDialog, SIGNAL(canceled()), this, SLOT(cancelRequested()));
172
                qApp->processEvents();
173
        }
174
        else
175
                progressDialog = NULL;
176
/* Set default Page to size defined in Preferences */
177
        b = 0.0;
178
        h = 0.0;
179
        if (progressDialog)
180
        {
181
                progressDialog->setOverallProgress(1);
182
                qApp->processEvents();
183
        }
184
        b = PrefsManager::instance()->appPrefs.docSetupPrefs.pageWidth;
185
        h = PrefsManager::instance()->appPrefs.docSetupPrefs.pageHeight;
186
        docWidth = b;
187
        docHeight = h;
188
        baseX = 0;
189
        baseY = 0;
190
        if (!interactive || (flags & LoadSavePlugin::lfInsertPage))
191
        {
192
                m_Doc->setPage(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, false);
193
                m_Doc->addPage(0);
194
                m_Doc->view()->addPage(0, true);
195
                baseX = 0;
196
                baseY = 0;
14546 fschmid 197
                baseX = m_Doc->currentPage()->xOffset();
198
                baseY = m_Doc->currentPage()->yOffset();
14536 fschmid 199
        }
200
        else
201
        {
202
                if (!m_Doc || (flags & LoadSavePlugin::lfCreateDoc))
203
                {
204
                        m_Doc=ScCore->primaryMainWindow()->doFileNew(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, false, 0, false, 0, 1, "Custom", true);
205
                        ScCore->primaryMainWindow()->HaveNewDoc();
206
                        ret = true;
207
                        baseX = 0;
208
                        baseY = 0;
209
                        baseX = m_Doc->currentPage()->xOffset();
210
                        baseY = m_Doc->currentPage()->yOffset();
211
                }
212
        }
213
        if ((!ret) && (interactive))
214
        {
215
                baseX = m_Doc->currentPage()->xOffset();
216
                baseY = m_Doc->currentPage()->yOffset();
217
        }
218
        if ((ret) || (!interactive))
219
        {
220
                if (docWidth > docHeight)
14991 cbradney 221
                        m_Doc->setPageOrientation(1);
14536 fschmid 222
                else
14991 cbradney 223
                        m_Doc->setPageOrientation(0);
224
                m_Doc->setPageSize("Custom");
14536 fschmid 225
        }
16645 jghali 226
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
227
                m_Doc->view()->Deselect();
14536 fschmid 228
        Elements.clear();
229
        m_Doc->setLoading(true);
230
        m_Doc->DoDrawing = false;
16105 fschmid 231
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16016 fschmid 232
                m_Doc->view()->updatesOn(false);
14754 jghali 233
        m_Doc->scMW()->setScriptRunning(true);
18181 fschmid 234
        qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
14536 fschmid 235
        QString CurDirP = QDir::currentPath();
236
        QDir::setCurrent(fi.path());
237
        if (convert(fName))
238
        {
239
                tmpSel->clear();
240
                QDir::setCurrent(CurDirP);
241
                if ((Elements.count() > 1) && (!(importerFlags & LoadSavePlugin::lfCreateDoc)))
16105 fschmid 242
                        m_Doc->groupObjectsList(Elements);
14536 fschmid 243
                m_Doc->DoDrawing = true;
14754 jghali 244
                m_Doc->scMW()->setScriptRunning(false);
14536 fschmid 245
                m_Doc->setLoading(false);
246
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
247
                if ((Elements.count() > 0) && (!ret) && (interactive))
248
                {
249
                        if (flags & LoadSavePlugin::lfScripted)
250
                        {
251
                                bool loadF = m_Doc->isLoading();
252
                                m_Doc->setLoading(false);
253
                                m_Doc->changed();
254
                                m_Doc->setLoading(loadF);
16105 fschmid 255
                                if (!(flags & LoadSavePlugin::lfLoadAsPattern))
14536 fschmid 256
                                {
16016 fschmid 257
                                        m_Doc->m_Selection->delaySignalsOn();
258
                                        for (int dre=0; dre<Elements.count(); ++dre)
259
                                        {
260
                                                m_Doc->m_Selection->addItem(Elements.at(dre), true);
261
                                        }
262
                                        m_Doc->m_Selection->delaySignalsOff();
263
                                        m_Doc->m_Selection->setGroupRect();
264
                                        m_Doc->view()->updatesOn(true);
14536 fschmid 265
                                }
266
                        }
267
                        else
268
                        {
269
                                m_Doc->DragP = true;
270
                                m_Doc->DraggedElem = 0;
271
                                m_Doc->DragElements.clear();
272
                                m_Doc->m_Selection->delaySignalsOn();
273
                                for (int dre=0; dre<Elements.count(); ++dre)
274
                                {
275
                                        tmpSel->addItem(Elements.at(dre), true);
276
                                }
277
                                tmpSel->setGroupRect();
18028 jghali 278
                                ScElemMimeData* md = ScriXmlDoc::WriteToMimeData(m_Doc, tmpSel);
14536 fschmid 279
                                m_Doc->itemSelection_DeleteItem(tmpSel);
280
                                m_Doc->view()->updatesOn(true);
14586 fschmid 281
                                if (importedColors.count() != 0)
282
                                {
283
                                        for (int cd = 0; cd < importedColors.count(); cd++)
284
                                        {
285
                                                m_Doc->PageColors.remove(importedColors[cd]);
286
                                        }
287
                                }
288
                                if (importedPatterns.count() != 0)
289
                                {
290
                                        for (int cd = 0; cd < importedPatterns.count(); cd++)
291
                                        {
292
                                                m_Doc->docPatterns.remove(importedPatterns[cd]);
293
                                        }
294
                                }
14536 fschmid 295
                                m_Doc->m_Selection->delaySignalsOff();
296
                                // We must copy the TransationSettings object as it is owned
297
                                // by handleObjectImport method afterwards
298
                                TransactionSettings* transacSettings = new TransactionSettings(trSettings);
299
                                m_Doc->view()->handleObjectImport(md, transacSettings);
300
                                m_Doc->DragP = false;
301
                                m_Doc->DraggedElem = 0;
302
                                m_Doc->DragElements.clear();
303
                        }
304
                }
305
                else
306
                {
307
                        m_Doc->changed();
308
                        m_Doc->reformPages();
16105 fschmid 309
                        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16016 fschmid 310
                                m_Doc->view()->updatesOn(true);
14536 fschmid 311
                }
312
                success = true;
313
        }
314
        else
315
        {
316
                QDir::setCurrent(CurDirP);
317
                m_Doc->DoDrawing = true;
14754 jghali 318
                m_Doc->scMW()->setScriptRunning(false);
14536 fschmid 319
                m_Doc->view()->updatesOn(true);
320
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
321
        }
322
        if (interactive)
323
                m_Doc->setLoading(false);
324
        //CB If we have a gui we must refresh it if we have used the progressbar
16105 fschmid 325
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16016 fschmid 326
        {
327
                if ((showProgress) && (!interactive))
328
                        m_Doc->view()->DrawNew();
329
        }
18181 fschmid 330
        qApp->restoreOverrideCursor();
14536 fschmid 331
        return success;
332
}
333
 
334
DrwPlug::~DrwPlug()
335
{
336
        if (progressDialog)
337
                delete progressDialog;
338
        delete tmpSel;
339
}
340
 
341
bool DrwPlug::convert(QString fn)
342
{
343
        QString tmp;
344
        Coords.resize(0);
345
        Coords.svgInit();
346
        importedColors.clear();
14586 fschmid 347
        importedPatterns.clear();
14546 fschmid 348
        DRWGroup gElements;
349
        gElements.xoffset = 0.0;
350
        gElements.yoffset = 0.0;
351
        gElements.nrOfItems = -1;
352
        gElements.counter = -1;
14536 fschmid 353
        groupStack.push(gElements);
14568 fschmid 354
        DRWObjectList gList;
355
        gList.groupX = 0.0;
356
        gList.groupY = 0.0;
357
        listStack.push(gList);
14536 fschmid 358
        scaleFactor = 0.15;
359
        lineWidth = 1.0;
360
        lineColor = "Black";
361
        fillColor = "Black";
362
        createObjCode = 0;
363
        nrOfPoints = 0;
14546 fschmid 364
        symbolCount = 0;
365
        recordCount = 0;
14561 fschmid 366
        imageValid = false;
14659 fschmid 367
        thumbRead = false;
14568 fschmid 368
        currentItem = NULL;
14536 fschmid 369
        if(progressDialog)
370
        {
371
                progressDialog->setOverallProgress(2);
372
                progressDialog->setLabel("GI", tr("Generating Items"));
373
                qApp->processEvents();
374
        }
375
        QFile f(fn);
376
        if (f.open(QIODevice::ReadOnly))
377
        {
378
                QDataStream ts(&f);
379
                ts.setByteOrder(QDataStream::LittleEndian);
380
                while (!ts.atEnd())
381
                {
382
                        quint8 dataS, cmd;
383
                        quint16 dataL;
384
                        uint dataLen;
385
                        int pos = ts.device()->pos();
386
                        ts >> dataS;
387
                        if (dataS == 0xFF)
388
                        {
389
                                ts >> dataL;
390
                                dataLen = dataL;
391
                        }
392
                        else
393
                                dataLen = dataS;
394
                        ts >> cmd;
395
                        decodeCmdData(ts, dataLen, cmd);
396
                        decodeCmd(cmd, pos);
14659 fschmid 397
                        if (progressDialog)
14681 fschmid 398
                        {
14659 fschmid 399
                                progressDialog->setProgress("GI", ts.device()->pos());
14681 fschmid 400
                                qApp->processEvents();
401
                        }
14561 fschmid 402
                        if (cmd == 254)
403
                                break;
14659 fschmid 404
                        if ((importerFlags & LoadSavePlugin::lfCreateThumbnail) && (cmd == 11))
405
                                thumbRead = true;
14665 fschmid 406
                        if ((importerFlags & LoadSavePlugin::lfCreateThumbnail) && (cmd == 27) && (thumbRead))
14659 fschmid 407
                                break;
14536 fschmid 408
                }
409
                if (Elements.count() == 0)
410
                {
411
                        if (importedColors.count() != 0)
412
                        {
413
                                for (int cd = 0; cd < importedColors.count(); cd++)
414
                                {
415
                                        m_Doc->PageColors.remove(importedColors[cd]);
416
                                }
417
                        }
14586 fschmid 418
                        if (importedPatterns.count() != 0)
419
                        {
420
                                for (int cd = 0; cd < importedPatterns.count(); cd++)
421
                                {
422
                                        m_Doc->docPatterns.remove(importedPatterns[cd]);
423
                                }
424
                        }
14536 fschmid 425
                }
426
                f.close();
427
        }
428
        if (progressDialog)
429
                progressDialog->close();
430
        return true;
431
}
432
 
433
void DrwPlug::decodeCmdData(QDataStream &ts, uint dataLen, quint8 cmd)
434
{
435
        cmdData.resize(0);
436
        uint count = 0;
437
        while (count < dataLen)
438
        {
439
                quint8 d;
440
                ts >> d;
441
                if ((cmd < 96) || (cmd > 160))
442
                {
443
                        if (d == 0xFF)
444
                        {
445
                                quint8 val, dd;
446
                                ts >> dd >> val;
447
                                for (uint cc = 0; cc < dd; cc++)
448
                                {
449
                                        cmdData.append(val);
450
                                        count++;
451
                                }
452
                        }
453
                        else
454
                        {
455
                                cmdData.append(d);
456
                                count++;
457
                        }
458
                }
459
                else
460
                {
461
                        cmdData.append(d);
462
                        count++;
463
                }
464
        }
465
}
466
 
467
void DrwPlug::decodeCmd(quint8 cmd, int pos)
468
{
14546 fschmid 469
        recordCount++;
14625 fschmid 470
        bool printMSG = false;
14744 fschmid 471
/*      if ((recordCount > 29) && (recordCount < 33))
14561 fschmid 472
        {
473
                QFile f(QString("/home/franz/cmddatas%1.bin").arg(recordCount));
474
                f.open(QIODevice::WriteOnly);
475
                f.write(cmdData);
476
                f.close();
477
        } */
14536 fschmid 478
        QDataStream ds(cmdData);
14574 fschmid 479
        DRWGradient gradient;
14586 fschmid 480
        QByteArray pattern;
14579 fschmid 481
        quint8 data8, chData;
14536 fschmid 482
        quint16 data16;
14574 fschmid 483
        int index;
14580 fschmid 484
        QFont font;
485
        QString textFont;
14536 fschmid 486
        ds.setByteOrder(QDataStream::LittleEndian);
14560 fschmid 487
        QString cmdText = QString("Record %1 Type: ").arg(recordCount);
14536 fschmid 488
        switch (cmd)
489
        {
490
                case 1:
14560 fschmid 491
                        cmdText += QString("DRW Background Color %1").arg(getColor(ds));
14536 fschmid 492
                        break;
493
                case 2:
14560 fschmid 494
                        cmdText += "DRW Facename";
14536 fschmid 495
                        break;
496
                case 3:
14561 fschmid 497
                        cmdText += QString("DRW Version Data %1").arg(QString(cmdData.toHex().left(64)));
14536 fschmid 498
                        break;
499
                case 4:
14568 fschmid 500
                        cmdText += QString("DRW ID Data %1").arg(QString(cmdData).left(20));
501
                        if (listStack.count() > 0)
502
                                listStack.top().itemGroupName = QString(cmdData);
14536 fschmid 503
                        break;
504
                case 5:
14648 fschmid 505
                        cmdText += QString("DRW Overlay Data %1").arg(QString(cmdData.toHex().left(20)));
14536 fschmid 506
                        break;
507
                case 6:
14560 fschmid 508
                        cmdText += "DRW Polygon";
14547 fschmid 509
                        if ((createObjCode == 1) || (createObjCode == 3))
14536 fschmid 510
                        {
511
                                bool first = true;
14538 fschmid 512
                                bool first2 = true;
513
                                QPointF startP;
14614 fschmid 514
                                QPainterPath path;
14536 fschmid 515
                                for (int a = 0; a < nrOfPoints; a++)
516
                                {
517
                                        QPointF coor = getCoordinate(ds);
518
                                        if (first)
519
                                        {
14615 fschmid 520
                                                path.moveTo(coor);
14538 fschmid 521
                                                if (first2)
522
                                                        startP = coor;
14536 fschmid 523
                                                first = false;
14538 fschmid 524
                                                first2 = false;
14536 fschmid 525
                                        }
526
                                        else
14538 fschmid 527
                                        {
528
                                                if (coor == startP)
529
                                                {
530
                                                        first = true;
14648 fschmid 531
                                                        path.closeSubpath();
14538 fschmid 532
                                                }
533
                                                else
14615 fschmid 534
                                                        path.lineTo(coor);
14538 fschmid 535
                                        }
14536 fschmid 536
                                }
537
                                if (currentItem != NULL)
538
                                {
14614 fschmid 539
                                        currentItem->PoLine.fromQPainterPath(path);
14635 fschmid 540
                                        QRectF bBoxO = path.boundingRect();
541
                                        if (bBoxO.x() < 0)
542
                                                currentItem->PoLine.translate(-bBoxO.x(), 0);
543
                                        if (bBoxO.y() < 0)
544
                                                currentItem->PoLine.translate(0, -bBoxO.y());
14536 fschmid 545
                                        finishItem(currentItem);
14635 fschmid 546
                                        if (currentItem != NULL)
547
                                        {
548
                                                handleLineStyle(currentItem, flags, lineColor);
549
                                                handleGradient(currentItem, patternIndex, fillColor, backColor, bBox);
550
                                        }
14536 fschmid 551
                                }
552
                                createObjCode = 0;
553
                                currentItem = NULL;
554
                        }
14538 fschmid 555
                        else if (createObjCode == 2)
556
                        {
557
                                bool first = true;
558
                                QPointF startP;
14614 fschmid 559
                                QPainterPath path;
14538 fschmid 560
                                int a = 0;
561
                                while (a < nrOfPoints)
562
                                {
563
                                        if (first)
564
                                        {
565
                                                QPointF coor = getCoordinate(ds);
566
                                                a++;
14615 fschmid 567
                                                path.moveTo(coor);
14538 fschmid 568
                                                startP = coor;
569
                                                first = false;
570
                                        }
571
                                        QPointF p1 = getCoordinate(ds);
572
                                        QPointF p2 = getCoordinate(ds);
573
                                        QPointF p3 = getCoordinate(ds);
574
                                        a += 3;
14615 fschmid 575
                                        path.cubicTo(p1, p2, p3);
14538 fschmid 576
                                }
577
                                if (currentItem != NULL)
578
                                {
14614 fschmid 579
                                        currentItem->PoLine.fromQPainterPath(path);
14635 fschmid 580
                                        QRectF bBoxO = path.boundingRect();
581
                                        if (bBoxO.x() < 0)
582
                                                currentItem->PoLine.translate(-bBoxO.x(), 0);
583
                                        if (bBoxO.y() < 0)
584
                                                currentItem->PoLine.translate(0, -bBoxO.y());
14614 fschmid 585
                                        finishItem(currentItem);
14635 fschmid 586
                                        if (currentItem != NULL)
587
                                        {
588
                                                handleLineStyle(currentItem, flags, lineColor);
589
                                                handleGradient(currentItem, patternIndex, fillColor, backColor, bBox);
590
                                        }
14538 fschmid 591
                                }
592
                                createObjCode = 0;
593
                                currentItem = NULL;
594
                        }
14574 fschmid 595
                        else if (createObjCode == 4)
596
                        {
597
                                bool first = true;
598
                                QPointF startP;
599
                                int a = 0;
14614 fschmid 600
                                QPainterPath path;
14589 fschmid 601
                                while (a < nrOfPoints-1)
14574 fschmid 602
                                {
603
                                        if (first)
604
                                        {
605
                                                QPointF coor = getCoordinate(ds);
606
                                                a++;
14615 fschmid 607
                                                path.moveTo(coor);
14574 fschmid 608
                                                startP = coor;
609
                                                first = false;
610
                                        }
611
                                        QPointF p1 = getCoordinate(ds);
14643 fschmid 612
                                        a++;
14574 fschmid 613
                                        QPointF p2 = getCoordinate(ds);
14643 fschmid 614
                                        a++;
14625 fschmid 615
                                        path.quadTo(p1, p2);
14574 fschmid 616
                                }
617
                                if (currentItem != NULL)
618
                                {
14614 fschmid 619
                                        currentItem->PoLine.fromQPainterPath(path);
14635 fschmid 620
                                        QRectF bBoxO = path.boundingRect();
621
                                        if (bBoxO.x() < 0)
622
                                                currentItem->PoLine.translate(-bBoxO.x(), 0);
623
                                        if (bBoxO.y() < 0)
624
                                                currentItem->PoLine.translate(0, -bBoxO.y());
14574 fschmid 625
                                        finishItem(currentItem);
14635 fschmid 626
                                        if (currentItem != NULL)
627
                                        {
628
                                                handleLineStyle(currentItem, flags, lineColor);
629
                                                handleGradient(currentItem, patternIndex, fillColor, backColor, bBox);
630
                                        }
14574 fschmid 631
                                }
632
                                createObjCode = 0;
633
                                currentItem = NULL;
634
                        }
14536 fschmid 635
                        break;
636
                case 7:
14546 fschmid 637
                        cmdText = "";
14536 fschmid 638
                        decodeSymbol(ds);
14562 fschmid 639
                        printMSG = false;
14536 fschmid 640
                        break;
641
                case 8:
14560 fschmid 642
                        cmdText += "DRW Text";
14579 fschmid 643
                        if (createObjCode == 5)
644
                        {
645
                                QString tx = QString(cmdData.left(nrOfChars));
14648 fschmid 646
                                QStringList parList = tx.split(QChar(13));
647
                                double yp = 0;
14579 fschmid 648
                                QPainterPath path;
649
                                QString fontN = "Arial";
650
                                if (fontMap.contains(fontID))
651
                                        fontN = fontMap[fontID];
14648 fschmid 652
                                QFont textFont = QFont(fontN, fontSize * 0.8);
14579 fschmid 653
                                QFontMetrics fm(textFont);
14648 fschmid 654
                                for (int a = 0; a < parList.size(); a++)
655
                                {
656
                                        path.addText( 0, yp, textFont, parList[a].trimmed());
657
                                        yp += fm.lineSpacing();
658
                                }
14579 fschmid 659
                                QTransform txS;
660
                                QRectF bbox = path.boundingRect();
661
                                txS = QTransform();
662
                                txS.scale(scaleFactor, scaleFactor);
663
                                path = txS.map(path);
664
                                txS = QTransform();
665
                                bbox = path.boundingRect();
666
                                txS.translate(-bbox.x(), -bbox.y());
667
                                txS.translate(0, fm.leading() * scaleFactor);
668
                                path = txS.map(path);
669
                                if (currentItem != NULL)
670
                                {
671
                                        currentItem->PoLine.fromQPainterPath(path);
14659 fschmid 672
                                        currentItem->setWidth(bbox.width());
14579 fschmid 673
                                        finishItem(currentItem, false);
674
                                }
675
                                createObjCode = 0;
676
                                currentItem = NULL;
677
                        }
14536 fschmid 678
                        break;
679
                case 9:
14560 fschmid 680
                        cmdText += "DRW Color";
14536 fschmid 681
                        break;
682
                case 10:
14560 fschmid 683
                        cmdText += "DRW Color Flag";
14536 fschmid 684
                        break;
685
                case 11:
14560 fschmid 686
                        cmdText += "DRW Preview Bitmap";
14659 fschmid 687
                        handlePreviewBitmap(ds);
14536 fschmid 688
                        break;
689
                case 14:
14560 fschmid 690
                        cmdText += "DRW View";
14536 fschmid 691
                        break;
692
                case 15:
14560 fschmid 693
                        cmdText += "DRW Old Grid";
14536 fschmid 694
                        break;
695
                case 16:
14648 fschmid 696
                        cmdText += QString("DRW Curr Overlay Data %1").arg(QString(cmdData.toHex().left(20)));
14536 fschmid 697
                        break;
698
                case 17:
14648 fschmid 699
                        cmdText += QString("DRW Visible Data %1").arg(QString(cmdData.toHex().left(20)));
14536 fschmid 700
                        break;
701
                case 18:
14648 fschmid 702
                        cmdText += QString("DRW Comment Data %1").arg(QString(cmdData.toHex().left(20)));
14536 fschmid 703
                        break;
704
                case 19:
14648 fschmid 705
                        cmdText += QString("DRW Info Data %1").arg(QString(cmdData).left(20));
14536 fschmid 706
                        break;
707
                case 20:
14560 fschmid 708
                        cmdText += "DRW Bitmap";
14536 fschmid 709
                        break;
710
                case 21:
14579 fschmid 711
                        ds >> fontID;
712
                        ds.device()->seek(0x13);
713
                        fontName = "";
714
                        ds >> chData;
715
                        while (chData != 0)
716
                        {
717
                                fontName += QChar(chData);
718
                                ds >> chData;
719
                        }
720
                        fontName = fontName.trimmed();
14580 fschmid 721
                        fontName.replace( QRegExp( "'" ) , QChar( ' ' ) );
722
                        {
14932 cbradney 723
                                textFont = m_Doc->itemToolPrefs().textFont;
14580 fschmid 724
                                bool found = false;
725
                                SCFontsIterator it(PrefsManager::instance()->appPrefs.fontPrefs.AvailFonts);
726
                                for ( ; it.hasNext(); it.next())
727
                                {
728
                                        QString fn = it.current().scName();
14586 fschmid 729
                                        if (fn == fontName)
14580 fschmid 730
                                        {
731
                                                found = true;
732
                                                break;
733
                                        }
734
                                }
735
                                if (!found)
736
                                {
14744 fschmid 737
                                        if (importerFlags & LoadSavePlugin::lfCreateThumbnail)
738
                                                fontName = PrefsManager::instance()->appPrefs.itemToolPrefs.textFont;
739
                                        else
14580 fschmid 740
                                        {
14744 fschmid 741
                                                if (!PrefsManager::instance()->appPrefs.fontPrefs.GFontSub.contains(fontName))
742
                                                {
743
                                                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
744
                                                        MissingFont *dia = new MissingFont(0, fontName, m_Doc);
745
                                                        dia->exec();
746
                                                        textFont = dia->getReplacementFont();
747
                                                        delete dia;
748
                                                        qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
749
                                                        PrefsManager::instance()->appPrefs.fontPrefs.GFontSub[fontName] = textFont;
750
                                                        fontName = textFont;
751
                                                }
752
                                                else
753
                                                        fontName = PrefsManager::instance()->appPrefs.fontPrefs.GFontSub[fontName];
14580 fschmid 754
                                        }
755
                                }
756
                        }
14579 fschmid 757
                        fontMap.insert(fontID, fontName);
758
                        cmdText += QString("DRW Font %1").arg(fontName);
14536 fschmid 759
                        break;
760
                case 22:
14560 fschmid 761
                        cmdText += "DRW Grid";
14536 fschmid 762
                        break;
763
                case 23:
14648 fschmid 764
                        cmdText += QString("DRW Overlay Name Data %1").arg(QString(cmdData).left(20));
765
                        printMSG = true;
14536 fschmid 766
                        break;
767
                case 24:
14560 fschmid 768
                        cmdText += "DRW Dimensions";
14536 fschmid 769
                        break;
770
                case 25:
771
                        ds >> data16;
772
                        scaleFactor = (1.0 / static_cast<double>(data16)) * 72.0;
14560 fschmid 773
                        cmdText += QString("DRW Resolution %1").arg(data16);
14536 fschmid 774
                        break;
775
                case 26:
14560 fschmid 776
                        cmdText += "DRW Ruler";
14536 fschmid 777
                        break;
778
                case 27:
14560 fschmid 779
                        cmdText += "DRW Page";
14536 fschmid 780
                        docWidth = getValue(ds);
781
                        docHeight = getValue(ds);
782
                        if (importerFlags & LoadSavePlugin::lfCreateDoc)
783
                        {
784
                                m_Doc->setPage(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, false);
785
                                if (docWidth > docHeight)
14991 cbradney 786
                                        m_Doc->setPageOrientation(1);
14536 fschmid 787
                                else
14991 cbradney 788
                                        m_Doc->setPageOrientation(0);
789
                                m_Doc->setPageSize("Custom");
790
                                m_Doc->changePageMargins(0, 0, 0, 0, docHeight, docWidth, docHeight, docWidth, m_Doc->pageOrientation(), m_Doc->pageSize(), m_Doc->currentPage()->pageNr(), 0);
14536 fschmid 791
                                cmdText = QString("DRW Page  Width %1  Height %2").arg(docWidth).arg(docHeight);
792
                        }
793
                        break;
794
                case 28:
14560 fschmid 795
                        cmdText += "DRW Pattern";
14586 fschmid 796
                        ds >> data8;
797
                        pattern.resize(16);
798
                        ds.readRawData(pattern.data(), 16);
799
                        patternDataMap.insert(data8, pattern);
14744 fschmid 800
                        printMSG = true;
14536 fschmid 801
                        break;
802
                case 29:
14560 fschmid 803
                        cmdText += "DRW Locked";
14536 fschmid 804
                        break;
805
                case 30:
14574 fschmid 806
                        ds >> data8;
807
                        index = data8;
808
                        ds >> data8;
809
                        gradient.type = data8;
810
                        ds >> data8;
811
                        gradient.xOffset = data8 / 100.0;
812
                        ds >> data8;
813
                        gradient.yOffset = data8 / 100.0;
814
                        ds >> data16;
815
                        gradient.angle = data16 / 10.0;
816
                        gradientMap.insert(index, gradient);
14659 fschmid 817
                        cmdText += QString("DRW Gradient  Index: %1 Type: %2 Offsets: %3 %4 Angle: %5").arg(index).arg(gradient.type).arg(gradient.xOffset).arg(gradient.yOffset).arg(gradient.angle);
818
                        printMSG = true;
14536 fschmid 819
                        break;
820
                case 31:
14560 fschmid 821
                        cmdText += "DRW Text Hdr";
14580 fschmid 822
                        ds >> data8;                                    // Version
823
                        ds >> data8;                                    // vertical alignment
824
                        cmdText += QString(" VAlign %1").arg(data8);
825
                        ds >> data16;                                   // MemFlags ????
826
                        ds >> data16;                                   // Textrotation
827
                        ds >> fontID;                                   // Font Nr
828
                        cmdText += QString(" Font %1").arg(fontID);
829
                        ds >> fontStyle;                                // Style
830
                        ds >> fontWidth;                                // Width
831
                        ds >> fontSize;                                 // Height
832
                        cmdText += QString(" Size %1").arg(fontSize);
833
                        ds >> nrOfParagraphs;                   // Nr of paragraph records
834
                        paragraphCounter = 0;
835
                        cmdText += QString(" NoPara %1").arg(nrOfParagraphs);
836
                        paragraphList.clear();
837
                        for (quint16 a = 0; a < nrOfParagraphs; a++)
838
                        {
839
                                DRWParagraph para;
840
                                ds >> data16;
841
                                ds >> data16;
842
                                ds >> data16;
843
                                ds >> para.paragraphAlignment;
844
                                ds.skipRawData(18);
845
                                ds >> para.paragraphLen;
846
                                para.paragraphLen -= 17;
847
                                ds.skipRawData(4);
848
                                paragraphList.append(para);
849
                        }
14536 fschmid 850
                        break;
851
                case 32:
14560 fschmid 852
                        cmdText += "DRW Band";
14561 fschmid 853
/* For this record the documentation is completly wrong
854
 
855
        offs    meaning
856
 
857
        2               Y-Offset
858
        4               bytes per row
859
        6               number of rows stored in this record
14580 fschmid 860
        8+              Image Data as raw uncompressed values, rows are aligned to even bytes
14561 fschmid 861
*/
862
                        if (imageValid)
863
                        {
864
                                quint16 xoff, yoff, len, count;
865
                                ds >> xoff >> yoff >> len >> count;
866
                                if (bitsPerPixel == 24)
867
                                {
868
                                        for (quint16 y = 0; y < count; y++)
869
                                        {
870
                                                QRgb *q = (QRgb*)(tmpImage.scanLine(yoff + y));
871
                                                for (quint16 x = 0; x < imageWidth; x++)
872
                                                {
873
                                                        quint8 r, g, b;
874
                                                        ds >> r >> g >> b;
875
                                                        *q = qRgba(r, g, b, 255);
876
                                                        q++;
877
                                                }
878
                                                scanLinesRead++;
879
                                        }
880
                                }
881
                                else if (bitsPerPixel == 8)
882
                                {
883
                                        for (quint16 y = 0; y < count; y++)
884
                                        {
885
                                                QRgb *q = (QRgb*)(tmpImage.scanLine(yoff + y));
14563 fschmid 886
                                                int pos = ds.device()->pos();
14561 fschmid 887
                                                for (quint16 x = 0; x < imageWidth; x++)
888
                                                {
889
                                                        quint8 r;
890
                                                        ds >> r;
891
                                                        *q = qRgba(r, r, r, 255);
892
                                                        q++;
893
                                                }
14563 fschmid 894
                                                QByteArray data;
895
                                                data.resize(imageWidth);
896
                                                ds.device()->seek(pos);
897
                                                ds.readRawData(data.data(), imageWidth);
14568 fschmid 898
                                                ds.device()->seek(pos + len);
14563 fschmid 899
                                                memcpy(tmpImage2.scanLine(yoff + y), data.data(), imageWidth);
14561 fschmid 900
                                                scanLinesRead++;
901
                                        }
902
                                }
903
                                if (scanLinesRead >= imageHeight)
904
                                {
905
                                        if (currentItem != NULL)
906
                                        {
18203 fschmid 907
                                                QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_drw_XXXXXX.png");
908
                                                tempFile->setAutoRemove(false);
909
                                                tempFile->open();
910
                                                QString fileName = getLongPathName(tempFile->fileName());
911
                                                tempFile->close();
14561 fschmid 912
                                                currentItem->isInlineImage = true;
18203 fschmid 913
                                                currentItem->isTempFile = true;
14561 fschmid 914
                                                tmpImage.save(fileName, "PNG");
915
                                                m_Doc->loadPict(fileName, currentItem);
18203 fschmid 916
                                                delete tempFile;
14561 fschmid 917
                                                currentItem->setImageScalingMode(false, false);
918
                                        }
919
                                        imageValid = false;
920
                                        tmpImage = QImage();
921
                                }
922
                        }
14536 fschmid 923
                        break;
924
                case 33:
925
                        ds >> data16;
14560 fschmid 926
                        cmdText += QString("DRW Symbolversion %1").arg(data16);
14536 fschmid 927
                        break;
928
                case 34:
14560 fschmid 929
                        cmdText += "DRW Text Para";
14580 fschmid 930
                        ds.device()->seek(0x11);
931
                        if (createObjCode == 6)
932
                        {
933
                                if (currentItem != NULL)
934
                                {
935
                                        DRWParagraph para = paragraphList.at(paragraphCounter);
936
                                        paragraphCounter++;
937
                                        ParagraphStyle newStyle;
938
                                        newStyle.setLineSpacingMode(static_cast<ParagraphStyle::LineSpacingMode>(1));
939
                                        newStyle.setAlignment(static_cast<ParagraphStyle::AlignmentType>(para.paragraphAlignment));
940
                                        newStyle.charStyle().setFontSize(fontSize * scaleFactor * 10.0 * 0.8);
14932 cbradney 941
                                        QString fontN(m_Doc->itemToolPrefs().textFont);
14580 fschmid 942
                                        if (fontMap.contains(fontID))
943
                                                fontN = fontMap[fontID];
944
                                        newStyle.charStyle().setFont((*m_Doc->AllFonts)[fontN]);
945
                                        newStyle.charStyle().setFillColor(fontColor);
946
                                        newStyle.setLineSpacing(newStyle.charStyle().font().height(fontSize * scaleFactor * 10.0 * 0.8));
947
                                        if (para.paragraphLen > 0)
948
                                        {
949
                                                int pos = currentItem->itemText.length();
950
                                                QByteArray data;
951
                                                data.resize(para.paragraphLen);
952
                                                ds.readRawData(data.data(), para.paragraphLen);
953
                                                QString chars = QString(data);
954
                                                if (!chars.isEmpty())
955
                                                {
956
                                                        currentItem->itemText.insertChars( -1, chars);
957
                                                        currentItem->itemText.applyStyle(pos, newStyle);
958
                                                }
959
                                                if (nrOfParagraphs > 0)
960
                                                        currentItem->itemText.insertChars(-1, SpecialChars::PARSEP);
961
                                        }
962
                                }
963
                        }
14536 fschmid 964
                        break;
965
                case 35:
14560 fschmid 966
                        cmdText += "DRW Colortable";
14563 fschmid 967
                        if (currentItem != NULL)
968
                        {
969
                                if (currentItem->asImageFrame())
970
                                {
18203 fschmid 971
                                        QString fileName = currentItem->Pfile;
14563 fschmid 972
                                        if (!fileName.isEmpty())
973
                                        {
974
                                                QVector<QRgb> colors;
975
                                                for (quint16 cc = 0; cc < 255; cc++)    // now reading ColorTable, exactly 1024 bytes
976
                                                {
977
                                                        quint8 r, g, b, a;
14578 fschmid 978
                                                        ds >> r >> g >> b >> a;                         // values are stored in RGB order
14563 fschmid 979
                                                        if ((r == rTrans) && (g == gTrans) && (b == bTrans))
980
                                                                colors.append(qRgba(r, g, b, 0));
981
                                                        else
982
                                                                colors.append(qRgb(r, g, b));
983
                                                }
984
                                                tmpImage2.setColorTable(colors);
985
                                                tmpImage2 = tmpImage2.convertToFormat(QImage::Format_ARGB32);
986
                                                tmpImage2.save(fileName, "PNG");
987
                                                m_Doc->loadPict(fileName, currentItem, true);
988
                                        }
989
                                }
990
                        }
14536 fschmid 991
                        break;
992
                case 36:
14560 fschmid 993
                        cmdText += "DRW Text Extra";
14536 fschmid 994
                        break;
995
                case 37:
14560 fschmid 996
                        cmdText += "DRW Max Link ID";
14536 fschmid 997
                        break;
998
                case 44:
14560 fschmid 999
                        cmdText += "Skip Symbols";
14536 fschmid 1000
                        break;
1001
                case 254:
14560 fschmid 1002
                        cmdText += "DRW EOF";
14562 fschmid 1003
                        decodeSymbol(ds, true);
14625 fschmid 1004
                        printMSG = true;
14536 fschmid 1005
                        break;
1006
                case 255:
14614 fschmid 1007
                        cmdText += QString("DRW Start File");
14625 fschmid 1008
                        printMSG = true;
14536 fschmid 1009
                        break;
1010
                default:
14625 fschmid 1011
                        cmdText += QString("Unknown Cmd-Nr %1  Data %2 Size %3").arg(cmd).arg(QString(cmdData.toHex().left(64))).arg(cmdData.size());
14536 fschmid 1012
                        break;
1013
        }
14648 fschmid 1014
        printMSG = false;
14579 fschmid 1015
        if (printMSG)
14536 fschmid 1016
        {
1017
                qDebug() << cmdText; // << QString("at %1").arg(pos, 8, 16);
1018
//              qDebug() << "\tData:" << cmdData.toHex().left(32);
14579 fschmid 1019
        }
14536 fschmid 1020
}
1021
 
14562 fschmid 1022
void DrwPlug::decodeSymbol(QDataStream &ds, bool last)
14536 fschmid 1023
{
14546 fschmid 1024
        symbolCount++;
14568 fschmid 1025
        QString cmdText = QString("Record %1 Symbol %2 Type:").arg(recordCount).arg(symbolCount);
14546 fschmid 1026
        bool printMSG = false;
1027
        double bX = 0.0;
1028
        double bY = 0.0;
14568 fschmid 1029
        double groupX = 0.0;
1030
        double groupY = 0.0;
1031
        DRWObjectList gList;
14546 fschmid 1032
        DRWGroup gElements;
1033
        DRWGroup cElements;
1034
        if (groupStack.count() > 0)
1035
        {
1036
                cElements = groupStack.top();
1037
                bX = cElements.xoffset;
1038
                bY = cElements.yoffset;
1039
                if (cElements.nrOfItems != -1)
1040
                {
1041
                        while (groupStack.count() > 1)
1042
                        {
1043
                                if (cElements.nrOfItems == cElements.counter)
1044
                                {
14568 fschmid 1045
                                        listStack.pop();
14560 fschmid 1046
                                        DRWGroup popped = groupStack.pop();
14546 fschmid 1047
                                        cElements = groupStack.top();
14560 fschmid 1048
                                        tmpSel->clear();
1049
                                        for (int dre = 0;  dre < popped.GElements.count(); ++dre)
1050
                                        {
1051
                                                tmpSel->addItem(popped.GElements.at(dre), true);
1052
                                        }
14546 fschmid 1053
                                        bX = cElements.xoffset;
1054
                                        bY = cElements.yoffset;
14562 fschmid 1055
                                        uint selectedItemCount = tmpSel->count();
1056
                                        if (selectedItemCount > 0)
14560 fschmid 1057
                                        {
14575 fschmid 1058
                                                double scx = 1.0;
1059
                                                double scy = 1.0;
14562 fschmid 1060
                                                QPainterPath gesPa;
1061
                                                bool firstP = true;
1062
                                                for (uint i = 0; i < selectedItemCount; ++i)
1063
                                                {
1064
                                                        QPainterPath pa;
1065
                                                        PageItem *item = tmpSel->itemAt(i);
1066
                                                        item->PoLine.translate(item->xPos(), item->yPos());
14648 fschmid 1067
                                                        pa = item->PoLine.toQPainterPath(false);
14564 fschmid 1068
                                                        if (!pa.isEmpty())
14562 fschmid 1069
                                                        {
14564 fschmid 1070
                                                                const QPainterPath::Element &elm = pa.elementAt(0);
14643 fschmid 1071
                                                                QPointF lastP = pa.currentPosition();
14564 fschmid 1072
                                                                bool conn = false;
14643 fschmid 1073
                                                                bool conn2 = false;
1074
                                                                if ((fabs(lastP.x() - elm.x) < 1) && (fabs(lastP.y() - elm.y) < 1))
14648 fschmid 1075
                                                                {
1076
                                                                        pa.closeSubpath();
14564 fschmid 1077
                                                                        conn = true;
14648 fschmid 1078
                                                                }
14643 fschmid 1079
                                                                if (!gesPa.isEmpty())
14564 fschmid 1080
                                                                {
14643 fschmid 1081
                                                                        const QPainterPath::Element &elm2 = gesPa.elementAt(0);
1082
                                                                        QPointF lastP2 = gesPa.currentPosition();
1083
                                                                        if ((fabs(lastP2.x() - elm2.x) < 1) && (fabs(lastP2.y() - elm2.y) < 1))
14648 fschmid 1084
                                                                        {
1085
                                                                                gesPa.closeSubpath();
14643 fschmid 1086
                                                                                conn2 = true;
14648 fschmid 1087
                                                                        }
14643 fschmid 1088
                                                                }
1089
                                                                if ((firstP) || (conn) || (conn2))
1090
                                                                {
14564 fschmid 1091
                                                                        gesPa.addPath(pa);
1092
                                                                        firstP = false;
1093
                                                                }
1094
                                                                else
1095
                                                                        gesPa.connectPath(pa);
14562 fschmid 1096
                                                        }
1097
                                                }
14614 fschmid 1098
                                                if (!gesPa.isEmpty())
1099
                                                {
14639 fschmid 1100
                                                        QRectF bb = gesPa.controlPointRect();
14632 fschmid 1101
                                                        if (popped.rotationAngle != 0)
1102
                                                        {
1103
                                                                QTransform mt;
1104
                                                                mt.translate(-bb.x(), -bb.y());
1105
                                                                gesPa = mt.map(gesPa);
1106
                                                                QTransform ma;
1107
                                                                ma.translate(popped.posPivot.x(), popped.posPivot.y());
1108
                                                                ma.rotate(-popped.rotationAngle / 10.0);
1109
                                                                gesPa = ma.map(gesPa);
1110
                                                        }
14639 fschmid 1111
                                                        bb = gesPa.controlPointRect();
14632 fschmid 1112
                                                        QTransform mt;
1113
                                                        mt.translate(-bb.x(), -bb.y());
1114
                                                        gesPa = mt.map(gesPa);
14648 fschmid 1115
                                                        if ((bb.width() != 0) && (bb.height() != 0) && (popped.width != 0) && (popped.height != 0))
1116
                                                        {
1117
                                                                if (bb.width() != popped.width)
1118
                                                                        scx = popped.width / bb.width();
1119
                                                                if (bb.height() != popped.height)
1120
                                                                        scy = popped.height / bb.height();
1121
                                                                QTransform ms;
1122
                                                                ms.scale(scx, scy);
1123
                                                                gesPa = ms.map(gesPa);
1124
                                                        }
14643 fschmid 1125
                                                        if (popped.filled)
1126
                                                                gesPa.closeSubpath();
14614 fschmid 1127
                                                        FPointArray res;
1128
                                                        res.fromQPainterPath(gesPa);
1129
                                                        PageItem *ite = tmpSel->takeItem(0);
14632 fschmid 1130
                                                        ite->setXYPos(popped.xoffset + baseX, popped.yoffset + baseY);
14614 fschmid 1131
                                                        ite->PoLine = res.copy();
1132
                                                        FPoint wh = getMaxClipF(&ite->PoLine);
1133
                                                        ite->setWidthHeight(wh.x(),wh.y());
1134
                                                        ite->OldB2 = ite->width();
1135
                                                        ite->OldH2 = ite->height();
14625 fschmid 1136
                                                        if (popped.filled)
1137
                                                                ite->setFillColor(popped.fillColor);
1138
                                                        else
1139
                                                                ite->setFillColor(CommonStrings::None);
14614 fschmid 1140
                                                        ite->setLineWidth(popped.lineWidth);
1141
                                                        ite->setLineWidth(ite->lineWidth() / qMin(scx, scy));
1142
                                                        handleLineStyle(ite, popped.flags, popped.lineColor);
14625 fschmid 1143
                                                        if (popped.filled)
1144
                                                                handleGradient(ite, popped.patternIndex, popped.fillColor, popped.backColor, QRectF(0, 0, ite->width(), ite->height()));
14614 fschmid 1145
                                                        groupStack.top().GElements.append(ite);
1146
                                                        listStack.top().GElements.append(ite);
1147
                                                }
14565 fschmid 1148
                                                selectedItemCount = tmpSel->count();
1149
                                                for (uint i = 0; i < selectedItemCount; ++i)
1150
                                                {
1151
                                                        Elements.removeAll(tmpSel->itemAt(i));
14568 fschmid 1152
                                                        listStack.top().GElements.removeAll(tmpSel->itemAt(i));
14565 fschmid 1153
                                                }
14562 fschmid 1154
                                                m_Doc->itemSelection_DeleteItem(tmpSel);
14560 fschmid 1155
                                        }
1156
                                        tmpSel->clear();
14546 fschmid 1157
                                }
1158
                                else
1159
                                        break;
1160
                        }
1161
                        groupStack.top().counter++;
1162
                }
1163
        }
14568 fschmid 1164
        if (listStack.count() > 1)
1165
        {
1166
                while (listStack.count() > 1)
1167
                {
1168
                        if (listStack.top().nrOfItems == listStack.top().counter)
1169
                        {
1170
                                DRWObjectList popped = listStack.pop();
1171
                                tmpSel->clear();
1172
                                for (int dre = 0;  dre < popped.GElements.count(); ++dre)
1173
                                {
1174
                                        tmpSel->addItem(popped.GElements.at(dre), true);
1175
                                }
1176
                                uint selectedItemCount = tmpSel->count();
1177
                                if (selectedItemCount > 0)
1178
                                {
14639 fschmid 1179
                                        if (popped.rotationAngle != 0)
14635 fschmid 1180
                                        {
1181
                                                PageItem* currItem;
1182
                                                QTransform ma;
14639 fschmid 1183
                                                ma.translate(popped.posPivot.x(), popped.posPivot.y());
1184
                                                ma.rotate(-popped.rotationAngle / 10.0);
14635 fschmid 1185
                                                FPoint n;
1186
                                                for (int a = 0; a < tmpSel->count(); ++a)
1187
                                                {
1188
                                                        currItem = tmpSel->itemAt(a);
14639 fschmid 1189
                                                        n = FPoint(currItem->xPos(), currItem->yPos());
14635 fschmid 1190
                                                        currItem->setXYPos(ma.m11() * n.x() + ma.m21() * n.y() + ma.dx(), ma.m22() * n.y() + ma.m12() * n.x() + ma.dy());
14639 fschmid 1191
                                                        currItem->rotateBy(-popped.rotationAngle / 10.0);
14635 fschmid 1192
                                                }
1193
                                        }
14639 fschmid 1194
                                        tmpSel->setGroupRect();
1195
                                        QRectF gr = tmpSel->getGroupRect();
1196
                                        double dx = popped.groupItem->xPos() - gr.x();
1197
                                        double dy = popped.groupItem->yPos() - gr.y();
1198
                                        for (int a = 0; a < tmpSel->count(); ++a)
1199
                                        {
1200
                                                tmpSel->itemAt(a)->moveBy(dx, dy);
1201
                                        }
1202
                                        tmpSel->setGroupRect();
14614 fschmid 1203
                                        if ((popped.scaleX != 0) || (popped.scaleY != 0))
14568 fschmid 1204
                                        {
14614 fschmid 1205
                                                if ((tmpSel->width() != 0) && (tmpSel->height() != 0) && (popped.width != 0) && (popped.height != 0))
1206
                                                {
1207
                                                        double scx = 1.0;
1208
                                                        if (tmpSel->width() != popped.width)
1209
                                                                scx = popped.width / tmpSel->width();
1210
                                                        double scy = 1.0;
1211
                                                        if (tmpSel->height() != popped.height)
1212
                                                                scy = popped.height / tmpSel->height();
1213
                                                        m_Doc->scaleGroup(scx, scy, true, tmpSel);
1214
                                                }
14568 fschmid 1215
                                        }
14574 fschmid 1216
                                        listStack.top().GElements.append(popped.groupItem);
14571 fschmid 1217
                                        for (uint i = 0; i < selectedItemCount; ++i)
1218
                                        {
1219
                                                PageItem *item = tmpSel->itemAt(i);
16105 fschmid 1220
                                                popped.groupItem->groupItemList.append(item);
1221
                                                item->gXpos = item->xPos() - popped.groupItem->xPos();
1222
                                                item->gYpos = item->yPos() - popped.groupItem->yPos();
16943 fschmid 1223
                                                item->Parent = popped.groupItem;
16772 fschmid 1224
                                                if (groupStack.count() > 0)
1225
                                                        groupStack.top().GElements.removeAll(tmpSel->itemAt(i));
1226
                                                Elements.removeAll(tmpSel->itemAt(i));
1227
                                                m_Doc->Items->removeAll(tmpSel->itemAt(i));
14571 fschmid 1228
                                        }
1229
                                        if (popped.itemGroupName.isEmpty())
16105 fschmid 1230
                                                popped.groupItem->setItemName( tr("Group%1").arg(m_Doc->GroupCounter));
14571 fschmid 1231
                                        else
1232
                                                popped.groupItem->setItemName(popped.itemGroupName);
1233
                                        popped.groupItem->AutoName = false;
16772 fschmid 1234
                                        popped.groupItem->groupWidth = tmpSel->width();
1235
                                        popped.groupItem->groupHeight = tmpSel->height();
14568 fschmid 1236
                                }
14570 fschmid 1237
                                m_Doc->GroupCounter++;
14568 fschmid 1238
                                tmpSel->clear();
1239
                        }
1240
                        else
1241
                                break;
1242
                }
1243
                listStack.top().counter++;
1244
                groupX = listStack.top().groupX;
1245
                groupY = listStack.top().groupY;
1246
        }
14562 fschmid 1247
        if (last)
1248
                return;
14586 fschmid 1249
/*      if ((symbolCount > 31) && (symbolCount < 33))
14546 fschmid 1250
        {
1251
                QFile f(QString("/home/franz/cmddatas%1.bin").arg(symbolCount));
1252
                f.open(QIODevice::WriteOnly);
1253
                f.write(cmdData);
1254
                f.close();
14586 fschmid 1255
        } */
14536 fschmid 1256
        int z;
14635 fschmid 1257
        quint8 data8, appFlags;
14574 fschmid 1258
        quint16 dummy, nPoints, nItems;
14536 fschmid 1259
        double boundingBoxXO, boundingBoxYO, boundingBoxWO, boundingBoxHO, cornerRadius;
1260
        QRectF bBoxO;
14538 fschmid 1261
        QString fillC = CommonStrings::None;
14536 fschmid 1262
        createObjCode = 0;
1263
        currentItem = NULL;
1264
        ds >> data8;                                                    // reading Symbol Type
1265
// now reading common values
1266
        ds >> flags;
14574 fschmid 1267
        QPainterPath path;
14614 fschmid 1268
        QPointF posEnd, posMid, posStart;
14580 fschmid 1269
        QLineF sLin, eLin;
18148 fschmid 1270
        getCoordinate(ds);                                              // don't remove dummy parameters
14536 fschmid 1271
        double boundingBoxX = getValue(ds);
1272
        double boundingBoxY = getValue(ds);
1273
        double boundingBoxW = getValue(ds);
1274
        double boundingBoxH = getValue(ds);
14635 fschmid 1275
        bBox = QRectF(QPointF(boundingBoxX, boundingBoxY), QPointF(boundingBoxW, boundingBoxH)).normalized();
14625 fschmid 1276
        rotationAngle = getRawValue(ds);
14614 fschmid 1277
        scaleX = getRawValue(ds);
1278
        scaleY = getRawValue(ds);
14578 fschmid 1279
        double rotS, rotE;
14579 fschmid 1280
        double posX = baseX + bBox.x() + bX + groupX;
1281
        double posY = baseY + bBox.y() + bY + groupY;
14536 fschmid 1282
        lineColor = getColor(ds);
1283
        ds >> dummy;            // handle
1284
        ds >> dummy;            // next
1285
        ds >> dummy;
1286
        ds >> dummy;            // prev
1287
        ds >> dummy;
1288
        switch (data8)                  // Symbol type is in the first data byte
1289
        {
1290
                case 0:
1291
                        cmdText += "elliptical Arc";
14578 fschmid 1292
                        ds >> patternIndex;
1293
                        fillColor = getColor(ds);
1294
                        if (patternIndex != 0)
1295
                                fillC = fillColor;
1296
                        posStart = getCoordinate(ds);
1297
                        posEnd = getCoordinate(ds);
14614 fschmid 1298
                        if (posStart == posEnd)
1299
                                break;
14578 fschmid 1300
                        boundingBoxXO = getValue(ds);
1301
                        boundingBoxYO = getValue(ds);
1302
                        boundingBoxWO = getValue(ds);
1303
                        boundingBoxHO = getValue(ds);
14639 fschmid 1304
                        getCommonData(ds);
14614 fschmid 1305
                        bBoxO = QRectF(QPointF(boundingBoxXO, boundingBoxYO), QPointF(boundingBoxWO, boundingBoxHO)).normalized();
1306
                        sLin = QLineF(bBoxO.center(), posStart);
1307
                        eLin = QLineF(bBoxO.center(), posEnd);
14580 fschmid 1308
                        rotS = sLin.angle();
1309
                        rotE = eLin.angle();
14639 fschmid 1310
                        if (rotS > rotE)
1311
                                rotS = rotS - 360;
14578 fschmid 1312
                        rotE = rotE - rotS;
1313
                        path = QPainterPath();
14614 fschmid 1314
                        path.arcMoveTo(bBoxO, rotS);
1315
                        path.arcTo(bBoxO, rotS, rotE);
14644 fschmid 1316
                        scaleX = 1;
1317
                        scaleY = 1;
14579 fschmid 1318
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14578 fschmid 1319
                        currentItem = m_Doc->Items->at(z);
1320
                        currentItem->PoLine.fromQPainterPath(path);
14639 fschmid 1321
                        bBoxO = path.controlPointRect();
14614 fschmid 1322
                        currentItem->PoLine.translate(-bBoxO.x(), -bBoxO.y());
14578 fschmid 1323
                        handleLineStyle(currentItem, flags, lineColor);
1324
                        finishItem(currentItem);
14536 fschmid 1325
                        break;
1326
                case 1:
1327
                        cmdText += "filled Polygon";
1328
                        ds >> patternIndex;
1329
                        fillColor = getColor(ds);
14538 fschmid 1330
                        if (patternIndex != 0)
1331
                                fillC = fillColor;
14536 fschmid 1332
                        ds >> dummy;
1333
                        ds >> nPoints;
1334
                        ds >> appFlags;
14639 fschmid 1335
                        getCommonData(ds);
14536 fschmid 1336
                        nrOfPoints = nPoints;
1337
                        createObjCode = 1;
14579 fschmid 1338
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14536 fschmid 1339
                        currentItem = m_Doc->Items->at(z);
14574 fschmid 1340
                        handleLineStyle(currentItem, flags, lineColor);
1341
                        handleGradient(currentItem, patternIndex, fillColor, backColor, bBox);
14536 fschmid 1342
                        break;
1343
                case 2:
14639 fschmid 1344
                        getCommonData(ds);
14568 fschmid 1345
                        ds.device()->seek(0x26);
1346
                        ds >> dummy;
14659 fschmid 1347
                        if (dummy > 0)
1348
                        {
16105 fschmid 1349
                                z = m_Doc->itemAdd(PageItem::Group, PageItem::Rectangle, posX, posY, bBox.width(), bBox.height(), 0, fillC, fillC, true);
14659 fschmid 1350
                                gList.groupItem = m_Doc->Items->at(z);
1351
                                gList.groupX = groupX + bBox.x();
1352
                                gList.groupY = groupY + bBox.y();
1353
                                gList.width = bBox.width();
1354
                                gList.height = bBox.height();
1355
                                gList.scaleX = scaleX;
1356
                                gList.scaleY = scaleY;
1357
                                gList.rotationAngle = rotationAngle;
1358
                                gList.nrOfItems = dummy;
1359
                                gList.counter = 0;
1360
                                gList.posPivot = posPivot;
1361
                                gList.itemGroupName = "";
1362
                                gList.GElements.clear();
1363
                                listStack.push(gList);
1364
                                gList.groupItem->ClipEdited = true;
1365
                                gList.groupItem->FrameType = 3;
1366
                                gList.groupItem->setTextFlowMode(PageItem::TextFlowDisabled);
1367
                                gList.groupItem->OldB2 = gList.groupItem->width();
1368
                                gList.groupItem->OldH2 = gList.groupItem->height();
1369
                                gList.groupItem->updateClip();
1370
                                Elements.append(gList.groupItem);
1371
                        }
14568 fschmid 1372
                        cmdText += QString("Group  Count %1").arg(dummy);
14536 fschmid 1373
                        break;
1374
                case 3:
1375
                        cmdText += "Ellipse";
1376
                        ds >> patternIndex;
1377
                        fillColor = getColor(ds);
14560 fschmid 1378
                        if (patternIndex != 0)
1379
                                fillC = fillColor;
14536 fschmid 1380
                        boundingBoxXO = getValue(ds);
1381
                        boundingBoxYO = getValue(ds);
1382
                        boundingBoxWO = getValue(ds);
1383
                        boundingBoxHO = getValue(ds);
1384
                        bBoxO = QRectF(QPointF(boundingBoxXO, boundingBoxYO), QPointF(boundingBoxWO, boundingBoxHO));
1385
                        cornerRadius = getValue(ds);
1386
                        ds >> appFlags;
14639 fschmid 1387
                        getCommonData(ds);
14579 fschmid 1388
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Ellipse, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14536 fschmid 1389
                        currentItem = m_Doc->Items->at(z);
1390
                        finishItem(currentItem);
14635 fschmid 1391
                        if (currentItem != NULL)
1392
                        {
1393
                                handleLineStyle(currentItem, flags, lineColor);
1394
                                handleGradient(currentItem, patternIndex, fillColor, backColor, bBox);
1395
                        }
14536 fschmid 1396
                        break;
1397
                case 5:
1398
                        cmdText += "Text";
14579 fschmid 1399
                        ds >> dummy;
1400
                        ds >> fontID;
1401
                        ds >> nrOfChars;
1402
                        ds >> fontSize;
14648 fschmid 1403
                        fontColor = lineColor;
14579 fschmid 1404
                        createObjCode = 5;
1405
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), 0, lineColor, CommonStrings::None, true);
1406
                        currentItem = m_Doc->Items->at(z);
14614 fschmid 1407
                        scaleX = 0;
14536 fschmid 1408
                        break;
1409
                case 6:
1410
                        cmdText += "Line";
14568 fschmid 1411
                        posEnd = getCoordinate(ds);
1412
                        posStart = getCoordinate(ds);
14589 fschmid 1413
                        if (posStart == posEnd)
1414
                                break;
14568 fschmid 1415
                        ds >> patternIndex;
14639 fschmid 1416
                        getCommonData(ds);
14568 fschmid 1417
                        lineWidth = patternIndex * scaleFactor;
14581 fschmid 1418
                        path = QPainterPath();
1419
                        path.moveTo(posStart);
1420
                        path.lineTo(posEnd);
14579 fschmid 1421
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14568 fschmid 1422
                        currentItem = m_Doc->Items->at(z);
14581 fschmid 1423
                        currentItem->PoLine.fromQPainterPath(path);
14614 fschmid 1424
                        bBoxO = path.boundingRect();
14581 fschmid 1425
                        currentItem->PoLine.translate(-bBoxO.x(), -bBoxO.y());
14574 fschmid 1426
                        handleLineStyle(currentItem, flags, lineColor);
14568 fschmid 1427
                        finishItem(currentItem);
14536 fschmid 1428
                        break;
1429
                case 8:
1430
                        cmdText += "Polyline";
1431
                        ds >> patternIndex;
1432
                        fillColor = getColor(ds);
14560 fschmid 1433
                        if (patternIndex != 0)
1434
                                fillC = fillColor;
14536 fschmid 1435
                        ds >> dummy;
1436
                        ds >> nPoints;
1437
                        ds >> appFlags;
14639 fschmid 1438
                        getCommonData(ds);
14536 fschmid 1439
                        nrOfPoints = nPoints;
14547 fschmid 1440
                        createObjCode = 3;
14579 fschmid 1441
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14536 fschmid 1442
                        currentItem = m_Doc->Items->at(z);
14574 fschmid 1443
                        handleLineStyle(currentItem, flags, lineColor);
14536 fschmid 1444
                        break;
1445
                case 9:
1446
                        cmdText += "Pie Wedge";
14625 fschmid 1447
                        printMSG = true;
14536 fschmid 1448
                        break;
1449
                case 10:
1450
                case 11:
1451
                        if (data8 == 10)
1452
                                cmdText += "Rectangle";
1453
                        else
1454
                                cmdText += "Rounded Rectangle";
1455
                        ds >> patternIndex;
1456
                        fillColor = getColor(ds);
14538 fschmid 1457
                        if (patternIndex != 0)
1458
                                fillC = fillColor;
14536 fschmid 1459
                        boundingBoxXO = getValue(ds);
1460
                        boundingBoxYO = getValue(ds);
1461
                        boundingBoxWO = getValue(ds);
1462
                        boundingBoxHO = getValue(ds);
1463
                        cornerRadius = getValue(ds);
1464
                        bBoxO = QRectF(QPointF(boundingBoxXO, boundingBoxYO), QPointF(boundingBoxWO, boundingBoxHO));
1465
                        ds >> appFlags;
14639 fschmid 1466
                        getCommonData(ds);
14579 fschmid 1467
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14536 fschmid 1468
                        currentItem = m_Doc->Items->at(z);
14574 fschmid 1469
                        handleLineStyle(currentItem, flags, lineColor);
14536 fschmid 1470
                        finishItem(currentItem);
14614 fschmid 1471
                        if (currentItem != NULL)
1472
                        {
1473
                                if (data8 == 11)
1474
                                        currentItem->setCornerRadius(cornerRadius);
1475
                                handleGradient(currentItem, patternIndex, fillColor, backColor, bBox);
1476
                        }
14536 fschmid 1477
                        break;
1478
                case 13:
1479
                        cmdText += "filled Ellipse";
1480
                        ds >> patternIndex;
1481
                        fillColor = getColor(ds);
14538 fschmid 1482
                        if (patternIndex != 0)
1483
                                fillC = fillColor;
14536 fschmid 1484
                        boundingBoxXO = getValue(ds);
1485
                        boundingBoxYO = getValue(ds);
1486
                        boundingBoxWO = getValue(ds);
1487
                        boundingBoxHO = getValue(ds);
1488
                        bBoxO = QRectF(QPointF(boundingBoxXO, boundingBoxYO), QPointF(boundingBoxWO, boundingBoxHO));
1489
                        cornerRadius = getValue(ds);
1490
                        ds >> appFlags;
14639 fschmid 1491
                        getCommonData(ds);
14579 fschmid 1492
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Ellipse, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14536 fschmid 1493
                        currentItem = m_Doc->Items->at(z);
14574 fschmid 1494
                        handleLineStyle(currentItem, flags, lineColor);
14536 fschmid 1495
                        finishItem(currentItem);
14614 fschmid 1496
                        if (currentItem != NULL)
1497
                                handleGradient(currentItem, patternIndex, fillColor, backColor, bBox);
14536 fschmid 1498
                        break;
1499
                case 14:
1500
                        cmdText += "elliptical Arc, clockwise";
14581 fschmid 1501
                        ds >> patternIndex;
1502
                        fillColor = getColor(ds);
1503
                        if (patternIndex != 0)
1504
                                fillC = fillColor;
1505
                        posStart = getCoordinate(ds);
1506
                        posEnd = getCoordinate(ds);
14614 fschmid 1507
                        if (posStart == posEnd)
1508
                                break;
14581 fschmid 1509
                        boundingBoxXO = getValue(ds);
1510
                        boundingBoxYO = getValue(ds);
1511
                        boundingBoxWO = getValue(ds);
1512
                        boundingBoxHO = getValue(ds);
14639 fschmid 1513
                        getCommonData(ds);
14614 fschmid 1514
                        bBoxO = QRectF(QPointF(boundingBoxXO, boundingBoxYO), QPointF(boundingBoxWO, boundingBoxHO)).normalized();
1515
                        sLin = QLineF(bBoxO.center(), posStart);
1516
                        eLin = QLineF(bBoxO.center(), posEnd);
14581 fschmid 1517
                        rotS = sLin.angle();
1518
                        rotE = eLin.angle();
14644 fschmid 1519
                        if (rotS < rotE)
1520
                                rotS = rotS + 360;
1521
                        rotE = rotS - rotE;
14581 fschmid 1522
                        path = QPainterPath();
14614 fschmid 1523
                        path.arcMoveTo(bBoxO, rotS);
14644 fschmid 1524
                        path.arcTo(bBoxO, rotS, -rotE);
1525
                        scaleX = 1;
1526
                        scaleY = 1;
14581 fschmid 1527
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
1528
                        currentItem = m_Doc->Items->at(z);
1529
                        currentItem->PoLine.fromQPainterPath(path);
14639 fschmid 1530
                        bBoxO = path.controlPointRect();
14614 fschmid 1531
                        currentItem->PoLine.translate(-bBoxO.x(), -bBoxO.y());
14581 fschmid 1532
                        handleLineStyle(currentItem, flags, lineColor);
1533
                        finishItem(currentItem);
14536 fschmid 1534
                        break;
1535
                case 15:
1536
                        cmdText += "filled parabolic Arc";
14614 fschmid 1537
                        ds >> patternIndex;
1538
                        fillColor = getColor(ds);
1539
                        if (patternIndex != 0)
1540
                                fillC = fillColor;
1541
                        posStart = getCoordinate(ds);
1542
                        posMid = getCoordinate(ds);
1543
                        posEnd = getCoordinate(ds);
1544
                        if (posStart == posEnd)
1545
                                break;
14639 fschmid 1546
                        getCommonData(ds);
14614 fschmid 1547
                        path = QPainterPath();
1548
                        path.moveTo(posStart);
14615 fschmid 1549
                        path.cubicTo(posMid, posMid, posEnd);
1550
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14614 fschmid 1551
                        currentItem = m_Doc->Items->at(z);
1552
                        currentItem->PoLine.fromQPainterPath(path);
14639 fschmid 1553
                        bBoxO = path.controlPointRect();
14614 fschmid 1554
                        currentItem->PoLine.translate(-bBoxO.x(), -bBoxO.y());
1555
                        finishItem(currentItem);
14635 fschmid 1556
                        if (currentItem != NULL)
1557
                        {
1558
                                handleLineStyle(currentItem, flags, lineColor);
1559
                                handleGradient(currentItem, patternIndex, fillColor, backColor, bBox);
1560
                        }
14536 fschmid 1561
                        break;
1562
                case 16:
1563
                        cmdText += "filled quadratic Spline";
14574 fschmid 1564
                        ds >> patternIndex;
1565
                        fillColor = getColor(ds);
1566
                        if (patternIndex != 0)
1567
                                fillC = fillColor;
1568
                        ds >> dummy;
1569
                        ds >> nPoints;
1570
                        ds >> appFlags;
14639 fschmid 1571
                        getCommonData(ds);
14574 fschmid 1572
                        nrOfPoints = nPoints;
14589 fschmid 1573
                        createObjCode = 4;
14615 fschmid 1574
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14589 fschmid 1575
                        currentItem = m_Doc->Items->at(z);
1576
                        handleLineStyle(currentItem, flags, lineColor);
1577
                        handleGradient(currentItem, patternIndex, fillColor, backColor, bBox);
14536 fschmid 1578
                        break;
1579
                case 17:
14614 fschmid 1580
                case 20:
14560 fschmid 1581
                        ds >> patternIndex;
1582
                        fillColor = getColor(ds);
14546 fschmid 1583
                        ds.device()->seek(0x2B);
14574 fschmid 1584
                        ds >> nItems;
14546 fschmid 1585
                        ds >> dummy;
14574 fschmid 1586
                        ds >> appFlags;
14639 fschmid 1587
                        getCommonData(ds);
14568 fschmid 1588
                        gElements.xoffset = bX + bBox.x() + groupX;
1589
                        gElements.yoffset = bY + bBox.y() + groupY;
14560 fschmid 1590
                        gElements.width = bBox.width();
1591
                        gElements.height = bBox.height();
14574 fschmid 1592
                        gElements.lineWidth = lineWidth;
14614 fschmid 1593
                        gElements.scaleX = scaleX;
1594
                        gElements.scaleY = scaleY;
14632 fschmid 1595
                        gElements.rotationAngle = rotationAngle;
1596
                        gElements.posPivot = posPivot;
14625 fschmid 1597
                        if (data8 == 17)
1598
                                gElements.filled = true;
1599
                        else
1600
                                gElements.filled = false;
14574 fschmid 1601
                        gElements.nrOfItems = nItems;
14546 fschmid 1602
                        gElements.counter = 0;
14560 fschmid 1603
                        gElements.patternIndex = patternIndex;
14574 fschmid 1604
                        gElements.flags = flags;
14560 fschmid 1605
                        gElements.fillColor = fillColor;
14562 fschmid 1606
                        gElements.lineColor = lineColor;
14574 fschmid 1607
                        gElements.backColor = backColor;
14546 fschmid 1608
                        groupStack.push(gElements);
14568 fschmid 1609
                        gList.groupX = groupX;
1610
                        gList.groupY = groupY;
1611
                        gList.width = bBox.width();
1612
                        gList.height = bBox.height();
1613
                        gList.nrOfItems = 0xFFFF;
1614
                        gList.counter = 0;
1615
                        listStack.push(gList);
14614 fschmid 1616
                        cmdText += QString("filled complex Object Count %1  Scale %2 %3 LW %4").arg(nItems).arg(scaleX).arg(scaleY).arg(lineWidth);
14536 fschmid 1617
                        break;
1618
                case 18:
1619
                        cmdText += "parabolic Arc";
14614 fschmid 1620
                        ds >> patternIndex;
1621
                        fillColor = getColor(ds);
1622
                        if (patternIndex != 0)
1623
                                fillC = fillColor;
1624
                        posStart = getCoordinate(ds);
1625
                        posMid = getCoordinate(ds);
1626
                        posEnd = getCoordinate(ds);
1627
                        if (posStart == posEnd)
1628
                                break;
14639 fschmid 1629
                        getCommonData(ds);
14614 fschmid 1630
                        path = QPainterPath();
1631
                        path.moveTo(posStart);
14615 fschmid 1632
                        path.cubicTo(posMid, posMid, posEnd);
1633
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14614 fschmid 1634
                        currentItem = m_Doc->Items->at(z);
1635
                        currentItem->PoLine.fromQPainterPath(path);
14639 fschmid 1636
                        bBoxO = path.controlPointRect();
14614 fschmid 1637
                        currentItem->PoLine.translate(-bBoxO.x(), -bBoxO.y());
1638
                        handleLineStyle(currentItem, flags, lineColor);
1639
                        finishItem(currentItem);
14536 fschmid 1640
                        break;
1641
                case 19:
1642
                        cmdText += "quadratic Spline";
14574 fschmid 1643
                        ds >> patternIndex;
1644
                        fillColor = getColor(ds);
1645
                        if (patternIndex != 0)
1646
                                fillC = fillColor;
1647
                        ds >> dummy;
1648
                        ds >> nPoints;
1649
                        ds >> appFlags;
14639 fschmid 1650
                        getCommonData(ds);
14574 fschmid 1651
                        nrOfPoints = nPoints;
14589 fschmid 1652
                        createObjCode = 4;
14614 fschmid 1653
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14589 fschmid 1654
                        currentItem = m_Doc->Items->at(z);
1655
                        handleLineStyle(currentItem, flags, lineColor);
14536 fschmid 1656
                        break;
1657
                case 22:
1658
                        cmdText += "Bitmap monochrome";
14561 fschmid 1659
                        ds >> dummy;
1660
                        boundingBoxXO = getValue(ds);
1661
                        boundingBoxYO = getValue(ds);
1662
                        boundingBoxWO = getValue(ds);
1663
                        boundingBoxHO = getValue(ds);
1664
                        ds >> bitsPerPixel;
1665
                        ds >> bytesScanline;
1666
                        ds >> planes;
1667
                        ds >> imageHeight;
1668
                        ds >> imageWidth;
14563 fschmid 1669
                        ds >> dummy;
1670
                        ds >> rTrans;
1671
                        ds >> gTrans;
1672
                        ds >> bTrans;
14639 fschmid 1673
                        getCommonData(ds);
14561 fschmid 1674
                        if ((bitsPerPixel == 24) || (bitsPerPixel == 8))
1675
                        {
14579 fschmid 1676
                                z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Rectangle, posX, posY, bBox.width(), bBox.height(), lineWidth, CommonStrings::None, CommonStrings::None, true);
14561 fschmid 1677
                                currentItem = m_Doc->Items->at(z);
1678
                                finishItem(currentItem);
1679
                                scanLinesRead = 0;
1680
                                tmpImage = QImage(imageWidth, imageHeight, QImage::Format_ARGB32);
14563 fschmid 1681
                                if (bitsPerPixel == 8)
1682
                                        tmpImage2 = QImage(imageWidth, imageHeight, QImage::Format_Indexed8);
14561 fschmid 1683
                                imageValid = true;
1684
                        }
14536 fschmid 1685
                        break;
1686
                case 23:
1687
                        cmdText += "Bezier line";
14538 fschmid 1688
                        ds >> patternIndex;
1689
                        fillColor = getColor(ds);
14560 fschmid 1690
                        if (patternIndex != 0)
1691
                                fillC = fillColor;
14538 fschmid 1692
                        ds >> dummy;
1693
                        ds >> nPoints;
1694
                        ds >> appFlags;
14639 fschmid 1695
                        getCommonData(ds);
14538 fschmid 1696
                        nrOfPoints = nPoints;
1697
                        createObjCode = 2;
14579 fschmid 1698
                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14538 fschmid 1699
                        currentItem = m_Doc->Items->at(z);
14574 fschmid 1700
                        handleLineStyle(currentItem, flags, lineColor);
14536 fschmid 1701
                        break;
1702
                case 24:
1703
                        cmdText += "filled Bezier line";
14538 fschmid 1704
                        ds >> patternIndex;
1705
                        fillColor = getColor(ds);
1706
                        if (patternIndex != 0)
1707
                                fillC = fillColor;
1708
                        ds >> dummy;
1709
                        ds >> nPoints;
1710
                        ds >> appFlags;
14639 fschmid 1711
                        getCommonData(ds);
14538 fschmid 1712
                        nrOfPoints = nPoints;
1713
                        createObjCode = 2;
14579 fschmid 1714
                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, posX, posY, bBox.width(), bBox.height(), lineWidth, fillC, lineColor, true);
14538 fschmid 1715
                        currentItem = m_Doc->Items->at(z);
14574 fschmid 1716
                        handleLineStyle(currentItem, flags, lineColor);
1717
                        handleGradient(currentItem, patternIndex, fillColor, backColor, bBox);
14536 fschmid 1718
                        break;
1719
                case 25:
1720
                        cmdText += "Rich Text";
14580 fschmid 1721
                        fontColor = lineColor;
14639 fschmid 1722
                        getCommonData(ds);
14580 fschmid 1723
                        createObjCode = 6;
1724
                        z = m_Doc->itemAdd(PageItem::TextFrame, PageItem::Rectangle, posX, posY, bBox.width(), bBox.height(), 0, CommonStrings::None, CommonStrings::None, true);
1725
                        currentItem = m_Doc->Items->at(z);
1726
                        currentItem->setTextToFrameDist(0.0, 0.0, 0.0, 0.0);
1727
                        finishItem(currentItem);
14536 fschmid 1728
                        break;
1729
                case 26:
1730
                        cmdText += "virtual Bitmap";
14625 fschmid 1731
                        printMSG = true;
14536 fschmid 1732
                        break;
1733
                case 27:
1734
                        cmdText += "simple Clip Path";
14625 fschmid 1735
                        printMSG = true;
14536 fschmid 1736
                        break;
1737
                case 28:
1738
                        cmdText += "tiled Clip Path";
14625 fschmid 1739
                        printMSG = true;
14536 fschmid 1740
                        break;
1741
                case 29:
1742
                        cmdText += "Path Text";
14625 fschmid 1743
                        printMSG = true;
14536 fschmid 1744
                        break;
14546 fschmid 1745
                default:
1746
                        cmdText += "Unknown";
1747
                        break;
14536 fschmid 1748
        }
14744 fschmid 1749
        printMSG = false;
14536 fschmid 1750
        if (printMSG)
1751
        {
14574 fschmid 1752
                if (currentItem != NULL)
1753
                        qDebug() << cmdText << " " << currentItem->itemName();
1754
                else
1755
                        qDebug() << cmdText;
14570 fschmid 1756
//              if (imageValid)
1757
//                      qDebug() << "Bits/Pixel" << bitsPerPixel << "Bytes" << bytesScanline << "Planes" << planes << "Height" << imageHeight << "Width" << imageWidth;
14579 fschmid 1758
//              qDebug() << "Pos" << rotS << " --> " << rotE << " Box " << boundingBoxWO << boundingBoxHO;
14536 fschmid 1759
//              qDebug() << "Rot" << rotationAngle << "Bounding Box" << bBoxO;
14546 fschmid 1760
//              qDebug() << "Line" << lineColor << "LWidth" << lineWidth << "Fill" << fillColor;
14536 fschmid 1761
//              qDebug() << "Scale" << scaleX << " " << scaleY;
14561 fschmid 1762
//              qDebug() << QString("Flags %1").arg(flags, 8, 2, QChar('0')) << QString("Pattern %1").arg(patternIndex, 2, 16, QChar('0'));
14574 fschmid 1763
//              if (createObjCode == 4)
1764
//              {
14536 fschmid 1765
//                      qDebug() << "Expecting" << nrOfPoints;
14574 fschmid 1766
//              }
14536 fschmid 1767
        }
1768
}
1769
 
14574 fschmid 1770
void DrwPlug::handleLineStyle(PageItem* currentItem, quint8 flags, QString lineColor)
1771
{
1772
        if ((flags & 0x0F) == 5)
1773
                currentItem->setLineColor(CommonStrings::None);
1774
        else
1775
                currentItem->setLineColor(lineColor);
1776
        if ((flags & 0x0F) == 0)
1777
                currentItem->setLineStyle(Qt::SolidLine);
1778
        else if ((flags & 0x0F) == 1)
1779
                currentItem->setLineStyle(Qt::DashLine);
1780
        else if ((flags & 0x0F) == 2)
1781
                currentItem->setLineStyle(Qt::DotLine);
1782
        else if ((flags & 0x0F) == 3)
1783
                currentItem->setLineStyle(Qt::DashDotLine);
1784
        else
1785
                currentItem->setLineStyle(Qt::SolidLine);
1786
}
1787
 
1788
void DrwPlug::handleGradient(PageItem* currentItem, quint8 patternIndex, QString fillColor, QString backColor, QRectF bBox)
1789
{
1790
        if ((fillColor == CommonStrings::None) || (backColor == CommonStrings::None))
1791
                return;
1792
        if ((patternIndex > 0x40) && (patternIndex < 0x80))
1793
        {
1794
                quint8 ind = patternIndex - 0x40;
1795
                DRWGradient grad;
1796
                if (gradientMap.contains(ind))
1797
                {
1798
                        grad = gradientMap[ind];
14659 fschmid 1799
                        if (grad.xOffset > 1)
1800
                                grad.xOffset -= 1;
1801
                        if (grad.yOffset > 1)
1802
                                grad.yOffset -= 1;
14574 fschmid 1803
                        double xoff = bBox.width() * grad.xOffset;
1804
                        double yoff = bBox.height() * grad.yOffset;
1805
                        VGradient FillGradient = VGradient(VGradient::linear);
1806
                        FillGradient.clearStops();
1807
                        const ScColor& gradC1 = m_Doc->PageColors[fillColor];
1808
                        FillGradient.addStop( ScColorEngine::getRGBColor(gradC1, m_Doc), 0.0, 0.5, 1.0, fillColor, 100 );
1809
                        const ScColor& gradC2 = m_Doc->PageColors[backColor];
1810
                        if (grad.type == 1)
1811
                        {
14659 fschmid 1812
                                FillGradient.addStop( ScColorEngine::getRGBColor(gradC2, m_Doc), qMin(grad.yOffset, 0.99), 0.5, 1.0, backColor, 100 );
1813
                                FillGradient.addStop( ScColorEngine::getRGBColor(gradC1, m_Doc), 1.0, 0.5, 1.0, fillColor, 100 );
14574 fschmid 1814
                                currentItem->GrType = 6;
1815
                                currentItem->fill_gradient = FillGradient;
14659 fschmid 1816
                                currentItem->setGradientVector(bBox.width() / 2.0, 0, bBox.width() / 2.0, bBox.height(), 0, 0, 1, 0);
14574 fschmid 1817
                        }
1818
                        else
1819
                        {
14659 fschmid 1820
                                FillGradient.addStop( ScColorEngine::getRGBColor(gradC2, m_Doc), 1.0, 0.5, 1.0, backColor, 100 );
14574 fschmid 1821
                                currentItem->GrType = 7;
1822
                                currentItem->fill_gradient = FillGradient;
14659 fschmid 1823
                                currentItem->setGradientVector(xoff, yoff, qMax(bBox.width(), bBox.height()), qMax(bBox.width(), bBox.height()), xoff, yoff, 1, 0);
14574 fschmid 1824
                        }
1825
                }
1826
        }
14586 fschmid 1827
        else if (((patternIndex > 0x80) && (patternIndex < 0xC0)) || (patternIndex > 0xC0))
1828
        {
1829
                int ind;
1830
                if (patternIndex > 0xC0)
1831
                        ind = patternIndex - 0xC0;
1832
                else
1833
                        ind = patternIndex - 0x80;
1834
                if (patternDataMap.contains(ind))
1835
                {
1836
                        QColor back = ScColorEngine::getRGBColor(m_Doc->PageColors[fillColor], m_Doc);
1837
                        QColor fore = ScColorEngine::getRGBColor(m_Doc->PageColors[backColor], m_Doc);
1838
                        QString patNa = QString("%1%2%3").arg(back.name()).arg(fore.name()).arg(ind);
1839
                        QString patternName;
1840
                        if (!patternMap.contains(patNa))
1841
                        {
1842
                                uint oldNum = m_Doc->TotalItems;
1843
                                QByteArray data = patternDataMap[ind];
1844
                                QVector<QRgb> colors;
1845
                                int offs = 0;
1846
                                QImage image;
1847
                                if (patternIndex > 0xC0)
1848
                                {
14588 fschmid 1849
                                        colors.append(qRgb(255,255,255));
1850
                                        colors.append(back.rgb());
14586 fschmid 1851
                                        image = QImage(16, 8, QImage::Format_Mono);
1852
                                        image.setColorTable(colors);
1853
                                        for (int rr = 0; rr < 8; rr++)
1854
                                        {
1855
                                                uchar *q = (uchar*)(image.scanLine(rr));
1856
                                                *q++ = data[offs++];
1857
                                                *q++ = data[offs++];
1858
                                        }
14635 fschmid 1859
                                        image = image.scaled(96, 48);
14586 fschmid 1860
                                }
1861
                                else
1862
                                {
14588 fschmid 1863
                                        colors.append(back.rgb());
1864
                                        colors.append(fore.rgb());
14586 fschmid 1865
                                        image = QImage(8, 8, QImage::Format_Mono);
1866
                                        image.setColorTable(colors);
1867
                                        for (int rr = 0; rr < 8; rr++)
1868
                                        {
1869
                                                uchar *q = (uchar*)(image.scanLine(rr));
1870
                                                *q++ = data[offs++];
1871
                                                offs++;
1872
                                        }
14635 fschmid 1873
                                        image = image.scaled(48, 48);
14586 fschmid 1874
                                }
1875
                                image = image.convertToFormat(QImage::Format_ARGB32);
1876
                                ScPattern pat = ScPattern();
1877
                                pat.setDoc(m_Doc);
1878
                                PageItem* newItem = new PageItem_ImageFrame(m_Doc, 0, 0, 1, 1, 0, CommonStrings::None, CommonStrings::None);
18203 fschmid 1879
                                QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_drw_XXXXXX.png");
1880
                                tempFile->setAutoRemove(false);
1881
                                tempFile->open();
1882
                                QString fileName = getLongPathName(tempFile->fileName());
1883
                                tempFile->close();
1884
                                delete tempFile;
14586 fschmid 1885
                                newItem->isInlineImage = true;
18203 fschmid 1886
                                newItem->isTempFile = true;
14588 fschmid 1887
                                image.setDotsPerMeterY(2834);
1888
                                image.setDotsPerMeterX(2834);
14586 fschmid 1889
                                image.save(fileName, "PNG");
1890
                                if (newItem->loadImage(fileName, false, 72, false))
1891
                                {
1892
                                        pat.width = image.width();
1893
                                        pat.height = image.height();
1894
                                        pat.scaleX = (72.0 / newItem->pixm.imgInfo.xres) * newItem->pixm.imgInfo.lowResScale;
1895
                                        pat.scaleY = (72.0 / newItem->pixm.imgInfo.xres) * newItem->pixm.imgInfo.lowResScale;
1896
                                        pat.pattern = newItem->pixm.qImage().copy();
1897
                                        newItem->setWidth(pat.pattern.width());
1898
                                        newItem->setHeight(pat.pattern.height());
1899
                                        newItem->SetRectFrame();
1900
                                        newItem->gXpos = 0.0;
1901
                                        newItem->gYpos = 0.0;
1902
                                        newItem->gWidth = pat.pattern.width();
1903
                                        newItem->gHeight = pat.pattern.height();
1904
                                        pat.items.append(newItem);
1905
                                }
1906
                                patternName = "Pattern_"+newItem->itemName();
1907
                                patternName = patternName.trimmed().simplified().replace(" ", "_");
1908
                                m_Doc->addPattern(patternName, pat);
1909
                                patternMap.insert(patNa, patternName);
1910
                                m_Doc->TotalItems = oldNum;
1911
                        }
1912
                        else
1913
                                patternName = patternMap[patNa];
1914
                        importedPatterns.append(patternName);
1915
                        currentItem->setPattern(patternName);
14635 fschmid 1916
                        currentItem->setPatternTransform(16.6666, 16.6666, 0, 0, 0, 0, 0);
14586 fschmid 1917
                        currentItem->GrType = 8;
1918
                }
1919
        }
14574 fschmid 1920
}
1921
 
14536 fschmid 1922
void DrwPlug::handlePreviewBitmap(QDataStream &ds)
1923
{
14659 fschmid 1924
        /* create a fake BMP header section */
1925
        QByteArray header;
1926
        header.resize(14);
1927
        header.fill(0);
1928
        QDataStream hs(&header, QIODevice::ReadWrite);
1929
        hs.setByteOrder(QDataStream::LittleEndian);
1930
        quint16 size;
1931
        size = 0x4D42;
1932
        hs << size;
1933
        size = cmdData.size() + 14;
1934
        hs << size;
1935
        header.append(cmdData);
1936
        thumbnailImage.loadFromData(header, "BMP");
14536 fschmid 1937
}
1938
 
1939
QString DrwPlug::handleColor(ScColor &color, QString proposedName)
1940
{
15771 fschmid 1941
        QString tmpName = m_Doc->PageColors.tryAddColor(proposedName, color);
1942
        if (tmpName == proposedName)
1943
                importedColors.append(tmpName);
14536 fschmid 1944
        return tmpName;
1945
}
1946
 
14639 fschmid 1947
 
1948
void DrwPlug::getCommonData(QDataStream &ds)
1949
{
1950
        quint16 dummy;
1951
        ds.device()->seek(0x38);
1952
        backColor = getColor(ds);
1953
        lineWidth = getValue(ds);
1954
        ds >> dummy;
1955
        posPivot = getCoordinate(ds);
1956
}
1957
 
14536 fschmid 1958
QString DrwPlug::getColor(QDataStream &ds)
1959
{
1960
        quint8 r, g, b, a;
1961
        ds >> r >> g >> b >> a;
1962
        ScColor color = ScColor(r, g, b);
1963
        return handleColor(color, "FromDRW"+color.name());
1964
}
1965
 
14547 fschmid 1966
void DrwPlug::finishItem(PageItem* ite, bool scale)
14536 fschmid 1967
{