Subversion Repositories Scribus

Rev

Rev 8562 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5977 jghali 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
5937 jghali 7
#include <qfile.h>
8
#include <qfileinfo.h>
6664 fschmid 9
#include <qregexp.h>
8501 cbradney 10
//Added by qt3to4:
11
#include <Q3CString>
8569 jghali 12
#include <Q3TextStream>
5937 jghali 13
#include "gsutil.h"
14
#include "scpaths.h"
15
#include "scribuscore.h"
16
#include "scimgdataloader_ps.h"
6759 fschmid 17
#include "prefsmanager.h"
6808 fschmid 18
#include "util.h"
7196 fschmid 19
#include "cmsettings.h"
20
#include "scimage.h"
5937 jghali 21
 
6762 fschmid 22
extern "C"
23
{
24
#define XMD_H           // shut JPEGlib up
25
#if defined(Q_OS_UNIXWARE)
26
#  define HAVE_BOOLEAN  // libjpeg under Unixware seems to need this
27
#endif
28
#include <jpeglib.h>
29
#include <jerror.h>
30
#undef HAVE_STDLIB_H
31
#ifdef const
32
#  undef const          // remove crazy C hackery in jconfig.h
33
#endif
34
}
35
 
5937 jghali 36
ScImgDataLoader_PS::ScImgDataLoader_PS(void) : ScImgDataLoader()
37
{
38
        initSupportedFormatList();
39
}
40
 
41
void ScImgDataLoader_PS::initSupportedFormatList(void)
42
{
43
        m_supportedFormats.clear();
44
        m_supportedFormats.append( "ps" );
45
        m_supportedFormats.append( "eps" );
7420 fschmid 46
        m_supportedFormats.append( "epsi" );
5937 jghali 47
}
48
 
49
void ScImgDataLoader_PS::loadEmbeddedProfile(const QString& fn)
50
{
6660 fschmid 51
        QChar tc;
52
        QString tmp;
5937 jghali 53
        m_embeddedProfile.resize(0);
54
        m_profileComponents = 0;
6660 fschmid 55
        if ( !QFile::exists(fn) )
56
                return;
57
        QFile f(fn);
8501 cbradney 58
        if (f.open(QIODevice::ReadOnly))
6660 fschmid 59
        {
8501 cbradney 60
                Q3TextStream ts(&f);
6660 fschmid 61
                while (!ts.atEnd())
62
                {
6664 fschmid 63
                        tmp = ts.readLine();
6660 fschmid 64
                        if (tmp.startsWith("%%BeginICCProfile:"))
65
                        {
66
                                QByteArray psdata;
67
                                while (!ts.atEnd())
68
                                {
6664 fschmid 69
                                        tmp = ts.readLine();
8569 jghali 70
                                        for (int a = 2; a < tmp.length(); a += 2)
6660 fschmid 71
                                        {
72
                                                bool ok;
73
                                                ushort data = tmp.mid(a, 2).toUShort(&ok, 16);
74
                                                psdata.resize(psdata.size()+1);
75
                                                psdata[psdata.size()-1] = data;
76
                                        }
77
                                        if (tmp.startsWith("%%EndICCProfile"))
78
                                        {
79
                                                cmsHPROFILE prof = cmsOpenProfileFromMem(psdata.data(), psdata.size());
80
                                                if (prof)
81
                                                {
82
                                                        if (static_cast<int>(cmsGetColorSpace(prof)) == icSigRgbData)
83
                                                                m_profileComponents = 3;
84
                                                        if (static_cast<int>(cmsGetColorSpace(prof)) == icSigCmykData)
85
                                                                m_profileComponents = 4;
86
                                                        const char *Descriptor;
87
                                                        Descriptor = cmsTakeProductDesc(prof);
88
                                                        m_imageInfoRecord.profileName = QString(Descriptor);
89
                                                        m_imageInfoRecord.isEmbedded = true;
90
                                                        m_embeddedProfile.duplicate((const char*)psdata.data(), psdata.size());
91
                                                }
92
                                                cmsCloseProfile(prof);
93
                                                break;
94
                                        }
95
                                }
96
                        }
97
                }
98
        }
5937 jghali 99
}
100
 
6759 fschmid 101
void ScImgDataLoader_PS::scanForFonts(QString fn)
102
{
103
        QString tmp;
104
        QFile f(fn);
8501 cbradney 105
        if (f.open(QIODevice::ReadOnly))
6759 fschmid 106
        {
8501 cbradney 107
                Q3TextStream ts(&f);
6759 fschmid 108
                while (!ts.atEnd())
109
                {
110
                        tmp = ts.readLine();
111
                        if (tmp.startsWith("%%BeginFont:"))
112
                        {
113
                                tmp = tmp.remove("%%BeginFont:");
8501 cbradney 114
                                Q3TextStream ts2(&tmp, QIODevice::ReadOnly);
6759 fschmid 115
                                QString tmp2;
116
                                ts2 >> tmp2;
117
                                FontListe.remove(tmp2);
118
                        }
119
                }
120
        }
121
}
122
 
6660 fschmid 123
bool ScImgDataLoader_PS::parseData(QString fn)
5937 jghali 124
{
6660 fschmid 125
        QChar tc;
6664 fschmid 126
        QString tmp, FarNam;
127
        ScColor cc;
128
        double x, y, b, h, c, m, k;
5937 jghali 129
        bool found = false;
6660 fschmid 130
        isDCS1 = false;
6664 fschmid 131
        isDCS2 = false;
6670 fschmid 132
        isDCS2multi = false;
6709 fschmid 133
        isPhotoshop = false;
134
        hasPhotoshopImageData = false;
7196 fschmid 135
        hasThumbnail = false;
6669 fschmid 136
        int plateCount = 0;
7184 fschmid 137
        uint startPos = 0;
6759 fschmid 138
        FontListe.clear();
5937 jghali 139
        QFile f(fn);
8501 cbradney 140
        if (f.open(QIODevice::ReadOnly))
5937 jghali 141
        {
8501 cbradney 142
                Q3CString tempBuf(9);
7184 fschmid 143
                f.readBlock(tempBuf.data(), 8);
144
                if (getDouble(QString(tempBuf.mid(0, 4)), true) == 0xC5D0D3C6)
7196 fschmid 145
                {
7184 fschmid 146
                        startPos = getDouble(tempBuf.mid(4, 4), false);
7196 fschmid 147
                        if (doThumbnail)
148
                        {
149
                                f.at(0);
150
                                QByteArray tmp2buf(29);
151
                                f.readBlock(tmp2buf.data(), 28);
152
                                uint thumbStart = 0;
153
                                thumbStart = tmp2buf[20] & 0xff;
154
                                thumbStart |= (tmp2buf[21] << 8) & 0xff00;
155
                                thumbStart |= (tmp2buf[22] << 16) & 0xff0000;
156
                                thumbStart |= (tmp2buf[23] << 24) & 0xff000000;
157
                                uint thumbLen = 0;
158
                                thumbLen = tmp2buf[24] & 0xff;
159
                                thumbLen |= (tmp2buf[25] << 8) & 0xff00;
160
                                thumbLen |= (tmp2buf[26] << 16) & 0xff0000;
161
                                thumbLen |= (tmp2buf[27] << 24) & 0xff000000;
162
                                if (thumbLen != 0)
163
                                {
164
                                        QByteArray imgc(thumbLen);
165
                                        f.at(thumbStart);
166
                                        uint readB = f.readBlock(imgc.data(), thumbLen);
7980 fschmid 167
                                        readB = 0;
7196 fschmid 168
                                        QString tmpFile = QDir::convertSeparators(ScPaths::getTempFileDir() + "preview.tiff");
169
                                        QFile f2(tmpFile);
8501 cbradney 170
                                        if (f2.open(QIODevice::WriteOnly))
7196 fschmid 171
                                                f2.writeBlock(imgc.data(), thumbLen);
172
                                        f2.close();
173
                                        imgc.resize(0);
174
                                        ScImage thum;
175
                                        CMSettings cms(0, "", 0);
176
                                        bool mode = true;
177
                                        if (thum.LoadPicture(tmpFile, cms, false, false, ScImage::RGBData, 72, &mode))
178
                                        {
179
                                                m_imageInfoRecord.exifDataValid = true;
180
                                                m_imageInfoRecord.exifInfo.thumbnail = thum.qImage().copy();
181
                                        }
182
                                        unlink(tmpFile);
183
                                        hasThumbnail = true;
184
                                }
185
                        }
186
                }
6653 fschmid 187
                bool psFound = false;
8501 cbradney 188
                Q3TextStream ts(&f);
7184 fschmid 189
                ts.device()->at(startPos);
5937 jghali 190
                while (!ts.atEnd())
191
                {
6664 fschmid 192
                        tmp = ts.readLine();
6669 fschmid 193
                        if (tmp.startsWith("%%Creator: "))
194
                                Creator = tmp.remove("%%Creator: ");
5937 jghali 195
                        if (tmp.startsWith("%%BoundingBox:"))
196
                        {
197
                                found = true;
198
                                BBox = tmp.remove("%%BoundingBox:");
199
                        }
200
                        if (!found)
201
                        {
202
                                if (tmp.startsWith("%%BoundingBox"))
203
                                {
204
                                        found = true;
205
                                        BBox = tmp.remove("%%BoundingBox");
206
                                }
207
                        }
6660 fschmid 208
                        if (tmp.startsWith("%%CyanPlate:"))
209
                        {
210
                                colorPlates.insert("Cyan", tmp.remove("%%CyanPlate: "));
211
                                isDCS1 = true;
212
                        }
213
                        if (tmp.startsWith("%%MagentaPlate:"))
214
                        {
215
                                colorPlates.insert("Magenta", tmp.remove("%%MagentaPlate: "));
216
                                isDCS1 = true;
217
                        }
218
                        if (tmp.startsWith("%%YellowPlate:"))
219
                        {
220
                                colorPlates.insert("Yellow", tmp.remove("%%YellowPlate: "));
221
                                isDCS1 = true;
222
                        }
223
                        if (tmp.startsWith("%%BlackPlate:"))
224
                        {
225
                                colorPlates.insert("Black", tmp.remove("%%BlackPlate: "));
226
                                isDCS1 = true;
227
                        }
6669 fschmid 228
                        if (tmp.startsWith("%%PlateFile: ("))
229
                        {
230
                                tmp = tmp.remove("%%PlateFile: (");
231
                                int endNam = tmp.find(")");
232
                                QString plateNam = tmp.left(endNam);
233
                                tmp = tmp.remove(plateNam+")");
8501 cbradney 234
                                Q3TextStream ts2(&tmp, QIODevice::ReadOnly);
6670 fschmid 235
                                QString posStr, dummy, lenStr;
236
                                ts2 >> dummy >> posStr >> lenStr;
6672 fschmid 237
                                if (dummy == "EPS")
6669 fschmid 238
                                {
6672 fschmid 239
                                        if (posStr.startsWith("#"))
6669 fschmid 240
                                        {
6672 fschmid 241
                                                posStr = posStr.remove(0, 1);
242
                                                uint pos = posStr.toUInt();
243
                                                uint len = lenStr.toUInt();
244
                                                struct plateOffsets offs;
245
                                                if (Creator.contains("Photoshop Version 9"))    // This is very strange, it seems that there is a bug in PS 9 which writes weired entries
246
                                                {
247
                                                        pos -= (191 + plateCount * 83);
248
                                                        len -= 83;
249
                                                }
250
                                                offs.pos = pos;
251
                                                offs.len = len;
252
                                                colorPlates2.insert(plateNam, offs);
253
                                                isDCS2 = true;
254
                                                plateCount++;
6669 fschmid 255
                                        }
6672 fschmid 256
                                        else
257
                                        {
258
                                                colorPlates.insert(plateNam, lenStr);
259
                                                isDCS2 = true;
260
                                                isDCS2multi = true;
261
                                        }
6669 fschmid 262
                                }
263
                        }
6759 fschmid 264
                        if (tmp.startsWith("%%DocumentFonts:"))
265
                        {
266
                                tmp = tmp.remove("%%DocumentFonts:");
8501 cbradney 267
                                Q3TextStream ts2(&tmp, QIODevice::ReadOnly);
6759 fschmid 268
                                QString tmp2;
269
                                ts2 >> tmp2;
270
                                if (!tmp2.isEmpty())
271
                                        FontListe.append(tmp2);
272
                                while (!ts.atEnd())
273
                                {
274
                                        uint oldPos = ts.device()->at();
275
                                        tmp = ts.readLine();
276
                                        if (!tmp.startsWith("%%+"))
277
                                        {
278
                                                ts.device()->at(oldPos);
279
                                                break;
280
                                        }
281
                                        tmp = tmp.remove(0,3);
8501 cbradney 282
                                        Q3TextStream ts2(&tmp, QIODevice::ReadOnly);
6759 fschmid 283
                                        QString tmp2;
284
                                        ts2 >> tmp2;
285
                                        if (!tmp2.isEmpty())
286
                                                FontListe.append(tmp2);
287
                                }
288
                        }
6664 fschmid 289
                        if (tmp.startsWith("%%CMYKCustomColor"))
290
                        {
291
                                tmp = tmp.remove(0,18);
8501 cbradney 292
                                Q3TextStream ts2(&tmp, QIODevice::ReadOnly);
6664 fschmid 293
                                ts2 >> c >> m >> y >> k;
294
                                FarNam = ts2.read();
295
                                FarNam = FarNam.stripWhiteSpace();
296
                                FarNam = FarNam.remove(0,1);
297
                                FarNam = FarNam.remove(FarNam.length()-1,1);
298
                                cc = ScColor(static_cast<int>(255 * c), static_cast<int>(255 * m), static_cast<int>(255 * y), static_cast<int>(255 * k));
299
                                cc.setSpotColor(true);
300
                                CustColors.insert(FarNam, cc);
301
                                while (!ts.atEnd())
302
                                {
6669 fschmid 303
                                        uint oldPos = ts.device()->at();
6664 fschmid 304
                                        tmp = ts.readLine();
305
                                        if (!tmp.startsWith("%%+"))
6669 fschmid 306
                                        {
307
                                                ts.device()->at(oldPos);
6664 fschmid 308
                                                break;
6669 fschmid 309
                                        }
6664 fschmid 310
                                        tmp = tmp.remove(0,3);
8501 cbradney 311
                                        Q3TextStream ts2(&tmp, QIODevice::ReadOnly);
6664 fschmid 312
                                        ts2 >> c >> m >> y >> k;
313
                                        FarNam = ts2.read();
314
                                        FarNam = FarNam.stripWhiteSpace();
315
                                        FarNam = FarNam.remove(0,1);
316
                                        FarNam = FarNam.remove(FarNam.length()-1,1);
317
                                        cc = ScColor(static_cast<int>(255 * c), static_cast<int>(255 * m), static_cast<int>(255 * y), static_cast<int>(255 * k));
318
                                        cc.setSpotColor(true);
319
                                        CustColors.insert(FarNam, cc);
320
                                }
321
                        }
5937 jghali 322
                        if (tmp.startsWith("%%EndComments"))
6653 fschmid 323
                        {
324
                                while (!ts.atEnd())
325
                                {
6664 fschmid 326
                                        tmp = ts.readLine();
6653 fschmid 327
                                        if ((!tmp.isEmpty()) && (!tmp.startsWith("%")))
328
                                        {
329
                                                psFound = true;
330
                                                break;
331
                                        }
6709 fschmid 332
                                        if (tmp.startsWith("%ImageData: "))
333
                                        {
334
                                                hasPhotoshopImageData = true;
335
                                                tmp.remove("%ImageData: ");
8501 cbradney 336
                                                Q3TextStream ts2(&tmp, QIODevice::ReadOnly);
6760 fschmid 337
                                                ts2 >> psXSize >> psYSize >> psDepth >> psMode >> psChannel >> psBlock >> psDataType >> psCommand;
338
                                                psCommand = psCommand.remove(0,1);
339
                                                psCommand = psCommand.remove(psCommand.length()-1,1);
6709 fschmid 340
                                        }
6653 fschmid 341
                                        if (tmp.startsWith("%BeginPhotoshop"))
342
                                        {
343
                                                QByteArray psdata;
344
                                                while (!ts.atEnd())
345
                                                {
6664 fschmid 346
                                                        tmp = ts.readLine();
6653 fschmid 347
                                                        if (tmp.startsWith("%EndPhotoshop"))
348
                                                        {
8569 jghali 349
                                                                QDataStream strPhot( &psdata, QIODevice::ReadOnly);
6653 fschmid 350
                                                                strPhot.setByteOrder( QDataStream::BigEndian );
351
                                                                PSDHeader fakeHeader;
8501 cbradney 352
                                                                Q3TextStream ts2(&BBox, QIODevice::ReadOnly);
6653 fschmid 353
                                                                ts2 >> x >> y >> b >> h;
6664 fschmid 354
                                                                fakeHeader.width = qRound(b);
355
                                                                fakeHeader.height = qRound(h);
6653 fschmid 356
                                                                parseRessourceData(strPhot, fakeHeader, psdata.size());
357
                                                                m_imageInfoRecord.valid = (m_imageInfoRecord.PDSpathData.size()) > 0 ? true : false;
6709 fschmid 358
                                                                isPhotoshop = true;
6653 fschmid 359
                                                                break;
360
                                                        }
8569 jghali 361
                                                        for (int a = 2; a < tmp.length(); a += 2)
6653 fschmid 362
                                                        {
363
                                                                bool ok;
364
                                                                ushort data = tmp.mid(a, 2).toUShort(&ok, 16);
365
                                                                psdata.resize(psdata.size()+1);
366
                                                                psdata[psdata.size()-1] = data;
367
                                                        }
368
                                                }
7196 fschmid 369
                                                if ((doThumbnail) && ((hasThumbnail) || (!m_imageInfoRecord.exifInfo.thumbnail.isNull())))
370
                                                        return true;
6653 fschmid 371
                                        }
6664 fschmid 372
                                        if (tmp.startsWith("%%BeginICCProfile:"))
373
                                        {
374
                                                QByteArray psdata;
375
                                                while (!ts.atEnd())
376
                                                {
377
                                                        tmp = ts.readLine();
8569 jghali 378
                                                        for (int a = 2; a < tmp.length(); a += 2)
6664 fschmid 379
                                                        {
380
                                                                bool ok;
381
                                                                ushort data = tmp.mid(a, 2).toUShort(&ok, 16);
382
                                                                psdata.resize(psdata.size()+1);
383
                                                                psdata[psdata.size()-1] = data;
384
                                                        }
385
                                                        if (tmp.startsWith("%%EndICCProfile"))
386
                                                        {
387
                                                                cmsHPROFILE prof = cmsOpenProfileFromMem(psdata.data(), psdata.size());
388
                                                                if (prof)
389
                                                                {
390
                                                                        if (static_cast<int>(cmsGetColorSpace(prof)) == icSigRgbData)
391
                                                                                m_profileComponents = 3;
392
                                                                        if (static_cast<int>(cmsGetColorSpace(prof)) == icSigCmykData)
393
                                                                                m_profileComponents = 4;
394
                                                                        const char *Descriptor;
395
                                                                        Descriptor = cmsTakeProductDesc(prof);
396
                                                                        m_imageInfoRecord.profileName = QString(Descriptor);
397
                                                                        m_imageInfoRecord.isEmbedded = true;
398
                                                                        m_embeddedProfile.duplicate((const char*)psdata.data(), psdata.size());
399
                                                                }
400
                                                                cmsCloseProfile(prof);
401
                                                                break;
402
                                                        }
403
                                                }
404
                                        }
6653 fschmid 405
                                        if (psFound)
406
                                                break;
407
                                }
408
                        }
409
                        if (psFound)
5937 jghali 410
                                break;
411
                }
412
        }
413
        f.close();
6660 fschmid 414
        return found;
415
}
416
 
417
bool ScImgDataLoader_PS::loadPicture(const QString& fn, int gsRes, bool thumbnail)
418
{
419
        QStringList args;
420
        double x, y, b, h;
421
        bool found = false;
422
        QString tmp, dummy, cmd1, cmd2, tmp2;
423
        QFileInfo fi = QFileInfo(fn);
424
        if (!fi.exists())
425
                return false;
426
        QString ext = fi.extension(false).lower();
6808 fschmid 427
        if (ext.isEmpty())
428
                ext = getImageType(fn);
6660 fschmid 429
        QString tmpFile = QDir::convertSeparators(ScPaths::getTempFileDir() + "sc.png");
430
        QString picFile = QDir::convertSeparators(fn);
431
        float xres = gsRes;
432
        float yres = gsRes;
433
 
434
        initialize();
435
        m_imageInfoRecord.type = 3;
436
        m_imageInfoRecord.exifDataValid = false;
7196 fschmid 437
        doThumbnail = thumbnail;
6669 fschmid 438
        colorPlates2.clear();
439
        colorPlates.clear();
440
        CustColors.clear();
441
        CustColors.insert("Cyan", ScColor(255, 0, 0, 0));
442
        CustColors.insert("Magenta", ScColor(0, 255, 0, 0));
443
        CustColors.insert("Yellow", ScColor(0, 0, 255, 0));
444
        CustColors.insert("Black", ScColor(0, 0, 0, 255));
6660 fschmid 445
        found = parseData(fn);
6759 fschmid 446
        if (FontListe.count() != 0)
447
        {
448
                scanForFonts(fn);
449
                if (FontListe.count() != 0)
450
                {
451
                        bool missing = false;
452
                        QString missingF = "";
8569 jghali 453
                        for (int fo = 0; fo < FontListe.count(); fo++)
6759 fschmid 454
                        {
455
                                if (!PrefsManager::instance()->appPrefs.AvailFonts.contains(FontListe[fo]))
456
                                {
457
                                        missing = true;
458
                                        missingF += FontListe[fo]+"\n";
459
                                }
460
                        }
461
                        if (missing)
462
                        {
463
                                m_message = QObject::tr("The Font(s):\n%1 are not available.\nThey have been replaced by \"Courier\"\nTherefore the image may be not correct").arg(missingF);
464
                                m_msgType = warningMsg;
465
                        }
466
                }
467
        }
6716 fschmid 468
        if ((thumbnail) && (m_imageInfoRecord.exifDataValid) && (!m_imageInfoRecord.exifInfo.thumbnail.isNull()))
6653 fschmid 469
        {
8501 cbradney 470
                Q3TextStream ts2(&BBox, QIODevice::ReadOnly);
6653 fschmid 471
                ts2 >> x >> y >> b >> h;
6664 fschmid 472
                m_imageInfoRecord.exifInfo.width = qRound(b);
473
                m_imageInfoRecord.exifInfo.height = qRound(h);
6653 fschmid 474
                m_image = m_imageInfoRecord.exifInfo.thumbnail;
6709 fschmid 475
                if ((isPhotoshop) && (hasPhotoshopImageData))
476
                {
6760 fschmid 477
                        m_imageInfoRecord.exifInfo.width = qRound(psXSize);
478
                        m_imageInfoRecord.exifInfo.height = qRound(psYSize);
6709 fschmid 479
                        m_imageInfoRecord.type = 7;
480
                        if (psMode == 4)
6716 fschmid 481
                        {
6709 fschmid 482
                                m_imageInfoRecord.colorspace = 1;
7175 fschmid 483
                                QRgb *s;
484
                                unsigned char cc, cm, cy, ck;
6716 fschmid 485
                                for( int yit=0; yit < m_image.height(); ++yit )
486
                                {
7175 fschmid 487
                                        s = (QRgb*)(m_image.scanLine( yit ));
6716 fschmid 488
                                        for(int xit=0; xit < m_image.width(); ++xit )
489
                                        {
7175 fschmid 490
                                                cc = 255 - qRed(*s);
491
                                                cm = 255 - qGreen(*s);
492
                                                cy = 255 - qBlue(*s);
8562 jghali 493
                                                ck = qMin(qMin(cc, cm), cy);
6716 fschmid 494
                                                *s = qRgba(cc-ck,cm-ck,cy-ck,ck);
495
                                                s++;
496
                                        }
497
                                }
498
                        }
6709 fschmid 499
                        else
500
                                m_imageInfoRecord.colorspace = 0;
501
                }
6716 fschmid 502
                else
503
                        m_imageInfoRecord.colorspace = 0;
6653 fschmid 504
                return true;
505
        }
5937 jghali 506
        if (found)
507
        {
6660 fschmid 508
                if (isDCS1)
509
                        loadDCS1(fn, gsRes);
6669 fschmid 510
                else if (isDCS2)
511
                        loadDCS2(fn, gsRes);
6709 fschmid 512
                else if ((isPhotoshop) && (hasPhotoshopImageData))
513
                        loadPhotoshop(fn, gsRes);
6664 fschmid 514
                else if ((!m_imageInfoRecord.isEmbedded) || ((m_imageInfoRecord.isEmbedded) && (m_profileComponents == 3)))
6660 fschmid 515
                {
8501 cbradney 516
                        Q3TextStream ts2(&BBox, QIODevice::ReadOnly);
6660 fschmid 517
                        ts2 >> x >> y >> b >> h;
518
                        h = h * gsRes / 72.0;
519
                        QStringList args;
520
                        xres = gsRes;
521
                        yres = gsRes;
7420 fschmid 522
                        if ((ext == "eps") || (ext == "epsi"))
6660 fschmid 523
                                args.append("-dEPSCrop");
524
                        args.append("-r"+QString::number(gsRes));
525
                        args.append("-sOutputFile="+tmpFile);
526
                        args.append(picFile);
527
                        int retg = callGS(args);
528
                        if (retg == 0)
5937 jghali 529
                        {
6660 fschmid 530
                                m_image.load(tmpFile);
531
                                m_image.setAlphaBuffer(true);
532
                                if (ScCore->havePNGAlpha() != 0)
5937 jghali 533
                                {
6660 fschmid 534
                                        int wi = m_image.width();
535
                                        int hi = m_image.height();
7175 fschmid 536
                                        QRgb alphaFF = qRgba(255,255,255,255);
537
                                        QRgb alpha00 = qRgba(255,255,255,  0);
538
                                        QRgb *s;
6660 fschmid 539
                                        for( int yi=0; yi < hi; ++yi )
5937 jghali 540
                                        {
7175 fschmid 541
                                                s = (QRgb*)(m_image.scanLine( yi ));
6660 fschmid 542
                                                for(int xi=0; xi < wi; ++xi )
543
                                                {
544
                                                        if((*s) == alphaFF)
545
                                                                (*s) &= alpha00;
546
                                                        s++;
547
                                                }
5937 jghali 548
                                        }
549
                                }
6660 fschmid 550
                                unlink(tmpFile);
7420 fschmid 551
                                if ((ext == "eps") || (ext == "epsi"))
6660 fschmid 552
                                {
553
                                        m_imageInfoRecord.BBoxX = static_cast<int>(x);
554
                                        m_imageInfoRecord.BBoxH = static_cast<int>(h);
555
                                }
556
                                else
557
                                {
558
                                        m_imageInfoRecord.BBoxX = 0;
559
                                        m_imageInfoRecord.BBoxH = m_image.height();
560
                                }
561
                                m_imageInfoRecord.xres = qRound(gsRes);
562
                                m_imageInfoRecord.yres = qRound(gsRes);
6664 fschmid 563
                                if ((m_imageInfoRecord.isEmbedded) && (m_profileComponents == 3))
564
                                        m_imageInfoRecord.type = 7;
6660 fschmid 565
                                m_imageInfoRecord.colorspace = 0;
566
                                m_image.setDotsPerMeterX ((int) (xres / 0.0254));
567
                                m_image.setDotsPerMeterY ((int) (yres / 0.0254));
5937 jghali 568
                        }
6660 fschmid 569
                }
6664 fschmid 570
                else
571
                {
8501 cbradney 572
                        Q3TextStream ts2(&BBox, QIODevice::ReadOnly);
6664 fschmid 573
                        ts2 >> x >> y >> b >> h;
574
                        h = h * gsRes / 72.0;
575
                        QStringList args;
576
                        xres = gsRes;
577
                        yres = gsRes;
7420 fschmid 578
                        if ((ext == "eps") || (ext == "epsi"))
6664 fschmid 579
                                args.append("-dEPSCrop");
580
                        args.append("-dGrayValues=256");
581
                        args.append("-r"+QString::number(gsRes));
582
                        args.append("-sOutputFile="+tmpFile);
583
                        args.append(picFile);
584
                        int retg = callGS(args, "bitcmyk");
585
                        if (retg == 0)
586
                        {
587
                                m_image.create( qRound(b * gsRes / 72.0), qRound(h * gsRes / 72.0), 32 );
6669 fschmid 588
                                m_image.fill(qRgba(0, 0, 0, 0));
6664 fschmid 589
                                int w = qRound(b * gsRes / 72.0);
590
                                int w2 = 4*w;
591
                                int h2 = qRound(h * gsRes / 72.0);
592
                                uint *p;
593
                                int cyan, magenta, yellow, black;
594
                                QByteArray imgc(w2);
595
                                QFile f(tmpFile);
8501 cbradney 596
                                if (f.open(QIODevice::ReadOnly))
6664 fschmid 597
                                {
598
                                        for (int y=0; y < h2; ++y )
599
                                        {
600
                                                p = (uint *)m_image.scanLine( y );
601
                                                f.readBlock(imgc.data(), w2);
602
                                                for (int x=0; x < w2; x += 4 )
603
                                                {
604
                                                        cyan = uchar(imgc[x]);
605
                                                        magenta = uchar(imgc[x + 1]);
606
                                                        yellow = uchar(imgc[x + 2]);
607
                                                        black = uchar(imgc[x + 3]);
608
                                                        *p = qRgba(cyan, magenta, yellow, black);
609
                                                        p++;
610
                                                }
611
                                        }
612
                                        f.close();
613
                                }
614
                                unlink(tmpFile);
7420 fschmid 615
                                if ((ext == "eps") || (ext == "epsi"))
6664 fschmid 616
                                {
617
                                        m_imageInfoRecord.BBoxX = static_cast<int>(x);
618
                                        m_imageInfoRecord.BBoxH = static_cast<int>(h);
619
                                }
620
                                else
621
                                {
622
                                        m_imageInfoRecord.BBoxX = 0;
623
                                        m_imageInfoRecord.BBoxH = m_image.height();
624
                                }
625
                                m_imageInfoRecord.xres = qRound(gsRes);
626
                                m_imageInfoRecord.yres = qRound(gsRes);
627
                                m_imageInfoRecord.colorspace = 1;
628
                                m_imageInfoRecord.type = 7;
629
                                m_image.setDotsPerMeterX ((int) (xres / 0.0254));
630
                                m_image.setDotsPerMeterY ((int) (yres / 0.0254));
631
                        }
632
                }
6660 fschmid 633
                return true;
634
        }
635
        return false;
636
}
637
 
6709 fschmid 638
void ScImgDataLoader_PS::loadPhotoshop(QString fn, int gsRes)
639
{
6763 fschmid 640
        if ((psDataType >= 1) && (psDataType <= 6) && ((psMode == 3) || (psMode == 4)))
6760 fschmid 641
        {
642
                loadPhotoshopBinary(fn);
643
                return;
644
        }
6709 fschmid 645
        QStringList args;
646
        double x, y, b, h;
647
        QFileInfo fi = QFileInfo(fn);
648
        QString ext = fi.extension(false).lower();
649
        QString tmpFile = QDir::convertSeparators(ScPaths::getTempFileDir() + "sc.png");
650
        int retg;
651
        int GsMajor;
652
        int GsMinor;
653
        getNumericGSVersion(GsMajor, GsMinor);
8501 cbradney 654
        Q3TextStream ts2(&BBox, QIODevice::ReadOnly);
6709 fschmid 655
        ts2 >> x >> y >> b >> h;
656
        h = h * gsRes / 72.0;
7420 fschmid 657
        if ((ext == "eps") || (ext == "epsi"))
6709 fschmid 658
                args.append("-dEPSCrop");
659
        if (psMode == 4)
660
                args.append("-dGrayValues=256");
661
        if ((GsMajor >= 8) && (GsMinor >= 53))
662
                args.append("-dNOPSICC");               // prevent GS from applying an embedded ICC profile as it will be applied later on in ScImage.
663
        args.append("-r"+QString::number(gsRes));
664
        args.append("-sOutputFile="+tmpFile);
665
        args.append(QDir::convertSeparators(fn));
666
        if (psMode == 4)
667
                retg = callGS(args, "bitcmyk");
668
        else
669
                retg = callGS(args);
670
        if (retg == 0)
671
        {
672
                if (psMode == 4)
673
                {
674
                        m_image.create( qRound(b * gsRes / 72.0), qRound(h * gsRes / 72.0), 32 );
675
                        m_image.fill(qRgba(0, 0, 0, 0));
676
                        int w = qRound(b * gsRes / 72.0);
677
                        int w2 = 4*w;
678
                        int h2 = qRound(h * gsRes / 72.0);
679
                        uint *p;
680
                        int cyan, magenta, yellow, black;
681
                        QByteArray imgc(w2);
682
                        QFile f(tmpFile);
8501 cbradney 683
                        if (f.open(QIODevice::ReadOnly))
6709 fschmid 684
                        {
685
                                for (int y=0; y < h2; ++y )
686
                                {
687
                                        p = (uint *)m_image.scanLine( y );
688
                                        f.readBlock(imgc.data(), w2);
689
                                        for (int x=0; x < w2; x += 4 )
690
                                        {
691
                                                cyan = uchar(imgc[x]);
692
                                                magenta = uchar(imgc[x + 1]);
693
                                                yellow = uchar(imgc[x + 2]);
694
                                                black = uchar(imgc[x + 3]);
695
                                                *p = qRgba(cyan, magenta, yellow, black);
696
                                                p++;
697
                                        }
698
                                }
699
                                f.close();
700
                        }
701
                        m_imageInfoRecord.colorspace = 1;
702
                        m_imageInfoRecord.type = 7;
703
                }
704
                else
705
                {
706
                        m_image.load(tmpFile);
707
                        m_image.setAlphaBuffer(true);
708
                        if (ScCore->havePNGAlpha() != 0)
709
                        {
710
                                int wi = m_image.width();
711
                                int hi = m_image.height();
7175 fschmid 712
                                QRgb alphaFF = qRgba(255,255,255,255);
713
                                QRgb alpha00 = qRgba(255,255,255,  0);
714
                                QRgb *s;
6709 fschmid 715
                                for( int yi=0; yi < hi; ++yi )
716
                                {
7175 fschmid 717
                                        s = (QRgb*)(m_image.scanLine( yi ));
6709 fschmid 718
                                        for(int xi=0; xi < wi; ++xi )
719
                                        {
720
                                                if((*s) == alphaFF)
721
                                                        (*s) &= alpha00;
722
                                                s++;
723
                                        }
724
                                }
725
                        }
726
                        m_imageInfoRecord.type = 7;
727
                        m_imageInfoRecord.colorspace = 0;
728
                }
729
                unlink(tmpFile);
7420 fschmid 730
                if ((ext == "eps") || (ext == "epsi"))
6709 fschmid 731
                {
732
                        m_imageInfoRecord.BBoxX = static_cast<int>(x);
733
                        m_imageInfoRecord.BBoxH = static_cast<int>(h);
734
                }
735
                else
736
                {
737
                        m_imageInfoRecord.BBoxX = 0;
738
                        m_imageInfoRecord.BBoxH = m_image.height();
739
                }
740
                m_image.setDotsPerMeterX ((int) (m_imageInfoRecord.xres / 0.0254));
741
                m_image.setDotsPerMeterY ((int) (m_imageInfoRecord.yres / 0.0254));
742
        }
743
}
744
 
6762 fschmid 745
void ScImgDataLoader_PS::decodeA85(QByteArray &psdata, QString tmp)
746
{
747
        uchar byte;
748
        ushort data;
749
        unsigned long sum = 0;
750
    int quintet = 0;
8569 jghali 751
        for (int c = 0; c < tmp.length(); c++)
6762 fschmid 752
        {
8569 jghali 753
                byte = QChar(tmp.at(c)).cell();
6762 fschmid 754
                if (byte >= '!' && byte <= 'u')
755
                {
756
                        sum = sum * 85 + ((unsigned long)byte - '!');
757
                        quintet++;
758
                        if (quintet == 5)
759
                        {
760
                                psdata.resize(psdata.size()+4);
761
                                data = sum >> 24;
762
                                psdata[psdata.size()-4] = data;
763
                                data = (sum >> 16) & 0xFF;
764
                                psdata[psdata.size()-3] = data;
765
                                data = (sum >> 8) & 0xFF;
766
                                psdata[psdata.size()-2] = data;
767
                                data = sum & 0xFF;
768
                                psdata[psdata.size()-1] = data;
769
                                quintet = 0;
770
                                sum = 0;
771
                }
772
                }
773
                else if (byte == 'z')
774
                {
775
                        psdata.resize(psdata.size()+4);
776
                        psdata[psdata.size()-4] = 0;
777
                        psdata[psdata.size()-3] = 0;
778
                        psdata[psdata.size()-2] = 0;
779
                        psdata[psdata.size()-1] = 0;
780
                }
781
                else if (byte == '~')
782
                {
783
                        if (quintet)
784
                        {
785
                                int i;
786
                                for (i = 0; i < 5 - quintet; i++)
787
                                        sum *= 85;
788
                                if (quintet > 1)
789
                                        sum += (0xFFFFFF >> ((quintet - 2) * 8));
790
                                for (i = 0; i < quintet - 1; i++)
791
                                {
792
                                        data = (sum >> (24 - 8 * i)) & 0xFF;
793
                                        psdata.resize(psdata.size()+1);
794
                                        psdata[psdata.size()-1] = data;
795
                                }
796
                                quintet = 0;
797
                        }
798
                        break;
799
                }
800
        }
801
}
802
 
803
typedef struct my_error_mgr
804
{
805
        struct jpeg_error_mgr pub;            /* "public" fields */
806
        jmp_buf setjmp_buffer;  /* for return to caller */
807
} *my_error_ptr;
808
 
809
static void my_error_exit (j_common_ptr cinfo)
810
{
811
        my_error_ptr myerr = (my_error_ptr) cinfo->err;
812
        (*cinfo->err->output_message) (cinfo);
813
        longjmp (myerr->setjmp_buffer, 1);
814
}
815
 
816
bool ScImgDataLoader_PS::loadPSjpeg(QString fn)
817
{
818
        if (!QFile::exists(fn))
819
                return false;
820
        struct jpeg_decompress_struct cinfo;
821
        struct my_error_mgr         jerr;
822
        FILE     *infile;
823
        cinfo.err = jpeg_std_error (&jerr.pub);
824
        jerr.pub.error_exit = my_error_exit;
825
        infile = NULL;
826
        if (setjmp (jerr.setjmp_buffer))
827
        {
828
                jpeg_destroy_decompress (&cinfo);
829
                if (infile)
830
                        fclose (infile);
831
                return false;
832
        }
833
        jpeg_create_decompress (&cinfo);
834
        if ((infile = fopen (fn.local8Bit(), "rb")) == NULL)
835
                return false;
836
        jpeg_stdio_src(&cinfo, infile);
837
        jpeg_read_header(&cinfo, true);
838
        jpeg_start_decompress(&cinfo);
839
        if ( cinfo.output_components == 3 || cinfo.output_components == 4)
840
                m_image.create( cinfo.output_width, cinfo.output_height, 32 );
841
        else if ( cinfo.output_components == 1 )
842
        {
843
                m_image.create( cinfo.output_width, cinfo.output_height, 8, 256 );
844
                for (int i=0; i<256; i++)
845
                        m_image.setColor(i, qRgb(i,i,i));
846
        }
847
        if (!m_image.isNull())
848
        {
849
                uchar** lines = m_image.jumpTable();
850
                while (cinfo.output_scanline < cinfo.output_height)
851
                        (void) jpeg_read_scanlines(&cinfo, lines + cinfo.output_scanline, cinfo.output_height);
852
                if ( cinfo.output_components == 3 )
853
                {
7175 fschmid 854
                        uchar *in;
855
                        QRgb *out;
6762 fschmid 856
                        for (uint j=0; j<cinfo.output_height; j++)
857
                        {
7175 fschmid 858
                                in = m_image.scanLine(j) + cinfo.output_width * 3;
859
                                out = (QRgb*) m_image.scanLine(j);
6762 fschmid 860
                                for (uint i=cinfo.output_width; i--; )
861
                                {
862
                                        in -= 3;
863
                                        out[i] = qRgb(in[0], in[1], in[2]);
864
                                }
865
                        }
866
                }
867
                if ( cinfo.output_components == 4 )
868
                {
7175 fschmid 869
                        QRgb *ptr;
870
                        unsigned char c, m, y ,k;
871
                        unsigned char *p;
6762 fschmid 872
                        for (int i = 0; i < m_image.height(); i++)
873
                        {
7175 fschmid 874
                                ptr = (QRgb*)  m_image.scanLine(i);
6762 fschmid 875
                                if ((cinfo.jpeg_color_space == JCS_YCCK) || ((cinfo.jpeg_color_space == JCS_CMYK) && (cinfo.saw_Adobe_marker)))
876
                                {
877
                                        for (int j = 0; j <  m_image.width(); j++)
878
                                        {
7175 fschmid 879
                                                p = (unsigned char *) ptr;
6762 fschmid 880
                                                c = p[0];
881
                                                m = p[1];
882
                                                y =  p[2];
883
                                                k =  p[3];
884
                                                *ptr = qRgba(c, m, y, k);
885
                                                ptr++;
886
                                        }
887
                                }
888
                                else
889
                                {
890
                                        for (int j = 0; j <  m_image.width(); j++)
891
                                        {
7175 fschmid 892
                                                p = (unsigned char *) ptr;
6762 fschmid 893
                                                c = p[0];
894
                                                m = p[1];
895
                                                y =  p[2];
896
                                                k =  p[3];
897
                                                *ptr = qRgba(y, m, c, k);
898
                                                ptr++;
899
                                        }
900
                                }
901
                        }
902
                }
903
                if ( cinfo.output_components == 1 )
904
                {
905
                        QImage tmpImg = m_image.convertDepth(32);
7175 fschmid 906
                        m_image.create( cinfo.output_width, cinfo.output_height, 32 );
907
                        QRgb *s;
908
                        QRgb *d;
6762 fschmid 909
                        for( int yi=0; yi < tmpImg.height(); ++yi )
910
                        {
7175 fschmid 911
                                s = (QRgb*)(tmpImg.scanLine( yi ));
912
                                d = (QRgb*)(m_image.scanLine( yi ));
6762 fschmid 913
                                for(int xi=0; xi < tmpImg.width(); ++xi )
914
                                {
915
                                        (*d) = (*s);
916
                                        s++;
917
                                        d++;
918
                                }
919
                        }
920
                }
921
                m_image.setAlphaBuffer(true);
922
        }
923
        (void) jpeg_finish_decompress(&cinfo);
924
        fclose (infile);
925
        jpeg_destroy_decompress (&cinfo);
926
        return (!m_image.isNull());
927
}
928
 
7195 fschmid 929
bool ScImgDataLoader_PS::loadPSjpeg(QString fn, QImage &tmpImg)
930
{
931
        if (!QFile::exists(fn))
932
                return false;
933
        struct jpeg_decompress_struct cinfo;
934
        struct my_error_mgr         jerr;
935
        FILE     *infile;
936
        cinfo.err = jpeg_std_error (&jerr.pub);
937
        jerr.pub.error_exit = my_error_exit;
938
        infile = NULL;
939
        if (setjmp (jerr.setjmp_buffer))
940
        {
941
                jpeg_destroy_decompress (&cinfo);
942
                if (infile)
943
                        fclose (infile);
944
                return false;
945
        }
946
        jpeg_create_decompress (&cinfo);
947
        if ((infile = fopen (fn.local8Bit(), "rb")) == NULL)
948
                return false;
949
        jpeg_stdio_src(&cinfo, infile);
950
        jpeg_read_header(&cinfo, true);
951
        jpeg_start_decompress(&cinfo);
952
        if ( cinfo.output_components == 3 || cinfo.output_components == 4)
953
                tmpImg.create( cinfo.output_width, cinfo.output_height, 32 );
954
        else if ( cinfo.output_components == 1 )
955
        {
956
                tmpImg.create( cinfo.output_width, cinfo.output_height, 8, 256 );
957
                for (int i=0; i<256; i++)
958
                        tmpImg.setColor(i, qRgb(i,i,i));
959
        }
960
        if (!tmpImg.isNull())
961
        {
962
                uchar** lines = tmpImg.jumpTable();
963
                while (cinfo.output_scanline < cinfo.output_height)
964
                        (void) jpeg_read_scanlines(&cinfo, lines + cinfo.output_scanline, cinfo.output_height);
965
                if ( cinfo.output_components == 3 )
966
                {
967
                        uchar *in;
968
                        QRgb *out;
969
                        for (uint j=0; j<cinfo.output_height; j++)
970
                        {
971
                                in = tmpImg.scanLine(j) + cinfo.output_width * 3;
972
                                out = (QRgb*) tmpImg.scanLine(j);
973
                                for (uint i=cinfo.output_width; i--; )
974
                                {
975
                                        in -= 3;
976
                                        out[i] = qRgb(in[0], in[1], in[2]);
977
                                }
978
                        }
979
                }
980
                if ( cinfo.output_components == 4 )
981
                {
982
                        QRgb *ptr;
983
                        unsigned char c, m, y ,k;
984
                        unsigned char *p;
985
                        for (int i = 0; i < tmpImg.height(); i++)
986
                        {
987
                                ptr = (QRgb*)  tmpImg.scanLine(i);
988
                                if ((cinfo.jpeg_color_space == JCS_YCCK) || ((cinfo.jpeg_color_space == JCS_CMYK) && (cinfo.saw_Adobe_marker)))
989
                                {
990
                                        for (int j = 0; j <  tmpImg.width(); j++)
991
                                        {
992
                                                p = (unsigned char *) ptr;
993
                                                c = p[0];
994
                                                m = p[1];
995
                                                y =  p[2];
996
                                                k =  p[3];
997
                                                *ptr = qRgba(c, m, y, k);
998
                                                ptr++;
999
                                        }
1000
                                }
1001
                                else
1002
                                {
1003
                                        for (int j = 0; j <  tmpImg.width(); j++)
1004
                                        {
1005
                                                p = (unsigned char *) ptr;
1006
                                                c = p[0];
1007
                                                m = p[1];
1008
                                                y =  p[2];
1009
                                                k =  p[3];
1010
                                                *ptr = qRgba(y, m, c, k);
1011
                                                ptr++;
1012
                                        }
1013
                                }
1014
                        }
1015
                }
1016
                if ( cinfo.output_components == 1 )
1017
                {
1018
                        QImage tmpImg2 = tmpImg.convertDepth(32);
1019
                        tmpImg.create( cinfo.output_width, cinfo.output_height, 32 );
1020
                        QRgb *s;
1021
                        QRgb *d;
1022
                        for( int yi=0; yi < tmpImg2.height(); ++yi )
1023
                        {
1024
                                s = (QRgb*)(tmpImg2.scanLine( yi ));
1025
                                d = (QRgb*)(tmpImg.scanLine( yi ));
1026
                                for(int xi=0; xi < tmpImg2.width(); ++xi )
1027
                                {
1028
                                        (*d) = (*s);
1029
                                        s++;
1030
                                        d++;
1031
                                }
1032
                        }
1033
                }
1034
                tmpImg.setAlphaBuffer(true);
1035
        }
1036
        (void) jpeg_finish_decompress(&cinfo);
1037
        fclose (infile);
1038
        jpeg_destroy_decompress (&cinfo);
1039
        return (!tmpImg.isNull());
1040
}
1041
 
