Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
13371 jghali 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
 
8
#include <QByteArray>
9
#include <QCursor>
10
#include <QDrag>
11
#include <QFile>
12
#include <QList>
13
#include <QMimeData>
14
#include <QRegExp>
15
#include <QStack>
16
#include <QStack>
17
#include <QTemporaryFile>
18
#include <QDebug>
19
 
20
#include <cstdlib>
21
#include <tiffio.h>
22
#include <zlib.h>
23
 
24
#include "commonstrings.h"
25
#include "customfdialog.h"
26
#include "importai.h"
27
#include "loadsaveplugin.h"
28
#include "missing.h"
29
#include "multiprogressdialog.h"
30
#include "prefscontext.h"
31
#include "prefsfile.h"
32
#include "prefsmanager.h"
33
#include "prefsmanager.h"
34
#include "prefstable.h"
35
#include "propertiespalette.h"
36
#include "rawimage.h"
37
#include "sccolorengine.h"
38
#include "scconfig.h"
13465 cbradney 39
#include "scclocale.h"
13371 jghali 40
#include "scmimedata.h"
41
#include "scpaths.h"
42
#include "scpattern.h"
43
#include "scribus.h"
44
#include "scribusXml.h"
45
#include "scribuscore.h"
46
#include "scribusdoc.h"
13503 cbradney 47
#include "sctextstream.h"
13371 jghali 48
#include "selection.h"
49
#include "text/specialchars.h"
50
#include "undomanager.h"
51
#include "util.h"
52
#include "util_color.h"
53
#include "util_file.h"
54
#include "util_formats.h"
55
#include "util_icon.h"
56
#include "util_math.h"
57
 
58
 
59
#ifdef HAVE_PODOFO
60
        #include <podofo/podofo.h>
61
#endif
62
 
63
extern SCRIBUS_API ScribusQApp * ScQApp;
64
 
65
AIPlug::AIPlug(ScribusDoc* doc, int flags)
66
{
67
        tmpSel=new Selection(this, false);
68
        m_Doc=doc;
69
        interactive = (flags & LoadSavePlugin::lfInteractive);
70
        progressDialog = NULL;
71
}
72
 
73
bool AIPlug::import(QString fNameIn, const TransactionSettings& trSettings, int flags, bool showProgress)
74
{
75
        QString fName = fNameIn;
76
        bool success = false;
77
        interactive = (flags & LoadSavePlugin::lfInteractive);
78
        importerFlags = flags;
79
        cancel = false;
80
        double x, y, b, h;
81
        bool ret = false;
82
        convertedPDF = false;
83
        CustColors.clear();
84
        QFileInfo fi = QFileInfo(fName);
85
//      QString ext = fi.suffix().toLower();
86
        if ( !ScCore->usingGUI() )
87
        {
88
                interactive = false;
89
                showProgress = false;
90
        }
91
 
92
/* Check if the file is an old style AI or one of the newer PDF wrapped ones */
93
        QFile fT(fName);
94
        if (fT.open(QIODevice::ReadOnly))
95
        {
96
                QByteArray tempBuf(9, ' ');
97
                fT.read(tempBuf.data(), 8);
98
                fT.close();
99
                if (tempBuf.startsWith("%PDF"))
100
                {
101
                        QFileInfo bF2(fName);
102
                        QString tmpFile = ScPaths::getTempFileDir()+ "/"+bF2.baseName()+"_tmp.ai";
103
                        if (!extractFromPDF(fName, tmpFile))
104
                                return false;
105
                        convertedPDF = true;
106
                        fName = tmpFile;
107
                }
108
        }
109
        QFile fT2(fName);
110
        if (fT2.open(QIODevice::ReadOnly))
111
        {
112
                QByteArray tempBuf(25, ' ');
113
                fT2.read(tempBuf.data(), 20);
114
                fT2.close();
115
                /* Illustrator CS files might be compressed
116
                        the compressed Data starts right after the "%AI12_CompressedData" comment
117
                        Compression is a simple zlib compression */
118
                if (tempBuf.startsWith("%AI12_CompressedData"))
119
                        decompressAIData(fName);
120
        }
121
        if ( showProgress )
122
        {
123
                ScribusMainWindow* mw=(m_Doc==0) ? ScCore->primaryMainWindow() : m_Doc->scMW();
124
                progressDialog = new MultiProgressDialog( tr("Importing: %1").arg(fi.fileName()), CommonStrings::tr_Cancel, mw );
125
                QStringList barNames, barTexts;
126
                barNames << "GI";
127
                barTexts << tr("Analyzing File:");
128
                QList<bool> barsNumeric;
129
                barsNumeric << false;
130
                progressDialog->addExtraProgressBars(barNames, barTexts, barsNumeric);
131
                progressDialog->setOverallTotalSteps(3);
132
                progressDialog->setOverallProgress(0);
133
                progressDialog->setProgress("GI", 0);
134
                progressDialog->show();
135
                connect(progressDialog, SIGNAL(canceled()), this, SLOT(cancelRequested()));
136
                qApp->processEvents();
137
        }
138
        else
139
                progressDialog = NULL;
140
/* Set default Page to size defined in Preferences */
141
        x = 0.0;
142
        y = 0.0;
143
        b = PrefsManager::instance()->appPrefs.PageWidth;
144
        h = PrefsManager::instance()->appPrefs.PageHeight;
145
        if (progressDialog)
146
        {
147
                progressDialog->setOverallProgress(1);
148
                qApp->processEvents();
149
        }
150
        parseHeader(fName, x, y, b, h);
151
        docX = x;
152
        docY = y;
153
        docWidth = b - x;
154
        docHeight = h - y;
155
        baseX = 0;
156
        baseY = 0;
157
        if (!interactive || (flags & LoadSavePlugin::lfInsertPage))
158
        {
159
                m_Doc->setPage(b-x, h-y, 0, 0, 0, 0, 0, 0, false, false);
160
                m_Doc->addPage(0);
161
                m_Doc->view()->addPage(0, true);
162
                baseX = 0;
163
                baseY = 0;
164
        }
165
        else
166
        {
167
                if (!m_Doc || (flags & LoadSavePlugin::lfCreateDoc))
168
                {
169
                        m_Doc=ScCore->primaryMainWindow()->doFileNew(b-x, h-y, 0, 0, 0, 0, 0, 0, false, false, 0, false, 0, 1, "Custom", true);
170
                        ScCore->primaryMainWindow()->HaveNewDoc();
171
                        ret = true;
172
                        baseX = 0;
173
                        baseY = 0;
174
                }
175
        }
176
        if (flags & LoadSavePlugin::lfCreateDoc)
177
        {
178
                m_Doc->documentInfo.setAuthor(docCreator);
179
                m_Doc->documentInfo.setPublisher(docOrganisation);
180
                m_Doc->documentInfo.setTitle(docTitle);
181
                m_Doc->documentInfo.setDate(docDate+" "+docTime);
182
        }
183
        if ((!ret) && (interactive))
184
        {
185
                baseX = m_Doc->currentPage()->xOffset();
186
                baseY = m_Doc->currentPage()->yOffset();
187
        }
188
        if ((ret) || (!interactive))
189
        {
190
                if (b-x > h-y)
191
                        m_Doc->PageOri = 1;
192
                else
193
                        m_Doc->PageOri = 0;
194
                m_Doc->m_pageSize = "Custom";
195
        }
196
        ColorList::Iterator it;
197
        for (it = CustColors.begin(); it != CustColors.end(); ++it)
198
        {
199
                if (!m_Doc->PageColors.contains(it.key()))
200
                        m_Doc->PageColors.insert(it.key(), it.value());
201
        }
202
        Elements.clear();
16644 jghali 203
        m_Doc->view()->Deselect();
13371 jghali 204
        m_Doc->setLoading(true);
205
        m_Doc->DoDrawing = false;
206
        m_Doc->view()->updatesOn(false);
14755 jghali 207
        m_Doc->scMW()->setScriptRunning(true);
18921 jghali 208
        qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
13371 jghali 209
        QString CurDirP = QDir::currentPath();
210
        QDir::setCurrent(fi.path());
211
        if (convert(fName))
212
        {
213
                tmpSel->clear();
214
                QDir::setCurrent(CurDirP);
215
                if ((Elements.count() > 1) && (!(importerFlags & LoadSavePlugin::lfCreateDoc)))
216
                {
217
                        bool isGroup = true;
218
                        int firstElem = -1;
219
                        if (Elements.at(0)->Groups.count() != 0)
220
                                firstElem = Elements.at(0)->Groups.top();
221
                        for (int bx = 0; bx < Elements.count(); ++bx)
222
                        {
223
                                PageItem* bxi = Elements.at(bx);
224
                                if (bxi->Groups.count() != 0)
225
                                {
226
                                        if (bxi->Groups.top() != firstElem)
227
                                                isGroup = false;
228
                                }
229
                                else
230
                                        isGroup = false;
231
                        }
232
                        if (!isGroup)
233
                        {
234
                                double minx = 99999.9;
235
                                double miny = 99999.9;
236
                                double maxx = -99999.9;
237
                                double maxy = -99999.9;
238
                                uint lowestItem = 999999;
239
                                uint highestItem = 0;
240
                                for (int a = 0; a < Elements.count(); ++a)
241
                                {
242
                                        Elements.at(a)->Groups.push(m_Doc->GroupCounter);
243
                                        PageItem* currItem = Elements.at(a);
244
                                        lowestItem = qMin(lowestItem, currItem->ItemNr);
245
                                        highestItem = qMax(highestItem, currItem->ItemNr);
246
                                        double x1, x2, y1, y2;
247
                                        currItem->getVisualBoundingRect(&x1, &y1, &x2, &y2);
248
                                        minx = qMin(minx, x1);
249
                                        miny = qMin(miny, y1);
250
                                        maxx = qMax(maxx, x2);
251
                                        maxy = qMax(maxy, y2);
252
                                }
253
                                double gx = minx;
254
                                double gy = miny;
255
                                double gw = maxx - minx;
256
                                double gh = maxy - miny;
257
                                PageItem *high = m_Doc->Items->at(highestItem);
258
                                int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, gx, gy, gw, gh, 0, m_Doc->toolSettings.dBrush, m_Doc->toolSettings.dPen, true);
259
                                PageItem *neu = m_Doc->Items->takeAt(z);
260
                                m_Doc->Items->insert(lowestItem, neu);
261
                                neu->Groups.push(m_Doc->GroupCounter);
262
                                neu->setItemName( tr("Group%1").arg(neu->Groups.top()));
263
                                neu->isGroupControl = true;
264
                                neu->groupsLastItem = high;
265
                                neu->setTextFlowMode(PageItem::TextFlowDisabled);
266
                                for (int a = 0; a < m_Doc->Items->count(); ++a)
267
                                {
268
                                        m_Doc->Items->at(a)->ItemNr = a;
269
                                }
270
                                Elements.prepend(neu);
271
                                m_Doc->GroupCounter++;
272
                        }
273
                }
274
                m_Doc->DoDrawing = true;
14755 jghali 275
                m_Doc->scMW()->setScriptRunning(false);
13371 jghali 276
                m_Doc->setLoading(false);
277
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
278
                if ((Elements.count() > 0) && (!ret) && (interactive))
279
                {
280
                        if (flags & LoadSavePlugin::lfScripted)
281
                        {
282
                                bool loadF = m_Doc->isLoading();
283
                                m_Doc->setLoading(false);
284
                                m_Doc->changed();
285
                                m_Doc->setLoading(loadF);
286
                                m_Doc->m_Selection->delaySignalsOn();
287
                                for (int dre=0; dre<Elements.count(); ++dre)
288
                                {
289
                                        m_Doc->m_Selection->addItem(Elements.at(dre), true);
290
                                }
291
                                m_Doc->m_Selection->delaySignalsOff();
292
                                m_Doc->m_Selection->setGroupRect();
293
                                m_Doc->view()->updatesOn(true);
294
                        }
295
                        else
296
                        {
297
                                m_Doc->DragP = true;
298
                                m_Doc->DraggedElem = 0;
299
                                m_Doc->DragElements.clear();
300
                                m_Doc->m_Selection->delaySignalsOn();
301
                                for (int dre=0; dre<Elements.count(); ++dre)
302
                                {
303
                                        m_Doc->DragElements.append(Elements.at(dre)->ItemNr);
304
                                        tmpSel->addItem(Elements.at(dre), true);
305
                                }
306
                                tmpSel->setGroupRect();
307
                                ScriXmlDoc *ss = new ScriXmlDoc();
308
                                ScElemMimeData* md = new ScElemMimeData();
309
                                md->setScribusElem(ss->WriteElem(m_Doc, m_Doc->view(), tmpSel));
310
                                delete ss;
311
/*#ifndef Q_WS_MAC*/
312
// see #2196
313
                                m_Doc->itemSelection_DeleteItem(tmpSel);
314
/*#else
315
                                qDebug("aiimport: leaving items on page");
316
#endif*/
317
                                m_Doc->view()->updatesOn(true);
318
                                m_Doc->m_Selection->delaySignalsOff();
319
                                // We must copy the TransationSettings object as it is owned
320
                                // by handleObjectImport method afterwards
321
                                TransactionSettings* transacSettings = new TransactionSettings(trSettings);
322
                                m_Doc->view()->handleObjectImport(md, transacSettings);
323
                                m_Doc->DragP = false;
324
                                m_Doc->DraggedElem = 0;
325
                                m_Doc->DragElements.clear();
326
                        }
327
                }
328
                else
329
                {
330
                        m_Doc->changed();
331
                        m_Doc->reformPages();
332
                        m_Doc->view()->updatesOn(true);
333
                }
334
                success = true;
335
        }
336
        else
337
        {
338
                QDir::setCurrent(CurDirP);
339
                m_Doc->DoDrawing = true;
14755 jghali 340
                m_Doc->scMW()->setScriptRunning(false);
13371 jghali 341
                m_Doc->view()->updatesOn(true);
342
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
343
        }
344
        if (interactive)
345
                m_Doc->setLoading(false);
346
        //CB If we have a gui we must refresh it if we have used the progressbar
347
        if ((showProgress) && (!interactive))
348
                m_Doc->view()->DrawNew();
349
        if (convertedPDF)
350
                QFile::remove(fName);
18921 jghali 351
        qApp->restoreOverrideCursor();
13371 jghali 352
        return success;
353
}
354
 
355
AIPlug::~AIPlug()
356
{
357
        if (progressDialog)
358
                delete progressDialog;
359
        delete tmpSel;
360
}
361
 
362
bool AIPlug::extractFromPDF(QString infile, QString outfile)
363
{
364
        bool ret = false;
365
#ifdef HAVE_PODOFO
366
        QFile outf(outfile);
367
        outf.open(QIODevice::WriteOnly);
368
        try
369
        {
370
                PoDoFo::PdfError::EnableDebug( false );
19670 jghali 371
#if (PODOFO_VERSION >= PODOFO_MAKE_VERSION(0, 7, 0))
13371 jghali 372
                PoDoFo::PdfError::EnableLogging( false );
373
#endif
19670 jghali 374
#if (PODOFO_VERSION >= PODOFO_MAKE_VERSION(0, 5, 99))
13371 jghali 375
                PoDoFo::PdfMemDocument doc( infile.toLocal8Bit().data() );
376
#else
377
                PoDoFo::PdfDocument doc( infile.toLocal8Bit().data() );
378
#endif
379
                PoDoFo::PdfPage *curPage = doc.GetPage(0);
380
                if (curPage != NULL)
381
                {
382
                        PoDoFo::PdfObject *piece = curPage->GetObject()->GetIndirectKey("PieceInfo");
383
                        if (piece != NULL)
384
                        {
385
                                PoDoFo::PdfObject *illy = piece->GetIndirectKey("Illustrator");
386
                                if (illy != NULL)
387
                                {
388
                                        PoDoFo::PdfObject *priv = illy->GetIndirectKey("Private");
389
                                        if (priv == NULL)
390
                                                priv = illy;
391
                                        int num = 0;
392
                                        PoDoFo::PdfObject *numBl = priv->GetIndirectKey("NumBlock");
393
                                        if (numBl != NULL)
394
                                                num = numBl->GetNumber() + 1;
395
                                        if (num == 0)
396
                                                num = 99999;
397
                                        QString name = "AIPrivateData%1";
398
                                        QString Key = name.arg(1);
399
                                        PoDoFo::PdfObject *data = priv->GetIndirectKey(PoDoFo::PdfName(Key.toUtf8().data()));
400
                                        if (data == NULL)
401
                                        {
402
                                                name = "AIPDFPrivateData%1";
403
                                                Key = name.arg(1);
404
                                                data = priv->GetIndirectKey(PoDoFo::PdfName(Key.toUtf8().data()));
405
                                        }
406
                                        if (data != NULL)
407
                                        {
408
                                                if (num == 2)
409
                                                {
410
                                                        Key = name.arg(1);
411
                                                        data = priv->GetIndirectKey(PoDoFo::PdfName(Key.toUtf8().data()));
412
                                                        PoDoFo::PdfStream const *stream = data->GetStream();
413
                                                        char *Buffer;
19686 jghali 414
#if (PODOFO_VERSION >= PODOFO_MAKE_VERSION(0, 8, 0))
15016 jghali 415
                                                        PoDoFo::pdf_long bLen = 0;
416
#elif defined(pdf_long)
13738 pierre 417
                                                        pdf_long bLen = 0;
418
#else
419
                                                        long bLen = 0;
420
#endif
13371 jghali 421
                                                        stream->GetFilteredCopy(&Buffer, &bLen);
422
                                                        outf.write(Buffer, bLen);
423
                                                        free( Buffer );
424
                                                }
425
                                                else
426
                                                {
427
                                                        for (int a = 2; a < num; a++)
428
                                                        {
429
                                                                Key = name.arg(a);
430
                                                                data = priv->GetIndirectKey(PoDoFo::PdfName(Key.toUtf8().data()));
431
                                                                if (data == NULL)
432
                                                                        break;
433
                                                                PoDoFo::PdfStream const *stream = data->GetStream();
434
                                                                char *Buffer;
19686 jghali 435
#if (PODOFO_VERSION >= PODOFO_MAKE_VERSION(0, 8, 0))
15016 jghali 436
                                                                PoDoFo::pdf_long bLen = 0;
437
#elif defined(pdf_long)
13738 pierre 438
                                                                pdf_long bLen = 0;
439
#else
440
                                                                long bLen = 0;
441
#endif
13371 jghali 442
                                                                stream->GetFilteredCopy(&Buffer, &bLen);
443
                                                                outf.write(Buffer, bLen);
444
                                                                free( Buffer );
445
                                                        }
446
                                                }
447
                                        }
448
                                        ret = true;
449
                                }
450
                        }
451
                }
452
                outf.close();
453
        }
454
        catch (PoDoFo::PdfError& e)
455
        {
456
                outf.close();
457
                qDebug("Scribus caught and handled the following exception from PoDoFo while processing a PDF format ai file:\n----\n");
458
                e.PrintErrorMsg();
459
                qDebug("----\nThe ai file could not be imported.\n");
460
                QFile::remove(outfile);
461
                return false;
462
        }
463
#endif
464
        return ret;
465
}
466
 
467
bool AIPlug::decompressAIData(QString &fName)
468
{
469
        QString f2 = fName+"_decom.ai";
470
        FILE *source = fopen(fName.toLocal8Bit().constData(), "rb");
471
        fseek(source, 20, SEEK_SET);
472
        FILE *dest = fopen(f2.toLocal8Bit().constData(), "wb");
473
        int ret;
474
        unsigned have;
475
        z_stream strm;
476
        char in[4096];
477
        char out[4096];
478
        strm.zalloc = Z_NULL;
479
        strm.zfree = Z_NULL;
480
        strm.opaque = Z_NULL;
481
        strm.avail_in = 0;
482
        strm.next_in = Z_NULL;
483
        ret = inflateInit(&strm);
484
        if (ret != Z_OK)
485
                return false;
486
        do
487
        {
488
                strm.avail_in = fread(in, 1, 4096, source);
489
                if (ferror(source))
490
                {
491
                        (void)inflateEnd(&strm);
492
                        return false;
493
                }
494
                if (strm.avail_in == 0)
495
                        break;
496
                strm.next_in = (Bytef*)in;
497
                do
498
                {
499
                        strm.avail_out = 4096;
500
                        strm.next_out = (Bytef*)out;
501
                        ret = inflate(&strm, Z_NO_FLUSH);
502
                        assert(ret != Z_STREAM_ERROR);
503
                        switch (ret)
504
                        {
505
                                case Z_NEED_DICT:
506
                                        ret = Z_DATA_ERROR;
507
                                case Z_DATA_ERROR:
508
                                case Z_MEM_ERROR:
509
                                        (void)inflateEnd(&strm);
510
                                        return false;
511
                        }
512
                        have = 4096 - strm.avail_out;
513
                        if (fwrite(out, 1, have, dest) != have || ferror(dest))
514
                        {
515
                                (void)inflateEnd(&strm);
516
                                return false;
517
                        }
518
                }
519
                while (strm.avail_out == 0);
520
        }
521
        while (ret != Z_STREAM_END);
522
        (void)inflateEnd(&strm);
523
        fclose(source);
524
        fclose(dest);
525
        if (!convertedPDF)
526
        {
527
                QFileInfo bF2(fName);
528
                QString tmpFile = ScPaths::getTempFileDir()+ "/"+bF2.baseName()+"_tmp.ai";
529
                moveFile(f2, tmpFile);
530
                fName = tmpFile;
531
                convertedPDF = true;
532
        }
533
        else
534
        {
535
                QFile::remove(fName);
536
                fName = f2;
537
        }
538
        return true;
539
}
540
 
541
bool AIPlug::parseHeader(QString fName, double &x, double &y, double &b, double &h)
542
{
543
        QString tmp, BBox, tmp2, FarNam;
544
        ScColor cc;
545
//      double c, m, yc, k;
546
        bool found = false;
547
        QFile f(fName);
548
        if (f.open(QIODevice::ReadOnly))
549
        {
550
/* Try to find Bounding Box */
551
                QDataStream ts(&f);
552
                while (!ts.atEnd())
553
                {
554
                        tmp = readLinefromDataStream(ts);
555
                        if (tmp.startsWith("%%BoundingBox:"))
556
                        {
557
                                found = true;
558
                                BBox = tmp.remove("%%BoundingBox:");
559
                        }
560
                        if (!found)
561
                        {
562
                                if (tmp.startsWith("%%BoundingBox"))
563
                                {
564
                                        found = true;
565
                                        BBox = tmp.remove("%%BoundingBox");
566
                                }
567
                        }
568
                        if (tmp.startsWith("%%HiResBoundingBox:"))
569
                        {
570
                                found = true;
571
                                BBox = tmp.remove("%%HiResBoundingBox:");
572
                        }
573
                        if (tmp.startsWith("%%For"))
574
                        {
575
                                QStringList res = getStrings(tmp);
576
                                if (res.count() > 1)
577
                                {
578
                                        docCreator = res[0];
579
                                        docOrganisation = res[1];
580
                                }
581
                        }
582
                        if (tmp.startsWith("%%CreationDate:"))
583
                        {
584
                                QStringList res = getStrings(tmp);
585
                                if (res.count() > 1)
586
                                {
587
                                        docDate = res[0];
588
                                        docTime = res[1];
589
                                }
590
                                else
591
                                {
592
                                        docDate = tmp.remove("%%CreationDate: ");
593
                                        docTime = "";
594
                                }
595
                        }
596
                        if (tmp.startsWith("%%Title"))
597
                        {
598
                                QStringList res = getStrings(tmp);
599
                                if (res.count() > 0)
600
                                        docTitle = res[0];
601
                        }
602
                        if (tmp.startsWith("%%EndComments"))
603
                                break;
604
                }
605
                f.close();
606
                if (found)
607
                {
608
                        QStringList bb = BBox.split(" ", QString::SkipEmptyParts);
609
                        if (bb.count() == 4)
610
                        {
13497 jghali 611
                                x = ScCLocale::toDoubleC(bb[0]);
612
                                y = ScCLocale::toDoubleC(bb[1]);
613
                                b = ScCLocale::toDoubleC(bb[2]);
614
                                h = ScCLocale::toDoubleC(bb[3]);
13371 jghali 615
                        }
616
                }
617
                importColorsFromFile(fName, CustColors);
618
        }
619
        return found;
620
}
621
 
