Subversion Repositories Scribus

Rev

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