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                 SPNodeContext * ncontext = SP_NODE_CONTEXT(event_context);
 887
 888                 Inkscape::NodePath::Path * nodepath = ncontext->shape_editor->get_nodepath();
 889                 // printf("I've got a nodepath, crazy\n");
 890
 891                 Geom::Rect nodes;
 892                 bool firstnode = true;
 893
 894                 if (nodepath->selected) {
 895                     for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
 896                        Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
 897                         for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
 898                            Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
 899                             if (node->selected) {
 900                                 // printf("\tSelected node\n");
 901                                 if (firstnode) {
 902                                     nodes = Geom::Rect(node->pos, node->pos);
 903                                     firstnode = false;
 904                                 } else {
 905                                     nodes.expandTo(node->pos);
 906                                 }
 907
 908                                 if (node->p.other != NULL) {
 909                                     /* Include previous node pos */
 910                                     nodes.expandTo(node->p.other->pos);
 911
 912                                     /* Include previous handle */
 913                                     if (!sp_node_side_is_line(node, &node->p)) {
 914                                         nodes.expandTo(node->p.pos);
 915                                     }
 916                                 }
 917
 918                                 if (node->n.other != NULL) {
 919                                     /* Include previous node pos */
 920                                     nodes.expandTo(node->n.other->pos);
 921
 922                                     /* Include previous handle */
 923                                     if (!sp_node_side_is_line(node, &node->n)) {
 924                                         nodes.expandTo(node->n.pos);
 925                                     }
 926                                 }
 927                             }
 928                         }
 929                     }
 930
 931                     if (!firstnode && nodes.area() * 2.0 < _quick_zoom_stored_area.area()) {
 932                         set_display_area(nodes, 10);
 933                         zoomed = true;
 934                     }
 935                 }
 936             }
 937         }
 938
 939         if (!zoomed) {
 940             Geom::OptRect const d = selection->bounds();
 941             if (d && d->area() * 2.0 < _quick_zoom_stored_area.area()) {
 942                 set_display_area(*d, 10);
 943                 zoomed = true;
 944             }
 945         }
 946
 947         if (!zoomed) {
 948             zoom_relative(_quick_zoom_stored_area.midpoint()[Geom::X], _quick_zoom_stored_area.midpoint()[Geom::Y], 2.0);
 949             zoomed = true;
 950         }
 951     } else {
 952         set_display_area(_quick_zoom_stored_area, 0);
 953     }
 954
 955     _quick_zoom_enabled = enable;
 956     return;
 957 }
 958
 959 /**
 960  * Zoom to point with absolute zoom factor.
 961  */
 962 void
 963 SPDesktop::zoom_absolute_keep_point (double cx, double cy, double px, double py, double zoom)
 964 {
 965     zoom = CLAMP (zoom, SP_DESKTOP_ZOOM_MIN, SP_DESKTOP_ZOOM_MAX);
 966
 967     // maximum or minimum zoom reached, but there's no exact equality because of rounding errors;
 968     // this check prevents "sliding" when trying to zoom in at maximum zoom;
 969     /// \todo someone please fix calculations properly and remove this hack
 970     if (fabs(_d2w.descrim() - zoom) < 0.0001*zoom && (fabs(SP_DESKTOP_ZOOM_MAX - zoom) < 0.01 || fabs(SP_DESKTOP_ZOOM_MIN - zoom) < 0.000001))
 971         return;
 972
 973     Geom::Rect const viewbox = canvas->getViewbox();
 974
 975     double const width2 = viewbox.dimensions()[Geom::X] / zoom;
 976     double const height2 = viewbox.dimensions()[Geom::Y] / zoom;
 977
 978     set_display_area(cx - px * width2,
 979                      cy - py * height2,
 980                      cx + (1 - px) * width2,
 981                      cy + (1 - py) * height2,
 982                      0.0);
 983 }
 984
 985 /**
 986  * Zoom to center with absolute zoom factor.
 987  */
 988 void
 989 SPDesktop::zoom_absolute (double cx, double cy, double zoom)
 990 {
 991     zoom_absolute_keep_point (cx, cy, 0.5, 0.5, zoom);
 992 }
 993
 994 /**
 995  * Zoom to point with relative zoom factor.
 996  */
 997 void
 998 SPDesktop::zoom_relative_keep_point (double cx, double cy, double zoom)
 999 {
1000     Geom::Rect const area = get_display_area();
1001
1002     if (cx < area.min()[Geom::X]) {
1003         cx = area.min()[Geom::X];
1004     }
1005     if (cx > area.max()[Geom::X]) {
1006         cx = area.max()[Geom::X];
1007     }
1008     if (cy < area.min()[Geom::Y]) {
1009         cy = area.min()[Geom::Y];
1010     }
1011     if (cy > area.max()[Geom::Y]) {
1012         cy = area.max()[Geom::Y];
1013     }
1014
1015     gdouble const scale = _d2w.descrim() * zoom;
1016     double const px = (cx - area.min()[Geom::X]) / area.dimensions()[Geom::X];
1017     double const py = (cy - area.min()[Geom::Y]) / area.dimensions()[Geom::Y];
1018
1019     zoom_absolute_keep_point(cx, cy, px, py, scale);
1020 }
1021
1022 /**
1023  * Zoom to center with relative zoom factor.
1024  */
1025 void
1026 SPDesktop::zoom_relative (double cx, double cy, double zoom)
1027 {
1028     gdouble scale = _d2w.descrim() * zoom;
1029     zoom_absolute (cx, cy, scale);
1030 }
1031
1032 /**
1033  * Set display area to origin and current document dimensions.
1034  */
1035 void
1036 SPDesktop::zoom_page()
1037 {
1038     Geom::Rect d(Geom::Point(0, 0),
1039                  Geom::Point(sp_document_width(doc()), sp_document_height(doc())));
1040
1041     if (d.minExtent() < 1.0) {
1042         return;
1043     }
1044
1045     set_display_area(d, 10);
1046 }
1047
1048 /**
1049  * Set display area to current document width.
1050  */
1051 void
1052 SPDesktop::zoom_page_width()
1053 {
1054     Geom::Rect const a = get_display_area();
1055
1056     if (sp_document_width(doc()) < 1.0) {
1057         return;
1058     }
1059
1060     Geom::Rect d(Geom::Point(0, a.midpoint()[Geom::Y]),
1061                  Geom::Point(sp_document_width(doc()), a.midpoint()[Geom::Y]));
1062
1063     set_display_area(d, 10);
1064 }
1065
1066 /**
1067  * Zoom to selection.
1068  */
1069 void
1070 SPDesktop::zoom_selection()
1071 {
1072     Geom::OptRect const d = selection->bounds();
1073
1074     if ( !d || d->minExtent() < 0.1 ) {
1075         return;
1076     }
1077
1078     set_display_area(*d, 10);
1079 }
1080
1081 /**
1082  * Tell widget to let zoom widget grab keyboard focus.
1083  */
1084 void
1085 SPDesktop::zoom_grab_focus()
1086 {
1087     _widget->letZoomGrabFocus();
1088 }
1089
1090 /**
1091  * Zoom to whole drawing.
1092  */
1093 void
1094 SPDesktop::zoom_drawing()
1095 {
1096     g_return_if_fail (doc() != NULL);
1097     SPItem *docitem = SP_ITEM (sp_document_root (doc()));
1098     g_return_if_fail (docitem != NULL);
1099
1100     Geom::OptRect d = sp_item_bbox_desktop(docitem);
1101
1102     /* Note that the second condition here indicates that
1103     ** there are no items in the drawing.
1104     */
1105     if ( !d || d->minExtent() < 0.1 ) {
1106         return;
1107     }
1108
1109     set_display_area(*d, 10);
1110 }
1111
1112 /**
1113  * Scroll canvas by specific coordinate amount in svg coordinates.
1114  */
1115 void
1116 SPDesktop::scroll_world_in_svg_coords (double dx, double dy, bool is_scrolling)
1117 {
1118     double scale = _d2w.descrim();
1119     scroll_world(dx*scale, dy*scale, is_scrolling);
1120 }
1121
1122 /**
1123  * Scroll canvas by specific coordinate amount.
1124  */
1125 void
1126 SPDesktop::scroll_world (double dx, double dy, bool is_scrolling)
1127 {
1128     g_assert(_widget);
1129
1130     Geom::Rect const viewbox = canvas->getViewbox();
1131
1132     sp_canvas_scroll_to(canvas, viewbox.min()[Geom::X] - dx, viewbox.min()[Geom::Y] - dy, FALSE, is_scrolling);
1133
1134     /*  update perspective lines if we are in the 3D box tool (so that infinite ones are shown correctly) */
1135     sp_box3d_context_update_lines(event_context);
1136
1137     _widget->updateRulers();
1138     _widget->updateScrollbars(_d2w.descrim());
1139 }
1140
1141 bool
1142 SPDesktop::scroll_to_point (Geom::Point const &p, gdouble autoscrollspeed)
1143 {
1144     using Geom::X;
1145     using Geom::Y;
1146
1147     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1148     gdouble autoscrolldistance = (gdouble) prefs->getIntLimited("/options/autoscrolldistance/value", 0, -1000, 10000);
1149
1150     // autoscrolldistance is in screen pixels, but the display area is in document units
1151     autoscrolldistance /= _d2w.descrim();
1152     // FIXME: This 2geom idiom doesn't allow us to declare dbox const
1153     Geom::Rect dbox = get_display_area();
1154     dbox.expandBy(-autoscrolldistance);
1155
1156     if (!(p[X] > dbox.min()[X] && p[X] < dbox.max()[X]) ||
1157         !(p[Y] > dbox.min()[Y] && p[Y] < dbox.max()[Y])   ) {
1158
1159         Geom::Point const s_w( p * (Geom::Matrix)_d2w );
1160
1161         gdouble x_to;
1162         if (p[X] < dbox.min()[X])
1163             x_to = dbox.min()[X];
1164         else if (p[X] > dbox.max()[X])
1165             x_to = dbox.max()[X];
1166         else
1167             x_to = p[X];
1168
1169         gdouble y_to;
1170         if (p[Y] < dbox.min()[Y])
1171             y_to = dbox.min()[Y];
1172         else if (p[Y] > dbox.max()[Y])
1173             y_to = dbox.max()[Y];
1174         else
1175             y_to = p[Y];
1176
1177         Geom::Point const d_dt(x_to, y_to);
1178         Geom::Point const d_w( d_dt * _d2w );
1179         Geom::Point const moved_w( d_w - s_w );
1180
1181         if (autoscrollspeed == 0)
1182             autoscrollspeed = prefs->getDoubleLimited("/options/autoscrollspeed/value", 1, 0, 10);
1183
1184         if (autoscrollspeed != 0)
1185             scroll_world (autoscrollspeed * moved_w);
1186
1187         return true;
1188     }
1189     return false;
1190 }
1191
1192 bool
1193 SPDesktop::is_iconified()
1194 {
1195     return 0!=(window_state & GDK_WINDOW_STATE_ICONIFIED);
1196 }
1197
1198 void
1199 SPDesktop::iconify()
1200 {
1201     _widget->setIconified();
1202 }
1203
1204 bool
1205 SPDesktop::is_maximized()
1206 {
1207     return 0!=(window_state & GDK_WINDOW_STATE_MAXIMIZED);
1208 }
1209
1210 void
1211 SPDesktop::maximize()
1212 {
1213     _widget->setMaximized();
1214 }
1215
1216 bool
1217 SPDesktop::is_fullscreen()
1218 {
1219     return 0!=(window_state & GDK_WINDOW_STATE_FULLSCREEN);
1220 }
1221
1222 void
1223 SPDesktop::fullscreen()
1224 {
1225     _widget->setFullscreen();
1226 }
1227
1228 /** \brief  Checks to see if the user is working in focused mode
1229
1230     Returns the value of \c _focusMode
1231 */
1232 bool
1233 SPDesktop::is_focusMode()
1234 {
1235     return _focusMode;
1236 }
1237
1238 /** \brief  Changes whether the user is in focus mode or not
1239     \param  mode  Which mode the view should be in
1240
1241 */
1242 void
1243 SPDesktop::focusMode (bool mode)
1244 {
1245     if (mode == _focusMode) { return; }
1246
1247     _focusMode = mode;
1248
1249     layoutWidget();
1250     //sp_desktop_widget_layout(SPDesktopWidget);
1251
1252     return;
1253 }
1254
1255 void
1256 SPDesktop::getWindowGeometry (gint &x, gint &y, gint &w, gint &h)
1257 {
1258     _widget->getGeometry (x, y, w, h);
1259 }
1260
1261 void
1262 SPDesktop::setWindowPosition (Geom::Point p)
1263 {
1264     _widget->setPosition (p);
1265 }
1266
1267 void
1268 SPDesktop::setWindowSize (gint w, gint h)
1269 {
1270     _widget->setSize (w, h);
1271 }
1272
1273 void
1274 SPDesktop::setWindowTransient (void *p, int transient_policy)
1275 {
1276     _widget->setTransient (p, transient_policy);
1277 }
1278
1279 Gtk::Window*
1280 SPDesktop::getToplevel( )
1281 {
1282     return _widget->getWindow();
1283 }
1284
1285 void
1286 SPDesktop::presentWindow()
1287 {
1288     _widget->present();
1289 }
1290
1291 bool
1292 SPDesktop::warnDialog (gchar *text)
1293 {
1294     return _widget->warnDialog (text);
1295 }
1296
1297 void
1298 SPDesktop::toggleRulers()
1299 {
1300     _widget->toggleRulers();
1301 }
1302
1303 void
1304 SPDesktop::toggleScrollbars()
1305 {
1306     _widget->toggleScrollbars();
1307 }
1308
1309 void
1310 SPDesktop::layoutWidget()
1311 {
1312     _widget->layout();
1313 }
1314
1315 void
1316 SPDesktop::destroyWidget()
1317 {
1318     _widget->destroy();
1319 }
1320
1321 bool
1322 SPDesktop::shutdown()
1323 {
1324     return _widget->shutdown();
1325 }
1326
1327 bool SPDesktop::onDeleteUI (GdkEventAny*)
1328 {
1329     if(shutdown())
1330         return true;
1331
1332     destroyWidget();
1333     return false;
1334 }
1335
1336 /**
1337  *  onWindowStateEvent
1338  *
1339  *  Called when the window changes its maximize/fullscreen/iconify/pinned state.
1340  *  Since GTK doesn't have a way to query this state information directly, we
1341  *  record it for the desktop here, and also possibly trigger a layout.
1342  */
1343 bool
1344 SPDesktop::onWindowStateEvent (GdkEventWindowState* event)
1345 {
1346     // Record the desktop window's state
1347     window_state = event->new_window_state;
1348
1349     // Layout may differ depending on full-screen mode or not
1350     GdkWindowState changed = event->changed_mask;
1351     if (changed & (GDK_WINDOW_STATE_FULLSCREEN|GDK_WINDOW_STATE_MAXIMIZED)) {
1352         layoutWidget();
1353     }
1354
1355     return false;
1356 }
1357
1358 void
1359 SPDesktop::setToolboxFocusTo (gchar const *label)
1360 {
1361     _widget->setToolboxFocusTo (label);
1362 }
1363
1364 void
1365 SPDesktop::setToolboxAdjustmentValue (gchar const* id, double val)
1366 {
1367     _widget->setToolboxAdjustmentValue (id, val);
1368 }
1369
1370 void
1371 SPDesktop::setToolboxSelectOneValue (gchar const* id, gint val)
1372 {
1373     _widget->setToolboxSelectOneValue (id, val);
1374 }
1375
1376 bool
1377 SPDesktop::isToolboxButtonActive (gchar const *id)
1378 {
1379     return _widget->isToolboxButtonActive (id);
1380 }
1381
1382 void
1383 SPDesktop::emitToolSubselectionChanged(gpointer data)
1384 {
1385     _tool_subselection_changed.emit(data);
1386     inkscape_subselection_changed (this);
1387 }
1388
1389 void
1390 SPDesktop::updateNow()
1391 {
1392   sp_canvas_update_now(canvas);
1393 }
1394
1395 void
1396 SPDesktop::enableInteraction()
1397 {
1398   _widget->enableInteraction();
1399 }
1400
1401 void SPDesktop::disableInteraction()
1402 {
1403   _widget->disableInteraction();
1404 }
1405
1406 void SPDesktop::setWaitingCursor()
1407 {
1408     GdkCursor *waiting = gdk_cursor_new(GDK_WATCH);
1409     gdk_window_set_cursor(GTK_WIDGET(sp_desktop_canvas(this))->window, waiting);
1410     gdk_cursor_unref(waiting);
1411     // GDK needs the flush for the cursor change to take effect
1412     gdk_flush();
1413     waiting_cursor = true;
1414 }
1415
1416 void SPDesktop::clearWaitingCursor()
1417 {
1418   if (waiting_cursor)
1419       sp_event_context_update_cursor(sp_desktop_event_context(this));
1420 }
1421
1422 void SPDesktop::toggleColorProfAdjust()
1423 {
1424     _widget->toggleColorProfAdjust();
1425 }
1426
1427 void SPDesktop::toggleGrids()
1428 {
1429     if (namedview->grids) {
1430         if(gridgroup) {
1431             showGrids(!grids_visible);
1432         }
1433     } else {
1434         //there is no grid present at the moment. add a rectangular grid and make it visible
1435         Inkscape::XML::Node *repr = SP_OBJECT_REPR(namedview);
1436         Inkscape::CanvasGrid::writeNewGridToRepr(repr, sp_desktop_document(this), Inkscape::GRID_RECTANGULAR);
1437         showGrids(true);
1438     }
1439 }
1440
1441 void SPDesktop::showGrids(bool show, bool dirty_document)
1442 {
1443     grids_visible = show;
1444     sp_namedview_show_grids(namedview, grids_visible, dirty_document);
1445     if (show) {
1446         sp_canvas_item_show(SP_CANVAS_ITEM(gridgroup));
1447     } else {
1448         sp_canvas_item_hide(SP_CANVAS_ITEM(gridgroup));
1449     }
1450 }
1451
1452 void SPDesktop::toggleSnapping()
1453 {
1454     bool v = namedview->snap_manager.snapprefs.getSnapEnabledGlobally();
1455     Inkscape::XML::Node *repr = SP_OBJECT_REPR(namedview);
1456     sp_repr_set_boolean(repr, "inkscape:snap-global", !v);
1457 }
1458
1459 //----------------------------------------------------------------------
1460 // Callback implementations. The virtual ones are connected by the view.
1461
1462 void
1463 SPDesktop::onPositionSet (double x, double y)
1464 {
1465     _widget->viewSetPosition (Geom::Point(x,y));
1466 }
1467
1468 void
1469 SPDesktop::onResized (double /*x*/, double /*y*/)
1470 {
1471    // Nothing called here
1472 }
1473
1474 /**
1475  * Redraw callback; queues Gtk redraw; connected by View.
1476  */
1477 void
1478 SPDesktop::onRedrawRequested ()
1479 {
1480     if (main) {
1481         _widget->requestCanvasUpdate();
1482     }
1483 }
1484
1485 void
1486 SPDesktop::updateCanvasNow()
1487 {
1488   _widget->requestCanvasUpdateAndWait();
1489 }
1490
1491 /**
1492  * Associate document with desktop.
1493  */
1494 void
1495 SPDesktop::setDocument (SPDocument *doc)
1496 {
1497     if (this->doc() && doc) {
1498         namedview->hide(this);
1499         sp_item_invoke_hide (SP_ITEM (sp_document_root (this->doc())), dkey);
1500     }
1501
1502     if (_layer_hierarchy) {
1503         _layer_hierarchy->clear();
1504         delete _layer_hierarchy;
1505     }
1506     _layer_hierarchy = new Inkscape::ObjectHierarchy(NULL);
1507     _layer_hierarchy->connectAdded(sigc::bind(sigc::ptr_fun(_layer_activated), this));
1508     _layer_hierarchy->connectRemoved(sigc::bind(sigc::ptr_fun(_layer_deactivated), this));
1509     _layer_hierarchy->connectChanged(sigc::bind(sigc::ptr_fun(_layer_hierarchy_changed), this));
1510     _layer_hierarchy->setTop(SP_DOCUMENT_ROOT(doc));
1511
1512     /* setup EventLog */
1513     event_log = new Inkscape::EventLog(doc);
1514     doc->addUndoObserver(*event_log);
1515
1516     _commit_connection.disconnect();
1517     _commit_connection = doc->connectCommit(sigc::mem_fun(*this, &SPDesktop::updateNow));
1518
1519     /// \todo fixme: This condition exists to make sure the code
1520     /// inside is NOT called on initialization, only on replacement. But there
1521     /// are surely more safe methods to accomplish this.
1522     // TODO since the comment had reversed logic, check the intent of this block of code:
1523     if (drawing) {
1524         NRArenaItem *ai = 0;
1525
1526         namedview = sp_document_namedview (doc, NULL);
1527         _modified_connection = namedview->connectModified(sigc::bind<2>(sigc::ptr_fun(&_namedview_modified), this));
1528         number = namedview->getViewCount();
1529
1530         ai = sp_item_invoke_show (SP_ITEM (sp_document_root (doc)),
1531                 SP_CANVAS_ARENA (drawing)->arena,
1532                 dkey,
1533                 SP_ITEM_SHOW_DISPLAY);
1534         if (ai) {
1535             nr_arena_item_add_child (SP_CANVAS_ARENA (drawing)->root, ai, NULL);
1536         }
1537         namedview->show(this);
1538         /* Ugly hack */
1539         activate_guides (true);
1540         /* Ugly hack */
1541         _namedview_modified (namedview, SP_OBJECT_MODIFIED_FLAG, this);
1542     }
1543
1544     _document_replaced_signal.emit (this, doc);
1545
1546     View::setDocument (doc);
1547 }
1548
1549 void
1550 SPDesktop::onStatusMessage
1551 (Inkscape::MessageType type, gchar const *message)
1552 {
1553     if (_widget) {
1554         _widget->setMessage(type, message);
1555     }
1556 }
1557
1558 void
1559 SPDesktop::onDocumentURISet (gchar const* uri)
1560 {
1561     _widget->setTitle(uri);
1562 }
1563
1564 /**
1565  * Resized callback.
1566  */
1567 void
1568 SPDesktop::onDocumentResized (gdouble width, gdouble height)
1569 {
1570     _doc2dt[5] = height;
1571     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (drawing), _doc2dt);
1572     Geom::Rect const a(Geom::Point(0, 0), Geom::Point(width, height));
1573     SP_CTRLRECT(page)->setRectangle(a);
1574     SP_CTRLRECT(page_border)->setRectangle(a);
1575 }
1576
1577
1578 void
1579 SPDesktop::_onActivate (SPDesktop* dt)
1580 {
1581     if (!dt->_widget) return;
1582     dt->_widget->activateDesktop();
1583 }
1584
1585 void
1586 SPDesktop::_onDeactivate (SPDesktop* dt)
1587 {
1588     if (!dt->_widget) return;
1589     dt->_widget->deactivateDesktop();
1590 }
1591
1592 void
1593 SPDesktop::_onSelectionModified
1594 (Inkscape::Selection */*selection*/, guint /*flags*/, SPDesktop *dt)
1595 {
1596     if (!dt->_widget) return;
1597     dt->_widget->updateScrollbars (dt->_d2w.descrim());
1598 }
1599
1600 static void
1601 _onSelectionChanged
1602 (Inkscape::Selection *selection, SPDesktop *desktop)
1603 {
1604     /** \todo
1605      * only change the layer for single selections, or what?
1606      * This seems reasonable -- for multiple selections there can be many
1607      * different layers involved.
1608      */
1609     SPItem *item=selection->singleItem();
1610     if (item) {
1611         SPObject *layer=desktop->layerForObject(item);
1612         if ( layer && layer != desktop->currentLayer() ) {
1613             desktop->setCurrentLayer(layer);
1614         }
1615     }
1616 }
1617
1618 /**
1619  * Calls event handler of current event context.
1620  * \param arena Unused
1621  * \todo fixme
1622  */
1623 static gint
1624 _arena_handler (SPCanvasArena */*arena*/, NRArenaItem *ai, GdkEvent *event, SPDesktop *desktop)
1625 {
1626     if (ai) {
1627         SPItem *spi = (SPItem*)NR_ARENA_ITEM_GET_DATA (ai);
1628         return sp_event_context_item_handler (desktop->event_context, spi, event);
1629     } else {
1630         return sp_event_context_root_handler (desktop->event_context, event);
1631     }
1632 }
1633
1634 static void
1635 _layer_activated(SPObject *layer, SPDesktop *desktop) {
1636     g_return_if_fail(SP_IS_GROUP(layer));
1637     SP_GROUP(layer)->setLayerDisplayMode(desktop->dkey, SPGroup::LAYER);
1638 }
1639
1640 /// Callback
1641 static void
1642 _layer_deactivated(SPObject *layer, SPDesktop *desktop) {
1643     g_return_if_fail(SP_IS_GROUP(layer));
1644     SP_GROUP(layer)->setLayerDisplayMode(desktop->dkey, SPGroup::GROUP);
1645 }
1646
1647 /// Callback
1648 static void
1649 _layer_hierarchy_changed(SPObject */*top*/, SPObject *bottom,
1650                                          SPDesktop *desktop)
1651 {
1652     desktop->_layer_changed_signal.emit (bottom);
1653 }
1654
1655 /// Called when document is starting to be rebuilt.
1656 static void
1657 _reconstruction_start (SPDesktop * desktop)
1658 {
1659     // printf("Desktop, starting reconstruction\n");
1660     desktop->_reconstruction_old_layer_id = g_strdup(SP_OBJECT_ID(desktop->currentLayer()));
1661     desktop->_layer_hierarchy->setBottom(desktop->currentRoot());
1662
1663     /*
1664     GSList const * selection_objs = desktop->selection->list();
1665     for (; selection_objs != NULL; selection_objs = selection_objs->next) {
1666
1667     }
1668     */
1669     desktop->selection->clear();
1670
1671     // printf("Desktop, starting reconstruction end\n");
1672 }
1673
1674 /// Called when document rebuild is finished.
1675 static void
1676 _reconstruction_finish (SPDesktop * desktop)
1677 {
1678     // printf("Desktop, finishing reconstruction\n");
1679     if (desktop->_reconstruction_old_layer_id == NULL)
1680         return;
1681
1682     SPObject * newLayer = SP_OBJECT_DOCUMENT(desktop->namedview)->getObjectById(desktop->_reconstruction_old_layer_id);
1683     if (newLayer != NULL)
1684         desktop->setCurrentLayer(newLayer);
1685
1686     g_free(desktop->_reconstruction_old_layer_id);
1687     desktop->_reconstruction_old_layer_id = NULL;
1688     // printf("Desktop, finishing reconstruction end\n");
1689     return;
1690 }
1691
1692 /**
1693  * Namedview_modified callback.
1694  */
1695 static void
1696 _namedview_modified (SPObject *obj, guint flags, SPDesktop *desktop)
1697 {
1698     SPNamedView *nv=SP_NAMEDVIEW(obj);
1699
1700     if (flags & SP_OBJECT_MODIFIED_FLAG) {
1701
1702         /* Recalculate snap distances */
1703         /* FIXME: why is the desktop getting involved in setting up something
1704         ** that is entirely to do with the namedview?
1705         */
1706         _update_snap_distances (desktop);
1707
1708         /* Show/hide page background */
1709         if (nv->pagecolor & 0xff) {
1710             sp_canvas_item_show (desktop->table);
1711             ((CtrlRect *) desktop->table)->setColor(0x00000000, true, nv->pagecolor);
1712             sp_canvas_item_move_to_z (desktop->table, 0);
1713         } else {
1714             sp_canvas_item_hide (desktop->table);
1715         }
1716
1717         /* Show/hide page border */
1718         if (nv->showborder) {
1719             // show
1720             sp_canvas_item_show (desktop->page_border);
1721             // set color and shadow
1722             ((CtrlRect *) desktop->page_border)->setColor(nv->bordercolor, false, 0x00000000);
1723             if (nv->pageshadow) {
1724                 ((CtrlRect *) desktop->page_border)->setShadow(nv->pageshadow, nv->bordercolor);
1725             }
1726             // place in the z-order stack
1727             if (nv->borderlayer == SP_BORDER_LAYER_BOTTOM) {
1728                  sp_canvas_item_move_to_z (desktop->page_border, 2);
1729             } else {
1730                 int order = sp_canvas_item_order (desktop->page_border);
1731                 int morder = sp_canvas_item_order (desktop->drawing);
1732                 if (morder > order) sp_canvas_item_raise (desktop->page_border,
1733                     morder - order);
1734             }
1735         } else {
1736                 sp_canvas_item_hide (desktop->page_border);
1737                 if (nv->pageshadow) {
1738                     ((CtrlRect *) desktop->page)->setShadow(0, 0x00000000);
1739                 }
1740         }
1741
1742         /* Show/hide page shadow */
1743         if (nv->showpageshadow && nv->pageshadow) {
1744             ((CtrlRect *) desktop->page_border)->setShadow(nv->pageshadow, nv->bordercolor);
1745         } else {
1746             ((CtrlRect *) desktop->page_border)->setShadow(0, 0x00000000);
1747         }
1748
1749         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1750         if (SP_RGBA32_A_U(nv->pagecolor) < 128 ||
1751             (SP_RGBA32_R_U(nv->pagecolor) +
1752              SP_RGBA32_G_U(nv->pagecolor) +
1753              SP_RGBA32_B_U(nv->pagecolor)) >= 384) {
1754             // the background color is light or transparent, use black outline
1755             SP_CANVAS_ARENA (desktop->drawing)->arena->outlinecolor = prefs->getInt("/options/wireframecolors/onlight", 0xff);
1756         } else { // use white outline
1757             SP_CANVAS_ARENA (desktop->drawing)->arena->outlinecolor = prefs->getInt("/options/wireframecolors/ondark", 0xffffffff);
1758         }
1759     }
1760 }
1761
1762 /**
1763  * Callback to reset snapper's distances.
1764  */
1765 static void
1766 _update_snap_distances (SPDesktop *desktop)
1767 {
1768     SPUnit const &px = sp_unit_get_by_id(SP_UNIT_PX);
1769
1770     SPNamedView &nv = *desktop->namedview;
1771
1772     //tell all grid snappers
1773     for ( GSList const *l = nv.grids; l != NULL; l = l->next) {
1774         Inkscape::CanvasGrid *grid = (Inkscape::CanvasGrid*) l->data;
1775         grid->snapper->setSnapperTolerance(sp_convert_distance_full(nv.gridtolerance,
1776                                                                       *nv.gridtoleranceunit,
1777                                                                       px));
1778     }
1779
1780     nv.snap_manager.guide.setSnapperTolerance(sp_convert_distance_full(nv.guidetolerance,
1781                                                                        *nv.guidetoleranceunit,
1782                                                                        px));
1783     nv.snap_manager.object.setSnapperTolerance(sp_convert_distance_full(nv.objecttolerance,
1784                                                                         *nv.objecttoleranceunit,
1785                                                                         px));
1786 }
1787
1788
1789 Geom::Matrix SPDesktop::w2d() const
1790 {
1791     return _w2d;
1792 }
1793
1794 Geom::Point SPDesktop::w2d(Geom::Point const &p) const
1795 {
1796     return p * _w2d;
1797 }
1798
1799 Geom::Point SPDesktop::d2w(Geom::Point const &p) const
1800 {
1801     return p * _d2w;
1802 }
1803
1804 Geom::Matrix SPDesktop::doc2dt() const
1805 {
1806     return _doc2dt;
1807 }
1808
1809 Geom::Matrix SPDesktop::dt2doc() const
1810 {
1811     // doc2dt is its own inverse
1812     return _doc2dt;
1813 }
1814
1815 Geom::Point SPDesktop::doc2dt(Geom::Point const &p) const
1816 {
1817     return p * _doc2dt;
1818 }
1819
1820 Geom::Point SPDesktop::dt2doc(Geom::Point const &p) const
1821 {
1822     return p * dt2doc();
1823 }
1824
1825
1826 /**
1827  * Pop event context from desktop's context stack. Never used.
1828  */
1829 // void
1830 // SPDesktop::pop_event_context (unsigned int key)
1831 // {
1832 //    SPEventContext *ec = NULL;
1833 //
1834 //    if (event_context && event_context->key == key) {
1835 //        g_return_if_fail (event_context);
1836 //        g_return_if_fail (event_context->next);
1837 //        ec = event_context;
1838 //        sp_event_context_deactivate (ec);
1839 //        event_context = ec->next;
1840 //        sp_event_context_activate (event_context);
1841 //        _event_context_changed_signal.emit (this, ec);
1842 //    }
1843 //
1844 //    SPEventContext *ref = event_context;
1845 //    while (ref && ref->next && ref->next->key != key)
1846 //        ref = ref->next;
1847 //
1848 //    if (ref && ref->next) {
1849 //        ec = ref->next;
1850 //        ref->next = ec->next;
1851 //    }
1852 //
1853 //    if (ec) {
1854 //        sp_event_context_finish (ec);
1855 //        g_object_unref (G_OBJECT (ec));
1856 //    }
1857 // }
1858
1859 /*
1860   Local Variables:
1861   mode:c++
1862   c-file-style:"stroustrup"
1863   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1864   indent-tabs-mode:nil
1865   fill-column:99
1866   End:
1867 */
1868 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :