Subversion Repositories Scribus

Rev

Rev 4923 | Rev 4949 | 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
*/
290 Franz 7
#include "importps.h"
8
#include "importps.moc"
2688 craig 9
 
10
#include "scconfig.h"
3207 craig 11
#include "scribus.h"
4923 avox 12
#include "scribusapp.h"
4546 subik 13
#include "commonstrings.h"
290 Franz 14
#include "customfdialog.h"
15
#include "mpalette.h"
415 Franz 16
#include "prefsfile.h"
2523 craig 17
#include "prefscontext.h"
18
#include "prefstable.h"
290 Franz 19
#include "scribusXml.h"
20
#include <qfile.h>
21
#include <qtextstream.h>
22
#include <qcursor.h>
1525 cbradney 23
#include <qdragobject.h>
4167 fschmid 24
#include <qregexp.h>
290 Franz 25
#include <cmath>
26
#include <cstdlib>
4930 cbradney 27
 
28
#include "multiprogressdialog.h"
1693 craig 29
#include "scpaths.h"
2529 craig 30
#include "scfontmetrics.h"
3934 cbradney 31
#include "selection.h"
4930 cbradney 32
#include "prefsmanager.h"
33
#include "undomanager.h"
2529 craig 34
#include "util.h"
290 Franz 35
 
4923 avox 36
extern ScribusQApp * ScQApp;
4645 subik 37
 
3207 craig 38
EPSPlug::EPSPlug(QString fName, bool isInteractive)
290 Franz 39
{
3207 craig 40
        interactive = isInteractive;
4923 avox 41
        cancel = false;
290 Franz 42
        double x, y, b, h, c, m, k;
43
        bool ret = false;
44
        bool found = false;
45
        CustColors.clear();
46
        QFileInfo fi = QFileInfo(fName);
47
        QString ext = fi.extension(false).lower();
4923 avox 48
        progressDialog = new MultiProgressDialog(tr("Importing Postscript"), CommonStrings::tr_Cancel, ScMW, "psexportprogress");
49
        if (progressDialog != NULL)
50
        {
51
                QStringList barNames, barTexts;
52
                barNames << "GI";
53
                barTexts << tr("Analyzing Postscript:");
54
                progressDialog->addExtraProgressBars(barNames, barTexts);
55
                progressDialog->setOverallTotalSteps(3);
56
                progressDialog->setOverallProgress(0);
57
                progressDialog->setProgress("GI", 0);
58
                progressDialog->show();
59
                connect(progressDialog->buttonCancel, SIGNAL(clicked()), this, SLOT(cancelRequested()));
60
                ScQApp->processEvents();
61
        }
62
 
319 Franz 63
/* Set default Page to size defined in Preferences */
290 Franz 64
        x = 0.0;
65
        y = 0.0;
2834 cbradney 66
        b = PrefsManager::instance()->appPrefs.PageWidth;
67
        h = PrefsManager::instance()->appPrefs.PageHeight;
290 Franz 68
        if ((ext == "eps") || (ext == "ps"))
69
        {
4000 fschmid 70
                QString tmp, BBox, tmp2, FarNam;
2886 fschmid 71
                ScColor cc;
290 Franz 72
                QFile f(fName);
73
                if (f.open(IO_ReadOnly))
74
                {
75
/* Try to find Bounding Box */
76
                        QTextStream ts(&f);
77
                        while (!ts.atEnd())
78
                        {
4000 fschmid 79
                                tmp = ts.readLine();
290 Franz 80
                                if (tmp.startsWith("%%BoundingBox:"))
81
                                {
82
                                        found = true;
83
                                        BBox = tmp.remove("%%BoundingBox:");
84
                                }
85
                                if (!found)
86
                                {
87
                                        if (tmp.startsWith("%%BoundingBox"))
88
                                        {
89
                                                found = true;
90
                                                BBox = tmp.remove("%%BoundingBox");
91
                                        }
92
                                }
93
/* Read CustomColors if available */
94
                                if (tmp.startsWith("%%CMYKCustomColor"))
95
                                {
4170 fschmid 96
                                        tmp = tmp.remove(0,18);
290 Franz 97
                                        QTextStream ts2(&tmp, IO_ReadOnly);
4000 fschmid 98
                                        ts2 >> c >> m >> y >> k;
290 Franz 99
                                        FarNam = ts2.read();
100
                                        FarNam = FarNam.stripWhiteSpace();
101
                                        FarNam = FarNam.remove(0,1);
102
                                        FarNam = FarNam.remove(FarNam.length()-1,1);
4167 fschmid 103
                                        QRegExp badchars("[\\s\\/\\{\\[\\]\\}\\<\\>\\(\\)\\%]");
104
                                        FarNam = FarNam.simplifyWhiteSpace().replace( badchars, "_" );
2886 fschmid 105
                                        cc = ScColor(static_cast<int>(255 * c), static_cast<int>(255 * m), static_cast<int>(255 * y), static_cast<int>(255 * k));
4000 fschmid 106
                                        cc.setSpotColor(true);
290 Franz 107
                                        CustColors.insert(FarNam, cc);
108
                                        while (!ts.atEnd())
109
                                        {
4000 fschmid 110
                                                tmp = ts.readLine();
290 Franz 111
                                                if (!tmp.startsWith("%%+"))
112
                                                        break;
4000 fschmid 113
                                                tmp = tmp.remove(0,3);
290 Franz 114
                                                QTextStream ts2(&tmp, IO_ReadOnly);
4000 fschmid 115
                                                ts2 >> c >> m >> y >> k;
290 Franz 116
                                                FarNam = ts2.read();
117
                                                FarNam = FarNam.stripWhiteSpace();
118
                                                FarNam = FarNam.remove(0,1);
119
                                                FarNam = FarNam.remove(FarNam.length()-1,1);
4170 fschmid 120
                                                QRegExp badchars("[\\s\\/\\{\\[\\]\\}\\<\\>\\(\\)\\%]");
121
                                                FarNam = FarNam.simplifyWhiteSpace().replace( badchars, "_" );
2886 fschmid 122
                                                cc = ScColor(static_cast<int>(255 * c), static_cast<int>(255 * m), static_cast<int>(255 * y), static_cast<int>(255 * k));
4000 fschmid 123
                                                cc.setSpotColor(true);
290 Franz 124
                                                CustColors.insert(FarNam, cc);
125
                                        }
126
                                }
127
                                if (tmp.startsWith("%%EndComments"))
128
                                        break;
129
                        }
130
                        f.close();
131
                        if (found)
132
                        {
319 Franz 133
                                QStringList bb = QStringList::split(" ", BBox);
134
                                if (bb.count() == 4)
135
                                {
136
                                        QTextStream ts2(&BBox, IO_ReadOnly);
137
                                        ts2 >> x >> y >> b >> h;
138
                                }
290 Franz 139
                        }
140
                }
141
        }
3207 craig 142
        if (!interactive)
290 Franz 143
        {
4026 craig 144
                ScMW->doc->setPage(b-x, h-y, 0, 0, 0, 0, 0, 0, false, false);
145
                ScMW->doc->addPage(0);
146
                ScMW->view->addPage(0, true);
290 Franz 147
        }
506 fschmid 148
        else
149
        {
4026 craig 150
                if (!ScMW->HaveDoc)
506 fschmid 151
                {
4026 craig 152
                        ScMW->doFileNew(b-x, h-y, 0, 0, 0, 0, 0, 0, false, false, 0, false, 0, 1, "Custom");
4268 fschmid 153
                        ScMW->HaveNewDoc();
506 fschmid 154
                        ret = true;
155
                }
156
        }
3207 craig 157
        if ((ret) || (!interactive))
550 fschmid 158
        {
159
                if (b-x > h-y)
4026 craig 160
                        ScMW->doc->PageOri = 1;
550 fschmid 161
                else
4026 craig 162
                        ScMW->doc->PageOri = 0;
163
                ScMW->doc->PageSize = "Custom";
550 fschmid 164
        }
1065 cbradney 165
        ColorList::Iterator it;
4026 craig 166
        ScribusDoc* Doku = ScMW->doc;
290 Franz 167
        for (it = CustColors.begin(); it != CustColors.end(); ++it)
168
        {
169
                if (!Doku->PageColors.contains(it.key()))
170
                        Doku->PageColors.insert(it.key(), it.data());
171
        }
172
        Elements.clear();
2880 fschmid 173
        FPoint minSize = Doku->minCanvasCoordinate;
174
        FPoint maxSize = Doku->maxCanvasCoordinate;
2891 cbradney 175
        Doku->setLoading(true);
290 Franz 176
        Doku->DoDrawing = false;
4026 craig 177
        ScMW->view->setUpdatesEnabled(false);
178
        ScMW->ScriptRunning = true;
290 Franz 179
        qApp->setOverrideCursor(QCursor(waitCursor), true);
180
        QString CurDirP = QDir::currentDirPath();
181
        QDir::setCurrent(fi.dirPath());
182
        if (convert(fName, x, y, b, h))
183
        {
4847 cbradney 184
                Doku->m_Selection->clear();
290 Franz 185
                QDir::setCurrent(CurDirP);
3207 craig 186
                if ((Elements.count() > 1) && (interactive))
290 Franz 187
                {
188
                        for (uint a = 0; a < Elements.count(); ++a)
189
                        {
190
                                Elements.at(a)->Groups.push(Doku->GroupCounter);
191
                        }
192
                        Doku->GroupCounter++;
193
                }
194
                Doku->DoDrawing = true;
4026 craig 195
                ScMW->view->setUpdatesEnabled(true);
196
                ScMW->ScriptRunning = false;
2891 cbradney 197
                Doku->setLoading(false);
290 Franz 198
                qApp->setOverrideCursor(QCursor(arrowCursor), true);
3207 craig 199
                if ((Elements.count() > 0) && (!ret) && (interactive))
290 Franz 200
                {
201
                        Doku->DragP = true;
202
                        Doku->DraggedElem = 0;
203
                        Doku->DragElements.clear();
204
                        for (uint dre=0; dre<Elements.count(); ++dre)
205
                        {
206
                                Doku->DragElements.append(Elements.at(dre)->ItemNr);
4847 cbradney 207
                                Doku->m_Selection->addItem(Elements.at(dre));
290 Franz 208
                        }
4302 avox 209
                        ScMW->view->setGroupRect();
290 Franz 210
                        ScriXmlDoc *ss = new ScriXmlDoc();
4026 craig 211
                        //QDragObject *dr = new QTextDrag(ss->WriteElem(&ScMW->view->SelItem, Doku, ScMW->view), ScMW->view->viewport());
4847 cbradney 212
                        QDragObject *dr = new QTextDrag(ss->WriteElem(Doku, ScMW->view, Doku->m_Selection),ScMW->view->viewport());
4302 avox 213
#ifndef QT_MAC
4546 subik 214
// see #2196
4707 cbradney 215
                        Doku->itemSelection_DeleteItem();
4302 avox 216
#endif
4593 cbradney 217
                        ScMW->view->resizeContents(qRound((maxSize.x() - minSize.x()) * ScMW->view->scale()), qRound((maxSize.y() - minSize.y()) * ScMW->view->scale()));
218
                        ScMW->view->scrollBy(qRound((Doku->minCanvasCoordinate.x() - minSize.x()) * ScMW->view->scale()), qRound((Doku->minCanvasCoordinate.y() - minSize.y()) * ScMW->view->scale()));
2880 fschmid 219
                        Doku->minCanvasCoordinate = minSize;
220
                        Doku->maxCanvasCoordinate = maxSize;
4026 craig 221
                        ScMW->view->updateContents();
290 Franz 222
                        dr->setPixmap(loadIcon("DragPix.xpm"));
4302 avox 223
#if 0
224
                        qDebug("psimport: data");
225
                        QString data(dr->encodedData("text/plain"));
226
                        for (uint i=0; i <= data.length() / 4000; i++) {
227
                                qDebug(data.mid(i*4000, 4000));
228
                        }
229
                        qDebug("psimport: enddata");
230
                        qDebug(QString("psimport: drag type %1").arg(dr->format()));
231
#endif
232
                        if (!dr->drag())
233
                                qDebug("psimport: couldn't start dragging!");
290 Franz 234
                        delete ss;
235
                        Doku->DragP = false;
236
                        Doku->DraggedElem = 0;
237
                        Doku->DragElements.clear();
238
                }
239
                else
357 Franz 240
                {
2891 cbradney 241
                        Doku->setModified(false);
4026 craig 242
                        ScMW->slotDocCh();
357 Franz 243
                }
290 Franz 244
        }
245
        else
246
        {
247
                QDir::setCurrent(CurDirP);
248
                Doku->DoDrawing = true;
4026 craig 249
                ScMW->view->setUpdatesEnabled(true);
250
                ScMW->ScriptRunning = false;
290 Franz 251
                qApp->setOverrideCursor(QCursor(arrowCursor), true);
252
        }
3207 craig 253
        if (interactive)
2891 cbradney 254
                Doku->setLoading(false);
290 Franz 255
}
256
 
257
bool EPSPlug::convert(QString fn, double x, double y, double b, double h)
258
{
4194 fschmid 259
        QStringList args;
260
        QString cmd, cmd1, cmd2, cmd3, tmp, tmp2, tmp3, tmp4;
3120 fschmid 261
        // import.prolog do not cope with filenames containing blank spaces
262
        // so take care that output filename does not (win32 compatibility)
4026 craig 263
        QString tmpFile = getShortPathName(ScMW->PrefsPfad)+ "/ps.out";
4801 avox 264
        QString errFile = getShortPathName(ScMW->PrefsPfad)+ "/ps.err";
1693 craig 265
        QString pfad = ScPaths::instance().libDir();
3120 fschmid 266
        QString pfad2 = QDir::convertSeparators(pfad + "import.prolog");
1735 fschmid 267
        QFileInfo fi = QFileInfo(fn);
268
        QString ext = fi.extension(false).lower();
4923 avox 269
 
270
        if (progressDialog) {
271
                progressDialog->setOverallProgress(1);
272
                ScQApp->processEvents();
273
        }
4194 fschmid 274
        args.append( getShortPathName(PrefsManager::instance()->ghostscriptExecutable()) );
275
        args.append( "-q" );
276
        args.append( "-dNOPAUSE" );
4745 avox 277
        args.append( "-sDEVICE=nullpage" );
4194 fschmid 278
        args.append( "-dBATCH" );
2523 craig 279
        // Add any extra font paths being used by Scribus to gs's font search
280
        // path We have to use Scribus's prefs context, not a plugin context, to
281
        // get to the required information.
2856 cbradney 282
        PrefsContext *pc = PrefsManager::instance()->prefsFile->getContext("Fonts");
2523 craig 283
        PrefsTable *extraFonts = pc->getTable("ExtraFontDirs");
4194 fschmid 284
        const char sep = ScPaths::envPathSeparator;
2523 craig 285
        if (extraFonts->getRowCount() >= 1)
4194 fschmid 286
                cmd = QString("-sFONTPATH=%1").arg(extraFonts->get(0,0));
2523 craig 287
        for (int i = 1; i < extraFonts->getRowCount(); ++i)
4194 fschmid 288
                cmd += QString("%1%2").arg(sep).arg(extraFonts->get(i,0));
289
        if( !cmd.isEmpty() )
290
                args.append( cmd );
2523 craig 291
        // then finish building the command and call gs
4788 avox 292
        args.append( QString("-g%1x%2").arg(tmp2.setNum(qRound((b-x)*4))).arg(tmp3.setNum(qRound((h-y)*4))) );
293
        args.append( "-r288");
294
        args.append( "-dTextAlphaBits=4" );
295
        args.append( "-dGraphicsAlphaBits=4" );
4194 fschmid 296
        args.append( "-c" );
297
        args.append( tmp.setNum(-x) );
298
        args.append( tmp.setNum(-y) );
299
        args.append( "translate" );
4740 avox 300
        args.append( QString("-sTraceFile=%1").arg(QDir::convertSeparators(tmpFile)) );
4801 avox 301
        QString exportPath = ScMW->doc->DocName + "-" + fi.baseName();
302
        QFileInfo exportFi(exportPath);
303
        if ( !exportFi.isWritable() ) {
304
                PrefsContext* docContext = PrefsManager::instance()->prefsFile->getContext("docdirs", false);
305
                QString docDir = ".";
306
                QString prefsDocDir=PrefsManager::instance()->documentDir();
307
                if (!prefsDocDir.isEmpty())
308
                        docDir = docContext->get("docsopen", prefsDocDir);
309
                else
310
                        docDir = docContext->get("docsopen", ".");             
311
                exportFi.setFile(docDir + "/" + exportFi.baseName());
312
        }
4867 cbradney 313
        //qDebug(QString("using export path %1").arg(exportFi.absFilePath()));
4801 avox 314
        args.append( QString("-sExportFiles=%1").arg(QDir::convertSeparators(exportFi.absFilePath())) );
4194 fschmid 315
        args.append( pfad2 );
316
        args.append( QDir::convertSeparators(fn) );
317
        args.append( "-c" );
318
        args.append( "flush" );
319
        args.append( "cfile" );
320
        args.append( "closefile" );
321
        args.append( "quit" );
322
        QCString finalCmd = args.join(" ").local8Bit();
4801 avox 323
        int ret = System(args, errFile, errFile);
290 Franz 324
        if (ret != 0)
325
        {
2791 craig 326
                qDebug("PostScript import failed when calling gs as: \n%s\n", finalCmd.data());
4725 avox 327
                qDebug("Ghostscript diagnostics:\n");
4801 avox 328
                QFile diag(errFile);
329
                if (diag.open(IO_ReadOnly) && !diag.atEnd() ) {
4725 avox 330
                        QString line;
4801 avox 331
                        while (diag.readLine(line, 120) > 0) {
332
                                qDebug("\t%s", line.ascii());
4725 avox 333
                        }
334
                        diag.close();
335
                }
336
                else {
337
                        qDebug("-- no output --");
338
                }
290 Franz 339
                QString mess = tr("Importing File:\n%1\nfailed!").arg(fn);
340
                QMessageBox::critical(0, tr("Fatal Error"), mess, 1, 0, 0);
341
                return false;
342
        }
4923 avox 343
        if(progressDialog) {
344
                progressDialog->setOverallProgress(2);
345
                progressDialog->setLabel("GI", tr("Generating Items"));
346
                ScQApp->processEvents();
347
        }
348
        if (!cancel) {
349
                parseOutput(tmpFile, ext == "eps");
350
        }
2921 fschmid 351
        QFile::remove(tmpFile);
4923 avox 352
        if (progressDialog)
353
                progressDialog->close();
290 Franz 354
        return true;
355
}
356
 
1735 fschmid 357
void EPSPlug::parseOutput(QString fn, bool eps)
290 Franz 358
{
359
        QString tmp, token, params, lasttoken, lastPath, currPath;
537 fschmid 360
        int z, lcap, ljoin, dc, pagecount;
319 Franz 361
        double dcp;
4770 avox 362
        bool fillRuleEvenOdd = true;
290 Franz 363
        PageItem* ite;
364
        QFile f(fn);
365
        lasttoken = "";
537 fschmid 366
        pagecount = 1;
290 Franz 367
        if (f.open(IO_ReadOnly))
368
        {
4923 avox 369
                if (progressDialog) {
370
                        progressDialog->setTotalSteps("GI", (int) f.size());
371
                        ScQApp->processEvents();
372
                }
290 Franz 373
                lastPath = "";
374
                currPath = "";
375
                LineW = 0;
376
                Opacity = 1;
4546 subik 377
                CurrColor = CommonStrings::None;
292 Franz 378
                JoinStyle = MiterJoin;
379
                CapStyle = FlatCap;
380
                DashPattern.clear();
290 Franz 381
                QTextStream ts(&f);
4923 avox 382
                int line_cnt = 0;
383
                while (!ts.atEnd() && !cancel)
290 Franz 384
                {
385
                        tmp = "";
386
                        tmp = ts.readLine();
4923 avox 387
                        if (progressDialog && (++line_cnt % 100 == 0)) {
388
                                progressDialog->setProgress("GI", (int) f.at());
389
                                ScQApp->processEvents();
390
                        }
4801 avox 391
                        token = tmp.section(' ', 0, 0);
392
                        params = tmp.section(' ', 1, -1, QString::SectionIncludeTrailingSep);
3207 craig 393
                        if ((lasttoken == "sp") && (!interactive) && (!eps))
537 fschmid 394
                        {
4026 craig 395
                                ScMW->doc->addPage(pagecount);
396
                                ScMW->view->addPage(pagecount, true);
537 fschmid 397
                                pagecount++;
398
                        }
290 Franz 399
                        if (token == "n")
400
                        {
401
                                Coords.resize(0);
402
                                FirstM = true;
403
                                WasM = false;
404
                                ClosedPath = false;
405
                        }
406
                        else if (token == "m")
407
                                WasM = true;
408
                        else if (token == "c")
409
                        {
410
                                Curve(&Coords, params);
411
                                currPath += params;
412
                        }
413
                        else if (token == "l")
414
                        {
415
                                LineTo(&Coords, params);
416
                                currPath += params;
417
                        }
4770 avox 418
                        else if (token == "fill-winding")
419
                        {
420
                                fillRuleEvenOdd = false;
421
                        }
422
                        else if (token == "fill-evenodd")
423
                        {
424
                                fillRuleEvenOdd = true;
425
                        }
290 Franz 426
                        else if (token == "f")
427
                        {
4770 avox 428
                                //TODO: pattern -> Imageframe + Clip
290 Franz 429
                                if (Coords.size() != 0)
430
                                {
431
                                        if ((Elements.count() != 0) && (lastPath == currPath))
432
                                        {
433
                                                ite = Elements.at(Elements.count()-1);
1394 cbradney 434
                                                ite->setFillColor(CurrColor);
435
                                                ite->setFillTransparency(1.0 - Opacity);
290 Franz 436
                                        }
437
                                        else
438
                                        {
439
                                                if (ClosedPath)
4546 subik 440
                                                        z = ScMW->doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, 0, 0, 10, 10, LineW, CurrColor, CommonStrings::None, true);
290 Franz 441
                                                else
4546 subik 442
                                                        z = ScMW->doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, 0, 0, 10, 10, LineW, CurrColor, CommonStrings::None, true);
4026 craig 443
                                                ite = ScMW->doc->Items->at(z);
4801 avox 444
                                                ite->PoLine = Coords.copy();  //FIXME: try to avoid copy if FPointArray when properly shared
4026 craig 445
                                                ite->PoLine.translate(ScMW->doc->currentPage->xOffset(), ScMW->doc->currentPage->yOffset());
290 Franz 446
                                                ite->ClipEdited = true;
447
                                                ite->FrameType = 3;
4770 avox 448
                                                ite->fillRule = (fillRuleEvenOdd);
1065 cbradney 449
                                                FPoint wh = getMaxClipF(&ite->PoLine);
3934 cbradney 450
                                                ite->setWidthHeight(wh.x(),wh.y());
290 Franz 451
                                                ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
1394 cbradney 452
                                                ite->setFillTransparency(1.0 - Opacity);
4026 craig 453
                                                ScMW->view->AdjustItemSize(ite);
290 Franz 454
                                                Elements.append(ite);
455
                                        }
456
                                        lastPath = currPath;
457
                                        currPath = "";
458
                                }
459
                        }
460
                        else if (token == "s")
461
                        {
462
                                if (Coords.size() != 0)
463
                                {
464
                                        LineW = QMAX(LineW, 0.1); // Set Linewidth to be a least 0.1 pts, a Stroke without a Linewidth makes no sense
465
                                        if ((Elements.count() != 0) && (lastPath == currPath))
466
                                        {
467
                                                ite = Elements.at(Elements.count()-1);
1394 cbradney 468
                                                ite->setLineColor(CurrColor);
4580 cbradney 469
                                                ite->setLineWidth(LineW);
292 Franz 470
                                                ite->PLineEnd = CapStyle;
471
                                                ite->PLineJoin = JoinStyle;
1394 cbradney 472
                                                ite->setLineTransparency(1.0 - Opacity);
292 Franz 473
                                                ite->DashOffset = DashOffset;
474
                                                ite->DashValues = DashPattern;
290 Franz 475
                                        }
476
                                        else
477
                                        {
4026 craig 478
                                                ScribusDoc* Doku = ScMW->doc;
290 Franz 479
                                                if (ClosedPath)
4546 subik 480
                                                        z = Doku->itemAdd(PageItem::Polygon, PageItem::Unspecified, 0, 0, 10, 10, LineW, CommonStrings::None, CurrColor, true);
290 Franz 481
                                                else
4546 subik 482
                                                        z = Doku->itemAdd(PageItem::PolyLine, PageItem::Unspecified, 0, 0, 10, 10, LineW, CommonStrings::None, CurrColor, true);
3727 cbradney 483
                                                ite = Doku->Items->at(z);
4801 avox 484
                                                ite->PoLine = Coords.copy(); //FIXME: try to avoid copy when FPointArray is properly shared
3200 cbradney 485
                                                ite->PoLine.translate(Doku->currentPage->xOffset(), Doku->currentPage->yOffset());
290 Franz 486
                                                ite->ClipEdited = true;
487
                                                ite->FrameType = 3;
292 Franz 488
                                                ite->PLineEnd = CapStyle;
489
                                                ite->PLineJoin = JoinStyle;
490
                                                ite->DashOffset = DashOffset;
491
                                                ite->DashValues = DashPattern;
1065 cbradney 492
                                                FPoint wh = getMaxClipF(&ite->PoLine);
3934 cbradney 493
                                                ite->setWidthHeight(wh.x(), wh.y());
290 Franz 494
                                                ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
1394 cbradney 495
                                                ite->setLineTransparency(1.0 - Opacity);
4026 craig 496
                                                ScMW->view->AdjustItemSize(ite);
290 Franz 497
                                                Elements.append(ite);
498
                                        }
499
                                        lastPath = currPath;
500
                                        currPath = "";
501
                                }
502
                        }
503
                        else if (token == "co")
504
                                CurrColor = parseColor(params);
1488 fschmid 505
                        else if (token == "corgb")
506
                                CurrColor = parseColor(params, colorModelRGB);
290 Franz 507
                        else if (token == "ci")
508
                        {
4923 avox 509
                                clipCoords = Coords;
510
                                Coords   = FPointArray(0);
290 Franz 511
                                lastPath = "";
512
                                currPath = "";
513
                        }
514
                        else if (token == "w")
515
                        {
516
                                QTextStream Lw(&params, IO_ReadOnly);
517
                                Lw >> LineW;
518
                                currPath += params;
519
                        }
292 Franz 520
                        else if (token == "ld")
521
                        {
522
                                QTextStream Lw(&params, IO_ReadOnly);
523
                                Lw >> dc;
524
                                Lw >> DashOffset;
525
                                DashPattern.clear();
526
                                if (dc != 0)
527
                                {
528
                                        for (int dcc = 0; dcc < dc; ++dcc)
529
                                        {
530
                                                Lw >> dcp;
531
                                                DashPattern.append(dcp);
532
                                        }
533
                                }
534
                                currPath += params;
535
                        }
536
                        else if (token == "lc")
537
                        {
538
                                QTextStream Lw(&params, IO_ReadOnly);
539
                                Lw >> lcap;
540
                                switch (lcap)
541
                                {
542
                                        case 0:
543
                                                CapStyle = Qt::FlatCap;
544
                                                break;
545
                                        case 1:
546
                                                CapStyle = Qt::RoundCap;
547
                                                break;
548
                                        case 2:
549
                                                CapStyle = Qt::SquareCap;
550
                                                break;
551
                                        default:
552
                                                CapStyle = Qt::FlatCap;
553
                                                break;
554
                                }
555
                                currPath += params;
556
                        }
557
                        else if (token == "lj")
558
                        {
559
                                QTextStream Lw(&params, IO_ReadOnly);
560
                                Lw >> ljoin;
561
                                switch (ljoin)
562
                                {
563
                                        case 0:
564
                                                JoinStyle = Qt::MiterJoin;
565
                                                break;
566
                                        case 1:
567
                                                JoinStyle = Qt::RoundJoin;
568
                                                break;
569
                                        case 2:
570
                                                JoinStyle = Qt::BevelJoin;
571
                                                break;
572
                                        default:
573
                                                JoinStyle = Qt::MiterJoin;
574
                                                break;
575
                                }
576
                                currPath += params;
577
                        }
4717 avox 578
                        else if (token == "cp") {
290 Franz 579
                                ClosedPath = true;
4717 avox 580
                        }
581
                        else if (token == "im") {
582
                                Image(params);
583
                        }
290 Franz 584
                        lasttoken = token;
585
                }
586
                f.close();
587
        }
588
}
589
 
4717 avox 590
void EPSPlug::Image(QString vals)
591
{
592
        double x, y, w, h, angle;
593
        int horpix, verpix;
594
        QString filename, device;
595
        QTextStream Code(&vals, IO_ReadOnly);
596
        Code >> x;
597
        Code >> y;
598
        Code >> w;
599
        Code >> h;
600
        Code >> angle;
601
        Code >> horpix;
602
        Code >> verpix;
603
        Code >> device;
4788 avox 604
        filename = Code.read().stripWhiteSpace();
4717 avox 605
        qDebug(QString("import %6 image %1: %2x%3 @ (%4,%5) °%5").arg(filename).arg(w).arg(h).arg(x).arg(y).arg(angle).arg(device));
606
        QString rawfile = filename.mid(0, filename.length()-3) + "dat";
607
        QStringList args;
608
        args.append( getShortPathName(PrefsManager::instance()->ghostscriptExecutable()) );
609
        args.append( "-q" );
610
        args.append( "-dNOPAUSE" );
611
        args.append( QString("-sDEVICE=%1").arg(device) );    
612
        args.append( "-dBATCH" );
613
        args.append( QString("-g%1x%2").arg(horpix).arg(verpix) );
614
        args.append( QString("-sOutputFile=%1").arg(QDir::convertSeparators(filename)) );
615
        args.append( QDir::convertSeparators(rawfile) );
616
        args.append( "-c" );
617
        args.append( "showpage" );
618
        args.append( "quit" );
619
        QCString finalCmd = args.join(" ").local8Bit();
620
        int ret = System(args);
621
        if (ret != 0)
622
        {
623
                qDebug("PostScript image conversion failed when calling gs as: \n%s\n", finalCmd.data());
4725 avox 624
                qDebug("Ghostscript diagnostics:\n");
625
                QFile diag(filename);
626
                if (diag.open(IO_ReadOnly)) {
627
                        QString line;
4740 avox 628
                        long int len;
629
                        bool gs_error = false;
630
                        do {
631
                                len = diag.readLine(line, 120);
632
                                gs_error |= line.contains("Error");
633
                                if (gs_error)
634
                                        qDebug("\t%s", line.ascii());
4725 avox 635
                        }
4740 avox 636
                        while (len > 0);
4725 avox 637
                        diag.close();
638
                }
639
                else {
640
                        qDebug("-- no output --");
641
                }
4717 avox 642
                QString mess = tr("Converting Image:\n%1\nfailed!").arg(rawfile);
643
                QMessageBox::critical(0, tr("Error"), mess, 1, 0, 0);
644
        }
4923 avox 645
        QFile::remove(rawfile);
4717 avox 646
        int z = ScMW->doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, 0, 0, w, h, LineW, CommonStrings::None, CurrColor, true);
647
        PageItem * ite = ScMW->doc->Items->at(z);
648
        ite->setXYPos(ScMW->doc->currentPage->xOffset() + x, ScMW->doc->currentPage->yOffset() + y);
649
        ite->setWidthHeight(w, h);
650
        ite->clearContents();
651
/*      FPoint a(x, y);
652
        FPoint b(x+w, y);
653
        FPoint c(x+w, y-h);
654
        FPoint d(x, y-h);
655
        ite->PoLine.resize(0);
656
        ite->PoLine.addQuadPoint(a, a, b, b);
657
        ite->PoLine.addQuadPoint(b, b, c, c);
658
        ite->PoLine.addQuadPoint(c, c, d, d);
659
        ite->PoLine.addQuadPoint(d, d, a, a);
660
        ite->PoLine.translate(ScMW->doc->currentPage->xOffset(), ScMW->doc->currentPage->yOffset());
661
        ite->ClipEdited = true;
662
        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
663
*/      ScMW->doc->loadPict(filename, ite, -1);
664
        ite->setRotation(angle);
665
        ite->setImageScalingMode(false, true); // fit to frame, keep ratio
666
//      ScMW->view->AdjustItemSize(ite);
667
        Elements.append(ite);  
668
}
669
 
670
 
290 Franz 671
void EPSPlug::LineTo(FPointArray *i, QString vals)
672
{
2877 cbradney 673
        if (vals.isEmpty())
290 Franz 674
                return;
675
        double x1, x2, y1, y2;
4801 avox 676
        x1 = vals.section(' ', 0, 0, QString::SectionSkipEmpty).toDouble();
677
        y1 = vals.section(' ', 1, 1, QString::SectionSkipEmpty).toDouble();
678
        x2 = vals.section(' ', 2, 2, QString::SectionSkipEmpty).toDouble();
679
        y2 = vals.section(' ', 3, 3, QString::SectionSkipEmpty).toDouble();
290 Franz 680
        if ((!FirstM) && (WasM))
681
                i->setMarker();
682
        FirstM = false;
683
        WasM = false;
684
        i->addPoint(FPoint(x1, y1));
685
        i->addPoint(FPoint(x1, y1));
686
        i->addPoint(FPoint(x2, y2));
687
        i->addPoint(FPoint(x2, y2));
688
}
689
 
