Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 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
*/
2688 craig 7
 
10862 cbradney 8
#include <QByteArray>
10223 cbradney 9
#include <QCursor>
13085 jghali 10
#include <QDebug>
9764 jghali 11
#include <QDrag>
10862 cbradney 12
#include <QFile>
13
#include <QList>
16546 jghali 14
#include <QMessageBox>
9764 jghali 15
#include <QMimeData>
10862 cbradney 16
#include <QRegExp>
9922 fschmid 17
#include <QStack>
10862 cbradney 18
 
290 Franz 19
#include <cstdlib>
4930 cbradney 20
 
10862 cbradney 21
#include "commonstrings.h"
22
#include "importps.h"
23
#include "loadsaveplugin.h"
24
#include "prefscontext.h"
25
#include "prefsfile.h"
26
#include "prefsmanager.h"
27
#include "prefstable.h"
28
#include "scconfig.h"
13457 cbradney 29
#include "scclocale.h"
12841 jghali 30
#include "scmimedata.h"
1693 craig 31
#include "scpaths.h"
10862 cbradney 32
#include "scribus.h"
33
#include "scribusXml.h"
34
#include "scribuscore.h"
13503 cbradney 35
#include "sctextstream.h"
3934 cbradney 36
#include "selection.h"
14170 jghali 37
#include "ui/customfdialog.h"
38
#include "ui/multiprogressdialog.h"
39
#include "ui/propertiespalette.h"
4930 cbradney 40
#include "undomanager.h"
2529 craig 41
#include "util.h"
12015 fschmid 42
#include "util_color.h"
10212 cbradney 43
#include "util_formats.h"
10200 cbradney 44
#include "util_icon.h"
10203 cbradney 45
#include "util_math.h"
13011 fschmid 46
#ifdef HAVE_PODOFO
47
        #include <podofo/podofo.h>
48
#endif
290 Franz 49
 
10862 cbradney 50
 
5346 mrdocs 51
extern SCRIBUS_API ScribusQApp * ScQApp;
4645 subik 52
 
8052 jghali 53
EPSPlug::EPSPlug(ScribusDoc* doc, int flags)
290 Franz 54
{
12971 jghali 55
        tmpSel = new Selection(this, false);
56
        m_Doc  = doc;
57
        progressDialog = NULL;
5539 mrdocs 58
        interactive = (flags & LoadSavePlugin::lfInteractive);
8052 jghali 59
}
60
 
13371 jghali 61
bool EPSPlug::import(QString fName, const TransactionSettings &trSettings, int flags, bool showProgress)
8052 jghali 62
{
63
        bool success = false;
64
        interactive = (flags & LoadSavePlugin::lfInteractive);
4923 avox 65
        cancel = false;
12015 fschmid 66
        double x, y, b, h;
290 Franz 67
        bool ret = false;
68
        bool found = false;
69
        CustColors.clear();
70
        QFileInfo fi = QFileInfo(fName);
10516 cbradney 71
        QString ext = fi.suffix().toLower();
5243 cbradney 72
        if ( !ScCore->usingGUI() ) {
4999 avox 73
                interactive = false;
74
                showProgress = false;
75
        }
5781 cbradney 76
        if ( showProgress )
77
        {
78
                ScribusMainWindow* mw=(m_Doc==0) ? ScCore->primaryMainWindow() : m_Doc->scMW();
10508 cbradney 79
                progressDialog = new MultiProgressDialog( tr("Importing: %1").arg(fi.fileName()), CommonStrings::tr_Cancel, mw);
4923 avox 80
                QStringList barNames, barTexts;
81
                barNames << "GI";
4949 cbradney 82
                barTexts << tr("Analyzing PostScript:");
9803 fschmid 83
                QList<bool> barsNumeric;
5370 cbradney 84
                barsNumeric << false;
85
                progressDialog->addExtraProgressBars(barNames, barTexts, barsNumeric);
4923 avox 86
                progressDialog->setOverallTotalSteps(3);
87
                progressDialog->setOverallProgress(0);
88
                progressDialog->setProgress("GI", 0);
89
                progressDialog->show();
10724 cbradney 90
                connect(progressDialog, SIGNAL(canceled()), this, SLOT(cancelRequested()));
5243 cbradney 91
                qApp->processEvents();
4923 avox 92
        }
4999 avox 93
        else {
94
                progressDialog = NULL;
95
        }
4923 avox 96
 
319 Franz 97
/* Set default Page to size defined in Preferences */
290 Franz 98
        x = 0.0;
99
        y = 0.0;
13876 cbradney 100
        b = PrefsManager::instance()->appPrefs.docSetupPrefs.pageWidth;
101
        h = PrefsManager::instance()->appPrefs.docSetupPrefs.pageHeight;
10136 cbradney 102
        if (extensionIndicatesEPSorPS(ext))
290 Franz 103
        {
4000 fschmid 104
                QString tmp, BBox, tmp2, FarNam;
2886 fschmid 105
                ScColor cc;
290 Franz 106
                QFile f(fName);
8501 cbradney 107
                if (f.open(QIODevice::ReadOnly))
290 Franz 108
                {
109
/* Try to find Bounding Box */
9991 fschmid 110
                        QDataStream ts(&f);
290 Franz 111
                        while (!ts.atEnd())
112
                        {
9991 fschmid 113
                                tmp = readLinefromDataStream(ts);
290 Franz 114
                                if (tmp.startsWith("%%BoundingBox:"))
115
                                {
116
                                        found = true;
117
                                        BBox = tmp.remove("%%BoundingBox:");
118
                                }
119
                                if (!found)
120
                                {
121
                                        if (tmp.startsWith("%%BoundingBox"))
122
                                        {
123
                                                found = true;
124
                                                BBox = tmp.remove("%%BoundingBox");
125
                                        }
126
                                }
127
                                if (tmp.startsWith("%%EndComments"))
12015 fschmid 128
                                        break;
290 Franz 129
                        }
130
                        f.close();
131
                        if (found)
132
                        {
10603 fschmid 133
                                QStringList bb = BBox.split(" ", QString::SkipEmptyParts);
319 Franz 134
                                if (bb.count() == 4)
135
                                {
13497 jghali 136
                                        x = ScCLocale::toDoubleC(bb[0]);
137
                                        y = ScCLocale::toDoubleC(bb[1]);
138
                                        b = ScCLocale::toDoubleC(bb[2]);
139
                                        h = ScCLocale::toDoubleC(bb[3]);
319 Franz 140
                                }
290 Franz 141
                        }
142
                }
12015 fschmid 143
                importColorsFromFile(fName, CustColors);
290 Franz 144
        }
13011 fschmid 145
#ifdef HAVE_PODOFO
146
        else if (extensionIndicatesPDF(ext))
147
        {
148
                try
149
                {
150
                        PoDoFo::PdfError::EnableDebug( false );
13016 cbradney 151
#if (PODOFO_VERSION == 0 && PODOFO_MINOR > 6)
152
                PoDoFo::PdfError::EnableLogging( false );
153
#endif
13011 fschmid 154
#if (PODOFO_VERSION == 0 && PODOFO_MINOR == 5 && PODOFO_REVISION == 99) || PODOFO_MINOR > 5
155
                        PoDoFo::PdfMemDocument doc( fName.toLocal8Bit().data() );
156
#else
157
                        PoDoFo::PdfDocument doc( fName.toLocal8Bit().data() );
158
#endif
159
                        PoDoFo::PdfPage *curPage = doc.GetPage(0);
160
                        if (curPage != NULL)
161
                        {
162
                                PoDoFo::PdfRect rect = curPage->GetMediaBox();
163
                                b = rect.GetWidth() - rect.GetLeft();
164
                                h = rect.GetHeight() - rect.GetBottom();
165
                        }
166
                }
167
                catch(PoDoFo::PdfError& e)
168
                {
13085 jghali 169
                        qDebug("%s", "PoDoFo error while reading page size!");
13011 fschmid 170
                        e.PrintErrorMsg();
171
                }
172
        }
173
#endif
7527 fschmid 174
        baseX = 0;
175
        baseY = 0;
5539 mrdocs 176
        if (!interactive || (flags & LoadSavePlugin::lfInsertPage))
290 Franz 177
        {
5781 cbradney 178
                m_Doc->setPage(b-x, h-y, 0, 0, 0, 0, 0, 0, false, false);
179
                m_Doc->addPage(0);
180
                m_Doc->view()->addPage(0, true);
7527 fschmid 181
                baseX = 0;
182
                baseY = 0;
290 Franz 183
        }
506 fschmid 184
        else
185
        {
5781 cbradney 186
                if (!m_Doc || (flags & LoadSavePlugin::lfCreateDoc))
506 fschmid 187
                {
5798 jghali 188
                        m_Doc=ScCore->primaryMainWindow()->doFileNew(b-x, h-y, 0, 0, 0, 0, 0, 0, false, false, 0, false, 0, 1, "Custom", true);
5781 cbradney 189
                        ScCore->primaryMainWindow()->HaveNewDoc();
506 fschmid 190
                        ret = true;
7527 fschmid 191
                        baseX = 0;
192
                        baseY = 0;
506 fschmid 193
                }
194
        }
7527 fschmid 195
        if ((!ret) && (interactive))
196
        {
197
                baseX = m_Doc->currentPage()->xOffset();
198
                baseY = m_Doc->currentPage()->yOffset();
199
        }
3207 craig 200
        if ((ret) || (!interactive))
550 fschmid 201
        {
202
                if (b-x > h-y)
14991 cbradney 203
                        m_Doc->setPageOrientation(1);
550 fschmid 204
                else
14991 cbradney 205
                        m_Doc->setPageOrientation(0);
206
                m_Doc->setPageSize("Custom");
550 fschmid 207
        }
1065 cbradney 208
        ColorList::Iterator it;
290 Franz 209
        for (it = CustColors.begin(); it != CustColors.end(); ++it)
210
        {
5781 cbradney 211
                if (!m_Doc->PageColors.contains(it.key()))
10516 cbradney 212
                        m_Doc->PageColors.insert(it.key(), it.value());
290 Franz 213
        }
12015 fschmid 214
        boundingBoxRect.addRect(0, 0, b-x, h-y);
290 Franz 215
        Elements.clear();
5781 cbradney 216
        m_Doc->setLoading(true);
217
        m_Doc->DoDrawing = false;
16105 fschmid 218
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16016 fschmid 219
                m_Doc->view()->updatesOn(false);
14754 jghali 220
        m_Doc->scMW()->setScriptRunning(true);
9380 fschmid 221
        qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
10398 cbradney 222
        QString CurDirP = QDir::currentPath();
10516 cbradney 223
        QDir::setCurrent(fi.path());
290 Franz 224
        if (convert(fName, x, y, b, h))
225
        {
7580 cbradney 226
//              m_Doc->m_Selection->clear();
227
                tmpSel->clear();
290 Franz 228
                QDir::setCurrent(CurDirP);
7691 fschmid 229
//              if ((Elements.count() > 1) && (interactive))
230
                if (Elements.count() > 1)
16105 fschmid 231
                        m_Doc->groupObjectsList(Elements);
5781 cbradney 232
                m_Doc->DoDrawing = true;
14754 jghali 233
                m_Doc->scMW()->setScriptRunning(false);
5781 cbradney 234
                m_Doc->setLoading(false);
9380 fschmid 235
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
3207 craig 236
                if ((Elements.count() > 0) && (!ret) && (interactive))
290 Franz 237
                {
8262 fschmid 238
                        if (flags & LoadSavePlugin::lfScripted)
290 Franz 239
                        {
8262 fschmid 240
                                bool loadF = m_Doc->isLoading();
241
                                m_Doc->setLoading(false);
242
                                m_Doc->changed();
243
                                m_Doc->setLoading(loadF);
16105 fschmid 244
                                if (!(flags & LoadSavePlugin::lfLoadAsPattern))
8262 fschmid 245
                                {
16016 fschmid 246
                                        m_Doc->m_Selection->delaySignalsOn();
247
                                        for (int dre=0; dre<Elements.count(); ++dre)
248
                                        {
249
                                                m_Doc->m_Selection->addItem(Elements.at(dre), true);
250
                                        }
251
                                        m_Doc->m_Selection->delaySignalsOff();
252
                                        m_Doc->m_Selection->setGroupRect();
253
                                        m_Doc->view()->updatesOn(true);
8262 fschmid 254
                                }
290 Franz 255
                        }
8262 fschmid 256
                        else
257
                        {
258
                                m_Doc->DragP = true;
259
                                m_Doc->DraggedElem = 0;
260
                                m_Doc->DragElements.clear();
11835 fschmid 261
                                m_Doc->m_Selection->delaySignalsOn();
9856 fschmid 262
                                for (int dre=0; dre<Elements.count(); ++dre)
8262 fschmid 263
                                {
264
                                        m_Doc->DragElements.append(Elements.at(dre)->ItemNr);
265
                                        tmpSel->addItem(Elements.at(dre), true);
266
                                }
267
                                tmpSel->setGroupRect();
268
                                ScriXmlDoc *ss = new ScriXmlDoc();
12841 jghali 269
                                ScElemMimeData* md = new ScElemMimeData();
14744 fschmid 270
                                md->setScribusElem(ss->WriteElem(m_Doc, tmpSel));
12971 jghali 271
                                delete ss;
272
/*#ifndef Q_WS_MAC*/
4546 subik 273
// see #2196
8262 fschmid 274
                                m_Doc->itemSelection_DeleteItem(tmpSel);
12971 jghali 275
/*#else
13085 jghali 276
                                qDebug() << "psimport: leaving items on page";
12971 jghali 277
#endif*/
8262 fschmid 278
                                m_Doc->view()->updatesOn(true);
11835 fschmid 279
                                m_Doc->m_Selection->delaySignalsOff();
13371 jghali 280
                                // We must copy the TransationSettings object as it is owned
281
                                // by handleObjectImport method afterwards
282
                                TransactionSettings* transacSettings = new TransactionSettings(trSettings);
283
                                m_Doc->view()->handleObjectImport(md, transacSettings);
8262 fschmid 284
                                m_Doc->DragP = false;
285
                                m_Doc->DraggedElem = 0;
286
                                m_Doc->DragElements.clear();
7991 fschmid 287
                        }
290 Franz 288
                }
289
                else
357 Franz 290
                {
5781 cbradney 291
                        m_Doc->changed();
6556 fschmid 292
                        m_Doc->reformPages();
16105 fschmid 293
                        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16016 fschmid 294
                                m_Doc->view()->updatesOn(true);
357 Franz 295
                }
8052 jghali 296
                success = true;
290 Franz 297
        }
298
        else
299
        {
300
                QDir::setCurrent(CurDirP);
5781 cbradney 301
                m_Doc->DoDrawing = true;
14754 jghali 302
                m_Doc->scMW()->setScriptRunning(false);
7452 fschmid 303
                m_Doc->view()->updatesOn(true);
9380 fschmid 304
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
290 Franz 305
        }
3207 craig 306
        if (interactive)
5781 cbradney 307
                m_Doc->setLoading(false);
5004 cbradney 308
        //CB If we have a gui we must refresh it if we have used the progressbar
16105 fschmid 309
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
16016 fschmid 310
        {
311
                if ((showProgress) && (!interactive))
312
                        m_Doc->view()->DrawNew();
313
        }
8052 jghali 314
        return success;
290 Franz 315
}
316
 
