Subversion Repositories Scribus

Rev

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