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  * @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-widget.h"
  44 #include "adg-widget-private.h"
  45 #include "adg-marshal.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_local_map           (GtkWidget       *widget,
  81                                                  AdgMatrix       *map,
  82                                                  AdgMatrix       *inverted);
  83 static void             set_local_map           (GtkWidget       *widget,
  84                                                  const AdgMatrix *map);
  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_READWRITE | G_PARAM_CONSTRUCT);
 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_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                                            adg_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_BUTTON_PRESS_MASK|
 158                           GDK_BUTTON2_MOTION_MASK|
 159                           GDK_SCROLL_MASK);
 160 }
 161
 162 static void
 163 dispose(GObject *object)
 164 {
 165     AdgWidgetPrivate *data = ((AdgWidget *) object)->data;
 166
 167     if (data->canvas != NULL) {
 168         g_object_unref(data->canvas);
 169         data->canvas = NULL;
 170     }
 171
 172     G_OBJECT_CLASS(adg_widget_parent_class)->dispose(object);
 173 }
 174
 175 static void
 176 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 177 {
 178     AdgWidgetPrivate *data = ((AdgWidget *) object)->data;
 179
 180     switch (prop_id) {
 181
 182     case PROP_CANVAS:
 183         g_value_set_object(value, data->canvas);
 184         break;
 185
 186     case PROP_FACTOR:
 187         g_value_set_double(value, data->factor);
 188         break;
 189
 190     default:
 191         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 192         break;
 193     }
 194 }
 195
 196 static void
 197 set_property(GObject *object,
 198              guint prop_id, const GValue *value, GParamSpec *pspec)
 199 {
 200     AdgWidget *widget;
 201     AdgWidgetPrivate *data;
 202
 203     widget = (AdgWidget *) object;
 204     data = widget->data;
 205
 206     switch (prop_id) {
 207
 208     case PROP_CANVAS:
 209         set_canvas(widget, g_value_get_object(value));
 210         break;
 211
 212     case PROP_FACTOR:
 213         data->factor = g_value_get_double(value);
 214         break;
 215
 216     default:
 217         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 218         break;
 219     }
 220 }
 221
 222
 223 /**
 224  * adg_widget_new:
 225  * @path: the #AdgPath to stroke
 226  *
 227  * Creates a new #AdgWidget.
 228  *
 229  * Returns: the newly created widget
 230  **/
 231 GtkWidget *
 232 adg_widget_new(AdgCanvas *canvas)
 233 {
 234     g_return_val_if_fail(ADG_IS_CANVAS(canvas), NULL);
 235
 236     return g_object_new(ADG_TYPE_WIDGET, "canvas", canvas, NULL);
 237 }
 238
 239
 240 /**
 241  * adg_widget_get_canvas:
 242  * @widget: an #AdgWidget
 243  *
 244  * Gets the canvas associated to @widget.
 245  *
 246  * Returns: the requested #AdgCanvas object or %NULL on errors
 247  **/
 248 AdgCanvas *
 249 adg_widget_get_canvas(AdgWidget *widget)
 250 {
 251     AdgWidgetPrivate *data;
 252
 253     g_return_val_if_fail(ADG_IS_WIDGET(widget), NULL);
 254
 255     data = widget->data;
 256
 257     return data->canvas;
 258 }
 259
 260 /**
 261  * adg_widget_set_canvas:
 262  * @widget: an #AdgWidget
 263  * @canvas: the new #AdgCanvas
 264  *
 265  * Sets a new canvas on @widget. The old canvas, if presents, is
 266  * unreferenced.
 267  **/
 268 void
 269 adg_widget_set_canvas(AdgWidget *widget, AdgCanvas *canvas)
 270 {
 271     g_return_if_fail(ADG_IS_WIDGET(widget));
 272
 273     set_canvas(widget, canvas);
 274
 275     g_object_notify((GObject *) widget, "canvas");
 276 }
 277
 278 /**
 279  * adg_widget_get_factor:
 280  * @widget: an #AdgWidget
 281  *
 282  * Gets the zoom factor associated to @widget. The zoom factor is
 283  * directly used to zoom in (that is, the default zoom factor of
 284  * 1.05 will zoom of 5% every iteration) and it is reversed while
 285  * zooming out (that is, the default factor will use 1/1.05).
 286  *
 287  * Returns: the requested zoom factor or 0 on error
 288  **/
 289 gdouble
 290 adg_widget_get_factor(AdgWidget *widget)
 291 {
 292     AdgWidgetPrivate *data;
 293
 294     g_return_val_if_fail(ADG_IS_WIDGET(widget), 0.);
 295
 296     data = widget->data;
 297
 298     return data->factor;
 299 }
 300
 301 /**
 302  * adg_widget_set_factor:
 303  * @widget: an #AdgWidget
 304  * @factor: the new zoom factor
 305  *
 306  * Sets a new zoom factor to @widget. If the factor is less than
 307  * 1, it will be clamped to 1.
 308  **/
 309 void
 310 adg_widget_set_factor(AdgWidget *widget, gdouble factor)
 311 {
 312     AdgWidgetPrivate *data;
 313
 314     g_return_if_fail(ADG_IS_WIDGET(widget));
 315
 316     data = widget->data;
 317     data->factor = CLAMP(factor, 1., G_MAXDOUBLE);
 318
 319     g_object_notify((GObject *) widget, "factor");
 320 }
 321
 322
 323 static void
 324 set_canvas(AdgWidget *widget, AdgCanvas *canvas)
 325 {
 326     AdgWidgetPrivate *data = widget->data;
 327
 328     if (data->canvas != NULL)
 329         g_object_unref(data->canvas);
 330
 331     data->canvas = canvas;
 332
 333     if (canvas != NULL)
 334         g_object_ref(data->canvas);
 335
 336     g_signal_emit(widget, signals[CANVAS_CHANGED], 0);
 337 }
 338
 339 static gboolean
 340 expose_event(GtkWidget *widget, GdkEventExpose *event)
 341 {
 342     AdgWidgetPrivate *data;
 343     AdgCanvas *canvas;
 344     GtkWidgetClass *parent_class;
 345
 346     data = ((AdgWidget *) widget)->data;
 347     canvas = data->canvas;
 348     parent_class = (GtkWidgetClass *) adg_widget_parent_class;
 349
 350     if (canvas != NULL) {
 351         cairo_t *cr = gdk_cairo_create(widget->window);
 352         adg_entity_render((AdgEntity *) canvas, cr);
 353         cairo_destroy(cr);
 354     }
 355
 356     if (parent_class->expose_event == NULL)
 357         return FALSE;
 358
 359     return parent_class->expose_event(widget, event);
 360 }
 361
 362 static gboolean
 363 scroll_event(GtkWidget *widget, GdkEventScroll *event)
 364 {
 365     GtkWidgetClass *parent_class;
 366     AdgWidgetPrivate *data;
 367     AdgMatrix map, inverted;
 368
 369     parent_class = (GtkWidgetClass *) adg_widget_parent_class;
 370     data = ((AdgWidget *) widget)->data;
 371
 372     if ((event->direction == GDK_SCROLL_UP ||
 373          event->direction == GDK_SCROLL_DOWN) &&
 374         get_local_map(widget, &map, &inverted)) {
 375         double factor, x, y;
 376
 377         if (event->direction == GDK_SCROLL_UP) {
 378             factor = data->factor;
 379         } else {
 380             factor = 1. / data->factor;
 381         }
 382
 383         x = event->x;
 384         y = event->y;
 385
 386         cairo_matrix_transform_point(&inverted, &x, &y);
 387
 388         cairo_matrix_scale(&map, factor, factor);
 389         cairo_matrix_translate(&map, x/factor - x, y/factor - y);
 390
 391         set_local_map(widget, &map);
 392
 393         gtk_widget_queue_draw(widget);
 394     }
 395
 396     if (parent_class->scroll_event == NULL)
 397         return FALSE;
 398
 399     return parent_class->scroll_event(widget, event);
 400 }
 401
 402 static gboolean
 403 button_press_event(GtkWidget *widget, GdkEventButton *event)
 404 {
 405     GtkWidgetClass *parent_class;
 406     AdgWidgetPrivate *data;
 407
 408     parent_class = (GtkWidgetClass *) adg_widget_parent_class;
 409     data = ((AdgWidget *) widget)->data;
 410
 411     if (event->type == GDK_BUTTON_PRESS && event->button == 2) {
 412         data->x_event = event->x;
 413         data->y_event = event->y;
 414     }
 415
 416     if (parent_class->button_press_event == NULL)
 417         return FALSE;
 418
 419     return parent_class->button_press_event(widget, event);
 420 }
 421
 422 static gboolean
 423 motion_notify_event(GtkWidget *widget, GdkEventMotion *event)
 424 {
 425     GtkWidgetClass *parent_class;
 426     AdgWidgetPrivate *data;
 427     AdgMatrix map, inverted;
 428
 429     parent_class = (GtkWidgetClass *) adg_widget_parent_class;
 430     data = ((AdgWidget *) widget)->data;
 431
 432     if ((event->state & GDK_BUTTON2_MASK) > 0 &&
 433         get_local_map(widget, &map, &inverted)) {
 434         double x, y;
 435
 436         x = event->x - data->x_event;
 437         y = event->y - data->y_event;
 438
 439         cairo_matrix_transform_distance(&inverted, &x, &y);
 440         cairo_matrix_translate(&map, x, y);
 441         data->x_event = event->x;
 442         data->y_event = event->y;
 443
 444         set_local_map(widget, &map);
 445
 446         gtk_widget_queue_draw(widget);
 447     }
 448
 449     if (parent_class->motion_notify_event == NULL)
 450         return FALSE;
 451
 452     return parent_class->motion_notify_event(widget, event);
 453 }
 454
 455 static gboolean
 456 get_local_map(GtkWidget *widget, AdgMatrix *map, AdgMatrix *inverted)
 457 {
 458     AdgWidgetPrivate *data;
 459     AdgCanvas *canvas;
 460
 461     data = ((AdgWidget *) widget)->data;
 462     canvas = data->canvas;
 463     if (canvas == NULL)
 464         return FALSE;
 465
 466     adg_entity_get_local_map((AdgEntity *) canvas, map);
 467     adg_matrix_copy(inverted, map);
 468
 469     return cairo_matrix_invert(inverted) == CAIRO_STATUS_SUCCESS;
 470 }
 471
 472 static void
 473 set_local_map(GtkWidget *widget, const AdgMatrix *map)
 474 {
 475     AdgWidgetPrivate *data;
 476     AdgCanvas *canvas;
 477
 478     data = ((AdgWidget *) widget)->data;
 479     canvas = data->canvas;
 480
 481     if (canvas != NULL)
 482         adg_entity_set_local_map((AdgEntity *) canvas, map);
 483 }