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 #include "desktop-style.h"
  94
  95 // TODO those includes are only for node tool quick zoom. Remove them after fixing it.
  96 #include "ui/tool/node-tool.h"
  97 #include "ui/tool/control-point-selection.h"
  98
  99 #include "display/sp-canvas.h"
 100
 101 namespace Inkscape { namespace XML { class Node; }}
 102
 103 // Callback declarations
 104 static void _onSelectionChanged (Inkscape::Selection *selection, SPDesktop *desktop);
 105 static gint _arena_handler (SPCanvasArena *arena, NRArenaItem *ai, GdkEvent *event, SPDesktop *desktop);
 106 static void _layer_activated(SPObject *layer, SPDesktop *desktop);
 107 static void _layer_deactivated(SPObject *layer, SPDesktop *desktop);
 108 static void _layer_hierarchy_changed(SPObject *top, SPObject *bottom, SPDesktop *desktop);
 109 static void _reconstruction_start(SPDesktop * desktop);
 110 static void _reconstruction_finish(SPDesktop * desktop);
 111 static void _namedview_modified (SPObject *obj, guint flags, SPDesktop *desktop);
 112
 113 /**
 114  * Return new desktop object.
 115  * \pre namedview != NULL.
 116  * \pre canvas != NULL.
 117  */
 118 SPDesktop::SPDesktop() :
 119     _dlg_mgr( 0 ),
 120     namedview( 0 ),
 121     canvas( 0 ),
 122     selection( 0 ),
 123     event_context( 0 ),
 124     layer_manager( 0 ),
 125     event_log( 0 ),
 126     temporary_item_list( 0 ),
 127     snapindicator( 0 ),
 128     acetate( 0 ),
 129     main( 0 ),
 130     gridgroup( 0 ),
 131     guides( 0 ),
 132     drawing( 0 ),
 133     sketch( 0 ),
 134     controls( 0 ),
 135     tempgroup ( 0 ),
 136     table( 0 ),
 137     page( 0 ),
 138     page_border( 0 ),
 139     current( 0 ),
 140     _focusMode(false),
 141     zooms_past( 0 ),
 142     zooms_future( 0 ),
 143     dkey( 0 ),
 144     number( 0 ),
 145     window_state(0),
 146     interaction_disabled_counter( 0 ),
 147     waiting_cursor( false ),
 148     guides_active( false ),
 149     gr_item( 0 ),
 150     gr_point_type( 0 ),
 151     gr_point_i( 0 ),
 152     gr_fill_or_stroke( true ),
 153     _layer_hierarchy( 0 ),
 154     _reconstruction_old_layer_id( 0 ),
 155     _display_mode(Inkscape::RENDERMODE_NORMAL),
 156     _widget( 0 ),
 157     _inkscape( 0 ),
 158     _guides_message_context( 0 ),
 159     _active( false ),
 160     _w2d(),
 161     _d2w(),
 162     _doc2dt( Geom::Scale(1, -1) ),
 163     grids_visible( false )
 164 {
 165     _d2w.setIdentity();
 166     _w2d.setIdentity();
 167
 168     selection = Inkscape::GC::release( new Inkscape::Selection(this) );
 169 }
 170
 171 void
 172 SPDesktop::init (SPNamedView *nv, SPCanvas *aCanvas, Inkscape::UI::View::EditWidgetInterface *widget)
 173 {
 174     _widget = widget;
 175
 176     // Temporary workaround for link order issues:
 177     Inkscape::DeviceManager::getManager().getDevices();
 178     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 179
 180     _guides_message_context = new Inkscape::MessageContext(const_cast<Inkscape::MessageStack*>(messageStack()));
 181
 182     current = prefs->getStyle("/desktop/style");
 183
 184     namedview = nv;
 185     canvas = aCanvas;
 186
 187     SPDocument *document = SP_OBJECT_DOCUMENT (namedview);
 188     /* Kill flicker */
 189     document->ensure_up_to_date ();
 190
 191     /* Setup Dialog Manager */
 192     _dlg_mgr = &Inkscape::UI::Dialog::DialogManager::getInstance();
 193
 194     dkey = SPItem::display_key_new (1);
 195
 196     /* Connect document */
 197     setDocument (document);
 198
 199     number = namedview->getViewCount();
 200
 201
 202     /* Setup Canvas */
 203     g_object_set_data (G_OBJECT (canvas), "SPDesktop", this);
 204
 205     SPCanvasGroup *root = sp_canvas_root (canvas);
 206
 207     /* Setup adminstrative layers */
 208     acetate = sp_canvas_item_new (root, GNOME_TYPE_CANVAS_ACETATE, NULL);
 209     g_signal_connect (G_OBJECT (acetate), "event", G_CALLBACK (sp_desktop_root_handler), this);
 210     main = (SPCanvasGroup *) sp_canvas_item_new (root, SP_TYPE_CANVAS_GROUP, NULL);
 211     g_signal_connect (G_OBJECT (main), "event", G_CALLBACK (sp_desktop_root_handler), this);
 212
 213     table = sp_canvas_item_new (main, SP_TYPE_CTRLRECT, NULL);
 214     SP_CTRLRECT(table)->setRectangle(Geom::Rect(Geom::Point(-80000, -80000), Geom::Point(80000, 80000)));
 215     SP_CTRLRECT(table)->setColor(0x00000000, true, 0x00000000);
 216     sp_canvas_item_move_to_z (table, 0);
 217
 218     page = sp_canvas_item_new (main, SP_TYPE_CTRLRECT, NULL);
 219     ((CtrlRect *) page)->setColor(0x00000000, FALSE, 0x00000000);
 220     page_border = sp_canvas_item_new (main, SP_TYPE_CTRLRECT, NULL);
 221
 222     drawing = sp_canvas_item_new (main, SP_TYPE_CANVAS_ARENA, NULL);
 223     g_signal_connect (G_OBJECT (drawing), "arena_event", G_CALLBACK (_arena_handler), this);
 224
 225     SP_CANVAS_ARENA (drawing)->arena->delta = prefs->getDouble("/options/cursortolerance/value", 1.0); // default is 1 px
 226
 227     if (prefs->getBool("/options/startmode/outline")) {
 228         // Start in outline mode
 229         setDisplayModeOutline();
 230     } else {
 231         // Start in normal mode, default
 232         setDisplayModeNormal();
 233     }
 234
 235     // The order in which these canvas items are added determines the z-order. It's therefore
 236     // important to add the tempgroup (which will contain the snapindicator) before adding the
 237     // controls. Only this way one will be able to quickly (before the snap indicator has
 238     // disappeared) reselect a node after snapping it. If the z-order is wrong however, this
 239     // will not work (the snap indicator is on top of the node handler; is the snapindicator
 240     // being selected? or does it intercept some of the events that should have gone to the
 241     // node handler? see bug https://bugs.launchpad.net/inkscape/+bug/414142)
 242     gridgroup = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 243     guides = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 244     sketch = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 245     tempgroup = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 246     controls = (SPCanvasGroup *) sp_canvas_item_new (main, SP_TYPE_CANVAS_GROUP, NULL);
 247
 248     /* Push select tool to the bottom of stack */
 249     /** \todo
 250      * FIXME: this is the only call to this.  Everything else seems to just
 251      * call "set" instead of "push".  Can we assume that there is only one
 252      * context ever?
 253      */
 254     push_event_context (SP_TYPE_SELECT_CONTEXT, "/tools/select", SP_EVENT_CONTEXT_STATIC);
 255
 256     // display rect and zoom are now handled in sp_desktop_widget_realize()
 257
 258     Geom::Rect const d(Geom::Point(0.0, 0.0),
 259                        Geom::Point(document->getWidth(), document->getHeight()));
 260
 261     SP_CTRLRECT(page)->setRectangle(d);
 262     SP_CTRLRECT(page_border)->setRectangle(d);
 263
 264     /* the following sets the page shadow on the canvas
 265        It was originally set to 5, which is really cheesy!
 266        It now is an attribute in the document's namedview. If a value of
 267        0 is used, then the constructor for a shadow is not initialized.
 268     */
 269
 270     if ( namedview->pageshadow != 0 && namedview->showpageshadow ) {
 271         SP_CTRLRECT(page_border)->setShadow(namedview->pageshadow, 0x3f3f3fff);
 272     }
 273
 274
 275     /* Connect event for page resize */
 276     _doc2dt[5] = document->getHeight ();
 277     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (drawing), _doc2dt);
 278
 279     _modified_connection = namedview->connectModified(sigc::bind<2>(sigc::ptr_fun(&_namedview_modified), this));
 280
 281     NRArenaItem *ai = SP_ITEM (sp_document_root (document))->invoke_show (
 282             SP_CANVAS_ARENA (drawing)->arena,
 283             dkey,
 284             SP_ITEM_SHOW_DISPLAY);
 285     if (ai) {
 286         nr_arena_item_add_child (SP_CANVAS_ARENA (drawing)->root, ai, NULL);
 287     }
 288
 289     namedview->show(this);
 290     /* Ugly hack */
 291     activate_guides (true);
 292     /* Ugly hack */
 293     _namedview_modified (namedview, SP_OBJECT_MODIFIED_FLAG, this);
 294
 295 /* Set up notification of rebuilding the document, this allows
 296        for saving object related settings in the document. */
 297     _reconstruction_start_connection =
 298         document->connectReconstructionStart(sigc::bind(sigc::ptr_fun(_reconstruction_start), this));
 299     _reconstruction_finish_connection =
 300         document->connectReconstructionFinish(sigc::bind(sigc::ptr_fun(_reconstruction_finish), this));
 301     _reconstruction_old_layer_id = NULL;
 302
 303     // ?
 304     // sp_active_desktop_set (desktop);
 305     _inkscape = INKSCAPE;
 306
 307     _activate_connection = _activate_signal.connect(
 308         sigc::bind(
 309             sigc::ptr_fun(_onActivate),
 310             this
 311         )
 312     );
 313      _deactivate_connection = _deactivate_signal.connect(
 314         sigc::bind(
 315             sigc::ptr_fun(_onDeactivate),
 316             this
 317         )
 318     );
 319
 320     _sel_modified_connection = selection->connectModified(
 321         sigc::bind(
 322             sigc::ptr_fun(&_onSelectionModified),
 323             this
 324         )
 325     );
 326     _sel_changed_connection = selection->connectChanged(
 327         sigc::bind(
 328             sigc::ptr_fun(&_onSelectionChanged),
 329             this
 330         )
 331     );
 332
 333
 334     /* setup LayerManager */
 335     //   (Setting up after the connections are all in place, as it may use some of them)
 336     layer_manager = new Inkscape::LayerManager( this );
 337
 338     showGrids(namedview->grids_visible, false);
 339
 340     temporary_item_list = new Inkscape::Display::TemporaryItemList( this );
 341     snapindicator = new Inkscape::Display::SnapIndicator ( this );
 342 }
 343
 344
 345 void SPDesktop::destroy()
 346 {
 347     if (snapindicator) {
 348         delete snapindicator;
 349         snapindicator = NULL;
 350     }
 351     if (temporary_item_list) {
 352         delete temporary_item_list;
 353         temporary_item_list = NULL;
 354     }
 355
 356     if (selection) {
 357         delete selection;
 358         selection = NULL;
 359     }
 360
 361     namedview->hide(this);
 362
 363     _activate_connection.disconnect();
 364     _deactivate_connection.disconnect();
 365     _sel_modified_connection.disconnect();
 366     _sel_changed_connection.disconnect();
 367     _modified_connection.disconnect();
 368     _commit_connection.disconnect();
 369     _reconstruction_start_connection.disconnect();
 370     _reconstruction_finish_connection.disconnect();
 371
 372     g_signal_handlers_disconnect_by_func(G_OBJECT (acetate), (gpointer) G_CALLBACK(sp_desktop_root_handler), this);
 373     g_signal_handlers_disconnect_by_func(G_OBJECT (main), (gpointer) G_CALLBACK(sp_desktop_root_handler), this);
 374     g_signal_handlers_disconnect_by_func(G_OBJECT (drawing), (gpointer) G_CALLBACK(_arena_handler), this);
 375
 376     while (event_context) {
 377         SPEventContext *ec = event_context;
 378         event_context = ec->next;
 379         sp_event_context_finish (ec);
 380         g_object_unref (G_OBJECT (ec));
 381     }
 382
 383     if (_layer_hierarchy) {
 384         delete _layer_hierarchy;
 385 //        _layer_hierarchy = NULL; //this should be here, but commented to find other bug somewhere else.
 386     }
 387
 388     if (layer_manager) {
 389         delete layer_manager;
 390         layer_manager = NULL;
 391     }
 392
 393     if (_inkscape) {
 394         _inkscape = NULL;
 395     }
 396
 397     if (drawing) {
 398         SP_ITEM (sp_document_root (doc()))->invoke_hide (dkey);
 399         drawing = NULL;
 400     }
 401
 402     delete _guides_message_context;
 403     _guides_message_context = NULL;
 404
 405     g_list_free (zooms_past);
 406     g_list_free (zooms_future);
 407 }
 408
 409 SPDesktop::~SPDesktop() {}
 410
 411 //--------------------------------------------------------------------
 412 /* Public methods */
 413
 414
 415 /* These methods help for temporarily showing things on-canvas.
 416  * The *only* valid use of the TemporaryItem* that you get from add_temporary_canvasitem
 417  * is when you want to prematurely remove the item from the canvas, by calling
 418  * desktop->remove_temporary_canvasitem(tempitem).
 419  */
 420 /** Note that lifetime is measured in milliseconds
 421  * One should *not* keep a reference to the SPCanvasItem, the temporary item code will
 422  * delete the object for you and the reference will become invalid without you knowing it.
 423  * It is perfectly safe to ignore the returned pointer: the object is deleted by itself, so don't delete it elsewhere!
 424  * The *only* valid use of the returned TemporaryItem* is as argument for SPDesktop::remove_temporary_canvasitem,
 425  * because the object might be deleted already without you knowing it.
 426  * move_to_bottom = true by default so the item does not interfere with handling of other items on the canvas like nodes.
 427  */
 428 Inkscape::Display::TemporaryItem *
 429 SPDesktop::add_temporary_canvasitem (SPCanvasItem *item, guint lifetime, bool move_to_bottom)
 430 {
 431     if (move_to_bottom) {
 432         sp_canvas_item_move_to_z(item, 0);
 433     }
 434
 435     return temporary_item_list->add_item(item, lifetime);
 436 }
 437
 438 /** It is perfectly safe to call this function while the object has already been deleted due to a timeout.
 439 */
 440 void
 441 SPDesktop::remove_temporary_canvasitem (Inkscape::Display::TemporaryItem * tempitem)
 442 {
 443     // check for non-null temporary_item_list, because during destruction of desktop, some destructor might try to access this list!
 444     if (tempitem && temporary_item_list) {
 445         temporary_item_list->delete_item(tempitem);
 446     }
 447 }
 448
 449 void SPDesktop::_setDisplayMode(Inkscape::RenderMode mode) {
 450     SP_CANVAS_ARENA (drawing)->arena->rendermode = mode;
 451     canvas->rendermode = mode;
 452     _display_mode = mode;
 453     sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (main), _d2w); // redraw
 454     _widget->setTitle(SP_DOCUMENT_NAME(sp_desktop_document(this)));
 455 }
 456
 457 void SPDesktop::displayModeToggle() {
 458     switch (_display_mode) {
 459     case Inkscape::RENDERMODE_NORMAL:
 460         _setDisplayMode(Inkscape::RENDERMODE_NO_FILTERS);
 461         break;
 462     case Inkscape::RENDERMODE_NO_FILTERS:
 463         _setDisplayMode(Inkscape::RENDERMODE_OUTLINE);
 464         break;
 465     case Inkscape::RENDERMODE_OUTLINE:
 466         _setDisplayMode(Inkscape::RENDERMODE_PRINT_COLORS_PREVIEW);
 467         break;
 468     case Inkscape::RENDERMODE_PRINT_COLORS_PREVIEW:
 469     default:
 470         _setDisplayMode(Inkscape::RENDERMODE_NORMAL);
 471     }
 472 }
 473
 474 /**
 475  * Returns current root (=bottom) layer.
 476  */
 477 SPObject *SPDesktop::currentRoot() const
 478 {
 479     return _layer_hierarchy ? _layer_hierarchy->top() : NULL;
 480 }
 481
 482 /**
 483  * Returns current top layer.
 484  */
 485 SPObject *SPDesktop::currentLayer() const
 486 {
 487     return _layer_hierarchy ? _layer_hierarchy->bottom() : NULL;
 488 }
 489
 490 /**
 491  * Sets the current layer of the desktop.
 492  *
 493  * Make \a object the top layer.
 494  */
 495 void SPDesktop::setCurrentLayer(SPObject *object) {
 496     g_return_if_fail(SP_IS_GROUP(object));
 497     g_return_if_fail( currentRoot() == object || (currentRoot() && currentRoot()->isAncestorOf(object)) );
 498     // printf("Set Layer to ID: %s\n", SP_OBJECT_ID(object));
 499     _layer_hierarchy->setBottom(object);
 500 }
 501
 502 void SPDesktop::toggleLayerSolo(SPObject *object) {
 503     g_return_if_fail(SP_IS_GROUP(object));
 504     g_return_if_fail( currentRoot() == object || (currentRoot() && currentRoot()->isAncestorOf(object)) );
 505
 506     bool othersShowing = false;
 507     std::vector<SPObject*> layers;
 508     for ( SPObject* obj = Inkscape::next_layer(currentRoot(), object); obj; obj = Inkscape::next_layer(currentRoot(), obj) ) {
 509         layers.push_back(obj);
 510         othersShowing |= !SP_ITEM(obj)->isHidden();
 511     }
 512     for ( SPObject* obj = Inkscape::previous_layer(currentRoot(), object); obj; obj = Inkscape::previous_layer(currentRoot(), obj) ) {
 513         layers.push_back(obj);
 514         othersShowing |= !SP_ITEM(obj)->isHidden();
 515     }
 516
 517
 518     if ( SP_ITEM(object)->isHidden() ) {
 519         SP_ITEM(object)->setHidden(false);
 520     }
 521
 522     for ( std::vector<SPObject*>::iterator it = layers.begin(); it != layers.end(); ++it ) {
 523         SP_ITEM(*it)->setHidden(othersShowing);
 524     }
 525 }
 526
 527 /**
 528  * Return layer that contains \a object.
 529  */
 530 SPObject *SPDesktop::layerForObject(SPObject *object) {
 531     g_return_val_if_fail(object != NULL, NULL);
 532
 533     SPObject *root=currentRoot();
 534     object = SP_OBJECT_PARENT(object);
 535     while ( object && object != root && !isLayer(object) ) {
 536         object = SP_OBJECT_PARENT(object);
 537     }
 538     return object;
 539 }
 540
 541 /**
 542  * True if object is a layer.
 543  */
 544 bool SPDesktop::isLayer(SPObject *object) const {
 545     return ( SP_IS_GROUP(object)
 546              && ( SP_GROUP(object)->effectiveLayerMode(this->dkey)
 547                   == SPGroup::LAYER ) );
 548 }
 549
 550 /**
 551  * True if desktop viewport fully contains \a item's bbox.
 552  */
 553 bool SPDesktop::isWithinViewport (SPItem *item) const
 554 {
 555     Geom::Rect const viewport = get_display_area();
 556     Geom::OptRect const bbox = item->getBboxDesktop();
 557     if (bbox) {
 558         return viewport.contains(*bbox);
 559     } else {
 560         return true;
 561     }
 562 }
 563
 564 ///
 565 bool SPDesktop::itemIsHidden(SPItem const *item) const {
 566     return item->isHidden(this->dkey);
 567 }
 568
 569 /**
 570  * Set activate property of desktop; emit signal if changed.
 571  */
 572 void
 573 SPDesktop::set_active (bool new_active)
 574 {
 575     if (new_active != _active) {
 576         _active = new_active;
 577         if (new_active) {
 578             _activate_signal.emit();
 579         } else {
 580             _deactivate_signal.emit();
 581         }
 582     }
 583 }
 584
 585 /**
 586  * Set activate status of current desktop's named view.
 587  */
 588 void
 589 SPDesktop::activate_guides(bool activate)
 590 {
 591     guides_active = activate;
 592     namedview->activateGuides(this, activate);
 593 }
 594
 595 /**
 596  * Make desktop switch documents.
 597  */
 598 void
 599 SPDesktop::change_document (SPDocument *theDocument)
 600 {
 601     g_return_if_fail (theDocument != NULL);
 602
 603     /* unselect everything before switching documents */
 604     selection->clear();
 605
 606     setDocument (theDocument);
 607
 608     /* update the rulers, connect the desktop widget's signal to the new namedview etc.
 609        (this can probably be done in a better way) */
 610     Gtk::Window *parent = this->getToplevel();
 611     g_assert(parent != NULL);
 612     SPDesktopWidget *dtw = (SPDesktopWidget *) parent->get_data("desktopwidget");
 613     if (dtw) {
 614         dtw->desktop = this;
 615     }
 616     dtw->updateNamedview();
 617
 618     _namedview_modified (namedview, SP_OBJECT_MODIFIED_FLAG, this);
 619     _document_replaced_signal.emit (this, theDocument);
 620 }
 621
 622 /**
 623  * Make desktop switch event contexts.
 624  */
 625 void
 626 SPDesktop::set_event_context (GtkType type, const gchar *config)
 627 {
 628     SPEventContext *ec;
 629     while (event_context) {
 630         ec = event_context;
 631         sp_event_context_deactivate (ec);
 632         // we have to keep event_context valid during destruction - otherwise writing
 633         // destructors is next to impossible
 634         SPEventContext *next = ec->next;
 635         sp_event_context_finish (ec);
 636         g_object_unref (G_OBJECT (ec));
 637         event_context = next;
 638     }
 639
 640     ec = sp_event_context_new (type, this, config, SP_EVENT_CONTEXT_STATIC);
 641     ec->next = event_context;
 642     event_context = ec;
 643     sp_event_context_activate (ec);
 644     _event_context_changed_signal.emit (this, ec);
 645 }
 646
 647 /**
 648  * Push event context onto desktop's context stack.
 649  */
 650 void
 651 SPDesktop::push_event_context (GtkType type, const gchar *config, unsigned int key)
 652 {
 653     SPEventContext *ref, *ec;
 654
 655     if (event_context && event_context->key == key) return;
 656     ref = event_context;
 657     while (ref && ref->next && ref->next->key != key) ref = ref->next;
 658     if (ref && ref->next) {
 659         ec = ref->next;
 660         ref->next = ec->next;
 661         sp_event_context_finish (ec);
 662         g_object_unref (G_OBJECT (ec));
 663     }
 664
 665     if (event_context) sp_event_context_deactivate (event_context);
 666     ec = sp_event_context_new (type, this, config, key);
 667     ec->next = event_context;
 668     event_context = ec;
 669     sp_event_context_activate (ec);
 670     _event_context_changed_signal.emit (this, ec);
 671 }
 672
 673 /**
 674  * Sets the coordinate status to a given point
 675  */
 676 void
 677 SPDesktop::set_coordinate_status (Geom::Point p) {
 678     _widget->setCoordinateStatus(p);
 679 }
 680
 681 /**
 682  * \see sp_document_item_from_list_at_point_bottom()
 683  */
 684 SPItem *
 685 SPDesktop::item_from_list_at_point_bottom (const GSList *list, Geom::Point const p) const
 686 {
 687     g_return_val_if_fail (doc() != NULL, NULL);
 688     return SPDocument::item_from_list_at_point_bottom (dkey, SP_GROUP (doc()->root), list, p);
 689 }
 690
 691 /**
 692  * \see sp_document_item_at_point()
 693  */
 694 SPItem *
 695 SPDesktop::item_at_point (Geom::Point const p, bool into_groups, SPItem *upto) const
 696 {
 697     g_return_val_if_fail (doc() != NULL, NULL);
 698     return doc()->item_at_point ( dkey, p, into_groups, upto);
 699 }
 700
 701 /**
 702  * \see sp_document_group_at_point()
 703  */
 704 SPItem *
 705 SPDesktop::group_at_point (Geom::Point const p) const
 706 {
 707     g_return_val_if_fail (doc() != NULL, NULL);
 708     return doc()->group_at_point (dkey, p);
 709 }
 710
 711 /**
 712  * \brief  Returns the mouse point in document coordinates; if mouse is
 713  * outside the canvas, returns the center of canvas viewpoint
 714  */
 715 Geom::Point
 716 SPDesktop::point() const
 717 {
 718     Geom::Point p = _widget->getPointer();
 719     Geom::Point pw = sp_canvas_window_to_world (canvas, p);
 720     p = w2d(pw);
 721
 722     Geom::Rect const r = canvas->getViewbox();
 723
 724     Geom::Point r0 = w2d(r.min());
 725     Geom::Point r1 = w2d(r.max());
 726
 727     if (p[Geom::X] >= r0[Geom::X] &&
 728         p[Geom::X] <= r1[Geom::X] &&
 729         p[Geom::Y] >= r1[Geom::Y] &&
 730         p[Geom::Y] <= r0[Geom::Y])
 731     {
 732         return p;
 733     } else {
 734         return (r0 + r1) / 2;
 735     }
 736 }
 737
 738 /**
 739  * Put current zoom data in history list.
 740  */
 741 void
 742 SPDesktop::push_current_zoom (GList **history)
 743 {
 744     Geom::Rect const area = get_display_area();
 745
 746     NRRect *old_zoom = g_new(NRRect, 1);
 747     old_zoom->x0 = area.min()[Geom::X];
 748     old_zoom->x1 = area.max()[Geom::X];
 749     old_zoom->y0 = area.min()[Geom::Y];
 750     old_zoom->y1 = area.max()[Geom::Y];
 751     if ( *history == NULL
 752          || !( ( ((NRRect *) ((*history)->data))->x0 == old_zoom->x0 ) &&
 753                ( ((NRRect *) ((*history)->data))->x1 == old_zoom->x1 ) &&
 754                ( ((NRRect *) ((*history)->data))->y0 == old_zoom->y0 ) &&
 755                ( ((NRRect *) ((*history)->data))->y1 == old_zoom->y1 ) ) )
 756     {
 757         *history = g_list_prepend (*history, old_zoom);
 758     }
 759 }
 760
 761 /**
 762  * Set viewbox (x0, x1, y0 and y1 are in document pixels. Border is in screen pixels).
 763  */
 764 void
 765 SPDesktop::set_display_area (double x0, double y0, double x1, double y1, double border, bool log)
 766 {
 767     g_assert(_widget);
 768
 769     // save the zoom
 770     if (log) {
 771         push_current_zoom(&zooms_past);
 772         // if we do a logged zoom, our zoom-forward list is invalidated, so delete it
 773         g_list_free (zooms_future);
 774         zooms_future = NULL;
 775     }
 776
 777     double const cx = 0.5 * (x0 + x1);
 778     double const cy = 0.5 * (y0 + y1);
 779
 780     // FIXME: This 2geom idiom doesn't allow us to declare dbox const
 781     Geom::Rect viewbox = canvas->getViewbox();
 782     viewbox.expandBy(-border);
 783
 784     double scale = _d2w.descrim();
 785     double newscale;
 786     if (((x1 - x0) * viewbox.dimensions()[Geom::Y]) > ((y1 - y0) * viewbox.dimensions()[Geom::X])) {
 787         newscale = viewbox.dimensions()[Geom::X] / (x1 - x0);
 788     } else {
 789         newscale = viewbox.dimensions()[Geom::Y] / (y1 - y0);
 790     }
 791
 792     newscale = CLAMP(newscale, SP_DESKTOP_ZOOM_MIN, SP_DESKTOP_ZOOM_MAX); // unit: 'screen pixels' per 'document pixels'
 793
 794     int clear = FALSE;
 795     if (!NR_DF_TEST_CLOSE (newscale, scale, 1e-4 * scale)) {
 796         // zoom changed - set new zoom factors
 797         _d2w = Geom::Scale(newscale, -newscale);
 798         _w2d = Geom::Scale(1/newscale, 1/-newscale);
 799         sp_canvas_item_affine_absolute(SP_CANVAS_ITEM(main), _d2w);
 800         clear = TRUE;
 801         signal_zoom_changed.emit(_d2w.descrim());
 802     }
 803
 804     /* Calculate top left corner (in document pixels) */
 805     x0 = cx - 0.5 * viewbox.dimensions()[Geom::X] / newscale;
 806     y1 = cy + 0.5 * viewbox.dimensions()[Geom::Y] / newscale;
 807
 808     /* Scroll */
 809     sp_canvas_scroll_to (canvas, x0 * newscale - border, y1 * -newscale - border, clear);
 810
 811     /*  update perspective lines if we are in the 3D box tool (so that infinite ones are shown correctly) */
 812     sp_box3d_context_update_lines(event_context);
 813
 814     _widget->updateRulers();
 815     _widget->updateScrollbars(_d2w.descrim());
 816     _widget->updateZoom();
 817 }
 818
 819 void SPDesktop::set_display_area(Geom::Rect const &a, Geom::Coord b, bool log)
 820 {
 821     set_display_area(a.min()[Geom::X], a.min()[Geom::Y], a.max()[Geom::X], a.max()[Geom::Y], b, log);
 822 }
 823
 824 /**
 825  * Return viewbox dimensions.
 826  */
 827 Geom::Rect SPDesktop::get_display_area() const
 828 {
 829     Geom::Rect const viewbox = canvas->getViewbox();
 830
 831     double const scale = _d2w[0];
 832
 833     return Geom::Rect(Geom::Point(viewbox.min()[Geom::X] / scale, viewbox.max()[Geom::Y] / -scale),
 834                       Geom::Point(viewbox.max()[Geom::X] / scale, viewbox.min()[Geom::Y] / -scale));
 835 }
 836
 837 /**
 838  * Revert back to previous zoom if possible.
 839  */
 840 void
 841 SPDesktop::prev_zoom()
 842 {
 843     if (zooms_past == NULL) {
 844         messageStack()->flash(Inkscape::WARNING_MESSAGE, _("No previous zoom."));
 845         return;
 846     }
 847
 848     // push current zoom into forward zooms list
 849     push_current_zoom (&zooms_future);
 850
 851     // restore previous zoom
 852     set_display_area (((NRRect *) zooms_past->data)->x0,
 853             ((NRRect *) zooms_past->data)->y0,
 854             ((NRRect *) zooms_past->data)->x1,
 855             ((NRRect *) zooms_past->data)->y1,
 856             0, false);
 857
 858     // remove the just-added zoom from the past zooms list
 859     zooms_past = g_list_remove (zooms_past, ((NRRect *) zooms_past->data));
 860 }
 861
 862 /**
 863  * Set zoom to next in list.
 864  */
 865 void
 866 SPDesktop::next_zoom()
 867 {
 868     if (zooms_future == NULL) {
 869         this->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("No next zoom."));
 870         return;
 871     }
 872
 873     // push current zoom into past zooms list
 874     push_current_zoom (&zooms_past);
 875
 876     // restore next zoom
 877     set_display_area (((NRRect *) zooms_future->data)->x0,
 878             ((NRRect *) zooms_future->data)->y0,
 879             ((NRRect *) zooms_future->data)->x1,
 880             ((NRRect *) zooms_future->data)->y1,
 881             0, false);
 882
 883     // remove the just-used zoom from the zooms_future list
 884     zooms_future = g_list_remove (zooms_future, ((NRRect *) zooms_future->data));
 885 }
 886
 887 /** \brief  Performs a quick zoom into what the user is working on
 888     \param  enable  Whether we're going in or out of quick zoom
 889
 890 */
 891 void
 892 SPDesktop::zoom_quick (bool enable)
 893 {
 894     if (enable == _quick_zoom_enabled) {
 895         return;
 896     }
 897
 898     if (enable == true) {
 899         _quick_zoom_stored_area = get_display_area();
 900         bool zoomed = false;
 901
 902         // TODO This needs to migrate into the node tool, but currently the design
 903         // of this method is sufficiently wrong to prevent this.
 904         if (!zoomed && INK_IS_NODE_TOOL(event_context)) {
 905             InkNodeTool *nt = static_cast<InkNodeTool*>(event_context);
 906             if (!nt->_selected_nodes->empty()) {
 907                 Geom::Rect nodes = *nt->_selected_nodes->bounds();
 908                 double area = nodes.area();
 909                 // do not zoom if a single cusp node is selected aand the bounds
 910                 // have zero area.
 911                 if (!Geom::are_near(area, 0) && area * 2.0 < _quick_zoom_stored_area.area()) {
 912                     set_display_area(nodes, true);
 913                     zoomed = true;
 914                 }
 915             }
 916         }
 917
 918         if (!zoomed) {
 919             Geom::OptRect const d = selection->bounds();
 920             if (d && d->area() * 2.0 < _quick_zoom_stored_area.area()) {
 921                 set_display_area(*d, true);
 922                 zoomed = true;
 923             }
 924         }
 925
 926         if (!zoomed) {
 927             zoom_relative(_quick_zoom_stored_area.midpoint()[Geom::X], _quick_zoom_stored_area.midpoint()[Geom::Y], 2.0);
 928             zoomed = true;
 929         }
 930     } else {
 931         set_display_area(_quick_zoom_stored_area, false);
 932     }
 933
 934     _quick_zoom_enabled = enable;
 935     return;
 936 }
 937
 938 /**
 939  * Zoom to point with absolute zoom factor.
 940  */
 941 void
 942 SPDesktop::zoom_absolute_keep_point (double cx, double cy, double px, double py, double zoom)
 943 {
 944     zoom = CLAMP (zoom, SP_DESKTOP_ZOOM_MIN, SP_DESKTOP_ZOOM_MAX);
 945
 946     // maximum or minimum zoom reached, but there's no exact equality because of rounding errors;
 947     // this check prevents "sliding" when trying to zoom in at maximum zoom;
 948     /// \todo someone please fix calculations properly and remove this hack
 949     if (fabs(_d2w.descrim() - zoom) < 0.0001*zoom && (fabs(SP_DESKTOP_ZOOM_MAX - zoom) < 0.01 || fabs(SP_DESKTOP_ZOOM_MIN - zoom) < 0.000001))
 950         return;
 951
 952     Geom::Rect const viewbox = canvas->getViewbox();
 953
 954     double const width2 = viewbox.dimensions()[Geom::X] / zoom;
 955     double const height2 = viewbox.dimensions()[Geom::Y] / zoom;
 956
 957     set_display_area(cx - px * width2,
 958                      cy - py * height2,
 959                      cx + (1 - px) * width2,
 960                      cy + (1 - py) * height2,
 961                      0.0);
 962 }
 963
 964 /**
 965   * Apply the desktop's current style or the tool style to the object.
 966   */
 967 void SPDesktop::applyCurrentOrToolStyle(SPObject *obj, Glib::ustring const &tool_path, bool with_text)
 968 {
 969         SPCSSAttr *css_current = sp_desktop_get_style(this, with_text);
 970     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 971
 972     if (prefs->getBool(tool_path + "/usecurrent") && css_current) {
 973         sp_repr_css_set(obj->getRepr(), css_current, "style");
 974     } else {
 975         SPCSSAttr *css = prefs->getInheritedStyle(tool_path + "/style");
 976         sp_repr_css_set(obj->getRepr(), css, "style");
 977         sp_repr_css_attr_unref(css);
 978     }
 979     if (css_current) {
 980         sp_repr_css_attr_unref(css_current);
 981     }
 982
 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(doc()->getWidth(), doc()->getHeight()));
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 (doc()->getWidth() < 1.0) {
1057         return;
1058     }
1059
1060     Geom::Rect d(Geom::Point(0, a.midpoint()[Geom::Y]),
1061                  Geom::Point(doc()->getWidth(), 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 = docitem->getBboxDesktop();
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::toggleSnapGlobal()
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 (sp_document_root (this->doc()))->invoke_hide (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 (sp_document_root (doc))->invoke_show (
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(desktop->currentLayer()->getId());
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         /* Show/hide page background */
1703         if (nv->pagecolor & 0xff) {
1704             sp_canvas_item_show (desktop->table);
1705             ((CtrlRect *) desktop->table)->setColor(0x00000000, true, nv->pagecolor);
1706             sp_canvas_item_move_to_z (desktop->table, 0);
1707         } else {
1708             sp_canvas_item_hide (desktop->table);
1709         }
1710
1711         /* Show/hide page border */
1712         if (nv->showborder) {
1713             // show
1714             sp_canvas_item_show (desktop->page_border);
1715             // set color and shadow
1716             ((CtrlRect *) desktop->page_border)->setColor(nv->bordercolor, false, 0x00000000);
1717             if (nv->pageshadow) {
1718                 ((CtrlRect *) desktop->page_border)->setShadow(nv->pageshadow, nv->bordercolor);
1719             }
1720             // place in the z-order stack
1721             if (nv->borderlayer == SP_BORDER_LAYER_BOTTOM) {
1722                  sp_canvas_item_move_to_z (desktop->page_border, 2);
1723             } else {
1724                 int order = sp_canvas_item_order (desktop->page_border);
1725                 int morder = sp_canvas_item_order (desktop->drawing);
1726                 if (morder > order) sp_canvas_item_raise (desktop->page_border,
1727                     morder - order);
1728             }
1729         } else {
1730                 sp_canvas_item_hide (desktop->page_border);
1731                 if (nv->pageshadow) {
1732                     ((CtrlRect *) desktop->page)->setShadow(0, 0x00000000);
1733                 }
1734         }
1735
1736         /* Show/hide page shadow */
1737         if (nv->showpageshadow && nv->pageshadow) {
1738             ((CtrlRect *) desktop->page_border)->setShadow(nv->pageshadow, nv->bordercolor);
1739         } else {
1740             ((CtrlRect *) desktop->page_border)->setShadow(0, 0x00000000);
1741         }
1742
1743         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1744         if (SP_RGBA32_A_U(nv->pagecolor) < 128 ||
1745             (SP_RGBA32_R_U(nv->pagecolor) +
1746              SP_RGBA32_G_U(nv->pagecolor) +
1747              SP_RGBA32_B_U(nv->pagecolor)) >= 384) {
1748             // the background color is light or transparent, use black outline
1749             SP_CANVAS_ARENA (desktop->drawing)->arena->outlinecolor = prefs->getInt("/options/wireframecolors/onlight", 0xff);
1750         } else { // use white outline
1751             SP_CANVAS_ARENA (desktop->drawing)->arena->outlinecolor = prefs->getInt("/options/wireframecolors/ondark", 0xffffffff);
1752         }
1753     }
1754 }
1755
1756 Geom::Matrix SPDesktop::w2d() const
1757 {
1758     return _w2d;
1759 }
1760
1761 Geom::Point SPDesktop::w2d(Geom::Point const &p) const
1762 {
1763     return p * _w2d;
1764 }
1765
1766 Geom::Point SPDesktop::d2w(Geom::Point const &p) const
1767 {
1768     return p * _d2w;
1769 }
1770
1771 Geom::Matrix SPDesktop::doc2dt() const
1772 {
1773     return _doc2dt;
1774 }
1775
1776 Geom::Matrix SPDesktop::dt2doc() const
1777 {
1778     // doc2dt is its own inverse
1779     return _doc2dt;
1780 }
1781
1782 Geom::Point SPDesktop::doc2dt(Geom::Point const &p) const
1783 {
1784     return p * _doc2dt;
1785 }
1786
1787 Geom::Point SPDesktop::dt2doc(Geom::Point const &p) const
1788 {
1789     return p * dt2doc();
1790 }
1791
1792
1793 /*
1794  * Pop event context from desktop's context stack. Never used.
1795  */
1796 // void
1797 // SPDesktop::pop_event_context (unsigned int key)
1798 // {
1799 //    SPEventContext *ec = NULL;
1800 //
1801 //    if (event_context && event_context->key == key) {
1802 //        g_return_if_fail (event_context);
1803 //        g_return_if_fail (event_context->next);
1804 //        ec = event_context;
1805 //        sp_event_context_deactivate (ec);
1806 //        event_context = ec->next;
1807 //        sp_event_context_activate (event_context);
1808 //        _event_context_changed_signal.emit (this, ec);
1809 //    }
1810 //
1811 //    SPEventContext *ref = event_context;
1812 //    while (ref && ref->next && ref->next->key != key)
1813 //        ref = ref->next;
1814 //
1815 //    if (ref && ref->next) {
1816 //        ec = ref->next;
1817 //        ref->next = ec->next;
1818 //    }
1819 //
1820 //    if (ec) {
1821 //        sp_event_context_finish (ec);
1822 //        g_object_unref (G_OBJECT (ec));
1823 //    }
1824 // }
1825
1826 /*
1827   Local Variables:
1828   mode:c++
1829   c-file-style:"stroustrup"
1830   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1831   indent-tabs-mode:nil
1832   fill-column:99
1833   End:
1834 */
1835 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :