src/desktop.cpp

   1 #define __SP_DESKTOP_C__
   2
   3 /** \file
   4  * Editable view implementation
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   MenTaLguY <mental@rydia.net>
   9  *   bulia byak <buliabyak@users.sf.net>
  10  *   Ralf Stephan <ralf@ark.in-berlin.de>
  11  *   John Bintz <jcoswell@coswellproductions.org>
  12  *   Johan Engelen <j.b.c.engelen@ewi.utwente.nl>
  13  *
  14  * Copyright (C) 2007 Jon A. Cruz
  15  * Copyright (C) 2006-2007 Johan Engelen
  16  * Copyright (C) 2006 John Bintz
  17  * Copyright (C) 2004 MenTaLguY
  18  * Copyright (C) 1999-2002 Lauris Kaplinski
  19  * Copyright (C) 2000-2001 Ximian, Inc.
  20  *
  21  * Released under GNU GPL, read the file 'COPYING' for more information
  22  */
  23
  24 /** \class SPDesktop
  25  * SPDesktop is a subclass of View, implementing an editable document
  26  * canvas.  It is extensively used by many UI controls that need certain
  27  * visual representations of their own.
  28  *
  29  * SPDesktop provides a certain set of SPCanvasItems, serving as GUI
  30  * layers of different control objects. The one containing the whole
  31  * document is the drawing layer. In addition to it, there are grid,
  32  * guide, sketch and control layers. The sketch layer is used for
  33  * temporary drawing objects, before the real objects in document are
  34  * created. The control layer contains editing knots, rubberband and
  35  * similar non-document UI objects.
  36  *
  37  * Each SPDesktop is associated with a SPNamedView node of the document
  38  * tree.  Currently, all desktops are created from a single main named
  39  * view, but in the future there may be support for different ones.
  40  * SPNamedView serves as an in-document container for desktop-related
  41  * data, like grid and guideline placement, snapping options and so on.
  42  *
  43  * Associated with each SPDesktop are the two most important editing
  44  * related objects - SPSelection and SPEventContext.
  45  *
  46  * Sodipodi keeps track of the active desktop and invokes notification
  47  * signals whenever it changes. UI elements can use these to update their
  48  * display to the selection of the currently active editing window.
  49  * (Lauris Kaplinski)
  50  */
  51
  52 #ifdef HAVE_CONFIG_H
  53 # include "config.h"
  54 #endif
  55
  56 #include <glibmm/i18n.h>
  57 #include <sigc++/functors/mem_fun.h>
  58 #include <gtkmm.h>
  59
  60 #include "macros.h"
  61 #include "inkscape-private.h"
  62 #include "desktop.h"
  63 #include "desktop-events.h"
  64 #include "desktop-handles.h"
  65 #include "document.h"
  66 #include "message-stack.h"
  67 #include "selection.h"
  68 #include "select-context.h"
  69 #include "sp-namedview.h"
  70 #include "color.h"
  71 #include "sp-item-group.h"
  72 #include "prefs-utils.h"
  73 #include "object-hierarchy.h"
  74 #include "helper/units.h"
  75 #include "display/canvas-arena.h"
  76 #include "display/nr-arena.h"
  77 #include "display/gnome-canvas-acetate.h"
  78 #include "display/sodipodi-ctrlrect.h"
  79 #include "display/sp-canvas-util.h"
  80 #include "libnr/nr-matrix-div.h"
  81 #include "libnr/nr-rect-ops.h"
  82 #include "ui/dialog/dialog-manager.h"
  83 #include "xml/repr.h"
  84 #include "message-context.h"
  85 #include "layer-manager.h"
  86 #include "event-log.h"
  87 #include "display/canvas-grid.h"
  88
  89 #include "display/sp-canvas.h"
  90
  91 namespace Inkscape { namespace XML { class Node; }}
  92
  93 // Callback declarations
  94 static void _onSelectionChanged (Inkscape::Selection *selection, SPDesktop *desktop);
  95 static gint _arena_handler (SPCanvasArena *arena, NRArenaItem *ai, GdkEvent *event, SPDesktop *desktop);
  96 static void _layer_activated(SPObject *layer, SPDesktop *desktop);
  97 static void _layer_deactivated(SPObject *layer, SPDesktop *desktop);
  98 static void _layer_hierarchy_changed(SPObject *top, SPObject *bottom, SPDesktop *desktop);
  99 static void _reconstruction_start(SPDesktop * desktop);
 100 static void _reconstruction_finish(SPDesktop * desktop);
 101 static void _namedview_modified (SPObject *obj, guint flags, SPDesktop *desktop);
 102 static void _update_snap_distances (SPDesktop *desktop);
 103
 104 /**
 105  * Return new desktop object.
 106  * \pre namedview != NULL.
 107  * \pre canvas != NULL.
 108  */
 109 SPDesktop::SPDesktop() :
 110     _dlg_mgr( 0 ),
 111     namedview( 0 ),
 112     canvas( 0 ),
 113     selection( 0 ),
 114     event_context( 0 ),
 115     layer_manager( 0 ),
 116     event_log( 0 ),
 117     acetate( 0 ),
 118     main( 0 ),
 119     gridgroup( 0 ),
 120     guides( 0 ),
 121     drawing( 0 ),
 122     sketch( 0 ),
 123     controls( 0 ),
 124     table( 0 ),
 125     page( 0 ),
 126     page_border( 0 ),
 127     current( 0 ),
 128     zooms_past( 0 ),
 129     zooms_future( 0 ),
 130     dkey( 0 ),
 131     number( 0 ),
 132     is_fullscreen( false ),
 133     interaction_disabled_counter( 0 ),
 134     waiting_cursor( false ),
 135     guides_active( false ),
 136     gr_item( 0 ),
 137     gr_point_type( 0 ),
 138     gr_point_i( 0 ),
 139     gr_fill_or_stroke( true ),
 140     _layer_hierarchy( 0 ),
 141     _reconstruction_old_layer_id( 0 ),
 142     _widget( 0 ),
 143     _inkscape( 0 ),
 144     _guides_message_context( 0 ),
 145     _active( false ),
 146     _w2d(),
 147     _d2w(),
 148     _doc2dt( NR::Matrix(NR::scale(1, -1)) ),
 149     grids_visible( true )
 150 {
 151     _d2w.set_identity();
 152     _w2d.set_identity();
 153
 154     selection = Inkscape::GC::release( new Inkscape::Selection(this) );
 155 }
 156
 157 void
 158 SPDesktop::init (SPNamedView *nv, SPCanvas *aCanvas)
 159 {
 160     _guides_message_context = new Inkscape::MessageContext(const_cast<Inkscape::MessageStack*>(messageStack()));
 161
 162     current = sp_repr_css_attr_inherited (inkscape_get_repr (INKSCAPE, "desktop"), "style");
 163
 164     namedview = nv;
 165     canvas = aCanvas;
 166
 167     SPDocument *document = SP_OBJECT_DOCUMENT (namedview);
 168     /* Kill flicker */
 169     sp_document_ensure_up_to_date (document);
 170
 171     /* Setup Dialog Manager */
 172     _dlg_mgr = new Inkscape::UI::Dialog::DialogManager();
 173
 174     dkey = sp_item_display_key_new (1);
 175
 176     /* Connect document */
 177     setDocument (document);
 178
 179     number = namedview->getViewCount();
 180
 181
 182     /* Setup Canvas */
 183     g_object_set_data (G_OBJECT (canvas), "SPDesktop", this);
 184
 185     SPCanvasGroup *root = sp_canvas_root (canvas);
 186
 187     /* Setup adminstrative layers */
 188     acetate = sp_canvas_item_new (root, GNOME_TYPE_CANVAS_ACETATE, NULL);
 189     g_signal_connect (G_OBJECT (acetate), "event", G_CALLBACK (sp_desktop_root_handler), this);
 190     main = (SPCanvasGroup *) sp_canvas_item_new (root, SP_TYPE_CANVAS_GROUP, NULL);
 191     g_signal_connect (G_OBJECT (main), "event", G_CALLBACK (sp_desktop_root_handler), this);
 192
 193     table = sp_canvas_item_new (main, SP_TYPE_CTRLRECT, NULL);
 194     SP_CTRLRECT(table)->setRectangle(NR::Rect(NR::Point(-80000, -80000), NR::Point(80000, 80000)));
 195     SP_CTRLRECT(table)->setColor(0x00000000, true, 0x00000000);
 196     sp_canvas_item_move_to_z (table, 0);
 197
 198     page = sp_canvas_item_new (main, SP_TYPE_CTRLRECT, NULL);
 199     ((CtrlRect *) page)->setColor(0x00000000, FALSE, 0x00000000);
 200     page_border = sp_canvas_item_new (main, SP_TYPE_CTRLRECT, NULL);
 201
 202     drawing = sp_canvas_item_new (main, SP_TYPE_CANVAS_ARENA, NULL);
 203     g_signal_connect (G_OBJECT (drawing), "arena_event", G_CALLBACK (_arena_handler), this);
 204
 205     SP_CANVAS_ARENA (drawing)->arena->delta = prefs_get_double_attribute ("options.cursortolerance", "value", 1.0); // default is 1 px
 206
 207     if (prefs_get_int_attribute("options.startmode", "outline", 0)) {
 208         // Start in outline mode
 209         setDisplayModeOutline();
 210     } else {
 211         // Start in normal mode, default
 212         setDisplayModeNormal();
 213     }
 214
 215     gridgroup = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 216     guides = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 217     sketch = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 218     controls = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 219
 220     /* Push select tool to the bottom of stack */
 221     /** \todo
 222      * FIXME: this is the only call to this.  Everything else seems to just
 223      * call "set" instead of "push".  Can we assume that there is only one
 224      * context ever?
 225      */
 226     push_event_context (SP_TYPE_SELECT_CONTEXT, "tools.select", SP_EVENT_CONTEXT_STATIC);
 227
 228     // display rect and zoom are now handled in sp_desktop_widget_realize()
 229
 230     NR::Rect const d(NR::Point(0.0, 0.0),
 231                      NR::Point(sp_document_width(document), sp_document_height(document)));
 232
 233     SP_CTRLRECT(page)->setRectangle(d);
 234     SP_CTRLRECT(page_border)->setRectangle(d);
 235
 236     /* the following sets the page shadow on the canvas
 237        It was originally set to 5, which is really cheesy!
 238        It now is an attribute in the document's namedview. If a value of
 239        0 is used, then the constructor for a shadow is not initialized.
 240     */
 241
 242     if ( namedview->pageshadow != 0 && namedview->showpageshadow ) {
 243         SP_CTRLRECT(page_border)->setShadow(namedview->pageshadow, 0x3f3f3fff);
 244     }
 245
 246
 247     /* Connect event for page resize */
 248     _doc2dt[5] = sp_document_height (document);
 249     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (drawing), _doc2dt);
 250
 251     _modified_connection = namedview->connectModified(sigc::bind<2>(sigc::ptr_fun(&_namedview_modified), this));
 252
 253     NRArenaItem *ai = sp_item_invoke_show (SP_ITEM (sp_document_root (document)),
 254             SP_CANVAS_ARENA (drawing)->arena,
 255             dkey,
 256             SP_ITEM_SHOW_DISPLAY);
 257     if (ai) {
 258         nr_arena_item_add_child (SP_CANVAS_ARENA (drawing)->root, ai, NULL);
 259         nr_arena_item_unref (ai);
 260     }
 261
 262     namedview->show(this);
 263     /* Ugly hack */
 264     activate_guides (true);
 265     /* Ugly hack */
 266     _namedview_modified (namedview, SP_OBJECT_MODIFIED_FLAG, this);
 267
 268 /* Set up notification of rebuilding the document, this allows
 269        for saving object related settings in the document. */
 270     _reconstruction_start_connection =
 271         document->connectReconstructionStart(sigc::bind(sigc::ptr_fun(_reconstruction_start), this));
 272     _reconstruction_finish_connection =
 273         document->connectReconstructionFinish(sigc::bind(sigc::ptr_fun(_reconstruction_finish), this));
 274     _reconstruction_old_layer_id = NULL;
 275
 276     // ?
 277     // sp_active_desktop_set (desktop);
 278     _inkscape = INKSCAPE;
 279
 280     _activate_connection = _activate_signal.connect(
 281         sigc::bind(
 282             sigc::ptr_fun(_onActivate),
 283             this
 284         )
 285     );
 286      _deactivate_connection = _deactivate_signal.connect(
 287         sigc::bind(
 288             sigc::ptr_fun(_onDeactivate),
 289             this
 290         )
 291     );
 292
 293     _sel_modified_connection = selection->connectModified(
 294         sigc::bind(
 295             sigc::ptr_fun(&_onSelectionModified),
 296             this
 297         )
 298     );
 299     _sel_changed_connection = selection->connectChanged(
 300         sigc::bind(
 301             sigc::ptr_fun(&_onSelectionChanged),
 302             this
 303         )
 304     );
 305
 306
 307     /* setup LayerManager */
 308     //   (Setting up after the connections are all in place, as it may use some of them)
 309     layer_manager = new Inkscape::LayerManager( this );
 310
 311     grids_visible = true;
 312 }
 313
 314
 315 void SPDesktop::destroy()
 316 {
 317     _activate_connection.disconnect();
 318     _deactivate_connection.disconnect();
 319     _sel_modified_connection.disconnect();
 320     _sel_changed_connection.disconnect();
 321     _modified_connection.disconnect();
 322     _commit_connection.disconnect();
 323     _reconstruction_start_connection.disconnect();
 324     _reconstruction_finish_connection.disconnect();
 325
 326     g_signal_handlers_disconnect_by_func(G_OBJECT (acetate), (gpointer) G_CALLBACK(sp_desktop_root_handler), this);
 327     g_signal_handlers_disconnect_by_func(G_OBJECT (main), (gpointer) G_CALLBACK(sp_desktop_root_handler), this);
 328     g_signal_handlers_disconnect_by_func(G_OBJECT (drawing), (gpointer) G_CALLBACK(_arena_handler), this);
 329
 330     while (event_context) {
 331         SPEventContext *ec = event_context;
 332         event_context = ec->next;
 333         sp_event_context_finish (ec);
 334         g_object_unref (G_OBJECT (ec));
 335     }
 336
 337     if (_layer_hierarchy) {
 338         delete _layer_hierarchy;
 339     }
 340
 341     if (_inkscape) {
 342         _inkscape = NULL;
 343     }
 344
 345     if (drawing) {
 346         sp_item_invoke_hide (SP_ITEM (sp_document_root (doc())), dkey);
 347         drawing = NULL;
 348     }
 349
 350     delete _guides_message_context;
 351     _guides_message_context = NULL;
 352
 353     g_list_free (zooms_past);
 354     g_list_free (zooms_future);
 355 }
 356
 357 SPDesktop::~SPDesktop() {}
 358
 359 //--------------------------------------------------------------------
 360 /* Public methods */
 361
 362 void SPDesktop::setDisplayModeNormal()
 363 {
 364     SP_CANVAS_ARENA (drawing)->arena->rendermode = RENDERMODE_NORMAL;
 365     canvas->rendermode = RENDERMODE_NORMAL; // canvas needs that for choosing the best buffer size
 366     displayMode = RENDERMODE_NORMAL;
 367     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (main), _d2w); // redraw
 368     _widget->setTitle(SP_DOCUMENT_NAME(sp_desktop_document(this)));
 369 }
 370
 371 void SPDesktop::setDisplayModeOutline()
 372 {
 373     SP_CANVAS_ARENA (drawing)->arena->rendermode = RENDERMODE_OUTLINE;
 374     canvas->rendermode = RENDERMODE_OUTLINE; // canvas needs that for choosing the best buffer size
 375     displayMode = RENDERMODE_OUTLINE;
 376     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (main), _d2w); // redraw
 377     _widget->setTitle(SP_DOCUMENT_NAME(sp_desktop_document(this)));
 378 }
 379
 380 void SPDesktop::displayModeToggle()
 381 {
 382     if (displayMode == RENDERMODE_OUTLINE)
 383         setDisplayModeNormal();
 384     else
 385         setDisplayModeOutline();
 386 }
 387
 388 /**
 389  * Returns current root (=bottom) layer.
 390  */
 391 SPObject *SPDesktop::currentRoot() const
 392 {
 393     return _layer_hierarchy ? _layer_hierarchy->top() : NULL;
 394 }
 395
 396 /**
 397  * Returns current top layer.
 398  */
 399 SPObject *SPDesktop::currentLayer() const
 400 {
 401     return _layer_hierarchy ? _layer_hierarchy->bottom() : NULL;
 402 }
 403
 404 /**
 405  * Sets the current layer of the desktop.
 406  *
 407  * Make \a object the top layer.
 408  */
 409 void SPDesktop::setCurrentLayer(SPObject *object) {
 410     g_return_if_fail(SP_IS_GROUP(object));
 411     g_return_if_fail( currentRoot() == object || (currentRoot() && currentRoot()->isAncestorOf(object)) );
 412     // printf("Set Layer to ID: %s\n", SP_OBJECT_ID(object));
 413     _layer_hierarchy->setBottom(object);
 414 }
 415
 416 /**
 417  * Return layer that contains \a object.
 418  */
 419 SPObject *SPDesktop::layerForObject(SPObject *object) {
 420     g_return_val_if_fail(object != NULL, NULL);
 421
 422     SPObject *root=currentRoot();
 423     object = SP_OBJECT_PARENT(object);
 424     while ( object && object != root && !isLayer(object) ) {
 425         object = SP_OBJECT_PARENT(object);
 426     }
 427     return object;
 428 }
 429
 430 /**
 431  * True if object is a layer.
 432  */
 433 bool SPDesktop::isLayer(SPObject *object) const {
 434     return ( SP_IS_GROUP(object)
 435              && ( SP_GROUP(object)->effectiveLayerMode(this->dkey)
 436                   == SPGroup::LAYER ) );
 437 }
 438
 439 /**
 440  * True if desktop viewport fully contains \a item's bbox.
 441  */
 442 bool SPDesktop::isWithinViewport (SPItem *item) const
 443 {
 444     NR::Rect const viewport = get_display_area();
 445     NR::Maybe<NR::Rect> const bbox = sp_item_bbox_desktop(item);
 446     if (bbox) {
 447         return viewport.contains(*bbox);
 448     } else {
 449         return true;
 450     }
 451 }
 452
 453 ///
 454 bool SPDesktop::itemIsHidden(SPItem const *item) const {
 455     return item->isHidden(this->dkey);
 456 }
 457
 458 /**
 459  * Set activate property of desktop; emit signal if changed.
 460  */
 461 void
 462 SPDesktop::set_active (bool new_active)
 463 {
 464     if (new_active != _active) {
 465         _active = new_active;
 466         if (new_active) {
 467             _activate_signal.emit();
 468         } else {
 469             _deactivate_signal.emit();
 470         }
 471     }
 472 }
 473
 474 /**
 475  * Set activate status of current desktop's named view.
 476  */
 477 void
 478 SPDesktop::activate_guides(bool activate)
 479 {
 480     guides_active = activate;
 481     namedview->activateGuides(this, activate);
 482 }
 483
 484 /**
 485  * Make desktop switch documents.
 486  */
 487 void
 488 SPDesktop::change_document (SPDocument *theDocument)
 489 {
 490     g_return_if_fail (theDocument != NULL);
 491
 492     /* unselect everything before switching documents */
 493     selection->clear();
 494
 495     setDocument (theDocument);
 496     _namedview_modified (namedview, SP_OBJECT_MODIFIED_FLAG, this);
 497     _document_replaced_signal.emit (this, theDocument);
 498 }
 499
 500 /**
 501  * Make desktop switch event contexts.
 502  */
 503 void
 504 SPDesktop::set_event_context (GtkType type, const gchar *config)
 505 {
 506     SPEventContext *ec;
 507     while (event_context) {
 508         ec = event_context;
 509         sp_event_context_deactivate (ec);
 510         event_context = ec->next;
 511         sp_event_context_finish (ec);
 512         g_object_unref (G_OBJECT (ec));
 513     }
 514
 515     Inkscape::XML::Node *repr = (config) ? inkscape_get_repr (_inkscape, config) : NULL;
 516     ec = sp_event_context_new (type, this, repr, SP_EVENT_CONTEXT_STATIC);
 517     ec->next = event_context;
 518     event_context = ec;
 519     sp_event_context_activate (ec);
 520     _event_context_changed_signal.emit (this, ec);
 521 }
 522
 523 /**
 524  * Push event context onto desktop's context stack.
 525  */
 526 void
 527 SPDesktop::push_event_context (GtkType type, const gchar *config, unsigned int key)
 528 {
 529     SPEventContext *ref, *ec;
 530     Inkscape::XML::Node *repr;
 531
 532     if (event_context && event_context->key == key) return;
 533     ref = event_context;
 534     while (ref && ref->next && ref->next->key != key) ref = ref->next;
 535     if (ref && ref->next) {
 536         ec = ref->next;
 537         ref->next = ec->next;
 538         sp_event_context_finish (ec);
 539         g_object_unref (G_OBJECT (ec));
 540     }
 541
 542     if (event_context) sp_event_context_deactivate (event_context);
 543     repr = (config) ? inkscape_get_repr (INKSCAPE, config) : NULL;
 544     ec = sp_event_context_new (type, this, repr, key);
 545     ec->next = event_context;
 546     event_context = ec;
 547     sp_event_context_activate (ec);
 548     _event_context_changed_signal.emit (this, ec);
 549 }
 550
 551 /**
 552  * Sets the coordinate status to a given point
 553  */
 554 void
 555 SPDesktop::set_coordinate_status (NR::Point p) {
 556     _widget->setCoordinateStatus(p);
 557 }
 558
 559 /**
 560  * \see sp_document_item_from_list_at_point_bottom()
 561  */
 562 SPItem *
 563 SPDesktop::item_from_list_at_point_bottom (const GSList *list, NR::Point const p) const
 564 {
 565     g_return_val_if_fail (doc() != NULL, NULL);
 566     return sp_document_item_from_list_at_point_bottom (dkey, SP_GROUP (doc()->root), list, p);
 567 }
 568
 569 /**
 570  * \see sp_document_item_at_point()
 571  */
 572 SPItem *
 573 SPDesktop::item_at_point (NR::Point const p, bool into_groups, SPItem *upto) const
 574 {
 575     g_return_val_if_fail (doc() != NULL, NULL);
 576     return sp_document_item_at_point (doc(), dkey, p, into_groups, upto);
 577 }
 578
 579 /**
 580  * \see sp_document_group_at_point()
 581  */
 582 SPItem *
 583 SPDesktop::group_at_point (NR::Point const p) const
 584 {
 585     g_return_val_if_fail (doc() != NULL, NULL);
 586     return sp_document_group_at_point (doc(), dkey, p);
 587 }
 588
 589 /**
 590  * \brief  Returns the mouse point in document coordinates; if mouse is
 591  * outside the canvas, returns the center of canvas viewpoint
 592  */
 593 NR::Point
 594 SPDesktop::point() const
 595 {
 596     NR::Point p = _widget->getPointer();
 597     NR::Point pw = sp_canvas_window_to_world (canvas, p);
 598     p = w2d(pw);
 599
 600     NR::Rect const r = canvas->getViewbox();
 601
 602     NR::Point r0 = w2d(r.min());
 603     NR::Point r1 = w2d(r.max());
 604
 605     if (p[NR::X] >= r0[NR::X] &&
 606         p[NR::X] <= r1[NR::X] &&
 607         p[NR::Y] >= r1[NR::Y] &&
 608         p[NR::Y] <= r0[NR::Y])
 609     {
 610         return p;
 611     } else {
 612         return (r0 + r1) / 2;
 613     }
 614 }
 615
 616 /**
 617  * Put current zoom data in history list.
 618  */
 619 void
 620 SPDesktop::push_current_zoom (GList **history)
 621 {
 622     NR::Rect const area = get_display_area();
 623
 624     NRRect *old_zoom = g_new(NRRect, 1);
 625     old_zoom->x0 = area.min()[NR::X];
 626     old_zoom->x1 = area.max()[NR::X];
 627     old_zoom->y0 = area.min()[NR::Y];
 628     old_zoom->y1 = area.max()[NR::Y];
 629     if ( *history == NULL
 630          || !( ( ((NRRect *) ((*history)->data))->x0 == old_zoom->x0 ) &&
 631                ( ((NRRect *) ((*history)->data))->x1 == old_zoom->x1 ) &&
 632                ( ((NRRect *) ((*history)->data))->y0 == old_zoom->y0 ) &&
 633                ( ((NRRect *) ((*history)->data))->y1 == old_zoom->y1 ) ) )
 634     {
 635         *history = g_list_prepend (*history, old_zoom);
 636     }
 637 }
 638
 639 /**
 640  * Set viewbox.
 641  */
 642 void
 643 SPDesktop::set_display_area (double x0, double y0, double x1, double y1, double border, bool log)
 644 {
 645     g_assert(_widget);
 646
 647     // save the zoom
 648     if (log) {
 649         push_current_zoom(&zooms_past);
 650         // if we do a logged zoom, our zoom-forward list is invalidated, so delete it
 651         g_list_free (zooms_future);
 652         zooms_future = NULL;
 653     }
 654
 655     double const cx = 0.5 * (x0 + x1);
 656     double const cy = 0.5 * (y0 + y1);
 657
 658     NR::Rect const viewbox = NR::expand(canvas->getViewbox(), border);
 659
 660     double scale = expansion(_d2w);
 661     double newscale;
 662     if (((x1 - x0) * viewbox.dimensions()[NR::Y]) > ((y1 - y0) * viewbox.dimensions()[NR::X])) {
 663         newscale = viewbox.dimensions()[NR::X] / (x1 - x0);
 664     } else {
 665         newscale = viewbox.dimensions()[NR::Y] / (y1 - y0);
 666     }
 667
 668     newscale = CLAMP(newscale, SP_DESKTOP_ZOOM_MIN, SP_DESKTOP_ZOOM_MAX);
 669
 670     int clear = FALSE;
 671     if (!NR_DF_TEST_CLOSE (newscale, scale, 1e-4 * scale)) {
 672         /* Set zoom factors */
 673         _d2w = NR::Matrix(NR::scale(newscale, -newscale));
 674         _w2d = NR::Matrix(NR::scale(1/newscale, 1/-newscale));
 675         sp_canvas_item_affine_absolute(SP_CANVAS_ITEM(main), _d2w);
 676         clear = TRUE;
 677     }
 678
 679     /* Calculate top left corner */
 680     x0 = cx - 0.5 * viewbox.dimensions()[NR::X] / newscale;
 681     y1 = cy + 0.5 * viewbox.dimensions()[NR::Y] / newscale;
 682
 683     /* Scroll */
 684     sp_canvas_scroll_to (canvas, x0 * newscale - border, y1 * -newscale - border, clear);
 685
 686     _widget->updateRulers();
 687     _widget->updateScrollbars(expansion(_d2w));
 688     _widget->updateZoom();
 689 }
 690
 691 void SPDesktop::set_display_area(NR::Rect const &a, NR::Coord b, bool log)
 692 {
 693     set_display_area(a.min()[NR::X], a.min()[NR::Y], a.max()[NR::X], a.max()[NR::Y], b, log);
 694 }
 695
 696 /**
 697  * Return viewbox dimensions.
 698  */
 699 NR::Rect SPDesktop::get_display_area() const
 700 {
 701     NR::Rect const viewbox = canvas->getViewbox();
 702
 703     double const scale = _d2w[0];
 704
 705     return NR::Rect(NR::Point(viewbox.min()[NR::X] / scale, viewbox.max()[NR::Y] / -scale),
 706                     NR::Point(viewbox.max()[NR::X] / scale, viewbox.min()[NR::Y] / -scale));
 707 }
 708
 709 /**
 710  * Revert back to previous zoom if possible.
 711  */
 712 void
 713 SPDesktop::prev_zoom()
 714 {
 715     if (zooms_past == NULL) {
 716         messageStack()->flash(Inkscape::WARNING_MESSAGE, _("No previous zoom."));
 717         return;
 718     }
 719
 720     // push current zoom into forward zooms list
 721     push_current_zoom (&zooms_future);
 722
 723     // restore previous zoom
 724     set_display_area (((NRRect *) zooms_past->data)->x0,
 725             ((NRRect *) zooms_past->data)->y0,
 726             ((NRRect *) zooms_past->data)->x1,
 727             ((NRRect *) zooms_past->data)->y1,
 728             0, false);
 729
 730     // remove the just-added zoom from the past zooms list
 731     zooms_past = g_list_remove (zooms_past, ((NRRect *) zooms_past->data));
 732 }
 733
 734 /**
 735  * Set zoom to next in list.
 736  */
 737 void
 738 SPDesktop::next_zoom()
 739 {
 740     if (zooms_future == NULL) {
 741         this->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("No next zoom."));
 742         return;
 743     }
 744
 745     // push current zoom into past zooms list
 746     push_current_zoom (&zooms_past);
 747
 748     // restore next zoom
 749     set_display_area (((NRRect *) zooms_future->data)->x0,
 750             ((NRRect *) zooms_future->data)->y0,
 751             ((NRRect *) zooms_future->data)->x1,
 752             ((NRRect *) zooms_future->data)->y1,
 753             0, false);
 754
 755     // remove the just-used zoom from the zooms_future list
 756     zooms_future = g_list_remove (zooms_future, ((NRRect *) zooms_future->data));
 757 }
 758
 759 /**
 760  * Zoom to point with absolute zoom factor.
 761  */
 762 void
 763 SPDesktop::zoom_absolute_keep_point (double cx, double cy, double px, double py, double zoom)
 764 {
 765     zoom = CLAMP (zoom, SP_DESKTOP_ZOOM_MIN, SP_DESKTOP_ZOOM_MAX);
 766
 767     // maximum or minimum zoom reached, but there's no exact equality because of rounding errors;
 768     // this check prevents "sliding" when trying to zoom in at maximum zoom;
 769     /// \todo someone please fix calculations properly and remove this hack
 770     if (fabs(expansion(_d2w) - zoom) < 0.0001*zoom && (fabs(SP_DESKTOP_ZOOM_MAX - zoom) < 0.01 || fabs(SP_DESKTOP_ZOOM_MIN - zoom) < 0.000001))
 771         return;
 772
 773     NR::Rect const viewbox = canvas->getViewbox();
 774
 775     double const width2 = viewbox.dimensions()[NR::X] / zoom;
 776     double const height2 = viewbox.dimensions()[NR::Y] / zoom;
 777
 778     set_display_area(cx - px * width2,
 779                      cy - py * height2,
 780                      cx + (1 - px) * width2,
 781                      cy + (1 - py) * height2,
 782                      0.0);
 783 }
 784
 785 /**
 786  * Zoom to center with absolute zoom factor.
 787  */
 788 void
 789 SPDesktop::zoom_absolute (double cx, double cy, double zoom)
 790 {
 791     zoom_absolute_keep_point (cx, cy, 0.5, 0.5, zoom);
 792 }
 793
 794 /**
 795  * Zoom to point with relative zoom factor.
 796  */
 797 void
 798 SPDesktop::zoom_relative_keep_point (double cx, double cy, double zoom)
 799 {
 800     NR::Rect const area = get_display_area();
 801
 802     if (cx < area.min()[NR::X]) {
 803         cx = area.min()[NR::X];
 804     }
 805     if (cx > area.max()[NR::X]) {
 806         cx = area.max()[NR::X];
 807     }
 808     if (cy < area.min()[NR::Y]) {
 809         cy = area.min()[NR::Y];
 810     }
 811     if (cy > area.max()[NR::Y]) {
 812         cy = area.max()[NR::Y];
 813     }
 814
 815     gdouble const scale = expansion(_d2w) * zoom;
 816     double const px = (cx - area.min()[NR::X]) / area.dimensions()[NR::X];
 817     double const py = (cy - area.min()[NR::Y]) / area.dimensions()[NR::Y];
 818
 819     zoom_absolute_keep_point(cx, cy, px, py, scale);
 820 }
 821
 822 /**
 823  * Zoom to center with relative zoom factor.
 824  */
 825 void
 826 SPDesktop::zoom_relative (double cx, double cy, double zoom)
 827 {
 828     gdouble scale = expansion(_d2w) * zoom;
 829     zoom_absolute (cx, cy, scale);
 830 }
 831
 832 /**
 833  * Set display area to origin and current document dimensions.
 834  */
 835 void
 836 SPDesktop::zoom_page()
 837 {
 838     NR::Rect d(NR::Point(0, 0),
 839                NR::Point(sp_document_width(doc()), sp_document_height(doc())));
 840
 841     if (d.isEmpty(1.0)) {
 842         return;
 843     }
 844
 845     set_display_area(d, 10);
 846 }
 847
 848 /**
 849  * Set display area to current document width.
 850  */
 851 void
 852 SPDesktop::zoom_page_width()
 853 {
 854     NR::Rect const a = get_display_area();
 855
 856     if (sp_document_width(doc()) < 1.0) {
 857         return;
 858     }
 859
 860     NR::Rect d(NR::Point(0, a.midpoint()[NR::Y]),
 861                NR::Point(sp_document_width(doc()), a.midpoint()[NR::Y]));
 862
 863     set_display_area(d, 10);
 864 }
 865
 866 /**
 867  * Zoom to selection.
 868  */
 869 void
 870 SPDesktop::zoom_selection()
 871 {
 872     NR::Maybe<NR::Rect> const d = selection->bounds();
 873
 874     if ( !d || d->isEmpty(0.1) ) {
 875         return;
 876     }
 877
 878     set_display_area(*d, 10);
 879 }
 880
 881 /**
 882  * Tell widget to let zoom widget grab keyboard focus.
 883  */
 884 void
 885 SPDesktop::zoom_grab_focus()
 886 {
 887     _widget->letZoomGrabFocus();
 888 }
 889
 890 /**
 891  * Zoom to whole drawing.
 892  */
 893 void
 894 SPDesktop::zoom_drawing()
 895 {
 896     g_return_if_fail (doc() != NULL);
 897     SPItem *docitem = SP_ITEM (sp_document_root (doc()));
 898     g_return_if_fail (docitem != NULL);
 899
 900     NR::Maybe<NR::Rect> d = sp_item_bbox_desktop(docitem);
 901
 902     /* Note that the second condition here indicates that
 903     ** there are no items in the drawing.
 904     */
 905     if ( !d || d->isEmpty(1.0) ) {
 906         return;
 907     }
 908
 909     set_display_area(*d, 10);
 910 }
 911
 912 /**
 913  * Scroll canvas by specific coordinate amount.
 914  */
 915 void
 916 SPDesktop::scroll_world (double dx, double dy, bool is_scrolling)
 917 {
 918     g_assert(_widget);
 919
 920     NR::Rect const viewbox = canvas->getViewbox();
 921
 922     sp_canvas_scroll_to(canvas, viewbox.min()[NR::X] - dx, viewbox.min()[NR::Y] - dy, FALSE, is_scrolling);
 923
 924     _widget->updateRulers();
 925     _widget->updateScrollbars(expansion(_d2w));
 926 }
 927
 928 bool
 929 SPDesktop::scroll_to_point (NR::Point const *p, gdouble autoscrollspeed)
 930 {
 931     gdouble autoscrolldistance = (gdouble) prefs_get_int_attribute_limited ("options.autoscrolldistance", "value", 0, -1000, 10000);
 932
 933     // autoscrolldistance is in screen pixels, but the display area is in document units
 934     autoscrolldistance /= expansion(_d2w);
 935     NR::Rect const dbox = NR::expand(get_display_area(), -autoscrolldistance);
 936
 937     if (!((*p)[NR::X] > dbox.min()[NR::X] && (*p)[NR::X] < dbox.max()[NR::X]) ||
 938         !((*p)[NR::Y] > dbox.min()[NR::Y] && (*p)[NR::Y] < dbox.max()[NR::Y])   ) {
 939
 940         NR::Point const s_w( (*p) * _d2w );
 941
 942         gdouble x_to;
 943         if ((*p)[NR::X] < dbox.min()[NR::X])
 944             x_to = dbox.min()[NR::X];
 945         else if ((*p)[NR::X] > dbox.max()[NR::X])
 946             x_to = dbox.max()[NR::X];
 947         else
 948             x_to = (*p)[NR::X];
 949
 950         gdouble y_to;
 951         if ((*p)[NR::Y] < dbox.min()[NR::Y])
 952             y_to = dbox.min()[NR::Y];
 953         else if ((*p)[NR::Y] > dbox.max()[NR::Y])
 954             y_to = dbox.max()[NR::Y];
 955         else
 956             y_to = (*p)[NR::Y];
 957
 958         NR::Point const d_dt(x_to, y_to);
 959         NR::Point const d_w( d_dt * _d2w );
 960         NR::Point const moved_w( d_w - s_w );
 961
 962         if (autoscrollspeed == 0)
 963             autoscrollspeed = prefs_get_double_attribute_limited ("options.autoscrollspeed", "value", 1, 0, 10);
 964
 965         if (autoscrollspeed != 0)
 966             scroll_world (autoscrollspeed * moved_w);
 967
 968         return true;
 969     }
 970     return false;
 971 }
 972
 973 void
 974 SPDesktop::fullscreen()
 975 {
 976     _widget->setFullscreen();
 977 }
 978
 979 void
 980 SPDesktop::getWindowGeometry (gint &x, gint &y, gint &w, gint &h)
 981 {
 982     _widget->getGeometry (x, y, w, h);
 983 }
 984
 985 void
 986 SPDesktop::setWindowPosition (NR::Point p)
 987 {
 988     _widget->setPosition (p);
 989 }
 990
 991 void
 992 SPDesktop::setWindowSize (gint w, gint h)
 993 {
 994     _widget->setSize (w, h);
 995 }
 996
 997 void
 998 SPDesktop::setWindowTransient (void *p, int transient_policy)
 999 {
1000     _widget->setTransient (p, transient_policy);
1001 }
1002
1003 void SPDesktop::getToplevel( GtkWidget*& toplevel )
1004 {
1005     toplevel = GTK_WIDGET( _widget->getWindow() );
1006 }
1007
1008 void
1009 SPDesktop::presentWindow()
1010 {
1011     _widget->present();
1012 }
1013
1014 bool
1015 SPDesktop::warnDialog (gchar *text)
1016 {
1017     return _widget->warnDialog (text);
1018 }
1019
1020 void
1021 SPDesktop::toggleRulers()
1022 {
1023     _widget->toggleRulers();
1024 }
1025
1026 void
1027 SPDesktop::toggleScrollbars()
1028 {
1029     _widget->toggleScrollbars();
1030 }
1031
1032 void
1033 SPDesktop::layoutWidget()
1034 {
1035     _widget->layout();
1036 }
1037
1038 void
1039 SPDesktop::destroyWidget()
1040 {
1041     _widget->destroy();
1042 }
1043
1044 bool
1045 SPDesktop::shutdown()
1046 {
1047     return _widget->shutdown();
1048 }
1049
1050 void
1051 SPDesktop::setToolboxFocusTo (gchar const *label)
1052 {
1053     _widget->setToolboxFocusTo (label);
1054 }
1055
1056 void
1057 SPDesktop::setToolboxAdjustmentValue (gchar const* id, double val)
1058 {
1059     _widget->setToolboxAdjustmentValue (id, val);
1060 }
1061
1062 bool
1063 SPDesktop::isToolboxButtonActive (gchar const *id)
1064 {
1065     return _widget->isToolboxButtonActive (id);
1066 }
1067
1068 void
1069 SPDesktop::emitToolSubselectionChanged(gpointer data)
1070 {
1071         _tool_subselection_changed.emit(data);
1072         inkscape_subselection_changed (this);
1073 }
1074
1075 void
1076 SPDesktop::updateNow()
1077 {
1078   sp_canvas_update_now(canvas);
1079 }
1080
1081 void
1082 SPDesktop::enableInteraction()
1083 {
1084   _widget->enableInteraction();
1085 }
1086
1087 void SPDesktop::disableInteraction()
1088 {
1089   _widget->disableInteraction();
1090 }
1091
1092 void SPDesktop::setWaitingCursor()
1093 {
1094     GdkCursor *waiting = gdk_cursor_new(GDK_WATCH);
1095     gdk_window_set_cursor(GTK_WIDGET(sp_desktop_canvas(this))->window, waiting);
1096     gdk_cursor_unref(waiting);
1097     waiting_cursor = true;
1098
1099     // Stupidly broken GDK cannot just set the new cursor right now - it needs some main loop iterations for that
1100     // Since setting waiting_cursor is usually immediately followed by some Real Work, we must run the iterations here
1101     // CAUTION: iterations may redraw, and redraw may be interrupted, so you cannot assume that anything is the same
1102     // after the call to setWaitingCursor as it was before
1103     while( Gtk::Main::events_pending() )
1104        Gtk::Main::iteration();
1105 }
1106
1107 void SPDesktop::clearWaitingCursor()
1108 {
1109   if (waiting_cursor)
1110       sp_event_context_update_cursor(sp_desktop_event_context(this));
1111 }
1112
1113 void SPDesktop::toggleGrid()
1114 {
1115     if (namedview->grids) {
1116         if(gridgroup) {
1117             grids_visible = !grids_visible;
1118             if (grids_visible) {
1119                 sp_canvas_item_show(SP_CANVAS_ITEM(gridgroup));
1120             } else {
1121                 sp_canvas_item_hide(SP_CANVAS_ITEM(gridgroup));
1122             }
1123         }
1124     } else {
1125         //there is no grid present at the moment. add a rectangular grid and make it visible
1126         Inkscape::XML::Node *repr = SP_OBJECT_REPR(namedview);
1127         Inkscape::CanvasGrid::writeNewGridToRepr(repr, Inkscape::GRID_RECTANGULAR);
1128         grids_visible = true;
1129         sp_canvas_item_show(SP_CANVAS_ITEM(gridgroup));
1130     }
1131 }
1132
1133
1134 //----------------------------------------------------------------------
1135 // Callback implementations. The virtual ones are connected by the view.
1136
1137 void
1138 SPDesktop::onPositionSet (double x, double y)
1139 {
1140     _widget->viewSetPosition (NR::Point(x,y));
1141 }
1142
1143 void
1144 SPDesktop::onResized (double x, double y)
1145 {
1146    // Nothing called here
1147 }
1148
1149 /**
1150  * Redraw callback; queues Gtk redraw; connected by View.
1151  */
1152 void
1153 SPDesktop::onRedrawRequested ()
1154 {
1155     if (main) {
1156         _widget->requestCanvasUpdate();
1157     }
1158 }
1159
1160 void
1161 SPDesktop::updateCanvasNow()
1162 {
1163   _widget->requestCanvasUpdateAndWait();
1164 }
1165
1166 /**
1167  * Associate document with desktop.
1168  */
1169 void
1170 SPDesktop::setDocument (SPDocument *doc)
1171 {
1172     if (this->doc() && doc) {
1173         namedview->hide(this);
1174         sp_item_invoke_hide (SP_ITEM (sp_document_root (this->doc())), dkey);
1175     }
1176
1177     if (_layer_hierarchy) {
1178         _layer_hierarchy->clear();
1179         delete _layer_hierarchy;
1180     }
1181     _layer_hierarchy = new Inkscape::ObjectHierarchy(NULL);
1182     _layer_hierarchy->connectAdded(sigc::bind(sigc::ptr_fun(_layer_activated), this));
1183     _layer_hierarchy->connectRemoved(sigc::bind(sigc::ptr_fun(_layer_deactivated), this));
1184     _layer_hierarchy->connectChanged(sigc::bind(sigc::ptr_fun(_layer_hierarchy_changed), this));
1185     _layer_hierarchy->setTop(SP_DOCUMENT_ROOT(doc));
1186
1187     /* setup EventLog */
1188     event_log = new Inkscape::EventLog(doc);
1189     doc->addUndoObserver(*event_log);
1190
1191     _commit_connection.disconnect();
1192     _commit_connection = doc->connectCommit(sigc::mem_fun(*this, &SPDesktop::updateNow));
1193
1194     /// \todo fixme: This condition exists to make sure the code
1195     /// inside is NOT called on initialization, only on replacement. But there
1196     /// are surely more safe methods to accomplish this.
1197     // TODO since the comment had reversed logic, check the intent of this block of code:
1198     if (drawing) {
1199         NRArenaItem *ai = 0;
1200
1201         namedview = sp_document_namedview (doc, NULL);
1202         _modified_connection = namedview->connectModified(sigc::bind<2>(sigc::ptr_fun(&_namedview_modified), this));
1203         number = namedview->getViewCount();
1204
1205         ai = sp_item_invoke_show (SP_ITEM (sp_document_root (doc)),
1206                 SP_CANVAS_ARENA (drawing)->arena,
1207                 dkey,
1208                 SP_ITEM_SHOW_DISPLAY);
1209         if (ai) {
1210             nr_arena_item_add_child (SP_CANVAS_ARENA (drawing)->root, ai, NULL);
1211             nr_arena_item_unref (ai);
1212         }
1213         namedview->show(this);
1214         /* Ugly hack */
1215         activate_guides (true);
1216         /* Ugly hack */
1217         _namedview_modified (namedview, SP_OBJECT_MODIFIED_FLAG, this);
1218     }
1219
1220     _document_replaced_signal.emit (this, doc);
1221
1222     View::setDocument (doc);
1223 }
1224
1225 void
1226 SPDesktop::onStatusMessage
1227 (Inkscape::MessageType type, gchar const *message)
1228 {
1229     if (_widget) {
1230         _widget->setMessage(type, message);
1231     }
1232 }
1233
1234 void
1235 SPDesktop::onDocumentURISet (gchar const* uri)
1236 {
1237     _widget->setTitle(uri);
1238 }
1239
1240 /**
1241  * Resized callback.
1242  */
1243 void
1244 SPDesktop::onDocumentResized (gdouble width, gdouble height)
1245 {
1246     _doc2dt[5] = height;
1247     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (drawing), _doc2dt);
1248     NR::Rect const a(NR::Point(0, 0), NR::Point(width, height));
1249     SP_CTRLRECT(page)->setRectangle(a);
1250     SP_CTRLRECT(page_border)->setRectangle(a);
1251 }
1252
1253
1254 void
1255 SPDesktop::_onActivate (SPDesktop* dt)
1256 {
1257     if (!dt->_widget) return;
1258     dt->_widget->activateDesktop();
1259 }
1260
1261 void
1262 SPDesktop::_onDeactivate (SPDesktop* dt)
1263 {
1264     if (!dt->_widget) return;
1265     dt->_widget->deactivateDesktop();
1266 }
1267
1268 void
1269 SPDesktop::_onSelectionModified
1270 (Inkscape::Selection *selection, guint flags, SPDesktop *dt)
1271 {
1272     if (!dt->_widget) return;
1273     dt->_widget->updateScrollbars (expansion(dt->_d2w));
1274 }
1275
1276 static void
1277 _onSelectionChanged
1278 (Inkscape::Selection *selection, SPDesktop *desktop)
1279 {
1280     /** \todo
1281      * only change the layer for single selections, or what?
1282      * This seems reasonable -- for multiple selections there can be many
1283      * different layers involved.
1284      */
1285     SPItem *item=selection->singleItem();
1286     if (item) {
1287         SPObject *layer=desktop->layerForObject(item);
1288         if ( layer && layer != desktop->currentLayer() ) {
1289             desktop->setCurrentLayer(layer);
1290         }
1291     }
1292 }
1293
1294 /**
1295  * Calls event handler of current event context.
1296  * \param arena Unused
1297  * \todo fixme
1298  */
1299 static gint
1300 _arena_handler (SPCanvasArena *arena, NRArenaItem *ai, GdkEvent *event, SPDesktop *desktop)
1301 {
1302     if (ai) {
1303         SPItem *spi = (SPItem*)NR_ARENA_ITEM_GET_DATA (ai);
1304         return sp_event_context_item_handler (desktop->event_context, spi, event);
1305     } else {
1306         return sp_event_context_root_handler (desktop->event_context, event);
1307     }
1308 }
1309
1310 static void
1311 _layer_activated(SPObject *layer, SPDesktop *desktop) {
1312     g_return_if_fail(SP_IS_GROUP(layer));
1313     SP_GROUP(layer)->setLayerDisplayMode(desktop->dkey, SPGroup::LAYER);
1314 }
1315
1316 /// Callback
1317 static void
1318 _layer_deactivated(SPObject *layer, SPDesktop *desktop) {
1319     g_return_if_fail(SP_IS_GROUP(layer));
1320     SP_GROUP(layer)->setLayerDisplayMode(desktop->dkey, SPGroup::GROUP);
1321 }
1322
1323 /// Callback
1324 static void
1325 _layer_hierarchy_changed(SPObject *top, SPObject *bottom,
1326                                          SPDesktop *desktop)
1327 {
1328     desktop->_layer_changed_signal.emit (bottom);
1329 }
1330
1331 /// Called when document is starting to be rebuilt.
1332 static void
1333 _reconstruction_start (SPDesktop * desktop)
1334 {
1335     // printf("Desktop, starting reconstruction\n");
1336     desktop->_reconstruction_old_layer_id = g_strdup(SP_OBJECT_ID(desktop->currentLayer()));
1337     desktop->_layer_hierarchy->setBottom(desktop->currentRoot());
1338
1339     /*
1340     GSList const * selection_objs = desktop->selection->list();
1341     for (; selection_objs != NULL; selection_objs = selection_objs->next) {
1342
1343     }
1344     */
1345     desktop->selection->clear();
1346
1347     // printf("Desktop, starting reconstruction end\n");
1348 }
1349
1350 /// Called when document rebuild is finished.
1351 static void
1352 _reconstruction_finish (SPDesktop * desktop)
1353 {
1354     // printf("Desktop, finishing reconstruction\n");
1355     if (desktop->_reconstruction_old_layer_id == NULL)
1356         return;
1357
1358     SPObject * newLayer = SP_OBJECT_DOCUMENT(desktop->namedview)->getObjectById(desktop->_reconstruction_old_layer_id);
1359     if (newLayer != NULL)
1360         desktop->setCurrentLayer(newLayer);
1361
1362     g_free(desktop->_reconstruction_old_layer_id);
1363     desktop->_reconstruction_old_layer_id = NULL;
1364     // printf("Desktop, finishing reconstruction end\n");
1365     return;
1366 }
1367
1368 /**
1369  * Namedview_modified callback.
1370  */
1371 static void
1372 _namedview_modified (SPObject *obj, guint flags, SPDesktop *desktop)
1373 {
1374     SPNamedView *nv=SP_NAMEDVIEW(obj);
1375
1376     if (flags & SP_OBJECT_MODIFIED_FLAG) {
1377
1378         /* Recalculate snap distances */
1379         /* FIXME: why is the desktop getting involved in setting up something
1380         ** that is entirely to do with the namedview?
1381         */
1382         _update_snap_distances (desktop);
1383
1384         /* Show/hide page background */
1385         if (nv->pagecolor & 0xff) {
1386             sp_canvas_item_show (desktop->table);
1387             ((CtrlRect *) desktop->table)->setColor(0x00000000, true, nv->pagecolor);
1388             sp_canvas_item_move_to_z (desktop->table, 0);
1389         } else {
1390             sp_canvas_item_hide (desktop->table);
1391         }
1392
1393         /* Show/hide page border */
1394         if (nv->showborder) {
1395             // show
1396             sp_canvas_item_show (desktop->page_border);
1397             // set color and shadow
1398             ((CtrlRect *) desktop->page_border)->setColor(nv->bordercolor, false, 0x00000000);
1399             if (nv->pageshadow) {
1400                 ((CtrlRect *) desktop->page_border)->setShadow(nv->pageshadow, nv->bordercolor);
1401             }
1402             // place in the z-order stack
1403             if (nv->borderlayer == SP_BORDER_LAYER_BOTTOM) {
1404                  sp_canvas_item_move_to_z (desktop->page_border, 2);
1405             } else {
1406                 int order = sp_canvas_item_order (desktop->page_border);
1407                 int morder = sp_canvas_item_order (desktop->drawing);
1408                 if (morder > order) sp_canvas_item_raise (desktop->page_border,
1409                                     morder - order);
1410             }
1411         } else {
1412                 sp_canvas_item_hide (desktop->page_border);
1413                 if (nv->pageshadow) {
1414                     ((CtrlRect *) desktop->page)->setShadow(0, 0x00000000);
1415                 }
1416         }
1417
1418         /* Show/hide page shadow */
1419         if (nv->showpageshadow && nv->pageshadow) {
1420             ((CtrlRect *) desktop->page_border)->setShadow(nv->pageshadow, nv->bordercolor);
1421         } else {
1422             ((CtrlRect *) desktop->page_border)->setShadow(0, 0x00000000);
1423         }
1424
1425         if (SP_RGBA32_A_U(nv->pagecolor) < 128 ||
1426             (SP_RGBA32_R_U(nv->pagecolor) +
1427              SP_RGBA32_G_U(nv->pagecolor) +
1428              SP_RGBA32_B_U(nv->pagecolor)) >= 384) {
1429             // the background color is light or transparent, use black outline
1430             SP_CANVAS_ARENA (desktop->drawing)->arena->outlinecolor = prefs_get_int_attribute("options.wireframecolors", "onlight", 0xff);
1431         } else { // use white outline
1432             SP_CANVAS_ARENA (desktop->drawing)->arena->outlinecolor = prefs_get_int_attribute("options.wireframecolors", "ondark", 0xffffffff);
1433         }
1434     }
1435 }
1436
1437 /**
1438  * Callback to reset snapper's distances.
1439  */
1440 static void
1441 _update_snap_distances (SPDesktop *desktop)
1442 {
1443     SPUnit const &px = sp_unit_get_by_id(SP_UNIT_PX);
1444
1445     SPNamedView &nv = *desktop->namedview;
1446
1447     //tell all grid snappers
1448     for ( GSList const *l = nv.grids; l != NULL; l = l->next) {
1449         Inkscape::CanvasGrid *grid = (Inkscape::CanvasGrid*) l->data;
1450         grid->snapper->setDistance(sp_convert_distance_full(nv.gridtolerance,
1451                                                                       *nv.gridtoleranceunit,
1452                                                                       px));
1453     }
1454
1455     nv.snap_manager.guide.setDistance(sp_convert_distance_full(nv.guidetolerance,
1456                                                                        *nv.guidetoleranceunit,
1457                                                                        px));
1458     nv.snap_manager.object.setDistance(sp_convert_distance_full(nv.objecttolerance,
1459                                                                         *nv.objecttoleranceunit,
1460                                                                         px));
1461 }
1462
1463
1464 NR::Matrix SPDesktop::w2d() const
1465 {
1466     return _w2d;
1467 }
1468
1469 NR::Point SPDesktop::w2d(NR::Point const &p) const
1470 {
1471     return p * _w2d;
1472 }
1473
1474 NR::Point SPDesktop::d2w(NR::Point const &p) const
1475 {
1476     return p * _d2w;
1477 }
1478
1479 NR::Matrix SPDesktop::doc2dt() const
1480 {
1481     return _doc2dt;
1482 }
1483
1484 NR::Point SPDesktop::doc2dt(NR::Point const &p) const
1485 {
1486     return p * _doc2dt;
1487 }
1488
1489 NR::Point SPDesktop::dt2doc(NR::Point const &p) const
1490 {
1491     return p / _doc2dt;
1492 }
1493
1494
1495 /**
1496  * Pop event context from desktop's context stack. Never used.
1497  */
1498 // void
1499 // SPDesktop::pop_event_context (unsigned int key)
1500 // {
1501 //    SPEventContext *ec = NULL;
1502 //
1503 //    if (event_context && event_context->key == key) {
1504 //        g_return_if_fail (event_context);
1505 //        g_return_if_fail (event_context->next);
1506 //        ec = event_context;
1507 //        sp_event_context_deactivate (ec);
1508 //        event_context = ec->next;
1509 //        sp_event_context_activate (event_context);
1510 //        _event_context_changed_signal.emit (this, ec);
1511 //    }
1512 //
1513 //    SPEventContext *ref = event_context;
1514 //    while (ref && ref->next && ref->next->key != key)
1515 //        ref = ref->next;
1516 //
1517 //    if (ref && ref->next) {
1518 //        ec = ref->next;
1519 //        ref->next = ec->next;
1520 //    }
1521 //
1522 //    if (ec) {
1523 //        sp_event_context_finish (ec);
1524 //        g_object_unref (G_OBJECT (ec));
1525 //    }
1526 // }
1527
1528 /*
1529   Local Variables:
1530   mode:c++
1531   c-file-style:"stroustrup"
1532   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1533   indent-tabs-mode:nil
1534   fill-column:99
1535   End:
1536 */
1537 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :