← Back to branch summary

~ubuntu-branches/ubuntu/breezy/gimp/breezy

« back to all changes in this revision

Viewing changes to plug-ins/print/gimp_color_window.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2005-10-04 19:04:46 UTC
  • Revision ID: james.westby@ubuntu.com-20051004190446-ukh32kwk56s4sjhu
Tags: upstream-2.2.8
Import upstream version 2.2.8

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/print/gimp_color_window.c
 
1
/*
 
2
 * "$Id: gimp_color_window.c,v 1.16 2004/11/04 10:06:22 mitch Exp $"
 
3
 *
 
4
 *   Main window code for Print plug-in for the GIMP.
 
5
 *
 
6
 *   Copyright 1997-2000 Michael Sweet (mike@easysw.com),
 
7
 *      Robert Krawitz (rlk@alum.mit.edu), Steve Miller (smiller@rni.net)
 
8
 *      and Michael Natterer (mitch@gimp.org)
 
9
 *
 
10
 *   This program is free software; you can redistribute it and/or modify it
 
11
 *   under the terms of the GNU General Public License as published by the Free
 
12
 *   Software Foundation; either version 2 of the License, or (at your option)
 
13
 *   any later version.
 
14
 *
 
15
 *   This program is distributed in the hope that it will be useful, but
 
16
 *   WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
17
 *   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 
18
 *   for more details.
 
19
 *
 
20
 *   You should have received a copy of the GNU General Public License
 
21
 *   along with this program; if not, write to the Free Software
 
22
 *   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
23
 */
 
24
 
 
25
#include "config.h"
 
26
 
 
27
#include <string.h>
 
28
 
 
29
#ifdef __GNUC__
 
30
#warning GTK_DISABLE_DEPRECATED
 
31
#endif
 
32
#undef GTK_DISABLE_DEPRECATED
 
33
 
 
34
#include <gtk/gtk.h>
 
35
 
 
36
#include <gimp-print/gimp-print.h>
 
37
 
 
38
#include "libgimp/gimp.h"
 
39
#include "libgimp/gimpui.h"
 
40
 
 
41
#include "print_gimp.h"
 
42
 
 
43
#include "libgimp/stdplugins-intl.h"
 
44
 
 
45
#define RESPONSE_RESET 1
 
46
 
 
47
gint    thumbnail_w, thumbnail_h, thumbnail_bpp;
 
48
guchar *thumbnail_data;
 
49
gint    adjusted_thumbnail_bpp;
 
50
guchar *adjusted_thumbnail_data;
 
51
 
 
52
GtkWidget *gimp_color_adjust_dialog;
 
53
 
 
54
static GtkObject *brightness_adjustment;
 
55
static GtkObject *saturation_adjustment;
 
56
static GtkObject *density_adjustment;
 
57
static GtkObject *contrast_adjustment;
 
58
static GtkObject *cyan_adjustment;
 
59
static GtkObject *magenta_adjustment;
 
60
static GtkObject *yellow_adjustment;
 
61
static GtkObject *gamma_adjustment;
 
62
 
 
63
GtkWidget   *dither_algo_combo       = NULL;
 
64
static gint  dither_algo_callback_id = -1;
 
65
 
 
66
static void gimp_brightness_update    (GtkAdjustment *adjustment);
 
67
static void gimp_saturation_update    (GtkAdjustment *adjustment);
 
68
static void gimp_density_update       (GtkAdjustment *adjustment);
 
69
static void gimp_contrast_update      (GtkAdjustment *adjustment);
 
70
static void gimp_cyan_update          (GtkAdjustment *adjustment);
 
71
static void gimp_magenta_update       (GtkAdjustment *adjustment);
 
72
static void gimp_yellow_update        (GtkAdjustment *adjustment);
 
73
static void gimp_gamma_update         (GtkAdjustment *adjustment);
 
74
static void gimp_set_color_defaults   (void);
 
75
 
 
76
static void gimp_dither_algo_callback (GtkWidget *widget,
 
77
                                       gpointer   data);
 
78
 
 
79
 
 
80
void        gimp_build_dither_combo   (void);
 
81
 
 
82
static GtkWidget *swatch = NULL;
 
83
 
 
84
static void
 
85
gimp_dither_algo_callback (GtkWidget *widget,
 
86
                           gpointer   data)
 
87
{
 
88
  const gchar *new_algo =
 
89
    gtk_entry_get_text (GTK_ENTRY (GTK_COMBO (dither_algo_combo)->entry));
 
90
  int i;
 
91
 
 
92
  for (i = 0; i < stp_dither_algorithm_count (); i++)
 
93
    if (strcasecmp (new_algo, stp_dither_algorithm_text (i)) == 0)
 
94
      {
 
95
        stp_set_dither_algorithm (*pv, stp_dither_algorithm_name (i));
 
96
        return;
 
97
      }
 
98
 
 
99
  stp_set_dither_algorithm (*pv, stp_default_dither_algorithm ());
 
100
}
 
101
 
 
102
void
 
103
gimp_build_dither_combo (void)
 
104
{
 
105
  stp_param_t *vec = g_new (stp_param_t, stp_dither_algorithm_count());
 
106
  gint i;
 
107
 
 
108
  for (i = 0; i < stp_dither_algorithm_count(); i++)
 
109
    {
 
110
      vec[i].name = g_strdup (stp_dither_algorithm_name (i));
 
111
      vec[i].text = g_strdup (stp_dither_algorithm_text (i));
 
112
    }
 
113
 
 
114
  gimp_plist_build_combo (dither_algo_combo,
 
115
                          stp_dither_algorithm_count (),
 
116
                          vec,
 
117
                          stp_get_dither_algorithm (*pv),
 
118
                          stp_default_dither_algorithm (),
 
119
                          G_CALLBACK (gimp_dither_algo_callback),
 
120
                          &dither_algo_callback_id);
 
121
 
 
122
  for (i = 0; i < stp_dither_algorithm_count (); i++)
 
123
    {
 
124
      g_free ((void *) vec[i].name);
 
125
      g_free ((void *) vec[i].text);
 
126
    }
 
127
  g_free (vec);
 
128
}
 
129
 
 
130
void
 
131
gimp_redraw_color_swatch (void)
 
132
{
 
133
  if (swatch)
 
134
    gtk_widget_queue_draw (swatch);
 
135
}
 
136
 
 
137
static gboolean
 
138
gimp_color_swatch_expose (void)
 
139
{
 
140
  (adjusted_thumbnail_bpp == 1
 
141
   ? gdk_draw_gray_image
 
142
   : gdk_draw_rgb_image) (swatch->window,
 
143
                          swatch->style->fg_gc[GTK_STATE_NORMAL],
 
144
                          0, 0, thumbnail_w, thumbnail_h,
 
145
                          GDK_RGB_DITHER_NORMAL,
 
146
                          adjusted_thumbnail_data,
 
147
                          adjusted_thumbnail_bpp * thumbnail_w);
 
148
 
 
149
  return FALSE;
 
150
}
 
151
 
 
152
static void
 
153
gimp_color_adjust_response (GtkWidget *widget,
 
154
                            gint       response_id,
 
155
                            gpointer   data)
 
156
{
 
157
  if (response_id == RESPONSE_RESET)
 
158
    {
 
159
      gimp_set_color_defaults ();
 
160
    }
 
161
  else
 
162
    {
 
163
      gtk_widget_hide (widget);
 
164
    }
 
165
}
 
166
 
 
167
/*
 
168
 * gimp_create_color_adjust_window (void)
 
169
 *
 
170
 * NOTES:
 
171
 *   creates the color adjuster popup, allowing the user to adjust brightness,
 
172
 *   contrast, saturation, etc.
 
173
 */
 
174
void
 
175
gimp_create_color_adjust_window (void)
 
176
{
 
177
  GtkWidget *vbox;
 
178
  GtkWidget *hbox;
 
179
  GtkWidget *frame;
 
180
  GtkWidget *table;
 
181
  GtkWidget *event_box;
 
182
 
 
183
  const stp_vars_t lower   = stp_minimum_settings ();
 
184
  const stp_vars_t upper   = stp_maximum_settings ();
 
185
  const stp_vars_t defvars = stp_default_settings ();
 
186
 
 
187
  /*
 
188
   * Fetch a thumbnail of the image we're to print from the Gimp.  This must
 
189
   *
 
190
   */
 
191
 
 
192
  thumbnail_w = THUMBNAIL_MAXW;
 
193
  thumbnail_h = THUMBNAIL_MAXH;
 
194
  thumbnail_data = gimp_image_get_thumbnail_data (image_ID,
 
195
                                                  &thumbnail_w,
 
196
                                                  &thumbnail_h,
 
197
                                                  &thumbnail_bpp);
 
198
 
 
199
  /*
 
200
   * thumbnail_w and thumbnail_h have now been adjusted to the actual
 
201
   * thumbnail dimensions.  Now initialize a color-adjusted version of
 
202
   * the thumbnail.
 
203
   */
 
204
 
 
205
  adjusted_thumbnail_data = g_malloc (3 * thumbnail_w * thumbnail_h);
 
206
 
 
207
  gimp_color_adjust_dialog =
 
208
    gimp_dialog_new (_("Print Color Adjust"), "print",
 
209
                     NULL, 0,
 
210
                     gimp_standard_help_func, "file-print-gimp",
 
211
 
 
212
                     GIMP_STOCK_RESET, RESPONSE_RESET,
 
213
                     GTK_STOCK_CLOSE,  GTK_RESPONSE_CLOSE,
 
214
 
 
215
                     NULL);
 
216
 
 
217
  gtk_dialog_set_default_response (GTK_DIALOG (gimp_color_adjust_dialog),
 
218
                                   GTK_RESPONSE_CLOSE);
 
219
 
 
220
  g_signal_connect (gimp_color_adjust_dialog, "response",
 
221
                    G_CALLBACK (gimp_color_adjust_response),
 
222
                    NULL);
 
223
 
 
224
  vbox = gtk_vbox_new (FALSE, 12);
 
225
  gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
 
226
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (gimp_color_adjust_dialog)->vbox),
 
227
                      vbox, FALSE, FALSE, 0);
 
228
  gtk_widget_show (vbox);
 
229
 
 
230
  /*
 
231
   * Drawing area for color swatch feedback display...
 
232
   */
 
233
 
 
234
  hbox = gtk_hbox_new (FALSE, 0);
 
235
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 
236
  gtk_widget_show (hbox);
 
237
 
 
238
  frame = gtk_frame_new (NULL);
 
239
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
 
240
  gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
 
241
  gtk_widget_show (frame);
 
242
 
 
243
  swatch = gtk_drawing_area_new ();
 
244
  gtk_widget_set_size_request (swatch, thumbnail_w, thumbnail_h);
 
245
  gtk_container_add (GTK_CONTAINER (frame), swatch);
 
246
  gtk_widget_show (swatch);
 
247
 
 
248
  g_signal_connect (swatch, "expose_event",
 
249
                    G_CALLBACK (gimp_color_swatch_expose),
 
250
                    NULL);
 
251
 
 
252
 
 
253
  table = gtk_table_new (9, 3, FALSE);
 
254
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
 
255
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 
256
  gtk_table_set_row_spacing (GTK_TABLE (table), 1, 12);
 
257
  gtk_table_set_row_spacing (GTK_TABLE (table), 4, 12);
 
258
  gtk_table_set_row_spacing (GTK_TABLE (table), 7, 12);
 
259
  gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
 
260
  gtk_widget_show (table);
 
261
 
 
262
 
 
263
  /*
 
264
   * Brightness slider...
 
265
   */
 
266
 
 
267
  brightness_adjustment =
 
268
    gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("Brightness:"), 200, 0,
 
269
                          stp_get_brightness (defvars),
 
270
                          stp_get_brightness (lower),
 
271
                          stp_get_brightness (upper),
 
272
                          stp_get_brightness (defvars) / 100,
 
273
                          stp_get_brightness (defvars) / 10,
 
274
                          3, TRUE, 0, 0, NULL, NULL);
 
275
  set_adjustment_tooltip (brightness_adjustment,
 
276
                          _("Set the brightness of the print.\n"
 
277
                            "0 is solid black, 2 is solid white"),
 
278
                          NULL);
 
279
  g_signal_connect (brightness_adjustment, "value_changed",
 
280
                    G_CALLBACK (gimp_brightness_update),
 
281
                    NULL);
 
282
 
 
283
  /*
 
284
   * Contrast slider...
 
285
   */
 
286
 
 
287
  contrast_adjustment =
 
288
    gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("Contrast:"), 200, 0,
 
289
                          stp_get_contrast (defvars),
 
290
                          stp_get_contrast (lower),
 
291
                          stp_get_contrast (upper),
 
292
                          stp_get_contrast (defvars) / 100,
 
293
                          stp_get_contrast (defvars) / 10,
 
294
                          3, TRUE, 0, 0, NULL, NULL);
 
295
  set_adjustment_tooltip (contrast_adjustment,
 
296
                          _("Set the contrast of the print"),
 
297
                          NULL);
 
298
  g_signal_connect (contrast_adjustment, "value_changed",
 
299
                    G_CALLBACK (gimp_contrast_update),
 
300
                    NULL);
 
301
 
 
302
  /*
 
303
   * Cyan slider...
 
304
   */
 
305
 
 
306
  cyan_adjustment =
 
307
    gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("Cyan:"), 200, 0,
 
308
                          stp_get_cyan (defvars),
 
309
                          stp_get_cyan (lower),
 
310
                          stp_get_cyan (upper),
 
311
                          stp_get_cyan (defvars) / 100,
 
312
                          stp_get_cyan (defvars) / 10,
 
313
                          3, TRUE, 0, 0, NULL, NULL);
 
314
  set_adjustment_tooltip (cyan_adjustment,
 
315
                          _("Adjust the cyan balance of the print"),
 
316
                          NULL);
 
317
  g_signal_connect (cyan_adjustment, "value_changed",
 
318
                    G_CALLBACK (gimp_cyan_update),
 
319
                    NULL);
 
320
 
 
321
  /*
 
322
   * Magenta slider...
 
323
   */
 
324
 
 
325
  magenta_adjustment =
 
326
    gimp_scale_entry_new (GTK_TABLE (table), 0, 3, _("Magenta:"), 200, 0,
 
327
                          stp_get_magenta (defvars),
 
328
                          stp_get_magenta (lower),
 
329
                          stp_get_magenta (upper),
 
330
                          stp_get_magenta (defvars) / 100,
 
331
                          stp_get_magenta (defvars) / 10,
 
332
                          3, TRUE, 0, 0, NULL, NULL);
 
333
  set_adjustment_tooltip (magenta_adjustment,
 
334
                          _("Adjust the magenta balance of the print"),
 
335
                          NULL);
 
336
  g_signal_connect (magenta_adjustment, "value_changed",
 
337
                    G_CALLBACK (gimp_magenta_update),
 
338
                    NULL);
 
339
 
 
340
  /*
 
341
   * Yellow slider...
 
342
   */
 
343
 
 
344
  yellow_adjustment =
 
345
    gimp_scale_entry_new (GTK_TABLE (table), 0, 4, _("Yellow:"), 200, 0,
 
346
                          stp_get_yellow (defvars),
 
347
                          stp_get_yellow (lower),
 
348
                          stp_get_yellow (upper),
 
349
                          stp_get_yellow (defvars) / 100,
 
350
                          stp_get_yellow (defvars) / 10,
 
351
                          3, TRUE, 0, 0, NULL, NULL);
 
352
  set_adjustment_tooltip (yellow_adjustment,
 
353
                          _("Adjust the yellow balance of the print"),
 
354
                          NULL);
 
355
  g_signal_connect (yellow_adjustment, "value_changed",
 
356
                    G_CALLBACK (gimp_yellow_update),
 
357
                    NULL);
 
358
 
 
359
  /*
 
360
   * Saturation slider...
 
361
   */
 
362
 
 
363
  saturation_adjustment =
 
364
    gimp_scale_entry_new (GTK_TABLE (table), 0, 5, _("Saturation:"), 200, 0,
 
365
                          stp_get_saturation (defvars),
 
366
                          stp_get_saturation (lower),
 
367
                          stp_get_saturation (upper),
 
368
                          stp_get_saturation (defvars) / 1000,
 
369
                          stp_get_saturation (defvars) / 100,
 
370
                          3, TRUE, 0, 0, NULL, NULL);
 
371
  set_adjustment_tooltip (saturation_adjustment,
 
372
                          _("Adjust the saturation (color balance) of the print\n"
 
373
                            "Use zero saturation to produce grayscale output "
 
374
                            "using color and black inks"),
 
375
                          NULL);
 
376
  g_signal_connect (saturation_adjustment, "value_changed",
 
377
                    G_CALLBACK (gimp_saturation_update),
 
378
                    NULL);
 
379
 
 
380
  /*
 
381
   * Density slider...
 
382
   */
 
383
 
 
384
  density_adjustment =
 
385
    gimp_scale_entry_new (GTK_TABLE (table), 0, 6, _("Density:"), 200, 0,
 
386
                          stp_get_density (defvars),
 
387
                          stp_get_density (lower),
 
388
                          stp_get_density (upper),
 
389
                          stp_get_density (defvars) / 1000,
 
390
                          stp_get_density (defvars) / 100,
 
391
                          3, TRUE, 0, 0, NULL, NULL);
 
392
  set_adjustment_tooltip (density_adjustment,
 
393
                          _("Adjust the density (amount of ink) of the print. "
 
394
                            "Reduce the density if the ink bleeds through the "
 
395
                            "paper or smears; increase the density if black "
 
396
                            "regions are not solid."),
 
397
                          NULL);
 
398
  g_signal_connect (density_adjustment, "value_changed",
 
399
                    G_CALLBACK (gimp_density_update),
 
400
                    NULL);
 
401
 
 
402
  /*
 
403
   * Gamma slider...
 
404
   */
 
405
 
 
406
  gamma_adjustment =
 
407
    gimp_scale_entry_new (GTK_TABLE (table), 0, 7, _("Gamma:"), 200, 0,
 
408
                          stp_get_gamma (defvars),
 
409
                          stp_get_gamma (lower),
 
410
                          stp_get_gamma (upper),
 
411
                          stp_get_gamma (defvars) / 1000,
 
412
                          stp_get_gamma (defvars) / 100,
 
413
                          3, TRUE, 0, 0, NULL, NULL);
 
414
  set_adjustment_tooltip (gamma_adjustment,
 
415
                          _("Adjust the gamma of the print. Larger values will "
 
416
                            "produce a generally brighter print, while smaller "
 
417
                            "values will produce a generally darker print. "
 
418
                            "Black and white will remain the same, unlike with "
 
419
                            "the brightness adjustment."),
 
420
                          NULL);
 
421
  g_signal_connect (gamma_adjustment, "value_changed",
 
422
                    G_CALLBACK (gimp_gamma_update),
 
423
                    NULL);
 
424
 
 
425
  /*
 
426
   * Dither algorithm option combo...
 
427
   */
 
428
 
 
429
 
 
430
  event_box = gtk_event_box_new ();
 
431
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 8,
 
432
                             _("Dither Algorithm:"), 0.0, 0.5,
 
433
                             event_box, 2, FALSE);
 
434
 
 
435
  dither_algo_combo = gtk_combo_new ();
 
436
  gtk_container_add (GTK_CONTAINER(event_box), dither_algo_combo);
 
437
  gtk_widget_show (dither_algo_combo);
 
438
 
 
439
  gimp_help_set_help_data (GTK_WIDGET (event_box),
 
440
                           _("Choose the dither algorithm to be used.\n"
 
441
                             "Adaptive Hybrid usually produces the best "
 
442
                             "all-around quality.\n"
 
443
                             "Ordered is faster and produces almost as good "
 
444
                             "quality on photographs.\n"
 
445
                             "Fast and Very Fast are considerably faster, and "
 
446
                             "work well for text and line art.\n"
 
447
                             "Hybrid Floyd-Steinberg generally produces "
 
448
                             "inferior output."),
 
449
                           NULL);
 
450
 
 
451
  gimp_build_dither_combo ();
 
452
}
 
453
 
 
454
static void
 
455
gimp_brightness_update (GtkAdjustment *adjustment)
 
456
{
 
457
  gimp_invalidate_preview_thumbnail ();
 
458
  if (stp_get_brightness (*pv) != adjustment->value)
 
459
    {
 
460
      stp_set_brightness (*pv, adjustment->value);
 
461
      gimp_update_adjusted_thumbnail ();
 
462
    }
 
463
}
 
464
 
 
465
static void
 
466
gimp_contrast_update (GtkAdjustment *adjustment)
 
467
{
 
468
  gimp_invalidate_preview_thumbnail ();
 
469
 
 
470
  if (stp_get_contrast (*pv) != adjustment->value)
 
471
    {
 
472
      stp_set_contrast (*pv, adjustment->value);
 
473
      gimp_update_adjusted_thumbnail ();
 
474
    }
 
475
}
 
476
 
 
477
static void
 
478
gimp_cyan_update (GtkAdjustment *adjustment)
 
479
{
 
480
  gimp_invalidate_preview_thumbnail ();
 
481
 
 
482
  if (stp_get_cyan (*pv) != adjustment->value)
 
483
    {
 
484
      stp_set_cyan (*pv, adjustment->value);
 
485
      gimp_update_adjusted_thumbnail ();
 
486
    }
 
487
}
 
488
 
 
489
static void
 
490
gimp_magenta_update (GtkAdjustment *adjustment)
 
491
{
 
492
  gimp_invalidate_preview_thumbnail ();
 
493
 
 
494
  if (stp_get_magenta (*pv) != adjustment->value)
 
495
    {
 
496
      stp_set_magenta (*pv, adjustment->value);
 
497
      gimp_update_adjusted_thumbnail ();
 
498
    }
 
499
}
 
500
 
 
501
static void
 
502
gimp_yellow_update (GtkAdjustment *adjustment)
 
503
{
 
504
  gimp_invalidate_preview_thumbnail ();
 
505
 
 
506
  if (stp_get_yellow (*pv) != adjustment->value)
 
507
    {
 
508
      stp_set_yellow (*pv, adjustment->value);
 
509
      gimp_update_adjusted_thumbnail ();
 
510
    }
 
511
}
 
512
 
 
513
static void
 
514
gimp_saturation_update (GtkAdjustment *adjustment)
 
515
{
 
516
  gimp_invalidate_preview_thumbnail ();
 
517
 
 
518
  if (stp_get_saturation (*pv) != adjustment->value)
 
519
    {
 
520
      stp_set_saturation (*pv, adjustment->value);
 
521
      gimp_update_adjusted_thumbnail ();
 
522
    }
 
523
}
 
524
 
 
525
static void
 
526
gimp_density_update (GtkAdjustment *adjustment)
 
527
{
 
528
  if (stp_get_density (*pv) != adjustment->value)
 
529
    {
 
530
      stp_set_density (*pv, adjustment->value);
 
531
    }
 
532
}
 
533
 
 
534
static void
 
535
gimp_gamma_update (GtkAdjustment *adjustment)
 
536
{
 
537
  gimp_invalidate_preview_thumbnail ();
 
538
 
 
539
  if (stp_get_gamma (*pv) != adjustment->value)
 
540
    {
 
541
      stp_set_gamma (*pv, adjustment->value);
 
542
      gimp_update_adjusted_thumbnail ();
 
543
    }
 
544
}
 
545
 
 
546
static void
 
547
gimp_set_adjustment_active (GtkObject *adj,
 
548
                            gboolean   active)
 
549
{
 
550
  gtk_widget_set_sensitive (GTK_WIDGET (GIMP_SCALE_ENTRY_LABEL (adj)), active);
 
551
  gtk_widget_set_sensitive (GTK_WIDGET (GIMP_SCALE_ENTRY_SCALE (adj)), active);
 
552
  gtk_widget_set_sensitive (GTK_WIDGET (GIMP_SCALE_ENTRY_SPINBUTTON (adj)),
 
553
                            active);
 
554
}
 
555
 
 
556
void
 
557
gimp_set_color_sliders_active (gboolean active)
 
558
{
 
559
  gimp_set_adjustment_active (cyan_adjustment, active);
 
560
  gimp_set_adjustment_active (magenta_adjustment, active);
 
561
  gimp_set_adjustment_active (yellow_adjustment, active);
 
562
  gimp_set_adjustment_active (saturation_adjustment, active);
 
563
}
 
564
 
 
565
void
 
566
gimp_do_color_updates (void)
 
567
{
 
568
  gtk_adjustment_set_value (GTK_ADJUSTMENT (brightness_adjustment),
 
569
                            stp_get_brightness (*pv));
 
570
 
 
571
  gtk_adjustment_set_value (GTK_ADJUSTMENT (gamma_adjustment),
 
572
                            stp_get_gamma (*pv));
 
573
 
 
574
  gtk_adjustment_set_value (GTK_ADJUSTMENT (contrast_adjustment),
 
575
                            stp_get_contrast (*pv));
 
576
 
 
577
  gtk_adjustment_set_value (GTK_ADJUSTMENT (cyan_adjustment),
 
578
                            stp_get_cyan (*pv));
 
579
 
 
580
  gtk_adjustment_set_value (GTK_ADJUSTMENT (magenta_adjustment),
 
581
                            stp_get_magenta (*pv));
 
582
 
 
583
  gtk_adjustment_set_value (GTK_ADJUSTMENT (yellow_adjustment),
 
584
                            stp_get_yellow (*pv));
 
585
 
 
586
  gtk_adjustment_set_value (GTK_ADJUSTMENT (saturation_adjustment),
 
587
                            stp_get_saturation (*pv));
 
588
 
 
589
  gtk_adjustment_set_value (GTK_ADJUSTMENT (density_adjustment),
 
590
                            stp_get_density (*pv));
 
591
 
 
592
  gimp_update_adjusted_thumbnail ();
 
593
}
 
594
 
 
595
void
 
596
gimp_set_color_defaults (void)
 
597
{
 
598
  const stp_vars_t defvars = stp_default_settings ();
 
599
 
 
600
  stp_set_brightness (*pv, stp_get_brightness (defvars));
 
601
  stp_set_gamma (*pv, stp_get_gamma (defvars));
 
602
  stp_set_contrast (*pv, stp_get_contrast (defvars));
 
603
  stp_set_cyan (*pv, stp_get_cyan (defvars));
 
604
  stp_set_magenta (*pv, stp_get_magenta (defvars));
 
605
  stp_set_yellow (*pv, stp_get_yellow (defvars));
 
606
  stp_set_saturation (*pv, stp_get_saturation (defvars));
 
607
  stp_set_density (*pv, stp_get_density (defvars));
 
608
 
 
609
  gimp_do_color_updates ();
 
610
}