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     window_state(0),
 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 bool
 974 SPDesktop::is_iconified()
 975 {
 976     return 0!=(window_state & GDK_WINDOW_STATE_ICONIFIED);
 977 }
 978
 979 void
 980 SPDesktop::iconify()
 981 {
 982     _widget->setIconified();
 983 }
 984
 985 bool
 986 SPDesktop::is_maximized()
 987 {
 988     return 0!=(window_state & GDK_WINDOW_STATE_MAXIMIZED);
 989 }
 990
 991 void
 992 SPDesktop::maximize()
 993 {
 994     _widget->setMaximized();
 995 }
 996
 997 bool
 998 SPDesktop::is_fullscreen()
 999 {
1000     return 0!=(window_state & GDK_WINDOW_STATE_FULLSCREEN);
1001 }
1002
1003 void
1004 SPDesktop::fullscreen()
1005 {
1006     _widget->setFullscreen();
1007 }
1008
1009 void
1010 SPDesktop::getWindowGeometry (gint &x, gint &y, gint &w, gint &h)
1011 {
1012     _widget->getGeometry (x, y, w, h);
1013 }
1014
1015 void
1016 SPDesktop::setWindowPosition (NR::Point p)
1017 {
1018     _widget->setPosition (p);
1019 }
1020
1021 void
1022 SPDesktop::setWindowSize (gint w, gint h)
1023 {
1024     _widget->setSize (w, h);
1025 }
1026
1027 void
1028 SPDesktop::setWindowTransient (void *p, int transient_policy)
1029 {
1030     _widget->setTransient (p, transient_policy);
1031 }
1032
1033 void SPDesktop::getToplevel( GtkWidget*& toplevel )
1034 {
1035     toplevel = GTK_WIDGET( _widget->getWindow() );
1036 }
1037
1038 void
1039 SPDesktop::presentWindow()
1040 {
1041     _widget->present();
1042 }
1043
1044 bool
1045 SPDesktop::warnDialog (gchar *text)
1046 {
1047     return _widget->warnDialog (text);
1048 }
1049
1050 void
1051 SPDesktop::toggleRulers()
1052 {
1053     _widget->toggleRulers();
1054 }
1055
1056 void
1057 SPDesktop::toggleScrollbars()
1058 {
1059     _widget->toggleScrollbars();
1060 }
1061
1062 void
1063 SPDesktop::layoutWidget()
1064 {
1065     _widget->layout();
1066 }
1067
1068 void
1069 SPDesktop::destroyWidget()
1070 {
1071     _widget->destroy();
1072 }
1073
1074 bool
1075 SPDesktop::shutdown()
1076 {
1077     return _widget->shutdown();
1078 }
1079
1080 void
1081 SPDesktop::setToolboxFocusTo (gchar const *label)
1082 {
1083     _widget->setToolboxFocusTo (label);
1084 }
1085
1086 void
1087 SPDesktop::setToolboxAdjustmentValue (gchar const* id, double val)
1088 {
1089     _widget->setToolboxAdjustmentValue (id, val);
1090 }
1091
1092 bool
1093 SPDesktop::isToolboxButtonActive (gchar const *id)
1094 {
1095     return _widget->isToolboxButtonActive (id);
1096 }
1097
1098 void
1099 SPDesktop::emitToolSubselectionChanged(gpointer data)
1100 {
1101         _tool_subselection_changed.emit(data);
1102         inkscape_subselection_changed (this);
1103 }
1104
1105 void
1106 SPDesktop::updateNow()
1107 {
1108   sp_canvas_update_now(canvas);
1109 }
1110
1111 void
1112 SPDesktop::enableInteraction()
1113 {
1114   _widget->enableInteraction();
1115 }
1116
1117 void SPDesktop::disableInteraction()
1118 {
1119   _widget->disableInteraction();
1120 }
1121
1122 void SPDesktop::setWaitingCursor()
1123 {
1124     GdkCursor *waiting = gdk_cursor_new(GDK_WATCH);
1125     gdk_window_set_cursor(GTK_WIDGET(sp_desktop_canvas(this))->window, waiting);
1126     gdk_cursor_unref(waiting);
1127     waiting_cursor = true;
1128
1129     // Stupidly broken GDK cannot just set the new cursor right now - it needs some main loop iterations for that
1130     // Since setting waiting_cursor is usually immediately followed by some Real Work, we must run the iterations here
1131     // CAUTION: iterations may redraw, and redraw may be interrupted, so you cannot assume that anything is the same
1132     // after the call to setWaitingCursor as it was before
1133     while( Gtk::Main::events_pending() )
1134        Gtk::Main::iteration();
1135 }
1136
1137 void SPDesktop::clearWaitingCursor()
1138 {
1139   if (waiting_cursor)
1140       sp_event_context_update_cursor(sp_desktop_event_context(this));
1141 }
1142
1143 void SPDesktop::toggleGrid()
1144 {
1145     if (namedview->grids) {
1146         if(gridgroup) {
1147             grids_visible = !grids_visible;
1148             if (grids_visible) {
1149                 sp_canvas_item_show(SP_CANVAS_ITEM(gridgroup));
1150             } else {
1151                 sp_canvas_item_hide(SP_CANVAS_ITEM(gridgroup));
1152             }
1153         }
1154     } else {
1155         //there is no grid present at the moment. add a rectangular grid and make it visible
1156         Inkscape::XML::Node *repr = SP_OBJECT_REPR(namedview);
1157         Inkscape::CanvasGrid::writeNewGridToRepr(repr, sp_desktop_document(this), Inkscape::GRID_RECTANGULAR);
1158         grids_visible = true;
1159         sp_canvas_item_show(SP_CANVAS_ITEM(gridgroup));
1160     }
1161 }
1162
1163
1164 //----------------------------------------------------------------------
1165 // Callback implementations. The virtual ones are connected by the view.
1166
1167 void
1168 SPDesktop::onPositionSet (double x, double y)
1169 {
1170     _widget->viewSetPosition (NR::Point(x,y));
1171 }
1172
1173 void
1174 SPDesktop::onResized (double x, double y)
1175 {
1176    // Nothing called here
1177 }
1178
1179 /**
1180  * Redraw callback; queues Gtk redraw; connected by View.
1181  */
1182 void
1183 SPDesktop::onRedrawRequested ()
1184 {
1185     if (main) {
1186         _widget->requestCanvasUpdate();
1187     }
1188 }
1189
1190 void
1191 SPDesktop::updateCanvasNow()
1192 {
1193   _widget->requestCanvasUpdateAndWait();
1194 }
1195
1196 /**
1197  * Associate document with desktop.
1198  */
1199 void
1200 SPDesktop::setDocument (SPDocument *doc)
1201 {
1202     if (this->doc() && doc) {
1203         namedview->hide(this);
1204         sp_item_invoke_hide (SP_ITEM (sp_document_root (this->doc())), dkey);
1205     }
1206
1207     if (_layer_hierarchy) {
1208         _layer_hierarchy->clear();
1209         delete _layer_hierarchy;
1210     }
1211     _layer_hierarchy = new Inkscape::ObjectHierarchy(NULL);
1212     _layer_hierarchy->connectAdded(sigc::bind(sigc::ptr_fun(_layer_activated), this));
1213     _layer_hierarchy->connectRemoved(sigc::bind(sigc::ptr_fun(_layer_deactivated), this));
1214     _layer_hierarchy->connectChanged(sigc::bind(sigc::ptr_fun(_layer_hierarchy_changed), this));
1215     _layer_hierarchy->setTop(SP_DOCUMENT_ROOT(doc));
1216
1217     /* setup EventLog */
1218     event_log = new Inkscape::EventLog(doc);
1219     doc->addUndoObserver(*event_log);
1220
1221     _commit_connection.disconnect();
1222     _commit_connection = doc->connectCommit(sigc::mem_fun(*this, &SPDesktop::updateNow));
1223
1224     /// \todo fixme: This condition exists to make sure the code
1225     /// inside is NOT called on initialization, only on replacement. But there
1226     /// are surely more safe methods to accomplish this.
1227     // TODO since the comment had reversed logic, check the intent of this block of code:
1228     if (drawing) {
1229         NRArenaItem *ai = 0;
1230
1231         namedview = sp_document_namedview (doc, NULL);
1232         _modified_connection = namedview->connectModified(sigc::bind<2>(sigc::ptr_fun(&_namedview_modified), this));
1233         number = namedview->getViewCount();
1234
1235         ai = sp_item_invoke_show (SP_ITEM (sp_document_root (doc)),
1236                 SP_CANVAS_ARENA (drawing)->arena,
1237                 dkey,
1238                 SP_ITEM_SHOW_DISPLAY);
1239         if (ai) {
1240             nr_arena_item_add_child (SP_CANVAS_ARENA (drawing)->root, ai, NULL);
1241             nr_arena_item_unref (ai);
1242         }
1243         namedview->show(this);
1244         /* Ugly hack */
1245         activate_guides (true);
1246         /* Ugly hack */
1247         _namedview_modified (namedview, SP_OBJECT_MODIFIED_FLAG, this);
1248     }
1249
1250     _document_replaced_signal.emit (this, doc);
1251
1252     View::setDocument (doc);
1253 }
1254
1255 void
1256 SPDesktop::onStatusMessage
1257 (Inkscape::MessageType type, gchar const *message)
1258 {
1259     if (_widget) {
1260         _widget->setMessage(type, message);
1261     }
1262 }
1263
1264 void
1265 SPDesktop::onDocumentURISet (gchar const* uri)
1266 {
1267     _widget->setTitle(uri);
1268 }
1269
1270 /**
1271  * Resized callback.
1272  */
1273 void
1274 SPDesktop::onDocumentResized (gdouble width, gdouble height)
1275 {
1276     _doc2dt[5] = height;
1277     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (drawing), _doc2dt);
1278     NR::Rect const a(NR::Point(0, 0), NR::Point(width, height));
1279     SP_CTRLRECT(page)->setRectangle(a);
1280     SP_CTRLRECT(page_border)->setRectangle(a);
1281 }
1282
1283
1284 void
1285 SPDesktop::_onActivate (SPDesktop* dt)
1286 {
1287     if (!dt->_widget) return;
1288     dt->_widget->activateDesktop();
1289 }
1290
1291 void
1292 SPDesktop::_onDeactivate (SPDesktop* dt)
1293 {
1294     if (!dt->_widget) return;
1295     dt->_widget->deactivateDesktop();
1296 }
1297
1298 void
1299 SPDesktop::_onSelectionModified
1300 (Inkscape::Selection *selection, guint flags, SPDesktop *dt)
1301 {
1302     if (!dt->_widget) return;
1303     dt->_widget->updateScrollbars (expansion(dt->_d2w));
1304 }
1305
1306 static void
1307 _onSelectionChanged
1308 (Inkscape::Selection *selection, SPDesktop *desktop)
1309 {
1310     /** \todo
1311      * only change the layer for single selections, or what?
1312      * This seems reasonable -- for multiple selections there can be many
1313      * different layers involved.
1314      */
1315     SPItem *item=selection->singleItem();
1316     if (item) {
1317         SPObject *layer=desktop->layerForObject(item);
1318         if ( layer && layer != desktop->currentLayer() ) {
1319             desktop->setCurrentLayer(layer);
1320         }
1321     }
1322 }
1323
1324 /**
1325  * Calls event handler of current event context.
1326  * \param arena Unused
1327  * \todo fixme
1328  */
1329 static gint
1330 _arena_handler (SPCanvasArena *arena, NRArenaItem *ai, GdkEvent *event, SPDesktop *desktop)
1331 {
1332     if (ai) {
1333         SPItem *spi = (SPItem*)NR_ARENA_ITEM_GET_DATA (ai);
1334         return sp_event_context_item_handler (desktop->event_context, spi, event);
1335     } else {
1336         return sp_event_context_root_handler (desktop->event_context, event);
1337     }
1338 }
1339
1340 static void
1341 _layer_activated(SPObject *layer, SPDesktop *desktop) {
1342     g_return_if_fail(SP_IS_GROUP(layer));
1343     SP_GROUP(layer)->setLayerDisplayMode(desktop->dkey, SPGroup::LAYER);
1344 }
1345
1346 /// Callback
1347 static void
1348 _layer_deactivated(SPObject *layer, SPDesktop *desktop) {
1349     g_return_if_fail(SP_IS_GROUP(layer));
1350     SP_GROUP(layer)->setLayerDisplayMode(desktop->dkey, SPGroup::GROUP);
1351 }
1352
1353 /// Callback
1354 static void
1355 _layer_hierarchy_changed(SPObject *top, SPObject *bottom,
1356                                          SPDesktop *desktop)
1357 {
1358     desktop->_layer_changed_signal.emit (bottom);
1359 }
1360
1361 /// Called when document is starting to be rebuilt.
1362 static void
1363 _reconstruction_start (SPDesktop * desktop)
1364 {
1365     // printf("Desktop, starting reconstruction\n");
1366     desktop->_reconstruction_old_layer_id = g_strdup(SP_OBJECT_ID(desktop->currentLayer()));
1367     desktop->_layer_hierarchy->setBottom(desktop->currentRoot());
1368
1369     /*
1370     GSList const * selection_objs = desktop->selection->list();
1371     for (; selection_objs != NULL; selection_objs = selection_objs->next) {
1372
1373     }
1374     */
1375     desktop->selection->clear();
1376
1377     // printf("Desktop, starting reconstruction end\n");
1378 }
1379
1380 /// Called when document rebuild is finished.
1381 static void
1382 _reconstruction_finish (SPDesktop * desktop)
1383 {
1384     // printf("Desktop, finishing reconstruction\n");
1385     if (desktop->_reconstruction_old_layer_id == NULL)
1386         return;
1387
1388     SPObject * newLayer = SP_OBJECT_DOCUMENT(desktop->namedview)->getObjectById(desktop->_reconstruction_old_layer_id);
1389     if (newLayer != NULL)
1390         desktop->setCurrentLayer(newLayer);
1391
1392     g_free(desktop->_reconstruction_old_layer_id);
1393     desktop->_reconstruction_old_layer_id = NULL;
1394     // printf("Desktop, finishing reconstruction end\n");
1395     return;
1396 }
1397
1398 /**
1399  * Namedview_modified callback.
1400  */
1401 static void
1402 _namedview_modified (SPObject *obj, guint flags, SPDesktop *desktop)
1403 {
1404     SPNamedView *nv=SP_NAMEDVIEW(obj);
1405
1406     if (flags & SP_OBJECT_MODIFIED_FLAG) {
1407
1408         /* Recalculate snap distances */
1409         /* FIXME: why is the desktop getting involved in setting up something
1410         ** that is entirely to do with the namedview?
1411         */
1412         _update_snap_distances (desktop);
1413
1414         /* Show/hide page background */
1415         if (nv->pagecolor & 0xff) {
1416             sp_canvas_item_show (desktop->table);
1417             ((CtrlRect *) desktop->table)->setColor(0x00000000, true, nv->pagecolor);
1418             sp_canvas_item_move_to_z (desktop->table, 0);
1419         } else {
1420             sp_canvas_item_hide (desktop->table);
1421         }
1422
1423         /* Show/hide page border */
1424         if (nv->showborder) {
1425             // show
1426             sp_canvas_item_show (desktop->page_border);
1427             // set color and shadow
1428             ((CtrlRect *) desktop->page_border)->setColor(nv->bordercolor, false, 0x00000000);
1429             if (nv->pageshadow) {
1430                 ((CtrlRect *) desktop->page_border)->setShadow(nv->pageshadow, nv->bordercolor);
1431             }
1432             // place in the z-order stack
1433             if (nv->borderlayer == SP_BORDER_LAYER_BOTTOM) {
1434                  sp_canvas_item_move_to_z (desktop->page_border, 2);
1435             } else {
1436                 int order = sp_canvas_item_order (desktop->page_border);
1437                 int morder = sp_canvas_item_order (desktop->drawing);
1438                 if (morder > order) sp_canvas_item_raise (desktop->page_border,
1439                                     morder - order);
1440             }
1441         } else {
1442                 sp_canvas_item_hide (desktop->page_border);
1443                 if (nv->pageshadow) {
1444                     ((CtrlRect *) desktop->page)->setShadow(0, 0x00000000);
1445                 }
1446         }
1447
1448         /* Show/hide page shadow */
1449         if (nv->showpageshadow && nv->pageshadow) {
1450             ((CtrlRect *) desktop->page_border)->setShadow(nv->pageshadow, nv->bordercolor);
1451         } else {
1452             ((CtrlRect *) desktop->page_border)->setShadow(0, 0x00000000);
1453         }
1454
1455         if (SP_RGBA32_A_U(nv->pagecolor) < 128 ||
1456             (SP_RGBA32_R_U(nv->pagecolor) +
1457              SP_RGBA32_G_U(nv->pagecolor) +
1458              SP_RGBA32_B_U(nv->pagecolor)) >= 384) {
1459             // the background color is light or transparent, use black outline
1460             SP_CANVAS_ARENA (desktop->drawing)->arena->outlinecolor = prefs_get_int_attribute("options.wireframecolors", "onlight", 0xff);
1461         } else { // use white outline
1462             SP_CANVAS_ARENA (desktop->drawing)->arena->outlinecolor = prefs_get_int_attribute("options.wireframecolors", "ondark", 0xffffffff);
1463         }
1464     }
1465 }
1466
1467 /**
1468  * Callback to reset snapper's distances.
1469  */
1470 static void
1471 _update_snap_distances (SPDesktop *desktop)
1472 {
1473     SPUnit const &px = sp_unit_get_by_id(SP_UNIT_PX);
1474
1475     SPNamedView &nv = *desktop->namedview;
1476
1477     //tell all grid snappers
1478     for ( GSList const *l = nv.grids; l != NULL; l = l->next) {
1479         Inkscape::CanvasGrid *grid = (Inkscape::CanvasGrid*) l->data;
1480         grid->snapper->setDistance(sp_convert_distance_full(nv.gridtolerance,
1481                                                                       *nv.gridtoleranceunit,
1482                                                                       px));
1483     }
1484
1485     nv.snap_manager.guide.setDistance(sp_convert_distance_full(nv.guidetolerance,
1486                                                                        *nv.guidetoleranceunit,
1487                                                                        px));
1488     nv.snap_manager.object.setDistance(sp_convert_distance_full(nv.objecttolerance,
1489                                                                         *nv.objecttoleranceunit,
1490                                                                         px));
1491 }
1492
1493
1494 NR::Matrix SPDesktop::w2d() const
1495 {
1496     return _w2d;
1497 }
1498
1499 NR::Point SPDesktop::w2d(NR::Point const &p) const
1500 {
1501     return p * _w2d;
1502 }
1503
1504 NR::Point SPDesktop::d2w(NR::Point const &p) const
1505 {
1506     return p * _d2w;
1507 }
1508
1509 NR::Matrix SPDesktop::doc2dt() const
1510 {
1511     return _doc2dt;
1512 }
1513
1514 NR::Point SPDesktop::doc2dt(NR::Point const &p) const
1515 {
1516     return p * _doc2dt;
1517 }
1518
1519 NR::Point SPDesktop::dt2doc(NR::Point const &p) const
1520 {
1521     return p / _doc2dt;
1522 }
1523
1524
1525 /**
1526  * Pop event context from desktop's context stack. Never used.
1527  */
1528 // void
1529 // SPDesktop::pop_event_context (unsigned int key)
1530 // {
1531 //    SPEventContext *ec = NULL;
1532 //
1533 //    if (event_context && event_context->key == key) {
1534 //        g_return_if_fail (event_context);
1535 //        g_return_if_fail (event_context->next);
1536 //        ec = event_context;
1537 //        sp_event_context_deactivate (ec);
1538 //        event_context = ec->next;
1539 //        sp_event_context_activate (event_context);
1540 //        _event_context_changed_signal.emit (this, ec);
1541 //    }
1542 //
1543 //    SPEventContext *ref = event_context;
1544 //    while (ref && ref->next && ref->next->key != key)
1545 //        ref = ref->next;
1546 //
1547 //    if (ref && ref->next) {
1548 //        ec = ref->next;
1549 //        ref->next = ec->next;
1550 //    }
1551 //
1552 //    if (ec) {
1553 //        sp_event_context_finish (ec);
1554 //        g_object_unref (G_OBJECT (ec));
1555 //    }
1556 // }
1557
1558 /*
1559   Local Variables:
1560   mode:c++
1561   c-file-style:"stroustrup"
1562   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1563   indent-tabs-mode:nil
1564   fill-column:99
1565   End:
1566 */
1567 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :