Subversion Repositories Scribus

Rev

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