gschem/src/gschem_page_view.c

   1 /* gEDA - GPL Electronic Design Automation
   2  * gschem - gEDA Schematic Capture
   3  * Copyright (C) 1998-2010 Ales Hvezda
   4  * Copyright (C) 1998-2020 gEDA Contributors (see ChangeLog for details)
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20 /*!
  21  * \file gschem_page_view.c
  22  *
  23  * \brief A widget for viewing a schematic page
  24  */
  25
  26 #include <config.h>
  27
  28 #include <stdio.h>
  29 #ifdef HAVE_STDLIB_H
  30 #include <stdlib.h>
  31 #endif
  32 #ifdef HAVE_STRING_H
  33 #include <string.h>
  34 #endif
  35
  36 #include <math.h>
  37
  38 #include "gschem.h"
  39 #include <gdk/gdkkeysyms.h>
  40
  41 #include "gtk/gtkmarshal.h"
  42
  43
  44
  45 #define INVALIDATE_MARGIN 1
  46
  47
  48
  49 enum
  50 {
  51   PROP_0,
  52   PROP_HADJUSTMENT,
  53   PROP_PAGE,
  54   PROP_PAGE_GEOMETRY,
  55   PROP_VADJUSTMENT
  56 };
  57
  58
  59 typedef void (*NotifyFunction) (void*,void*);
  60
  61 static void
  62 dispose (GObject *object);
  63
  64 static void
  65 finalize (GObject *object);
  66
  67 static void
  68 get_property (GObject *object, guint param_id, GValue *value, GParamSpec *pspec);
  69
  70 static void
  71 gschem_page_view_class_init (GschemPageViewClass *klass);
  72
  73 static void
  74 gschem_page_view_init (GschemPageView *view);
  75
  76 static void
  77 gschem_page_view_update_hadjustment (GschemPageView *view);
  78
  79 static void
  80 gschem_page_view_update_vadjustment (GschemPageView *view);
  81
  82 static void
  83 hadjustment_value_changed (GtkAdjustment *vadjustment, GschemPageView *view);
  84
  85 static void
  86 remove_page_weak_reference (PAGE *page, gpointer geometry, GschemPageView *view);
  87
  88 static void
  89 page_deleted (PAGE *page, GschemPageView *view);
  90
  91 static void
  92 set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec);
  93
  94 static void
  95 set_scroll_adjustments (GschemPageView *view, GtkAdjustment *hadjustment, GtkAdjustment *vadjustment);
  96
  97 static void
  98 vadjustment_value_changed (GtkAdjustment *vadjustment, GschemPageView *view);
  99
 100
 101
 102 static GObjectClass *gschem_page_view_parent_class = NULL;
 103
 104
 105 /*
 106  *  In later versions of GTK+, the GtkScrolledWindow uses an interface, instead
 107  *  of signals, to set the scrollbar adjustments. When Gschem uses on of these
 108  *  more recent version of GTK+, this function will no longer be needed.
 109  */
 110 static void
 111 cclosure_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,
 112                                       GValue       *return_value G_GNUC_UNUSED,
 113                                       guint         n_param_values,
 114                                       const GValue *param_values,
 115                                       gpointer      invocation_hint G_GNUC_UNUSED,
 116                                       gpointer      marshal_data)
 117 {
 118   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer     data1,
 119                                                     gpointer     arg_1,
 120                                                     gpointer     arg_2,
 121                                                     gpointer     data2);
 122
 123   register GMarshalFunc_VOID__OBJECT_OBJECT callback;
 124   register GCClosure *cc = (GCClosure*) closure;
 125   register gpointer data1, data2;
 126
 127   g_return_if_fail (n_param_values == 3);
 128
 129   if (G_CCLOSURE_SWAP_DATA (closure)) {
 130     data1 = closure->data;
 131     data2 = g_value_peek_pointer (param_values + 0);
 132   }
 133   else {
 134     data1 = g_value_peek_pointer (param_values + 0);
 135     data2 = closure->data;
 136   }
 137
 138   callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
 139
 140   callback (data1,
 141             g_value_get_object (param_values + 1),
 142             g_value_get_object (param_values + 2),
 143             data2);
 144 }
 145
 146
 147
 148 /*! \brief Dispose of the object
 149  */
 150 static void
 151 dispose (GObject *object)
 152 {
 153   GschemPageView *view;
 154
 155   g_return_if_fail (object != NULL);
 156   view = GSCHEM_PAGE_VIEW (object);
 157   g_return_if_fail (view != NULL);
 158
 159   gschem_page_view_set_hadjustment (view, NULL);
 160   gschem_page_view_set_vadjustment (view, NULL);
 161
 162   g_hash_table_foreach (view->geometry_table, (GHFunc)remove_page_weak_reference, view);
 163   g_hash_table_remove_all (view->geometry_table);
 164
 165   /* We aren't bothering about invoking
 166    *   gschem_page_view_set_page (view, NULL)
 167    * directly here since the current page itself must use its weak
 168    * reference to call cleanup closure (page_deleted) for this
 169    * view */
 170
 171   /* lastly, chain up to the parent dispose */
 172
 173   g_return_if_fail (gschem_page_view_parent_class != NULL);
 174   gschem_page_view_parent_class->dispose (object);
 175 }
 176
 177
 178
 179 /*! \brief Event handler for window realized
 180  */
 181 static void
 182 event_realize(GtkWidget *widget, gpointer unused)
 183 {
 184   GschemPageView *view = GSCHEM_PAGE_VIEW(widget);
 185   GdkWindow *window = gtk_widget_get_window (widget);
 186
 187   g_return_if_fail (view != NULL);
 188   g_return_if_fail (window != NULL);
 189
 190   gtk_widget_get_allocation (widget, &(view->previous_allocation));
 191 }
 192
 193
 194
 195 /*! \brief Event handler for window unrealized
 196  */
 197 static void
 198 event_unrealize(GtkWidget *widget, gpointer unused)
 199 {
 200   GschemPageView *view = GSCHEM_PAGE_VIEW(widget);
 201
 202   g_return_if_fail (view != NULL);
 203 }
 204
 205
 206
 207 /*! \brief Finalize object
 208  */
 209 static void
 210 finalize (GObject *object)
 211 {
 212   GschemPageView *view = GSCHEM_PAGE_VIEW (object);
 213
 214   g_return_if_fail (view != NULL);
 215   g_return_if_fail (view->geometry_table != NULL);
 216
 217   g_hash_table_destroy (view->geometry_table);
 218
 219   /* lastly, chain up to the parent finalize */
 220
 221   g_return_if_fail (gschem_page_view_parent_class != NULL);
 222   gschem_page_view_parent_class->finalize (object);
 223 }
 224
 225
 226
 227 /*! \brief Get a property
 228  *
 229  *  \param [in]     object
 230  *  \param [in]     param_id
 231  *  \param [in,out] value
 232  *  \param [in]     pspec
 233  */
 234 static void
 235 get_property (GObject *object, guint param_id, GValue *value, GParamSpec *pspec)
 236 {
 237   GschemPageView *view = GSCHEM_PAGE_VIEW (object);
 238
 239   switch (param_id) {
 240     case PROP_HADJUSTMENT:
 241       g_value_set_object (value, gschem_page_view_get_hadjustment (view));
 242       break;
 243
 244     case PROP_PAGE:
 245       g_value_set_pointer (value, gschem_page_view_get_page (view));
 246       break;
 247
 248     case PROP_PAGE_GEOMETRY:
 249       g_value_set_boxed (value, gschem_page_view_get_page_geometry (view));
 250       break;
 251
 252     case PROP_VADJUSTMENT:
 253       g_value_set_object (value, gschem_page_view_get_vadjustment (view));
 254       break;
 255
 256     default:
 257       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 258   }
 259 }
 260
 261
 262
 263 /*! \brief Initialize GschemPageView class
 264  *
 265  *  \param [in] klass The class for the GschemPageView
 266  */
 267 static void
 268 gschem_page_view_class_init (GschemPageViewClass *klass)
 269 {
 270   gschem_page_view_parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
 271
 272   G_OBJECT_CLASS (klass)->dispose  = dispose;
 273   G_OBJECT_CLASS (klass)->finalize = finalize;
 274
 275   G_OBJECT_CLASS (klass)->get_property = get_property;
 276   G_OBJECT_CLASS (klass)->set_property = set_property;
 277
 278   g_object_class_install_property (G_OBJECT_CLASS (klass),
 279                                    PROP_HADJUSTMENT,
 280                                    g_param_spec_object ("hadjustment",
 281                                                         "Horizontal adjustment",
 282                                                         "Horizontal adjustment",
 283                                                         GTK_TYPE_ADJUSTMENT,
 284                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 285
 286   g_object_class_install_property (G_OBJECT_CLASS (klass),
 287                                    PROP_PAGE,
 288                                    g_param_spec_pointer ("page",
 289                                                          "Page",
 290                                                          "Page",
 291                                                          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 292
 293   g_object_class_install_property (G_OBJECT_CLASS (klass),
 294                                    PROP_PAGE_GEOMETRY,
 295                                    g_param_spec_boxed ("page-geometry",
 296                                                        "Page Geometry",
 297                                                        "Page Geometry",
 298                                                        GSCHEM_TYPE_PAGE_GEOMETRY,
 299                                                        G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 300
 301   g_object_class_install_property (G_OBJECT_CLASS (klass),
 302                                    PROP_VADJUSTMENT,
 303                                    g_param_spec_object ("vadjustment",
 304                                                         "Vertical adjustment",
 305                                                         "Vertical adjustment",
 306                                                         GTK_TYPE_ADJUSTMENT,
 307                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 308
 309   GTK_WIDGET_CLASS (klass)->set_scroll_adjustments_signal = g_signal_new (
 310     "set-scroll-adjustments",
 311     G_OBJECT_CLASS_TYPE (klass),
 312     G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 313     0,
 314     NULL,
 315     NULL,
 316     cclosure_marshal_VOID__OBJECT_OBJECT,
 317     G_TYPE_NONE,
 318     2,
 319     GTK_TYPE_ADJUSTMENT,
 320     GTK_TYPE_ADJUSTMENT);
 321
 322   g_signal_new (
 323     "update-grid-info",
 324     G_OBJECT_CLASS_TYPE (klass),
 325     G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 326     0,
 327     NULL,
 328     NULL,
 329     g_cclosure_marshal_VOID__VOID,
 330     G_TYPE_NONE,
 331     0);
 332 }
 333
 334
 335
 336 /*! \brief Get the horizontal adjustment for this view
 337  *
 338  *  \param [in] view The view
 339  *  \return The horizontal adjustment for this view
 340  */
 341 GtkAdjustment*
 342 gschem_page_view_get_hadjustment (GschemPageView *view)
 343 {
 344   g_return_val_if_fail (view != NULL, NULL);
 345
 346   return view->hadjustment;
 347 }
 348
 349
 350
 351 /*! \brief Get page for this view
 352  *
 353  *  \param [in] view The view
 354  *  \return The page for the view
 355  */
 356 PAGE*
 357 gschem_page_view_get_page (GschemPageView *view)
 358 {
 359   g_return_val_if_fail (view != NULL, NULL);
 360
 361   return view->page;
 362 }
 363
 364
 365
 366 /*! \brief Get page geometry for this view
 367  *
 368  *  \param [in] view The view
 369  *  \return The page geometry for the view
 370  */
 371 GschemPageGeometry*
 372 gschem_page_view_get_page_geometry (GschemPageView *view)
 373 {
 374   PAGE *page = NULL;
 375   GschemPageGeometry *geometry = NULL;
 376   GdkWindow *window = NULL;
 377   int screen_width;
 378   int screen_height;
 379
 380   g_return_val_if_fail (view != NULL, NULL);
 381
 382   page = gschem_page_view_get_page (view);
 383   if (page == NULL) {
 384     return NULL;
 385   }
 386
 387   geometry = g_hash_table_lookup (view->geometry_table, page);
 388
 389   window = gtk_widget_get_window (GTK_WIDGET (view));
 390   g_return_val_if_fail (window != NULL, NULL);
 391   screen_width = gdk_window_get_width (window);
 392   screen_height = gdk_window_get_height (window);
 393
 394   if (geometry == NULL) {
 395     geometry = gschem_page_geometry_new_with_values (screen_width,
 396                                                      screen_height,
 397                                                      view->page->toplevel->init_left,
 398                                                      view->page->toplevel->init_top,
 399                                                      view->page->toplevel->init_right,
 400                                                      view->page->toplevel->init_bottom,
 401                                                      view->page->toplevel->init_left,
 402                                                      view->page->toplevel->init_top,
 403                                                      view->page->toplevel->init_right,
 404                                                      view->page->toplevel->init_bottom);
 405
 406     g_hash_table_insert (view->geometry_table, page, geometry);
 407
 408     gschem_page_geometry_zoom_extents (geometry,
 409                                        view->page->toplevel,
 410                                        s_page_objects (page));
 411   }
 412   else {
 413     gschem_page_geometry_set_values (geometry,
 414                                      max (fabs ((double)(gschem_page_geometry_get_viewport_right (geometry) - gschem_page_geometry_get_viewport_left (geometry)) / screen_width), (fabs ((double)(gschem_page_geometry_get_viewport_top (geometry) - gschem_page_geometry_get_viewport_bottom (geometry)) / screen_height))),
 415                                      screen_width,
 416                                      screen_height,
 417                                      gschem_page_geometry_get_viewport_left (geometry),
 418                                      gschem_page_geometry_get_viewport_top (geometry),
 419                                      gschem_page_geometry_get_viewport_right (geometry),
 420                                      gschem_page_geometry_get_viewport_bottom (geometry));
 421   }
 422
 423   return geometry;
 424 }
 425
 426
 427
 428 /*! \brief Get/register GschemPageView type.
 429  */
 430 GType
 431 gschem_page_view_get_type ()
 432 {
 433   static GType type = 0;
 434
 435   if (type == 0) {
 436     static const GTypeInfo info = {
 437       sizeof(GschemPageViewClass),
 438       NULL,                                                    /* base_init */
 439       NULL,                                                    /* base_finalize */
 440       (GClassInitFunc) gschem_page_view_class_init,
 441       NULL,                                                    /* class_finalize */
 442       NULL,                                                    /* class_data */
 443       sizeof(GschemPageView),
 444       0,                                                       /* n_preallocs */
 445       (GInstanceInitFunc) gschem_page_view_init,
 446     };
 447
 448     type = g_type_register_static (GTK_TYPE_DRAWING_AREA, "GschemPageView", &info, 0);
 449   }
 450
 451   return type;
 452 }
 453
 454
 455
 456 /*! \brief Get the vertical adjustment for this view
 457  *
 458  *  \param [in] view The view
 459  *  \return The vertical adjustment for this view
 460  */
 461 GtkAdjustment*
 462 gschem_page_view_get_vadjustment (GschemPageView *view)
 463 {
 464   g_return_val_if_fail (view != NULL, NULL);
 465
 466   return view->vadjustment;
 467 }
 468
 469
 470
 471 /*! \brief Schedule redraw for the entire window
 472  *
 473  *  \param [in,out] view The Gschem page view to redraw
 474  */
 475 void
 476 gschem_page_view_invalidate_all (GschemPageView *view)
 477 {
 478   GdkWindow *window;
 479
 480   /* this function can be called early during initialization */
 481   if (view == NULL) {
 482     return;
 483   }
 484
 485   window = gtk_widget_get_window (GTK_WIDGET (view));
 486
 487   if (window == NULL) {
 488     return;
 489   }
 490
 491   gdk_window_invalidate_rect (window, NULL, FALSE);
 492 }
 493
 494
 495
 496 /*! \brief Schedule redraw of the given object
 497  *
 498  *  \param [in,out] view   The Gschem page view to redraw
 499  *  \param [in]     object The object to redraw
 500  */
 501 void
 502 gschem_page_view_invalidate_object (GschemPageView *view, OBJECT *object)
 503 {
 504   g_return_if_fail (object != NULL);
 505   g_return_if_fail (view != NULL);
 506
 507   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (view))) {
 508     return;
 509   }
 510
 511   PAGE *page = gschem_page_view_get_page (view);
 512
 513   if (page != NULL) {
 514     gboolean success;
 515     int world_bottom;
 516     int world_right;
 517     int world_left;
 518     int world_top;
 519
 520     success = world_get_single_object_bounds (page->toplevel,
 521                                               object,
 522                                               &world_left,
 523                                               &world_top,
 524                                               &world_right,
 525                                               &world_bottom);
 526
 527     if (success) {
 528       gschem_page_view_invalidate_world_rect (view,
 529                                               world_left,
 530                                               world_top,
 531                                               world_right,
 532                                               world_bottom);
 533     }
 534   }
 535 }
 536
 537
 538
 539 /*! \brief Schedule redraw of the given rectange
 540  *
 541  *  \param [in,out] view   The Gschem page view to redraw
 542  *  \param [in]     left
 543  *  \param [in]     top
 544  *  \param [in]     right
 545  *  \param [in]     bottom
 546  */
 547 void
 548 gschem_page_view_invalidate_screen_rect (GschemPageView *view, int left, int top, int right, int bottom)
 549 {
 550   int bloat;
 551   int cue_half_size;
 552   int grip_half_size;
 553   GdkRectangle rect;
 554   GdkWindow *window;
 555
 556   g_return_if_fail (view != NULL);
 557
 558   window = gtk_widget_get_window (GTK_WIDGET (view));
 559
 560   if (window == NULL) {
 561     return;
 562   }
 563
 564   grip_half_size = GRIP_SIZE / 2;
 565   cue_half_size = gschem_page_view_SCREENabs (view, CUE_BOX_SIZE);
 566   bloat = MAX (grip_half_size, cue_half_size) + INVALIDATE_MARGIN;
 567
 568   rect.x = MIN(left, right) - bloat;
 569   rect.y = MIN(top, bottom) - bloat;
 570   rect.width = 1 + abs( left - right ) + 2 * bloat;
 571   rect.height = 1 + abs( top - bottom ) + 2 * bloat;
 572
 573   gdk_window_invalidate_rect (window, &rect, FALSE);
 574 }
 575
 576
 577
 578 /*! \brief Schedule redraw of the given rectange
 579  *
 580  *  \param [in,out] view   The Gschem page view to redraw
 581  *  \param [in]     left
 582  *  \param [in]     top
 583  *  \param [in]     right
 584  *  \param [in]     bottom
 585  */
 586 void
 587 gschem_page_view_invalidate_world_rect (GschemPageView *view, int left, int top, int right, int bottom)
 588 {
 589   int screen_bottom;
 590   int screen_right;
 591   int screen_left;
 592   int screen_top;
 593
 594   g_return_if_fail (view != NULL);
 595
 596   gschem_page_view_WORLDtoSCREEN (view, left, top, &screen_left, &screen_top);
 597   gschem_page_view_WORLDtoSCREEN (view, right, bottom, &screen_right, &screen_bottom);
 598
 599   gschem_page_view_invalidate_screen_rect (view,
 600                                            screen_left,
 601                                            screen_top,
 602                                            screen_right,
 603                                            screen_bottom);
 604 }
 605
 606
 607
 608 /*! \brief Initialize GschemPageView instance
 609  *
 610  *  \param [in,out] view the gschem page view
 611  */
 612 static void
 613 gschem_page_view_init (GschemPageView *view)
 614 {
 615   g_return_if_fail (view != NULL);
 616
 617   view->hadjustment = NULL;
 618   view->vadjustment = NULL;
 619
 620   view->geometry_table = g_hash_table_new_full (g_direct_hash,
 621                                                 g_direct_equal,
 622                                                 NULL,
 623                                                 (GDestroyNotify) gschem_page_geometry_free);
 624
 625   view->page = NULL;
 626   view->configured = FALSE;
 627
 628   view->doing_pan = FALSE;
 629   view->pan_x = 0;
 630   view->pan_y = 0;
 631   view->throttle = 0;
 632
 633   g_signal_connect (view,
 634                     "set-scroll-adjustments",
 635                     G_CALLBACK (set_scroll_adjustments),
 636                     NULL);
 637
 638   g_signal_connect(view,
 639                    "realize",
 640                    G_CALLBACK (event_realize),
 641                    NULL);
 642
 643   g_signal_connect(view,
 644                    "unrealize",
 645                    G_CALLBACK (event_unrealize),
 646                    NULL);
 647 }
 648
 649
 650
 651 /*! \brief Create a new instance of the GschemPageView
 652  *  \par Function Description
 653  *  This function creates a new instance of the GschemPageView
 654  *  structure. The resulting view becomes a "viewport" for the
 655  *  given \a page. If the page is not NULL, a weak reference
 656  *  callback is added for \a page so that it can do necessary
 657  *  clean-up for the view when the page is deleted (e.g. due to
 658  *  using close-page! Scheme function).
 659  *
 660  *  \param [in] page The page to refer to.
 661  *
 662  *  \return A new instance of the GschemPageView
 663  */
 664 GschemPageView*
 665 gschem_page_view_new_with_page (PAGE *page)
 666 {
 667   GschemPageView *view = GSCHEM_PAGE_VIEW (g_object_new (GSCHEM_TYPE_PAGE_VIEW,
 668                                                          "page", page,
 669                                                          NULL));
 670   if (page) {
 671     s_page_weak_ref (page, (NotifyFunction) page_deleted, view);
 672   }
 673
 674   return view;
 675 }
 676
 677
 678
 679 /*! \brief Pan the view on the given world coordinate using given zoom factor
 680  *
 681  *  \param [in,out] page_view This GschemPageView
 682  *  \param [in]     w_x       The world x coordinate of the new center
 683  *  \param [in]     w_y       The world y coordinate of the new center
 684  *  \param [in]     relativ_zoom_factor  The zoom factor
 685  */
 686 void
 687 gschem_page_view_pan_general (GschemPageView *view, int w_x, int w_y, double relativ_zoom_factor)
 688 {
 689   GschemPageGeometry *geometry = NULL;
 690
 691   g_return_if_fail (view != NULL);
 692
 693   geometry = gschem_page_view_get_page_geometry (view);
 694   g_return_if_fail (geometry != NULL);
 695
 696   /* make mouse to the new world-center;
 697      attention: there are information looses because of type cast in mil_x */
 698
 699   gschem_page_geometry_pan_general (geometry, w_x, w_y, relativ_zoom_factor);
 700
 701   g_signal_emit_by_name (view, "update-grid-info");
 702   gschem_page_view_update_scroll_adjustments (view);
 703   gschem_page_view_invalidate_all (view);
 704 }
 705
 706
 707 /*! \brief Center the view on the given world coordinate
 708  *
 709  *  \param [in,out] page_view This GschemPageView
 710  *  \param [in]     w_x       The world x coordinate of the new center
 711  *  \param [in]     w_y       The world y coordinate of the new center
 712  */
 713 void
 714 gschem_page_view_pan (GschemPageView *view, int w_x, int w_y)
 715 {
 716   gschem_page_view_pan_general (view, w_x, w_y, 1);
 717   /* Trigger a motion event to update the objects being drawn */
 718   /* This works e.g. if the view is centered at the mouse pointer position */
 719   x_event_faked_motion (view, NULL);
 720
 721   gschem_page_view_update_scroll_adjustments (view);
 722   gschem_page_view_invalidate_all (view);
 723 }
 724
 725
 726
 727 /*! \brief Pan the view by the given screen coordinate displacement
 728  *
 729  *  \param [in,out] view      This GschemPageView
 730  *  \param [in]     diff_x    The screen x coordinate displacement
 731  *  \param [in]     diff_y    The screen y coordinate displacement
 732  */
 733 void
 734 gschem_page_view_pan_mouse (GschemPageView *view, int diff_x, int diff_y)
 735 {
 736   GschemPageGeometry *geometry = NULL;
 737   double world_cx, world_cy;
 738   double page_cx, page_cy;
 739
 740   g_return_if_fail (view != NULL);
 741
 742   geometry = gschem_page_view_get_page_geometry (view);
 743   g_return_if_fail (geometry != NULL);
 744
 745 #if DEBUG
 746   printf("gschem_page_view_pan_mouse(): diff_x=%d, diff_y=%d\n", diff_x, diff_y);
 747 #endif
 748
 749   page_cx = (gschem_page_geometry_get_viewport_left (geometry) + gschem_page_geometry_get_viewport_right (geometry)) / 2.0;
 750   page_cy = (gschem_page_geometry_get_viewport_top (geometry) + gschem_page_geometry_get_viewport_bottom (geometry)) / 2.0;
 751
 752   world_cx = page_cx - gschem_page_view_WORLDabs (view, diff_x);
 753   world_cy = page_cy + gschem_page_view_WORLDabs (view, diff_y);
 754
 755 #if DEBUG
 756   printf("  world_cx=%f, world_cy=%f\n", world_cx, world_cy);
 757 #endif
 758
 759   gschem_page_view_pan_general (view, world_cx, world_cy, 1);
 760
 761   /* Trigger a motion event to update the objects being drawn */
 762   /* Don't emit such an event if diffs are zero to avoid recursion */
 763   if (diff_x == 0 && diff_y == 0) {
 764     x_event_faked_motion (view, NULL);
 765   }
 766 }
 767
 768
 769
 770 /*! \brief Start mouse panning in the view
 771  *  \par Function Description
 772  *  This function saves current coordinates of the mouse pointer
 773  *  to pan_x and pan_y  and toggles the view into pan mode.
 774  *
 775  *  \param [in,out] view  This GschemPageView
 776  *  \param [in]     x     The screen x coordinate
 777  *  \param [in]     y     The screen y coordinate
 778  */
 779 void gschem_page_view_pan_start (GschemPageView *view, int x, int y)
 780 {
 781   view->doing_pan = TRUE;
 782   view->pan_x = x;
 783   view->pan_y = y;
 784   view->throttle = 0;
 785 }
 786
 787
 788
 789 /*! \brief Continue mouse panning in the view
 790  *  \par Function Description
 791  *  In the view pan mode, this function calculates displacement of
 792  *  the mouse pointer relative to its previous position and repans
 793  *  the view taking into account the given mouse pan gain setting.
 794  *  Then it replaces pan_x and pan_y with the new coordinates.
 795  *
 796  *  \param [in,out] view            This GschemPageView
 797  *  \param [in]     mousepan_gain   Mouse pan gain
 798  *  \param [in]     x               The new screen x coordinate
 799  *  \param [in]     y               The new screen y coordinate
 800  */
 801 void
 802 gschem_page_view_pan_motion (GschemPageView *view, int mousepan_gain, int x, int y)
 803 {
 804   int pdiff_x, pdiff_y;
 805
 806   if (view->doing_pan) {
 807     pdiff_x = x - view->pan_x;
 808     pdiff_y = y - view->pan_y;
 809
 810     if (!(view->throttle % 5)) {
 811       gschem_page_view_pan_mouse(view,
 812                                  pdiff_x * mousepan_gain,
 813                                  pdiff_y * mousepan_gain);
 814
 815       view->pan_x = x;
 816       view->pan_y = y;
 817     }
 818     view->throttle++;
 819   }
 820 }
 821
 822 /*! \brief End mouse panning in the view
 823  *  \par Function Description
 824  *  This function resets the view pan mode and invalidates the
 825  *  view after panning.
 826  *
 827  *  \param [in,out] view      This GschemPageView
 828  *  \returns TRUE if panning has been finished, or FALSE if there was no panning
 829  */
 830 gboolean
 831 gschem_page_view_pan_end (GschemPageView *view)
 832 {
 833   if (view->doing_pan) {
 834     gschem_page_view_invalidate_all (view);
 835     view->doing_pan = FALSE;
 836     return TRUE;
 837   } else {
 838     return FALSE;
 839   }
 840 }
 841
 842
 843
 844 /*! \brief Transform SCREEN coordinates to WORLD coordinates
 845  *  \par Function Description
 846  *  This function takes in SCREEN x/y coordinates and
 847  *  transforms them to WORLD x/y coordinates.
 848  *
 849  *  \param [in]  view       The GschemPageView object.
 850  *  \param [in]  mx         The x coordinate in SCREEN units.
 851  *  \param [in]  my         The y coordinate in SCREEN units.
 852  *  \param [out] x          The x coordinate in WORLD units.
 853  *  \param [out] y          The y coordinate in WORLD units.
 854  *  \note Question: why are we returning in x and y
 855  *                  if this is SCREEN to WORLD shouldn't WORLD
 856  *                  coordinates be returned in mx and my?
 857  */
 858 void
 859 gschem_page_view_SCREENtoWORLD (GschemPageView *view, int mx, int my, int *x, int *y)
 860 {
 861   GschemPageGeometry *geometry = gschem_page_view_get_page_geometry (view);
 862
 863   g_return_if_fail (geometry != NULL);
 864
 865   *x = gschem_page_geometry_mil_x (geometry, mx);
 866   *y = gschem_page_geometry_mil_y (geometry, my);
 867 }
 868
 869
 870
 871 /*! \brief Set the horizontal scroll adjustment for this view
 872  *
 873  *  \param [in,out] view The view
 874  *  \param [in]     hadjustment The horizontal scroll adjustment
 875  */
 876 void
 877 gschem_page_view_set_hadjustment (GschemPageView *view, GtkAdjustment *hadjustment)
 878 {
 879   g_return_if_fail (view != NULL);
 880
 881   if (view->hadjustment != NULL) {
 882     g_signal_handlers_disconnect_by_func (G_OBJECT (view->hadjustment),
 883                                           G_CALLBACK (hadjustment_value_changed),
 884                                           view);
 885
 886     g_object_unref (view->hadjustment);
 887   }
 888
 889   view->hadjustment = hadjustment;
 890
 891   if (view->hadjustment != NULL) {
 892     g_object_ref (view->hadjustment);
 893
 894     g_signal_connect (G_OBJECT (view->hadjustment),
 895                       "value-changed",
 896                       G_CALLBACK (hadjustment_value_changed),
 897                       view);
 898   }
 899
 900   g_object_notify (G_OBJECT (view), "hadjustment");
 901 }
 902
 903
 904
 905 /*! \brief Set the page for this view
 906  *
 907  *  The toplevel property must be set and the page must belong to that
 908  *  toplevel.
 909  *
 910  *  \param [in,out] view The view
 911  *  \param [in]     page The page
 912  */
 913 void
 914 gschem_page_view_set_page (GschemPageView *view, PAGE *page)
 915 {
 916   g_return_if_fail (view != NULL);
 917   g_return_if_fail (view->geometry_table != NULL);
 918
 919   if (page != view->page) {
 920
 921     view->page = page;
 922
 923     if (page) {
 924       s_page_weak_ref (page, (NotifyFunction) page_deleted, view);
 925
 926       g_return_if_fail (page->toplevel != NULL);
 927       s_page_goto (page->toplevel, page);
 928       /* gschem_toplevel_page_changed is called by the notify::page handler */
 929
 930       /* redraw the current page and update UI */
 931       gschem_page_view_invalidate_all (view);
 932       if (gtk_widget_get_window (GTK_WIDGET (view)) != NULL)
 933         gschem_page_view_update_scroll_adjustments (view);
 934
 935       g_object_notify (G_OBJECT (view), "page");
 936       g_object_notify (G_OBJECT (view), "page-geometry");
 937       g_signal_emit_by_name (view, "update-grid-info");
 938
 939     } else {
 940       if (view->hadjustment != NULL) {
 941         gtk_adjustment_set_page_size (view->hadjustment,
 942                                       gtk_adjustment_get_upper (view->hadjustment));
 943       }
 944       if (view->vadjustment != NULL) {
 945         gtk_adjustment_set_page_size (view->vadjustment,
 946                                       gtk_adjustment_get_upper (view->vadjustment));
 947       }
 948     }
 949   }
 950 }
 951
 952
 953 /*! \brief Set the vertical scroll adjustment for this view
 954  *
 955  *  \param [in,out] view The view
 956  *  \param [in]     vadjustment The vertical scroll adjustment
 957  */
 958 void
 959 gschem_page_view_set_vadjustment (GschemPageView *view, GtkAdjustment *vadjustment)
 960 {
 961   g_return_if_fail (view != NULL);
 962
 963   if (view->vadjustment != NULL) {
 964     g_signal_handlers_disconnect_by_func (G_OBJECT (view->vadjustment),
 965                                           G_CALLBACK (vadjustment_value_changed),
 966                                           view);
 967
 968     g_object_unref (view->vadjustment);
 969   }
 970
 971   view->vadjustment = vadjustment;
 972
 973   if (view->vadjustment != NULL) {
 974     g_object_ref (view->vadjustment);
 975
 976     g_signal_connect (G_OBJECT (view->vadjustment),
 977                       "value-changed",
 978                       G_CALLBACK (vadjustment_value_changed),
 979                       view);
 980   }
 981
 982   g_object_notify (G_OBJECT (view), "vadjustment");
 983 }
 984
 985
 986
 987 /*! \brief Signal handler for a horizontal scroll adjustment change
 988  */
 989 static void
 990 hadjustment_value_changed (GtkAdjustment *hadjustment, GschemPageView *view)
 991 {
 992   g_return_if_fail (hadjustment != NULL);
 993   g_return_if_fail (view != NULL);
 994
 995   GschemPageGeometry *geometry = gschem_page_view_get_page_geometry (view);
 996
 997   if (view->hadjustment != NULL && geometry != NULL) {
 998     int current_left;
 999     int new_left;
1000
1001     g_return_if_fail (view->hadjustment == hadjustment);
1002
1003     current_left = gschem_page_geometry_get_viewport_left (geometry),
1004     new_left = (int) hadjustment->value;
1005
1006     geometry->viewport_left = new_left;
1007     geometry->viewport_right = geometry->viewport_right - (current_left - new_left);
1008
1009     gschem_page_view_invalidate_all (view);
1010   }
1011 }
1012
1013
1014
1015 /*! \brief Set a gobject property
1016  */
1017 static void
1018 set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec)
1019 {
1020   GschemPageView *view = GSCHEM_PAGE_VIEW (object);
1021
1022   switch (param_id) {
1023     case PROP_HADJUSTMENT:
1024       gschem_page_view_set_hadjustment (view, g_value_get_object (value));
1025       break;
1026
1027     case PROP_PAGE:
1028       gschem_page_view_set_page (view, g_value_get_pointer (value));
1029       break;
1030
1031     case PROP_VADJUSTMENT:
1032       gschem_page_view_set_vadjustment (view, g_value_get_object (value));
1033       break;
1034
1035     default:
1036       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1037   }
1038 }
1039
1040
1041
1042 /*! \brief Get absolute SCREEN value
1043  *
1044  *  \par Function Description
1045  *  Converts WORLD value \a val to absolute SCREEN value.
1046  *
1047  *  \param [in]     view       This GschemPageView
1048  *  \param [in]     val        The value to convert
1049  *  \return The converted value in SCREEN pixels
1050  */
1051 int
1052 gschem_page_view_SCREENabs(GschemPageView *view, int val)
1053 {
1054   double f0,f1;
1055   double i;
1056   int j;
1057   GschemPageGeometry *geometry = gschem_page_view_get_page_geometry (view);
1058
1059   g_return_val_if_fail (view != NULL, 0);
1060
1061   if (geometry == NULL) return 0;
1062
1063   f0 = gschem_page_geometry_get_viewport_left  (geometry);
1064   f1 = gschem_page_geometry_get_viewport_right (geometry);
1065   i = (double)(geometry->screen_width) * (double)(val) / (f1 - f0);
1066
1067 #ifdef HAS_RINT
1068   j = rint(i);
1069 #else
1070   j = i;
1071 #endif
1072
1073   return(j);
1074 }
1075
1076
1077
1078 /*! \brief Update the horizontal scroll adjustment
1079  */
1080 static void
1081 gschem_page_view_update_hadjustment (GschemPageView *view)
1082 {
1083   g_return_if_fail (view != NULL);
1084
1085   GschemPageGeometry *geometry = gschem_page_view_get_page_geometry (view);
1086
1087   if (view->hadjustment != NULL && geometry != NULL) {
1088
1089     gtk_adjustment_set_page_increment (view->hadjustment,
1090                                        abs (geometry->viewport_right - geometry->viewport_left) - 100.0);
1091
1092     gtk_adjustment_set_page_size (view->hadjustment,
1093                                   abs (geometry->viewport_right - geometry->viewport_left));
1094
1095     gtk_adjustment_set_value (view->hadjustment,
1096                                geometry->viewport_left);
1097
1098 #if DEBUG
1099     printf("H %f %f\n", view->hadjustment->lower, view->hadjustment->upper);
1100     printf("Hp %f\n", view->hadjustment->page_size);
1101 #endif
1102
1103     gtk_adjustment_changed(view->hadjustment);
1104     gtk_adjustment_value_changed (view->hadjustment);
1105   }
1106 }
1107
1108
1109
1110 /*! \brief Update the scroll adjustments
1111  */
1112 void
1113 gschem_page_view_update_scroll_adjustments (GschemPageView *view)
1114 {
1115   g_return_if_fail (view != NULL);
1116
1117   gschem_page_view_update_hadjustment (view);
1118   gschem_page_view_update_vadjustment (view);
1119 }
1120
1121
1122
1123 /*! \brief Update the vertical scroll adjustment
1124  */
1125 static void
1126 gschem_page_view_update_vadjustment (GschemPageView *view)
1127 {
1128   g_return_if_fail (view != NULL);
1129
1130   GschemPageGeometry *geometry = gschem_page_view_get_page_geometry (view);
1131
1132   if (view->vadjustment != NULL && geometry != NULL) {
1133
1134     gtk_adjustment_set_page_increment(view->vadjustment,
1135                                       abs (geometry->viewport_bottom - geometry->viewport_top) - 100.0);
1136
1137     gtk_adjustment_set_page_size (view->vadjustment,
1138                                   abs (geometry->viewport_bottom - geometry->viewport_top));
1139
1140     gtk_adjustment_set_value(view->vadjustment,
1141                              geometry->world_bottom - geometry->viewport_bottom);
1142
1143 #if DEBUG
1144     printf("V %f %f\n", view->vadjustment->lower, view->vadjustment->upper);
1145     printf("Vp %f\n", view->vadjustment->page_size);
1146 #endif
1147
1148     gtk_adjustment_changed(view->vadjustment);
1149     gtk_adjustment_value_changed (view->vadjustment);
1150   }
1151 }
1152
1153
1154 /*! \brief Get absolute WORLD coordinate.
1155  *  \par Function Description
1156  *  Get absolute WORLD coordinate.
1157  *
1158  *  \param [in,out] view The view
1159  *  \param [in]     val        The coordinate to convert.
1160  *  \return The converted WORLD coordinate.
1161  */
1162 int
1163 gschem_page_view_WORLDabs(GschemPageView *page_view, int val)
1164 {
1165   GtkAllocation allocation;
1166   double fw0,fw1,fw,fval;
1167   double i;
1168   int j;
1169
1170   GschemPageGeometry *geometry = gschem_page_view_get_page_geometry (page_view);
1171
1172   gtk_widget_get_allocation (GTK_WIDGET(page_view), &allocation);
1173
1174   fw1 = geometry->viewport_right;
1175   fw0 = geometry->viewport_left;
1176   fw  = allocation.width;
1177   fval = val;
1178   i = fval * (fw1 - fw0) / fw;
1179
1180 #ifdef HAS_RINT
1181   j = rint(i);
1182 #else
1183   j = i;
1184 #endif
1185
1186   return(j);
1187 }
1188
1189
1190
1191 /*! \brief
1192  *
1193  */
1194 static void
1195 remove_page_weak_reference (PAGE *page, gpointer geometry, GschemPageView *view)
1196 {
1197   typedef void (*NotifyFunction) (void*,void*);
1198
1199   g_return_if_fail (page != NULL);
1200   g_return_if_fail (view != NULL);
1201
1202   s_page_weak_unref (page, (NotifyFunction) page_deleted, view);
1203 }
1204
1205
1206
1207 /*! \brief
1208  *
1209  */
1210 static void
1211 page_deleted (PAGE *page, GschemPageView *view)
1212 {
1213   g_return_if_fail (page != NULL);
1214   g_return_if_fail (view != NULL);
1215   g_return_if_fail (view->geometry_table != NULL);
1216
1217   g_hash_table_remove (view->geometry_table, page);
1218   if (view->page == page)
1219     gschem_page_view_set_page (view, NULL);
1220 }
1221
1222
1223
1224 /*! \brief Signal handler for setting the scroll adjustments
1225  *
1226  *  Sent from the GtkScrolledWindow to set the adjustments for the
1227  *  corresponding scroll bars.
1228  */
1229 static void
1230 set_scroll_adjustments (GschemPageView *view, GtkAdjustment *hadjustment, GtkAdjustment *vadjustment)
1231 {
1232   gschem_page_view_set_hadjustment (view, hadjustment);
1233   gschem_page_view_set_vadjustment (view, vadjustment);
1234 }
1235
1236
1237
1238 /*! \brief Signal handler for a vertical scroll adjustment change
1239  */
1240 static void
1241 vadjustment_value_changed (GtkAdjustment *vadjustment, GschemPageView *view)
1242 {
1243   g_return_if_fail (vadjustment != NULL);
1244   g_return_if_fail (view != NULL);
1245
1246   GschemPageGeometry *geometry = gschem_page_view_get_page_geometry (view);
1247
1248   if (view->vadjustment != NULL && geometry != NULL) {
1249     int current_bottom;
1250     int new_bottom;
1251
1252     g_return_if_fail (view->vadjustment == vadjustment);
1253
1254     current_bottom = geometry->viewport_bottom;
1255     new_bottom = geometry->world_bottom - (int) vadjustment->value;
1256
1257     geometry->viewport_bottom = new_bottom;
1258     geometry->viewport_top = geometry->viewport_top - (current_bottom - new_bottom);
1259
1260     gschem_page_view_invalidate_all (view);
1261   }
1262 }
1263
1264
1265
1266 /*! \brief Transform WORLD coordinates to SCREEN coordinates
1267  */
1268 void
1269 gschem_page_view_WORLDtoSCREEN (GschemPageView *view, int x, int y, int *px, int *py)
1270 {
1271   GschemPageGeometry *geometry = gschem_page_view_get_page_geometry (view);
1272
1273   *px = *py = 0;
1274
1275   g_return_if_fail (geometry != NULL);
1276
1277   *px = gschem_page_geometry_pix_x (geometry, x);
1278   *py = gschem_page_geometry_pix_y (geometry, y);
1279 }
1280
1281
1282
1283 /*! \brief Zoom the view to the extents of a set of objects
1284  *
1285  *  By providing a NULL for the objects parameter, this function will zoom to
1286  *  the extents of all objects in the drawing.
1287  *
1288  *  \param [in,out] view    This GschemPageView
1289  *  \param [in]     objects The list of objects to compute extents, or NULL
1290  */
1291 void
1292 gschem_page_view_zoom_extents (GschemPageView *view, const GList *objects)
1293 {
1294   GschemPageGeometry *geometry = NULL;
1295   PAGE *page = NULL;
1296   const GList *temp = objects;
1297
1298   g_return_if_fail (view != NULL);
1299
1300   page = gschem_page_view_get_page (view);
1301   g_return_if_fail (page != NULL);
1302
1303   geometry = gschem_page_view_get_page_geometry (view);
1304   g_return_if_fail (geometry != NULL);
1305
1306   if (temp == NULL) {
1307     temp = s_page_objects (gschem_page_view_get_page (view));
1308   }
1309
1310   gschem_page_geometry_zoom_extents (geometry, page->toplevel, temp);
1311
1312   /* Trigger a motion event to update the objects being drawn */
1313   x_event_faked_motion (view, NULL);
1314
1315   g_signal_emit_by_name (view, "update-grid-info");
1316   gschem_page_view_update_scroll_adjustments (view);
1317   gschem_page_view_invalidate_all (view);
1318 }
1319
1320 /*! \brief utility function to find the first parent that has a ->page
1321  *
1322  *  \param [in] object    The object
1323  *  \return the parent object that had a non-NULL ->page
1324  */
1325 OBJECT *gschem_page_get_page_object(OBJECT *object)
1326 {
1327   OBJECT *page_obj = object;
1328   while((page_obj != NULL) && (page_obj->page == NULL))
1329     page_obj = page_obj->parent;
1330   return page_obj;
1331 }
1332
1333 /*! \brief Zoom in on a single text object
1334  *
1335  *  \param [in] view      This GschemPageView
1336  *  \param [in] object    The text object
1337  */
1338 void
1339 gschem_page_view_zoom_text (GschemPageView *view, OBJECT *object, gboolean zoom_hidden)
1340 {
1341   OBJECT *page_obj;
1342   int success;
1343   int x[2];
1344   int y[2];
1345   int viewport_center_x, viewport_center_y, viewport_width, viewport_height;
1346   double k;
1347   int old_show_hidden;
1348
1349   g_return_if_fail (view != NULL);
1350   GschemPageGeometry *geometry = gschem_page_view_get_page_geometry (view);
1351   g_return_if_fail (geometry != NULL);
1352
1353   g_return_if_fail (object != NULL);
1354
1355   page_obj = gschem_page_get_page_object(object);
1356
1357   g_return_if_fail (page_obj->page != NULL);
1358   g_return_if_fail (page_obj->page->toplevel != NULL);
1359   g_return_if_fail (object->text != NULL);
1360
1361   if (zoom_hidden) {
1362     old_show_hidden = page_obj->page->toplevel->show_hidden_text;
1363     page_obj->page->toplevel->show_hidden_text = 1;
1364   }
1365
1366   success = world_get_single_object_bounds (page_obj->page->toplevel,
1367                                             object,
1368                                             &x[0],
1369                                             &y[0],
1370                                             &x[1],
1371                                             &y[1]);
1372   if (zoom_hidden)
1373     page_obj->page->toplevel->show_hidden_text = old_show_hidden;
1374
1375   if (success) {
1376
1377     /* Here we are trying to make the text screen height to be about */
1378     /* 50 pixels high, perhaps a future enhancement will be to make */
1379     /* this number configurable */
1380     viewport_center_x = (x[1] + x[0]) / 2;
1381     viewport_center_y = (y[1] + y[0]) / 2;
1382     k = ((y[1] - y[0]) / 50);
1383     viewport_height = geometry->screen_height * k;
1384     viewport_width  = geometry->screen_width  * k;
1385
1386     gschem_page_geometry_set_values (geometry,
1387                                      k,
1388                                      geometry->screen_width,
1389                                      geometry->screen_height,
1390                                      viewport_center_x - viewport_width / 2,
1391                                      viewport_center_y - viewport_height / 2,
1392                                      viewport_center_x + viewport_width / 2,
1393                                      viewport_center_y + viewport_height / 2);
1394
1395     gschem_page_view_invalidate_all (view);
1396   }
1397 }
1398
1399
1400 /*! \brief Redraw page on the view
1401  *
1402  *  \param [in] view      The GschemPageView object which page to redraw
1403  */
1404 void
1405 gschem_page_view_redraw (GschemPageView *view, GdkEventExpose *event, GschemToplevel *w_current)
1406 {
1407   GschemPageGeometry *geometry;
1408   PAGE *page;
1409
1410 #if DEBUG
1411   printf("EXPOSE\n");
1412 #endif
1413
1414   g_return_if_fail (view != NULL);
1415   g_return_if_fail (w_current != NULL);
1416
1417   page = gschem_page_view_get_page (view);
1418
1419   if (page != NULL) {
1420     geometry = gschem_page_view_get_page_geometry (view);
1421
1422     g_return_if_fail (view != NULL);
1423
1424     o_redraw_rect (w_current,
1425                    gtk_widget_get_window (GTK_WIDGET(view)),
1426                    page,
1427                    geometry,
1428                    &(event->area));
1429   }
1430 }