merge from trunk (r11952)

(bzr r11668.1.46)

1 files changed, 341 insertions, 122 deletions

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