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 "gtkintl.h"
  26
  27 struct _GtkColorPlanePrivate
  28 {
  29   GtkAdjustment *h_adj;
  30   GtkAdjustment *s_adj;
  31   GtkAdjustment *v_adj;
  32
  33   cairo_surface_t *surface;
  34   gboolean in_drag;
  35 };
  36
  37 G_DEFINE_TYPE (GtkColorPlane, gtk_color_plane, GTK_TYPE_DRAWING_AREA)
  38
  39 static void
  40 sv_to_xy (GtkColorPlane *plane,
  41           gint          *x,
  42           gint          *y)
  43 {
  44   gdouble s, v;
  45   gint width, height;
  46
  47   width = gtk_widget_get_allocated_width (GTK_WIDGET (plane));
  48   height = gtk_widget_get_allocated_height (GTK_WIDGET (plane));
  49
  50   s = gtk_adjustment_get_value (plane->priv->s_adj);
  51   v = gtk_adjustment_get_value (plane->priv->v_adj);
  52
  53   *x = CLAMP (width * v, 0, width - 1);
  54   *y = CLAMP (height * (1 - s), 0, height - 1);
  55 }
  56
  57 static gboolean
  58 plane_draw (GtkWidget *widget,
  59             cairo_t   *cr)
  60 {
  61   GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
  62   gint x, y;
  63   gint width, height;
  64
  65   cairo_set_source_surface (cr, plane->priv->surface, 0, 0);
  66   cairo_paint (cr);
  67
  68   sv_to_xy (plane, &x, &y);
  69   width = gtk_widget_get_allocated_width (widget);
  70   height = gtk_widget_get_allocated_height (widget);
  71
  72   cairo_move_to (cr, 0,     y + 0.5);
  73   cairo_line_to (cr, width, y + 0.5);
  74
  75   cairo_move_to (cr, x + 0.5, 0);
  76   cairo_line_to (cr, x + 0.5, height);
  77
  78   if (gtk_widget_has_visible_focus (widget))
  79     {
  80       cairo_set_line_width (cr, 3.0);
  81       cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.6);
  82       cairo_stroke_preserve (cr);
  83
  84       cairo_set_line_width (cr, 1.0);
  85       cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.8);
  86       cairo_stroke (cr);
  87     }
  88   else
  89     {
  90       cairo_set_line_width (cr, 1.0);
  91       cairo_set_source_rgba (cr, 0.8, 0.8, 0.8, 0.8);
  92       cairo_stroke (cr);
  93     }
  94
  95   return FALSE;
  96 }
  97
  98 static void
  99 create_surface (GtkColorPlane *plane)
 100 {
 101   GtkWidget *widget = GTK_WIDGET (plane);
 102   cairo_t *cr;
 103   cairo_surface_t *surface;
 104   gint width, height, stride;
 105   cairo_surface_t *tmp;
 106   guint red, green, blue;
 107   guint32 *data, *p;
 108   gdouble h, s, v;
 109   gdouble r, g, b;
 110   gdouble sf, vf;
 111   gint x, y;
 112
 113   if (!gtk_widget_get_realized (widget))
 114     return;
 115
 116   width = gtk_widget_get_allocated_width (widget);
 117   height = gtk_widget_get_allocated_height (widget);
 118
 119   surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget),
 120                                                CAIRO_CONTENT_COLOR,
 121                                                width, height);
 122
 123   if (plane->priv->surface)
 124     cairo_surface_destroy (plane->priv->surface);
 125   plane->priv->surface = surface;
 126
 127   if (width == 1 || height == 1)
 128     return;
 129
 130   stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, width);
 131
 132   data = g_malloc (height * stride);
 133
 134   h = gtk_adjustment_get_value (plane->priv->h_adj);
 135   sf = 1.0 / (height - 1);
 136   vf = 1.0 / (width - 1);
 137   for (y = 0; y < height; y++)
 138     {
 139       s = CLAMP (1.0 - y * sf, 0.0, 1.0);
 140       p = data + y * (stride / 4);
 141       for (x = 0; x < width; x++)
 142         {
 143           v = x * vf;
 144           gtk_hsv_to_rgb (h, s, v, &r, &g, &b);
 145           red = CLAMP (r * 255, 0, 255);
 146           green = CLAMP (g * 255, 0, 255);
 147           blue = CLAMP (b * 255, 0, 255);
 148           p[x] = (red << 16) | (green << 8) | blue;
 149         }
 150     }
 151
 152   tmp = cairo_image_surface_create_for_data ((guchar *)data, CAIRO_FORMAT_RGB24,
 153                                              width, height, stride);
 154   cr = cairo_create (surface);
 155
 156   cairo_set_source_surface (cr, tmp, 0, 0);
 157   cairo_paint (cr);
 158
 159   cairo_destroy (cr);
 160   cairo_surface_destroy (tmp);
 161   g_free (data);
 162 }
 163
 164 static gboolean
 165 plane_configure (GtkWidget         *widget,
 166                  GdkEventConfigure *event)
 167 {
 168   create_surface (GTK_COLOR_PLANE (widget));
 169   return TRUE;
 170 }
 171
 172 static void
 173 set_cross_grab (GtkWidget *widget,
 174                 GdkDevice *device,
 175                 guint32    time)
 176 {
 177   GdkCursor *cursor;
 178
 179   cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (widget)),
 180                                        GDK_CROSSHAIR);
 181   gdk_device_grab (device,
 182                    gtk_widget_get_window (widget),
 183                    GDK_OWNERSHIP_NONE,
 184                    FALSE,
 185                    GDK_POINTER_MOTION_MASK
 186                     | GDK_POINTER_MOTION_HINT_MASK
 187                     | GDK_BUTTON_RELEASE_MASK,
 188                    cursor,
 189                    time);
 190   g_object_unref (cursor);
 191 }
 192
 193 static gboolean
 194 plane_grab_broken (GtkWidget          *widget,
 195                    GdkEventGrabBroken *event)
 196 {
 197   GTK_COLOR_PLANE (widget)->priv->in_drag = FALSE;
 198   return TRUE;
 199 }
 200
 201 static void
 202 h_changed (GtkColorPlane *plane)
 203 {
 204   create_surface (plane);
 205   gtk_widget_queue_draw (GTK_WIDGET (plane));
 206 }
 207
 208 static void
 209 sv_changed (GtkColorPlane *plane)
 210 {
 211   gtk_widget_queue_draw (GTK_WIDGET (plane));
 212 }
 213
 214 static void
 215 update_color (GtkColorPlane *plane,
 216               gint           x,
 217               gint           y)
 218 {
 219   GtkWidget *widget = GTK_WIDGET (plane);
 220   gdouble s, v;
 221
 222   s = CLAMP (1 - y * (1.0 / gtk_widget_get_allocated_height (widget)), 0, 1);
 223   v = CLAMP (x * (1.0 / gtk_widget_get_allocated_width (widget)), 0, 1);
 224   gtk_adjustment_set_value (plane->priv->s_adj, s);
 225   gtk_adjustment_set_value (plane->priv->v_adj, v);
 226
 227   gtk_widget_queue_draw (widget);
 228 }
 229
 230 static gboolean
 231 plane_button_press (GtkWidget      *widget,
 232                     GdkEventButton *event)
 233 {
 234   GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
 235
 236   if (event->button == GDK_BUTTON_SECONDARY)
 237     {
 238       gboolean handled;
 239
 240       g_signal_emit_by_name (widget, "popup-menu", &handled);
 241
 242       return TRUE;
 243     }
 244
 245   if (plane->priv->in_drag || event->button != GDK_BUTTON_PRIMARY)
 246     return FALSE;
 247
 248   plane->priv->in_drag = TRUE;
 249   set_cross_grab (widget, gdk_event_get_device ((GdkEvent*)event), event->time);
 250   update_color (plane, event->x, event->y);
 251   gtk_widget_grab_focus (widget);
 252
 253   return TRUE;
 254 }
 255
 256 static gboolean
 257 plane_button_release (GtkWidget      *widget,
 258                       GdkEventButton *event)
 259 {
 260   GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
 261
 262   if (!plane->priv->in_drag || event->button != GDK_BUTTON_PRIMARY)
 263     return FALSE;
 264
 265   plane->priv->in_drag = FALSE;
 266
 267   update_color (plane, event->x, event->y);
 268   gdk_device_ungrab (gdk_event_get_device ((GdkEvent *) event), event->time);
 269
 270   return TRUE;
 271 }
 272
 273 static gboolean
 274 plane_motion_notify (GtkWidget      *widget,
 275                      GdkEventMotion *event)
 276 {
 277   GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
 278
 279   if (!plane->priv->in_drag)
 280     return FALSE;
 281
 282   gdk_event_request_motions (event);
 283   update_color (plane, event->x, event->y);
 284
 285   return TRUE;
 286 }
 287
 288 static void
 289 sv_move (GtkColorPlane *plane,
 290          gdouble        ds,
 291          gdouble        dv)
 292 {
 293   gdouble s, v;
 294
 295   s = gtk_adjustment_get_value (plane->priv->s_adj);
 296   v = gtk_adjustment_get_value (plane->priv->v_adj);
 297
 298   if (s + ds > 1)
 299     {
 300       if (s < 1)
 301         s = 1;
 302       else
 303         goto error;
 304     }
 305   else if (s + ds < 0)
 306     {
 307       if (s > 0)
 308         s = 0;
 309       else
 310         goto error;
 311     }
 312   else
 313     {
 314       s += ds;
 315     }
 316
 317   if (v + dv > 1)
 318     {
 319       if (v < 1)
 320         v = 1;
 321       else
 322         goto error;
 323     }
 324   else if (v + dv < 0)
 325     {
 326       if (v > 0)
 327         v = 0;
 328       else
 329         goto error;
 330     }
 331   else
 332     {
 333       v += dv;
 334     }
 335
 336   gtk_adjustment_set_value (plane->priv->s_adj, s);
 337   gtk_adjustment_set_value (plane->priv->v_adj, v);
 338   return;
 339
 340 error:
 341   gtk_widget_error_bell (GTK_WIDGET (plane));
 342 }
 343
 344 static gboolean
 345 plane_key_press (GtkWidget   *widget,
 346                  GdkEventKey *event)
 347 {
 348   GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
 349   gdouble step;
 350
 351   if ((event->state & GDK_MOD1_MASK) != 0)
 352     step = 0.1;
 353   else
 354     step = 0.01;
 355
 356   if (event->keyval == GDK_KEY_Up ||
 357       event->keyval == GDK_KEY_KP_Up)
 358     sv_move (plane, step, 0);
 359   else if (event->keyval == GDK_KEY_Down ||
 360            event->keyval == GDK_KEY_KP_Down)
 361     sv_move (plane, -step, 0);
 362   else if (event->keyval == GDK_KEY_Left ||
 363            event->keyval == GDK_KEY_KP_Left)
 364     sv_move (plane, 0, -step);
 365   else if (event->keyval == GDK_KEY_Right ||
 366            event->keyval == GDK_KEY_KP_Right)
 367     sv_move (plane, 0, step);
 368   else
 369     return GTK_WIDGET_CLASS (gtk_color_plane_parent_class)->key_press_event (widget, event);
 370
 371   return TRUE;
 372 }
 373
 374 static void
 375 gtk_color_plane_init (GtkColorPlane *plane)
 376 {
 377   AtkObject *atk_obj;
 378
 379   plane->priv = G_TYPE_INSTANCE_GET_PRIVATE (plane,
 380                                              GTK_TYPE_COLOR_PLANE,
 381                                              GtkColorPlanePrivate);
 382
 383   gtk_widget_set_can_focus (GTK_WIDGET (plane), TRUE);
 384   gtk_widget_set_events (GTK_WIDGET (plane), GDK_KEY_PRESS_MASK
 385                                              | GDK_BUTTON_PRESS_MASK
 386                                              | GDK_BUTTON_RELEASE_MASK
 387                                              | GDK_POINTER_MOTION_MASK);
 388
 389   atk_obj = gtk_widget_get_accessible (GTK_WIDGET (plane));
 390   if (GTK_IS_ACCESSIBLE (atk_obj))
 391     {
 392       atk_object_set_name (atk_obj, _("Color Plane"));
 393       atk_object_set_role (atk_obj, ATK_ROLE_COLOR_CHOOSER);
 394     }
 395 }
 396
 397 static void
 398 plane_finalize (GObject *object)
 399 {
 400   GtkColorPlane *plane = GTK_COLOR_PLANE (object);
 401
 402   if (plane->priv->surface)
 403     cairo_surface_destroy (plane->priv->surface);
 404
 405   g_clear_object (&plane->priv->h_adj);
 406   g_clear_object (&plane->priv->s_adj);
 407   g_clear_object (&plane->priv->v_adj);
 408
 409   G_OBJECT_CLASS (gtk_color_plane_parent_class)->finalize (object);
 410 }
 411
 412 static void
 413 gtk_color_plane_class_init (GtkColorPlaneClass *class)
 414 {
 415   GObjectClass *object_class = G_OBJECT_CLASS (class);
 416   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 417
 418   object_class->finalize = plane_finalize;
 419
 420   widget_class->draw = plane_draw;
 421   widget_class->configure_event = plane_configure;
 422   widget_class->button_press_event = plane_button_press;
 423   widget_class->button_release_event = plane_button_release;
 424   widget_class->motion_notify_event = plane_motion_notify;
 425   widget_class->grab_broken_event = plane_grab_broken;
 426   widget_class->key_press_event = plane_key_press;
 427
 428   g_type_class_add_private (class, sizeof (GtkColorPlanePrivate));
 429 }
 430
 431 GtkWidget *
 432 gtk_color_plane_new (GtkAdjustment *h_adj,
 433                      GtkAdjustment *s_adj,
 434                      GtkAdjustment *v_adj)
 435 {
 436   GtkColorPlane *plane;
 437
 438   plane = (GtkColorPlane *) g_object_new (GTK_TYPE_COLOR_PLANE, NULL);
 439
 440   plane->priv->h_adj = g_object_ref_sink (h_adj);
 441   plane->priv->s_adj = g_object_ref_sink (s_adj);
 442   plane->priv->v_adj = g_object_ref_sink (v_adj);
 443   g_signal_connect_swapped (h_adj, "value-changed", G_CALLBACK (h_changed), plane);
 444   g_signal_connect_swapped (s_adj, "value-changed", G_CALLBACK (sv_changed), plane);
 445   g_signal_connect_swapped (v_adj, "value-changed", G_CALLBACK (sv_changed), plane);
 446
 447   return (GtkWidget *)plane;
 448 }