7580 cbradney 317
EPSPlug::~EPSPlug()
318
{
11677 jghali 319
        if (progressDialog)
320
                delete progressDialog;
7580 cbradney 321
        delete tmpSel;
322
}
323
 
324
 
290 Franz 325
bool EPSPlug::convert(QString fn, double x, double y, double b, double h)
326
{
4194 fschmid 327
        QStringList args;
328
        QString cmd, cmd1, cmd2, cmd3, tmp, tmp2, tmp3, tmp4;
3120 fschmid 329
        // import.prolog do not cope with filenames containing blank spaces
330
        // so take care that output filename does not (win32 compatibility)
6592 jghali 331
        QString tmpFile = getShortPathName(ScPaths::getTempFileDir())+ "/ps.out";
332
        QString errFile = getShortPathName(ScPaths::getTempFileDir())+ "/ps.err";
1693 craig 333
        QString pfad = ScPaths::instance().libDir();
3120 fschmid 334
        QString pfad2 = QDir::convertSeparators(pfad + "import.prolog");
1735 fschmid 335
        QFileInfo fi = QFileInfo(fn);
10516 cbradney 336
        QString ext = fi.suffix().toLower();
4923 avox 337
 
338
        if (progressDialog) {
339
                progressDialog->setOverallProgress(1);
5243 cbradney 340
                qApp->processEvents();
4923 avox 341
        }
12015 fschmid 342
/*
343
// Destill the eps with ghostscript to get a clean eps file
344
        QString cleanFile = getShortPathName(ScPaths::getTempFileDir())+ "/clean.eps";
4194 fschmid 345
        args.append( "-q" );
346
        args.append( "-dNOPAUSE" );
12015 fschmid 347
        args.append( "-sDEVICE=epswrite" );
348
        args.append( "-dBATCH" );
349
        args.append( "-dSAFER" );
350
        args.append( "-dDEVICEWIDTH=250000" );
351
        args.append( "-dDEVICEHEIGHT=250000" );
352
        args.append( QString("-sOutputFile=%1").arg(QDir::convertSeparators(cleanFile)) );
353
        args.append( QDir::convertSeparators(fn) );
354
        System(getShortPathName(PrefsManager::instance()->ghostscriptExecutable()), args, errFile, errFile, &cancel);
355
        args.clear();
356
*/
357
        args.append( "-q" );
358
        args.append( "-dNOPAUSE" );
12919 fschmid 359
        args.append( "-dNODISPLAY" );
4194 fschmid 360
        args.append( "-dBATCH" );
4978 avox 361
        args.append( "-dDELAYBIND" );
2523 craig 362
        // Add any extra font paths being used by Scribus to gs's font search
363
        // path We have to use Scribus's prefs context, not a plugin context, to
364
        // get to the required information.
2856 cbradney 365
        PrefsContext *pc = PrefsManager::instance()->prefsFile->getContext("Fonts");
2523 craig 366
        PrefsTable *extraFonts = pc->getTable("ExtraFontDirs");
4194 fschmid 367
        const char sep = ScPaths::envPathSeparator;
2523 craig 368
        if (extraFonts->getRowCount() >= 1)
4194 fschmid 369
                cmd = QString("-sFONTPATH=%1").arg(extraFonts->get(0,0));
2523 craig 370
        for (int i = 1; i < extraFonts->getRowCount(); ++i)
4194 fschmid 371
                cmd += QString("%1%2").arg(sep).arg(extraFonts->get(i,0));
372
        if( !cmd.isEmpty() )
373
                args.append( cmd );
2523 craig 374
        // then finish building the command and call gs
12919 fschmid 375
        args.append( QString("-g%1x%2").arg(tmp2.setNum(qRound((b-x)*4))).arg(tmp3.setNum(qRound((h-y)*4))) );
376
        args.append( "-r288");
4788 avox 377
        args.append( "-dTextAlphaBits=4" );
378
        args.append( "-dGraphicsAlphaBits=4" );
4194 fschmid 379
        args.append( "-c" );
380
        args.append( tmp.setNum(-x) );
381
        args.append( tmp.setNum(-y) );
382
        args.append( "translate" );
4740 avox 383
        args.append( QString("-sTraceFile=%1").arg(QDir::convertSeparators(tmpFile)) );
5781 cbradney 384
        QString exportPath = m_Doc->DocName + "-" + fi.baseName();
4801 avox 385
        QFileInfo exportFi(exportPath);
386
        if ( !exportFi.isWritable() ) {
387
                PrefsContext* docContext = PrefsManager::instance()->prefsFile->getContext("docdirs", false);
388
                QString docDir = ".";
389
                QString prefsDocDir=PrefsManager::instance()->documentDir();
390
                if (!prefsDocDir.isEmpty())
391
                        docDir = docContext->get("docsopen", prefsDocDir);
392
                else
393
                        docDir = docContext->get("docsopen", ".");             
394
                exportFi.setFile(docDir + "/" + exportFi.baseName());
395
        }
13085 jghali 396
        //qDebug() << QString("using export path %1").arg(exportFi.absFilePath());
10516 cbradney 397
        args.append( QString("-sExportFiles=%1").arg(QDir::convertSeparators(exportFi.absoluteFilePath())) );
4194 fschmid 398
        args.append( pfad2 );
399
        args.append( QDir::convertSeparators(fn) );
400
        args.append( "-c" );
401
        args.append( "flush" );
402
        args.append( "cfile" );
403
        args.append( "closefile" );
404
        args.append( "quit" );
10493 fschmid 405
        QByteArray finalCmd = args.join(" ").toLocal8Bit();
11777 jghali 406
        int ret = System(getShortPathName(PrefsManager::instance()->ghostscriptExecutable()), args, errFile, errFile, &cancel);
407
        if (ret != 0 && !cancel)
290 Franz 408
        {
2791 craig 409
                qDebug("PostScript import failed when calling gs as: \n%s\n", finalCmd.data());
13085 jghali 410
                qDebug("%s", "Ghostscript diagnostics:\n");
4801 avox 411
                QFile diag(errFile);
8501 cbradney 412
                if (diag.open(QIODevice::ReadOnly) && !diag.atEnd() ) {
8665 cbradney 413
                        char buf[121];
414
                        while (diag.readLine(buf, 120) > 0) {
415
                                qDebug("\t%s", buf);
4725 avox 416
                        }
417
                        diag.close();
418
                }
419
                else {
13085 jghali 420
                        qDebug("%s", "-- no output --");
4725 avox 421
                }
6591 jghali 422
                if (progressDialog)
423
                        progressDialog->close();
290 Franz 424
                QString mess = tr("Importing File:\n%1\nfailed!").arg(fn);
425
                QMessageBox::critical(0, tr("Fatal Error"), mess, 1, 0, 0);
426
                return false;
427
        }
11777 jghali 428
        if(progressDialog && !cancel) {
4923 avox 429
                progressDialog->setOverallProgress(2);
430
                progressDialog->setLabel("GI", tr("Generating Items"));
5243 cbradney 431
                qApp->processEvents();
4923 avox 432
        }
433
        if (!cancel) {
10136 cbradney 434
                parseOutput(tmpFile, extensionIndicatesEPSorPS(ext));
4923 avox 435
        }
2921 fschmid 436
        QFile::remove(tmpFile);
12015 fschmid 437
//      QFile::remove(cleanFile);
4923 avox 438
        if (progressDialog)
439
                progressDialog->close();
290 Franz 440
        return true;
441
}
442
 
1735 fschmid 443
void EPSPlug::parseOutput(QString fn, bool eps)
290 Franz 444
{
445
        QString tmp, token, params, lasttoken, lastPath, currPath;
537 fschmid 446
        int z, lcap, ljoin, dc, pagecount;
4962 avox 447
        int failedImages = 0;
319 Franz 448
        double dcp;
4770 avox 449
        bool fillRuleEvenOdd = true;
290 Franz 450
        PageItem* ite;
9922 fschmid 451
        QStack<PageItem*> groupStack;
16105 fschmid 452
        QStack< QList<PageItem*> > groupStackP;
9919 jghali 453
        QStack<int>  gsStack;
454
        QStack<uint> gsStackMarks;
290 Franz 455
        QFile f(fn);
456
        lasttoken = "";
537 fschmid 457
        pagecount = 1;
8501 cbradney 458
        if (f.open(QIODevice::ReadOnly))
290 Franz 459
        {
9763 jghali 460
                int fProgress = 0;
461
                int fSize = (int) f.size();
4923 avox 462
                if (progressDialog) {
9763 jghali 463
                        progressDialog->setTotalSteps("GI", fSize);
5243 cbradney 464
                        qApp->processEvents();
4923 avox 465
                }
290 Franz 466
                lastPath = "";
467
                currPath = "";
468
                LineW = 0;
469
                Opacity = 1;
4546 subik 470
                CurrColor = CommonStrings::None;
8528 cbradney 471
                JoinStyle = Qt::MiterJoin;
472
                CapStyle = Qt::FlatCap;
292 Franz 473
                DashPattern.clear();
13497 jghali 474
                ScTextStream ts(&f);
4923 avox 475
                int line_cnt = 0;
476
                while (!ts.atEnd() && !cancel)
290 Franz 477
                {
478
                        tmp = "";
479
                        tmp = ts.readLine();
4923 avox 480
                        if (progressDialog && (++line_cnt % 100 == 0)) {
10516 cbradney 481
                                int fPos = f.pos();
9856 fschmid 482
                                int progress = static_cast<int>(ceil(fPos / (double) fSize * 100));
9763 jghali 483
                                if (progress > fProgress)
484
                                {
485
                                        progressDialog->setProgress("GI", fPos);
486
                                        qApp->processEvents();
487
                                        fProgress = progress;
488
                                }
4923 avox 489
                        }
4801 avox 490
                        token = tmp.section(' ', 0, 0);
491
                        params = tmp.section(' ', 1, -1, QString::SectionIncludeTrailingSep);
5006 avox 492
                        if (lasttoken == "sp"  && !eps && token != "sp" ) //av: messes up anyway: && (!interactive))
537 fschmid 493
                        {
5781 cbradney 494
                                m_Doc->addPage(pagecount);
495
                                m_Doc->view()->addPage(pagecount, true);
537 fschmid 496
                                pagecount++;
497
                        }
290 Franz 498
                        if (token == "n")
499
                        {
500
                                Coords.resize(0);
501
                                FirstM = true;
502
                                WasM = false;
503
                                ClosedPath = false;
504
                        }
505
                        else if (token == "m")
506
                                WasM = true;
507
                        else if (token == "c")
508
                        {
509
                                Curve(&Coords, params);
510
                                currPath += params;
511
                        }
512
                        else if (token == "l")
513
                        {
514
                                LineTo(&Coords, params);
515
                                currPath += params;
516
                        }
4770 avox 517
                        else if (token == "fill-winding")
518
                        {
519
                                fillRuleEvenOdd = false;
520
                        }
521
                        else if (token == "fill-evenodd")
522
                        {
523
                                fillRuleEvenOdd = true;
524
                        }
290 Franz 525
                        else if (token == "f")
526
                        {
4770 avox 527
                                //TODO: pattern -> Imageframe + Clip
290 Franz 528
                                if (Coords.size() != 0)
529
                                {
530
                                        if ((Elements.count() != 0) && (lastPath == currPath))
531
                                        {
532
                                                ite = Elements.at(Elements.count()-1);
1394 cbradney 533
                                                ite->setFillColor(CurrColor);
534
                                                ite->setFillTransparency(1.0 - Opacity);
8017 fschmid 535
                                                lastPath = "";
290 Franz 536
                                        }
537
                                        else
538
                                        {
539
                                                if (ClosedPath)
7488 fschmid 540
                                                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColor, CommonStrings::None, true);
290 Franz 541
                                                else
7488 fschmid 542
                                                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColor, CommonStrings::None, true);
5781 cbradney 543
                                                ite = m_Doc->Items->at(z);
4801 avox 544
                                                ite->PoLine = Coords.copy();  //FIXME: try to avoid copy if FPointArray when properly shared
5781 cbradney 545
                                                ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
290 Franz 546
                                                ite->ClipEdited = true;
547
                                                ite->FrameType = 3;
4770 avox 548
                                                ite->fillRule = (fillRuleEvenOdd);
1065 cbradney 549
                                                FPoint wh = getMaxClipF(&ite->PoLine);
3934 cbradney 550
                                                ite->setWidthHeight(wh.x(),wh.y());
290 Franz 551
                                                ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
1394 cbradney 552
                                                ite->setFillTransparency(1.0 - Opacity);
11705 fschmid 553
                                                ite->setTextFlowMode(PageItem::TextFlowDisabled);
7736 cbradney 554
                                                m_Doc->AdjustItemSize(ite);
16252 fschmid 555
                                                if (ite->itemType() == PageItem::Polygon)
556
                                                        ite->ContourLine = ite->PoLine.copy();
16105 fschmid 557
                                                if ((groupStack.count() != 0) && (groupStackP.count() != 0))
558
                                                        groupStackP.top().append(ite);
290 Franz 559
                                                Elements.append(ite);
8017 fschmid 560
                                                lastPath = currPath;
290 Franz 561
                                        }
562
                                        currPath = "";
563
                                }
564
                        }
565
                        else if (token == "s")
566
                        {
567
                                if (Coords.size() != 0)
568
                                {
13013 fschmid 569
                                //      LineW = qMax(LineW, 0.01); // Set Linewidth to be a least 0.01 pts, a Stroke without a Linewidth makes no sense
290 Franz 570
                                        if ((Elements.count() != 0) && (lastPath == currPath))
571
                                        {
572
                                                ite = Elements.at(Elements.count()-1);
1394 cbradney 573
                                                ite->setLineColor(CurrColor);
4580 cbradney 574
                                                ite->setLineWidth(LineW);
292 Franz 575
                                                ite->PLineEnd = CapStyle;
576
                                                ite->PLineJoin = JoinStyle;
1394 cbradney 577
                                                ite->setLineTransparency(1.0 - Opacity);
292 Franz 578
                                                ite->DashOffset = DashOffset;
579
                                                ite->DashValues = DashPattern;
290 Franz 580
                                        }
581
                                        else
582
                                        {
583
                                                if (ClosedPath)
7488 fschmid 584
                                                        z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColor, true);
290 Franz 585
                                                else
7488 fschmid 586
                                                        z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColor, true);
5781 cbradney 587
                                                ite = m_Doc->Items->at(z);
4801 avox 588
                                                ite->PoLine = Coords.copy(); //FIXME: try to avoid copy when FPointArray is properly shared
5781 cbradney 589
                                                ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
290 Franz 590
                                                ite->ClipEdited = true;
591
                                                ite->FrameType = 3;
292 Franz 592
                                                ite->PLineEnd = CapStyle;
593
                                                ite->PLineJoin = JoinStyle;
594
                                                ite->DashOffset = DashOffset;
595
                                                ite->DashValues = DashPattern;
1065 cbradney 596
                                                FPoint wh = getMaxClipF(&ite->PoLine);
3934 cbradney 597
                                                ite->setWidthHeight(wh.x(), wh.y());
290 Franz 598
                                                ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
1394 cbradney 599
                                                ite->setLineTransparency(1.0 - Opacity);
7736 cbradney 600
                                                m_Doc->AdjustItemSize(ite);
16252 fschmid 601
                                                if (ite->itemType() == PageItem::Polygon)
602
                                                        ite->ContourLine = ite->PoLine.copy();
13011 fschmid 603
                                                ite->setLineWidth(LineW);
11705 fschmid 604
                                                ite->setTextFlowMode(PageItem::TextFlowDisabled);
16105 fschmid 605
                                                if ((groupStack.count() != 0) && (groupStackP.count() != 0))
606
                                                        groupStackP.top().append(ite);
290 Franz 607
                                                Elements.append(ite);
608
                                        }
8017 fschmid 609
                                        lastPath = "";
290 Franz 610
                                        currPath = "";
611
                                }
612
                        }
613
                        else if (token == "co")
7991 fschmid 614
                                CurrColor = parseColor(params, eps);
1488 fschmid 615
                        else if (token == "corgb")
7991 fschmid 616
                                CurrColor = parseColor(params, eps, colorModelRGB);
290 Franz 617
                        else if (token == "ci")
618
                        {
6451 fschmid 619
                                if (Coords.size() != 0)
620
                                {
12015 fschmid 621
                                        QString vers = QString(qVersion()).left(5);
622
                                        if (vers < "4.3.3")
6451 fschmid 623
                                        {
12015 fschmid 624
                                                clipCoords = Coords;
16105 fschmid 625
                                                z = m_Doc->itemAdd(PageItem::Group, PageItem::Rectangle, baseX, baseY, 10, 10, 0, CommonStrings::None, CommonStrings::None, true);
12015 fschmid 626
                                                ite = m_Doc->Items->at(z);
627
                                                ite->PoLine = Coords.copy();  //FIXME: try to avoid copy if FPointArray when properly shared
628
                                                ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
629
                                                ite->ClipEdited = true;
630
                                                ite->FrameType = 3;
631
                                                FPoint wh = getMaxClipF(&ite->PoLine);
632
                                                ite->setWidthHeight(wh.x(),wh.y());
633
                                                ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
16243 fschmid 634
                                                m_Doc->AdjustItemSize(ite, true);
16252 fschmid 635
                                                ite->ContourLine = ite->PoLine.copy();
12015 fschmid 636
                                                ite->setItemName( tr("Group%1").arg(m_Doc->GroupCounter));
637
                                                ite->setTextFlowMode(PageItem::TextFlowDisabled);
638
                                                Elements.append(ite);
16105 fschmid 639
                                                if ((groupStack.count() != 0) && (groupStackP.count() != 0))
640
                                                        groupStackP.top().append(ite);
12015 fschmid 641
                                                groupStack.push(ite);
16105 fschmid 642
                                                QList<PageItem*> gElements;
643
                                                groupStackP.push(gElements);
12015 fschmid 644
                                                gsStackMarks.push(gsStack.count());
645
                                                m_Doc->GroupCounter++;
6451 fschmid 646
                                        }
12015 fschmid 647
                                        else
648
                                        {
649
                                                QPainterPath tmpPath = Coords.toQPainterPath(true);
650
                                                tmpPath = boundingBoxRect.intersected(tmpPath);
651
                                                if ((tmpPath.boundingRect().width() != 0) && (tmpPath.boundingRect().height() != 0))
652
                                                {
653
                                                        clipCoords.fromQPainterPath(tmpPath);
16105 fschmid 654
                                                        z = m_Doc->itemAdd(PageItem::Group, PageItem::Rectangle, baseX, baseY, 10, 10, 0, CommonStrings::None, CommonStrings::None, true);
12015 fschmid 655
                                                        ite = m_Doc->Items->at(z);
656
                                                        ite->PoLine = clipCoords.copy();  //FIXME: try to avoid copy if FPointArray when properly shared
657
                                                        ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
658
                                                        ite->ClipEdited = true;
659
                                                        ite->FrameType = 3;
660
                                                        FPoint wh = getMaxClipF(&ite->PoLine);
661
                                                        ite->setWidthHeight(wh.x(),wh.y());
662
                                                        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
16243 fschmid 663
                                                        m_Doc->AdjustItemSize(ite, true);
16252 fschmid 664
                                                        ite->ContourLine = ite->PoLine.copy();
12015 fschmid 665
                                                        ite->setItemName( tr("Group%1").arg(m_Doc->GroupCounter));
666
                                                        ite->setTextFlowMode(PageItem::TextFlowDisabled);
667
                                                        Elements.append(ite);
16105 fschmid 668
                                                        if ((groupStack.count() != 0) && (groupStackP.count() != 0))
669
                                                                groupStackP.top().append(ite);
12015 fschmid 670
                                                        groupStack.push(ite);
16105 fschmid 671
                                                        QList<PageItem*> gElements;
672
                                                        groupStackP.push(gElements);
12015 fschmid 673
                                                        gsStackMarks.push(gsStack.count());
674
                                                        m_Doc->GroupCounter++;
675
                                                }
676
                                        }
6451 fschmid 677
                                }
4923 avox 678
                                Coords   = FPointArray(0);
290 Franz 679
                                lastPath = "";
680
                                currPath = "";
681
                        }
