Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
2886 fschmid 7
/***************************************************************************
8
                          sccolor.cpp  -  description
9
                             -------------------
10
    begin                : Sun Sep 9 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
 
24
#include <qcolor.h>
25
#include <qstring.h>
26
 
27
#include "sccolor.h"
28
 
29
#include "scconfig.h"
30
 
31
#ifdef HAVE_CMS
32
        #include CMS_INC
5369 mrdocs 33
        extern cmsHTRANSFORM stdTransRGBMonG;
34
        extern cmsHTRANSFORM stdTransCMYKMonG;
2886 fschmid 35
        extern cmsHTRANSFORM stdProofG;
36
        extern cmsHTRANSFORM stdTransCMYKG;
37
        extern cmsHTRANSFORM stdProofCMYKG;
38
        extern cmsHTRANSFORM stdTransRGBG;
3046 fschmid 39
        extern cmsHTRANSFORM stdProofGCG;
40
        extern cmsHTRANSFORM stdProofCMYKGCG;
5243 cbradney 41
        extern bool SoftProofing;
5369 mrdocs 42
        extern bool Gamut;
2886 fschmid 43
        extern bool CMSuse;
44
#endif
45
extern bool CMSavail;
46
bool ScColor::UseProf = true;
47
 
48
ScColor::ScColor()
49
{
3490 avox 50
//      setColor(0, 0, 0, 0);
51
        Model = colorModelCMYK;
52
        C = M = Y = K = 0;
53
        R = G = B = 255;
54
        RGB = Qt::white;
55
 
2886 fschmid 56
        Spot = false;
3041 fschmid 57
        outOfGamutFlag = false;
3060 fschmid 58
        Regist = false;
2886 fschmid 59
}
60
 
61
ScColor::ScColor(int c, int m, int y, int k)
62
{
63
        setColor(c, m, y, k);
64
        Spot = false;
3041 fschmid 65
        outOfGamutFlag = false;
3060 fschmid 66
        Regist = false;
2886 fschmid 67
}
68
 
69
ScColor::ScColor(int r, int g, int b)
70
{
71
        setColorRGB(r, g, b);
72
        Spot = false;
3041 fschmid 73
        outOfGamutFlag = false;
3060 fschmid 74
        Regist = false;
2886 fschmid 75
}
76
 
4608 cbradney 77
bool ScColor::operator==(const ScColor& rhs) const
78
{
79
        if (Model!=rhs.Model)
80
                return false;
81
        if (Spot!=rhs.Spot)
82
                return false;
83
        if (Regist!=rhs.Regist)
84
                return false;
85
        if (Model==colorModelRGB)
86
        {
87
                return (R==rhs.R && G==rhs.G && B==rhs.B);
88
        }
89
        if (Model==colorModelCMYK)
90
        {
91
                return (C==rhs.C && M==rhs.M && Y==rhs.Y && K==rhs.K);
92
        }
93
        return false;
94
}
95
 
2886 fschmid 96
void ScColor::setColor(int c, int m, int y, int k)
97
{
98
        C = c;
99
        M = m;
100
        Y = y;
101
        K = k;
102
        Model = colorModelCMYK;
103
        RecalcRGB();
104
}
105
 
106
void ScColor::setColorRGB(int r, int g, int b)
107
{
108
        R = r;
109
        G = g;
110
        B = b;
111
        Model = colorModelRGB;
112
        RecalcRGB();
113
}
114
 
115
void ScColor::setColorModel (colorModel cm)
116
{
117
        Model = cm;
118
        RecalcRGB();
119
}
120
 
121
colorModel ScColor::getColorModel ()
122
{
123
        return Model;
124
 }
125
 
126
void ScColor::fromQColor(QColor color)
127
{
128
        int r, g, b;
129
        color.rgb(&r, &g, &b);
130
        setColorRGB(r, g, b);
131
}
132
 
133
QColor ScColor::getRGBColor()
134
{
135
        return RGB;
136
}
5369 mrdocs 137
 
138
QColor ScColor::getShadeColor(int level)
139
{
140
        int r, g, b;
141
        getShadeColorRGB(&r, &g, &b, level);
142
        return QColor(r, g, b);
143
}
2886 fschmid 144
 
145
void ScColor::getShadeColorCMYK(int *c, int *m, int *y, int *k, int level)
146
{
147
        if (Model == colorModelRGB)
148
        {
149
                int r, g, b;
150
                ScColor tmpR;
151
                getShadeColorRGB(&r, &g, &b, level);
152
                tmpR.setColorRGB(r, g, b);
153
                tmpR.getCMYK(c, m, y, k);
154
        }
155
        else
156
        {
157
                *c = C * level / 100;
158
                *m = M * level / 100;
159
                *y = Y * level / 100;
160
                *k = K * level / 100;
161
        }
162
}
163
 
164
void ScColor::getShadeColorRGB(int *r, int *g, int *b, int level)
165
{
166
        int h, s, v, snew;
167
 
168
        if (Model == colorModelCMYK)
169
        {
170
                int c, m, y, k;
171
                getShadeColorCMYK(&c, &m, &y, &k, level);
172
                ScColor tmpC(c, m, y, k);
173
                tmpC.getRGB(r, g, b);
174
        }
175
        else
176
        {
177
                QColor tmpR(R, G, B);
178
                tmpR.hsv(&h, &s, &v);
179
 
180
                if (R == G && G == B)
181
                {
182
                        snew = 255 - ((255 - v) * level / 100);
183
                        tmpR.setHsv(h, s, snew);
184
                }
185
                else
186
                {
187
                        snew = s * level / 100;
188
                        tmpR.setHsv(h, snew, v);
189
                }
190
 
191
                tmpR.getRgb(r, g, b);
192
        }
193
}
194
 
5369 mrdocs 195
QColor ScColor::getDisplayColor()
196
{
197
        QColor tmp;
198
        if (Model == colorModelRGB)
199
                tmp = getDisplayColor(R, G, B);
200
        else
201
                tmp = getDisplayColor(C, M, Y, K);
202
        return tmp;
203
}
204
 
205
QColor ScColor::getDisplayColorGC()
206
{
207
        QColor tmp;
208
        if( SoftProofing && Gamut )
209
        {
210
                checkGamut();
211
                tmp = outOfGamutFlag ? QColor(0, 255, 0) : getDisplayColor();
212
        }
213
        else
214
                tmp = getDisplayColor();
215
        return tmp;
216
}
217
 
218
QColor ScColor::getColorProof(bool gamutCheck)
219
{
220
        QColor tmp;
221
        if (Model == colorModelRGB)
222
                tmp = getColorProof(R, G, B, gamutCheck & Gamut);
223
        else
224
                tmp = getColorProof(C, M, Y, K, gamutCheck & Gamut);
225
        return tmp;
226
}
227
 
2886 fschmid 228
QColor ScColor::getShadeColorProof(int level)
229
{
230
        QColor tmp;
231
        ScColor tmp2;
232
        int r, g, b, c, m ,y, k;
5369 mrdocs 233
#if defined HAVE_CMS
234
        bool doGC = Gamut;
235
#else
236
        bool doGC = false;
237
#endif
2886 fschmid 238
 
239
        if (Model == colorModelRGB)
240
        {
241
                getShadeColorRGB(&r, &g, &b, level);
5369 mrdocs 242
                tmp = getColorProof(r, g, b, doGC);
2886 fschmid 243
        }
244
        else
245
        {
246
                getShadeColorCMYK(&c, &m, &y, &k, level);
5369 mrdocs 247
                tmp = getColorProof(c, m, y, k, doGC);
2886 fschmid 248
        }
249
 
5369 mrdocs 250
        return tmp;
2886 fschmid 251
}
252
 
253
void ScColor::getRawRGBColor(int *r, int *g, int *b)
254
{
255
        *r = 255-QMIN(255, C+K);
256
        *g = 255-QMIN(255, M+K);
257
        *b = 255-QMIN(255, Y+K);
258
}
259
 
3046 fschmid 260
QColor ScColor::getRawRGBColor()
261
{
262
        return QColor(255-QMIN(255, C+K), 255-QMIN(255, M+K), 255-QMIN(255, Y+K));
263
}
264
 
2886 fschmid 265
void ScColor::getRGB(int *r, int *g, int *b)
266
{
267
        *r = R;
268
        *g = G;
269
        *b = B;
270
}
271
 
272
void ScColor::getCMYK(int *c, int *m, int *y, int *k)
273
{
274
        *c = C;
275
        *m = M;
276
        *y = Y;
277
        *k = K;
278
}
279
 
280
void ScColor::applyGCR()
281
{
282
#ifdef HAVE_CMS
283
        if (!(CMSuse && CMSavail))
284
        {
285
#endif
286
                int k = QMIN(QMIN(C, M), Y);
287
                C = C - k;
288
                M = M - k;
289
                Y = Y - k;
290
                K = QMIN((K + k), 255);
291
#ifdef HAVE_CMS
292
        }
293
#endif
294
}
295
 
296
QString ScColor::name()
297
{
298
        QString tmp, name="#";
299
        switch (Model)
300
        {
301
        case colorModelCMYK:
302
                tmp.setNum(C, 16);
303
                if (tmp.length() < 2)
304
                        tmp.insert(0, "0");
305
                name += tmp;
306
                tmp.setNum(M, 16);
307
                if (tmp.length() < 2)
308
                        tmp.insert(0, "0");
309
                name += tmp;
310
                tmp.setNum(Y, 16);
311
                if (tmp.length() < 2)
312
                        tmp.insert(0, "0");
313
                name += tmp;
314
                tmp.setNum(K, 16);
315
                if (tmp.length() < 2)
316
                        tmp.insert(0, "0");
317
                name += tmp;
318
                return name;
319
                break;
320
        case colorModelRGB:
321
                tmp.setNum(R, 16);
322
                if (tmp.length() < 2)
323
                        tmp.insert(0, "0");
324
                name += tmp;
325
                tmp.setNum(G, 16);
326
                if (tmp.length() < 2)
327
                        tmp.insert(0, "0");
328
                name += tmp;
329
                tmp.setNum(B, 16);
330
                if (tmp.length() < 2)
331
                        tmp.insert(0, "0");
332
                name += tmp;
333
                return name;
334
        }
335
        return "";
336
}
337
 
4535 fschmid 338
QString ScColor::nameCMYK()
339
{
340
        QString tmp, name="#";
341
        tmp.setNum(C, 16);
342
        if (tmp.length() < 2)
343
                tmp.insert(0, "0");
344
        name += tmp;
345
        tmp.setNum(M, 16);
346
        if (tmp.length() < 2)
347
                tmp.insert(0, "0");
348
        name += tmp;
349
        tmp.setNum(Y, 16);
350
        if (tmp.length() < 2)
351
                tmp.insert(0, "0");
352
        name += tmp;
353
        tmp.setNum(K, 16);
354
        if (tmp.length() < 2)
355
                tmp.insert(0, "0");
356
        name += tmp;
357
        return name;
358
}
359
 
360
QString ScColor::nameRGB()
361
{
362
        QString tmp, name="#";
363
        tmp.setNum(R, 16);
364
        if (tmp.length() < 2)
365
                tmp.insert(0, "0");
366
        name += tmp;
367
        tmp.setNum(G, 16);
368
        if (tmp.length() < 2)
369
                tmp.insert(0, "0");
370
        name += tmp;
371
        tmp.setNum(B, 16);
372
        if (tmp.length() < 2)
373
                tmp.insert(0, "0");
374
        name += tmp;
375
        return name;
376
}
377
 
2886 fschmid 378
void ScColor::setNamedColor(QString name)
379
{
380
        bool ok;
381
        if (name.length () == 9)
382
        {
383
                int c = name.mid(1,2).toInt(&ok, 16);
384
                int m = name.mid(3,2).toInt(&ok, 16);
385
                int y = name.mid(5,2).toInt(&ok, 16);
386
                int k = name.mid(7,2).toInt(&ok, 16);
387
                setColor(c, m, y, k);
388
        }
389
        else if (name.length () == 7)
390
        {
391
                int r = name.mid(1,2).toInt(&ok, 16);
392
                int g = name.mid(3,2).toInt(&ok, 16);
393
                int b = name.mid(5,2).toInt(&ok, 16);
394
                setColorRGB(r, g, b);
395
        }
396
}
397
 
3041 fschmid 398
bool ScColor::isOutOfGamut()
399
{
400
        return outOfGamutFlag;
401
}
402
 
3046 fschmid 403
void ScColor::checkGamut()
404
{
405
        outOfGamutFlag = false;
3057 fschmid 406
        if (Spot)
407
                return;
3046 fschmid 408
#ifdef HAVE_CMS
409
        WORD inC[4];
410
        WORD outC[4];
411
        if (CMSuse && CMSavail)
412
        {
413
                bool alert = true;
414
                cmsHTRANSFORM xformProof;
415
                if (Model == colorModelRGB)
416
                {
417
                        inC[0] = R*257;
418
                        inC[1] = G*257;
419
                        inC[2] = B*257;
420
                        xformProof = stdProofGCG;
421
                        if ((R == 0) && (B == 0) && (G == 255))
422
                                alert = false;
3052 fschmid 423
                        if ((R == G && G == B))
424
                                alert = false;
3046 fschmid 425
                }
426
                else
427
                {
428
                        inC[0] = C*257;
429
                        inC[1] = M*257;
430
                        inC[2] = Y*257;
431
                        inC[3] = K*257;
432
                        xformProof = stdProofCMYKGCG;
3051 fschmid 433
                        if ((M == 0) && (K == 0) && (C == 255) && (Y == 255))
3046 fschmid 434
                                alert = false;
3052 fschmid 435
                        if ((M == 0) && (C == 0) && (Y == 0))
436
                                alert = false;
437
                        if ((M == C) && (C == Y) && (Y == K))
438
                                alert = false;
3046 fschmid 439
                }
3052 fschmid 440
                if (alert)
441
                {
442
                        cmsDoTransform(xformProof, inC, outC, 1);
443
                        if ((alert) && ((outC[0]/257 == 0) && (outC[1]/257 == 255) & (outC[2]/257 == 0)))
444
                                outOfGamutFlag = true;
445
                }
3046 fschmid 446
        }
447
#endif
448
}
449
 
2886 fschmid 450
void ScColor::RecalcRGB()
451
{
3041 fschmid 452
        outOfGamutFlag = false;
3163 fschmid 453
        bool alert = true;
2886 fschmid 454
#ifdef HAVE_CMS
455
        WORD inC[4];
456
        WORD outC[4];
3163 fschmid 457
        if ((CMSuse && CMSavail) && (!Spot))
2886 fschmid 458
        {
3163 fschmid 459
                if (Model == colorModelRGB)
2886 fschmid 460
                {
3163 fschmid 461
                        // allow RGB greys to go got to CMYK greys without transform
462
                        if (R == G && G == B)
2886 fschmid 463
                        {
3163 fschmid 464
                                C = M = Y = 0;
465
                                K = 255 - R;
466
                        }
467
                        else
468
                        {
2886 fschmid 469
                                inC[0] = R * 257;
470
                                inC[1] = G * 257;
471
                                inC[2] = B * 257;
5369 mrdocs 472
                                cmsDoTransform(stdTransCMYKG, inC, outC, 1);
473
                                C = outC[0] / 257;
474
                                M = outC[1] / 257;
475
                                Y = outC[2] / 257;
476
                                K = outC[3] / 257;
477
                                checkGamut();
2886 fschmid 478
                        }
479
                }
3163 fschmid 480
                else
2886 fschmid 481
                {
482
                        inC[0] = C * 257;
483
                        inC[1] = M * 257;
484
                        inC[2] = Y * 257;
485
                        inC[3] = K * 257;
5369 mrdocs 486
                        cmsDoTransform(stdTransRGBG, inC, outC, 1);
2886 fschmid 487
                        R = outC[0] / 257;
488
                        G = outC[1] / 257;
489
                        B = outC[2] / 257;
5369 mrdocs 490
                        checkGamut();
2886 fschmid 491
                }
492
        }
3163 fschmid 493
        else
2886 fschmid 494
        {
3163 fschmid 495
#endif
2886 fschmid 496
                if (Model == colorModelRGB)
497
                {
3163 fschmid 498
                        K = QMIN(QMIN(255 - R, 255 - G), 255 - B);
499
                        C = 255 - R - K;
500
                        M = 255 - G - K;
501
                        Y = 255 - B - K;
2886 fschmid 502
                }
503
                else
504
                {
3163 fschmid 505
                        R = 255 - QMIN(255, C + K);
506
                        G = 255 - QMIN(255, M + K);
507
                        B = 255 - QMIN(255, Y + K);
2886 fschmid 508
                }
3163 fschmid 509
#ifdef HAVE_CMS
2886 fschmid 510
        }
511
#endif
3163 fschmid 512
        RGB = QColor(R, G, B);
2886 fschmid 513
}
3051 fschmid 514
 
5369 mrdocs 515
QColor ScColor::getColorProof(int r, int g, int b, bool gamutCkeck)
516
{
517
#ifdef HAVE_CMS
518
        WORD inC[4];
519
        WORD outC[4];
520
        bool alert = true;
521
        if ((CMSuse && CMSavail) && (!Spot))
522
        {
523
                inC[0] = r * 257;
524
                inC[1] = g * 257;
525
                inC[2] = b * 257;
526
                if (SoftProofing)
527
                {
528
                        cmsHTRANSFORM xform = gamutCkeck ? stdProofGCG : stdProofG;
529
                        cmsDoTransform(xform, inC, outC, 1);
530
                        r = outC[0] / 257;
531
                        g = outC[1] / 257;
532
                        b = outC[2] / 257;
533
                }
534
                else
535
                {
536
                        cmsDoTransform(stdTransRGBMonG, inC, outC, 1);
537
                        r = outC[0] / 257;
538
                        g = outC[1] / 257;
539
                        b = outC[2] / 257;
540
                }
541
        }
542
#endif
543
        return QColor(r, g, b);
544
}
545
 
546
QColor ScColor::getColorProof(int c, int m, int y, int k, bool gamutCkeck)
547
{
548
        int  r = 0, g = 0, b = 0;
549
#ifdef HAVE_CMS
550
        WORD inC[4];
551
        WORD outC[4];
552
        bool alert = true;
553
        if ((CMSuse && CMSavail) && (!Spot))
554
        {
555
                inC[0] = c * 257;
556
                inC[1] = m * 257;
557
                inC[2] = y * 257;
558
                inC[3] = k * 257;
559
                if (SoftProofing)
560
                {
561
                        cmsHTRANSFORM xform = gamutCkeck ? stdProofCMYKGCG : stdProofCMYKG;
562
                        cmsDoTransform(xform, inC, outC, 1);
563
                        r = outC[0] / 257;
564
                        g = outC[1] / 257;
565
                        b = outC[2] / 257;
566
                }
567
                else
568
                {
569
                        cmsDoTransform(stdTransCMYKMonG, inC, outC, 1);
570
                        r = outC[0] / 257;
571
                        g = outC[1] / 257;
572
                        b = outC[2] / 257;
573
                }
574
        }
575
        else
576
        {
577
#endif
578
                r = 255 - QMIN(255, c + k);
579
                g = 255 - QMIN(255, m + k);
580
                b = 255 - QMIN(255, y + k);
581
#ifdef HAVE_CMS
582
        }
583
#endif
584
        return QColor(r, g, b);
585
}
586
 
587
QColor ScColor::getDisplayColor(int r, int g, int b)
588
{
589
#ifdef HAVE_CMS
590
        WORD inC[4];
591
        WORD outC[4];
592
        bool alert = true;
593
        if ((CMSuse && CMSavail) && (!Spot))
594
        {
595
                inC[0] = r * 257;
596
                inC[1] = g * 257;
597
                inC[2] = b * 257;
598
                cmsDoTransform(stdTransRGBMonG, inC, outC, 1);
599
                r = outC[0] / 257;
600
                g = outC[1] / 257;
601
                b = outC[2] / 257;
602
        }
603
#endif
604
        return QColor(r, g, b);
605
}
606
 
607
QColor ScColor::getDisplayColor(int c, int m, int y, int k)
608
{
609
        int  r = 0, g = 0, b = 0;
610
#ifdef HAVE_CMS
611
        WORD inC[4];
612
        WORD outC[4];
613
        bool alert = true;
614
        if ((CMSuse && CMSavail) && (!Spot))
615
        {
616
                inC[0] = c * 257;
617
                inC[1] = m * 257;
618
                inC[2] = y * 257;
619
                inC[3] = k * 257;
620
                cmsDoTransform(stdTransCMYKMonG, inC, outC, 1);
621
                r = outC[0] / 257;
622
                g = outC[1] / 257;
623
                b = outC[2] / 257;
624
        }
625
        else
626
        {
627
#endif
628
                r = 255 - QMIN(255, c + k);
629
                g = 255 - QMIN(255, m + k);
630
                b = 255 - QMIN(255, y + k);
631
#ifdef HAVE_CMS
632
        }
633
#endif
634
        return QColor(r, g, b);
635
}
636
 
3060 fschmid 637
bool ScColor::isRegistrationColor()
638
{
639
        return Regist;
640
}
641
 
642
void ScColor::setRegistrationColor(bool s)
643
{
644
        Regist = s;
645
}
646
 
3051 fschmid 647
bool ScColor::isSpotColor()
648
{
649
        return Spot;
650
}
651
 
652
void ScColor::setSpotColor(bool s)
653
{
654
        Spot = s;
655
}