Subversion Repositories Scribus

Rev

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