622
QString AIPlug::removeAIPrefix(QString comment)
623
{
624
        QString tmp;
625
        if (comment.startsWith("%AI"))
626
        {
627
                int an = comment.indexOf("_");
628
                tmp = comment.remove(0, an+1);
629
        }
630
        else
631
                tmp = comment;
632
        return tmp;
633
}
634
 
635
QString AIPlug::parseColor(QString data)
636
{
637
        QString ret = CommonStrings::None;
638
        if (data.isEmpty())
639
                return ret;
640
        double c, m, y, k;
641
        ScColor tmp;
642
        ColorList::Iterator it;
13497 jghali 643
        ScTextStream Code(&data, QIODevice::ReadOnly);
13371 jghali 644
        bool found = false;
645
        Code >> c;
646
        Code >> m;
647
        Code >> y;
648
        Code >> k;
649
        int Cc = qRound(c * 255);
650
        int Mc = qRound(m * 255);
651
        int Yc = qRound(y * 255);
652
        int Kc = qRound(k * 255);
653
        int hC, hM, hY, hK;
654
        tmp.setColor(Cc, Mc, Yc, Kc);
655
        for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
656
        {
657
                if (it.value().getColorModel() == colorModelCMYK)
658
                {
659
                        it.value().getCMYK(&hC, &hM, &hY, &hK);
660
                        if ((Cc == hC) && (Mc == hM) && (Yc == hY) && (Kc == hK))
661
                        {
662
                                ret = it.key();
663
                                found = true;
664
                                break;
665
                        }
666
                }
667
        }
668
        if (!found)
669
        {
670
                tmp.setSpotColor(false);
671
                tmp.setRegistrationColor(false);
672
                QString namPrefix = "FromAI";
673
                m_Doc->PageColors.insert(namPrefix+tmp.name(), tmp);
674
//              importedColors.append(namPrefix+tmp.name());
675
                ret = namPrefix+tmp.name();
676
        }
16524 fschmid 677
        meshColorMode = 0;
13371 jghali 678
        return ret;
679
}
680
 
681
QString AIPlug::parseColorGray(QString data)
682
{
683
        QString ret = CommonStrings::None;
684
        if (data.isEmpty())
685
                return ret;
686
        double k;
687
        ScColor tmp;
688
        ColorList::Iterator it;
13497 jghali 689
        ScTextStream Code(&data, QIODevice::ReadOnly);
13371 jghali 690
        bool found = false;
691
        Code >> k;
692
        int Kc = 255 - qRound(k * 255);
693
        int hC, hM, hY, hK;
694
        tmp.setColor(0, 0, 0, Kc);
695
        for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
696
        {
697
                if (it.value().getColorModel() == colorModelCMYK)
698
                {
699
                        it.value().getCMYK(&hC, &hM, &hY, &hK);
700
                        if ((hC == 0) && (hM == 0) && (hY == 0) && (Kc == hK))
701
                        {
702
                                ret = it.key();
703
                                found = true;
704
                                break;
705
                        }
706
                }
707
        }
708
        if (!found)
709
        {
710
                tmp.setSpotColor(false);
711
                tmp.setRegistrationColor(false);
712
                QString namPrefix = "FromAI";
713
                m_Doc->PageColors.insert(namPrefix+tmp.name(), tmp);
714
//              importedColors.append(namPrefix+tmp.name());
715
                ret = namPrefix+tmp.name();
716
        }
16524 fschmid 717
        meshColorMode = 2;
13371 jghali 718
        return ret;
719
}
720
 
721
QString AIPlug::parseColorRGB(QString data)
722
{
723
        QString ret = CommonStrings::None;
724
        if (data.isEmpty())
725
                return ret;
726
        double r, g, b;
727
        ScColor tmp;
728
        ColorList::Iterator it;
13497 jghali 729
        ScTextStream Code(&data, QIODevice::ReadOnly);
13371 jghali 730
        bool found = false;
731
        Code >> r;
732
        Code >> g;
733
        Code >> b;
734
        int Rc = qRound(r * 255);
735
        int Gc = qRound(g * 255);
736
        int Bc = qRound(b * 255);
737
        int hR, hG, hB;
738
        tmp.setColorRGB(Rc, Gc, Bc);
739
        for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
740
        {
741
                if (it.value().getColorModel() == colorModelRGB)
742
                {
743
                        it.value().getRGB(&hR, &hG, &hB);
744
                        if ((Rc == hR) && (Gc == hG) && (Bc == hB))
745
                        {
746
                                ret = it.key();
747
                                found = true;
748
                                break;
749
                        }
750
                }
751
        }
752
        if (!found)
753
        {
754
                tmp.setSpotColor(false);
755
                tmp.setRegistrationColor(false);
756
                QString namPrefix = "FromAI";
757
                m_Doc->PageColors.insert(namPrefix+tmp.name(), tmp);
758
//              importedColors.append(namPrefix+tmp.name());
759
                ret = namPrefix+tmp.name();
760
        }
16524 fschmid 761
        meshColorMode = 1;
13371 jghali 762
        return ret;
763
}
764
 
765
QString AIPlug::parseCustomColor(QString data, double &shade)
766
{
767
        QString ret = CommonStrings::None;
768
        if (data.isEmpty())
769
                return ret;
770
        double c, m, y, k, sh;
771
        ScColor tmp;
772
        ColorList::Iterator it;
13497 jghali 773
        ScTextStream Code(&data, QIODevice::ReadOnly);
13371 jghali 774
        bool found = false;
775
        Code >> c;
776
        Code >> m;
777
        Code >> y;
778
        Code >> k;
779
        QString tmpS = data;
780
        int an = data.indexOf("(");
781
        int en = data.lastIndexOf(")");
782
        QString FarNam = data.mid(an+1, en-an-1);
783
        FarNam.remove("\\");
784
        QString FarSha = data.mid(en+1, data.size() - en);
13497 jghali 785
        ScTextStream Val(&FarSha, QIODevice::ReadOnly);
13371 jghali 786
        Val >> sh;
787
        shade = (1.0 - sh) * 100.0;
788
        int Cc = qRound(c * 255);
789
        int Mc = qRound(m * 255);
790
        int Yc = qRound(y * 255);
791
        int Kc = qRound(k * 255);
792
        int hC, hM, hY, hK;
793
        tmp.setColor(Cc, Mc, Yc, Kc);
794
        for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
795
        {
796
                if (it.value().getColorModel() == colorModelCMYK)
797
                {
798
                        it.value().getCMYK(&hC, &hM, &hY, &hK);
799
                        if ((Cc == hC) && (Mc == hM) && (Yc == hY) && (Kc == hK))
800
                        {
801
                                ret = it.key();
802
                                found = true;
803
                                break;
804
                        }
805
                }
806
        }
807
        if (!found)
808
        {
809
                tmp.setSpotColor(true);
810
                tmp.setRegistrationColor(false);
811
                m_Doc->PageColors.insert(FarNam, tmp);
812
//              importedColors.append(FarNam);
813
                ret = FarNam;
814
        }
16524 fschmid 815
        meshColorMode = 0;
13371 jghali 816
        return ret;
817
}
818
 
819
QString AIPlug::parseCustomColorX(QString data, double &shade, QString type)
820
{
821
        QString ret = CommonStrings::None;
822
        if (data.isEmpty())
823
                return ret;
824
        double c, m, y, k, sh, r, g, b;
825
        ScColor tmp;
826
        ColorList::Iterator it;
13497 jghali 827
        ScTextStream Code(&data, QIODevice::ReadOnly);
13371 jghali 828
        bool found = false;
829
        if (type == "1")
830
        {
831
                Code >> r;
832
                Code >> g;
833
                Code >> b;
834
                int Rc = qRound(r * 255);
835
                int Gc = qRound(g * 255);
836
                int Bc = qRound(b * 255);
837
                int hR, hG, hB;
838
                tmp.setColorRGB(Rc, Gc, Bc);
839
                for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
840
                {
841
                        if (it.value().getColorModel() == colorModelRGB)
842
                        {
843
                                it.value().getRGB(&hR, &hG, &hB);
844
                                if ((Rc == hR) && (Gc == hG) && (Bc == hB))
845
                                {
846
                                        ret = it.key();
847
                                        found = true;
848
                                        break;
849
                                }
850
                        }
851
                }
16524 fschmid 852
                meshColorMode = 1;
13371 jghali 853
        }
854
        else
855
        {
856
                Code >> c;
857
                Code >> m;
858
                Code >> y;
859
                Code >> k;
860
                int Cc = qRound(c * 255);
861
                int Mc = qRound(m * 255);
862
                int Yc = qRound(y * 255);
863
                int Kc = qRound(k * 255);
864
                int hC, hM, hY, hK;
865
                tmp.setColor(Cc, Mc, Yc, Kc);
866
                for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
867
                {
868
                        if (it.value().getColorModel() == colorModelCMYK)
869
                        {
870
                                it.value().getCMYK(&hC, &hM, &hY, &hK);
871
                                if ((Cc == hC) && (Mc == hM) && (Yc == hY) && (Kc == hK))
872
                                {
873
                                        ret = it.key();
874
                                        found = true;
875
                                        break;
876
                                }
877
                        }
878
                }
16524 fschmid 879
                meshColorMode = 0;
13371 jghali 880
        }
881
        QString tmpS = data;
882
        int an = data.indexOf("(");
883
        int en = data.lastIndexOf(")");
884
        QString FarNam = data.mid(an+1, en-an-1);
885
        FarNam.remove("\\");
886
        QString FarSha = data.mid(en+1, data.size() - en);
13497 jghali 887
        ScTextStream Val(&FarSha, QIODevice::ReadOnly);
13371 jghali 888
        Val >> sh;
889
        shade = (1.0 - sh) * 100.0;
890
        if (!found)
891
        {
892
                if (type == "0")
893
                        tmp.setSpotColor(true);
894
                tmp.setRegistrationColor(false);
895
                m_Doc->PageColors.insert(FarNam, tmp);
896
//              importedColors.append(FarNam);
897
                ret = FarNam;
898
        }
899
        return ret;
900
}
901
 
902
QStringList AIPlug::getStrings(QString data)
903
{
904
        QStringList result;
905
        result.clear();
906
        QChar tmp;
907
        QString tmp2 = "";
908
        QString tmp3 = "";
909
        bool paran = false;
910
        bool skip = false;
911
        int digitCount = 0;
912
        for (int a = 0; a < data.count(); a++)
913
        {
914
                tmp = data[a];
915
                if (skip)
916
                {
917
                        if (paran)
918
                        {
919
                                if (tmp.isDigit())
920
                                {
921
                                        tmp3 += tmp;
922
                                        digitCount++;
923
                                        if (digitCount == 3)
924
                                        {
925
                                                bool ok = false;
926
                                                int code = tmp3.toInt(&ok, 8);
927
                                                if (ok)
928
                                                        tmp2 += QChar(code);
929
                                                digitCount = 0;
930
                                                tmp3 = "";
931
                                                skip = false;
932
                                        }
933
                                }
934
                                else
935
                                {
936
                                        if (tmp == 'r')
937
                                                tmp = SpecialChars::PARSEP;
938
                                        tmp2 += tmp;
939
                                        skip = false;
940
                                }
941
                        }
942
                        continue;
943
                }
944
                if (tmp == '(')
945
                {
946
                        paran = true;
947
                        continue;
948
                }
949
                if (tmp == ')')
950
                {
951
                        paran = false;
952
                        result.append(tmp2);
953
                        tmp2 = "";
954
                        continue;
955
                }
956
                if (tmp == '\\')
957
                {
958
                        skip = true;
959
                        continue;
960
                }
961
                if (paran)
962
                        tmp2 += tmp;
963
        }
964
        return result;
965
}
966
 
967
void AIPlug::getCommands(QString data, QStringList &commands)
968
{
969
        QString tmp;
970
        QString tmp2;
971
        QString tmp3;
972
        bool paran = false;
973
        bool arra = false;
974
        bool skip = false;
975
        for (int a = 0; a < data.count(); a++)
976
        {
977
                tmp = data[a];
978
                if (skip)
979
                {
980
                        tmp2 += tmp;
981
                        skip = false;
982
                        continue;
983
                }
984
                if (tmp == "(")
985
                {
986
                        paran = true;
987
                        tmp2 += tmp;
988
                        continue;
989
                }
990
                if (tmp == ")")
991
                {
992
                        paran = false;
993
                        tmp2 += tmp;
994
                        continue;
995
                }
996
                if (tmp == "[")
997
                {
998
                        arra = true;
999
                        tmp2 += tmp;
1000
                        continue;
1001
                }
1002
                if (tmp == "]")
1003
                {
1004
                        arra = false;
1005
                        tmp2 += tmp;
1006
                        continue;
1007
                }
1008
//              if (tmp == "\\")
1009
//              {
1010
//                      skip = true;
1011
//                      continue;
1012
//              }
1013
                if (!paran)
1014
                {
1015
                        if (tmp == " ")
1016
                        {
1017
                                tmp3 += " " + tmp2;
1018
                                if (commandList.contains(tmp2))
1019
                                {
1020
                                        commands.append(tmp3);
1021
                                        tmp3 = "";
1022
                                }
1023
                                tmp2 = "";
1024
                                continue;
1025
                        }
1026
                }
1027
                tmp2 += tmp;
1028
        }
1029
        if (!tmp2.isEmpty())
1030
        {
1031
                tmp3 += " " + tmp2;
1032
                commands.append(tmp3);
1033
        }
1034
}
1035
 
1036
void AIPlug::processData(QString data)
1037
{
1038
        double x, y, x1, y1, x2, y2;
1039
        int z, tmpInt;
1040
        PageItem *ite;
1041
        QString command = "";
1042
        QString Cdata = "";
1043
        QStringList da;
1044
        getCommands(data, da);
1045
        for (int a = 0; a < da.count(); a++)
1046
        {
1047
                Cdata = da[a];
1048
                if (((Cdata.startsWith("%")) || (Cdata.startsWith(" %"))) && (!meshMode))
1049
                        continue;
1050
                QStringList da2 = Cdata.split(" ", QString::SkipEmptyParts);
1051
                if (da2.count() == 0)
1052
                        return;
1053
                command = da2[da2.count()-1];
1054
/* Start Path construction commands */
1055
                if (command == "m")
1056
                {
13497 jghali 1057
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1058
                        ts2 >> x >> y;
1059
                        Coords.svgMoveTo(x - docX, docHeight - (y - docY));
1060
                        currentPoint = FPoint(x - docX, docHeight - (y - docY));
1061
                }
1062
                else if ((command == "L") || (command == "l"))
1063
                {
13497 jghali 1064
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1065
                        ts2 >> x >> y;
1066
                        Coords.svgLineTo(x - docX, docHeight - (y - docY));
1067
                        currentPoint = FPoint(x - docX, docHeight - (y - docY));
1068
                }
1069
                else if ((command == "C") || (command == "c"))
1070
                {
13497 jghali 1071
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1072
                        ts2 >> x >> y >> x1 >> y1 >> x2 >> y2;
1073
                        Coords.svgCurveToCubic(x - docX, docHeight - (y - docY),
1074
                                                                   x1 - docX, docHeight - (y1 - docY),
1075
                                                                   x2 - docX, docHeight - (y2 - docY));
1076
                        currentPoint = FPoint(x2 - docX, docHeight - (y2 - docY));
1077
                }
1078
                else if ((command == "Y") || (command == "y"))
1079
                {
13497 jghali 1080
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1081
                        ts2 >> x1 >> y1 >> x2 >> y2;
16524 fschmid 1082
                        Coords.svgCurveToCubic(x1 - docX, docHeight - (y1 - docY), x2 - docX, docHeight - (y2 - docY), x2 - docX, docHeight - (y2 - docY));
13371 jghali 1083
                        currentPoint = FPoint(x2 - docX, docHeight - (y2 - docY));
1084
                }
1085
                else if ((command == "V") || (command == "v"))
1086
                {
13497 jghali 1087
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1088
                        ts2 >> x >> y >> x2 >> y2;
16524 fschmid 1089
                        Coords.svgCurveToCubic(currentPoint.x(), currentPoint.y(), x - docX, docHeight - (y - docY), x2 - docX, docHeight - (y2 - docY));
13371 jghali 1090
                        currentPoint = FPoint(x2 - docX, docHeight - (y2 - docY));
1091
                }
1092
/* End Path construction commands */
1093
/* Start Object creation commands */
1094
                else if ((command == "b") || (command == "B") || (command == "f") || (command == "F") || (command == "s") || (command == "S"))
1095
                {
1096
                        if (Coords.size() > 3)
1097
                        {
1098
                                if ((!WasU) || ((WasU) && (FirstU)))
1099
                                {
1100
                                        if ((command == "B") || (command == "F") || (command == "S"))
1101
                                        {
1102
                                                if (command == "F")
1103
                                                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CommonStrings::None, true);
1104
                                                else if (command == "B")
1105
                                                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
1106
                                                else
1107
                                                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColorStroke, true);
1108
                                        }
1109
                                        else
1110
                                        {
1111
                                                if (command == "f")
1112
                                                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CommonStrings::None, true);
1113
                                                else if (command == "b")
1114
                                                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
1115
                                                else
1116
                                                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColorStroke, true);
1117
                                        }
1118
                                        ite = m_Doc->Items->at(z);
1119
                                        ite->PoLine = Coords.copy();
1120
                                        ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
1121
                                        ite->ClipEdited = true;
1122
                                        ite->FrameType = 3;
1123
                                        ite->setFillShade(CurrFillShade);
1124
                                        ite->setLineShade(CurrStrokeShade);
1125
                                        ite->setFillEvenOdd(fillRule);
1126
                                        ite->setFillTransparency(1.0 - Opacity);
1127
                                        ite->setLineTransparency(1.0 - Opacity);
1128
        //                              ite->setFillBlendmode(blendMode);
1129
        //                              ite->setLineBlendmode(blendMode);
1130
                                        if (!currentPatternName.isEmpty())
1131
                                        {
1132
                                                ite->setPattern(currentPatternName);
1133
                                                ite->setPatternTransform(currentPatternXScale * 100, currentPatternYScale * 100, currentPatternX, currentPatternY, currentPatternRotation);
1134
                                                ite->GrType = 8;
1135
                                                currentPatternName = "";
1136
                                        }
1137
                                        ite->setLineEnd(CapStyle);
1138
                                        ite->setLineJoin(JoinStyle);
1139
                                        if (!WasU)
1140
                                        {
1141
                                                FPoint wh = getMaxClipF(&ite->PoLine);
1142
                                                ite->setWidthHeight(wh.x(),wh.y());
1143
                                                ite->setTextFlowMode(PageItem::TextFlowDisabled);
1144
                                                m_Doc->AdjustItemSize(ite);
1145
                                        }
16524 fschmid 1146
                                        if (importerFlags & LoadSavePlugin::lfCreateDoc)
1147
                                                ite->setLocked(itemLocked);
13371 jghali 1148
                                        if (patternMode)
1149
                                                PatternElements.append(ite);
1150
                                        else
1151
                                                Elements.append(ite);
1152
                                        if (groupStack.count() != 0)
1153
                                                groupStack.top().append(ite);
1154
 
1155
                                }
1156
                                else
1157
                                {
17294 jghali 1158
                                        ite = m_Doc->Items->last();
13371 jghali 1159
                                        ite->PoLine.setMarker();
1160
                                        Coords.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
1161
                                        ite->PoLine.putPoints(ite->PoLine.size(), Coords.size(), Coords);
1162
                                }
1163
                                Coords.resize(0);
1164
                                Coords.svgInit();
16524 fschmid 1165
                                CurrFillShade = 100.0;
1166
                                CurrStrokeShade = 100.0;
13371 jghali 1167
                                FirstU = false;
1168
                                itemRendered = true;
1169
                        }
1170
                }
1171
                else if (command == "*u")
1172
                {
1173
                        FirstU = true;
1174
                        WasU = true;
1175
                }
1176
                else if (command == "*U")
1177
                {
1178
                        WasU = false;
17294 jghali 1179
                        ite = m_Doc->Items->last();
13371 jghali 1180
                        FPoint wh = getMaxClipF(&ite->PoLine);
1181
                        ite->setWidthHeight(wh.x(),wh.y());
1182
                        m_Doc->AdjustItemSize(ite);
1183
                }
1184
                else if ((command == "u") || (command == "q"))
1185
                {
1186
                        QList<PageItem*> gElements;
1187
                        groupStack.push(gElements);
1188
                }
1189
                else if ((command == "U") || (command == "Q"))
1190
                {
1191
                        if (groupStack.count() != 0)
1192
                        {
1193
                                QList<PageItem*> gElements = groupStack.pop();
1194
                                tmpSel->clear();
1195
                                if (gElements.count() > 0)
1196
                                {
1197
                                        for (int dre = 0; dre < gElements.count(); ++dre)
1198
                                        {
1199
                                                tmpSel->addItem(gElements.at(dre), true);
1200
                                        }
1201
                                        m_Doc->itemSelection_GroupObjects(false, false, tmpSel);
1202
                                        ite = tmpSel->itemAt(0);
1203
                                        if ((clipCoords.size() > 4) && (command == "Q"))
1204
                                        {
1205
                                                ite = tmpSel->itemAt(0);
1206
                                                clipCoords.translate(m_Doc->currentPage()->xOffset()-ite->xPos(), m_Doc->currentPage()->yOffset()-ite->yPos());
1207
                                                ite->PoLine = clipCoords.copy();
1208
                                                ite->PoLine.translate(baseX, baseY);
1209
                                        }
1210
                                if (patternMode)
1211
                                        PatternElements.append(ite);
1212
                                else
1213
                                        Elements.append(ite);
1214
                                }
1215
                                if (groupStack.count() != 0)
1216
                                {
1217
                                        for (int as = 0; as < tmpSel->count(); ++as)
1218
                                        {
1219
                                                groupStack.top().append(tmpSel->itemAt(as));
1220
                                        }
1221
                                }
1222
                                tmpSel->clear();
1223
                        }
1224
                        if (command == "Q")
1225
                        {
1226
                                clipCoords.resize(0);
1227
                                clipCoords.svgInit();
1228
                        }
1229
                }
1230
                else if (command == "W")
1231
                {
1232
                        if (clipCoords.size() > 0)
1233
                                clipCoords.setMarker();
1234
                        clipCoords.putPoints(clipCoords.size(), Coords.size(), Coords);
1235
                }
1236
/* End Object construction commands */
1237
/* Start Graphics state commands */
1238
                else if (command == "A")
1239
                {
13497 jghali 1240
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1241
                        ts2 >> tmpInt;
1242
                        if (tmpInt == 1)
1243
                                itemLocked = true;
1244
                        else
1245
                                itemLocked = false;
1246
                }
1247
                else if (command == "w")
1248
                {
13497 jghali 1249
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1250
                        ts2 >> LineW;
1251
                }
1252
                else if (command == "j")
1253
                {
13497 jghali 1254
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1255
                        ts2 >> tmpInt;
1256
                        if (tmpInt == 0)
1257
                                JoinStyle = Qt::MiterJoin;
1258
                        else if (tmpInt == 1)
1259
                                JoinStyle = Qt::RoundJoin;
22495 jghali 1260
                        else if (tmpInt == 2)
13371 jghali 1261
                                JoinStyle = Qt::BevelJoin;
1262
                }
1263
                else if (command == "J")
1264
                {
13497 jghali 1265
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1266
                        ts2 >> tmpInt;
1267
                        if (tmpInt == 0)
1268
                                CapStyle = Qt::FlatCap;
1269
                        else if (tmpInt == 1)
1270
                                CapStyle = Qt::RoundCap;
22495 jghali 1271
                        else if (tmpInt == 2)
13371 jghali 1272
                                CapStyle = Qt::SquareCap;
1273
                }
1274
                /* undocumented Command Xy
1275
                        - has up to 5 Parameters
1276
                        - first Parameter might be the Blendmode
1277
                        - second Parameter is the Opacity
1278
                */
1279
                else if (command == "Xy")
1280
                {
13497 jghali 1281
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1282
                        ts2 >> blendMode >> Opacity;
1283
                }
1284
                else if (command == "XR")
1285
                {
13497 jghali 1286
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1287
                        ts2 >> tmpInt;
1288
                        if (tmpInt == 1)
1289
                                fillRule = true;
1290
                        else
1291
                                fillRule = false;
1292
                }
1293
                else if (command == "Bb")
1294
                {
1295
                        gradientMode = true;
1296
                        wasBC = false;
1297
                        itemRendered = false;
1298
                        startMatrix = QMatrix();
1299
                        endMatrix = QMatrix();
1300
                }
1301
                else if (command == "Xm")
1302
                {
13497 jghali 1303
                        ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
13371 jghali 1304
                        double m1, m2, m3, m4, m5, m6;
1305
                        gVals >> m1 >> m2 >> m3 >> m4 >> m5 >> m6;
1306
                        startMatrix.translate(m5, -m6);
1307
                        endMatrix.scale(m1, m4);
1308
                        wasBC = true;
1309
                }
1310
                else if (command == "Bm")
1311
                {
1312
                        if (m_gradients[currentGradientName].type() == 1)
1313
                        {
13497 jghali 1314
                                ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
13371 jghali 1315
                                double m1, m2, m3, m4, m5, m6;
1316
                                gVals >> m1 >> m2 >> m3 >> m4 >> m5 >> m6;
1317
                                startMatrix.translate(m5, -m6);
1318
//                              endMatrix.scale(m1, m4);
1319
                                endMatrix *= QMatrix(m1, m2, m3, m4, 0, 0);
1320
//                              endMatrix = QMatrix(m1, m2, m3, m4, m5, m6);
1321
                                wasBC = true;
1322
                        }
1323
                }
1324
                else if (command == "BB")
1325
                {
1326
                        if (itemRendered)
1327
                        {
1328
                                gradientMode = false;
17294 jghali 1329
                                ite = m_Doc->Items->last();
13371 jghali 1330
                                ite->fill_gradient = m_gradients[currentGradientName];
1331
                                if (ite->fill_gradient.type() == 0)
1332
                                        ite->GrType = 6;
1333
                                else
1334
                                        ite->GrType = 7;
1335
                                QMatrix m1;
1336
                                m1.translate(currentGradientOrigin.x() - ite->xPos(), currentGradientOrigin.y() - ite->yPos());
1337
                                m1.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
1338
                                m1.rotate(-currentGradientAngle);
1339
                                ite->GrStartX = currentGradientOrigin.x() - ite->xPos() + m_Doc->currentPage()->xOffset();
1340
                                ite->GrStartY = currentGradientOrigin.y() - ite->yPos() + m_Doc->currentPage()->yOffset();
1341
                                QPointF target = m1.map(QPointF(currentGradientLenght, 0.0));
1342
                                ite->GrEndX = target.x();
1343
                                ite->GrEndY = target.y();
1344
                                if (wasBC)
1345
                                {
1346
                                        QPointF newS = startMatrix.map(QPointF(ite->GrStartX, ite->GrStartY));
1347
                                        ite->GrStartX = newS.x();
1348
                                        ite->GrStartY = newS.y();
1349
                                        QMatrix m2;
1350
//                                      m2.translate(ite->GrStartX, ite->GrStartY);
1351
                                        m2.rotate(-currentGradientAngle);
1352
                                        m2 *= endMatrix;
1353
                                        QPointF target = m2.map(QPointF(currentGradientLenght, 0.0));
1354
                                        ite->GrEndX = target.x();
1355
                                        ite->GrEndY = target.y();
1356
                                }
1357
                        }
1358
                        wasBC = false;
1359
                        currentGradientMatrix = QMatrix();
1360
                        currentGradientOrigin = QPointF(0.0, 0.0);
1361
                        currentGradientAngle = 0.0;
1362
                        currentGradientLenght = 1.0;
1363
                        itemRendered = false;
1364
                }
1365
                else if (command == "Bg")
1366
                {
1367
                        int an = Cdata.indexOf("(");
1368
                        int en = Cdata.lastIndexOf(")");
1369
                        currentGradientName = Cdata.mid(an+1, en-an-1);
1370
                        currentGradientName.remove("\\");
1371
                        QString tmpS = Cdata.mid(en+1, Cdata.size() - en);
13497 jghali 1372
                        ScTextStream gVals(&tmpS, QIODevice::ReadOnly);
13371 jghali 1373
                        double xOrig, yOrig, m1, m2, m3, m4, m5, m6;
1374
                        gVals >> xOrig >> yOrig >> currentGradientAngle >> currentGradientLenght >> m1 >> m2 >> m3 >> m4 >> m5 >> m6;
1375
                        currentGradientOrigin = QPointF(xOrig - docX, docHeight - (yOrig - docY));
1376
                        currentGradientMatrix = QMatrix(m1, m2, m3, m4, m5, m6);
1377
                }
1378
/* End Graphics state commands */
1379
/* Start Color commands */
1380
                else if ((command == "G") || (command == "g"))
1381
                {
1382
                        if (command == "G")
1383
                                CurrColorStroke = parseColorGray(Cdata);
1384
                        else
1385
                                CurrColorFill = parseColorGray(Cdata);
1386
                }
1387
                else if ((command == "K") || (command == "k"))
1388
                {
1389
                        if (command == "K")
1390
                                CurrColorStroke = parseColor(Cdata);
1391
                        else
1392
                                CurrColorFill = parseColor(Cdata);
1393
                }
1394
                else if ((command == "XA") || (command == "Xa"))
1395
                {
1396
                        QString Xdata = da2[da2.count()-4] + " " + da2[da2.count()-3] + " " + da2[da2.count()-2];
1397
                        if (command == "XA")
1398
                                CurrColorStroke = parseColorRGB(Xdata);
1399
                        else
1400
                                CurrColorFill = parseColorRGB(Xdata);
1401
                }
1402
                else if ((command == "XX") || (command == "Xx") || (command == "Xk"))
1403
                {
1404
                        if (command == "XX")
1405
                                CurrColorStroke = parseCustomColorX(Cdata, CurrStrokeShade, da2[da2.count()-2]);
1406
                        else
1407
                                CurrColorFill = parseCustomColorX(Cdata, CurrFillShade, da2[da2.count()-2]);
1408
                }
1409
                else if ((command == "X") || (command == "x"))
1410
                {
1411
                        if (command == "X")
1412
                                CurrColorStroke = parseCustomColor(Cdata, CurrStrokeShade);
1413
                        else
1414
                                CurrColorFill = parseCustomColor(Cdata, CurrFillShade);
1415
                }
1416
                else if (command == "p")
1417
                {
1418
                        int an = Cdata.indexOf("(");
1419
                        int en = Cdata.lastIndexOf(")");
1420
                        currentPatternName = Cdata.mid(an+1, en-an-1);
1421
                        currentPatternName.remove("\\");
1422
                        currentPatternName = currentPatternName.trimmed().simplified().replace(" ", "_");
1423
                        QString tmpS = Cdata.mid(en+1, Cdata.size() - en);
13497 jghali 1424
                        ScTextStream gVals(&tmpS, QIODevice::ReadOnly);
13371 jghali 1425
                        gVals >> currentPatternX >> currentPatternY >> currentPatternXScale >> currentPatternYScale >> currentPatternRotation;
1426
                }
1427
                else if (command == "X!")
1428
                {
1429
                        if (Cdata.contains("/Mesh"))
1430
                        {
1431
                                QList<PageItem*> gElements;
1432
                                groupStack.push(gElements);
1433
                                meshMode = true;
1434
                                meshNodeCounter = 0;
1435
                                accumColorC = 0.0;
1436
                                accumColorM = 0.0;
1437
                                accumColorY = 0.0;
1438
                                accumColorK = 0.0;
1439
                        }
1440
                        if (Cdata.contains("/End"))
1441
                        {
1442
                                meshMode = false;
1443
                                if (groupStack.count() != 0)
1444
                                {
1445
                                        QList<PageItem*> gElements = groupStack.pop();
1446
                                        tmpSel->clear();
1447
                                        if (gElements.count() > 0)
1448
                                        {
1449
                                                for (int dre = 0; dre < gElements.count(); ++dre)
1450
                                                {
1451
                                                        tmpSel->addItem(gElements.at(dre), true);
1452
                                                }
1453
                                                m_Doc->itemSelection_GroupObjects(false, false, tmpSel);
1454
                                                ite = tmpSel->itemAt(0);
1455
                                                if (patternMode)
1456
                                                        PatternElements.append(ite);
1457
                                                else
1458
                                                        Elements.append(ite);
1459
                                        }
1460
                                        if (groupStack.count() != 0)
1461
                                        {
1462
                                                for (int as = 0; as < tmpSel->count(); ++as)
1463
                                                {
1464
                                                        groupStack.top().append(tmpSel->itemAt(as));
1465
                                                }
1466
                                        }
1467
                                        tmpSel->clear();
1468
                                }
1469
                        }
1470
                }
1471
                else if (command == "X#")