6451 fschmid 682
                        else if (token == "gs")
683
                        {
684
                                gsStack.push(1);
685
                        }
686
                        else if (token == "gr")
687
                        {
11762 jghali 688
                                // #6834 : self defense against incorrectly balanced save/restore
689
                                if (gsStack.count() > 0)
690
                                        gsStack.pop();
16105 fschmid 691
                                if ((groupStack.count() != 0) && (groupStackP.count() != 0))
6451 fschmid 692
                                {
8546 cbradney 693
                                        if (gsStack.count() < static_cast<int>(gsStackMarks.top()))
6451 fschmid 694
                                        {
695
                                                PageItem *ite = groupStack.pop();
16105 fschmid 696
                                                QList<PageItem*> gList = groupStackP.pop();
697
                                                for (int d = 0; d < gList.count(); d++)
8769 fschmid 698
                                                {
16105 fschmid 699
                                                        Elements.removeAll(gList.at(d));
8769 fschmid 700
                                                }
16105 fschmid 701
                                                m_Doc->groupObjectsToItem(ite, gList);
6451 fschmid 702
                                                gsStackMarks.pop();
703
                                        }
704
                                }
705
                        }
290 Franz 706
                        else if (token == "w")
707
                        {
13497 jghali 708
                                ScTextStream Lw(&params, QIODevice::ReadOnly);
290 Franz 709
                                Lw >> LineW;
710
                        }
292 Franz 711
                        else if (token == "ld")
712
                        {
13497 jghali 713
                                ScTextStream Lw(&params, QIODevice::ReadOnly);
292 Franz 714
                                Lw >> dc;
715
                                Lw >> DashOffset;
716
                                DashPattern.clear();
717
                                if (dc != 0)
718
                                {
719
                                        for (int dcc = 0; dcc < dc; ++dcc)
720
                                        {
721
                                                Lw >> dcp;
722
                                                DashPattern.append(dcp);
723
                                        }
724
                                }
725
                        }
726
                        else if (token == "lc")
