home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / hue_saturation.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-17  |  23.1 KB  |  838 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17.  */
  18. #include "config.h"
  19.  
  20. #include <glib.h>
  21.  
  22. #include "apptypes.h"
  23.  
  24. #include "appenv.h"
  25. #include "drawable.h"
  26. #include "gimage_mask.h"
  27. #include "gdisplay.h"
  28. #include "gimpui.h"
  29. #include "hue_saturation.h"
  30.  
  31. #include "libgimp/gimpcolorspace.h"
  32. #include "libgimp/gimpmath.h"
  33.  
  34. #include "libgimp/gimpintl.h"
  35.  
  36.  
  37. #define HUE_PARTITION_MASK  GDK_EXPOSURE_MASK | GDK_ENTER_NOTIFY_MASK
  38.  
  39. #define SLIDER_WIDTH  200
  40. #define DA_WIDTH  40
  41. #define DA_HEIGHT 20
  42.  
  43. #define HUE_PARTITION      0x0
  44. #define HUE_SLIDER         0x1
  45. #define LIGHTNESS_SLIDER   0x2
  46. #define SATURATION_SLIDER  0x4
  47. #define DRAW               0x40
  48. #define ALL                0xFF
  49.  
  50. /*  the hue-saturation structures  */
  51.  
  52. typedef struct _HueSaturation HueSaturation;
  53.  
  54. struct _HueSaturation
  55. {
  56.   gint x, y;    /*  coords for last mouse click  */
  57. };
  58.  
  59. /*  the hue-saturation tool options  */
  60. static ToolOptions *hue_saturation_options = NULL;
  61.  
  62. /*  the hue-saturation tool dialog  */
  63. static HueSaturationDialog *hue_saturation_dialog = NULL;
  64.  
  65. /*  Local variables  */
  66. static gint hue_transfer[6][256];
  67. static gint lightness_transfer[6][256];
  68. static gint saturation_transfer[6][256];
  69. static gint default_colors[6][3] =
  70. {
  71.   { 255,   0,   0 },
  72.   { 255, 255,   0 },
  73.   {   0, 255,   0 },
  74.   {   0, 255, 255 },
  75.   {   0,   0, 255 },
  76.   { 255,   0, 255 }
  77. };
  78.  
  79. /*  hue saturation action functions  */
  80. static void   hue_saturation_control (Tool *, ToolAction, gpointer);
  81.  
  82. static HueSaturationDialog * hue_saturation_dialog_new (void);
  83.  
  84. static void   hue_saturation_update                  (HueSaturationDialog *,
  85.                               gint);
  86. static void   hue_saturation_preview                 (HueSaturationDialog *);
  87. static void   hue_saturation_reset_callback          (GtkWidget *, gpointer);
  88. static void   hue_saturation_ok_callback             (GtkWidget *, gpointer);
  89. static void   hue_saturation_cancel_callback         (GtkWidget *, gpointer);
  90. static void   hue_saturation_partition_callback      (GtkWidget *, gpointer);
  91. static void   hue_saturation_preview_update          (GtkWidget *, gpointer);
  92. static void   hue_saturation_hue_adjustment_update        (GtkAdjustment *,
  93.                                gpointer);
  94. static void   hue_saturation_lightness_adjustment_update  (GtkAdjustment *,
  95.                                gpointer);
  96. static void   hue_saturation_saturation_adjustment_update (GtkAdjustment *,
  97.                                gpointer);
  98. static gint   hue_saturation_hue_partition_events    (GtkWidget *, GdkEvent *,
  99.                               HueSaturationDialog *);
  100.  
  101. /*  hue saturation machinery  */
  102.  
  103. void
  104. hue_saturation_calculate_transfers (HueSaturationDialog *hsd)
  105. {
  106.   gint value;
  107.   gint hue;
  108.   gint i;
  109.  
  110.   /*  Calculate transfers  */
  111.   for (hue = 0; hue < 6; hue++)
  112.     for (i = 0; i < 256; i++)
  113.       {
  114.     value = (hsd->hue[0] + hsd->hue[hue + 1]) * 255.0 / 360.0;
  115.     if ((i + value) < 0)
  116.       hue_transfer[hue][i] = 255 + (i + value);
  117.     else if ((i + value) > 255)
  118.       hue_transfer[hue][i] = i + value - 255;
  119.     else
  120.       hue_transfer[hue][i] = i + value;
  121.  
  122.     /*  Lightness  */
  123.     value = (hsd->lightness[0] + hsd->lightness[hue + 1]) * 127.0 / 100.0;
  124.     value = CLAMP (value, -255, 255);
  125.     if (value < 0)
  126.       lightness_transfer[hue][i] = (unsigned char) ((i * (255 + value)) / 255);
  127.     else
  128.       lightness_transfer[hue][i] = (unsigned char) (i + ((255 - i) * value) / 255);
  129.  
  130.     /*  Saturation  */
  131.     value = (hsd->saturation[0] + hsd->saturation[hue + 1]) * 255.0 / 100.0;
  132.     value = CLAMP (value, -255, 255);
  133.  
  134.     /* This change affects the way saturation is computed. With the
  135.        old code (different code for value < 0), increasing the
  136.        saturation affected muted colors very much, and bright colors
  137.        less. With the new code, it affects muted colors and bright
  138.        colors more or less evenly. For enhancing the color in photos,
  139.        the new behavior is exactly what you want. It's hard for me
  140.        to imagine a case in which the old behavior is better.
  141.     */
  142.     saturation_transfer[hue][i] = CLAMP ((i * (255 + value)) / 255, 0, 255);
  143.       }
  144. }
  145.  
  146. void
  147. hue_saturation (PixelRegion *srcPR,
  148.         PixelRegion *destPR,
  149.         void        *user_data)
  150. {
  151.   HueSaturationDialog *hsd;
  152.   unsigned char *src, *s;
  153.   unsigned char *dest, *d;
  154.   int alpha;
  155.   int w, h;
  156.   int r, g, b;
  157.   int hue;
  158.  
  159.   hsd = (HueSaturationDialog *) user_data;
  160.  
  161.   /*  Set the transfer arrays  (for speed)  */
  162.   h = srcPR->h;
  163.   src = srcPR->data;
  164.   dest = destPR->data;
  165.   alpha = (srcPR->bytes == 4) ? TRUE : FALSE;
  166.  
  167.   while (h--)
  168.     {
  169.       w = srcPR->w;
  170.       s = src;
  171.       d = dest;
  172.       while (w--)
  173.     {
  174.       r = s[RED_PIX];
  175.       g = s[GREEN_PIX];
  176.       b = s[BLUE_PIX];
  177.  
  178.       gimp_rgb_to_hls (&r, &g, &b);
  179.  
  180.       if (r < 43)
  181.         hue = 0;
  182.       else if (r < 85)
  183.         hue = 1;
  184.       else if (r < 128)
  185.         hue = 2;
  186.       else if (r < 171)
  187.         hue = 3;
  188.       else if (r < 213)
  189.         hue = 4;
  190.       else
  191.         hue = 5;
  192.  
  193.       r = hue_transfer[hue][r];
  194.       g = lightness_transfer[hue][g];
  195.       b = saturation_transfer[hue][b];
  196.  
  197.       gimp_hls_to_rgb (&r, &g, &b);
  198.  
  199.       d[RED_PIX] = r;
  200.       d[GREEN_PIX] = g;
  201.       d[BLUE_PIX] = b;
  202.  
  203.       if (alpha)
  204.         d[ALPHA_PIX] = s[ALPHA_PIX];
  205.  
  206.       s += srcPR->bytes;
  207.       d += destPR->bytes;
  208.     }
  209.  
  210.       src += srcPR->rowstride;
  211.       dest += destPR->rowstride;
  212.     }
  213. }
  214.  
  215. /*  hue saturation action functions  */
  216.  
  217. static void
  218. hue_saturation_control (Tool       *tool,
  219.             ToolAction  action,
  220.             gpointer    gdisp_ptr)
  221. {
  222.   switch (action)
  223.     {
  224.     case PAUSE:
  225.       break;
  226.  
  227.     case RESUME:
  228.       break;
  229.  
  230.     case HALT:
  231.       hue_saturation_dialog_hide ();
  232.       break;
  233.  
  234.     default:
  235.       break;
  236.     }
  237. }
  238.  
  239. Tool *
  240. tools_new_hue_saturation (void)
  241. {
  242.   Tool * tool;
  243.   HueSaturation * private;
  244.  
  245.   /*  The tool options  */
  246.   if (!hue_saturation_options)
  247.     {
  248.       hue_saturation_options = tool_options_new (_("Hue-Saturation"));
  249.       tools_register (HUE_SATURATION, hue_saturation_options);
  250.     }
  251.  
  252.   tool = tools_new_tool (HUE_SATURATION);
  253.   private = g_new0 (HueSaturation, 1);
  254.  
  255.   tool->scroll_lock = TRUE;   /*  Disallow scrolling  */
  256.   tool->preserve    = FALSE;  /*  Don't preserve on drawable change  */
  257.  
  258.   tool->private = (void *) private;
  259.  
  260.   tool->control_func = hue_saturation_control;
  261.  
  262.   return tool;
  263. }
  264.  
  265. void
  266. hue_saturation_dialog_hide (void)
  267. {
  268.   if (hue_saturation_dialog)
  269.     hue_saturation_cancel_callback (NULL, (gpointer) hue_saturation_dialog);
  270. } 
  271.   
  272. void
  273. tools_free_hue_saturation (Tool *tool)
  274. {
  275.   HueSaturation * color_bal;
  276.  
  277.   color_bal = (HueSaturation *) tool->private;
  278.  
  279.   /*  Close the hue saturation dialog  */
  280.   hue_saturation_dialog_hide ();
  281.  
  282.   g_free (color_bal);
  283. }
  284.  
  285. void
  286. hue_saturation_initialize (GDisplay *gdisp)
  287. {
  288.   gint i;
  289.  
  290.   if (! drawable_color (gimage_active_drawable (gdisp->gimage)))
  291.     {
  292.       g_message (_("Hue-Saturation operates only on RGB color drawables."));
  293.       return;
  294.     }
  295.  
  296.   /*  The "hue-saturation" dialog  */
  297.   if (!hue_saturation_dialog)
  298.     hue_saturation_dialog = hue_saturation_dialog_new ();
  299.   else
  300.     if (!GTK_WIDGET_VISIBLE (hue_saturation_dialog->shell))
  301.       gtk_widget_show (hue_saturation_dialog->shell);
  302.  
  303.   for (i = 0; i < 7; i++)
  304.     {
  305.       hue_saturation_dialog->hue[i] = 0.0;
  306.       hue_saturation_dialog->lightness[i] = 0.0;
  307.       hue_saturation_dialog->saturation[i] = 0.0;
  308.     }
  309.  
  310.   hue_saturation_dialog->drawable = gimage_active_drawable (gdisp->gimage);
  311.   hue_saturation_dialog->image_map =
  312.     image_map_create (gdisp, hue_saturation_dialog->drawable);
  313.  
  314.   hue_saturation_update (hue_saturation_dialog, ALL);
  315. }
  316.  
  317. void
  318. hue_saturation_free (void)
  319. {
  320.   if (hue_saturation_dialog)
  321.     {
  322.       if (hue_saturation_dialog->image_map)
  323.     {
  324.       active_tool->preserve = TRUE;
  325.       image_map_abort (hue_saturation_dialog->image_map);
  326.       active_tool->preserve = FALSE;
  327.  
  328.       hue_saturation_dialog->image_map = NULL;
  329.     }
  330.       gtk_widget_destroy (hue_saturation_dialog->shell);
  331.     }
  332. }
  333.  
  334. /***************************/
  335. /*  Hue-Saturation dialog  */
  336. /***************************/
  337.  
  338. static HueSaturationDialog *
  339. hue_saturation_dialog_new (void)
  340. {
  341.   HueSaturationDialog *hsd;
  342.   GtkWidget *main_vbox;
  343.   GtkWidget *main_hbox;
  344.   GtkWidget *vbox;
  345.   GtkWidget *hbox;
  346.   GtkWidget *table;
  347.   GtkWidget *label;
  348.   GtkWidget *slider;
  349.   GtkWidget *abox;
  350.   GtkWidget *spinbutton;
  351.   GtkWidget *toggle;
  352.   GtkWidget *radio_button;
  353.   GtkWidget *frame;
  354.   GtkObject *data;
  355.   GSList *group = NULL;
  356.   gint i;
  357.  
  358.   gchar *hue_partition_names[] =
  359.   {
  360.     N_("Master"),
  361.     N_("R"),
  362.     N_("Y"),
  363.     N_("G"),
  364.     N_("C"),
  365.     N_("B"),
  366.     N_("M")
  367.   };
  368.  
  369.   hsd = g_new (HueSaturationDialog, 1);
  370.   hsd->hue_partition = ALL_HUES;
  371.   hsd->preview       = TRUE;
  372.  
  373.   /*  The shell and main vbox  */
  374.   hsd->shell = gimp_dialog_new (_("Hue-Saturation"), "hue_saturation",
  375.                 tools_help_func, NULL,
  376.                 GTK_WIN_POS_NONE,
  377.                 FALSE, TRUE, FALSE,
  378.  
  379.                 _("OK"), hue_saturation_ok_callback,
  380.                 hsd, NULL, NULL, TRUE, FALSE,
  381.                 _("Reset"), hue_saturation_reset_callback,
  382.                 hsd, NULL, NULL, FALSE, FALSE,
  383.                 _("Cancel"), hue_saturation_cancel_callback,
  384.                 hsd, NULL, NULL, FALSE, TRUE,
  385.  
  386.                 NULL);
  387.  
  388.   main_vbox = gtk_vbox_new (FALSE, 4);
  389.   gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 4);
  390.   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (hsd->shell)->vbox), main_vbox);
  391.  
  392.   /*  The main hbox containing hue partitions and sliders  */
  393.   main_hbox = gtk_hbox_new (FALSE, 12);
  394.   gtk_box_pack_start (GTK_BOX (main_vbox), main_hbox, FALSE, FALSE, 0);
  395.  
  396.   /*  The table containing hue partitions  */
  397.   table = gtk_table_new (7, 2, FALSE);
  398.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  399.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  400.   gtk_box_pack_start (GTK_BOX (main_hbox), table, FALSE, FALSE, 0);
  401.  
  402.   /*  the radio buttons for hue partitions  */
  403.   for (i = 0; i < 7; i++)
  404.     {
  405.       radio_button = gtk_radio_button_new_with_label (group, gettext (hue_partition_names[i]));
  406.       group = gtk_radio_button_group (GTK_RADIO_BUTTON (radio_button));
  407.       gtk_object_set_data (GTK_OBJECT (radio_button), "hue_partition",
  408.                (gpointer) i);
  409.  
  410.       if (!i)
  411.     {
  412.       gtk_table_attach (GTK_TABLE (table), radio_button, 0, 2, 0, 1,
  413.                 GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  414.     }
  415.       else
  416.     {
  417.       gtk_table_attach (GTK_TABLE (table), radio_button, 0, 1, i, i + 1,
  418.                 GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  419.  
  420.       frame = gtk_frame_new (NULL);
  421.       gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  422.       gtk_table_attach (GTK_TABLE (table), frame,  1, 2, i, i + 1,
  423.                 GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  424.       hsd->hue_partition_da[i - 1] = gtk_preview_new (GTK_PREVIEW_COLOR);
  425.       gtk_preview_size (GTK_PREVIEW (hsd->hue_partition_da[i - 1]),
  426.                 DA_WIDTH, DA_HEIGHT);
  427.       gtk_widget_set_events (hsd->hue_partition_da[i - 1],
  428.                  HUE_PARTITION_MASK);
  429.       gtk_signal_connect (GTK_OBJECT (hsd->hue_partition_da[i - 1]), "event",
  430.                   GTK_SIGNAL_FUNC (hue_saturation_hue_partition_events),
  431.                   hsd);
  432.       gtk_container_add (GTK_CONTAINER (frame), hsd->hue_partition_da[i - 1]);
  433.  
  434.       gtk_widget_show (hsd->hue_partition_da[i - 1]);
  435.       gtk_widget_show (frame);
  436.     }
  437.  
  438.       gtk_signal_connect (GTK_OBJECT (radio_button), "toggled",
  439.               GTK_SIGNAL_FUNC (hue_saturation_partition_callback),
  440.               hsd);
  441.  
  442.       gtk_widget_show (radio_button);
  443.     }
  444.  
  445.   gtk_widget_show (table);
  446.  
  447.   /*  The vbox for the table and preview toggle  */
  448.   vbox = gtk_vbox_new (FALSE, 4);
  449.   gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0);
  450.  
  451.   label = gtk_label_new (_("Hue / Lightness / Saturation Adjustments"));
  452.   gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
  453.   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
  454.   gtk_widget_show (label);
  455.  
  456.   /*  The table containing sliders  */
  457.   table = gtk_table_new (3, 3, FALSE);
  458.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  459.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  460.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  461.  
  462.   /*  Create the hue scale widget  */
  463.   label = gtk_label_new (_("Hue:"));
  464.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  465.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
  466.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  467.  
  468.   data = gtk_adjustment_new (0, -180, 180.0, 1.0, 1.0, 0.0);
  469.   hsd->hue_data = GTK_ADJUSTMENT (data);
  470.  
  471.   slider = gtk_hscale_new (hsd->hue_data);
  472.   gtk_widget_set_usize (slider, SLIDER_WIDTH, -1);
  473.   gtk_scale_set_digits (GTK_SCALE (slider), 0);
  474.   gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
  475.   gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
  476.   gtk_table_attach (GTK_TABLE (table), slider, 1, 2, 0, 1,
  477.             GTK_EXPAND | GTK_SHRINK | GTK_FILL,
  478.             GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
  479.  
  480.   abox = gtk_vbox_new (FALSE, 0);
  481.   spinbutton = gtk_spin_button_new (hsd->hue_data, 1.0, 0);
  482.   gtk_widget_set_usize (spinbutton, 74, -1);
  483.   gtk_box_pack_end (GTK_BOX (abox), spinbutton, FALSE, FALSE, 0);
  484.   gtk_table_attach (GTK_TABLE (table), abox, 2, 3, 0, 1,
  485.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  486.  
  487.   gtk_signal_connect (GTK_OBJECT (hsd->hue_data), "value_changed",
  488.               GTK_SIGNAL_FUNC (hue_saturation_hue_adjustment_update),
  489.               hsd);
  490.  
  491.   gtk_widget_show (label);
  492.   gtk_widget_show (slider);
  493.   gtk_widget_show (spinbutton);
  494.   gtk_widget_show (abox);
  495.  
  496.   /*  Create the lightness scale widget  */
  497.   label = gtk_label_new (_("Lightness:"));
  498.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  499.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
  500.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  501.  
  502.   data = gtk_adjustment_new (0, -100.0, 100.0, 1.0, 1.0, 0.0);
  503.   hsd->lightness_data = GTK_ADJUSTMENT (data);
  504.  
  505.   slider = gtk_hscale_new (hsd->lightness_data);
  506.   gtk_widget_set_usize (slider, SLIDER_WIDTH, -1);
  507.   gtk_scale_set_digits (GTK_SCALE (slider), 0);
  508.   gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
  509.   gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
  510.   gtk_table_attach (GTK_TABLE (table), slider, 1, 2, 1, 2,
  511.             GTK_EXPAND | GTK_SHRINK | GTK_FILL,
  512.             GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
  513.  
  514.   abox = gtk_vbox_new (FALSE, 0);
  515.   spinbutton = gtk_spin_button_new (hsd->lightness_data, 1.0, 0);
  516.   gtk_widget_set_usize (spinbutton, 75, -1);
  517.   gtk_box_pack_end (GTK_BOX (abox), spinbutton, FALSE, FALSE, 0);
  518.   gtk_table_attach (GTK_TABLE (table), abox, 2, 3, 1, 2,
  519.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  520.  
  521.   gtk_signal_connect (GTK_OBJECT (hsd->lightness_data), "value_changed",
  522.               GTK_SIGNAL_FUNC (hue_saturation_lightness_adjustment_update),
  523.               hsd);
  524.  
  525.   gtk_widget_show (label);
  526.   gtk_widget_show (slider);
  527.   gtk_widget_show (spinbutton);
  528.   gtk_widget_show (abox);
  529.  
  530.   /*  Create the saturation scale widget  */
  531.   label = gtk_label_new (_("Saturation:"));
  532.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  533.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
  534.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  535.  
  536.   data = gtk_adjustment_new (0, -100.0, 100.0, 1.0, 1.0, 0.0);
  537.   hsd->saturation_data = GTK_ADJUSTMENT (data);
  538.  
  539.   slider = gtk_hscale_new (hsd->saturation_data);
  540.   gtk_widget_set_usize (slider, SLIDER_WIDTH, -1);
  541.   gtk_scale_set_digits (GTK_SCALE (slider), 0);
  542.   gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
  543.   gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
  544.   gtk_table_attach (GTK_TABLE (table), slider, 1, 2, 2, 3,
  545.             GTK_EXPAND | GTK_SHRINK | GTK_FILL,
  546.             GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
  547.  
  548.   abox = gtk_vbox_new (FALSE, 0);
  549.   spinbutton = gtk_spin_button_new (hsd->saturation_data, 1.0, 0);
  550.   gtk_widget_set_usize (spinbutton, 75, -1);
  551.   gtk_box_pack_end (GTK_BOX (abox), spinbutton, FALSE, FALSE, 0);
  552.   gtk_table_attach (GTK_TABLE (table), abox, 2, 3, 2, 3,
  553.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  554.  
  555.   gtk_signal_connect (GTK_OBJECT (hsd->saturation_data), "value_changed",
  556.               GTK_SIGNAL_FUNC (hue_saturation_saturation_adjustment_update),
  557.               hsd);
  558.  
  559.   gtk_widget_show (label);
  560.   gtk_widget_show (slider);
  561.   gtk_widget_show (spinbutton);
  562.   gtk_widget_show (abox);
  563.  
  564.   gtk_widget_show (table);
  565.  
  566.   /*  Horizontal box for preview toggle button  */
  567.   hbox = gtk_hbox_new (FALSE, 4);
  568.   gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  569.  
  570.   /*  The preview toggle  */
  571.   toggle = gtk_check_button_new_with_label (_("Preview"));
  572.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), hsd->preview);
  573.   gtk_box_pack_end (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
  574.  
  575.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  576.               GTK_SIGNAL_FUNC (hue_saturation_preview_update),
  577.               hsd);
  578.  
  579.   gtk_widget_show (toggle);
  580.   gtk_widget_show (hbox);
  581.  
  582.   gtk_widget_show (vbox);
  583.   gtk_widget_show (main_hbox);
  584.   gtk_widget_show (main_vbox);
  585.   gtk_widget_show (hsd->shell);
  586.  
  587.   return hsd;
  588. }
  589.  
  590. static void
  591. hue_saturation_update (HueSaturationDialog *hsd,
  592.                gint                 update)
  593. {
  594.   gint i, j, b;
  595.   gint rgb[3];
  596.   guchar buf[DA_WIDTH * 3];
  597.  
  598.   if (update & HUE_SLIDER)
  599.     {
  600.       gtk_adjustment_set_value (GTK_ADJUSTMENT (hsd->hue_data),
  601.                 hsd->hue[hsd->hue_partition]);
  602.     }
  603.   if (update & LIGHTNESS_SLIDER)
  604.     {
  605.       gtk_adjustment_set_value (GTK_ADJUSTMENT (hsd->lightness_data),
  606.                 hsd->lightness[hsd->hue_partition]);
  607.     }
  608.   if (update & SATURATION_SLIDER)
  609.     {
  610.       gtk_adjustment_set_value (GTK_ADJUSTMENT (hsd->saturation_data),
  611.                 hsd->saturation[hsd->hue_partition]);
  612.     }
  613.  
  614.   hue_saturation_calculate_transfers (hsd);
  615.  
  616.   for (i = 0; i < 6; i++)
  617.     {
  618.       rgb[RED_PIX]   = default_colors[i][RED_PIX];
  619.       rgb[GREEN_PIX] = default_colors[i][GREEN_PIX];
  620.       rgb[BLUE_PIX]  = default_colors[i][BLUE_PIX];
  621.  
  622.       gimp_rgb_to_hls (rgb, rgb + 1, rgb + 2);
  623.  
  624.       rgb[RED_PIX]   = hue_transfer[i][rgb[RED_PIX]];
  625.       rgb[GREEN_PIX] = lightness_transfer[i][rgb[GREEN_PIX]];
  626.       rgb[BLUE_PIX]  = saturation_transfer[i][rgb[BLUE_PIX]];
  627.  
  628.       gimp_hls_to_rgb (rgb, rgb + 1, rgb + 2);
  629.  
  630.       for (j = 0; j < DA_WIDTH; j++)
  631.     for (b = 0; b < 3; b++)
  632.       buf[j * 3 + b] = (guchar) rgb[b];
  633.  
  634.       for (j = 0; j < DA_HEIGHT; j++)
  635.     gtk_preview_draw_row (GTK_PREVIEW (hsd->hue_partition_da[i]),
  636.                   buf, 0, j, DA_WIDTH);
  637.  
  638.       if (update & DRAW)
  639.     gtk_widget_draw (hsd->hue_partition_da[i], NULL);
  640.     }
  641. }
  642.  
  643. static void
  644. hue_saturation_preview (HueSaturationDialog *hsd)
  645. {
  646.   if (!hsd->image_map)
  647.     {
  648.       g_warning ("hue_saturation_preview(): No image map");
  649.       return;
  650.     }
  651.  
  652.   active_tool->preserve = TRUE;
  653.   image_map_apply (hsd->image_map, hue_saturation, (void *) hsd);
  654.   active_tool->preserve = FALSE;
  655. }
  656.  
  657. static void
  658. hue_saturation_reset_callback (GtkWidget *widget,
  659.                    gpointer   data)
  660. {
  661.   HueSaturationDialog *hsd;
  662.  
  663.   hsd = (HueSaturationDialog *) data;
  664.  
  665.   hsd->hue[hsd->hue_partition] = 0.0;
  666.   hsd->lightness[hsd->hue_partition] = 0.0;
  667.   hsd->saturation[hsd->hue_partition] = 0.0;
  668.  
  669.   hue_saturation_update (hsd, ALL);
  670.  
  671.   if (hsd->preview)
  672.     hue_saturation_preview (hsd);
  673. }
  674.  
  675. static void
  676. hue_saturation_ok_callback (GtkWidget *widget,
  677.                 gpointer   data)
  678. {
  679.   HueSaturationDialog *hsd;
  680.  
  681.   hsd = (HueSaturationDialog *) data;
  682.  
  683.   gimp_dialog_hide (hsd->shell);
  684.  
  685.   active_tool->preserve = TRUE;
  686.  
  687.   if (!hsd->preview)
  688.     image_map_apply (hsd->image_map, hue_saturation, (void *) hsd);
  689.  
  690.   if (hsd->image_map)
  691.     image_map_commit (hsd->image_map);
  692.  
  693.   active_tool->preserve = FALSE;
  694.  
  695.   hsd->image_map = NULL;
  696.  
  697.   active_tool->gdisp_ptr = NULL;
  698.   active_tool->drawable = NULL;
  699. }
  700.  
  701. static void
  702. hue_saturation_cancel_callback (GtkWidget *widget,
  703.                 gpointer   data)
  704. {
  705.   HueSaturationDialog *hsd;
  706.  
  707.   hsd = (HueSaturationDialog *) data;
  708.  
  709.   gimp_dialog_hide (hsd->shell);
  710.  
  711.   if (hsd->image_map)
  712.     {
  713.       active_tool->preserve = TRUE;
  714.       image_map_abort (hsd->image_map);
  715.       active_tool->preserve = FALSE;
  716.  
  717.       gdisplays_flush ();
  718.       hsd->image_map = NULL;
  719.     }
  720.  
  721.   active_tool->gdisp_ptr = NULL;
  722.   active_tool->drawable = NULL;
  723. }
  724.  
  725. static void
  726. hue_saturation_partition_callback (GtkWidget *widget,
  727.                    gpointer   data)
  728. {
  729.   HueSaturationDialog *hsd;
  730.   HueRange partition;
  731.  
  732.   hsd = (HueSaturationDialog *) data;
  733.  
  734.   partition = (HueRange) gtk_object_get_data (GTK_OBJECT (widget),
  735.                           "hue_partition");
  736.   hsd->hue_partition = partition;
  737.  
  738.   hue_saturation_update (hsd, ALL);
  739. }
  740.  
  741. static void
  742. hue_saturation_preview_update (GtkWidget *widget,
  743.                    gpointer   data)
  744. {
  745.   HueSaturationDialog *hsd;
  746.  
  747.   hsd = (HueSaturationDialog *) data;
  748.  
  749.   if (GTK_TOGGLE_BUTTON (widget)->active)
  750.     {
  751.       hsd->preview = TRUE;
  752.       hue_saturation_preview (hsd);
  753.     }
  754.   else
  755.     {
  756.       hsd->preview = FALSE;
  757.       if (hsd->image_map)
  758.     {
  759.       active_tool->preserve = TRUE;
  760.       image_map_clear (hsd->image_map);
  761.       active_tool->preserve = FALSE;
  762.       gdisplays_flush ();
  763.     }
  764.     }
  765. }
  766.  
  767. static void
  768. hue_saturation_hue_adjustment_update (GtkAdjustment *adjustment,
  769.                       gpointer       data)
  770. {
  771.   HueSaturationDialog *hsd;
  772.  
  773.   hsd = (HueSaturationDialog *) data;
  774.  
  775.   if (hsd->hue[hsd->hue_partition] != adjustment->value)
  776.     {
  777.       hsd->hue[hsd->hue_partition] = adjustment->value;
  778.       hue_saturation_update (hsd, DRAW);
  779.  
  780.       if (hsd->preview)
  781.     hue_saturation_preview (hsd);
  782.     }
  783. }
  784.  
  785. static void
  786. hue_saturation_lightness_adjustment_update (GtkAdjustment *adjustment,
  787.                         gpointer       data)
  788. {
  789.   HueSaturationDialog *hsd;
  790.  
  791.   hsd = (HueSaturationDialog *) data;
  792.  
  793.   if (hsd->lightness[hsd->hue_partition] != adjustment->value)
  794.     {
  795.       hsd->lightness[hsd->hue_partition] = adjustment->value;
  796.       hue_saturation_update (hsd, DRAW);
  797.  
  798.       if (hsd->preview)
  799.     hue_saturation_preview (hsd);
  800.     }
  801. }
  802.  
  803. static void
  804. hue_saturation_saturation_adjustment_update (GtkAdjustment *adjustment,
  805.                          gpointer       data)
  806. {
  807.   HueSaturationDialog *hsd;
  808.  
  809.   hsd = (HueSaturationDialog *) data;
  810.  
  811.   if (hsd->saturation[hsd->hue_partition] != adjustment->value)
  812.     {
  813.       hsd->saturation[hsd->hue_partition] = adjustment->value;
  814.       hue_saturation_update (hsd, DRAW);
  815.  
  816.       if (hsd->preview)
  817.     hue_saturation_preview (hsd);
  818.     }
  819. }
  820.  
  821. static gint
  822. hue_saturation_hue_partition_events (GtkWidget           *widget,
  823.                      GdkEvent            *event,
  824.                      HueSaturationDialog *hsd)
  825. {
  826.   switch (event->type)
  827.     {
  828.     case GDK_EXPOSE:
  829.       hue_saturation_update (hsd, HUE_PARTITION);
  830.       break;
  831.  
  832.     default:
  833.       break;
  834.     }
  835.  
  836.   return FALSE;
  837. }
  838.