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