727
                        {
13497 jghali 728
                                ScTextStream Lw(&params, QIODevice::ReadOnly);
292 Franz 729
                                Lw >> lcap;
730
                                switch (lcap)
731
                                {
732
                                        case 0:
733
                                                CapStyle = Qt::FlatCap;
734
                                                break;
735
                                        case 1:
736
                                                CapStyle = Qt::RoundCap;
737
                                                break;
738
                                        case 2:
739
                                                CapStyle = Qt::SquareCap;
740
                                                break;
741
                                        default:
742
                                                CapStyle = Qt::FlatCap;
743
                                                break;
744
                                }
745
                        }
746
                        else if (token == "lj")
747
                        {
13497 jghali 748
                                ScTextStream Lw(&params, QIODevice::ReadOnly);
292 Franz 749
                                Lw >> ljoin;
750
                                switch (ljoin)
751
                                {
752
                                        case 0:
753
                                                JoinStyle = Qt::MiterJoin;
754
                                                break;
755
                                        case 1:
756
                                                JoinStyle = Qt::RoundJoin;
757
                                                break;
758
                                        case 2:
759
                                                JoinStyle = Qt::BevelJoin;
760
                                                break;
761
                                        default:
762
                                                JoinStyle = Qt::MiterJoin;
763
                                                break;
764
                                }
765
                        }
4717 avox 766
                        else if (token == "cp") {
290 Franz 767
                                ClosedPath = true;
4717 avox 768
                        }
769
                        else if (token == "im") {
4962 avox 770
                                if ( !Image(params) )
771
                                        ++failedImages;
4717 avox 772
                        }
290 Franz 773
                        lasttoken = token;
774
                }
775
                f.close();
6451 fschmid 776
                if (groupStack.count() != 0)
777
                {
778
                        while (!groupStack.isEmpty())
779
                        {
780
                                PageItem *ite = groupStack.pop();
16105 fschmid 781
                                QList<PageItem*> gList = groupStackP.pop();
782
                                for (int d = 0; d < gList.count(); d++)
8769 fschmid 783
                                {
16105 fschmid 784
                                        Elements.removeAll(gList.at(d));
8769 fschmid 785
                                }
16105 fschmid 786
                                m_Doc->groupObjectsToItem(ite, gList);
6451 fschmid 787
                        }
788
                }
290 Franz 789
        }
4962 avox 790
        if (failedImages > 0)
791
        {
792
                QString mess = tr("Converting of %1 images failed!").arg(failedImages);
793
                QMessageBox::critical(0, tr("Error"), mess, 1, 0, 0);
794
        }
290 Franz 795
}
796
 
4962 avox 797
bool EPSPlug::Image(QString vals)
4717 avox 798
{
799
        double x, y, w, h, angle;
800
        int horpix, verpix;
801
        QString filename, device;
13497 jghali 802
        ScTextStream Code(&vals, QIODevice::ReadOnly);
4717 avox 803
        Code >> x;
804
        Code >> y;
805
        Code >> w;
806
        Code >> h;
807
        Code >> angle;
808
        Code >> horpix;
809
        Code >> verpix;
810
        Code >> device;
10394 cbradney 811
        filename = Code.readAll().trimmed();
4999 avox 812
        if (device.startsWith("psd")) {
813
                filename = filename.mid(0, filename.length()-3) + "psd";
814
        }
815
 
10516 cbradney 816
        qDebug("%s", QString("import %7 image %1: %2x%3 @ (%4,%5) °%6").arg(filename).arg(w).arg(h).arg(x).arg(y).arg(angle).arg(device).toLocal8Bit().data());
4717 avox 817
        QString rawfile = filename.mid(0, filename.length()-3) + "dat";
818
        QStringList args;
819
        args.append( "-q" );
820
        args.append( "-dNOPAUSE" );
821
        args.append( QString("-sDEVICE=%1").arg(device) );    
822
        args.append( "-dBATCH" );
823
        args.append( QString("-g%1x%2").arg(horpix).arg(verpix) );
824
        args.append( QString("-sOutputFile=%1").arg(QDir::convertSeparators(filename)) );
825
        args.append( QDir::convertSeparators(rawfile) );
826
        args.append( "-c" );
827
        args.append( "showpage" );
828
        args.append( "quit" );
10493 fschmid 829
        QByteArray finalCmd = args.join(" ").toLocal8Bit();
10006 cbradney 830
        int ret = System(getShortPathName(PrefsManager::instance()->ghostscriptExecutable()), args);
4717 avox 831
        if (ret != 0)
832
        {
833
                qDebug("PostScript image conversion failed when calling gs as: \n%s\n", finalCmd.data());
4986 avox 834
                qDebug("Ghostscript diagnostics: %d\n", ret);
4725 avox 835
                QFile diag(filename);
8501 cbradney 836
                if (diag.open(QIODevice::ReadOnly)) {
8665 cbradney 837
                        char buf[121];
4740 avox 838
                        long int len;
839
                        bool gs_error = false;
840
                        do {
8665 cbradney 841
                                len = diag.readLine(buf, 120);
842
                                gs_error |= (strstr(buf,"Error")==NULL);
4740 avox 843
                                if (gs_error)
8665 cbradney 844
                                        qDebug("\t%s", buf);
4725 avox 845
                        }
4740 avox 846
                        while (len > 0);
4725 avox 847
                        diag.close();
4983 avox 848
                        }
4725 avox 849
                else {
13085 jghali 850
                        qDebug("%s", "-- no output --");
4725 avox 851
                }
13085 jghali 852
                qDebug("%s", "Failed file was:\n");
4983 avox 853
                QFile dat(rawfile);
8501 cbradney 854
                if (dat.open(QIODevice::ReadOnly)) {
8665 cbradney 855
                        char buf[121];
4983 avox 856
                        long int len;
857
                        do {
8665 cbradney 858
                                len = dat.readLine(buf, 120);
859
                                qDebug("\t%s", buf);
4983 avox 860
                        }
8665 cbradney 861
                        while ( len > 0 && !(strstr(buf, "image")==NULL) );
4983 avox 862
                        dat.close();
863
                }
864
                else {
13085 jghali 865
                        qDebug("%s", "-- empty --");
4983 avox 866
                }
4717 avox 867
        }
4923 avox 868
        QFile::remove(rawfile);
7488 fschmid 869
        int z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset(), w, h, LineW, CommonStrings::None, CurrColor, true);
5781 cbradney 870
        PageItem * ite = m_Doc->Items->at(z);
