gimp/app/color_notebook.c

/* The GIMP -- an image manipulation program
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * color_notebook module (C) 1998 Austin Donnelly <austin@greenend.org.uk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#define __COLOR_NOTEBOOK_C__ 1

#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <gmodule.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>

#include "apptypes.h"

#include "color_area.h"
#include "color_notebook.h"
#include "colormaps.h"
#include "gimpdnd.h"
#include "gimpui.h"

#include "libgimp/gimphelpui.h"
#include "libgimp/gimpcolorselector.h"
#include "libgimp/gimpcolorspace.h"

#include "libgimp/gimpintl.h"


#define COLOR_AREA_WIDTH   74
#define COLOR_AREA_HEIGHT  20


typedef enum
{
  UPDATE_NOTEBOOK   = 1 << 0,
  UPDATE_CHANNEL    = 1 << 1,
  UPDATE_NEW_COLOR  = 1 << 2,
  UPDATE_ORIG_COLOR = 1 << 3,
  UPDATE_CALLER     = 1 << 4
} ColorNotebookUpdateType;


struct _ColorNotebook
{
  GtkWidget                *shell;
  GtkWidget                *notebook;

  GtkWidget                *new_color;
  GtkWidget                *orig_color;
  GtkWidget                *toggles[7];
  GtkObject                *slider_data[7];
  GtkWidget                *hex_entry;

  GdkGC                    *gc;

  gint                      values[7];
  gint                      orig_values[4];

  GimpColorSelectorChannelType  active_channel;

  ColorNotebookCallback     callback;
  gpointer                  client_data;

  gint                      wants_updates;

  ColorSelectorInstance    *selectors;
  ColorSelectorInstance    *cur_page;
};


/* information we keep on each registered colour selector */
typedef struct _ColorSelectorInfo ColorSelectorInfo;

struct _ColorSelectorInfo
{
  gchar                       *name;    /* label used in notebook tab */
  gchar                       *help_page;
  GimpColorSelectorMethods     methods;
  gint                         refs;    /* number of instances around */
  gboolean                     active;
  GimpColorSelectorFinishedCB  death_callback;
  gpointer                     death_data;

  ColorSelectorInfo           *next;
};

struct _ColorSelectorInstance
{
  ColorNotebook         *color_notebook;
  ColorSelectorInfo     *info;
  GtkWidget             *frame;   /* main widget */
  gpointer               selector_data;

  ColorSelectorInstance *next;
};


static void       color_notebook_ok_callback     (GtkWidget         *widget,
						  gpointer           data);
static void       color_notebook_cancel_callback (GtkWidget         *widget,
						  gpointer           data);
static void       color_notebook_update_callback (gpointer           data,
						  gint               hue,
						  gint               saturation,
						  gint               value,
						  gint               red,
						  gint               green,
						  gint               blue,
						  gint               alpha);
static void       color_notebook_page_switch     (GtkWidget         *widget,
						  GtkNotebookPage   *page,
						  guint              page_num,
						  gpointer           data);
static void       color_notebook_help_func       (const gchar       *help_data);

static void       color_notebook_selector_death  (ColorSelectorInfo *info);

static void       color_notebook_update          (ColorNotebook     *cnp,
						  ColorNotebookUpdateType update);
static void       color_notebook_update_notebook (ColorNotebook     *cnp);
static void       color_notebook_update_channel  (ColorNotebook     *cnp);
static void       color_notebook_update_caller   (ColorNotebook     *cnp);
static void       color_notebook_update_colors   (ColorNotebook     *cnp,
						  ColorNotebookUpdateType which);
static void       color_notebook_update_rgb_values (ColorNotebook   *cnp);
static void       color_notebook_update_hsv_values (ColorNotebook   *cnp);
static void       color_notebook_update_scales     (ColorNotebook   *cnp,
						    gint             skip);

static gboolean   color_notebook_color_events    (GtkWidget         *widget,
						  GdkEvent          *event,
						  gpointer           data);

static void       color_notebook_toggle_update   (GtkWidget         *widget,
						  gpointer           data);
static void       color_notebook_scale_update    (GtkAdjustment     *adjustment,
						  gpointer           data);
static gint       color_notebook_hex_entry_events (GtkWidget      *widget,
						   GdkEvent       *event,
						   gpointer        data);

static void       color_notebook_drag_new_color  (GtkWidget         *widget,
						  guchar            *r,
						  guchar            *g,
						  guchar            *b,
						  guchar            *a,
						  gpointer           data);
static void       color_notebook_drop_new_color  (GtkWidget         *widget,
						  guchar             r,
						  guchar             g,
						  guchar             b,
						  guchar             a,
						  gpointer           data);
static void       color_notebook_drag_old_color  (GtkWidget         *widget,
						  guchar            *r,
						  guchar            *g,
						  guchar            *b,
						  guchar            *a,
						  gpointer           data);


/* master list of all registered colour selectors */
static ColorSelectorInfo *selector_info = NULL;

/*  dnd stuff  */
static GtkTargetEntry color_notebook_target_table[] =
{
  GIMP_TARGET_COLOR
};
static guint n_color_notebook_targets = (sizeof (color_notebook_target_table) /
					 sizeof (color_notebook_target_table[0]));


ColorNotebook *
color_notebook_new (gint                   red,
		    gint                   green,
		    gint                   blue,
		    gint                   alpha,
		    ColorNotebookCallback  callback,
		    gpointer               client_data,
		    gboolean               wants_updates,
		    gboolean               show_alpha)
{
  ColorNotebook         *cnp;
  GtkWidget             *main_hbox;
  GtkWidget             *right_vbox;
  GtkWidget             *colors_frame;
  GtkWidget             *hbox;
  GtkWidget             *table;
  GtkWidget             *label;
  GSList                *group;
  gchar                  buffer[16];
  ColorSelectorInfo     *info;
  ColorSelectorInstance *csel;
  gint                   i;

  static gchar *toggle_titles[] = 
  { 
    N_("H"),
    N_("S"),
    N_("V"),
    N_("R"),
    N_("G"),
    N_("B"),
    N_("A")
  };
  static gchar *slider_tips[7] = 
  { 
    N_("Hue"),
    N_("Saturation"),
    N_("Value"),
    N_("Red"),
    N_("Green"),
    N_("Blue"),
    N_("Alpha")
  };
  static gdouble  slider_max_vals[] = { 360, 100, 100, 255, 255, 255, 255 };
  static gdouble  slider_incs[]     = {  30,  10,  10,  16,  16,  16,  16 };

  g_return_val_if_fail (selector_info != NULL, NULL);

  cnp = g_new0 (ColorNotebook, 1);

  cnp->gc            = NULL;

  cnp->callback      = callback;
  cnp->client_data   = client_data;
  cnp->wants_updates = wants_updates;
  cnp->selectors     = NULL;
  cnp->cur_page      = NULL;

  cnp->values[GIMP_COLOR_SELECTOR_RED]   = cnp->orig_values[0] = red   & 0xff;
  cnp->values[GIMP_COLOR_SELECTOR_GREEN] = cnp->orig_values[1] = green & 0xff;
  cnp->values[GIMP_COLOR_SELECTOR_BLUE]  = cnp->orig_values[2] = blue  & 0xff;
  cnp->values[GIMP_COLOR_SELECTOR_ALPHA] = cnp->orig_values[3] = alpha & 0xff;

  color_notebook_update_hsv_values (cnp); 

  cnp->shell =
    gimp_dialog_new (_("Color Selection"), "color_selection",
		     color_notebook_help_func, (const gchar *) cnp,
		     GTK_WIN_POS_NONE,
		     FALSE, FALSE, FALSE,

		     wants_updates ? _("Close") : _("OK"),
		     color_notebook_ok_callback,
		     cnp, NULL, NULL, TRUE, wants_updates,
		     wants_updates ? _("Revert to Old Color") : _("Cancel"),
		     color_notebook_cancel_callback,
		     cnp, NULL, NULL, FALSE, !wants_updates,

		     NULL);

  main_hbox = gtk_hbox_new (FALSE, 6);
  gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 2);
  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (cnp->shell)->vbox), main_hbox);
  gtk_widget_show (main_hbox);

  /* do we actually need a notebook? */
  if (selector_info->next)
    {
      cnp->notebook = gtk_notebook_new ();
      gtk_box_pack_start (GTK_BOX (main_hbox), cnp->notebook,
			  FALSE, FALSE, 0);
      gtk_widget_show (cnp->notebook);
    }
  else /* only one selector */
    {
      cnp->notebook = NULL;
    }

  /* create each registered color selector */
  info = selector_info;
  while (info)
    {
      if (info->active)
	{
	  csel = g_new (ColorSelectorInstance, 1);
	  csel->color_notebook = cnp;
	  csel->info = info;
	  info->refs++;
	  csel->frame =
	    info->methods.new (cnp->values[GIMP_COLOR_SELECTOR_HUE],
			       cnp->values[GIMP_COLOR_SELECTOR_SATURATION],
			       cnp->values[GIMP_COLOR_SELECTOR_VALUE],
			       cnp->values[GIMP_COLOR_SELECTOR_RED],
			       cnp->values[GIMP_COLOR_SELECTOR_GREEN],
			       cnp->values[GIMP_COLOR_SELECTOR_BLUE],
			       cnp->values[GIMP_COLOR_SELECTOR_ALPHA],
			       show_alpha,
			       color_notebook_update_callback, csel,
			       &csel->selector_data);
	  gtk_object_set_data (GTK_OBJECT (csel->frame), "gimp_color_notebook",
			       csel);

	  if (cnp->notebook)
	    {
	      label = gtk_label_new (info->name);
	      gtk_widget_show (label);
	      /* hide the frame, so it doesn't get selected by mistake */
	      gtk_widget_hide (csel->frame);
	      gtk_notebook_append_page (GTK_NOTEBOOK (cnp->notebook),
					csel->frame,
					label);
	    }
	  else
	    {
	      gtk_box_pack_start (GTK_BOX (main_hbox), csel->frame,
				  FALSE, FALSE, 0);
	    }

	  gtk_widget_show (csel->frame);

	  if (!cnp->cur_page)
	    cnp->cur_page = csel;

	  /* link into list of all selectors hanging off the new notebook */
	  csel->next = cnp->selectors;
	  cnp->selectors = csel;
	}

      info = info->next;
    }

  /*  The right vertical box with old/new color area and color space sliders  */
  right_vbox = gtk_vbox_new (FALSE, 2);
  gtk_box_pack_start (GTK_BOX (main_hbox), right_vbox, TRUE, TRUE, 0);
  gtk_widget_show (right_vbox);

  /*  The old/new color area frame and hbox  */
  colors_frame = gtk_frame_new (NULL);
  gtk_frame_set_shadow_type (GTK_FRAME (colors_frame), GTK_SHADOW_IN);
  gtk_box_pack_start (GTK_BOX (right_vbox), colors_frame, FALSE, FALSE, 0);
  gtk_widget_show (colors_frame);

  hbox = gtk_hbox_new (TRUE, 2);
  gtk_container_add (GTK_CONTAINER (colors_frame), hbox);
  gtk_widget_show (hbox);

  /*  The new color area  */
  cnp->new_color = gtk_drawing_area_new ();
  gtk_drawing_area_size (GTK_DRAWING_AREA (cnp->new_color),
                         COLOR_AREA_WIDTH, COLOR_AREA_HEIGHT);
  gtk_widget_set_events (cnp->new_color, GDK_EXPOSURE_MASK);
  gtk_signal_connect (GTK_OBJECT (cnp->new_color), "event",
                      GTK_SIGNAL_FUNC (color_notebook_color_events),
                      cnp);

  gtk_object_set_user_data (GTK_OBJECT (cnp->new_color), cnp);
  gtk_box_pack_start (GTK_BOX (hbox), cnp->new_color, TRUE, TRUE, 0);
  gtk_widget_show (cnp->new_color);

  /*  dnd stuff  */
  gtk_drag_source_set (cnp->new_color,
                       GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
                       color_notebook_target_table, n_color_notebook_targets,
                       GDK_ACTION_COPY | GDK_ACTION_MOVE);
  gimp_dnd_color_source_set (cnp->new_color, color_notebook_drag_new_color, cnp);

  gtk_drag_dest_set (cnp->new_color,
                     GTK_DEST_DEFAULT_HIGHLIGHT |
                     GTK_DEST_DEFAULT_MOTION |
                     GTK_DEST_DEFAULT_DROP,
                     color_notebook_target_table, n_color_notebook_targets,
                     GDK_ACTION_COPY);
  gimp_dnd_color_dest_set (cnp->new_color, color_notebook_drop_new_color, cnp);

  /*  The old color area  */
  cnp->orig_color = gtk_drawing_area_new ();
  gtk_drawing_area_size (GTK_DRAWING_AREA (cnp->orig_color),
                         COLOR_AREA_WIDTH, COLOR_AREA_HEIGHT);
  gtk_widget_set_events (cnp->orig_color, GDK_EXPOSURE_MASK);
  gtk_signal_connect (GTK_OBJECT (cnp->orig_color), "event",
                      GTK_SIGNAL_FUNC (color_notebook_color_events),
                      cnp);
  gtk_object_set_user_data (GTK_OBJECT (cnp->orig_color), cnp);
  gtk_box_pack_start (GTK_BOX (hbox), cnp->orig_color, TRUE, TRUE, 0);
  gtk_widget_show (cnp->orig_color);

  /*  dnd stuff  */
  gtk_drag_source_set (cnp->orig_color,
                       GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
                       color_notebook_target_table, n_color_notebook_targets,
                       GDK_ACTION_COPY | GDK_ACTION_MOVE);
  gimp_dnd_color_source_set (cnp->orig_color, color_notebook_drag_old_color,
			     cnp);

  /*  The color space sliders, toggle buttons and entries  */
  table = gtk_table_new (7, 3, FALSE);
  gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  gtk_table_set_col_spacings (GTK_TABLE (table), 2);
  gtk_box_pack_start (GTK_BOX (right_vbox), table, TRUE, TRUE, 0);
  gtk_widget_show (table);

  group = NULL;
  for (i = 0; i < 7; i++)
    {
      cnp->toggles[i] =
        gtk_radio_button_new_with_label (group, gettext (toggle_titles[i]));
      gimp_help_set_help_data (cnp->toggles[i], gettext (slider_tips[i]), NULL);
      group = gtk_radio_button_group (GTK_RADIO_BUTTON (cnp->toggles[i]));
      gtk_table_attach (GTK_TABLE (table), cnp->toggles[i],
                        0, 1, i, i + 1, GTK_FILL, GTK_EXPAND, 0, 0);
      gtk_signal_connect (GTK_OBJECT (cnp->toggles[i]), "toggled",
                          GTK_SIGNAL_FUNC (color_notebook_toggle_update),
                          cnp);
      gtk_widget_show (cnp->toggles[i]);

      cnp->slider_data[i] = gimp_scale_entry_new (GTK_TABLE (table), 0, i,
                                                  NULL, 
                                                  80, 55,
                                                  cnp->values[i], 
                                                  0.0, slider_max_vals[i],
                                                  1.0, slider_incs[i],
                                                  0, TRUE, 0.0, 0.0,
                                                  gettext (slider_tips[i]),
                                                  NULL);
      gtk_signal_connect (GTK_OBJECT (cnp->slider_data[i]), "value_changed",
                          GTK_SIGNAL_FUNC (color_notebook_scale_update),
                          cnp);
    }

  /* The hex triplet entry */
  hbox = gtk_hbox_new (FALSE, 3);
  gtk_box_pack_start (GTK_BOX (right_vbox), hbox, FALSE, FALSE, 0);
  gtk_widget_show (hbox);

  cnp->hex_entry = gtk_entry_new ();
  g_snprintf (buffer, sizeof (buffer), "#%.2x%.2x%.2x", red, green, blue);
  gtk_entry_set_text (GTK_ENTRY (cnp->hex_entry), buffer);
  gtk_widget_set_usize (GTK_WIDGET (cnp->hex_entry), 75, 0);
  gtk_box_pack_end (GTK_BOX (hbox), cnp->hex_entry, FALSE, FALSE, 2);
  gtk_signal_connect (GTK_OBJECT (cnp->hex_entry), "focus_out_event",
                      GTK_SIGNAL_FUNC (color_notebook_hex_entry_events),
                      cnp);
  gtk_signal_connect (GTK_OBJECT (cnp->hex_entry), "key_press_event",
                      GTK_SIGNAL_FUNC (color_notebook_hex_entry_events),
                      cnp);
  gtk_widget_show (cnp->hex_entry);

  label = gtk_label_new (_("Hex Triplet:"));
  gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
  gtk_widget_show (label);

  gtk_widget_show (cnp->shell);

  /* this must come after showing the widget, otherwise we get a
   * switch_page signal for a non-visible color selector, which is bad
   * news.
   */
  if (cnp->notebook)
    {
      gtk_signal_connect (GTK_OBJECT (cnp->notebook), "switch_page",
			  GTK_SIGNAL_FUNC (color_notebook_page_switch),
			  cnp);
    }

  return cnp;
}

void
color_notebook_show (ColorNotebook *cnp)
{
  g_return_if_fail (cnp != NULL);

  if (! GTK_WIDGET_VISIBLE (cnp->shell))
    gtk_widget_show (cnp->shell);
  else
    gdk_window_raise (cnp->shell->window);
}

void
color_notebook_hide (ColorNotebook *cnp)
{
  g_return_if_fail (cnp != NULL);
  gtk_widget_hide (cnp->shell);
}

void
color_notebook_free (ColorNotebook *cnp)
{
  ColorSelectorInstance *csel, *next;

  g_return_if_fail (cnp != NULL);

  gtk_widget_destroy (cnp->shell);

  /* call the free functions for all the color selectors */
  csel = cnp->selectors;
  while (csel)
    {
      next = csel->next;

      csel->info->methods.free (csel->selector_data);

      csel->info->refs--;
      if (csel->info->refs == 0 && !csel->info->active)
	color_notebook_selector_death (csel->info);

      g_free (csel);
      csel = next;
    }

  g_free (cnp);
}

void
color_notebook_set_color (ColorNotebook *cnp,
			  gint           red,
			  gint           green,
			  gint           blue,
			  gint           alpha)
{
  g_return_if_fail (cnp != NULL);

  cnp->values[GIMP_COLOR_SELECTOR_RED]   = cnp->orig_values[0] = red;
  cnp->values[GIMP_COLOR_SELECTOR_GREEN] = cnp->orig_values[1] = green;
  cnp->values[GIMP_COLOR_SELECTOR_BLUE]  = cnp->orig_values[2] = blue;
  cnp->values[GIMP_COLOR_SELECTOR_ALPHA] = cnp->orig_values[3] = alpha;

  color_notebook_update (cnp,
			 UPDATE_NOTEBOOK   |
			 UPDATE_ORIG_COLOR |
			 UPDATE_NEW_COLOR);
}

/*
 * Called by a color selector on user selection of a color
 */
static void
color_notebook_update_callback (gpointer data,
				gint     hue,
				gint     saturation,
				gint     value,
				gint     red,
				gint     green,
				gint     blue,
				gint     alpha)
{
  ColorSelectorInstance *csel;
  ColorNotebook         *cnp;

  g_return_if_fail (data != NULL);

  csel = (ColorSelectorInstance *) data;
  cnp = csel->color_notebook;

  cnp->values[GIMP_COLOR_SELECTOR_HUE]        = hue;
  cnp->values[GIMP_COLOR_SELECTOR_SATURATION] = saturation;
  cnp->values[GIMP_COLOR_SELECTOR_VALUE]      = value;
  cnp->values[GIMP_COLOR_SELECTOR_RED]        = red;
  cnp->values[GIMP_COLOR_SELECTOR_GREEN]      = green;
  cnp->values[GIMP_COLOR_SELECTOR_BLUE]       = blue;
  cnp->values[GIMP_COLOR_SELECTOR_ALPHA]      = alpha;

  color_notebook_update_scales (cnp, -1);

  color_notebook_update (cnp,
			 UPDATE_NEW_COLOR |
			 UPDATE_CALLER);
}

static void
color_notebook_ok_callback (GtkWidget *widget,
			    gpointer   data)
{
  ColorNotebook *cnp;

  cnp = (ColorNotebook *) data;

  if (cnp->callback)
    {
      (* cnp->callback) (cnp->values[GIMP_COLOR_SELECTOR_RED],
			 cnp->values[GIMP_COLOR_SELECTOR_GREEN],
			 cnp->values[GIMP_COLOR_SELECTOR_BLUE],
			 cnp->values[GIMP_COLOR_SELECTOR_ALPHA],
			 COLOR_NOTEBOOK_OK,
			 cnp->client_data);
    }
}

static void
color_notebook_cancel_callback (GtkWidget *widget,
				gpointer   data)
{
  ColorNotebook *cnp;

  cnp = (ColorNotebook *) data;

  if (cnp->callback)
    {
      (* cnp->callback) (cnp->orig_values[0],
			 cnp->orig_values[1],
			 cnp->orig_values[2],
			 cnp->orig_values[3],
			 COLOR_NOTEBOOK_CANCEL,
			 cnp->client_data);
    }
}

static void
color_notebook_page_switch (GtkWidget       *widget,
			    GtkNotebookPage *page,
			    guint            page_num,
			    gpointer         data)
{
  ColorNotebook         *cnp;
  ColorSelectorInstance *csel;

  cnp = (ColorNotebook *) data;

  csel = gtk_object_get_data (GTK_OBJECT (page->child), "gimp_color_notebook");

  g_return_if_fail (cnp != NULL && csel != NULL);

  cnp->cur_page = csel;

  color_notebook_update (cnp, UPDATE_CHANNEL | UPDATE_NOTEBOOK);
}

static void
color_notebook_help_func (const gchar *data)
{
  ColorNotebook *cnp;
  gchar         *help_path;

  cnp = (ColorNotebook *) data;

  help_path = g_strconcat ("dialogs/color_selectors/",
			   cnp->cur_page->info->help_page,
			   NULL);
  gimp_standard_help_func (help_path);
  g_free (help_path);
}

/**************************/
/* Registration functions */

G_MODULE_EXPORT
GimpColorSelectorID
gimp_color_selector_register (const gchar              *name,
			      const gchar              *help_page,
			      GimpColorSelectorMethods *methods)
{
  ColorSelectorInfo *info;

  /* check the name is unique */
  info = selector_info;
  while (info)
    {
      if (!strcmp (info->name, name))
	return NULL;
      info = info->next;
    }

  info = g_new (ColorSelectorInfo, 1);

  info->name      = g_strdup (name);
  info->help_page = g_strdup (help_page);
  info->methods   = *methods;
  info->refs      = 0;
  info->active    = TRUE;

  info->next      = selector_info;

  selector_info = info;
  
  return info;
}


G_MODULE_EXPORT
gboolean
gimp_color_selector_unregister (GimpColorSelectorID          id,
				GimpColorSelectorFinishedCB  callback,
				gpointer                     data)
{
  ColorSelectorInfo *info;

  info = selector_info;
  while (info)
    {
      if (info == id)
	{
	  info->active         = FALSE;
	  info->death_callback = callback;
	  info->death_data     = data;
	  if (info->refs == 0)
	    color_notebook_selector_death (info);
	  return TRUE;
	}
      info = info->next;
    }

  g_warning ("unknown color selector id %p", id);
  return FALSE;
}

static void
color_notebook_selector_death (ColorSelectorInfo *info)
{
  ColorSelectorInfo *here, *prev;

  here = selector_info;
  prev = NULL;
  while (here)
    {
      if (here == info)
	{	  
	  if (prev)
	    prev->next = info->next;
	  else
	    selector_info = info->next;

	  if (info->death_callback)
	    (*info->death_callback) (info->death_data);

	  g_free (info->name);
	  g_free (info);

	  return;
	}
      prev = here;
      here = here->next;
    }

  g_warning ("color selector %p not found, can't happen!", info);
}

static void
color_notebook_update (ColorNotebook           *cnp,
		       ColorNotebookUpdateType  update)
{
  if (!cnp)
    return;

  if (update & UPDATE_NOTEBOOK)
    color_notebook_update_notebook (cnp);

  if (update & UPDATE_CHANNEL)
    color_notebook_update_channel (cnp);

  if (update & UPDATE_NEW_COLOR)
    color_notebook_update_colors (cnp, UPDATE_NEW_COLOR);

  if (update & UPDATE_ORIG_COLOR)
    color_notebook_update_colors (cnp, UPDATE_ORIG_COLOR);

  if (update & UPDATE_CALLER && cnp->wants_updates)
    color_notebook_update_caller (cnp);
}

static void
color_notebook_update_notebook (ColorNotebook *cnp)
{
  ColorSelectorInstance *csel;

  g_return_if_fail (cnp != NULL);

  csel = cnp->cur_page;
  csel->info->methods.set_color (csel->selector_data,
				 cnp->values[GIMP_COLOR_SELECTOR_HUE],
				 cnp->values[GIMP_COLOR_SELECTOR_SATURATION],
				 cnp->values[GIMP_COLOR_SELECTOR_VALUE],
				 cnp->values[GIMP_COLOR_SELECTOR_RED],
				 cnp->values[GIMP_COLOR_SELECTOR_GREEN],
				 cnp->values[GIMP_COLOR_SELECTOR_BLUE],
				 cnp->values[GIMP_COLOR_SELECTOR_ALPHA]);
}

static void
color_notebook_update_channel (ColorNotebook *cnp)
{
  ColorSelectorInstance *csel;

  g_return_if_fail (cnp != NULL);

  csel = cnp->cur_page;
  csel->info->methods.set_channel (csel->selector_data,
				   cnp->active_channel);
}

static void
color_notebook_update_caller (ColorNotebook *cnp)
{
  if (cnp && cnp->callback)
    {
      (* cnp->callback) (cnp->values[GIMP_COLOR_SELECTOR_RED],
			 cnp->values[GIMP_COLOR_SELECTOR_GREEN],
			 cnp->values[GIMP_COLOR_SELECTOR_BLUE],
			 cnp->values[GIMP_COLOR_SELECTOR_ALPHA],
			 COLOR_NOTEBOOK_UPDATE,
			 cnp->client_data);
    }
}

static void
color_notebook_update_colors (ColorNotebook           *cnp,
			      ColorNotebookUpdateType  which)
{
  GdkWindow *window;
  GdkColor   color;
  gint       red, green, blue;
  gint       width, height;

  if (!cnp)
    return;

  if (which == UPDATE_ORIG_COLOR)
    {
      window = cnp->orig_color->window;
      red    = cnp->orig_values[0];
      green  = cnp->orig_values[1];
      blue   = cnp->orig_values[2];
    }
  else if (which == UPDATE_NEW_COLOR)
    {
      window = cnp->new_color->window;
      red    = cnp->values[GIMP_COLOR_SELECTOR_RED];
      green  = cnp->values[GIMP_COLOR_SELECTOR_GREEN];
      blue   = cnp->values[GIMP_COLOR_SELECTOR_BLUE];
    }
  else
    {
      return;
    }

  /* if we haven't yet been realized, there's no need to redraw
   * anything.
   */
  if (!window)
    return;

  color.pixel = get_color (red, green, blue);

  gdk_window_get_size (window, &width, &height);

  if (cnp->gc)
    {
      color_area_draw_rect (window, cnp->gc,
                            0, 0, width, height,
                            red, green, blue);
    }
}

