Subversion Repositories Scribus

Rev

Rev 20752 | Rev 21555 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
6125 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
/***************************************************************************
8
                          util.cpp  -  description
9
                             -------------------
10
    begin                : Fri Sep 14 2001
11
    copyright            : (C) 2001 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
23
 
12461 avox 24
#include <QDomDocument>
25
#include <QPainter>
20185 craig 26
 
6795 jghali 27
#include "commonstrings.h"
12015 fschmid 28
#include "fileloader.h"
20185 craig 29
#include "iconmanager.h"
14792 fschmid 30
#include "loadsaveplugin.h"
12015 fschmid 31
#include "plugins/formatidlist.h"
20185 craig 32
#include "scclocale.h"
33
#include "sccolorengine.h"
34
#include "scconfig.h"
35
#include "scpixmapcache.h"
36
#include "scribusdoc.h"
37
#include "sctextstream.h"
20145 fschmid 38
#include "third_party/zip/scribus_zip.h"
6125 cbradney 39
#include "util.h"
20185 craig 40
#include "util_color.h"
12015 fschmid 41
#include "util_formats.h"
6125 cbradney 42
 
20185 craig 43
 
6795 jghali 44
using namespace std;
6125 cbradney 45
 
6795 jghali 46
void handleOldColorShade(ScribusDoc* doc, QString& colName, int& shade)
47
{
48
        int r, g, b;
49
        bool found = false;
8164 avox 50
        if( colName.isEmpty() || colName == CommonStrings::None || !doc->PageColors.contains(colName))
6795 jghali 51
                return;
8164 avox 52
 
53
        const ScColor& scCol1(doc->PageColors[colName]);
54
 
6795 jghali 55
        if( (shade == 100) || (scCol1.getColorModel() != colorModelRGB) )
56
                return;
57
        scCol1.getRGB(&r, &g, &b);
58
        QColor col1 = getOldColorShade(r, g, b, shade), col2;
59
        ColorList::Iterator it, itEnd = doc->PageColors.end();
60
        for( it = doc->PageColors.begin(); it != itEnd; it++)
61
        {
10516 cbradney 62
                if ( it.value().getColorModel() == colorModelRGB )
6795 jghali 63
                {
10516 cbradney 64
                        it.value().getRGB(&r, &g, &b);
7576 jghali 65
                        col2.setRgb(r, g, b);
66
                        if( col1 == col2 )
67
                        {
68
                                found = true;
69
                                break;
70
                        }
6795 jghali 71
                }
72
        }
73
        if(!found)
74
        {
75
                ScColor tmp;
76
                tmp.fromQColor(col1);
77
                colName = QString("%1 %2%").arg(colName).arg(shade);
78
                doc->PageColors.insert(colName, tmp);
79
        }
80
        else
81
                colName = it.key();
82
        shade = 100;
83
}
6125 cbradney 84
 
6795 jghali 85
QColor getOldColorShade(const QColor& color, int shade)
86
{
87
        int r, g, b;
88
        color.getRgb(&r, &g, &b);
89
        return getOldColorShade(r, g, b, shade);
90
}
6125 cbradney 91
 
9920 fschmid 92
QColor getOldColorShade(uchar red, uchar green, uchar blue, int shade)
6795 jghali 93
{
94
        int h, s, v, snew;
9948 jghali 95
        QColor color(red, green, blue);
10592 fschmid 96
        color.getHsv(&h, &s, &v);
6795 jghali 97
        if (red == green && green == blue)
98
        {
99
                snew = 255 - ((255 - v) * shade / 100);
100
                color.setHsv(h, s, snew);
101
        }
102
        else
103
        {
104
                snew = s * shade / 100;
105
                color.setHsv(h, snew, v);
106
        }
107
        return color;
108
}
6125 cbradney 109
 
110
QImage ProofImage(QImage *Image, ScribusDoc* doc)
111
{
112
        QImage out = Image->copy();
113
        bool cmsUse = doc ? doc->HasCMS : false;
114
        bool softProofing = doc ? doc->SoftProofing : false;
115
        if (cmsUse && softProofing)
116
        {
117
                int outheight=out.height();
118
                for (int i=0; i < outheight; ++i)
119
                {
14170 jghali 120
                        uchar* ptr = out.scanLine(i);
121
                        doc->stdProofImg.apply(ptr, ptr, out.width());
6125 cbradney 122
                }
123
        }
124
        else
125
        {
126
                if (cmsUse)
127
                {
128
                        int outheight=out.height();
129
                        for (int i=0; i < outheight; ++i)
130
                        {
14170 jghali 131
                                uchar* ptr = out.scanLine(i);
132
                                doc->stdTransImg.apply(ptr, ptr, out.width());
6125 cbradney 133
                        }
134
                }
135
        }
136
        return out;
137
}
138
 
139
QColor SetColor(ScribusDoc *currentDoc, QString color, int shad)
140
{
14139 fschmid 141
        if (color == CommonStrings::None)
142
                return QColor(0, 0, 0, 0);
7478 jghali 143
        const ScColor& col = currentDoc->PageColors[color];
144
        return ScColorEngine::getShadeColorProof(col, currentDoc, shad);
6125 cbradney 145
}
146
 
147
 
148
/**
149
 * QPixmaps are really slow with Qt/Mac 3.3.4. Really, *really*, slow.
150
 * So we better cache them.
151
 */
152
QPixmap * getSmallPixmap(QColor rgb)
153
{
154
        static ScPixmapCache<QRgb> pxCache;
155
 
156
        QRgb index=rgb.rgb();
157
        if (pxCache.contains(index))
158
                return pxCache[index];
159
 
160
        QPixmap *pm = new QPixmap(15, 15);
161
        pm->fill(rgb);
162
        QPainter p;
163
        p.begin(pm);
164
        p.setBrush(Qt::NoBrush);
165
        QPen b(Qt::black, 1);
166
        p.setPen(b);
167
        p.drawRect(0, 0, 15, 15);
168
        p.end();
169
        pxCache.insert(index, pm);
170
        return pm;
171
}
172
 
173
QPixmap * getWidePixmap(QColor rgb)
174
{
175
        static ScPixmapCache<QRgb> pxCache;
176
 
177
        QRgb index=rgb.rgb();
178
        if (pxCache.contains(index))
179
                return pxCache[index];
180
 
181
        QPixmap *pm = new QPixmap(30, 15);
182
        pm->fill(rgb);
183
        pxCache.insert(index, pm);
184
        return pm;
185
}
186
 
20145 fschmid 187
static quint64 code64(const ScColor & col)
188
{
189
        int C = 0;
190
        int M = 0;
191
        int Y = 0;
192
        int K = 0;
193
        int R = 0;
194
        int G = 0;
195
        int B = 0;
196
        quint64 result = 0;
15599 fschmid 197
        if (col.getColorModel() == colorModelRGB)
198
        {
199
                col.getRGB( &R, &G, &B );
200
                QColor color = QColor(R, G, B);
201
                color.getCmyk(&C, &M, &Y, &K);
202
        }
20145 fschmid 203
        else if (col.getColorModel() == colorModelCMYK)
15599 fschmid 204
        {
205
                col.getCMYK( &C, &M, &Y, &K );
206
                R = 255-qMin(255, C + K);
207
                G = 255-qMin(255, M + K);
208
                B = 255-qMin(255, Y + K);
209
        }
20145 fschmid 210
        else
211
        {
212
                double L, a, b;
213
                col.getLab(&L, &a, &b);
214
                R = qRound(L);
21039 jghali 215
                G = qRound(a + 128);
216
                B = qRound(b + 128);
20145 fschmid 217
        }
6125 cbradney 218
        result |= col.getColorModel() == colorModelRGB ? 1 : 0;
7478 jghali 219
        result |= col.isSpotColor() ? 64 : 0;
220
        result |= col.isRegistrationColor() ? 32 : 0;
6125 cbradney 221
        result <<= 8;
222
        result |= C;
223
        result <<= 8;
224
        result |= M;
225
        result <<= 8;
226
        result |= Y;
227
        result <<= 8;
228
        result |= K;
229
        result <<= 8;
230
        result |= R;
231
        result <<= 8;
232
        result |= G;
233
        result <<= 8;
234
        result |= B;
235
        return result;
236
}
237
 
20145 fschmid 238
QPixmap * getFancyPixmap(const ScColor& col, ScribusDoc* doc)
239
{
10592 fschmid 240
        static ScPixmapCache<quint64> pxCache;
6125 cbradney 241
 
242
        static QPixmap alertIcon;
243
        static QPixmap cmykIcon;
244
        static QPixmap rgbIcon;
20145 fschmid 245
        static QPixmap labIcon;
6125 cbradney 246
        static QPixmap spotIcon;
247
        static QPixmap regIcon;
248
        static bool iconsInitialized = false;
249
 
20145 fschmid 250
        if ( !iconsInitialized )
251
        {
20185 craig 252
                IconManager* im=IconManager::instance();
253
                alertIcon = im->loadPixmap("alert.png");
254
                cmykIcon = im->loadPixmap("cmyk.png");
255
                rgbIcon = im->loadPixmap("rgb.png");
256
                labIcon = im->loadPixmap("lab.png");
257
                spotIcon = im->loadPixmap("spot.png");
258
                regIcon = im->loadPixmap("register.png");
6125 cbradney 259
                iconsInitialized = true;
260
        }
261
 
20145 fschmid 262
        quint64 res = code64(col);
6125 cbradney 263
        if (pxCache.contains(res))
264
                return pxCache[res];
265
 
20145 fschmid 266
        QPixmap *pa = new QPixmap(60, 15);
267
        QPixmap *pm = getSmallPixmap(ScColorEngine::getDisplayColor(col, doc));
15599 fschmid 268
//      QPixmap *pm=getSmallPixmap(col.getRawRGBColor());
6125 cbradney 269
        pa->fill(Qt::white);
270
        paintAlert(*pm, *pa, 0, 0);
7478 jghali 271
        if (ScColorEngine::isOutOfGamut(col, doc))
6125 cbradney 272
                paintAlert(alertIcon, *pa, 15, 0);
15719 fschmid 273
        if (col.getColorModel() == colorModelCMYK)   // || (col.isSpotColor()))
6125 cbradney 274
                paintAlert(cmykIcon, *pa, 30, 0);
20145 fschmid 275
        else if (col.getColorModel() == colorModelRGB)
6125 cbradney 276
                paintAlert(rgbIcon, *pa, 30, 0);
20145 fschmid 277
        else if (col.getColorModel() == colorModelLab)
278
                paintAlert(labIcon, *pa, 30, 0);
6125 cbradney 279
        if (col.isSpotColor())
280
                paintAlert(spotIcon, *pa, 46, 2);
281
        if (col.isRegistrationColor())
282
                paintAlert(regIcon, *pa, 45, 0);
283
        pxCache.insert(res, pa);
284
        return pa;
285
}
286
 
287
 
288
void paintAlert(QPixmap &toPaint, QPixmap &target, int x, int y, bool useMask)
289
{
290
        // there is no alpha mask in the beginning
10592 fschmid 291
//      if (useMask)
292
//      {
293
//              if (target.mask().isNull())
294
//                      target.setMask(QBitmap(target.width(), target.height(), useMask));
295
//      }
6125 cbradney 296
        QPainter p;
297
        p.begin(&target);
298
        p.drawPixmap(x, y, toPaint);
299
        if (useMask)
300
        {
8538 subik 301
// Qt4 FIXME: Qt4 can use better alpha setting. see colorlistbox.cpp
302
//              QPainter alpha; // transparency handling
303
//              alpha.begin(target.mask());
304
//              alpha.setBrush(Qt::color1);
305
//              alpha.setPen(Qt::color1);
306
//              alpha.drawRect(x, y, 15, 15);
307
//              if (!toPaint.mask().isNull())
308
//                      alpha.drawPixmap(x, y, toPaint.mask());
309
//              alpha.end();
6125 cbradney 310
        }
311
        p.end();
312
}
313
 
314
unsigned char INT_MULT ( unsigned char a, unsigned char b )
315
{
316
        int c = a * b + 0x80;
317
        return (unsigned char)(( ( c >> 8 ) + c ) >> 8);
318
}
319
 
320
void RGBTOHSV ( uchar& red, uchar& green, uchar& blue )
321
{
322
        int r, g, b;
323
        double h, s, v;
324
        int min, max;
325
        h = 0.;
326
        r = red;
327
        g = green;
328
        b = blue;
329
        if ( r > g )
330
        {
8562 jghali 331
                max = qMax( r, b );
332
                min = qMin( g, b );
6125 cbradney 333
        }
334
        else
335
        {
8562 jghali 336
                max = qMax( g, b );
337
                min = qMin( r, b );
6125 cbradney 338
        }
339
        v = max;
340
        if ( max != 0 )
341
                s = ( ( max - min ) * 255 ) / (double)max;
342
        else
343
                s = 0;
344
        if ( s == 0 )
345
                h = 0;
346
        else
347
        {
348
                int delta = max - min;
349
                if ( r == max )
350
                        h = ( g - b ) / (double)delta;
351
                else if ( g == max )
352
                        h = 2 + ( b - r ) / (double)delta;
353
                else if ( b == max )
354
                        h = 4 + ( r - g ) / (double)delta;
355
                h *= 42.5;
356
                if ( h < 0 )
357
                        h += 255;
358
                if ( h > 255 )
359
                        h -= 255;
360
        }
361
        red   = (uchar)h;
362
        green = (uchar)s;
363
        blue  = (uchar)v;
364
}
365
 
366
void HSVTORGB ( uchar& hue, uchar& saturation, uchar& value )
367
{
368
        if ( saturation == 0 )
369
        {
370
                hue        = value;
371
                saturation = value;
20026 avox 372
                /* value   = value;*/
6125 cbradney 373
        }
374
        else
375
        {
376
                double h = hue * 6. / 255.;
377
                double s = saturation / 255.;
378
                double v = value / 255.;
379
 
380
                double f = h - (int)h;
381
                double p = v * ( 1. - s );
382
                double q = v * ( 1. - ( s * f ) );
383
                double t = v * ( 1. - ( s * ( 1. - f ) ) );
384
                // Worth a note here that gcc 2.96 will generate different results
385
                // depending on optimization mode on i386.
386
                switch ((int)h)
387
                {
388
                case 0:
389
                        hue        = (uchar)( v * 255 );
390
                        saturation = (uchar)( t * 255 );
391
                        value      = (uchar)( p * 255 );
392
                        break;
393
                case 1:
394
                        hue        = (uchar)( q * 255 );
395
                        saturation = (uchar)( v * 255 );
396
                        value      = (uchar)( p * 255 );
397
                        break;
398
                case 2:
399
                        hue        = (uchar)( p * 255 );
400
                        saturation = (uchar)( v * 255 );
401
                        value      = (uchar)( t * 255 );
402
                        break;
403
                case 3:
404
                        hue        = (uchar)( p * 255 );
405
                        saturation = (uchar)( q * 255 );
406
                        value      = (uchar)( v * 255 );
407
                        break;
408
                case 4:
409
                        hue        = (uchar)( t * 255 );
410
                        saturation = (uchar)( p * 255 );
411
                        value      = (uchar)( v * 255 );
412
                        break;
413
                case 5:
414
                        hue        = (uchar)( v * 255 );
415
                        saturation = (uchar)( p * 255 );
416
                        value      = (uchar)( q * 255 );
417
                }
418
        }
419
}
420
 
421
void RGBTOHLS ( uchar& red, uchar& green, uchar& blue )
422
{
8027 fschmid 423
        double var_R = ( red / 255.0 );
424
        double var_G = ( green / 255.0 );
425
        double var_B = ( blue / 255.0 );
8562 jghali 426
        double var_Min = qMin( var_R, qMin(var_G, var_B) );    //Min. value of RGB
427
        double var_Max = qMax( var_R, qMax(var_G, var_B) );    //Max. value of RGB
8027 fschmid 428
        double del_Max = var_Max - var_Min;             //Delta RGB value
429
        double L = ( var_Max + var_Min ) / 2.0;
430
        double H = 0;
431
        double S = 0;
432
        double del_R = 0;
433
        double del_G = 0;
434
        double del_B = 0;
435
        if ( del_Max == 0 )
6125 cbradney 436
        {
8027 fschmid 437
                H = 0;
438
                S = 0;
6125 cbradney 439
        }
440
        else
441
        {
8027 fschmid 442
                if ( L < 0.5 )
443
                        S = del_Max / ( var_Max + var_Min );
6125 cbradney 444
                else
8027 fschmid 445
                        S = del_Max / ( 2 - var_Max - var_Min );
446
                del_R = ( ( ( var_Max - var_R ) / 6.0 ) + ( del_Max / 2.0 ) ) / del_Max;
447
                del_G = ( ( ( var_Max - var_G ) / 6.0 ) + ( del_Max / 2.0 ) ) / del_Max;
448
                del_B = ( ( ( var_Max - var_B ) / 6.0 ) + ( del_Max / 2.0 ) ) / del_Max;
449
                if ( var_R == var_Max )
450
                        H = del_B - del_G;
451
           else if ( var_G == var_Max )
452
                        H = ( 1.0 / 3.0 ) + del_R - del_B;
453
                else if ( var_B == var_Max )
454
                        H = ( 2.0 / 3.0 ) + del_G - del_R;
455
                if ( H < 0 )
456
                        H += 1;
457
                if ( H > 1 )
458
                        H -= 1;
6125 cbradney 459
        }
8027 fschmid 460
        red = qRound(H * 255);
461
        green = qRound(L * 255);
462
        blue = qRound(S * 255);
6125 cbradney 463
}
464
 
8027 fschmid 465
double HLSVALUE ( double n1, double n2, double hue )
6125 cbradney 466
{
8027 fschmid 467
        if ( hue < 0 )
468
                hue += 1;
469
        if ( hue > 1 )
470
                hue -= 1;
471
        if ( ( 6 * hue ) < 1 )
472
                return n1 + ( n2 - n1 ) * 6 * hue;
473
        if ( ( 2 * hue ) < 1 )
474
                return n2;
475
        if ( ( 3 * hue ) < 2 )
476
                return n1 + ( n2 - n1 ) * ( ( 2.0 / 3.0 ) - hue ) * 6;
477
        return n1;
6125 cbradney 478
}
479
 
480
void HLSTORGB ( uchar& hue, uchar& lightness, uchar& saturation )
481
{
8027 fschmid 482
        double H = ( hue / 255.0 );
483
        double L = ( lightness / 255.0 );
484
        double S = ( saturation / 255.0 );
485
        if (S == 0)
6125 cbradney 486
        {
8027 fschmid 487
                hue = qRound(255 * L);
488
                saturation = qRound(255 * L);
489
                return;
6125 cbradney 490
        }
8027 fschmid 491
        double var_1 = 0;
492
        double var_2 = 0;
493
        if ( L < 0.5 )
494
                var_2 = L * ( 1 + S );
6125 cbradney 495
        else
8027 fschmid 496
                var_2 = ( L + S ) - ( S * L );
497
        var_1 = 2 * L - var_2;
498
        hue = qRound(255 * HLSVALUE( var_1, var_2, H + ( 1.0 / 3.0 ) ));
499
        lightness = qRound(255 * HLSVALUE( var_1, var_2, H ));
500
        saturation = qRound(255 * HLSVALUE( var_1, var_2, H - ( 1.0 / 3.0 ) ));
6125 cbradney 501
}
502
 
6193 fschmid 503
double getCurveYValue(FPointArray &curve, double x, bool linear)
6125 cbradney 504
{
505
    double t;
506
    FPoint p;
507
    FPoint p0,p1,p2,p3;
508
    double c0,c1,c2,c3;
509
    double val = 0.5;
510
    if(curve.size() == 0)
511
        return 0.5;
512
    // First find curve segment
513
    p = curve.point(0);
514
    if(x < p.x())
515
        return p.y();
516
    p = curve.point(curve.size()-1);
517
    if(x >= p.x())
518
        return p.y();
18114 jghali 519
        int cc = 0;
6125 cbradney 520
    // Find the four control points (two on each side of x)    
521
    p = curve.point(0);
522
    while(x >= p.x())
523
    {
524
                cc++;
525
        p = curve.point(cc);
526
    }
527
    if (cc > 1)
528
    {
529
        p0 = curve.point(cc-2);
530
        p1 = curve.point(cc-1);
531
    }
532
    else
533
        p1 = p0 = curve.point(0);
534
    p2 = p;
535
    if (cc < curve.size()-1)
536
        p3 = curve.point(cc+1);
537
    else
538
        p3 = p;
539
    // Calculate the value
6193 fschmid 540
        if (linear)
541
        {
542
                double mc;
543
                if (p1.x() - p2.x() != 0.0)
544
                        mc = (p1.y() - p2.y()) / (p1.x() - p2.x());
545
                else
546
                        mc = p2.y() / p2.x();
547
                val = (x - p1.x()) * mc + p1.y();
548
        }
549
        else
550
        {
551
                t = (x - p1.x()) / (p2.x() - p1.x());
552
                c2 = (p2.y() - p0.y()) * (p2.x()-p1.x()) / (p2.x()-p0.x());
553
                c3 = p1.y();
554
                c0 = -2*p2.y() + 2*c3 + c2 + (p3.y() - p1.y()) * (p2.x() - p1.x()) / (p3.x() - p1.x());
555
                c1 = p2.y() - c3 - c2 - c0;
556
                val = ((c0*t + c1)*t + c2)*t + c3;
557
        }
558
        if(val < 0.0)
559
                val = 0.0;
560
        if(val > 1.0)
561
                val = 1.0;
562
        return val;
6125 cbradney 563
}
564
 
8018 fschmid 565
double Lum(uchar red, uchar green, uchar blue)
566
{
567
        return 0.3 * (red / 255.0) + 0.59 * (green / 255.0) + 0.11 * (blue / 255.0);
568
}
569
 
570
double LumD(double red, double green, double blue)
571
{
572
        return 0.3 * red + 0.59 * green + 0.11 * blue;
573
}
574
 
575
void setLum(uchar& red, uchar& green, uchar& blue, double lum)
576
{
577
        double rP = (red / 255.0);
578
        double gP = (green / 255.0);
579
        double bP = (blue / 255.0);
580
        double d = lum - Lum(red, green, blue);
581
        rP += d;
582
        gP += d;
583
        bP += d;
584
        clipColor(rP, gP, bP);
585
        red = qRound(rP * 255);
586
        green = qRound(gP * 255);
587
        blue = qRound(bP * 255);
588
        return;
589
}
590
 
591
void clipColor(double& red, double& green, double& blue)
592
{
593
        double l = LumD(red, green, blue);
8562 jghali 594
        double n = qMin(red, qMin(green, blue));
595
        double x = qMax(red, qMax(green, blue));
8018 fschmid 596
        if (n < 0.0)
597
        {
598
                red = l + (((red - l) * l) / (l - n));
599
                green = l + (((green - l) * l) / (l - n));
600
                blue = l + (((blue - l) * l) / (l - n));
601
        }
602
        if (x > 1.0)
603
        {
604
                red = l + (((red - l) * (1.0 - l)) / (x - l));
605
                green = l + (((green - l) * (1.0 - l)) / (x - l));
606
                blue = l + (((blue - l) * (1.0 - l)) / (x - l));
607
        }
608
}
10121 cbradney 609
 
610
QString colorSpaceText(int cs)
611
{
612
        if (cs==0)
613
                return CommonStrings::trRGB;
614
        if (cs==1)
615
                return CommonStrings::trCMYK;
616
        if (cs==2)
617
                return CommonStrings::trGrayscale;
618
        if (cs==3)
619
                return CommonStrings::trDuotone;
17758 jghali 620
        if (cs==4)
621
                return CommonStrings::trMonochrome;
10121 cbradney 622
        return CommonStrings::trUnknownCS;
623
}
12015 fschmid 624
 
