Subversion Repositories Scribus

Rev

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

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