From trunk

(bzr r6885)

11 files changed, 637 insertions, 655 deletions

diff --git a/src/widgets/dash-selector.cpp b/src/widgets/dash-selector.cpp
index 57f9259e2..284a8a596 100644
--- a/src/widgets/dash-selector.cpp
+++ b/src/widgets/dash-selector.cpp
@@ -1,9 +1,9 @@
 #define __SP_DASH_SELECTOR_NEW_C__
 
-/*
- * Optionmenu for selecting dash patterns
- *
- * Author:
+/** @file
+ * @brief Option menu for selecting dash patterns - implementation
+ */
+/* Author:
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *   bulia byak <buliabyak@users.sf.net>
  *   Maximilian Albert <maximilian.albert@gmail.com>
@@ -28,6 +28,7 @@
 
 #include "style.h"
 #include "dialogs/dialog-events.h"
+#include "preferences.h"
 
 #include <gtkmm/optionmenu.h>
 #include <gtkmm/adjustment.h>
@@ -36,6 +37,8 @@
 
 #include "dash-selector.h"
 
+gchar const *const SPDashSelector::_prefs_path = "/palette/dashes";
+
 static double dash_0[] = {-1.0};
 static double dash_1_1[] = {1.0, 1.0, -1.0};
 static double dash_2_1[] = {2.0, 1.0, -1.0};
@@ -49,9 +52,9 @@ static double **dashes = NULL;
 
 static void sp_dash_selector_menu_item_image_realize(Gtk::Image *px, double *pattern);
 
-SPDashSelector::SPDashSelector(Inkscape::XML::Node *drepr) {
+SPDashSelector::SPDashSelector() {
     // TODO: find something more sensible here!!
-    init_dashes(drepr);
+    init_dashes();
 
     Gtk::Tooltips *tt = new Gtk::Tooltips();
 
@@ -89,39 +92,33 @@ SPDashSelector::~SPDashSelector() {
 }
 
 void
-SPDashSelector::init_dashes(Inkscape::XML::Node *drepr) {
+SPDashSelector::init_dashes() {
     if (!dashes) {
-        int ndashes = 0;
-        if (drepr) {
-            for (Inkscape::XML::Node *dr = drepr->firstChild(); dr; dr = dr->next()) {
-                if (!strcmp (dr->name(), "dash"))
-                    ndashes += 1;
-            }
-        }
-
-        if (ndashes > 0) {
+        
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        std::vector<Glib::ustring> dash_prefs = prefs->getAllDirs(_prefs_path);
+        
+        if (!dash_prefs.empty()) {
             int pos = 0;
             SPStyle *style = sp_style_new (NULL);
-            dashes = g_new (double *, ndashes + 1);
-            for (Inkscape::XML::Node *dr = drepr->firstChild(); dr; dr = dr->next()) {
-                if (!strcmp (dr->name(), "dash")) {
-                    sp_style_read_from_repr (style, dr);
-                    if (style->stroke_dash.n_dash > 0) {
-                        dashes[pos] = g_new (double, style->stroke_dash.n_dash + 1);
-                        double *d = dashes[pos];
-                        int i = 0;
-                        for (; i < style->stroke_dash.n_dash; i++) {
-                            d[i] = style->stroke_dash.dash[i];
-                        }
-                        d[i] = -1;
-                    } else {
-                        dashes[pos] = dash_0;
+            dashes = g_new (double *, dash_prefs.size() + 1);
+            
+            for (std::vector<Glib::ustring>::iterator i = dash_prefs.begin(); i != dash_prefs.end(); ++i) {
+                sp_style_read_from_prefs(style, *i);
+                
+                if (style->stroke_dash.n_dash > 0) {
+                    dashes[pos] = g_new (double, style->stroke_dash.n_dash + 1);
+                    double *d = dashes[pos];
+                    int i = 0;
+                    for (; i < style->stroke_dash.n_dash; i++) {
+                        d[i] = style->stroke_dash.dash[i];
                     }
-                    pos += 1;
+                    d[i] = -1;
+                } else {
+                    dashes[pos] = dash_0;
                 }
+                pos += 1;
             }
-            sp_style_unref (style);
-            dashes[pos] = NULL;
         } else {
             dashes = builtin_dashes;
         }
diff --git a/src/widgets/dash-selector.h b/src/widgets/dash-selector.h
index 97e0b7379..25417285a 100644
--- a/src/widgets/dash-selector.h
+++ b/src/widgets/dash-selector.h
@@ -1,10 +1,10 @@
 #ifndef __SP_DASH_SELECTOR_NEW_H__
 #define __SP_DASH_SELECTOR_NEW_H__
 
-/*
- * Optionmenu for selecting dash patterns
- *
- * Author:
+/** @file
+ * @brief Option menu for selecting dash patterns
+ */
+/* Authors:
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *   Maximilian Albert <maximilian.albert> (gtkmm-ification)
  *
@@ -13,8 +13,7 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include "xml/repr.h"
-
+#include <glibmm/ustring.h>
 #include <gtkmm/box.h>
 #include <sigc++/signal.h>
 
@@ -28,7 +27,7 @@ class Adjustment;
 // TODO: should we rather derive this from OptionMenu and add the spinbutton somehow else?
 class SPDashSelector : public Gtk::HBox {
 public:
-    SPDashSelector(Inkscape::XML::Node *drepr);
+    SPDashSelector();
     ~SPDashSelector();
 
     void set_dash(int ndash, double *dash, double offset);
@@ -37,13 +36,15 @@ public:
     sigc::signal<void> changed_signal;
 
 private:
-    static void init_dashes(Inkscape::XML::Node *drepr);
+    static void init_dashes();
     void dash_activate(Gtk::MenuItem *mi);
     void offset_value_changed();
     Gtk::MenuItem *menu_item_new(double *pattern);
 
     Gtk::OptionMenu *dash;
     Gtk::Adjustment *offset;
+    
+    static gchar const *const _prefs_path;
 };
 
 #endif
diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp
index e4190b930..3c78eb0bb 100644
--- a/src/widgets/desktop-widget.cpp
+++ b/src/widgets/desktop-widget.cpp
@@ -2,8 +2,8 @@
 
 /** \file
  * Desktop widget implementation
- *
- * Authors:
+ */
+/* Authors:
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *   MenTaLguY <mental@rydia.net>
  *   bulia byak <buliabyak@users.sf.net>
@@ -57,7 +57,6 @@
 #include "ege-select-one-action.h"
 #include "ege-color-prof-tracker.h"
 #include "color-profile-fns.h"
-#include "xml/node-observer.h"
 #include "box3d-context.h"
 #include "sp-image.h"
 
@@ -114,48 +113,68 @@ static void sp_dtw_zoom_selection (GtkMenuItem *item, gpointer data);
 
 SPViewWidgetClass *dtw_parent_class;
 
-using Inkscape::XML::Node;
-
-class PrefWatcher : public Inkscape::XML::NodeObserver {
+class CMSPrefWatcher {
 public:
-    PrefWatcher();
-    virtual ~PrefWatcher();
-
-
-    virtual void notifyChildAdded( Node &/*node*/, Node &/*child*/, Node */*prev*/ ) {}
-    virtual void notifyChildRemoved( Node &/*node*/, Node &/*child*/, Node */*prev*/ ) {}
-    virtual void notifyChildOrderChanged( Node &/*node*/, Node &/*child*/,
-                                          Node */*old_prev*/, Node */*new_prev*/ ) {}
-    virtual void notifyContentChanged( Node &/*node*/,
-                                       Inkscape::Util::ptr_shared<char> /*old_content*/,
-                                       Inkscape::Util::ptr_shared<char> /*new_content*/ ) {}
-    virtual void notifyAttributeChanged( Node &node, GQuark name,
-                                         Inkscape::Util::ptr_shared<char> old_value,
-                                         Inkscape::Util::ptr_shared<char> new_value );
-    void add( SPDesktopWidget* dtw );
-    void remove( SPDesktopWidget* dtw );
+    CMSPrefWatcher() :
+        _dpw(*this),
+        _spw(*this),
+        _tracker(ege_color_prof_tracker_new(0))
+    {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        g_signal_connect( G_OBJECT(_tracker), "modified", G_CALLBACK(hook), this );
+        prefs->addObserver(_dpw);
+        prefs->addObserver(_spw);
+    }
+    virtual ~CMSPrefWatcher() {}
+
+    //virtual void notify(PrefValue &);
+    void add( SPDesktopWidget* dtw ) {
+        _widget_list.push_back(dtw);
+    }
+    void remove( SPDesktopWidget* dtw ) {
+        _widget_list.remove(dtw);
+    }
 
 private:
-    static void hook(EgeColorProfTracker *tracker, gint a, gint b, PrefWatcher *watcher);
+    static void hook(EgeColorProfTracker *tracker, gint a, gint b, CMSPrefWatcher *watcher);
+    
+    class DisplayProfileWatcher : public Inkscape::Preferences::Observer {
+    public:
+        DisplayProfileWatcher(CMSPrefWatcher &pw) : Observer("/options/displayprofile"), _pw(pw) {}
+        virtual void notify(Inkscape::Preferences::Entry const &val) {
+            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+            _pw._setCmsSensitive(!prefs->getString("/options/displayprofile/uri").empty());
+            _pw._refreshAll();
+        }
+    private:
+        CMSPrefWatcher &_pw;
+    };
+    
+    DisplayProfileWatcher _dpw;
+    
+    class SoftProofWatcher : public Inkscape::Preferences::Observer {
+    public:
+        SoftProofWatcher(CMSPrefWatcher &pw) : Observer("/options/softproof"), _pw(pw) {}
+        virtual void notify(Inkscape::Preferences::Entry const &) {
+            _pw._refreshAll();
+        }
+    private:
+        CMSPrefWatcher &_pw;
+    };
+    
+    SoftProofWatcher _spw;
+    
+    void _refreshAll();
+    void _setCmsSensitive(bool value);
 
-    std::list<SPDesktopWidget*> dtws;
+    std::list<SPDesktopWidget*> _widget_list;
     EgeColorProfTracker *_tracker;
+    
+    friend class DisplayProfileWatcher;
+    friend class SoftproofWatcher;
 };
 
-PrefWatcher::PrefWatcher() :
-    NodeObserver(),
-    dtws(),
-    _tracker(0)
-{
-    _tracker = ege_color_prof_tracker_new(0);
-    g_signal_connect( G_OBJECT(_tracker), "modified", G_CALLBACK(hook), this );
-}
-
-PrefWatcher::~PrefWatcher()
-{
-}
-
-void PrefWatcher::hook(EgeColorProfTracker */*tracker*/, gint screen, gint monitor, PrefWatcher */*watcher*/)
+void CMSPrefWatcher::hook(EgeColorProfTracker */*tracker*/, gint screen, gint monitor, CMSPrefWatcher */*watcher*/)
 {
 #if ENABLE_LCMS
     unsigned char* buf = 0;
@@ -166,56 +185,32 @@ void PrefWatcher::hook(EgeColorProfTracker */*tracker*/, gint screen, gint monit
 #endif // ENABLE_LCMS
 }
 
-void PrefWatcher::add( SPDesktopWidget* dtw )
-{
-    dtws.push_back(dtw);
-}
-
-void PrefWatcher::remove( SPDesktopWidget* dtw )
+/// @todo Use conditional compilation in saner places. The whole PrefWatcher
+/// object is unnecessary if ENABLE_LCMS is not defined.
+void CMSPrefWatcher::_refreshAll()
 {
-    dtws.remove(dtw);
+#if ENABLE_LCMS
+    for ( std::list<SPDesktopWidget*>::iterator it = _widget_list.begin(); it != _widget_list.end(); ++it ) {
+        (*it)->requestCanvasUpdate();
+    }
+#endif // ENABLE_LCMS
 }
 
-void PrefWatcher::notifyAttributeChanged( Node &node, GQuark name,
-                                          Inkscape::Util::ptr_shared<char> /*old_value*/,
-                                          Inkscape::Util::ptr_shared<char> /*new_value*/ )
+void CMSPrefWatcher::_setCmsSensitive(bool enabled)
 {
 #if ENABLE_LCMS
-    (void)name;
-    if ( strcmp("group", node.name()) == 0 ) {
-        gchar const* id = node.attribute("id");
-        bool refresh = false;
-        if ( !id ) {
-            // bad
-        } else if (strcmp("displayprofile", id) == 0) {
-            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-            Glib::ustring current = prefs->getString("options.displayprofile", "uri");
-            bool enabled = !current.empty();
-
-            for ( std::list<SPDesktopWidget*>::iterator it = dtws.begin(); it != dtws.end(); ++it ) {
-                SPDesktopWidget* dtw = *it;
-                if ( GTK_WIDGET_SENSITIVE( dtw->cms_adjust ) != enabled ) {
-                    cms_adjust_set_sensitive( dtw, enabled );
-                }
-            }
-            refresh = true;
-        } else if (strcmp("softproof", id) == 0) {
-            refresh = true;
-        }
-
-        if ( refresh ) {
-            for ( std::list<SPDesktopWidget*>::iterator it = dtws.begin(); it != dtws.end(); ++it ) {
-                (*it)->requestCanvasUpdate();
-            }
+    for ( std::list<SPDesktopWidget*>::iterator it = _widget_list.begin(); it != _widget_list.end(); ++it ) {
+        SPDesktopWidget *dtw = *it;
+        if ( GTK_WIDGET_SENSITIVE( dtw->cms_adjust ) != enabled ) {
+            cms_adjust_set_sensitive( dtw, enabled );
         }
     }
 #else
-    (void)node;
-    (void)name;
+    (void) enabled;
 #endif // ENABLE_LCMS
 }
 
-static PrefWatcher* watcher = 0;
+static CMSPrefWatcher* watcher = NULL;
 
 void
 SPDesktopWidget::setMessage (Inkscape::MessageType type, const gchar *message)
@@ -317,7 +312,7 @@ sp_desktop_widget_init (SPDesktopWidget *dtw)
     {
         using Inkscape::UI::Dialogs::SwatchesPanel;
 
-        SwatchesPanel* swatches = new SwatchesPanel("embedded.swatches");
+        SwatchesPanel* swatches = new SwatchesPanel("/embedded/swatches");
         swatches->setOrientation( Gtk::ANCHOR_SOUTH );
         dtw->panels = GTK_WIDGET(swatches->gobj());
         gtk_box_pack_end( GTK_BOX( dtw->vbox ), dtw->panels, FALSE, TRUE, 0 );
@@ -378,7 +373,7 @@ sp_desktop_widget_init (SPDesktopWidget *dtw)
                                                  "sticky_zoom",
                                                  _("Zoom drawing if window size changes"),
                                                  dtw->tt);
-    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dtw->sticky_zoom), prefs->getBool("options.stickyzoom", "value"));
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dtw->sticky_zoom), prefs->getBool("/options/stickyzoom/value"));
     gtk_box_pack_start (GTK_BOX (dtw->vscrollbar_box), dtw->sticky_zoom, FALSE, FALSE, 0);
     dtw->vadj = (GtkAdjustment *) gtk_adjustment_new (0.0, -4000.0, 4000.0, 10.0, 100.0, 4.0);
     dtw->vscrollbar = gtk_vscrollbar_new (GTK_ADJUSTMENT (dtw->vadj));
@@ -402,11 +397,11 @@ sp_desktop_widget_init (SPDesktopWidget *dtw)
                                                dtw->tt );
 #if ENABLE_LCMS
     {
-        Glib::ustring current = prefs->getString("options.displayprofile", "uri");
+        Glib::ustring current = prefs->getString("/options/displayprofile/uri");
         bool enabled = current.length() > 0;
         cms_adjust_set_sensitive( dtw, enabled );
         if ( enabled ) {
-            bool active = prefs->getBool("options.displayprofile", "enable");
+            bool active = prefs->getBool("/options/displayprofile/enable");
             if ( active ) {
                 sp_button_toggle_set_down( SP_BUTTON(dtw->cms_adjust), TRUE );
             }
@@ -418,10 +413,8 @@ sp_desktop_widget_init (SPDesktopWidget *dtw)
 #endif // ENABLE_LCMS
     gtk_table_attach( GTK_TABLE(canvas_tbl), dtw->cms_adjust, 2, 3, 2, 3, (GtkAttachOptions)(GTK_SHRINK), (GtkAttachOptions)(GTK_SHRINK), 0, 0);
     {
-        Inkscape::Preferences* prefs = Inkscape::Preferences::get();
         if (!watcher) {
-            watcher = new PrefWatcher();
-            prefs->addPrefsObserver( watcher );
+            watcher = new CMSPrefWatcher();
         }
         watcher->add(dtw);
     }
@@ -429,20 +422,20 @@ sp_desktop_widget_init (SPDesktopWidget *dtw)
     /* Canvas */
     dtw->canvas = SP_CANVAS (sp_canvas_new_aa ());
 #if ENABLE_LCMS
-    dtw->canvas->enable_cms_display_adj = prefs->getBool("options.displayprofile", "enable");
+    dtw->canvas->enable_cms_display_adj = prefs->getBool("/options/displayprofile/enable");
 #endif // ENABLE_LCMS
     GTK_WIDGET_SET_FLAGS (GTK_WIDGET (dtw->canvas), GTK_CAN_FOCUS);
     style = gtk_style_copy (GTK_WIDGET (dtw->canvas)->style);
     style->bg[GTK_STATE_NORMAL] = style->white;
     gtk_widget_set_style (GTK_WIDGET (dtw->canvas), style);
-    if ( prefs->getBool("options.useextinput", "value", true) )
+    if ( prefs->getBool("/options/useextinput/value", true) )
       gtk_widget_set_extension_events(GTK_WIDGET (dtw->canvas) , GDK_EXTENSION_EVENTS_ALL); //set extension events for tablets, unless disabled in preferences
     g_signal_connect (G_OBJECT (dtw->canvas), "event", G_CALLBACK (sp_desktop_widget_event), dtw);
     gtk_table_attach (GTK_TABLE (canvas_tbl), GTK_WIDGET(dtw->canvas), 1, 2, 1, 2, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), 0, 0);
 
     /* Dock */
     bool create_dock =
-        prefs->getIntLimited("options.dialogtype", "value", Inkscape::UI::Dialog::FLOATING, 0, 1) ==
+        prefs->getIntLimited("/options/dialogtype/value", Inkscape::UI::Dialog::FLOATING, 0, 1) ==
         Inkscape::UI::Dialog::DOCK;
 
     if (create_dock) {
@@ -782,7 +775,7 @@ void cms_adjust_toggled( GtkWidget */*button*/, gpointer data )
         dtw->canvas->enable_cms_display_adj = down;
         dtw->requestCanvasUpdate();
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setBool("options.displayprofile", "enable", down);
+        prefs->setBool("/options/displayprofile/enable", down);
     }
 #endif // ENABLE_LCMS
 }
@@ -948,18 +941,18 @@ SPDesktopWidget::shutdown()
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         bool maxed = desktop->is_maximized();
         bool full = desktop->is_fullscreen();
-        prefs->setBool("desktop.geometry", "fullscreen", full);
-        prefs->setBool("desktop.geometry", "maximized", maxed);
+        prefs->setBool("/desktop/geometry/fullscreen", full);
+        prefs->setBool("/desktop/geometry/maximized", maxed);
         gint w, h, x, y;
         desktop->getWindowGeometry(x, y, w, h);
         // Don't save geom for maximized windows.  It
         // just tells you the current maximized size, which is not
         // as useful as whatever value it had previously.
         if (!maxed && !full) {
-            prefs->setInt("desktop.geometry", "width", w);
-            prefs->setInt("desktop.geometry", "height", h);
-            prefs->setInt("desktop.geometry", "x", x);
-            prefs->setInt("desktop.geometry", "y", y);
+            prefs->setInt("/desktop/geometry/width", w);
+            prefs->setInt("/desktop/geometry/height", h);
+            prefs->setInt("/desktop/geometry/x", x);
+            prefs->setInt("/desktop/geometry/y", y);
         }
     }
 
@@ -1148,10 +1141,10 @@ sp_desktop_widget_maximize(SPDesktopWidget *dtw)
                 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
                 gint w, h, x, y;
                 dtw->getWindowGeometry(x, y, w, h);
-                prefs->setInt("desktop.geometry", "width", w);
-                prefs->setInt("desktop.geometry", "height", h);
-                prefs->setInt("desktop.geometry", "x", x);
-                prefs->setInt("desktop.geometry", "y", y);
+                prefs->setInt("/desktop/geometry/width", w);
+                prefs->setInt("/desktop/geometry/height", h);
+                prefs->setInt("/desktop/geometry/x", x);
+                prefs->setInt("/desktop/geometry/y", y);
             }
             gtk_window_maximize(topw);
         }
@@ -1176,10 +1169,10 @@ sp_desktop_widget_fullscreen(SPDesktopWidget *dtw)
                 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
                 gint w, h, x, y;
                 dtw->getWindowGeometry(x, y, w, h);
-                prefs->setInt("desktop.geometry", "width", w);
-                prefs->setInt("desktop.geometry", "height", h);
-                prefs->setInt("desktop.geometry", "x", x);
-                prefs->setInt("desktop.geometry", "y", y);
+                prefs->setInt("/desktop/geometry/width", w);
+                prefs->setInt("/desktop/geometry/height", h);
+                prefs->setInt("/desktop/geometry/x", x);
+                prefs->setInt("/desktop/geometry/y", y);
             }
             gtk_window_fullscreen(topw);
             // widget layout is triggered by the resulting window_state_event
@@ -1194,72 +1187,56 @@ sp_desktop_widget_fullscreen(SPDesktopWidget *dtw)
 void
 sp_desktop_widget_layout (SPDesktopWidget *dtw)
 {
-	gchar * pref_path = NULL;
-	gchar const * pref_root = NULL;
-
-	if (dtw->desktop->is_focusMode()) {
-		pref_root = "focus.";
-	} else if (dtw->desktop->is_fullscreen()) {
-		pref_root = "fullscreen.";
-	} else {
-		pref_root = "window.";
-	}
-
-	pref_path = g_strconcat(pref_root, "menu", NULL);
-
+    Glib::ustring pref_root;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
-    if (!prefs->getBool(pref_path, "state", true)) {
+    if (dtw->desktop->is_focusMode()) {
+	    pref_root = "/focus/";
+    } else if (dtw->desktop->is_fullscreen()) {
+	    pref_root = "/fullscreen/";
+    } else {
+	    pref_root = "/window/";
+    }
+
+    if (!prefs->getBool(pref_root + "menu/state", true)) {
         gtk_widget_hide_all (dtw->menubar);
     } else {
         gtk_widget_show_all (dtw->menubar);
     }
-	g_free(pref_path);
 
-	pref_path = g_strconcat(pref_root, "commands", NULL);
-    if (!prefs->getBool(pref_path, "state", true)) {
+    if (!prefs->getBool(pref_root + "commands/state", true)) {
         gtk_widget_hide_all (dtw->commands_toolbox);
     } else {
         gtk_widget_show_all (dtw->commands_toolbox);
     }
-	g_free(pref_path);
 
-	pref_path = g_strconcat(pref_root, "toppanel", NULL);
-    if (!prefs->getBool(pref_path, "state", true)) {
+    if (!prefs->getBool(pref_root + "toppanel/state", true)) {
         gtk_widget_hide_all (dtw->aux_toolbox);
     } else {
         // we cannot just show_all because that will show all tools' panels;
         // this is a function from toolbox.cpp that shows only the current tool's panel
         show_aux_toolbox (dtw->aux_toolbox);
     }
-	g_free(pref_path);
 
-	pref_path = g_strconcat(pref_root, "toolbox", NULL);
-    if (!prefs->getBool(pref_path, "state", true)) {
+    if (!prefs->getBool(pref_root + "toolbox/state", true)) {
         gtk_widget_hide_all (dtw->tool_toolbox);
     } else {
         gtk_widget_show_all (dtw->tool_toolbox);
     }
-	g_free(pref_path);
 
-	pref_path = g_strconcat(pref_root, "statusbar", NULL);
-    if (!prefs->getBool(pref_path, "state", true)) {
+    if (!prefs->getBool(pref_root + "statusbar/state", true)) {
         gtk_widget_hide_all (dtw->statusbar);
     } else {
         gtk_widget_show_all (dtw->statusbar);
     }
-	g_free(pref_path);
 
-	pref_path = g_strconcat(pref_root, "panels", NULL);
-    if (!prefs->getBool(pref_path, "state", true)) {
+    if (!prefs->getBool(pref_root + "panels/state", true)) {
         gtk_widget_hide_all( dtw->panels );
     } else {
         gtk_widget_show_all( dtw->panels );
     }
-	g_free(pref_path);
 
-	pref_path = g_strconcat(pref_root, "scrollbars", NULL);
-    if (!prefs->getBool(pref_path, "state", true)) {
+    if (!prefs->getBool(pref_root + "scrollbars/state", true)) {
         gtk_widget_hide_all (dtw->hscrollbar);
         gtk_widget_hide_all (dtw->vscrollbar_box);
         gtk_widget_hide_all( dtw->cms_adjust );
@@ -1268,19 +1245,14 @@ sp_desktop_widget_layout (SPDesktopWidget *dtw)
         gtk_widget_show_all (dtw->vscrollbar_box);
         gtk_widget_show_all( dtw->cms_adjust );
     }
-	g_free(pref_path);
 
-	pref_path = g_strconcat(pref_root, "rulers", NULL);
-    if (!prefs->getBool(pref_path, "state", true)) {
+    if (!prefs->getBool(pref_root + "rulers/state", true)) {
         gtk_widget_hide_all (dtw->hruler);
         gtk_widget_hide_all (dtw->vruler);
     } else {
         gtk_widget_show_all (dtw->hruler);
         gtk_widget_show_all (dtw->vruler);
     }
-	g_free(pref_path);
-
-	return;
 }
 
 void
@@ -1468,7 +1440,7 @@ sp_desktop_widget_adjustment_value_changed (GtkAdjustment */*adj*/, SPDesktopWid
 bool SPDesktopWidget::onFocusInEvent(GdkEventFocus*)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    if (prefs->getBool("options.bitmapautoreload", "value", true)) {
+    if (prefs->getBool("/options/bitmapautoreload/value", true)) {
         GSList const *imageList = sp_document_get_resource_list(desktop->doc(), "image");
         for (GSList const *p = imageList; p; p = p->next) {
             SPImage* image = SP_IMAGE(p->data);
@@ -1646,11 +1618,11 @@ sp_desktop_widget_toggle_rulers (SPDesktopWidget *dtw)
     if (GTK_WIDGET_VISIBLE (dtw->hruler)) {
         gtk_widget_hide_all (dtw->hruler);
         gtk_widget_hide_all (dtw->vruler);
-        prefs->setBool(dtw->desktop->is_fullscreen() ? "fullscreen.rulers" : "window.rulers", "state", false);
+        prefs->setBool(dtw->desktop->is_fullscreen() ? "/fullscreen/rulers/state" : "/window/rulers/state", false);
     } else {
         gtk_widget_show_all (dtw->hruler);
         gtk_widget_show_all (dtw->vruler);
-        prefs->setBool(dtw->desktop->is_fullscreen() ? "fullscreen.rulers" : "window.rulers", "state", true);
+        prefs->setBool(dtw->desktop->is_fullscreen() ? "/fullscreen/rulers/state" : "/window/rulers/state", true);
     }
 }
 
@@ -1662,12 +1634,12 @@ sp_desktop_widget_toggle_scrollbars (SPDesktopWidget *dtw)
         gtk_widget_hide_all (dtw->hscrollbar);
         gtk_widget_hide_all (dtw->vscrollbar_box);
         gtk_widget_hide_all( dtw->cms_adjust );
-        prefs->setBool(dtw->desktop->is_fullscreen() ? "fullscreen.scrollbars" : "window.scrollbars", "state", false);
+        prefs->setBool(dtw->desktop->is_fullscreen() ? "/fullscreen/scrollbars/state" : "/window/scrollbars/state", false);
     } else {
         gtk_widget_show_all (dtw->hscrollbar);
         gtk_widget_show_all (dtw->vscrollbar_box);
         gtk_widget_show_all( dtw->cms_adjust );
-        prefs->setBool(dtw->desktop->is_fullscreen() ? "fullscreen.scrollbars" : "window.scrollbars", "state", true);
+        prefs->setBool(dtw->desktop->is_fullscreen() ? "/fullscreen/scrollbars/state" : "/window/scrollbars/state", true);
     }
 }
 
@@ -1690,10 +1662,10 @@ sp_spw_toggle_menubar (SPDesktopWidget *dtw, bool is_fullscreen)
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     if (GTK_WIDGET_VISIBLE (dtw->menubar)) {
         gtk_widget_hide_all (dtw->menubar);
-        prefs->setBool(is_fullscreen ? "fullscreen.menu" : "window.menu", "state", false);
+        prefs->setBool(is_fullscreen ? "/fullscreen/menu/state" : "/window/menu/state", false);
     } else {
         gtk_widget_show_all (dtw->menubar);
-        prefs->setBool(is_fullscreen ? "fullscreen.menu" : "window.menu", "state", true);
+        prefs->setBool(is_fullscreen ? "/fullscreen/menu/state" : "/window/menu/state", true);
     }
 }
 */
diff --git a/src/widgets/gradient-toolbar.cpp b/src/widgets/gradient-toolbar.cpp
index afb20cbd5..319ef4be1 100644
--- a/src/widgets/gradient-toolbar.cpp
+++ b/src/widgets/gradient-toolbar.cpp
@@ -26,7 +26,7 @@
 #include "widgets/gradient-image.h"
 #include "style.h"
 
-#include "prefs-utils.h"
+#include "preferences.h"
 #include "document-private.h"
 #include "desktop.h"
 #include "desktop-handles.h"
@@ -47,25 +47,27 @@
 //########################
 
 static void gr_toggle_type (GtkWidget *button, gpointer data) {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     GtkWidget *linear = (GtkWidget *) g_object_get_data (G_OBJECT(data), "linear");
     GtkWidget *radial = (GtkWidget *) g_object_get_data (G_OBJECT(data), "radial");
     if (button == linear && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (linear))) {
-        prefs_set_int_attribute ("tools.gradient", "newgradient", SP_GRADIENT_TYPE_LINEAR);
+        prefs->setInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR);
         if (radial) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radial), FALSE);
     } else if (button == radial && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (radial))) {
-        prefs_set_int_attribute ("tools.gradient", "newgradient", SP_GRADIENT_TYPE_RADIAL);
+        prefs->setInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_RADIAL);
         if (linear) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (linear), FALSE);
     }
 }
 
 static void gr_toggle_fillstroke (GtkWidget *button, gpointer data) {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     GtkWidget *fill = (GtkWidget *) g_object_get_data (G_OBJECT(data), "fill");
     GtkWidget *stroke = (GtkWidget *) g_object_get_data (G_OBJECT(data), "stroke");
     if (button == fill && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (fill))) {
-        prefs_set_int_attribute ("tools.gradient", "newfillorstroke", 1);
+        prefs->setBool("/tools/gradient/newfillorstroke", true);
         if (stroke) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (stroke), FALSE);
     } else if (button == stroke && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (stroke))) {
-        prefs_set_int_attribute ("tools.gradient", "newfillorstroke", 0);
+        prefs->setBool("/tools/gradient/newfillorstroke", false);
         if (fill) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fill), FALSE);
     }
 }
@@ -113,8 +115,9 @@ gradient.
 void
 gr_apply_gradient (Inkscape::Selection *selection, GrDrag *drag, SPGradient *gr)
 {
-    SPGradientType new_type = (SPGradientType) prefs_get_int_attribute ("tools.gradient", "newgradient", SP_GRADIENT_TYPE_LINEAR);
-    guint new_fill = prefs_get_int_attribute ("tools.gradient", "newfillorstroke", 1);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    SPGradientType new_type = (SPGradientType) prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR);
+    guint new_fill = prefs->getBool("/tools/gradient/newfillorstroke", true);
 
 
     // GRADIENTFIXME: make this work for multiple selected draggers.
@@ -512,6 +515,7 @@ gr_change_widget (SPDesktop *desktop)
 GtkWidget *
 sp_gradient_toolbox_new(SPDesktop *desktop)
 {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     GtkWidget *tbl = gtk_toolbar_new();
 
     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
@@ -537,7 +541,7 @@ sp_gradient_toolbox_new(SPDesktop *desktop)
     g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl);
     g_object_set_data(G_OBJECT(tbl), "linear", button);
     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
-              prefs_get_int_attribute ("tools.gradient", "newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_LINEAR);
+              prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_LINEAR);
     gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
     }
 
@@ -551,7 +555,7 @@ sp_gradient_toolbox_new(SPDesktop *desktop)
     g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl);
     g_object_set_data(G_OBJECT(tbl), "radial", button);
     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
-              prefs_get_int_attribute ("tools.gradient", "newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_RADIAL);
+              prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_RADIAL);
     gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
     }
 
@@ -579,7 +583,7 @@ sp_gradient_toolbox_new(SPDesktop *desktop)
     g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl);
     g_object_set_data(G_OBJECT(tbl), "fill", button);
     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
-                                  prefs_get_int_attribute ("tools.gradient", "newfillorstroke", 1) == 1);
+                                  prefs->getBool("/tools/gradient/newfillorstroke", true));
     gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
     }
 
@@ -593,7 +597,7 @@ sp_gradient_toolbox_new(SPDesktop *desktop)
     g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl);
     g_object_set_data(G_OBJECT(tbl), "stroke", button);
     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
-                                  prefs_get_int_attribute ("tools.gradient", "newfillorstroke", 1) == 0);
+                                  !prefs->getBool("/tools/gradient/newfillorstroke", true));
     gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
     }
 
diff --git a/src/widgets/gradient-vector.cpp b/src/widgets/gradient-vector.cpp
index 881f34628..5f4d06172 100644
--- a/src/widgets/gradient-vector.cpp
+++ b/src/widgets/gradient-vector.cpp
@@ -36,7 +36,7 @@
 #include "xml/repr.h"
 
 #include "../dialogs/dialog-events.h"
-#include "../prefs-utils.h"
+#include "../preferences.h"
 #include "svg/css-ostringstream.h"
 #include "sp-stop.h"
 
@@ -65,7 +65,7 @@ static guint signals[LAST_SIGNAL] = {0};
 static GtkWidget *dlg = NULL;
 static win_data wd;
 static gint x = -1000, y = -1000, w = 0, h = 0; // impossible original values to make sure they are read from prefs
-static gchar const *prefs_path = "dialogs.gradienteditor";
+static Glib::ustring const prefs_path = "/dialogs/gradienteditor/";
 
 GtkType
 sp_gradient_vector_selector_get_type (void)
@@ -892,67 +892,68 @@ sp_gradient_vector_widget_new (SPGradient *gradient, SPStop *select_stop)
 GtkWidget *
 sp_gradient_vector_editor_new (SPGradient *gradient, SPStop *stop)
 {
-	GtkWidget *wid;
-
-	if (dlg == NULL) {
-
-		dlg = sp_window_new (_("Gradient editor"), TRUE);
-		if (x == -1000 || y == -1000) {
-			x = prefs_get_int_attribute (prefs_path, "x", 0);
-			y = prefs_get_int_attribute (prefs_path, "y", 0);
-		}
-		if (w ==0 || h == 0) {
-			w = prefs_get_int_attribute (prefs_path, "w", 0);
-			h = prefs_get_int_attribute (prefs_path, "h", 0);
-		}
-
-                if (x<0) x=0;
-                if (y<0) y=0;
-
-		if (x != 0 || y != 0)
-			gtk_window_move ((GtkWindow *) dlg, x, y);
-		else
-			gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
-		if (w && h) gtk_window_resize ((GtkWindow *) dlg, w, h);
-		sp_transientize (dlg);
-		wd.win = dlg;
-		wd.stop = 0;
-		g_signal_connect (G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd);
-		gtk_signal_connect (GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg);
-		gtk_signal_connect (GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_gradient_vector_dialog_destroy), dlg);
-		gtk_signal_connect (GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_gradient_vector_dialog_delete), dlg);
-		g_signal_connect (G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_gradient_vector_dialog_delete), dlg);
-		g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_hide", G_CALLBACK (sp_dialog_hide), dlg );
-		g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_unhide", G_CALLBACK (sp_dialog_unhide), dlg );
-
-		gtk_container_set_border_width (GTK_CONTAINER (dlg), PAD);
-
-		wid = (GtkWidget*)sp_gradient_vector_widget_new (gradient, stop);
-		g_object_set_data (G_OBJECT (dlg), "gradient-vector-widget", wid);
-		/* Connect signals */
-		gtk_widget_show (wid);
-		gtk_container_add (GTK_CONTAINER (dlg), wid);
-	} else {
-		// FIXME: temp fix for 0.38
-		// Simply load_gradient into the editor does not work for multi-stop gradients,
-		// as the stop list and other widgets are in a wrong state and crash readily.
-		// Instead we just delete the window (by sending the delete signal)
-		// and call sp_gradient_vector_editor_new again, so it creates the window anew.
-
-		GdkEventAny event;
-		GtkWidget *widget = (GtkWidget *) dlg;
-		event.type = GDK_DELETE;
-		event.window = widget->window;
-		event.send_event = TRUE;
-		g_object_ref (G_OBJECT (event.window));
-		gtk_main_do_event ((GdkEvent*)&event);
-		g_object_unref (G_OBJECT (event.window));
-
-		g_assert (dlg == NULL);
-		sp_gradient_vector_editor_new (gradient, stop);
-	}
-
-	return dlg;
+    GtkWidget *wid;
+
+    if (dlg == NULL) {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+        dlg = sp_window_new (_("Gradient editor"), TRUE);
+        if (x == -1000 || y == -1000) {
+            x = prefs->getInt(prefs_path + "x", -1000);
+            y = prefs->getInt(prefs_path + "y", -1000);
+        }
+        if (w ==0 || h == 0) {
+            w = prefs->getInt(prefs_path + "w", 0);
+            h = prefs->getInt(prefs_path + "h", 0);
+        }
+
+        if (x<0) x=0;
+        if (y<0) y=0;
+
+        if (x != 0 || y != 0)
+	        gtk_window_move ((GtkWindow *) dlg, x, y);
+        else
+	        gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
+        if (w && h) gtk_window_resize ((GtkWindow *) dlg, w, h);
+        sp_transientize (dlg);
+        wd.win = dlg;
+        wd.stop = 0;
+        g_signal_connect (G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd);
+        gtk_signal_connect (GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg);
+        gtk_signal_connect (GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_gradient_vector_dialog_destroy), dlg);
+        gtk_signal_connect (GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_gradient_vector_dialog_delete), dlg);
+        g_signal_connect (G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_gradient_vector_dialog_delete), dlg);
+        g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_hide", G_CALLBACK (sp_dialog_hide), dlg );
+        g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_unhide", G_CALLBACK (sp_dialog_unhide), dlg );
+
+        gtk_container_set_border_width (GTK_CONTAINER (dlg), PAD);
+
+        wid = (GtkWidget*)sp_gradient_vector_widget_new (gradient, stop);
+        g_object_set_data (G_OBJECT (dlg), "gradient-vector-widget", wid);
+        /* Connect signals */
+        gtk_widget_show (wid);
+        gtk_container_add (GTK_CONTAINER (dlg), wid);
+    } else {
+        // FIXME: temp fix for 0.38
+        // Simply load_gradient into the editor does not work for multi-stop gradients,
+        // as the stop list and other widgets are in a wrong state and crash readily.
+        // Instead we just delete the window (by sending the delete signal)
+        // and call sp_gradient_vector_editor_new again, so it creates the window anew.
+
+        GdkEventAny event;
+        GtkWidget *widget = (GtkWidget *) dlg;
+        event.type = GDK_DELETE;
+        event.window = widget->window;
+        event.send_event = TRUE;
+        g_object_ref (G_OBJECT (event.window));
+        gtk_main_do_event ((GdkEvent*)&event);
+        g_object_unref (G_OBJECT (event.window));
+
+        g_assert (dlg == NULL);
+        sp_gradient_vector_editor_new (gradient, stop);
+    }
+
+    return dlg;
 }
 
 static void
@@ -1051,18 +1052,19 @@ sp_gradient_vector_dialog_destroy (GtkObject *object, gpointer data)
 static gboolean
 sp_gradient_vector_dialog_delete (GtkWidget *widget, GdkEvent *event, GtkWidget *dialog)
 {
-	gtk_window_get_position ((GtkWindow *) dlg, &x, &y);
-	gtk_window_get_size ((GtkWindow *) dlg, &w, &h);
+    gtk_window_get_position ((GtkWindow *) dlg, &x, &y);
+    gtk_window_get_size ((GtkWindow *) dlg, &w, &h);
 
     if (x<0) x=0;
     if (y<0) y=0;
 
-	prefs_set_int_attribute (prefs_path, "x", x);
-	prefs_set_int_attribute (prefs_path, "y", y);
-	prefs_set_int_attribute (prefs_path, "w", w);
-	prefs_set_int_attribute (prefs_path, "h", h);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setInt(prefs_path + "x", x);
+    prefs->setInt(prefs_path + "y", y);
+    prefs->setInt(prefs_path + "w", w);
+    prefs->setInt(prefs_path + "h", h);
 
-	return FALSE; // which means, go ahead and destroy it
+    return FALSE; // which means, go ahead and destroy it
 }
 
 /* Widget destroy handler */
diff --git a/src/widgets/icon.cpp b/src/widgets/icon.cpp
index 401d76474..4c0439da7 100644
--- a/src/widgets/icon.cpp
+++ b/src/widgets/icon.cpp
@@ -27,7 +27,7 @@
 #include <gtkmm/image.h>
 
 #include "path-prefix.h"
-#include "prefs-utils.h"
+#include "preferences.h"
 #include "inkscape.h"
 #include "document.h"
 #include "sp-item.h"
@@ -280,7 +280,8 @@ static void setupLegacyNaming() {
 static GtkWidget *
 sp_icon_new_full( Inkscape::IconSize lsize, gchar const *name )
 {
-    static gint dump = prefs_get_int_attribute_limited( "debug.icons", "dumpGtk", 0, 0, 1 );
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    static bool dump = prefs->getBool( "/debug/icons/dumpGtk");
 
     GtkWidget *widget = 0;
         gint trySize = CLAMP( static_cast<gint>(lsize), 0, static_cast<gint>(G_N_ELEMENTS(iconSizeLookup) - 1) );
@@ -336,7 +337,7 @@ sp_icon_new_full( Inkscape::IconSize lsize, gchar const *name )
                 // Add a hook to render if set visible before prerender is done.
                 g_signal_connect( G_OBJECT(widget), "map", G_CALLBACK(imageMapNamedCB), GINT_TO_POINTER(0) );
 
-                if ( prefs_get_int_attribute_limited( "options.iconrender", "named_nodelay", 0, 0, 1 ) ) {
+                if ( prefs->getBool("/options/iconrender/named_nodelay") ) {
                     int psize = sp_icon_get_phys_size(lsize);
                     prerender_icon(name, mappedSize, psize);
                 } else {
@@ -408,7 +409,8 @@ static void injectCustomSize()
     // TODO - still need to handle the case of theme changes and resize, especially as we can't re-register a string.
     if ( !sizeMapDone )
     {
-        gint dump = prefs_get_int_attribute_limited( "debug.icons", "dumpDefault", 0, 0, 1 );
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        bool dump = prefs->getBool( "/debug/icons/dumpDefault");
         gint width = 0;
         gint height = 0;
         if ( gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &width, &height ) ) {
@@ -493,7 +495,8 @@ int sp_icon_get_phys_size(int size)
 
     if ( !init ) {
         sizeDirty = false;
-        gint dump = prefs_get_int_attribute_limited( "debug.icons", "dumpDefault", 0, 0, 1 );
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        bool dump = prefs->getBool("/debug/icons/dumpDefault");
 
         if ( dump ) {
             g_message( "Default icon sizes:" );
@@ -650,7 +653,8 @@ extern "C" guchar *
 sp_icon_doc_icon( SPDocument *doc, NRArenaItem *root,
                   gchar const *name, unsigned psize )
 {
-    gint const dump = prefs_get_int_attribute_limited( "debug.icons", "dumpSvg", 0, 0, 1 );
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    bool const dump = prefs->getBool("/debug/icons/dumpSvg");
     guchar *px = NULL;
 
     if (doc) {
@@ -763,7 +767,7 @@ sp_icon_doc_icon( SPDocument *doc, NRArenaItem *root,
                                              NR_ARENA_ITEM_RENDER_NO_CACHE );
                 nr_pixblock_release(&B);
 
-                gint useOverlay = prefs_get_int_attribute_limited( "debug.icons", "overlaySvg", 0, 0, 1 );
+                bool useOverlay = prefs->getBool("/debug/icons/overlaySvg");
                 if ( useOverlay ) {
                     sp_icon_overlay_pixels( px, psize, psize, 4 * psize, 0x00, 0x00, 0xff );
                 }
@@ -890,7 +894,8 @@ static void populate_placeholder_icon(gchar const* name, GtkIconSize size)
 }
 
 static void addToIconSet(GdkPixbuf* pb, gchar const* name, GtkIconSize lsize, unsigned psize) {
-    static gint dump = prefs_get_int_attribute_limited( "debug.icons", "dumpGtk", 0, 0, 1 );
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    static bool dump = prefs->getBool("/debug/icons/dumpGtk");
     GtkStockItem stock;
     gboolean stockFound = gtk_stock_lookup( name, &stock );
     if ( !stockFound ) {
@@ -924,7 +929,8 @@ static void addToIconSet(GdkPixbuf* pb, gchar const* name, GtkIconSize lsize, un
 // returns true if icon needed preloading, false if nothing was done
 bool prerender_icon(gchar const *name, GtkIconSize lsize, unsigned psize)
 {
-    static gint dump = prefs_get_int_attribute_limited( "debug.icons", "dumpGtk", 0, 0, 1 );
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    static bool dump = prefs->getBool("/debug/icons/dumpGtk");
     Glib::ustring key = icon_cache_key(name, lsize, psize);
     GdkPixbuf *pb = get_cached_pixbuf(key);
     if (pb) {
diff --git a/src/widgets/select-toolbar.cpp b/src/widgets/select-toolbar.cpp
index 5f43f7925..af1883916 100644
--- a/src/widgets/select-toolbar.cpp
+++ b/src/widgets/select-toolbar.cpp
@@ -25,7 +25,7 @@
 #include "widgets/icon.h"
 #include "widgets/sp-widget.h"
 
-#include "prefs-utils.h"
+#include "preferences.h"
 #include "selection-chemistry.h"
 #include "document.h"
 #include "inkscape.h"
@@ -39,7 +39,6 @@
 #include "helper/units.h"
 #include "inkscape.h"
 #include "verbs.h"
-#include "prefs-utils.h"
 #include "selection.h"
 #include "selection-chemistry.h"
 #include "sp-item-transform.h"
@@ -62,10 +61,11 @@ sp_selection_layout_widget_update(SPWidget *spw, Inkscape::Selection *sel)
 
     g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
 
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     using Geom::X;
     using Geom::Y;
     if ( sel && !sel->isEmpty() ) {
-        int prefs_bbox = prefs_get_int_attribute("tools", "bounding_box", 0);
+        int prefs_bbox = prefs->getInt("/tools/bounding_box", 0);
         SPItem::BBoxType bbox_type = (prefs_bbox ==0)? 
             SPItem::APPROXIMATE_BBOX : SPItem::GEOMETRIC_BBOX;
         boost::optional<Geom::Rect> const bbox(sel->bounds(bbox_type));
@@ -155,7 +155,8 @@ sp_object_layout_any_value_changed(GtkAdjustment *adj, SPWidget *spw)
     SPDocument *document = sp_desktop_document(desktop);
 
     sp_document_ensure_up_to_date (document);
-    int prefs_bbox = prefs_get_int_attribute("tools", "bounding_box", 0);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    int prefs_bbox = prefs->getInt("/tools/bounding_box");
     SPItem::BBoxType bbox_type = (prefs_bbox ==0)? 
         SPItem::APPROXIMATE_BBOX : SPItem::GEOMETRIC_BBOX;
     boost::optional<Geom::Rect> bbox = selection->bounds(bbox_type);
@@ -236,9 +237,9 @@ sp_object_layout_any_value_changed(GtkAdjustment *adj, SPWidget *spw)
         sp_canvas_force_full_redraw_after_interruptions(sp_desktop_canvas(desktop), 0);
 
         gdouble strokewidth = stroke_average_width (selection->itemList());
-        int transform_stroke = prefs_get_int_attribute ("options.transform", "stroke", 1);
+        int transform_stroke = prefs->getBool("/options/transform/stroke", true) ? 1 : 0;
 
-        NR::Matrix scaler = get_scale_transform_with_stroke (*bbox, strokewidth, transform_stroke, x0, y0, x1, y1);
+        Geom::Matrix scaler = get_scale_transform_with_stroke (*bbox, strokewidth, transform_stroke, x0, y0, x1, y1);
 
         sp_selection_apply_affine(selection, scaler);
         sp_document_maybe_done (document, actionkey, SP_VERB_CONTEXT_SELECT,
@@ -292,9 +293,11 @@ static EgeAdjustmentAction * create_adjustment_action( gchar const *name,
 
 // toggle button callbacks and updaters
 
-static void toggle_stroke( GtkToggleAction* act, gpointer data ) {
-    gboolean active = gtk_toggle_action_get_active( act );
-    prefs_set_int_attribute( "options.transform", "stroke", active ? 1 : 0 );
+static void toggle_stroke( GtkToggleAction* act, gpointer data )
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(act);
+    prefs->setBool("/options/transform/stroke", active);
     SPDesktop *desktop = (SPDesktop *)data;
     if ( active ) {
         desktop->messageStack()->flash(Inkscape::INFORMATION_MESSAGE, _("Now <b>stroke width</b> is <b>scaled</b> when objects are scaled."));
@@ -303,9 +306,11 @@ static void toggle_stroke( GtkToggleAction* act, gpointer data ) {
     }
 }
 
-static void toggle_corners( GtkToggleAction* act, gpointer data) {
-    gboolean active = gtk_toggle_action_get_active( act );
-    prefs_set_int_attribute( "options.transform", "rectcorners", active ? 1 : 0 );
+static void toggle_corners( GtkToggleAction* act, gpointer data)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(act);
+    prefs->setBool("/options/transform/rectcorners", active);
     SPDesktop *desktop = (SPDesktop *)data;
     if ( active ) {
         desktop->messageStack()->flash(Inkscape::INFORMATION_MESSAGE, _("Now <b>rounded rectangle corners</b> are <b>scaled</b> when rectangles are scaled."));
@@ -314,9 +319,11 @@ static void toggle_corners( GtkToggleAction* act, gpointer data) {
     }
 }
 
-static void toggle_gradient( GtkToggleAction *act, gpointer data ) {
-    gboolean active = gtk_toggle_action_get_active( act );
-    prefs_set_int_attribute( "options.transform", "gradient", active ? 1 : 0 );
+static void toggle_gradient( GtkToggleAction *act, gpointer data )
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(act);
+    prefs->setBool("/options/transform/gradient", active);
     SPDesktop *desktop = (SPDesktop *)data;
     if ( active ) {
         desktop->messageStack()->flash(Inkscape::INFORMATION_MESSAGE, _("Now <b>gradients</b> are <b>transformed</b> along with their objects when those are transformed (moved, scaled, rotated, or skewed)."));
@@ -325,9 +332,11 @@ static void toggle_gradient( GtkToggleAction *act, gpointer data ) {
     }
 }
 
-static void toggle_pattern( GtkToggleAction* act, gpointer data ) {
-    gboolean active = gtk_toggle_action_get_active( act );
-    prefs_set_int_attribute( "options.transform", "pattern", active ? 1 : 0 );
+static void toggle_pattern( GtkToggleAction* act, gpointer data )
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(act);
+    prefs->setInt("/options/transform/pattern", active);
     SPDesktop *desktop = (SPDesktop *)data;
     if ( active ) {
         desktop->messageStack()->flash(Inkscape::INFORMATION_MESSAGE, _("Now <b>patterns</b> are <b>transformed</b> along with their objects when those are transformed (moved, scaled, rotated, or skewed)."));
@@ -378,7 +387,8 @@ static GtkAction* create_action_for_verb( Inkscape::Verb* verb, Inkscape::UI::Vi
 void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
     Inkscape::UI::View::View *view = desktop;
-    Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1);
+    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     GtkAction* act = 0;
 
@@ -532,7 +542,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
                                                     _("When scaling objects, scale the stroke width by the same proportion"),
                                                     "transform_stroke",
                                                     Inkscape::ICON_SIZE_DECORATION );
-    gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs_get_int_attribute("options.transform", "stroke", 1) );
+    gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs->getBool("/options/transform/stroke", true) );
     g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_stroke), desktop) ;
     gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
     }
@@ -543,7 +553,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
                                                     _("When scaling rectangles, scale the radii of rounded corners"),
                                                     "transform_corners",
                                                   Inkscape::ICON_SIZE_DECORATION );
-    gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs_get_int_attribute("options.transform", "rectcorners", 1) );
+    gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs->getBool("/options/transform/rectcorners", true) );
     g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_corners), desktop) ;
     gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
     }
@@ -554,7 +564,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
                                                     _("Move gradients (in fill or stroke) along with the objects"),
                                                     "transform_gradient",
                                                   Inkscape::ICON_SIZE_DECORATION );
-    gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs_get_int_attribute("options.transform", "gradient", 1) );
+    gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs->getBool("/options/transform/gradient", true) );
     g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_gradient), desktop) ;
     gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
     }
@@ -565,7 +575,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
                                                     _("Move patterns (in fill or stroke) along with the objects"),
                                                     "transform_pattern",
                                                   Inkscape::ICON_SIZE_DECORATION );
-    gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs_get_int_attribute("options.transform", "pattern", 1) );
+    gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs->getBool("/options/transform/pattern", true) );
     g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_pattern), desktop) ;
     gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
     }
diff --git a/src/widgets/sp-color-icc-selector.cpp b/src/widgets/sp-color-icc-selector.cpp
index 43a2a3cbe..b18290923 100644
--- a/src/widgets/sp-color-icc-selector.cpp
+++ b/src/widgets/sp-color-icc-selector.cpp
@@ -24,7 +24,7 @@
 #include "color-profile.h"
 //#define DEBUG_LCMS
 #ifdef DEBUG_LCMS
-#include "prefs-utils.h"
+#include "preferences.h"
 #include <gtk/gtkmessagedialog.h>
 #endif // DEBUG_LCMS
 #endif // ENABLE_LCMS
@@ -34,10 +34,11 @@
 extern guint update_in_progress;
 #define DEBUG_MESSAGE(key, ...) \
 {\
-    gint dump = prefs_get_int_attribute_limited("options.scislac", #key, 0, 0, 1);\
-    gint dumpD = prefs_get_int_attribute_limited("options.scislac", #key"D", 0, 0, 1);\
-    gint dumpD2 = prefs_get_int_attribute_limited("options.scislac", #key"D2", 0, 0, 1);\
-    dumpD &= ( (update_in_progress == 0) || dumpD2 );\
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();\
+    bool dump = prefs->getBool("/options/scislac/" #key);\
+    bool dumpD = prefs->getBool("/options/scislac/" #key "D");\
+    bool dumpD2 = prefs->getBool("/options/scislac/" #key "D2");\
+    dumpD &&= ( (update_in_progress == 0) || dumpD2 );\
     if ( dump )\
     {\
         g_message( __VA_ARGS__ );\
diff --git a/src/widgets/sp-color-notebook.cpp b/src/widgets/sp-color-notebook.cpp
index 376cd8ee5..9766a9498 100644
--- a/src/widgets/sp-color-notebook.cpp
+++ b/src/widgets/sp-color-notebook.cpp
@@ -26,7 +26,7 @@
 #include <glibmm/i18n.h>
 
 #include "../dialogs/dialog-events.h"
-#include "../prefs-utils.h"
+#include "../preferences.h"
 #include "sp-color-notebook.h"
 #include "spw-utilities.h"
 #include "sp-color-scales.h"
@@ -97,19 +97,19 @@ sp_color_notebook_class_init (SPColorNotebookClass *klass)
 
 static void
 sp_color_notebook_switch_page(GtkNotebook *notebook,
-							  GtkNotebookPage *page,
-							  guint page_num,
-							  SPColorNotebook *colorbook)
+                              GtkNotebookPage *page,
+                              guint page_num,
+                              SPColorNotebook *colorbook)
 {
-	if ( colorbook )
-	{
+    if ( colorbook )
+    {
         ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
         nb->switchPage( notebook, page, page_num );
 
-	// remember the page we seitched to
-        prefs_set_int_attribute ("colorselector", "page", page_num);
-
-	}
+        // remember the page we seitched to
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->setInt("/colorselector/page", page_num);
+    }
 }
 
 void ColorNotebook::switchPage(GtkNotebook*,
@@ -274,7 +274,8 @@ void ColorNotebook::init()
                       XPAD, YPAD);
 
 	// restore the last active page
-	gtk_notebook_set_current_page (GTK_NOTEBOOK (_book), prefs_get_int_attribute ("colorselector", "page", 0));
+	Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+	gtk_notebook_set_current_page (GTK_NOTEBOOK (_book), prefs->getInt("/colorselector/page", 0));
 
 	{
 		gboolean found = FALSE;
diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
index b70684692..b945765db 100644
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
@@ -1,28 +1,25 @@
-/** \file
- * Controls bars for some of Inkscape's tools
- * (for some tools, they are in their own files)
+/** @file
+ * @brief Controls bars for some of Inkscape's tools (for some tools,
+ * they are in their own files)
+ */
+/* Authors:
+ *   MenTaLguY <mental@rydia.net>
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   bulia byak <buliabyak@users.sf.net>
+ *   Frank Felfe <innerspace@iname.com>
+ *   John Cliff <simarilius@yahoo.com>
+ *   David Turner <novalis@gnu.org>
+ *   Josh Andler <scislac@scislac.com>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *   Maximilian Albert <maximilian.albert@gmail.com>
+ *
+ * Copyright (C) 2004 David Turner
+ * Copyright (C) 2003 MenTaLguY
+ * Copyright (C) 1999-2008 authors
+ * Copyright (C) 2001-2002 Ximian, Inc.
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
  */
-
-/*
-*
-* Authors:
-*   MenTaLguY <mental@rydia.net>
-*   Lauris Kaplinski <lauris@kaplinski.com>
-*   bulia byak <buliabyak@users.sf.net>
-*   Frank Felfe <innerspace@iname.com>
-*   John Cliff <simarilius@yahoo.com>
-*   David Turner <novalis@gnu.org>
-*   Josh Andler <scislac@scislac.com>
-*   Jon A. Cruz <jon@joncruz.org>
-*   Maximilian Albert <maximilian.albert@gmail.com>
-*
-* Copyright (C) 2004 David Turner
-* Copyright (C) 2003 MenTaLguY
-* Copyright (C) 1999-2008 authors
-* Copyright (C) 2001-2002 Ximian, Inc.
-*
-* Released under GNU GPL, read the file 'COPYING' for more information
-*/
 
 #ifdef HAVE_CONFIG_H
 # include "config.h"
@@ -140,14 +137,14 @@ static void       sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* ma
 namespace { GtkWidget *sp_text_toolbox_new (SPDesktop *desktop); }
 
 
-Inkscape::IconSize prefToSize( gchar const *path, gchar const *attr, int base ) {
+Inkscape::IconSize prefToSize( Glib::ustring const &path, int base ) {
     static Inkscape::IconSize sizeChoices[] = {
         Inkscape::ICON_SIZE_LARGE_TOOLBAR,
         Inkscape::ICON_SIZE_SMALL_TOOLBAR,
         Inkscape::ICON_SIZE_MENU
     };
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    int index = prefs->getIntLimited( path, attr, base, 0, G_N_ELEMENTS(sizeChoices) );
+    int index = prefs->getIntLimited( path, base, 0, G_N_ELEMENTS(sizeChoices) );
     return sizeChoices[index];
 }
 
@@ -194,29 +191,29 @@ static struct {
     { "SPNodeContext",   "node_toolbox",   0, sp_node_toolbox_prep,              "NodeToolbar",
       SP_VERB_INVALID, 0, 0},
     { "SPTweakContext",   "tweak_toolbox",   0, sp_tweak_toolbox_prep,              "TweakToolbar",
-      SP_VERB_CONTEXT_TWEAK_PREFS, "tools.tweak", N_("Color/opacity used for color tweaking")},
+      SP_VERB_CONTEXT_TWEAK_PREFS, "/tools/tweak", N_("Color/opacity used for color tweaking")},
     { "SPZoomContext",   "zoom_toolbox",   0, sp_zoom_toolbox_prep,              "ZoomToolbar",
       SP_VERB_INVALID, 0, 0},
     { "SPStarContext",   "star_toolbox",   0, sp_star_toolbox_prep,              "StarToolbar",
-      SP_VERB_CONTEXT_STAR_PREFS,   "tools.shapes.star",     N_("Style of new stars")},
+      SP_VERB_CONTEXT_STAR_PREFS,   "/tools/shapes/star",     N_("Style of new stars")},
     { "SPRectContext",   "rect_toolbox",   0, sp_rect_toolbox_prep,              "RectToolbar",
-      SP_VERB_CONTEXT_RECT_PREFS,   "tools.shapes.rect",     N_("Style of new rectangles")},
+      SP_VERB_CONTEXT_RECT_PREFS,   "/tools/shapes/rect",     N_("Style of new rectangles")},
     { "Box3DContext",  "3dbox_toolbox",  0, box3d_toolbox_prep,             "3DBoxToolbar",
-      SP_VERB_CONTEXT_3DBOX_PREFS,  "tools.shapes.3dbox",    N_("Style of new 3D boxes")},
+      SP_VERB_CONTEXT_3DBOX_PREFS,  "/tools/shapes/3dbox",    N_("Style of new 3D boxes")},
     { "SPArcContext",    "arc_toolbox",    0, sp_arc_toolbox_prep,               "ArcToolbar",
-      SP_VERB_CONTEXT_ARC_PREFS,    "tools.shapes.arc",      N_("Style of new ellipses")},
+      SP_VERB_CONTEXT_ARC_PREFS,    "/tools/shapes/arc",      N_("Style of new ellipses")},
     { "SPSpiralContext", "spiral_toolbox", 0, sp_spiral_toolbox_prep,            "SpiralToolbar",
-      SP_VERB_CONTEXT_SPIRAL_PREFS, "tools.shapes.spiral",   N_("Style of new spirals")},
+      SP_VERB_CONTEXT_SPIRAL_PREFS, "/tools/shapes/spiral",   N_("Style of new spirals")},
     { "SPPencilContext", "pencil_toolbox", 0, sp_pencil_toolbox_prep,            "PencilToolbar",
-      SP_VERB_CONTEXT_PENCIL_PREFS, "tools.freehand.pencil", N_("Style of new paths created by Pencil")},
+      SP_VERB_CONTEXT_PENCIL_PREFS, "/tools/freehand/pencil", N_("Style of new paths created by Pencil")},
     { "SPPenContext", "pen_toolbox", 0, sp_pen_toolbox_prep,                     "PenToolbar",
-      SP_VERB_CONTEXT_PEN_PREFS,    "tools.freehand.pen",    N_("Style of new paths created by Pen")},
+      SP_VERB_CONTEXT_PEN_PREFS,    "/tools/freehand/pen",    N_("Style of new paths created by Pen")},
     { "SPDynaDrawContext", "calligraphy_toolbox", 0, sp_calligraphy_toolbox_prep,"CalligraphyToolbar",
-      SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "tools.calligraphic", N_("Style of new calligraphic strokes")},
+      SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "/tools/calligraphic", N_("Style of new calligraphic strokes")},
     { "SPEraserContext", "eraser_toolbox", 0, sp_eraser_toolbox_prep,"EraserToolbar",
-      SP_VERB_CONTEXT_ERASER_PREFS, "tools.eraser", _("TBD")},
+      SP_VERB_CONTEXT_ERASER_PREFS, "/tools/eraser", _("TBD")},
     { "SPLPEToolContext", "lpetool_toolbox", 0, sp_lpetool_toolbox_prep, "LPEToolToolbar",
-      SP_VERB_CONTEXT_LPETOOL_PREFS, "tools.lpetool", _("TBD")},
+      SP_VERB_CONTEXT_LPETOOL_PREFS, "/tools/lpetool", _("TBD")},
     { "SPTextContext",   "text_toolbox",   sp_text_toolbox_new, 0,               0,
       SP_VERB_INVALID, 0, 0},
     { "SPDropperContext", "dropper_toolbox", 0, sp_dropper_toolbox_prep,         "DropperToolbar",
@@ -226,7 +223,7 @@ static struct {
     { "SPConnectorContext", "connector_toolbox", 0, sp_connector_toolbox_prep,   "ConnectorToolbar",
       SP_VERB_INVALID, 0, 0},
     { "SPFloodContext",  "paintbucket_toolbox",  0, sp_paintbucket_toolbox_prep, "PaintbucketToolbar",
-      SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "tools.paintbucket", N_("Style of Paint Bucket fill objects")},
+      SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "/tools/paintbucket", N_("Style of Paint Bucket fill objects")},
     { NULL, NULL, NULL, NULL, NULL, SP_VERB_INVALID, NULL, NULL }
 };
 
@@ -276,6 +273,7 @@ static gchar const * ui_descr =
         "    <toolitem action='NodeCuspAction' />"
         "    <toolitem action='NodeSmoothAction' />"
         "    <toolitem action='NodeSymmetricAction' />"
+        "    <toolitem action='NodeAutoAction' />"
         "    <separator />"
         "    <toolitem action='NodeLineAction' />"
         "    <toolitem action='NodeCurveAction' />"
@@ -561,7 +559,7 @@ Gtk::Widget* VerbAction::create_menu_item_vfunc()
 Gtk::Widget* VerbAction::create_tool_item_vfunc()
 {
 //     Gtk::Widget* widg = Gtk::Action::create_tool_item_vfunc();
-    Inkscape::IconSize toolboxSize = prefToSize("toolbox.tools", "small");
+    Inkscape::IconSize toolboxSize = prefToSize("/toolbox/tools/small");
     GtkWidget* toolbox = 0;
     GtkWidget *button = sp_toolbox_button_new_from_verb_with_doubleclick( toolbox, toolboxSize,
                                                                           SP_BUTTON_TYPE_TOGGLE,
@@ -768,7 +766,7 @@ Glib::RefPtr<Gtk::ActionGroup> create_or_fetch_actions( SPDesktop* desktop )
         SP_VERB_ZOOM_SELECTION,
     };
 
-    Inkscape::IconSize toolboxSize = prefToSize("toolbox", "small");
+    Inkscape::IconSize toolboxSize = prefToSize("/toolbox/small");
 
     static std::map<SPDesktop*, Glib::RefPtr<Gtk::ActionGroup> > groups;
     Glib::RefPtr<Gtk::ActionGroup> mainActions;
@@ -913,7 +911,7 @@ sp_commands_toolbox_new()
 
 static EgeAdjustmentAction * create_adjustment_action( gchar const *name,
                                                        gchar const *label, gchar const *shortLabel, gchar const *tooltip,
-                                                       gchar const *path, gchar const *data, gdouble def,
+                                                       Glib::ustring const &path, gdouble def,
                                                        GtkWidget *focusTarget,
                                                        GtkWidget *us,
                                                        GObject *dataKludge,
@@ -924,7 +922,7 @@ static EgeAdjustmentAction * create_adjustment_action( gchar const *name,
                                                        gdouble climb = 0.1, guint digits = 3, double factor = 1.0 )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    GtkAdjustment* adj = GTK_ADJUSTMENT( gtk_adjustment_new( prefs->getDouble(path, data, def) * factor,
+    GtkAdjustment* adj = GTK_ADJUSTMENT( gtk_adjustment_new( prefs->getDouble(path, def) * factor,
                                                              lower, upper, step, page, page ) );
     if (us) {
         sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(us), adj );
@@ -950,7 +948,9 @@ static EgeAdjustmentAction * create_adjustment_action( gchar const *name,
     }
 
     if ( dataKludge ) {
-        g_object_set_data( dataKludge, data, adj );
+        // Rather lame, but it's the only place where we need to get the entry name
+        // but we don't have an Entry
+        g_object_set_data( dataKludge, prefs->getEntry(path).getEntryName().data(), adj );
     }
 
     // Using a cast just to make sure we pass in the right kind of function pointer
@@ -1060,10 +1060,17 @@ sp_node_path_edit_symmetrical(void)
     if (shape_editor) shape_editor->set_node_type(Inkscape::NodePath::NODE_SYMM);
 }
 
+void
+sp_node_path_edit_auto(void)
+{
+    ShapeEditor *shape_editor = get_current_shape_editor();
+    if (shape_editor) shape_editor->set_node_type(Inkscape::NodePath::NODE_AUTO);
+}
+
 static void toggle_show_handles (GtkToggleAction *act, gpointer /*data*/) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     bool show = gtk_toggle_action_get_active( act );
-    prefs->setBool("tools.nodes", "show_handles",  show);
+    prefs->setBool("/tools/nodes/show_handles",  show);
     ShapeEditor *shape_editor = get_current_shape_editor();
     if (shape_editor) shape_editor->show_handles(show);
 }
@@ -1071,7 +1078,7 @@ static void toggle_show_handles (GtkToggleAction *act, gpointer /*data*/) {
 static void toggle_show_helperpath (GtkToggleAction *act, gpointer /*data*/) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     bool show = gtk_toggle_action_get_active( act );
-    prefs->setBool("tools.nodes", "show_helperpath",  show);
+    prefs->setBool("/tools/nodes/show_helperpath",  show);
     ShapeEditor *shape_editor = get_current_shape_editor();
     if (shape_editor) shape_editor->show_helperpath(show);
 }
@@ -1164,7 +1171,7 @@ sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_
     SPUnit const *unit = tracker->getActiveUnit();
 
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
-        prefs->setDouble("tools.nodes", value_name, sp_units_get_pixels(adj->value, *unit));
+        prefs->setDouble(Glib::ustring("/tools/nodes/") + value_name, sp_units_get_pixels(adj->value, *unit));
     }
 
     // quit if run by the attr_changed listener
@@ -1258,7 +1265,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
     tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units );
     g_object_set_data( holder, "tracker", tracker );
 
-    Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1);
+    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
 
     {
         InkAction* inky = ink_action_new( "NodeInsertAction",
@@ -1355,6 +1362,16 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
     }
 
     {
+        InkAction* inky = ink_action_new( "NodeAutoAction",
+                                          _("Node Auto"),
+                                          _("Make selected nodes auto-smooth"),
+                                          "node_auto",
+                                          secondarySize );
+        g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_auto), 0 );
+        gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
+    }
+
+    {
         InkAction* inky = ink_action_new( "NodeLineAction",
                                           _("Node Line"),
                                           _("Make selected segments lines"),
@@ -1382,7 +1399,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                                       Inkscape::ICON_SIZE_DECORATION );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_handles), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("tools.nodes", "show_handles", true) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/nodes/show_handles", true) );
     }
 
     {
@@ -1393,7 +1410,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                                       Inkscape::ICON_SIZE_DECORATION );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_helperpath), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("tools.nodes", "show_helperpath", false) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/nodes/show_helperpath", false) );
     }
 
     {
@@ -1436,7 +1453,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
         gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
         eact = create_adjustment_action( "NodeXAction",
                                          _("X coordinate:"), _("X:"), _("X coordinate of selected node(s)"),
-                                         "tools.nodes", "Xcoord", 0,
+                                         "/tools/nodes/Xcoord", 0,
                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-nodes",
                                          -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -1454,7 +1471,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
         gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
         eact = create_adjustment_action( "NodeYAction",
                                          _("Y coordinate:"), _("Y:"), _("Y coordinate of selected node(s)"),
-                                         "tools.nodes", "Ycoord", 0,
+                                         "/tools/nodes/Ycoord", 0,
                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
                                          -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -1608,10 +1625,10 @@ setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
     gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal );
 
     GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, "/ui/ToolToolbar" );
-    if ( prefs->getIntLimited("toolbox", "icononly", 1, 0, 1) ) {
+    if ( prefs->getBool("/toolbox/icononly", true) ) {
         gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
     }
-    Inkscape::IconSize toolboxSize = prefToSize("toolbox.tools", "small");
+    Inkscape::IconSize toolboxSize = prefToSize("/toolbox/tools/small");
     gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), (GtkIconSize)toolboxSize );
 
     gtk_toolbar_set_orientation(GTK_TOOLBAR(toolBar), GTK_ORIENTATION_VERTICAL);
@@ -1625,7 +1642,7 @@ setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
     }
 
     gtk_container_add( GTK_CONTAINER(toolbox), toolBar );
-//     Inkscape::IconSize toolboxSize = prefToSize("toolbox.tools", "small");
+//     Inkscape::IconSize toolboxSize = prefToSize("/toolbox/tools/small");
 }
 
 
@@ -1703,9 +1720,8 @@ setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
             g_free( tmp );
             tmp = 0;
 
-            Inkscape::IconSize toolboxSize = prefToSize("toolbox", "small");
-            /// @todo convert to getBool
-            if ( prefs->getIntLimited( "toolbox", "icononly", 1, 0, 1 ) ) {
+            Inkscape::IconSize toolboxSize = prefToSize("/toolbox/small");
+            if ( prefs->getBool( "/toolbox/icononly", true) ) {
                 gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
             }
             gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast<GtkIconSize>(toolboxSize) );
@@ -1803,11 +1819,11 @@ setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
     gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal );
 
     GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, "/ui/CommandsToolbar" );
-    if ( prefs->getBool("toolbox", "icononly", true) ) {
+    if ( prefs->getBool("/toolbox/icononly", true) ) {
         gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
     }
 
-    Inkscape::IconSize toolboxSize = prefToSize("toolbox", "small");
+    Inkscape::IconSize toolboxSize = prefToSize("/toolbox/small");
     gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), (GtkIconSize)toolboxSize );
 
     gtk_toolbar_set_orientation(GTK_TOOLBAR(toolBar), GTK_ORIENTATION_HORIZONTAL);
@@ -1870,7 +1886,7 @@ static void sp_stb_magnitude_value_changed( GtkAdjustment *adj, GObject *dataKlu
         // do not remember prefs if this call is initiated by an undo change, because undoing object
         // creation sets bogus values to its attributes before it is deleted
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setInt("tools.shapes.star", "magnitude", (gint)adj->value);
+        prefs->setInt("/tools/shapes/star/magnitude", (gint)adj->value);
     }
 
     // quit if run by the attr_changed listener
@@ -1908,7 +1924,7 @@ static void sp_stb_proportion_value_changed( GtkAdjustment *adj, GObject *dataKl
 
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble("tools.shapes.star", "proportion", adj->value);
+        prefs->setDouble("/tools/shapes/star/proportion", adj->value);
     }
 
     // quit if run by the attr_changed listener
@@ -1952,7 +1968,7 @@ static void sp_stb_sides_flat_state_changed( EgeSelectOneAction *act, GObject *d
 
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setBool( "tools.shapes.star", "isflatsided", flat);
+        prefs->setBool( "/tools/shapes/star/isflatsided", flat);
     }
 
     // quit if run by the attr_changed listener
@@ -1995,7 +2011,7 @@ static void sp_stb_rounded_value_changed( GtkAdjustment *adj, GObject *dataKludg
 
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble("tools.shapes.star", "rounded", (gdouble) adj->value);
+        prefs->setDouble("/tools/shapes/star/rounded", (gdouble) adj->value);
     }
 
     // quit if run by the attr_changed listener
@@ -2030,7 +2046,7 @@ static void sp_stb_randomized_value_changed( GtkAdjustment *adj, GObject *dataKl
 
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble("tools.shapes.star", "randomized", (gdouble) adj->value);
+        prefs->setDouble("/tools/shapes/star/randomized", (gdouble) adj->value);
     }
 
     // quit if run by the attr_changed listener
@@ -2077,7 +2093,7 @@ static void star_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *n
     GtkAdjustment *adj = 0;
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    bool isFlatSided = prefs->getBool("tools.shapes.star", "isflatsided", true);
+    bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true);
 
     if (!strcmp(name, "inkscape:randomized")) {
         adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(tbl), "randomized") );
@@ -2223,7 +2239,7 @@ sp_toolbox_add_label(GtkWidget *tbl, gchar const *title, bool wide)
 
 static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
-    Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1);
+    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
 
     {
         EgeOutputAction* act = ege_output_action_new( "StarStateAction", _("<b>New:</b>"), "", 0 );
@@ -2235,7 +2251,7 @@ static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
     {
         EgeAdjustmentAction* eact = 0;
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        bool isFlatSided = prefs->getBool("tools.shapes.star", "isflatsided", true);
+        bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true);
 
         /* Flatsided checkbox */
         {
@@ -2277,7 +2293,7 @@ static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
         gdouble values[] = {3, 4, 5, 6, 7, 8, 10, 12, 20};
         eact = create_adjustment_action( "MagnitudeAction",
                                          _("Corners"), _("Corners:"), _("Number of corners of a polygon or star"),
-                                         "tools.shapes.star", "magnitude", 3,
+                                         "/tools/shapes/star/magnitude", 3,
                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                          3, 1024, 1, 5,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -2296,7 +2312,7 @@ static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
                                          // TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle.
                                          // Base radius is the same for the closest handle.
                                          _("Base radius to tip radius ratio"),
-                                         "tools.shapes.star", "proportion", 0.5,
+                                         "/tools/shapes/star/proportion", 0.5,
                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                          0.01, 1.0, 0.01, 0.1,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -2317,7 +2333,7 @@ static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
         gdouble values[] = {-1, -0.2, -0.03, 0, 0.05, 0.1, 0.2, 0.3, 0.5, 1, 10};
         eact = create_adjustment_action( "RoundednessAction",
                                          _("Rounded"), _("Rounded:"), _("How much rounded are the corners (0 for sharp)"),
-                                         "tools.shapes.star", "rounded", 0.0,
+                                         "/tools/shapes/star/rounded", 0.0,
                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                          -10.0, 10.0, 0.01, 0.1,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -2332,7 +2348,7 @@ static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
         gdouble values[] = {0, 0.01, 0.1, 0.5, 10};
         eact = create_adjustment_action( "RandomizationAction",
                                          _("Randomized"), _("Randomized:"), _("Scatter randomly the corners and angles"),
-                                         "tools.shapes.star", "randomized", 0.0,
+                                         "/tools/shapes/star/randomized", 0.0,
                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                          -10.0, 10.0, 0.001, 0.01,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -2392,7 +2408,7 @@ sp_rtb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name,
 
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble("tools.shapes.rect", value_name, sp_units_get_pixels(adj->value, *unit));
+        prefs->setDouble(Glib::ustring("/tools/shapes/rect/") + value_name, sp_units_get_pixels(adj->value, *unit));
     }
 
     // quit if run by the attr_changed listener
@@ -2592,7 +2608,7 @@ sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
 static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
     EgeAdjustmentAction* eact = 0;
-    Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1);
+    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
 
     {
         EgeOutputAction* act = ege_output_action_new( "RectStateAction", _("<b>New:</b>"), "", 0 );
@@ -2614,7 +2630,7 @@ static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
         gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
         eact = create_adjustment_action( "RectWidthAction",
                                          _("Width"), _("W:"), _("Width of rectangle"),
-                                         "tools.shapes.rect", "width", 0,
+                                         "/tools/shapes/rect/width", 0,
                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-rect",
                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -2631,7 +2647,7 @@ static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
         gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
         eact = create_adjustment_action( "RectHeightAction",
                                          _("Height"), _("H:"), _("Height of rectangle"),
-                                         "tools.shapes.rect", "height", 0,
+                                         "/tools/shapes/rect/height", 0,
                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -2648,7 +2664,7 @@ static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
         gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};
         eact = create_adjustment_action( "RadiusXAction",
                                          _("Horizontal radius"), _("Rx:"), _("Horizontal radius of rounded corners"),
-                                         "tools.shapes.rect", "rx", 0,
+                                         "/tools/shapes/rect/rx", 0,
                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -2663,7 +2679,7 @@ static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
         gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};
         eact = create_adjustment_action( "RadiusYAction",
                                          _("Vertical radius"), _("Ry:"), _("Vertical radius of rounded corners"),
-                                         "tools.shapes.rect", "ry", 0,
+                                         "/tools/shapes/rect/ry", 0,
                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -2777,16 +2793,14 @@ static void box3d_persp_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar c
 {
     GtkWidget *tbl = GTK_WIDGET(data);
 
-    // quit if run by the attr_changed listener
-    // note: it used to work without the differently called freeze_ attributes (here and in
-    //       box3d_angle_value_changed()) but I now it doesn't so I'm leaving them in for now
-    if (g_object_get_data(G_OBJECT(tbl), "freeze_angle")) {
+    // quit if run by the attr_changed or selection changed listener
+    if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
         return;
     }
 
     // set freeze so that it can be caught in box3d_angle_z_value_changed() (to avoid calling
     // sp_document_maybe_done() when the document is undo insensitive)
-    g_object_set_data(G_OBJECT(tbl), "freeze_attr", GINT_TO_POINTER(TRUE));
+    g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
 
     // TODO: Only update the appropriate part of the toolbar
 //    if (!strcmp(name, "inkscape:vp_z")) {
@@ -2796,7 +2810,7 @@ static void box3d_persp_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar c
     Persp3D *persp = persp3d_get_from_repr(repr);
     persp3d_update_box_reprs(persp);
 
-    g_object_set_data(G_OBJECT(tbl), "freeze_attr", GINT_TO_POINTER(FALSE));
+    g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
 }
 
 static Inkscape::XML::NodeEventVector box3d_persp_tb_repr_events =
@@ -2838,9 +2852,11 @@ box3d_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
 
         inkscape_active_document()->current_persp3d = persp3d_get_from_repr(persp_repr);
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setString("tools.shapes.3dbox", "persp", persp_repr->attribute("id"));
+        prefs->setString("/tools/shapes/3dbox/persp", persp_repr->attribute("id"));
 
+        g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE));
         box3d_resync_toolbar(persp_repr, tbl);
+        g_object_set_data(tbl, "freeze", GINT_TO_POINTER(FALSE));
     }
 }
 
@@ -2850,15 +2866,13 @@ box3d_angle_value_changed(GtkAdjustment *adj, GObject *dataKludge, Proj::Axis ax
     SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
     SPDocument *document = sp_desktop_document(desktop);
 
-    // quit if run by the attr_changed listener
-    // note: it used to work without the differently called freeze_ attributes (here and in
-    //       box3d_persp_tb_event_attr_changed()) but I now it doesn't so I'm leaving them in for now
-    if (g_object_get_data( dataKludge, "freeze_attr" )) {
+    // quit if run by the attr_changed or selection changed listener
+    if (g_object_get_data( dataKludge, "freeze" )) {
         return;
     }
 
     // in turn, prevent listener from responding
-    g_object_set_data(dataKludge, "freeze_angle", GINT_TO_POINTER(TRUE));
+    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();
@@ -2874,7 +2888,7 @@ box3d_angle_value_changed(GtkAdjustment *adj, GObject *dataKludge, Proj::Axis ax
     // TODO: use the correct axis here, too
     sp_document_maybe_done(document, "perspangle", SP_VERB_CONTEXT_3DBOX, _("3D Box: Change perspective (angle of infinite axis)"));
 
-    g_object_set_data( dataKludge, "freeze_angle", GINT_TO_POINTER(FALSE) );
+    g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
 }
 
 
@@ -2945,7 +2959,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
                                          _("Angle in X direction"), _("Angle X:"),
                                          // Translators: PL is short for 'perspective line'
                                          _("Angle of PLs in X direction"),
-                                         "tools.shapes.3dbox", "box3d_angle_x", 30,
+                                         "/tools/shapes/3dbox/box3d_angle_x", 30,
                                          GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-box3d",
                                          -360.0, 360.0, 1.0, 10.0,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -2973,8 +2987,8 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_object_set_data( holder, "box3d_vp_x_state_action", act );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_x_state_changed), box3d_angle_x );
-        gtk_action_set_sensitive( GTK_ACTION(box3d_angle_x), !prefs->getBool("tools.shapes.3dbox", "vp_x_state", true) );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("tools.shapes.3dbox", "vp_x_state", true) );
+        gtk_action_set_sensitive( GTK_ACTION(box3d_angle_x), !prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) );
     }
 
     /* Angle Y */
@@ -2985,7 +2999,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
                                          _("Angle in Y direction"), _("Angle Y:"),
                                          // Translators: PL is short for 'perspective line'
                                          _("Angle of PLs in Y direction"),
-                                         "tools.shapes.3dbox", "box3d_angle_y", 30,
+                                         "/tools/shapes/3dbox/box3d_angle_y", 30,
                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                          -360.0, 360.0, 1.0, 10.0,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -3012,8 +3026,8 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_object_set_data( holder, "box3d_vp_y_state_action", act );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_y_state_changed), box3d_angle_y );
-        gtk_action_set_sensitive( GTK_ACTION(box3d_angle_y), !prefs->getBool("tools.shapes.3dbox", "vp_y_state", true) );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("tools.shapes.3dbox", "vp_y_state", true) );
+        gtk_action_set_sensitive( GTK_ACTION(box3d_angle_y), !prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) );
     }
 
     /* Angle Z */
@@ -3024,7 +3038,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
                                          _("Angle in Z direction"), _("Angle Z:"),
                                          // Translators: PL is short for 'perspective line'
                                          _("Angle of PLs in Z direction"),
-                                         "tools.shapes.3dbox", "box3d_angle_z", 30,
+                                         "/tools/shapes/3dbox/box3d_angle_z", 30,
                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                          -360.0, 360.0, 1.0, 10.0,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -3051,8 +3065,8 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_object_set_data( holder, "box3d_vp_z_state_action", act );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_z_state_changed), box3d_angle_z );
-        gtk_action_set_sensitive( GTK_ACTION(box3d_angle_z), !prefs->getBool("tools.shapes.3dbox", "vp_z_state", true) );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("tools.shapes.3dbox", "vp_z_state", true) );
+        gtk_action_set_sensitive( GTK_ACTION(box3d_angle_z), !prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) );
     }
 
     sigc::connection *connection = new sigc::connection(
@@ -3067,13 +3081,13 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
 //########################
 
 static void
-sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name)
+sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, Glib::ustring const &value_name)
 {
     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
 
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble("tools.shapes.spiral", value_name, adj->value);
+        prefs->setDouble("/tools/shapes/spiral/" + value_name, adj->value);
     }
 
     // quit if run by the attr_changed listener
@@ -3084,7 +3098,7 @@ sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_nam
     // in turn, prevent listener from responding
     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
 
-    gchar* namespaced_name = g_strconcat("sodipodi:", value_name, NULL);
+    gchar* namespaced_name = g_strconcat("sodipodi:", value_name.data(), NULL);
 
     bool modmade = false;
     for (GSList const *items = sp_desktop_selection(desktop)->itemList();
@@ -3233,7 +3247,7 @@ sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl
 static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
     EgeAdjustmentAction* eact = 0;
-    Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1);
+    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
 
     {
         EgeOutputAction* act = ege_output_action_new( "SpiralStateAction", _("<b>New:</b>"), "", 0 );
@@ -3248,7 +3262,7 @@ static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio
         gdouble values[] = {0.01, 0.5, 1, 2, 3, 5, 10, 20, 50, 100};
         eact = create_adjustment_action( "SpiralRevolutionAction",
                                          _("Number of turns"), _("Turns:"), _("Number of revolutions"),
-                                         "tools.shapes.spiral", "revolution", 3.0,
+                                         "/tools/shapes/spiral/revolution", 3.0,
                                          GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-spiral",
                                          0.01, 1024.0, 0.1, 1.0,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -3262,7 +3276,7 @@ static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio
         gdouble values[] = {0, 0.1, 0.5, 1, 1.5, 5, 20};
         eact = create_adjustment_action( "SpiralExpansionAction",
                                          _("Divergence"), _("Divergence:"), _("How much denser/sparser are outer revolutions; 1 = uniform"),
-                                         "tools.shapes.spiral", "expansion", 1.0,
+                                         "/tools/shapes/spiral/expansion", 1.0,
                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                          0.0, 1000.0, 0.01, 1.0,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -3276,7 +3290,7 @@ static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio
         gdouble values[] = {0, 0.5, 0.9};
         eact = create_adjustment_action( "SpiralT0Action",
                                          _("Inner radius"), _("Inner radius:"), _("Radius of the innermost revolution (relative to the spiral size)"),
-                                         "tools.shapes.spiral", "t0", 0.0,
+                                         "/tools/shapes/spiral/t0", 0.0,
                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                          0.0, 0.999, 0.01, 1.0,
                                          labels, values, G_N_ELEMENTS(labels),
@@ -3308,13 +3322,13 @@ static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio
 //########################
 
 /* This is used in generic functions below to share large portions of code between pen and pencil tool */
-static char const *
+static Glib::ustring const
 freehand_tool_name(GObject *dataKludge)
 {
     SPDesktop *desktop = (SPDesktop *) g_object_get_data(dataKludge, "desktop");
     return ( tools_isactive(desktop, TOOLS_FREEHAND_PEN)
-             ? "tools.freehand.pen"
-             : "tools.freehand.pencil" );
+             ? "/tools/freehand/pen"
+             : "/tools/freehand/pencil" );
 }
 
 static void freehand_mode_changed(EgeSelectOneAction* act, GObject* tbl)
@@ -3322,7 +3336,7 @@ static void freehand_mode_changed(EgeSelectOneAction* act, GObject* tbl)
     gint mode = ege_select_one_action_get_active(act);
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt(freehand_tool_name(tbl), "freehand-mode", mode);
+    prefs->setInt(freehand_tool_name(tbl) + "/freehand-mode", mode);
 
     SPDesktop *desktop = (SPDesktop *) g_object_get_data(tbl, "desktop");
 
@@ -3339,8 +3353,8 @@ static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* ho
     /* Freehand mode toggle buttons */
     {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        guint freehandMode = prefs->getInt(( tool_is_pencil ? "tools.freehand.pencil" : "tools.freehand.pen" ), "freehand-mode", 0);
-        Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1);
+        guint freehandMode = prefs->getInt(( tool_is_pencil ? "/tools/freehand/pencil/freehand-mode" : "/tools/freehand/pen/freehand-mode" ), 0);
+        Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
 
         {
             GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
@@ -3398,7 +3412,7 @@ static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* ho
 static void freehand_change_shape(EgeSelectOneAction* act, GObject *dataKludge) {
     gint shape = ege_select_one_action_get_active( act );
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt(freehand_tool_name(dataKludge), "shape", shape);
+    prefs->setInt(freehand_tool_name(dataKludge) + "/shape", shape);
 }
 
 /**
@@ -3439,7 +3453,7 @@ freehand_add_advanced_shape_options(GtkActionGroup* mainActions, GObject* holder
             _("Shape:"), ("Shape"), NULL, GTK_TREE_MODEL(model));
         g_object_set( act1, "short_label", _("Shape:"), NULL );
         ege_select_one_action_set_appearance( act1, "compact" );
-        ege_select_one_action_set_active( act1, prefs->getInt(( tool_is_pencil ? "tools.freehand.pencil" : "tools.freehand.pen" ), "shape", 0) );
+        ege_select_one_action_set_active( act1, prefs->getInt(( tool_is_pencil ? "/tools/freehand/pencil/shape" : "/tools/freehand/pen/shape" ), 0) );
         g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(freehand_change_shape), holder );
         gtk_action_group_add_action( mainActions, GTK_ACTION(act1) );
         g_object_set_data( holder, "shape_action", act1 );
@@ -3473,7 +3487,6 @@ sp_pencil_tb_defaults(GtkWidget */*widget*/, GtkObject *obj)
 static void
 sp_pencil_tb_tolerance_value_changed(GtkAdjustment *adj, GObject *tbl)
 {
-
     // quit if run by the attr_changed listener
     if (g_object_get_data( tbl, "freeze" )) {
         return;
@@ -3481,45 +3494,36 @@ sp_pencil_tb_tolerance_value_changed(GtkAdjustment *adj, GObject *tbl)
     // in turn, prevent listener from responding
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
-    prefs->setDouble("tools.freehand.pencil", "tolerance", adj->value);
+    prefs->setDouble("/tools/freehand/pencil/tolerance", adj->value);
     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-
 }
 
-
-
-static void
-sp_pencil_tb_tolerance_value_changed_external(Inkscape::XML::Node */*repr*/,
-                                              const gchar */*key*/,
-                                              const gchar */*oldval*/,
-                                              const gchar */*newval*/,
-                                              bool /*is_interactive*/,
-                                              void * data)
-{
-    GObject* tbl = G_OBJECT(data);
-    if (g_object_get_data( tbl, "freeze" )) {
-        return;
+class PencilToleranceObserver : public Inkscape::Preferences::Observer {
+public:
+    PencilToleranceObserver(Glib::ustring const &path, GObject *x) : Observer(path), _obj(x)
+    {
+        g_object_set_data(_obj, "prefobserver", this);
     }
+    virtual ~PencilToleranceObserver() {
+        if (g_object_get_data(_obj, "prefobserver") == this) {
+	        g_object_set_data(_obj, "prefobserver", NULL);
+        }
+    }
+    virtual void notify(Inkscape::Preferences::Entry const &val) {
+        GObject* tbl = _obj;
+        if (g_object_get_data( tbl, "freeze" )) {
+            return;
+        }
+        g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
 
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
-
-    GtkAdjustment * adj = (GtkAdjustment*)g_object_get_data(tbl,
-                                                            "tolerance");
-
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    double v = prefs->getDouble("tools.freehand.pencil", "tolerance", adj->value);
-    gtk_adjustment_set_value(adj, v);
-    g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
-
-}
+        GtkAdjustment * adj = (GtkAdjustment*)g_object_get_data(tbl, "tolerance");
 
-static Inkscape::XML::NodeEventVector pencil_node_events =
-{
-    NULL,
-    NULL,
-    sp_pencil_tb_tolerance_value_changed_external,
-    NULL,
-    NULL,
+        double v = val.getDouble(adj->value);
+        gtk_adjustment_set_value(adj, v);
+        g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+    }
+private:
+    GObject *_obj;
 };
 
 
@@ -3536,7 +3540,7 @@ static void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio
         eact = create_adjustment_action( "PencilToleranceAction",
                                          _("Smoothing:"), _("Smoothing: "),
                  _("How much smoothing (simplifying) is applied to the line"),
-                                         "tools.freehand.pencil", "tolerance",
+                                         "/tools/freehand/pencil/tolerance",
                                          3.0,
                                          GTK_WIDGET(desktop->canvas), NULL,
                                          holder, TRUE, "altx-pencil",
@@ -3547,11 +3551,8 @@ static void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio
         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
 
-        Inkscape::XML::Node *repr = inkscape_get_repr(INKSCAPE,
-                                                      "tools.freehand.pencil");
-        repr->addListener(&pencil_node_events, G_OBJECT(holder));
-        g_object_set_data(G_OBJECT(holder), "repr", repr);
-
+        PencilToleranceObserver *obs =
+            new PencilToleranceObserver("/tools/freehand/pencil/tolerance", G_OBJECT(holder));
     }
 
     /* advanced shape options */
@@ -3580,26 +3581,26 @@ static void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio
 static void sp_tweak_width_value_changed( GtkAdjustment *adj, GObject */*tbl*/ )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "tools.tweak", "width", adj->value * 0.01 );
+    prefs->setDouble( "/tools/tweak/width", adj->value * 0.01 );
 }
 
 static void sp_tweak_force_value_changed( GtkAdjustment *adj, GObject */*tbl*/ )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "tools.tweak", "force", adj->value * 0.01 );
+    prefs->setDouble( "/tools/tweak/force", adj->value * 0.01 );
 }
 
 static void sp_tweak_pressure_state_changed( GtkToggleAction *act, gpointer /*data*/ )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("tools.tweak", "usepressure", gtk_toggle_action_get_active(act));
+    prefs->setBool("/tools/tweak/usepressure", gtk_toggle_action_get_active(act));
 }
 
 static void sp_tweak_mode_changed( EgeSelectOneAction *act, GObject *tbl )
 {
     int mode = ege_select_one_action_get_active( act );
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("tools.tweak", "mode", mode);
+    prefs->setInt("/tools/tweak/mode", mode);
 
     GtkAction *doh = GTK_ACTION(g_object_get_data( tbl, "tweak_doh"));
     GtkAction *dos = GTK_ACTION(g_object_get_data( tbl, "tweak_dos"));
@@ -3627,29 +3628,29 @@ static void sp_tweak_mode_changed( EgeSelectOneAction *act, GObject *tbl )
 static void sp_tweak_fidelity_value_changed( GtkAdjustment *adj, GObject */*tbl*/ )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "tools.tweak", "fidelity", adj->value * 0.01 );
+    prefs->setDouble( "/tools/tweak/fidelity", adj->value * 0.01 );
 }
 
 static void tweak_toggle_doh (GtkToggleAction *act, gpointer /*data*/) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("tools.tweak", "doh", gtk_toggle_action_get_active(act));
+    prefs->setBool("/tools/tweak/doh", gtk_toggle_action_get_active(act));
 }
 static void tweak_toggle_dos (GtkToggleAction *act, gpointer /*data*/) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("tools.tweak", "dos", gtk_toggle_action_get_active(act));
+    prefs->setBool("/tools/tweak/dos", gtk_toggle_action_get_active(act));
 }
 static void tweak_toggle_dol (GtkToggleAction *act, gpointer /*data*/) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("tools.tweak", "dol", gtk_toggle_action_get_active(act));
+    prefs->setBool("/tools/tweak/dol", gtk_toggle_action_get_active(act));
 }
 static void tweak_toggle_doo (GtkToggleAction *act, gpointer /*data*/) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("tools.tweak", "doo", gtk_toggle_action_get_active(act));
+    prefs->setBool("/tools/tweak/doo", gtk_toggle_action_get_active(act));
 }
 
 static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
 {
-    Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1);
+    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     {
@@ -3658,7 +3659,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
         gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
         EgeAdjustmentAction *eact = create_adjustment_action( "TweakWidthAction",
                                                               _("Width"), _("Width:"), _("The width of the tweak area (relative to the visible canvas area)"),
-                                                              "tools.tweak", "width", 15,
+                                                              "/tools/tweak/width", 15,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-tweak",
                                                               1, 100, 1.0, 0.0,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -3675,7 +3676,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
         gdouble values[] = {1, 5, 10, 20, 30, 50, 70, 100};
         EgeAdjustmentAction *eact = create_adjustment_action( "TweakForceAction",
                                                               _("Force"), _("Force:"), _("The force of the tweak action"),
-                                                              "tools.tweak", "force", 20,
+                                                              "/tools/tweak/force", 20,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "tweak-force",
                                                               1, 100, 1.0, 0.0,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -3794,14 +3795,14 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
         ege_select_one_action_set_icon_size( act, secondarySize );
         ege_select_one_action_set_tooltip_column( act, 1  );
 
-        gint mode = prefs->getInt("tools.tweak", "mode", 0);
+        gint mode = prefs->getInt("/tools/tweak/mode", 0);
         ege_select_one_action_set_active( act, mode );
         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_tweak_mode_changed), holder );
 
         g_object_set_data( G_OBJECT(holder), "tweak_tool_mode", act);
     }
 
-    guint mode = prefs->getInt("tools.tweak", "mode", 0);
+    guint mode = prefs->getInt("/tools/tweak/mode", 0);
 
     {
         EgeOutputAction* act = ege_output_action_new( "TweakChannelsLabel", _("Channels:"), "", 0 );
@@ -3822,7 +3823,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
         g_object_set( act, "short_label", _("H"), NULL );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doh), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getInt( "tools.tweak", "doh", 1 ) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/doh", true) );
         if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER)
             gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
         g_object_set_data( holder, "tweak_doh", act);
@@ -3837,7 +3838,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
         g_object_set( act, "short_label", _("S"), NULL );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dos), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getInt( "tools.tweak", "dos", 1 ) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/dos", true) );
         if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER)
             gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
         g_object_set_data( holder, "tweak_dos", act );
@@ -3852,7 +3853,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
         g_object_set( act, "short_label", _("L"), NULL );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dol), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getInt( "tools.tweak", "dol", 1 ) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/dol", true) );
         if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER)
             gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
         g_object_set_data( holder, "tweak_dol", act );
@@ -3867,7 +3868,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
         g_object_set( act, "short_label", _("O"), NULL );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doo), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getInt( "tools.tweak", "doo", 1 ) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/doo", true) );
         if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER)
             gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
         g_object_set_data( holder, "tweak_doo", act );
@@ -3879,7 +3880,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
         EgeAdjustmentAction *eact = create_adjustment_action( "TweakFidelityAction",
                                                               _("Fidelity"), _("Fidelity:"),
                                                               _("Low fidelity simplifies paths; high fidelity preserves path features but may generate a lot of new nodes"),
-                                                              "tools.tweak", "fidelity", 50,
+                                                              "/tools/tweak/fidelity", 50,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "tweak-fidelity",
                                                               1, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -3901,7 +3902,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction
                                                       Inkscape::ICON_SIZE_DECORATION );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_tweak_pressure_state_changed), NULL);
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("tools.tweak", "usepressure", true) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/usepressure", true) );
     }
 
 }
@@ -3918,29 +3919,26 @@ static void update_presets_list (GObject *tbl)
 
     EgeSelectOneAction *sel = static_cast<EgeSelectOneAction *>(g_object_get_data(tbl, "profile_selector"));
     if (!sel) {
-        ege_select_one_action_set_active(sel, 0);
+        // WTF!? This will cause a segfault if ever reached
+        //ege_select_one_action_set_active(sel, 0);
         return;
     }
 
-    int total_prefs = prefs->childCount("tools.calligraphic.preset");
-
-    for (int i = 0; i < total_prefs; ++i) {
-        Glib::ustring preset_path = prefs->getNthChild("tools.calligraphic.preset", i);
-        /// @todo Remove the use of _getNode()
-        Inkscape::XML::Node *preset_repr = prefs->_getNode(preset_path);
+    std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
 
+    int ege_index = 1;
+    for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i, ++ege_index) {
         bool match = true;
+	
+        std::vector<Inkscape::Preferences::Entry> preset = prefs->getAllEntries(*i);
+        for (std::vector<Inkscape::Preferences::Entry>::iterator j = preset.begin(); j != preset.end(); ++j) {
+            Glib::ustring entry_name = j->getEntryName();
+            if (entry_name == "id" || entry_name == "name") continue;
 
-        for ( Inkscape::Util::List<Inkscape::XML::AttributeRecord const> iter = preset_repr->attributeList();
-              iter;
-              ++iter ) {
-            const gchar *attr_name = g_quark_to_string(iter->key);
-            if (!strcmp(attr_name, "id") || !strcmp(attr_name, "name"))
-                continue;
-            void *widget = g_object_get_data(tbl, attr_name);
+            void *widget = g_object_get_data(tbl, entry_name.data());
             if (widget) {
                 if (GTK_IS_ADJUSTMENT(widget)) {
-                    double v = prefs->getDouble(preset_path, attr_name, 0); // fixme: no min/max checks here, add?
+                    double v = j->getDouble();
                     GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
                     //std::cout << "compared adj " << attr_name << gtk_adjustment_get_value(adj) << " to " << v << "\n";
                     if (fabs(gtk_adjustment_get_value(adj) - v) > 1e-6) {
@@ -3948,7 +3946,7 @@ static void update_presets_list (GObject *tbl)
                         break;
                     }
                 } else if (GTK_IS_TOGGLE_ACTION(widget)) {
-                    bool v = prefs->getBool(preset_path, attr_name);
+                    bool v = j->getBool();
                     GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
                     //std::cout << "compared toggle " << attr_name << gtk_toggle_action_get_active(toggle) << " to " << v << "\n";
                     if ( static_cast<bool>(gtk_toggle_action_get_active(toggle)) != v ) {
@@ -3957,13 +3955,13 @@ 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);
-            ege_select_one_action_set_active(sel, i + 1); // one-based index
+            ege_select_one_action_set_active(sel, ege_index); // one-based index
             return;
         }
     }
@@ -3975,70 +3973,70 @@ static void update_presets_list (GObject *tbl)
 static void sp_ddc_mass_value_changed( GtkAdjustment *adj, GObject* tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "tools.calligraphic", "mass", adj->value * 0.01 );
+    prefs->setDouble( "/tools/calligraphic/mass", adj->value * 0.01 );
     update_presets_list(tbl);
 }
 
 static void sp_ddc_wiggle_value_changed( GtkAdjustment *adj, GObject* tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "tools.calligraphic", "wiggle", adj->value * 0.01 );
+    prefs->setDouble( "/tools/calligraphic/wiggle", adj->value * 0.01 );
     update_presets_list(tbl);
 }
 
 static void sp_ddc_angle_value_changed( GtkAdjustment *adj, GObject* tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "tools.calligraphic", "angle", adj->value );
+    prefs->setDouble( "/tools/calligraphic/angle", adj->value );
     update_presets_list(tbl);
 }
 
 static void sp_ddc_width_value_changed( GtkAdjustment *adj, GObject *tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "tools.calligraphic", "width", adj->value * 0.01 );
+    prefs->setDouble( "/tools/calligraphic/width", adj->value * 0.01 );
     update_presets_list(tbl);
 }
 
 static void sp_ddc_velthin_value_changed( GtkAdjustment *adj, GObject* tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble("tools.calligraphic", "thinning", adj->value * 0.01 );
+    prefs->setDouble("/tools/calligraphic/thinning", adj->value * 0.01 );
     update_presets_list(tbl);
 }
 
 static void sp_ddc_flatness_value_changed( GtkAdjustment *adj, GObject* tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "tools.calligraphic", "flatness", adj->value * 0.01);
+    prefs->setDouble( "/tools/calligraphic/flatness", adj->value * 0.01);
     update_presets_list(tbl);
 }
 
 static void sp_ddc_tremor_value_changed( GtkAdjustment *adj, GObject* tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "tools.calligraphic", "tremor", adj->value * 0.01 );
+    prefs->setDouble( "/tools/calligraphic/tremor", adj->value * 0.01 );
     update_presets_list(tbl);
 }
 
 static void sp_ddc_cap_rounding_value_changed( GtkAdjustment *adj, GObject* tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "tools.calligraphic", "cap_rounding", adj->value );
+    prefs->setDouble( "/tools/calligraphic/cap_rounding", adj->value );
     update_presets_list(tbl);
 }
 
 static void sp_ddc_pressure_state_changed( GtkToggleAction *act, GObject*  tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("tools.calligraphic", "usepressure", gtk_toggle_action_get_active( act ));
+    prefs->setBool("/tools/calligraphic/usepressure", gtk_toggle_action_get_active( act ));
     update_presets_list(tbl);
 }
 
 static void sp_ddc_trace_background_changed( GtkToggleAction *act, GObject*  tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("tools.calligraphic", "tracebackground", gtk_toggle_action_get_active( act ));
+    prefs->setBool("/tools/calligraphic/tracebackground", gtk_toggle_action_get_active( act ));
     update_presets_list(tbl);
 }
 
@@ -4046,7 +4044,7 @@ static void sp_ddc_tilt_state_changed( GtkToggleAction *act, GObject*  tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     GtkAction * calligraphy_angle = static_cast<GtkAction *> (g_object_get_data(tbl,"angle_action"));
-    prefs->setBool("tools.calligraphic", "usetilt", gtk_toggle_action_get_active( act ));
+    prefs->setBool("/tools/calligraphic/usetilt", gtk_toggle_action_get_active( act ));
     update_presets_list(tbl);
     if (calligraphy_angle )
         gtk_action_set_sensitive( calligraphy_angle, !gtk_toggle_action_get_active( act ) );
@@ -4081,18 +4079,17 @@ static void sp_dcc_build_presets_list(GObject *tbl)
         gtk_list_store_append( model, &iter );
         gtk_list_store_set( model, &iter, 0, _("No preset"), 1, 0, -1 );
     }
-
-    /// @todo Use public Preferences API instead of node manipulation
+    
+    // iterate over all presets to populate the list
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    Inkscape::XML::Node *repr = prefs->_getNode("tools.calligraphic.preset", true);
-    Inkscape::XML::Node *child_repr = repr->firstChild();
+    std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
     int ii=1;
-    while (child_repr) {
-        GtkTreeIter iter;
-        char *preset_name = (char *) child_repr->attribute("name");
+    
+    for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i) {
+    	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, 1, ii++, -1 );
-        child_repr = child_repr->next();
+        gtk_list_store_set( model, &iter, 0, preset_name.data(), 1, ii++, -1 );
     }
 
     {
@@ -4131,29 +4128,28 @@ static void sp_dcc_save_profile (GtkWidget */*widget*/, GObject *tbl)
     }
 
     g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE));
-
+    
+    // If there's a preset with the given name, find it and set save_path appropriately
+    std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
+    int total_presets = presets.size();
     int new_index = -1;
-    Glib::ustring pref_path;
-    int total_prefs = prefs->childCount("tools.calligraphic.preset");
-
-    for (int i = 0; i < total_prefs; ++i) {
-        Glib::ustring path = prefs->getNthChild("tools.calligraphic.preset", i);
-        Glib::ustring name = prefs->getString(path, "name");
-        if (!name.empty() && ( profile_name == name )) {
-            // we already have preset with this name, replace its values
-            new_index = i;
-            pref_path = path;
+    Glib::ustring save_path; // profile pref path without a trailing slash
+    
+    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;
+            save_path = *i;
             break;
-        }
+    	}
     }
 
     if (new_index == -1) {
         // no preset with this name, create
-        /// @todo This is wrong, the name should be encoded in the key
-        /// to allow deletion of presets
-        new_index = total_prefs + 1;
-        gchar *profile_id = g_strdup_printf(".dcc%d", new_index);
-        pref_path = Glib::ustring("tools.calligraphic.preset") + profile_id;
+        new_index = total_presets + 1;
+        gchar *profile_id = g_strdup_printf("/dcc%d", new_index);
+        save_path = Glib::ustring("/tools/calligraphic/preset") + profile_id;
         g_free(profile_id);
     }
 
@@ -4163,22 +4159,20 @@ static void sp_dcc_save_profile (GtkWidget */*widget*/, GObject *tbl)
         if (widget) {
             if (GTK_IS_ADJUSTMENT(widget)) {
                 GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
-                double v = gtk_adjustment_get_value(adj);
-                prefs->setDouble(pref_path, widget_name, v);
+                prefs->setDouble(save_path + "/" + widget_name, gtk_adjustment_get_value(adj));
                 //std::cout << "wrote adj " << widget_name << ": " << v << "\n";
             } else if (GTK_IS_TOGGLE_ACTION(widget)) {
                 GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
-                bool v = gtk_toggle_action_get_active(toggle);
-                prefs->setBool(pref_path, widget_name, v);
+                prefs->setBool(save_path + "/" + widget_name, gtk_toggle_action_get_active(toggle));
                 //std::cout << "wrote tog " << widget_name << ": " << v << "\n";
             } else {
-               g_warning("Unknown widget type for preset: %s\n", widget_name);
+                g_warning("Unknown widget type for preset: %s\n", widget_name);
             }
         } else {
             g_warning("Bad key when writing preset: %s\n", widget_name);
         }
     }
-    prefs->setString(pref_path, "name", profile_name);
+    prefs->setString(save_path + "/name", profile_name);
 
     g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
     sp_dcc_build_presets_list (tbl);
@@ -4190,6 +4184,11 @@ static void sp_ddc_change_profile(EgeSelectOneAction* act, GObject* tbl) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     gint preset_index = ege_select_one_action_get_active( act );
+    // This is necessary because EgeSelectOneAction spams us with GObject "changed" signal calls
+    // even when the preset is not changed. It would be good to replace it with something more
+    // modern. Index 0 means "No preset", so we don't do anything.
+    if (preset_index == 0) return;
+
     gint save_presets_index = GPOINTER_TO_INT(g_object_get_data(tbl, "save_presets_index"));
 
     if (preset_index == save_presets_index) {
@@ -4202,44 +4201,37 @@ static void sp_ddc_change_profile(EgeSelectOneAction* act, GObject* tbl) {
         return;
 
     // preset_index is one-based so we subtract 1
-    Glib::ustring preset_path = prefs->getNthChild("tools.calligraphic.preset", preset_index - 1);
+    std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
+    Glib::ustring preset_path = presets.at(preset_index - 1);
 
     if (!preset_path.empty()) {
         g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE)); //temporarily block the selector so no one will updadte it while we're reading it
-
-        /// @todo Remove the use of _getNode() in this fragment, modify
-        /// the public interface of Preferences if necessary
-        Inkscape::XML::Node *preset_repr = prefs->_getNode(preset_path);
+        
+        std::vector<Inkscape::Preferences::Entry> preset = prefs->getAllEntries(preset_path);
 
         // Shouldn't this be std::map?
-        for ( Inkscape::Util::List<Inkscape::XML::AttributeRecord const> iter = preset_repr->attributeList();
-              iter;
-              ++iter ) {
-            const gchar *attr_name = g_quark_to_string(iter->key);
-            if (!strcmp(attr_name, "id") || !strcmp(attr_name, "name"))
-                continue;
-            void *widget = g_object_get_data(tbl, attr_name);
+        for (std::vector<Inkscape::Preferences::Entry>::iterator i = preset.begin(); i != preset.end(); ++i) {
+            Glib::ustring entry_name = i->getEntryName();
+            if (entry_name == "id" || entry_name == "name") continue;
+            void *widget = g_object_get_data(tbl, entry_name.data());
             if (widget) {
                 if (GTK_IS_ADJUSTMENT(widget)) {
-                    double v = prefs->getDouble(preset_path, attr_name, 0); // fixme: no min/max checks here, add?
                     GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
-                    gtk_adjustment_set_value(adj, v);
+                    gtk_adjustment_set_value(adj, i->getDouble());
                     //std::cout << "set adj " << attr_name << " to " << v << "\n";
                 } else if (GTK_IS_TOGGLE_ACTION(widget)) {
-                    int v = prefs->getInt(preset_path, attr_name, 0); // fixme: no min/max checks here, add?
                     GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
-                    gtk_toggle_action_set_active(toggle, v);
+                    gtk_toggle_action_set_active(toggle, i->getBool());
                     //std::cout << "set toggle " << attr_name << " to " << v << "\n";
                 } else {
-                    g_warning("Unknown widget type for preset: %s\n", attr_name);
+                    g_warning("Unknown widget type for preset: %s\n", entry_name.data());
                 }
             } else {
-                g_warning("Bad key found in a preset record: %s\n", attr_name);
+                g_warning("Bad key found in a preset record: %s\n", entry_name.data());
             }
         }
         g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
     }
-
 }
 
 
@@ -4258,7 +4250,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
         EgeAdjustmentAction *eact = create_adjustment_action( "CalligraphyWidthAction",
                                                               _("Pen Width"), _("Width:"),
                                                               _("The width of the calligraphic pen (relative to the visible canvas area)"),
-                                                              "tools.calligraphic", "width", 15,
+                                                              "/tools/calligraphic/width", 15,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-calligraphy",
                                                               1, 100, 1.0, 0.0,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -4275,7 +4267,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
         EgeAdjustmentAction* eact = create_adjustment_action( "ThinningAction",
                                                               _("Stroke Thinning"), _("Thinning:"),
                                                               _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"),
-                                                              "tools.calligraphic", "thinning", 10,
+                                                              "/tools/calligraphic/thinning", 10,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                                               -100, 100, 1, 0.1,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -4291,7 +4283,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
         EgeAdjustmentAction* eact = create_adjustment_action( "AngleAction",
                                                               _("Pen Angle"), _("Angle:"),
                                                               _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"),
-                                                              "tools.calligraphic", "angle", 30,
+                                                              "/tools/calligraphic/angle", 30,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "calligraphy-angle",
                                                               -90.0, 90.0, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -4309,7 +4301,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
         EgeAdjustmentAction* eact = create_adjustment_action( "FixationAction",
                                                               _("Fixation"), _("Fixation:"),
                                                               _("Angle behavior (0 = nib always perpendicular to stroke direction, 100 = fixed angle)"),
-                                                              "tools.calligraphic", "flatness", 90,
+                                                              "/tools/calligraphic/flatness", 90,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                                               0.0, 100, 1.0, 10.0,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -4326,7 +4318,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
         EgeAdjustmentAction* eact = create_adjustment_action( "CapRoundingAction",
                                                               _("Cap rounding"), _("Caps:"),
                                                               _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"),
-                                                              "tools.calligraphic", "cap_rounding", 0.0,
+                                                              "/tools/calligraphic/cap_rounding", 0.0,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                                               0.0, 5.0, 0.01, 0.1,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -4342,7 +4334,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
         EgeAdjustmentAction* eact = create_adjustment_action( "TremorAction",
                                                               _("Stroke Tremor"), _("Tremor:"),
                                                               _("Increase to make strokes rugged and trembling"),
-                                                              "tools.calligraphic", "tremor", 0.0,
+                                                              "/tools/calligraphic/tremor", 0.0,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                                               0.0, 100, 1, 0.0,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -4360,7 +4352,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
         EgeAdjustmentAction* eact = create_adjustment_action( "WiggleAction",
                                                               _("Pen Wiggle"), _("Wiggle:"),
                                                               _("Increase to make the pen waver and wiggle"),
-                                                              "tools.calligraphic", "wiggle", 0.0,
+                                                              "/tools/calligraphic/wiggle", 0.0,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                                               0.0, 100, 1, 0.0,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -4377,7 +4369,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
         EgeAdjustmentAction* eact = create_adjustment_action( "MassAction",
                                                               _("Pen Mass"), _("Mass:"),
                                                               _("Increase to make the pen drag behind, as if slowed by inertia"),
-                                                              "tools.calligraphic", "mass", 2.0,
+                                                              "/tools/calligraphic/mass", 2.0,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
                                                               0.0, 100, 1, 0.0,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -4397,7 +4389,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
                                                           Inkscape::ICON_SIZE_DECORATION );
             gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
             g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_trace_background_changed), holder);
-            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("tools.calligraphic", "tracebackground", false) );
+            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/calligraphic/tracebackground", false) );
             g_object_set_data( holder, "tracebackground", act );
         }
 
@@ -4410,7 +4402,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
                                                           Inkscape::ICON_SIZE_DECORATION );
             gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
             g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_pressure_state_changed), holder);
-            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("tools.calligraphic", "usepressure", true) );
+            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/calligraphic/usepressure", true) );
             g_object_set_data( holder, "usepressure", act );
         }
 
@@ -4423,8 +4415,8 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
                                                           Inkscape::ICON_SIZE_DECORATION );
             gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
             g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_tilt_state_changed), holder );
-            gtk_action_set_sensitive( GTK_ACTION(calligraphy_angle), !prefs->getBool("tools.calligraphic", "usetilt", true) );
-            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("tools.calligraphic", "usetilt", true) );
+            gtk_action_set_sensitive( GTK_ACTION(calligraphy_angle), !prefs->getBool("/tools/calligraphic/usetilt", true) );
+            gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/calligraphic/usetilt", true) );
             g_object_set_data( holder, "usetilt", act );
         }
 
@@ -4473,7 +4465,7 @@ sp_arctb_startend_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *v
 
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble("tools.shapes.arc", value_name, (adj->value * M_PI)/ 180);
+        prefs->setDouble(Glib::ustring("/tools/shapes/arc") + value_name, (adj->value * M_PI)/ 180);
     }
 
     // quit if run by the attr_changed listener
@@ -4542,7 +4534,7 @@ static void sp_arctb_open_state_changed( EgeSelectOneAction *act, GObject *tbl )
     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setBool("tools.shapes.arc", "open", ege_select_one_action_get_active(act) != 0);
+        prefs->setBool("/tools/shapes/arc/open", ege_select_one_action_get_active(act) != 0);
     }
 
     // quit if run by the attr_changed listener
@@ -4696,7 +4688,7 @@ static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     EgeAdjustmentAction* eact = 0;
-    Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1);
+    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
 
 
     {
@@ -4711,7 +4703,7 @@ static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         eact = create_adjustment_action( "ArcStartAction",
                                          _("Start"), _("Start:"),
                                          _("The angle (in degrees) from the horizontal to the arc's start point"),
-                                         "tools.shapes.arc", "start", 0.0,
+                                         "/tools/shapes/arc/start", 0.0,
                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-arc",
                                          -360.0, 360.0, 1.0, 10.0,
                                          0, 0, 0,
@@ -4724,7 +4716,7 @@ static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         eact = create_adjustment_action( "ArcEndAction",
                                          _("End"), _("End:"),
                                          _("The angle (in degrees) from the horizontal to the arc's end point"),
-                                         "tools.shapes.arc", "end", 0.0,
+                                         "/tools/shapes/arc/end", 0.0,
                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
                                          -360.0, 360.0, 1.0, 10.0,
                                          0, 0, 0,
@@ -4762,7 +4754,7 @@ static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
         ege_select_one_action_set_icon_size( act, secondarySize );
         ege_select_one_action_set_tooltip_column( act, 1  );
 
-        bool isClosed = !prefs->getBool("tools.shapes.arc", "open", false);
+        bool isClosed = !prefs->getBool("/tools/shapes/arc/open", false);
         ege_select_one_action_set_active( act, isClosed ? 0 : 1 );
         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_arctb_open_state_changed), holder );
     }
@@ -4807,7 +4799,7 @@ static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions,
 
 static void toggle_dropper_pick_alpha( GtkToggleAction* act, gpointer tbl ) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt( "tools.dropper", "pick", gtk_toggle_action_get_active( act ) );
+    prefs->setInt( "/tools/dropper/pick", gtk_toggle_action_get_active( act ) );
     GtkAction* set_action = GTK_ACTION( g_object_get_data(G_OBJECT(tbl), "set_action") );
     if ( set_action ) {
         if ( gtk_toggle_action_get_active( act ) ) {
@@ -4822,7 +4814,7 @@ static void toggle_dropper_pick_alpha( GtkToggleAction* act, gpointer tbl ) {
 
 static void toggle_dropper_set_alpha( GtkToggleAction* act, gpointer tbl ) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt( "tools.dropper", "setalpha", gtk_toggle_action_get_active( act ) ? 1 : 0 );
+    prefs->setBool( "/tools/dropper/setalpha", gtk_toggle_action_get_active( act ) );
     spinbutton_defocus(GTK_OBJECT(tbl));
 }
 
@@ -4837,7 +4829,7 @@ static void toggle_dropper_set_alpha( GtkToggleAction* act, gpointer tbl ) {
 static void sp_dropper_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* mainActions, GObject* holder)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    gint pickAlpha = prefs->getInt( "tools.dropper", "pick", 1 );
+    gint pickAlpha = prefs->getInt( "/tools/dropper/pick", 1 );
 
     {
         EgeOutputAction* act = ege_output_action_new( "DropperOpacityAction", _("Opacity:"), "", 0 );
@@ -4867,7 +4859,7 @@ static void sp_dropper_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* main
         g_object_set( act, "short_label", _("Assign"), NULL );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_object_set_data( holder, "set_action", act );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getInt( "tools.dropper", "setalpha", 1 ) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/dropper/setalpha", true) );
         // make sure it's disabled if we're not picking alpha
         gtk_action_set_sensitive( GTK_ACTION(act), pickAlpha );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_dropper_set_alpha), holder );
@@ -4913,7 +4905,7 @@ static void sp_lpetool_mode_changed(EgeSelectOneAction *act, GObject *tbl)
 
         if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
             Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-            prefs->setInt( "tools.lpetool", "mode", mode );
+            prefs->setInt( "/tools/lpetool/mode", mode );
         }
 
         g_object_set_data(tbl, "freeze", GINT_TO_POINTER(FALSE));
@@ -4971,7 +4963,7 @@ lpetool_toggle_show_bbox (GtkToggleAction *act, gpointer data) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     bool show = gtk_toggle_action_get_active( act );
-    prefs->setInt("tools.lpetool", "show_bbox",  show ? 1 : 0);
+    prefs->setBool("/tools/lpetool/show_bbox",  show);
 
     if (tools_isactive(desktop, TOOLS_LPETOOL)) {
         SPLPEToolContext *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
@@ -4990,7 +4982,7 @@ lpetool_toggle_show_measuring_info (GtkToggleAction *act, GObject *tbl) {
     if (tools_isactive(desktop, TOOLS_LPETOOL)) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         bool show = gtk_toggle_action_get_active( act );
-        prefs->setInt("tools.lpetool", "show_measuring_info",  show ? 1 : 0);
+        prefs->setBool("/tools/lpetool/show_measuring_info",  show);
         lpetool_show_measuring_info(lc, show);
         gtk_action_set_sensitive(GTK_ACTION(unitact), show);
     }
@@ -5000,7 +4992,7 @@ static void lpetool_unit_changed(GtkAction* /*act*/, GObject* tbl) {
     UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(tbl, "tracker"));
     SPUnit const *unit = tracker->getActiveUnit();
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("tools.lpetool", "unitid", unit->unit_id);
+    prefs->setInt("/tools/lpetool/unitid", unit->unit_id);
 
     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
     if (SP_IS_LPETOOL_CONTEXT(desktop->event_context)) {
@@ -5026,10 +5018,10 @@ lpetool_toggle_set_bbox (GtkToggleAction *act, gpointer data) {
 
         // TODO: should we provide a way to store points in prefs?
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setDouble("tools.lpetool", "bbox_upperleftx", A[Geom::X]);
-        prefs->setDouble("tools.lpetool", "bbox_upperlefty", A[Geom::Y]);
-        prefs->setDouble("tools.lpetool", "bbox_lowerrightx", B[Geom::X]);
-        prefs->setDouble("tools.lpetool", "bbox_lowerrighty", B[Geom::Y]);
+        prefs->setDouble("/tools/lpetool/bbox_upperleftx", A[Geom::X]);
+        prefs->setDouble("/tools/lpetool/bbox_upperlefty", A[Geom::Y]);
+        prefs->setDouble("/tools/lpetool/bbox_lowerrightx", B[Geom::X]);
+        prefs->setDouble("/tools/lpetool/bbox_lowerrighty", B[Geom::Y]);
 
         lpetool_context_reset_limiting_bbox(SP_LPETOOL_CONTEXT(desktop->event_context));
     }
@@ -5103,7 +5095,7 @@ static void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActi
     SPUnit const *unit = tracker->getActiveUnit();
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("tools.lpetool", "unitid", unit->unit_id);
+    prefs->setInt("/tools/lpetool/unitid", unit->unit_id);
 
     /** Automatically create a list of LPEs that get added to the toolbar **/
     {
@@ -5141,7 +5133,7 @@ static void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActi
         ege_select_one_action_set_icon_column( act, 2 );
         ege_select_one_action_set_tooltip_column( act, 1  );
 
-        gint lpeToolMode = prefs->getInt("tools.lpetool", "mode", 0);
+        gint lpeToolMode = prefs->getInt("/tools/lpetool/mode", 0);
         ege_select_one_action_set_active( act, lpeToolMode );
         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_lpetool_mode_changed), holder );
     }
@@ -5155,7 +5147,7 @@ static void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActi
                                                       Inkscape::ICON_SIZE_DECORATION );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_show_bbox), desktop );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getInt( "tools.lpetool", "show_bbox", 1 ) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/lpetool/show_bbox", true ) );
     }
 
     /* Set limiting bounding box to bbox of current selection */
@@ -5196,7 +5188,7 @@ static void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActi
                                                       Inkscape::ICON_SIZE_DECORATION );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_show_measuring_info), holder );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getInt( "tools.lpetool", "show_measuring_info", 1 ) );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/lpetool/show_measuring_info", true ) );
     }
 
     // add the units menu
@@ -5205,7 +5197,7 @@ static void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActi
         gtk_action_group_add_action( mainActions, act );
         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(lpetool_unit_changed), (GObject*)holder );
         g_object_set_data(holder, "lpetool_units_action", act);
-        gtk_action_set_sensitive(act, prefs->getInt("tools.lpetool", "show_measuring_info", 1));
+        gtk_action_set_sensitive(act, prefs->getBool("/tools/lpetool/show_measuring_info", true));
     }
 
     /* Open LPE dialog (to adapt parameters numerically) */
@@ -5241,17 +5233,17 @@ static void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActi
 static void sp_erc_width_value_changed( GtkAdjustment *adj, GObject *tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "tools.eraser", "width", adj->value * 0.01 );
+    prefs->setDouble( "/tools/eraser/width", adj->value * 0.01 );
     update_presets_list(tbl);
 }
 
 static void sp_erasertb_mode_changed( EgeSelectOneAction *act, GObject *tbl )
 {
     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
-    gint eraserMode = (ege_select_one_action_get_active( act ) != 0) ? 1 : 0;
+    bool eraserMode = ege_select_one_action_get_active( act ) != 0;
     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        prefs->setInt( "tools.eraser", "mode", eraserMode );
+        prefs->setBool( "/tools/eraser/mode", eraserMode );
     }
 
     // only take action if run by the attr_changed listener
@@ -5277,7 +5269,7 @@ static void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio
         EgeAdjustmentAction *eact = create_adjustment_action( "EraserWidthAction",
                                                               _("Pen Width"), _("Width:"),
                                                               _("The width of the eraser pen (relative to the visible canvas area)"),
-                                                              "tools.eraser", "width", 15,
+                                                              "/tools/eraser/width", 15,
                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-eraser",
                                                               1, 100, 1.0, 0.0,
                                                               labels, values, G_N_ELEMENTS(labels),
@@ -5317,7 +5309,7 @@ static void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio
 
         /// @todo Convert to boolean?
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        gint eraserMode = (prefs->getInt("tools.eraser", "mode", 0) != 0) ? 1 : 0;
+        gint eraserMode = prefs->getBool("/tools/eraser/mode") ? 1 : 0;
         ege_select_one_action_set_active( act, eraserMode );
         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_erasertb_mode_changed), holder );
     }
@@ -5385,20 +5377,15 @@ sp_text_toolbox_selection_changed (Inkscape::Selection */*selection*/, GObject *
     // If querying returned nothing, read the style from the text tool prefs (default style for new texts)
     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
-
-        Inkscape::XML::Node *repr = inkscape_get_repr (INKSCAPE, "tools.text");
-        if (repr) {
-            sp_style_read_from_repr (query, repr);
-            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);
-                return;
-            }
-            g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(TRUE));
-        } else {
+        
+	    sp_style_read_from_prefs(query, "/tools/text");
+	    
+	    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);
             return;
         }
+        g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(TRUE));
     } else {
         g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(FALSE));
     }
@@ -5635,7 +5622,8 @@ sp_text_toolbox_family_changed (GtkTreeSelection    *selection,
     // If querying returned nothing, set the default style of the tool (for new texts)
     if (result_fontspec == QUERY_STYLE_NOTHING)
     {
-        sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style");
+    	Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    	prefs->setStyle("/tools/text/style", css);
         sp_text_edit_dialog_default_set_insensitive (); //FIXME: Replace trough a verb
     }
     else
@@ -5727,7 +5715,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)
     {
-        sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style");
+    	Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    	prefs->setStyle("/tools/text/style", css);
     }
 
     sp_style_unref(query);
@@ -5805,7 +5794,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)
     {
-        sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style");
+    	Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    	prefs->setStyle("/tools/text/style", css);
     }
 
     sp_style_unref(query);
@@ -5854,7 +5844,8 @@ sp_text_toolbox_orientation_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)
     {
-        sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style");
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    	prefs->setStyle("/tools/text/style", css);
     }
 
     sp_desktop_set_style (desktop, css, true, true);
@@ -5954,7 +5945,8 @@ sp_text_toolbox_size_changed  (GtkComboBox *cbox,
     // If querying returned nothing, read the style from the text tool prefs (default style for new texts)
     if (result_numbers == QUERY_STYLE_NOTHING)
     {
-        sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style");
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    	prefs->setStyle("/tools/text/style", css);
     }
 
     sp_style_unref(query);
@@ -6117,7 +6109,7 @@ GtkWidget*
 sp_text_toolbox_new (SPDesktop *desktop)
 {
     GtkToolbar   *tbl = GTK_TOOLBAR(gtk_toolbar_new());
-    GtkIconSize secondarySize = static_cast<GtkIconSize>(prefToSize("toolbox", "secondary", 1));
+    GtkIconSize secondarySize = static_cast<GtkIconSize>(prefToSize("/toolbox/secondary", 1));
 
     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
@@ -6437,12 +6429,12 @@ static void sp_connector_graph_layout(void)
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     // hack for clones, see comment in align-and-distribute.cpp
-    int saved_compensation = prefs->getInt("options.clonecompensation", "value", SP_CLONE_COMPENSATION_UNMOVED);
-    prefs->setInt("options.clonecompensation", "value", SP_CLONE_COMPENSATION_UNMOVED);
+    int saved_compensation = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
+    prefs->setInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
 
     graphlayout(sp_desktop_selection(SP_ACTIVE_DESKTOP)->itemList());
 
-    prefs->setInt("options.clonecompensation", "value", saved_compensation);
+    prefs->setInt("/options/clonecompensation/value", saved_compensation);
 
     sp_document_done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, _("Arrange connector network"));
 }
@@ -6450,14 +6442,14 @@ static void sp_connector_graph_layout(void)
 static void sp_directed_graph_layout_toggled( GtkToggleAction* act, GtkObject */*tbl*/ )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("tools.connector", "directedlayout",
+    prefs->setBool("/tools/connector/directedlayout",
                 gtk_toggle_action_get_active( act ));
 }
 
 static void sp_nooverlaps_graph_layout_toggled( GtkToggleAction* act, GtkObject */*tbl*/ )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setBool("tools.connector", "avoidoverlaplayout",
+    prefs->setBool("/tools/connector/avoidoverlaplayout",
                 gtk_toggle_action_get_active( act ));
 }
 
@@ -6465,7 +6457,7 @@ static void sp_nooverlaps_graph_layout_toggled( GtkToggleAction* act, GtkObject
 static void connector_length_changed(GtkAdjustment *adj, GObject* tbl)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble("tools.connector", "length", adj->value);
+    prefs->setDouble("/tools/connector/length", adj->value);
     spinbutton_defocus(GTK_OBJECT(tbl));
 }
 
@@ -6503,7 +6495,7 @@ static Inkscape::XML::NodeEventVector connector_tb_repr_events = {
 static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1);
+    Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1);
 
     {
         InkAction* inky = ink_action_new( "ConnectorAvoidAction",
@@ -6531,7 +6523,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA
     eact = create_adjustment_action( "ConnectorSpacingAction",
                                      _("Connector Spacing"), _("Spacing:"),
                                      _("The amount of space left around objects by auto-routing connectors"),
-                                     "tools.connector", "spacing", defaultConnSpacing,
+                                     "/tools/connector/spacing", defaultConnSpacing,
                                      GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "inkscape:connector-spacing",
                                      0, 100, 1.0, 10.0,
                                      0, 0, 0,
@@ -6553,7 +6545,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA
     eact = create_adjustment_action( "ConnectorLengthAction",
                                      _("Connector Length"), _("Length:"),
                                      _("Ideal length for connectors when layout is applied"),
-                                     "tools.connector", "length", 100,
+                                     "/tools/connector/length", 100,
                                      GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "inkscape:connector-length",
                                      10, 1000, 10.0, 100.0,
                                      0, 0, 0,
@@ -6570,7 +6562,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA
                                                       Inkscape::ICON_SIZE_DECORATION );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
 
-        bool tbuttonstate = prefs->getBool("tools.connector", "directedlayout");
+        bool tbuttonstate = prefs->getBool("/tools/connector/directedlayout");
         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE ));
 
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_directed_graph_layout_toggled), holder );
@@ -6585,7 +6577,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA
                                                       Inkscape::ICON_SIZE_DECORATION );
         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
 
-        bool tbuttonstate = prefs->getBool("tools.connector", "avoidoverlaplayout");
+        bool tbuttonstate = prefs->getBool("/tools/connector/avoidoverlaplayout");
         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), (tbuttonstate ? TRUE : FALSE ));
 
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_nooverlaps_graph_layout_toggled), holder );
@@ -6620,13 +6612,13 @@ static void paintbucket_channels_changed(EgeSelectOneAction* act, GObject* /*tbl
 static void paintbucket_threshold_changed(GtkAdjustment *adj, GObject */*tbl*/)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("tools.paintbucket", "threshold", (gint)adj->value);
+    prefs->setInt("/tools/paintbucket/threshold", (gint)adj->value);
 }
 
 static void paintbucket_autogap_changed(EgeSelectOneAction* act, GObject */*tbl*/)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setInt("tools.paintbucket", "autogap", ege_select_one_action_get_active( act ));
+    prefs->setBool("/tools/paintbucket/autogap", ege_select_one_action_get_active( act ));
 }
 
 static void paintbucket_offset_changed(GtkAdjustment *adj, GObject *tbl)
@@ -6635,8 +6627,8 @@ static void paintbucket_offset_changed(GtkAdjustment *adj, GObject *tbl)
     SPUnit const *unit = tracker->getActiveUnit();
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
-    prefs->setDouble("tools.paintbucket", "offset", (gdouble)sp_units_get_pixels(adj->value, *unit));
-    prefs->setString("tools.paintbucket", "offsetunits", sp_unit_get_abbreviation(unit));
+    prefs->setDouble("/tools/paintbucket/offset", (gdouble)sp_units_get_pixels(adj->value, *unit));
+    prefs->setString("/tools/paintbucket/offsetunits", sp_unit_get_abbreviation(unit));
 }
 
 static void paintbucket_defaults (GtkWidget *, GObject *tbl)
@@ -6686,7 +6678,7 @@ static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
         EgeSelectOneAction* act1 = ege_select_one_action_new( "ChannelsAction", _("Fill by"), (""), NULL, GTK_TREE_MODEL(model) );
         g_object_set( act1, "short_label", _("Fill by:"), NULL );
         ege_select_one_action_set_appearance( act1, "compact" );
-        ege_select_one_action_set_active( act1, prefs->getInt("tools.paintbucket", "channels", 0) );
+        ege_select_one_action_set_active( act1, prefs->getInt("/tools/paintbucket/channels", 0) );
         g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(paintbucket_channels_changed), holder );
         gtk_action_group_add_action( mainActions, GTK_ACTION(act1) );
         g_object_set_data( holder, "channels_action", act1 );
@@ -6698,7 +6690,7 @@ static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
             "ThresholdAction",
             _("Fill Threshold"), _("Threshold:"),
             _("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"),
-            "tools.paintbucket", "threshold", 5, GTK_WIDGET(desktop->canvas), NULL, holder, TRUE,
+            "/tools/paintbucket/threshold", 5, GTK_WIDGET(desktop->canvas), NULL, holder, TRUE,
             "inkscape:paintbucket-threshold", 0, 100.0, 1.0, 0.0,
             0, 0, 0,
             paintbucket_threshold_changed, 1, 0 );
@@ -6709,7 +6701,7 @@ static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
 
     // Create the units menu.
     UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE );
-    Glib::ustring stored_unit = prefs->getString("tools.paintbucket", "offsetunits");
+    Glib::ustring stored_unit = prefs->getString("/tools/paintbucket/offsetunits");
     if (!stored_unit.empty())
         tracker->setActiveUnit(sp_unit_get_by_abbreviation(stored_unit.data()));
     g_object_set_data( holder, "tracker", tracker );
@@ -6724,7 +6716,7 @@ static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
             "OffsetAction",
             _("Grow/shrink by"), _("Grow/shrink by:"),
             _("The amount to grow (positive) or shrink (negative) the created fill path"),
-            "tools.paintbucket", "offset", 0, GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE,
+            "/tools/paintbucket/offset", 0, GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE,
             "inkscape:paintbucket-offset", -1e6, 1e6, 0.1, 0.5,
             0, 0, 0,
             paintbucket_offset_changed, 1, 2);
@@ -6751,7 +6743,7 @@ static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
         EgeSelectOneAction* act2 = ege_select_one_action_new( "AutoGapAction", _("Close gaps"), (""), NULL, GTK_TREE_MODEL(model) );
         g_object_set( act2, "short_label", _("Close gaps:"), NULL );
         ege_select_one_action_set_appearance( act2, "compact" );
-        ege_select_one_action_set_active( act2, prefs->getInt("tools.paintbucket", "autogap", 0) );
+        ege_select_one_action_set_active( act2, prefs->getBool("/tools/paintbucket/autogap") );
         g_signal_connect( G_OBJECT(act2), "changed", G_CALLBACK(paintbucket_autogap_changed), holder );
         gtk_action_group_add_action( mainActions, GTK_ACTION(act2) );
         g_object_set_data( holder, "autogap_action", act2 );
@@ -6780,7 +6772,3 @@ static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main
   End:
 */
 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
-
-
-
-
diff --git a/src/widgets/toolbox.h b/src/widgets/toolbox.h
index 27bf6d052..a4d6f21a5 100644
--- a/src/widgets/toolbox.h
+++ b/src/widgets/toolbox.h
@@ -42,7 +42,7 @@ void aux_toolbox_space(GtkWidget *tb, gint space);
 // utility
 void sp_toolbox_add_label(GtkWidget *tbl, gchar const *title, bool wide = true);
 
-Inkscape::IconSize prefToSize( gchar const *path, gchar const *attr, int base = 0 );
+Inkscape::IconSize prefToSize(Glib::ustring const &path, int base = 0 );
 
 #endif /* !SEEN_TOOLBOX_H */