Pileus Git - ~andy/gtk/blob - gtk/gtkhsv.c

   1 /* HSV color selector for GTK+
   2  *
   3  * Copyright (C) 1999 The Free Software Foundation
   4  *
   5  * Authors: Simon Budig <Simon.Budig@unix-ag.org> (original code)
   6  *          Federico Mena-Quintero <federico@gimp.org> (cleanup for GTK+)
   7  *          Jonathan Blandford <jrb@redhat.com> (cleanup for GTK+)
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 #include <config.h>
  26 #include <math.h>
  27 #include <string.h>
  28 #include "gtkalias.h"
  29 #include "gtkhsv.h"
  30 #include "gdk/gdkkeysyms.h"
  31 #include "gtkbindings.h"
  32 #include "gtkcontainer.h"
  33 #include "gtkmarshalers.h"
  34
  35 /*
  36  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  37  * file for a list of people on the GTK+ Team.  See the ChangeLog
  38  * files for a list of changes.  These files are distributed with
  39  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  40  */
  41
  42 /* Default width/height */
  43 #define DEFAULT_SIZE 100
  44
  45 /* Default ring width */
  46 #define DEFAULT_RING_WIDTH 10
  47
  48
  49 /* Dragging modes */
  50 typedef enum {
  51   DRAG_NONE,
  52   DRAG_H,
  53   DRAG_SV
  54 } DragMode;
  55
  56 /* Private part of the GtkHSV structure */
  57 typedef struct {
  58   /* Color value */
  59   double h;
  60   double s;
  61   double v;
  62
  63   /* Size and ring width */
  64   int size;
  65   int ring_width;
  66
  67   /* Window for capturing events */
  68   GdkWindow *window;
  69
  70   /* GC for drawing */
  71   GdkGC *gc;
  72
  73   /* Dragging mode */
  74   DragMode mode;
  75
  76   guint focus_on_ring : 1;
  77
  78 } HSVPrivate;
  79
  80 \f
  81
  82 /* Signal IDs */
  83
  84 enum {
  85   CHANGED,
  86   MOVE,
  87   LAST_SIGNAL
  88 };
  89
  90 static void     gtk_hsv_class_init     (GtkHSVClass      *class);
  91 static void     gtk_hsv_init           (GtkHSV           *hsv);
  92 static void     gtk_hsv_destroy        (GtkObject        *object);
  93 static void     gtk_hsv_map            (GtkWidget        *widget);
  94 static void     gtk_hsv_unmap          (GtkWidget        *widget);
  95 static void     gtk_hsv_realize        (GtkWidget        *widget);
  96 static void     gtk_hsv_unrealize      (GtkWidget        *widget);
  97 static void     gtk_hsv_size_request   (GtkWidget        *widget,
  98                                         GtkRequisition   *requisition);
  99 static void     gtk_hsv_size_allocate  (GtkWidget        *widget,
 100                                         GtkAllocation    *allocation);
 101 static gint     gtk_hsv_button_press   (GtkWidget        *widget,
 102                                         GdkEventButton   *event);
 103 static gint     gtk_hsv_button_release (GtkWidget        *widget,
 104                                         GdkEventButton   *event);
 105 static gint     gtk_hsv_motion         (GtkWidget        *widget,
 106                                         GdkEventMotion   *event);
 107 static gint     gtk_hsv_expose         (GtkWidget        *widget,
 108                                         GdkEventExpose   *event);
 109 static gboolean gtk_hsv_focus          (GtkWidget        *widget,
 110                                         GtkDirectionType  direction);
 111 static void     gtk_hsv_move           (GtkHSV           *hsv,
 112                                         GtkDirectionType  dir);
 113
 114 static guint hsv_signals[LAST_SIGNAL];
 115 static GtkWidgetClass *parent_class;
 116
 117
 118 /**
 119  * gtk_hsv_get_type:
 120  * @void:
 121  *
 122  * Registers the &GtkHSV class if necessary, and returns the type ID associated
 123  * to it.
 124  *
 125  * Return value: The type ID of the &GtkHSV class.
 126  **/
 127 GType
 128 gtk_hsv_get_type (void)
 129 {
 130   static GType hsv_type = 0;
 131
 132   if (!hsv_type) {
 133     static const GTypeInfo hsv_info = {
 134       sizeof (GtkHSVClass),
 135       NULL,             /* base_init */
 136       NULL,             /* base_finalize */
 137       (GClassInitFunc) gtk_hsv_class_init,
 138       NULL,             /* class_finalize */
 139       NULL,             /* class_data */
 140       sizeof (GtkHSV),
 141       0,                /* n_preallocs */
 142       (GInstanceInitFunc) gtk_hsv_init,
 143     };
 144
 145     hsv_type = g_type_register_static (GTK_TYPE_WIDGET, "GtkHSV",
 146                                        &hsv_info, 0);
 147   }
 148
 149   return hsv_type;
 150 }
 151
 152 /* Class initialization function for the HSV color selector */
 153 static void
 154 gtk_hsv_class_init (GtkHSVClass *class)
 155 {
 156   GtkObjectClass *object_class;
 157   GtkWidgetClass *widget_class;
 158   GtkHSVClass    *hsv_class;
 159   GtkBindingSet  *binding_set;
 160
 161   object_class = (GtkObjectClass *) class;
 162   widget_class = (GtkWidgetClass *) class;
 163   hsv_class = GTK_HSV_CLASS (class);
 164
 165   parent_class = g_type_class_peek_parent (class);
 166
 167   object_class->destroy = gtk_hsv_destroy;
 168
 169   widget_class->map = gtk_hsv_map;
 170   widget_class->unmap = gtk_hsv_unmap;
 171   widget_class->realize = gtk_hsv_realize;
 172   widget_class->unrealize = gtk_hsv_unrealize;
 173   widget_class->size_request = gtk_hsv_size_request;
 174   widget_class->size_allocate = gtk_hsv_size_allocate;
 175   widget_class->button_press_event = gtk_hsv_button_press;
 176   widget_class->button_release_event = gtk_hsv_button_release;
 177   widget_class->motion_notify_event = gtk_hsv_motion;
 178   widget_class->expose_event = gtk_hsv_expose;
 179   widget_class->focus = gtk_hsv_focus;
 180
 181   hsv_class->move = gtk_hsv_move;
 182
 183   hsv_signals[CHANGED] =
 184     g_signal_new ("changed",
 185                   G_OBJECT_CLASS_TYPE (object_class),
 186                   G_SIGNAL_RUN_FIRST,
 187                   G_STRUCT_OFFSET (GtkHSVClass, changed),
 188                   NULL, NULL,
 189                   _gtk_marshal_VOID__VOID,
 190                   G_TYPE_NONE, 0);
 191
 192   hsv_signals[MOVE] =
 193     g_signal_new ("move",
 194                   G_OBJECT_CLASS_TYPE (object_class),
 195                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 196                   G_STRUCT_OFFSET (GtkHSVClass, move),
 197                   NULL, NULL,
 198                   _gtk_marshal_VOID__ENUM,
 199                   G_TYPE_NONE, 1,
 200                   GTK_TYPE_DIRECTION_TYPE);
 201
 202   binding_set = gtk_binding_set_by_class (class);
 203
 204   gtk_binding_entry_add_signal (binding_set, GDK_Up, 0,
 205                                 "move", 1,
 206                                 G_TYPE_ENUM, GTK_DIR_UP);
 207   gtk_binding_entry_add_signal (binding_set, GDK_KP_Up, 0,
 208                                 "move", 1,
 209                                 G_TYPE_ENUM, GTK_DIR_UP);
 210
 211   gtk_binding_entry_add_signal (binding_set, GDK_Down, 0,
 212                                 "move", 1,
 213                                 G_TYPE_ENUM, GTK_DIR_DOWN);
 214   gtk_binding_entry_add_signal (binding_set, GDK_KP_Down, 0,
 215                                 "move", 1,
 216                                 G_TYPE_ENUM, GTK_DIR_DOWN);
 217
 218
 219   gtk_binding_entry_add_signal (binding_set, GDK_Right, 0,
 220                                 "move", 1,
 221                                 G_TYPE_ENUM, GTK_DIR_RIGHT);
 222   gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, 0,
 223                                 "move", 1,
 224                                 G_TYPE_ENUM, GTK_DIR_RIGHT);
 225
 226   gtk_binding_entry_add_signal (binding_set, GDK_Left, 0,
 227                                 "move", 1,
 228                                 G_TYPE_ENUM, GTK_DIR_LEFT);
 229   gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, 0,
 230                                 "move", 1,
 231                                 G_TYPE_ENUM, GTK_DIR_LEFT);
 232 }
 233
 234 /* Object initialization function for the HSV color selector */
 235 static void
 236 gtk_hsv_init (GtkHSV *hsv)
 237 {
 238   HSVPrivate *priv;
 239
 240   priv = g_new0 (HSVPrivate, 1);
 241   hsv->priv = priv;
 242
 243   GTK_WIDGET_SET_FLAGS (hsv, GTK_NO_WINDOW);
 244   GTK_WIDGET_SET_FLAGS (hsv, GTK_CAN_FOCUS);
 245
 246   priv->h = 0.0;
 247   priv->s = 0.0;
 248   priv->v = 0.0;
 249
 250   priv->size = DEFAULT_SIZE;
 251   priv->ring_width = DEFAULT_RING_WIDTH;
 252 }
 253
 254 /* Destroy handler for the HSV color selector */
 255 static void
 256 gtk_hsv_destroy (GtkObject *object)
 257 {
 258   GtkHSV *hsv;
 259
 260   g_return_if_fail (GTK_IS_HSV (object));
 261
 262   hsv = GTK_HSV (object);
 263
 264   if (hsv->priv)
 265     {
 266       g_free (hsv->priv);
 267       hsv->priv = NULL;
 268     }
 269
 270   GTK_OBJECT_CLASS (parent_class)->destroy (object);
 271 }
 272
 273 /* Default signal handlers */
 274
 275
 276 /* Map handler for the HSV color selector */
 277
 278 static void
 279 gtk_hsv_map (GtkWidget *widget)
 280 {
 281   GtkHSV *hsv;
 282   HSVPrivate *priv;
 283
 284   hsv = GTK_HSV (widget);
 285   priv = hsv->priv;
 286
 287   GTK_WIDGET_CLASS (parent_class)->map (widget);
 288
 289   gdk_window_show (priv->window);
 290 }
 291
 292 /* Unmap handler for the HSV color selector */
 293
 294 static void
 295 gtk_hsv_unmap (GtkWidget *widget)
 296 {
 297   GtkHSV *hsv;
 298   HSVPrivate *priv;
 299
 300   hsv = GTK_HSV (widget);
 301   priv = hsv->priv;
 302
 303   gdk_window_hide (priv->window);
 304
 305   GTK_WIDGET_CLASS (parent_class)->unmap (widget);
 306 }
 307
 308 /* Realize handler for the HSV color selector */
 309 static void
 310 gtk_hsv_realize (GtkWidget *widget)
 311 {
 312   GtkHSV *hsv;
 313   HSVPrivate *priv;
 314   GdkWindowAttr attr;
 315   int attr_mask;
 316   GdkWindow *parent_window;
 317
 318   hsv = GTK_HSV (widget);
 319   priv = hsv->priv;
 320
 321   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 322
 323   /* Create window */
 324
 325   attr.window_type = GDK_WINDOW_CHILD;
 326   attr.x = widget->allocation.x;
 327   attr.y = widget->allocation.y;
 328   attr.width = widget->allocation.width;
 329   attr.height = widget->allocation.height;
 330   attr.wclass = GDK_INPUT_ONLY;
 331   attr.event_mask = gtk_widget_get_events (widget);
 332   attr.event_mask |= (GDK_KEY_PRESS_MASK
 333                       | GDK_BUTTON_PRESS_MASK
 334                       | GDK_BUTTON_RELEASE_MASK
 335                       | GDK_POINTER_MOTION_MASK
 336                       | GDK_ENTER_NOTIFY_MASK
 337                       | GDK_LEAVE_NOTIFY_MASK);
 338
 339   attr_mask = GDK_WA_X | GDK_WA_Y;
 340
 341   parent_window = gtk_widget_get_parent_window (widget);
 342
 343   widget->window = parent_window;
 344   g_object_ref (widget->window);
 345
 346   priv->window = gdk_window_new (parent_window, &attr, attr_mask);
 347   gdk_window_set_user_data (priv->window, hsv);
 348
 349   widget->style = gtk_style_attach (widget->style, widget->window);
 350
 351   /* Create GC */
 352
 353   priv->gc = gdk_gc_new (parent_window);
 354 }
 355
 356 /* Unrealize handler for the HSV color selector */
 357 static void
 358 gtk_hsv_unrealize (GtkWidget *widget)
 359 {
 360   GtkHSV *hsv;
 361   HSVPrivate *priv;
 362
 363   hsv = GTK_HSV (widget);
 364   priv = hsv->priv;
 365
 366   gdk_window_set_user_data (priv->window, NULL);
 367   gdk_window_destroy (priv->window);
 368   priv->window = NULL;
 369
 370   g_object_unref (priv->gc);
 371   priv->gc = NULL;
 372
 373   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 374     GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
 375 }
 376
 377 /* Size_request handler for the HSV color selector */
 378 static void
 379 gtk_hsv_size_request (GtkWidget      *widget,
 380                       GtkRequisition *requisition)
 381 {
 382   GtkHSV *hsv = GTK_HSV (widget);
 383   HSVPrivate *priv = hsv->priv;
 384   gint focus_width;
 385   gint focus_pad;
 386
 387   gtk_widget_style_get (widget,
 388                         "focus-line-width", &focus_width,
 389                         "focus-padding", &focus_pad,
 390                         NULL);
 391
 392   requisition->width = priv->size + 2 * (focus_width + focus_pad);
 393   requisition->height = priv->size + 2 * (focus_width + focus_pad);
 394 }
 395
 396 /* Size_allocate handler for the HSV color selector */
 397 static void
 398 gtk_hsv_size_allocate (GtkWidget     *widget,
 399                        GtkAllocation *allocation)
 400 {
 401   GtkHSV *hsv;
 402   HSVPrivate *priv;
 403
 404   hsv = GTK_HSV (widget);
 405   priv = hsv->priv;
 406
 407   widget->allocation = *allocation;
 408
 409   if (GTK_WIDGET_REALIZED (widget))
 410     gdk_window_move_resize (priv->window,
 411                             allocation->x,
 412                             allocation->y,
 413                             allocation->width,
 414                             allocation->height);
 415 }
 416
 417
 418 /* Utility functions */
 419
 420 #define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
 421
 422 /* Converts from HSV to RGB */
 423 static void
 424 hsv_to_rgb (gdouble *h,
 425             gdouble *s,
 426             gdouble *v)
 427 {
 428   gdouble hue, saturation, value;
 429   gdouble f, p, q, t;
 430
 431   if (*s == 0.0)
 432     {
 433       *h = *v;
 434       *s = *v;
 435       *v = *v; /* heh */
 436     }
 437   else
 438     {
 439       hue = *h * 6.0;
 440       saturation = *s;
 441       value = *v;
 442
 443       if (hue == 6.0)
 444         hue = 0.0;
 445
 446       f = hue - (int) hue;
 447       p = value * (1.0 - saturation);
 448       q = value * (1.0 - saturation * f);
 449       t = value * (1.0 - saturation * (1.0 - f));
 450
 451       switch ((int) hue)
 452         {
 453         case 0:
 454           *h = value;
 455           *s = t;
 456           *v = p;
 457           break;
 458
 459         case 1:
 460           *h = q;
 461           *s = value;
 462           *v = p;
 463           break;
 464
 465         case 2:
 466           *h = p;
 467           *s = value;
 468           *v = t;
 469           break;
 470
 471         case 3:
 472           *h = p;
 473           *s = q;
 474           *v = value;
 475           break;
 476
 477         case 4:
 478           *h = t;
 479           *s = p;
 480           *v = value;
 481           break;
 482
 483         case 5:
 484           *h = value;
 485           *s = p;
 486           *v = q;
 487           break;
 488
 489         default:
 490           g_assert_not_reached ();
 491         }
 492     }
 493 }
 494
 495 /* Converts from RGB to HSV */
 496 static void
 497 rgb_to_hsv (gdouble *r,
 498             gdouble *g,
 499             gdouble *b)
 500 {
 501   gdouble red, green, blue;
 502   gdouble h, s, v;
 503   gdouble min, max;
 504   gdouble delta;
 505
 506   red = *r;
 507   green = *g;
 508   blue = *b;
 509
 510   h = 0.0;
 511
 512   if (red > green)
 513     {
 514       if (red > blue)
 515         max = red;
 516       else
 517         max = blue;
 518
 519       if (green < blue)
 520         min = green;
 521       else
 522         min = blue;
 523     }
 524   else
 525     {
 526       if (green > blue)
 527         max = green;
 528       else
 529         max = blue;
 530
 531       if (red < blue)
 532         min = red;
 533       else
 534         min = blue;
 535     }
 536
 537   v = max;
 538
 539   if (max != 0.0)
 540     s = (max - min) / max;
 541   else
 542     s = 0.0;
 543
 544   if (s == 0.0)
 545     h = 0.0;
 546   else
 547     {
 548       delta = max - min;
 549
 550       if (red == max)
 551         h = (green - blue) / delta;
 552       else if (green == max)
 553         h = 2 + (blue - red) / delta;
 554       else if (blue == max)
 555         h = 4 + (red - green) / delta;
 556
 557       h /= 6.0;
 558
 559       if (h < 0.0)
 560         h += 1.0;
 561       else if (h > 1.0)
 562         h -= 1.0;
 563     }
 564
 565   *r = h;
 566   *g = s;
 567   *b = v;
 568 }
 569
 570 /* Computes the vertices of the saturation/value triangle */
 571 static void
 572 compute_triangle (GtkHSV *hsv,
 573                   gint   *hx,
 574                   gint   *hy,
 575                   gint   *sx,
 576                   gint   *sy,
 577                   gint   *vx,
 578                   gint   *vy)
 579 {
 580   HSVPrivate *priv;
 581   gdouble center;
 582   gdouble inner, outer;
 583   gdouble angle;
 584
 585   priv = hsv->priv;
 586
 587   center = GTK_WIDGET (hsv)->requisition.width / 2.0;
 588   outer = priv->size / 2.0;
 589   inner = outer - priv->ring_width;
 590   angle = priv->h * 2.0 * G_PI;
 591
 592   *hx = floor (center + cos (angle) * inner + 0.5);
 593   *hy = floor (center - sin (angle) * inner + 0.5);
 594   *sx = floor (center + cos (angle + 2.0 * G_PI / 3.0) * inner + 0.5);
 595   *sy = floor (center - sin (angle + 2.0 * G_PI / 3.0) * inner + 0.5);
 596   *vx = floor (center + cos (angle + 4.0 * G_PI / 3.0) * inner + 0.5);
 597   *vy = floor (center - sin (angle + 4.0 * G_PI / 3.0) * inner + 0.5);
 598 }
 599
 600 /* Computes whether a point is inside the hue ring */
 601 static gboolean
 602 is_in_ring (GtkHSV *hsv,
 603             gdouble x,
 604             gdouble y)
 605 {
 606   HSVPrivate *priv;
 607   gdouble dx, dy, dist;
 608   gdouble center, inner, outer;
 609
 610   priv = hsv->priv;
 611
 612   center = priv->size / 2.0;
 613   outer = priv->size / 2.0;
 614   inner = outer - priv->ring_width;
 615
 616   dx = x - center;
 617   dy = center - y;
 618   dist = dx * dx + dy * dy;
 619
 620   return (dist >= inner * inner && dist <= outer * outer);
 621 }
 622
 623 /* Computes a saturation/value pair based on the mouse coordinates */
 624 static void
 625 compute_sv (GtkHSV  *hsv,
 626             gdouble  x,
 627             gdouble  y,
 628             gdouble *s,
 629             gdouble *v)
 630 {
 631   HSVPrivate *priv;
 632   int ihx, ihy, isx, isy, ivx, ivy;
 633   double hx, hy, sx, sy, vx, vy;
 634   double center;
 635
 636   priv = hsv->priv;
 637
 638   compute_triangle (hsv, &ihx, &ihy, &isx, &isy, &ivx, &ivy);
 639   center = GTK_WIDGET (hsv)->requisition.width / 2.0;
 640   hx = ihx - center;
 641   hy = center - ihy;
 642   sx = isx - center;
 643   sy = center - isy;
 644   vx = ivx - center;
 645   vy = center - ivy;
 646   x -= center;
 647   y = center - y;
 648
 649   if (vx * (x - sx) + vy * (y - sy) < 0.0)
 650     {
 651       *s = 1.0;
 652       *v = (((x - sx) * (hx - sx) + (y - sy) * (hy-sy))
 653             / ((hx - sx) * (hx - sx) + (hy - sy) * (hy - sy)));
 654
 655       if (*v < 0.0)
 656         *v = 0.0;
 657       else if (*v > 1.0)
 658         *v = 1.0;
 659     }
 660   else if (hx * (x - sx) + hy * (y - sy) < 0.0)
 661     {
 662       *s = 0.0;
 663       *v = (((x - sx) * (vx - sx) + (y - sy) * (vy - sy))
 664             / ((vx - sx) * (vx - sx) + (vy - sy) * (vy - sy)));
 665
 666       if (*v < 0.0)
 667         *v = 0.0;
 668       else if (*v > 1.0)
 669         *v = 1.0;
 670     }
 671   else if (sx * (x - hx) + sy * (y - hy) < 0.0)
 672     {
 673       *v = 1.0;
 674       *s = (((x - vx) * (hx - vx) + (y - vy) * (hy - vy)) /
 675             ((hx - vx) * (hx - vx) + (hy - vy) * (hy - vy)));
 676
 677       if (*s < 0.0)
 678         *s = 0.0;
 679       else if (*s > 1.0)
 680         *s = 1.0;
 681     }
 682   else
 683     {
 684       *v = (((x - sx) * (hy - vy) - (y - sy) * (hx - vx))
 685             / ((vx - sx) * (hy - vy) - (vy - sy) * (hx - vx)));
 686
 687       if (*v<= 0.0)
 688         {
 689           *v = 0.0;
 690           *s = 0.0;
 691         }
 692       else
 693         {
 694           if (*v > 1.0)
 695             *v = 1.0;
 696
 697           if (fabs (hy - vy) < fabs (hx - vx))
 698             *s = (x - sx - *v * (vx - sx)) / (*v * (hx - vx));
 699           else
 700             *s = (y - sy - *v * (vy - sy)) / (*v * (hy - vy));
 701
 702           if (*s < 0.0)
 703             *s = 0.0;
 704           else if (*s > 1.0)
 705             *s = 1.0;
 706         }
 707     }
 708 }
 709
 710 /* Computes whether a point is inside the saturation/value triangle */
 711 static gboolean
 712 is_in_triangle (GtkHSV *hsv,
 713                 gdouble x,
 714                 gdouble y)
 715 {
 716   int hx, hy, sx, sy, vx, vy;
 717   double det, s, v;
 718
 719   compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
 720
 721   det = (vx - sx) * (hy - sy) - (vy - sy) * (hx - sx);
 722
 723   s = ((x - sx) * (hy - sy) - (y - sy) * (hx - sx)) / det;
 724   v = ((vx - sx) * (y - sy) - (vy - sy) * (x - sx)) / det;
 725
 726   return (s >= 0.0 && v >= 0.0 && s + v <= 1.0);
 727 }
 728
 729 /* Computes a value based on the mouse coordinates */
 730 static double
 731 compute_v (GtkHSV *hsv,
 732            gdouble x,
 733            gdouble y)
 734 {
 735   HSVPrivate *priv;
 736   double center;
 737   double dx, dy;
 738   double angle;
 739
 740   priv = hsv->priv;
 741
 742   center = GTK_WIDGET (hsv)->requisition.width / 2.0;
 743   dx = x - center;
 744   dy = center - y;
 745
 746   angle = atan2 (dy, dx);
 747   if (angle < 0.0)
 748     angle += 2.0 * G_PI;
 749
 750   return angle / (2.0 * G_PI);
 751 }
 752
 753 /* Event handlers */
 754
 755 static void
 756 set_cross_grab (GtkHSV *hsv,
 757                 guint32 time)
 758 {
 759   HSVPrivate *priv;
 760   GdkCursor *cursor;
 761
 762   priv = hsv->priv;
 763
 764   cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (hsv)),
 765                                        GDK_CROSSHAIR);
 766   gdk_pointer_grab (priv->window, FALSE,
 767                     (GDK_POINTER_MOTION_MASK
 768                      | GDK_POINTER_MOTION_HINT_MASK
 769                      | GDK_BUTTON_RELEASE_MASK),
 770                     NULL,
 771                     cursor,
 772                     time);
 773   gdk_cursor_unref (cursor);
 774 }
 775
 776 /* Button_press_event handler for the HSV color selector */
 777 static gint
 778 gtk_hsv_button_press (GtkWidget      *widget,
 779                       GdkEventButton *event)
 780 {
 781   GtkHSV *hsv;
 782   HSVPrivate *priv;
 783   double x, y;
 784
 785   hsv = GTK_HSV (widget);
 786   priv = hsv->priv;
 787
 788   if (priv->mode != DRAG_NONE || event->button != 1)
 789     return FALSE;
 790
 791   x = event->x;
 792   y = event->y;
 793
 794   if (is_in_ring (hsv, x, y))
 795     {
 796       priv->mode = DRAG_H;
 797       set_cross_grab (hsv, event->time);
 798
 799       gtk_hsv_set_color (hsv,
 800                          compute_v (hsv, x, y),
 801                          priv->s,
 802                          priv->v);
 803
 804       gtk_widget_grab_focus (widget);
 805       priv->focus_on_ring = TRUE;
 806
 807       return TRUE;
 808     }
 809
 810   if (is_in_triangle (hsv, x, y))
 811     {
 812       gdouble s, v;
 813
 814       priv->mode = DRAG_SV;
 815       set_cross_grab (hsv, event->time);
 816
 817       compute_sv (hsv, x, y, &s, &v);
 818       gtk_hsv_set_color (hsv, priv->h, s, v);
 819
 820       gtk_widget_grab_focus (widget);
 821       priv->focus_on_ring = FALSE;
 822
 823       return TRUE;
 824     }
 825
 826   return FALSE;
 827 }
 828
 829 /* Button_release_event handler for the HSV color selector */
 830 static gint
 831 gtk_hsv_button_release (GtkWidget      *widget,
 832                         GdkEventButton *event)
 833 {
 834   GtkHSV *hsv;
 835   HSVPrivate *priv;
 836   DragMode mode;
 837   gdouble x, y;
 838
 839   hsv = GTK_HSV (widget);
 840   priv = hsv->priv;
 841
 842   if (priv->mode == DRAG_NONE || event->button != 1)
 843     return FALSE;
 844
 845   /* Set the drag mode to DRAG_NONE so that signal handlers for "catched"
 846    * can see that this is the final color state.
 847    */
 848
 849   mode = priv->mode;
 850   priv->mode = DRAG_NONE;
 851
 852   x = event->x;
 853   y = event->y;
 854
 855   if (mode == DRAG_H)
 856     gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
 857   else if (mode == DRAG_SV) {
 858     double s, v;
 859
 860     compute_sv (hsv, x, y, &s, &v);
 861     gtk_hsv_set_color (hsv, priv->h, s, v);
 862   } else
 863     g_assert_not_reached ();
 864
 865   gdk_display_pointer_ungrab (gdk_drawable_get_display (event->window),
 866                               event->time);
 867   return TRUE;
 868 }
 869
 870 /* Motion_notify_event handler for the HSV color selector */
 871 static gint
 872 gtk_hsv_motion (GtkWidget      *widget,
 873                 GdkEventMotion *event)
 874 {
 875   GtkHSV *hsv;
 876   HSVPrivate *priv;
 877   double x, y;
 878   gint ix, iy;
 879   GdkModifierType mods;
 880
 881   hsv = GTK_HSV (widget);
 882   priv = hsv->priv;
 883
 884   if (priv->mode == DRAG_NONE)
 885     return FALSE;
 886
 887   if (event->is_hint)
 888     {
 889       gdk_window_get_pointer (priv->window, &ix, &iy, &mods);
 890       x = ix;
 891       y = iy;
 892     }
 893   else
 894     {
 895       x = event->x;
 896       y = event->y;
 897     }
 898
 899   if (priv->mode == DRAG_H)
 900     {
 901       gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
 902       return TRUE;
 903     }
 904   else if (priv->mode == DRAG_SV)
 905     {
 906       double s, v;
 907
 908       compute_sv (hsv, x, y, &s, &v);
 909       gtk_hsv_set_color (hsv, priv->h, s, v);
 910       return TRUE;
 911     }
 912
 913   g_assert_not_reached ();
 914   return FALSE;
 915 }
 916
 917
 918 /* Redrawing */
 919
 920 /* Paints the hue ring */
 921 static void
 922 paint_ring (GtkHSV      *hsv,
 923             GdkDrawable *drawable,
 924             gint         x,
 925             gint         y,
 926             gint         width,
 927             gint         height)
 928 {
 929   GtkWidget *widget = GTK_WIDGET (hsv);
 930   HSVPrivate *priv;
 931   int xx, yy;
 932   gdouble dx, dy, dist;
 933   gdouble center;
 934   gdouble inner, outer;
 935   guchar *buf, *p;
 936   gdouble angle;
 937   gdouble hue;
 938   gdouble r, g, b;
 939   GdkBitmap *mask;
 940   GdkGC *gc;
 941   GdkColor color;
 942   gint focus_width;
 943   gint focus_pad;
 944
 945   gtk_widget_style_get (widget,
 946                         "focus-line-width", &focus_width,
 947                         "focus-padding", &focus_pad,
 948                         NULL);
 949
 950   priv = hsv->priv;
 951
 952   center = widget->requisition.width / 2.0;
 953
 954   outer = priv->size / 2.0;
 955   inner = outer - priv->ring_width;
 956
 957   /* Paint the ring */
 958
 959   buf = g_new (guchar, width * height * 3);
 960
 961   for (yy = 0; yy < height; yy++)
 962     {
 963       p = buf + yy * width * 3;
 964
 965       dy = -(yy + y - center);
 966
 967       for (xx = 0; xx < width; xx++)
 968         {
 969           dx = xx + x - center;
 970
 971           dist = dx * dx + dy * dy;
 972           if (dist < ((inner-1) * (inner-1)) || dist > ((outer+1) * (outer+1)))
 973             {
 974               *p++ = 0;
 975               *p++ = 0;
 976               *p++ = 0;
 977               continue;
 978             }
 979
 980           angle = atan2 (dy, dx);
 981           if (angle < 0.0)
 982             angle += 2.0 * G_PI;
 983
 984           hue = angle / (2.0 * G_PI);
 985
 986           r = hue;
 987           g = 1.0;
 988           b = 1.0;
 989           hsv_to_rgb (&r, &g, &b);
 990
 991           *p++ = floor (r * 255 + 0.5);
 992           *p++ = floor (g * 255 + 0.5);
 993           *p++ = floor (b * 255 + 0.5);
 994         }
 995     }
 996
 997   /* Create clipping mask */
 998
 999   mask = gdk_pixmap_new (GTK_WIDGET (hsv)->window, width, height, 1);
1000
1001   gc = gdk_gc_new (mask);
1002
1003   color.pixel = 0;
1004   gdk_gc_set_foreground (gc, &color);
1005   gdk_draw_rectangle (mask, gc, TRUE,
1006                       0, 0, width, height);
1007
1008
1009   color.pixel = 1;
1010   gdk_gc_set_foreground (gc, &color);
1011   gdk_draw_arc (mask, gc, TRUE,
1012                 focus_width + focus_pad - x,
1013                 focus_width + focus_pad - y,
1014                 priv->size - 1, priv->size - 1,
1015                 0, 360 * 64);
1016
1017   color.pixel = 0;
1018   gdk_gc_set_foreground (gc, &color);
1019   gdk_draw_arc (mask, gc, TRUE,
1020                 focus_width + focus_pad - x + priv->ring_width - 1,
1021                 focus_width + focus_pad - y + priv->ring_width - 1,
1022                 priv->size - 2 * priv->ring_width + 1, priv->size - 2 * priv->ring_width + 1,
1023                 0, 360 * 64);
1024
1025   g_object_unref (gc);
1026
1027   gdk_gc_set_clip_mask (priv->gc, mask);
1028   gdk_gc_set_clip_origin (priv->gc, 0, 0);
1029
1030   /* Draw ring */
1031
1032   gdk_draw_rgb_image_dithalign (drawable, priv->gc, 0, 0, width, height,
1033                                 GDK_RGB_DITHER_MAX,
1034                                 buf,
1035                                 width * 3,
1036                                 x, y);
1037
1038   /* Draw value marker */
1039
1040   r = priv->h;
1041   g = 1.0;
1042   b = 1.0;
1043   hsv_to_rgb (&r, &g, &b);
1044
1045   if (INTENSITY (r, g, b) > 0.5)
1046     {
1047       color.red = 0x0000;
1048       color.green = 0x0000;
1049       color.blue = 0x0000;
1050     }
1051   else
1052     {
1053       color.red = 0xffff;
1054       color.green = 0xffff;
1055       color.blue = 0xffff;
1056     }
1057
1058   gdk_gc_set_rgb_fg_color (priv->gc, &color);
1059
1060   gdk_draw_line (drawable, priv->gc,
1061                  -x + center, -y + center,
1062                  -x + center + cos (priv->h * 2.0 * G_PI) * center,
1063                  -y + center - sin (priv->h * 2.0 * G_PI) * center);
1064
1065   gdk_gc_set_clip_mask (priv->gc, NULL);
1066   g_object_unref (mask);
1067
1068   g_free (buf);
1069
1070   /* Draw ring outline */
1071
1072   if (GTK_WIDGET_HAS_FOCUS (hsv) && priv->focus_on_ring)
1073     {
1074       gtk_paint_focus (widget->style, drawable,
1075                        GTK_WIDGET_STATE (widget),
1076                        NULL, widget, NULL,
1077                        x, y, width, height);
1078     }
1079 }
1080
1081 /* Converts an HSV triplet to an integer RGB triplet */
1082 static void
1083 get_color (gdouble h,
1084            gdouble s,
1085            gdouble v,
1086            gint   *r,
1087            gint   *g,
1088            gint   *b)
1089 {
1090   hsv_to_rgb (&h, &s, &v);
1091
1092   *r = floor (h * 255 + 0.5);
1093   *g = floor (s * 255 + 0.5);
1094   *b = floor (v * 255 + 0.5);
1095 }
1096
1097 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
1098
1099 #define LERP(a, b, v1, v2, i) (((v2) - (v1) != 0)                                       \
1100                                ? ((a) + ((b) - (a)) * ((i) - (v1)) / ((v2) - (v1)))     \
1101                                : (a))
1102
1103 /* Paints the HSV triangle */
1104 static void
1105 paint_triangle (GtkHSV      *hsv,
1106                 GdkDrawable *drawable,
1107                 gint         x,
1108                 gint         y,
1109                 gint         width,
1110                 gint         height)
1111 {
1112   GtkWidget *widget = GTK_WIDGET (hsv);
1113   HSVPrivate *priv;
1114   gint hx, hy, sx, sy, vx, vy; /* HSV vertices */
1115   gint x1, y1, r1, g1, b1; /* First vertex in scanline order */
1116   gint x2, y2, r2, g2, b2; /* Second vertex */
1117   gint x3, y3, r3, g3, b3; /* Third vertex */
1118   gint t;
1119   guchar *buf, *p;
1120   gint xl, xr, rl, rr, gl, gr, bl, br; /* Scanline data */
1121   gint xx, yy;
1122   GdkBitmap *mask;
1123   GdkGC *gc;
1124   GdkColor color;
1125   GdkPoint points[3];
1126   gdouble r, g, b;
1127   gchar *detail;
1128
1129   priv = hsv->priv;
1130
1131   /* Compute triangle's vertices */
1132
1133   compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
1134
1135   x1 = hx;
1136   y1 = hy;
1137   get_color (priv->h, 1.0, 1.0, &r1, &g1, &b1);
1138
1139   x2 = sx;
1140   y2 = sy;
1141   get_color (priv->h, 1.0, 0.0, &r2, &g2, &b2);
1142
1143   x3 = vx;
1144   y3 = vy;
1145   get_color (priv->h, 0.0, 1.0, &r3, &g3, &b3);
1146
1147   if (y2 > y3)
1148     {
1149       SWAP (x2, x3, t);
1150       SWAP (y2, y3, t);
1151       SWAP (r2, r3, t);
1152       SWAP (g2, g3, t);
1153       SWAP (b2, b3, t);
1154     }
1155
1156   if (y1 > y3)
1157     {
1158       SWAP (x1, x3, t);
1159       SWAP (y1, y3, t);
1160       SWAP (r1, r3, t);
1161       SWAP (g1, g3, t);
1162       SWAP (b1, b3, t);
1163     }
1164
1165   if (y1 > y2)
1166     {
1167       SWAP (x1, x2, t);
1168       SWAP (y1, y2, t);
1169       SWAP (r1, r2, t);
1170       SWAP (g1, g2, t);
1171       SWAP (b1, b2, t);
1172     }
1173
1174   /* Shade the triangle */
1175
1176   buf = g_new (guchar, width * height * 3);
1177
1178   for (yy = 0; yy < height; yy++)
1179     {
1180       p = buf + yy * width * 3;
1181
1182       if (yy + y < y1 || yy + y > y3)
1183         for (xx = 0; xx < width; xx++)
1184           {
1185             *p++ = 0;
1186             *p++ = 0;
1187             *p++ = 0;
1188           }
1189       else {
1190         if (yy + y < y2)
1191           {
1192             xl = LERP (x1, x2, y1, y2, yy + y);
1193
1194             rl = LERP (r1, r2, y1, y2, yy + y);
1195             gl = LERP (g1, g2, y1, y2, yy + y);
1196             bl = LERP (b1, b2, y1, y2, yy + y);
1197           }
1198         else
1199           {
1200             xl = LERP (x2, x3, y2, y3, yy + y);
1201
1202             rl = LERP (r2, r3, y2, y3, yy + y);
1203             gl = LERP (g2, g3, y2, y3, yy + y);
1204             bl = LERP (b2, b3, y2, y3, yy + y);
1205           }
1206
1207         xr = LERP (x1, x3, y1, y3, yy + y);
1208
1209         rr = LERP (r1, r3, y1, y3, yy + y);
1210         gr = LERP (g1, g3, y1, y3, yy + y);
1211         br = LERP (b1, b3, y1, y3, yy + y);
1212
1213         if (xl > xr)
1214           {
1215             SWAP (xl, xr, t);
1216             SWAP (rl, rr, t);
1217             SWAP (gl, gr, t);
1218             SWAP (bl, br, t);
1219           }
1220
1221         for (xx = 0; xx < width; xx++)
1222           {
1223             if (xx + x < xl || xx + x > xr)
1224               {
1225                 *p++ = 0;
1226                 *p++ = 0;
1227                 *p++ = 0;
1228               }
1229             else
1230               {
1231                 *p++ = LERP (rl, rr, xl, xr, xx + x);
1232                 *p++ = LERP (gl, gr, xl, xr, xx + x);
1233                 *p++ = LERP (bl, br, xl, xr, xx + x);
1234               }
1235           }
1236       }
1237     }
1238
1239   /* Create clipping mask */
1240
1241   mask = gdk_pixmap_new (widget->window, width, height, 1);
1242
1243   gc = gdk_gc_new (mask);
1244
1245   color.pixel = 0;
1246   gdk_gc_set_foreground (gc, &color);
1247   gdk_draw_rectangle (mask, gc, TRUE,
1248                       0, 0, width, height);
1249
1250   color.pixel = 1;
1251   gdk_gc_set_foreground (gc, &color);
1252
1253   points[0].x = x1 - x;
1254   points[0].y = y1 - y;
1255   points[1].x = x2 - x;
1256   points[1].y = y2 - y;
1257   points[2].x = x3 - x;
1258   points[2].y = y3 - y;
1259   gdk_draw_polygon (mask, gc, TRUE, points, 3);
1260
1261   g_object_unref (gc);
1262
1263   gdk_gc_set_clip_mask (priv->gc, mask);
1264   gdk_gc_set_clip_origin (priv->gc, 0, 0);
1265
1266   /* Draw triangle */
1267
1268   gdk_draw_rgb_image_dithalign (drawable, priv->gc, 0, 0, width, height,
1269                                 GDK_RGB_DITHER_MAX,
1270                                 buf,
1271                                 width * 3,
1272                                 x, y);
1273
1274   gdk_gc_set_clip_mask (priv->gc, NULL);
1275   g_object_unref (mask);
1276
1277   g_free (buf);
1278
1279   /* Draw value marker */
1280
1281   xx = floor (sx + (vx - sx) * priv->v + (hx - vx) * priv->s * priv->v + 0.5) - x;
1282   yy = floor (sy + (vy - sy) * priv->v + (hy - vy) * priv->s * priv->v + 0.5) - y;
1283
1284   r = priv->h;
1285   g = priv->s;
1286   b = priv->v;
1287   hsv_to_rgb (&r, &g, &b);
1288
1289   if (INTENSITY (r, g, b) > 0.5)
1290     {
1291       detail = "colorwheel_light";
1292       color.red = 0x0000;
1293       color.green = 0x0000;
1294       color.blue = 0x0000;
1295     }
1296   else
1297     {
1298       detail = "colorwheel_dark";
1299       color.red = 0xffff;
1300       color.green = 0xffff;
1301       color.blue = 0xffff;
1302     }
1303
1304   gdk_gc_set_rgb_fg_color (priv->gc, &color);
1305
1306 #define OUTER_RADIUS 4
1307 #define INNER_RADIUS 3
1308 #define FOCUS_RADIUS 6
1309
1310   gdk_draw_arc (drawable, priv->gc, FALSE,
1311                 xx - OUTER_RADIUS, yy - OUTER_RADIUS,
1312                 OUTER_RADIUS * 2, OUTER_RADIUS * 2,
1313                 0, 360 * 64);
1314   gdk_draw_arc (drawable, priv->gc, FALSE,
1315                 xx - INNER_RADIUS, yy - INNER_RADIUS,
1316                 INNER_RADIUS * 2, INNER_RADIUS * 2,
1317                 0, 360 * 64);
1318
1319   /* Draw focus outline */
1320
1321   if (GTK_WIDGET_HAS_FOCUS (hsv) &&
1322       !priv->focus_on_ring)
1323     {
1324       gint focus_width;
1325       gint focus_pad;
1326
1327       gtk_widget_style_get (widget,
1328                             "focus-line-width", &focus_width,
1329                             "focus-padding", &focus_pad,
1330                             NULL);
1331
1332       gtk_paint_focus (widget->style, drawable,
1333                        GTK_WIDGET_STATE (widget),
1334                        NULL, widget, detail,
1335                        xx - FOCUS_RADIUS - focus_width - focus_pad,
1336                        yy - FOCUS_RADIUS - focus_width - focus_pad,
1337                        2 * (FOCUS_RADIUS + focus_width + focus_pad),
1338                        2 * (FOCUS_RADIUS + focus_width + focus_pad));
1339     }
1340
1341 }
1342
1343 /* Paints the contents of the HSV color selector */
1344 static void
1345 paint (GtkHSV      *hsv,
1346        GdkDrawable *drawable,
1347        gint         x,
1348        gint         y,
1349        gint         width,
1350        gint         height)
1351 {
1352   paint_ring (hsv, drawable, x, y, width, height);
1353   paint_triangle (hsv, drawable, x, y, width, height);
1354 }
1355
1356 /* Expose_event handler for the HSV color selector */
1357 static gint
1358 gtk_hsv_expose (GtkWidget      *widget,
1359                 GdkEventExpose *event)
1360 {
1361   GtkHSV *hsv;
1362   HSVPrivate *priv;
1363   GdkRectangle rect, dest;
1364   GdkPixmap *pixmap;
1365
1366   hsv = GTK_HSV (widget);
1367   priv = hsv->priv;
1368
1369   if (!(GTK_WIDGET_DRAWABLE (widget) && event->window == widget->window))
1370     return FALSE;
1371
1372   rect.x = widget->allocation.x;
1373   rect.y = widget->allocation.y;
1374   rect.width = widget->allocation.width;
1375   rect.height = widget->allocation.height;
1376
1377   if (!gdk_rectangle_intersect (&event->area, &rect, &dest))
1378     return FALSE;
1379
1380   pixmap = gdk_pixmap_new (widget->window, dest.width, dest.height,
1381                            gtk_widget_get_visual (widget)->depth);
1382
1383   rect = dest;
1384   rect.x = 0;
1385   rect.y = 0;
1386
1387   gdk_draw_rectangle (pixmap,
1388                       widget->style->bg_gc[GTK_WIDGET_STATE (widget)],
1389                       TRUE,
1390                       0, 0, dest.width, dest.height);
1391   paint (hsv, pixmap,
1392          dest.x - widget->allocation.x, dest.y - widget->allocation.y,
1393          dest.width, dest.height);
1394
1395   gdk_draw_drawable (widget->window,
1396                      priv->gc,
1397                      pixmap,
1398                      0, 0,
1399                      dest.x,
1400                      dest.y,
1401                      event->area.width, event->area.height);
1402
1403   g_object_unref (pixmap);
1404
1405   return FALSE;
1406 }
1407
1408 static gboolean
1409 gtk_hsv_focus (GtkWidget       *widget,
1410                GtkDirectionType dir)
1411 {
1412   GtkHSV *hsv;
1413   HSVPrivate *priv;
1414
1415   hsv = GTK_HSV (widget);
1416   priv = hsv->priv;
1417
1418   if (!GTK_WIDGET_HAS_FOCUS (hsv))
1419     {
1420       if (dir == GTK_DIR_TAB_BACKWARD)
1421         priv->focus_on_ring = FALSE;
1422       else
1423         priv->focus_on_ring = TRUE;
1424
1425       gtk_widget_grab_focus (GTK_WIDGET (hsv));
1426       return TRUE;
1427     }
1428
1429   switch (dir)
1430     {
1431     case GTK_DIR_UP:
1432       if (priv->focus_on_ring)
1433         return FALSE;
1434       else
1435         priv->focus_on_ring = TRUE;
1436       break;
1437
1438     case GTK_DIR_DOWN:
1439       if (priv->focus_on_ring)
1440         priv->focus_on_ring = FALSE;
1441       else
1442         return FALSE;
1443       break;
1444
1445     case GTK_DIR_LEFT:
1446     case GTK_DIR_TAB_BACKWARD:
1447       if (priv->focus_on_ring)
1448         return FALSE;
1449       else
1450         priv->focus_on_ring = TRUE;
1451       break;
1452
1453     case GTK_DIR_RIGHT:
1454     case GTK_DIR_TAB_FORWARD:
1455       if (priv->focus_on_ring)
1456         priv->focus_on_ring = FALSE;
1457       else
1458         return FALSE;
1459       break;
1460     }
1461
1462   gtk_widget_queue_draw (GTK_WIDGET (hsv));
1463
1464   return TRUE;
1465 }
1466
1467 /**
1468  * gtk_hsv_new:
1469  * @void:
1470  *
1471  * Creates a new HSV color selector.
1472  *
1473  * Return value: A newly-created HSV color selector.
1474  **/
1475 GtkWidget*
1476 gtk_hsv_new (void)
1477 {
1478   return g_object_new (GTK_TYPE_HSV, NULL);
1479 }
1480
1481 /**
1482  * gtk_hsv_set_color:
1483  * @hsv: An HSV color selector.
1484  * @h: Hue.
1485  * @s: Saturation.
1486  * @v: Value.
1487  *
1488  * Sets the current color in an HSV color selector.  Color component values must
1489  * be in the [0.0, 1.0] range.
1490  **/
1491 void
1492 gtk_hsv_set_color (GtkHSV *hsv,
1493                    gdouble h,
1494                    gdouble s,
1495                    gdouble v)
1496 {
1497   HSVPrivate *priv;
1498
1499   g_return_if_fail (hsv != NULL);
1500   g_return_if_fail (GTK_IS_HSV (hsv));
1501   g_return_if_fail (h >= 0.0 && h <= 1.0);
1502   g_return_if_fail (s >= 0.0 && s <= 1.0);
1503   g_return_if_fail (v >= 0.0 && v <= 1.0);
1504
1505   priv = hsv->priv;
1506
1507   priv->h = h;
1508   priv->s = s;
1509   priv->v = v;
1510
1511   g_signal_emit (hsv, hsv_signals[CHANGED], 0);
1512
1513   gtk_widget_queue_draw (GTK_WIDGET (hsv));
1514 }
1515
1516 /**
1517  * gtk_hsv_get_color:
1518  * @hsv: An HSV color selector.
1519  * @h: Return value for the hue.
1520  * @s: Return value for the saturation.
1521  * @v: Return value for the value.
1522  *
1523  * Queries the current color in an HSV color selector.  Returned values will be
1524  * in the [0.0, 1.0] range.
1525  **/
1526 void
1527 gtk_hsv_get_color (GtkHSV *hsv, double *h, double *s, double *v)
1528 {
1529   HSVPrivate *priv;
1530
1531   g_return_if_fail (GTK_IS_HSV (hsv));
1532
1533   priv = hsv->priv;
1534
1535   if (h)
1536     *h = priv->h;
1537
1538   if (s)
1539     *s = priv->s;
1540
1541   if (v)
1542     *v = priv->v;
1543 }
1544
1545 /**
1546  * gtk_hsv_set_metrics:
1547  * @hsv: An HSV color selector.
1548  * @size: Diameter for the hue ring.
1549  * @ring_width: Width of the hue ring.
1550  *
1551  * Sets the size and ring width of an HSV color selector.
1552  **/
1553 void
1554 gtk_hsv_set_metrics (GtkHSV *hsv,
1555                      gint    size,
1556                      gint    ring_width)
1557 {
1558   HSVPrivate *priv;
1559   int same_size;
1560
1561   g_return_if_fail (GTK_IS_HSV (hsv));
1562   g_return_if_fail (size > 0);
1563   g_return_if_fail (ring_width > 0);
1564   g_return_if_fail (2 * ring_width + 1 <= size);
1565
1566   priv = hsv->priv;
1567
1568   same_size = (priv->size == size);
1569
1570   priv->size = size;
1571   priv->ring_width = ring_width;
1572
1573   if (same_size)
1574     gtk_widget_queue_draw (GTK_WIDGET (hsv));
1575   else
1576     gtk_widget_queue_resize (GTK_WIDGET (hsv));
1577 }
1578
1579 /**
1580  * gtk_hsv_get_metrics:
1581  * @hsv: An HSV color selector.
1582  * @size: Return value for the diameter of the hue ring.
1583  * @ring_width: Return value for the width of the hue ring.
1584  *
1585  * Queries the size and ring width of an HSV color selector.
1586  **/
1587 void
1588 gtk_hsv_get_metrics (GtkHSV *hsv,
1589                      gint   *size,
1590                      gint   *ring_width)
1591 {
1592   HSVPrivate *priv;
1593
1594   g_return_if_fail (GTK_IS_HSV (hsv));
1595
1596   priv = hsv->priv;
1597
1598   if (size)
1599     *size = priv->size;
1600
1601   if (ring_width)
1602     *ring_width = priv->ring_width;
1603 }
1604
1605 /**
1606  * gtk_hsv_is_adjusting:
1607  * @hsv:
1608  *
1609  * An HSV color selector can be said to be adjusting if multiple rapid changes
1610  * are being made to its value, for example, when the user is adjusting the
1611  * value with the mouse.  This function queries whether the HSV color selector
1612  * is being adjusted or not.
1613  *
1614  * Return value: TRUE if clients can ignore changes to the color value, since
1615  * they may be transitory, or FALSE if they should consider the color value
1616  * status to be final.
1617  **/
1618 gboolean
1619 gtk_hsv_is_adjusting (GtkHSV *hsv)
1620 {
1621   HSVPrivate *priv;
1622
1623   g_return_val_if_fail (GTK_IS_HSV (hsv), FALSE);
1624
1625   priv = hsv->priv;
1626
1627   return priv->mode != DRAG_NONE;
1628 }
1629
1630 /**
1631  * gtk_hsv_to_rgb:
1632  * @h: Hue.
1633  * @s: Saturation.
1634  * @v: Value.
1635  * @r: Return value for the red component.
1636  * @g: Return value for the green component.
1637  * @b: Return value for the blue component.
1638  *
1639  * Converts a color from HSV space to RGB.  Input values must be in the
1640  * [0.0, 1.0] range; output values will be in the same range.
1641  **/
1642 void
1643 gtk_hsv_to_rgb (gdouble  h,
1644                 gdouble  s,
1645                 gdouble  v,
1646                 gdouble *r,
1647                 gdouble *g,
1648                 gdouble *b)
1649 {
1650   g_return_if_fail (h >= 0.0 && h <= 1.0);
1651   g_return_if_fail (s >= 0.0 && s <= 1.0);
1652   g_return_if_fail (v >= 0.0 && v <= 1.0);
1653
1654   hsv_to_rgb (&h, &s, &v);
1655
1656   if (r)
1657     *r = h;
1658
1659   if (g)
1660     *g = s;
1661
1662   if (b)
1663     *b = v;
1664 }
1665
1666 /**
1667  * gtk_hsv_to_rgb:
1668  * @r: Red.
1669  * @g: Green.
1670  * @b: Blue.
1671  * @h: Return value for the hue component.
1672  * @s: Return value for the saturation component.
1673  * @v: Return value for the value component.
1674  *
1675  * Converts a color from RGB space to HSV.  Input values must be in the
1676  * [0.0, 1.0] range; output values will be in the same range.
1677  **/
1678 void
1679 gtk_rgb_to_hsv (gdouble  r,
1680                 gdouble  g,
1681                 gdouble  b,
1682                 gdouble *h,
1683                 gdouble *s,
1684                 gdouble *v)
1685 {
1686   g_return_if_fail (r >= 0.0 && r <= 1.0);
1687   g_return_if_fail (g >= 0.0 && g <= 1.0);
1688   g_return_if_fail (b >= 0.0 && b <= 1.0);
1689
1690   rgb_to_hsv (&r, &g, &b);
1691
1692   if (h)
1693     *h = r;
1694
1695   if (s)
1696     *s = g;
1697
1698   if (v)
1699     *v = b;
1700 }
1701
1702 static void
1703 gtk_hsv_move (GtkHSV          *hsv,
1704               GtkDirectionType dir)
1705 {
1706   HSVPrivate *priv;
1707   gdouble hue, sat, val;
1708   gint hx, hy, sx, sy, vx, vy; /* HSV vertices */
1709   gint x, y; /* position in triangle */
1710
1711   priv = hsv->priv;
1712
1713   hue = priv->h;
1714   sat = priv->s;
1715   val = priv->v;
1716
1717   compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
1718
1719   x = floor (sx + (vx - sx) * priv->v + (hx - vx) * priv->s * priv->v + 0.5);
1720   y = floor (sy + (vy - sy) * priv->v + (hy - vy) * priv->s * priv->v + 0.5);
1721
1722 #define HUE_DELTA 0.002
1723   switch (dir)
1724     {
1725     case GTK_DIR_UP:
1726       if (priv->focus_on_ring)
1727         hue += HUE_DELTA;
1728       else
1729         {
1730           y -= 1;
1731           compute_sv (hsv, x, y, &sat, &val);
1732         }
1733       break;
1734
1735     case GTK_DIR_DOWN:
1736       if (priv->focus_on_ring)
1737         hue -= HUE_DELTA;
1738       else
1739         {
1740           y += 1;
1741           compute_sv (hsv, x, y, &sat, &val);
1742         }
1743       break;
1744
1745     case GTK_DIR_LEFT:
1746       if (priv->focus_on_ring)
1747         hue += HUE_DELTA;
1748       else
1749         {
1750           x -= 1;
1751           compute_sv (hsv, x, y, &sat, &val);
1752         }
1753       break;
1754
1755     case GTK_DIR_RIGHT:
1756       if (priv->focus_on_ring)
1757         hue -= HUE_DELTA
1758           ;
1759       else
1760         {
1761           x += 1;
1762           compute_sv (hsv, x, y, &sat, &val);
1763         }
1764       break;
1765
1766     default:
1767       /* we don't care about the tab directions */
1768       break;
1769     }
1770
1771   /* Wrap */
1772   if (hue < 0.0)
1773     hue = 1.0;
1774   else if (hue > 1.0)
1775     hue = 0.0;
1776
1777   gtk_hsv_set_color (hsv, hue, sat, val);
1778 }