merge from trunk (r11952)

(bzr r11668.1.46)

9 files changed, 609 insertions, 191 deletions

diff --git a/src/ui/dialog/clonetiler.cpp b/src/ui/dialog/clonetiler.cpp
index f51470826..e971cfb09 100644
--- a/src/ui/dialog/clonetiler.cpp
+++ b/src/ui/dialog/clonetiler.cpp
@@ -815,9 +815,15 @@ CloneTiler::CloneTiler (void) :
                 GtkWidget *frame = gtk_frame_new (_("1. Pick from the drawing:"));
                 gtk_box_pack_start (GTK_BOX (vvb), frame, FALSE, FALSE, 0);
 
+#if GTK_CHECK_VERSION(3,0,0)
+                GtkWidget *table = gtk_grid_new();
+                gtk_grid_set_row_spacing(GTK_GRID(table), 4);
+                gtk_grid_set_column_spacing(GTK_GRID(table), 6);
+#else
                 GtkWidget *table = gtk_table_new (3, 3, FALSE);
                 gtk_table_set_row_spacings (GTK_TABLE (table), 4);
                 gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+#endif
                 gtk_container_add(GTK_CONTAINER(frame), table);
 
 
@@ -893,9 +899,16 @@ CloneTiler::CloneTiler (void) :
                 GtkWidget *frame = gtk_frame_new (_("2. Tweak the picked value:"));
                 gtk_box_pack_start (GTK_BOX (vvb), frame, FALSE, FALSE, VB_MARGIN);
 
+#if GTK_CHECK_VERSION(3,0,0)
+                GtkWidget *table = gtk_grid_new();
+                gtk_grid_set_row_spacing(GTK_GRID(table), 4);
+                gtk_grid_set_column_spacing(GTK_GRID(table), 6);
+#else
                 GtkWidget *table = gtk_table_new (4, 2, FALSE);
                 gtk_table_set_row_spacings (GTK_TABLE (table), 4);
                 gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+#endif
+
                 gtk_container_add(GTK_CONTAINER(frame), table);
 
                 {
@@ -935,10 +948,15 @@ CloneTiler::CloneTiler (void) :
                 GtkWidget *frame = gtk_frame_new (_("3. Apply the value to the clones':"));
                 gtk_box_pack_start (GTK_BOX (vvb), frame, FALSE, FALSE, 0);
 
-
+#if GTK_CHECK_VERSION(3,0,0)
+                GtkWidget *table = gtk_grid_new();
+                gtk_grid_set_row_spacing(GTK_GRID(table), 4);
+                gtk_grid_set_column_spacing(GTK_GRID(table), 6);
+#else
                 GtkWidget *table = gtk_table_new (2, 2, FALSE);
                 gtk_table_set_row_spacings (GTK_TABLE (table), 4);
                 gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+#endif
                 gtk_container_add(GTK_CONTAINER(frame), table);
 
                 {
@@ -987,10 +1005,17 @@ CloneTiler::CloneTiler (void) :
 
         // Rows/columns, width/height
         {
+#if GTK_CHECK_VERSION(3,0,0)
+            GtkWidget *table = gtk_grid_new();
+            gtk_grid_set_row_spacing(GTK_GRID(table), 4);
+            gtk_grid_set_column_spacing(GTK_GRID(table), 6);
+#else
             GtkWidget *table = gtk_table_new (2, 2, FALSE);
-            gtk_container_set_border_width (GTK_CONTAINER (table), VB_MARGIN);
             gtk_table_set_row_spacings (GTK_TABLE (table), 4);
             gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+#endif
+
+            gtk_container_set_border_width (GTK_CONTAINER (table), VB_MARGIN);
             gtk_box_pack_start (GTK_BOX (mainbox), table, FALSE, FALSE, 0);
 
             {
@@ -2807,15 +2832,29 @@ void CloneTiler::clonetiler_table_attach(GtkWidget *table, GtkWidget *widget, fl
 {
     GtkWidget *a = gtk_alignment_new (align, 0, 0, 0);
     gtk_container_add(GTK_CONTAINER(a), widget);
-    gtk_table_attach ( GTK_TABLE (table), a, col, col + 1, row, row + 1, (GtkAttachOptions)4, (GtkAttachOptions)0, 0, 0 );
+
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(table, GTK_ALIGN_FILL);
+    gtk_widget_set_valign(table, GTK_ALIGN_CENTER);
+    gtk_grid_attach(GTK_GRID(table), a, col, row, 1, 1);
+#else
+    gtk_table_attach ( GTK_TABLE (table), a, col, col + 1, row, row + 1, GTK_FILL, (GtkAttachOptions)0, 0, 0 );
+#endif
 }
 
 GtkWidget * CloneTiler::clonetiler_table_x_y_rand(int values)
 {
+#if GTK_CHECK_VERSION(3,0,0)
+    GtkWidget *table = gtk_grid_new();
+    gtk_grid_set_row_spacing(GTK_GRID(table), 6);
+    gtk_grid_set_column_spacing(GTK_GRID(table), 8);
+#else
     GtkWidget *table = gtk_table_new (values + 2, 5, FALSE);
-    gtk_container_set_border_width (GTK_CONTAINER (table), VB_MARGIN);
     gtk_table_set_row_spacings (GTK_TABLE (table), 6);
     gtk_table_set_col_spacings (GTK_TABLE (table), 8);
+#endif
+
+    gtk_container_set_border_width (GTK_CONTAINER (table), VB_MARGIN);
 
     {
 #if GTK_CHECK_VERSION(3,0,0)
diff --git a/src/ui/dialog/document-metadata.cpp b/src/ui/dialog/document-metadata.cpp
index 6318ffbbb..efe25d843 100644
--- a/src/ui/dialog/document-metadata.cpp
+++ b/src/ui/dialog/document-metadata.cpp
@@ -61,13 +61,30 @@ DocumentMetadata::getInstance()
 
 
 DocumentMetadata::DocumentMetadata()
+#if WITH_GTKMM_3_0
+    : UI::Widget::Panel ("", "/dialogs/documentmetadata", SP_VERB_DIALOG_METADATA)
+#else
     : UI::Widget::Panel ("", "/dialogs/documentmetadata", SP_VERB_DIALOG_METADATA),
       _page_metadata1(1, 1), _page_metadata2(1, 1)
+#endif
 {
     hide();
     _getContents()->set_spacing (4);
     _getContents()->pack_start(_notebook, true, true);
 
+    _page_metadata1.set_border_width(2);
+    _page_metadata2.set_border_width(2);
+   
+#if WITH_GTKMM_3_0
+    _page_metadata1.set_column_spacing(2);
+    _page_metadata2.set_column_spacing(2);
+    _page_metadata1.set_row_spacing(2);
+    _page_metadata2.set_row_spacing(2);
+#else 
+    _page_metadata1.set_spacings(2);
+    _page_metadata2.set_spacings(2);
+#endif
+    
     _notebook.append_page(_page_metadata1, _("Metadata"));
     _notebook.append_page(_page_metadata2, _("License"));
 
@@ -98,50 +115,6 @@ DocumentMetadata::~DocumentMetadata()
         delete (*it);
 }
 
-//========================================================================
-
-/**
- * Helper function that attachs widgets in a 3xn table. The widgets come in an
- * array that has two entries per table row. The two entries code for four
- * possible cases: (0,0) means insert space in first column; (0, non-0) means
- * widget in columns 2-3; (non-0, 0) means label in columns 1-3; and
- * (non-0, non-0) means two widgets in columns 2 and 3.
- */
-inline void attach_all(Gtk::Table &table, const Gtk::Widget *arr[], unsigned size, int start = 0)
-{
-    for (unsigned i=0, r=start; i<size/sizeof(Gtk::Widget*); i+=2)
-    {
-        if (arr[i] && arr[i+1])
-        {
-            table.attach (const_cast<Gtk::Widget&>(*arr[i]),   1, 2, r, r+1,
-                      Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
-            table.attach (const_cast<Gtk::Widget&>(*arr[i+1]), 2, 3, r, r+1,
-                      Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
-        }
-        else
-        {
-            if (arr[i+1])
-                table.attach (const_cast<Gtk::Widget&>(*arr[i+1]), 1, 3, r, r+1,
-                      Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
-            else if (arr[i])
-            {
-                Gtk::Label& label = static_cast<Gtk::Label&> (const_cast<Gtk::Widget&>(*arr[i]));
-                label.set_alignment (0.0);
-                table.attach (label, 0, 3, r, r+1,
-                      Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
-            }
-            else
-            {
-                Gtk::HBox *space = manage (new Gtk::HBox);
-                space->set_size_request (SPACE_SIZE_X, SPACE_SIZE_Y);
-                table.attach (*space, 0, 1, r, r+1,
-                      (Gtk::AttachOptions)0, (Gtk::AttachOptions)0,0,0);
-            }
-        }
-        ++r;
-    }
-}
-
 void
 DocumentMetadata::build_metadata()
 {
@@ -152,7 +125,14 @@ DocumentMetadata::build_metadata()
     Gtk::Label *label = manage (new Gtk::Label);
     label->set_markup (_("<b>Dublin Core Entities</b>"));
     label->set_alignment (0.0);
-    _page_metadata1.table().attach (*label, 0,3,0,1, Gtk::FILL, (Gtk::AttachOptions)0,0,0);
+
+#if WITH_GTKMM_3_0
+    label->set_valign(Gtk::ALIGN_CENTER);
+    _page_metadata1.attach(*label, 0, 0, 3, 1);
+#else
+    _page_metadata1.attach(*label, 0,3,0,1, Gtk::FILL, (Gtk::AttachOptions)0,0,0);
+#endif
+
      /* add generic metadata entry areas */
     struct rdf_work_entity_t * entity;
     int row = 1;
@@ -162,9 +142,22 @@ DocumentMetadata::build_metadata()
             _rdflist.push_back (w);
             Gtk::HBox *space = manage (new Gtk::HBox);
             space->set_size_request (SPACE_SIZE_X, SPACE_SIZE_Y);
-            _page_metadata1.table().attach (*space, 0,1, row, row+1, Gtk::FILL, (Gtk::AttachOptions)0,0,0);
-            _page_metadata1.table().attach (w->_label, 1,2, row, row+1, Gtk::FILL, (Gtk::AttachOptions)0,0,0);
-            _page_metadata1.table().attach (*w->_packable, 2,3, row, row+1, Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
+
+#if WITH_GTKMM_3_0
+            space->set_valign(Gtk::ALIGN_CENTER);
+            _page_metadata1.attach(*space, 0, row, 1, 1);
+
+            w->_label.set_valign(Gtk::ALIGN_CENTER);
+            _page_metadata1.attach(w->_label, 1, row, 1, 1);
+
+            w->_packable->set_hexpand();
+            w->_packable->set_valign(Gtk::ALIGN_CENTER);
+            _page_metadata1.attach(*w->_packable, 2, row, 1, 1);
+#else
+            _page_metadata1.attach(*space, 0,1, row, row+1, Gtk::FILL, (Gtk::AttachOptions)0,0,0);
+            _page_metadata1.attach(w->_label, 1,2, row, row+1, Gtk::FILL, (Gtk::AttachOptions)0,0,0);
+            _page_metadata1.attach(*w->_packable, 2,3, row, row+1, Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
+#endif
         }
     }
 
@@ -174,14 +167,31 @@ DocumentMetadata::build_metadata()
     Gtk::Label *llabel = manage (new Gtk::Label);
     llabel->set_markup (_("<b>License</b>"));
     llabel->set_alignment (0.0);
-    _page_metadata2.table().attach (*llabel, 0,3, row, row+1, Gtk::FILL, (Gtk::AttachOptions)0,0,0);
+
+#if WITH_GTKMM_3_0
+    llabel->set_valign(Gtk::ALIGN_CENTER);
+    _page_metadata2.attach(*llabel, 0, row, 3, 1);
+#else
+    _page_metadata2.attach(*llabel, 0,3, row, row+1, Gtk::FILL, (Gtk::AttachOptions)0,0,0);
+#endif
+
     /* add license selector pull-down and URI */
     ++row;
     _licensor.init (_wr);
     Gtk::HBox *space = manage (new Gtk::HBox);
     space->set_size_request (SPACE_SIZE_X, SPACE_SIZE_Y);
-    _page_metadata2.table().attach (*space, 0,1, row, row+1, Gtk::FILL, (Gtk::AttachOptions)0,0,0);
-    _page_metadata2.table().attach (_licensor, 1,3, row, row+1, Gtk::EXPAND|Gtk::FILL, (Gtk::AttachOptions)0,0,0);
+
+#if WITH_GTKMM_3_0
+    space->set_valign(Gtk::ALIGN_CENTER);
+    _page_metadata2.attach(*space, 0, row, 1, 1);
+
+    _licensor.set_hexpand();
+    _licensor.set_valign(Gtk::ALIGN_CENTER);
+    _page_metadata2.attach(_licensor, 1, row, 2, 1);
+#else
+    _page_metadata2.attach(*space, 0,1, row, row+1, Gtk::FILL, (Gtk::AttachOptions)0,0,0);
+    _page_metadata2.attach(_licensor, 1,3, row, row+1, Gtk::EXPAND|Gtk::FILL, (Gtk::AttachOptions)0,0,0);
+#endif
 }
 
 /**
diff --git a/src/ui/dialog/document-metadata.h b/src/ui/dialog/document-metadata.h
index f201679b5..3b7ed1ec8 100644
--- a/src/ui/dialog/document-metadata.h
+++ b/src/ui/dialog/document-metadata.h
@@ -13,12 +13,22 @@
 #ifndef INKSCAPE_UI_DIALOG_DOCUMENT_METADATA_H
 #define INKSCAPE_UI_DIALOG_DOCUMENT_METADATA_H
 
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
 #include <list>
 #include <stddef.h>
 #include "ui/widget/panel.h"
 #include <gtkmm/notebook.h>
+
+#if WITH_GTKMM_3_0
+# include <gtkmm/grid.h>
+#else
+# include <gtkmm/table.h>
+#endif
+
 #include "ui/widget/licensor.h"
-#include "ui/widget/notebook-page.h"
 #include "ui/widget/registry.h"
 
 namespace Inkscape {
@@ -51,8 +61,13 @@ protected:
 
     Gtk::Notebook  _notebook;
 
-    UI::Widget::NotebookPage _page_metadata1;
-    UI::Widget::NotebookPage _page_metadata2;
+#if WITH_GTKMM_3_0
+    Gtk::Grid     _page_metadata1;
+    Gtk::Grid     _page_metadata2;
+#else
+    Gtk::Table     _page_metadata1;
+    Gtk::Table     _page_metadata2;
+#endif
 
     //---------------------------------------------------------------
     RDElist _rdflist;
diff --git a/src/ui/dialog/guides.cpp b/src/ui/dialog/guides.cpp
index d20f2a220..1f02002ca 100644
--- a/src/ui/dialog/guides.cpp
+++ b/src/ui/dialog/guides.cpp
@@ -168,30 +168,54 @@ void GuidelinePropertiesDialog::_setup() {
 
     Gtk::Box *mainVBox = get_vbox();
 
+#if WITH_GTKMM_3_0
+    _layout_table.set_row_spacing(4);
+    _layout_table.set_column_spacing(4);
+#else
     _layout_table.set_spacings(4);
     _layout_table.resize (3, 4);
+#endif
 
     mainVBox->pack_start(_layout_table, false, false, 0);
 
     _label_name.set_label("foo0");
-    _layout_table.attach(_label_name,
-                         0, 3, 0, 1, Gtk::FILL, Gtk::FILL);
     _label_name.set_alignment(0, 0.5);
 
     _label_descr.set_label("foo1");
-    _layout_table.attach(_label_descr,
-                         0, 3, 1, 2, Gtk::FILL, Gtk::FILL);
     _label_descr.set_alignment(0, 0.5);
+    
+#if WITH_GTKMM_3_0
+    _label_name.set_halign(Gtk::ALIGN_FILL);
+    _label_name.set_valign(Gtk::ALIGN_FILL);
+    _layout_table.attach(_label_name, 0, 0, 3, 1);
+
+    _label_descr.set_halign(Gtk::ALIGN_FILL);
+    _label_descr.set_valign(Gtk::ALIGN_FILL);
+    _layout_table.attach(_label_descr, 0, 1, 3, 1);
+
+    _label_entry.set_halign(Gtk::ALIGN_FILL);
+    _label_entry.set_valign(Gtk::ALIGN_FILL);
+    _label_entry.set_hexpand();
+    _layout_table.attach(_label_entry, 1, 2, 2, 1);
+
+    _color.set_halign(Gtk::ALIGN_FILL);
+    _color.set_valign(Gtk::ALIGN_FILL);
+    _color.set_hexpand();
+    _layout_table.attach(_color, 1, 3, 2, 1);
+#else
+    _layout_table.attach(_label_name,
+                         0, 3, 0, 1, Gtk::FILL, Gtk::FILL);
 
-    // indent
-//    _layout_table.attach(*manage(new Gtk::Label(" ")),
-//                         0, 1, 2, 3, Gtk::FILL, Gtk::FILL, 10);
+    _layout_table.attach(_label_descr,
+                         0, 3, 1, 2, Gtk::FILL, Gtk::FILL);
 
     _layout_table.attach(_label_entry,
                          1, 3, 2, 3, Gtk::EXPAND | Gtk::FILL, Gtk::FILL);
 
     _layout_table.attach(_color,
                          1, 3, 3, 4, Gtk::EXPAND | Gtk::FILL, Gtk::FILL);
+#endif
+
     _color.signal_color_set().connect(sigc::mem_fun(*this, &GuidelinePropertiesDialog::_colorChanged));
 
 
@@ -211,6 +235,22 @@ void GuidelinePropertiesDialog::_setup() {
     _spin_button_y.setDigits(3);
     _spin_button_y.setIncrements(1.0, 10.0);
     _spin_button_y.setRange(-1e6, 1e6);
+
+#if WITH_GTKMM_3_0
+    _spin_button_x.set_halign(Gtk::ALIGN_FILL);
+    _spin_button_x.set_valign(Gtk::ALIGN_FILL);
+    _spin_button_x.set_hexpand();
+    _layout_table.attach(_spin_button_x, 1, 4, 1, 1);
+    
+    _spin_button_y.set_halign(Gtk::ALIGN_FILL);
+    _spin_button_y.set_valign(Gtk::ALIGN_FILL);
+    _spin_button_y.set_hexpand();
+    _layout_table.attach(_spin_button_y, 1, 5, 1, 1);
+
+    _unit_menu.set_halign(Gtk::ALIGN_FILL);
+    _unit_menu.set_valign(Gtk::ALIGN_FILL);
+    _layout_table.attach(_unit_menu, 2, 4, 1, 1);
+#else
     _layout_table.attach(_spin_button_x,
                          1, 2, 4, 5, Gtk::EXPAND | Gtk::FILL, Gtk::FILL);
     _layout_table.attach(_spin_button_y,
@@ -218,17 +258,33 @@ void GuidelinePropertiesDialog::_setup() {
 
     _layout_table.attach(_unit_menu,
                          2, 3, 4, 5, Gtk::FILL, Gtk::FILL);
+#endif
 
     // angle spinbutton
     _spin_angle.setDigits(3);
     _spin_angle.setIncrements(1.0, 10.0);
     _spin_angle.setRange(-3600., 3600.);
+
+#if WITH_GTKMM_3_0
+    _spin_angle.set_halign(Gtk::ALIGN_FILL);
+    _spin_angle.set_valign(Gtk::ALIGN_FILL);
+    _spin_angle.set_hexpand();
+    _layout_table.attach(_spin_angle, 1, 6, 2, 1);
+
+    // mode radio button
+    _relative_toggle.set_halign(Gtk::ALIGN_FILL);
+    _relative_toggle.set_valign(Gtk::ALIGN_FILL);
+    _relative_toggle.set_hexpand();
+    _layout_table.attach(_relative_toggle, 1, 7, 2, 1);
+#else
     _layout_table.attach(_spin_angle,
                          1, 3, 6, 7, Gtk::EXPAND | Gtk::FILL, Gtk::FILL);
 
     // mode radio button
     _layout_table.attach(_relative_toggle,
                          1, 3, 7, 8, Gtk::EXPAND | Gtk::FILL, Gtk::FILL);
+#endif
+
     _relative_toggle.signal_toggled().connect(sigc::mem_fun(*this, &GuidelinePropertiesDialog::_modeChanged));
     _relative_toggle.set_active(_relative_toggle_status);
 
diff --git a/src/ui/dialog/guides.h b/src/ui/dialog/guides.h
index d06c3afc8..a15667152 100644
--- a/src/ui/dialog/guides.h
+++ b/src/ui/dialog/guides.h
@@ -11,8 +11,18 @@
 #ifndef INKSCAPE_DIALOG_GUIDELINE_H
 #define INKSCAPE_DIALOG_GUIDELINE_H
 
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
 #include <gtkmm/dialog.h>
+
+#if WITH_GTKMM_3_0
+#include <gtkmm/grid.h>
+#else
 #include <gtkmm/table.h>
+#endif
+
 #include <gtkmm/label.h>
 #include <gtkmm/colorbutton.h>
 #include "ui/widget/button.h"
@@ -62,7 +72,13 @@ private:
 
     SPDesktop *_desktop;
     SPGuide *_guide;
+
+#if WITH_GTKMM_3_0
+    Gtk::Grid  _layout_table;
+#else
     Gtk::Table  _layout_table;
+#endif
+
     Gtk::Label  _label_name;
     Gtk::Label  _label_descr;
     Inkscape::UI::Widget::CheckButton _relative_toggle;
diff --git a/src/ui/dialog/input.cpp b/src/ui/dialog/input.cpp
index 7e2b0a1e1..4c567a6e3 100644
--- a/src/ui/dialog/input.cpp
+++ b/src/ui/dialog/input.cpp
@@ -357,6 +357,15 @@ static std::map<Gdk::InputMode, Glib::ustring> &getModeToString()
     return mapping;
 }
 
+static int getModeId(Gdk::InputMode im)
+{
+    if (im == Gdk::MODE_DISABLED) return 0;
+    if (im == Gdk::MODE_SCREEN) return 1;
+    if (im == Gdk::MODE_WINDOW) return 2;
+
+    return 0;
+}
+
 static std::map<Glib::ustring, Gdk::InputMode> &getStringToMode()
 {
     static std::map<Glib::ustring, Gdk::InputMode> mapping;
@@ -400,15 +409,59 @@ private:
         static void setCellStateToggle(Gtk::CellRenderer *rndr, Gtk::TreeIter const &iter);
 
         void saveSettings();
+        void onTreeSelect();
         void useExtToggled();
 
-        Glib::RefPtr<Gtk::TreeStore> store;
-        Gtk::TreeIter tabletIter;
-        Gtk::TreeView tree;
-        Gtk::ScrolledWindow treeScroller;
+        void onModeChange();
+        void setKeys(gint count);
+        void setAxis(gint count);
+
+        Glib::RefPtr<Gtk::TreeStore> confDeviceStore;
+        Gtk::TreeIter confDeviceIter;
+        Gtk::TreeView confDeviceTree;
+        Gtk::ScrolledWindow confDeviceScroller;
         Blink watcher;
         Gtk::CheckButton useExt;
         Gtk::Button save;
+
+        Gtk::HPaned pane;
+        Gtk::VBox detailsBox;
+        Gtk::HBox titleFrame;
+        Gtk::Label titleLabel;
+        Inkscape::UI::Widget::Frame axisFrame;
+        Inkscape::UI::Widget::Frame keysFrame;
+        Gtk::VBox axisVBox;
+        Gtk::ComboBoxText modeCombo;
+        Gtk::Label modeLabel;
+        Gtk::HBox modeBox;
+
+        class KeysColumns : public Gtk::TreeModel::ColumnRecord
+        {
+          public:
+            KeysColumns()
+            {
+                add(name);
+                add(value);
+            }
+            virtual ~KeysColumns() {}
+
+            Gtk::TreeModelColumn<Glib::ustring> name;
+            Gtk::TreeModelColumn<Glib::ustring> value;
+        };
+
+        KeysColumns keysColumns;
+        KeysColumns axisColumns;
+
+        Glib::RefPtr<Gtk::ListStore> axisStore;
+        Gtk::TreeView     axisTree;
+        Gtk::ScrolledWindow axisScroll;
+
+        Glib::RefPtr<Gtk::ListStore> keysStore;
+        Gtk::TreeView     keysTree;
+        Gtk::ScrolledWindow keysScroll;
+        Gtk::CellRendererAccel _kb_shortcut_renderer;
+
+
     };
 
     static DeviceModelColumns &getCols();
@@ -425,11 +478,11 @@ private:
     GdkInputSource lastSourceSeen;
     Glib::ustring lastDevnameSeen;
 
-    Glib::RefPtr<Gtk::TreeStore> store;
-    Gtk::TreeIter tabletIter;
-    Gtk::TreeView tree;
-    Inkscape::UI::Widget::Frame detailFrame;
+    Glib::RefPtr<Gtk::TreeStore> deviceStore;
+    Gtk::TreeIter deviceIter;
+    Gtk::TreeView deviceTree;
     Inkscape::UI::Widget::Frame testFrame;
+    Inkscape::UI::Widget::Frame axisFrame;
     Gtk::ScrolledWindow treeScroller;
     Gtk::ScrolledWindow detailScroller;
     Gtk::HPaned splitter;
@@ -439,12 +492,13 @@ private:
     Gtk::Label devAxesCount;
     Gtk::ComboBoxText axesCombo;
     Gtk::ProgressBar axesValues[6];
+    Gtk::Table axisTable;
+
     Gtk::ComboBoxText buttonCombo;
     Gtk::ComboBoxText linkCombo;
     sigc::connection linkConnection;
     Gtk::Label keyVal;
     Gtk::Entry keyEntry;
-    Gtk::Table devDetails;
     Gtk::Notebook topHolder;
     Gtk::Image testThumb;
     Gtk::Image testButtons[24];
@@ -454,6 +508,7 @@ private:
 
     ConfPanel cfgPanel;
 
+
     static void setupTree( Glib::RefPtr<Gtk::TreeStore> store, Gtk::TreeIter &tablet );
     void setupValueAndCombo( gint reported, gint actual, Gtk::Label& label, Gtk::ComboBoxText& combo );
     void updateTestButtons( Glib::ustring const& key, gint hotButton );
@@ -526,17 +581,17 @@ InputDialogImpl::InputDialogImpl() :
 
     lastSourceSeen((GdkInputSource)-1),
     lastDevnameSeen(""),
-    store(Gtk::TreeStore::create(getCols())),
-    tabletIter(),
-    tree(store),
-    detailFrame(),
+    deviceStore(Gtk::TreeStore::create(getCols())),
+    deviceIter(),
+    deviceTree(deviceStore),
     testFrame(_("Test Area")),
+    axisFrame(_("Axis")),
     treeScroller(),
     detailScroller(),
     splitter(),
     split2(),
+    axisTable(11, 2),
     linkCombo(),
-    devDetails(12, 2),
     topHolder(),
     imageTable(8, 7),
     testDetector(),
@@ -547,10 +602,12 @@ InputDialogImpl::InputDialogImpl() :
 
     treeScroller.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
     treeScroller.set_shadow_type(Gtk::SHADOW_IN);
-    treeScroller.add(tree);
+    treeScroller.add(deviceTree);
     treeScroller.set_size_request(50, 0);
-    split2.pack1(testFrame, false, false);
-    split2.pack2(detailFrame, true, true);
+
+    split2.pack1(axisFrame, false, false);
+    split2.pack2(testFrame, true, true);
+
     splitter.pack1(treeScroller);
     splitter.pack2(split2);
 
@@ -585,27 +642,35 @@ InputDialogImpl::InputDialogImpl() :
     }
 
 
-    topHolder.append_page(cfgPanel, _("Configuration"));
-    topHolder.append_page(splitter, _("Hardware"));
-    topHolder.show_all();
-    topHolder.set_current_page(0);
+    // This is a hidden preference to enable the "hardware" details in a separate tab
+    // By default this is not available to users
+    if (Preferences::get()->getBool("/dialogs/inputdevices/test")) {
+        topHolder.append_page(cfgPanel, _("Configuration"));
+        topHolder.append_page(splitter, _("Hardware"));
+        topHolder.show_all();
+        topHolder.set_current_page(0);
+        contents->pack_start(topHolder);
+    } else {
+        contents->pack_start(cfgPanel);
+    }
 
-    contents->pack_start(topHolder);
 
     int rowNum = 0;
 
 /*    Gtk::Label* lbl = Gtk::manage(new Gtk::Label(_("Name:")));
-    devDetails.attach(*lbl, 0, 1, rowNum, rowNum+ 1,
+    axisTable.attach(*lbl, 0, 1, rowNum, rowNum+ 1,
                       ::Gtk::FILL,
                       ::Gtk::SHRINK);
-    devDetails.attach(devName, 1, 2, rowNum, rowNum + 1,
+    axisTable.attach(devName, 1, 2, rowNum, rowNum + 1,
                       ::Gtk::SHRINK,
                       ::Gtk::SHRINK);
 
     rowNum++;*/
 
+    axisFrame.add(axisTable);
+
     Gtk::Label *lbl = Gtk::manage(new Gtk::Label(_("Link:")));
-    devDetails.attach(*lbl, 0, 1, rowNum, rowNum+ 1,
+    axisTable.attach(*lbl, 0, 1, rowNum, rowNum+ 1,
                       ::Gtk::FILL,
                       ::Gtk::SHRINK);
 
@@ -614,21 +679,23 @@ InputDialogImpl::InputDialogImpl() :
     linkCombo.set_sensitive(false);
     linkConnection = linkCombo.signal_changed().connect(sigc::mem_fun(*this, &InputDialogImpl::linkComboChanged));
 
-    devDetails.attach(linkCombo, 1, 2, rowNum, rowNum + 1,
+    axisTable.attach(linkCombo, 1, 2, rowNum, rowNum + 1,
                       ::Gtk::FILL,
                       ::Gtk::SHRINK);
     rowNum++;
 
+
     lbl = Gtk::manage(new Gtk::Label(_("Axes count:")));
-    devDetails.attach(*lbl, 0, 1, rowNum, rowNum+ 1,
+    axisTable.attach(*lbl, 0, 1, rowNum, rowNum+ 1,
                       ::Gtk::FILL,
                       ::Gtk::SHRINK);
-    devDetails.attach(devAxesCount, 1, 2, rowNum, rowNum + 1,
+    axisTable.attach(devAxesCount, 1, 2, rowNum, rowNum + 1,
                       ::Gtk::SHRINK,
                       ::Gtk::SHRINK);
 
     rowNum++;
 
+
 /*
     lbl = Gtk::manage(new Gtk::Label(_("Actual axes count:")));
     devDetails.attach(*lbl, 0, 1, rowNum, rowNum+ 1,
@@ -643,22 +710,24 @@ InputDialogImpl::InputDialogImpl() :
 
     for ( guint barNum = 0; barNum < static_cast<guint>(G_N_ELEMENTS(axesValues)); barNum++ ) {
         lbl = Gtk::manage(new Gtk::Label(_("axis:")));
-        devDetails.attach(*lbl, 0, 1, rowNum, rowNum+ 1,
-                          ::Gtk::FILL,
+        axisTable.attach(*lbl, 0, 1, rowNum, rowNum+ 1,
+                          ::Gtk::EXPAND,
                           ::Gtk::SHRINK);
-        devDetails.attach(axesValues[barNum], 1, 2, rowNum, rowNum + 1,
+        axisTable.attach(axesValues[barNum], 1, 2, rowNum, rowNum + 1,
                           ::Gtk::EXPAND,
                           ::Gtk::SHRINK);
         axesValues[barNum].set_sensitive(false);
 
         rowNum++;
+
+
     }
 
     lbl = Gtk::manage(new Gtk::Label(_("Button count:")));
-    devDetails.attach(*lbl, 0, 1, rowNum, rowNum+ 1,
+    axisTable.attach(*lbl, 0, 1, rowNum, rowNum+ 1,
                       ::Gtk::FILL,
                       ::Gtk::SHRINK);
-    devDetails.attach(devKeyCount, 1, 2, rowNum, rowNum + 1,
+    axisTable.attach(devKeyCount, 1, 2, rowNum, rowNum + 1,
                       ::Gtk::SHRINK,
                       ::Gtk::SHRINK);
 
@@ -676,7 +745,7 @@ InputDialogImpl::InputDialogImpl() :
     rowNum++;
 */
 
-    devDetails.attach(keyVal, 0, 2, rowNum, rowNum + 1,
+    axisTable.attach(keyVal, 0, 2, rowNum, rowNum + 1,
                       ::Gtk::FILL,
                       ::Gtk::SHRINK);
     rowNum++;
@@ -696,19 +765,18 @@ InputDialogImpl::InputDialogImpl() :
 #endif
     testDetector.add_events(Gdk::POINTER_MOTION_MASK|Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK |Gdk::PROXIMITY_IN_MASK|Gdk::PROXIMITY_OUT_MASK|Gdk::SCROLL_MASK);
 
-    devDetails.attach(keyEntry, 0, 2, rowNum, rowNum + 1,
+    axisTable.attach(keyEntry, 0, 2, rowNum, rowNum + 1,
                       ::Gtk::FILL,
                       ::Gtk::SHRINK);
     rowNum++;
 
 
-    devDetails.set_sensitive(false);
-    detailScroller.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+    axisTable.set_sensitive(false);
+
+/*    detailScroller.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
     detailScroller.set_shadow_type(Gtk::SHADOW_NONE);
     detailScroller.set_border_width (0);
-    detailScroller.add(devDetails);
-    detailFrame.add(detailScroller);
-    detailFrame.set_size_request(0, 60);
+    detailScroller.add(devDetails);*/
 
 //- 16x16/devices
 // gnome-dev-mouse-optical
@@ -717,25 +785,24 @@ InputDialogImpl::InputDialogImpl() :
 // mouse
 
 
-
     //Add the TreeView's view columns:
-    tree.append_column("I", getCols().thumbnail);
-    tree.append_column("Bar", getCols().description);
+    deviceTree.append_column("I", getCols().thumbnail);
+    deviceTree.append_column("Bar", getCols().description);
 
-    tree.set_enable_tree_lines();
-    tree.set_headers_visible(false);
-    tree.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &InputDialogImpl::resyncToSelection));
+    deviceTree.set_enable_tree_lines();
+    deviceTree.set_headers_visible(false);
+    deviceTree.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &InputDialogImpl::resyncToSelection));
 
 
-    setupTree( store, tabletIter );
+    setupTree( deviceStore, deviceIter );
 
     Inkscape::DeviceManager::getManager().signalDeviceChanged().connect(sigc::mem_fun(*this, &InputDialogImpl::handleDeviceChange));
     Inkscape::DeviceManager::getManager().signalAxesChanged().connect(sigc::mem_fun(*this, &InputDialogImpl::updateDeviceAxes));
     Inkscape::DeviceManager::getManager().signalButtonsChanged().connect(sigc::mem_fun(*this, &InputDialogImpl::updateDeviceButtons));
-    Glib::RefPtr<Gtk::TreeView> treePtr(&tree);
-    Inkscape::DeviceManager::getManager().signalLinkChanged().connect(sigc::bind(sigc::ptr_fun(&InputDialogImpl::updateDeviceLinks), tabletIter, treePtr));
+    Glib::RefPtr<Gtk::TreeView> treePtr(&deviceTree);
+    Inkscape::DeviceManager::getManager().signalLinkChanged().connect(sigc::bind(sigc::ptr_fun(&InputDialogImpl::updateDeviceLinks), deviceIter, treePtr));
 
-    tree.expand_all();
+    deviceTree.expand_all();
     show_all_children();
 }
 
@@ -777,12 +844,30 @@ static Glib::ustring getCommon( std::list<Glib::ustring> const &names )
     return result;
 }
 
+
+void InputDialogImpl::ConfPanel::onModeChange()
+{
+    Glib::ustring newText = modeCombo.get_active_text();
+
+    Glib::RefPtr<Gtk::TreeSelection> sel = confDeviceTree.get_selection();
+    Gtk::TreeModel::iterator iter = sel->get_selected();
+    if (iter) {
+        Glib::RefPtr<InputDevice const> dev = (*iter)[getCols().device];
+        if (dev && (getStringToMode().find(newText) != getStringToMode().end())) {
+            Gdk::InputMode mode = getStringToMode()[newText];
+            Inkscape::DeviceManager::getManager().setMode( dev->getId(), mode );
+        }
+    }
+
+}
+
+
 void InputDialogImpl::setupTree( Glib::RefPtr<Gtk::TreeStore> store, Gtk::TreeIter &tablet )
 {
     std::list<Glib::RefPtr<InputDevice const> > devList = Inkscape::DeviceManager::getManager().getDevices();
     if ( !devList.empty() ) {
-        Gtk::TreeModel::Row row = *(store->append());
-        row[getCols().description] = _("Hardware");
+        //Gtk::TreeModel::Row row = *(store->append());
+        //row[getCols().description] = _("Hardware");
 
         // Let's make some tablets!!!
         std::list<TabletTmp> tablets;
@@ -807,7 +892,7 @@ void InputDialogImpl::setupTree( Glib::RefPtr<Gtk::TreeStore> store, Gtk::TreeIt
 
         // Phase 2 - build a UI for the present devices
         for ( std::list<TabletTmp>::iterator it = tablets.begin(); it != tablets.end(); ++it ) {
-            tablet = store->append(row.children());
+            tablet = store->prepend(/*row.children()*/);
             Gtk::TreeModel::Row childrow = *tablet;
             if ( it->name.empty() ) {
                 // Check to see if we can derive one
@@ -870,13 +955,14 @@ void InputDialogImpl::setupTree( Glib::RefPtr<Gtk::TreeStore> store, Gtk::TreeIt
         for ( std::list<Glib::RefPtr<InputDevice const> >::iterator it = devList.begin(); it != devList.end(); ++it ) {
             Glib::RefPtr<InputDevice const> dev = *it;
             if ( dev && (consumed.find( dev->getId() ) == consumed.end()) ) {
-                Gtk::TreeModel::Row deviceRow = *(store->append(row.children()));
+                Gtk::TreeModel::Row deviceRow = *(store->prepend(/*row.children()*/));
                 deviceRow[getCols().description] = dev->getName();
                 deviceRow[getCols().device] = dev;
                 deviceRow[getCols().mode] = dev->getMode();
                 deviceRow[getCols().thumbnail] = getPix(PIX_CORE);
             }
         }
+
     } else {
         g_warning("No devices found");
     }
@@ -885,84 +971,158 @@ void InputDialogImpl::setupTree( Glib::RefPtr<Gtk::TreeStore> store, Gtk::TreeIt
 
 InputDialogImpl::ConfPanel::ConfPanel() :
     Gtk::VBox(),
-    store(Gtk::TreeStore::create(getCols())),
-    tabletIter(),
-    tree(store),
-    treeScroller(),
+    confDeviceStore(Gtk::TreeStore::create(getCols())),
+    confDeviceIter(),
+    confDeviceTree(confDeviceStore),
+    confDeviceScroller(),
     watcher(*this),
     useExt(_("_Use pressure-sensitive tablet (requires restart)"), true),
-    save(_("_Save"), true)
+    save(_("_Save"), true),
+    detailsBox(false, 4),
+    titleFrame(false, 4),
+    titleLabel(""),
+    axisFrame(_("Axes")),
+    keysFrame(_("Keys")),
+    modeLabel(_("Mode")),
+    modeBox(false, 4)
+
 {
-    pack_start(treeScroller);
 
-    treeScroller.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
-    treeScroller.add(tree);
 
-    class Foo : public Gtk::TreeModel::ColumnRecord {
+    confDeviceScroller.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+    confDeviceScroller.set_shadow_type(Gtk::SHADOW_IN);
+    confDeviceScroller.add(confDeviceTree);
+    confDeviceScroller.set_size_request(120, 0);
+
+    /*    class Foo : public Gtk::TreeModel::ColumnRecord {
     public :
         Gtk::TreeModelColumn<Glib::ustring> one;
         Foo() {add(one);}
     };
     static Foo foo;
-    Glib::RefPtr<Gtk::ListStore> poppers = Gtk::ListStore::create(foo);
-    poppers->reference();
-
-    Gtk::TreeModel::Row row = *(poppers->append());
-    row[foo.one] = getModeToString()[Gdk::MODE_DISABLED];
-    row = *(poppers->append());
-    row[foo.one] = getModeToString()[Gdk::MODE_SCREEN];
-    row = *(poppers->append());
-    row[foo.one] = getModeToString()[Gdk::MODE_WINDOW];
 
     //Add the TreeView's view columns:
     {
         Gtk::CellRendererToggle *rendr = new Gtk::CellRendererToggle();
         Gtk::TreeViewColumn *col = new Gtk::TreeViewColumn("xx", *rendr);
         if (col) {
-            tree.append_column(*col);
+            confDeviceTree.append_column(*col);
             col->set_cell_data_func(*rendr, sigc::ptr_fun(setCellStateToggle));
-            rendr->signal_toggled().connect(sigc::bind(sigc::ptr_fun(commitCellStateChange), store));
+            rendr->signal_toggled().connect(sigc::bind(sigc::ptr_fun(commitCellStateChange), confDeviceStore));
         }
-    }
+    }*/
 
-    int expPos = tree.append_column("", getCols().expander);
+    //int expPos = confDeviceTree.append_column("", getCols().expander);
 
-    tree.append_column("I", getCols().thumbnail);
-    tree.append_column("Bar", getCols().description);
+    confDeviceTree.append_column("I", getCols().thumbnail);
+    confDeviceTree.append_column("Bar", getCols().description);
 
-    {
-        Gtk::CellRendererCombo *rendr = new Gtk::CellRendererCombo();
-        rendr->property_model().set_value(poppers);
-        rendr->property_text_column().set_value(0);
-        rendr->property_has_entry() = false;
+    //confDeviceTree.get_column(0)->set_fixed_width(100);
+    //confDeviceTree.get_column(1)->set_expand();
+
+/*    {
         Gtk::TreeViewColumn *col = new Gtk::TreeViewColumn("X", *rendr);
         if (col) {
-            tree.append_column(*col);
+            confDeviceTree.append_column(*col);
             col->set_cell_data_func(*rendr, sigc::ptr_fun(setModeCellString));
-            rendr->signal_edited().connect(sigc::bind(sigc::ptr_fun(commitCellModeChange), store));
+            rendr->signal_edited().connect(sigc::bind(sigc::ptr_fun(commitCellModeChange), confDeviceStore));
             rendr->property_editable() = true;
         }
-    }
+    }*/
 
-    tree.set_enable_tree_lines();
-    tree.set_headers_visible(false);
-    tree.set_expander_column( *tree.get_column(expPos - 1) );
+    //confDeviceTree.set_enable_tree_lines();
+    confDeviceTree.property_enable_tree_lines() = false;
+    confDeviceTree.property_enable_grid_lines() = false;
+    confDeviceTree.set_headers_visible(false);
+    //confDeviceTree.set_expander_column( *confDeviceTree.get_column(expPos - 1) );
 
-    setupTree( store, tabletIter );
+    confDeviceTree.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &InputDialogImpl::ConfPanel::onTreeSelect));
 
-    Glib::RefPtr<Gtk::TreeView> treePtr(&tree);
-    Inkscape::DeviceManager::getManager().signalLinkChanged().connect(sigc::bind(sigc::ptr_fun(&InputDialogImpl::updateDeviceLinks), tabletIter, treePtr));
+    setupTree( confDeviceStore, confDeviceIter );
 
-    tree.expand_all();
+    Glib::RefPtr<Gtk::TreeView> treePtr(&confDeviceTree);
+    Inkscape::DeviceManager::getManager().signalLinkChanged().connect(sigc::bind(sigc::ptr_fun(&InputDialogImpl::updateDeviceLinks), confDeviceIter, treePtr));
+
+    confDeviceTree.expand_all();
 
     useExt.set_active(Preferences::get()->getBool("/options/useextinput/value"));
     useExt.signal_toggled().connect(sigc::mem_fun(*this, &InputDialogImpl::ConfPanel::useExtToggled));
-    pack_start(useExt, Gtk::PACK_SHRINK);
 
+    Gtk::HButtonBox *buttonBox = manage (new Gtk::HButtonBox);
+    buttonBox->set_layout (Gtk::BUTTONBOX_END);
+    //Gtk::Alignment *align = new Gtk::Alignment(Gtk::ALIGN_END, Gtk::ALIGN_START, 0, 0);
+    buttonBox->add(save);
     save.signal_clicked().connect(sigc::mem_fun(*this, &InputDialogImpl::ConfPanel::saveSettings));
-    Gtk::Alignment *align = new Gtk::Alignment(Gtk::ALIGN_END, Gtk::ALIGN_START, 0, 0);
-    align->add(save);
-    pack_start(*Gtk::manage(align), Gtk::PACK_SHRINK);
+
+    titleFrame.pack_start(titleLabel, true, true);
+    //titleFrame.set_shadow_type(Gtk::SHADOW_IN);
+
+    modeCombo.append(getModeToString()[Gdk::MODE_DISABLED]);
+    modeCombo.append(getModeToString()[Gdk::MODE_SCREEN]);
+    modeCombo.append(getModeToString()[Gdk::MODE_WINDOW]);
+    modeCombo.set_tooltip_text(_("A device can be 'Disabled', its co-ordinates mapped to the whole 'Screen', or to a single (usually focused) 'Window'"));
+    modeCombo.signal_changed().connect(sigc::mem_fun(*this, &InputDialogImpl::ConfPanel::onModeChange));
+
+    modeBox.pack_start(modeLabel, false, false);
+    modeBox.pack_start(modeCombo, true, true);
+
+    axisVBox.add(axisScroll);
+    axisFrame.add(axisVBox);
+
+    keysFrame.add(keysScroll);
+
+    /**
+     * Scrolled Window
+     */
+    keysScroll.add(keysTree);
+    keysScroll.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+    keysScroll.set_shadow_type(Gtk::SHADOW_IN);
+    keysScroll.set_size_request(120, 80);
+
+    keysStore = Gtk::ListStore::create(keysColumns);
+
+    _kb_shortcut_renderer.property_editable() = true;
+
+    keysTree.set_model(keysStore);
+    keysTree.set_headers_visible(false);
+    keysTree.append_column("Name", keysColumns.name);
+    keysTree.append_column("Value", keysColumns.value);
+
+    //keysTree.append_column("Value", _kb_shortcut_renderer);
+    //keysTree.get_column(1)->add_attribute(_kb_shortcut_renderer.property_text(), keysColumns.value);
+    //_kb_shortcut_renderer.signal_accel_edited().connect( sigc::mem_fun(*this, &InputDialogImpl::onKBTreeEdited) );
+    //_kb_shortcut_renderer.signal_accel_cleared().connect( sigc::mem_fun(*this, &InputDialogImpl::onKBTreeCleared) );
+
+    axisStore = Gtk::ListStore::create(axisColumns);
+
+    axisTree.set_model(axisStore);
+    axisTree.set_headers_visible(false);
+    axisTree.append_column("Name", axisColumns.name);
+    axisTree.append_column("Value", axisColumns.value);
+
+    /**
+     * Scrolled Window
+     */
+    axisScroll.add(axisTree);
+    axisScroll.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+    axisScroll.set_shadow_type(Gtk::SHADOW_IN);
+    axisScroll.set_size_request(0, 150);
+
+    pane.pack1(confDeviceScroller);
+    pane.pack2(detailsBox);
+
+    detailsBox.pack_start(titleFrame, false, false, 6);
+    detailsBox.pack_start(modeBox, false, false, 6);
+    detailsBox.pack_start(axisFrame, false, false);
+    detailsBox.pack_start(keysFrame, false, false);
+
+    pack_start(pane, true, true);
+    pack_start(useExt, Gtk::PACK_SHRINK);
+    pack_start(*buttonBox, false, false);
+
+    // Select the first device
+    confDeviceTree.get_selection()->select(confDeviceStore->get_iter("0"));
+
 }
 
 InputDialogImpl::ConfPanel::~ConfPanel()
@@ -995,6 +1155,8 @@ void InputDialogImpl::ConfPanel::commitCellModeChange(Glib::ustring const &path,
             Inkscape::DeviceManager::getManager().setMode( dev->getId(), mode );
         }
     }
+
+
 }
 
 void InputDialogImpl::ConfPanel::setCellStateToggle(Gtk::CellRenderer *rndr, Gtk::TreeIter const &iter)
@@ -1029,6 +1191,25 @@ void InputDialogImpl::ConfPanel::commitCellStateChange(Glib::ustring const &path
     }
 }
 
+void InputDialogImpl::ConfPanel::onTreeSelect()
+{
+    Glib::RefPtr<Gtk::TreeSelection> treeSel = confDeviceTree.get_selection();
+    Gtk::TreeModel::iterator iter = treeSel->get_selected();
+    if (iter) {
+        Gtk::TreeModel::Row row = *iter;
+        Glib::ustring val = row[getCols().description];
+        Glib::RefPtr<InputDevice const> dev = row[getCols().device];
+        Gdk::InputMode mode = (*iter)[getCols().mode];
+        modeCombo.set_active(getModeId(mode));
+
+        titleLabel.set_markup("<b>" + row[getCols().description] + "</b>");
+
+        if (dev) {
+            setKeys(dev->getNumKeys());
+            setAxis(dev->getNumAxes());
+        }
+    }
+}
 void InputDialogImpl::ConfPanel::saveSettings()
 {
     Inkscape::DeviceManager::getManager().saveConfig();
@@ -1070,8 +1251,8 @@ void InputDialogImpl::handleDeviceChange(Glib::RefPtr<InputDevice const> device)
 {
 //     g_message("OUCH!!!! for %p  hits %s", &device, device->getId().c_str());
     std::vector<Glib::RefPtr<Gtk::TreeStore> > stores;
-    stores.push_back(store);
-    stores.push_back(cfgPanel.store);
+    stores.push_back(deviceStore);
+    stores.push_back(cfgPanel.confDeviceStore);
 
     for (std::vector<Glib::RefPtr<Gtk::TreeStore> >::iterator it = stores.begin(); it != stores.end(); ++it) {
         Gtk::TreeModel::iterator deviceIter;
@@ -1154,11 +1335,11 @@ bool InputDialogImpl::findDeviceByLink(const Gtk::TreeModel::iterator& iter,
 
 void InputDialogImpl::updateDeviceLinks(Glib::RefPtr<InputDevice const> device, Gtk::TreeIter tabletIter, Glib::RefPtr<Gtk::TreeView> tree)
 {
-    Glib::RefPtr<Gtk::TreeStore> store = Glib::RefPtr<Gtk::TreeStore>::cast_dynamic(tree->get_model());
+    Glib::RefPtr<Gtk::TreeStore> deviceStore = Glib::RefPtr<Gtk::TreeStore>::cast_dynamic(tree->get_model());
 
 //     g_message("Links!!!! for %p  hits [%s]  with link of [%s]", &device, device->getId().c_str(), device->getLink().c_str());
     Gtk::TreeModel::iterator deviceIter;
-    store->foreach_iter( sigc::bind<Glib::ustring, Gtk::TreeModel::iterator*>(
+    deviceStore->foreach_iter( sigc::bind<Glib::ustring, Gtk::TreeModel::iterator*>(
                              sigc::ptr_fun(&InputDialogImpl::findDevice),
                              device->getId(),
                              &deviceIter) );
@@ -1176,16 +1357,16 @@ void InputDialogImpl::updateDeviceLinks(Glib::RefPtr<InputDevice const> device,
                 Glib::ustring descr = (*deviceIter)[getCols().description];
                 Glib::RefPtr<Gdk::Pixbuf> thumb = (*deviceIter)[getCols().thumbnail];
 
-                Gtk::TreeModel::Row deviceRow = *store->append(tabletIter->children());
+                Gtk::TreeModel::Row deviceRow = *deviceStore->append(tabletIter->children());
                 deviceRow[getCols().description] = descr;
                 deviceRow[getCols().thumbnail] = thumb;
                 deviceRow[getCols().device] = dev;
                 deviceRow[getCols().mode] = dev->getMode();
 
                 Gtk::TreeModel::iterator oldParent = deviceIter->parent();
-                store->erase(deviceIter);
+                deviceStore->erase(deviceIter);
                 if ( oldParent->children().empty() ) {
-                    store->erase(oldParent);
+                    deviceStore->erase(oldParent);
                 }
             }
         } else {
@@ -1193,7 +1374,7 @@ void InputDialogImpl::updateDeviceLinks(Glib::RefPtr<InputDevice const> device,
             if ( deviceIter->parent() == tabletIter ) {
                 // Simple case. Not already linked
 
-                Gtk::TreeIter newGroup = store->append(tabletIter->children());
+                Gtk::TreeIter newGroup = deviceStore->append(tabletIter->children());
                 (*newGroup)[getCols().description] = _("Pen");
                 (*newGroup)[getCols().thumbnail] = getPix(PIX_PEN);
 
@@ -1201,7 +1382,7 @@ void InputDialogImpl::updateDeviceLinks(Glib::RefPtr<InputDevice const> device,
                 Glib::ustring descr = (*deviceIter)[getCols().description];
                 Glib::RefPtr<Gdk::Pixbuf> thumb = (*deviceIter)[getCols().thumbnail];
 
-                Gtk::TreeModel::Row deviceRow = *store->append(newGroup->children());
+                Gtk::TreeModel::Row deviceRow = *deviceStore->append(newGroup->children());
                 deviceRow[getCols().description] = descr;
                 deviceRow[getCols().thumbnail] = thumb;
                 deviceRow[getCols().device] = dev;
@@ -1209,7 +1390,7 @@ void InputDialogImpl::updateDeviceLinks(Glib::RefPtr<InputDevice const> device,
 
 
                 Gtk::TreeModel::iterator linkIter;
-                store->foreach_iter( sigc::bind<Glib::ustring, Gtk::TreeModel::iterator*>(
+                deviceStore->foreach_iter( sigc::bind<Glib::ustring, Gtk::TreeModel::iterator*>(
                                          sigc::ptr_fun(&InputDialogImpl::findDeviceByLink),
                                          device->getId(),
                                          &linkIter) );
@@ -1218,22 +1399,22 @@ void InputDialogImpl::updateDeviceLinks(Glib::RefPtr<InputDevice const> device,
                     descr = (*linkIter)[getCols().description];
                     thumb = (*linkIter)[getCols().thumbnail];
 
-                    deviceRow = *store->append(newGroup->children());
+                    deviceRow = *deviceStore->append(newGroup->children());
                     deviceRow[getCols().description] = descr;
                     deviceRow[getCols().thumbnail] = thumb;
                     deviceRow[getCols().device] = dev;
                     deviceRow[getCols().mode] = dev->getMode();
                     Gtk::TreeModel::iterator oldParent = linkIter->parent();
-                    store->erase(linkIter);
+                    deviceStore->erase(linkIter);
                     if ( oldParent->children().empty() ) {
-                        store->erase(oldParent);
+                        deviceStore->erase(oldParent);
                     }
                 }
 
                 Gtk::TreeModel::iterator oldParent = deviceIter->parent();
-                store->erase(deviceIter);
+                deviceStore->erase(deviceIter);
                 if ( oldParent->children().empty() ) {
-                    store->erase(oldParent);
+                    deviceStore->erase(oldParent);
                 }
                 tree->expand_row(Gtk::TreePath(newGroup), true);
             }
@@ -1242,7 +1423,7 @@ void InputDialogImpl::updateDeviceLinks(Glib::RefPtr<InputDevice const> device,
 }
 
 void InputDialogImpl::linkComboChanged() {
-    Glib::RefPtr<Gtk::TreeSelection> treeSel = tree.get_selection();
+    Glib::RefPtr<Gtk::TreeSelection> treeSel = deviceTree.get_selection();
     Gtk::TreeModel::iterator iter = treeSel->get_selected();
     if (iter) {
         Gtk::TreeModel::Row row = *iter;
@@ -1268,14 +1449,15 @@ void InputDialogImpl::linkComboChanged() {
 
 void InputDialogImpl::resyncToSelection() {
     bool clear = true;
-    Glib::RefPtr<Gtk::TreeSelection> treeSel = tree.get_selection();
+    Glib::RefPtr<Gtk::TreeSelection> treeSel = deviceTree.get_selection();
     Gtk::TreeModel::iterator iter = treeSel->get_selected();
     if (iter) {
         Gtk::TreeModel::Row row = *iter;
         Glib::ustring val = row[getCols().description];
         Glib::RefPtr<InputDevice const> dev = row[getCols().device];
+
         if ( dev ) {
-            devDetails.set_sensitive(true);
+            axisTable.set_sensitive(true);
 
             linkConnection.block();
             linkCombo.remove_all();
@@ -1300,21 +1482,60 @@ void InputDialogImpl::resyncToSelection() {
 
             clear = false;
             devName.set_label(row[getCols().description]);
-            detailFrame.set_label(row[getCols().description]);
+            axisFrame.set_label(row[getCols().description]);
             setupValueAndCombo( dev->getNumAxes(), dev->getNumAxes(), devAxesCount, axesCombo);
             setupValueAndCombo( dev->getNumKeys(), dev->getNumKeys(), devKeyCount, buttonCombo);
+
+
         }
     }
 
-    devDetails.set_sensitive(!clear);
+    axisTable.set_sensitive(!clear);
     if (clear) {
-        detailFrame.set_label("");
+        axisFrame.set_label("");
         devName.set_label("");
         devAxesCount.set_label("");
         devKeyCount.set_label("");
     }
 }
 
+void InputDialogImpl::ConfPanel::setAxis(gint count)
+{
+    /*
+     * TODO - Make each axis editable
+     */
+    axisStore->clear();
+
+    static Glib::ustring axesLabels[6] = {_("X"), _("Y"), _("Pressure"), _("X tilt"), _("Y tilt"), _("Wheel")};
+
+    for ( gint barNum = 0; barNum < static_cast<gint>(G_N_ELEMENTS(axesLabels)); barNum++ ) {
+
+            Gtk::TreeModel::Row row = *(axisStore->append());
+            row[axisColumns.name] = axesLabels[barNum];
+            if (barNum < count) {
+                row[axisColumns.value] = Glib::ustring::format(barNum+1);
+            } else {
+                row[axisColumns.value] = _("None");
+            }
+    }
+
+}
+void InputDialogImpl::ConfPanel::setKeys(gint count)
+{
+    /*
+     * TODO - Make each key assignable
+     */
+
+    keysStore->clear();
+
+    for (gint i = 0; i < count; i++) {
+        Gtk::TreeModel::Row row = *(keysStore->append());
+        row[keysColumns.name] = Glib::ustring::format(i+1);
+        row[keysColumns.value] = _("Disabled");
+    }
+
+
+}
 void InputDialogImpl::setupValueAndCombo( gint reported, gint actual, Gtk::Label& label, Gtk::ComboBoxText& combo )
 {
     gchar *tmp = g_strdup_printf("%d", reported);
@@ -1350,9 +1571,9 @@ void InputDialogImpl::updateTestButtons( Glib::ustring const& key, gint hotButto
 
 void InputDialogImpl::updateTestAxes( Glib::ustring const& key, GdkDevice* dev )
 {
-    static gdouble epsilon = 0.0001;
+    //static gdouble epsilon = 0.0001;
     {
-        Glib::RefPtr<Gtk::TreeSelection> treeSel = tree.get_selection();
+        Glib::RefPtr<Gtk::TreeSelection> treeSel = deviceTree.get_selection();
         Gtk::TreeModel::iterator iter = treeSel->get_selected();
         if (iter) {
             Gtk::TreeModel::Row row = *iter;
@@ -1364,7 +1585,6 @@ void InputDialogImpl::updateTestAxes( Glib::ustring const& key, GdkDevice* dev )
         }
     }
 
-
     for ( gint i = 0; i < static_cast<gint>(G_N_ELEMENTS(testAxes)); i++ ) {
         if ( axesMap[key].find(i) != axesMap[key].end() ) {
             switch ( axesMap[key][i].first ) {
@@ -1379,7 +1599,6 @@ void InputDialogImpl::updateTestAxes( Glib::ustring const& key, GdkDevice* dev )
                     testAxes[i].set(getPix(PIX_AXIS_OFF));
                     axesValues[i].set_sensitive(true);
                     if ( dev && (i < static_cast<gint>(G_N_ELEMENTS(axesValues)) ) ) {
-
                        // FIXME: Device axis ranges are inaccessible in GTK+ 3 and
 		       // are deprecated in GTK+ 2. Progress-bar ranges are disabled
 		       // until we find an alternative solution
diff --git a/src/ui/dialog/layer-properties.cpp b/src/ui/dialog/layer-properties.cpp
index 245dac5e0..6a1bc829e 100644
--- a/src/ui/dialog/layer-properties.cpp
+++ b/src/ui/dialog/layer-properties.cpp
@@ -42,18 +42,35 @@ LayerPropertiesDialog::LayerPropertiesDialog()
 {
     Gtk::Box *mainVBox = get_vbox();
 
+#if WITH_GTKMM_3_0
+    _layout_table.set_row_spacing(4);
+    _layout_table.set_column_spacing(4);
+#else
     _layout_table.set_spacings(4);
     _layout_table.resize (1, 2);
+#endif
 
     // Layer name widgets
     _layer_name_entry.set_activates_default(true);
     _layer_name_label.set_label(_("Layer name:"));
     _layer_name_label.set_alignment(1.0, 0.5);
 
+#if WITH_GTKMM_3_0
+    _layer_name_label.set_halign(Gtk::ALIGN_FILL);
+    _layer_name_label.set_valign(Gtk::ALIGN_FILL);
+    _layout_table.attach(_layer_name_label, 0, 0, 1, 1);
+    
+    _layer_name_entry.set_halign(Gtk::ALIGN_FILL);
+    _layer_name_entry.set_valign(Gtk::ALIGN_FILL);
+    _layer_name_entry.set_hexpand();
+    _layout_table.attach(_layer_name_entry, 1, 0, 1, 1);
+#else
     _layout_table.attach(_layer_name_label,
                          0, 1, 0, 1, Gtk::FILL, Gtk::FILL);
     _layout_table.attach(_layer_name_entry,
                          1, 2, 0, 1, Gtk::FILL | Gtk::EXPAND, Gtk::FILL);
+#endif
+
     mainVBox->pack_start(_layout_table, true, true, 4);
 
     // Buttons
@@ -149,7 +166,9 @@ LayerPropertiesDialog::_setup_position_controls() {
     _layer_position_combo.set_cell_data_func(_label_renderer,
                                              sigc::mem_fun(*this, &LayerPropertiesDialog::_prepareLabelRenderer));
 
+#if !WITH_GTKMM_3_0
     _layout_table.resize (2, 2);
+#endif
 
     Gtk::ListStore::iterator row;
     row = _dropdown_list->append();
@@ -163,12 +182,25 @@ LayerPropertiesDialog::_setup_position_controls() {
     row->set_value(_dropdown_columns.position, LPOS_CHILD);
     row->set_value(_dropdown_columns.name, Glib::ustring(_("As sublayer of current")));
 
-    _layout_table.attach(_layer_position_combo,
-                         1, 2, 1, 2, Gtk::FILL | Gtk::EXPAND, Gtk::FILL);
     _layer_position_label.set_label(_("Position:"));
     _layer_position_label.set_alignment(1.0, 0.5);
+    
+#if WITH_GTKMM_3_0
+    _layer_position_combo.set_halign(Gtk::ALIGN_FILL);
+    _layer_position_combo.set_valign(Gtk::ALIGN_FILL);
+    _layer_position_combo.set_hexpand();
+    _layout_table.attach(_layer_position_combo, 1, 1, 1, 1);
+
+    _layer_position_label.set_halign(Gtk::ALIGN_FILL);
+    _layer_position_label.set_valign(Gtk::ALIGN_FILL);
+    _layout_table.attach(_layer_position_label, 0, 1, 1, 1);
+#else
+    _layout_table.attach(_layer_position_combo,
+                         1, 2, 1, 2, Gtk::FILL | Gtk::EXPAND, Gtk::FILL);
     _layout_table.attach(_layer_position_label,
                          0, 1, 1, 2, Gtk::FILL, Gtk::FILL);
+#endif
+
     show_all_children();
 }
 
@@ -222,8 +254,17 @@ LayerPropertiesDialog::_setup_layers_controls() {
     _layout_table.remove(_layer_name_entry);
     _layout_table.remove(_layer_name_label);
 
+#if WITH_GTKMM_3_0
+    _scroller.set_halign(Gtk::ALIGN_FILL);
+    _scroller.set_valign(Gtk::ALIGN_FILL);
+    _scroller.set_hexpand();
+    _scroller.set_vexpand();
+    _layout_table.attach(_scroller, 0, 1, 2, 1);
+#else
     _layout_table.attach(_scroller,
                          0, 2, 1, 2, Gtk::FILL | Gtk::EXPAND, Gtk::FILL | Gtk::EXPAND);
+#endif
+
     show_all_children();
 }
 
diff --git a/src/ui/dialog/layer-properties.h b/src/ui/dialog/layer-properties.h
index 46b31ad35..9de303f89 100644
--- a/src/ui/dialog/layer-properties.h
+++ b/src/ui/dialog/layer-properties.h
@@ -12,10 +12,20 @@
 #ifndef INKSCAPE_DIALOG_LAYER_PROPERTIES_H
 #define INKSCAPE_DIALOG_LAYER_PROPERTIES_H
 
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
 #include <gtkmm/dialog.h>
 #include <gtkmm/entry.h>
 #include <gtkmm/label.h>
+
+#if WITH_GTKMM_3_0
+#include <gtkmm/grid.h>
+#else
 #include <gtkmm/table.h>
+#endif
+
 #include <gtkmm/combobox.h>
 #include <gtkmm/liststore.h>
 #include <gtkmm/treeview.h>
@@ -92,7 +102,13 @@ protected:
     Gtk::Entry        _layer_name_entry;
     Gtk::Label        _layer_position_label;
     Gtk::ComboBox     _layer_position_combo;
+
+#if WITH_GTKMM_3_0
+    Gtk::Grid         _layout_table;
+#else
     Gtk::Table        _layout_table;
+#endif
+
     bool              _position_visible;
 
     class ModelColumns : public Gtk::TreeModel::ColumnRecord
diff --git a/src/ui/dialog/ocaldialogs.cpp b/src/ui/dialog/ocaldialogs.cpp
index 174f361fd..c7bff185c 100644
--- a/src/ui/dialog/ocaldialogs.cpp
+++ b/src/ui/dialog/ocaldialogs.cpp
@@ -1112,8 +1112,14 @@ void ImportDialog::on_xml_file_read(const Glib::RefPtr<Gio::AsyncResult>& result
     xmlDoc *doc = NULL;
     xmlNode *root_element = NULL;
 
-    doc = xmlReadMemory(data, (int) length, xml_uri.c_str(), NULL,
-            XML_PARSE_RECOVER + XML_PARSE_NOWARNING + XML_PARSE_NOERROR);
+    int parse_options = XML_PARSE_RECOVER + XML_PARSE_NOWARNING + XML_PARSE_NOERROR;  // do not use XML_PARSE_NOENT ! see bug lp:1025185
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    bool allowNetAccess = prefs->getBool("/options/externalresources/xml/allow_net_access", false);
+    if (!allowNetAccess) {
+        parse_options |= XML_PARSE_NONET;
+    }
+
+    doc = xmlReadMemory(data, (int) length, xml_uri.c_str(), NULL, parse_options);
         
     if (doc == NULL) {
         // If nothing is returned, no results could be found