adg/adg-widget.c

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