17400 fschmid 625
bool importColorsFromFile(QString fileName, ColorList &EditColors, QHash<QString, VGradient> *dialogGradients, bool merge)
12015 fschmid 626
{
627
        int oldCount = EditColors.count();
628
        if (!fileName.isEmpty())
629
        {
630
                QFileInfo fi = QFileInfo(fileName);
631
                QString ext = fi.suffix().toLower();
14792 fschmid 632
                if (extensionIndicatesEPSorPS(ext))
12015 fschmid 633
                {
634
                        QString tmp, tmp2, FarNam;
635
                        double c, m, y, k;
636
                        ScColor cc;
637
                        QFile f(fileName);
638
                        if (f.open(QIODevice::ReadOnly))
639
                        {
640
                                bool isAtend = false;
641
                                QDataStream ts(&f);
642
                                while (!ts.atEnd())
643
                                {
644
                                        tmp = readLinefromDataStream(ts);
645
                                        if ((tmp.startsWith("%%CMYKCustomColor")) || (tmp.startsWith("%%CMYKProcessColor")))
646
                                        {
647
                                                if (tmp.contains("(atend)"))
648
                                                        isAtend = true;
649
                                                else
650
                                                {
651
                                                        if (tmp.startsWith("%%CMYKCustomColor"))
652
                                                                tmp = tmp.remove(0,18);
653
                                                        else if (tmp.startsWith("%%CMYKProcessColor"))
654
                                                                tmp = tmp.remove(0,19);
13497 jghali 655
                                                        ScTextStream ts2(&tmp, QIODevice::ReadOnly);
12015 fschmid 656
                                                        ts2 >> c >> m >> y >> k;
657
                                                        FarNam = ts2.readAll();
658
                                                        FarNam = FarNam.trimmed();
659
                                                        FarNam = FarNam.remove(0,1);
660
                                                        FarNam = FarNam.remove(FarNam.length()-1,1);
661
                                                        FarNam = FarNam.simplified();
12086 fschmid 662
                                                        cc = ScColor(qRound(255 * c), qRound(255 * m), qRound(255 * y), qRound(255 * k));
12015 fschmid 663
                                                        cc.setSpotColor(true);
15771 fschmid 664
                                                        if (!FarNam.isEmpty())
665
                                                                EditColors.tryAddColor(FarNam, cc);
12015 fschmid 666
                                                        while (!ts.atEnd())
667
                                                        {
668
                                                                quint64 oldPos = ts.device()->pos();
669
                                                                tmp = readLinefromDataStream(ts);
670
                                                                if (!tmp.startsWith("%%+"))
671
                                                                {
672
                                                                        ts.device()->seek(oldPos);
673
                                                                        break;
674
                                                                }
675
                                                                tmp = tmp.remove(0,3);
13497 jghali 676
                                                                ScTextStream ts2(&tmp, QIODevice::ReadOnly);
12015 fschmid 677
                                                                ts2 >> c >> m >> y >> k;
678
                                                                FarNam = ts2.readAll();
679
                                                                FarNam = FarNam.trimmed();
680
                                                                FarNam = FarNam.remove(0,1);
681
                                                                FarNam = FarNam.remove(FarNam.length()-1,1);
682
                                                                FarNam = FarNam.simplified();
12086 fschmid 683
                                                                cc = ScColor(qRound(255 * c), qRound(255 * m), qRound(255 * y), qRound(255 * k));
12015 fschmid 684
                                                                cc.setSpotColor(true);
15771 fschmid 685
                                                                if (!FarNam.isEmpty())
686
                                                                        EditColors.tryAddColor(FarNam, cc);
12015 fschmid 687
                                                        }
688
                                                }
689
                                        }
14791 fschmid 690
                                        if ((tmp.startsWith("%%RGBCustomColor")) || (tmp.startsWith("%%RGBProcessColor")))
12015 fschmid 691
                                        {
692
                                                if (tmp.contains("(atend)"))
693
                                                        isAtend = true;
694
                                                else
695
                                                {
14791 fschmid 696
                                                        if (tmp.startsWith("%%RGBCustomColor"))
697
                                                                tmp = tmp.remove(0,17);
698
                                                        else if (tmp.startsWith("%%RGBProcessColor"))
699
                                                                tmp = tmp.remove(0,18);
13497 jghali 700
                                                        ScTextStream ts2(&tmp, QIODevice::ReadOnly);
12015 fschmid 701
                                                        ts2 >> c >> m >> y;
702
                                                        FarNam = ts2.readAll();
703
                                                        FarNam = FarNam.trimmed();
704
                                                        FarNam = FarNam.remove(0,1);
705
                                                        FarNam = FarNam.remove(FarNam.length()-1,1);
706
                                                        FarNam = FarNam.simplified();
12086 fschmid 707
                                                        cc = ScColor(qRound(255 * c), qRound(255 * m), qRound(255 * y));
15771 fschmid 708
                                                        if (!FarNam.isEmpty())
709
                                                                EditColors.tryAddColor(FarNam, cc);
12015 fschmid 710
                                                        while (!ts.atEnd())
711
                                                        {
712
                                                                quint64 oldPos = ts.device()->pos();
713
                                                                tmp = readLinefromDataStream(ts);
714
                                                                if (!tmp.startsWith("%%+"))
715
                                                                {
716
                                                                        ts.device()->seek(oldPos);
717
                                                                        break;
718
                                                                }
719
                                                                tmp = tmp.remove(0,3);
13497 jghali 720
                                                                ScTextStream ts2(&tmp, QIODevice::ReadOnly);
12015 fschmid 721
                                                                ts2 >> c >> m >> y;
722
                                                                FarNam = ts2.readAll();
723
                                                                FarNam = FarNam.trimmed();
724
                                                                FarNam = FarNam.remove(0,1);
725
                                                                FarNam = FarNam.remove(FarNam.length()-1,1);
726
                                                                FarNam = FarNam.simplified();
12086 fschmid 727
                                                                cc = ScColor(qRound(255 * c), qRound(255 * m), qRound(255 * y));
15771 fschmid 728
                                                                if (!FarNam.isEmpty())
729
                                                                        EditColors.tryAddColor(FarNam, cc);
12015 fschmid 730
                                                        }
731
                                                }
732
                                        }
733
                                        if (tmp.startsWith("%%EndComments"))
734
                                        {
735
                                                if (!isAtend)
736
                                                        break;
737
                                        }
738
                                }
739
                                f.close();
740
                        }
741
                }
742
                else
743
                {
14792 fschmid 744
                        QStringList allFormatsV = LoadSavePlugin::getExtensionsForColors();
745
                        if (allFormatsV.contains(ext))
12015 fschmid 746
                        {
14792 fschmid 747
                                FileLoader fl(fileName);
17326 jghali 748
                                int testResult = fl.testFile();
14792 fschmid 749
                                if (testResult != -1)
12015 fschmid 750
                                {
14792 fschmid 751
                                        ColorList LColors;
17326 jghali 752
                                        if (fl.readColors(LColors))
12015 fschmid 753
                                        {
14792 fschmid 754
                                                ColorList::Iterator it;
755
                                                for (it = LColors.begin(); it != LColors.end(); ++it)
756
                                                {
15771 fschmid 757
                                                        EditColors.tryAddColor(it.key(), it.value());
14792 fschmid 758
                                                }
18688 fschmid 759
                                                return (EditColors.count() != oldCount);
12015 fschmid 760
                                        }
761
                                }
762
                        }
18688 fschmid 763
                        if (ext == "acb")                       // Adobe color book format
15758 fschmid 764
                        {
765
                                QFile fiC(fileName);
766
                                if (fiC.open(QIODevice::ReadOnly))
767
                                {
768
                                        ScColor lf = ScColor();
769
                                        quint16 vers = 0;
770
                                        quint32 signature;
771
                                        QDataStream ts(&fiC);
772
                                        ts.setByteOrder(QDataStream::BigEndian);
773
                                        ts >> signature;
774
                                        ts >> vers;
775
                                        if ((signature == 0x38424342) && (vers == 1))
776
                                        {
777
                                                quint16 vendor, numcolors, colType;
778
                                                ts >> vendor;
779
                                                QString title           = readAdobeUniCodeString(ts);
780
                                                QString prefix          = readAdobeUniCodeString(ts);
781
                                                QString postfix         = readAdobeUniCodeString(ts);
782
                                                QString description     = readAdobeUniCodeString(ts);
783
                                                ts >> numcolors;
784
                                                ts.skipRawData(4);
785
                                                ts >> colType;
786
                                                for (quint16 cc = 0; cc < numcolors; cc++)
787
                                                {
788
                                                        QString name = readAdobeUniCodeString(ts);
789
                                                        if (vendor == 3000)
790
                                                                name.prepend("ANPA");
791
                                                        else if (vendor == 3001)
792
                                                                name.prepend("Focoltone");
793
                                                        else if (vendor == 3002)
794
                                                                name.prepend("PantoneCoated");
795
                                                        else if (vendor == 3003)
796
                                                                name.prepend("PantoneProcess");
797
                                                        else if (vendor == 3004)
798
                                                                name.prepend("PantoneProSlim");
799
                                                        else if (vendor == 3005)
800
                                                                name.prepend("PantoneUncoated");
801
                                                        else if (vendor == 3006)
802
                                                                name.prepend("Toyo");
803
                                                        else if (vendor == 3007)
804
                                                                name.prepend("Trumatch");
805
                                                        else if (vendor == 3008)
806
                                                                name.prepend("HKSE");
807
                                                        else if (vendor == 3009)
808
                                                                name.prepend("HKSK");
809
                                                        else if (vendor == 3010)
810
                                                                name.prepend("HKSN");
811
                                                        else if (vendor == 3011)
812
                                                                name.prepend("HKSZ");
813
                                                        else if (vendor == 3012)
814
                                                                name.prepend("DIC");
815
                                                        else if (vendor == 3020)
816
                                                                name.prepend("PantonePastelCoated");
817
                                                        else if (vendor == 3021)
818
                                                                name.prepend("PantonePastelUncoated");
819
                                                        else if (vendor == 3022)
820
                                                                name.prepend("PantoneMetallic");
821
                                                        ts.skipRawData(6);
822
                                                        quint8 componentR, componentG, componentB, componentK;
823
                                                        ts >> componentR >> componentG >> componentB;
824
                                                        if (colType == 2)
825
                                                                ts >> componentK;
826
                                                        if (!name.isEmpty())
827
                                                        {
828
                                                                bool validColor = false;
829
                                                                if (colType == 0)                       // RBG
830
                                                                {
831
                                                                        lf.setColorRGB(componentR, componentG, componentB);
832
                                                                        validColor = true;
833
                                                                }
834
                                                                else if (colType == 2)          // CMYK
835
                                                                {
836
                                                                        lf.setColor(255 - componentR, 255 - componentG, 255 - componentB, 255 - componentK);
837
                                                                        validColor = true;
838
                                                                }
839
                                                                if (validColor)
840
                                                                {
841
                                                                        lf.setSpotColor(false);
842
                                                                        lf.setRegistrationColor(false);
15771 fschmid 843
                                                                        EditColors.tryAddColor(name, lf);
15758 fschmid 844
                                                                }
845
                                                        }
846
                                                }
15770 fschmid 847
                                                fiC.close();
15758 fschmid 848
                                        }
15770 fschmid 849
                                        else                                    // try AutoCAD XML format
850
                                        {
851
                                                fiC.close();
852
                                                QByteArray docBytes("");
853
                                                loadRawText(fileName, docBytes);
854
                                                QString docText("");
855
                                                docText = QString::fromUtf8(docBytes);
856
                                                QDomDocument docu("scridoc");
857
                                                if (!docu.setContent(docText))
858
                                                        return false;
859
                                                QDomElement elem = docu.documentElement();
860
                                                QDomNode PAGE = elem.firstChild();
861
                                                while(!PAGE.isNull())
862
                                                {
863
                                                        QDomElement pg = PAGE.toElement();
864
                                                        if (pg.tagName() == "colorPage")
865
                                                        {
866
                                                                QDomNode colNode = pg.firstChild();
867
                                                                while(!colNode.isNull())
868
                                                                {
869
                                                                        QDomElement cg = colNode.toElement();
870
                                                                        if (cg.tagName() == "colorEntry")
871
                                                                        {
20752 jghali 872
                                                                                int r (0), g(0), b(0);
15770 fschmid 873
                                                                                QString colorName = "";
874
                                                                                QDomNode colEntry = cg.firstChild();
875
                                                                                while(!colEntry.isNull())
876
                                                                                {
877
                                                                                        QDomElement cc = colEntry.toElement();
878
                                                                                        if (cc.tagName() == "colorName")
879
                                                                                                colorName = cc.text();
880
                                                                                        else if (cc.tagName() == "RGB8")
881
                                                                                        {
882
                                                                                                QDomNode colVal = cc.firstChild();
883
                                                                                                while(!colVal.isNull())
884
                                                                                                {
885
                                                                                                        QDomElement cv = colVal.toElement();
886
                                                                                                        if (cv.tagName() == "red")
887
                                                                                                                r = cv.text().toInt();
888
                                                                                                        else if (cv.tagName() == "green")
889
                                                                                                                g = cv.text().toInt();
890
                                                                                                        else if (cv.tagName() == "blue")
891
                                                                                                                b = cv.text().toInt();
892
                                                                                                        colVal = colVal.nextSibling();
893
                                                                                                }
894
                                                                                        }
895
                                                                                        colEntry = colEntry.nextSibling();
896
                                                                                }
897
                                                                                if (!colorName.isEmpty())
898
                                                                                {
899
                                                                                        lf.setColorRGB(r, g, b);
900
                                                                                        lf.setSpotColor(false);
901
                                                                                        lf.setRegistrationColor(false);
15771 fschmid 902
                                                                                        EditColors.tryAddColor(colorName, lf);
15770 fschmid 903
                                                                                }
904
                                                                        }
905
                                                                        colNode = colNode.nextSibling();
906
                                                                }
907
                                                        }
908
                                                        PAGE = PAGE.nextSibling();
909
                                                }
910
                                        }
15758 fschmid 911
                                }
912
                        }
15750 fschmid 913
                        else if (ext == "aco")                  // Adobe color swatch format
914
                        {
915
                                QFile fiC(fileName);
916
                                if (fiC.open(QIODevice::ReadOnly))
917
                                {
918
                                        ScColor lf = ScColor();
919
                                        QDataStream ts(&fiC);
920
                                        ts.setByteOrder(QDataStream::BigEndian);
921
                                        quint16 vers = 0;
922
                                        ts >> vers;
923
                                        if (vers == 1)
924
                                        {
925
                                                quint16 count1 = 0;
926
                                                quint16 count2 = 0;
927
                                                ts >> count1;
19972 fschmid 928
                                                qint64 pos = ts.device()->pos();
929
                                                if (pos + count1 * 10 < fiC.size())
15750 fschmid 930
                                                {
19972 fschmid 931
                                                        ts.skipRawData(count1 * 10);
932
                                                        ts >> vers >> count2;
933
                                                        if ((vers == 2) && (count1 == count2))
15750 fschmid 934
                                                        {
19972 fschmid 935
                                                                for (quint16 cc = 0; cc < count2; cc++)
936
                                                                {
937
                                                                        quint16 colType;
938
                                                                        quint16 componentR, componentG, componentB, componentK;
939
                                                                        ts >> colType >> componentR >> componentG >> componentB >> componentK;
940
                                                                        QString name = readAdobeUniCodeString(ts);
941
                                                                        if (!name.isEmpty())
942
                                                                        {
943
                                                                                bool validColor = false;
944
                                                                                if (colType == 0)                       // RBG
945
                                                                                {
946
                                                                                        lf.setColorRGB(componentR >> 8, componentG >> 8, componentB >> 8);
947
                                                                                        validColor = true;
948
                                                                                }
949
                                                                                else if (colType == 1)          // HSB
950
                                                                                {
951
                                                                                        uchar hc, sc, bc;
952
                                                                                        hc = componentR >> 8;
953
                                                                                        sc = componentG >> 8;
954
                                                                                        bc = componentB >> 8;
955
                                                                                        HSVTORGB(hc, sc, bc);
956
                                                                                        lf.setColorRGB(hc, sc, bc);
957
                                                                                        validColor = true;
958
                                                                                }
959
                                                                                else if (colType == 2)          // CMYK
960
                                                                                {
961
                                                                                        lf.setColor(255 - (componentR >> 8), 255 - (componentG >> 8), 255 - (componentB >> 8), 255 - (componentK >> 8));
962
                                                                                        validColor = true;
963
                                                                                }
964
                                                                                else if (colType == 8)          // Grayscale
965
                                                                                {
966
                                                                                        lf.setColor(0, 0, 0, qRound((componentK / 10000.0) * 255));
967
                                                                                        validColor = true;
968
                                                                                }
969
                                                                                if (validColor)
970
                                                                                {
971
                                                                                        lf.setSpotColor(false);
972
                                                                                        lf.setRegistrationColor(false);
973
                                                                                        EditColors.tryAddColor(name, lf);
974
                                                                                }
975
                                                                        }
976
                                                                }
977
                                                        }
978
                                                }
979
                                                else
980
                                                {
981
                                                        QFileInfo fiCinf(fileName);
982
                                                        QString baseName = fiCinf.baseName();
983
                                                        baseName.replace(" ", "_");
984
                                                        for (quint16 cc = 0; cc < count1; cc++)
985
                                                        {
15750 fschmid 986
                                                                quint16 colType;
987
                                                                quint16 componentR, componentG, componentB, componentK;
988
                                                                ts >> colType >> componentR >> componentG >> componentB >> componentK;
19972 fschmid 989
                                                                bool validColor = false;
990
                                                                if (colType == 0)                       // RBG
15750 fschmid 991
                                                                {
19972 fschmid 992
                                                                        lf.setColorRGB(componentR >> 8, componentG >> 8, componentB >> 8);
993
                                                                        validColor = true;
15750 fschmid 994
                                                                }
19972 fschmid 995
                                                                else if (colType == 1)          // HSB
996
                                                                {
997
                                                                        uchar hc, sc, bc;
998
                                                                        hc = componentR >> 8;
999
                                                                        sc = componentG >> 8;
1000
                                                                        bc = componentB >> 8;
1001
                                                                        HSVTORGB(hc, sc, bc);
1002
                                                                        lf.setColorRGB(hc, sc, bc);
1003
                                                                        validColor = true;
1004
                                                                }
1005
                                                                else if (colType == 2)          // CMYK
1006
                                                                {
1007
                                                                        lf.setColor(255 - (componentR >> 8), 255 - (componentG >> 8), 255 - (componentB >> 8), 255 - (componentK >> 8));
1008
                                                                        validColor = true;
1009
                                                                }
1010
                                                                else if (colType == 8)          // Grayscale
1011
                                                                {
1012
                                                                        lf.setColor(0, 0, 0, qRound((componentK / 10000.0) * 255));
1013
                                                                        validColor = true;
1014
                                                                }
1015
                                                                if (validColor)
1016
                                                                {
1017
                                                                        lf.setSpotColor(false);
1018
                                                                        lf.setRegistrationColor(false);
1019
                                                                        QString name = baseName+lf.name().toUpper();
1020
                                                                        EditColors.tryAddColor(name, lf);
1021
                                                                }
15750 fschmid 1022
                                                        }
1023
                                                }
1024
                                        }
1025
                                        fiC.close();
1026
                                }
1027
                        }
20162 fschmid 1028
                        else if (ext == "ase")                  // Adobe swatch exchange format
1029
                        {
1030
                                QFile fiC(fileName);
1031
                                if (fiC.open(QIODevice::ReadOnly))
1032
                                {
1033
                                        ScColor lf = ScColor();
1034
                                        QDataStream ts(&fiC);
1035
                                        ts.setByteOrder(QDataStream::BigEndian);
1036
                                        ts.setFloatingPointPrecision(QDataStream::SinglePrecision);
1037
                                        quint16 vers1 = 0;
1038
                                        quint16 vers2 = 0;
1039
                                        quint32 signature;
1040
                                        ts >> signature;
1041
                                        ts >> vers1 >> vers2;
1042
                                        if ((signature == 0x41534546) && (vers1 == 1) && (vers2 == 0))
1043
                                        {
1044
                                                QString blockName;
1045
                                                quint32 numBlocks;
1046
                                                ts >> numBlocks;
1047
                                                for (quint32 n = 0; n < numBlocks; n++)
1048
                                                {
1049
                                                        quint16 blockType;
1050
                                                        quint32 blockLen;
1051
                                                        ts >> blockType;
1052
                                                        ts >> blockLen;
1053
                                                        if (blockType == 0xC001)
1054
                                                                blockName = readAdobeUniCodeString16(ts);
1055
                                                        else if (blockType == 0x0001)
1056
                                                        {
1057
                                                                if (blockName.isEmpty())
1058
                                                                        blockName = fi.baseName();
1059
                                                                QString Cname = readAdobeUniCodeString16(ts);
1060
                                                                quint32 clrType;
1061
                                                                quint16 spotMode;
1062
                                                                ts >> clrType;
1063
                                                                if (clrType == 0x52474220)              // RGB
1064
                                                                {
1065
                                                                        float r, g, b;
1066
                                                                        ts >> r >> g >> b;
1067
                                                                        ts >> spotMode;
1068
                                                                        lf.setColorRGB(qRound(255 * r), qRound(255 * g), qRound(255 * b));
20163 fschmid 1069
                                                                        lf.setSpotColor(spotMode == 1);
20162 fschmid 1070
                                                                        lf.setRegistrationColor(false);
1071
                                                                        if (Cname.isEmpty())
1072
                                                                        {
1073
                                                                                Cname = blockName + QString("#%1%2%3").arg(qRound(255 * r),2,16,QChar('0')).arg(qRound(255 * g),2,16,QChar('0')).arg(qRound(255 * b),2,16,QChar('0')).toUpper();
1074
                                                                                Cname.replace(" ","_");
1075
                                                                        }
1076
                                                                        EditColors.tryAddColor(Cname, lf);
1077
                                                                }
1078
                                                                else if (clrType == 0x434D594B) // CMYK
1079
                                                                {
1080
                                                                        float c, m, y, k;
1081
                                                                        ts >> c >> m >> y >> k;
1082
                                                                        ts >> spotMode;
1083
                                                                        lf.setColor(qRound(255 * c), qRound(255 * m), qRound(255 * y), qRound(255 * k));
20163 fschmid 1084
                                                                        lf.setSpotColor(spotMode == 1);
20162 fschmid 1085
                                                                        lf.setRegistrationColor(false);
1086
                                                                        if (Cname.isEmpty())
1087
                                                                        {
1088
                                                                                Cname = blockName + QString("#%1%2%3%4").arg(qRound(255 * c),2,16,QChar('0')).arg(qRound(255 * m),2,16,QChar('0')).arg(qRound(255 * y),2,16,QChar('0')).arg(qRound(255 * k),2,16,QChar('0')).toUpper();
1089
                                                                                Cname.replace(" ","_");
1090
                                                                        }
1091
                                                                        EditColors.tryAddColor(Cname, lf);
1092
                                                                }
1093
                                                                else if (clrType == 0x47726179) // Gray
1094
                                                                {
1095
                                                                        float g;
1096
                                                                        ts >> g;
1097
                                                                        ts >> spotMode;
1098
                                                                        lf.setColor(0, 0, 0, qRound(255 * g));
20163 fschmid 1099
                                                                        lf.setSpotColor(spotMode == 1);
20162 fschmid 1100
                                                                        lf.setRegistrationColor(false);
1101
                                                                        if (Cname.isEmpty())
1102
                                                                        {
1103
                                                                                Cname = blockName + QString("#000000%1").arg(qRound(255 * g),2,16,QChar('0')).toUpper();
1104
                                                                                Cname.replace(" ","_");
1105
                                                                        }
1106
                                                                        EditColors.tryAddColor(Cname, lf);
1107
                                                                }
1108
                                                                else if (clrType == 0x4C414220) // Lab
1109
                                                                {
1110
                                                                        float L, a, b;
1111
                                                                        ts >> L >> a >> b;
1112
                                                                        ts >> spotMode;
1113
                                                                        lf.setColor(L * 100.0, a, b);
20163 fschmid 1114
                                                                        lf.setSpotColor(spotMode == 1);
20162 fschmid 1115
                                                                        lf.setRegistrationColor(false);
1116
                                                                        if (Cname.isEmpty())
1117
                                                                        {
1118
                                                                                Cname = blockName + QString("_%1_%2_%3").arg(qRound(L * 100)).arg(qRound(a)).arg(qRound(b));
1119
                                                                                Cname.replace(" ","_");
1120
                                                                        }
1121
                                                                        EditColors.tryAddColor(Cname, lf);
1122
                                                                }
1123
                                                        }
1124
                                                }
1125
                                        }
1126
                                        fiC.close();
1127
                                }
1128
                        }
15709 fschmid 1129
                        else if (ext == "skp")                  // Sk1 palette
12015 fschmid 1130
                        {
1131
                                QFile fiC(fileName);
1132
                                if (fiC.open(QIODevice::ReadOnly))
1133
                                {
15709 fschmid 1134
                                        bool isCMYK = false;
1135
                                        QByteArray docBytes("");
1136
                                        loadRawText(fileName, docBytes);
1137
                                        QString docText("");
1138
                                        docText = QString::fromUtf8(docBytes);
1139
                                        QDomDocument docu("scridoc");
1140
                                        docu.setContent(docText);
1141
                                        ScColor lf = ScColor();
1142
                                        QDomElement elem = docu.documentElement();
1143
                                        QDomNode PAGE = elem.firstChild();
1144
                                        while(!PAGE.isNull())
1145
                                        {
1146
                                                QDomElement pg = PAGE.toElement();
1147
                                                if(pg.tagName() == "description")
1148
                                                {
1149
                                                        if (pg.attribute("type", "") == "CMYK")
1150
                                                                isCMYK = true;
1151
                                                }
1152
                                                if(pg.tagName() == "color")
1153
                                                {
1154
                                                        QString Cname;
1155
                                                        if (isCMYK)
1156
                                                        {
1157
                                                                double c, m, y, k;
1158
                                                                c = pg.attribute("c", "0").toDouble();
1159
                                                                m = pg.attribute("m", "0").toDouble();
1160
                                                                y = pg.attribute("y", "0").toDouble();
1161
                                                                k = pg.attribute("k", "0").toDouble();
1162
                                                                Cname = pg.attribute("name", "");
1163
                                                                if (!Cname.isEmpty())
1164
                                                                {
1165
                                                                        lf.setColor(qRound(255 * c), qRound(255 * m), qRound(255 * y), qRound(255 * k));
1166
                                                                        lf.setSpotColor(false);
1167
                                                                        lf.setRegistrationColor(false);
15771 fschmid 1168
                                                                        EditColors.tryAddColor(Cname, lf);
15709 fschmid 1169
                                                                }
1170
                                                        }
1171
                                                        else
1172
                                                        {
1173
                                                                double r, g, b;
1174
                                                                r = pg.attribute("r", "0").toDouble();
1175
                                                                g = pg.attribute("g", "0").toDouble();
1176
                                                                b = pg.attribute("b", "0").toDouble();
1177
                                                                Cname = pg.attribute("name", "");
1178
                                                                if (!Cname.isEmpty())
1179
                                                                {
1180
                                                                        lf.setColorRGB(qRound(255 * r), qRound(255 * g), qRound(255 * b));
1181
                                                                        lf.setSpotColor(false);
1182
                                                                        lf.setRegistrationColor(false);
15771 fschmid 1183
                                                                        EditColors.tryAddColor(Cname, lf);
15709 fschmid 1184
                                                                }
1185
                                                        }
1186
                                                }
1187
                                                PAGE=PAGE.nextSibling();
1188
                                        }
1189
                                }
1190
                                fiC.close();
1191
                        }
20145 fschmid 1192
                        else if (ext == "sbz")
1193
                        {
1194
                                ScZipHandler *uz = new ScZipHandler();
1195
                                if (uz->open(fileName))
1196
                                {
1197
                                        if (uz->contains("swatchbook.xml"))
1198
                                        {
1199
                                                QByteArray docBytes;
1200
                                                if (uz->read("swatchbook.xml", docBytes))
1201
                                                {
1202
                                                        QString docText("");
1203
                                                        docText = QString::fromUtf8(docBytes);
1204
                                                        QDomDocument docu("scridoc");
1205
                                                        if (docu.setContent(docText))
1206
                                                        {
1207
                                                                QDomElement docElem = docu.documentElement();
1208
                                                                for(QDomElement drawPag = docElem.firstChildElement(); !drawPag.isNull(); drawPag = drawPag.nextSiblingElement())
1209
                                                                {
1210
                                                                        if (drawPag.tagName() == "materials")
1211
                                                                        {
1212
                                                                                for(QDomElement spf = drawPag.firstChildElement(); !spf.isNull(); spf = spf.nextSiblingElement() )
1213
                                                                                {
1214
                                                                                        if (spf.tagName() == "color")
1215
                                                                                        {
1216
                                                                                                bool isSpot = spf.attribute("usage") == "spot";
1217
                                                                                                QString colorName = "";
1218
                                                                                                ScColor tmp;
1219
                                                                                                tmp.setRegistrationColor(false);
1220
                                                                                                for(QDomElement spp = spf.firstChildElement(); !spp.isNull(); spp = spp.nextSiblingElement() )
1221
                                                                                                {
1222
                                                                                                        if (spp.tagName() == "metadata")
1223
                                                                                                        {
1224
                                                                                                                for(QDomElement spm = spp.firstChildElement(); !spm.isNull(); spm = spm.nextSiblingElement() )
1225
                                                                                                                {
1226
                                                                                                                        if (spm.tagName() == "dc:identifier")
1227
                                                                                                                                colorName = spm.text();
1228
                                                                                                                }
1229
                                                                                                        }
1230
                                                                                                        else if (spp.tagName() == "values")
1231
                                                                                                        {
1232
                                                                                                                QString colorVals = spp.text();
1233
                                                                                                                ScTextStream CoE(&colorVals, QIODevice::ReadOnly);
1234
                                                                                                                if (spp.attribute("model") == "Lab")
1235
                                                                                                                {
1236
                                                                                                                        double inC[3];
1237
                                                                                                                        CoE >> inC[0];
1238
                                                                                                                        CoE >> inC[1];
1239
                                                                                                                        CoE >> inC[2];
1240
                                                                                                                        tmp.setColor(inC[0], inC[1], inC[2]);
1241
                                                                                                                        tmp.setSpotColor(isSpot);
1242
                                                                                                                }
1243
                                                                                                                else if (spp.attribute("model") == "CMYK")
1244
                                                                                                                {
1245
                                                                                                                        double c, m, y, k;
1246
                                                                                                                        CoE >> c >> m >> y >> k;
1247
                                                                                                                        tmp.setColor(qRound(255 * c), qRound(255 * m), qRound(255 * y), qRound(255 * k));
1248
                                                                                                                        tmp.setSpotColor(isSpot);
1249
                                                                                                                }
1250
                                                                                                                else if (spp.attribute("model") == "RGB")
1251
                                                                                                                {
1252
                                                                                                                        double r, g, b;
1253
                                                                                                                        CoE >> r >> g >> b;
1254
                                                                                                                        tmp.setColorRGB(qRound(255 * r), qRound(255 * g), qRound(255 * b));
1255
                                                                                                                        tmp.setSpotColor(false);
1256
                                                                                                                }
1257
                                                                                                        }
1258
                                                                                                }
1259
                                                                                                if (!colorName.isEmpty())
1260
                                                                                                        EditColors.tryAddColor(colorName, tmp);
1261
                                                                                        }
1262
                                                                                }
1263
                                                                        }
1264
                                                                }
1265
                                                        }
1266
                                                }
1267
                                        }
1268
                                }
1269
                                delete uz;
1270
                        }
15709 fschmid 1271
                        else                                                    // try for OpenOffice, Viva and our own format
1272
                        {
1273
                                QFile fiC(fileName);
1274
                                if (fiC.open(QIODevice::ReadOnly))
1275
                                {
12015 fschmid 1276
                                        QString ColorEn, Cname;
1277
                                        int Rval, Gval, Bval, Kval;
13497 jghali 1278
                                        ScTextStream tsC(&fiC);
12015 fschmid 1279
                                        ColorEn = tsC.readLine();
1280
                                        bool cus = false;
1281
                                        if (ColorEn.contains("OpenOffice"))
1282
                                                cus = true;
13837 fschmid 1283
                                        if ((ColorEn.startsWith("<?xml version=")) || (ColorEn.contains("VivaColors")))
12015 fschmid 1284
                                        {
1285
                                                QByteArray docBytes("");
1286
                                                loadRawText(fileName, docBytes);
1287
                                                QString docText("");
1288
                                                docText = QString::fromUtf8(docBytes);
1289
                                                QDomDocument docu("scridoc");
1290
                                                docu.setContent(docText);
1291
                                                ScColor lf = ScColor();
1292
                                                QDomElement elem = docu.documentElement();
13837 fschmid 1293
                                                QString dTag = "";
1294
                                                dTag = elem.tagName();
1295
                                                QString nameMask = "%1";
1296
                                                nameMask = elem.attribute("mask", "%1");
12015 fschmid 1297
                                                QDomNode PAGE = elem.firstChild();
1298
                                                while(!PAGE.isNull())
1299
                                                {
1300
                                                        QDomElement pg = PAGE.toElement();
1301
                                                        if(pg.tagName()=="COLOR" && pg.attribute("NAME")!=CommonStrings::None)
1302
                                                        {
1303
                                                                if (pg.hasAttribute("CMYK"))
1304
                                                                        lf.setNamedColor(pg.attribute("CMYK"));
20162 fschmid 1305
                                                                else if (pg.hasAttribute("RGB"))
1306
                                                                        lf.fromQColor(QColor(pg.attribute("RGB")));
12015 fschmid 1307
                                                                else
20162 fschmid 1308
                                                                {
1309
                                                                        double L = pg.attribute("L", "0").toDouble();
1310
                                                                        double a = pg.attribute("A", "0").toDouble();
1311
                                                                        double b = pg.attribute("B", "0").toDouble();
1312
                                                                        lf.setColor(L, a, b);
1313
                                                                }
12015 fschmid 1314
                                                                if (pg.hasAttribute("Spot"))
1315
                                                                        lf.setSpotColor(static_cast<bool>(pg.attribute("Spot").toInt()));
1316
                                                                else
1317
                                                                        lf.setSpotColor(false);
1318
                                                                if (pg.hasAttribute("Register"))
1319
                                                                        lf.setRegistrationColor(static_cast<bool>(pg.attribute("Register").toInt()));
1320
                                                                else
1321
                                                                        lf.setRegistrationColor(false);
15771 fschmid 1322
                                                                EditColors.tryAddColor(pg.attribute("NAME"), lf);
12015 fschmid 1323
                                                        }
15599 fschmid 1324
                                                        else if (pg.tagName() == "Gradient")
1325
                                                        {
1326
                                                                if (dialogGradients != NULL)
1327
                                                                {
1328
                                                                        VGradient gra = VGradient(VGradient::linear);
1329
                                                                        gra.clearStops();
1330
                                                                        QDomNode grad = pg.firstChild();
1331
                                                                        while(!grad.isNull())
1332
                                                                        {
1333
                                                                                QDomElement stop = grad.toElement();
1334
                                                                                QString name = stop.attribute("NAME");
1335
                                                                                double ramp  = ScCLocale::toDoubleC(stop.attribute("RAMP"), 0.0);
1336
                                                                                int shade    = stop.attribute("SHADE", "100").toInt();
1337
                                                                                double opa   = ScCLocale::toDoubleC(stop.attribute("TRANS"), 1.0);
1338
                                                                                QColor color;
1339
                                                                                if (name == CommonStrings::None)
1340
                                                                                        color = QColor(255, 255, 255, 0);
1341
                                                                                else
1342
                                                                                {
1343
                                                                                        const ScColor& col = EditColors[name];
1344
                                                                                        color = ScColorEngine::getShadeColorProof(col, NULL, shade);
1345
                                                                                }
1346
                                                                                gra.addStop(color, ramp, 0.5, opa, name, shade);
1347
                                                                                grad = grad.nextSibling();
1348
                                                                        }
15611 fschmid 1349
                                                                        if ((!dialogGradients->contains(pg.attribute("Name"))) || (merge))
15599 fschmid 1350
                                                                                dialogGradients->insert(pg.attribute("Name"), gra);
1351
                                                                        else
1352
                                                                        {
1353
                                                                                QString tmp;
1354
                                                                                QString name = pg.attribute("Name");
1355
                                                                                name += "("+tmp.setNum(dialogGradients->count())+")";
1356
                                                                                dialogGradients->insert(name, gra);
1357
                                                                        }
1358
                                                                }
1359
                                                        }
12172 fschmid 1360
                                                        else if (pg.tagName()=="draw:color" && pg.attribute("draw:name")!=CommonStrings::None)
1361
                                                        {
1362
                                                                if (pg.hasAttribute("draw:color"))
1363
                                                                        lf.setNamedColor(pg.attribute("draw:color"));
1364
                                                                lf.setSpotColor(false);
1365
                                                                lf.setRegistrationColor(false);
1366
                                                                QString nam = pg.attribute("draw:name");
15771 fschmid 1367
                                                                if (!nam.isEmpty())
1368
                                                                        EditColors.tryAddColor(nam, lf);
12172 fschmid 1369
                                                        }
13837 fschmid 1370
                                                        else if (dTag == "VivaColors")
1371
                                                        {
1372
                                                                int cVal = 0;
1373
                                                                int mVal = 0;
1374
                                                                int yVal = 0;
1375
                                                                int kVal = 0;
1376
                                                                QString nam = nameMask.arg(pg.attribute("name"));
1377
                                                                if (pg.attribute("type") == "cmyk")
1378
                                                                {
1379
                                                                        QDomNode colNode = pg.firstChild();
1380
                                                                        while(!colNode.isNull())
1381
                                                                        {
1382
                                                                                QDomElement colVal = colNode.toElement();
1383
                                                                                if (colVal.tagName() == "cyan")
1384
                                                                                        cVal = colVal.text().toInt();
1385
                                                                                if (colVal.tagName() == "magenta")
1386
                                                                                        mVal = colVal.text().toInt();
1387
                                                                                if (colVal.tagName() == "yellow")
1388
                                                                                        yVal = colVal.text().toInt();
1389
                                                                                if (colVal.tagName() == "key")
1390
                                                                                        kVal = colVal.text().toInt();
1391
                                                                                colNode = colNode.nextSibling();
1392
                                                                        }
1393
                                                                        lf.setColor(qRound(2.55 * cVal), qRound(2.55 * mVal), qRound(2.55 * yVal), qRound(2.55 * kVal));
1394
                                                                        lf.setSpotColor(false);
1395
                                                                        lf.setRegistrationColor(false);
15771 fschmid 1396
                                                                        if (!nam.isEmpty())
1397
                                                                                EditColors.tryAddColor(nam, lf);
13837 fschmid 1398
                                                                }
1399
                                                                else if (pg.attribute("type") == "rgb")
1400
                                                                {
1401
                                                                        QDomNode colNode = pg.firstChild();
1402
                                                                        while(!colNode.isNull())
1403
                                                                        {
1404
                                                                                QDomElement colVal = colNode.toElement();
1405
                                                                                if (colVal.tagName() == "red")
1406
                                                                                        cVal = colVal.text().toInt();
1407
                                                                                if (colVal.tagName() == "green")
1408
                                                                                        mVal = colVal.text().toInt();
1409
                                                                                if (colVal.tagName() == "blue")
1410
                                                                                        yVal = colVal.text().toInt();
1411
                                                                                colNode = colNode.nextSibling();
1412
                                                                        }
1413
                                                                        lf.setColorRGB(cVal, mVal, yVal);
1414
                                                                        lf.setSpotColor(false);
1415
                                                                        lf.setRegistrationColor(false);
15771 fschmid 1416
                                                                        if (!nam.isEmpty())
1417
                                                                                EditColors.tryAddColor(nam, lf);
13837 fschmid 1418
                                                                }
1419
                                                        }
12015 fschmid 1420
                                                        PAGE=PAGE.nextSibling();
1421
                                                }
1422
                                        }
1423
                                        else
1424
                                        {
12861 fschmid 1425
                                                QString paletteName = "";
1426
                                                QString dummy;
1427
                                                if (ColorEn.startsWith("GIMP Palette"))
1428
                                                {
1429
                                                        ColorEn = tsC.readLine();
13497 jghali 1430
                                                        ScTextStream CoE(&ColorEn, QIODevice::ReadOnly);
12861 fschmid 1431
                                                        CoE >> dummy >> paletteName;
1432
                                                }
12015 fschmid 1433
                                                while (!tsC.atEnd())
1434
                                                {
1435
                                                        ScColor tmp;
1436
                                                        ColorEn = tsC.readLine();
1437
                                                        if (ColorEn.length()>0 && ColorEn[0]==QChar('#'))
1438
                                                                continue;
13497 jghali 1439
                                                        ScTextStream CoE(&ColorEn, QIODevice::ReadOnly);
12015 fschmid 1440
                                                        CoE >> Rval;
1441
                                                        CoE >> Gval;
1442
                                                        CoE >> Bval;
1443
                                                        if (cus)
1444
                                                        {
1445
                                                                CoE >> Kval;
1446
                                                                Cname = CoE.readAll().trimmed();
1447
                                                                tmp.setColor(Rval, Gval, Bval, Kval);
1448
                                                        }
1449
                                                        else
1450
                                                        {
1451
                                                                Cname = CoE.readAll().trimmed();
1452
                                                                tmp.setColorRGB(Rval, Gval, Bval);
1453
                                                        }
12861 fschmid 1454
                                                        if (Cname == "Untitled")
1455
                                                                Cname = "";
1456
                                                        if (Cname.length() == 0)
12015 fschmid 1457
                                                        {
1458
                                                                if (!cus)
12861 fschmid 1459
                                                                        Cname = paletteName + QString("#%1%2%3").arg(Rval,2,16).arg(Gval,2,16).arg(Bval,2,16).toUpper();
12015 fschmid 1460
                                                                else
12861 fschmid 1461
                                                                        Cname = paletteName + QString("#%1%2%3%4").arg(Rval,2,16).arg(Gval,2,16).arg(Bval,2,16).arg(Kval,2,16).toUpper();
12015 fschmid 1462
                                                                Cname.replace(" ","0");
1463
                                                        }
15771 fschmid 1464
                                                        EditColors.tryAddColor(Cname, tmp);
12015 fschmid 1465
                                                }
1466
                                        }
1467
                                        fiC.close();
1468
                                }
1469
                        }
1470
                }
1471
        }
1472
        return (EditColors.count() != oldCount);
1473
}