src/adg/adg-gtk-layout.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010,2011,2012,2013  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-gtk-layout
  23  * @short_description: A scrollable #AdgGtkArea based widget
  24  *
  25  * This is an #AdgGtkArea derived object with scrolling capabilities.
  26  * It means an #AdgGtkLayout object can be added directly to a
  27  * #GtkScrolledWindow container without the need for an intermediate
  28  * #GtkViewport container.
  29  *
  30  * Since: 1.0
  31  **/
  32
  33 /**
  34  * AdgGtkLayout:
  35  *
  36  * All fields are private and should not be used directly.
  37  * Use its public methods instead.
  38  *
  39  * Since: 1.0
  40  **/
  41
  42
  43 #include "adg-internal.h"
  44 #include <gtk/gtk.h>
  45
  46 #include "adg-container.h"
  47 #include "adg-table.h"
  48 #include "adg-title-block.h"
  49 #include <adg-canvas.h>
  50 #include "adg-gtk-area.h"
  51
  52 #include "adg-gtk-layout.h"
  53 #include "adg-gtk-layout-private.h"
  54
  55 #define _ADG_OLD_OBJECT_CLASS  ((GObjectClass *) adg_gtk_layout_parent_class)
  56 #define _ADG_OLD_WIDGET_CLASS  ((GtkWidgetClass *) adg_gtk_layout_parent_class)
  57 #define _ADG_OLD_AREA_CLASS    ((AdgGtkAreaClass *) adg_gtk_layout_parent_class)
  58
  59
  60 G_DEFINE_TYPE_WITH_CODE(AdgGtkLayout, adg_gtk_layout, ADG_GTK_TYPE_AREA,
  61                         G_IMPLEMENT_INTERFACE(GTK_TYPE_SCROLLABLE, NULL))
  62
  63 enum {
  64     PROP_0,
  65     PROP_HADJUSTMENT,
  66     PROP_HSCROLL_POLICY,
  67     PROP_VADJUSTMENT,
  68     PROP_VSCROLL_POLICY
  69 };
  70
  71
  72 static void     _adg_dispose                    (GObject        *object);
  73 static void     _adg_get_property               (GObject        *object,
  74                                                  guint           prop_id,
  75                                                  GValue         *value,
  76                                                  GParamSpec     *pspec);
  77 static void     _adg_set_property               (GObject        *object,
  78                                                  guint           prop_id,
  79                                                  const GValue   *value,
  80                                                  GParamSpec     *pspec);
  81 static void     _adg_parent_set                 (GtkWidget      *widget,
  82                                                  GtkWidget      *old_parent);
  83 static void     _adg_size_allocate              (GtkWidget      *widget,
  84                                                  GtkAllocation  *allocation);
  85 static void     _adg_canvas_changed             (AdgGtkArea     *area,
  86                                                  AdgCanvas      *old_canvas);
  87 static void     _adg_extents_changed            (AdgGtkArea     *area,
  88                                                  const CpmlExtents *old_extents);
  89 static void     _adg_set_parent_size            (AdgGtkLayout   *layout);
  90 static void     _adg_set_adjustment             (AdgGtkLayout   *layout,
  91                                                  GtkAdjustment **dst,
  92                                                  GtkAdjustment  *src);
  93 static void     _adg_update_adjustments         (AdgGtkLayout   *layout);
  94 static void     _adg_value_changed              (AdgGtkLayout   *layout);
  95
  96
  97 static void
  98 adg_gtk_layout_class_init(AdgGtkLayoutClass *klass)
  99 {
 100     GObjectClass *gobject_class;
 101     GtkWidgetClass *widget_class;
 102     AdgGtkAreaClass *area_class;
 103
 104     gobject_class = (GObjectClass *) klass;
 105     widget_class = (GtkWidgetClass *) klass;
 106     area_class = (AdgGtkAreaClass *) klass;
 107
 108     g_type_class_add_private(klass, sizeof(AdgGtkLayoutPrivate));
 109
 110     gobject_class->dispose = _adg_dispose;
 111     gobject_class->get_property = _adg_get_property;
 112     gobject_class->set_property = _adg_set_property;
 113
 114     widget_class->parent_set = _adg_parent_set;
 115     widget_class->size_allocate = _adg_size_allocate;
 116
 117     area_class->canvas_changed = _adg_canvas_changed;
 118     area_class->extents_changed = _adg_extents_changed;
 119
 120     g_object_class_override_property(gobject_class, PROP_HADJUSTMENT,
 121                                      "hadjustment");
 122     g_object_class_override_property(gobject_class, PROP_HSCROLL_POLICY,
 123                                      "hscroll-policy");
 124     g_object_class_override_property(gobject_class, PROP_VADJUSTMENT,
 125                                      "vadjustment");
 126     g_object_class_override_property(gobject_class, PROP_VSCROLL_POLICY,
 127                                      "vscroll-policy");
 128 }
 129
 130 static void
 131 adg_gtk_layout_init(AdgGtkLayout *layout)
 132 {
 133     AdgGtkLayoutPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(layout,
 134                                                             ADG_GTK_TYPE_LAYOUT,
 135                                                             AdgGtkLayoutPrivate);
 136
 137     data->hadjustment = NULL;
 138     data->vadjustment = NULL;
 139     data->policy_stored = FALSE;
 140     data->viewport.is_defined = FALSE;
 141
 142     layout->data = data;
 143 }
 144
 145 static void
 146 _adg_dispose(GObject *object)
 147 {
 148     AdgGtkLayoutPrivate *data = ((AdgGtkLayout *) object)->data;
 149
 150     if (data->hadjustment != NULL) {
 151         g_object_unref(data->hadjustment);
 152         data->hadjustment = NULL;
 153     }
 154
 155     if (data->vadjustment != NULL) {
 156         g_object_unref(data->vadjustment);
 157         data->vadjustment = NULL;
 158     }
 159
 160     if (_ADG_OLD_OBJECT_CLASS->dispose != NULL)
 161         _ADG_OLD_OBJECT_CLASS->dispose(object);
 162 }
 163
 164 static void
 165 _adg_get_property(GObject *object, guint prop_id,
 166                   GValue *value, GParamSpec *pspec)
 167 {
 168     AdgGtkLayoutPrivate *data = ((AdgGtkLayout *) object)->data;
 169
 170     switch (prop_id) {
 171     case PROP_HADJUSTMENT:
 172         g_value_set_object(value, data->hadjustment);
 173         break;
 174     case PROP_HSCROLL_POLICY:
 175         g_value_set_enum(value, data->hpolicy);
 176         break;
 177     case PROP_VADJUSTMENT:
 178         g_value_set_object(value, data->vadjustment);
 179         break;
 180     case PROP_VSCROLL_POLICY:
 181         g_value_set_enum(value, data->vpolicy);
 182         break;
 183     default:
 184         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 185         break;
 186     }
 187 }
 188
 189 static void
 190 _adg_set_property(GObject *object, guint prop_id,
 191                   const GValue *value, GParamSpec *pspec)
 192 {
 193     AdgGtkLayout *layout;
 194     AdgGtkLayoutPrivate *data;
 195     GtkAdjustment *adjustment;
 196
 197     layout = (AdgGtkLayout *) object;
 198     data = layout->data;
 199
 200     switch (prop_id) {
 201     case PROP_HADJUSTMENT:
 202         adjustment = g_value_get_object(value);
 203         if (adjustment == NULL)
 204             adjustment = (GtkAdjustment *) gtk_adjustment_new(0, 0, 0, 0, 0, 0);
 205
 206         _adg_set_adjustment(layout, &data->hadjustment, adjustment);
 207         break;
 208     case PROP_HSCROLL_POLICY:
 209         data->hpolicy = g_value_get_enum(value);
 210         break;
 211     case PROP_VADJUSTMENT:
 212         adjustment = g_value_get_object(value);
 213         if (adjustment == NULL)
 214             adjustment = (GtkAdjustment *) gtk_adjustment_new(0, 0, 0, 0, 0, 0);
 215
 216         _adg_set_adjustment(layout, &data->vadjustment, adjustment);
 217         break;
 218     case PROP_VSCROLL_POLICY:
 219         data->vpolicy = g_value_get_enum(value);
 220         break;
 221     default:
 222         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 223         break;
 224     }
 225 }
 226
 227
 228 /**
 229  * adg_gtk_layout_new:
 230  *
 231  * Creates a new empty #AdgGtkLayout. The widget is useful only after
 232  * an #AdgCanvas has been added either using the #AdgGtkLayout:canvas
 233  * property or with adg_gtk_layout_set_canvas().
 234  *
 235  * Returns: (transfer full): the newly created widget.
 236  *
 237  * Since: 1.0
 238  **/
 239 GtkWidget *
 240 adg_gtk_layout_new(void)
 241 {
 242     return g_object_new(ADG_GTK_TYPE_LAYOUT, NULL);
 243 }
 244
 245 /**
 246  * adg_gtk_layout_new_with_canvas:
 247  * @canvas: the #AdgCanvas shown by this widget
 248  *
 249  * Creates a new #AdgGtkLayout and sets the #AdgGtkLayout:canvas property
 250  * to @canvas.
 251  *
 252  * Returns: (transfer full): the newly created widget.
 253  *
 254  * Since: 1.0
 255  **/
 256 GtkWidget *
 257 adg_gtk_layout_new_with_canvas(AdgCanvas *canvas)
 258 {
 259     g_return_val_if_fail(ADG_IS_CANVAS(canvas), NULL);
 260
 261     return g_object_new(ADG_GTK_TYPE_LAYOUT, "canvas", canvas, NULL);
 262 }
 263
 264 /**
 265  * adg_gtk_layout_set_hadjustment:
 266  * @layout: an #AdgGtkLayout
 267  * @hadjustment: the new adjustment
 268  *
 269  * Sets the new horizontal adjustment for @layout to @hadjustment.
 270  * The old adjustment, if present, is unreferenced.
 271  *
 272  * This is basically the same as manually setting the
 273  * #AdgGtkLayout:hadjustment property with g_object_set().
 274  *
 275  * Since: 1.0
 276  **/
 277 void
 278 adg_gtk_layout_set_hadjustment(AdgGtkLayout *layout,
 279                                GtkAdjustment *hadjustment)
 280 {
 281     g_return_if_fail(ADG_GTK_IS_LAYOUT(layout));
 282     g_object_set(layout, "hadjustment", hadjustment, NULL);
 283 }
 284
 285 /**
 286  * adg_gtk_layout_get_hadjustment:
 287  * @layout: an #AdgGtkLayout
 288  *
 289  * Retrieves the current horizontal adjustment of @layout.
 290  *
 291  * The returned alignment is owned by @layout and should
 292  * not be modified or freed.
 293  *
 294  * Returns: (transfer none): the alignment of @layout.
 295  *
 296  * Since: 1.0
 297  **/
 298 GtkAdjustment *
 299 adg_gtk_layout_get_hadjustment(AdgGtkLayout *layout)
 300 {
 301     AdgGtkLayoutPrivate *data;
 302
 303     g_return_val_if_fail(ADG_GTK_IS_LAYOUT(layout), NULL);
 304
 305     data = layout->data;
 306
 307     return data->hadjustment;
 308 }
 309
 310 /**
 311  * adg_gtk_layout_set_vadjustment:
 312  * @layout: an #AdgGtkLayout
 313  * @vadjustment: the new adjustment
 314  *
 315  * Sets the new vertical adjustment for @layout to @vadjustment.
 316  * The old adjustment, if present, is unreferenced.
 317  *
 318  * This is basically the same as manually setting the
 319  * #AdgGtkLayout:vadjustment property with g_object_set().
 320  *
 321  * Since: 1.0
 322  **/
 323 void
 324 adg_gtk_layout_set_vadjustment(AdgGtkLayout *layout,
 325                                GtkAdjustment *vadjustment)
 326 {
 327     g_return_if_fail(ADG_GTK_IS_LAYOUT(layout));
 328     g_object_set(layout, "vadjustment", vadjustment, NULL);
 329 }
 330
 331 /**
 332  * adg_gtk_layout_get_vadjustment:
 333  * @layout: an #AdgGtkLayout
 334  *
 335  * Retrieves the current vertical adjustment of @layout.
 336  *
 337  * The returned alignment is owned by @layout and should
 338  * not be modified or freed.
 339  *
 340  * Returns: (transfer none): the alignment of @layout.
 341  *
 342  * Since: 1.0
 343  **/
 344 GtkAdjustment *
 345 adg_gtk_layout_get_vadjustment(AdgGtkLayout *layout)
 346 {
 347     AdgGtkLayoutPrivate *data;
 348
 349     g_return_val_if_fail(ADG_GTK_IS_LAYOUT(layout), NULL);
 350
 351     data = layout->data;
 352
 353     return data->vadjustment;
 354 }
 355
 356
 357 static void
 358 _adg_parent_set(GtkWidget *widget, GtkWidget *old_parent)
 359 {
 360     AdgGtkLayout *layout = (AdgGtkLayout *) widget;
 361
 362     if (_ADG_OLD_WIDGET_CLASS->parent_set != NULL)
 363         _ADG_OLD_WIDGET_CLASS->parent_set(widget, old_parent);
 364
 365     _adg_set_parent_size(layout);
 366 }
 367
 368 static void
 369 _adg_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
 370 {
 371     AdgGtkLayout *layout;
 372     AdgGtkLayoutPrivate *data;
 373
 374     layout = (AdgGtkLayout *) widget;
 375     data = layout->data;
 376
 377     if (_ADG_OLD_WIDGET_CLASS->size_allocate != NULL)
 378         _ADG_OLD_WIDGET_CLASS->size_allocate(widget, allocation);
 379
 380     /* Resize the viewport on a new allocation.
 381      * TODO: plan other policies instead of forcibly set only the
 382      * size field on the viewport struct, such as modifying the
 383      * org to keep the sheet centered in the allocation space. */
 384     data->viewport.size.x = allocation->width;
 385     data->viewport.size.y = allocation->height;
 386     data->viewport.is_defined = TRUE;
 387
 388     _adg_update_adjustments(layout);
 389 }
 390
 391 static void
 392 _adg_canvas_changed(AdgGtkArea *area, AdgCanvas *old_canvas)
 393 {
 394     AdgGtkLayout *layout;
 395     AdgGtkLayoutPrivate *data;
 396
 397     layout = (AdgGtkLayout *) area;
 398     data = layout->data;
 399
 400     if (_ADG_OLD_AREA_CLASS->canvas_changed != NULL)
 401         _ADG_OLD_AREA_CLASS->canvas_changed(area, old_canvas);
 402
 403     /* By convention, expect the origin of a new canvas to be
 404      * on the top/left corner of the allocation area */
 405     data->viewport.org.x = 0;
 406     data->viewport.org.y = 0;
 407
 408     _adg_set_parent_size(layout);
 409 }
 410
 411 static void
 412 _adg_extents_changed(AdgGtkArea *area, const CpmlExtents *old_extents)
 413 {
 414     if (_ADG_OLD_AREA_CLASS->extents_changed != NULL)
 415         _ADG_OLD_AREA_CLASS->extents_changed(area, old_extents);
 416
 417     _adg_update_adjustments((AdgGtkLayout *) area);
 418 }
 419
 420 static void
 421 _adg_set_parent_size(AdgGtkLayout *layout)
 422 {
 423     GtkWidget *widget;
 424     AdgGtkLayoutPrivate *data;
 425     GtkWidget *parent;
 426     const CpmlExtents *sheet;
 427     GtkScrolledWindow *scrolled_window;
 428
 429     widget = (GtkWidget *) layout;
 430
 431     /* When the widget is realized it is too late to suggest a size */
 432     if (gtk_widget_get_realized(widget))
 433         return;
 434
 435     data = layout->data;
 436     parent = gtk_widget_get_parent(widget);
 437     if (!GTK_IS_WIDGET(parent))
 438         return;
 439
 440     sheet = adg_gtk_area_get_extents((AdgGtkArea *) layout);
 441     if (sheet == NULL || !sheet->is_defined)
 442         return;
 443
 444     gtk_widget_set_size_request(parent, sheet->size.x + 2, sheet->size.y + 2);
 445
 446     if (GTK_IS_SCROLLED_WINDOW(parent) && !data->policy_stored) {
 447         scrolled_window = (GtkScrolledWindow *) parent;
 448
 449         gtk_scrolled_window_get_policy(scrolled_window,
 450                                        &data->hpolicy, &data->vpolicy);
 451         gtk_scrolled_window_set_policy(scrolled_window,
 452                                        GTK_POLICY_NEVER, GTK_POLICY_NEVER);
 453
 454         data->policy_stored = TRUE;
 455     }
 456 }
 457
 458 static void
 459 _adg_set_adjustment(AdgGtkLayout *layout,
 460                     GtkAdjustment **dst, GtkAdjustment *src)
 461 {
 462     GCallback value_changed;
 463
 464     if (*dst == src)
 465         return;
 466
 467     value_changed = G_CALLBACK(_adg_value_changed);
 468
 469     if (*dst != NULL) {
 470         /* Release the old adjustment */
 471         g_signal_handlers_disconnect_by_func(*dst, (gpointer) value_changed, layout);
 472         g_object_unref(*dst);
 473     }
 474
 475     g_signal_connect_swapped(src, "value-changed", value_changed, layout);
 476     g_object_ref_sink(src);
 477
 478     *dst = src;
 479 }
 480
 481 /**
 482  * _adg_update_adjustments:
 483  * @layout: an #AdgGtkLayout
 484  *
 485  * Updates the scrollbars according to the new extents of the canvas
 486  * of @area and to the current viewport.
 487  *
 488  * The algorithm uses three local #CpmlExtents variables: the
 489  * <var>viewport</var> (what physically shown by the graphic device),
 490  * the <var>sheet</var> (the extents of the drawing, margins
 491  * included) and <var>surface</var> (a helper variable that is the
 492  * union of the previous two extents).
 493  *
 494  * Since: 1.0
 495  **/
 496 static void
 497 _adg_update_adjustments(AdgGtkLayout *layout)
 498 {
 499     AdgGtkArea *area;
 500     AdgCanvas *canvas;
 501     const CpmlExtents *sheet, *viewport;
 502     AdgGtkLayoutPrivate *data;
 503     GtkAdjustment *hadj, *vadj;
 504     CpmlExtents surface;
 505
 506     area = (AdgGtkArea *) layout;
 507     canvas = adg_gtk_area_get_canvas(area);
 508     if (canvas == NULL)
 509         return;
 510
 511     sheet = adg_gtk_area_get_extents(area);
 512     if (sheet == NULL || !sheet->is_defined)
 513         return;
 514
 515     data = layout->data;
 516     hadj = data->hadjustment;
 517     vadj = data->vadjustment;
 518     viewport = &data->viewport;
 519     surface = *sheet;
 520     cpml_extents_add(&surface, viewport);
 521
 522     if (data->policy_stored) {
 523         /* Restore the original policy for the scrollbars */
 524         GtkWidget *parent;
 525         GtkScrolledWindow *scrolled_window;
 526
 527         parent = gtk_widget_get_parent((GtkWidget *) layout);
 528         scrolled_window = (GtkScrolledWindow *) parent;
 529
 530         gtk_scrolled_window_set_policy(scrolled_window,
 531                                        data->hpolicy, data->vpolicy);
 532
 533         data->policy_stored = TRUE;
 534     }
 535
 536     g_object_set(hadj,
 537                  "lower", surface.org.x,
 538                  "upper", surface.org.x + surface.size.x,
 539                  "page-size", viewport->size.x,
 540                  "value", viewport->org.x,
 541                  NULL);
 542     g_object_set(vadj,
 543                  "lower", surface.org.y,
 544                  "upper", surface.org.y + surface.size.y,
 545                  "page-size", viewport->size.y,
 546                  "value", viewport->org.y,
 547                  NULL);
 548 }
 549
 550 static void
 551 _adg_value_changed(AdgGtkLayout *layout)
 552 {
 553     GtkWidget *widget;
 554     AdgGtkArea *area;
 555     AdgGtkLayoutPrivate *data;
 556     CpmlPair org;
 557     cairo_matrix_t map;
 558
 559     widget = (GtkWidget *) layout;
 560
 561     if (!gtk_widget_get_realized(widget))
 562         return;
 563
 564     area = (AdgGtkArea *) layout;
 565     data = layout->data;
 566     org.x = gtk_adjustment_get_value(data->hadjustment);
 567     org.y = gtk_adjustment_get_value(data->vadjustment);
 568
 569     cairo_matrix_init_translate(&map, data->viewport.org.x - org.x,
 570                                 data->viewport.org.y - org.y);
 571     adg_gtk_area_transform_render_map(area, &map, ADG_TRANSFORM_BEFORE);
 572
 573     gtk_widget_queue_draw(widget);
 574     _adg_update_adjustments(layout);
 575 }