Connector tool: make connectors avoid the convex hull of shapes.

(bzr r8857.1.2)

9 files changed, 665 insertions, 467 deletions

diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp
index e3bf1ae9c..b63992afe 100644
--- a/src/widgets/desktop-widget.cpp
+++ b/src/widgets/desktop-widget.cpp
@@ -613,12 +613,20 @@ SPDesktopWidget::updateTitle(gchar const* uri)
         if (this->desktop->number > 1) {
             if (this->desktop->getMode() == Inkscape::RENDERMODE_OUTLINE) {
                 g_string_printf (name, _("%s: %d (outline) - Inkscape"), fname, this->desktop->number);
+            } else if (this->desktop->getMode() == Inkscape::RENDERMODE_NO_FILTERS) {
+                g_string_printf (name, _("%s: %d (no filters) - Inkscape"), fname, this->desktop->number);
+            } else if (this->desktop->getMode() == Inkscape::RENDERMODE_PRINT_COLORS_PREVIEW) {
+                g_string_printf (name, _("%s: %d (print colors preview) - Inkscape"), fname, this->desktop->number);
             } else {
                 g_string_printf (name, _("%s: %d - Inkscape"), fname, this->desktop->number);
             }
         } else {
             if (this->desktop->getMode() == Inkscape::RENDERMODE_OUTLINE) {
                 g_string_printf (name, _("%s (outline) - Inkscape"), fname);
+            } else if (this->desktop->getMode() == Inkscape::RENDERMODE_NO_FILTERS) {
+                g_string_printf (name, _("%s (no filters) - Inkscape"), fname);
+            } else if (this->desktop->getMode() == Inkscape::RENDERMODE_PRINT_COLORS_PREVIEW) {
+                g_string_printf (name, _("%s (print colors preview) - Inkscape"), fname);
             } else {
                 g_string_printf (name, _("%s - Inkscape"), fname);
             }
diff --git a/src/widgets/icon.cpp b/src/widgets/icon.cpp
index 5824b102c..743502d27 100644
--- a/src/widgets/icon.cpp
+++ b/src/widgets/icon.cpp
@@ -714,7 +714,7 @@ int sp_icon_get_phys_size(int size)
     static int lastSys[Inkscape::ICON_SIZE_DECORATION + 1];
     static int vals[Inkscape::ICON_SIZE_DECORATION + 1];
 
-    size = CLAMP( size, GTK_ICON_SIZE_MENU, Inkscape::ICON_SIZE_DECORATION );
+    size = CLAMP( size, static_cast<int>(GTK_ICON_SIZE_MENU), static_cast<int>(Inkscape::ICON_SIZE_DECORATION) );
 
     if ( !sizeMapDone ) {
         injectCustomSize();
diff --git a/src/widgets/ruler.cpp b/src/widgets/ruler.cpp
index c90b55e73..c70d96991 100644
--- a/src/widgets/ruler.cpp
+++ b/src/widgets/ruler.cpp
@@ -727,6 +727,7 @@ sp_vruler_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 // code, those warnings are actually desired. They say "Hey! Fix this". We
 // definitely don't want to hide/ignore them. --JonCruz
 
+// TODO address const/non-const gchar* issue:
 /// Ruler metrics.
 static GtkRulerMetric const sp_ruler_metrics[] = {
   // NOTE: the order of records in this struct must correspond to the SPMetric enum.
diff --git a/src/widgets/sp-color-icc-selector.cpp b/src/widgets/sp-color-icc-selector.cpp
index a10d2380c..3b4b6b711 100644
--- a/src/widgets/sp-color-icc-selector.cpp
+++ b/src/widgets/sp-color-icc-selector.cpp
@@ -17,12 +17,12 @@
 #include "inkscape.h"
 #include "profile-manager.h"
 
-#define noDEBUG_LCMS
+#define DEBUG_LCMS
 
 #if ENABLE_LCMS
 #include "color-profile-fns.h"
 #include "color-profile.h"
-//#define DEBUG_LCMS
+
 #ifdef DEBUG_LCMS
 #include "preferences.h"
 #include <gtk/gtkmessagedialog.h>
@@ -603,7 +603,7 @@ void ColorICCSelector::_profilesChanged( std::string const & name )
 void ColorICCSelector::_colorChanged()
 {
     _updating = TRUE;
-//     sp_color_icc_set_color( SP_COLOR_ICC( _icc ), &color );
+     //sp_color_icc_set_color( SP_COLOR_ICC( _icc ), &color );
 
 #ifdef DEBUG_LCMS
     g_message( "/^^^^^^^^^  %p::_colorChanged(%08x:%s)", this,
diff --git a/src/widgets/sp-color-notebook.cpp b/src/widgets/sp-color-notebook.cpp
index 779895de4..3ba39dd30 100644
--- a/src/widgets/sp-color-notebook.cpp
+++ b/src/widgets/sp-color-notebook.cpp
@@ -32,6 +32,10 @@
 #include "sp-color-scales.h"
 #include "sp-color-icc-selector.h"
 #include "sp-color-wheel-selector.h"
+#include "svg/svg-icc-color.h"
+#include "../inkscape.h"
+#include "../document.h"
+#include "../profile-manager.h"
 
 struct SPColorNotebookTracker {
 	const gchar* name;
@@ -324,9 +328,37 @@ void ColorNotebook::init()
 
 	row++;
 
-	/* Create RGBA entry and color preview */
 	GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0);
 
+#if ENABLE_LCMS
+	/* Create color management icons */
+        _box_colormanaged = gtk_event_box_new ();
+        GtkWidget *colormanaged = gtk_image_new_from_icon_name ("color-management-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
+        gtk_container_add (GTK_CONTAINER (_box_colormanaged), colormanaged);
+        GtkTooltips *tooltips_colormanaged = gtk_tooltips_new ();
+        gtk_tooltips_set_tip (tooltips_colormanaged, _box_colormanaged, _("Color Managed"), "");
+        gtk_widget_set_sensitive (_box_colormanaged, false);
+	gtk_box_pack_start(GTK_BOX(rgbabox), _box_colormanaged, FALSE, FALSE, 2);
+
+        _box_outofgamut = gtk_event_box_new ();
+        GtkWidget *outofgamut = gtk_image_new_from_icon_name ("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
+        gtk_container_add (GTK_CONTAINER (_box_outofgamut), outofgamut);
+        GtkTooltips *tooltips_outofgamut = gtk_tooltips_new ();
+        gtk_tooltips_set_tip (tooltips_outofgamut, _box_outofgamut, _("Out of gamut!"), "");
+        gtk_widget_set_sensitive (_box_outofgamut, false);
+	gtk_box_pack_start(GTK_BOX(rgbabox), _box_outofgamut, FALSE, FALSE, 2);
+
+        _box_toomuchink = gtk_event_box_new ();
+        GtkWidget *toomuchink = gtk_image_new_from_icon_name ("too-much-ink-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
+        gtk_container_add (GTK_CONTAINER (_box_toomuchink), toomuchink);
+        GtkTooltips *tooltips_toomuchink = gtk_tooltips_new ();
+        gtk_tooltips_set_tip (tooltips_toomuchink, _box_toomuchink, _("Too much ink!"), "");
+        gtk_widget_set_sensitive (_box_toomuchink, false);
+	gtk_box_pack_start(GTK_BOX(rgbabox), _box_toomuchink, FALSE, FALSE, 2);
+
+#endif //ENABLE_LCMS
+
+	/* Create RGBA entry and color preview */
 	_rgbal = gtk_label_new_with_mnemonic (_("RGBA_:"));
 	gtk_misc_set_alignment (GTK_MISC (_rgbal), 1.0, 0.5);
 	gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2);
@@ -341,7 +373,13 @@ void ColorNotebook::init()
 
 	sp_set_font_size_smaller (rgbabox);
 	gtk_widget_show_all (rgbabox);
-	gtk_table_attach (GTK_TABLE (table), rgbabox, 1, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
+
+#if ENABLE_LCMS
+        //the "too much ink" icon is initially hidden
+        gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
+#endif //ENABLE_LCMS
+
+        gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
 
 #ifdef SPCS_PREVIEW
 	_p = sp_color_preview_new (0xffffffff);
@@ -485,6 +523,40 @@ void ColorNotebook::_updateRgbaEntry( const SPColor& color, gfloat alpha )
 {
     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
 
+#if ENABLE_LCMS    
+    /* update color management icon*/
+    gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL);
+
+    /* update out-of-gamut icon */
+    gtk_widget_set_sensitive (_box_outofgamut, false);
+    if (color.icc){
+        Inkscape::ColorProfile* target_profile = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
+        if ( target_profile )
+            gtk_widget_set_sensitive (_box_outofgamut, target_profile->GamutCheck(color));
+    }
+
+    /* update too-much-ink icon */
+    gtk_widget_set_sensitive (_box_toomuchink, false);
+    if (color.icc){
+        Inkscape::ColorProfile* prof = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
+        if (prof->getColorSpace() == icSigCmykData || prof->getColorSpace() == icSigCmyData){
+            gtk_widget_show(GTK_WIDGET(_box_toomuchink));
+            double ink_sum = 0;
+            for (unsigned int i=0; i<color.icc->colors.size(); i++){
+                ink_sum += color.icc->colors[i];
+            }
+
+            /* Some literature states that when the sum of paint values exceed 320%, it is considered to be a satured color,
+                which means the paper can get too wet due to an excessive ammount of ink. This may lead to several issues
+                such as misalignment and poor quality of printing in general.*/
+            if ( ink_sum > 3.2 )
+                gtk_widget_set_sensitive (_box_toomuchink, true);
+        } else {
+            gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
+        }
+    }
+#endif //ENABLE_LCMS
+
     if ( !_updatingrgba )
     {
         gchar s[32];
diff --git a/src/widgets/sp-color-notebook.h b/src/widgets/sp-color-notebook.h
index bf6fb1002..5eb29ac73 100644
--- a/src/widgets/sp-color-notebook.h
+++ b/src/widgets/sp-color-notebook.h
@@ -61,6 +61,9 @@ protected:
     gulong _entryId;
     GtkWidget *_book;
     GtkWidget *_rgbal, *_rgbae; /* RGBA entry */
+#if ENABLE_LCMS
+    GtkWidget *_box_outofgamut, *_box_colormanaged, *_box_toomuchink;
+#endif //ENABLE_LCMS
     GtkWidget *_p; /* Color preview */
     GtkWidget *_btn;
     GtkWidget *_popup;
diff --git a/src/widgets/sp-color-scales.cpp b/src/widgets/sp-color-scales.cpp
index cf06247e7..e41b81e5c 100644
--- a/src/widgets/sp-color-scales.cpp
+++ b/src/widgets/sp-color-scales.cpp
@@ -10,6 +10,8 @@
 #include <glibmm/i18n.h>
 #include "../dialogs/dialog-events.h"
 #include "sp-color-scales.h"
+#include "svg/svg-icc-color.h"
+#include "svg/svg-device-color.h"
 
 #define CSC_CHANNEL_R (1 << 0)
 #define CSC_CHANNEL_G (1 << 1)
@@ -230,6 +232,12 @@ void ColorScales::_recalcColor( gboolean changing )
         case SP_COLOR_SCALES_MODE_CMYK:
         {
             _getCmykaFloatv( c );
+            color.device = new SVGDeviceColor();
+            color.device->type=DEVICE_CMYK;
+            color.device->colors.clear();
+            for (int i=0;i<4;i++){
+              color.device->colors.push_back(c[i]);
+            }
 
             float rgb[3];
             sp_color_cmyk_to_rgb_floatv( rgb, c[0], c[1], c[2], c[3] );
@@ -241,6 +249,10 @@ void ColorScales::_recalcColor( gboolean changing )
             g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode);
             break;
         }
+
+        /* Preserve ICC */
+        color.icc = _color.icc ? new SVGICCColor(*_color.icc) : 0;
+
         _updateInternals( color, alpha, _dragging );
     }
     else
@@ -470,11 +482,20 @@ void ColorScales::setMode(SPColorScalesMode mode)
 		gtk_widget_show (_s[4]);
 		gtk_widget_show (_b[4]);
 		_updating = TRUE;
-		sp_color_rgb_to_cmyk_floatv (c, rgba[0], rgba[1], rgba[2]);
-		setScaled( _a[0], c[0] );
-		setScaled( _a[1], c[1] );
-		setScaled( _a[2], c[2] );
-		setScaled( _a[3], c[3] );
+
+    if (_color.device && _color.device->type == DEVICE_CMYK){
+		  setScaled( _a[0], _color.device->colors[0] );
+		  setScaled( _a[1], _color.device->colors[1] );
+		  setScaled( _a[2], _color.device->colors[2] );
+		  setScaled( _a[3], _color.device->colors[3] );
+    } else {
+      //If we still dont have a device-color, convert from rbga
+		  sp_color_rgb_to_cmyk_floatv (c, rgba[0], rgba[1], rgba[2]);
+		  setScaled( _a[0], c[0] );
+		  setScaled( _a[1], c[1] );
+		  setScaled( _a[2], c[2] );
+		  setScaled( _a[3], c[3] );
+    }
 		setScaled( _a[4], rgba[3] );
 		_updating = FALSE;
 		_updateSliders( CSC_CHANNELS_ALL );
diff --git a/src/widgets/sp-color-wheel-selector.cpp b/src/widgets/sp-color-wheel-selector.cpp
index 174b071f9..6012f4e20 100644
--- a/src/widgets/sp-color-wheel-selector.cpp
+++ b/src/widgets/sp-color-wheel-selector.cpp
@@ -10,7 +10,8 @@
 #include "../dialogs/dialog-events.h"
 #include "sp-color-wheel-selector.h"
 #include "sp-color-scales.h"
-
+#include "sp-color-icc-selector.h"
+#include "../svg/svg-icc-color.h"
 
 G_BEGIN_DECLS
 
@@ -205,6 +206,11 @@ sp_color_wheel_selector_new (void)
 
 /* Helpers for setting color value */
 
+static void preserve_icc(SPColor *color, SPColorWheelSelector *cs){
+    ColorSelector* selector = (ColorSelector*)(SP_COLOR_SELECTOR(cs)->base);
+    color->icc = selector->getColor().icc ? new SVGICCColor(*selector->getColor().icc) : 0;
+}
+
 void ColorWheelSelector::_colorChanged()
 {
 #ifdef DUMP_CHANGE_INFO
@@ -237,6 +243,7 @@ void ColorWheelSelector::_adjustmentChanged( GtkAdjustment *adjustment, SPColorW
 
     wheelSelector->_updating = TRUE;
 
+    preserve_icc(&wheelSelector->_color, cs);
     wheelSelector->_updateInternals( wheelSelector->_color, ColorScales::getScaled( wheelSelector->_adj ), wheelSelector->_dragging );
 
     wheelSelector->_updating = FALSE;
@@ -249,6 +256,8 @@ void ColorWheelSelector::_sliderGrabbed( SPColorSlider *slider, SPColorWheelSele
     if (!wheelSelector->_dragging) {
         wheelSelector->_dragging = TRUE;
         wheelSelector->_grabbed();
+
+        preserve_icc(&wheelSelector->_color, cs);
         wheelSelector->_updateInternals( wheelSelector->_color, ColorScales::getScaled( wheelSelector->_adj ), wheelSelector->_dragging );
     }
 }
@@ -260,6 +269,8 @@ void ColorWheelSelector::_sliderReleased( SPColorSlider *slider, SPColorWheelSel
     if (wheelSelector->_dragging) {
         wheelSelector->_dragging = FALSE;
         wheelSelector->_released();
+
+        preserve_icc(&wheelSelector->_color, cs);
         wheelSelector->_updateInternals( wheelSelector->_color, ColorScales::getScaled( wheelSelector->_adj ), wheelSelector->_dragging );
     }
 }
@@ -269,6 +280,7 @@ void ColorWheelSelector::_sliderChanged( SPColorSlider *slider, SPColorWheelSele
     (void)slider;
     ColorWheelSelector* wheelSelector = (ColorWheelSelector*)(SP_COLOR_SELECTOR(cs)->base);
 
+    preserve_icc(&wheelSelector->_color, cs);
     wheelSelector->_updateInternals( wheelSelector->_color, ColorScales::getScaled( wheelSelector->_adj ), wheelSelector->_dragging );
 }
 
@@ -285,6 +297,7 @@ void ColorWheelSelector::_wheelChanged( SPColorWheel *wheel, SPColorWheelSelecto
 
     sp_color_slider_set_colors (SP_COLOR_SLIDER(wheelSelector->_slider), start, mid, end);
 
+    preserve_icc(&color, cs);
     wheelSelector->_updateInternals( color, wheelSelector->_alpha, sp_color_wheel_is_adjusting( wheel ) );
 }
 
diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
index b10c60c79..02cd0b478 100644
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
@@ -926,11 +926,11 @@ sp_commands_toolbox_new()
 GtkWidget *
 sp_snap_toolbox_new()
 {
-	GtkWidget *tb = gtk_vbox_new(FALSE, 0);
-	gtk_box_set_spacing(GTK_BOX(tb), AUX_SPACING);
-	g_object_set_data(G_OBJECT(tb), "desktop", NULL);
+    GtkWidget *tb = gtk_vbox_new(FALSE, 0);
+    gtk_box_set_spacing(GTK_BOX(tb), AUX_SPACING);
+    g_object_set_data(G_OBJECT(tb), "desktop", NULL);
 
-	//GtkWidget *tb = gtk_toolbar_new();
+    //GtkWidget *tb = gtk_toolbar_new();
     //g_object_set_data(G_OBJECT(tb), "desktop", NULL);
 
     gtk_widget_set_sensitive(tb, FALSE);
@@ -1904,314 +1904,314 @@ update_commands_toolbox(SPDesktop */*desktop*/, SPEventContext */*eventcontext*/
 
 void toggle_snap_callback (GtkToggleAction *act, gpointer data) { //data points to the toolbox
 
-	if (g_object_get_data(G_OBJECT(data), "freeze" )) {
-		return;
-	}
-
-	gpointer ptr = g_object_get_data(G_OBJECT(data), "desktop");
-	g_assert(ptr != NULL);
-
-	SPDesktop *dt = reinterpret_cast<SPDesktop*>(ptr);
-	SPNamedView *nv = sp_desktop_namedview(dt);
-	SPDocument *doc = SP_OBJECT_DOCUMENT(nv);
-
-	if (dt == NULL || nv == NULL) {
-		g_warning("No desktop or namedview specified (in toggle_snap_callback)!");
-		return;
-	}
-
-	Inkscape::XML::Node *repr = SP_OBJECT_REPR(nv);
-
-	if (repr == NULL) {
-		g_warning("This namedview doesn't have a xml representation attached!");
-		return;
-	}
-
-	bool saved = sp_document_get_undo_sensitive(doc);
-	sp_document_set_undo_sensitive(doc, false);
-
-	bool v = false;
-	SPAttributeEnum attr = (SPAttributeEnum) GPOINTER_TO_INT(g_object_get_data(G_OBJECT(act), "SP_ATTR_INKSCAPE"));
-
-	switch (attr) {
-	case SP_ATTR_INKSCAPE_SNAP_GLOBAL:
-		dt->toggleSnapGlobal();
-		break;
-	case SP_ATTR_INKSCAPE_SNAP_BBOX:
-		v = nv->snap_manager.snapprefs.getSnapModeBBox();
-		sp_repr_set_boolean(repr, "inkscape:snap-bbox", !v);
-		break;
-	case SP_ATTR_INKSCAPE_BBOX_PATHS:
-		v = nv->snap_manager.snapprefs.getSnapToBBoxPath();
-		sp_repr_set_boolean(repr, "inkscape:bbox-paths", !v);
-		break;
-	case SP_ATTR_INKSCAPE_BBOX_NODES:
-		v = nv->snap_manager.snapprefs.getSnapToBBoxNode();
-		sp_repr_set_boolean(repr, "inkscape:bbox-nodes", !v);
-		break;
-	case SP_ATTR_INKSCAPE_SNAP_NODES:
-		v = nv->snap_manager.snapprefs.getSnapModeNode();
-		sp_repr_set_boolean(repr, "inkscape:snap-nodes", !v);
-		break;
-	case SP_ATTR_INKSCAPE_OBJECT_PATHS:
-		v = nv->snap_manager.snapprefs.getSnapToItemPath();
-		sp_repr_set_boolean(repr, "inkscape:object-paths", !v);
-		break;
-	case SP_ATTR_INKSCAPE_OBJECT_NODES:
-		v = nv->snap_manager.snapprefs.getSnapToItemNode();
-		sp_repr_set_boolean(repr, "inkscape:object-nodes", !v);
-		break;
-	case SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES:
-		v = nv->snap_manager.snapprefs.getSnapSmoothNodes();
-		sp_repr_set_boolean(repr, "inkscape:snap-smooth-nodes", !v);
-		break;
-	case SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS:
-		v = nv->snap_manager.snapprefs.getSnapIntersectionCS();
-		sp_repr_set_boolean(repr, "inkscape:snap-intersection-paths", !v);
-		break;
-	case SP_ATTR_INKSCAPE_SNAP_CENTER:
-		v = nv->snap_manager.snapprefs.getIncludeItemCenter();
-		sp_repr_set_boolean(repr, "inkscape:snap-center", !v);
-		break;
-	case SP_ATTR_INKSCAPE_SNAP_GRIDS:
-		v = nv->snap_manager.snapprefs.getSnapToGrids();
-		sp_repr_set_boolean(repr, "inkscape:snap-grids", !v);
-		break;
-	case SP_ATTR_INKSCAPE_SNAP_TO_GUIDES:
-		v = nv->snap_manager.snapprefs.getSnapToGuides();
-		sp_repr_set_boolean(repr, "inkscape:snap-to-guides", !v);
-		break;
-	case SP_ATTR_INKSCAPE_SNAP_PAGE:
-		v = nv->snap_manager.snapprefs.getSnapToPageBorder();
-		sp_repr_set_boolean(repr, "inkscape:snap-page", !v);
-		break;
-	/*case SP_ATTR_INKSCAPE_SNAP_INTERS_GRIDGUIDE:
-		v = nv->snap_manager.snapprefs.getSnapIntersectionGG();
-		sp_repr_set_boolean(repr, "inkscape:snap-intersection-grid-guide", !v);
-		break;*/
-	case SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS:
-		v = nv->snap_manager.snapprefs.getSnapLineMidpoints();
-		sp_repr_set_boolean(repr, "inkscape:snap-midpoints", !v);
-		break;
-	case SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS:
-		v = nv->snap_manager.snapprefs.getSnapObjectMidpoints();
-		sp_repr_set_boolean(repr, "inkscape:snap-object-midpoints", !v);
-		break;
-	case SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS:
-		v = nv->snap_manager.snapprefs.getSnapBBoxEdgeMidpoints();
-		sp_repr_set_boolean(repr, "inkscape:snap-bbox-edge-midpoints", !v);
-		break;
-	case SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS:
-		v = nv->snap_manager.snapprefs.getSnapBBoxMidpoints();
-		sp_repr_set_boolean(repr, "inkscape:snap-bbox-midpoints", !v);
-		break;
-	default:
-		g_warning("toggle_snap_callback has been called with an ID for which no action has been defined");
-		break;
-	}
-
-	// The snapping preferences are stored in the document, and therefore toggling makes the document dirty
-	doc->setModifiedSinceSave();
-
-	sp_document_set_undo_sensitive(doc, saved);
+    if (g_object_get_data(G_OBJECT(data), "freeze" )) {
+        return;
+    }
+
+    gpointer ptr = g_object_get_data(G_OBJECT(data), "desktop");
+    g_assert(ptr != NULL);
+
+    SPDesktop *dt = reinterpret_cast<SPDesktop*>(ptr);
+    SPNamedView *nv = sp_desktop_namedview(dt);
+    SPDocument *doc = SP_OBJECT_DOCUMENT(nv);
+
+    if (dt == NULL || nv == NULL) {
+        g_warning("No desktop or namedview specified (in toggle_snap_callback)!");
+        return;
+    }
+
+    Inkscape::XML::Node *repr = SP_OBJECT_REPR(nv);
+
+    if (repr == NULL) {
+        g_warning("This namedview doesn't have a xml representation attached!");
+        return;
+    }
+
+    bool saved = sp_document_get_undo_sensitive(doc);
+    sp_document_set_undo_sensitive(doc, false);
+
+    bool v = false;
+    SPAttributeEnum attr = (SPAttributeEnum) GPOINTER_TO_INT(g_object_get_data(G_OBJECT(act), "SP_ATTR_INKSCAPE"));
+
+    switch (attr) {
+        case SP_ATTR_INKSCAPE_SNAP_GLOBAL:
+            dt->toggleSnapGlobal();
+            break;
+        case SP_ATTR_INKSCAPE_SNAP_BBOX:
+            v = nv->snap_manager.snapprefs.getSnapModeBBox();
+            sp_repr_set_boolean(repr, "inkscape:snap-bbox", !v);
+            break;
+        case SP_ATTR_INKSCAPE_BBOX_PATHS:
+            v = nv->snap_manager.snapprefs.getSnapToBBoxPath();
+            sp_repr_set_boolean(repr, "inkscape:bbox-paths", !v);
+            break;
+        case SP_ATTR_INKSCAPE_BBOX_NODES:
+            v = nv->snap_manager.snapprefs.getSnapToBBoxNode();
+            sp_repr_set_boolean(repr, "inkscape:bbox-nodes", !v);
+            break;
+        case SP_ATTR_INKSCAPE_SNAP_NODES:
+            v = nv->snap_manager.snapprefs.getSnapModeNode();
+            sp_repr_set_boolean(repr, "inkscape:snap-nodes", !v);
+            break;
+        case SP_ATTR_INKSCAPE_OBJECT_PATHS:
+            v = nv->snap_manager.snapprefs.getSnapToItemPath();
+            sp_repr_set_boolean(repr, "inkscape:object-paths", !v);
+            break;
+        case SP_ATTR_INKSCAPE_OBJECT_NODES:
+            v = nv->snap_manager.snapprefs.getSnapToItemNode();
+            sp_repr_set_boolean(repr, "inkscape:object-nodes", !v);
+            break;
+        case SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES:
+            v = nv->snap_manager.snapprefs.getSnapSmoothNodes();
+            sp_repr_set_boolean(repr, "inkscape:snap-smooth-nodes", !v);
+            break;
+        case SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS:
+            v = nv->snap_manager.snapprefs.getSnapIntersectionCS();
+            sp_repr_set_boolean(repr, "inkscape:snap-intersection-paths", !v);
+            break;
+        case SP_ATTR_INKSCAPE_SNAP_CENTER:
+            v = nv->snap_manager.snapprefs.getIncludeItemCenter();
+            sp_repr_set_boolean(repr, "inkscape:snap-center", !v);
+            break;
+        case SP_ATTR_INKSCAPE_SNAP_GRIDS:
+            v = nv->snap_manager.snapprefs.getSnapToGrids();
+            sp_repr_set_boolean(repr, "inkscape:snap-grids", !v);
+            break;
+        case SP_ATTR_INKSCAPE_SNAP_TO_GUIDES:
+            v = nv->snap_manager.snapprefs.getSnapToGuides();
+            sp_repr_set_boolean(repr, "inkscape:snap-to-guides", !v);
+            break;
+        case SP_ATTR_INKSCAPE_SNAP_PAGE:
+            v = nv->snap_manager.snapprefs.getSnapToPageBorder();
+            sp_repr_set_boolean(repr, "inkscape:snap-page", !v);
+            break;
+            /*case SP_ATTR_INKSCAPE_SNAP_INTERS_GRIDGUIDE:
+              v = nv->snap_manager.snapprefs.getSnapIntersectionGG();
+              sp_repr_set_boolean(repr, "inkscape:snap-intersection-grid-guide", !v);
+              break;*/
+        case SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS:
+            v = nv->snap_manager.snapprefs.getSnapLineMidpoints();
+            sp_repr_set_boolean(repr, "inkscape:snap-midpoints", !v);
+            break;
+        case SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS:
+            v = nv->snap_manager.snapprefs.getSnapObjectMidpoints();
+            sp_repr_set_boolean(repr, "inkscape:snap-object-midpoints", !v);
+            break;
+        case SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS:
+            v = nv->snap_manager.snapprefs.getSnapBBoxEdgeMidpoints();
+            sp_repr_set_boolean(repr, "inkscape:snap-bbox-edge-midpoints", !v);
+            break;
+        case SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS:
+            v = nv->snap_manager.snapprefs.getSnapBBoxMidpoints();
+            sp_repr_set_boolean(repr, "inkscape:snap-bbox-midpoints", !v);
+            break;
+        default:
+            g_warning("toggle_snap_callback has been called with an ID for which no action has been defined");
+            break;
+    }
+
+    // The snapping preferences are stored in the document, and therefore toggling makes the document dirty
+    doc->setModifiedSinceSave();
+
+    sp_document_set_undo_sensitive(doc, saved);
 }
 
 void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
 {
-	Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-	Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions(desktop);
-
-	gchar const * descr =
-	        "<ui>"
-	        "  <toolbar name='SnapToolbar'>"
-	        "    <toolitem action='ToggleSnapGlobal' />"
-			"    <separator />"
-			"    <toolitem action='ToggleSnapFromBBoxCorner' />"
-			"    <toolitem action='ToggleSnapToBBoxPath' />"
-			"    <toolitem action='ToggleSnapToBBoxNode' />"
-			"    <toolitem action='ToggleSnapToFromBBoxEdgeMidpoints' />"
-			"    <toolitem action='ToggleSnapToFromBBoxCenters' />"
-			"    <separator />"
-			"    <toolitem action='ToggleSnapFromNode' />"
-			"    <toolitem action='ToggleSnapToItemPath' />"
-			"    <toolitem action='ToggleSnapToPathIntersections' />"
-			"    <toolitem action='ToggleSnapToItemNode' />"
-			"    <toolitem action='ToggleSnapToSmoothNodes' />"
-			"    <toolitem action='ToggleSnapToFromLineMidpoints' />"
-			"    <toolitem action='ToggleSnapToFromObjectCenters' />"
-			"    <toolitem action='ToggleSnapToFromRotationCenter' />"
-			"    <separator />"
-			"    <toolitem action='ToggleSnapToPageBorder' />"
-			"    <toolitem action='ToggleSnapToGrids' />"
-			"    <toolitem action='ToggleSnapToGuides' />"
-		  //"    <toolitem action='ToggleSnapToGridGuideIntersections' />"
-			"  </toolbar>"
-	        "</ui>";
-
-	Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapGlobal",
-		    _("Snap"), _("Enable snapping"), INKSCAPE_ICON_SNAP, secondarySize,
-		    SP_ATTR_INKSCAPE_SNAP_GLOBAL);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapFromBBoxCorner",
-		    _("Bounding box"), _("Snap bounding box corners"), INKSCAPE_ICON_SNAP_BOUNDING_BOX,
-		    secondarySize, SP_ATTR_INKSCAPE_SNAP_BBOX);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxPath",
-		    _("Bounding box edges"), _("Snap to edges of a bounding box"),
-		    INKSCAPE_ICON_SNAP_BOUNDING_BOX_EDGES, secondarySize, SP_ATTR_INKSCAPE_BBOX_PATHS);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxNode",
-		    _("Bounding box corners"), _("Snap to bounding box corners"),
-		    INKSCAPE_ICON_SNAP_BOUNDING_BOX_CORNERS, secondarySize, SP_ATTR_INKSCAPE_BBOX_NODES);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromBBoxEdgeMidpoints",
-		    _("BBox Edge Midpoints"), _("Snap from and to midpoints of bounding box edges"),
-		    INKSCAPE_ICON_SNAP_BOUNDING_BOX_MIDPOINTS, secondarySize,
-		    SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromBBoxCenters",
-		    _("BBox Centers"), _("Snapping from and to centers of bounding boxes"),
-		    INKSCAPE_ICON_SNAP_BOUNDING_BOX_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapFromNode",
-		    _("Nodes"), _("Snap nodes or handles"), INKSCAPE_ICON_SNAP_NODES, secondarySize, SP_ATTR_INKSCAPE_SNAP_NODES);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemPath",
-		    _("Paths"), _("Snap to paths"), INKSCAPE_ICON_SNAP_NODES_PATH, secondarySize,
-		    SP_ATTR_INKSCAPE_OBJECT_PATHS);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPathIntersections",
-		    _("Path intersections"), _("Snap to path intersections"),
-		    INKSCAPE_ICON_SNAP_NODES_INTERSECTION, secondarySize, SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemNode",
-		    _("To nodes"), _("Snap to cusp nodes"), INKSCAPE_ICON_SNAP_NODES_CUSP, secondarySize,
-		    SP_ATTR_INKSCAPE_OBJECT_NODES);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToSmoothNodes",
-		    _("Smooth nodes"), _("Snap to smooth nodes"), INKSCAPE_ICON_SNAP_NODES_SMOOTH,
-		    secondarySize, SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromLineMidpoints",
-		    _("Line Midpoints"), _("Snap from and to midpoints of line segments"),
-		    INKSCAPE_ICON_SNAP_NODES_MIDPOINT, secondarySize, SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromObjectCenters",
-		    _("Object Centers"), _("Snap from and to centers of objects"),
-		    INKSCAPE_ICON_SNAP_NODES_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromRotationCenter",
-		    _("Rotation Centers"), _("Snap from and to an item's rotation center"),
-		    INKSCAPE_ICON_SNAP_NODES_ROTATION_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_CENTER);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPageBorder",
-		    _("Page border"), _("Snap to the page border"), INKSCAPE_ICON_SNAP_PAGE,
-		    secondarySize, SP_ATTR_INKSCAPE_SNAP_PAGE);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGrids",
-		    _("Grids"), _("Snap to grids"), INKSCAPE_ICON_GRID_RECTANGULAR, secondarySize,
-		    SP_ATTR_INKSCAPE_SNAP_GRIDS);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGuides",
-		    _("Guides"), _("Snap to guides"), INKSCAPE_ICON_GUIDES, secondarySize,
-		    SP_ATTR_INKSCAPE_SNAP_TO_GUIDES);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}
-
-	/*{
-		InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGridGuideIntersections",
-		    _("Grid/guide intersections"), _("Snap to intersections of a grid with a guide"),
-		    INKSCAPE_ICON_SNAP_GRID_GUIDE_INTERSECTIONS, secondarySize,
-		    SP_ATTR_INKSCAPE_SNAP_INTERS_GRIDGUIDE);
-
-		gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
-		g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
-	}*/
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions(desktop);
+
+    gchar const * descr =
+        "<ui>"
+        "  <toolbar name='SnapToolbar'>"
+        "    <toolitem action='ToggleSnapGlobal' />"
+        "    <separator />"
+        "    <toolitem action='ToggleSnapFromBBoxCorner' />"
+        "    <toolitem action='ToggleSnapToBBoxPath' />"
+        "    <toolitem action='ToggleSnapToBBoxNode' />"
+        "    <toolitem action='ToggleSnapToFromBBoxEdgeMidpoints' />"
+        "    <toolitem action='ToggleSnapToFromBBoxCenters' />"
+        "    <separator />"
+        "    <toolitem action='ToggleSnapFromNode' />"
+        "    <toolitem action='ToggleSnapToItemPath' />"
+        "    <toolitem action='ToggleSnapToPathIntersections' />"
+        "    <toolitem action='ToggleSnapToItemNode' />"
+        "    <toolitem action='ToggleSnapToSmoothNodes' />"
+        "    <toolitem action='ToggleSnapToFromLineMidpoints' />"
+        "    <toolitem action='ToggleSnapToFromObjectCenters' />"
+        "    <toolitem action='ToggleSnapToFromRotationCenter' />"
+        "    <separator />"
+        "    <toolitem action='ToggleSnapToPageBorder' />"
+        "    <toolitem action='ToggleSnapToGrids' />"
+        "    <toolitem action='ToggleSnapToGuides' />"
+        //"    <toolitem action='ToggleSnapToGridGuideIntersections' />"
+        "  </toolbar>"
+        "</ui>";
+
+    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapGlobal",
+                                                     _("Snap"), _("Enable snapping"), INKSCAPE_ICON_SNAP, secondarySize,
+                                                     SP_ATTR_INKSCAPE_SNAP_GLOBAL);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapFromBBoxCorner",
+                                                     _("Bounding box"), _("Snap bounding box corners"), INKSCAPE_ICON_SNAP_BOUNDING_BOX,
+                                                     secondarySize, SP_ATTR_INKSCAPE_SNAP_BBOX);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxPath",
+                                                     _("Bounding box edges"), _("Snap to edges of a bounding box"),
+                                                     INKSCAPE_ICON_SNAP_BOUNDING_BOX_EDGES, secondarySize, SP_ATTR_INKSCAPE_BBOX_PATHS);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxNode",
+                                                     _("Bounding box corners"), _("Snap to bounding box corners"),
+                                                     INKSCAPE_ICON_SNAP_BOUNDING_BOX_CORNERS, secondarySize, SP_ATTR_INKSCAPE_BBOX_NODES);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromBBoxEdgeMidpoints",
+                                                     _("BBox Edge Midpoints"), _("Snap from and to midpoints of bounding box edges"),
+                                                     INKSCAPE_ICON_SNAP_BOUNDING_BOX_MIDPOINTS, secondarySize,
+                                                     SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromBBoxCenters",
+                                                     _("BBox Centers"), _("Snapping from and to centers of bounding boxes"),
+                                                     INKSCAPE_ICON_SNAP_BOUNDING_BOX_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapFromNode",
+                                                     _("Nodes"), _("Snap nodes or handles"), INKSCAPE_ICON_SNAP_NODES, secondarySize, SP_ATTR_INKSCAPE_SNAP_NODES);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemPath",
+                                                     _("Paths"), _("Snap to paths"), INKSCAPE_ICON_SNAP_NODES_PATH, secondarySize,
+                                                     SP_ATTR_INKSCAPE_OBJECT_PATHS);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPathIntersections",
+                                                     _("Path intersections"), _("Snap to path intersections"),
+                                                     INKSCAPE_ICON_SNAP_NODES_INTERSECTION, secondarySize, SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemNode",
+                                                     _("To nodes"), _("Snap to cusp nodes"), INKSCAPE_ICON_SNAP_NODES_CUSP, secondarySize,
+                                                     SP_ATTR_INKSCAPE_OBJECT_NODES);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToSmoothNodes",
+                                                     _("Smooth nodes"), _("Snap to smooth nodes"), INKSCAPE_ICON_SNAP_NODES_SMOOTH,
+                                                     secondarySize, SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromLineMidpoints",
+                                                     _("Line Midpoints"), _("Snap from and to midpoints of line segments"),
+                                                     INKSCAPE_ICON_SNAP_NODES_MIDPOINT, secondarySize, SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromObjectCenters",
+                                                     _("Object Centers"), _("Snap from and to centers of objects"),
+                                                     INKSCAPE_ICON_SNAP_NODES_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromRotationCenter",
+                                                     _("Rotation Centers"), _("Snap from and to an item's rotation center"),
+                                                     INKSCAPE_ICON_SNAP_NODES_ROTATION_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_CENTER);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPageBorder",
+                                                     _("Page border"), _("Snap to the page border"), INKSCAPE_ICON_SNAP_PAGE,
+                                                     secondarySize, SP_ATTR_INKSCAPE_SNAP_PAGE);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGrids",
+                                                     _("Grids"), _("Snap to grids"), INKSCAPE_ICON_GRID_RECTANGULAR, secondarySize,
+                                                     SP_ATTR_INKSCAPE_SNAP_GRIDS);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    {
+        InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGuides",
+                                                     _("Guides"), _("Snap to guides"), INKSCAPE_ICON_GUIDES, secondarySize,
+                                                     SP_ATTR_INKSCAPE_SNAP_TO_GUIDES);
+
+        gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+    }
+
+    /*{
+      InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGridGuideIntersections",
+      _("Grid/guide intersections"), _("Snap to intersections of a grid with a guide"),
+      INKSCAPE_ICON_SNAP_GRID_GUIDE_INTERSECTIONS, secondarySize,
+      SP_ATTR_INKSCAPE_SNAP_INTERS_GRIDGUIDE);
+
+      gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
+      g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
+      }*/
 
     GtkUIManager* mgr = gtk_ui_manager_new();
     GError* errVal = 0;
@@ -2243,94 +2243,94 @@ void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
 
 void update_snap_toolbox(SPDesktop *desktop, SPEventContext */*eventcontext*/, GtkWidget *toolbox)
 {
-	g_assert(desktop != NULL);
-	g_assert(toolbox != NULL);
-
-	SPNamedView *nv = sp_desktop_namedview(desktop);
-	if (nv == NULL) {
-		g_warning("Namedview cannot be retrieved (in update_snap_toolbox)!");
-		return;
-	}
-
-	Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions(desktop);
-
-	Glib::RefPtr<Gtk::Action> act1 = mainActions->get_action("ToggleSnapGlobal");
-	Glib::RefPtr<Gtk::Action> act2 = mainActions->get_action("ToggleSnapFromBBoxCorner");
-	Glib::RefPtr<Gtk::Action> act3 = mainActions->get_action("ToggleSnapToBBoxPath");
-	Glib::RefPtr<Gtk::Action> act4 = mainActions->get_action("ToggleSnapToBBoxNode");
-	Glib::RefPtr<Gtk::Action> act4b = mainActions->get_action("ToggleSnapToFromBBoxEdgeMidpoints");
-	Glib::RefPtr<Gtk::Action> act4c = mainActions->get_action("ToggleSnapToFromBBoxCenters");
-	Glib::RefPtr<Gtk::Action> act5 = mainActions->get_action("ToggleSnapFromNode");
-	Glib::RefPtr<Gtk::Action> act6 = mainActions->get_action("ToggleSnapToItemPath");
-	Glib::RefPtr<Gtk::Action> act6b = mainActions->get_action("ToggleSnapToPathIntersections");
-	Glib::RefPtr<Gtk::Action> act7 = mainActions->get_action("ToggleSnapToItemNode");
-	Glib::RefPtr<Gtk::Action> act8 = mainActions->get_action("ToggleSnapToSmoothNodes");
-	Glib::RefPtr<Gtk::Action> act9 = mainActions->get_action("ToggleSnapToFromLineMidpoints");
-	Glib::RefPtr<Gtk::Action> act10 = mainActions->get_action("ToggleSnapToFromObjectCenters");
-	Glib::RefPtr<Gtk::Action> act11 = mainActions->get_action("ToggleSnapToFromRotationCenter");
-	Glib::RefPtr<Gtk::Action> act12 = mainActions->get_action("ToggleSnapToPageBorder");
-	//Glib::RefPtr<Gtk::Action> act13 = mainActions->get_action("ToggleSnapToGridGuideIntersections");
-	Glib::RefPtr<Gtk::Action> act14 = mainActions->get_action("ToggleSnapToGrids");
-	Glib::RefPtr<Gtk::Action> act15 = mainActions->get_action("ToggleSnapToGuides");
-
-
-	if (!act1) {
-		return; // The snap actions haven't been defined yet (might be the case during startup)
-	}
-
-	// The ..._set_active calls below will toggle the buttons, but this shouldn't lead to
-	// changes in our document because we're only updating the UI;
-	// Setting the "freeze" parameter to true will block the code in toggle_snap_callback()
-	g_object_set_data(G_OBJECT(toolbox), "freeze", GINT_TO_POINTER(TRUE));
-
-	bool const c1 = nv->snap_manager.snapprefs.getSnapEnabledGlobally();
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act1->gobj()), c1);
-
-	bool const c2 = nv->snap_manager.snapprefs.getSnapModeBBox();
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act2->gobj()), c2);
-	gtk_action_set_sensitive(GTK_ACTION(act2->gobj()), c1);
-
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act3->gobj()), nv->snap_manager.snapprefs.getSnapToBBoxPath());
-	gtk_action_set_sensitive(GTK_ACTION(act3->gobj()), c1 && c2);
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4->gobj()), nv->snap_manager.snapprefs.getSnapToBBoxNode());
-	gtk_action_set_sensitive(GTK_ACTION(act4->gobj()), c1 && c2);
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4b->gobj()), nv->snap_manager.snapprefs.getSnapBBoxEdgeMidpoints());
-	gtk_action_set_sensitive(GTK_ACTION(act4b->gobj()), c1 && c2);
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4c->gobj()), nv->snap_manager.snapprefs.getSnapBBoxMidpoints());
-	gtk_action_set_sensitive(GTK_ACTION(act4c->gobj()), c1 && c2);
-
-	bool const c3 = nv->snap_manager.snapprefs.getSnapModeNode();
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act5->gobj()), c3);
-	gtk_action_set_sensitive(GTK_ACTION(act5->gobj()), c1);
-
-	bool const c4 = nv->snap_manager.snapprefs.getSnapToItemPath();
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act6->gobj()), c4);
-	gtk_action_set_sensitive(GTK_ACTION(act6->gobj()), c1 && c3);
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act6b->gobj()), nv->snap_manager.snapprefs.getSnapIntersectionCS());
-	gtk_action_set_sensitive(GTK_ACTION(act6b->gobj()), c1 && c3 && c4);
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act7->gobj()), nv->snap_manager.snapprefs.getSnapToItemNode());
-	gtk_action_set_sensitive(GTK_ACTION(act7->gobj()), c1 && c3);
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act8->gobj()), nv->snap_manager.snapprefs.getSnapSmoothNodes());
-	gtk_action_set_sensitive(GTK_ACTION(act8->gobj()), c1 && c3);
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act9->gobj()), nv->snap_manager.snapprefs.getSnapLineMidpoints());
-	gtk_action_set_sensitive(GTK_ACTION(act9->gobj()), c1 && c3);
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act10->gobj()), nv->snap_manager.snapprefs.getSnapObjectMidpoints());
-	gtk_action_set_sensitive(GTK_ACTION(act10->gobj()), c1 && c3);
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act11->gobj()), nv->snap_manager.snapprefs.getIncludeItemCenter());
-	gtk_action_set_sensitive(GTK_ACTION(act11->gobj()), c1 && c3);
-
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act12->gobj()), nv->snap_manager.snapprefs.getSnapToPageBorder());
-	gtk_action_set_sensitive(GTK_ACTION(act12->gobj()), c1);
-	//gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act13->gobj()), nv->snap_manager.snapprefs.getSnapIntersectionGG());
-	//gtk_action_set_sensitive(GTK_ACTION(act13->gobj()), c1);
-
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act14->gobj()), nv->snap_manager.snapprefs.getSnapToGrids());
-	gtk_action_set_sensitive(GTK_ACTION(act14->gobj()), c1);
-	gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act15->gobj()), nv->snap_manager.snapprefs.getSnapToGuides());
-	gtk_action_set_sensitive(GTK_ACTION(act15->gobj()), c1);
-
-
-	g_object_set_data(G_OBJECT(toolbox), "freeze", GINT_TO_POINTER(FALSE)); // unfreeze (see above)
+    g_assert(desktop != NULL);
+    g_assert(toolbox != NULL);
+
+    SPNamedView *nv = sp_desktop_namedview(desktop);
+    if (nv == NULL) {
+        g_warning("Namedview cannot be retrieved (in update_snap_toolbox)!");
+        return;
+    }
+
+    Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions(desktop);
+
+    Glib::RefPtr<Gtk::Action> act1 = mainActions->get_action("ToggleSnapGlobal");
+    Glib::RefPtr<Gtk::Action> act2 = mainActions->get_action("ToggleSnapFromBBoxCorner");
+    Glib::RefPtr<Gtk::Action> act3 = mainActions->get_action("ToggleSnapToBBoxPath");
+    Glib::RefPtr<Gtk::Action> act4 = mainActions->get_action("ToggleSnapToBBoxNode");
+    Glib::RefPtr<Gtk::Action> act4b = mainActions->get_action("ToggleSnapToFromBBoxEdgeMidpoints");
+    Glib::RefPtr<Gtk::Action> act4c = mainActions->get_action("ToggleSnapToFromBBoxCenters");
+    Glib::RefPtr<Gtk::Action> act5 = mainActions->get_action("ToggleSnapFromNode");
+    Glib::RefPtr<Gtk::Action> act6 = mainActions->get_action("ToggleSnapToItemPath");
+    Glib::RefPtr<Gtk::Action> act6b = mainActions->get_action("ToggleSnapToPathIntersections");
+    Glib::RefPtr<Gtk::Action> act7 = mainActions->get_action("ToggleSnapToItemNode");
+    Glib::RefPtr<Gtk::Action> act8 = mainActions->get_action("ToggleSnapToSmoothNodes");
+    Glib::RefPtr<Gtk::Action> act9 = mainActions->get_action("ToggleSnapToFromLineMidpoints");
+    Glib::RefPtr<Gtk::Action> act10 = mainActions->get_action("ToggleSnapToFromObjectCenters");
+    Glib::RefPtr<Gtk::Action> act11 = mainActions->get_action("ToggleSnapToFromRotationCenter");
+    Glib::RefPtr<Gtk::Action> act12 = mainActions->get_action("ToggleSnapToPageBorder");
+    //Glib::RefPtr<Gtk::Action> act13 = mainActions->get_action("ToggleSnapToGridGuideIntersections");
+    Glib::RefPtr<Gtk::Action> act14 = mainActions->get_action("ToggleSnapToGrids");
+    Glib::RefPtr<Gtk::Action> act15 = mainActions->get_action("ToggleSnapToGuides");
+
+
+    if (!act1) {
+        return; // The snap actions haven't been defined yet (might be the case during startup)
+    }
+
+    // The ..._set_active calls below will toggle the buttons, but this shouldn't lead to
+    // changes in our document because we're only updating the UI;
+    // Setting the "freeze" parameter to true will block the code in toggle_snap_callback()
+    g_object_set_data(G_OBJECT(toolbox), "freeze", GINT_TO_POINTER(TRUE));
+
+    bool const c1 = nv->snap_manager.snapprefs.getSnapEnabledGlobally();
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act1->gobj()), c1);
+
+    bool const c2 = nv->snap_manager.snapprefs.getSnapModeBBox();
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act2->gobj()), c2);
+    gtk_action_set_sensitive(GTK_ACTION(act2->gobj()), c1);
+
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act3->gobj()), nv->snap_manager.snapprefs.getSnapToBBoxPath());
+    gtk_action_set_sensitive(GTK_ACTION(act3->gobj()), c1 && c2);
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4->gobj()), nv->snap_manager.snapprefs.getSnapToBBoxNode());
+    gtk_action_set_sensitive(GTK_ACTION(act4->gobj()), c1 && c2);
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4b->gobj()), nv->snap_manager.snapprefs.getSnapBBoxEdgeMidpoints());
+    gtk_action_set_sensitive(GTK_ACTION(act4b->gobj()), c1 && c2);
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4c->gobj()), nv->snap_manager.snapprefs.getSnapBBoxMidpoints());
+    gtk_action_set_sensitive(GTK_ACTION(act4c->gobj()), c1 && c2);
+
+    bool const c3 = nv->snap_manager.snapprefs.getSnapModeNode();
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act5->gobj()), c3);
+    gtk_action_set_sensitive(GTK_ACTION(act5->gobj()), c1);
+
+    bool const c4 = nv->snap_manager.snapprefs.getSnapToItemPath();
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act6->gobj()), c4);
+    gtk_action_set_sensitive(GTK_ACTION(act6->gobj()), c1 && c3);
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act6b->gobj()), nv->snap_manager.snapprefs.getSnapIntersectionCS());
+    gtk_action_set_sensitive(GTK_ACTION(act6b->gobj()), c1 && c3 && c4);
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act7->gobj()), nv->snap_manager.snapprefs.getSnapToItemNode());
+    gtk_action_set_sensitive(GTK_ACTION(act7->gobj()), c1 && c3);
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act8->gobj()), nv->snap_manager.snapprefs.getSnapSmoothNodes());
+    gtk_action_set_sensitive(GTK_ACTION(act8->gobj()), c1 && c3);
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act9->gobj()), nv->snap_manager.snapprefs.getSnapLineMidpoints());
+    gtk_action_set_sensitive(GTK_ACTION(act9->gobj()), c1 && c3);
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act10->gobj()), nv->snap_manager.snapprefs.getSnapObjectMidpoints());
+    gtk_action_set_sensitive(GTK_ACTION(act10->gobj()), c1 && c3);
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act11->gobj()), nv->snap_manager.snapprefs.getIncludeItemCenter());
+    gtk_action_set_sensitive(GTK_ACTION(act11->gobj()), c1 && c3);
+
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act12->gobj()), nv->snap_manager.snapprefs.getSnapToPageBorder());
+    gtk_action_set_sensitive(GTK_ACTION(act12->gobj()), c1);
+    //gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act13->gobj()), nv->snap_manager.snapprefs.getSnapIntersectionGG());
+    //gtk_action_set_sensitive(GTK_ACTION(act13->gobj()), c1);
+
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act14->gobj()), nv->snap_manager.snapprefs.getSnapToGrids());
+    gtk_action_set_sensitive(GTK_ACTION(act14->gobj()), c1);
+    gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act15->gobj()), nv->snap_manager.snapprefs.getSnapToGuides());
+    gtk_action_set_sensitive(GTK_ACTION(act15->gobj()), c1);
+
+
+    g_object_set_data(G_OBJECT(toolbox), "freeze", GINT_TO_POINTER(FALSE)); // unfreeze (see above)
 }
 
 void show_aux_toolbox(GtkWidget *toolbox_toplevel)
@@ -2412,8 +2412,8 @@ static void sp_stb_proportion_value_changed( GtkAdjustment *adj, GObject *dataKl
 
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
         if (!IS_NAN(adj->value)) {
-			Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-			prefs->setDouble("/tools/shapes/star/proportion", adj->value);
+            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+            prefs->setDouble("/tools/shapes/star/proportion", adj->value);
         }
     }
 
@@ -3226,7 +3226,7 @@ box3d_set_button_and_adjustment(Persp3D *persp, Proj::Axis axis,
     // TODO: Take all selected perspectives into account but don't touch the state button if not all of them
     //       have the same state (otherwise a call to box3d_vp_z_state_changed() is triggered and the states
     //       are reset).
-    bool is_infinite = !persp3d_VP_is_finite(persp, axis);
+    bool is_infinite = !persp3d_VP_is_finite(persp->perspective_impl, axis);
 
     if (is_infinite) {
         gtk_toggle_action_set_active(tact, TRUE);
@@ -3254,6 +3254,10 @@ box3d_resync_toolbar(Inkscape::XML::Node *persp_repr, GObject *data) {
     GtkAction *act = 0;
     GtkToggleAction *tact = 0;
     Persp3D *persp = persp3d_get_from_repr(persp_repr);
+    if (!persp) {
+        // Hmm, is it an error if this happens?
+        return;
+    }
     {
         adj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "box3d_angle_x"));
         act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_x_action"));
@@ -3340,7 +3344,7 @@ box3d_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
             sp_repr_synthesize_events(persp_repr, &box3d_persp_tb_repr_events, tbl);
         }
 
-        inkscape_active_document()->current_persp3d = persp3d_get_from_repr(persp_repr);
+        inkscape_active_document()->setCurrentPersp3D(persp3d_get_from_repr(persp_repr));
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         prefs->setString("/tools/shapes/3dbox/persp", persp_repr->attribute("id"));
 
@@ -3364,7 +3368,6 @@ box3d_angle_value_changed(GtkAdjustment *adj, GObject *dataKludge, Proj::Axis ax
     // in turn, prevent listener from responding
     g_object_set_data(dataKludge, "freeze", GINT_TO_POINTER(TRUE));
 
-    //Persp3D *persp = document->current_persp3d;
     std::list<Persp3D *> sel_persps = sp_desktop_selection(desktop)->perspList();
     if (sel_persps.empty()) {
         // this can happen when the document is created; we silently ignore it
@@ -3372,7 +3375,7 @@ box3d_angle_value_changed(GtkAdjustment *adj, GObject *dataKludge, Proj::Axis ax
     }
     Persp3D *persp = sel_persps.front();
 
-    persp->tmat.set_infinite_direction (axis, adj->value);
+    persp->perspective_impl->tmat.set_infinite_direction (axis, adj->value);
     SP_OBJECT(persp)->updateRepr();
 
     // TODO: use the correct axis here, too
@@ -3435,7 +3438,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     EgeAdjustmentAction* eact = 0;
     SPDocument *document = sp_desktop_document (desktop);
-    Persp3D *persp = document->current_persp3d;
+    Persp3DImpl *persp_impl = document->getCurrentPersp3DImpl();
 
     EgeAdjustmentAction* box3d_angle_x = 0;
     EgeAdjustmentAction* box3d_angle_y = 0;
@@ -3459,7 +3462,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         box3d_angle_x = eact;
     }
 
-    if (!persp3d_VP_is_finite(persp, Proj::X)) {
+    if (!persp3d_VP_is_finite(persp_impl, Proj::X)) {
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
     } else {
         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
@@ -3499,7 +3502,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         box3d_angle_y = eact;
     }
 
-    if (!persp3d_VP_is_finite(persp, Proj::Y)) {
+    if (!persp3d_VP_is_finite(persp_impl, Proj::Y)) {
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
     } else {
         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
@@ -3538,7 +3541,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         box3d_angle_z = eact;
     }
 
-    if (!persp3d_VP_is_finite(persp, Proj::Z)) {
+    if (!persp3d_VP_is_finite(persp_impl, Proj::Z)) {
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
     } else {
         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
@@ -3988,6 +3991,7 @@ sp_pencil_tb_tolerance_value_changed(GtkAdjustment *adj, GObject *tbl)
     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
 }
 
+/*
 class PencilToleranceObserver : public Inkscape::Preferences::Observer {
 public:
     PencilToleranceObserver(Glib::ustring const &path, GObject *x) : Observer(path), _obj(x)
@@ -3996,7 +4000,7 @@ public:
     }
     virtual ~PencilToleranceObserver() {
         if (g_object_get_data(_obj, "prefobserver") == this) {
-	        g_object_set_data(_obj, "prefobserver", NULL);
+            g_object_set_data(_obj, "prefobserver", NULL);
         }
     }
     virtual void notify(Inkscape::Preferences::Entry const &val) {
@@ -4015,7 +4019,7 @@ public:
 private:
     GObject *_obj;
 };
-
+*/
 
 static void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
@@ -4040,9 +4044,6 @@ static void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio
                                          1, 2);
         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
-
-        PencilToleranceObserver *obs =
-            new PencilToleranceObserver("/tools/freehand/pencil/tolerance", G_OBJECT(holder));
     }
 
     /* advanced shape options */
@@ -4408,11 +4409,13 @@ static void sp_spray_width_value_changed( GtkAdjustment *adj, GObject */*tbl*/ )
     prefs->setDouble( "/tools/spray/width", adj->value );
 }
 
-static void sp_spray_force_value_changed( GtkAdjustment *adj, GObject */*tbl*/ )
+/*
+static void sp_spray_force_value_changed( GtkAdjustment * / *adj* /, GObject * / *tbl* / )
 {
     //Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     //prefs->setDouble( "/tools/spray/force", adj->value * 0.01 );
 }
+*/
 
 static void sp_spray_mean_value_changed( GtkAdjustment *adj, GObject */*tbl*/ )
 {
@@ -4432,7 +4435,7 @@ static void sp_spray_pressure_state_changed( GtkToggleAction *act, gpointer /*da
     prefs->setBool("/tools/spray/usepressure", gtk_toggle_action_get_active(act));
 }
 
-static void sp_spray_mode_changed( EgeSelectOneAction *act, GObject *tbl )
+static void sp_spray_mode_changed( EgeSelectOneAction *act, GObject */*tbl*/ )
 {
     int mode = ege_select_one_action_get_active( act );
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
@@ -4469,15 +4472,15 @@ static void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
 
     {
         /* Width */
-        gchar const* labels[] = {_("(pinch spray)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad spray)")};
+        gchar const* labels[] = {_("(narrow spray)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad spray)")};
         gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
         EgeAdjustmentAction *eact = create_adjustment_action( "SprayWidthAction",
                                                               _("Width"), _("Width:"), _("The width of the spray area (relative to the visible canvas area)"),
                                                               "/tools/spray/width", 15,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-spray",
-                                                              1, 100, 1.0, 0.0,
+                                                              1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_spray_width_value_changed,  0.01, 0, 100 );
+                                                              sp_spray_width_value_changed,  1, 0 );
         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
@@ -4491,9 +4494,9 @@ static void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
                                                               _("Mean"), _("Mean:"), _("The mean of the spray action"),
                                                               "/tools/spray/mean", 20,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-mean",
-                                                              1, 100, 1.0, 0.0,
+                                                              1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_spray_mean_value_changed,  0.01, 0, 100 );
+                                                              sp_spray_mean_value_changed,  1, 0 );
         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
@@ -4507,9 +4510,9 @@ static void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
                                                               _("SD"), _("SD:"), _("The standard deviation of the spray action"),
                                                               "/tools/spray/standard_deviation", 20,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-standard_deviation",
-                                                              1, 100, 1.0, 0.0,
+                                                              1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_spray_standard_deviation_value_changed,  0.01, 0, 100 );
+                                                              sp_spray_standard_deviation_value_changed,  1, 0 );
         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
@@ -4561,7 +4564,7 @@ static void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
     }
 
     {   /* Population */
-        gchar const* labels[] = {_("(rough, simplified)"), 0, 0, _("(default)"), 0, 0, _("(fine, but many nodes)")};
+        gchar const* labels[] = {_("(low population)"), 0, 0, _("(default)"), 0, 0, _("(high population)")};
         gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
         EgeAdjustmentAction *eact = create_adjustment_action( "SprayPopulationAction",
                                                               _("Population"), _("Population:"),
@@ -4570,7 +4573,7 @@ static void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-population",
                                                               1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_spray_population_value_changed,  0.01, 0, 100 );
+                                                              sp_spray_population_value_changed,  1, 0 );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
         g_object_set_data( holder, "spray_population", eact );
@@ -4637,9 +4640,9 @@ static void update_presets_list (GObject *tbl)
                     }
                 }
             }
-	}
+        }
 
-	if (match) {
+        if (match) {
             // newly added item is at the same index as the
             // save command, so we need to change twice for it to take effect
             ege_select_one_action_set_active(sel, 0);
@@ -4768,7 +4771,7 @@ static void sp_dcc_build_presets_list(GObject *tbl)
     int ii=1;
 
     for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i) {
-    	GtkTreeIter iter;
+        GtkTreeIter iter;
         Glib::ustring preset_name = prefs->getString(*i + "/name");
         gtk_list_store_append( model, &iter );
         gtk_list_store_set( model, &iter, 0, _(preset_name.data()), 1, ii++, -1 );
@@ -4820,12 +4823,12 @@ static void sp_dcc_save_profile (GtkWidget */*widget*/, GObject *tbl)
 
     int temp_index = 0;
     for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i, ++temp_index) {
-    	Glib::ustring name = prefs->getString(*i + "/name");
-    	if (!name.empty() && profile_name == name) {
-    	    new_index = temp_index;
+        Glib::ustring name = prefs->getString(*i + "/name");
+        if (!name.empty() && profile_name == name) {
+            new_index = temp_index;
             save_path = *i;
             break;
-    	}
+        }
     }
 
     if (new_index == -1) {
@@ -4937,7 +4940,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-calligraphy",
                                                               1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
-                                                              sp_ddc_width_value_changed,  1, 0);
+                                                              sp_ddc_width_value_changed,  1, 0 );
         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
@@ -6063,9 +6066,9 @@ sp_text_toolbox_selection_changed (Inkscape::Selection */*selection*/, GObject *
     if (result_family == QUERY_STYLE_NOTHING || result_style == QUERY_STYLE_NOTHING || result_numbers == QUERY_STYLE_NOTHING) {
         // there are no texts in selection, read from prefs
 
-	    sp_style_read_from_prefs(query, "/tools/text");
+        sp_style_read_from_prefs(query, "/tools/text");
 
-	    if (g_object_get_data(tbl, "text_style_from_prefs")) {
+        if (g_object_get_data(tbl, "text_style_from_prefs")) {
             // do not reset the toolbar style from prefs if we already did it last time
             sp_style_unref(query);
             g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
@@ -6216,7 +6219,7 @@ sp_text_toolbox_selection_modified (Inkscape::Selection *selection, guint /*flag
 }
 
 void
-sp_text_toolbox_subselection_changed (gpointer /*dragger*/, GObject *tbl)
+sp_text_toolbox_subselection_changed (gpointer /*tc*/, GObject *tbl)
 {
     sp_text_toolbox_selection_changed (NULL, tbl);
 }
@@ -6342,8 +6345,85 @@ sp_text_toolbox_anchoring_toggled (GtkRadioButton   *button,
     int prop = GPOINTER_TO_INT(data);
 
     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-    SPCSSAttr *css = sp_repr_css_attr_new ();
 
+    // move the x of all texts to preserve the same bbox
+    Inkscape::Selection *selection = sp_desktop_selection(desktop);
+    for (GSList const *items = selection->itemList(); items != NULL; items = items->next) {
+        if (SP_IS_TEXT((SPItem *) items->data)) {
+            SPItem *item = SP_ITEM(items->data);
+
+            unsigned writing_mode = SP_OBJECT_STYLE(item)->writing_mode.value;
+            // below, variable names suggest horizontal move, but we check the writing direction
+            // and move in the corresponding axis
+            int axis;
+            if (writing_mode == SP_CSS_WRITING_MODE_LR_TB || writing_mode == SP_CSS_WRITING_MODE_RL_TB) {
+                axis = NR::X;
+            } else {
+                axis = NR::Y;
+            }
+
+            Geom::OptRect bbox
+                  = item->getBounds(Geom::identity(), SPItem::GEOMETRIC_BBOX);
+            if (!bbox)
+                continue;
+            double width = bbox->dimensions()[axis];
+            // If you want to align within some frame, other than the text's own bbox, calculate
+            // the left and right (or top and bottom for tb text) slacks of the text inside that
+            // frame (currently unused)
+            double left_slack = 0;
+            double right_slack = 0;
+            unsigned old_align = SP_OBJECT_STYLE(item)->text_align.value;
+            double move = 0;
+            if (old_align == SP_CSS_TEXT_ALIGN_START || old_align == SP_CSS_TEXT_ALIGN_LEFT) {
+                switch (prop) {
+                    case 0:
+                        move = -left_slack;
+                        break;
+                    case 1:
+                        move = width/2 + (right_slack - left_slack)/2;
+                        break;
+                    case 2:
+                        move = width + right_slack;
+                        break;
+                }
+            } else if (old_align == SP_CSS_TEXT_ALIGN_CENTER) {
+                switch (prop) {
+                    case 0:
+                        move = -width/2 - left_slack;
+                        break;
+                    case 1:
+                        move = (right_slack - left_slack)/2;
+                        break;
+                    case 2:
+                        move = width/2 + right_slack;
+                        break;
+                }
+            } else if (old_align == SP_CSS_TEXT_ALIGN_END || old_align == SP_CSS_TEXT_ALIGN_RIGHT) {
+                switch (prop) {
+                    case 0:
+                        move = -width - left_slack;
+                        break;
+                    case 1:
+                        move = -width/2 + (right_slack - left_slack)/2;
+                        break;
+                    case 2:
+                        move = right_slack;
+                        break;
+                }
+            }
+            Geom::Point XY = SP_TEXT(item)->attributes.firstXY();
+            if (axis == NR::X) {
+                XY = XY + Geom::Point (move, 0);
+            } else {
+                XY = XY + Geom::Point (0, move);
+            }
+            SP_TEXT(item)->attributes.setFirstXY(XY);
+            SP_OBJECT(item)->updateRepr();
+            SP_OBJECT(item)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+        }
+    }
+
+    SPCSSAttr *css = sp_repr_css_attr_new ();
     switch (prop)
     {
         case 0:
@@ -6382,8 +6462,8 @@ sp_text_toolbox_anchoring_toggled (GtkRadioButton   *button,
     // If querying returned nothing, read the style from the text tool prefs (default style for new texts)
     if (result_numbers == QUERY_STYLE_NOTHING)
     {
-    	Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    	prefs->mergeStyle("/tools/text/style", css);
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->mergeStyle("/tools/text/style", css);
     }
 
     sp_style_unref(query);
@@ -6486,8 +6566,8 @@ sp_text_toolbox_style_toggled (GtkToggleButton  *button,
     // If querying returned nothing, read the style from the text tool prefs (default style for new texts)
     if (result_fontspec == QUERY_STYLE_NOTHING)
     {
-    	Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    	prefs->mergeStyle("/tools/text/style", css);
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->mergeStyle("/tools/text/style", css);
     }
 
     sp_style_unref(query);
@@ -6536,7 +6616,7 @@ sp_text_toolbox_orientation_toggled (GtkRadioButton  *button,
     if (result_numbers == QUERY_STYLE_NOTHING)
     {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    	prefs->mergeStyle("/tools/text/style", css);
+        prefs->mergeStyle("/tools/text/style", css);
     }
 
     sp_desktop_set_style (desktop, css, true, true);
@@ -6571,7 +6651,7 @@ sp_text_toolbox_family_keypress (GtkWidget */*w*/, GdkEventKey *event, GObject *
 }
 
 gboolean
-sp_text_toolbox_family_list_keypress (GtkWidget *w, GdkEventKey *event, GObject */*tbl*/)
+sp_text_toolbox_family_list_keypress (GtkWidget */*w*/, GdkEventKey *event, GObject */*tbl*/)
 {
     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
     if (!desktop) return FALSE;
@@ -6648,7 +6728,7 @@ sp_text_toolbox_size_changed  (GtkComboBox *cbox,
     if (result_numbers == QUERY_STYLE_NOTHING)
     {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    	prefs->mergeStyle("/tools/text/style", css);
+        prefs->mergeStyle("/tools/text/style", css);
     }
 
     sp_style_unref(query);
@@ -6759,14 +6839,14 @@ cell_data_func  (GtkCellLayout */*cell_layout*/,
     g_free(family_escaped);
 }
 
-gboolean            text_toolbox_completion_match_selected    (GtkEntryCompletion *widget,
-                                                        GtkTreeModel       *model,
-                                                        GtkTreeIter        *iter,
-                                                        GObject *tbl)
+gboolean text_toolbox_completion_match_selected(GtkEntryCompletion */*widget*/,
+                                                GtkTreeModel       *model,
+                                                GtkTreeIter        *iter,
+                                                GObject            *tbl)
 {
     // We intercept this signal so as to fire family_changed at once (without it, you'd have to
     // press Enter again after choosing a completion)
-    gchar *family;
+    gchar *family = 0;
     gtk_tree_model_get(model, iter, 0, &family, -1);
 
     GtkEntry *entry = GTK_ENTRY (g_object_get_data (G_OBJECT (tbl), "family-entry"));
@@ -6799,9 +6879,9 @@ cbe_add_completion (GtkComboBoxEntry *cbe, GObject *tbl){
     g_object_unref(completion);
 }
 
-void        sp_text_toolbox_family_popnotify          (GtkComboBox *widget,
-                                                       void *property,
-                                                        GObject *tbl)
+void sp_text_toolbox_family_popnotify(GtkComboBox *widget,
+                                      void */*property*/,
+                                      GObject *tbl)
 {
   // while the drop-down is open, we disable font family changing, reenabling it only when it closes
 
@@ -7109,7 +7189,7 @@ static void sp_connector_orthogonal_toggled( GtkToggleAction* act, GObject *tbl
     {
         return;
     }
-    
+
 
     // quit if run by the _changed callbacks
     if (g_object_get_data( tbl, "freeze" )) {
@@ -7160,7 +7240,7 @@ static void connector_curvature_changed(GtkAdjustment *adj, GObject* tbl)
     {
         return;
     }
-    
+
 
     // quit if run by the _changed callbacks
     if (g_object_get_data( tbl, "freeze" )) {
@@ -7280,7 +7360,7 @@ static void sp_nooverlaps_graph_layout_toggled( GtkToggleAction* act, GtkObject
 }
 
 
-static void connector_length_changed(GtkAdjustment *adj, GObject* tbl)
+static void connector_length_changed(GtkAdjustment *adj, GObject* /*tbl*/)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setDouble("/tools/connector/length", adj->value);
@@ -7495,9 +7575,9 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA
         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_new_connection_point), holder );
         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
     }
-    
+
     // Remove selected connection point button
-    
+
     {
         InkAction* inky = ink_action_new( "ConnectorRemoveConnPointAction",
                                           _("Remove connection point"),
@@ -7507,7 +7587,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA
         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_remove_connection_point), holder );
         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
     }
-    
+
 
     // Code to watch for changes to the connector-spacing attribute in
     // the XML.