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