871
        ite->setXYPos(m_Doc->currentPage()->xOffset() + x, m_Doc->currentPage()->yOffset() + y);
4717 avox 872
        ite->setWidthHeight(w, h);
873
        ite->clearContents();
874
/*      FPoint a(x, y);
875
        FPoint b(x+w, y);
876
        FPoint c(x+w, y-h);
877
        FPoint d(x, y-h);
878
        ite->PoLine.resize(0);
879
        ite->PoLine.addQuadPoint(a, a, b, b);
880
        ite->PoLine.addQuadPoint(b, b, c, c);
881
        ite->PoLine.addQuadPoint(c, c, d, d);
882
        ite->PoLine.addQuadPoint(d, d, a, a);
5781 cbradney 883
        ite->PoLine.translate(m_Doc->currentPage->xOffset() - x, m_Doc->currentPage->yOffset() - y);
4717 avox 884
        ite->ClipEdited = true;
885
        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
4976 avox 886
*/
5781 cbradney 887
        m_Doc->loadPict(filename, ite, -1);
4717 avox 888
        ite->setRotation(angle);
889
        ite->setImageScalingMode(false, true); // fit to frame, keep ratio
5781 cbradney 890
//      m_Doc->view()->AdjustItemSize(ite);
4962 avox 891
        Elements.append(ite);
892
        return ret == 0;
4717 avox 893
}
894
 
895
 
290 Franz 896
void EPSPlug::LineTo(FPointArray *i, QString vals)
897
{
2877 cbradney 898
        if (vals.isEmpty())
290 Franz 899
                return;
900
        double x1, x2, y1, y2;
13457 cbradney 901
        x1 = ScCLocale::toDoubleC(vals.section(' ', 0, 0, QString::SectionSkipEmpty));
902
        y1 = ScCLocale::toDoubleC(vals.section(' ', 1, 1, QString::SectionSkipEmpty));
903
        x2 = ScCLocale::toDoubleC(vals.section(' ', 2, 2, QString::SectionSkipEmpty));
904
        y2 = ScCLocale::toDoubleC(vals.section(' ', 3, 3, QString::SectionSkipEmpty));
290 Franz 905
        if ((!FirstM) && (WasM))
906
                i->setMarker();
907
        FirstM = false;
908
        WasM = false;
909
        i->addPoint(FPoint(x1, y1));
910
        i->addPoint(FPoint(x1, y1));
911
        i->addPoint(FPoint(x2, y2));
912
        i->addPoint(FPoint(x2, y2));
913
}
914
 
915
void EPSPlug::Curve(FPointArray *i, QString vals)
916
{
2877 cbradney 917
        if (vals.isEmpty())
290 Franz 918
                return;
919
        double x1, x2, y1, y2, x3, y3, x4, y4;
13457 cbradney 920
        x1 = ScCLocale::toDoubleC(vals.section(' ', 0, 0, QString::SectionSkipEmpty));
921
        y1 = ScCLocale::toDoubleC(vals.section(' ', 1, 1, QString::SectionSkipEmpty));
922
        x2 = ScCLocale::toDoubleC(vals.section(' ', 2, 2, QString::SectionSkipEmpty));
923
        y2 = ScCLocale::toDoubleC(vals.section(' ', 3, 3, QString::SectionSkipEmpty));
924
        x3 = ScCLocale::toDoubleC(vals.section(' ', 4, 4, QString::SectionSkipEmpty));
925
        y3 = ScCLocale::toDoubleC(vals.section(' ', 5, 5, QString::SectionSkipEmpty));
926
        x4 = ScCLocale::toDoubleC(vals.section(' ', 6, 6, QString::SectionSkipEmpty));
927
        y4 = ScCLocale::toDoubleC(vals.section(' ', 7, 7, QString::SectionSkipEmpty));
290 Franz 928
        if ((!FirstM) && (WasM))
929
                i->setMarker();
930
        FirstM = false;
931
        WasM = false;
932
        i->addPoint(FPoint(x1, y1));
933
        i->addPoint(FPoint(x2, y2));
934
        i->addPoint(FPoint(x4, y4));
935
        i->addPoint(FPoint(x3, y3));
936
}
937
 
7991 fschmid 938
QString EPSPlug::parseColor(QString vals, bool eps, colorModel model)
290 Franz 939
{
4546 subik 940
        QString ret = CommonStrings::None;
2877 cbradney 941
        if (vals.isEmpty())
290 Franz 942
                return ret;
1488 fschmid 943
        double c, m, y, k, r, g, b;
2886 fschmid 944
        ScColor tmp;
13497 jghali 945
        ScTextStream Code(&vals, QIODevice::ReadOnly);
1488 fschmid 946
        if (model == colorModelRGB)
290 Franz 947
        {
1488 fschmid 948
                Code >> r;
949
                Code >> g;
950
                Code >> b;
951
                Code >> Opacity;
7928 fschmid 952
// Why adding 0.5 here color values range from 0 to 255 not 1 to 256 ??
953
/*              int Rc = static_cast<int>(r * 255 + 0.5);
1488 fschmid 954
                int Gc = static_cast<int>(g * 255 + 0.5);
7928 fschmid 955
                int Bc = static_cast<int>(b * 255 + 0.5); */
956
                int Rc = qRound(r * 255);
957
                int Gc = qRound(g * 255);
958
                int Bc = qRound(b * 255);
1488 fschmid 959
                tmp.setColorRGB(Rc, Gc, Bc);
290 Franz 960
        }
1488 fschmid 961
        else
962
        {
963
                Code >> c;
964
                Code >> m;
965
                Code >> y;
966
                Code >> k;
967
                Code >> Opacity;
7928 fschmid 968
                int Cc = qRound(c * 255);
969
                int Mc = qRound(m * 255);
970
                int Yc = qRound(y * 255);
971
                int Kc = qRound(k * 255);
1488 fschmid 972
                tmp.setColor(Cc, Mc, Yc, Kc);
973
        }
15771 fschmid 974
        tmp.setSpotColor(false);
975
        tmp.setRegistrationColor(false);
976
        QString namPrefix = "FromEPS";
977
        if (!eps)
978
                namPrefix = "FromPS";
979
        QString fNam = m_Doc->PageColors.tryAddColor(namPrefix+tmp.name(), tmp);
980
        ret = fNam;
290 Franz 981
        return ret;
982
}