690
void EPSPlug::Curve(FPointArray *i, QString vals)
691
{
2877 cbradney 692
        if (vals.isEmpty())
290 Franz 693
                return;
694
        double x1, x2, y1, y2, x3, y3, x4, y4;
4801 avox 695
        x1 = vals.section(' ', 0, 0, QString::SectionSkipEmpty).toDouble();
696
        y1 = vals.section(' ', 1, 1, QString::SectionSkipEmpty).toDouble();
697
        x2 = vals.section(' ', 2, 2, QString::SectionSkipEmpty).toDouble();
698
        y2 = vals.section(' ', 3, 3, QString::SectionSkipEmpty).toDouble();
699
        x3 = vals.section(' ', 4, 4, QString::SectionSkipEmpty).toDouble();
700
        y3 = vals.section(' ', 5, 5, QString::SectionSkipEmpty).toDouble();
701
        x4 = vals.section(' ', 6, 6, QString::SectionSkipEmpty).toDouble();
702
        y4 = vals.section(' ', 7, 7, QString::SectionSkipEmpty).toDouble();
290 Franz 703
        if ((!FirstM) && (WasM))
704
                i->setMarker();
705
        FirstM = false;
706
        WasM = false;
707
        i->addPoint(FPoint(x1, y1));
708
        i->addPoint(FPoint(x2, y2));
709
        i->addPoint(FPoint(x4, y4));
710
        i->addPoint(FPoint(x3, y3));
711
}
712
 
1488 fschmid 713
QString EPSPlug::parseColor(QString vals, colorModel model)
290 Franz 714
{
4026 craig 715
        ScribusDoc* Doku = ScMW->doc;
4546 subik 716
        QString ret = CommonStrings::None;
2877 cbradney 717
        if (vals.isEmpty())
290 Franz 718
                return ret;
1488 fschmid 719
        double c, m, y, k, r, g, b;
2886 fschmid 720
        ScColor tmp;
1488 fschmid 721
        ColorList::Iterator it;
290 Franz 722
        QTextStream Code(&vals, IO_ReadOnly);
723
        bool found = false;
1488 fschmid 724
        if (model == colorModelRGB)
290 Franz 725
        {
1488 fschmid 726
                Code >> r;
727
                Code >> g;
728
                Code >> b;
729
                Code >> Opacity;
730
                int Rc = static_cast<int>(r * 255 + 0.5);
731
                int Gc = static_cast<int>(g * 255 + 0.5);
732
                int Bc = static_cast<int>(b * 255 + 0.5);
733
                int hR, hG, hB;
734
                tmp.setColorRGB(Rc, Gc, Bc);
735
                for (it = Doku->PageColors.begin(); it != Doku->PageColors.end(); ++it)
290 Franz 736
                {
1488 fschmid 737
                        Doku->PageColors[it.key()].getRGB(&hR, &hG, &hB);
738
                        if ((Rc == hR) && (Gc == hG) && (Bc == hB))
739
                        {
740
                                if (Doku->PageColors[it.key()].getColorModel() == colorModelRGB)
741
                                {
742
                                        ret = it.key();
743
                                        found = true;
744
                                }
745
                        }
290 Franz 746
                }
747
        }
1488 fschmid 748
        else
749
        {
750
                Code >> c;
751
                Code >> m;
752
                Code >> y;
753
                Code >> k;
754
                Code >> Opacity;
755
                int Cc = static_cast<int>(c * 255 + 0.5);
756
                int Mc = static_cast<int>(m * 255 + 0.5);
757
                int Yc = static_cast<int>(y * 255 + 0.5);
758
                int Kc = static_cast<int>(k * 255 + 0.5);
759
                int hC, hM, hY, hK;
760
                tmp.setColor(Cc, Mc, Yc, Kc);
761
                for (it = Doku->PageColors.begin(); it != Doku->PageColors.end(); ++it)
762
                {
763
                        Doku->PageColors[it.key()].getCMYK(&hC, &hM, &hY, &hK);
764
                        if ((Cc == hC) && (Mc == hM) && (Yc == hY) && (Kc == hK))
765
                        {
766
                                if (Doku->PageColors[it.key()].getColorModel() == colorModelCMYK)
767
                                {
768
                                        ret = it.key();
769
                                        found = true;
770
                                }
771
                        }
772
                }
773
        }
290 Franz 774
        if (!found)
775
        {
776
                Doku->PageColors.insert("FromEPS"+tmp.name(), tmp);
4026 craig 777
                ScMW->propertiesPalette->updateColorList();
290 Franz 778
                ret = "FromEPS"+tmp.name();
779
        }
780
        return ret;
781
}