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