1472
                {
1473
                        int an = Cdata.indexOf("_");
1474
                        QString cmdLine = Cdata.remove(0, an+1);
1475
                        an = cmdLine.lastIndexOf("/");
1476
                        QString tmpS = cmdLine.mid(an+1, Cdata.size());
13497 jghali 1477
                        ScTextStream mVals(&tmpS, QIODevice::ReadOnly);
13371 jghali 1478
                        QString mKey;
1479
                        mVals >> mKey;
1480
                        if (mKey == "Size")
1481
                        {
1482
                                int ans = cmdLine.indexOf("[");
1483
                                int ens = cmdLine.lastIndexOf("]");
1484
                                QString sizeVals = cmdLine.mid(ans+1, ens-ans-1);
13497 jghali 1485
                                ScTextStream mVals2(&sizeVals, QIODevice::ReadOnly);
13371 jghali 1486
                                mVals2 >> meshXSize >> meshYSize;
1487
                        }
1488
                        if (mKey == "P")
1489
                        {
1490
                                int ans = cmdLine.indexOf("[");
1491
                                int ens = cmdLine.lastIndexOf("]");
1492
                                QString posVals = cmdLine.mid(ans+1, ens-ans-1);
13497 jghali 1493
                                ScTextStream mVals3(&posVals, QIODevice::ReadOnly);
13371 jghali 1494
                                mVals3 >> currentMeshXPos >> currentMeshYPos;
1495
                                accumColorC = 0.0;
1496
                                accumColorM = 0.0;
1497
                                accumColorY = 0.0;
1498
                                accumColorK = 0.0;
1499
                        }
1500
                        if (mKey == "CS")
1501
                        {
1502
                                if (Cdata.contains("CMYK"))
1503
                                        meshColorMode = 0;
1504
                                else if (Cdata.contains("RGB"))
1505
                                        meshColorMode = 1;
16524 fschmid 1506
                                else if (Cdata.contains("Gray"))
1507
                                        meshColorMode = 2;
13371 jghali 1508
                        }
1509
                        if (mKey == "E")
1510
                        {
1511
                                ScColor tmpColor;
1512
                                ColorList::Iterator it;
1513
                                int Cc = qRound((accumColorC / 4.0) * 255);
1514
                                int Mc = qRound((accumColorM / 4.0) * 255);
1515
                                int Yc = qRound((accumColorY / 4.0) * 255);
1516
                                int Kc = qRound((accumColorK / 4.0) * 255);
1517
                                int hC, hM, hY, hK;
1518
                                bool found = false;
1519
                                if (meshColorMode == 0)
1520
                                {
1521
                                        tmpColor.setColor(Cc, Mc, Yc, Kc);
1522
                                        for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
1523
                                        {
1524
                                                if (it.value().getColorModel() == colorModelCMYK)
1525
                                                {
1526
                                                        it.value().getCMYK(&hC, &hM, &hY, &hK);
1527
                                                        if ((Cc == hC) && (Mc == hM) && (Yc == hY) && (Kc == hK))
1528
                                                        {
1529
                                                                CurrColorFill = it.key();
1530
                                                                found = true;
1531
                                                                break;
1532
                                                        }
1533
                                                }
1534
                                        }
1535
                                }
16524 fschmid 1536
                                else if (meshColorMode == 1)
13371 jghali 1537
                                {
1538
                                        tmpColor.setColorRGB(Cc, Mc, Yc);
1539
                                        for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
1540
                                        {
1541
                                                if (it.value().getColorModel() == colorModelRGB)
1542
                                                {
1543
                                                        it.value().getRGB(&hC, &hM, &hY);
1544
                                                        if ((Cc == hC) && (Mc == hM) && (Yc == hY))
1545
                                                        {
1546
                                                                CurrColorFill = it.key();
1547
                                                                found = true;
1548
                                                                break;
1549
                                                        }
1550
                                                }
1551
                                        }
1552
                                }
16524 fschmid 1553
                                else if (meshColorMode == 2)
1554
                                {
1555
                                        tmpColor.setColor(0, 0, 0, Cc);
1556
                                        for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
1557
                                        {
1558
                                                if (it.value().getColorModel() == colorModelCMYK)
1559
                                                {
1560
                                                        it.value().getCMYK(&hC, &hM, &hY, &hK);
1561
                                                        if ((Cc == hC) && (Mc == hM) && (Yc == hY) && (Kc == hK))
1562
                                                        {
1563
                                                                CurrColorFill = it.key();
1564
                                                                found = true;
1565
                                                                break;
1566
                                                        }
1567
                                                }
1568
                                        }
1569
                                }
13371 jghali 1570
                                if (!found)
1571
                                {
1572
                                        tmpColor.setSpotColor(false);
1573
                                        tmpColor.setRegistrationColor(false);
1574
                                        QString namPrefix = "FromAI";
1575
                                        m_Doc->PageColors.insert(namPrefix+tmpColor.name(), tmpColor);
1576
                                        CurrColorFill = namPrefix+tmpColor.name();
1577
                                }
1578
                                meshNodeCounter = 0;
1579
                                Coords.resize(0);
1580
                                Coords.svgInit();
1581
                                Coords.svgMoveTo(meshNode1PointX, meshNode1PointY);
1582
                                Coords.svgCurveToCubic(meshNode1Control2X, meshNode1Control2Y, meshNode2Control1X, meshNode2Control1Y, meshNode2PointX, meshNode2PointY);
1583
                                Coords.svgCurveToCubic(meshNode2Control2X, meshNode2Control2Y, meshNode3Control1X, meshNode3Control1Y, meshNode3PointX, meshNode3PointY);
1584
                                Coords.svgCurveToCubic(meshNode3Control2X, meshNode3Control2Y, meshNode4Control1X, meshNode4Control1Y, meshNode4PointX, meshNode4PointY);
1585
                                Coords.svgCurveToCubic(meshNode4Control2X, meshNode4Control2Y, meshNode1Control1X, meshNode1Control1Y, meshNode1PointX, meshNode1PointY);
1586
                                z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, 0, CurrColorFill, CurrColorFill, true);
1587
                                ite = m_Doc->Items->at(z);
1588
                                ite->PoLine = Coords.copy();
1589
                                ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
1590
                                ite->ClipEdited = true;
1591
                                ite->FrameType = 3;
1592
                                ite->setFillShade(CurrFillShade);
1593
                                ite->setLineShade(CurrFillShade);
1594
                                ite->setFillEvenOdd(fillRule);
1595
                                ite->setFillTransparency(1.0 - Opacity);
1596
                                ite->setLineTransparency(1.0 - Opacity);
1597
                                ite->setLineEnd(CapStyle);
1598
                                ite->setLineJoin(JoinStyle);
1599
                                if (importerFlags & LoadSavePlugin::lfCreateDoc)
1600
                                        ite->setLocked(itemLocked);
1601
                                FPoint wh = getMaxClipF(&ite->PoLine);
1602
                                ite->setWidthHeight(wh.x(),wh.y());
1603
                                ite->setTextFlowMode(PageItem::TextFlowDisabled);
1604
                                m_Doc->AdjustItemSize(ite);
1605
                                if (patternMode)
1606
                                        PatternElements.append(ite);
1607
                                else
1608
                                        Elements.append(ite);
1609
                                if (groupStack.count() != 0)
1610
                                        groupStack.top().append(ite);
1611
                                Coords.resize(0);
1612
                                Coords.svgInit();
1613
                        }
1614
                        if (mKey == "N")
1615
                        {
1616
                                double cVal, mVal, yVal, kVal, coorX1, coorY1, coorX2, coorY2, coorX3, coorY3;
1617
                                int dummy;
1618
                                meshNodeCounter++;
1619
                                int ans = cmdLine.indexOf("[");
1620
                                int ens = cmdLine.lastIndexOf("]");
1621
                                QString nodeVals = cmdLine.mid(ans+1, ens-ans-1);
13497 jghali 1622
                                ScTextStream mVals4(&nodeVals, QIODevice::ReadOnly);
13371 jghali 1623
                                kVal = 0.0;
1624
                                if (meshColorMode == 0)
1625
                                        mVals4 >> cVal >> mVal >> yVal >> kVal >> coorX1 >> coorY1 >> coorX2 >> coorY2 >> dummy >> coorX3 >> coorY3;
16524 fschmid 1626
                                else if (meshColorMode == 1)
13371 jghali 1627
                                        mVals4 >> cVal >> mVal >> yVal >> coorX1 >> coorY1 >> coorX2 >> coorY2 >> dummy >> coorX3 >> coorY3;
16524 fschmid 1628
                                else if (meshColorMode == 2)
1629
                                        mVals4 >> cVal >> coorX1 >> coorY1 >> coorX2 >> coorY2 >> dummy >> coorX3 >> coorY3;
13371 jghali 1630
                                accumColorC += cVal;
1631
                                accumColorM += mVal;
1632
                                accumColorY += yVal;
1633
                                accumColorK += kVal;
1634
                                if (meshNodeCounter == 1)
1635
                                {
1636
                                        meshNode1PointX = coorX1 - docX;
1637
                                        meshNode1PointY = docHeight - (coorY1 - docY);
1638
                                        meshNode1Control2X = coorX2 - docX;
1639
                                        meshNode1Control2Y = docHeight - (coorY2 - docY);
1640
                                        meshNode1Control1X = coorX3 - docX;
1641
                                        meshNode1Control1Y = docHeight - (coorY3 - docY);
1642
                                }
1643
                                if (meshNodeCounter == 2)
1644
                                {
1645
                                        meshNode2PointX = coorX1 - docX;
1646
                                        meshNode2PointY = docHeight - (coorY1 - docY);
1647
                                        meshNode2Control2X = coorX2 - docX;
1648
                                        meshNode2Control2Y = docHeight - (coorY2 - docY);
1649
                                        meshNode2Control1X = coorX3 - docX;
1650
                                        meshNode2Control1Y = docHeight - (coorY3 - docY);
1651
                                }
1652
                                if (meshNodeCounter == 3)
1653
                                {
1654
                                        meshNode3PointX = coorX1 - docX;
1655
                                        meshNode3PointY = docHeight - (coorY1 - docY);
1656
                                        meshNode3Control2X = coorX2 - docX;
1657
                                        meshNode3Control2Y = docHeight - (coorY2 - docY);
1658
                                        meshNode3Control1X = coorX3 - docX;
1659
                                        meshNode3Control1Y = docHeight - (coorY3 - docY);
1660
                                }
1661
                                if (meshNodeCounter == 4)
1662
                                {
1663
                                        meshNode4PointX = coorX1 - docX;
1664
                                        meshNode4PointY = docHeight - (coorY1 - docY);
1665
                                        meshNode4Control2X = coorX2 - docX;
1666
                                        meshNode4Control2Y = docHeight - (coorY2 - docY);
1667
                                        meshNode4Control1X = coorX3 - docX;
1668
                                        meshNode4Control1Y = docHeight - (coorY3 - docY);
1669
                                }
1670
                        }
1671
                }
1672
/* End Color commands */
1673
/* Start Layer commands */
1674
                else if (command == "Lb")
1675
                {
1676
                        if (importerFlags & LoadSavePlugin::lfCreateDoc)
1677
                        {
1678
                                int visible, preview, enabled, printing, dummy, rc, gc, bc;
13497 jghali 1679
                                ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1680
                                ts2 >> visible >> preview >> enabled >> printing >> dummy >> dummy >> dummy >> rc >> gc >> bc;
1681
                                if (!firstLayer)
1682
                                        currentLayer = m_Doc->addLayer("Layer", true);
1683
                                m_Doc->setLayerVisible(currentLayer, static_cast<bool>(visible));
1684
                                m_Doc->setLayerOutline(currentLayer, static_cast<bool>(!preview));
1685
                                m_Doc->setLayerLocked(currentLayer, static_cast<bool>(!enabled));
1686
                                m_Doc->setLayerPrintable(currentLayer, static_cast<bool>(printing));
1687
                                m_Doc->setLayerMarker(currentLayer, QColor(rc, gc, bc));
1688
                                firstLayer = false;
1689
                        }
1690
                        Coords.resize(0);
1691
                        Coords.svgInit();
1692
                }
1693
                else if (command == "LB")
1694
                {
1695
                        Coords.resize(0);
1696
                        Coords.svgInit();
1697
                }
1698
                else if (command == "Ln")
1699
                {
1700
                        if (importerFlags & LoadSavePlugin::lfCreateDoc)
1701
                        {
1702
                                int an = Cdata.indexOf("(");
1703
                                int en = Cdata.lastIndexOf(")");
1704
                                QString LayerNam = Cdata.mid(an+1, en-an-1);
1705
                                LayerNam.remove("\\");
1706
                                m_Doc->changeLayerName(currentLayer, LayerNam);
1707
                        }
1708
                }
1709
/* End Layer commands */
1710
/* Start Text commands */
1711
                else if (command == "To")
1712
                {
13497 jghali 1713
                        ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
13371 jghali 1714
                        ts2 >> textMode;
1715
                        textData.clear();
1716
                        textMatrix = QMatrix();
1717
                        maxWidth = 0;
1718
                        tempW = 0;
1719
                        maxHeight = 0;
1720
                        textKern = 0;
1721
                        startCurrentTextRange = 0;
1722
                        endCurrentTextRange = 0;
1723
                        textScaleH = 1000;
1724
                        textScaleV = 1000;
1725
                }
1726
                else if (command == "Tp")
1727
                {
13497 jghali 1728
                        ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
13371 jghali 1729
                        double m1, m2, m3, m4, m5, m6;
1730
                        gVals >> m1 >> m2 >> m3 >> m4 >> m5 >> m6;
1731
                        textMatrix = QMatrix(m1, m2, m3, m4, m5, m6);
1732
                }
1733
                else if (command == "Tx") // || (command == "TX"))
1734
                {
1735
                        QStringList res = getStrings(Cdata);
1736
                        if (res.count() > 0)
1737
                        {
1738
                                QString tex = res[0];
1739
                                double tempH = 0;
1740
                                startCurrentTextRange = textData.length();
1741
                                for (int tt = 0; tt < tex.length(); ++tt)
1742
                                {
1743
                                        CharStyle nstyle;
1744
                                        QString ch = tex.mid(tt,1);
1745
                                        nstyle.setFont((*m_Doc->AllFonts)[textFont]);
1746
                                        nstyle.setFontSize(textSize);
1747
                                        nstyle.setFillColor(CurrColorFill);
1748
                                        nstyle.setTracking(textKern);
1749
                                        nstyle.setFillShade(100);
1750
                                        nstyle.setStrokeColor(CurrColorStroke);
1751
                                        nstyle.setStrokeShade(100);
1752
                                        nstyle.setScaleH(textScaleH);
1753
                                        nstyle.setScaleV(textScaleV);
1754
                                        nstyle.setBaselineOffset(0);
1755
                                        nstyle.setShadowXOffset(50);
1756
                                        nstyle.setShadowYOffset(-50);
1757
                                        nstyle.setOutlineWidth(10);
1758
                                        nstyle.setUnderlineOffset(-1);
1759
                                        nstyle.setUnderlineWidth(-1);
1760
                                        nstyle.setStrikethruOffset(-1);
1761
                                        nstyle.setStrikethruWidth(-1);
1762
                                        nstyle.setFeatures(StyleFlag(ScStyle_Default).featureList());
1763
                                        int pot = textData.length();
1764
                                        textData.insertChars(pot, ch);
1765
                                        textData.applyCharStyle(pot, 1, nstyle);
1766
                                        tempW += nstyle.font().realCharWidth(ch[0], nstyle.fontSize() / 10.0)+1;
1767
                                        tempH  = qMax(tempH, nstyle.font().height(nstyle.fontSize() / 10.0) + 2.0);
1768
                                        maxWidth  = qMax(tempW, maxWidth);
1769
                                        maxHeight = qMax(tempH, maxHeight);
1770
                                        if ((ch == SpecialChars::PARSEP) || (ch == SpecialChars::LINEBREAK))
1771
                                        {
1772
                                                maxHeight += nstyle.font().height(nstyle.fontSize() / 10.0);
1773
                                                tempW = 0;
1774
                                        }
1775
                                        endCurrentTextRange = pot;
1776
                                }
1777
                        }
1778
                }
1779
                else if (command == "Tk")
1780
                {
1781
                        int flag;
1782
                        double val;
13497 jghali 1783
                        ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
13371 jghali 1784
                        gVals >> flag >> val;
1785
                        if (flag == 1)
1786
                                val = 0;
1787
                        double oldval = textData.charStyle(startCurrentTextRange).tracking();
1788
                        CharStyle nstyle = textData.charStyle(startCurrentTextRange);
1789
                        nstyle.setTracking(oldval + val);
1790
                        textData.applyCharStyle(startCurrentTextRange, 1, nstyle);
1791
                }
1792
                else if (command == "Tc")
1793
                {
13497 jghali 1794
                        ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
13371 jghali 1795
                        gVals >> textKern;
1796
                        textKern *= 100.0;
1797
                }
1798
                else if (command == "Tz")
1799
                {
13497 jghali 1800
                        ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
13371 jghali 1801
                        gVals >> textScaleH >> textScaleV;
1802
                        textScaleH *= 10.0;
1803
                        textScaleV *= 10.0;
1804
                }
1805
                else if (command == "T*")
1806
                {
1807
                        CharStyle nstyle;
1808
                        QString ch = SpecialChars::LINEBREAK;
1809
                        nstyle.setFont((*m_Doc->AllFonts)[textFont]);
1810
                        nstyle.setFontSize(textSize);
1811
                        nstyle.setFillColor(CurrColorFill);
1812
                        nstyle.setTracking(textKern);
1813
                        nstyle.setFillShade(100);
1814
                        nstyle.setStrokeColor(CurrColorStroke);
1815
                        nstyle.setStrokeShade(100);
1816
                        nstyle.setScaleH(textScaleH);
1817
                        nstyle.setScaleV(textScaleV);
1818
                        nstyle.setBaselineOffset(0);
1819
                        nstyle.setShadowXOffset(50);
1820
                        nstyle.setShadowYOffset(-50);
1821
                        nstyle.setOutlineWidth(10);
1822
                        nstyle.setUnderlineOffset(-1);
1823
                        nstyle.setUnderlineWidth(-1);
1824
                        nstyle.setStrikethruOffset(-1);
1825
                        nstyle.setStrikethruWidth(-1);
1826
                        nstyle.setFeatures(StyleFlag(ScStyle_Default).featureList());
1827
                        int pot = textData.length();
1828
                        textData.insertChars(pot, ch);
1829
                        textData.applyCharStyle(pot, 1, nstyle);
1830
                        maxHeight += nstyle.font().height(nstyle.fontSize() / 10.0) + 2.0;
1831
                        tempW = 0;
1832
                }
1833
                else if (command == "Tf")
1834
                {
13497 jghali 1835
                        ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
13371 jghali 1836
                        gVals >> textFont >> textSize;
1837
                        textFont.remove(0, 2);
1838
                        QString family = textFont;
1839
                        QString ret = "";
1840
                        family.replace( QRegExp( "'" ) , QChar( ' ' ) );
1841
                        textFont = m_Doc->toolSettings.defFont;
1842
                        bool found = false;
1843
                        SCFontsIterator it(PrefsManager::instance()->appPrefs.AvailFonts);
1844
                        for ( ; it.hasNext(); it.next())
1845
                        {
1846
                                QString fam;
1847
                                QString fn = it.current().scName();
1848
                                int pos = fn.indexOf(" ");
1849
                                fam = fn.left(pos);
1850
                                if (fam == family)
1851
                                {
1852
                                        found = true;
1853
                                        ret = fn;
1854
                                }
1855
                        }
1856
                        if (found)
1857
                                textFont = family;
1858
                        else
1859
                        {
1860
                                if (!PrefsManager::instance()->appPrefs.GFontSub.contains(family))
1861
                                {
1862
                                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1863
                                        MissingFont *dia = new MissingFont(0, family, m_Doc);
1864
                                        dia->exec();
1865
                                        QString tmpf = dia->getReplacementFont();
1866
                                        delete dia;
1867
                                        qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
1868
                                        PrefsManager::instance()->appPrefs.GFontSub[family] = tmpf;
1869
                                }
1870
                                else
1871
                                        textFont = PrefsManager::instance()->appPrefs.GFontSub[family];
1872
                        }
1873
                        textSize *= 10.0;
1874
                }
1875
                else if (command == "TO")
1876
                {
1877
                        if (textData.length() > 0)
1878
                        {
1879
                                if (!((textData.length() == 1) && (textData.text(0) == SpecialChars::PARSEP)))
1880
                                {
1881
                                        QPointF pos = QPointF(textMatrix.dx(), textMatrix.dy());
1882
                                        pos += QPointF(m_Doc->currentPage()->xOffset(), -m_Doc->currentPage()->yOffset());
1883
                                        pos += QPointF(0.0, textSize / 10.0 + 2.0);
1884
                                        z = m_Doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, pos.x() - docX, docHeight - (pos.y() - docY), 10, 10, 0, CommonStrings::None, CommonStrings::None, true);
1885
                                        ite = m_Doc->Items->at(z);
1886
                                        ite->setTextToFrameDist(0.0, 0.0, 0.0, 0.0);
1887
                                        ite->itemText.append(textData);
1888
                                        double xpos = ite->xPos();
1889
                                        double ypos = ite->yPos();
1890
                                        ite->setWidthHeight(qMax(ite->width(), maxWidth), qMax(ite->height(), maxHeight));
1891
                                        double xoffset = 0.0, yoffset = 0.0;
1892
                                        double rotation = getRotationFromMatrix(textMatrix, 0.0);
1893
                                        if (rotation != 0.0)
1894
                                        {
1895
                                                double temp = textSize / 10.0 + 2.0;
1896
                                                xoffset = sin(rotation) * temp;
1897
                                                yoffset = cos(rotation) * temp;
1898
                                        }
1899
                                        ite->setXPos(xpos + xoffset);
1900
                                        ite->setYPos(ypos + yoffset);
1901
                                        ite->setRotation(rotation * 180 / M_PI);
1902
                                        ite->SetRectFrame();
1903
                                        m_Doc->setRedrawBounding(ite);
1904
                                        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
1905
                                        ite->setTextFlowMode(PageItem::TextFlowDisabled);
1906
                                        ite->setFillShade(CurrFillShade);
1907
                                        ite->setLineShade(CurrStrokeShade);
1908
                                        ite->setFillEvenOdd(fillRule);
1909
                                        ite->setFillTransparency(1.0 - Opacity);
1910
                                        ite->setLineTransparency(1.0 - Opacity);
1911
                                        ite->setLineEnd(CapStyle);
1912
                                        ite->setLineJoin(JoinStyle);
1913
                                        if (importerFlags & LoadSavePlugin::lfCreateDoc)
1914
                                                ite->setLocked(itemLocked);
1915
                                        if (patternMode)
1916
                                                PatternElements.append(ite);
1917
                                        else
1918
                                                Elements.append(ite);
1919
                                        if (groupStack.count() != 0)
1920
                                                groupStack.top().append(ite);
1921
                                }
1922
                        }
1923
                }
1924
/* End Text commands */
1925
/* Start special Commands */
1926
                else if (command == "*")
1927
                {
1928
                        Coords.resize(0);
1929
                        Coords.svgInit();
1930
                }
1931
                else if ((command == "N") || (command == "n"))
1932
                {
1933
                        Coords.resize(0);
1934
                        Coords.svgInit();
1935
                }
1936
                else if (command == "[")
1937
                {
1938
                        Coords.resize(0);
1939
                        Coords.svgInit();
1940
                        int an = Cdata.indexOf("(");
1941
                        int en = Cdata.lastIndexOf(")");
1942
                        if ((an != -1) && (en != -1))
1943
                        {
1944
                                patternMode = true;
1945
                                currentPatternDefName = Cdata.mid(an+1, en-an-1);
1946
                                currentPatternDefName.remove("\\");
1947
                                currentPatternDefName = currentPatternDefName.trimmed().simplified().replace(" ", "_");
1948
                                QString tmpS = Cdata.mid(en+1, Cdata.size() - en);
13497 jghali 1949
                                ScTextStream gVals(&tmpS, QIODevice::ReadOnly);
13371 jghali 1950
                                gVals >> patternX1 >> patternY1 >> patternX2 >> patternY2;
1951
                        }
1952
                }
1953
/* End special Commands */
1954
/* Skip everything else */
1955
//              else
1956
//                      qDebug(command);
1957
        }
1958
}
1959
 
1960
void AIPlug::processGradientData(QString data)
1961
{
1962
        QString command = "";
1963
        QString Cdata = "";
1964
        QStringList da;
1965
        getCommands(data, da);
1966
        for (int a = 0; a < da.count(); a++)
1967
        {
1968
                Cdata = da[a];
1969
                QStringList da2 = Cdata.split(" ", QString::SkipEmptyParts);
17294 jghali 1970
                command = da2.last();
13371 jghali 1971
                if (command == "Bd")
1972
                {
1973
                        QString tmpS = Cdata;
1974
                        int an = Cdata.indexOf("(");
1975
                        int en = Cdata.lastIndexOf(")");
1976
                        currentGradientName = Cdata.mid(an+1, en-an-1);
1977
                        currentGradientName.remove("\\");
1978
                        if (da2[da2.count()-3] == "0")
1979
                                currentGradient = VGradient(VGradient::linear);
1980
                        else
1981
                                currentGradient = VGradient(VGradient::radial);
1982
                        currentGradient.clearStops();
1983
                }
1984
                else if ((command == "%_Bs") || (command == "%_BS"))
1985
                {
1986
                        QString stopName = "";
13465 cbradney 1987
                        double stop = ScCLocale::toDoubleC(da2[da2.count()-2]) / 100.0;
13371 jghali 1988
                        double colorShade = 100.0;
1989
                        int colortype = da2[da2.count()-4].toInt();
1990
                        if (colortype == 0)
1991
                        {
1992
                                stopName = parseColorGray(Cdata);
1993
                                const ScColor& gradC = m_Doc->PageColors[stopName];
1994
                                currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), stop, 0.5, 1.0, stopName, 100 );
1995
                        }
1996
                        else if (colortype == 1)
1997
                        {
1998
                                stopName = parseColor(Cdata);
1999
                                const ScColor& gradC = m_Doc->PageColors[stopName];
2000
                                currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), stop, 0.5, 1.0, stopName, 100 );
2001
                        }
2002
                        else if (colortype == 2)
2003
                        {
2004
                                stopName = parseColor(Cdata);
2005
                                const ScColor& gradC = m_Doc->PageColors[stopName];
2006
                                currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), stop, 0.5, 1.0, stopName, 100 );
2007
                        }
2008
                        else if (colortype == 3)
2009
                        {
2010
                                stopName = parseCustomColor(Cdata, colorShade);
18127 jghali 2011
                                int stopShade =  qRound(colorShade);
13371 jghali 2012
                                const ScColor& gradC = m_Doc->PageColors[stopName];
18127 jghali 2013
                                currentGradient.addStop( ScColorEngine::getShadeColor(gradC, m_Doc, stopShade), stop, 0.5, 1.0, stopName, stopShade);
13371 jghali 2014
                        }
2015
                        else if (colortype == 4)
2016
                        {
2017
                                stopName = parseCustomColorX(Cdata, colorShade, "0");
18127 jghali 2018
                                int stopShade =  qRound(colorShade);
13371 jghali 2019
                                const ScColor& gradC = m_Doc->PageColors[stopName];
18127 jghali 2020
                                currentGradient.addStop( ScColorEngine::getShadeColor(gradC, m_Doc, stopShade), stop, 0.5, 1.0, stopName, stopShade);
13371 jghali 2021
                        }
2022
                }
2023
                else if (command == "BD")
2024
                {
2025
                        m_gradients.insert(currentGradientName, currentGradient);
2026
                        currentGradient = VGradient(VGradient::linear);
2027
                        currentGradient.clearStops();
2028
                        currentGradient.setRepeatMethod( VGradient::none );
2029
                        currentGradientName = "";
2030
                }
2031
        }
2032
}
2033
 
2034
void AIPlug::processPattern(QDataStream &ts)
2035
{
2036
        QString tmp = "";
2037
        QString tmpData = "";
2038
        while (!ts.atEnd())
2039
        {
2040
                tmp = removeAIPrefix(readLinefromDataStream(ts));
2041
                if (patternMode)
2042
                {
2043
                        if (tmp == "EndPattern")
2044
                        {
2045
                                tmpSel->clear();
2046
                                if (PatternElements.count() > 0)
2047
                                {
2048
                                        for (int dre = 0; dre < PatternElements.count(); ++dre)
2049
                                        {
2050
                                                tmpSel->addItem(PatternElements.at(dre), true);
2051
                                        }
2052
                                        if (PatternElements.count() > 1)
2053
                                                m_Doc->itemSelection_GroupObjects(false, false, tmpSel);
2054
                                        ScPattern pat = ScPattern();
2055
                                        pat.setDoc(m_Doc);
2056
                                        PageItem* currItem = tmpSel->itemAt(0);
2057
                                        currItem->setItemName(currentPatternDefName);
2058
                                        m_Doc->DoDrawing = true;
2059
                                        QImage tmpImg = currItem->DrawObj_toImage();
2060
                                        QImage retImg = QImage(qRound(patternX2 - patternX1), qRound(patternY2 - patternY1), QImage::Format_ARGB32);
2061
                                        retImg.fill( qRgba(255, 255, 255, 0) );
2062
                                        QPainter p;
2063
                                        p.begin(&retImg);
2064
                                        if (PatternElements.count() > 1)
2065
                                                p.drawImage(qRound(-patternX1), qRound(-patternY1), tmpImg);
2066
                                        else
2067
                                                p.drawImage(0, 0, tmpImg);
2068
                                        p.end();
2069
                                        pat.pattern = retImg;
2070
//                                      pat.pattern = currItem->DrawObj_toImage();
2071
                                        m_Doc->DoDrawing = false;
2072
                                        //                      pat.width = currItem->gWidth;
2073
                                        //                      pat.height = currItem->gHeight;
2074
                                        pat.width = patternX2 - patternX1;
2075
                                        pat.height = patternY2 - patternY1;
2076
                                        pat.xoffset = -patternX1;
2077
                                        pat.yoffset = -patternY1;
2078
                                        for (int as = 0; as < tmpSel->count(); ++as)
2079
                                        {
2080
                                                PageItem* Neu = tmpSel->itemAt(as);
2081
                                                Neu->moveBy(-patternX1, -patternY1, true);
2082
                                                Neu->gXpos -= patternX1;
2083
                                                Neu->gYpos -= patternY1;
2084
                                                pat.items.append(Neu);
2085
                                        }
2086
                                        m_Doc->itemSelection_DeleteItem(tmpSel);
2087
                                        m_Doc->addPattern(currentPatternDefName, pat);
2088
                                }
2089
                                PatternElements.clear();
2090
                                currentPatternDefName = "";
2091
                                break;
2092
                        }
2093
                        else if (tmp.startsWith("Tile"))
2094
                                continue;
2095
                        else if (tmp.contains(") @"))
2096
                        {
2097
                                tmpData += tmp;
2098
                                tmpData.remove(") @");
2099
                                processData(tmpData);
2100
                                tmpData = "";
2101
                        }
2102
                        else if (tmp.contains(") &"))
2103
                        {
2104
                                tmpData += tmp;
2105
                                tmpData.remove(") &");
2106
                                processData(tmpData);
2107
                                tmpData = "";
2108
                        }
2109
                        else
2110
                        {
2111
                                if (tmp.startsWith("("))
2112
                                        tmp.remove(0, 1);
2113
                                tmpData += " "+tmp;
2114
                        }
2115
                }
2116
                else if (tmp == "EndPattern")
2117
                {
2118
                        PatternElements.clear();
2119
                        currentPatternDefName = "";
2120
                        break;
2121
                }
2122
                else
2123
                        processData(tmp);
2124
        }
2125
        patternMode = false;
2126
}
2127
 
2128
void AIPlug::processRaster(QDataStream &ts)
2129
{
2130
        double m1, m2, m3, m4, m5, m6, x1, y1, x2, y2, dummy;
2131
        int w, h, type, alpha, bin, bits;
2132
        QString tmp = "";
2133
        QString cumulated = "";
2134
        while (!ts.atEnd())
2135
        {
2136
                tmp = readLinefromDataStream(ts);
2137
                if (tmp.startsWith("%"))
2138
                        break;
2139
                tmp.remove("[");
2140
                tmp.remove("]");
2141
                if (!tmp.isEmpty())
2142
                        cumulated += " " + tmp;
2143
        }
2144
        QString Cdata = "";
2145
        QStringList da;
2146
        getCommands(cumulated, da);
17294 jghali 2147
        Cdata = da.last();
13497 jghali 2148
        ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
13371 jghali 2149
        gVals >> m1 >> m2 >> m3 >> m4 >> m5 >> m6 >> x1 >> y1 >> x2 >> y2 >> w >> h >> bits >> type >> alpha >> dummy >> bin;
2150
//      qDebug() << QString("Matrix: %1 %2 %3 %4 %5 %6").arg(m1).arg(m2).arg(m3).arg(m4).arg(m5).arg(m6);
2151
//      qDebug() << QString("Bounds: %1 %2 %3 %4").arg(x1).arg(y1).arg(x2).arg(y2);
2152
//      qDebug() << QString("Size: %1 %2").arg(w).arg(h);
2153
//      qDebug() << QString("Bits: %1").arg(bits);
2154
//      qDebug() << QString("Typ: %1").arg(type);
2155
//      qDebug() << QString("Alpha-Channels: %1").arg(alpha);
2156
//      qDebug() << QString("Encoding: %1").arg(bin);
2157
        uint dataSize = w * h * (type + alpha);
2158
        uint alphaData = w * h * type;
2159
        bool cmyk = false;
2160
        if (type == 4)
2161
                cmyk = true;
2162
        if (tmp.startsWith("%%BeginData"))
2163
        {
2164
                QString dummyS;
13497 jghali 2165
                ScTextStream gVals2(&tmp, QIODevice::ReadOnly);
13371 jghali 2166
                tmp = readLinefromDataStream(ts);
2167
        }
2168
        QByteArray psdata;
2169
        psdata.resize(dataSize);
2170
        RawImage m_image;
2171
        if (type == 4)
2172
        {
2173
                if (alpha > 0)
2174
                        m_image.create(w, 1, 5);
2175
                else
2176
                        m_image.create(w, 1, 4);
2177
        }
2178
        else
2179
        {
2180
                if (alpha > 0)
2181
                        m_image.create(w, 1, 4);
2182
                else
2183
                        m_image.create(w, 1, 3);
2184
        }
2185
        bool first = false;
2186
        if (bin == 0) // 0 = ASCII encoded data
2187
        {
2188
                uint dataPointer = 0;
2189
                while (!ts.atEnd())
2190
                {
2191
                        if (first)
2192
                                tmp = readLinefromDataStream(ts);
2193
                        first = true;
2194
                        if (tmp.startsWith("%AI5_EndRaster"))
2195
                                break;
2196
                        for (int a = 1; a < tmp.length(); a += 2)
2197
                        {
2198
                                bool ok;
2199
                                ushort data = tmp.mid(a, 2).toUShort(&ok, 16);
2200
                                psdata[dataPointer++] = data;
2201
                        }
2202
                }
2203
        }
2204
        else
2205
        {
2206
                psdata.resize(dataSize);
2207
                ts.readRawData(psdata.data(), dataSize);
2208
        }
2209
        QMatrix imgMatrix = QMatrix(m1, m2, m3, m4, m5, m6);
2210
        QPointF pos = QPointF(imgMatrix.dx(), imgMatrix.dy());
2211
        pos += QPointF(m_Doc->currentPage()->xOffset(), -m_Doc->currentPage()->yOffset());
2212
        pos += QPointF(baseX, -baseY);
2213
        int z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, pos.x() - docX, docHeight - (pos.y() - docY), 10, 10, 0, CurrColorFill, CurrColorStroke, true);
2214
        PageItem* ite = m_Doc->Items->at(z);
2215
        ite->setWidthHeight(w * m1, h * m4);
2216
        double rotation = getRotationFromMatrix(imgMatrix, 0.0);
2217
        ite->setRotation(rotation * 180 / M_PI);
2218
        ite->SetRectFrame();
2219
        m_Doc->setRedrawBounding(ite);
2220
        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
2221
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
2222
        ite->setFillShade(CurrFillShade);
2223
        ite->setLineShade(CurrStrokeShade);
2224
        ite->setFillEvenOdd(fillRule)