← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to plug-ins/common/channel_mixer.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2008-10-06 13:30:41 UTC
  • mto: This revision was merged to the branch mainline in revision 35.
  • Revision ID: james.westby@ubuntu.com-20081006133041-3panbkcanaymfsmp
Tags: upstream-2.6.0
Import upstream version 2.6.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/common/channel_mixer.c
1
 
/****************************************************************************
2
 
 * This is a plugin for GIMP v 2.0 or later.
3
 
 *
4
 
 * Copyright (C) 2002 Martin Guldahl <mguldahl@xmission.com>
5
 
 * Based on GTK code from:
6
 
 *    homomorphic (Copyright (C) 2001 Valter Marcus Hilden)
7
 
 *    rand-noted  (Copyright (C) 1998 Miles O'Neal)
8
 
 *    nlfilt      (Copyright (C) 1997 Eric L. Hernes)
9
 
 *    pagecurl    (Copyright (C) 1996 Federico Mena Quintero)
10
 
 *
11
 
 * This program is free software; you can redistribute it and/or modify
12
 
 * it under the terms of the GNU General Public License as published by
13
 
 * the Free Software Foundation; either version 2 of the License, or
14
 
 * (at your option) any later version.
15
 
 *
16
 
 * This program is distributed in the hope that it will be useful,
17
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
 
 * GNU General Public License for more details.
20
 
 *
21
 
 * You should have received a copy of the GNU General Public License
22
 
 * along with this program; if not, write to the Free Software
23
 
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24
 
 *
25
 
 ****************************************************************************/
26
 
 
27
 
#include "config.h"
28
 
 
29
 
#include <errno.h>
30
 
#include <string.h>
31
 
 
32
 
#include <glib/gstdio.h>
33
 
 
34
 
#include <libgimp/gimp.h>
35
 
#include <libgimp/gimpui.h>
36
 
 
37
 
#include "libgimp/stdplugins-intl.h"
38
 
 
39
 
 
40
 
#define PLUG_IN_PROC    "plug-in-colors-channel-mixer"
41
 
#define PLUG_IN_BINARY  "channel_mixer"
42
 
#define CM_LINE_SIZE    1024
43
 
 
44
 
typedef enum
45
 
{
46
 
  CM_RED_CHANNEL,
47
 
  CM_GREEN_CHANNEL,
48
 
  CM_BLUE_CHANNEL
49
 
} CmModeType;
50
 
 
51
 
typedef struct
52
 
{
53
 
  gdouble        red_gain;
54
 
  gdouble        green_gain;
55
 
  gdouble        blue_gain;
56
 
} CmChannelType;
57
 
 
58
 
typedef struct
59
 
{
60
 
  CmChannelType  red;
61
 
  CmChannelType  green;
62
 
  CmChannelType  blue;
63
 
  CmChannelType  black;
64
 
 
65
 
  gboolean       monochrome;
66
 
  gboolean       preserve_luminosity;
67
 
 
68
 
  CmModeType     output_channel;
69
 
  gboolean       preview;
70
 
 
71
 
  GtkAdjustment *red_data;
72
 
  GtkAdjustment *green_data;
73
 
  GtkAdjustment *blue_data;
74
 
 
75
 
  GtkWidget     *combo;
76
 
 
77
 
  CmModeType     old_output_channel;
78
 
 
79
 
  GtkWidget     *monochrome_toggle;
80
 
  GtkWidget     *preserve_luminosity_toggle;
81
 
} CmParamsType;
82
 
 
83
 
 
84
 
static void     query (void);
85
 
static void     run   (const gchar      *name,
86
 
                       gint              nparams,
87
 
                       const GimpParam  *param,
88
 
                       gint             *nreturn_vals,
89
 
                       GimpParam       **return_vals);
90
 
 
91
 
static void     cm_set_defaults                 (CmParamsType     *mix);
92
 
 
93
 
static void     channel_mixer                   (CmParamsType     *mix,
94
 
                                                 GimpDrawable     *drawable);
95
 
static gboolean cm_dialog                       (CmParamsType     *mix,
96
 
                                                 GimpDrawable     *drawable);
97
 
 
98
 
static void     cm_red_scale_callback           (GtkAdjustment    *adjustment,
99
 
                                                 CmParamsType     *mix);
100
 
static void     cm_green_scale_callback         (GtkAdjustment    *adjustment,
101
 
                                                 CmParamsType     *mix);
102
 
static void     cm_blue_scale_callback          (GtkAdjustment    *adjustment,
103
 
                                                 CmParamsType     *mix);
104
 
static void     cm_monochrome_callback          (GtkWidget        *widget,
105
 
                                                 CmParamsType     *mix);
106
 
static void     cm_preserve_luminosity_callback (GtkWidget        *widget,
107
 
                                                 CmParamsType     *mix);
108
 
static void     cm_load_file_callback           (GtkWidget        *widget,
109
 
                                                 CmParamsType     *mix);
110
 
static void     cm_load_file_response_callback  (GtkWidget        *dialog,
111
 
                                                 gint              response_id,
112
 
                                                 CmParamsType     *mix);
113
 
static void     cm_save_file_callback           (GtkWidget        *widget,
114
 
                                                 CmParamsType     *mix);
115
 
static void     cm_save_file_response_callback  (GtkWidget        *dialog,
116
 
                                                 gint              response_id,
117
 
                                                 CmParamsType     *mix);
118
 
static void     cm_reset_callback               (GtkWidget        *widget,
119
 
                                                 CmParamsType     *mix);
120
 
static void     cm_combo_callback               (GtkWidget        *widget,
121
 
                                                 CmParamsType     *mix);
122
 
 
123
 
static gdouble  cm_calculate_norm               (CmParamsType     *mix,
124
 
                                                 CmChannelType    *ch);
125
 
 
126
 
static inline guchar cm_mix_pixel               (CmChannelType    *ch,
127
 
                                                 guchar            r,
128
 
                                                 guchar            g,
129
 
                                                 guchar            b,
130
 
                                                 gdouble           norm);
131
 
 
132
 
static void     cm_preview                      (CmParamsType      *mix,
133
 
                                                 GimpPreview       *preview);
134
 
static void     cm_set_adjusters                (CmParamsType      *mix);
135
 
static void     cm_update_ui                    (CmParamsType      *mix);
136
 
 
137
 
static void     cm_save_file                    (CmParamsType      *mix,
138
 
                                                 FILE              *fp);
139
 
 
140
 
 
141
 
const GimpPlugInInfo PLUG_IN_INFO =
142
 
{
143
 
  NULL,  /* init_proc  */
144
 
  NULL,  /* quit_proc  */
145
 
  query, /* query_proc */
146
 
  run    /* run_proc   */
147
 
};
148
 
 
149
 
static GtkWidget    *preview;
150
 
 
151
 
 
152
 
MAIN ()
153
 
 
154
 
static void
155
 
query (void)
156
 
{
157
 
  static const GimpParamDef args[] =
158
 
  {
159
 
    { GIMP_PDB_INT32,    "run-mode",   "Interactive, non-interactive" },
160
 
    { GIMP_PDB_IMAGE,    "image",      "Input image (unused)" },
161
 
    { GIMP_PDB_DRAWABLE, "drawable",   "Input drawable" },
162
 
    { GIMP_PDB_INT32,    "monochrome", "Monochrome (TRUE or FALSE)" },
163
 
    { GIMP_PDB_FLOAT,    "rr-gain",    "Set the red gain for the red channel" },
164
 
    { GIMP_PDB_FLOAT,    "rg-gain",    "Set the green gain for the red channel" },
165
 
    { GIMP_PDB_FLOAT,    "rb-gain",    "Set the blue gain for the red channel" },
166
 
    { GIMP_PDB_FLOAT,    "gr-gain",    "Set the red gain for the green channel" },
167
 
    { GIMP_PDB_FLOAT,    "gg-gain",    "Set the green gain for the green channel" },
168
 
    { GIMP_PDB_FLOAT,    "gb-gain",    "Set the blue gain for the green channel" },
169
 
    { GIMP_PDB_FLOAT,    "br-gain",    "Set the red gain for the blue channel" },
170
 
    { GIMP_PDB_FLOAT,    "bg-gain",    "Set the green gain for the blue channel" },
171
 
    { GIMP_PDB_FLOAT,    "bb-gain",    "Set the blue gain for the blue channel" }
172
 
  };
173
 
 
174
 
  gimp_install_procedure (PLUG_IN_PROC,
175
 
                          N_("Alter colors by mixing RGB Channels"),
176
 
                          "This plug-in mixes the RGB channels.",
177
 
                          "Martin Guldahl <mguldahl@xmission.com>",
178
 
                          "Martin Guldahl <mguldahl@xmission.com>",
179
 
                          "2002",
180
 
                          N_("Channel Mi_xer..."),
181
 
                          "RGB*",
182
 
                          GIMP_PLUGIN,
183
 
                          G_N_ELEMENTS (args), 0,
184
 
                          args, NULL);
185
 
 
186
 
  gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Colors/Components");
187
 
}
188
 
 
189
 
static void
190
 
run (const gchar      *name,
191
 
     gint              nparams,
192
 
     const GimpParam  *param,
193
 
     gint             *nreturn_vals,
194
 
     GimpParam       **return_vals)
195
 
{
196
 
  static GimpParam   values[1];
197
 
  GimpDrawable      *drawable;
198
 
  GimpRunMode        run_mode;
199
 
  CmParamsType       mix;
200
 
  GimpPDBStatusType  status = GIMP_PDB_SUCCESS;
201
 
 
202
 
  run_mode = param[0].data.d_int32;
203
 
 
204
 
  INIT_I18N ();
205
 
 
206
 
  *nreturn_vals = 1;
207
 
  *return_vals  = values;
208
 
 
209
 
  values[0].type          = GIMP_PDB_STATUS;
210
 
  values[0].data.d_status = status;
211
 
 
212
 
  drawable = gimp_drawable_get (param[2].data.d_drawable);
213
 
 
214
 
  if (gimp_drawable_is_rgb (drawable->drawable_id))
215
 
    {
216
 
      cm_set_defaults (&mix);
217
 
      mix.preview = TRUE;
218
 
 
219
 
      switch (run_mode)
220
 
        {
221
 
        case GIMP_RUN_INTERACTIVE:
222
 
          gimp_get_data (PLUG_IN_PROC, &mix);
223
 
 
224
 
          if (! cm_dialog (&mix, drawable))
225
 
            {
226
 
              gimp_drawable_detach (drawable);
227
 
              return;
228
 
            }
229
 
 
230
 
          break;
231
 
 
232
 
        case GIMP_RUN_NONINTERACTIVE:
233
 
          mix.monochrome = param[3].data.d_int32;
234
 
 
235
 
          if (mix.monochrome)
236
 
            {
237
 
              mix.black.red_gain   = param[4].data.d_float;
238
 
              mix.black.green_gain = param[5].data.d_float;
239
 
              mix.black.blue_gain  = param[6].data.d_float;
240
 
            }
241
 
          else
242
 
            {
243
 
              mix.red.red_gain     = param[4].data.d_float;
244
 
              mix.red.green_gain   = param[5].data.d_float;
245
 
              mix.red.blue_gain    = param[6].data.d_float;
246
 
 
247
 
              mix.green.red_gain   = param[7].data.d_float;
248
 
              mix.green.green_gain = param[8].data.d_float;
249
 
              mix.green.blue_gain  = param[9].data.d_float;
250
 
 
251
 
              mix.blue.red_gain    = param[10].data.d_float;
252
 
              mix.blue.green_gain  = param[11].data.d_float;
253
 
              mix.blue.blue_gain   = param[12].data.d_float;
254
 
            }
255
 
          break;
256
 
 
257
 
        case GIMP_RUN_WITH_LAST_VALS:
258
 
          gimp_get_data (PLUG_IN_PROC, &mix);
259
 
          break;
260
 
 
261
 
        default:
262
 
          break;
263
 
        }
264
 
 
265
 
      if (status == GIMP_PDB_SUCCESS)
266
 
        {
267
 
          /* printf("Channel Mixer:: Mode:%d  r %f  g %f  b %f\n ",
268
 
                 param[3].data.d_int32, mix.black.red_gain,
269
 
                 mix.black.green_gain, mix.black.blue_gain); */
270
 
 
271
 
          gimp_progress_init (_("Channel Mixer"));
272
 
 
273
 
          channel_mixer (&mix, drawable);
274
 
 
275
 
          if (run_mode != GIMP_RUN_NONINTERACTIVE)
276
 
            gimp_displays_flush ();
277
 
 
278
 
          if (run_mode == GIMP_RUN_INTERACTIVE)
279
 
            gimp_set_data (PLUG_IN_PROC, &mix, sizeof (CmParamsType));
280
 
        }
281
 
    }
282
 
  else
283
 
    {
284
 
      status = GIMP_PDB_EXECUTION_ERROR;
285
 
    }
286
 
 
287
 
  values[0].data.d_status = status;
288
 
 
289
 
  gimp_drawable_detach (drawable);
290
 
}
291
 
 
292
 
static void
293
 
cm_set_defaults (CmParamsType *mix)
294
 
{
295
 
  const CmParamsType defaults =
296
 
  {
297
 
    { 1.0, 0.0, 0.0 },
298
 
    { 0.0, 1.0, 0.0 },
299
 
    { 0.0, 0.0, 1.0 },
300
 
    { 1.0, 0.0, 0.0 },
301
 
    FALSE,
302
 
    FALSE,
303
 
    CM_RED_CHANNEL
304
 
  };
305
 
 
306
 
  memcpy (mix, &defaults, G_STRUCT_OFFSET (CmParamsType, preview));
307
 
}
308
 
 
309
 
static gdouble
310
 
cm_calculate_norm (CmParamsType  *mix,
311
 
                   CmChannelType *ch)
312
 
{
313
 
  gdouble sum = ch->red_gain + ch->green_gain + ch->blue_gain;
314
 
 
315
 
  if (sum == 0.0 || ! mix->preserve_luminosity)
316
 
    return 1.0;
317
 
 
318
 
  return fabs (1 / sum);
319
 
}
320
 
 
321
 
static inline guchar
322
 
cm_mix_pixel (CmChannelType *ch,
323
 
              guchar         r,
324
 
              guchar         g,
325
 
              guchar         b,
326
 
              gdouble        norm)
327
 
{
328
 
  gdouble c = ch->red_gain * r + ch->green_gain * g + ch->blue_gain * b;
329
 
 
330
 
  c *= norm;
331
 
 
332
 
  return (guchar) CLAMP0255 (c);
333
 
}
334
 
 
335
 
static inline void
336
 
cm_process_pixel (CmParamsType  *mix,
337
 
                  const guchar  *s,
338
 
                  guchar        *d,
339
 
                  const gdouble  red_norm,
340
 
                  const gdouble  green_norm,
341
 
                  const gdouble  blue_norm,
342
 
                  const gdouble  black_norm)
343
 
{
344
 
  if (mix->monochrome)
345
 
    {
346
 
      d[0] = d[1] = d[2] =
347
 
        cm_mix_pixel (&mix->black, s[0], s[1], s[2], black_norm);
348
 
    }
349
 
  else
350
 
    {
351
 
      d[0] = cm_mix_pixel (&mix->red,   s[0], s[1], s[2], red_norm);
352
 
      d[1] = cm_mix_pixel (&mix->green, s[0], s[1], s[2], green_norm);
353
 
      d[2] = cm_mix_pixel (&mix->blue,  s[0], s[1], s[2], blue_norm);
354
 
    }
355
 
}
356
 
 
357
 
static void
358
 
channel_mixer (CmParamsType *mix,
359
 
               GimpDrawable *drawable)
360
 
{
361
 
  GimpPixelRgn  src_rgn, dest_rgn;
362
 
  gpointer      pr;
363
 
  gboolean      has_alpha;
364
 
  gdouble       red_norm, green_norm, blue_norm, black_norm;
365
 
  gint          i, total, processed = 0;
366
 
  gint          x1, y1;
367
 
  gint          width, height;
368
 
 
369
 
  if (! gimp_drawable_mask_intersect (drawable->drawable_id,
370
 
                                      &x1, &y1, &width, &height))
371
 
    return;
372
 
 
373
 
  red_norm   = cm_calculate_norm (mix, &mix->red);
374
 
  green_norm = cm_calculate_norm (mix, &mix->green);
375
 
  blue_norm  = cm_calculate_norm (mix, &mix->blue);
376
 
  black_norm = cm_calculate_norm (mix, &mix->black);
377
 
 
378
 
  has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
379
 
 
380
 
  gimp_pixel_rgn_init (&src_rgn, drawable,
381
 
                       x1, y1, width, height, FALSE, FALSE);
382
 
  gimp_pixel_rgn_init (&dest_rgn, drawable,
383
 
                       x1, y1, width, height, TRUE, TRUE);
384
 
 
385
 
  total = width * height;
386
 
 
387
 
  for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn), i = 0;
388
 
       pr != NULL;
389
 
       pr = gimp_pixel_rgns_process (pr), i++)
390
 
    {
391
 
      const guchar *src  = src_rgn.data;
392
 
      guchar       *dest = dest_rgn.data;
393
 
      gint          x, y;
394
 
 
395
 
      for (y = 0; y < src_rgn.h; y++)
396
 
        {
397
 
          const guchar *s = src;
398
 
          guchar       *d = dest;
399
 
 
400
 
          if (has_alpha)
401
 
            {
402
 
              for (x = 0; x < src_rgn.w; x++, s += 4, d += 4)
403
 
                {
404
 
                  cm_process_pixel (mix, s, d,
405
 
                                    red_norm, green_norm, blue_norm,
406
 
                                    black_norm);
407
 
                  d[3] = s[3];
408
 
                }
409
 
            }
410
 
          else
411
 
            {
412
 
              for (x = 0; x < src_rgn.w; x++, s += 3, d += 3)
413
 
                {
414
 
                  cm_process_pixel (mix, s, d,
415
 
                                    red_norm, green_norm, blue_norm,
416
 
                                    black_norm);
417
 
                }
418
 
            }
419
 
 
420
 
          src += src_rgn.rowstride;
421
 
          dest += dest_rgn.rowstride;
422
 
        }
423
 
 
424
 
      processed += src_rgn.w * src_rgn.h;
425
 
 
426
 
      if (i % 16 == 0)
427
 
        gimp_progress_update ((gdouble) processed / (gdouble) total);
428
 
    }
429
 
 
430
 
  gimp_progress_update (1.0);
431
 
 
432
 
  gimp_drawable_flush (drawable);
433
 
  gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
434
 
  gimp_drawable_update (drawable->drawable_id, x1, y1, width, height);
435
 
}
436
 
 
437
 
static gboolean
438
 
cm_dialog (CmParamsType *mix,
439
 
           GimpDrawable *drawable)
440
 
{
441
 
  GtkWidget *dialog;
442
 
  GtkWidget *main_vbox;
443
 
  GtkWidget *vbox;
444
 
  GtkWidget *frame;
445
 
  GtkWidget *hbox;
446
 
  GtkWidget *button;
447
 
  GtkWidget *label;
448
 
  GtkWidget *image;
449
 
  GtkWidget *table;
450
 
  gdouble    red_value, green_value, blue_value;
451
 
  gboolean   run;
452
 
 
453
 
  gimp_ui_init (PLUG_IN_BINARY, FALSE);
454
 
 
455
 
  /* get values */
456
 
  if (mix->monochrome)
457
 
    {
458
 
      red_value   = mix->black.red_gain   * 100;
459
 
      green_value = mix->black.green_gain * 100;
460
 
      blue_value  = mix->black.blue_gain  * 100;
461
 
    }
462
 
  else
463
 
    {
464
 
      switch (mix->output_channel)
465
 
        {
466
 
        case CM_RED_CHANNEL:
467
 
          red_value   = mix->red.red_gain   * 100;
468
 
          green_value = mix->red.green_gain * 100;
469
 
          blue_value  = mix->red.blue_gain  * 100;
470
 
          break;
471
 
 
472
 
        case CM_GREEN_CHANNEL:
473
 
          red_value   = mix->green.red_gain   * 100;
474
 
          green_value = mix->green.green_gain * 100;
475
 
          blue_value  = mix->green.blue_gain  * 100;
476
 
          break;
477
 
 
478
 
        case CM_BLUE_CHANNEL:
479
 
          red_value   = mix->blue.red_gain   * 100;
480
 
          green_value = mix->blue.green_gain * 100;
481
 
          blue_value  = mix->blue.blue_gain  * 100;
482
 
          break;
483
 
 
484
 
        default:
485
 
          g_assert_not_reached ();
486
 
 
487
 
          red_value = green_value = blue_value = 0.0;
488
 
          break;
489
 
        }
490
 
    }
491
 
 
492
 
  dialog = gimp_dialog_new (_("Channel Mixer"), PLUG_IN_BINARY,
493
 
                            NULL, 0,
494
 
                            gimp_standard_help_func, PLUG_IN_PROC,
495
 
 
496
 
                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
497
 
                            GTK_STOCK_OK,     GTK_RESPONSE_OK,
498
 
 
499
 
                            NULL);
500
 
 
501
 
  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
502
 
                                           GTK_RESPONSE_OK,
503
 
                                           GTK_RESPONSE_CANCEL,
504
 
                                           -1);
505
 
 
506
 
  gimp_window_set_transient (GTK_WINDOW (dialog));
507
 
 
508
 
  main_vbox = gtk_vbox_new (FALSE, 12);
509
 
  gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
510
 
  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox);
511
 
  gtk_widget_show (main_vbox);
512
 
 
513
 
  preview = gimp_zoom_preview_new (drawable);
514
 
  gtk_box_pack_start_defaults (GTK_BOX (main_vbox), preview);
515
 
  gtk_widget_show (preview);
516
 
  g_signal_connect_swapped (preview, "invalidated",
517
 
                            G_CALLBACK (cm_preview),
518
 
                            mix);
519
 
 
520
 
  frame = gimp_frame_new (NULL);
521
 
  gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
522
 
  gtk_widget_show (frame);
523
 
 
524
 
  hbox = gtk_hbox_new (FALSE, 6);
525
 
  gtk_frame_set_label_widget (GTK_FRAME (frame), hbox);
526
 
  gtk_widget_show (hbox);
527
 
 
528
 
  label = gtk_label_new_with_mnemonic (_("O_utput channel:"));
529
 
 
530
 
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
531
 
  gtk_widget_show (label);
532
 
 
533
 
  mix->combo = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL);
534
 
 
535
 
  gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (mix->combo),
536
 
                             GIMP_INT_STORE_VALUE,    CM_RED_CHANNEL,
537
 
                             GIMP_INT_STORE_LABEL,    _("Red"),
538
 
                             GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_CHANNEL_RED,
539
 
                             -1);
540
 
  gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (mix->combo),
541
 
                             GIMP_INT_STORE_VALUE,    CM_GREEN_CHANNEL,
542
 
                             GIMP_INT_STORE_LABEL,    _("Green"),
543
 
                             GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_CHANNEL_GREEN,
544
 
                             -1);
545
 
  gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (mix->combo),
546
 
                             GIMP_INT_STORE_VALUE,    CM_BLUE_CHANNEL,
547
 
                             GIMP_INT_STORE_LABEL,    _("Blue"),
548
 
                             GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_CHANNEL_BLUE,
549
 
                             -1);
550
 
 
551
 
  gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (mix->combo),
552
 
                                 mix->output_channel);
553
 
 
554
 
  g_signal_connect (mix->combo, "changed",
555
 
                    G_CALLBACK (cm_combo_callback),
556
 
                    mix);
557
 
 
558
 
  gtk_box_pack_start (GTK_BOX (hbox), mix->combo, TRUE, TRUE, 0);
559
 
  gtk_widget_show (mix->combo);
560
 
 
561
 
  if (mix->monochrome)
562
 
    gtk_widget_set_sensitive (mix->combo, FALSE);
563
 
 
564
 
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), mix->combo);
565
 
 
566
 
  /*........................................................... */
567
 
 
568
 
  table = gtk_table_new (3, 4, FALSE);
569
 
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
570
 
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
571
 
  gtk_container_add (GTK_CONTAINER (frame), table);
572
 
  gtk_widget_show (table);
573
 
 
574
 
  image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_RED,
575
 
                                    GTK_ICON_SIZE_BUTTON);
576
 
  gtk_table_attach (GTK_TABLE (table), image,
577
 
                    0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
578
 
  gtk_widget_show (image);
579
 
 
580
 
  mix->red_data =
581
 
    GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 1, 0,
582
 
                                          _("_Red:"), 150, -1,
583
 
                                          red_value, -200.0, 200.0,
584
 
                                          1.0, 10.0, 1,
585
 
                                          TRUE, 0.0, 0.0,
586
 
                                          NULL, NULL));
587
 
 
588
 
  g_signal_connect (mix->red_data, "value-changed",
589
 
                    G_CALLBACK (cm_red_scale_callback),
590
 
                    mix);
591
 
 
592
 
  image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_GREEN,
593
 
                                    GTK_ICON_SIZE_BUTTON);
594
 
  gtk_table_attach (GTK_TABLE (table), image,
595
 
                    0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
596
 
  gtk_widget_show (image);
597
 
 
598
 
  mix->green_data =
599
 
    GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 1, 1,
600
 
                                          _("_Green:"), 150, -1,
601
 
                                          green_value, -200.0, 200.0,
602
 
                                          1.0, 10.0, 1,
603
 
                                          TRUE, 0.0, 0.0,
604
 
                                          NULL, NULL));
605
 
 
606
 
  g_signal_connect (mix->green_data, "value-changed",
607
 
                    G_CALLBACK (cm_green_scale_callback),
608
 
                    mix);
609
 
 
610
 
 
611
 
  image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_BLUE,
612
 
                                    GTK_ICON_SIZE_BUTTON);
613
 
  gtk_table_attach (GTK_TABLE (table), image,
614
 
                    0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
615
 
  gtk_widget_show (image);
616
 
 
617
 
  mix->blue_data =
618
 
    GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 1, 2,
619
 
                                          _("_Blue:"), 150, -1,
620
 
                                          blue_value, -200.0, 200.0,
621
 
                                          1.0, 10.0, 1,
622
 
                                          TRUE, 0.0, 0.0,
623
 
                                          NULL, NULL));
624
 
 
625
 
  g_signal_connect (mix->blue_data, "value-changed",
626
 
                    G_CALLBACK (cm_blue_scale_callback),
627
 
                    mix);
628
 
 
629
 
  vbox = gtk_vbox_new (6, FALSE);
630
 
  gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
631
 
  gtk_widget_show (vbox);
632
 
 
633
 
  /*  The monochrome toggle  */
634
 
  mix->monochrome_toggle =
635
 
    gtk_check_button_new_with_mnemonic (_("_Monochrome"));
636
 
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->monochrome_toggle),
637
 
                                mix->monochrome);
638
 
  gtk_box_pack_start (GTK_BOX (vbox), mix->monochrome_toggle,
639
 
                      FALSE, FALSE, 0);
640
 
  gtk_widget_show (mix->monochrome_toggle);
641
 
 
642
 
  g_signal_connect (mix->monochrome_toggle, "toggled",
643
 
                    G_CALLBACK (cm_monochrome_callback),
644
 
                    mix);
645
 
 
646
 
  /*  The preserve luminosity toggle  */
647
 
  mix->preserve_luminosity_toggle =
648
 
    gtk_check_button_new_with_mnemonic (_("Preserve _luminosity"));
649
 
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
650
 
                                (mix->preserve_luminosity_toggle),
651
 
                                mix->preserve_luminosity);
652
 
  gtk_box_pack_start (GTK_BOX (vbox), mix->preserve_luminosity_toggle,
653
 
                      FALSE, FALSE, 0);
654
 
  gtk_widget_show (mix->preserve_luminosity_toggle);
655
 
 
656
 
  g_signal_connect (mix->preserve_luminosity_toggle, "toggled",
657
 
                    G_CALLBACK (cm_preserve_luminosity_callback),
658
 
                    mix);
659
 
 
660
 
  /*........................................................... */
661
 
  /*  Horizontal box for file i/o  */
662
 
  hbox = gtk_hbox_new (FALSE, 6);
663
 
  gtk_box_pack_end (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
664
 
  gtk_widget_show (hbox);
665
 
 
666
 
  button = gtk_button_new_from_stock (GTK_STOCK_OPEN);
667
 
  gtk_container_add (GTK_CONTAINER (hbox), button);
668
 
  gtk_widget_show (button);
669
 
 
670
 
  g_signal_connect (button, "clicked",
671
 
                    G_CALLBACK (cm_load_file_callback),
672
 
                    mix);
673
 
 
674
 
  button = gtk_button_new_from_stock (GTK_STOCK_SAVE);
675
 
  gtk_container_add (GTK_CONTAINER (hbox), button);
676
 
  gtk_widget_show (button);
677
 
 
678
 
  g_signal_connect (button, "clicked",
679
 
                    G_CALLBACK (cm_save_file_callback),
680
 
                    mix);
681
 
 
682
 
  button = gtk_button_new_from_stock (GIMP_STOCK_RESET);
683
 
  gtk_container_add (GTK_CONTAINER (hbox), button);
684
 
  gtk_widget_show (button);
685
 
 
686
 
  g_signal_connect (button, "clicked",
687
 
                    G_CALLBACK (cm_reset_callback),
688
 
                    mix);
689
 
 
690
 
  gtk_widget_show (dialog);
691
 
 
692
 
  run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
693
 
 
694
 
  gtk_widget_destroy (dialog);
695
 
 
696
 
  return run;
697
 
}
698
 
 
699
 
static void
700
 
cm_red_scale_callback (GtkAdjustment *adjustment,
701
 
                       CmParamsType  *mix)
702
 
{
703
 
  if (mix->monochrome)
704
 
    {
705
 
      mix->black.red_gain = adjustment->value / 100.0;
706
 
    }
707
 
  else
708
 
    {
709
 
      switch (mix->output_channel)
710
 
        {
711
 
        case CM_RED_CHANNEL:
712
 
          mix->red.red_gain = adjustment->value / 100.0;
713
 
          break;
714
 
        case CM_GREEN_CHANNEL:
715
 
          mix->green.red_gain = adjustment->value / 100.0;
716
 
          break;
717
 
        case CM_BLUE_CHANNEL:
718
 
          mix->blue.red_gain = adjustment->value / 100.0;
719
 
          break;
720
 
        }
721
 
    }
722
 
 
723
 
  gimp_preview_invalidate (GIMP_PREVIEW (preview));
724
 
}
725
 
 
726
 
static void
727
 
cm_green_scale_callback (GtkAdjustment *adjustment,
728
 
                         CmParamsType  *mix)
729
 
{
730
 
  if (mix->monochrome)
731
 
    {
732
 
      mix->black.green_gain = adjustment->value / 100.0;
733
 
    }
734
 
  else
735
 
    {
736
 
      switch (mix->output_channel)
737
 
        {
738
 
        case CM_RED_CHANNEL:
739
 
          mix->red.green_gain = adjustment->value / 100.0;
740
 
          break;
741
 
        case CM_GREEN_CHANNEL:
742
 
          mix->green.green_gain = adjustment->value / 100.0;
743
 
          break;
744
 
        case CM_BLUE_CHANNEL:
745
 
          mix->blue.green_gain = adjustment->value / 100.0;
746
 
          break;
747
 
        }
748
 
    }
749
 
 
750
 
  gimp_preview_invalidate (GIMP_PREVIEW (preview));
751
 
}
752
 
 
753
 
static void
754
 
cm_blue_scale_callback (GtkAdjustment *adjustment,
755
 
                        CmParamsType  *mix)
756
 
{
757
 
  if (mix->monochrome)
758
 
    {
759
 
      mix->black.blue_gain = adjustment->value / 100.0;
760
 
    }
761
 
  else
762
 
    {
763
 
      switch (mix->output_channel)
764
 
        {
765
 
        case CM_RED_CHANNEL:
766
 
          mix->red.blue_gain = adjustment->value / 100.0;
767
 
          break;
768
 
        case CM_GREEN_CHANNEL:
769
 
          mix->green.blue_gain = adjustment->value / 100.0;
770
 
          break;
771
 
        case CM_BLUE_CHANNEL:
772
 
          mix->blue.blue_gain = adjustment->value / 100.0;
773
 
          break;
774
 
        }
775
 
    }
776
 
 
777
 
  gimp_preview_invalidate (GIMP_PREVIEW (preview));
778
 
}
779
 
 
780
 
static void
781
 
cm_preview (CmParamsType *mix,
782
 
            GimpPreview  *preview)
783
 
{
784
 
  guchar       *src, *s;
785
 
  guchar       *dst, *d;
786
 
  gint          x, y;
787
 
  gdouble       red_norm, green_norm, blue_norm, black_norm;
788
 
  gint          width, height, bpp;
789
 
  GimpDrawable *drawable;
790
 
 
791
 
  red_norm   = cm_calculate_norm (mix, &mix->red);
792
 
  green_norm = cm_calculate_norm (mix, &mix->green);
793
 
  blue_norm  = cm_calculate_norm (mix, &mix->blue);
794
 
  black_norm = cm_calculate_norm (mix, &mix->black);
795
 
 
796
 
  drawable = gimp_zoom_preview_get_drawable (GIMP_ZOOM_PREVIEW (preview));
797
 
 
798
 
  src = s = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview),
799
 
                                          &width, &height, &bpp);
800
 
 
801
 
  dst = d = g_new (guchar, width * height * bpp);
802
 
 
803
 
  for (y = 0; y < height; y++)
804
 
    {
805
 
      for (x = 0; x < width; x++, s += bpp, d += bpp)
806
 
        {
807
 
          cm_process_pixel (mix, s, d,
808
 
                            red_norm, green_norm, blue_norm,
809
 
                            black_norm);
810
 
 
811
 
          if (bpp == 4)
812
 
            d[3] = s[3];
813
 
        }
814
 
    }
815
 
 
816
 
  gimp_preview_draw_buffer (GIMP_PREVIEW (preview), dst, bpp * width);
817
 
 
818
 
  g_free (src);
819
 
  g_free (dst);
820
 
}
821
 
 
822
 
static void
823
 
cm_monochrome_callback (GtkWidget    *widget,
824
 
                        CmParamsType *mix)
825
 
{
826
 
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
827
 
    {
828
 
      mix->old_output_channel = mix->output_channel;
829
 
      mix->monochrome = TRUE;
830
 
      gtk_widget_set_sensitive (mix->combo, FALSE);
831
 
    }
832
 
  else
833
 
    {
834
 
      mix->output_channel = mix->old_output_channel;
835
 
      mix->monochrome = FALSE;
836
 
      gtk_widget_set_sensitive (mix->combo, TRUE);
837
 
    }
838
 
 
839
 
  cm_set_adjusters (mix);
840
 
 
841
 
  gimp_preview_invalidate (GIMP_PREVIEW (preview));
842
 
}
843
 
 
844
 
static void
845
 
cm_preserve_luminosity_callback (GtkWidget    *widget,
846
 
                                 CmParamsType *mix)
847
 
{
848
 
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
849
 
    mix->preserve_luminosity = TRUE;
850
 
  else
851
 
    mix->preserve_luminosity = FALSE;
852
 
 
853
 
  gimp_preview_invalidate (GIMP_PREVIEW (preview));
854
 
}
855
 
 
856
 
static gchar *
857
 
cm_settings_filename (void)
858
 
{
859
 
  return g_build_filename (gimp_directory (),
860
 
                           "channel-mixer",
861
 
                           "settings",
862
 
                           NULL);
863
 
}
864
 
 
865
 
static void
866
 
cm_load_file_callback (GtkWidget    *widget,
867
 
                       CmParamsType *mix)
868
 
{
869
 
  static GtkWidget *dialog = NULL;
870
 
 
871
 
  if (! dialog)
872
 
    {
873
 
      GtkWidget *parent = gtk_widget_get_toplevel (widget);
874
 
      gchar     *name;
875
 
 
876
 
      dialog =
877
 
        gtk_file_chooser_dialog_new (_("Load Channel Mixer Settings"),
878
 
                                     GTK_WINDOW (parent),
879
 
                                     GTK_FILE_CHOOSER_ACTION_OPEN,
880
 
 
881
 
                                     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
882
 
                                     GTK_STOCK_OPEN,   GTK_RESPONSE_OK,
883
 
 
884
 
                                     NULL);
885
 
 
886
 
      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
887
 
                                               GTK_RESPONSE_OK,
888
 
                                               GTK_RESPONSE_CANCEL,
889
 
                                               -1);
890
 
 
891
 
      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
892
 
 
893
 
      g_signal_connect (dialog, "response",
894
 
                        G_CALLBACK (cm_load_file_response_callback),
895
 
                        mix);
896
 
      g_signal_connect (dialog, "delete-event",
897
 
                        G_CALLBACK (gtk_true),
898
 
                        NULL);
899
 
 
900
 
      name = cm_settings_filename ();
901
 
      gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), name);
902
 
      g_free (name);
903
 
    }
904
 
 
905
 
  gtk_window_present (GTK_WINDOW (dialog));
906
 
}
907
 
 
908
 
static void
909
 
cm_load_file_response_callback (GtkWidget    *dialog,
910
 
                                gint          response_id,
911
 
                                CmParamsType *mix)
912
 
{
913
 
  FILE *fp;
914
 
 
915
 
  if (response_id == GTK_RESPONSE_OK)
916
 
    {
917
 
      gchar *filename;
918
 
 
919
 
      filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
920
 
 
921
 
      fp = g_fopen (filename, "rb");
922
 
 
923
 
      if (fp)
924
 
        {
925
 
          gchar buf[3][CM_LINE_SIZE];
926
 
 
927
 
          buf[0][0] = '\0';
928
 
          buf[1][0] = '\0';
929
 
          buf[2][0] = '\0';
930
 
 
931
 
          fgets (buf[0], CM_LINE_SIZE - 1, fp);
932
 
 
933
 
          fscanf (fp, "%*s %1023s", buf[0]);
934
 
          if (strcmp (buf[0], "RED") == 0)
935
 
            mix->output_channel = CM_RED_CHANNEL;
936
 
          else if (strcmp (buf[0], "GREEN") == 0)
937
 
            mix->output_channel = CM_GREEN_CHANNEL;
938
 
          else if (strcmp (buf[0], "BLUE") == 0)
939
 
            mix->output_channel = CM_BLUE_CHANNEL;
940
 
 
941
 
          fscanf (fp, "%*s %1023s", buf[0]); /* preview flag, preserved for compatibility */
942
 
 
943
 
          fscanf (fp, "%*s %1023s", buf[0]);
944
 
          if (strcmp (buf[0], "TRUE") == 0)
945
 
            mix->monochrome = TRUE;
946
 
          else
947
 
            mix->monochrome = FALSE;
948
 
 
949
 
          fscanf (fp, "%*s %1023s", buf[0]);
950
 
          if (strcmp (buf[0], "TRUE") == 0)
951
 
            mix->preserve_luminosity = TRUE;
952
 
          else
953
 
            mix->preserve_luminosity = FALSE;
954
 
 
955
 
          fscanf (fp, "%*s %1023s %1023s %1023s", buf[0], buf[1], buf[2]);
956
 
          mix->red.red_gain   = g_ascii_strtod (buf[0], NULL);
957
 
          mix->red.green_gain = g_ascii_strtod (buf[1], NULL);
958
 
          mix->red.blue_gain  = g_ascii_strtod (buf[2], NULL);
959
 
 
960
 
          fscanf (fp, "%*s %1023s %1023s %1023s", buf[0], buf[1], buf[2]);
961
 
          mix->green.red_gain   = g_ascii_strtod (buf[0], NULL);
962
 
          mix->green.green_gain = g_ascii_strtod (buf[1], NULL);
963
 
          mix->green.blue_gain  = g_ascii_strtod (buf[2], NULL);
964
 
 
965
 
          fscanf (fp, "%*s %1023s %1023s %1023s", buf[0], buf[1], buf[2]);
966
 
          mix->blue.red_gain   = g_ascii_strtod (buf[0], NULL);
967
 
          mix->blue.green_gain = g_ascii_strtod (buf[1], NULL);
968
 
          mix->blue.blue_gain  = g_ascii_strtod (buf[2], NULL);
969
 
 
970
 
          fscanf (fp, "%*s %1023s %1023s %1023s", buf[0], buf[1], buf[2]);
971
 
          mix->black.red_gain   = g_ascii_strtod (buf[0], NULL);
972
 
          mix->black.green_gain = g_ascii_strtod (buf[1], NULL);
973
 
          mix->black.blue_gain  = g_ascii_strtod (buf[2], NULL);
974
 
 
975
 
          fclose (fp);
976
 
 
977
 
          cm_update_ui (mix);
978
 
        }
979
 
      else
980
 
        {
981
 
          g_message (_("Could not open '%s' for reading: %s"),
982
 
                     gimp_filename_to_utf8 (filename),
983
 
                     g_strerror (errno));
984
 
        }
985
 
 
986
 
      g_free (filename);
987
 
    }
988
 
 
989
 
  gtk_widget_hide (dialog);
990
 
}
991
 
 
992
 
static void
993
 
cm_save_file_callback (GtkWidget    *widget,
994
 
                       CmParamsType *mix)
995
 
{
996
 
  static GtkWidget *dialog = NULL;
997
 
 
998
 
  if (! dialog)
999
 
    {
1000
 
      GtkWidget *parent = gtk_widget_get_toplevel (widget);
1001
 
      gchar     *name;
1002
 
 
1003
 
      dialog =
1004
 
        gtk_file_chooser_dialog_new (_("Save Channel Mixer Settings"),
1005
 
                                     GTK_WINDOW (parent),
1006
 
                                     GTK_FILE_CHOOSER_ACTION_SAVE,
1007
 
 
1008
 
                                     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1009
 
                                     GTK_STOCK_SAVE,   GTK_RESPONSE_OK,
1010
 
 
1011
 
                                     NULL);
1012
 
 
1013
 
      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
1014
 
                                               GTK_RESPONSE_OK,
1015
 
                                               GTK_RESPONSE_CANCEL,
1016
 
                                               -1);
1017
 
      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
1018
 
 
1019
 
      gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
1020
 
                                                      TRUE);
1021
 
 
1022
 
      g_signal_connect (dialog, "response",
1023
 
                        G_CALLBACK (cm_save_file_response_callback),
1024
 
                        mix);
1025
 
      g_signal_connect (dialog, "delete-event",
1026
 
                        G_CALLBACK (gtk_true),
1027
 
                        NULL);
1028
 
 
1029
 
      name = cm_settings_filename ();
1030
 
      gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), name);
1031
 
      g_free (name);
1032
 
    }
1033
 
 
1034
 
  gtk_window_present (GTK_WINDOW (dialog));
1035
 
}
1036
 
 
1037
 
static void
1038
 
cm_save_file_response_callback (GtkWidget    *dialog,
1039
 
                                gint          response_id,
1040
 
                                CmParamsType *mix)
1041
 
{
1042
 
  gchar *filename;
1043
 
  FILE  *file = NULL;
1044
 
 
1045
 
  if (response_id != GTK_RESPONSE_OK)
1046
 
    {
1047
 
      gtk_widget_hide (dialog);
1048
 
      return;
1049
 
    }
1050
 
 
1051
 
  filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1052
 
  if (! filename)
1053
 
    return;
1054
 
 
1055
 
  file = g_fopen (filename, "wb");
1056
 
 
1057
 
  if (! file)
1058
 
    {
1059
 
      g_message (_("Could not open '%s' for writing: %s"),
1060
 
                 gimp_filename_to_utf8 (filename), g_strerror (errno));
1061
 
      g_free (filename);
1062
 
      return;
1063
 
    }
1064
 
 
1065
 
  cm_save_file (mix, file);
1066
 
 
1067
 
  g_message (_("Parameters were saved to '%s'"),
1068
 
             gimp_filename_to_utf8 (filename));
1069
 
 
1070
 
  gtk_widget_hide (dialog);
1071
 
}
1072
 
 
1073
 
static void
1074
 
cm_save_file (CmParamsType *mix,
1075
 
              FILE         *fp)
1076
 
{
1077
 
  const gchar *str = NULL;
1078
 
  gchar        buf[3][G_ASCII_DTOSTR_BUF_SIZE];
1079
 
 
1080
 
  switch (mix->output_channel)
1081
 
    {
1082
 
    case CM_RED_CHANNEL:
1083
 
      str = "RED";
1084
 
      break;
1085
 
    case CM_GREEN_CHANNEL:
1086
 
      str = "GREEN";
1087
 
      break;
1088
 
    case CM_BLUE_CHANNEL:
1089
 
      str = "BLUE";
1090
 
      break;
1091
 
    default:
1092
 
      g_assert_not_reached ();
1093
 
      break;
1094
 
    }
1095
 
 
1096
 
  fprintf (fp, "# Channel Mixer Configuration File\n");
1097
 
 
1098
 
  fprintf (fp, "CHANNEL: %s\n", str);
1099
 
  fprintf (fp, "PREVIEW: %s\n", "TRUE"); /* preserved for compatibility */
1100
 
  fprintf (fp, "MONOCHROME: %s\n",
1101
 
           mix->monochrome ? "TRUE" : "FALSE");
1102
 
  fprintf (fp, "PRESERVE_LUMINOSITY: %s\n",
1103
 
           mix->preserve_luminosity ? "TRUE" : "FALSE");
1104
 
 
1105
 
  fprintf (fp, "RED: %s %s %s\n",
1106
 
           g_ascii_formatd (buf[0], sizeof (buf[0]), "%5.3f",
1107
 
                            mix->red.red_gain),
1108
 
           g_ascii_formatd (buf[1], sizeof (buf[1]), "%5.3f",
1109
 
                            mix->red.green_gain),
1110
 
           g_ascii_formatd (buf[2], sizeof (buf[2]), "%5.3f",
1111
 
                            mix->red.blue_gain));
1112
 
 
1113
 
  fprintf (fp, "GREEN: %s %s %s\n",
1114
 
           g_ascii_formatd (buf[0], sizeof (buf[0]), "%5.3f",
1115
 
                            mix->green.red_gain),
1116
 
           g_ascii_formatd (buf[1], sizeof (buf[1]), "%5.3f",
1117
 
                            mix->green.green_gain),
1118
 
           g_ascii_formatd (buf[2], sizeof (buf[2]), "%5.3f",
1119
 
                            mix->green.blue_gain));
1120
 
 
1121
 
  fprintf (fp, "BLUE: %s %s %s\n",
1122
 
           g_ascii_formatd (buf[0], sizeof (buf[0]), "%5.3f",
1123
 
                            mix->blue.red_gain),
1124
 
           g_ascii_formatd (buf[1], sizeof (buf[1]), "%5.3f",
1125
 
                            mix->blue.green_gain),
1126
 
           g_ascii_formatd (buf[2], sizeof (buf[2]), "%5.3f",
1127
 
                            mix->blue.blue_gain));
1128
 
 
1129
 
  fprintf (fp, "BLACK: %s %s %s\n",
1130
 
           g_ascii_formatd (buf[0], sizeof (buf[0]), "%5.3f",
1131
 
                            mix->black.red_gain),
1132
 
           g_ascii_formatd (buf[1], sizeof (buf[1]), "%5.3f",
1133
 
                            mix->black.green_gain),
1134
 
           g_ascii_formatd (buf[2], sizeof (buf[2]), "%5.3f",
1135
 
                            mix->black.blue_gain));
1136
 
 
1137
 
  fclose (fp);
1138
 
}
1139
 
 
1140
 
static void
1141
 
cm_reset_callback (GtkWidget    *widget,
1142
 
                   CmParamsType *mix)
1143
 
{
1144
 
  cm_set_defaults (mix);
1145
 
  cm_update_ui (mix);
1146
 
}
1147
 
 
1148
 
static void
1149
 
cm_combo_callback (GtkWidget    *widget,
1150
 
                   CmParamsType *mix)
1151
 
{
1152
 
  gint value;
1153
 
 
1154
 
  if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value))
1155
 
    {
1156
 
      mix->output_channel = value;
1157
 
 
1158
 
      cm_set_adjusters (mix);
1159
 
    }
1160
 
}
1161
 
 
1162
 
static void
1163
 
cm_set_adjusters (CmParamsType *mix)
1164
 
{
1165
 
  if (mix->monochrome)
1166
 
    {
1167
 
      gtk_adjustment_set_value (mix->red_data,   mix->black.red_gain   * 100.0);
1168
 
      gtk_adjustment_set_value (mix->green_data, mix->black.green_gain * 100.0);
1169
 
      gtk_adjustment_set_value (mix->blue_data,  mix->black.blue_gain  * 100.0);
1170
 
 
1171
 
      return;
1172
 
    }
1173
 
 
1174
 
  switch (mix->output_channel)
1175
 
    {
1176
 
    case CM_RED_CHANNEL:
1177
 
      gtk_adjustment_set_value (mix->red_data,   mix->red.red_gain   * 100.0);
1178
 
      gtk_adjustment_set_value (mix->green_data, mix->red.green_gain * 100.0);
1179
 
      gtk_adjustment_set_value (mix->blue_data,  mix->red.blue_gain  * 100.0);
1180
 
      break;
1181
 
 
1182
 
    case CM_GREEN_CHANNEL:
1183
 
      gtk_adjustment_set_value (mix->red_data,   mix->green.red_gain   * 100.0);
1184
 
      gtk_adjustment_set_value (mix->green_data, mix->green.green_gain * 100.0);
1185
 
      gtk_adjustment_set_value (mix->blue_data,  mix->green.blue_gain  * 100.0);
1186
 
      break;
1187
 
 
1188
 
    case CM_BLUE_CHANNEL:
1189
 
      gtk_adjustment_set_value (mix->red_data,   mix->blue.red_gain   * 100.0);
1190
 
      gtk_adjustment_set_value (mix->green_data, mix->blue.green_gain * 100.0);
1191
 
      gtk_adjustment_set_value (mix->blue_data,  mix->blue.blue_gain  * 100.0);
1192
 
      break;
1193
 
    }
1194
 
}
1195
 
 
1196
 
static void
1197
 
cm_update_ui (CmParamsType *mix)
1198
 
{
1199
 
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->monochrome_toggle),
1200
 
                                mix->monochrome);
1201
 
 
1202
 
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->preserve_luminosity_toggle),
1203
 
                                mix->preserve_luminosity);
1204
 
 
1205
 
  gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (mix->combo),
1206
 
                                 mix->output_channel);
1207
 
 
1208
 
  cm_set_adjusters (mix);
1209
 
 
1210
 
  gimp_preview_invalidate (GIMP_PREVIEW (preview));
1211
 
}