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-2008 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 <2geom/rect.h>
  61 #include "macros.h"
  62 #include "inkscape-private.h"
  63 #include "desktop.h"
  64 #include "desktop-events.h"
  65 #include "desktop-handles.h"
  66 #include "document.h"
  67 #include "message-stack.h"
  68 #include "selection.h"
  69 #include "select-context.h"
  70 #include "sp-namedview.h"
  71 #include "color.h"
  72 #include "sp-item-group.h"
  73 #include "preferences.h"
  74 #include "object-hierarchy.h"
  75 #include "helper/units.h"
  76 #include "display/canvas-arena.h"
  77 #include "display/nr-arena.h"
  78 #include "display/gnome-canvas-acetate.h"
  79 #include "display/sodipodi-ctrlrect.h"
  80 #include "display/sp-canvas-util.h"
  81 #include "display/canvas-temporary-item-list.h"
  82 #include "display/snap-indicator.h"
  83 #include "ui/dialog/dialog-manager.h"
  84 #include "xml/repr.h"
  85 #include "message-context.h"
  86 #include "device-manager.h"
  87 #include "layer-fns.h"
  88 #include "layer-manager.h"
  89 #include "event-log.h"
  90 #include "display/canvas-grid.h"
  91 #include "widgets/desktop-widget.h"
  92 #include "box3d-context.h"
  93
  94 #include "display/sp-canvas.h"
  95
  96 namespace Inkscape { namespace XML { class Node; }}
  97
  98 // Callback declarations
  99 static void _onSelectionChanged (Inkscape::Selection *selection, SPDesktop *desktop);
 100 static gint _arena_handler (SPCanvasArena *arena, NRArenaItem *ai, GdkEvent *event, SPDesktop *desktop);
 101 static void _layer_activated(SPObject *layer, SPDesktop *desktop);
 102 static void _layer_deactivated(SPObject *layer, SPDesktop *desktop);
 103 static void _layer_hierarchy_changed(SPObject *top, SPObject *bottom, SPDesktop *desktop);
 104 static void _reconstruction_start(SPDesktop * desktop);
 105 static void _reconstruction_finish(SPDesktop * desktop);
 106 static void _namedview_modified (SPObject *obj, guint flags, SPDesktop *desktop);
 107 static void _update_snap_distances (SPDesktop *desktop);
 108
 109 /**
 110  * Return new desktop object.
 111  * \pre namedview != NULL.
 112  * \pre canvas != NULL.
 113  */
 114 SPDesktop::SPDesktop() :
 115     _dlg_mgr( 0 ),
 116     namedview( 0 ),
 117     canvas( 0 ),
 118     selection( 0 ),
 119     event_context( 0 ),
 120     layer_manager( 0 ),
 121     event_log( 0 ),
 122     temporary_item_list( 0 ),
 123     snapindicator( 0 ),
 124     acetate( 0 ),
 125     main( 0 ),
 126     gridgroup( 0 ),
 127     guides( 0 ),
 128     drawing( 0 ),
 129     sketch( 0 ),
 130     controls( 0 ),
 131     tempgroup ( 0 ),
 132     table( 0 ),
 133     page( 0 ),
 134     page_border( 0 ),
 135     current( 0 ),
 136     _focusMode(false),
 137     zooms_past( 0 ),
 138     zooms_future( 0 ),
 139     dkey( 0 ),
 140     number( 0 ),
 141     window_state(0),
 142     interaction_disabled_counter( 0 ),
 143     waiting_cursor( false ),
 144     guides_active( false ),
 145     gr_item( 0 ),
 146     gr_point_type( 0 ),
 147     gr_point_i( 0 ),
 148     gr_fill_or_stroke( true ),
 149     _layer_hierarchy( 0 ),
 150     _reconstruction_old_layer_id( 0 ),
 151     _display_mode(Inkscape::RENDERMODE_NORMAL),
 152     _saved_display_mode(Inkscape::RENDERMODE_NORMAL),
 153     _widget( 0 ),
 154     _inkscape( 0 ),
 155     _guides_message_context( 0 ),
 156     _active( false ),
 157     _w2d(),
 158     _d2w(),
 159     _doc2dt( Geom::Scale(1, -1) ),
 160     grids_visible( false )
 161 {
 162     _d2w.setIdentity();
 163     _w2d.setIdentity();
 164
 165     selection = Inkscape::GC::release( new Inkscape::Selection(this) );
 166 }
 167
 168 void
 169 SPDesktop::init (SPNamedView *nv, SPCanvas *aCanvas)
 170 {
 171     // Temporary workaround for link order issues:
 172     Inkscape::DeviceManager::getManager().getDevices();
 173     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 174
 175     _guides_message_context = new Inkscape::MessageContext(const_cast<Inkscape::MessageStack*>(messageStack()));
 176
 177     current = prefs->getStyle("/desktop/style");
 178
 179     namedview = nv;
 180     canvas = aCanvas;
 181
 182     SPDocument *document = SP_OBJECT_DOCUMENT (namedview);
 183     /* Kill flicker */
 184     sp_document_ensure_up_to_date (document);
 185
 186     /* Setup Dialog Manager */
 187     _dlg_mgr = &Inkscape::UI::Dialog::DialogManager::getInstance();
 188
 189     dkey = sp_item_display_key_new (1);
 190
 191     /* Connect document */
 192     setDocument (document);
 193
 194     number = namedview->getViewCount();
 195
 196
 197     /* Setup Canvas */
 198     g_object_set_data (G_OBJECT (canvas), "SPDesktop", this);
 199
 200     SPCanvasGroup *root = sp_canvas_root (canvas);
 201
 202     /* Setup adminstrative layers */
 203     acetate = sp_canvas_item_new (root, GNOME_TYPE_CANVAS_ACETATE, NULL);
 204     g_signal_connect (G_OBJECT (acetate), "event", G_CALLBACK (sp_desktop_root_handler), this);
 205     main = (SPCanvasGroup *) sp_canvas_item_new (root, SP_TYPE_CANVAS_GROUP, NULL);
 206     g_signal_connect (G_OBJECT (main), "event", G_CALLBACK (sp_desktop_root_handler), this);
 207
 208     table = sp_canvas_item_new (main, SP_TYPE_CTRLRECT, NULL);
 209     SP_CTRLRECT(table)->setRectangle(Geom::Rect(Geom::Point(-80000, -80000), Geom::Point(80000, 80000)));
 210     SP_CTRLRECT(table)->setColor(0x00000000, true, 0x00000000);
 211     sp_canvas_item_move_to_z (table, 0);
 212
 213     page = sp_canvas_item_new (main, SP_TYPE_CTRLRECT, NULL);
 214     ((CtrlRect *) page)->setColor(0x00000000, FALSE, 0x00000000);
 215     page_border = sp_canvas_item_new (main, SP_TYPE_CTRLRECT, NULL);
 216
 217     drawing = sp_canvas_item_new (main, SP_TYPE_CANVAS_ARENA, NULL);
 218     g_signal_connect (G_OBJECT (drawing), "arena_event", G_CALLBACK (_arena_handler), this);
 219
 220     SP_CANVAS_ARENA (drawing)->arena->delta = prefs->getDouble("/options/cursortolerance/value", 1.0); // default is 1 px
 221
 222     if (prefs->getBool("/options/startmode/outline")) {
 223         // Start in outline mode
 224         setDisplayModeOutline();
 225     } else {
 226         // Start in normal mode, default
 227         setDisplayModeNormal();
 228     }
 229
 230     gridgroup = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 231     guides = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 232     sketch = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 233     controls = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 234     tempgroup = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 235
 236     /* Push select tool to the bottom of stack */
 237     /** \todo
 238      * FIXME: this is the only call to this.  Everything else seems to just
 239      * call "set" instead of "push".  Can we assume that there is only one
 240      * context ever?
 241      */
 242     push_event_context (SP_TYPE_SELECT_CONTEXT, "/tools/select", SP_EVENT_CONTEXT_STATIC);
 243
 244     // display rect and zoom are now handled in sp_desktop_widget_realize()
 245
 246     Geom::Rect const d(Geom::Point(0.0, 0.0),
 247                        Geom::Point(sp_document_width(document), sp_document_height(document)));
 248
 249     SP_CTRLRECT(page)->setRectangle(d);
 250     SP_CTRLRECT(page_border)->setRectangle(d);
 251
 252     /* the following sets the page shadow on the canvas
 253        It was originally set to 5, which is really cheesy!
 254        It now is an attribute in the document's namedview. If a value of
 255        0 is used, then the constructor for a shadow is not initialized.
 256     */
 257
 258     if ( namedview->pageshadow != 0 && namedview->showpageshadow ) {
 259         SP_CTRLRECT(page_border)->setShadow(namedview->pageshadow, 0x3f3f3fff);
 260     }
 261
 262
 263     /* Connect event for page resize */
 264     _doc2dt[5] = sp_document_height (document);
 265     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (drawing), _doc2dt);
 266
 267     _modified_connection = namedview->connectModified(sigc::bind<2>(sigc::ptr_fun(&_namedview_modified), this));
 268
 269     NRArenaItem *ai = sp_item_invoke_show (SP_ITEM (sp_document_root (document)),
 270             SP_CANVAS_ARENA (drawing)->arena,
 271             dkey,
 272             SP_ITEM_SHOW_DISPLAY);
 273     if (ai) {
 274         nr_arena_item_add_child (SP_CANVAS_ARENA (drawing)->root, ai, NULL);
 275     }
 276
 277     namedview->show(this);
 278     /* Ugly hack */
 279     activate_guides (true);
 280     /* Ugly hack */
 281     _namedview_modified (namedview, SP_OBJECT_MODIFIED_FLAG, this);
 282
 283 /* Set up notification of rebuilding the document, this allows
 284        for saving object related settings in the document. */
 285     _reconstruction_start_connection =
 286         document->connectReconstructionStart(sigc::bind(sigc::ptr_fun(_reconstruction_start), this));
 287     _reconstruction_finish_connection =
 288         document->connectReconstructionFinish(sigc::bind(sigc::ptr_fun(_reconstruction_finish), this));
 289     _reconstruction_old_layer_id = NULL;
 290
 291     // ?
 292     // sp_active_desktop_set (desktop);
 293     _inkscape = INKSCAPE;
 294
 295     _activate_connection = _activate_signal.connect(
 296         sigc::bind(
 297             sigc::ptr_fun(_onActivate),
 298             this
 299         )
 300     );
 301      _deactivate_connection = _deactivate_signal.connect(
 302         sigc::bind(
 303             sigc::ptr_fun(_onDeactivate),
 304             this
 305         )
 306     );
 307
 308     _sel_modified_connection = selection->connectModified(
 309         sigc::bind(
 310             sigc::ptr_fun(&_onSelectionModified),
 311             this
 312         )
 313     );
 314     _sel_changed_connection = selection->connectChanged(
 315         sigc::bind(
 316             sigc::ptr_fun(&_onSelectionChanged),
 317             this
 318         )
 319     );
 320
 321
 322     /* setup LayerManager */
 323     //   (Setting up after the connections are all in place, as it may use some of them)
 324     layer_manager = new Inkscape::LayerManager( this );
 325
 326     showGrids(namedview->grids_visible, false);
 327
 328     temporary_item_list = new Inkscape::Display::TemporaryItemList( this );
 329     snapindicator = new Inkscape::Display::SnapIndicator ( this );
 330 }
 331
 332
 333 void SPDesktop::destroy()
 334 {
 335     if (snapindicator) {
 336         delete snapindicator;
 337         snapindicator = NULL;
 338     }
 339     if (temporary_item_list) {
 340         delete temporary_item_list;
 341         temporary_item_list = NULL;
 342     }
 343
 344     if (selection) {
 345         delete selection;
 346         selection = NULL;
 347     }
 348
 349     namedview->hide(this);
 350
 351     _activate_connection.disconnect();
 352     _deactivate_connection.disconnect();
 353     _sel_modified_connection.disconnect();
 354     _sel_changed_connection.disconnect();
 355     _modified_connection.disconnect();
 356     _commit_connection.disconnect();
 357     _reconstruction_start_connection.disconnect();
 358     _reconstruction_finish_connection.disconnect();
 359
 360     g_signal_handlers_disconnect_by_func(G_OBJECT (acetate), (gpointer) G_CALLBACK(sp_desktop_root_handler), this);
 361     g_signal_handlers_disconnect_by_func(G_OBJECT (main), (gpointer) G_CALLBACK(sp_desktop_root_handler), this);
 362     g_signal_handlers_disconnect_by_func(G_OBJECT (drawing), (gpointer) G_CALLBACK(_arena_handler), this);
 363
 364     while (event_context) {
 365         SPEventContext *ec = event_context;
 366         event_context = ec->next;
 367         sp_event_context_finish (ec);
 368         g_object_unref (G_OBJECT (ec));
 369     }
 370
 371     if (_layer_hierarchy) {
 372         delete _layer_hierarchy;
 373 //        _layer_hierarchy = NULL; //this should be here, but commented to find other bug somewhere else.
 374     }
 375
 376     if (layer_manager) {
 377         delete layer_manager;
 378         layer_manager = NULL;
 379     }
 380
 381     if (_inkscape) {
 382         _inkscape = NULL;
 383     }
 384
 385     if (drawing) {
 386         sp_item_invoke_hide (SP_ITEM (sp_document_root (doc())), dkey);
 387         drawing = NULL;
 388     }
 389
 390     delete _guides_message_context;
 391     _guides_message_context = NULL;
 392
 393     g_list_free (zooms_past);
 394     g_list_free (zooms_future);
 395 }
 396
 397 SPDesktop::~SPDesktop() {}
 398
 399 //--------------------------------------------------------------------
 400 /* Public methods */
 401
 402
 403 /* These methods help for temporarily showing things on-canvas.
 404  * The *only* valid use of the TemporaryItem* that you get from add_temporary_canvasitem
 405  * is when you want to prematurely remove the item from the canvas, by calling
 406  * desktop->remove_temporary_canvasitem(tempitem).
 407  */
 408 /** Note that lifetime is measured in milliseconds
 409  * One should *not* keep a reference to the SPCanvasItem, the temporary item code will
 410  * delete the object for you and the reference will become invalid without you knowing it.
 411  * It is perfectly safe to ignore the returned pointer: the object is deleted by itself, so don't delete it elsewhere!
 412  * The *only* valid use of the returned TemporaryItem* is as argument for SPDesktop::remove_temporary_canvasitem,
 413  * because the object might be deleted already without you knowing it.
 414  * move_to_bottom = true by default so the item does not interfere with handling of other items on the canvas like nodes.
 415  */
 416 Inkscape::Display::TemporaryItem *
 417 SPDesktop::add_temporary_canvasitem (SPCanvasItem *item, guint lifetime, bool move_to_bottom)
 418 {
 419     if (move_to_bottom) {
 420         sp_canvas_item_move_to_z(item, 0);
 421     }
 422
 423     return temporary_item_list->add_item(item, lifetime);
 424 }
 425
 426 /** It is perfectly safe to call this function while the object has already been deleted due to a timeout.
 427 */
 428 void
 429 SPDesktop::remove_temporary_canvasitem (Inkscape::Display::TemporaryItem * tempitem)
 430 {
 431     // check for non-null temporary_item_list, because during destruction of desktop, some destructor might try to access this list!
 432     if (tempitem && temporary_item_list) {
 433         temporary_item_list->delete_item(tempitem);
 434     }
 435 }
 436
 437 void SPDesktop::_setDisplayMode(Inkscape::RenderMode mode) {
 438     SP_CANVAS_ARENA (drawing)->arena->rendermode = mode;
 439     canvas->rendermode = mode;
 440     _display_mode = mode;
 441     if (mode != Inkscape::RENDERMODE_OUTLINE) {
 442         _saved_display_mode = _display_mode;
 443     }
 444     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (main), _d2w); // redraw
 445     _widget->setTitle(SP_DOCUMENT_NAME(sp_desktop_document(this)));
 446 }
 447
 448 void SPDesktop::displayModeToggle() {
 449     if (_display_mode == Inkscape::RENDERMODE_OUTLINE) {
 450         _setDisplayMode(_saved_display_mode);
 451     } else {
 452         _setDisplayMode(Inkscape::RENDERMODE_OUTLINE);
 453     }
 454 }
 455
 456 /**
 457  * Returns current root (=bottom) layer.
 458  */
 459 SPObject *SPDesktop::currentRoot() const
 460 {
 461     return _layer_hierarchy ? _layer_hierarchy->top() : NULL;
 462 }
 463
 464 /**
 465  * Returns current top layer.
 466  */
 467 SPObject *SPDesktop::currentLayer() const
 468 {
 469     return _layer_hierarchy ? _layer_hierarchy->bottom() : NULL;
 470 }
 471
 472 /**
 473  * Sets the current layer of the desktop.
 474  *
 475  * Make \a object the top layer.
 476  */
 477 void SPDesktop::setCurrentLayer(SPObject *object) {
 478     g_return_if_fail(SP_IS_GROUP(object));
 479     g_return_if_fail( currentRoot() == object || (currentRoot() && currentRoot()->isAncestorOf(object)) );
 480     // printf("Set Layer to ID: %s\n", SP_OBJECT_ID(object));
 481     _layer_hierarchy->setBottom(object);
 482 }
 483
 484 void SPDesktop::toggleLayerSolo(SPObject *object) {
 485     g_return_if_fail(SP_IS_GROUP(object));
 486     g_return_if_fail( currentRoot() == object || (currentRoot() && currentRoot()->isAncestorOf(object)) );
 487
 488     bool othersShowing = false;
 489     std::vector<SPObject*> layers;
 490     for ( SPObject* obj = Inkscape::next_layer(currentRoot(), object); obj; obj = Inkscape::next_layer(currentRoot(), obj) ) {
 491         layers.push_back(obj);
 492         othersShowing |= !SP_ITEM(obj)->isHidden();
 493     }
 494     for ( SPObject* obj = Inkscape::previous_layer(currentRoot(), object); obj; obj = Inkscape::previous_layer(currentRoot(), obj) ) {
 495         layers.push_back(obj);
 496         othersShowing |= !SP_ITEM(obj)->isHidden();
 497     }
 498
 499
 500     if ( SP_ITEM(object)->isHidden() ) {
 501         SP_ITEM(object)->setHidden(false);
 502     }
 503
 504     for ( std::vector<SPObject*>::iterator it = layers.begin(); it != layers.end(); ++it ) {
 505         SP_ITEM(*it)->setHidden(othersShowing);
 506     }
 507 }
 508
 509 /**
 510  * Return layer that contains \a object.
 511  */
 512 SPObject *SPDesktop::layerForObject(SPObject *object) {
 513     g_return_val_if_fail(object != NULL, NULL);
 514
 515     SPObject *root=currentRoot();
 516     object = SP_OBJECT_PARENT(object);
 517     while ( object && object != root && !isLayer(object) ) {
 518         object = SP_OBJECT_PARENT(object);
 519     }
 520     return object;
 521 }
 522
 523 /**
 524  * True if object is a layer.
 525  */
 526 bool SPDesktop::isLayer(SPObject *object) const {
 527     return ( SP_IS_GROUP(object)
 528              && ( SP_GROUP(object)->effectiveLayerMode(this->dkey)
 529                   == SPGroup::LAYER ) );
 530 }
 531
 532 /**
 533  * True if desktop viewport fully contains \a item's bbox.
 534  */
 535 bool SPDesktop::isWithinViewport (SPItem *item) const
 536 {
 537     Geom::Rect const viewport = get_display_area();
 538     Geom::OptRect const bbox = sp_item_bbox_desktop(item);
 539     if (bbox) {
 540         return viewport.contains(*bbox);
 541     } else {
 542         return true;
 543     }
 544 }
 545
 546 ///
 547 bool SPDesktop::itemIsHidden(SPItem const *item) const {
 548     return item->isHidden(this->dkey);
 549 }
 550
 551 /**
 552  * Set activate property of desktop; emit signal if changed.
 553  */
 554 void
 555 SPDesktop::set_active (bool new_active)
 556 {
 557     if (new_active != _active) {
 558         _active = new_active;
 559         if (new_active) {
 560             _activate_signal.emit();
 561         } else {
 562             _deactivate_signal.emit();
 563         }
 564     }
 565 }
 566
 567 /**
 568  * Set activate status of current desktop's named view.
 569  */
 570 void
 571 SPDesktop::activate_guides(bool activate)
 572 {
 573     guides_active = activate;
 574     namedview->activateGuides(this, activate);
 575 }
 576
 577 /**
 578  * Make desktop switch documents.
 579  */
 580 void
 581 SPDesktop::change_document (SPDocument *theDocument)
 582 {
 583     g_return_if_fail (theDocument != NULL);
 584
 585     /* unselect everything before switching documents */
 586     selection->clear();
 587
 588     setDocument (theDocument);
 589
 590     /* update the rulers, connect the desktop widget's signal to the new namedview etc.
 591        (this can probably be done in a better way) */
 592     Gtk::Window *parent = this->getToplevel();
 593     g_assert(parent != NULL);
 594     SPDesktopWidget *dtw = (SPDesktopWidget *) parent->get_data("desktopwidget");
 595     if (dtw) dtw->desktop = this;
 596     sp_desktop_widget_update_namedview(dtw);
 597
 598     _namedview_modified (namedview, SP_OBJECT_MODIFIED_FLAG, this);
 599     _document_replaced_signal.emit (this, theDocument);
 600 }
 601
 602 /**
 603  * Make desktop switch event contexts.
 604  */
 605 void
 606 SPDesktop::set_event_context (GtkType type, const gchar *config)
 607 {
 608     SPEventContext *ec;
 609     while (event_context) {
 610         ec = event_context;
 611         sp_event_context_deactivate (ec);
 612         event_context = ec->next;
 613         sp_event_context_finish (ec);
 614         g_object_unref (G_OBJECT (ec));
 615     }
 616
 617     ec = sp_event_context_new (type, this, config, SP_EVENT_CONTEXT_STATIC);
 618     ec->next = event_context;
 619     event_context = ec;
 620     sp_event_context_activate (ec);
 621     _event_context_changed_signal.emit (this, ec);
 622 }
 623
 624 /**
 625  * Push event context onto desktop's context stack.
 626  */
 627 void
 628 SPDesktop::push_event_context (GtkType type, const gchar *config, unsigned int key)
 629 {
 630     SPEventContext *ref, *ec;
 631
 632     if (event_context && event_context->key == key) return;
 633     ref = event_context;
 634     while (ref && ref->next && ref->next->key != key) ref = ref->next;
 635     if (ref && ref->next) {
 636         ec = ref->next;
 637         ref->next = ec->next;
 638         sp_event_context_finish (ec);
 639         g_object_unref (G_OBJECT (ec));
 640     }
 641
 642     if (event_context) sp_event_context_deactivate (event_context);
 643     ec = sp_event_context_new (type, this, config, key);
 644     ec->next = event_context;
 645     event_context = ec;
 646     sp_event_context_activate (ec);
 647     _event_context_changed_signal.emit (this, ec);
 648 }
 649
 650 /**
 651  * Sets the coordinate status to a given point
 652  */
 653 void
 654 SPDesktop::set_coordinate_status (Geom::Point p) {
 655     _widget->setCoordinateStatus(p);
 656 }
 657
 658 /**
 659  * \see sp_document_item_from_list_at_point_bottom()
 660  */
 661 SPItem *
 662 SPDesktop::item_from_list_at_point_bottom (const GSList *list, Geom::Point const p) const
 663 {
 664     g_return_val_if_fail (doc() != NULL, NULL);
 665     return sp_document_item_from_list_at_point_bottom (dkey, SP_GROUP (doc()->root), list, p);
 666 }
 667
 668 /**
 669  * \see sp_document_item_at_point()
 670  */
 671 SPItem *
 672 SPDesktop::item_at_point (Geom::Point const p, bool into_groups, SPItem *upto) const
 673 {
 674     g_return_val_if_fail (doc() != NULL, NULL);
 675     return sp_document_item_at_point (doc(), dkey, p, into_groups, upto);
 676 }
 677
 678 /**
 679  * \see sp_document_group_at_point()
 680  */
 681 SPItem *
 682 SPDesktop::group_at_point (Geom::Point const p) const
 683 {
 684     g_return_val_if_fail (doc() != NULL, NULL);
 685     return sp_document_group_at_point (doc(), dkey, p);
 686 }
 687
 688 /**
 689  * \brief  Returns the mouse point in document coordinates; if mouse is
 690  * outside the canvas, returns the center of canvas viewpoint
 691  */
 692 Geom::Point
 693 SPDesktop::point() const
 694 {
 695     Geom::Point p = _widget->getPointer();
 696     Geom::Point pw = sp_canvas_window_to_world (canvas, p);
 697     p = w2d(pw);
 698
 699     Geom::Rect const r = canvas->getViewbox();
 700
 701     Geom::Point r0 = w2d(r.min());
 702     Geom::Point r1 = w2d(r.max());
 703
 704     if (p[Geom::X] >= r0[Geom::X] &&
 705         p[Geom::X] <= r1[Geom::X] &&
 706         p[Geom::Y] >= r1[Geom::Y] &&
 707         p[Geom::Y] <= r0[Geom::Y])
 708     {
 709         return p;
 710     } else {
 711         return (r0 + r1) / 2;
 712     }
 713 }
 714
 715 /**
 716  * Put current zoom data in history list.
 717  */
 718 void
 719 SPDesktop::push_current_zoom (GList **history)
 720 {
 721     Geom::Rect const area = get_display_area();
 722
 723     NRRect *old_zoom = g_new(NRRect, 1);
 724     old_zoom->x0 = area.min()[Geom::X];
 725     old_zoom->x1 = area.max()[Geom::X];
 726     old_zoom->y0 = area.min()[Geom::Y];
 727     old_zoom->y1 = area.max()[Geom::Y];
 728     if ( *history == NULL
 729          || !( ( ((NRRect *) ((*history)->data))->x0 == old_zoom->x0 ) &&
 730                ( ((NRRect *) ((*history)->data))->x1 == old_zoom->x1 ) &&
 731                ( ((NRRect *) ((*history)->data))->y0 == old_zoom->y0 ) &&
 732                ( ((NRRect *) ((*history)->data))->y1 == old_zoom->y1 ) ) )
 733     {
 734         *history = g_list_prepend (*history, old_zoom);
 735     }
 736 }
 737
 738 /**
 739  * Set viewbox (x0, x1, y0 and y1 are in document pixels. Border is in screen pixels).
 740  */
 741 void
 742 SPDesktop::set_display_area (double x0, double y0, double x1, double y1, double border, bool log)
 743 {
 744     g_assert(_widget);
 745
 746     // save the zoom
 747     if (log) {
 748         push_current_zoom(&zooms_past);
 749         // if we do a logged zoom, our zoom-forward list is invalidated, so delete it
 750         g_list_free (zooms_future);
 751         zooms_future = NULL;
 752     }
 753
 754     double const cx = 0.5 * (x0 + x1);
 755     double const cy = 0.5 * (y0 + y1);
 756
 757     // FIXME: This 2geom idiom doesn't allow us to declare dbox const
 758     Geom::Rect viewbox = canvas->getViewbox();
 759     viewbox.expandBy(-border);
 760
 761     double scale = _d2w.descrim();
 762     double newscale;
 763     if (((x1 - x0) * viewbox.dimensions()[Geom::Y]) > ((y1 - y0) * viewbox.dimensions()[Geom::X])) {
 764         newscale = viewbox.dimensions()[Geom::X] / (x1 - x0);
 765     } else {
 766         newscale = viewbox.dimensions()[Geom::Y] / (y1 - y0);
 767     }
 768
 769     newscale = CLAMP(newscale, SP_DESKTOP_ZOOM_MIN, SP_DESKTOP_ZOOM_MAX); // unit: 'screen pixels' per 'document pixels'
 770
 771     int clear = FALSE;
 772     if (!NR_DF_TEST_CLOSE (newscale, scale, 1e-4 * scale)) {
 773         /* Set zoom factors */
 774         _d2w = Geom::Scale(newscale, -newscale);
 775         _w2d = Geom::Scale(1/newscale, 1/-newscale);
 776         sp_canvas_item_affine_absolute(SP_CANVAS_ITEM(main), _d2w);
 777         clear = TRUE;
 778     }
 779
 780     /* Calculate top left corner (in document pixels) */
 781     x0 = cx - 0.5 * viewbox.dimensions()[Geom::X] / newscale;
 782     y1 = cy + 0.5 * viewbox.dimensions()[Geom::Y] / newscale;
 783
 784     /* Scroll */
 785     sp_canvas_scroll_to (canvas, x0 * newscale - border, y1 * -newscale - border, clear);
 786
 787     /*  update perspective lines if we are in the 3D box tool (so that infinite ones are shown correctly) */
 788     sp_box3d_context_update_lines(event_context);
 789
 790     _widget->updateRulers();
 791     _widget->updateScrollbars(_d2w.descrim());
 792     _widget->updateZoom();
 793 }
 794
 795 void SPDesktop::set_display_area(Geom::Rect const &a, Geom::Coord b, bool log)
 796 {
 797     set_display_area(a.min()[Geom::X], a.min()[Geom::Y], a.max()[Geom::X], a.max()[Geom::Y], b, log);
 798 }
 799
 800 /**
 801  * Return viewbox dimensions.
 802  */
 803 Geom::Rect SPDesktop::get_display_area() const
 804 {
 805     Geom::Rect const viewbox = canvas->getViewbox();
 806
 807     double const scale = _d2w[0];
 808
 809     return Geom::Rect(Geom::Point(viewbox.min()[Geom::X] / scale, viewbox.max()[Geom::Y] / -scale),
 810                       Geom::Point(viewbox.max()[Geom::X] / scale, viewbox.min()[Geom::Y] / -scale));
 811 }
 812
 813 /**
 814  * Revert back to previous zoom if possible.
 815  */
 816 void
 817 SPDesktop::prev_zoom()
 818 {
 819     if (zooms_past == NULL) {
 820         messageStack()->flash(Inkscape::WARNING_MESSAGE, _("No previous zoom."));
 821         return;
 822     }
 823
 824     // push current zoom into forward zooms list
 825     push_current_zoom (&zooms_future);
 826
 827     // restore previous zoom
 828     set_display_area (((NRRect *) zooms_past->data)->x0,
 829             ((NRRect *) zooms_past->data)->y0,
 830             ((NRRect *) zooms_past->data)->x1,
 831             ((NRRect *) zooms_past->data)->y1,
 832             0, false);
 833
 834     // remove the just-added zoom from the past zooms list
 835     zooms_past = g_list_remove (zooms_past, ((NRRect *) zooms_past->data));
 836 }
 837
 838 /**
 839  * Set zoom to next in list.
 840  */
 841 void
 842 SPDesktop::next_zoom()
 843 {
 844     if (zooms_future == NULL) {
 845         this->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("No next zoom."));
 846         return;
 847     }
 848
 849     // push current zoom into past zooms list
 850     push_current_zoom (&zooms_past);
 851
 852     // restore next zoom
 853     set_display_area (((NRRect *) zooms_future->data)->x0,
 854             ((NRRect *) zooms_future->data)->y0,
 855             ((NRRect *) zooms_future->data)->x1,
 856             ((NRRect *) zooms_future->data)->y1,
 857             0, false);
 858
 859     // remove the just-used zoom from the zooms_future list
 860     zooms_future = g_list_remove (zooms_future, ((NRRect *) zooms_future->data));
 861 }
 862
 863 #include "tools-switch.h"
 864 #include "node-context.h"
 865 #include "shape-editor.h"
 866 #include "nodepath.h"
 867
 868 /** \brief  Performs a quick zoom into what the user is working on
 869     \param  enable  Whether we're going in or out of quick zoom
 870
 871 */
 872 void
 873 SPDesktop::zoom_quick (bool enable)
 874 {
 875     if (enable == _quick_zoom_enabled) {
 876         return;
 877     }
 878
 879     if (enable == true) {
 880         _quick_zoom_stored_area = get_display_area();
 881         bool zoomed = false;
 882
 883         if (!zoomed) {
 884             SPItem * singleItem = selection->singleItem();
 885             if (singleItem != NULL && tools_isactive(this, TOOLS_NODES)) {
 886
 887                 Inkscape::NodePath::Path * nodepath = event_context->shape_editor->get_nodepath();
 888                 // printf("I've got a nodepath, crazy\n");
 889
 890                 Geom::Rect nodes;
 891                 bool firstnode = true;
 892
 893                 if (nodepath->selected) {
 894                     for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
 895                        Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
 896                         for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
 897                            Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
 898                             if (node->selected) {
 899                                 // printf("\tSelected node\n");
 900                                 if (firstnode) {
 901                                     nodes = Geom::Rect(node->pos, node->pos);
 902                                     firstnode = false;
 903                                 } else {
 904                                     nodes.expandTo(node->pos);
 905                                 }
 906
 907                                 if (node->p.other != NULL) {
 908                                     /* Include previous node pos */
 909                                     nodes.expandTo(node->p.other->pos);
 910
 911                                     /* Include previous handle */
 912                                     if (!sp_node_side_is_line(node, &node->p)) {
 913                                         nodes.expandTo(node->p.pos);
 914                                     }
 915                                 }
 916
 917                                 if (node->n.other != NULL) {
 918                                     /* Include previous node pos */
 919                                     nodes.expandTo(node->n.other->pos);
 920
 921                                     /* Include previous handle */
 922                                     if (!sp_node_side_is_line(node, &node->n)) {
 923                                         nodes.expandTo(node->n.pos);
 924                                     }
 925                                 }
 926                             }
 927                         }
 928                     }
 929
 930                     if (!firstnode && nodes.area() * 2.0 < _quick_zoom_stored_area.area()) {
 931                         set_display_area(nodes, 10);
 932                         zoomed = true;
 933                     }
 934                 }
 935             }
 936         }
 937
 938         if (!zoomed) {
 939             Geom::OptRect const d = selection->bounds();
 940             if (d && d->area() * 2.0 < _quick_zoom_stored_area.area()) {
 941                 set_display_area(*d, 10);
 942                 zoomed = true;
 943             }
 944         }
 945
 946         if (!zoomed) {
 947             zoom_relative(_quick_zoom_stored_area.midpoint()[Geom::X], _quick_zoom_stored_area.midpoint()[Geom::Y], 2.0);
 948             zoomed = true;
 949         }
 950     } else {
 951         set_display_area(_quick_zoom_stored_area, 0);
 952     }
 953
 954     _quick_zoom_enabled = enable;
 955     return;
 956 }
 957
 958 /**
 959  * Zoom to point with absolute zoom factor.
 960  */
 961 void
 962 SPDesktop::zoom_absolute_keep_point (double cx, double cy, double px, double py, double zoom)
 963 {
 964     zoom = CLAMP (zoom, SP_DESKTOP_ZOOM_MIN, SP_DESKTOP_ZOOM_MAX);
 965
 966     // maximum or minimum zoom reached, but there's no exact equality because of rounding errors;
 967     // this check prevents "sliding" when trying to zoom in at maximum zoom;
 968     /// \todo someone please fix calculations properly and remove this hack
 969     if (fabs(_d2w.descrim() - zoom) < 0.0001*zoom && (fabs(SP_DESKTOP_ZOOM_MAX - zoom) < 0.01 || fabs(SP_DESKTOP_ZOOM_MIN - zoom) < 0.000001))
 970         return;
 971
 972     Geom::Rect const viewbox = canvas->getViewbox();
 973
 974     double const width2 = viewbox.dimensions()[Geom::X] / zoom;
 975     double const height2 = viewbox.dimensions()[Geom::Y] / zoom;
 976
 977     set_display_area(cx - px * width2,
 978                      cy - py * height2,
 979                      cx + (1 - px) * width2,
 980                      cy + (1 - py) * height2,
 981                      0.0);
 982 }
 983
 984 /**
 985  * Zoom to center with absolute zoom factor.
 986  */
 987 void
 988 SPDesktop::zoom_absolute (double cx, double cy, double zoom)
 989 {
 990     zoom_absolute_keep_point (cx, cy, 0.5, 0.5, zoom);
 991 }
 992
 993 /**
 994  * Zoom to point with relative zoom factor.
 995  */
 996 void
 997 SPDesktop::zoom_relative_keep_point (double cx, double cy, double zoom)
 998 {
 999     Geom::Rect const area = get_display_area();
1000
1001     if (cx < area.min()[Geom::X]) {
1002         cx = area.min()[Geom::X];
1003     }
1004     if (cx > area.max()[Geom::X]) {
1005         cx = area.max()[Geom::X];
1006     }
1007     if (cy < area.min()[Geom::Y]) {
1008         cy = area.min()[Geom::Y];
1009     }
1010     if (cy > area.max()[Geom::Y]) {
1011         cy = area.max()[Geom::Y];
1012     }
1013
1014     gdouble const scale = _d2w.descrim() * zoom;
1015     double const px = (cx - area.min()[Geom::X]) / area.dimensions()[Geom::X];
1016     double const py = (cy - area.min()[Geom::Y]) / area.dimensions()[Geom::Y];
1017
1018     zoom_absolute_keep_point(cx, cy, px, py, scale);
1019 }
1020
1021 /**
1022  * Zoom to center with relative zoom factor.
1023  */
1024 void
1025 SPDesktop::zoom_relative (double cx, double cy, double zoom)
1026 {
1027     gdouble scale = _d2w.descrim() * zoom;
1028     zoom_absolute (cx, cy, scale);
1029 }
1030
1031 /**
1032  * Set display area to origin and current document dimensions.
1033  */
1034 void
1035 SPDesktop::zoom_page()
1036 {
1037     Geom::Rect d(Geom::Point(0, 0),
1038                  Geom::Point(sp_document_width(doc()), sp_document_height(doc())));
1039
1040     if (d.minExtent() < 1.0) {
1041         return;
1042     }
1043
1044     set_display_area(d, 10);
1045 }
1046
1047 /**
1048  * Set display area to current document width.
1049  */
1050 void
1051 SPDesktop::zoom_page_width()
1052 {
1053     Geom::Rect const a = get_display_area();
1054
1055     if (sp_document_width(doc()) < 1.0) {
1056         return;
1057     }
1058
1059     Geom::Rect d(Geom::Point(0, a.midpoint()[Geom::Y]),
1060                  Geom::Point(sp_document_width(doc()), a.midpoint()[Geom::Y]));
1061
1062     set_display_area(d, 10);
1063 }
1064
1065 /**
1066  * Zoom to selection.
1067  */
1068 void
1069 SPDesktop::zoom_selection()
1070 {
1071     Geom::OptRect const d = selection->bounds();
1072
1073     if ( !d || d->minExtent() < 0.1 ) {
1074         return;
1075     }
1076
1077     set_display_area(*d, 10);
1078 }
1079
1080 /**
1081  * Tell widget to let zoom widget grab keyboard focus.
1082  */
1083 void
1084 SPDesktop::zoom_grab_focus()
1085 {
1086     _widget->letZoomGrabFocus();
1087 }
1088
1089 /**
1090  * Zoom to whole drawing.
1091  */
1092 void
1093 SPDesktop::zoom_drawing()
1094 {
1095     g_return_if_fail (doc() != NULL);
1096     SPItem *docitem = SP_ITEM (sp_document_root (doc()));
1097     g_return_if_fail (docitem != NULL);
1098
1099     Geom::OptRect d = sp_item_bbox_desktop(docitem);
1100
1101     /* Note that the second condition here indicates that
1102     ** there are no items in the drawing.
1103     */
1104     if ( !d || d->minExtent() < 0.1 ) {
1105         return;
1106     }
1107
1108     set_display_area(*d, 10);
1109 }
1110
1111 /**
1112  * Scroll canvas by specific coordinate amount in svg coordinates.
1113  */
1114 void
1115 SPDesktop::scroll_world_in_svg_coords (double dx, double dy, bool is_scrolling)
1116 {
1117     double scale = _d2w.descrim();
1118     scroll_world(dx*scale, dy*scale, is_scrolling);
1119 }
1120
1121 /**
1122  * Scroll canvas by specific coordinate amount.
1123  */
1124 void
1125 SPDesktop::scroll_world (double dx, double dy, bool is_scrolling)
1126 {
1127     g_assert(_widget);
1128
1129     Geom::Rect const viewbox = canvas->getViewbox();
1130
1131     sp_canvas_scroll_to(canvas, viewbox.min()[Geom::X] - dx, viewbox.min()[Geom::Y] - dy, FALSE, is_scrolling);
1132
1133     /*  update perspective lines if we are in the 3D box tool (so that infinite ones are shown correctly) */
1134     sp_box3d_context_update_lines(event_context);
1135
1136     _widget->updateRulers();
1137     _widget->updateScrollbars(_d2w.descrim());
1138 }
1139
1140 bool
1141 SPDesktop::scroll_to_point (Geom::Point const &p, gdouble autoscrollspeed)
1142 {
1143     using Geom::X;
1144     using Geom::Y;
1145
1146     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1147     gdouble autoscrolldistance = (gdouble) prefs->getIntLimited("/options/autoscrolldistance/value", 0, -1000, 10000);
1148
1149     // autoscrolldistance is in screen pixels, but the display area is in document units
1150     autoscrolldistance /= _d2w.descrim();
1151     // FIXME: This 2geom idiom doesn't allow us to declare dbox const
1152     Geom::Rect dbox = get_display_area();
1153     dbox.expandBy(-autoscrolldistance);
1154
1155     if (!(p[X] > dbox.min()[X] && p[X] < dbox.max()[X]) ||
1156         !(p[Y] > dbox.min()[Y] && p[Y] < dbox.max()[Y])   ) {
1157
1158         Geom::Point const s_w( p * (Geom::Matrix)_d2w );
1159
1160         gdouble x_to;
1161         if (p[X] < dbox.min()[X])
1162             x_to = dbox.min()[X];
1163         else if (p[X] > dbox.max()[X])
1164             x_to = dbox.max()[X];
1165         else
1166             x_to = p[X];
1167
1168         gdouble y_to;
1169         if (p[Y] < dbox.min()[Y])
1170             y_to = dbox.min()[Y];
1171         else if (p[Y] > dbox.max()[Y])
1172             y_to = dbox.max()[Y];
1173         else
1174             y_to = p[Y];
1175
1176         Geom::Point const d_dt(x_to, y_to);
1177         Geom::Point const d_w( d_dt * _d2w );
1178         Geom::Point const moved_w( d_w - s_w );
1179
1180         if (autoscrollspeed == 0)
1181             autoscrollspeed = prefs->getDoubleLimited("/options/autoscrollspeed/value", 1, 0, 10);
1182
1183         if (autoscrollspeed != 0)
1184             scroll_world (autoscrollspeed * moved_w);
1185
1186         return true;
1187     }
1188     return false;
1189 }
1190
1191 bool
1192 SPDesktop::is_iconified()
1193 {
1194     return 0!=(window_state & GDK_WINDOW_STATE_ICONIFIED);
1195 }
1196
1197 void
1198 SPDesktop::iconify()
1199 {
1200     _widget->setIconified();
1201 }
1202
1203 bool
1204 SPDesktop::is_maximized()
1205 {
1206     return 0!=(window_state & GDK_WINDOW_STATE_MAXIMIZED);
1207 }
1208
1209 void
1210 SPDesktop::maximize()
1211 {
1212     _widget->setMaximized();
1213 }
1214
1215 bool
1216 SPDesktop::is_fullscreen()
1217 {
1218     return 0!=(window_state & GDK_WINDOW_STATE_FULLSCREEN);
1219 }
1220
1221 void
1222 SPDesktop::fullscreen()
1223 {
1224     _widget->setFullscreen();
1225 }
1226
1227 /** \brief  Checks to see if the user is working in focused mode
1228
1229     Returns the value of \c _focusMode
1230 */
1231 bool
1232 SPDesktop::is_focusMode()
1233 {
1234     return _focusMode;
1235 }
1236
1237 /** \brief  Changes whether the user is in focus mode or not
1238     \param  mode  Which mode the view should be in
1239
1240 */
1241 void
1242 SPDesktop::focusMode (bool mode)
1243 {
1244     if (mode == _focusMode) { return; }
1245
1246     _focusMode = mode;
1247
1248     layoutWidget();
1249     //sp_desktop_widget_layout(SPDesktopWidget);
1250
1251     return;
1252 }
1253
1254 void
1255 SPDesktop::getWindowGeometry (gint &x, gint &y, gint &w, gint &h)
1256 {
1257     _widget->getGeometry (x, y, w, h);
1258 }
1259
1260 void
1261 SPDesktop::setWindowPosition (Geom::Point p)
1262 {
1263     _widget->setPosition (p);
1264 }
1265
1266 void
1267 SPDesktop::setWindowSize (gint w, gint h)
1268 {
1269     _widget->setSize (w, h);
1270 }
1271
1272 void
1273 SPDesktop::setWindowTransient (void *p, int transient_policy)
1274 {
1275     _widget->setTransient (p, transient_policy);
1276 }
1277
1278 Gtk::Window*
1279 SPDesktop::getToplevel( )
1280 {
1281     return _widget->getWindow();
1282 }
1283
1284 void
1285 SPDesktop::presentWindow()
1286 {
1287     _widget->present();
1288 }
1289
1290 bool
1291 SPDesktop::warnDialog (gchar *text)
1292 {
1293     return _widget->warnDialog (text);
1294 }
1295
1296 void
1297 SPDesktop::toggleRulers()
1298 {
1299     _widget->toggleRulers();
1300 }
1301
1302 void
1303 SPDesktop::toggleScrollbars()
1304 {
1305     _widget->toggleScrollbars();
1306 }
1307
1308 void
1309 SPDesktop::layoutWidget()
1310 {
1311     _widget->layout();
1312 }
1313
1314 void
1315 SPDesktop::destroyWidget()
1316 {
1317     _widget->destroy();
1318 }
1319
1320 bool
1321 SPDesktop::shutdown()
1322 {
1323     return _widget->shutdown();
1324 }
1325
1326 bool SPDesktop::onDeleteUI (GdkEventAny*)
1327 {
1328     if(shutdown())
1329         return true;
1330
1331     destroyWidget();
1332     return false;
1333 }
1334
1335 /**
1336  *  onWindowStateEvent
1337  *
1338  *  Called when the window changes its maximize/fullscreen/iconify/pinned state.
1339  *  Since GTK doesn't have a way to query this state information directly, we
1340  *  record it for the desktop here, and also possibly trigger a layout.
1341  */
1342 bool
1343 SPDesktop::onWindowStateEvent (GdkEventWindowState* event)
1344 {
1345     // Record the desktop window's state
1346     window_state = event->new_window_state;
1347
1348     // Layout may differ depending on full-screen mode or not
1349     GdkWindowState changed = event->changed_mask;
1350     if (changed & (GDK_WINDOW_STATE_FULLSCREEN|GDK_WINDOW_STATE_MAXIMIZED)) {
1351         layoutWidget();
1352     }
1353
1354     return false;
1355 }
1356
1357 void
1358 SPDesktop::setToolboxFocusTo (gchar const *label)
1359 {
1360     _widget->setToolboxFocusTo (label);
1361 }
1362
1363 void
1364 SPDesktop::setToolboxAdjustmentValue (gchar const* id, double val)
1365 {
1366     _widget->setToolboxAdjustmentValue (id, val);
1367 }
1368
1369 void
1370 SPDesktop::setToolboxSelectOneValue (gchar const* id, gint val)
1371 {
1372     _widget->setToolboxSelectOneValue (id, val);
1373 }
1374
1375 bool
1376 SPDesktop::isToolboxButtonActive (gchar const *id)
1377 {
1378     return _widget->isToolboxButtonActive (id);
1379 }
1380
1381 void
1382 SPDesktop::emitToolSubselectionChanged(gpointer data)
1383 {
1384     _tool_subselection_changed.emit(data);
1385     inkscape_subselection_changed (this);
1386 }
1387
1388 void
1389 SPDesktop::updateNow()
1390 {
1391   sp_canvas_update_now(canvas);
1392 }
1393
1394 void
1395 SPDesktop::enableInteraction()
1396 {
1397   _widget->enableInteraction();
1398 }
1399
1400 void SPDesktop::disableInteraction()
1401 {
1402   _widget->disableInteraction();
1403 }
1404
1405 void SPDesktop::setWaitingCursor()
1406 {
1407     GdkCursor *waiting = gdk_cursor_new(GDK_WATCH);
1408     gdk_window_set_cursor(GTK_WIDGET(sp_desktop_canvas(this))->window, waiting);
1409     gdk_cursor_unref(waiting);
1410     // GDK needs the flush for the cursor change to take effect
1411     gdk_flush();
1412     waiting_cursor = true;
1413 }
1414
1415 void SPDesktop::clearWaitingCursor()
1416 {
1417   if (waiting_cursor)
1418       sp_event_context_update_cursor(sp_desktop_event_context(this));
1419 }
1420
1421 void SPDesktop::toggleColorProfAdjust()
1422 {
1423     _widget->toggleColorProfAdjust();
1424 }
1425
1426 void SPDesktop::toggleGrids()
1427 {
1428     if (namedview->grids) {
1429         if(gridgroup) {
1430             showGrids(!grids_visible);
1431         }
1432     } else {
1433         //there is no grid present at the moment. add a rectangular grid and make it visible
1434         Inkscape::XML::Node *repr = SP_OBJECT_REPR(namedview);
1435         Inkscape::CanvasGrid::writeNewGridToRepr(repr, sp_desktop_document(this), Inkscape::GRID_RECTANGULAR);
1436         showGrids(true);
1437     }
1438 }
1439
1440 void SPDesktop::showGrids(bool show, bool dirty_document)
1441 {
1442     grids_visible = show;
1443     sp_namedview_show_grids(namedview, grids_visible, dirty_document);
1444     if (show) {
1445         sp_canvas_item_show(SP_CANVAS_ITEM(gridgroup));
1446     } else {
1447         sp_canvas_item_hide(SP_CANVAS_ITEM(gridgroup));
1448     }
1449 }
1450
1451 void SPDesktop::toggleSnapGlobal()
1452 {
1453     bool v = namedview->snap_manager.snapprefs.getSnapEnabledGlobally();
1454     Inkscape::XML::Node *repr = SP_OBJECT_REPR(namedview);
1455     sp_repr_set_boolean(repr, "inkscape:snap-global", !v);
1456 }
1457
1458 //----------------------------------------------------------------------
1459 // Callback implementations. The virtual ones are connected by the view.
1460
1461 void
1462 SPDesktop::onPositionSet (double x, double y)
1463 {
1464     _widget->viewSetPosition (Geom::Point(x,y));
1465 }
1466
1467 void
1468 SPDesktop::onResized (double /*x*/, double /*y*/)
1469 {
1470    // Nothing called here
1471 }
1472
1473 /**
1474  * Redraw callback; queues Gtk redraw; connected by View.
1475  */
1476 void
1477 SPDesktop::onRedrawRequested ()
1478 {
1479     if (main) {
1480         _widget->requestCanvasUpdate();
1481     }
1482 }
1483
1484 void
1485 SPDesktop::updateCanvasNow()
1486 {
1487   _widget->requestCanvasUpdateAndWait();
1488 }
1489
1490 /**
1491  * Associate document with desktop.
1492  */
1493 void
1494 SPDesktop::setDocument (SPDocument *doc)
1495 {
1496     if (this->doc() && doc) {
1497         namedview->hide(this);
1498         sp_item_invoke_hide (SP_ITEM (sp_document_root (this->doc())), dkey);
1499     }
1500
1501     if (_layer_hierarchy) {
1502         _layer_hierarchy->clear();
1503         delete _layer_hierarchy;
1504     }
1505     _layer_hierarchy = new Inkscape::ObjectHierarchy(NULL);
1506     _layer_hierarchy->connectAdded(sigc::bind(sigc::ptr_fun(_layer_activated), this));
1507     _layer_hierarchy->connectRemoved(sigc::bind(sigc::ptr_fun(_layer_deactivated), this));
1508     _layer_hierarchy->connectChanged(sigc::bind(sigc::ptr_fun(_layer_hierarchy_changed), this));
1509     _layer_hierarchy->setTop(SP_DOCUMENT_ROOT(doc));
1510
1511     /* setup EventLog */
1512     event_log = new Inkscape::EventLog(doc);
1513     doc->addUndoObserver(*event_log);
1514
1515     _commit_connection.disconnect();
1516     _commit_connection = doc->connectCommit(sigc::mem_fun(*this, &SPDesktop::updateNow));
1517
1518     /// \todo fixme: This condition exists to make sure the code
1519     /// inside is NOT called on initialization, only on replacement. But there
1520     /// are surely more safe methods to accomplish this.
1521     // TODO since the comment had reversed logic, check the intent of this block of code:
1522     if (drawing) {
1523         NRArenaItem *ai = 0;
1524
1525         namedview = sp_document_namedview (doc, NULL);
1526         _modified_connection = namedview->connectModified(sigc::bind<2>(sigc::ptr_fun(&_namedview_modified), this));
1527         number = namedview->getViewCount();
1528
1529         ai = sp_item_invoke_show (SP_ITEM (sp_document_root (doc)),
1530                 SP_CANVAS_ARENA (drawing)->arena,
1531                 dkey,
1532                 SP_ITEM_SHOW_DISPLAY);
1533         if (ai) {
1534             nr_arena_item_add_child (SP_CANVAS_ARENA (drawing)->root, ai, NULL);
1535         }
1536         namedview->show(this);
1537         /* Ugly hack */
1538         activate_guides (true);
1539         /* Ugly hack */
1540         _namedview_modified (namedview, SP_OBJECT_MODIFIED_FLAG, this);
1541     }
1542
1543     _document_replaced_signal.emit (this, doc);
1544
1545     View::setDocument (doc);
1546 }
1547
1548 void
1549 SPDesktop::onStatusMessage
1550 (Inkscape::MessageType type, gchar const *message)
1551 {
1552     if (_widget) {
1553         _widget->setMessage(type, message);
1554     }
1555 }
1556
1557 void
1558 SPDesktop::onDocumentURISet (gchar const* uri)
1559 {
1560     _widget->setTitle(uri);
1561 }
1562
1563 /**
1564  * Resized callback.
1565  */
1566 void
1567 SPDesktop::onDocumentResized (gdouble width, gdouble height)
1568 {
1569     _doc2dt[5] = height;
1570     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (drawing), _doc2dt);
1571     Geom::Rect const a(Geom::Point(0, 0), Geom::Point(width, height));
1572     SP_CTRLRECT(page)->setRectangle(a);
1573     SP_CTRLRECT(page_border)->setRectangle(a);
1574 }
1575
1576
1577 void
1578 SPDesktop::_onActivate (SPDesktop* dt)
1579 {
1580     if (!dt->_widget) return;
1581     dt->_widget->activateDesktop();
1582 }
1583
1584 void
1585 SPDesktop::_onDeactivate (SPDesktop* dt)
1586 {
1587     if (!dt->_widget) return;
1588     dt->_widget->deactivateDesktop();
1589 }
1590
1591 void
1592 SPDesktop::_onSelectionModified
1593 (Inkscape::Selection */*selection*/, guint /*flags*/, SPDesktop *dt)
1594 {
1595     if (!dt->_widget) return;
1596     dt->_widget->updateScrollbars (dt->_d2w.descrim());
1597 }
1598
1599 static void
1600 _onSelectionChanged
1601 (Inkscape::Selection *selection, SPDesktop *desktop)
1602 {
1603     /** \todo
1604      * only change the layer for single selections, or what?
1605      * This seems reasonable -- for multiple selections there can be many
1606      * different layers involved.
1607      */
1608     SPItem *item=selection->singleItem();
1609     if (item) {
1610         SPObject *layer=desktop->layerForObject(item);
1611         if ( layer && layer != desktop->currentLayer() ) {
1612             desktop->setCurrentLayer(layer);
1613         }
1614     }
1615 }
1616
1617 /**
1618  * Calls event handler of current event context.
1619  * \param arena Unused
1620  * \todo fixme
1621  */
1622 static gint
1623 _arena_handler (SPCanvasArena */*arena*/, NRArenaItem *ai, GdkEvent *event, SPDesktop *desktop)
1624 {
1625     if (ai) {
1626         SPItem *spi = (SPItem*)NR_ARENA_ITEM_GET_DATA (ai);
1627         return sp_event_context_item_handler (desktop->event_context, spi, event);
1628     } else {
1629         return sp_event_context_root_handler (desktop->event_context, event);
1630     }
1631 }
1632
1633 static void
1634 _layer_activated(SPObject *layer, SPDesktop *desktop) {
1635     g_return_if_fail(SP_IS_GROUP(layer));
1636     SP_GROUP(layer)->setLayerDisplayMode(desktop->dkey, SPGroup::LAYER);
1637 }
1638
1639 /// Callback
1640 static void
1641 _layer_deactivated(SPObject *layer, SPDesktop *desktop) {
1642     g_return_if_fail(SP_IS_GROUP(layer));
1643     SP_GROUP(layer)->setLayerDisplayMode(desktop->dkey, SPGroup::GROUP);
1644 }
1645
1646 /// Callback
1647 static void
1648 _layer_hierarchy_changed(SPObject */*top*/, SPObject *bottom,
1649                                          SPDesktop *desktop)
1650 {
1651     desktop->_layer_changed_signal.emit (bottom);
1652 }
1653
1654 /// Called when document is starting to be rebuilt.
1655 static void
1656 _reconstruction_start (SPDesktop * desktop)
1657 {
1658     // printf("Desktop, starting reconstruction\n");
1659     desktop->_reconstruction_old_layer_id = g_strdup(SP_OBJECT_ID(desktop->currentLayer()));
1660     desktop->_layer_hierarchy->setBottom(desktop->currentRoot());
1661
1662     /*
1663     GSList const * selection_objs = desktop->selection->list();
1664     for (; selection_objs != NULL; selection_objs = selection_objs->next) {
1665
1666     }
1667     */
1668     desktop->selection->clear();
1669
1670     // printf("Desktop, starting reconstruction end\n");
1671 }
1672
1673 /// Called when document rebuild is finished.
1674 static void
1675 _reconstruction_finish (SPDesktop * desktop)
1676 {
1677     // printf("Desktop, finishing reconstruction\n");
1678     if (desktop->_reconstruction_old_layer_id == NULL)
1679         return;
1680
1681     SPObject * newLayer = SP_OBJECT_DOCUMENT(desktop->namedview)->getObjectById(desktop->_reconstruction_old_layer_id);
1682     if (newLayer != NULL)
1683         desktop->setCurrentLayer(newLayer);
1684
1685     g_free(desktop->_reconstruction_old_layer_id);
1686     desktop->_reconstruction_old_layer_id = NULL;
1687     // printf("Desktop, finishing reconstruction end\n");
1688     return;
1689 }
1690
1691 /**
1692  * Namedview_modified callback.
1693  */
1694 static void
1695 _namedview_modified (SPObject *obj, guint flags, SPDesktop *desktop)
1696 {
1697     SPNamedView *nv=SP_NAMEDVIEW(obj);
1698
1699     if (flags & SP_OBJECT_MODIFIED_FLAG) {
1700
1701         /* Recalculate snap distances */
1702         /* FIXME: why is the desktop getting involved in setting up something
1703         ** that is entirely to do with the namedview?
1704         */
1705         _update_snap_distances (desktop);
1706
1707         /* Show/hide page background */
1708         if (nv->pagecolor & 0xff) {
1709             sp_canvas_item_show (desktop->table);
1710             ((CtrlRect *) desktop->table)->setColor(0x00000000, true, nv->pagecolor);
1711             sp_canvas_item_move_to_z (desktop->table, 0);
1712         } else {
1713             sp_canvas_item_hide (desktop->table);
1714         }
1715
1716         /* Show/hide page border */
1717         if (nv->showborder) {
1718             // show
1719             sp_canvas_item_show (desktop->page_border);
1720             // set color and shadow
1721             ((CtrlRect *) desktop->page_border)->setColor(nv->bordercolor, false, 0x00000000);
1722             if (nv->pageshadow) {
1723                 ((CtrlRect *) desktop->page_border)->setShadow(nv->pageshadow, nv->bordercolor);
1724             }
1725             // place in the z-order stack
1726             if (nv->borderlayer == SP_BORDER_LAYER_BOTTOM) {
1727                  sp_canvas_item_move_to_z (desktop->page_border, 2);
1728             } else {
1729                 int order = sp_canvas_item_order (desktop->page_border);
1730                 int morder = sp_canvas_item_order (desktop->drawing);
1731                 if (morder > order) sp_canvas_item_raise (desktop->page_border,
1732                     morder - order);
1733             }
1734         } else {
1735                 sp_canvas_item_hide (desktop->page_border);
1736                 if (nv->pageshadow) {
1737                     ((CtrlRect *) desktop->page)->setShadow(0, 0x00000000);
1738                 }
1739         }
1740
1741         /* Show/hide page shadow */
1742         if (nv->showpageshadow && nv->pageshadow) {
1743             ((CtrlRect *) desktop->page_border)->setShadow(nv->pageshadow, nv->bordercolor);
1744         } else {
1745             ((CtrlRect *) desktop->page_border)->setShadow(0, 0x00000000);
1746         }
1747
1748         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1749         if (SP_RGBA32_A_U(nv->pagecolor) < 128 ||
1750             (SP_RGBA32_R_U(nv->pagecolor) +
1751              SP_RGBA32_G_U(nv->pagecolor) +
1752              SP_RGBA32_B_U(nv->pagecolor)) >= 384) {
1753             // the background color is light or transparent, use black outline
1754             SP_CANVAS_ARENA (desktop->drawing)->arena->outlinecolor = prefs->getInt("/options/wireframecolors/onlight", 0xff);
1755         } else { // use white outline
1756             SP_CANVAS_ARENA (desktop->drawing)->arena->outlinecolor = prefs->getInt("/options/wireframecolors/ondark", 0xffffffff);
1757         }
1758     }
1759 }
1760
1761 /**
1762  * Callback to reset snapper's distances.
1763  */
1764 static void
1765 _update_snap_distances (SPDesktop *desktop)
1766 {
1767     SPUnit const &px = sp_unit_get_by_id(SP_UNIT_PX);
1768
1769     SPNamedView &nv = *desktop->namedview;
1770
1771     //tell all grid snappers
1772     for ( GSList const *l = nv.grids; l != NULL; l = l->next) {
1773         Inkscape::CanvasGrid *grid = (Inkscape::CanvasGrid*) l->data;
1774         grid->snapper->setSnapperTolerance(sp_convert_distance_full(nv.gridtolerance,
1775                                                                       *nv.gridtoleranceunit,
1776                                                                       px));
1777     }
1778
1779     nv.snap_manager.guide.setSnapperTolerance(sp_convert_distance_full(nv.guidetolerance,
1780                                                                        *nv.guidetoleranceunit,
1781                                                                        px));
1782     nv.snap_manager.object.setSnapperTolerance(sp_convert_distance_full(nv.objecttolerance,
1783                                                                         *nv.objecttoleranceunit,
1784                                                                         px));
1785 }
1786
1787
1788 Geom::Matrix SPDesktop::w2d() const
1789 {
1790     return _w2d;
1791 }
1792
1793 Geom::Point SPDesktop::w2d(Geom::Point const &p) const
1794 {
1795     return p * _w2d;
1796 }
1797
1798 Geom::Point SPDesktop::d2w(Geom::Point const &p) const
1799 {
1800     return p * _d2w;
1801 }
1802
1803 Geom::Matrix SPDesktop::doc2dt() const
1804 {
1805     return _doc2dt;
1806 }
1807
1808 Geom::Matrix SPDesktop::dt2doc() const
1809 {
1810     // doc2dt is its own inverse
1811     return _doc2dt;
1812 }
1813
1814 Geom::Point SPDesktop::doc2dt(Geom::Point const &p) const
1815 {
1816     return p * _doc2dt;
1817 }
1818
1819 Geom::Point SPDesktop::dt2doc(Geom::Point const &p) const
1820 {
1821     return p * dt2doc();
1822 }
1823
1824
1825 /**
1826  * Pop event context from desktop's context stack. Never used.
1827  */
1828 // void
1829 // SPDesktop::pop_event_context (unsigned int key)
1830 // {
1831 //    SPEventContext *ec = NULL;
1832 //
1833 //    if (event_context && event_context->key == key) {
1834 //        g_return_if_fail (event_context);
1835 //        g_return_if_fail (event_context->next);
1836 //        ec = event_context;
1837 //        sp_event_context_deactivate (ec);
1838 //        event_context = ec->next;
1839 //        sp_event_context_activate (event_context);
1840 //        _event_context_changed_signal.emit (this, ec);
1841 //    }
1842 //
1843 //    SPEventContext *ref = event_context;
1844 //    while (ref && ref->next && ref->next->key != key)
1845 //        ref = ref->next;
1846 //
1847 //    if (ref && ref->next) {
1848 //        ec = ref->next;
1849 //        ref->next = ec->next;
1850 //    }
1851 //
1852 //    if (ec) {
1853 //        sp_event_context_finish (ec);
1854 //        g_object_unref (G_OBJECT (ec));
1855 //    }
1856 // }
1857
1858 /*
1859   Local Variables:
1860   mode:c++
1861   c-file-style:"stroustrup"
1862   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1863   indent-tabs-mode:nil
1864   fill-column:99
1865   End:
1866 */
1867 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :