/* HSV color selector for GTK+

 *

 * Copyright (C) 1999 The Free Software Foundation

 *

 * Authors: Simon Budig <Simon.Budig@unix-ag.org> (original code)

 *          Federico Mena-Quintero <federico@gimp.org> (cleanup for GTK+)

 *          Jonathan Blandford <jrb@redhat.com> (cleanup for GTK+)

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.

 */

#include "config.h"

#include <math.h>

#include <string.h>

#include "gdk/gdkkeysyms.h"

#include "gtkhsv.h"

#include "gtkbindings.h"

#include "gtkmarshalers.h"

#include "gtkintl.h"

#include "gtkalias.h"

/* Default width/height */

#define DEFAULT_SIZE 100

/* Default ring width */

#define DEFAULT_RING_WIDTH 10

/* Dragging modes */

typedef enum {

  DRAG_NONE,

  DRAG_H,

  DRAG_SV

} DragMode;

/* Private part of the GtkHSV structure */

typedef struct {

  /* Color value */

  double h;

  double s;

  double v;

  /* Size and ring width */

  int size;

  int ring_width;

  /* Window for capturing events */

  GdkWindow *window;

  /* Dragging mode */

  DragMode mode;

  guint focus_on_ring : 1;

} HSVPrivate;

/* Signal IDs */

enum {

  CHANGED,

  MOVE,

  LAST_SIGNAL

};

static void     gtk_hsv_destroy        (GtkObject        *object);

static void     gtk_hsv_map            (GtkWidget        *widget);

static void     gtk_hsv_unmap          (GtkWidget        *widget);

static void     gtk_hsv_realize        (GtkWidget        *widget);

static void     gtk_hsv_unrealize      (GtkWidget        *widget);

static void     gtk_hsv_size_request   (GtkWidget        *widget,

					GtkRequisition   *requisition);

static void     gtk_hsv_size_allocate  (GtkWidget        *widget,

					GtkAllocation    *allocation);

static gint     gtk_hsv_button_press   (GtkWidget        *widget,

					GdkEventButton   *event);

static gint     gtk_hsv_button_release (GtkWidget        *widget,

					GdkEventButton   *event);

static gint     gtk_hsv_motion         (GtkWidget        *widget,

					GdkEventMotion   *event);

static gint     gtk_hsv_expose         (GtkWidget        *widget,

					GdkEventExpose   *event);

static gboolean gtk_hsv_grab_broken    (GtkWidget          *widget,

					GdkEventGrabBroken *event);

static gboolean gtk_hsv_focus          (GtkWidget        *widget,

					GtkDirectionType  direction);

static void     gtk_hsv_move           (GtkHSV           *hsv,

					GtkDirectionType  dir);

static guint hsv_signals[LAST_SIGNAL];

G_DEFINE_TYPE (GtkHSV, gtk_hsv, GTK_TYPE_WIDGET)

/* Class initialization function for the HSV color selector */

static void

gtk_hsv_class_init (GtkHSVClass *class)

{

  GObjectClass   *gobject_class;

  GtkObjectClass *object_class;

  GtkWidgetClass *widget_class;

  GtkHSVClass    *hsv_class;

  GtkBindingSet  *binding_set;

  gobject_class = (GObjectClass *) class;

  object_class = (GtkObjectClass *) class;

  widget_class = (GtkWidgetClass *) class;

  hsv_class = GTK_HSV_CLASS (class);

  object_class->destroy = gtk_hsv_destroy;

  widget_class->map = gtk_hsv_map;

  widget_class->unmap = gtk_hsv_unmap;                                      

  widget_class->realize = gtk_hsv_realize;

  widget_class->unrealize = gtk_hsv_unrealize;

  widget_class->size_request = gtk_hsv_size_request;

  widget_class->size_allocate = gtk_hsv_size_allocate;

  widget_class->button_press_event = gtk_hsv_button_press;

  widget_class->button_release_event = gtk_hsv_button_release;

  widget_class->motion_notify_event = gtk_hsv_motion;

  widget_class->expose_event = gtk_hsv_expose;

  widget_class->focus = gtk_hsv_focus;

  widget_class->grab_broken_event = gtk_hsv_grab_broken;

  hsv_class->move = gtk_hsv_move;

  hsv_signals[CHANGED] =

    g_signal_new (I_("changed"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkHSVClass, changed),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  hsv_signals[MOVE] =

    g_signal_new (I_("move"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

		  G_STRUCT_OFFSET (GtkHSVClass, move),

		  NULL, NULL,

		  _gtk_marshal_VOID__ENUM,

		  G_TYPE_NONE, 1,

		  GTK_TYPE_DIRECTION_TYPE);

  binding_set = gtk_binding_set_by_class (class);

  gtk_binding_entry_add_signal (binding_set, GDK_Up, 0,

                                "move", 1,

                                G_TYPE_ENUM, GTK_DIR_UP);

  gtk_binding_entry_add_signal (binding_set, GDK_KP_Up, 0,

                                "move", 1,

                                G_TYPE_ENUM, GTK_DIR_UP);

  gtk_binding_entry_add_signal (binding_set, GDK_Down, 0,

                                "move", 1,

                                G_TYPE_ENUM, GTK_DIR_DOWN);

  gtk_binding_entry_add_signal (binding_set, GDK_KP_Down, 0,

                                "move", 1,

                                G_TYPE_ENUM, GTK_DIR_DOWN);

  gtk_binding_entry_add_signal (binding_set, GDK_Right, 0,

                                "move", 1,

                                G_TYPE_ENUM, GTK_DIR_RIGHT);

  gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, 0,

                                "move", 1,

                                G_TYPE_ENUM, GTK_DIR_RIGHT);

  gtk_binding_entry_add_signal (binding_set, GDK_Left, 0,

                                "move", 1,

                                G_TYPE_ENUM, GTK_DIR_LEFT);

  gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, 0,

                                "move", 1,

                                G_TYPE_ENUM, GTK_DIR_LEFT);

  g_type_class_add_private (gobject_class, sizeof (HSVPrivate));   

}

/* Object initialization function for the HSV color selector */

static void

gtk_hsv_init (GtkHSV *hsv)

{

  HSVPrivate *priv;

  priv = G_TYPE_INSTANCE_GET_PRIVATE (hsv, GTK_TYPE_HSV, HSVPrivate);

  hsv->priv = priv;

  gtk_widget_set_has_window (GTK_WIDGET (hsv), FALSE);

  gtk_widget_set_can_focus (GTK_WIDGET (hsv), TRUE);

  priv->h = 0.0;

  priv->s = 0.0;

  priv->v = 0.0;

  priv->size = DEFAULT_SIZE;

  priv->ring_width = DEFAULT_RING_WIDTH;

}

/* Destroy handler for the HSV color selector */

static void

gtk_hsv_destroy (GtkObject *object)

{

  GTK_OBJECT_CLASS (gtk_hsv_parent_class)->destroy (object);

}

/* Default signal handlers */

/* Map handler for the HSV color selector */

static void

gtk_hsv_map (GtkWidget *widget)

{

  GtkHSV *hsv;

  HSVPrivate *priv;

  hsv = GTK_HSV (widget);

  priv = hsv->priv;

  GTK_WIDGET_CLASS (gtk_hsv_parent_class)->map (widget);

  gdk_window_show (priv->window);

}

/* Unmap handler for the HSV color selector */

static void

gtk_hsv_unmap (GtkWidget *widget)

{

  GtkHSV *hsv;

  HSVPrivate *priv;

  hsv = GTK_HSV (widget);

  priv = hsv->priv;

  gdk_window_hide (priv->window);

  GTK_WIDGET_CLASS (gtk_hsv_parent_class)->unmap (widget);

}                                                                           

/* Realize handler for the HSV color selector */

static void

gtk_hsv_realize (GtkWidget *widget)

{

  GtkHSV *hsv;

  HSVPrivate *priv;

  GdkWindowAttr attr;

  int attr_mask;

  GdkWindow *parent_window;

  hsv = GTK_HSV (widget);

  priv = hsv->priv;

  gtk_widget_set_realized (widget, TRUE);

  /* Create window */

  attr.window_type = GDK_WINDOW_CHILD;

  attr.x = widget->allocation.x;

  attr.y = widget->allocation.y;

  attr.width = widget->allocation.width;

  attr.height = widget->allocation.height;

  attr.wclass = GDK_INPUT_ONLY;

  attr.event_mask = gtk_widget_get_events (widget);

  attr.event_mask |= (GDK_KEY_PRESS_MASK

                      | GDK_BUTTON_PRESS_MASK

		      | GDK_BUTTON_RELEASE_MASK

		      | GDK_POINTER_MOTION_MASK

                      | GDK_ENTER_NOTIFY_MASK

                      | GDK_LEAVE_NOTIFY_MASK);

  attr_mask = GDK_WA_X | GDK_WA_Y;

  parent_window = gtk_widget_get_parent_window (widget);

  widget->window = parent_window;

  g_object_ref (widget->window);

  priv->window = gdk_window_new (parent_window, &attr, attr_mask);

  gdk_window_set_user_data (priv->window, hsv);

  widget->style = gtk_style_attach (widget->style, widget->window);

}

/* Unrealize handler for the HSV color selector */

static void

gtk_hsv_unrealize (GtkWidget *widget)

{

  GtkHSV *hsv;

  HSVPrivate *priv;

  hsv = GTK_HSV (widget);

  priv = hsv->priv;

  gdk_window_set_user_data (priv->window, NULL);

  gdk_window_destroy (priv->window);

  priv->window = NULL;

  GTK_WIDGET_CLASS (gtk_hsv_parent_class)->unrealize (widget);

}

/* Size_request handler for the HSV color selector */

static void

gtk_hsv_size_request (GtkWidget      *widget,

		      GtkRequisition *requisition)

{

  GtkHSV *hsv = GTK_HSV (widget);

  HSVPrivate *priv = hsv->priv;

  gint focus_width;

  gint focus_pad;

  gtk_widget_style_get (widget,

			"focus-line-width", &focus_width,

			"focus-padding", &focus_pad,

			NULL);

  requisition->width = priv->size + 2 * (focus_width + focus_pad);

  requisition->height = priv->size + 2 * (focus_width + focus_pad);

}

/* Size_allocate handler for the HSV color selector */

static void

gtk_hsv_size_allocate (GtkWidget     *widget,

		       GtkAllocation *allocation)

{

  GtkHSV *hsv;

  HSVPrivate *priv;

  hsv = GTK_HSV (widget);

  priv = hsv->priv;

  widget->allocation = *allocation;

  if (gtk_widget_get_realized (widget))

    gdk_window_move_resize (priv->window,

			    allocation->x,

			    allocation->y,

			    allocation->width,

			    allocation->height);

}

/* Utility functions */

#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)

/* Converts from HSV to RGB */

static void

hsv_to_rgb (gdouble *h,

	    gdouble *s,

	    gdouble *v)

{

  gdouble hue, saturation, value;

  gdouble f, p, q, t;

  if (*s == 0.0)

    {

      *h = *v;

      *s = *v;

      *v = *v; /* heh */

    }

  else

    {

      hue = *h * 6.0;

      saturation = *s;

      value = *v;

      if (hue == 6.0)

	hue = 0.0;

      f = hue - (int) hue;

      p = value * (1.0 - saturation);

      q = value * (1.0 - saturation * f);

      t = value * (1.0 - saturation * (1.0 - f));

      switch ((int) hue)

	{

	case 0:

	  *h = value;

	  *s = t;

	  *v = p;

	  break;

	case 1:

	  *h = q;

	  *s = value;

	  *v = p;

	  break;

	case 2:

	  *h = p;

	  *s = value;

	  *v = t;

	  break;

	case 3:

	  *h = p;

	  *s = q;

	  *v = value;

	  break;

	case 4:

	  *h = t;

	  *s = p;

	  *v = value;

	  break;

	case 5:

	  *h = value;

	  *s = p;

	  *v = q;

	  break;

	default:

	  g_assert_not_reached ();

	}

    }

}

/* Converts from RGB to HSV */

static void

rgb_to_hsv (gdouble *r,

	    gdouble *g,

	    gdouble *b)

{

  gdouble red, green, blue;

  gdouble h, s, v;

  gdouble min, max;

  gdouble delta;

  red = *r;

  green = *g;

  blue = *b;

  h = 0.0;

  if (red > green)

    {

      if (red > blue)

	max = red;

      else

	max = blue;

      if (green < blue)

	min = green;

      else

	min = blue;

    }

  else

    {

      if (green > blue)

	max = green;

      else

	max = blue;

      if (red < blue)

	min = red;

      else

	min = blue;

    }

  v = max;

  if (max != 0.0)

    s = (max - min) / max;

  else

    s = 0.0;

  if (s == 0.0)

    h = 0.0;

  else

    {

      delta = max - min;

      if (red == max)

	h = (green - blue) / delta;

      else if (green == max)

	h = 2 + (blue - red) / delta;

      else if (blue == max)

	h = 4 + (red - green) / delta;

      h /= 6.0;

      if (h < 0.0)

	h += 1.0;

      else if (h > 1.0)

	h -= 1.0;

    }

  *r = h;

  *g = s;

  *b = v;

}

/* Computes the vertices of the saturation/value triangle */

static void

compute_triangle (GtkHSV *hsv,

		  gint   *hx,

		  gint   *hy,

		  gint   *sx,

		  gint   *sy,

		  gint   *vx,

		  gint   *vy)

{

  HSVPrivate *priv;

  gdouble center_x;

  gdouble center_y;

  gdouble inner, outer;

  gdouble angle;

  priv = hsv->priv;

  center_x = GTK_WIDGET (hsv)->allocation.width / 2.0;

  center_y = GTK_WIDGET (hsv)->allocation.height / 2.0;

  outer = priv->size / 2.0;

  inner = outer - priv->ring_width;

  angle = priv->h * 2.0 * G_PI;

  *hx = floor (center_x + cos (angle) * inner + 0.5);

  *hy = floor (center_y - sin (angle) * inner + 0.5);

  *sx = floor (center_x + cos (angle + 2.0 * G_PI / 3.0) * inner + 0.5);

  *sy = floor (center_y - sin (angle + 2.0 * G_PI / 3.0) * inner + 0.5);

  *vx = floor (center_x + cos (angle + 4.0 * G_PI / 3.0) * inner + 0.5);

  *vy = floor (center_y - sin (angle + 4.0 * G_PI / 3.0) * inner + 0.5);

}

/* Computes whether a point is inside the hue ring */

static gboolean

is_in_ring (GtkHSV *hsv,

	    gdouble x,

	    gdouble y)

{

  HSVPrivate *priv;

  gdouble dx, dy, dist;

  gdouble center_x;

  gdouble center_y;

  gdouble inner, outer;

  priv = hsv->priv;

  center_x = GTK_WIDGET (hsv)->allocation.width / 2.0;

  center_y = GTK_WIDGET (hsv)->allocation.height / 2.0;

  outer = priv->size / 2.0;

  inner = outer - priv->ring_width;

  dx = x - center_x;

  dy = center_y - y;

  dist = dx * dx + dy * dy;

  return (dist >= inner * inner && dist <= outer * outer);

}

/* Computes a saturation/value pair based on the mouse coordinates */

static void

compute_sv (GtkHSV  *hsv,

	    gdouble  x,

	    gdouble  y,

	    gdouble *s,

	    gdouble *v)

{

  int ihx, ihy, isx, isy, ivx, ivy;

  double hx, hy, sx, sy, vx, vy;

  double center_x;

  double center_y;

  compute_triangle (hsv, &ihx, &ihy, &isx, &isy, &ivx, &ivy);

  center_x = GTK_WIDGET (hsv)->allocation.width / 2.0;

  center_y = GTK_WIDGET (hsv)->allocation.height / 2.0;

  hx = ihx - center_x;

  hy = center_y - ihy;

  sx = isx - center_x;

  sy = center_y - isy;

  vx = ivx - center_x;

  vy = center_y - ivy;

  x -= center_x;

  y = center_y - y;

  if (vx * (x - sx) + vy * (y - sy) < 0.0)

    {

      *s = 1.0;

      *v = (((x - sx) * (hx - sx) + (y - sy) * (hy-sy))

	    / ((hx - sx) * (hx - sx) + (hy - sy) * (hy - sy)));

      if (*v < 0.0)

	*v = 0.0;

      else if (*v > 1.0)

	*v = 1.0;

    }

  else if (hx * (x - sx) + hy * (y - sy) < 0.0)

    {

      *s = 0.0;

      *v = (((x - sx) * (vx - sx) + (y - sy) * (vy - sy))

	    / ((vx - sx) * (vx - sx) + (vy - sy) * (vy - sy)));

      if (*v < 0.0)

	*v = 0.0;

      else if (*v > 1.0)

	*v = 1.0;

    }

  else if (sx * (x - hx) + sy * (y - hy) < 0.0)

    {

      *v = 1.0;

      *s = (((x - vx) * (hx - vx) + (y - vy) * (hy - vy)) /

	    ((hx - vx) * (hx - vx) + (hy - vy) * (hy - vy)));

      if (*s < 0.0)

	*s = 0.0;

      else if (*s > 1.0)

	*s = 1.0;

    }

  else

    {

      *v = (((x - sx) * (hy - vy) - (y - sy) * (hx - vx))

	    / ((vx - sx) * (hy - vy) - (vy - sy) * (hx - vx)));

      if (*v<= 0.0)

	{

	  *v = 0.0;

	  *s = 0.0;

	}

      else

	{

	  if (*v > 1.0)

	    *v = 1.0;

	  if (fabs (hy - vy) < fabs (hx - vx))

	    *s = (x - sx - *v * (vx - sx)) / (*v * (hx - vx));

	  else

	    *s = (y - sy - *v * (vy - sy)) / (*v * (hy - vy));

	  if (*s < 0.0)

	    *s = 0.0;

	  else if (*s > 1.0)

	    *s = 1.0;

	}

    }

}

/* Computes whether a point is inside the saturation/value triangle */

static gboolean

is_in_triangle (GtkHSV *hsv,

		gdouble x,

		gdouble y)

{

  int hx, hy, sx, sy, vx, vy;

  double det, s, v;

  compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy;;

  det = (vx - sx) * (hy - sy) - (vy - sy) * (hx - sx);

  s = ((x - sx) * (hy - sy) - (y - sy) * (hx - sx)) / det;

  v = ((vx - sx) * (y - sy) - (vy - sy) * (x - sx)) / det;

  return (s >= 0.0 && v >= 0.0 && s + v <= 1.0);

}

/* Computes a value based on the mouse coordinates */

static double

compute_v (GtkHSV *hsv,

	   gdouble x,

	   gdouble y)

{

  double center_x;

  double center_y;

  double dx, dy;

  double angle;

  center_x = GTK_WIDGET (hsv)->allocation.width / 2.0;

  center_y = GTK_WIDGET (hsv)->allocation.height / 2.0;

  dx = x - center_x;

  dy = center_y - y;

  angle = atan2 (dy, dx);

  if (angle < 0.0)

    angle += 2.0 * G_PI;

  return angle / (2.0 * G_PI);

}

/* Event handlers */

static void

set_cross_grab (GtkHSV *hsv,

		guint32 time)

{

  HSVPrivate *priv;

  GdkCursor *cursor;

  priv = hsv->priv;

  cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (hsv)),

				       GDK_CROSSHAIR);

  gdk_pointer_grab (priv->window, FALSE,

		    (GDK_POINTER_MOTION_MASK

		     | GDK_POINTER_MOTION_HINT_MASK

		     | GDK_BUTTON_RELEASE_MASK),

		    NULL,

		    cursor,

		    time);

  gdk_cursor_unref (cursor);

}

static gboolean 

gtk_hsv_grab_broken (GtkWidget          *widget,

		     GdkEventGrabBroken *event)

{

  GtkHSV *hsv = GTK_HSV (widget);

  HSVPrivate *priv;

  priv = hsv->priv;

  priv->mode = DRAG_NONE;

  return TRUE;

}

/* Button_press_event handler for the HSV color selector */

static gint

gtk_hsv_button_press (GtkWidget      *widget,

		      GdkEventButton *event)

{

  GtkHSV *hsv;

  HSVPrivate *priv;

  double x, y;

  hsv = GTK_HSV (widget);

  priv = hsv->priv;

  if (priv->mode != DRAG_NONE || event->button != 1)

    return FALSE;

  x = event->x;

  y = event->y;

  if (is_in_ring (hsv, x, y))

    {

      priv->mode = DRAG_H;

      set_cross_grab (hsv, event->time);

      gtk_hsv_set_color (hsv,

			 compute_v (hsv, x, y),

			 priv->s,

			 priv->v);

      gtk_widget_grab_focus (widget);

      priv->focus_on_ring = TRUE;

      return TRUE;

    }

  if (is_in_triangle (hsv, x, y))

    {

      gdouble s, v;

      priv->mode = DRAG_SV;

      set_cross_grab (hsv, event->time);

      compute_sv (hsv, x, y, &s, &v);

      gtk_hsv_set_color (hsv, priv->h, s, v);

      gtk_widget_grab_focus (widget);

      priv->focus_on_ring = FALSE;

      return TRUE;

    }

  return FALSE;

}

/* Button_release_event handler for the HSV color selector */

static gint

gtk_hsv_button_release (GtkWidget      *widget,

			GdkEventButton *event)

{

  GtkHSV *hsv;

  HSVPrivate *priv;

  DragMode mode;

  gdouble x, y;

  hsv = GTK_HSV (widget);

  priv = hsv->priv;

  if (priv->mode == DRAG_NONE || event->button != 1)

    return FALSE;

  /* Set the drag mode to DRAG_NONE so that signal handlers for "catched"

   * can see that this is the final color state.

   */

  mode = priv->mode;

  priv->mode = DRAG_NONE;

  x = event->x;

  y = event->y;

  if (mode == DRAG_H)

    gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);

  else if (mode == DRAG_SV) {

    double s, v;

    compute_sv (hsv, x, y, &s, &v);

    gtk_hsv_set_color (hsv, priv->h, s, v);

  } else

    g_assert_not_reached ();

  gdk_display_pointer_ungrab (gdk_window_get_display (event->window),

			      event->time);

  return TRUE;

}

/* Motion_notify_event handler for the HSV color selector */

static gint

gtk_hsv_motion (GtkWidget      *widget,

		GdkEventMotion *event)

{

  GtkHSV *hsv;

  HSVPrivate *priv;

  double x, y;

  GdkModifierType mods;

  hsv = GTK_HSV (widget);

  priv = hsv->priv;

  if (priv->mode == DRAG_NONE)

    return FALSE;

  gdk_event_request_motions (event);

  x = event->x;

  y = event->y;

  mods = event->state;

  if (priv->mode == DRAG_H)

    {

      gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);

      return TRUE;

    }

  else if (priv->mode == DRAG_SV)

    {

      double s, v;

      compute_sv (hsv, x, y, &s, &v);

      gtk_hsv_set_color (hsv, priv->h, s, v);

      return TRUE;

    }

  g_assert_not_reached ();

  return FALSE;

}

/* Redrawing */

/* Paints the hue ring */

static void