static void
color_notebook_update_rgb_values (ColorNotebook *cnp)
{
  gdouble h, s, v;

  if (!cnp)
    return;

  h = cnp->values[GIMP_COLOR_SELECTOR_HUE]        / 360.0;
  s = cnp->values[GIMP_COLOR_SELECTOR_SATURATION] / 100.0;
  v = cnp->values[GIMP_COLOR_SELECTOR_VALUE]      / 100.0;

  gimp_hsv_to_rgb_double (&h, &s, &v);

  cnp->values[GIMP_COLOR_SELECTOR_RED]   = h * 255;
  cnp->values[GIMP_COLOR_SELECTOR_GREEN] = s * 255;
  cnp->values[GIMP_COLOR_SELECTOR_BLUE]  = v * 255;
}

static void
color_notebook_update_hsv_values (ColorNotebook *cnp)
{
  gdouble r, g, b;

  if (!cnp)
    return;

  r = cnp->values[GIMP_COLOR_SELECTOR_RED]   / 255.0;
  g = cnp->values[GIMP_COLOR_SELECTOR_GREEN] / 255.0;
  b = cnp->values[GIMP_COLOR_SELECTOR_BLUE]  / 255.0;

  gimp_rgb_to_hsv_double (&r, &g, &b);

  cnp->values[GIMP_COLOR_SELECTOR_HUE]        = r * 360.0;
  cnp->values[GIMP_COLOR_SELECTOR_SATURATION] = g * 100.0;
  cnp->values[GIMP_COLOR_SELECTOR_VALUE]      = b * 100.0;
}

static void
color_notebook_update_scales (ColorNotebook *cnp,
			      gint           skip)
{
  gchar buffer[16];
  gint  i;

  if (!cnp)
    return;

  for (i = 0; i < 7; i++)
    if (i != skip)
      {
	gtk_signal_handler_block_by_data (GTK_OBJECT (cnp->slider_data[i]), cnp);
	gtk_adjustment_set_value (GTK_ADJUSTMENT (cnp->slider_data[i]),
				  cnp->values[i]);
	gtk_signal_handler_unblock_by_data (GTK_OBJECT (cnp->slider_data[i]), cnp);
      }

  g_snprintf (buffer, sizeof (buffer), "#%.2x%.2x%.2x",
              cnp->values[GIMP_COLOR_SELECTOR_RED],
              cnp->values[GIMP_COLOR_SELECTOR_GREEN],
              cnp->values[GIMP_COLOR_SELECTOR_BLUE]);

  gtk_entry_set_text (GTK_ENTRY (cnp->hex_entry), buffer);
}


static gboolean
color_notebook_color_events (GtkWidget *widget,
			     GdkEvent  *event,
			     gpointer   data)
{
  ColorNotebook *cnp;

  cnp = (ColorNotebook *) data;

  if (!cnp)
    return FALSE;

  switch (event->type)
    {
    case GDK_EXPOSE:
      if (!cnp->gc)
        cnp->gc = gdk_gc_new (widget->window);

      if (widget == cnp->new_color)
        color_notebook_update (cnp, UPDATE_NEW_COLOR);
      else if (widget == cnp->orig_color)
        color_notebook_update (cnp, UPDATE_ORIG_COLOR);
      break;

    default:
      break;
    }

  return FALSE;
}

static void
color_notebook_toggle_update (GtkWidget *widget,
			      gpointer   data)
{
  ColorNotebook *cnp;
  gint           i;

  if (! GTK_TOGGLE_BUTTON (widget)->active)
    return;

  cnp = (ColorNotebook *) data;

  if (!cnp)
    return;

  for (i = 0; i < 7; i++)
    if (widget == cnp->toggles[i])
      cnp->active_channel = (GimpColorSelectorChannelType) i;

  color_notebook_update (cnp, UPDATE_CHANNEL);
}

static void
color_notebook_scale_update (GtkAdjustment *adjustment,
			     gpointer       data)
{
  ColorNotebook *cnp;
  gint           old_values[7];
  gint           i, j;

  cnp = (ColorNotebook *) data;

  if (!cnp)
    return;

  for (i = 0; i < 7; i++)
    if (cnp->slider_data[i] == GTK_OBJECT (adjustment))
      break;

  for (j = 0; j < 7; j++)
    old_values[j] = cnp->values[j];

  cnp->values[i] = (gint) (GTK_ADJUSTMENT (adjustment)->value);

  if ((i >= GIMP_COLOR_SELECTOR_HUE) && (i <= GIMP_COLOR_SELECTOR_VALUE))
    {
      color_notebook_update_rgb_values (cnp);
    }
  else if ((i >= GIMP_COLOR_SELECTOR_RED) && (i <= GIMP_COLOR_SELECTOR_BLUE))
    {
      color_notebook_update_hsv_values (cnp);
    }

  color_notebook_update_scales (cnp, i);

  color_notebook_update (cnp,
			 UPDATE_NOTEBOOK  |
			 UPDATE_NEW_COLOR |
			 UPDATE_CALLER);
}

static gint
color_notebook_hex_entry_events (GtkWidget *widget,
				 GdkEvent  *event,
				 gpointer   data)
{
  ColorNotebook *cnp;
  gchar          buffer[8];
  gchar         *hex_color;
  guint          hex_rgb;

  cnp = (ColorNotebook *) data;

  if (!cnp)
    return FALSE;
  
  switch (event->type)
    {
    case GDK_KEY_PRESS:
      if (((GdkEventKey *) event)->keyval != GDK_Return)
        break;
      /*  else fall through  */

    case GDK_FOCUS_CHANGE:
      hex_color = g_strdup (gtk_entry_get_text (GTK_ENTRY (cnp->hex_entry)));

      g_snprintf (buffer, sizeof (buffer), "#%.2x%.2x%.2x",
                  cnp->values[GIMP_COLOR_SELECTOR_RED],
                  cnp->values[GIMP_COLOR_SELECTOR_GREEN],
                  cnp->values[GIMP_COLOR_SELECTOR_BLUE]);

      if ((strlen (hex_color) == 7) &&
          (g_strcasecmp (buffer, hex_color) != 0))
        {
          if ((sscanf (hex_color, "#%x", &hex_rgb) == 1) &&
              (hex_rgb < (1 << 24)))
	    {
	      cnp->values[GIMP_COLOR_SELECTOR_RED] = (hex_rgb & 0xff0000) >> 16;
	      cnp->values[GIMP_COLOR_SELECTOR_GREEN] = (hex_rgb & 0x00ff00) >> 8;
	      cnp->values[GIMP_COLOR_SELECTOR_BLUE] = (hex_rgb & 0x0000ff);

	      color_notebook_update_hsv_values (cnp);
	      color_notebook_update_scales (cnp, -1);

	      color_notebook_update (cnp,
				     UPDATE_NOTEBOOK  |
				     UPDATE_NEW_COLOR |
				     UPDATE_CALLER);
	    }
        }

      g_free (hex_color);

      break;

    default:
      /*  do nothing  */
      break;
    }

  return FALSE;
}

static void
color_notebook_drag_new_color (GtkWidget *widget,
			       guchar    *r,
			       guchar    *g,
			       guchar    *b,
			       guchar    *a,
			       gpointer   data)
{
  ColorNotebook *cnp;

  cnp = (ColorNotebook *) data;

  *r = (guchar) cnp->values[GIMP_COLOR_SELECTOR_RED];
  *g = (guchar) cnp->values[GIMP_COLOR_SELECTOR_GREEN];
  *b = (guchar) cnp->values[GIMP_COLOR_SELECTOR_BLUE];
  *a = (guchar) cnp->values[GIMP_COLOR_SELECTOR_ALPHA];
}

static void
color_notebook_drop_new_color (GtkWidget *widget,
			       guchar     r,
			       guchar     g,
			       guchar     b,
			       guchar     a,
			       gpointer   data)
{
  ColorNotebook *cnp;

  cnp = (ColorNotebook *) data;

  cnp->values[GIMP_COLOR_SELECTOR_RED]   = (gint) r;
  cnp->values[GIMP_COLOR_SELECTOR_GREEN] = (gint) g;
  cnp->values[GIMP_COLOR_SELECTOR_BLUE]  = (gint) b;
  cnp->values[GIMP_COLOR_SELECTOR_ALPHA] = (gint) a;

  color_notebook_update_hsv_values (cnp);
  color_notebook_update_scales (cnp, -1);

  color_notebook_update (cnp,
			 UPDATE_NOTEBOOK  |
			 UPDATE_NEW_COLOR |
			 UPDATE_CALLER);
}

static void
color_notebook_drag_old_color (GtkWidget *widget,
			       guchar    *r,
			       guchar    *g,
			       guchar    *b,
			       guchar    *a,
			       gpointer   data)
{
  ColorNotebook *cnp;

  cnp = (ColorNotebook *) data;

  *r = (guchar) cnp->orig_values[0];
  *g = (guchar) cnp->orig_values[1];
  *b = (guchar) cnp->orig_values[2];
  *a = (guchar) cnp->orig_values[3];
}