← Back to branch summary

~valavanisalex/ubuntu/precise/inkscape/fix-943984

« back to all changes in this revision

Viewing changes to inkscape-0.47pre1/src/widgets/sp-color-scales.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Bryce Harrington
  • Date: 2009-07-02 17:09:45 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20090702170945-nn6d6zswovbwju1t
Tags: 0.47~pre1-0ubuntu1
https://launchpad.net/bugs/348842
https://launchpad.net/bugs/391149
* New upstream release.
  - Don't constrain maximization on small resolution devices (pre0)
    (LP: #348842)
  - Fixes segfault on startup (pre0)
    (LP: #391149)

Show diffs side-by-side

added added

removed removed

Lines of Context:
inkscape-0.47pre1/src/widgets/sp-color-scales.cpp
 
1
/*
 
2
 *   bulia byak <buliabyak@users.sf.net>
 
3
 */
 
4
 
 
5
#ifdef HAVE_CONFIG_H
 
6
# include "config.h"
 
7
#endif
 
8
#include <math.h>
 
9
#include <gtk/gtk.h>
 
10
#include <glibmm/i18n.h>
 
11
#include "../dialogs/dialog-events.h"
 
12
#include "sp-color-scales.h"
 
13
 
 
14
#define CSC_CHANNEL_R (1 << 0)
 
15
#define CSC_CHANNEL_G (1 << 1)
 
16
#define CSC_CHANNEL_B (1 << 2)
 
17
#define CSC_CHANNEL_A (1 << 3)
 
18
#define CSC_CHANNEL_H (1 << 0)
 
19
#define CSC_CHANNEL_S (1 << 1)
 
20
#define CSC_CHANNEL_V (1 << 2)
 
21
#define CSC_CHANNEL_C (1 << 0)
 
22
#define CSC_CHANNEL_M (1 << 1)
 
23
#define CSC_CHANNEL_Y (1 << 2)
 
24
#define CSC_CHANNEL_K (1 << 3)
 
25
#define CSC_CHANNEL_CMYKA (1 << 4)
 
26
 
 
27
#define CSC_CHANNELS_ALL 0
 
28
 
 
29
 
 
30
G_BEGIN_DECLS
 
31
 
 
32
static void sp_color_scales_class_init (SPColorScalesClass *klass);
 
33
static void sp_color_scales_init (SPColorScales *cs);
 
34
static void sp_color_scales_destroy (GtkObject *object);
 
35
 
 
36
static void sp_color_scales_show_all (GtkWidget *widget);
 
37
static void sp_color_scales_hide_all (GtkWidget *widget);
 
38
 
 
39
static const gchar *sp_color_scales_hue_map (void);
 
40
 
 
41
G_END_DECLS
 
42
 
 
43
static SPColorSelectorClass *parent_class;
 
44
 
 
45
#define XPAD 4
 
46
#define YPAD 1
 
47
 
 
48
#define noDUMP_CHANGE_INFO 1
 
49
 
 
50
GType
 
51
sp_color_scales_get_type (void)
 
52
{
 
53
        static GType type = 0;
 
54
        if (!type) {
 
55
                static const GTypeInfo info = {
 
56
                        sizeof (SPColorScalesClass),
 
57
                        NULL, /* base_init */
 
58
                        NULL, /* base_finalize */
 
59
                        (GClassInitFunc) sp_color_scales_class_init,
 
60
                        NULL, /* class_finalize */
 
61
                        NULL, /* class_data */
 
62
                        sizeof (SPColorScales),
 
63
                        0,        /* n_preallocs */
 
64
                        (GInstanceInitFunc) sp_color_scales_init,
 
65
                        NULL
 
66
                };
 
67
 
 
68
                type = g_type_register_static (SP_TYPE_COLOR_SELECTOR,
 
69
                                                                           "SPColorScales",
 
70
                                                                           &info,
 
71
                                                                           static_cast< GTypeFlags > (0) );
 
72
        }
 
73
        return type;
 
74
}
 
75
 
 
76
static void
 
77
sp_color_scales_class_init (SPColorScalesClass *klass)
 
78
{
 
79
        static const gchar* nameset[] = {N_("RGB"), N_("HSL"), N_("CMYK"), 0};
 
80
        GtkObjectClass *object_class;
 
81
        GtkWidgetClass *widget_class;
 
82
        SPColorSelectorClass *selector_class;
 
83
 
 
84
        object_class = (GtkObjectClass *) klass;
 
85
        widget_class = (GtkWidgetClass *) klass;
 
86
        selector_class = SP_COLOR_SELECTOR_CLASS (klass);
 
87
 
 
88
        parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass));
 
89
 
 
90
        selector_class->name = nameset;
 
91
        selector_class->submode_count = 3;
 
92
 
 
93
        object_class->destroy = sp_color_scales_destroy;
 
94
 
 
95
        widget_class->show_all = sp_color_scales_show_all;
 
96
        widget_class->hide_all = sp_color_scales_hide_all;
 
97
}
 
98
 
 
99
ColorScales::ColorScales( SPColorSelector* csel )
 
100
    : ColorSelector( csel ),
 
101
      _mode( SP_COLOR_SCALES_MODE_NONE ),
 
102
      _rangeLimit( 255.0 ),
 
103
      _updating( FALSE ),
 
104
      _dragging( FALSE )
 
105
{
 
106
    for (gint i = 0; i < 5; i++) {
 
107
        _l[i] = 0;
 
108
        _a[i] = 0;
 
109
        _s[i] = 0;
 
110
        _b[i] = 0;
 
111
    }
 
112
}
 
113
 
 
114
ColorScales::~ColorScales()
 
115
{
 
116
    for (gint i = 0; i < 5; i++) {
 
117
        _l[i] = 0;
 
118
        _a[i] = 0;
 
119
        _s[i] = 0;
 
120
        _b[i] = 0;
 
121
    }
 
122
}
 
123
 
 
124
void sp_color_scales_init (SPColorScales *cs)
 
125
{
 
126
    SP_COLOR_SELECTOR(cs)->base = new ColorScales( SP_COLOR_SELECTOR(cs) );
 
127
 
 
128
    if ( SP_COLOR_SELECTOR(cs)->base )
 
129
    {
 
130
        SP_COLOR_SELECTOR(cs)->base->init();
 
131
    }
 
132
}
 
133
 
 
134
void ColorScales::init()
 
135
{
 
136
        GtkWidget *t;
 
137
        gint i;
 
138
 
 
139
        _updating = FALSE;
 
140
        _dragging = FALSE;
 
141
 
 
142
        _tt = gtk_tooltips_new();
 
143
 
 
144
        t = gtk_table_new (5, 3, FALSE);
 
145
        gtk_widget_show (t);
 
146
        gtk_box_pack_start (GTK_BOX (_csel), t, TRUE, TRUE, 0);
 
147
 
 
148
        /* Create components */
 
149
        for (i = 0; i < static_cast< gint > (G_N_ELEMENTS(_a)) ; i++) {
 
150
                /* Label */
 
151
                _l[i] = gtk_label_new("");
 
152
                gtk_misc_set_alignment (GTK_MISC (_l[i]), 1.0, 0.5);
 
153
                gtk_widget_show (_l[i]);
 
154
                gtk_table_attach (GTK_TABLE (t), _l[i], 0, 1, i, i + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
 
155
                /* Adjustment */
 
156
                _a[i] = (GtkAdjustment *) gtk_adjustment_new (0.0, 0.0, _rangeLimit, 1.0, 10.0, 10.0);
 
157
                /* Slider */
 
158
                _s[i] = sp_color_slider_new (_a[i]);
 
159
                gtk_widget_show (_s[i]);
 
160
                gtk_table_attach (GTK_TABLE (t), _s[i], 1, 2, i, i + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)GTK_FILL, XPAD, YPAD);
 
161
 
 
162
                /* Spinbutton */
 
163
                _b[i] = gtk_spin_button_new (GTK_ADJUSTMENT (_a[i]), 1.0, 0);
 
164
                sp_dialog_defocus_on_enter (_b[i]);
 
165
                gtk_label_set_mnemonic_widget (GTK_LABEL(_l[i]), _b[i]);
 
166
                gtk_widget_show (_b[i]);
 
167
                gtk_table_attach (GTK_TABLE (t), _b[i], 2, 3, i, i + 1, (GtkAttachOptions)0, (GtkAttachOptions)0, XPAD, YPAD);
 
168
 
 
169
                /* Attach channel value to adjustment */
 
170
                gtk_object_set_data (GTK_OBJECT (_a[i]), "channel", GINT_TO_POINTER (i));
 
171
                /* Signals */
 
172
                gtk_signal_connect (GTK_OBJECT (_a[i]), "value_changed",
 
173
                                        GTK_SIGNAL_FUNC (_adjustmentAnyChanged), _csel);
 
174
                gtk_signal_connect (GTK_OBJECT (_s[i]), "grabbed",
 
175
                                        GTK_SIGNAL_FUNC (_sliderAnyGrabbed), _csel);
 
176
                gtk_signal_connect (GTK_OBJECT (_s[i]), "released",
 
177
                                        GTK_SIGNAL_FUNC (_sliderAnyReleased), _csel);
 
178
                gtk_signal_connect (GTK_OBJECT (_s[i]), "changed",
 
179
                                        GTK_SIGNAL_FUNC (_sliderAnyChanged), _csel);
 
180
        }
 
181
 
 
182
        /* Initial mode is none, so it works */
 
183
        setMode(SP_COLOR_SCALES_MODE_RGB);
 
184
}
 
185
 
 
186
static void
 
187
sp_color_scales_destroy (GtkObject *object)
 
188
{
 
189
        if (((GtkObjectClass *) (parent_class))->destroy)
 
190
                (* ((GtkObjectClass *) (parent_class))->destroy) (object);
 
191
}
 
192
 
 
193
static void
 
194
sp_color_scales_show_all (GtkWidget *widget)
 
195
{
 
196
        gtk_widget_show (widget);
 
197
}
 
198
 
 
199
static void
 
200
sp_color_scales_hide_all (GtkWidget *widget)
 
201
{
 
202
        gtk_widget_hide (widget);
 
203
}
 
204
 
 
205
GtkWidget *
 
206
sp_color_scales_new (void)
 
207
{
 
208
        SPColorScales *csel;
 
209
 
 
210
        csel = (SPColorScales*)gtk_type_new (SP_TYPE_COLOR_SCALES);
 
211
 
 
212
        return GTK_WIDGET (csel);
 
213
}
 
214
 
 
215
void ColorScales::_recalcColor( gboolean changing )
 
216
{
 
217
    if ( changing )
 
218
    {
 
219
        SPColor color;
 
220
        gfloat alpha = 1.0;
 
221
        gfloat c[5];
 
222
 
 
223
        switch (_mode) {
 
224
        case SP_COLOR_SCALES_MODE_RGB:
 
225
        case SP_COLOR_SCALES_MODE_HSV:
 
226
            _getRgbaFloatv(c);
 
227
            color.set( c[0], c[1], c[2] );
 
228
            alpha = c[3];
 
229
            break;
 
230
        case SP_COLOR_SCALES_MODE_CMYK:
 
231
        {
 
232
            _getCmykaFloatv( c );
 
233
 
 
234
            float rgb[3];
 
235
            sp_color_cmyk_to_rgb_floatv( rgb, c[0], c[1], c[2], c[3] );
 
236
            color.set( rgb[0], rgb[1], rgb[2] );
 
237
            alpha = c[4];
 
238
            break;
 
239
        }
 
240
        default:
 
241
            g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode);
 
242
            break;
 
243
        }
 
244
        _updateInternals( color, alpha, _dragging );
 
245
    }
 
246
    else
 
247
    {
 
248
        _updateInternals( _color, _alpha, _dragging );
 
249
    }
 
250
}
 
251
 
 
252
/* Helpers for setting color value */
 
253
gfloat ColorScales::getScaled( const GtkAdjustment *a )
 
254
{
 
255
    gfloat val = a->value / a->upper;
 
256
    return val;
 
257
}
 
258
 
 
259
void ColorScales::setScaled( GtkAdjustment *a, gfloat v )
 
260
{
 
261
    gfloat val = v * a->upper;
 
262
    gtk_adjustment_set_value( a, val );
 
263
}
 
264
 
 
265
void ColorScales::_setRangeLimit( gdouble upper )
 
266
{
 
267
    _rangeLimit = upper;
 
268
    for ( gint i = 0; i < static_cast<gint>(G_N_ELEMENTS(_a)); i++ ) {
 
269
        _a[i]->upper = upper;
 
270
        gtk_adjustment_changed( _a[i] );
 
271
    }
 
272
}
 
273
 
 
274
void ColorScales::_colorChanged()
 
275
{
 
276
#ifdef DUMP_CHANGE_INFO
 
277
    g_message("ColorScales::_colorChanged( this=%p, %f, %f, %f,   %f)", this, _color.v.c[0], _color.v.c[1], _color.v.c[2], _alpha );
 
278
#endif
 
279
    gfloat tmp[3];
 
280
    gfloat c[5] = {0.0, 0.0, 0.0, 0.0};
 
281
 
 
282
    switch (_mode) {
 
283
    case SP_COLOR_SCALES_MODE_RGB:
 
284
        sp_color_get_rgb_floatv( &_color, c );
 
285
        c[3] = _alpha;
 
286
        c[4] = 0.0;
 
287
        break;
 
288
    case SP_COLOR_SCALES_MODE_HSV:
 
289
        sp_color_get_rgb_floatv( &_color, tmp );
 
290
        sp_color_rgb_to_hsl_floatv (c, tmp[0], tmp[1], tmp[2]);
 
291
        c[3] = _alpha;
 
292
        c[4] = 0.0;
 
293
        break;
 
294
    case SP_COLOR_SCALES_MODE_CMYK:
 
295
        sp_color_get_cmyk_floatv( &_color, c );
 
296
        c[4] = _alpha;
 
297
        break;
 
298
    default:
 
299
        g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode);
 
300
        break;
 
301
    }
 
302
 
 
303
    _updating = TRUE;
 
304
    setScaled( _a[0], c[0] );
 
305
    setScaled( _a[1], c[1] );
 
306
    setScaled( _a[2], c[2] );
 
307
    setScaled( _a[3], c[3] );
 
308
    setScaled( _a[4], c[4] );
 
309
    _updateSliders( CSC_CHANNELS_ALL );
 
310
    _updating = FALSE;
 
311
}
 
312
 
 
313
void ColorScales::_getRgbaFloatv( gfloat *rgba )
 
314
{
 
315
        g_return_if_fail (rgba != NULL);
 
316
 
 
317
        switch (_mode) {
 
318
        case SP_COLOR_SCALES_MODE_RGB:
 
319
                rgba[0] = getScaled(_a[0]);
 
320
                rgba[1] = getScaled(_a[1]);
 
321
                rgba[2] = getScaled(_a[2]);
 
322
                rgba[3] = getScaled(_a[3]);
 
323
                break;
 
324
        case SP_COLOR_SCALES_MODE_HSV:
 
325
                sp_color_hsl_to_rgb_floatv (rgba, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]));
 
326
                rgba[3] = getScaled(_a[3]);
 
327
                break;
 
328
        case SP_COLOR_SCALES_MODE_CMYK:
 
329
                sp_color_cmyk_to_rgb_floatv (rgba, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3]));
 
330
                rgba[3] = getScaled(_a[4]);
 
331
                break;
 
332
        default:
 
333
                g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__);
 
334
                break;
 
335
        }
 
336
}
 
337
 
 
338
void ColorScales::_getCmykaFloatv( gfloat *cmyka )
 
339
{
 
340
        gfloat rgb[3];
 
341
 
 
342
        g_return_if_fail (cmyka != NULL);
 
343
 
 
344
        switch (_mode) {
 
345
        case SP_COLOR_SCALES_MODE_RGB:
 
346
                sp_color_rgb_to_cmyk_floatv (cmyka, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]));
 
347
                cmyka[4] = getScaled(_a[3]);
 
348
                break;
 
349
        case SP_COLOR_SCALES_MODE_HSV:
 
350
                sp_color_hsl_to_rgb_floatv (rgb, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]));
 
351
                sp_color_rgb_to_cmyk_floatv (cmyka, rgb[0], rgb[1], rgb[2]);
 
352
                cmyka[4] = getScaled(_a[3]);
 
353
                break;
 
354
        case SP_COLOR_SCALES_MODE_CMYK:
 
355
                cmyka[0] = getScaled(_a[0]);
 
356
                cmyka[1] = getScaled(_a[1]);
 
357
                cmyka[2] = getScaled(_a[2]);
 
358
                cmyka[3] = getScaled(_a[3]);
 
359
                cmyka[4] = getScaled(_a[4]);
 
360
                break;
 
361
        default:
 
362
                g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__);
 
363
                break;
 
364
        }
 
365
}
 
366
 
 
367
guint32 ColorScales::_getRgba32()
 
368
{
 
369
        gfloat c[4];
 
370
        guint32 rgba;
 
371
 
 
372
        _getRgbaFloatv(c);
 
373
 
 
374
        rgba = SP_RGBA32_F_COMPOSE (c[0], c[1], c[2], c[3]);
 
375
 
 
376
        return rgba;
 
377
}
 
378
 
 
379
void ColorScales::setMode(SPColorScalesMode mode)
 
380
{
 
381
        gfloat rgba[4];
 
382
        gfloat c[4];
 
383
 
 
384
        if (_mode == mode) return;
 
385
 
 
386
        if ((_mode == SP_COLOR_SCALES_MODE_RGB) ||
 
387
                (_mode == SP_COLOR_SCALES_MODE_HSV) ||
 
388
                (_mode == SP_COLOR_SCALES_MODE_CMYK)) {
 
389
                _getRgbaFloatv(rgba);
 
390
        } else {
 
391
                rgba[0] = rgba[1] = rgba[2] = rgba[3] = 1.0;
 
392
        }
 
393
 
 
394
        _mode = mode;
 
395
 
 
396
        switch (mode) {
 
397
        case SP_COLOR_SCALES_MODE_RGB:
 
398
                _setRangeLimit(255.0);
 
399
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_R"));
 
400
                gtk_tooltips_set_tip (_tt, _s[0], _("Red"), NULL);
 
401
                gtk_tooltips_set_tip (_tt, _b[0], _("Red"), NULL);
 
402
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_G"));
 
403
                gtk_tooltips_set_tip (_tt, _s[1], _("Green"), NULL);
 
404
                gtk_tooltips_set_tip (_tt, _b[1], _("Green"), NULL);
 
405
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_B"));
 
406
                gtk_tooltips_set_tip (_tt, _s[2], _("Blue"), NULL);
 
407
                gtk_tooltips_set_tip (_tt, _b[2], _("Blue"), NULL);
 
408
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_A"));
 
409
                gtk_tooltips_set_tip (_tt, _s[3], _("Alpha (opacity)"), NULL);
 
410
                gtk_tooltips_set_tip (_tt, _b[3], _("Alpha (opacity)"), NULL);
 
411
                sp_color_slider_set_map (SP_COLOR_SLIDER (_s[0]), NULL);
 
412
                gtk_widget_hide (_l[4]);
 
413
                gtk_widget_hide (_s[4]);
 
414
                gtk_widget_hide (_b[4]);
 
415
                _updating = TRUE;
 
416
                setScaled( _a[0], rgba[0] );
 
417
                setScaled( _a[1], rgba[1] );
 
418
                setScaled( _a[2], rgba[2] );
 
419
                setScaled( _a[3], rgba[3] );
 
420
                _updating = FALSE;
 
421
                _updateSliders( CSC_CHANNELS_ALL );
 
422
                break;
 
423
        case SP_COLOR_SCALES_MODE_HSV:
 
424
                _setRangeLimit(255.0);
 
425
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_H"));
 
426
                gtk_tooltips_set_tip (_tt, _s[0], _("Hue"), NULL);
 
427
                gtk_tooltips_set_tip (_tt, _b[0], _("Hue"), NULL);
 
428
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_S"));
 
429
                gtk_tooltips_set_tip (_tt, _s[1], _("Saturation"), NULL);
 
430
                gtk_tooltips_set_tip (_tt, _b[1], _("Saturation"), NULL);
 
431
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_L"));
 
432
                gtk_tooltips_set_tip (_tt, _s[2], _("Lightness"), NULL);
 
433
                gtk_tooltips_set_tip (_tt, _b[2], _("Lightness"), NULL);
 
434
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_A"));
 
435
                gtk_tooltips_set_tip (_tt, _s[3], _("Alpha (opacity)"), NULL);
 
436
                gtk_tooltips_set_tip (_tt, _b[3], _("Alpha (opacity)"), NULL);
 
437
                sp_color_slider_set_map (SP_COLOR_SLIDER (_s[0]), (guchar*)sp_color_scales_hue_map ());
 
438
                gtk_widget_hide (_l[4]);
 
439
                gtk_widget_hide (_s[4]);
 
440
                gtk_widget_hide (_b[4]);
 
441
                _updating = TRUE;
 
442
                c[0] = 0.0;
 
443
                sp_color_rgb_to_hsl_floatv (c, rgba[0], rgba[1], rgba[2]);
 
444
                setScaled( _a[0], c[0] );
 
445
                setScaled( _a[1], c[1] );
 
446
                setScaled( _a[2], c[2] );
 
447
                setScaled( _a[3], rgba[3] );
 
448
                _updating = FALSE;
 
449
                _updateSliders( CSC_CHANNELS_ALL );
 
450
                break;
 
451
        case SP_COLOR_SCALES_MODE_CMYK:
 
452
                _setRangeLimit(100.0);
 
453
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_C"));
 
454
                gtk_tooltips_set_tip (_tt, _s[0], _("Cyan"), NULL);
 
455
                gtk_tooltips_set_tip (_tt, _b[0], _("Cyan"), NULL);
 
456
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_M"));
 
457
                gtk_tooltips_set_tip (_tt, _s[1], _("Magenta"), NULL);
 
458
                gtk_tooltips_set_tip (_tt, _b[1], _("Magenta"), NULL);
 
459
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_Y"));
 
460
                gtk_tooltips_set_tip (_tt, _s[2], _("Yellow"), NULL);
 
461
                gtk_tooltips_set_tip (_tt, _b[2], _("Yellow"), NULL);
 
462
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_K"));
 
463
                gtk_tooltips_set_tip (_tt, _s[3], _("Black"), NULL);
 
464
                gtk_tooltips_set_tip (_tt, _b[3], _("Black"), NULL);
 
465
                gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[4]), _("_A"));
 
466
                gtk_tooltips_set_tip (_tt, _s[4], _("Alpha (opacity)"), NULL);
 
467
                gtk_tooltips_set_tip (_tt, _b[4], _("Alpha (opacity)"), NULL);
 
468
                sp_color_slider_set_map (SP_COLOR_SLIDER (_s[0]), NULL);
 
469
                gtk_widget_show (_l[4]);
 
470
                gtk_widget_show (_s[4]);
 
471
                gtk_widget_show (_b[4]);
 
472
                _updating = TRUE;
 
473
                sp_color_rgb_to_cmyk_floatv (c, rgba[0], rgba[1], rgba[2]);
 
474
                setScaled( _a[0], c[0] );
 
475
                setScaled( _a[1], c[1] );
 
476
                setScaled( _a[2], c[2] );
 
477
                setScaled( _a[3], c[3] );
 
478
                setScaled( _a[4], rgba[3] );
 
479
                _updating = FALSE;
 
480
                _updateSliders( CSC_CHANNELS_ALL );
 
481
                break;
 
482
        default:
 
483
                g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__);
 
484
                break;
 
485
        }
 
486
}
 
487
 
 
488
SPColorScalesMode ColorScales::getMode() const
 
489
{
 
490
        return _mode;
 
491
}
 
492
 
 
493
void ColorScales::setSubmode( guint submode )
 
494
{
 
495
        g_return_if_fail (_csel != NULL);
 
496
        g_return_if_fail (SP_IS_COLOR_SCALES (_csel));
 
497
        g_return_if_fail (submode < 3);
 
498
 
 
499
        switch ( submode )
 
500
        {
 
501
        default:
 
502
        case 0:
 
503
                setMode(SP_COLOR_SCALES_MODE_RGB);
 
504
                break;
 
505
        case 1:
 
506
                setMode(SP_COLOR_SCALES_MODE_HSV);
 
507
                break;
 
508
        case 2:
 
509
                setMode(SP_COLOR_SCALES_MODE_CMYK);
 
510
                break;
 
511
        }
 
512
}
 
513
 
 
514
guint ColorScales::getSubmode() const
 
515
{
 
516
        guint submode = 0;
 
517
 
 
518
        switch ( _mode )
 
519
        {
 
520
        case SP_COLOR_SCALES_MODE_HSV:
 
521
                submode = 1;
 
522
                break;
 
523
        case SP_COLOR_SCALES_MODE_CMYK:
 
524
                submode = 2;
 
525
                break;
 
526
        case SP_COLOR_SCALES_MODE_RGB:
 
527
        default:
 
528
                submode = 0;
 
529
        }
 
530
 
 
531
        return submode;
 
532
}
 
533
 
 
534
void ColorScales::_adjustmentAnyChanged( GtkAdjustment *adjustment, SPColorScales *cs )
 
535
{
 
536
        gint channel = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (adjustment), "channel"));
 
537
 
 
538
        _adjustmentChanged(cs, channel);
 
539
}
 
540
 
 
541
void ColorScales::_sliderAnyGrabbed( SPColorSlider *slider, SPColorScales *cs )
 
542
{
 
543
    (void)slider;
 
544
    ColorScales* scales = (ColorScales*)(SP_COLOR_SELECTOR(cs)->base);
 
545
        if (!scales->_dragging) {
 
546
                scales->_dragging = TRUE;
 
547
        scales->_grabbed();
 
548
        scales->_recalcColor( FALSE );
 
549
        }
 
550
}
 
551
 
 
552
void ColorScales::_sliderAnyReleased( SPColorSlider *slider, SPColorScales *cs )
 
553
{
 
554
    (void)slider;
 
555
    ColorScales* scales = (ColorScales*)(SP_COLOR_SELECTOR(cs)->base);
 
556
        if (scales->_dragging) {
 
557
                scales->_dragging = FALSE;
 
558
        scales->_released();
 
559
        scales->_recalcColor( FALSE );
 
560
        }
 
561
}
 
562
 
 
563
void ColorScales::_sliderAnyChanged( SPColorSlider *slider, SPColorScales *cs )
 
564
{
 
565
    (void)slider;
 
566
    ColorScales* scales = (ColorScales*)(SP_COLOR_SELECTOR(cs)->base);
 
567
 
 
568
    scales->_recalcColor( TRUE );
 
569
}
 
570
 
 
571
void ColorScales::_adjustmentChanged( SPColorScales *cs, guint channel )
 
572
{
 
573
        ColorScales* scales = (ColorScales*)(SP_COLOR_SELECTOR(cs)->base);
 
574
        if (scales->_updating) return;
 
575
 
 
576
        scales->_updating = TRUE;
 
577
 
 
578
        scales->_updateSliders( (1 << channel) );
 
579
 
 
580
        scales->_recalcColor (TRUE);
 
581
 
 
582
        scales->_updating = FALSE;
 
583
}
 
584
 
 
585
void ColorScales::_updateSliders( guint channels )
 
586
{
 
587
        gfloat rgb0[3], rgbm[3], rgb1[3];
 
588
#ifdef SPCS_PREVIEW
 
589
        guint32 rgba;
 
590
#endif
 
591
        switch (_mode) {
 
592
        case SP_COLOR_SCALES_MODE_RGB:
 
593
                if ((channels != CSC_CHANNEL_R) && (channels != CSC_CHANNEL_A)) {
 
594
                        /* Update red */
 
595
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[0]),
 
596
                                                        SP_RGBA32_F_COMPOSE (0.0, getScaled(_a[1]), getScaled(_a[2]), 1.0),
 
597
                                                        SP_RGBA32_F_COMPOSE (0.5, getScaled(_a[1]), getScaled(_a[2]), 1.0),
 
598
                                                        SP_RGBA32_F_COMPOSE (1.0, getScaled(_a[1]), getScaled(_a[2]), 1.0));
 
599
                }
 
600
                if ((channels != CSC_CHANNEL_G) && (channels != CSC_CHANNEL_A)) {
 
601
                        /* Update green */
 
602
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[1]),
 
603
                                                        SP_RGBA32_F_COMPOSE (getScaled(_a[0]), 0.0, getScaled(_a[2]), 1.0),
 
604
                                                        SP_RGBA32_F_COMPOSE (getScaled(_a[0]), 0.5, getScaled(_a[2]), 1.0),
 
605
                                                        SP_RGBA32_F_COMPOSE (getScaled(_a[0]), 1.0, getScaled(_a[2]), 1.0));
 
606
                }
 
607
                if ((channels != CSC_CHANNEL_B) && (channels != CSC_CHANNEL_A)) {
 
608
                        /* Update blue */
 
609
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[2]),
 
610
                                                        SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 0.0, 1.0),
 
611
                                                        SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 0.5, 1.0),
 
612
                                                        SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 1.0, 1.0));
 
613
                }
 
614
                if (channels != CSC_CHANNEL_A) {
 
615
                        /* Update alpha */
 
616
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[3]),
 
617
                                                        SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.0),
 
618
                                                        SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.5),
 
619
                                                        SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 1.0));
 
620
                }
 
621
                break;
 
622
        case SP_COLOR_SCALES_MODE_HSV:
 
623
                /* Hue is never updated */
 
624
                if ((channels != CSC_CHANNEL_S) && (channels != CSC_CHANNEL_A)) {
 
625
                        /* Update saturation */
 
626
                        sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), 0.0, getScaled(_a[2]));
 
627
                        sp_color_hsl_to_rgb_floatv (rgbm, getScaled(_a[0]), 0.5, getScaled(_a[2]));
 
628
                        sp_color_hsl_to_rgb_floatv (rgb1, getScaled(_a[0]), 1.0, getScaled(_a[2]));
 
629
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[1]),
 
630
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
 
631
                                                        SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
 
632
                                                        SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
 
633
                }
 
634
                if ((channels != CSC_CHANNEL_V) && (channels != CSC_CHANNEL_A)) {
 
635
                        /* Update value */
 
636
                        sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), 0.0);
 
637
                        sp_color_hsl_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), 0.5);
 
638
                        sp_color_hsl_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), 1.0);
 
639
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[2]),
 
640
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
 
641
                                                        SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
 
642
                                                        SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
 
643
                }
 
644
                if (channels != CSC_CHANNEL_A) {
 
645
                        /* Update alpha */
 
646
                        sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]));
 
647
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[3]),
 
648
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.0),
 
649
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.5),
 
650
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0));
 
651
                }
 
652
                break;
 
653
        case SP_COLOR_SCALES_MODE_CMYK:
 
654
                if ((channels != CSC_CHANNEL_C) && (channels != CSC_CHANNEL_CMYKA)) {
 
655
                        /* Update C */
 
656
                        sp_color_cmyk_to_rgb_floatv (rgb0, 0.0, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3]));
 
657
                        sp_color_cmyk_to_rgb_floatv (rgbm, 0.5, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3]));
 
658
                        sp_color_cmyk_to_rgb_floatv (rgb1, 1.0, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3]));
 
659
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[0]),
 
660
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
 
661
                                                        SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
 
662
                                                        SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
 
663
                }
 
664
                if ((channels != CSC_CHANNEL_M) && (channels != CSC_CHANNEL_CMYKA)) {
 
665
                        /* Update M */
 
666
                        sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), 0.0, getScaled(_a[2]), getScaled(_a[3]));
 
667
                        sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), 0.5, getScaled(_a[2]), getScaled(_a[3]));
 
668
                        sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), 1.0, getScaled(_a[2]), getScaled(_a[3]));
 
669
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[1]),
 
670
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
 
671
                                                        SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
 
672
                                                        SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
 
673
                }
 
674
                if ((channels != CSC_CHANNEL_Y) && (channels != CSC_CHANNEL_CMYKA)) {
 
675
                        /* Update Y */
 
676
                        sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), 0.0, getScaled(_a[3]));
 
677
                        sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), 0.5, getScaled(_a[3]));
 
678
                        sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), 1.0, getScaled(_a[3]));
 
679
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[2]),
 
680
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
 
681
                                                        SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
 
682
                                                        SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
 
683
                }
 
684
                if ((channels != CSC_CHANNEL_K) && (channels != CSC_CHANNEL_CMYKA)) {
 
685
                        /* Update K */
 
686
                        sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.0);
 
687
                        sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.5);
 
688
                        sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 1.0);
 
689
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[3]),
 
690
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0),
 
691
                                                        SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0),
 
692
                                                        SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0));
 
693
                }
 
694
                if (channels != CSC_CHANNEL_CMYKA) {
 
695
                        /* Update alpha */
 
696
                        sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3]));
 
697
                        sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[4]),
 
698
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.0),
 
699
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.5),
 
700
                                                        SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0));
 
701
                }
 
702
                break;
 
703
        default:
 
704
                g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__);
 
705
                break;
 
706
        }
 
707
 
 
708
        // Force the internal color to be updated
 
709
    if ( !_updating )
 
710
    {
 
711
        _recalcColor( TRUE );
 
712
    }
 
713
 
 
714
#ifdef SPCS_PREVIEW
 
715
        rgba = sp_color_scales_get_rgba32 (cs);
 
716
        sp_color_preview_set_rgba32 (SP_COLOR_PREVIEW (_p), rgba);
 
717
#endif
 
718
}
 
719
 
 
720
static const gchar *
 
721
sp_color_scales_hue_map (void)
 
722
{
 
723
        static gchar *map = NULL;
 
724
 
 
725
        if (!map) {
 
726
                gchar *p;
 
727
                gint h;
 
728
                map = g_new (gchar, 4 * 1024);
 
729
                p = map;
 
730
                for (h = 0; h < 1024; h++) {
 
731
                        gfloat rgb[3];
 
732
                        sp_color_hsl_to_rgb_floatv (rgb, h / 1024.0, 1.0, 0.5);
 
733
                        *p++ = SP_COLOR_F_TO_U (rgb[0]);
 
734
                        *p++ = SP_COLOR_F_TO_U (rgb[1]);
 
735
                        *p++ = SP_COLOR_F_TO_U (rgb[2]);
 
736
                        *p++ = 255;
 
737
                }
 
738
        }
 
739
 
 
740
        return map;
 
741
}
 
742
 
 
743