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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2012 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19
  20 #include "gtkcolorplaneprivate.h"
  21
  22 #include "gtkaccessible.h"
  23 #include "gtkadjustment.h"
  24 #include "gtkcolorutils.h"
  25 #include "gtkpressandholdprivate.h"
  26 #include "gtkintl.h"
  27
  28 struct _GtkColorPlanePrivate
  29 {
  30   GtkAdjustment *h_adj;
  31   GtkAdjustment *s_adj;
  32   GtkAdjustment *v_adj;
  33
  34   cairo_surface_t *surface;
  35   gboolean in_drag;
  36
  37   GtkPressAndHold *press_and_hold;
  38 };
  39
  40 G_DEFINE_TYPE (GtkColorPlane, gtk_color_plane, GTK_TYPE_DRAWING_AREA)
  41
  42 static void
  43 sv_to_xy (GtkColorPlane *plane,
  44           gint          *x,
  45           gint          *y)
  46 {
  47   gdouble s, v;
  48   gint width, height;
  49
  50   width = gtk_widget_get_allocated_width (GTK_WIDGET (plane));
  51   height = gtk_widget_get_allocated_height (GTK_WIDGET (plane));
  52
  53   s = gtk_adjustment_get_value (plane->priv->s_adj);
  54   v = gtk_adjustment_get_value (plane->priv->v_adj);
  55
  56   *x = CLAMP (width * v, 0, width - 1);
  57   *y = CLAMP (height * (1 - s), 0, height - 1);
  58 }
  59
  60 static gboolean
  61 plane_draw (GtkWidget *widget,
  62             cairo_t   *cr)
  63 {
  64   GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
  65   gint x, y;
  66   gint width, height;
  67
  68   cairo_set_source_surface (cr, plane->priv->surface, 0, 0);
  69   cairo_paint (cr);
  70
  71   sv_to_xy (plane, &x, &y);
  72   width = gtk_widget_get_allocated_width (widget);
  73   height = gtk_widget_get_allocated_height (widget);
  74
  75   cairo_move_to (cr, 0,     y + 0.5);
  76   cairo_line_to (cr, width, y + 0.5);
  77
  78   cairo_move_to (cr, x + 0.5, 0);
  79   cairo_line_to (cr, x + 0.5, height);
  80
  81   if (gtk_widget_has_visible_focus (widget))
  82     {
  83       cairo_set_line_width (cr, 3.0);
  84       cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.6);
  85       cairo_stroke_preserve (cr);
  86
  87       cairo_set_line_width (cr, 1.0);
  88       cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.8);
  89       cairo_stroke (cr);
  90     }
  91   else
  92     {
  93       cairo_set_line_width (cr, 1.0);
  94       cairo_set_source_rgba (cr, 0.8, 0.8, 0.8, 0.8);
  95       cairo_stroke (cr);
  96     }
  97
  98   return FALSE;
  99 }
 100
 101 static void
 102 create_surface (GtkColorPlane *plane)
 103 {
 104   GtkWidget *widget = GTK_WIDGET (plane);
 105   cairo_t *cr;
 106   cairo_surface_t *surface;
 107   gint width, height, stride;
 108   cairo_surface_t *tmp;
 109   guint red, green, blue;
 110   guint32 *data, *p;
 111   gdouble h, s, v;
 112   gdouble r, g, b;
 113   gdouble sf, vf;
 114   gint x, y;
 115
 116   if (!gtk_widget_get_realized (widget))
 117     return;
 118
 119   width = gtk_widget_get_allocated_width (widget);
 120   height = gtk_widget_get_allocated_height (widget);
 121
 122   surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget),
 123                                                CAIRO_CONTENT_COLOR,
 124                                                width, height);
 125
 126   if (plane->priv->surface)
 127     cairo_surface_destroy (plane->priv->surface);
 128   plane->priv->surface = surface;
 129
 130   if (width == 1 || height == 1)
 131     return;
 132
 133   stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, width);
 134
 135   data = g_malloc (height * stride);
 136
 137   h = gtk_adjustment_get_value (plane->priv->h_adj);
 138   sf = 1.0 / (height - 1);
 139   vf = 1.0 / (width - 1);
 140   for (y = 0; y < height; y++)
 141     {
 142       s = CLAMP (1.0 - y * sf, 0.0, 1.0);
 143       p = data + y * (stride / 4);
 144       for (x = 0; x < width; x++)
 145         {
 146           v = x * vf;
 147           gtk_hsv_to_rgb (h, s, v, &r, &g, &b);
 148           red = CLAMP (r * 255, 0, 255);
 149           green = CLAMP (g * 255, 0, 255);
 150           blue = CLAMP (b * 255, 0, 255);
 151           p[x] = (red << 16) | (green << 8) | blue;
 152         }
 153     }
 154
 155   tmp = cairo_image_surface_create_for_data ((guchar *)data, CAIRO_FORMAT_RGB24,
 156                                              width, height, stride);
 157   cr = cairo_create (surface);
 158
 159   cairo_set_source_surface (cr, tmp, 0, 0);
 160   cairo_paint (cr);
 161
 162   cairo_destroy (cr);
 163   cairo_surface_destroy (tmp);
 164   g_free (data);
 165 }
 166
 167 static gboolean
 168 plane_configure (GtkWidget         *widget,
 169                  GdkEventConfigure *event)
 170 {
 171   create_surface (GTK_COLOR_PLANE (widget));
 172   return TRUE;
 173 }
 174
 175 static void
 176 set_cross_grab (GtkWidget *widget,
 177                 GdkDevice *device,
 178                 guint32    time)
 179 {
 180   GdkCursor *cursor;
 181
 182   cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (widget)),
 183                                        GDK_CROSSHAIR);
 184   gdk_device_grab (device,
 185                    gtk_widget_get_window (widget),
 186                    GDK_OWNERSHIP_NONE,
 187                    FALSE,
 188                    GDK_POINTER_MOTION_MASK
 189                     | GDK_POINTER_MOTION_HINT_MASK
 190                     | GDK_BUTTON_RELEASE_MASK,
 191                    cursor,
 192                    time);
 193   g_object_unref (cursor);
 194 }
 195
 196 static gboolean
 197 plane_grab_broken (GtkWidget          *widget,
 198                    GdkEventGrabBroken *event)
 199 {
 200   GTK_COLOR_PLANE (widget)->priv->in_drag = FALSE;
 201   return TRUE;
 202 }
 203
 204 static void
 205 h_changed (GtkColorPlane *plane)
 206 {
 207   create_surface (plane);
 208   gtk_widget_queue_draw (GTK_WIDGET (plane));
 209 }
 210
 211 static void
 212 sv_changed (GtkColorPlane *plane)
 213 {
 214   gtk_widget_queue_draw (GTK_WIDGET (plane));
 215 }
 216
 217 static void
 218 update_color (GtkColorPlane *plane,
 219               gint           x,
 220               gint           y)
 221 {
 222   GtkWidget *widget = GTK_WIDGET (plane);
 223   gdouble s, v;
 224
 225   s = CLAMP (1 - y * (1.0 / gtk_widget_get_allocated_height (widget)), 0, 1);
 226   v = CLAMP (x * (1.0 / gtk_widget_get_allocated_width (widget)), 0, 1);
 227   gtk_adjustment_set_value (plane->priv->s_adj, s);
 228   gtk_adjustment_set_value (plane->priv->v_adj, v);
 229
 230   gtk_widget_queue_draw (widget);
 231 }
 232
 233 static gboolean
 234 plane_button_press (GtkWidget      *widget,
 235                     GdkEventButton *event)
 236 {
 237   GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
 238
 239   if (event->button == GDK_BUTTON_SECONDARY)
 240     {
 241       gboolean handled;
 242
 243       g_signal_emit_by_name (widget, "popup-menu", &handled);
 244
 245       return TRUE;
 246     }
 247
 248   if (plane->priv->in_drag || event->button != GDK_BUTTON_PRIMARY)
 249     return FALSE;
 250
 251   plane->priv->in_drag = TRUE;
 252   set_cross_grab (widget, gdk_event_get_device ((GdkEvent*)event), event->time);
 253   update_color (plane, event->x, event->y);
 254   gtk_widget_grab_focus (widget);
 255
 256   return TRUE;
 257 }
 258
 259 static gboolean
 260 plane_button_release (GtkWidget      *widget,
 261                       GdkEventButton *event)
 262 {
 263   GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
 264
 265   if (!plane->priv->in_drag || event->button != GDK_BUTTON_PRIMARY)
 266     return FALSE;
 267
 268   plane->priv->in_drag = FALSE;
 269
 270   update_color (plane, event->x, event->y);
 271   gdk_device_ungrab (gdk_event_get_device ((GdkEvent *) event), event->time);
 272
 273   return TRUE;
 274 }
 275
 276 static gboolean
 277 plane_motion_notify (GtkWidget      *widget,
 278                      GdkEventMotion *event)
 279 {
 280   GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
 281
 282   if (!plane->priv->in_drag)
 283     return FALSE;
 284
 285   gdk_event_request_motions (event);
 286   update_color (plane, event->x, event->y);
 287
 288   return TRUE;
 289 }
 290
 291 static void
 292 hold_action (GtkPressAndHold *pah,
 293              gint             x,
 294              gint             y,
 295              GtkColorPlane   *plane)
 296 {
 297   gboolean handled;
 298
 299   g_signal_emit_by_name (plane, "popup-menu", &handled);
 300 }
 301
 302 static void
 303 tap_action (GtkPressAndHold *pah,
 304             gint             x,
 305             gint             y,
 306             GtkColorPlane   *plane)
 307 {
 308   update_color (plane, x, y);
 309 }
 310
 311 static gboolean
 312 plane_touch (GtkWidget     *widget,
 313              GdkEventTouch *event)
 314 {
 315   GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
 316
 317   if (!plane->priv->press_and_hold)
 318     {
 319       gint drag_threshold;
 320
 321       g_object_get (gtk_widget_get_settings (widget),
 322                     "gtk-dnd-drag-threshold", &drag_threshold,
 323                     NULL);
 324
 325       plane->priv->press_and_hold = gtk_press_and_hold_new ();
 326
 327       g_object_set (plane->priv->press_and_hold,
 328                     "drag-threshold", drag_threshold,
 329                     "hold-time", 1000,
 330                     NULL);
 331
 332       g_signal_connect (plane->priv->press_and_hold, "hold",
 333                         G_CALLBACK (hold_action), plane);
 334       g_signal_connect (plane->priv->press_and_hold, "tap",
 335                         G_CALLBACK (tap_action), plane);
 336     }
 337
 338   gtk_press_and_hold_process_event (plane->priv->press_and_hold, (GdkEvent *)event);
 339
 340   return TRUE;
 341 }
 342
 343 static void
 344 sv_move (GtkColorPlane *plane,
 345          gdouble        ds,
 346          gdouble        dv)
 347 {
 348   gdouble s, v;
 349
 350   s = gtk_adjustment_get_value (plane->priv->s_adj);
 351   v = gtk_adjustment_get_value (plane->priv->v_adj);
 352
 353   if (s + ds > 1)
 354     {
 355       if (s < 1)
 356         s = 1;
 357       else
 358         goto error;
 359     }
 360   else if (s + ds < 0)
 361     {
 362       if (s > 0)
 363         s = 0;
 364       else
 365         goto error;
 366     }
 367   else
 368     {
 369       s += ds;
 370     }
 371
 372   if (v + dv > 1)
 373     {
 374       if (v < 1)
 375         v = 1;
 376       else
 377         goto error;
 378     }
 379   else if (v + dv < 0)
 380     {
 381       if (v > 0)
 382         v = 0;
 383       else
 384         goto error;
 385     }
 386   else
 387     {
 388       v += dv;
 389     }
 390
 391   gtk_adjustment_set_value (plane->priv->s_adj, s);
 392   gtk_adjustment_set_value (plane->priv->v_adj, v);
 393   return;
 394
 395 error:
 396   gtk_widget_error_bell (GTK_WIDGET (plane));
 397 }
 398
 399 static gboolean
 400 plane_key_press (GtkWidget   *widget,
 401                  GdkEventKey *event)
 402 {
 403   GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
 404   gdouble step;
 405
 406   if ((event->state & GDK_MOD1_MASK) != 0)
 407     step = 0.1;
 408   else
 409     step = 0.01;
 410
 411   if (event->keyval == GDK_KEY_Up ||
 412       event->keyval == GDK_KEY_KP_Up)
 413     sv_move (plane, step, 0);
 414   else if (event->keyval == GDK_KEY_Down ||
 415            event->keyval == GDK_KEY_KP_Down)
 416     sv_move (plane, -step, 0);
 417   else if (event->keyval == GDK_KEY_Left ||
 418            event->keyval == GDK_KEY_KP_Left)
 419     sv_move (plane, 0, -step);
 420   else if (event->keyval == GDK_KEY_Right ||
 421            event->keyval == GDK_KEY_KP_Right)
 422     sv_move (plane, 0, step);
 423   else
 424     return GTK_WIDGET_CLASS (gtk_color_plane_parent_class)->key_press_event (widget, event);
 425
 426   return TRUE;
 427 }
 428
 429 static void
 430 gtk_color_plane_init (GtkColorPlane *plane)
 431 {
 432   AtkObject *atk_obj;
 433
 434   plane->priv = G_TYPE_INSTANCE_GET_PRIVATE (plane,
 435                                              GTK_TYPE_COLOR_PLANE,
 436                                              GtkColorPlanePrivate);
 437
 438   gtk_widget_set_can_focus (GTK_WIDGET (plane), TRUE);
 439   gtk_widget_set_events (GTK_WIDGET (plane), GDK_KEY_PRESS_MASK
 440                                              | GDK_BUTTON_PRESS_MASK
 441                                              | GDK_BUTTON_RELEASE_MASK
 442                                              | GDK_POINTER_MOTION_MASK);
 443
 444   atk_obj = gtk_widget_get_accessible (GTK_WIDGET (plane));
 445   if (GTK_IS_ACCESSIBLE (atk_obj))
 446     {
 447       atk_object_set_name (atk_obj, _("Color Plane"));
 448       atk_object_set_role (atk_obj, ATK_ROLE_COLOR_CHOOSER);
 449     }
 450 }
 451
 452 static void
 453 plane_finalize (GObject *object)
 454 {
 455   GtkColorPlane *plane = GTK_COLOR_PLANE (object);
 456
 457   if (plane->priv->surface)
 458     cairo_surface_destroy (plane->priv->surface);
 459
 460   g_clear_object (&plane->priv->h_adj);
 461   g_clear_object (&plane->priv->s_adj);
 462   g_clear_object (&plane->priv->v_adj);
 463
 464   g_clear_object (&plane->priv->press_and_hold);
 465
 466   G_OBJECT_CLASS (gtk_color_plane_parent_class)->finalize (object);
 467 }
 468
 469 static void
 470 gtk_color_plane_class_init (GtkColorPlaneClass *class)
 471 {
 472   GObjectClass *object_class = G_OBJECT_CLASS (class);
 473   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 474
 475   object_class->finalize = plane_finalize;
 476
 477   widget_class->draw = plane_draw;
 478   widget_class->configure_event = plane_configure;
 479   widget_class->button_press_event = plane_button_press;
 480   widget_class->button_release_event = plane_button_release;
 481   widget_class->motion_notify_event = plane_motion_notify;
 482   widget_class->grab_broken_event = plane_grab_broken;
 483   widget_class->key_press_event = plane_key_press;
 484   widget_class->touch_event= plane_touch;
 485
 486   g_type_class_add_private (class, sizeof (GtkColorPlanePrivate));
 487 }
 488
 489 GtkWidget *
 490 gtk_color_plane_new (GtkAdjustment *h_adj,
 491                      GtkAdjustment *s_adj,
 492                      GtkAdjustment *v_adj)
 493 {
 494   GtkColorPlane *plane;
 495
 496   plane = (GtkColorPlane *) g_object_new (GTK_TYPE_COLOR_PLANE, NULL);
 497
 498   plane->priv->h_adj = g_object_ref_sink (h_adj);
 499   plane->priv->s_adj = g_object_ref_sink (s_adj);
 500   plane->priv->v_adj = g_object_ref_sink (v_adj);
 501   g_signal_connect_swapped (h_adj, "value-changed", G_CALLBACK (h_changed), plane);
 502   g_signal_connect_swapped (s_adj, "value-changed", G_CALLBACK (sv_changed), plane);
 503   g_signal_connect_swapped (v_adj, "value-changed", G_CALLBACK (sv_changed), plane);
 504
 505   return (GtkWidget *)plane;
 506 }