From: joncruz Date: Thu, 13 Mar 2008 07:55:00 +0000 (+0000) Subject: Adding new extended input devices dialog X-Git-Url: https://git.tokkee.org/?a=commitdiff_plain;h=b1fd0330076a954f02eb6a6a7879a90cb1886557;p=inkscape.git Adding new extended input devices dialog --- diff --git a/src/ui/dialog/Makefile_insert b/src/ui/dialog/Makefile_insert index f72838c7f..9d9bce605 100644 --- a/src/ui/dialog/Makefile_insert +++ b/src/ui/dialog/Makefile_insert @@ -38,6 +38,8 @@ ui_dialog_libuidialog_a_SOURCES = \ ui/dialog/find.h \ ui/dialog/inkscape-preferences.cpp \ ui/dialog/inkscape-preferences.h \ + ui/dialog/input.cpp \ + ui/dialog/input.h \ ui/dialog/layer-editor.cpp \ ui/dialog/layer-editor.h \ ui/dialog/livepatheffect-editor.cpp \ diff --git a/src/ui/dialog/dialog-manager.cpp b/src/ui/dialog/dialog-manager.cpp index 17215ac00..15ebcef5a 100644 --- a/src/ui/dialog/dialog-manager.cpp +++ b/src/ui/dialog/dialog-manager.cpp @@ -27,6 +27,7 @@ #include "ui/dialog/filter-effects-dialog.h" #include "ui/dialog/find.h" #include "ui/dialog/inkscape-preferences.h" +#include "ui/dialog/input.h" #include "ui/dialog/layer-editor.h" #include "ui/dialog/livepatheffect-editor.h" #include "ui/dialog/memory.h" @@ -112,6 +113,8 @@ DialogManager::DialogManager() { registerFactory("UndoHistory", &create); registerFactory("XmlEditor", &create); + registerFactory("InputDevices", &create); + } else { registerFactory("AlignAndDistribute", &create); @@ -138,6 +141,8 @@ DialogManager::DialogManager() { registerFactory("UndoHistory", &create); registerFactory("XmlEditor", &create); + registerFactory("InputDevices", &create); + } } diff --git a/src/ui/dialog/input.cpp b/src/ui/dialog/input.cpp new file mode 100644 index 000000000..71eb16ccb --- /dev/null +++ b/src/ui/dialog/input.cpp @@ -0,0 +1,801 @@ + + +/* XPM */ +static char *eraser[] = { +/* columns rows colors chars-per-pixel */ +"16 16 5 1", +" c black", +". c green", +"X c #808080", +"o c gray100", +"O c None", +/* pixels */ +"OOOOOOOOOOOOOOOO", +"OOOOOOOOOOOOO OO", +"OOOOOOOOOOOO . O", +"OOOOOOOOOOO . OO", +"OOOOOOOOOO . OOO", +"OOOOOOOOO . OOOO", +"OOOOOOOO . OOOOO", +"OOOOOOOXo OOOOOO", +"OOOOOOXoXOOOOOOO", +"OOOOOXoXOOOOOOOO", +"OOOOXoXOOOOOOOOO", +"OOOXoXOOOOOOOOOO", +"OOXoXOOOOOOOOOOO", +"OOXXOOOOOOOOOOOO", +"OOOOOOOOOOOOOOOO", +"OOOOOOOOOOOOOOOO" +}; + +/* XPM */ +static char *mouse[] = { +/* columns rows colors chars-per-pixel */ +"16 16 3 1", +" c black", +". c gray100", +"X c None", +/* pixels */ +"XXXXXXXXXXXXXXXX", +"XXXXXXXXXXXXXXXX", +"XXXXXXXXXXXXXXXX", +"XXXXXXXXXXXXXXXX", +"XXXXXXX XXXXXXX", +"XXXXX . XXXXXXX", +"XXXX .... XXXXXX", +"XXXX .... XXXXXX", +"XXXXX .... XXXXX", +"XXXXX .... XXXXX", +"XXXXXX .... XXXX", +"XXXXXX .... XXXX", +"XXXXXXX . XXXXX", +"XXXXXXX XXXXXXX", +"XXXXXXXXXXXXXXXX", +"XXXXXXXXXXXXXXXX" +}; + +/* XPM */ +static char *pen[] = { +/* columns rows colors chars-per-pixel */ +"16 16 3 1", +" c black", +". c gray100", +"X c None", +/* pixels */ +"XXXXXXXXXXXXXXXX", +"XXXXXXXXXXXXX XX", +"XXXXXXXXXXXX . X", +"XXXXXXXXXXX . XX", +"XXXXXXXXXX . XXX", +"XXXXXXXXX . XXXX", +"XXXXXXXX . XXXXX", +"XXXXXXX . XXXXXX", +"XXXXXX . XXXXXXX", +"XXXXX . XXXXXXXX", +"XXXX . XXXXXXXXX", +"XXX . XXXXXXXXXX", +"XX . XXXXXXXXXXX", +"XX XXXXXXXXXXXX", +"XXXXXXXXXXXXXXXX", +"XXXXXXXXXXXXXXXX" +}; + +/* XPM */ +static char *sidebuttons[] = { +/* columns rows colors chars-per-pixel */ +"16 16 4 1", +" c black", +". c #808080", +"o c green", +"O c None", +/* pixels */ +"OOOOOOOOOOOOOOOO", +"OOOOOOOOOOOOOOOO", +"O..............O", +"O.OOOOOOOOOOOO.O", +"O OOOOOOOO O", +"O o OOOOOOOO o O", +"O o OOOOOOOO o O", +"O OOOOOOOO O", +"O.OOOOOOOOOOOO.O", +"O.OOOOOOOOOOOO.O", +"O.OOOOOOOOOOOO.O", +"O.OOOOOOOOOOOO.O", +"O.OOOOOOOOOOOO.O", +"O..............O", +"OOOOOOOOOOOOOOOO", +"OOOOOOOOOOOOOOOO" +}; + +/* XPM */ +static char *tablet[] = { +/* columns rows colors chars-per-pixel */ +"16 16 3 1", +" c black", +". c gray100", +"X c None", +/* pixels */ +"XXXXXXXXXXXXXXXX", +"XXXXXXXXXXXXXXXX", +"X X", +"X ............ X", +"X ............ X", +"X ............ X", +"X ............ X", +"X ............ X", +"X ............ X", +"X ............ X", +"X ............ X", +"X ............ X", +"X ............ X", +"X X", +"XXXXXXXXXXXXXXXX", +"XXXXXXXXXXXXXXXX" +}; + +/* XPM */ +static char *tip[] = { +/* columns rows colors chars-per-pixel */ +"16 16 5 1", +" c black", +". c green", +"X c #808080", +"o c gray100", +"O c None", +/* pixels */ +"OOOOOOOOOOOOOOOO", +"OOOOOOOOOOOOOXOO", +"OOOOOOOOOOOOXoXO", +"OOOOOOOOOOOXoXOO", +"OOOOOOOOOOXoXOOO", +"OOOOOOOOOXoXOOOO", +"OOOOOOOOXoXOOOOO", +"OOOOOOO oXOOOOOO", +"OOOOOO . OOOOOOO", +"OOOOO . OOOOOOOO", +"OOOO . OOOOOOOOO", +"OOO . OOOOOOOOOO", +"OO . OOOOOOOOOOO", +"OO OOOOOOOOOOOO", +"OOOOOOOOOOOOOOOO", +"OOOOOOOOOOOOOOOO" +}; + + + + + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ui/widget/panel.h" + +#include "input.h" + +namespace Inkscape { +namespace UI { +namespace Dialog { + +static void createFakeList(); +GdkDevice fakeout[5]; +static GList* fakeList = 0; + + + +class MyModelColumns : public Gtk::TreeModel::ColumnRecord +{ +public: + Gtk::TreeModelColumn filename; + Gtk::TreeModelColumn description; + Gtk::TreeModelColumn< Glib::RefPtr > thumbnail; + Gtk::TreeModelColumn device; + + MyModelColumns() { add(filename); add(description); add(thumbnail); add(device); } +}; + +class InputDialogImpl : public InputDialog { +public: + InputDialogImpl(); + virtual ~InputDialogImpl() {} + +private: + Glib::RefPtr penPix; + Glib::RefPtr mousePix; + Glib::RefPtr tipPix; + Glib::RefPtr tabletPix; + Glib::RefPtr eraserPix; + Glib::RefPtr sidebuttonsPix; + + std::map > buttonMap; + + GdkInputSource lastSourceSeen; + Glib::ustring lastDevnameSeen; + + MyModelColumns cols; + Glib::RefPtr store; + Gtk::TreeView tree; + Gtk::Frame frame2; + Gtk::Frame testFrame; + Gtk::ScrolledWindow treeScroller; + Gtk::ScrolledWindow detailScroller; + Gtk::HPaned splitter; + Gtk::VPaned split2; + Gtk::Label devName; + Gtk::Label devKeyCount; + Gtk::Label devAxesCount; + Gtk::ComboBoxText axesCombo; + Gtk::ComboBoxText buttonCombo; + Gtk::ComboBoxText modeCombo; + Gtk::Label keyVal; + Gtk::Entry keyEntry; + Gtk::Table devDetails; + Gtk::HPaned confSplitter; + Gtk::Notebook topHolder; + Gtk::Image testThumb; + Gtk::EventBox testDetector; + + void setupValueAndCombo( gint reported, gint actual, Gtk::Label& label, Gtk::ComboBoxText& combo ); + bool eventSnoop(GdkEvent* event); + void foo(); +}; + + +// Now that we've defined the *Impl class, we can do the method to aquire one. +InputDialog &InputDialog::getInstance() +{ + InputDialog *dialog = new InputDialogImpl(); + return *dialog; +} + + +InputDialogImpl::InputDialogImpl() : + InputDialog(), + + penPix(Gdk::Pixbuf::create_from_xpm_data(pen)), + mousePix(Gdk::Pixbuf::create_from_xpm_data(mouse)), + tipPix(Gdk::Pixbuf::create_from_xpm_data(tip)), + tabletPix(Gdk::Pixbuf::create_from_xpm_data(tablet)), + eraserPix(Gdk::Pixbuf::create_from_xpm_data(eraser)), + sidebuttonsPix(Gdk::Pixbuf::create_from_xpm_data(sidebuttons)), + + lastSourceSeen((GdkInputSource)-1), + lastDevnameSeen(""), + cols(), + store(Gtk::TreeStore::create(cols)), + tree(store), + frame2(), + testFrame("Test Area"), + treeScroller(), + detailScroller(), + splitter(), + split2(), + modeCombo(), + devDetails(6, 2), + confSplitter(), + topHolder() +{ + Gtk::Box *contents = _getContents(); + + + treeScroller.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); + treeScroller.add(tree); + split2.pack1(testFrame); + split2.pack2(frame2); + splitter.pack1(treeScroller); + splitter.pack2(split2); + + testDetector.add(testThumb); + testFrame.add(testDetector); + testThumb.set(tabletPix); + testThumb.set_padding(24, 24); + + topHolder.append_page(confSplitter, "Configuration"); + topHolder.append_page(splitter, "Hardware"); +// confSplitter.show_all(); +// splitter.show_all(); + topHolder.show_all(); + topHolder.set_current_page(1); + + contents->pack_start(topHolder); + + int rowNum = 0; + + Gtk::Label* lbl = Gtk::manage(new Gtk::Label("Name:")); + devDetails.attach(*lbl, 0, 1, rowNum, rowNum+ 1, + ::Gtk::FILL, + ::Gtk::SHRINK); + devDetails.attach(devName, 1, 2, rowNum, rowNum + 1, + ::Gtk::SHRINK, + ::Gtk::SHRINK); + + rowNum++; + + lbl = Gtk::manage(new Gtk::Label("Mode:")); + devDetails.attach(*lbl, 0, 1, rowNum, rowNum+ 1, + ::Gtk::FILL, + ::Gtk::SHRINK); + + modeCombo.append_text("Disabled"); + modeCombo.append_text("Screen"); + modeCombo.append_text("Window"); + modeCombo.set_active_text("Disabled"); + modeCombo.set_sensitive(false); + + devDetails.attach(modeCombo, 1, 2, rowNum, rowNum + 1, + ::Gtk::FILL, + ::Gtk::SHRINK); + rowNum++; + + lbl = Gtk::manage(new Gtk::Label("Reported axes count:")); + devDetails.attach(*lbl, 0, 1, rowNum, rowNum+ 1, + ::Gtk::FILL, + ::Gtk::SHRINK); + devDetails.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, + ::Gtk::FILL, + ::Gtk::SHRINK); + devDetails.attach(axesCombo, 1, 2, rowNum, rowNum + 1, + ::Gtk::SHRINK, + ::Gtk::SHRINK); + + rowNum++; + + lbl = Gtk::manage(new Gtk::Label("Reported button count:")); + devDetails.attach(*lbl, 0, 1, rowNum, rowNum+ 1, + ::Gtk::FILL, + ::Gtk::SHRINK); + devDetails.attach(devKeyCount, 1, 2, rowNum, rowNum + 1, + ::Gtk::SHRINK, + ::Gtk::SHRINK); + + rowNum++; + + lbl = Gtk::manage(new Gtk::Label("Actual button count:")); + devDetails.attach(*lbl, 0, 1, rowNum, rowNum+ 1, + ::Gtk::FILL, + ::Gtk::SHRINK); + devDetails.attach(buttonCombo, 1, 2, rowNum, rowNum + 1, + ::Gtk::SHRINK, + ::Gtk::SHRINK); + + rowNum++; + + devDetails.attach(keyVal, 0, 2, rowNum, rowNum + 1, + ::Gtk::FILL, + ::Gtk::SHRINK); + rowNum++; + + + testDetector.signal_event().connect(sigc::mem_fun(*this, &InputDialogImpl::eventSnoop)); + +// void gdk_input_set_extension_events (GdkWindow *window, +// gint mask, +// GdkExtensionMode mode); + + gtk_widget_set_extension_events( GTK_WIDGET(testDetector.gobj()), GDK_EXTENSION_EVENTS_ALL ); + 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, + ::Gtk::FILL, + ::Gtk::SHRINK); + rowNum++; + + + devDetails.set_sensitive(false); + detailScroller.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); + detailScroller.add(devDetails); + frame2.add(detailScroller); + +//- 16x16/devices +// gnome-dev-mouse-optical +// input-mouse +// input-tablet +// mouse + + + + Gtk::TreeModel::Row row; + Gtk::TreeModel::Row childrow; + Gtk::TreeModel::Row deviceRow; + + + //Add the TreeView's view columns: + tree.append_column("I", cols.thumbnail); + tree.append_column("Bar", cols.description); + + tree.set_enable_tree_lines(); + tree.set_headers_visible(false); + tree.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &InputDialogImpl::foo)); + + + GList* devList = gdk_devices_list(); + if ( !fakeList ) { + createFakeList(); + } + devList = fakeList; + if ( devList ) { + g_message("Found some"); + + { + GdkModifierType defaultModMask = static_cast(gtk_accelerator_get_default_mod_mask()); + gchar* name = gtk_accelerator_name(GDK_a, defaultModMask); + gchar* label = gtk_accelerator_get_label(GDK_a, defaultModMask); + g_message("Name: [%s] label:[%s]", name, label); + g_free(name); + g_free(label); + } + + row = *(store->append()); + row[cols.description] = "Hardware"; + + childrow = *(store->append(row.children())); + childrow[cols.description] = "Tablet"; + childrow[cols.thumbnail] = tabletPix; + + for ( GList* curr = devList; curr; curr = g_list_next(curr) ) { + GdkDevice* dev = reinterpret_cast(curr->data); + if ( dev ) { + g_message("device: name[%s] source[0x%x] mode[0x%x] cursor[%s] axis count[%d] key count[%d]", dev->name, dev->source, dev->mode, + dev->has_cursor?"Yes":"no", dev->num_axes, dev->num_keys); + + if ( dev->source != GDK_SOURCE_MOUSE ) { + deviceRow = *(store->append(childrow.children())); + deviceRow[cols.description] = dev->name; + deviceRow[cols.device] = dev; + switch ( dev->source ) { + case GDK_SOURCE_PEN: + if (deviceRow[cols.description] == "pad") { + deviceRow[cols.thumbnail] = sidebuttonsPix; + } else { + deviceRow[cols.thumbnail] = tipPix; + } + break; + case GDK_SOURCE_CURSOR: + deviceRow[cols.thumbnail] = mousePix; + break; + case GDK_SOURCE_ERASER: + deviceRow[cols.thumbnail] = eraserPix; + break; + default: + ; // nothing + } + } + } else { + g_warning("Null device in list"); + } + } + } else { + g_message("NO DEVICES FOUND"); + } + + + tree.expand_all(); + show_all_children(); +} + +void InputDialogImpl::foo() { + bool clear = true; + Glib::RefPtr treeSel = tree.get_selection(); + Gtk::TreeModel::iterator iter = treeSel->get_selected(); + if (iter) { + Gtk::TreeModel::Row row = *iter; + Glib::ustring val = row[cols.description]; + GdkDevice* dev = row[cols.device]; + if ( dev ) { + devDetails.set_sensitive(true); + modeCombo.set_sensitive(true); + switch( dev->mode ) { + case GDK_MODE_DISABLED: + modeCombo.set_active(0); + break; + case GDK_MODE_SCREEN: + modeCombo.set_active(1); + break; + case GDK_MODE_WINDOW: + modeCombo.set_active(2); + break; + default: + ; + } + clear = false; + devName.set_label(row[cols.description]); + setupValueAndCombo( dev->num_axes, dev->num_axes, devAxesCount, axesCombo); + setupValueAndCombo( dev->num_keys, dev->num_keys, devKeyCount, buttonCombo); + } + } + + devDetails.set_sensitive(!clear); + if (clear) { + devName.set_label(""); + devAxesCount.set_label(""); + devKeyCount.set_label(""); + } +} + +void InputDialogImpl::setupValueAndCombo( gint reported, gint actual, Gtk::Label& label, Gtk::ComboBoxText& combo ) +{ + gchar *tmp = g_strdup_printf("%d", reported); + label.set_label(tmp); + g_free(tmp); + + combo.clear_items(); + for ( gint i = 1; i <= reported; ++i ) { + tmp = g_strdup_printf("%d", i); + combo.append_text(tmp); + g_free(tmp); + } + + if ( (1 <= actual) && (actual <= reported) ) { + combo.set_active(actual - 1); + } +} + +bool InputDialogImpl::eventSnoop(GdkEvent* event) +{ + int modmod = 0; + + GdkInputSource source = lastSourceSeen; + Glib::ustring devName = lastDevnameSeen; + + switch ( event->type ) { + case GDK_KEY_PRESS: + case GDK_KEY_RELEASE: + { + GdkEventKey* keyEvt = reinterpret_cast(event); + gchar* name = gtk_accelerator_name(keyEvt->keyval, static_cast(keyEvt->state)); + keyVal.set_label(name); + g_message("%d KEY state:0x%08x 0x%04x [%s]", keyEvt->type, keyEvt->state, keyEvt->keyval, name); + g_free(name); + } + break; + case GDK_BUTTON_PRESS: + modmod = 1; + // fallthrough + case GDK_BUTTON_RELEASE: + { + GdkEventButton* btnEvt = reinterpret_cast(event); + Glib::ustring key; + if ( btnEvt->device ) { + source = btnEvt->device->source; + devName = btnEvt->device->name; + switch ( btnEvt->device->source ) { + case GDK_SOURCE_MOUSE: + key = "M:"; + break; + case GDK_SOURCE_CURSOR: + key = "C:"; + break; + case GDK_SOURCE_PEN: + key = "P:"; + break; + case GDK_SOURCE_ERASER: + key = "E:"; + break; + default: + key = "?:"; + } + key += devName; + + if ( buttonMap[key].find(btnEvt->button) == buttonMap[key].end() ) { + g_message("New button found for %s = %d", key.c_str(), btnEvt->button); + buttonMap[key].insert(btnEvt->button); + } + } + gchar* name = gtk_accelerator_name(0, static_cast(btnEvt->state)); + keyVal.set_label(name); + g_message("%d BTN state:0x%08x %c %4d [%s] dev:%p [%s] ", + btnEvt->type, btnEvt->state, + (modmod ? '+':'-'), + btnEvt->button, name, btnEvt->device, + (btnEvt->device ? btnEvt->device->name : "null") + + ); + g_free(name); + } + break; + case GDK_MOTION_NOTIFY: + { + GdkEventMotion* btnMtn = reinterpret_cast(event); + if ( btnMtn->device ) { + source = btnMtn->device->source; + devName = btnMtn->device->name; + } + gchar* name = gtk_accelerator_name(0, static_cast(btnMtn->state)); + keyVal.set_label(name); + g_message("%d MOV state:0x%08x [%s] dev:%p [%s] %3.2f %3.2f %3.2f %3.2f %3.2f %3.2f", btnMtn->type, btnMtn->state, + name, btnMtn->device, + (btnMtn->device ? btnMtn->device->name : "null"), + ((btnMtn->device && btnMtn->axes && (btnMtn->device->num_axes > 0)) ? btnMtn->axes[0]:0), + ((btnMtn->device && btnMtn->axes && (btnMtn->device->num_axes > 1)) ? btnMtn->axes[1]:0), + ((btnMtn->device && btnMtn->axes && (btnMtn->device->num_axes > 2)) ? btnMtn->axes[2]:0), + ((btnMtn->device && btnMtn->axes && (btnMtn->device->num_axes > 3)) ? btnMtn->axes[3]:0), + ((btnMtn->device && btnMtn->axes && (btnMtn->device->num_axes > 4)) ? btnMtn->axes[4]:0), + ((btnMtn->device && btnMtn->axes && (btnMtn->device->num_axes > 5)) ? btnMtn->axes[5]:0) + ); + g_free(name); + } + break; + default: + ;// nothing + } + + + if ( (lastSourceSeen != source) || (lastDevnameSeen != devName) ) { + g_message("FLIPPIES %d => %d", lastSourceSeen, source); + switch (source) { + case GDK_SOURCE_MOUSE: + { + testThumb.set(mousePix); + } + break; + case GDK_SOURCE_CURSOR: + { + g_message("flip to cursor"); + testThumb.set(mousePix); + } + break; + case GDK_SOURCE_PEN: + { + if (devName == "pad") { + g_message("flip to pad"); + testThumb.set(sidebuttonsPix); + } else { + g_message("flip to pen"); + testThumb.set(tipPix); + } + } + break; + case GDK_SOURCE_ERASER: + { + g_message("flip to eraser"); + testThumb.set(eraserPix); + } + break; + default: + g_message("gurgle"); + } + lastSourceSeen = source; + lastDevnameSeen = devName; + } + + return false; +} + + + + + +GdkDeviceAxis padAxes[] = {{GDK_AXIS_X, 0.0, 0.0}, + {GDK_AXIS_Y, 0.0, 0.0}, + {GDK_AXIS_PRESSURE, 0.0, 1.0}, + {GDK_AXIS_XTILT, -1.0, 1.0}, + {GDK_AXIS_YTILT, -1.0, 1.0}, + {GDK_AXIS_WHEEL, 0.0, 1.0}}; +GdkDeviceKey padKeys[] = {{0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, + {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}}; + +GdkDeviceAxis eraserAxes[] = {{GDK_AXIS_X, 0.0, 0.0}, + {GDK_AXIS_Y, 0.0, 0.0}, + {GDK_AXIS_PRESSURE, 0.0, 1.0}, + {GDK_AXIS_XTILT, -1.0, 1.0}, + {GDK_AXIS_YTILT, -1.0, 1.0}, + {GDK_AXIS_WHEEL, 0.0, 1.0}}; +GdkDeviceKey eraserKeys[] = {{0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, + {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}}; + +GdkDeviceAxis cursorAxes[] = {{GDK_AXIS_X, 0.0, 0.0}, + {GDK_AXIS_Y, 0.0, 0.0}, + {GDK_AXIS_PRESSURE, 0.0, 1.0}, + {GDK_AXIS_XTILT, -1.0, 1.0}, + {GDK_AXIS_YTILT, -1.0, 1.0}, + {GDK_AXIS_WHEEL, 0.0, 1.0}}; +GdkDeviceKey cursorKeys[] = {{0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, + {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}}; + +GdkDeviceAxis stylusAxes[] = {{GDK_AXIS_X, 0.0, 0.0}, + {GDK_AXIS_Y, 0.0, 0.0}, + {GDK_AXIS_PRESSURE, 0.0, 1.0}, + {GDK_AXIS_XTILT, -1.0, 1.0}, + {GDK_AXIS_YTILT, -1.0, 1.0}, + {GDK_AXIS_WHEEL, 0.0, 1.0}}; +GdkDeviceKey stylusKeys[] = {{0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, + {0, (GdkModifierType)0}, {0, (GdkModifierType)0}, {0, (GdkModifierType)0}}; + + +GdkDeviceAxis coreAxes[] = {{GDK_AXIS_X, 0.0, 0.0}, + {GDK_AXIS_Y, 0.0, 0.0}}; + + +static void createFakeList() { + if ( !fakeList ) { + fakeout[0].name = "pad"; + fakeout[0].source = GDK_SOURCE_PEN; + fakeout[0].mode = GDK_MODE_SCREEN; + fakeout[0].has_cursor = TRUE; + fakeout[0].num_axes = 6; + fakeout[0].axes = padAxes; + fakeout[0].num_keys = 8; + fakeout[0].keys = padKeys; + + fakeout[1].name = "eraser"; + fakeout[1].source = GDK_SOURCE_ERASER; + fakeout[1].mode = GDK_MODE_SCREEN; + fakeout[1].has_cursor = TRUE; + fakeout[1].num_axes = 6; + fakeout[1].axes = eraserAxes; + fakeout[1].num_keys = 7; + fakeout[1].keys = eraserKeys; + + fakeout[2].name = "cursor"; + fakeout[2].source = GDK_SOURCE_CURSOR; + fakeout[2].mode = GDK_MODE_SCREEN; + fakeout[2].has_cursor = TRUE; + fakeout[2].num_axes = 6; + fakeout[2].axes = cursorAxes; + fakeout[2].num_keys = 7; + fakeout[2].keys = cursorKeys; + + fakeout[3].name = "stylus"; + fakeout[3].source = GDK_SOURCE_PEN; + fakeout[3].mode = GDK_MODE_SCREEN; + fakeout[3].has_cursor = TRUE; + fakeout[3].num_axes = 6; + fakeout[3].axes = stylusAxes; + fakeout[3].num_keys = 7; + fakeout[3].keys = stylusKeys; + + fakeout[4].name = "Core Pointer"; + fakeout[4].source = GDK_SOURCE_MOUSE; + fakeout[4].mode = GDK_MODE_SCREEN; + fakeout[4].has_cursor = TRUE; + fakeout[4].num_axes = 2; + fakeout[4].axes = coreAxes; + fakeout[4].num_keys = 0; + fakeout[4].keys = NULL; + + for ( guint pos = 0; pos < G_N_ELEMENTS(fakeout); pos++) { + fakeList = g_list_append(fakeList, &(fakeout[pos])); + } + } +} + + + +} // end namespace Inkscape +} // end namespace UI +} // end namespace Dialog + + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 : diff --git a/src/ui/dialog/input.h b/src/ui/dialog/input.h new file mode 100644 index 000000000..3404424da --- /dev/null +++ b/src/ui/dialog/input.h @@ -0,0 +1,38 @@ + +#ifndef INKSCAPE_UI_DIALOG_INPUT_H +#define INKSCAPE_UI_DIALOG_INPUT_H + + +#include "verbs.h" +#include "ui/widget/panel.h" + +namespace Inkscape { +namespace UI { +namespace Dialog { + + +class InputDialog : public UI::Widget::Panel +{ +public: + static InputDialog &getInstance(); + + InputDialog() : UI::Widget::Panel("", "dialogs.inputdevices", SP_VERB_DIALOG_INPUT) {} + virtual ~InputDialog() {} +}; + +} // namespace Dialog +} // namesapce UI +} // namespace Inkscape + +#endif // INKSCAPE_UI_DIALOG_INPUT_H + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 : diff --git a/src/verbs.cpp b/src/verbs.cpp index f4428a2ac..7baf6de07 100644 --- a/src/verbs.cpp +++ b/src/verbs.cpp @@ -47,7 +47,9 @@ #include "dialogs/extensions.h" #include "dialogs/swatches.h" #include "dialogs/layers-panel.h" +#ifndef USE_NEW_INPUT_DEVICES #include "dialogs/input.h" +#endif #ifdef WITH_INKBOARD #include "jabber_whiteboard/session-manager.h" @@ -1743,7 +1745,11 @@ DialogVerb::perform(SPAction *action, void *data, void */*pdata*/) } #endif case SP_VERB_DIALOG_INPUT: +#ifdef USE_NEW_INPUT_DEVICES + dt->_dlg_mgr->showDialog("InputDevices"); +#else sp_input_dialog(); +#endif break; case SP_VERB_DIALOG_EXTENSIONEDITOR: dt->_dlg_mgr->showDialog("ExtensionEditor");