6760 fschmid 1042
void ScImgDataLoader_PS::loadPhotoshopBinary(QString fn)
1043
{
7195 fschmid 1044
        double x, y, b, h;
8501 cbradney 1045
        Q3TextStream ts2(&BBox, QIODevice::ReadOnly);
7195 fschmid 1046
        ts2 >> x >> y >> b >> h;
6760 fschmid 1047
        QFileInfo fi = QFileInfo(fn);
1048
        QString ext = fi.extension(false).lower();
6762 fschmid 1049
        QString tmpFile = QDir::convertSeparators(ScPaths::getTempFileDir() + "sc.jpg");
1050
        QFile f2(tmpFile);
6760 fschmid 1051
        QString tmp;
1052
        m_image.create(psXSize, psYSize, 32);
1053
        m_image.fill(qRgba(0, 0, 0, 0));
7195 fschmid 1054
        m_imageInfoRecord.xres = qRound(psXSize / b * 72.0);
1055
        m_imageInfoRecord.yres = qRound(psYSize / h * 72.0);
6760 fschmid 1056
        QByteArray psdata;
1057
        QFile f(fn);
1058
        int yCount = 0;
8501 cbradney 1059
        if (f.open(QIODevice::ReadOnly))
6760 fschmid 1060
        {
6762 fschmid 1061
                if (psDataType > 2)
1062
                {
8501 cbradney 1063
                        f2.open(QIODevice::WriteOnly);
6762 fschmid 1064
                }
8501 cbradney 1065
                Q3TextStream ts(&f);
6760 fschmid 1066
                while (!ts.atEnd())
1067
                {
1068
                        tmp = ts.readLine();
1069
                        if (tmp == psCommand)
1070
                        {
1071
                                if (psDataType == 1)
1072
                                {
7175 fschmid 1073
                                        QRgb *p;
1074
                                        uchar cc, cm, cy, ck;
7211 fschmid 1075
                                        for (int yh = 0; yh < m_image.height(); ++yh )
6761 fschmid 1076
                                        {
1077
                                                if (psMode == 4)
1078
                                                        psdata.resize(psXSize * (4 + psChannel));
1079
                                                else
1080
                                                        psdata.resize(psXSize * (3 + psChannel));
1081
                                                f.readBlock(psdata.data(), psdata.size());
7211 fschmid 1082
                                                p = (QRgb *)m_image.scanLine( yh );
1083
                                                for (int xh = 0; xh < m_image.width(); ++xh )
6761 fschmid 1084
                                                {
7211 fschmid 1085
                                                        cc = psdata[xh];
1086
                                                        cm = psdata[psXSize+xh];
1087
                                                        cy = psdata[psXSize*2+xh];
1088
                                                        ck = psdata[psXSize*3+xh];
6761 fschmid 1089
                                                        if (psMode == 4)
1090
                                                                *p = qRgba(cc, cm, cy, ck);
1091
                                                        else
1092
                                                                *p = qRgba(cc, cm, cy, 255);
1093
                                                        p++;
1094
                                                }
1095
                                        }
6760 fschmid 1096
                                }
6762 fschmid 1097
                                else if (psDataType > 1)
6760 fschmid 1098
                                {
1099
                                        while (!ts.atEnd())
1100
                                        {
1101
                                                tmp = ts.readLine();
1102
                                                if ((tmp.isEmpty()) || (tmp.startsWith("%%EndBinary")))
1103
                                                        break;
6762 fschmid 1104
                                                if (psDataType == 2)
6760 fschmid 1105
                                                {
8569 jghali 1106
                                                        for (int a = 0; a < tmp.length(); a += 2)
6762 fschmid 1107
                                                        {
1108
                                                                bool ok;
1109
                                                                ushort data = tmp.mid(a, 2).toUShort(&ok, 16);
1110
                                                                psdata.resize(psdata.size()+1);
1111
                                                                psdata[psdata.size()-1] = data;
1112
                                                        }
6760 fschmid 1113
                                                }
6762 fschmid 1114
                                                else
1115
                                                {
1116
                                                        decodeA85(psdata, tmp);
1117
                                                        f2.writeBlock(psdata.data(), psdata.size());
1118
                                                        psdata.resize(0);
1119
                                                }
6760 fschmid 1120
                                        }
6762 fschmid 1121
                                        if (psDataType > 2)
6760 fschmid 1122
                                        {
6762 fschmid 1123
                                                f2.close();
1124
                                                loadPSjpeg(tmpFile);
1125
                                                unlink(tmpFile);
1126
                                        }
1127
                                        else
1128
                                        {
7175 fschmid 1129
                                                QRgb *p;
1130
                                                uchar cc, cm, cy, ck;
7211 fschmid 1131
                                                for (int yh = 0; yh < m_image.height(); ++yh )
6761 fschmid 1132
                                                {
7211 fschmid 1133
                                                        p = (QRgb *)m_image.scanLine( yh );
1134
                                                        for (int xh = 0; xh < m_image.width(); ++xh )
6762 fschmid 1135
                                                        {
7211 fschmid 1136
                                                                cc = psdata[yCount+xh];
1137
                                                                cm = psdata[yCount+psXSize+xh];
1138
                                                                cy = psdata[yCount+psXSize*2+xh];
6762 fschmid 1139
                                                                if (psMode == 4)
7211 fschmid 1140
                                                                {
1141
                                                                        ck = psdata[yCount+psXSize*3+xh];
6762 fschmid 1142
                                                                        *p = qRgba(cc, cm, cy, ck);
7211 fschmid 1143
                                                                }
6762 fschmid 1144
                                                                else
1145
                                                                        *p = qRgba(cc, cm, cy, 255);
1146
                                                                p++;
1147
                                                        }
6761 fschmid 1148
                                                        if (psMode == 4)
6762 fschmid 1149
                                                                yCount += psXSize * (4 + psChannel);
6761 fschmid 1150
                                                        else
6762 fschmid 1151
                                                                yCount += psXSize * (3 + psChannel);
6761 fschmid 1152
                                                }
6760 fschmid 1153
                                        }
1154
                                }
1155
                                if (psMode == 4)
1156
                                        m_imageInfoRecord.colorspace = 1;
1157
                                else
1158
                                        m_imageInfoRecord.colorspace = 0;
1159
                                m_imageInfoRecord.type = 7;
1160
                                m_imageInfoRecord.BBoxX = 0;
1161
                                m_imageInfoRecord.BBoxH = m_image.height();
1162
                                m_image.setDotsPerMeterX ((int) (m_imageInfoRecord.xres / 0.0254));
1163
                                m_image.setDotsPerMeterY ((int) (m_imageInfoRecord.yres / 0.0254));
7211 fschmid 1164
                                f.close();
1165
                                return;
6760 fschmid 1166
                        }
1167
                }
1168
                f.close();
1169
        }
1170
}
1171
 
7195 fschmid 1172
void ScImgDataLoader_PS::loadPhotoshopBinary(QString fn, QImage &tmpImg)
1173
{
1174
        double x, y, b, h;
8501 cbradney 1175
        Q3TextStream ts2(&BBox, QIODevice::ReadOnly);
7195 fschmid 1176
        ts2 >> x >> y >> b >> h;
1177
        QFileInfo fi = QFileInfo(fn);
1178
        QString ext = fi.extension(false).lower();
1179
        QString tmpFile = QDir::convertSeparators(ScPaths::getTempFileDir() + "sc.jpg");
1180
        QFile f2(tmpFile);
1181
        QString tmp;
1182
        tmpImg.create(psXSize, psYSize, 32);
1183
        tmpImg.fill(qRgba(0, 0, 0, 0));
1184
        QByteArray psdata;
1185
        QFile f(fn);
1186
        int yCount = 0;
8501 cbradney 1187
        if (f.open(QIODevice::ReadOnly))
7195 fschmid 1188
        {
1189
                if (psDataType > 2)
1190
                {
8501 cbradney 1191
                        f2.open(QIODevice::WriteOnly);
7195 fschmid 1192
                }
8501 cbradney 1193
                Q3TextStream ts(&f);
7195 fschmid 1194
                while (!ts.atEnd())
1195
                {
1196
                        tmp = ts.readLine();
1197
                        if (tmp == psCommand)
1198
                        {
1199
                                if (psDataType == 1)
1200
                                {
1201
                                        QRgb *p;
1202
                                        uchar cc, cm, cy, ck;
7211 fschmid 1203
                                        for (int yh = 0; yh < tmpImg.height(); ++yh )
7195 fschmid 1204
                                        {
1205
                                                if (psMode == 4)
1206
                                                        psdata.resize(psXSize * (4 + psChannel));
1207
                                                else
1208
                                                        psdata.resize(psXSize * (3 + psChannel));
1209
                                                f.readBlock(psdata.data(), psdata.size());
7211 fschmid 1210
                                                p = (QRgb *)tmpImg.scanLine( yh );
1211
                                                for (int xh = 0; xh < tmpImg.width(); ++xh )
7195 fschmid 1212
                                                {
7211 fschmid 1213
                                                        cc = psdata[xh];
1214
                                                        cm = psdata[psXSize+xh];
1215
                                                        cy = psdata[psXSize*2+xh];
7195 fschmid 1216
                                                        if (psMode == 4)
7211 fschmid 1217
                                                        {
1218
                                                                ck = psdata[psXSize*3+xh];
7195 fschmid 1219
                                                                *p = qRgba(cc, cm, cy, ck);
7211 fschmid 1220
                                                        }
7195 fschmid 1221
                                                        else
1222
                                                                *p = qRgba(cc, cm, cy, 255);
1223
                                                        p++;
1224
                                                }
1225
                                        }
1226
                                }
1227
                                else if (psDataType > 1)
1228
                                {
1229
                                        while (!ts.atEnd())
1230
                                        {
1231
                                                tmp = ts.readLine();
1232
                                                if ((tmp.isEmpty()) || (tmp.startsWith("%%EndBinary")))
1233
                                                        break;
1234
                                                if (psDataType == 2)
1235
                                                {
8569 jghali 1236
                                                        for (int a = 0; a < tmp.length(); a += 2)
7195 fschmid 1237
                                                        {
1238
                                                                bool ok;
1239
                                                                ushort data = tmp.mid(a, 2).toUShort(&ok, 16);
1240
                                                                psdata.resize(psdata.size()+1);
1241
                                                                psdata[psdata.size()-1] = data;
1242
                                                        }
1243
                                                }
1244
                                                else
1245
                                                {
1246
                                                        decodeA85(psdata, tmp);
1247
                                                        f2.writeBlock(psdata.data(), psdata.size());
1248
                                                        psdata.resize(0);
1249
                                                }
1250
                                        }
1251
                                        if (psDataType > 2)
1252
                                        {
1253
                                                f2.close();
1254
                                                loadPSjpeg(tmpFile, tmpImg);
1255
                                                unlink(tmpFile);
1256
                                        }
1257
                                        else
1258
                                        {
1259
                                                QRgb *p;
1260
                                                uchar cc, cm, cy, ck;
7211 fschmid 1261
                                                for (int yh = 0; yh < tmpImg.height(); ++yh )
7195 fschmid 1262
                                                {
7211 fschmid 1263
                                                        p = (QRgb *)tmpImg.scanLine( yh );
1264
                                                        for (int xh = 0; xh < tmpImg.width(); ++xh )
7195 fschmid 1265
                                                        {
7211 fschmid 1266
                                                                cc = psdata[yCount+xh];
1267
                                                                cm = psdata[yCount+psXSize+xh];
1268
                                                                cy = psdata[yCount+psXSize*2+xh];
7195 fschmid 1269
                                                                if (psMode == 4)
7211 fschmid 1270
                                                                {
1271
                                                                        ck = psdata[yCount+psXSize*3+xh];
7195 fschmid 1272
                                                                        *p = qRgba(cc, cm, cy, ck);
7211 fschmid 1273
                                                                }
7195 fschmid 1274
                                                                else
1275
                                                                        *p = qRgba(cc, cm, cy, 255);
1276
                                                                p++;
1277
                                                        }
1278
                                                        if (psMode == 4)
1279
                                                                yCount += psXSize * (4 + psChannel);
1280
                                                        else
1281
                                                                yCount += psXSize * (3 + psChannel);
1282
                                                }
1283
                                        }
1284
                                }
7211 fschmid 1285
                                f.close();
1286
                                return;
7195 fschmid 1287
                        }
1288
                }
1289
                f.close();
1290
        }
1291
}
1292
 
6669 fschmid 1293
void ScImgDataLoader_PS::loadDCS2(QString fn, int gsRes)
1294
{
1295
        QStringList args;
1296
        double x, y, b, h;
1297
        QFileInfo fi = QFileInfo(fn);
1298
        QString ext = fi.extension(false).lower();
1299
        QString tmpFile = QDir::convertSeparators(ScPaths::getTempFileDir() + "sc.png");
1300
        QString tmpFile2 = QDir::convertSeparators(ScPaths::getTempFileDir() + "tmp.eps");
6670 fschmid 1301
        QString baseFile = fi.dirPath(true);
6669 fschmid 1302
        QString picFile = QDir::convertSeparators(fn);
1303
        float xres = gsRes;
1304
        float yres = gsRes;
8501 cbradney 1305
        Q3TextStream ts2(&BBox, QIODevice::ReadOnly);
6669 fschmid 1306
        ts2 >> x >> y >> b >> h;
1307
        xres = gsRes;
1308
        yres = gsRes;
7195 fschmid 1309
        if ((isPhotoshop) && (hasPhotoshopImageData))
1310
        {
1311
                m_image.create(psXSize, psYSize, 32);
1312
                xres = psXSize / b * 72.0;
1313
                yres = psYSize / h * 72.0;
1314
        }
1315
        else
1316
                m_image.create( qRound(b * gsRes / 72.0), qRound(h * gsRes / 72.0), 32 );
6669 fschmid 1317
        m_image.fill(qRgba(0, 0, 0, 0));
6670 fschmid 1318
        if (!isDCS2multi)
6669 fschmid 1319
        {
6670 fschmid 1320
                for (QMap<QString, plateOffsets>::Iterator it = colorPlates2.begin(); it != colorPlates2.end(); ++it)
6669 fschmid 1321
                {
6670 fschmid 1322
                        QByteArray imgc(it.data().len);
1323
                        QFile f(picFile);
8501 cbradney 1324
                        if (f.open(QIODevice::ReadOnly))
6670 fschmid 1325
                        {
1326
                                f.at(it.data().pos);
1327
                                uint readB = f.readBlock(imgc.data(), it.data().len);
7980 fschmid 1328
                                readB = 0;
6670 fschmid 1329
                        }
1330
                        f.close();
1331
                        QFile f2(tmpFile2);
8501 cbradney 1332
                        if (f2.open(QIODevice::WriteOnly))
6670 fschmid 1333
                                f2.writeBlock(imgc.data(), it.data().len);
1334
                        f2.close();
1335
                        imgc.resize(0);
7195 fschmid 1336
                        if ((isPhotoshop) && (hasPhotoshopImageData))
6670 fschmid 1337
                        {
1338
                                QImage tmpImg;
7195 fschmid 1339
                                loadPhotoshopBinary(tmpFile2, tmpImg);
6670 fschmid 1340
                                blendImages(tmpImg, CustColors[it.key()]);
1341
                        }
7195 fschmid 1342
                        else
1343
                        {
1344
                                args.append("-dEPSCrop");
1345
                                args.append("-r"+QString::number(gsRes));
1346
                                args.append("-sOutputFile="+tmpFile);
1347
                                args.append(tmpFile2);
1348
                                int retg = callGS(args);
1349
                                if (retg == 0)
1350
                                {
1351
                                        QImage tmpImg;
1352
                                        tmpImg.load(tmpFile);
1353
                                        blendImages(tmpImg, CustColors[it.key()]);
1354
                                        unlink(tmpFile);
1355
                                }
1356
                        }
6670 fschmid 1357
                        unlink(tmpFile2);
6669 fschmid 1358
                }
6670 fschmid 1359
        }
1360
        else
1361
        {
1362
                for (QMap<QString, QString>::Iterator it = colorPlates.begin(); it != colorPlates.end(); ++it)
6669 fschmid 1363
                {
6670 fschmid 1364
                        tmpFile2 = QDir::convertSeparators(baseFile+"/"+it.data());
7195 fschmid 1365
                        if ((isPhotoshop) && (hasPhotoshopImageData))
6670 fschmid 1366
                        {
1367
                                QImage tmpImg;
7195 fschmid 1368
                                loadPhotoshopBinary(tmpFile2, tmpImg);
6670 fschmid 1369
                                blendImages(tmpImg, CustColors[it.key()]);
1370
                        }
7195 fschmid 1371
                        else
1372
                        {
1373
                                args.append("-dEPSCrop");
1374
                                args.append("-r"+QString::number(gsRes));
1375
                                args.append("-sOutputFile="+tmpFile);
1376
                                args.append(tmpFile2);
1377
                                int retg = callGS(args);
1378
                                if (retg == 0)
1379
                                {
1380
                                        QImage tmpImg;
1381
                                        tmpImg.load(tmpFile);
1382
                                        blendImages(tmpImg, CustColors[it.key()]);
1383
                                        unlink(tmpFile);
1384
                                }
1385
                                args.clear();
1386
                        }
6669 fschmid 1387
                }
1388
        }
7420 fschmid 1389
        if ((ext == "eps") || (ext == "epsi"))
6669 fschmid 1390
        {
1391
                m_imageInfoRecord.BBoxX = static_cast<int>(x);
1392
                m_imageInfoRecord.BBoxH = static_cast<int>(h);
1393
        }
1394
        else
1395
        {
1396
                m_imageInfoRecord.BBoxX = 0;
1397
                m_imageInfoRecord.BBoxH = m_image.height();
1398
        }
7195 fschmid 1399
        m_imageInfoRecord.xres = qRound(xres);
1400
        m_imageInfoRecord.yres = qRound(yres);
6669 fschmid 1401
        m_imageInfoRecord.colorspace = 1;
1402
        m_imageInfoRecord.type = 7;
1403
        m_image.setDotsPerMeterX ((int) (xres / 0.0254));
1404
        m_image.setDotsPerMeterY ((int) (yres / 0.0254));
1405
}
1406
 
6660 fschmid 1407
void ScImgDataLoader_PS::loadDCS1(QString fn, int gsRes)
1408
{
1409
        QStringList args;
1410
        double x, y, b, h;
1411
        QFileInfo fi = QFileInfo(fn);
1412
        QString ext = fi.extension(false).lower();
1413
        QString tmpFile = QDir::convertSeparators(ScPaths::getTempFileDir() + "sc.png");
1414
        QString baseFile = fi.dirPath(true);
1415
        QString picFile;
1416
        float xres = gsRes;
1417
        float yres = gsRes;
8501 cbradney 1418
        Q3TextStream ts2(&BBox, QIODevice::ReadOnly);
6660 fschmid 1419
        ts2 >> x >> y >> b >> h;
1420
        xres = gsRes;
1421
        yres = gsRes;
1422
        m_image.create( qRound(b * gsRes / 72.0), qRound(h * gsRes / 72.0), 32 );
6669 fschmid 1423
        m_image.fill(qRgba(0, 0, 0, 0));
7420 fschmid 1424
        if ((ext == "eps") || (ext == "epsi"))
6660 fschmid 1425
                args.append("-dEPSCrop");
1426
        args.append("-r"+QString::number(gsRes));
1427
        args.append("-sOutputFile="+tmpFile);
1428
        picFile = QDir::convertSeparators(baseFile+"/"+colorPlates["Cyan"]);
1429
        args.append(picFile);
1430
        int retg = callGS(args);
1431
        if (retg == 0)
1432
        {
1433
                QImage tmpImg;
1434
                tmpImg.load(tmpFile);
1435
                blendImages(tmpImg, ScColor(255, 0, 0, 0));
1436
                unlink(tmpFile);
1437
        }
1438
        args.clear();
1439
 
7420 fschmid 1440
        if ((ext == "eps") || (ext == "epsi"))
6660 fschmid 1441
                args.append("-dEPSCrop");
1442
        args.append("-r"+QString::number(gsRes));
1443
        args.append("-sOutputFile="+tmpFile);
1444
        picFile = QDir::convertSeparators(baseFile+"/"+colorPlates["Magenta"]);
1445
        args.append(picFile);
1446
        retg = callGS(args);
1447
        if (retg == 0)
1448
        {
1449
                QImage tmpImg;
1450
                tmpImg.load(tmpFile);
1451
                blendImages(tmpImg, ScColor(0, 255, 0, 0));
1452
                unlink(tmpFile);
1453
        }
1454
        args.clear();
1455
 
7420 fschmid 1456
        if ((ext == "eps") || (ext == "epsi"))
6660 fschmid 1457
                args.append("-dEPSCrop");
1458
        args.append("-r"+QString::number(gsRes));
1459
        args.append("-sOutputFile="+tmpFile);
1460
        picFile = QDir::convertSeparators(baseFile+"/"+colorPlates["Yellow"]);
1461
        args.append(picFile);
1462
        retg = callGS(args);
1463
        if (retg == 0)
1464
        {
1465
                QImage tmpImg;
1466
                tmpImg.load(tmpFile);
1467
                blendImages(tmpImg, ScColor(0, 0, 255, 0));
1468
                unlink(tmpFile);
1469
        }
1470
        args.clear();
1471
 
7420 fschmid 1472
        if ((ext == "eps") || (ext == "epsi"))
6660 fschmid 1473
                args.append("-dEPSCrop");
1474
        args.append("-r"+QString::number(gsRes));
1475
        args.append("-sOutputFile="+tmpFile);
1476
        picFile = QDir::convertSeparators(baseFile+"/"+colorPlates["Black"]);
1477
        args.append(picFile);
1478
        retg = callGS(args);
1479
        if (retg == 0)
1480
        {
1481
                QImage tmpImg;
1482
                tmpImg.load(tmpFile);
1483
                blendImages(tmpImg, ScColor(0, 0, 0, 255));
1484
                unlink(tmpFile);
1485
        }
1486
        args.clear();
1487
 
7420 fschmid 1488
        if ((ext == "eps") || (ext == "epsi"))
6660 fschmid 1489
        {
1490
                m_imageInfoRecord.BBoxX = static_cast<int>(x);
1491
                m_imageInfoRecord.BBoxH = static_cast<int>(h);
1492
        }
1493
        else
1494
        {
1495
                m_imageInfoRecord.BBoxX = 0;
1496
                m_imageInfoRecord.BBoxH = m_image.height();
1497
        }
1498
        m_imageInfoRecord.xres = qRound(gsRes);
1499
        m_imageInfoRecord.yres = qRound(gsRes);
1500
        m_imageInfoRecord.colorspace = 1;
1501
        m_imageInfoRecord.type = 7;
1502
        m_image.setDotsPerMeterX ((int) (xres / 0.0254));
1503
        m_image.setDotsPerMeterY ((int) (yres / 0.0254));
1504
}
1505
 
1506
void ScImgDataLoader_PS::blendImages(QImage &source, ScColor col)
1507
{
1508
        int h = source.height();
1509
        int w = source.width();
1510
        int cyan, c, m, yc, k, cc, mm, yy, kk;
1511
        col.getCMYK(&c, &m, &yc, &k);
7175 fschmid 1512
        QRgb *p;
1513
        QRgb *pq;
6660 fschmid 1514
        for (int y=0; y < h; ++y )
1515
        {
7175 fschmid 1516
                p = (QRgb *)m_image.scanLine( y );
1517
                pq = (QRgb *)source.scanLine( y );
6660 fschmid 1518
                for (int x=0; x < w; ++x )
1519
                {
1520
                        cyan = 255 - qRed(*pq);
1521
                        if (cyan != 0)
5937 jghali 1522
                        {
8562 jghali 1523
                                (c == 0) ? cc = qRed(*p) : cc = qMin(c * cyan / 255 + qRed(*p), 255);
1524
                                (m == 0) ? mm = qGreen(*p) : mm = qMin(m * cyan / 255 + qGreen(*p), 255);
1525
                                (yc == 0) ? yy = qBlue(*p) : yy = qMin(yc * cyan / 255 + qBlue(*p), 255);
1526
                                (k == 0) ? kk = qAlpha(*p) : kk = qMin(k * cyan / 255 + qAlpha(*p), 255);
6660 fschmid 1527
                                *p = qRgba(cc, mm, yy, kk);
5937 jghali 1528
                        }
6660 fschmid 1529
                        p++;
1530
                        pq++;
5937 jghali 1531
                }
1532
        }
1533
}
1534
 
1535
void ScImgDataLoader_PS::preloadAlphaChannel(const QString& fn, int gsRes)
1536
{
1537
        float xres, yres;
7980 fschmid 1538
//      short resolutionunit = 0;
5937 jghali 1539
        initialize();
1540
        QFileInfo fi = QFileInfo(fn);
1541
        if (!fi.exists())
1542
                return;
1543
        QString tmp, BBox, tmp2;
1544
        QString ext = fi.extension(false).lower();
1545
        QString tmpFile = QDir::convertSeparators(ScPaths::getTempFileDir() + "sc.png");
1546
        QString picFile = QDir::convertSeparators(fn);
1547
        double x, y, b, h;
1548
        bool found = false;
7980 fschmid 1549
//      int retg = -1;
5937 jghali 1550
        QChar tc;
1551
 
1552
        QFile f(fn);
8501 cbradney 1553
        if (f.open(QIODevice::ReadOnly))
5937 jghali 1554
        {
8501 cbradney 1555
                Q3TextStream ts(&f);
5937 jghali 1556
                while (!ts.atEnd())
1557
                {
1558
                        tc = ' ';
1559
                        tmp = "";
1560
                        while ((tc != '\n') && (tc != '\r'))
1561
                        {
1562
                                ts >> tc;
1563
                                if ((tc != '\n') && (tc != '\r'))
1564
                                        tmp += tc;
1565
                        }
1566
                        if (tmp.startsWith("%%BoundingBox:"))
1567
                        {
1568
                                found = true;
1569
                                BBox = tmp.remove("%%BoundingBox:");
1570
                        }
1571
                        if (!found)
1572
                        {
1573
                                if (tmp.startsWith("%%BoundingBox"))
1574
                                {
1575
                                        found = true;
1576
                                        BBox = tmp.remove("%%BoundingBox");
1577
                                }
1578
                        }
1579
                        if (tmp.startsWith("%%EndComments"))
1580
                                break;
1581
                }
1582
        }
1583
        f.close();
1584
        if (found)
1585
        {
8501 cbradney 1586
                Q3TextStream ts2(&BBox, QIODevice::ReadOnly);
5937 jghali 1587
                ts2 >> x >> y >> b >> h;
1588
                h = h * gsRes / 72.0;
1589
                QStringList args;
1590
                xres = gsRes;
1591
                yres = gsRes;
7420 fschmid 1592
                if ((ext == "eps") || (ext == "epsi"))
5937 jghali 1593
                        args.append("-dEPSCrop");
1594
                args.append("-r"+QString::number(gsRes));
1595
                args.append("-sOutputFile="+tmpFile);
1596
                args.append(picFile);
1597
                int retg = callGS(args);
1598
                if (retg == 0)
1599
                {
1600
                        m_image.load(tmpFile);
1601
                        m_image.setAlphaBuffer(true);
1602
                        if (ScCore->havePNGAlpha() != 0)
1603
                        {
1604
                                int wi = m_image.width();
1605
                                int hi = m_image.height();
7175 fschmid 1606
                                QRgb alphaFF = qRgba(255,255,255,255);
1607
                                QRgb alpha00 = qRgba(255,255,255,  0);
1608
                                QRgb *s;
5937 jghali 1609
                                for( int yi=0; yi < hi; ++yi )
1610
                                {
7175 fschmid 1611
                                        s = (QRgb*)(m_image.scanLine( yi ));
5937 jghali 1612
                                        for(int xi=0; xi < wi; ++xi )
1613
                                        {
1614
                                                if((*s) == alphaFF)
1615
                                                        (*s) &= alpha00;
1616
                                                s++;
1617
                                        }
1618
                                }
1619
                        }
1620
                        m_image.setAlphaBuffer(true);
1621
                        unlink(tmpFile);
1622
                }
1623
        }
1624
}