src/widgets/gradient-image.cpp

   1 #define __SP_GRADIENT_IMAGE_C__
   2
   3 /*
   4  * A simple gradient preview
   5  *
   6  * Author:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *
   9  * Copyright (C) 2001-2002 Lauris Kaplinski
  10  * Copyright (C) 2001 Ximian, Inc.
  11  *
  12  * Released under GNU GPL, read the file 'COPYING' for more information
  13  */
  14
  15 #include <libnr/nr-pixblock-pattern.h>
  16 #include "macros.h"
  17 #include "../display/nr-plain-stuff.h"
  18 #include "../display/nr-plain-stuff-gdk.h"
  19 #include "gradient-image.h"
  20 #include "sp-gradient.h"
  21 #include "sp-gradient-fns.h"
  22
  23 #include <sigc++/functors/ptr_fun.h>
  24 #include <sigc++/adaptors/bind.h>
  25
  26 #define VBLOCK 16
  27
  28 static void sp_gradient_image_class_init (SPGradientImageClass *klass);
  29 static void sp_gradient_image_init (SPGradientImage *image);
  30 static void sp_gradient_image_destroy (GtkObject *object);
  31
  32 static void sp_gradient_image_realize (GtkWidget *widget);
  33 static void sp_gradient_image_unrealize (GtkWidget *widget);
  34 static void sp_gradient_image_size_request (GtkWidget *widget, GtkRequisition *requisition);
  35 static void sp_gradient_image_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
  36 static gint sp_gradient_image_expose (GtkWidget *widget, GdkEventExpose *event);
  37
  38 static void sp_gradient_image_gradient_release (SPObject *, SPGradientImage *im);
  39 static void sp_gradient_image_gradient_modified (SPObject *, guint flags, SPGradientImage *im);
  40 static void sp_gradient_image_update (SPGradientImage *img);
  41
  42 static GtkWidgetClass *parent_class;
  43
  44 GtkType
  45 sp_gradient_image_get_type (void)
  46 {
  47     //TODO: switch to GObject
  48     // GtkType and such calls were deprecated a while back with the
  49     // introduction of GObject as a separate layer, with GType instead. --JonCruz
  50
  51         static GtkType type = 0;
  52         if (!type) {
  53                 GtkTypeInfo info = {
  54                         (gchar*) "SPGradientImage",
  55                         sizeof (SPGradientImage),
  56                         sizeof (SPGradientImageClass),
  57                         (GtkClassInitFunc) sp_gradient_image_class_init,
  58                         (GtkObjectInitFunc) sp_gradient_image_init,
  59                         NULL, NULL, NULL
  60                 };
  61                 type = gtk_type_unique (GTK_TYPE_WIDGET, &info);
  62         }
  63         return type;
  64 }
  65
  66 static void
  67 sp_gradient_image_class_init (SPGradientImageClass *klass)
  68 {
  69         GtkObjectClass *object_class;
  70         GtkWidgetClass *widget_class;
  71
  72         object_class = (GtkObjectClass *) klass;
  73         widget_class = (GtkWidgetClass *) klass;
  74
  75         parent_class = (GtkWidgetClass*)gtk_type_class (GTK_TYPE_WIDGET);
  76
  77         object_class->destroy = sp_gradient_image_destroy;
  78
  79         widget_class->realize = sp_gradient_image_realize;
  80         widget_class->unrealize = sp_gradient_image_unrealize;
  81         widget_class->size_request = sp_gradient_image_size_request;
  82         widget_class->size_allocate = sp_gradient_image_size_allocate;
  83         widget_class->expose_event = sp_gradient_image_expose;
  84 }
  85
  86 static void
  87 sp_gradient_image_init (SPGradientImage *image)
  88 {
  89         GTK_WIDGET_SET_FLAGS (image, GTK_NO_WINDOW);
  90
  91         image->gradient = NULL;
  92         image->px = NULL;
  93
  94         new (&image->release_connection) sigc::connection();
  95         new (&image->modified_connection) sigc::connection();
  96 }
  97
  98 static void
  99 sp_gradient_image_destroy (GtkObject *object)
 100 {
 101         SPGradientImage *image;
 102
 103         image = SP_GRADIENT_IMAGE (object);
 104
 105         if (image->gradient) {
 106                 image->release_connection.disconnect();
 107                 image->modified_connection.disconnect();
 108                 image->gradient = NULL;
 109         }
 110
 111         image->release_connection.~connection();
 112         image->modified_connection.~connection();
 113
 114         if (((GtkObjectClass *) (parent_class))->destroy)
 115                 (* ((GtkObjectClass *) (parent_class))->destroy) (object);
 116 }
 117
 118 static void
 119 sp_gradient_image_realize (GtkWidget *widget)
 120 {
 121         SPGradientImage *image;
 122
 123         image = SP_GRADIENT_IMAGE (widget);
 124
 125         if (((GtkWidgetClass *) parent_class)->realize)
 126                 (* ((GtkWidgetClass *) parent_class)->realize) (widget);
 127
 128         g_assert (!image->px);
 129         image->px = g_new (guchar, 3 * VBLOCK * widget->allocation.width);
 130         sp_gradient_image_update (image);
 131 }
 132
 133 static void
 134 sp_gradient_image_unrealize (GtkWidget *widget)
 135 {
 136         SPGradientImage *image;
 137
 138         image = SP_GRADIENT_IMAGE (widget);
 139
 140         if (((GtkWidgetClass *) parent_class)->unrealize)
 141                 (* ((GtkWidgetClass *) parent_class)->unrealize) (widget);
 142
 143         g_assert (image->px);
 144         g_free (image->px);
 145         image->px = NULL;
 146 }
 147
 148 static void
 149 sp_gradient_image_size_request (GtkWidget *widget, GtkRequisition *requisition)
 150 {
 151         SPGradientImage *slider;
 152
 153         slider = SP_GRADIENT_IMAGE (widget);
 154
 155         requisition->width = 64;
 156         requisition->height = 12;
 157 }
 158
 159 static void
 160 sp_gradient_image_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 161 {
 162         SPGradientImage *image;
 163
 164         image = SP_GRADIENT_IMAGE (widget);
 165
 166         widget->allocation = *allocation;
 167
 168         if (GTK_WIDGET_REALIZED (widget)) {
 169                 g_free (image->px);
 170                 image->px = g_new (guchar, 3 * VBLOCK * allocation->width);
 171         }
 172
 173         sp_gradient_image_update (image);
 174 }
 175
 176 static gint
 177 sp_gradient_image_expose (GtkWidget *widget, GdkEventExpose *event)
 178 {
 179         SPGradientImage *image;
 180
 181         image = SP_GRADIENT_IMAGE (widget);
 182
 183         if (GTK_WIDGET_DRAWABLE (widget)) {
 184                 gint x0, y0, x1, y1;
 185                 x0 = MAX (event->area.x, widget->allocation.x);
 186                 y0 = MAX (event->area.y, widget->allocation.y);
 187                 x1 = MIN (event->area.x + event->area.width, widget->allocation.x + widget->allocation.width);
 188                 y1 = MIN (event->area.y + event->area.height, widget->allocation.y + widget->allocation.height);
 189                 if ((x1 > x0) && (y1 > y0)) {
 190                         if (image->px) {
 191                                 if (image->gradient) {
 192                                         gint y;
 193                                         guchar *p;
 194                                         p = image->px + 3 * (x0 - widget->allocation.x);
 195                                         for (y = y0; y < y1; y += VBLOCK) {
 196                                                 gdk_draw_rgb_image (widget->window, widget->style->black_gc,
 197                                                                     x0, y,
 198                                                                     (x1 - x0), MIN (VBLOCK, y1 - y),
 199                                                                     GDK_RGB_DITHER_MAX,
 200                                                                     p, widget->allocation.width * 3);
 201                                         }
 202                                 } else {
 203                                         nr_gdk_draw_gray_garbage (widget->window, widget->style->black_gc,
 204                                                                   x0, y0,
 205                                                                   x1 - x0, y1 - y0);
 206                                 }
 207                         } else {
 208                                 gdk_draw_rectangle (widget->window, widget->style->black_gc,
 209                                                     x0, y0,
 210                                                     (x1 - x0), (y1 - x0),
 211                                                     TRUE);
 212                         }
 213                 }
 214         }
 215
 216         return TRUE;
 217 }
 218
 219 GtkWidget *
 220 sp_gradient_image_new (SPGradient *gradient)
 221 {
 222         SPGradientImage *image;
 223
 224         image = (SPGradientImage*)gtk_type_new (SP_TYPE_GRADIENT_IMAGE);
 225
 226         sp_gradient_image_set_gradient (image, gradient);
 227
 228         return (GtkWidget *) image;
 229 }
 230
 231 void
 232 sp_gradient_image_set_gradient (SPGradientImage *image, SPGradient *gradient)
 233 {
 234         if (image->gradient) {
 235                 image->release_connection.disconnect();
 236                 image->modified_connection.disconnect();
 237         }
 238
 239         image->gradient = gradient;
 240
 241         if (gradient) {
 242                 image->release_connection = gradient->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gradient_image_gradient_release), image));
 243                 image->modified_connection = gradient->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_gradient_image_gradient_modified), image));
 244         }
 245
 246         sp_gradient_image_update (image);
 247 }
 248
 249 static void
 250 sp_gradient_image_gradient_release (SPObject *, SPGradientImage *image)
 251 {
 252         if (image->gradient) {
 253                 image->release_connection.disconnect();
 254                 image->modified_connection.disconnect();
 255         }
 256
 257         image->gradient = NULL;
 258
 259         sp_gradient_image_update (image);
 260 }
 261
 262 static void
 263 sp_gradient_image_gradient_modified (SPObject *, guint /*flags*/, SPGradientImage *image)
 264 {
 265         sp_gradient_image_update (image);
 266 }
 267
 268 static void
 269 sp_gradient_image_update (SPGradientImage *image)
 270 {
 271         GtkAllocation *allocation;
 272
 273         if (!image->px) return;
 274
 275         allocation = &((GtkWidget *) image)->allocation;
 276
 277         if (image->gradient) {
 278                 nr_render_checkerboard_rgb (image->px, allocation->width, VBLOCK, 3 * allocation->width, 0, 0);
 279                 sp_gradient_render_vector_block_rgb (image->gradient,
 280                                                      image->px, allocation->width, VBLOCK, 3 * allocation->width,
 281                                                      0, allocation->width, TRUE);
 282         } else {
 283                 NRPixBlock pb;
 284                 nr_pixblock_setup_extern (&pb, NR_PIXBLOCK_MODE_R8G8B8,
 285                                           0, 0, allocation->width, VBLOCK,
 286                                           image->px, 3 * allocation->width, TRUE, FALSE);
 287                 nr_pixblock_render_gray_noise (&pb, NULL);
 288                 nr_pixblock_release (&pb);
 289         }
 290
 291         if (GTK_WIDGET_DRAWABLE (image)) {
 292                 gtk_widget_queue_draw (GTK_WIDGET (image));
 293         }
 294 }