adg/adg-widget.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010  Nicola Fontana <ntd at entidi.it>
   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., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 /**
  22  * SECTION:adg-widget
  23  * @short_description: A #GtkWidget specifically designed to contain
  24  *                     an #AdgCanvas entity
  25  *
  26  * This is a #GtkDrawingArea derived object that provides an easy way
  27  * to show an ADG based canvas. Its default implementation reacts to
  28  * some mouse events: if you drag the mouse by keepeng the wheel pressed
  29  * the canvas is translated by translating its local map; if the mouse
  30  * wheel is rotated, the local map of the canvas is scaled up or down
  31  * (accordling to the wheel direction) by a factor specified in the
  32  * #AdgWidget:factor property.
  33  **/
  34
  35 /**
  36  * AdgWidget:
  37  *
  38  * All fields are private and should not be used directly.
  39  * Use its public methods instead.
  40  **/
  41
  42
  43 #include "adg-internal.h"
  44 #include "adg-canvas.h"
  45 #include "adg-widget.h"
  46 #include "adg-widget-private.h"
  47 #include "adg-marshal.h"
  48
  49 #define PARENT_WIDGET_CLASS  ((GtkWidgetClass *) adg_widget_parent_class)
  50
  51
  52 enum {
  53     PROP_0,
  54     PROP_CANVAS,
  55     PROP_FACTOR
  56 };
  57
  58 enum {
  59     CANVAS_CHANGED,
  60     LAST_SIGNAL
  61 };
  62
  63
  64 static void             dispose                 (GObject         *object);
  65 static void             get_property            (GObject         *object,
  66                                                  guint            prop_id,
  67                                                  GValue          *value,
  68                                                  GParamSpec      *pspec);
  69 static void             set_property            (GObject         *object,
  70                                                  guint            prop_id,
  71                                                  const GValue    *value,
  72                                                  GParamSpec      *pspec);
  73 static void             set_canvas              (AdgWidget       *widget,
  74                                                  AdgCanvas       *canvas);
  75 static gboolean         expose_event            (GtkWidget       *widget,
  76                                                  GdkEventExpose  *event);
  77 static gboolean         scroll_event            (GtkWidget       *widget,
  78                                                  GdkEventScroll  *event);
  79 static gboolean         button_press_event      (GtkWidget       *widget,
  80                                                  GdkEventButton  *event);
  81 static gboolean         motion_notify_event     (GtkWidget       *widget,
  82                                                  GdkEventMotion  *event);
  83 static gboolean         get_local_map           (GtkWidget       *widget,
  84                                                  AdgMatrix       *map,
  85                                                  AdgMatrix       *inverted);
  86 static void             set_local_map           (GtkWidget       *widget,
  87                                                  const AdgMatrix *map);
  88
  89 static guint signals[LAST_SIGNAL] = { 0 };
  90
  91
  92 G_DEFINE_TYPE(AdgWidget, adg_widget, GTK_TYPE_DRAWING_AREA);
  93
  94
  95 static void
  96 adg_widget_class_init(AdgWidgetClass *klass)
  97 {
  98     GObjectClass *gobject_class;
  99     GtkWidgetClass *widget_class;
 100     GParamSpec *param;
 101
 102     gobject_class = (GObjectClass *) klass;
 103     widget_class = (GtkWidgetClass *) klass;
 104
 105     g_type_class_add_private(klass, sizeof(AdgWidgetPrivate));
 106
 107     gobject_class->dispose = dispose;
 108     gobject_class->get_property = get_property;
 109     gobject_class->set_property = set_property;
 110
 111     widget_class->expose_event = expose_event;
 112     widget_class->scroll_event = scroll_event;
 113     widget_class->button_press_event = button_press_event;
 114     widget_class->motion_notify_event = motion_notify_event;
 115
 116     param = g_param_spec_object("canvas",
 117                                 P_("Canvas"),
 118                                 P_("The canvas to be shown by this widget"),
 119                                 ADG_TYPE_CANVAS,
 120                                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
 121     g_object_class_install_property(gobject_class, PROP_CANVAS, param);
 122
 123     param = g_param_spec_double("factor",
 124                                 P_("Factor"),
 125                                 P_("The factor used in zooming in and out"),
 126                                 1., G_MAXDOUBLE, 1.05,
 127                                 G_PARAM_READWRITE);
 128     g_object_class_install_property(gobject_class, PROP_FACTOR, param);
 129
 130     /**
 131      * AdgWidget::canvas-changed:
 132      * @widget: an #AdgWidget
 133      *
 134      * Emitted when the widget has a new canvas.
 135      **/
 136     signals[CANVAS_CHANGED] = g_signal_new("canvas-changed", ADG_TYPE_WIDGET,
 137                                            G_SIGNAL_RUN_LAST|G_SIGNAL_NO_RECURSE,
 138                                            G_STRUCT_OFFSET(AdgWidgetClass, canvas_changed),
 139                                            NULL, NULL,
 140                                            adg_marshal_VOID__VOID,
 141                                            G_TYPE_NONE, 0);
 142 }
 143
 144 static void
 145 adg_widget_init(AdgWidget *widget)
 146 {
 147     AdgWidgetPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(widget,
 148                                                          ADG_TYPE_WIDGET,
 149                                                          AdgWidgetPrivate);
 150
 151     data->canvas = NULL;
 152     data->factor = 1.05;
 153     data->x_event = 0;
 154     data->y_event = 0;
 155
 156     widget->data = data;
 157
 158     /* Enable GDK events to catch wheel rotation and drag */
 159     gtk_widget_add_events((GtkWidget *) widget,
 160                           GDK_BUTTON_PRESS_MASK|
 161                           GDK_BUTTON2_MOTION_MASK|
 162                           GDK_SCROLL_MASK);
 163 }
 164
 165 static void
 166 dispose(GObject *object)
 167 {
 168     AdgWidgetPrivate *data = ((AdgWidget *) object)->data;
 169
 170     if (data->canvas != NULL) {
 171         g_object_unref(data->canvas);
 172         data->canvas = NULL;
 173     }
 174
 175     G_OBJECT_CLASS(adg_widget_parent_class)->dispose(object);
 176 }
 177
 178 static void
 179 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 180 {
 181     AdgWidgetPrivate *data = ((AdgWidget *) object)->data;
 182
 183     switch (prop_id) {
 184
 185     case PROP_CANVAS:
 186         g_value_set_object(value, data->canvas);
 187         break;
 188
 189     case PROP_FACTOR:
 190         g_value_set_double(value, data->factor);
 191         break;
 192
 193     default:
 194         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 195         break;
 196     }
 197 }
 198
 199 static void
 200 set_property(GObject *object,
 201              guint prop_id, const GValue *value, GParamSpec *pspec)
 202 {
 203     AdgWidget *widget;
 204     AdgWidgetPrivate *data;
 205
 206     widget = (AdgWidget *) object;
 207     data = widget->data;
 208
 209     switch (prop_id) {
 210
 211     case PROP_CANVAS:
 212         set_canvas(widget, g_value_get_object(value));
 213         break;
 214
 215     case PROP_FACTOR:
 216         data->factor = g_value_get_double(value);
 217         break;
 218
 219     default:
 220         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 221         break;
 222     }
 223 }
 224
 225
 226 /**
 227  * adg_widget_new:
 228  * @path: the #AdgPath to stroke
 229  *
 230  * Creates a new #AdgWidget.
 231  *
 232  * Returns: the newly created widget
 233  **/
 234 GtkWidget *
 235 adg_widget_new(AdgCanvas *canvas)
 236 {
 237     g_return_val_if_fail(ADG_IS_CANVAS(canvas), NULL);
 238
 239     return g_object_new(ADG_TYPE_WIDGET, "canvas", canvas, NULL);
 240 }
 241
 242
 243 /**
 244  * adg_widget_set_canvas:
 245  * @widget: an #AdgWidget
 246  * @canvas: the new #AdgCanvas
 247  *
 248  * Sets a new canvas on @widget. The old canvas, if presents, is
 249  * unreferenced.
 250  **/
 251 void
 252 adg_widget_set_canvas(AdgWidget *widget, AdgCanvas *canvas)
 253 {
 254     g_return_if_fail(ADG_IS_WIDGET(widget));
 255
 256     set_canvas(widget, canvas);
 257
 258     g_object_notify((GObject *) widget, "canvas");
 259 }
 260
 261 /**
 262  * adg_widget_get_canvas:
 263  * @widget: an #AdgWidget
 264  *
 265  * Gets the canvas associated to @widget.
 266  *
 267  * Returns: the requested #AdgCanvas object or %NULL on errors
 268  **/
 269 AdgCanvas *
 270 adg_widget_get_canvas(AdgWidget *widget)
 271 {
 272     AdgWidgetPrivate *data;
 273
 274     g_return_val_if_fail(ADG_IS_WIDGET(widget), NULL);
 275
 276     data = widget->data;
 277
 278     return data->canvas;
 279 }
 280
 281 /**
 282  * adg_widget_set_factor:
 283  * @widget: an #AdgWidget
 284  * @factor: the new zoom factor
 285  *
 286  * Sets a new zoom factor to @widget. If the factor is less than
 287  * 1, it will be clamped to 1.
 288  **/
 289 void
 290 adg_widget_set_factor(AdgWidget *widget, gdouble factor)
 291 {
 292     AdgWidgetPrivate *data;
 293
 294     g_return_if_fail(ADG_IS_WIDGET(widget));
 295
 296     data = widget->data;
 297     data->factor = CLAMP(factor, 1., G_MAXDOUBLE);
 298
 299     g_object_notify((GObject *) widget, "factor");
 300 }
 301
 302 /**
 303  * adg_widget_get_factor:
 304  * @widget: an #AdgWidget
 305  *
 306  * Gets the zoom factor associated to @widget. The zoom factor is
 307  * directly used to zoom in (that is, the default zoom factor of
 308  * 1.05 will zoom of 5% every iteration) and it is reversed while
 309  * zooming out (that is, the default factor will use 1/1.05).
 310  *
 311  * Returns: the requested zoom factor or 0 on error
 312  **/
 313 gdouble
 314 adg_widget_get_factor(AdgWidget *widget)
 315 {
 316     AdgWidgetPrivate *data;
 317
 318     g_return_val_if_fail(ADG_IS_WIDGET(widget), 0.);
 319
 320     data = widget->data;
 321
 322     return data->factor;
 323 }
 324
 325
 326 static void
 327 set_canvas(AdgWidget *widget, AdgCanvas *canvas)
 328 {
 329     AdgWidgetPrivate *data = widget->data;
 330
 331     if (data->canvas != NULL)
 332         g_object_unref(data->canvas);
 333
 334     data->canvas = canvas;
 335
 336     if (canvas != NULL)
 337         g_object_ref(data->canvas);
 338
 339     g_signal_emit(widget, signals[CANVAS_CHANGED], 0);
 340 }
 341
 342 static gboolean
 343 expose_event(GtkWidget *widget, GdkEventExpose *event)
 344 {
 345     AdgWidgetPrivate *data;
 346     AdgCanvas *canvas;
 347
 348     data = ((AdgWidget *) widget)->data;
 349     canvas = data->canvas;
 350
 351     if (canvas != NULL) {
 352         cairo_t *cr = gdk_cairo_create(widget->window);
 353         adg_entity_render((AdgEntity *) canvas, cr);
 354         cairo_destroy(cr);
 355     }
 356
 357     if (PARENT_WIDGET_CLASS->expose_event == NULL)
 358         return FALSE;
 359
 360     return PARENT_WIDGET_CLASS->expose_event(widget, event);
 361 }
 362
 363 static gboolean
 364 scroll_event(GtkWidget *widget, GdkEventScroll *event)
 365 {
 366     AdgWidgetPrivate *data;
 367     AdgMatrix map, inverted;
 368
 369     data = ((AdgWidget *) widget)->data;
 370
 371     if ((event->direction == GDK_SCROLL_UP ||
 372          event->direction == GDK_SCROLL_DOWN) &&
 373         get_local_map(widget, &map, &inverted)) {
 374         double factor, x, y;
 375
 376         if (event->direction == GDK_SCROLL_UP) {
 377             factor = data->factor;
 378         } else {
 379             factor = 1. / data->factor;
 380         }
 381
 382         x = event->x;
 383         y = event->y;
 384
 385         cairo_matrix_transform_point(&inverted, &x, &y);
 386
 387         cairo_matrix_scale(&map, factor, factor);
 388         cairo_matrix_translate(&map, x/factor - x, y/factor - y);
 389
 390         set_local_map(widget, &map);
 391
 392         gtk_widget_queue_draw(widget);
 393     }
 394
 395     if (PARENT_WIDGET_CLASS->scroll_event == NULL)
 396         return FALSE;
 397
 398     return PARENT_WIDGET_CLASS->scroll_event(widget, event);
 399 }
 400
 401 static gboolean
 402 button_press_event(GtkWidget *widget, GdkEventButton *event)
 403 {
 404     AdgWidgetPrivate *data = ((AdgWidget *) widget)->data;
 405
 406     if (event->type == GDK_BUTTON_PRESS && event->button == 2) {
 407         data->x_event = event->x;
 408         data->y_event = event->y;
 409     }
 410
 411     if (PARENT_WIDGET_CLASS->button_press_event == NULL)
 412         return FALSE;
 413
 414     return PARENT_WIDGET_CLASS->button_press_event(widget, event);
 415 }
 416
 417 static gboolean
 418 motion_notify_event(GtkWidget *widget, GdkEventMotion *event)
 419 {
 420     AdgWidgetPrivate *data;
 421     AdgMatrix map, inverted;
 422
 423     data = ((AdgWidget *) widget)->data;
 424
 425     if ((event->state & GDK_BUTTON2_MASK) > 0 &&
 426         get_local_map(widget, &map, &inverted)) {
 427         double x, y;
 428
 429         x = event->x - data->x_event;
 430         y = event->y - data->y_event;
 431
 432         cairo_matrix_transform_distance(&inverted, &x, &y);
 433         cairo_matrix_translate(&map, x, y);
 434         data->x_event = event->x;
 435         data->y_event = event->y;
 436
 437         set_local_map(widget, &map);
 438
 439         gtk_widget_queue_draw(widget);
 440     }
 441
 442     if (PARENT_WIDGET_CLASS->motion_notify_event == NULL)
 443         return FALSE;
 444
 445     return PARENT_WIDGET_CLASS->motion_notify_event(widget, event);
 446 }
 447
 448 static gboolean
 449 get_local_map(GtkWidget *widget, AdgMatrix *map, AdgMatrix *inverted)
 450 {
 451     AdgWidgetPrivate *data;
 452     AdgCanvas *canvas;
 453
 454     data = ((AdgWidget *) widget)->data;
 455     canvas = data->canvas;
 456     if (canvas == NULL)
 457         return FALSE;
 458
 459     adg_matrix_copy(map, adg_entity_get_local_map((AdgEntity *) canvas));
 460     adg_matrix_copy(inverted, map);
 461
 462     return cairo_matrix_invert(inverted) == CAIRO_STATUS_SUCCESS;
 463 }
 464
 465 static void
 466 set_local_map(GtkWidget *widget, const AdgMatrix *map)
 467 {
 468     AdgWidgetPrivate *data;
 469     AdgCanvas *canvas;
 470
 471     data = ((AdgWidget *) widget)->data;
 472     canvas = data->canvas;
 473
 474     if (canvas != NULL)
 475         adg_entity_set_local_map((AdgEntity *) canvas, map);
 476 }