Pileus Git - ~andy/gtk/blob - gtk/deprecated/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, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 /*
  24  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  25  * file for a list of people on the GTK+ Team.  See the ChangeLog
  26  * files for a list of changes.  These files are distributed with
  27  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  28  */
  29
  30 #include "config.h"
  31
  32 #define GDK_DISABLE_DEPRECATION_WARNINGS
  33
  34 #include <math.h>
  35 #include <string.h>
  36
  37 #include "gtkhsv.h"
  38 #include "gtkbindings.h"
  39 #include "gtkmarshalers.h"
  40 #include "gtkstylecontext.h"
  41 #include "gtktypebuiltins.h"
  42 #include "gtkintl.h"
  43
  44
  45 /**
  46  * SECTION:gtkhsv
  47  * @Short_description: A 'color wheel' widget
  48  * @Title: GtkHSV
  49  * @See_also: #GtkColorSelection, #GtkColorSelectionDialog
  50  *
  51  * #GtkHSV is the 'color wheel' part of a complete color selector widget.
  52  * It allows to select a color by determining its HSV components in an
  53  * intuitive way. Moving the selection around the outer ring changes the hue,
  54  * and moving the selection point inside the inner triangle changes value and
  55  * saturation.
  56  *
  57  * #GtkHSV has been deprecated together with #GtkColorSelection, where
  58  * it was used.
  59  */
  60
  61
  62 /* Default width/height */
  63 #define DEFAULT_SIZE 100
  64
  65 /* Default ring width */
  66 #define DEFAULT_RING_WIDTH 10
  67
  68
  69 /* Dragging modes */
  70 typedef enum {
  71   DRAG_NONE,
  72   DRAG_H,
  73   DRAG_SV
  74 } DragMode;
  75
  76 /* Private part of the GtkHSV structure */
  77 struct _GtkHSVPrivate
  78 {
  79   /* Color value */
  80   double h;
  81   double s;
  82   double v;
  83
  84   /* Size and ring width */
  85   int size;
  86   int ring_width;
  87
  88   /* Window for capturing events */
  89   GdkWindow *window;
  90
  91   /* Dragging mode */
  92   DragMode mode;
  93
  94   guint focus_on_ring : 1;
  95 };
  96
  97
  98 /* Signal IDs */
  99
 100 enum {
 101   CHANGED,
 102   MOVE,
 103   LAST_SIGNAL
 104 };
 105
 106 static void     gtk_hsv_destroy              (GtkWidget          *widget);
 107 static void     gtk_hsv_realize              (GtkWidget          *widget);
 108 static void     gtk_hsv_unrealize            (GtkWidget          *widget);
 109 static void     gtk_hsv_get_preferred_width  (GtkWidget          *widget,
 110                                               gint               *minimum,
 111                                               gint               *natural);
 112 static void     gtk_hsv_get_preferred_height (GtkWidget          *widget,
 113                                               gint               *minimum,
 114                                               gint               *natural);
 115 static void     gtk_hsv_size_allocate        (GtkWidget          *widget,
 116                                               GtkAllocation      *allocation);
 117 static gboolean gtk_hsv_button_press         (GtkWidget          *widget,
 118                                               GdkEventButton     *event);
 119 static gboolean gtk_hsv_button_release       (GtkWidget          *widget,
 120                                               GdkEventButton     *event);
 121 static gboolean gtk_hsv_motion               (GtkWidget          *widget,
 122                                               GdkEventMotion     *event);
 123 static gboolean gtk_hsv_draw                 (GtkWidget          *widget,
 124                                               cairo_t            *cr);
 125 static gboolean gtk_hsv_grab_broken          (GtkWidget          *widget,
 126                                               GdkEventGrabBroken *event);
 127 static gboolean gtk_hsv_focus                (GtkWidget          *widget,
 128                                               GtkDirectionType    direction);
 129 static void     gtk_hsv_move                 (GtkHSV             *hsv,
 130                                               GtkDirectionType    dir);
 131
 132 static guint hsv_signals[LAST_SIGNAL];
 133
 134 G_DEFINE_TYPE (GtkHSV, gtk_hsv, GTK_TYPE_WIDGET)
 135
 136 /* Class initialization function for the HSV color selector */
 137 static void
 138 gtk_hsv_class_init (GtkHSVClass *class)
 139 {
 140   GObjectClass   *gobject_class;
 141   GtkWidgetClass *widget_class;
 142   GtkHSVClass    *hsv_class;
 143   GtkBindingSet  *binding_set;
 144
 145   gobject_class = (GObjectClass *) class;
 146   widget_class = (GtkWidgetClass *) class;
 147   hsv_class = GTK_HSV_CLASS (class);
 148
 149   widget_class->destroy = gtk_hsv_destroy;
 150   widget_class->realize = gtk_hsv_realize;
 151   widget_class->unrealize = gtk_hsv_unrealize;
 152   widget_class->get_preferred_width = gtk_hsv_get_preferred_width;
 153   widget_class->get_preferred_height = gtk_hsv_get_preferred_height;
 154   widget_class->size_allocate = gtk_hsv_size_allocate;
 155   widget_class->button_press_event = gtk_hsv_button_press;
 156   widget_class->button_release_event = gtk_hsv_button_release;
 157   widget_class->motion_notify_event = gtk_hsv_motion;
 158   widget_class->draw = gtk_hsv_draw;
 159   widget_class->focus = gtk_hsv_focus;
 160   widget_class->grab_broken_event = gtk_hsv_grab_broken;
 161
 162   gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_COLOR_CHOOSER);
 163
 164   hsv_class->move = gtk_hsv_move;
 165
 166   hsv_signals[CHANGED] =
 167     g_signal_new (I_("changed"),
 168                   G_OBJECT_CLASS_TYPE (gobject_class),
 169                   G_SIGNAL_RUN_FIRST,
 170                   G_STRUCT_OFFSET (GtkHSVClass, changed),
 171                   NULL, NULL,
 172                   _gtk_marshal_VOID__VOID,
 173                   G_TYPE_NONE, 0);
 174
 175   hsv_signals[MOVE] =
 176     g_signal_new (I_("move"),
 177                   G_OBJECT_CLASS_TYPE (gobject_class),
 178                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 179                   G_STRUCT_OFFSET (GtkHSVClass, move),
 180                   NULL, NULL,
 181                   _gtk_marshal_VOID__ENUM,
 182                   G_TYPE_NONE, 1,
 183                   GTK_TYPE_DIRECTION_TYPE);
 184
 185   binding_set = gtk_binding_set_by_class (class);
 186
 187   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Up, 0,
 188                                 "move", 1,
 189                                 G_TYPE_ENUM, GTK_DIR_UP);
 190   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Up, 0,
 191                                 "move", 1,
 192                                 G_TYPE_ENUM, GTK_DIR_UP);
 193   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Down, 0,
 194                                 "move", 1,
 195                                 G_TYPE_ENUM, GTK_DIR_DOWN);
 196   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Down, 0,
 197                                 "move", 1,
 198                                 G_TYPE_ENUM, GTK_DIR_DOWN);
 199   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 0,
 200                                 "move", 1,
 201                                 G_TYPE_ENUM, GTK_DIR_RIGHT);
 202   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, 0,
 203                                 "move", 1,
 204                                 G_TYPE_ENUM, GTK_DIR_RIGHT);
 205   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 0,
 206                                 "move", 1,
 207                                 G_TYPE_ENUM, GTK_DIR_LEFT);
 208   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, 0,
 209                                 "move", 1,
 210                                 G_TYPE_ENUM, GTK_DIR_LEFT);
 211
 212   g_type_class_add_private (gobject_class, sizeof (GtkHSVPrivate));
 213 }
 214
 215 static void
 216 gtk_hsv_init (GtkHSV *hsv)
 217 {
 218   GtkHSVPrivate *priv;
 219
 220   priv = G_TYPE_INSTANCE_GET_PRIVATE (hsv, GTK_TYPE_HSV, GtkHSVPrivate);
 221
 222   hsv->priv = priv;
 223
 224   gtk_widget_set_has_window (GTK_WIDGET (hsv), FALSE);
 225   gtk_widget_set_can_focus (GTK_WIDGET (hsv), TRUE);
 226
 227   priv->h = 0.0;
 228   priv->s = 0.0;
 229   priv->v = 0.0;
 230
 231   priv->size = DEFAULT_SIZE;
 232   priv->ring_width = DEFAULT_RING_WIDTH;
 233 }
 234
 235 static void
 236 gtk_hsv_destroy (GtkWidget *widget)
 237 {
 238   GTK_WIDGET_CLASS (gtk_hsv_parent_class)->destroy (widget);
 239 }
 240
 241 static void
 242 gtk_hsv_realize (GtkWidget *widget)
 243 {
 244   GtkHSV *hsv = GTK_HSV (widget);
 245   GtkHSVPrivate *priv = hsv->priv;
 246   GtkAllocation allocation;
 247   GdkWindow *parent_window;
 248   GdkWindowAttr attr;
 249   int attr_mask;
 250
 251   gtk_widget_set_realized (widget, TRUE);
 252
 253   gtk_widget_get_allocation (widget, &allocation);
 254
 255   attr.window_type = GDK_WINDOW_CHILD;
 256   attr.x = allocation.x;
 257   attr.y = allocation.y;
 258   attr.width = allocation.width;
 259   attr.height = allocation.height;
 260   attr.wclass = GDK_INPUT_ONLY;
 261   attr.event_mask = gtk_widget_get_events (widget);
 262   attr.event_mask |= (GDK_KEY_PRESS_MASK
 263                       | GDK_BUTTON_PRESS_MASK
 264                       | GDK_BUTTON_RELEASE_MASK
 265                       | GDK_POINTER_MOTION_MASK
 266                       | GDK_ENTER_NOTIFY_MASK
 267                       | GDK_LEAVE_NOTIFY_MASK);
 268   attr_mask = GDK_WA_X | GDK_WA_Y;
 269
 270   parent_window = gtk_widget_get_parent_window (widget);
 271   gtk_widget_set_window (widget, parent_window);
 272   g_object_ref (parent_window);
 273
 274   priv->window = gdk_window_new (parent_window, &attr, attr_mask);
 275   gdk_window_set_user_data (priv->window, hsv);
 276   gdk_window_show (priv->window);
 277 }
 278
 279 static void
 280 gtk_hsv_unrealize (GtkWidget *widget)
 281 {
 282   GtkHSV *hsv = GTK_HSV (widget);
 283   GtkHSVPrivate *priv = hsv->priv;
 284
 285   gdk_window_set_user_data (priv->window, NULL);
 286   gdk_window_destroy (priv->window);
 287   priv->window = NULL;
 288
 289   GTK_WIDGET_CLASS (gtk_hsv_parent_class)->unrealize (widget);
 290 }
 291
 292 static void
 293 gtk_hsv_get_preferred_width (GtkWidget *widget,
 294                              gint      *minimum,
 295                              gint      *natural)
 296 {
 297   GtkHSV *hsv = GTK_HSV (widget);
 298   GtkHSVPrivate *priv = hsv->priv;
 299   gint focus_width;
 300   gint focus_pad;
 301
 302   gtk_widget_style_get (widget,
 303                         "focus-line-width", &focus_width,
 304                         "focus-padding", &focus_pad,
 305                         NULL);
 306
 307   *minimum = priv->size + 2 * (focus_width + focus_pad);
 308   *natural = priv->size + 2 * (focus_width + focus_pad);
 309 }
 310
 311 static void
 312 gtk_hsv_get_preferred_height (GtkWidget *widget,
 313                               gint      *minimum,
 314                               gint      *natural)
 315 {
 316   GtkHSV *hsv = GTK_HSV (widget);
 317   GtkHSVPrivate *priv = hsv->priv;
 318   gint focus_width;
 319   gint focus_pad;
 320
 321   gtk_widget_style_get (widget,
 322                         "focus-line-width", &focus_width,
 323                         "focus-padding", &focus_pad,
 324                         NULL);
 325
 326   *minimum = priv->size + 2 * (focus_width + focus_pad);
 327   *natural = priv->size + 2 * (focus_width + focus_pad);
 328 }
 329
 330 static void
 331 gtk_hsv_size_allocate (GtkWidget     *widget,
 332                        GtkAllocation *allocation)
 333 {
 334   GtkHSV *hsv = GTK_HSV (widget);
 335   GtkHSVPrivate *priv = hsv->priv;
 336
 337   gtk_widget_set_allocation (widget, allocation);
 338
 339   if (gtk_widget_get_realized (widget))
 340     gdk_window_move_resize (priv->window,
 341                             allocation->x,
 342                             allocation->y,
 343                             allocation->width,
 344                             allocation->height);
 345 }
 346
 347
 348 /* Utility functions */
 349
 350 #define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
 351
 352 /* Converts from HSV to RGB */
 353 static void
 354 hsv_to_rgb (gdouble *h,
 355             gdouble *s,
 356             gdouble *v)
 357 {
 358   gdouble hue, saturation, value;
 359   gdouble f, p, q, t;
 360
 361   if (*s == 0.0)
 362     {
 363       *h = *v;
 364       *s = *v;
 365       *v = *v; /* heh */
 366     }
 367   else
 368     {
 369       hue = *h * 6.0;
 370       saturation = *s;
 371       value = *v;
 372
 373       if (hue == 6.0)
 374         hue = 0.0;
 375
 376       f = hue - (int) hue;
 377       p = value * (1.0 - saturation);
 378       q = value * (1.0 - saturation * f);
 379       t = value * (1.0 - saturation * (1.0 - f));
 380
 381       switch ((int) hue)
 382         {
 383         case 0:
 384           *h = value;
 385           *s = t;
 386           *v = p;
 387           break;
 388
 389         case 1:
 390           *h = q;
 391           *s = value;
 392           *v = p;
 393           break;
 394
 395         case 2:
 396           *h = p;
 397           *s = value;
 398           *v = t;
 399           break;
 400
 401         case 3:
 402           *h = p;
 403           *s = q;
 404           *v = value;
 405           break;
 406
 407         case 4:
 408           *h = t;
 409           *s = p;
 410           *v = value;
 411           break;
 412
 413         case 5:
 414           *h = value;
 415           *s = p;
 416           *v = q;
 417           break;
 418
 419         default:
 420           g_assert_not_reached ();
 421         }
 422     }
 423 }
 424
 425 /* Computes the vertices of the saturation/value triangle */
 426 static void
 427 compute_triangle (GtkHSV *hsv,
 428                   gint   *hx,
 429                   gint   *hy,
 430                   gint   *sx,
 431                   gint   *sy,
 432                   gint   *vx,
 433                   gint   *vy)
 434 {
 435   GtkHSVPrivate *priv = hsv->priv;
 436   GtkWidget *widget = GTK_WIDGET (hsv);
 437   gdouble center_x;
 438   gdouble center_y;
 439   gdouble inner, outer;
 440   gdouble angle;
 441
 442   center_x = gtk_widget_get_allocated_width (widget) / 2.0;
 443   center_y = gtk_widget_get_allocated_height (widget) / 2.0;
 444   outer = priv->size / 2.0;
 445   inner = outer - priv->ring_width;
 446   angle = priv->h * 2.0 * G_PI;
 447
 448   *hx = floor (center_x + cos (angle) * inner + 0.5);
 449   *hy = floor (center_y - sin (angle) * inner + 0.5);
 450   *sx = floor (center_x + cos (angle + 2.0 * G_PI / 3.0) * inner + 0.5);
 451   *sy = floor (center_y - sin (angle + 2.0 * G_PI / 3.0) * inner + 0.5);
 452   *vx = floor (center_x + cos (angle + 4.0 * G_PI / 3.0) * inner + 0.5);
 453   *vy = floor (center_y - sin (angle + 4.0 * G_PI / 3.0) * inner + 0.5);
 454 }
 455
 456 /* Computes whether a point is inside the hue ring */
 457 static gboolean
 458 is_in_ring (GtkHSV *hsv,
 459             gdouble x,
 460             gdouble y)
 461 {
 462   GtkHSVPrivate *priv = hsv->priv;
 463   GtkWidget *widget = GTK_WIDGET (hsv);
 464   gdouble dx, dy, dist;
 465   gdouble center_x;
 466   gdouble center_y;
 467   gdouble inner, outer;
 468
 469   center_x = gtk_widget_get_allocated_width (widget) / 2.0;
 470   center_y = gtk_widget_get_allocated_height (widget) / 2.0;
 471   outer = priv->size / 2.0;
 472   inner = outer - priv->ring_width;
 473
 474   dx = x - center_x;
 475   dy = center_y - y;
 476   dist = dx * dx + dy * dy;
 477
 478   return (dist >= inner * inner && dist <= outer * outer);
 479 }
 480
 481 /* Computes a saturation/value pair based on the mouse coordinates */
 482 static void
 483 compute_sv (GtkHSV  *hsv,
 484             gdouble  x,
 485             gdouble  y,
 486             gdouble *s,
 487             gdouble *v)
 488 {
 489   GtkWidget *widget = GTK_WIDGET (hsv);
 490   int ihx, ihy, isx, isy, ivx, ivy;
 491   double hx, hy, sx, sy, vx, vy;
 492   double center_x;
 493   double center_y;
 494
 495   compute_triangle (hsv, &ihx, &ihy, &isx, &isy, &ivx, &ivy);
 496   center_x = gtk_widget_get_allocated_width (widget) / 2.0;
 497   center_y = gtk_widget_get_allocated_height (widget) / 2.0;
 498   hx = ihx - center_x;
 499   hy = center_y - ihy;
 500   sx = isx - center_x;
 501   sy = center_y - isy;
 502   vx = ivx - center_x;
 503   vy = center_y - ivy;
 504   x -= center_x;
 505   y = center_y - y;
 506
 507   if (vx * (x - sx) + vy * (y - sy) < 0.0)
 508     {
 509       *s = 1.0;
 510       *v = (((x - sx) * (hx - sx) + (y - sy) * (hy-sy))
 511             / ((hx - sx) * (hx - sx) + (hy - sy) * (hy - sy)));
 512
 513       if (*v < 0.0)
 514         *v = 0.0;
 515       else if (*v > 1.0)
 516         *v = 1.0;
 517     }
 518   else if (hx * (x - sx) + hy * (y - sy) < 0.0)
 519     {
 520       *s = 0.0;
 521       *v = (((x - sx) * (vx - sx) + (y - sy) * (vy - sy))
 522             / ((vx - sx) * (vx - sx) + (vy - sy) * (vy - sy)));
 523
 524       if (*v < 0.0)
 525         *v = 0.0;
 526       else if (*v > 1.0)
 527         *v = 1.0;
 528     }
 529   else if (sx * (x - hx) + sy * (y - hy) < 0.0)
 530     {
 531       *v = 1.0;
 532       *s = (((x - vx) * (hx - vx) + (y - vy) * (hy - vy)) /
 533             ((hx - vx) * (hx - vx) + (hy - vy) * (hy - vy)));
 534
 535       if (*s < 0.0)
 536         *s = 0.0;
 537       else if (*s > 1.0)
 538         *s = 1.0;
 539     }
 540   else
 541     {
 542       *v = (((x - sx) * (hy - vy) - (y - sy) * (hx - vx))
 543             / ((vx - sx) * (hy - vy) - (vy - sy) * (hx - vx)));
 544
 545       if (*v<= 0.0)
 546         {
 547           *v = 0.0;
 548           *s = 0.0;
 549         }
 550       else
 551         {
 552           if (*v > 1.0)
 553             *v = 1.0;
 554
 555           if (fabs (hy - vy) < fabs (hx - vx))
 556             *s = (x - sx - *v * (vx - sx)) / (*v * (hx - vx));
 557           else
 558             *s = (y - sy - *v * (vy - sy)) / (*v * (hy - vy));
 559
 560           if (*s < 0.0)
 561             *s = 0.0;
 562           else if (*s > 1.0)
 563             *s = 1.0;
 564         }
 565     }
 566 }
 567
 568 /* Computes whether a point is inside the saturation/value triangle */
 569 static gboolean
 570 is_in_triangle (GtkHSV *hsv,
 571                 gdouble x,
 572                 gdouble y)
 573 {
 574   int hx, hy, sx, sy, vx, vy;
 575   double det, s, v;
 576
 577   compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
 578
 579   det = (vx - sx) * (hy - sy) - (vy - sy) * (hx - sx);
 580
 581   s = ((x - sx) * (hy - sy) - (y - sy) * (hx - sx)) / det;
 582   v = ((vx - sx) * (y - sy) - (vy - sy) * (x - sx)) / det;
 583
 584   return (s >= 0.0 && v >= 0.0 && s + v <= 1.0);
 585 }
 586
 587 /* Computes a value based on the mouse coordinates */
 588 static double
 589 compute_v (GtkHSV *hsv,
 590            gdouble x,
 591            gdouble y)
 592 {
 593   GtkWidget *widget = GTK_WIDGET (hsv);
 594   double center_x;
 595   double center_y;
 596   double dx, dy;
 597   double angle;
 598
 599   center_x = gtk_widget_get_allocated_width (widget) / 2.0;
 600   center_y = gtk_widget_get_allocated_height (widget) / 2.0;
 601   dx = x - center_x;
 602   dy = center_y - y;
 603
 604   angle = atan2 (dy, dx);
 605   if (angle < 0.0)
 606     angle += 2.0 * G_PI;
 607
 608   return angle / (2.0 * G_PI);
 609 }
 610
 611 /* Event handlers */
 612
 613 static void
 614 set_cross_grab (GtkHSV    *hsv,
 615                 GdkDevice *device,
 616                 guint32    time)
 617 {
 618   GtkHSVPrivate *priv = hsv->priv;
 619   GdkCursor *cursor;
 620
 621   cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (hsv)),
 622                                        GDK_CROSSHAIR);
 623   gdk_device_grab (device,
 624                    priv->window,
 625                    GDK_OWNERSHIP_NONE,
 626                    FALSE,
 627                    GDK_POINTER_MOTION_MASK
 628                     | GDK_POINTER_MOTION_HINT_MASK
 629                     | GDK_BUTTON_RELEASE_MASK,
 630                    cursor,
 631                    time);
 632   g_object_unref (cursor);
 633 }
 634
 635 static gboolean
 636 gtk_hsv_grab_broken (GtkWidget          *widget,
 637                      GdkEventGrabBroken *event)
 638 {
 639   GtkHSV *hsv = GTK_HSV (widget);
 640   GtkHSVPrivate *priv = hsv->priv;
 641
 642   priv->mode = DRAG_NONE;
 643
 644   return TRUE;
 645 }
 646
 647 static gint
 648 gtk_hsv_button_press (GtkWidget      *widget,
 649                       GdkEventButton *event)
 650 {
 651   GtkHSV *hsv = GTK_HSV (widget);
 652   GtkHSVPrivate *priv = hsv->priv;
 653   double x, y;
 654
 655   if (priv->mode != DRAG_NONE || event->button != GDK_BUTTON_PRIMARY)
 656     return FALSE;
 657
 658   x = event->x;
 659   y = event->y;
 660
 661   if (is_in_ring (hsv, x, y))
 662     {
 663       priv->mode = DRAG_H;
 664       set_cross_grab (hsv, gdk_event_get_device ((GdkEvent *) event), event->time);
 665
 666       gtk_hsv_set_color (hsv,
 667                          compute_v (hsv, x, y),
 668                          priv->s,
 669                          priv->v);
 670
 671       gtk_widget_grab_focus (widget);
 672       priv->focus_on_ring = TRUE;
 673
 674       return TRUE;
 675     }
 676
 677   if (is_in_triangle (hsv, x, y))
 678     {
 679       gdouble s, v;
 680
 681       priv->mode = DRAG_SV;
 682       set_cross_grab (hsv, gdk_event_get_device ((GdkEvent *) event), event->time);
 683
 684       compute_sv (hsv, x, y, &s, &v);
 685       gtk_hsv_set_color (hsv, priv->h, s, v);
 686
 687       gtk_widget_grab_focus (widget);
 688       priv->focus_on_ring = FALSE;
 689
 690       return TRUE;
 691     }
 692
 693   return FALSE;
 694 }
 695
 696 static gint
 697 gtk_hsv_button_release (GtkWidget      *widget,
 698                         GdkEventButton *event)
 699 {
 700   GtkHSV *hsv = GTK_HSV (widget);
 701   GtkHSVPrivate *priv = hsv->priv;
 702   DragMode mode;
 703   gdouble x, y;
 704
 705   if (priv->mode == DRAG_NONE || event->button != GDK_BUTTON_PRIMARY)
 706     return FALSE;
 707
 708   /* Set the drag mode to DRAG_NONE so that signal handlers for "catched"
 709    * can see that this is the final color state.
 710    */
 711   mode = priv->mode;
 712   priv->mode = DRAG_NONE;
 713
 714   x = event->x;
 715   y = event->y;
 716
 717   if (mode == DRAG_H)
 718     {
 719       gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
 720     }
 721   else if (mode == DRAG_SV)
 722     {
 723       gdouble s, v;
 724
 725       compute_sv (hsv, x, y, &s, &v);
 726       gtk_hsv_set_color (hsv, priv->h, s, v);
 727     }
 728   else
 729     {
 730       g_assert_not_reached ();
 731     }
 732
 733   gdk_device_ungrab (gdk_event_get_device ((GdkEvent *) event), event->time);
 734
 735   return TRUE;
 736 }
 737
 738 static gint
 739 gtk_hsv_motion (GtkWidget      *widget,
 740                 GdkEventMotion *event)
 741 {
 742   GtkHSV *hsv = GTK_HSV (widget);
 743   GtkHSVPrivate *priv = hsv->priv;
 744   gdouble x, y;
 745
 746   if (priv->mode == DRAG_NONE)
 747     return FALSE;
 748
 749   gdk_event_request_motions (event);
 750   x = event->x;
 751   y = event->y;
 752
 753   if (priv->mode == DRAG_H)
 754     {
 755       gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
 756       return TRUE;
 757     }
 758   else if (priv->mode == DRAG_SV)
 759     {
 760       gdouble s, v;
 761
 762       compute_sv (hsv, x, y, &s, &v);
 763       gtk_hsv_set_color (hsv, priv->h, s, v);
 764       return TRUE;
 765     }
 766
 767   g_assert_not_reached ();
 768
 769   return FALSE;
 770 }
 771
 772
 773 /* Redrawing */
 774
 775 /* Paints the hue ring */
 776 static void
 777 paint_ring (GtkHSV  *hsv,
 778             cairo_t *cr)
 779 {
 780   GtkHSVPrivate *priv = hsv->priv;
 781   GtkWidget *widget = GTK_WIDGET (hsv);
 782   int xx, yy, width, height;
 783   gdouble dx, dy, dist;
 784   gdouble center_x;
 785   gdouble center_y;
 786   gdouble inner, outer;
 787   guint32 *buf, *p;
 788   gdouble angle;
 789   gdouble hue;
 790   gdouble r, g, b;
 791   cairo_surface_t *source;
 792   cairo_t *source_cr;
 793   gint stride;
 794
 795   width = gtk_widget_get_allocated_width (widget);
 796   height = gtk_widget_get_allocated_height (widget);
 797
 798   center_x = width / 2.0;
 799   center_y = height / 2.0;
 800
 801   outer = priv->size / 2.0;
 802   inner = outer - priv->ring_width;
 803
 804   /* Create an image initialized with the ring colors */
 805
 806   stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, width);
 807   buf = g_new (guint32, height * stride / 4);
 808
 809   for (yy = 0; yy < height; yy++)
 810     {
 811       p = buf + yy * width;
 812
 813       dy = -(yy - center_y);
 814
 815       for (xx = 0; xx < width; xx++)
 816         {
 817           dx = xx - center_x;
 818
 819           dist = dx * dx + dy * dy;
 820           if (dist < ((inner-1) * (inner-1)) || dist > ((outer+1) * (outer+1)))
 821             {
 822               *p++ = 0;
 823               continue;
 824             }
 825
 826           angle = atan2 (dy, dx);
 827           if (angle < 0.0)
 828             angle += 2.0 * G_PI;
 829
 830           hue = angle / (2.0 * G_PI);
 831
 832           r = hue;
 833           g = 1.0;
 834           b = 1.0;
 835           hsv_to_rgb (&r, &g, &b);
 836
 837           *p++ = (((int)floor (r * 255 + 0.5) << 16) |
 838                   ((int)floor (g * 255 + 0.5) << 8) |
 839                   (int)floor (b * 255 + 0.5));
 840         }
 841     }
 842
 843   source = cairo_image_surface_create_for_data ((unsigned char *)buf,
 844                                                 CAIRO_FORMAT_RGB24,
 845                                                 width, height, stride);
 846
 847   /* Now draw the value marker onto the source image, so that it
 848    * will get properly clipped at the edges of the ring
 849    */
 850   source_cr = cairo_create (source);
 851
 852   r = priv->h;
 853   g = 1.0;
 854   b = 1.0;
 855   hsv_to_rgb (&r, &g, &b);
 856
 857   if (INTENSITY (r, g, b) > 0.5)
 858     cairo_set_source_rgb (source_cr, 0., 0., 0.);
 859   else
 860     cairo_set_source_rgb (source_cr, 1., 1., 1.);
 861
 862   cairo_move_to (source_cr, center_x, center_y);
 863   cairo_line_to (source_cr,
 864                  center_x + cos (priv->h * 2.0 * G_PI) * priv->size / 2,
 865                  center_y - sin (priv->h * 2.0 * G_PI) * priv->size / 2);
 866   cairo_stroke (source_cr);
 867   cairo_destroy (source_cr);
 868
 869   /* Draw the ring using the source image */
 870
 871   cairo_save (cr);
 872
 873   cairo_set_source_surface (cr, source, 0, 0);
 874   cairo_surface_destroy (source);
 875
 876   cairo_set_line_width (cr, priv->ring_width);
 877   cairo_new_path (cr);
 878   cairo_arc (cr,
 879              center_x, center_y,
 880              priv->size / 2. - priv->ring_width / 2.,
 881              0, 2 * G_PI);
 882   cairo_stroke (cr);
 883
 884   cairo_restore (cr);
 885
 886   g_free (buf);
 887 }
 888
 889 /* Converts an HSV triplet to an integer RGB triplet */
 890 static void
 891 get_color (gdouble h,
 892            gdouble s,
 893            gdouble v,
 894            gint   *r,
 895            gint   *g,
 896            gint   *b)
 897 {
 898   hsv_to_rgb (&h, &s, &v);
 899
 900   *r = floor (h * 255 + 0.5);
 901   *g = floor (s * 255 + 0.5);
 902   *b = floor (v * 255 + 0.5);
 903 }
 904
 905 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
 906
 907 #define LERP(a, b, v1, v2, i) (((v2) - (v1) != 0)                                       \
 908                                ? ((a) + ((b) - (a)) * ((i) - (v1)) / ((v2) - (v1)))     \
 909                                : (a))
 910
 911 /* Number of pixels we extend out from the edges when creating
 912  * color source to avoid artifacts
 913  */
 914 #define PAD 3
 915
 916 /* Paints the HSV triangle */
 917 static void
 918 paint_triangle (GtkHSV   *hsv,
 919                 cairo_t  *cr,
 920                 gboolean  draw_focus)
 921 {
 922   GtkHSVPrivate *priv = hsv->priv;
 923   GtkWidget *widget = GTK_WIDGET (hsv);
 924   gint hx, hy, sx, sy, vx, vy; /* HSV vertices */
 925   gint x1, y1, r1, g1, b1; /* First vertex in scanline order */
 926   gint x2, y2, r2, g2, b2; /* Second vertex */
 927   gint x3, y3, r3, g3, b3; /* Third vertex */
 928   gint t;
 929   guint32 *buf, *p, c;
 930   gint xl, xr, rl, rr, gl, gr, bl, br; /* Scanline data */
 931   gint xx, yy;
 932   gint x_interp, y_interp;
 933   gint x_start, x_end;
 934   cairo_surface_t *source;
 935   gdouble r, g, b;
 936   gint stride;
 937   int width, height;
 938   GtkStyleContext *context;
 939
 940   priv = hsv->priv;
 941   width = gtk_widget_get_allocated_width (widget);
 942   height = gtk_widget_get_allocated_height (widget);
 943   /* Compute triangle's vertices */
 944
 945   compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
 946
 947   x1 = hx;
 948   y1 = hy;
 949   get_color (priv->h, 1.0, 1.0, &r1, &g1, &b1);
 950
 951   x2 = sx;
 952   y2 = sy;
 953   get_color (priv->h, 1.0, 0.0, &r2, &g2, &b2);
 954
 955   x3 = vx;
 956   y3 = vy;
 957   get_color (priv->h, 0.0, 1.0, &r3, &g3, &b3);
 958
 959   if (y2 > y3)
 960     {
 961       SWAP (x2, x3, t);
 962       SWAP (y2, y3, t);
 963       SWAP (r2, r3, t);
 964       SWAP (g2, g3, t);
 965       SWAP (b2, b3, t);
 966     }
 967
 968   if (y1 > y3)
 969     {
 970       SWAP (x1, x3, t);
 971       SWAP (y1, y3, t);
 972       SWAP (r1, r3, t);
 973       SWAP (g1, g3, t);
 974       SWAP (b1, b3, t);
 975     }
 976
 977   if (y1 > y2)
 978     {
 979       SWAP (x1, x2, t);
 980       SWAP (y1, y2, t);
 981       SWAP (r1, r2, t);
 982       SWAP (g1, g2, t);
 983       SWAP (b1, b2, t);
 984     }
 985
 986   /* Shade the triangle */
 987
 988   stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, width);
 989   buf = g_new (guint32, height * stride / 4);
 990
 991   for (yy = 0; yy < height; yy++)
 992     {
 993       p = buf + yy * width;
 994
 995       if (yy >= y1 - PAD && yy < y3 + PAD) {
 996         y_interp = CLAMP (yy, y1, y3);
 997
 998         if (y_interp < y2)
 999           {
1000             xl = LERP (x1, x2, y1, y2, y_interp);
1001
1002             rl = LERP (r1, r2, y1, y2, y_interp);
1003             gl = LERP (g1, g2, y1, y2, y_interp);
1004             bl = LERP (b1, b2, y1, y2, y_interp);
1005           }
1006         else
1007           {
1008             xl = LERP (x2, x3, y2, y3, y_interp);
1009
1010             rl = LERP (r2, r3, y2, y3, y_interp);
1011             gl = LERP (g2, g3, y2, y3, y_interp);
1012             bl = LERP (b2, b3, y2, y3, y_interp);
1013           }
1014
1015         xr = LERP (x1, x3, y1, y3, y_interp);
1016
1017         rr = LERP (r1, r3, y1, y3, y_interp);
1018         gr = LERP (g1, g3, y1, y3, y_interp);
1019         br = LERP (b1, b3, y1, y3, y_interp);
1020
1021         if (xl > xr)
1022           {
1023             SWAP (xl, xr, t);
1024             SWAP (rl, rr, t);
1025             SWAP (gl, gr, t);
1026             SWAP (bl, br, t);
1027           }
1028
1029         x_start = MAX (xl - PAD, 0);
1030         x_end = MIN (xr + PAD, width);
1031         x_start = MIN (x_start, x_end);
1032
1033         c = (rl << 16) | (gl << 8) | bl;
1034
1035         for (xx = 0; xx < x_start; xx++)
1036           *p++ = c;
1037
1038         for (; xx < x_end; xx++)
1039           {
1040             x_interp = CLAMP (xx, xl, xr);
1041
1042             *p++ = ((LERP (rl, rr, xl, xr, x_interp) << 16) |
1043                     (LERP (gl, gr, xl, xr, x_interp) << 8) |
1044                     LERP (bl, br, xl, xr, x_interp));
1045           }
1046
1047         c = (rr << 16) | (gr << 8) | br;
1048
1049         for (; xx < width; xx++)
1050           *p++ = c;
1051       }
1052     }
1053
1054   source = cairo_image_surface_create_for_data ((unsigned char *)buf,
1055                                                 CAIRO_FORMAT_RGB24,
1056                                                 width, height, stride);
1057
1058   /* Draw a triangle with the image as a source */
1059
1060   cairo_set_source_surface (cr, source, 0, 0);
1061   cairo_surface_destroy (source);
1062
1063   cairo_move_to (cr, x1, y1);
1064   cairo_line_to (cr, x2, y2);
1065   cairo_line_to (cr, x3, y3);
1066   cairo_close_path (cr);
1067   cairo_fill (cr);
1068
1069   g_free (buf);
1070
1071   /* Draw value marker */
1072
1073   xx = floor (sx + (vx - sx) * priv->v + (hx - vx) * priv->s * priv->v + 0.5);
1074   yy = floor (sy + (vy - sy) * priv->v + (hy - vy) * priv->s * priv->v + 0.5);
1075
1076   r = priv->h;
1077   g = priv->s;
1078   b = priv->v;
1079   hsv_to_rgb (&r, &g, &b);
1080
1081   context = gtk_widget_get_style_context (widget);
1082
1083   gtk_style_context_save (context);
1084
1085   if (INTENSITY (r, g, b) > 0.5)
1086     {
1087       gtk_style_context_add_class (context, "light-area-focus");
1088       cairo_set_source_rgb (cr, 0., 0., 0.);
1089     }
1090   else
1091     {
1092       gtk_style_context_add_class (context, "dark-area-focus");
1093       cairo_set_source_rgb (cr, 1., 1., 1.);
1094     }
1095
1096 #define RADIUS 4
1097 #define FOCUS_RADIUS 6
1098
1099   cairo_new_path (cr);
1100   cairo_arc (cr, xx, yy, RADIUS, 0, 2 * G_PI);
1101   cairo_stroke (cr);
1102
1103   /* Draw focus outline */
1104
1105   if (draw_focus && !priv->focus_on_ring)
1106     {
1107       gint focus_width;
1108       gint focus_pad;
1109
1110       gtk_widget_style_get (widget,
1111                             "focus-line-width", &focus_width,
1112                             "focus-padding", &focus_pad,
1113                             NULL);
1114
1115       gtk_render_focus (context, cr,
1116                         xx - FOCUS_RADIUS - focus_width - focus_pad,
1117                         yy - FOCUS_RADIUS - focus_width - focus_pad,
1118                         2 * (FOCUS_RADIUS + focus_width + focus_pad),
1119                         2 * (FOCUS_RADIUS + focus_width + focus_pad));
1120     }
1121
1122   gtk_style_context_restore (context);
1123 }
1124
1125 /* Paints the contents of the HSV color selector */
1126 static gboolean
1127 gtk_hsv_draw (GtkWidget *widget,
1128               cairo_t   *cr)
1129 {
1130   GtkHSV *hsv = GTK_HSV (widget);
1131   GtkHSVPrivate *priv = hsv->priv;
1132   gboolean draw_focus;
1133
1134   draw_focus = gtk_widget_has_visible_focus (widget);
1135
1136   paint_ring (hsv, cr);
1137   paint_triangle (hsv, cr, draw_focus);
1138
1139
1140   if (draw_focus && priv->focus_on_ring)
1141     {
1142       GtkStyleContext *context;
1143
1144       context = gtk_widget_get_style_context (widget);
1145
1146       gtk_render_focus (context, cr, 0, 0,
1147                         gtk_widget_get_allocated_width (widget),
1148                         gtk_widget_get_allocated_height (widget));
1149     }
1150
1151   return FALSE;
1152 }
1153
1154 static gboolean
1155 gtk_hsv_focus (GtkWidget       *widget,
1156                GtkDirectionType dir)
1157 {
1158   GtkHSV *hsv = GTK_HSV (widget);
1159   GtkHSVPrivate *priv = hsv->priv;
1160
1161   if (!gtk_widget_has_focus (widget))
1162     {
1163       if (dir == GTK_DIR_TAB_BACKWARD)
1164         priv->focus_on_ring = FALSE;
1165       else
1166         priv->focus_on_ring = TRUE;
1167
1168       gtk_widget_grab_focus (GTK_WIDGET (hsv));
1169       return TRUE;
1170     }
1171
1172   switch (dir)
1173     {
1174     case GTK_DIR_UP:
1175       if (priv->focus_on_ring)
1176         return FALSE;
1177       else
1178         priv->focus_on_ring = TRUE;
1179       break;
1180
1181     case GTK_DIR_DOWN:
1182       if (priv->focus_on_ring)
1183         priv->focus_on_ring = FALSE;
1184       else
1185         return FALSE;
1186       break;
1187
1188     case GTK_DIR_LEFT:
1189     case GTK_DIR_TAB_BACKWARD:
1190       if (priv->focus_on_ring)
1191         return FALSE;
1192       else
1193         priv->focus_on_ring = TRUE;
1194       break;
1195
1196     case GTK_DIR_RIGHT:
1197     case GTK_DIR_TAB_FORWARD:
1198       if (priv->focus_on_ring)
1199         priv->focus_on_ring = FALSE;
1200       else
1201         return FALSE;
1202       break;
1203     }
1204
1205   gtk_widget_queue_draw (GTK_WIDGET (hsv));
1206
1207   return TRUE;
1208 }
1209
1210 /**
1211  * gtk_hsv_new:
1212  *
1213  * Creates a new HSV color selector.
1214  *
1215  * Return value: A newly-created HSV color selector.
1216  *
1217  * Since: 2.14
1218  */
1219 GtkWidget*
1220 gtk_hsv_new (void)
1221 {
1222   return g_object_new (GTK_TYPE_HSV, NULL);
1223 }
1224
1225 /**
1226  * gtk_hsv_set_color:
1227  * @hsv: An HSV color selector
1228  * @h: Hue
1229  * @s: Saturation
1230  * @v: Value
1231  *
1232  * Sets the current color in an HSV color selector.
1233  * Color component values must be in the [0.0, 1.0] range.
1234  *
1235  * Since: 2.14
1236  */
1237 void
1238 gtk_hsv_set_color (GtkHSV *hsv,
1239                    gdouble h,
1240                    gdouble s,
1241                    gdouble v)
1242 {
1243   GtkHSVPrivate *priv;
1244
1245   g_return_if_fail (GTK_IS_HSV (hsv));
1246   g_return_if_fail (h >= 0.0 && h <= 1.0);
1247   g_return_if_fail (s >= 0.0 && s <= 1.0);
1248   g_return_if_fail (v >= 0.0 && v <= 1.0);
1249
1250   priv = hsv->priv;
1251
1252   priv->h = h;
1253   priv->s = s;
1254   priv->v = v;
1255
1256   g_signal_emit (hsv, hsv_signals[CHANGED], 0);
1257
1258   gtk_widget_queue_draw (GTK_WIDGET (hsv));
1259 }
1260
1261 /**
1262  * gtk_hsv_get_color:
1263  * @hsv: An HSV color selector
1264  * @h: (out): Return value for the hue
1265  * @s: (out): Return value for the saturation
1266  * @v: (out): Return value for the value
1267  *
1268  * Queries the current color in an HSV color selector.
1269  * Returned values will be in the [0.0, 1.0] range.
1270  *
1271  * Since: 2.14
1272  */
1273 void
1274 gtk_hsv_get_color (GtkHSV *hsv,
1275                    double *h,
1276                    double *s,
1277                    double *v)
1278 {
1279   GtkHSVPrivate *priv;
1280
1281   g_return_if_fail (GTK_IS_HSV (hsv));
1282
1283   priv = hsv->priv;
1284
1285   if (h)
1286     *h = priv->h;
1287
1288   if (s)
1289     *s = priv->s;
1290
1291   if (v)
1292     *v = priv->v;
1293 }
1294
1295 /**
1296  * gtk_hsv_set_metrics:
1297  * @hsv: An HSV color selector
1298  * @size: Diameter for the hue ring
1299  * @ring_width: Width of the hue ring
1300  *
1301  * Sets the size and ring width of an HSV color selector.
1302  *
1303  * Since: 2.14
1304  */
1305 void
1306 gtk_hsv_set_metrics (GtkHSV *hsv,
1307                      gint    size,
1308                      gint    ring_width)
1309 {
1310   GtkHSVPrivate *priv;
1311   int same_size;
1312
1313   g_return_if_fail (GTK_IS_HSV (hsv));
1314   g_return_if_fail (size > 0);
1315   g_return_if_fail (ring_width > 0);
1316   g_return_if_fail (2 * ring_width + 1 <= size);
1317
1318   priv = hsv->priv;
1319
1320   same_size = (priv->size == size);
1321
1322   priv->size = size;
1323   priv->ring_width = ring_width;
1324
1325   if (same_size)
1326     gtk_widget_queue_draw (GTK_WIDGET (hsv));
1327   else
1328     gtk_widget_queue_resize (GTK_WIDGET (hsv));
1329 }
1330
1331 /**
1332  * gtk_hsv_get_metrics:
1333  * @hsv: An HSV color selector
1334  * @size: (out): Return value for the diameter of the hue ring
1335  * @ring_width: (out): Return value for the width of the hue ring
1336  *
1337  * Queries the size and ring width of an HSV color selector.
1338  *
1339  * Since: 2.14
1340  */
1341 void
1342 gtk_hsv_get_metrics (GtkHSV *hsv,
1343                      gint   *size,
1344                      gint   *ring_width)
1345 {
1346   GtkHSVPrivate *priv;
1347
1348   g_return_if_fail (GTK_IS_HSV (hsv));
1349
1350   priv = hsv->priv;
1351
1352   if (size)
1353     *size = priv->size;
1354
1355   if (ring_width)
1356     *ring_width = priv->ring_width;
1357 }
1358
1359 /**
1360  * gtk_hsv_is_adjusting:
1361  * @hsv: A #GtkHSV
1362  *
1363  * An HSV color selector can be said to be adjusting if multiple rapid
1364  * changes are being made to its value, for example, when the user is
1365  * adjusting the value with the mouse. This function queries whether
1366  * the HSV color selector is being adjusted or not.
1367  *
1368  * Return value: %TRUE if clients can ignore changes to the color value,
1369  *     since they may be transitory, or %FALSE if they should consider
1370  *     the color value status to be final.
1371  *
1372  * Since: 2.14
1373  */
1374 gboolean
1375 gtk_hsv_is_adjusting (GtkHSV *hsv)
1376 {
1377   GtkHSVPrivate *priv;
1378
1379   g_return_val_if_fail (GTK_IS_HSV (hsv), FALSE);
1380
1381   priv = hsv->priv;
1382
1383   return priv->mode != DRAG_NONE;
1384 }
1385
1386 static void
1387 gtk_hsv_move (GtkHSV          *hsv,
1388               GtkDirectionType dir)
1389 {
1390   GtkHSVPrivate *priv = hsv->priv;
1391   gdouble hue, sat, val;
1392   gint hx, hy, sx, sy, vx, vy; /* HSV vertices */
1393   gint x, y; /* position in triangle */
1394
1395   hue = priv->h;
1396   sat = priv->s;
1397   val = priv->v;
1398
1399   compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
1400
1401   x = floor (sx + (vx - sx) * priv->v + (hx - vx) * priv->s * priv->v + 0.5);
1402   y = floor (sy + (vy - sy) * priv->v + (hy - vy) * priv->s * priv->v + 0.5);
1403
1404 #define HUE_DELTA 0.002
1405   switch (dir)
1406     {
1407     case GTK_DIR_UP:
1408       if (priv->focus_on_ring)
1409         hue += HUE_DELTA;
1410       else
1411         {
1412           y -= 1;
1413           compute_sv (hsv, x, y, &sat, &val);
1414         }
1415       break;
1416
1417     case GTK_DIR_DOWN:
1418       if (priv->focus_on_ring)
1419         hue -= HUE_DELTA;
1420       else
1421         {
1422           y += 1;
1423           compute_sv (hsv, x, y, &sat, &val);
1424         }
1425       break;
1426
1427     case GTK_DIR_LEFT:
1428       if (priv->focus_on_ring)
1429         hue += HUE_DELTA;
1430       else
1431         {
1432           x -= 1;
1433           compute_sv (hsv, x, y, &sat, &val);
1434         }
1435       break;
1436
1437     case GTK_DIR_RIGHT:
1438       if (priv->focus_on_ring)
1439         hue -= HUE_DELTA
1440           ;
1441       else
1442         {
1443           x += 1;
1444           compute_sv (hsv, x, y, &sat, &val);
1445         }
1446       break;
1447
1448     default:
1449       /* we don't care about the tab directions */
1450       break;
1451     }
1452
1453   /* Wrap */
1454   if (hue < 0.0)
1455     hue = 1.0;
1456   else if (hue > 1.0)
1457     hue = 0.0;
1458
1459   gtk_hsv_set_color (hsv, hue, sat, val);
1460 }
1461