Skip to content

Instantly share code, notes, and snippets.

@Ryochan7

Ryochan7/gist:b18694066703769ace60

Created October 8, 2014 18:59
Show Gist options
  • Save Ryochan7/b18694066703769ace60 to your computer and use it in GitHub Desktop.
Save Ryochan7/b18694066703769ace60 to your computer and use it in GitHub Desktop.
Download ZIP
libxkbcommon testing
Raw
gistfile1.diff
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 98808fd..af75d90 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -504,6 +504,8 @@ if(UNIX)
else()
list(APPEND LIBS ${SDL_LIBRARIES})
endif(USE_SDL_2)
+
+ list(APPEND LIBS xkbcommon)
elseif (WIN32)
if(USE_SDL_2)
# Perform extra voodoo to get proper library paths and include
diff --git a/src/eventhandlers/uinputeventhandler.cpp b/src/eventhandlers/uinputeventhandler.cpp
index 44c23d4..e81be9a 100644
--- a/src/eventhandlers/uinputeventhandler.cpp
+++ b/src/eventhandlers/uinputeventhandler.cpp
@@ -3,13 +3,14 @@
#include <linux/input.h>
#include <linux/uinput.h>
-//#include <QDebug>
+#include <QDebug>
#include <QTextStream>
#include <QStringList>
#include <QStringListIterator>
#include <QFileInfo>
#include <QTimer>
+#include <uinputhelper.h>
#ifdef WITH_X11
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
@@ -207,7 +208,12 @@ void UInputEventHandler::sendKeyboardEvent(JoyButtonSlot *slot, bool pressed)
if (device == JoyButtonSlot::JoyKeyboard)
{
- write_uinput_event(keyboardFileHandler, EV_KEY, code, pressed ? 1 : 0);
+ unsigned int alias = UInputHelper::getInstance()->getInputKey(code);
+ //unsigned int alias = KEY_W;
+ if (alias)
+ {
+ write_uinput_event(keyboardFileHandler, EV_KEY, alias, pressed ? 1 : 0);
+ }
}
}
diff --git a/src/qtuinputkeymapper.cpp b/src/qtuinputkeymapper.cpp
index 20218f1..341ef1f 100644
--- a/src/qtuinputkeymapper.cpp
+++ b/src/qtuinputkeymapper.cpp
@@ -1,7 +1,11 @@
+//#include <QDebug>
+
#include <linux/input.h>
#include <linux/uinput.h>
-//#include <QDebug>
+#include <xkbcommon/xkbcommon.h>
+#include <xkbcommon/xkbcommon-keysyms.h>
+#include <xkbcommon/xkbcommon-names.h>
#include "qtuinputkeymapper.h"
@@ -14,91 +18,117 @@ QtUInputKeyMapper::QtUInputKeyMapper(QObject *parent) :
void QtUInputKeyMapper::populateAlphaHashes()
{
// Map lowercase alpha keys
- qtKeyToVirtualKey[Qt::Key_A] = KEY_A;
- qtKeyToVirtualKey[Qt::Key_B] = KEY_B;
- qtKeyToVirtualKey[Qt::Key_C] = KEY_C;
- qtKeyToVirtualKey[Qt::Key_D] = KEY_D;
- qtKeyToVirtualKey[Qt::Key_E] = KEY_E;
- qtKeyToVirtualKey[Qt::Key_F] = KEY_F;
- qtKeyToVirtualKey[Qt::Key_G] = KEY_G;
- qtKeyToVirtualKey[Qt::Key_H] = KEY_H;
- qtKeyToVirtualKey[Qt::Key_I] = KEY_I;
- qtKeyToVirtualKey[Qt::Key_J] = KEY_J;
- qtKeyToVirtualKey[Qt::Key_K] = KEY_K;
- qtKeyToVirtualKey[Qt::Key_L] = KEY_L;
- qtKeyToVirtualKey[Qt::Key_M] = KEY_M;
- qtKeyToVirtualKey[Qt::Key_N] = KEY_N;
- qtKeyToVirtualKey[Qt::Key_O] = KEY_O;
- qtKeyToVirtualKey[Qt::Key_P] = KEY_P;
- qtKeyToVirtualKey[Qt::Key_Q] = KEY_Q;
- qtKeyToVirtualKey[Qt::Key_R] = KEY_R;
- qtKeyToVirtualKey[Qt::Key_S] = KEY_S;
- qtKeyToVirtualKey[Qt::Key_T] = KEY_T;
- qtKeyToVirtualKey[Qt::Key_U] = KEY_U;
- qtKeyToVirtualKey[Qt::Key_V] = KEY_V;
- qtKeyToVirtualKey[Qt::Key_W] = KEY_W;
- qtKeyToVirtualKey[Qt::Key_X] = KEY_X;
- qtKeyToVirtualKey[Qt::Key_Y] = KEY_Y;
- qtKeyToVirtualKey[Qt::Key_Z] = KEY_Z;
+ qtKeyToVirtualKey[Qt::Key_A] = XKB_KEY_a;
+ qtKeyToVirtualKey[Qt::Key_B] = XKB_KEY_b;
+ qtKeyToVirtualKey[Qt::Key_C] = XKB_KEY_c;
+ qtKeyToVirtualKey[Qt::Key_D] = XKB_KEY_d;
+ qtKeyToVirtualKey[Qt::Key_E] = XKB_KEY_e;
+ qtKeyToVirtualKey[Qt::Key_F] = XKB_KEY_f;
+ qtKeyToVirtualKey[Qt::Key_G] = XKB_KEY_g;
+ qtKeyToVirtualKey[Qt::Key_H] = XKB_KEY_h;
+ qtKeyToVirtualKey[Qt::Key_I] = XKB_KEY_i;
+ qtKeyToVirtualKey[Qt::Key_J] = XKB_KEY_j;
+ qtKeyToVirtualKey[Qt::Key_K] = XKB_KEY_k;
+ qtKeyToVirtualKey[Qt::Key_L] = XKB_KEY_l;
+ qtKeyToVirtualKey[Qt::Key_M] = XKB_KEY_m;
+ qtKeyToVirtualKey[Qt::Key_N] = XKB_KEY_n;
+ qtKeyToVirtualKey[Qt::Key_O] = XKB_KEY_o;
+ qtKeyToVirtualKey[Qt::Key_P] = XKB_KEY_p;
+ qtKeyToVirtualKey[Qt::Key_Q] = XKB_KEY_q;
+ qtKeyToVirtualKey[Qt::Key_R] = XKB_KEY_r;
+ qtKeyToVirtualKey[Qt::Key_S] = XKB_KEY_s;
+ qtKeyToVirtualKey[Qt::Key_T] = XKB_KEY_t;
+ qtKeyToVirtualKey[Qt::Key_U] = XKB_KEY_u;
+ qtKeyToVirtualKey[Qt::Key_V] = XKB_KEY_v;
+ qtKeyToVirtualKey[Qt::Key_W] = XKB_KEY_w;
+ qtKeyToVirtualKey[Qt::Key_X] = XKB_KEY_x;
+ qtKeyToVirtualKey[Qt::Key_Y] = XKB_KEY_y;
+ qtKeyToVirtualKey[Qt::Key_Z] = XKB_KEY_z;
}
void QtUInputKeyMapper::populateFKeyHashes()
{
// Map F1 - F10
- for (int i=0; i <= (KEY_F10 - KEY_F1); i++)
+ for (int i=0; i <= (XKB_KEY_F11 - XKB_KEY_F1); i++)
{
qtKeyToVirtualKey[Qt::Key_F1 + i] = KEY_F1 + i;
}
+ qtKeyToVirtualKey[Qt::Key_F12] = XKB_KEY_F12;
+ qtKeyToVirtualKey[Qt::Key_F13] = XKB_KEY_F13;
+ qtKeyToVirtualKey[Qt::Key_F14] = XKB_KEY_F14;
+ qtKeyToVirtualKey[Qt::Key_F15] = XKB_KEY_F15;
+ qtKeyToVirtualKey[Qt::Key_F16] = XKB_KEY_F16;
+ qtKeyToVirtualKey[Qt::Key_F17] = XKB_KEY_F17;
+ qtKeyToVirtualKey[Qt::Key_F18] = XKB_KEY_F18;
+ qtKeyToVirtualKey[Qt::Key_F19] = XKB_KEY_F19;
+ qtKeyToVirtualKey[Qt::Key_F20] = XKB_KEY_F20;
+ qtKeyToVirtualKey[Qt::Key_F21] = XKB_KEY_F21;
+ qtKeyToVirtualKey[Qt::Key_F22] = XKB_KEY_F22;
+ qtKeyToVirtualKey[Qt::Key_F23] = XKB_KEY_F23;
+ qtKeyToVirtualKey[Qt::Key_F24] = XKB_KEY_F24;
+
// Map F11 and F12
- for (int i=0; i <= (KEY_F12 - KEY_F11); i++)
+ /*for (int i=0; i <= (KEY_F12 - KEY_F11); i++)
{
qtKeyToVirtualKey[Qt::Key_F11 + i] = KEY_F11 + i;
}
+ */
// Map F13 - F24
- for (int i=0; i <= (KEY_F24 - KEY_F13); i++)
+ /*for (int i=0; i <= (KEY_F24 - KEY_F13); i++)
{
qtKeyToVirtualKey[Qt::Key_F13 + i] = KEY_F13 + i;
}
+ */
+
+
}
void QtUInputKeyMapper::populateNumPadHashes()
{
+ for (int i=0; i <= (XKB_KEY_KP_9 - XKB_KEY_KP_0); i++)
+ {
+ qtKeyToVirtualKey[AntKey_KP_0 + i] = XKB_KEY_KP_0 + i;
+ }
+
// Map Numpad 0
- qtKeyToVirtualKey[AntKey_KP_0] = KEY_KP0;
+ //qtKeyToVirtualKey[AntKey_KP_0] = KEY_KP0;
// Map Numpad 1 - 3
- for (int i=0; i <= (KEY_KP3 - KEY_KP1); i++)
+ /*for (int i=0; i <= (KEY_KP3 - KEY_KP1); i++)
{
qtKeyToVirtualKey[AntKey_KP_1 + i] = KEY_KP1 + i;
}
+ */
// Map Numpad 4 - 6
- for (int i=0; i <= (KEY_KP6 - KEY_KP4); i++)
+ /*for (int i=0; i <= (KEY_KP6 - KEY_KP4); i++)
{
qtKeyToVirtualKey[AntKey_KP_4 + i] = KEY_KP4 + i;
}
+ */
// Map Numpad 7 - 9
- for (int i=0; i <= (KEY_KP9 - KEY_KP7); i++)
+ /*for (int i=0; i <= (KEY_KP9 - KEY_KP7); i++)
{
qtKeyToVirtualKey[AntKey_KP_7 + i] = KEY_KP7 + i;
}
+ */
}
void QtUInputKeyMapper::populateSpecialCharHashes()
{
- qtKeyToVirtualKey[Qt::Key_QuoteLeft] = KEY_GRAVE;
- qtKeyToVirtualKey[Qt::Key_Minus] = KEY_MINUS;
- qtKeyToVirtualKey[Qt::Key_Equal] = KEY_EQUAL;
- qtKeyToVirtualKey[Qt::Key_BracketLeft] = KEY_LEFTBRACE;
- qtKeyToVirtualKey[Qt::Key_BracketRight] = KEY_RIGHTBRACE;
- qtKeyToVirtualKey[Qt::Key_Semicolon] = KEY_SEMICOLON;
- qtKeyToVirtualKey[Qt::Key_Apostrophe] = KEY_APOSTROPHE;
- qtKeyToVirtualKey[Qt::Key_Comma] = KEY_COMMA;
- qtKeyToVirtualKey[Qt::Key_Period] = KEY_DOT;
- qtKeyToVirtualKey[Qt::Key_Slash] = KEY_SLASH;
+ qtKeyToVirtualKey[Qt::Key_QuoteLeft] = XKB_KEY_quoteleft;
+ qtKeyToVirtualKey[Qt::Key_Minus] = XKB_KEY_minus;
+ qtKeyToVirtualKey[Qt::Key_Equal] = XKB_KEY_equal;
+ qtKeyToVirtualKey[Qt::Key_BracketLeft] = XKB_KEY_bracketleft;
+ qtKeyToVirtualKey[Qt::Key_BracketRight] = XKB_KEY_bracketright;
+ qtKeyToVirtualKey[Qt::Key_Semicolon] = XKB_KEY_semicolon;
+ qtKeyToVirtualKey[Qt::Key_Apostrophe] = XKB_KEY_apostrophe;
+ qtKeyToVirtualKey[Qt::Key_Comma] = XKB_KEY_comma;
+ qtKeyToVirtualKey[Qt::Key_Period] = XKB_KEY_period;
+ qtKeyToVirtualKey[Qt::Key_Slash] = XKB_KEY_slash;
}
void QtUInputKeyMapper::populateMappingHashes()
@@ -106,58 +136,57 @@ void QtUInputKeyMapper::populateMappingHashes()
if (qtKeyToVirtualKey.isEmpty())
{
// misc keys
- qtKeyToVirtualKey[Qt::Key_Escape] = KEY_ESC;
- qtKeyToVirtualKey[Qt::Key_Tab] = KEY_TAB;
- qtKeyToVirtualKey[Qt::Key_Backspace] = KEY_BACKSPACE;
- qtKeyToVirtualKey[Qt::Key_Return] = KEY_ENTER;
- qtKeyToVirtualKey[Qt::Key_Insert] = KEY_INSERT;
- qtKeyToVirtualKey[Qt::Key_Delete] = KEY_DELETE;
- qtKeyToVirtualKey[Qt::Key_Pause] = KEY_PAUSE;
- qtKeyToVirtualKey[Qt::Key_Print] = KEY_PRINT;
- qtKeyToVirtualKey[Qt::Key_Space] = KEY_SPACE;
+ qtKeyToVirtualKey[Qt::Key_Escape] = XKB_KEY_Escape;
+ qtKeyToVirtualKey[Qt::Key_Tab] = XKB_KEY_Tab;
+ qtKeyToVirtualKey[Qt::Key_Backspace] = XKB_KEY_BackSpace;
+ qtKeyToVirtualKey[Qt::Key_Return] = XKB_KEY_Return;
+ qtKeyToVirtualKey[Qt::Key_Insert] = XKB_KEY_Insert;
+ qtKeyToVirtualKey[Qt::Key_Delete] = XKB_KEY_Delete;
+ qtKeyToVirtualKey[Qt::Key_Pause] = XKB_KEY_Pause;
+ qtKeyToVirtualKey[Qt::Key_Print] = XKB_KEY_Print;
+ qtKeyToVirtualKey[Qt::Key_Space] = XKB_KEY_space;
// cursor movement
- qtKeyToVirtualKey[Qt::Key_Home] = KEY_HOME;
- qtKeyToVirtualKey[Qt::Key_End] = KEY_END;
- qtKeyToVirtualKey[Qt::Key_Left] = KEY_LEFT;
- qtKeyToVirtualKey[Qt::Key_Up] = KEY_UP;
- qtKeyToVirtualKey[Qt::Key_Right] = KEY_RIGHT;
- qtKeyToVirtualKey[Qt::Key_Down] = KEY_DOWN;
- qtKeyToVirtualKey[Qt::Key_PageUp] = KEY_PAGEUP;
- qtKeyToVirtualKey[Qt::Key_PageDown] = KEY_PAGEDOWN;
+ qtKeyToVirtualKey[Qt::Key_Home] = XKB_KEY_Home;
+ qtKeyToVirtualKey[Qt::Key_End] = XKB_KEY_End;
+ qtKeyToVirtualKey[Qt::Key_Left] = XKB_KEY_Left;
+ qtKeyToVirtualKey[Qt::Key_Up] = XKB_KEY_Up;
+ qtKeyToVirtualKey[Qt::Key_Right] = XKB_KEY_Right;
+ qtKeyToVirtualKey[Qt::Key_Down] = XKB_KEY_Down;
+ qtKeyToVirtualKey[Qt::Key_PageUp] = XKB_KEY_Page_Up;
+ qtKeyToVirtualKey[Qt::Key_PageDown] = XKB_KEY_Page_Down;
// modifiers
- qtKeyToVirtualKey[Qt::Key_Shift] = KEY_LEFTSHIFT;
- qtKeyToVirtualKey[Qt::Key_Control] = KEY_LEFTCTRL;
- qtKeyToVirtualKey[Qt::Key_Alt] = KEY_LEFTALT;
-
- qtKeyToVirtualKey[Qt::Key_CapsLock] = KEY_CAPSLOCK;
- qtKeyToVirtualKey[Qt::Key_NumLock] = KEY_NUMLOCK;
- qtKeyToVirtualKey[Qt::Key_ScrollLock] = KEY_SCROLLLOCK;
- qtKeyToVirtualKey[Qt::Key_Meta] = KEY_LEFTMETA;
- qtKeyToVirtualKey[AntKey_Meta_R] = KEY_RIGHTMETA;
- qtKeyToVirtualKey[Qt::Key_Menu] = KEY_COMPOSE;
- qtKeyToVirtualKey[Qt::Key_Help] = KEY_HELP;
+ qtKeyToVirtualKey[Qt::Key_Shift] = XKB_KEY_Shift_L;
+ qtKeyToVirtualKey[Qt::Key_Control] = XKB_KEY_Control_L;
+ qtKeyToVirtualKey[Qt::Key_Alt] = XKB_KEY_Alt_L;
+
+ qtKeyToVirtualKey[Qt::Key_CapsLock] = XKB_KEY_Caps_Lock;
+ qtKeyToVirtualKey[Qt::Key_NumLock] = XKB_KEY_Num_Lock;
+ qtKeyToVirtualKey[Qt::Key_ScrollLock] = XKB_KEY_Scroll_Lock;
+ qtKeyToVirtualKey[Qt::Key_Meta] = XKB_KEY_Meta_L;
+ qtKeyToVirtualKey[AntKey_Meta_R] = XKB_KEY_Meta_R;
+ qtKeyToVirtualKey[Qt::Key_Menu] = XKB_KEY_Menu;
+ qtKeyToVirtualKey[Qt::Key_Help] = XKB_KEY_Help;
// media keys
- qtKeyToVirtualKey[Qt::Key_VolumeDown] = KEY_VOLUMEDOWN;
- qtKeyToVirtualKey[Qt::Key_VolumeMute] = KEY_MUTE;
- qtKeyToVirtualKey[Qt::Key_VolumeUp] = KEY_VOLUMEUP;
- qtKeyToVirtualKey[Qt::Key_MediaPlay] = KEY_PLAYPAUSE;
- qtKeyToVirtualKey[Qt::Key_MediaStop] = KEY_STOPCD;
- qtKeyToVirtualKey[Qt::Key_MediaPrevious] = KEY_PREVIOUSSONG;
- qtKeyToVirtualKey[Qt::Key_MediaNext] = KEY_NEXTSONG;
- qtKeyToVirtualKey[Qt::Key_MediaRecord] = KEY_RECORD;
+ qtKeyToVirtualKey[Qt::Key_VolumeDown] = XKB_KEY_XF86AudioLowerVolume;
+ qtKeyToVirtualKey[Qt::Key_VolumeMute] = XKB_KEY_XF86AudioMute;
+ qtKeyToVirtualKey[Qt::Key_VolumeUp] = XKB_KEY_XF86AudioRaiseVolume;
+ qtKeyToVirtualKey[Qt::Key_MediaPlay] = XKB_KEY_XF86AudioPlay;
+ qtKeyToVirtualKey[Qt::Key_MediaStop] = XKB_KEY_XF86AudioStop;
+ qtKeyToVirtualKey[Qt::Key_MediaPrevious] = XKB_KEY_XF86AudioPrev;
+ qtKeyToVirtualKey[Qt::Key_MediaNext] = XKB_KEY_XF86AudioNext;
+ qtKeyToVirtualKey[Qt::Key_MediaRecord] = XKB_KEY_XF86AudioRecord;
// Map 0-9 keys
- for (unsigned int i=0; i <= (KEY_9 - KEY_1); i++)
+ for (unsigned int i=0; i <= (XKB_KEY_9 - XKB_KEY_0); i++)
{
- qtKeyToVirtualKey[Qt::Key_1 + i] = KEY_1 + i;
+ qtKeyToVirtualKey[Qt::Key_0 + i] = XKB_KEY_0 + i;
}
- qtKeyToVirtualKey[Qt::Key_0] = KEY_0;
// launch keys
- qtKeyToVirtualKey[Qt::Key_LaunchMail] = KEY_MAIL;
+ qtKeyToVirtualKey[Qt::Key_LaunchMail] = XKB_KEY_XF86Mail;
/*qtKeyToVirtualKey[Qt::Key_Launch0] = XF86XK_MyComputer;
qtKeyToVirtualKey[Qt::Key_Launch1] = XF86XK_Calculator;
qtKeyToVirtualKey[Qt::Key_Standby] = XF86XK_Standby;
@@ -183,28 +212,28 @@ void QtUInputKeyMapper::populateMappingHashes()
populateNumPadHashes();
// Map custom defined keys
- qtKeyToVirtualKey[AntKey_Shift_R] = KEY_RIGHTSHIFT;
- qtKeyToVirtualKey[AntKey_Control_R] = KEY_RIGHTCTRL;
- qtKeyToVirtualKey[AntKey_Alt_R] = KEY_RIGHTALT;
- qtKeyToVirtualKey[AntKey_KP_Multiply] = KEY_KPASTERISK;
+ qtKeyToVirtualKey[AntKey_Shift_R] = XKB_KEY_Shift_R;
+ qtKeyToVirtualKey[AntKey_Control_R] = XKB_KEY_Control_R;
+ qtKeyToVirtualKey[AntKey_Alt_R] = XKB_KEY_Alt_R;
+ qtKeyToVirtualKey[AntKey_KP_Multiply] = XKB_KEY_multiply;
// numeric and function keypad keys
- qtKeyToVirtualKey[Qt::Key_Enter] = KEY_KPENTER;
- qtKeyToVirtualKey[AntKey_KP_Home] = KEY_KP7;
- qtKeyToVirtualKey[AntKey_KP_Left] = KEY_KP4;
- qtKeyToVirtualKey[AntKey_KP_Up] = KEY_KP8;
- qtKeyToVirtualKey[AntKey_KP_Right] = KEY_KP6;
- qtKeyToVirtualKey[AntKey_KP_Down] = KEY_KP2;
- qtKeyToVirtualKey[AntKey_KP_Prior] = KEY_KP9;
- qtKeyToVirtualKey[AntKey_KP_Next] = KEY_KP3;
- qtKeyToVirtualKey[AntKey_KP_End] = KEY_KP1;
-
- qtKeyToVirtualKey[AntKey_KP_Begin] = KEY_KP5;
- qtKeyToVirtualKey[AntKey_KP_Insert] = KEY_KP0;
- qtKeyToVirtualKey[AntKey_KP_Add] = KEY_KPPLUS;
- qtKeyToVirtualKey[AntKey_KP_Subtract] = KEY_KPMINUS;
- qtKeyToVirtualKey[AntKey_KP_Decimal] = KEY_KPDOT;
- qtKeyToVirtualKey[AntKey_KP_Divide] = KEY_KPSLASH;
+ qtKeyToVirtualKey[Qt::Key_Enter] = XKB_KEY_KP_Enter;
+ qtKeyToVirtualKey[AntKey_KP_Home] = XKB_KEY_KP_Home;
+ qtKeyToVirtualKey[AntKey_KP_Left] = XKB_KEY_KP_Left;
+ qtKeyToVirtualKey[AntKey_KP_Up] = XKB_KEY_KP_Up;
+ qtKeyToVirtualKey[AntKey_KP_Right] = XKB_KEY_KP_Right;
+ qtKeyToVirtualKey[AntKey_KP_Down] = XKB_KEY_KP_Down;
+ qtKeyToVirtualKey[AntKey_KP_Prior] = XKB_KEY_KP_Page_Up;
+ qtKeyToVirtualKey[AntKey_KP_Next] = XKB_KEY_KP_Page_Down;
+ qtKeyToVirtualKey[AntKey_KP_End] = XKB_KEY_KP_End;
+
+ qtKeyToVirtualKey[AntKey_KP_Begin] = XKB_KEY_KP_Begin;
+ qtKeyToVirtualKey[AntKey_KP_Insert] = XKB_KEY_KP_Insert;
+ qtKeyToVirtualKey[AntKey_KP_Add] = XKB_KEY_KP_Add;
+ qtKeyToVirtualKey[AntKey_KP_Subtract] = XKB_KEY_KP_Subtract;
+ qtKeyToVirtualKey[AntKey_KP_Decimal] = XKB_KEY_KP_Decimal;
+ qtKeyToVirtualKey[AntKey_KP_Divide] = XKB_KEY_KP_Divide;
/*
// International input method support keys
@@ -358,7 +387,7 @@ void QtUInputKeyMapper::populateMappingHashes()
}
// Override some entries.
- virtualKeyToQtKey[KEY_KP0] = AntKey_KP_0;
+ /*virtualKeyToQtKey[KEY_KP0] = AntKey_KP_0;
virtualKeyToQtKey[KEY_KP1] = AntKey_KP_1;
virtualKeyToQtKey[KEY_KP2] = AntKey_KP_2;
virtualKeyToQtKey[KEY_KP3] = AntKey_KP_3;
@@ -368,5 +397,6 @@ void QtUInputKeyMapper::populateMappingHashes()
virtualKeyToQtKey[KEY_KP7] = AntKey_KP_7;
virtualKeyToQtKey[KEY_KP8] = AntKey_KP_8;
virtualKeyToQtKey[KEY_KP9] = AntKey_KP_9;
+ */
}
}
diff --git a/src/qtuinputkeymapper.h b/src/qtuinputkeymapper.h
index 1905764..ebe857a 100644
--- a/src/qtuinputkeymapper.h
+++ b/src/qtuinputkeymapper.h
@@ -19,6 +19,11 @@ protected:
void populateFKeyHashes();
void populateNumPadHashes();
void populateSpecialCharHashes();
+ void initializeXKBCommon();
+
+ struct xkb_context *ctx;
+ struct xkb_keymap *keymap;
+ struct xkb_state *state;
signals:
diff --git a/src/uinputhelper.cpp b/src/uinputhelper.cpp
index b53dcc8..5854395 100644
--- a/src/uinputhelper.cpp
+++ b/src/uinputhelper.cpp
@@ -1,20 +1,29 @@
#include <linux/input.h>
#include <linux/uinput.h>
#include <QCoreApplication>
+#include <QDebug>
#include "uinputhelper.h"
+static int evkey_offset = 8;
+
UInputHelper* UInputHelper::_instance = 0;
UInputHelper::UInputHelper(QObject *parent) :
QObject(parent)
{
+ initializeXKBCommon();
populateKnownAliases();
+ populateXKBMapping();
connect(qApp, SIGNAL(aboutToQuit()), this, SLOT(deleteLater()));
}
UInputHelper::~UInputHelper()
{
+ xkb_state_unref(state);
+ xkb_keymap_unref(keymap);
+ xkb_context_unref(ctx);
+
_instance = 0;
}
@@ -22,237 +31,239 @@ void UInputHelper::populateKnownAliases()
{
if (knownAliasesX11SymVK.isEmpty())
{
- knownAliasesX11SymVK.insert("a", KEY_A);
- knownAliasesX11SymVK.insert("b", KEY_B);
- knownAliasesX11SymVK.insert("c", KEY_C);
- knownAliasesX11SymVK.insert("d", KEY_D);
- knownAliasesX11SymVK.insert("e", KEY_E);
- knownAliasesX11SymVK.insert("f", KEY_F);
- knownAliasesX11SymVK.insert("g", KEY_G);
- knownAliasesX11SymVK.insert("h", KEY_H);
- knownAliasesX11SymVK.insert("i", KEY_I);
- knownAliasesX11SymVK.insert("j", KEY_J);
- knownAliasesX11SymVK.insert("k", KEY_K);
- knownAliasesX11SymVK.insert("l", KEY_L);
- knownAliasesX11SymVK.insert("m", KEY_M);
- knownAliasesX11SymVK.insert("n", KEY_N);
- knownAliasesX11SymVK.insert("o", KEY_O);
- knownAliasesX11SymVK.insert("p", KEY_P);
- knownAliasesX11SymVK.insert("q", KEY_Q);
- knownAliasesX11SymVK.insert("r", KEY_R);
- knownAliasesX11SymVK.insert("s", KEY_S);
- knownAliasesX11SymVK.insert("t", KEY_T);
- knownAliasesX11SymVK.insert("u", KEY_U);
- knownAliasesX11SymVK.insert("v", KEY_V);
- knownAliasesX11SymVK.insert("w", KEY_W);
- knownAliasesX11SymVK.insert("x", KEY_X);
- knownAliasesX11SymVK.insert("y", KEY_Y);
- knownAliasesX11SymVK.insert("z", KEY_Z);
-
- knownAliasesX11SymVK.insert("Escape", KEY_ESC);
- knownAliasesX11SymVK.insert("F1", KEY_F1);
- knownAliasesX11SymVK.insert("F2", KEY_F2);
- knownAliasesX11SymVK.insert("F3", KEY_F3);
- knownAliasesX11SymVK.insert("F4", KEY_F4);
- knownAliasesX11SymVK.insert("F5", KEY_F5);
- knownAliasesX11SymVK.insert("F6", KEY_F6);
- knownAliasesX11SymVK.insert("F7", KEY_F7);
- knownAliasesX11SymVK.insert("F8", KEY_F8);
- knownAliasesX11SymVK.insert("F9", KEY_F9);
- knownAliasesX11SymVK.insert("F10", KEY_F10);
- knownAliasesX11SymVK.insert("F11", KEY_F11);
- knownAliasesX11SymVK.insert("F12", KEY_F12);
-
- knownAliasesX11SymVK.insert("grave", KEY_GRAVE);
- knownAliasesX11SymVK.insert("1", KEY_1);
- knownAliasesX11SymVK.insert("2", KEY_2);
- knownAliasesX11SymVK.insert("3", KEY_3);
- knownAliasesX11SymVK.insert("4", KEY_4);
- knownAliasesX11SymVK.insert("5", KEY_5);
- knownAliasesX11SymVK.insert("6", KEY_6);
- knownAliasesX11SymVK.insert("7", KEY_7);
- knownAliasesX11SymVK.insert("8", KEY_8);
- knownAliasesX11SymVK.insert("9", KEY_9);
- knownAliasesX11SymVK.insert("0", KEY_0);
- knownAliasesX11SymVK.insert("minus", KEY_MINUS);
- knownAliasesX11SymVK.insert("equal", KEY_EQUAL);
- knownAliasesX11SymVK.insert("BackSpace", KEY_BACKSPACE);
- knownAliasesX11SymVK.insert("Tab", KEY_TAB);
- knownAliasesX11SymVK.insert("bracketleft", KEY_LEFTBRACE);
- knownAliasesX11SymVK.insert("bracketright", KEY_RIGHTBRACE);
- knownAliasesX11SymVK.insert("backslash", KEY_BACKSLASH);
- knownAliasesX11SymVK.insert("Caps_Lock", KEY_CAPSLOCK);
- knownAliasesX11SymVK.insert("semicolon", KEY_SEMICOLON);
- knownAliasesX11SymVK.insert("apostrophe", KEY_APOSTROPHE);
- knownAliasesX11SymVK.insert("Return", KEY_ENTER);
- knownAliasesX11SymVK.insert("Shift_L", KEY_LEFTSHIFT);
- knownAliasesX11SymVK.insert("comma", KEY_COMMA);
- knownAliasesX11SymVK.insert("period", KEY_DOT);
- knownAliasesX11SymVK.insert("slash", KEY_SLASH);
- knownAliasesX11SymVK.insert("Control_L", KEY_LEFTCTRL);
- knownAliasesX11SymVK.insert("Super_L", KEY_MENU);
- knownAliasesX11SymVK.insert("Alt_L", KEY_LEFTALT);
- knownAliasesX11SymVK.insert("space", KEY_SPACE);
- knownAliasesX11SymVK.insert("Alt_R", KEY_RIGHTALT);
- knownAliasesX11SymVK.insert("Menu", KEY_COMPOSE);
- knownAliasesX11SymVK.insert("Control_R", KEY_RIGHTCTRL);
- knownAliasesX11SymVK.insert("Shift_R", KEY_RIGHTSHIFT);
-
- knownAliasesX11SymVK.insert("Up", KEY_UP);
- knownAliasesX11SymVK.insert("Left", KEY_LEFT);
- knownAliasesX11SymVK.insert("Down", KEY_DOWN);
- knownAliasesX11SymVK.insert("Right", KEY_RIGHT);
- knownAliasesX11SymVK.insert("Print", KEY_PRINT);
- knownAliasesX11SymVK.insert("Insert", KEY_INSERT);
- knownAliasesX11SymVK.insert("Delete", KEY_DELETE);
- knownAliasesX11SymVK.insert("Home", KEY_HOME);
- knownAliasesX11SymVK.insert("End", KEY_END);
- knownAliasesX11SymVK.insert("Prior", KEY_PAGEUP);
- knownAliasesX11SymVK.insert("Next", KEY_PAGEDOWN);
-
- knownAliasesX11SymVK.insert("Num_Lock", KEY_NUMLOCK);
- knownAliasesX11SymVK.insert("KP_Divide", KEY_KPSLASH);
- knownAliasesX11SymVK.insert("KP_Multiply", KEY_KPASTERISK);
- knownAliasesX11SymVK.insert("KP_Subtract", KEY_KPMINUS);
- knownAliasesX11SymVK.insert("KP_Add", KEY_KPPLUS);
- knownAliasesX11SymVK.insert("KP_Enter", KEY_KPENTER);
-
- knownAliasesX11SymVK.insert("KP_1", KEY_KP1);
- knownAliasesX11SymVK.insert("KP_2", KEY_KP2);
- knownAliasesX11SymVK.insert("KP_3", KEY_KP3);
- knownAliasesX11SymVK.insert("KP_4", KEY_KP4);
- knownAliasesX11SymVK.insert("KP_5", KEY_KP5);
- knownAliasesX11SymVK.insert("KP_6", KEY_KP6);
- knownAliasesX11SymVK.insert("KP_7", KEY_KP7);
- knownAliasesX11SymVK.insert("KP_8", KEY_KP8);
- knownAliasesX11SymVK.insert("KP_9", KEY_KP9);
- knownAliasesX11SymVK.insert("KP_0", KEY_KP0);
- knownAliasesX11SymVK.insert("KP_Decimal", KEY_KPDOT);
-
- knownAliasesX11SymVK.insert("Scroll_Lock", KEY_SCROLLLOCK);
- knownAliasesX11SymVK.insert("Pause", KEY_PAUSE);
+ knownAliasesX11SymVK.insert("a", XKB_KEY_a);
+ knownAliasesX11SymVK.insert("b", XKB_KEY_b);
+ knownAliasesX11SymVK.insert("c", XKB_KEY_c);
+ knownAliasesX11SymVK.insert("d", XKB_KEY_d);
+ knownAliasesX11SymVK.insert("e", XKB_KEY_e);
+ knownAliasesX11SymVK.insert("f", XKB_KEY_f);
+ knownAliasesX11SymVK.insert("g", XKB_KEY_g);
+ knownAliasesX11SymVK.insert("h", XKB_KEY_h);
+ knownAliasesX11SymVK.insert("i", XKB_KEY_i);
+ knownAliasesX11SymVK.insert("j", XKB_KEY_j);
+ knownAliasesX11SymVK.insert("k", XKB_KEY_k);
+ knownAliasesX11SymVK.insert("l", XKB_KEY_l);
+ knownAliasesX11SymVK.insert("m", XKB_KEY_m);
+ knownAliasesX11SymVK.insert("n", XKB_KEY_n);
+ knownAliasesX11SymVK.insert("o", XKB_KEY_o);
+ knownAliasesX11SymVK.insert("p", XKB_KEY_p);
+ knownAliasesX11SymVK.insert("q", XKB_KEY_q);
+ knownAliasesX11SymVK.insert("r", XKB_KEY_r);
+ knownAliasesX11SymVK.insert("s", XKB_KEY_s);
+ knownAliasesX11SymVK.insert("t", XKB_KEY_t);
+ knownAliasesX11SymVK.insert("u", XKB_KEY_u);
+ knownAliasesX11SymVK.insert("v", XKB_KEY_v);
+ knownAliasesX11SymVK.insert("w", XKB_KEY_w);
+ knownAliasesX11SymVK.insert("x", XKB_KEY_x);
+ knownAliasesX11SymVK.insert("y", XKB_KEY_y);
+ knownAliasesX11SymVK.insert("z", XKB_KEY_z);
+
+ knownAliasesX11SymVK.insert("Escape", XKB_KEY_Escape);
+ knownAliasesX11SymVK.insert("F1", XKB_KEY_F1);
+ knownAliasesX11SymVK.insert("F2", XKB_KEY_F2);
+ knownAliasesX11SymVK.insert("F3", XKB_KEY_F3);
+ knownAliasesX11SymVK.insert("F4", XKB_KEY_F4);
+ knownAliasesX11SymVK.insert("F5", XKB_KEY_F5);
+ knownAliasesX11SymVK.insert("F6", XKB_KEY_F6);
+ knownAliasesX11SymVK.insert("F7", XKB_KEY_F7);
+ knownAliasesX11SymVK.insert("F8", XKB_KEY_F8);
+ knownAliasesX11SymVK.insert("F9", XKB_KEY_F9);
+ knownAliasesX11SymVK.insert("F10", XKB_KEY_F10);
+ knownAliasesX11SymVK.insert("F11", XKB_KEY_F11);
+ knownAliasesX11SymVK.insert("F12", XKB_KEY_F12);
+
+ knownAliasesX11SymVK.insert("grave", XKB_KEY_grave);
+ knownAliasesX11SymVK.insert("1", XKB_KEY_1);
+ knownAliasesX11SymVK.insert("2", XKB_KEY_2);
+ knownAliasesX11SymVK.insert("3", XKB_KEY_3);
+ knownAliasesX11SymVK.insert("4", XKB_KEY_4);
+ knownAliasesX11SymVK.insert("5", XKB_KEY_5);
+ knownAliasesX11SymVK.insert("6", XKB_KEY_6);
+ knownAliasesX11SymVK.insert("7", XKB_KEY_7);
+ knownAliasesX11SymVK.insert("8", XKB_KEY_8);
+ knownAliasesX11SymVK.insert("9", XKB_KEY_9);
+ knownAliasesX11SymVK.insert("0", XKB_KEY_0);
+ knownAliasesX11SymVK.insert("minus", XKB_KEY_minus);
+ knownAliasesX11SymVK.insert("equal", XKB_KEY_equal);
+ knownAliasesX11SymVK.insert("BackSpace", XKB_KEY_BackSpace);
+ knownAliasesX11SymVK.insert("Tab", XKB_KEY_Tab);
+ knownAliasesX11SymVK.insert("bracketleft", XKB_KEY_braceleft);
+ knownAliasesX11SymVK.insert("bracketright", XKB_KEY_braceright);
+ knownAliasesX11SymVK.insert("backslash", XKB_KEY_backslash);
+ knownAliasesX11SymVK.insert("Caps_Lock", XKB_KEY_Caps_Lock);
+ knownAliasesX11SymVK.insert("semicolon", XKB_KEY_semicolon);
+ knownAliasesX11SymVK.insert("apostrophe", XKB_KEY_apostrophe);
+ knownAliasesX11SymVK.insert("Return", XKB_KEY_Return);
+ knownAliasesX11SymVK.insert("Shift_L", XKB_KEY_Shift_L);
+ knownAliasesX11SymVK.insert("comma", XKB_KEY_comma);
+ knownAliasesX11SymVK.insert("period", XKB_KEY_period);
+ knownAliasesX11SymVK.insert("slash", XKB_KEY_slash);
+ knownAliasesX11SymVK.insert("Control_L", XKB_KEY_Control_L);
+ knownAliasesX11SymVK.insert("Super_L", XKB_KEY_Super_L);
+ knownAliasesX11SymVK.insert("Alt_L", XKB_KEY_Alt_L);
+ knownAliasesX11SymVK.insert("space", XKB_KEY_space);
+ knownAliasesX11SymVK.insert("Alt_R", XKB_KEY_Alt_R);
+ knownAliasesX11SymVK.insert("Menu", XKB_KEY_Meta_R);
+ knownAliasesX11SymVK.insert("Control_R", XKB_KEY_Control_R);
+ knownAliasesX11SymVK.insert("Shift_R", XKB_KEY_Shift_R);
+
+ knownAliasesX11SymVK.insert("Up", XKB_KEY_uparrow);
+ knownAliasesX11SymVK.insert("Left", XKB_KEY_leftarrow);
+ knownAliasesX11SymVK.insert("Down", XKB_KEY_downarrow);
+ knownAliasesX11SymVK.insert("Right", XKB_KEY_rightarrow);
+ knownAliasesX11SymVK.insert("Print", XKB_KEY_Print);
+ knownAliasesX11SymVK.insert("Insert", XKB_KEY_Insert);
+ knownAliasesX11SymVK.insert("Delete", XKB_KEY_Delete);
+ knownAliasesX11SymVK.insert("Home", XKB_KEY_Home);
+ knownAliasesX11SymVK.insert("End", XKB_KEY_End);
+ knownAliasesX11SymVK.insert("Prior", XKB_KEY_Page_Up);
+ knownAliasesX11SymVK.insert("Next", XKB_KEY_Page_Down);
+
+ knownAliasesX11SymVK.insert("Num_Lock", XKB_KEY_Num_Lock);
+ knownAliasesX11SymVK.insert("KP_Divide", XKB_KEY_KP_Divide);
+ knownAliasesX11SymVK.insert("KP_Multiply", XKB_KEY_KP_Multiply);
+ knownAliasesX11SymVK.insert("KP_Subtract", XKB_KEY_KP_Subtract);
+ knownAliasesX11SymVK.insert("KP_Add", XKB_KEY_KP_Add);
+ knownAliasesX11SymVK.insert("KP_Enter", XKB_KEY_KP_Enter);
+
+ knownAliasesX11SymVK.insert("KP_1", XKB_KEY_KP_1);
+ knownAliasesX11SymVK.insert("KP_2", XKB_KEY_KP_2);
+ knownAliasesX11SymVK.insert("KP_3", XKB_KEY_KP_3);
+ knownAliasesX11SymVK.insert("KP_4", XKB_KEY_KP_4);
+ knownAliasesX11SymVK.insert("KP_5", XKB_KEY_KP_5);
+ knownAliasesX11SymVK.insert("KP_6", XKB_KEY_KP_6);
+ knownAliasesX11SymVK.insert("KP_7", XKB_KEY_KP_7);
+ knownAliasesX11SymVK.insert("KP_8", XKB_KEY_KP_8);
+ knownAliasesX11SymVK.insert("KP_9", XKB_KEY_KP_9);
+ knownAliasesX11SymVK.insert("KP_0", XKB_KEY_KP_0);
+ knownAliasesX11SymVK.insert("KP_Decimal", XKB_KEY_KP_Decimal);
+
+ knownAliasesX11SymVK.insert("Scroll_Lock", XKB_KEY_Scroll_Lock);
+ knownAliasesX11SymVK.insert("Pause", XKB_KEY_Pause);
}
if (knownAliasesVKStrings.isEmpty())
{
- knownAliasesVKStrings.insert(KEY_A, tr("a"));
- knownAliasesVKStrings.insert(KEY_B, tr("b"));
- knownAliasesVKStrings.insert(KEY_C, tr("c"));
- knownAliasesVKStrings.insert(KEY_D, tr("d"));
- knownAliasesVKStrings.insert(KEY_E, tr("e"));
- knownAliasesVKStrings.insert(KEY_F, tr("f"));
- knownAliasesVKStrings.insert(KEY_G, tr("g"));
- knownAliasesVKStrings.insert(KEY_H, tr("h"));
- knownAliasesVKStrings.insert(KEY_I, tr("i"));
- knownAliasesVKStrings.insert(KEY_J, tr("j"));
- knownAliasesVKStrings.insert(KEY_K, tr("k"));
- knownAliasesVKStrings.insert(KEY_L, tr("l"));
- knownAliasesVKStrings.insert(KEY_M, tr("m"));
- knownAliasesVKStrings.insert(KEY_N, tr("n"));
- knownAliasesVKStrings.insert(KEY_O, tr("o"));
- knownAliasesVKStrings.insert(KEY_P, tr("p"));
- knownAliasesVKStrings.insert(KEY_Q, tr("q"));
- knownAliasesVKStrings.insert(KEY_R, tr("r"));
- knownAliasesVKStrings.insert(KEY_S, tr("s"));
- knownAliasesVKStrings.insert(KEY_T, tr("t"));
- knownAliasesVKStrings.insert(KEY_U, tr("u"));
- knownAliasesVKStrings.insert(KEY_V, tr("v"));
- knownAliasesVKStrings.insert(KEY_W, tr("w"));
- knownAliasesVKStrings.insert(KEY_X, tr("x"));
- knownAliasesVKStrings.insert(KEY_Y, tr("y"));
- knownAliasesVKStrings.insert(KEY_Z, tr("z"));
-
- knownAliasesVKStrings.insert(KEY_ESC, tr("Esc"));
- knownAliasesVKStrings.insert(KEY_F1, tr("F1"));
- knownAliasesVKStrings.insert(KEY_F2, tr("F2"));
- knownAliasesVKStrings.insert(KEY_F3, tr("F3"));
- knownAliasesVKStrings.insert(KEY_F4, tr("F4"));
- knownAliasesVKStrings.insert(KEY_F5, tr("F5"));
- knownAliasesVKStrings.insert(KEY_F6, tr("F6"));
- knownAliasesVKStrings.insert(KEY_F7, tr("F7"));
- knownAliasesVKStrings.insert(KEY_F8, tr("F8"));
- knownAliasesVKStrings.insert(KEY_F9, tr("F9"));
- knownAliasesVKStrings.insert(KEY_F10, tr("F10"));
- knownAliasesVKStrings.insert(KEY_F11, tr("F11"));
- knownAliasesVKStrings.insert(KEY_F12, tr("F12"));
-
- knownAliasesVKStrings.insert(KEY_GRAVE, tr("`"));
- knownAliasesVKStrings.insert(KEY_1, tr("1"));
- knownAliasesVKStrings.insert(KEY_2, tr("2"));
- knownAliasesVKStrings.insert(KEY_3, tr("3"));
- knownAliasesVKStrings.insert(KEY_4, tr("4"));
- knownAliasesVKStrings.insert(KEY_5, tr("5"));
- knownAliasesVKStrings.insert(KEY_6, tr("6"));
- knownAliasesVKStrings.insert(KEY_7, tr("7"));
- knownAliasesVKStrings.insert(KEY_8, tr("8"));
- knownAliasesVKStrings.insert(KEY_9, tr("9"));
- knownAliasesVKStrings.insert(KEY_0, tr("0"));
- knownAliasesVKStrings.insert(KEY_MINUS, tr("-"));
- knownAliasesVKStrings.insert(KEY_EQUAL, tr("="));
- knownAliasesVKStrings.insert(KEY_BACKSPACE, tr("BackSpace"));
- knownAliasesVKStrings.insert(KEY_TAB, tr("Tab"));
- knownAliasesVKStrings.insert(KEY_LEFTBRACE, tr("["));
- knownAliasesVKStrings.insert(KEY_RIGHTBRACE, tr("]"));
- knownAliasesVKStrings.insert(KEY_BACKSLASH, tr("\\"));
- knownAliasesVKStrings.insert(KEY_CAPSLOCK, tr("CapsLock"));
- knownAliasesVKStrings.insert(KEY_SEMICOLON, tr(";"));
- knownAliasesVKStrings.insert(KEY_APOSTROPHE, tr("'"));
- knownAliasesVKStrings.insert(KEY_ENTER, tr("Enter"));
- knownAliasesVKStrings.insert(KEY_LEFTSHIFT, tr("Shift_L"));
- knownAliasesVKStrings.insert(KEY_COMMA, tr(","));
- knownAliasesVKStrings.insert(KEY_DOT, tr("."));
- knownAliasesVKStrings.insert(KEY_SLASH, tr("/"));
- knownAliasesVKStrings.insert(KEY_LEFTCTRL, tr("Ctrl_L"));
- knownAliasesVKStrings.insert(KEY_MENU, tr("Super_L"));
- knownAliasesVKStrings.insert(KEY_LEFTALT, tr("Alt_L"));
- knownAliasesVKStrings.insert(KEY_SPACE, tr("Space"));
- knownAliasesVKStrings.insert(KEY_RIGHTALT, tr("Alt_R"));
- knownAliasesVKStrings.insert(KEY_COMPOSE, tr("Menu"));
- knownAliasesVKStrings.insert(KEY_RIGHTCTRL, tr("Ctrl_R"));
- knownAliasesVKStrings.insert(KEY_RIGHTSHIFT, tr("Shift_R"));
-
- knownAliasesVKStrings.insert(KEY_UP, tr("Up"));
- knownAliasesVKStrings.insert(KEY_LEFT, tr("Left"));
- knownAliasesVKStrings.insert(KEY_DOWN, tr("Down"));
- knownAliasesVKStrings.insert(KEY_RIGHT, tr("Right"));
- knownAliasesVKStrings.insert(KEY_PRINT, tr("PrtSc"));
- knownAliasesVKStrings.insert(KEY_INSERT, tr("Ins"));
- knownAliasesVKStrings.insert(KEY_DELETE, tr("Del"));
- knownAliasesVKStrings.insert(KEY_HOME, tr("Home"));
- knownAliasesVKStrings.insert(KEY_END, tr("End"));
- knownAliasesVKStrings.insert(KEY_PAGEUP, tr("PgUp"));
- knownAliasesVKStrings.insert(KEY_PAGEDOWN, tr("PgDn"));
-
- knownAliasesVKStrings.insert(KEY_NUMLOCK, tr("NumLock"));
- knownAliasesVKStrings.insert(KEY_KPSLASH, tr("/"));
- knownAliasesVKStrings.insert(KEY_KPASTERISK, tr("*"));
- knownAliasesVKStrings.insert(KEY_KPMINUS, tr("-"));
- knownAliasesVKStrings.insert(KEY_KPPLUS, tr("+"));
- knownAliasesVKStrings.insert(KEY_KPENTER, tr("KP_Enter"));
-
- knownAliasesVKStrings.insert(KEY_KP1, tr("KP_1"));
- knownAliasesVKStrings.insert(KEY_KP2, tr("KP_2"));
- knownAliasesVKStrings.insert(KEY_KP3, tr("KP_3"));
- knownAliasesVKStrings.insert(KEY_KP4, tr("KP_4"));
- knownAliasesVKStrings.insert(KEY_KP5, tr("KP_5"));
- knownAliasesVKStrings.insert(KEY_KP6, tr("KP_6"));
- knownAliasesVKStrings.insert(KEY_KP7, tr("KP_7"));
- knownAliasesVKStrings.insert(KEY_KP8, tr("KP_8"));
- knownAliasesVKStrings.insert(KEY_KP9, tr("KP_9"));
- knownAliasesVKStrings.insert(KEY_KP0, tr("KP_0"));
-
- knownAliasesVKStrings.insert(KEY_SCROLLLOCK, tr("SCLK"));
- knownAliasesVKStrings.insert(KEY_PAUSE, tr("Pause"));
- knownAliasesVKStrings.insert(KEY_KPDOT, tr("."));
- knownAliasesVKStrings.insert(KEY_LEFTMETA, tr("Super_L"));
- knownAliasesVKStrings.insert(KEY_RIGHTMETA, tr("Super_R"));
- knownAliasesVKStrings.insert(KEY_MUTE, tr("Mute"));
- knownAliasesVKStrings.insert(KEY_VOLUMEDOWN, tr("VolDn"));
- knownAliasesVKStrings.insert(KEY_VOLUMEUP, tr("VolUp"));
- knownAliasesVKStrings.insert(KEY_PLAYPAUSE, tr("Play"));
- knownAliasesVKStrings.insert(KEY_STOPCD, tr("Stop"));
- knownAliasesVKStrings.insert(KEY_PREVIOUSSONG, tr("Prev"));
- knownAliasesVKStrings.insert(KEY_NEXTSONG, tr("Next"));
+ knownAliasesVKStrings.insert(XKB_KEY_a, tr("a"));
+ knownAliasesVKStrings.insert(XKB_KEY_b, tr("b"));
+ knownAliasesVKStrings.insert(XKB_KEY_c, tr("c"));
+ knownAliasesVKStrings.insert(XKB_KEY_d, tr("d"));
+ knownAliasesVKStrings.insert(XKB_KEY_e, tr("e"));
+ knownAliasesVKStrings.insert(XKB_KEY_f, tr("f"));
+ knownAliasesVKStrings.insert(XKB_KEY_g, tr("g"));
+ knownAliasesVKStrings.insert(XKB_KEY_h, tr("h"));
+ knownAliasesVKStrings.insert(XKB_KEY_i, tr("i"));
+ knownAliasesVKStrings.insert(XKB_KEY_j, tr("j"));
+ knownAliasesVKStrings.insert(XKB_KEY_k, tr("k"));
+ knownAliasesVKStrings.insert(XKB_KEY_l, tr("l"));
+ knownAliasesVKStrings.insert(XKB_KEY_m, tr("m"));
+ knownAliasesVKStrings.insert(XKB_KEY_n, tr("n"));
+ knownAliasesVKStrings.insert(XKB_KEY_o, tr("o"));
+ knownAliasesVKStrings.insert(XKB_KEY_p, tr("p"));
+ knownAliasesVKStrings.insert(XKB_KEY_q, tr("q"));
+ knownAliasesVKStrings.insert(XKB_KEY_r, tr("r"));
+ knownAliasesVKStrings.insert(XKB_KEY_s, tr("s"));
+ knownAliasesVKStrings.insert(XKB_KEY_t, tr("t"));
+ knownAliasesVKStrings.insert(XKB_KEY_u, tr("u"));
+ knownAliasesVKStrings.insert(XKB_KEY_v, tr("v"));
+ knownAliasesVKStrings.insert(XKB_KEY_w, tr("w"));
+ knownAliasesVKStrings.insert(XKB_KEY_x, tr("x"));
+ knownAliasesVKStrings.insert(XKB_KEY_y, tr("y"));
+ knownAliasesVKStrings.insert(XKB_KEY_z, tr("z"));
+
+ knownAliasesVKStrings.insert(XKB_KEY_Escape, tr("Esc"));
+ knownAliasesVKStrings.insert(XKB_KEY_F1, tr("F1"));
+ knownAliasesVKStrings.insert(XKB_KEY_F2, tr("F2"));
+ knownAliasesVKStrings.insert(XKB_KEY_F3, tr("F3"));
+ knownAliasesVKStrings.insert(XKB_KEY_F4, tr("F4"));
+ knownAliasesVKStrings.insert(XKB_KEY_F5, tr("F5"));
+ knownAliasesVKStrings.insert(XKB_KEY_F6, tr("F6"));
+ knownAliasesVKStrings.insert(XKB_KEY_F7, tr("F7"));
+ knownAliasesVKStrings.insert(XKB_KEY_F8, tr("F8"));
+ knownAliasesVKStrings.insert(XKB_KEY_F9, tr("F9"));
+ knownAliasesVKStrings.insert(XKB_KEY_F10, tr("F10"));
+ knownAliasesVKStrings.insert(XKB_KEY_F11, tr("F11"));
+ knownAliasesVKStrings.insert(XKB_KEY_F12, tr("F12"));
+
+ knownAliasesVKStrings.insert(XKB_KEY_grave, tr("`"));
+ knownAliasesVKStrings.insert(XKB_KEY_1, tr("1"));
+ knownAliasesVKStrings.insert(XKB_KEY_2, tr("2"));
+ knownAliasesVKStrings.insert(XKB_KEY_3, tr("3"));
+ knownAliasesVKStrings.insert(XKB_KEY_4, tr("4"));
+ knownAliasesVKStrings.insert(XKB_KEY_5, tr("5"));
+ knownAliasesVKStrings.insert(XKB_KEY_6, tr("6"));
+ knownAliasesVKStrings.insert(XKB_KEY_7, tr("7"));
+ knownAliasesVKStrings.insert(XKB_KEY_8, tr("8"));
+ knownAliasesVKStrings.insert(XKB_KEY_9, tr("9"));
+ knownAliasesVKStrings.insert(XKB_KEY_0, tr("0"));
+
+ knownAliasesVKStrings.insert(XKB_KEY_minus, tr("-"));
+ knownAliasesVKStrings.insert(XKB_KEY_equal, tr("="));
+ knownAliasesVKStrings.insert(XKB_KEY_BackSpace, tr("BackSpace"));
+ knownAliasesVKStrings.insert(XKB_KEY_Tab, tr("Tab"));
+ knownAliasesVKStrings.insert(XKB_KEY_braceleft, tr("["));
+ knownAliasesVKStrings.insert(XKB_KEY_braceright, tr("]"));
+ knownAliasesVKStrings.insert(XKB_KEY_backslash, tr("\\"));
+ knownAliasesVKStrings.insert(XKB_KEY_Caps_Lock, tr("CapsLock"));
+ knownAliasesVKStrings.insert(XKB_KEY_semicolon, tr(";"));
+ knownAliasesVKStrings.insert(XKB_KEY_apostrophe, tr("'"));
+ knownAliasesVKStrings.insert(XKB_KEY_Return, tr("Enter"));
+ knownAliasesVKStrings.insert(XKB_KEY_Shift_L, tr("Shift_L"));
+ knownAliasesVKStrings.insert(XKB_KEY_comma, tr(","));
+ knownAliasesVKStrings.insert(XKB_KEY_period, tr("."));
+ knownAliasesVKStrings.insert(XKB_KEY_slash, tr("/"));
+ knownAliasesVKStrings.insert(XKB_KEY_Control_L, tr("Ctrl_L"));
+ knownAliasesVKStrings.insert(XKB_KEY_Super_L, tr("Super_L"));
+ knownAliasesVKStrings.insert(XKB_KEY_Alt_L, tr("Alt_L"));
+ knownAliasesVKStrings.insert(XKB_KEY_space, tr("Space"));
+ knownAliasesVKStrings.insert(XKB_KEY_Alt_R, tr("Alt_R"));
+ knownAliasesVKStrings.insert(XKB_KEY_Meta_R, tr("Menu"));
+ knownAliasesVKStrings.insert(XKB_KEY_Control_R, tr("Ctrl_R"));
+ knownAliasesVKStrings.insert(XKB_KEY_Shift_R, tr("Shift_R"));
+
+ knownAliasesVKStrings.insert(XKB_KEY_uparrow, tr("Up"));
+ knownAliasesVKStrings.insert(XKB_KEY_leftarrow, tr("Left"));
+ knownAliasesVKStrings.insert(XKB_KEY_downarrow, tr("Down"));
+ knownAliasesVKStrings.insert(XKB_KEY_rightarrow, tr("Right"));
+ knownAliasesVKStrings.insert(XKB_KEY_Print, tr("PrtSc"));
+ knownAliasesVKStrings.insert(XKB_KEY_Insert, tr("Ins"));
+ knownAliasesVKStrings.insert(XKB_KEY_Delete, tr("Del"));
+ knownAliasesVKStrings.insert(XKB_KEY_Home, tr("Home"));
+ knownAliasesVKStrings.insert(XKB_KEY_End, tr("End"));
+ knownAliasesVKStrings.insert(XKB_KEY_Page_Up, tr("PgUp"));
+ knownAliasesVKStrings.insert(XKB_KEY_Page_Down, tr("PgDn"));
+
+ knownAliasesVKStrings.insert(XKB_KEY_Num_Lock, tr("NumLock"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_Divide, tr("/"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_Multiply, tr("*"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_Subtract, tr("-"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_Add, tr("+"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_Enter, tr("KP_Enter"));
+
+ knownAliasesVKStrings.insert(XKB_KEY_KP_1, tr("KP_1"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_2, tr("KP_2"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_3, tr("KP_3"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_4, tr("KP_4"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_5, tr("KP_5"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_6, tr("KP_6"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_7, tr("KP_7"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_8, tr("KP_8"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_9, tr("KP_9"));
+ knownAliasesVKStrings.insert(XKB_KEY_KP_0, tr("KP_0"));
+
+ knownAliasesVKStrings.insert(XKB_KEY_Scroll_Lock, tr("SCLK"));
+ knownAliasesVKStrings.insert(XKB_KEY_Pause, tr("Pause"));
+ knownAliasesVKStrings.insert(XKB_KEY_period, tr("."));
+ knownAliasesVKStrings.insert(XKB_KEY_Super_L, tr("Super_L"));
+ knownAliasesVKStrings.insert(XKB_KEY_Super_R, tr("Super_R"));
+
+ knownAliasesVKStrings.insert(XKB_KEY_XF86AudioMute, tr("Mute"));
+ knownAliasesVKStrings.insert(XKB_KEY_XF86AudioLowerVolume, tr("VolDn"));
+ knownAliasesVKStrings.insert(XKB_KEY_XF86AudioRaiseVolume, tr("VolUp"));
+ knownAliasesVKStrings.insert(XKB_KEY_XF86AudioPlay, tr("Play"));
+ knownAliasesVKStrings.insert(XKB_KEY_XF86AudioStop, tr("Stop"));
+ knownAliasesVKStrings.insert(XKB_KEY_XF86AudioPrev, tr("Prev"));
+ knownAliasesVKStrings.insert(XKB_KEY_XF86AudioNext, tr("Next"));
}
}
@@ -300,3 +311,97 @@ unsigned int UInputHelper::getVirtualKey(QString codestring)
return temp;
}
+
+unsigned int UInputHelper::getInputKey(unsigned int virtualkey)
+{
+ unsigned int temp = 0;
+ if (xkbToKeyMapping.contains(virtualkey))
+ {
+ qDebug() << "VIRTUAL KEY: " << QString::number(virtualkey, 16);
+ temp = xkbToKeyMapping.value(virtualkey);
+ qDebug() << "TEMP : " << temp;
+ }
+
+ return temp;
+}
+
+void UInputHelper::initializeXKBCommon()
+{
+ struct xkb_rule_names names;
+ names.rules = "evdev";
+ names.model = "pc105";
+ names.layout = "fr";
+ names.variant = "";
+ names.options = "";
+
+ ctx = xkb_context_new(XKB_CONTEXT_NO_ENVIRONMENT_NAMES);
+ keymap = xkb_keymap_new_from_names(ctx, &names, XKB_MAP_COMPILE_PLACEHOLDER);
+ state = xkb_state_new(keymap);
+}
+
+void UInputHelper::populateXKBMapping()
+{
+ if (keytoXkbMapping.isEmpty())
+ {
+ for (int i = KEY_ESC; i <= KEY_MICMUTE; i++)
+ {
+ insertKeyToXKBEntry(i);
+ }
+ /*keytoXkbMapping.insert(KEY_A, xkb_state_key_get_one_sym(state, KEY_A + evkey_offset));
+ keytoXkbMapping.insert(KEY_B, xkb_state_key_get_one_sym(state, KEY_B + evkey_offset));
+ keytoXkbMapping.insert(KEY_C, xkb_state_key_get_one_sym(state, KEY_C + evkey_offset));
+ keytoXkbMapping.insert(KEY_D, xkb_state_key_get_one_sym(state, KEY_D + evkey_offset));
+ keytoXkbMapping.insert(KEY_E, xkb_state_key_get_one_sym(state, KEY_E + evkey_offset));
+ keytoXkbMapping.insert(KEY_F, xkb_state_key_get_one_sym(state, KEY_F + evkey_offset));
+ keytoXkbMapping.insert(KEY_G, xkb_state_key_get_one_sym(state, KEY_G + evkey_offset));
+ keytoXkbMapping.insert(KEY_H, xkb_state_key_get_one_sym(state, KEY_H + evkey_offset));
+
+ keytoXkbMapping.insert(KEY_I, xkb_state_key_get_one_sym(state, KEY_I + evkey_offset));
+ keytoXkbMapping.insert(KEY_J, xkb_state_key_get_one_sym(state, KEY_J + evkey_offset));
+ keytoXkbMapping.insert(KEY_K, xkb_state_key_get_one_sym(state, KEY_K + evkey_offset));
+ keytoXkbMapping.insert(KEY_L, xkb_state_key_get_one_sym(state, KEY_L + evkey_offset));
+ keytoXkbMapping.insert(KEY_M, xkb_state_key_get_one_sym(state, KEY_M + evkey_offset));
+ keytoXkbMapping.insert(KEY_N, xkb_state_key_get_one_sym(state, KEY_N + evkey_offset));
+ keytoXkbMapping.insert(KEY_O, xkb_state_key_get_one_sym(state, KEY_O + evkey_offset));
+ keytoXkbMapping.insert(KEY_P, xkb_state_key_get_one_sym(state, KEY_P + evkey_offset));
+ keytoXkbMapping.insert(KEY_Q, xkb_state_key_get_one_sym(state, KEY_Q + evkey_offset));
+ keytoXkbMapping.insert(KEY_R, xkb_state_key_get_one_sym(state, KEY_R + evkey_offset));
+
+
+ keytoXkbMapping.insert(KEY_S, xkb_state_key_get_one_sym(state, KEY_S + evkey_offset));
+ keytoXkbMapping.insert(KEY_T, xkb_state_key_get_one_sym(state, KEY_T + evkey_offset));
+ keytoXkbMapping.insert(KEY_U, xkb_state_key_get_one_sym(state, KEY_U + evkey_offset));
+ keytoXkbMapping.insert(KEY_V, xkb_state_key_get_one_sym(state, KEY_V + evkey_offset));
+ keytoXkbMapping.insert(KEY_W, xkb_state_key_get_one_sym(state, KEY_W + evkey_offset));
+ keytoXkbMapping.insert(KEY_X, xkb_state_key_get_one_sym(state, KEY_X + evkey_offset));
+ keytoXkbMapping.insert(KEY_Y, xkb_state_key_get_one_sym(state, KEY_Y + evkey_offset));
+ keytoXkbMapping.insert(KEY_Z, xkb_state_key_get_one_sym(state, KEY_Z + evkey_offset));
+
+ insertKeyToXKBEntry(KEY_1);*/
+ }
+
+ if (xkbToKeyMapping.isEmpty())
+ {
+ QHashIterator<unsigned int, unsigned int> iter(keytoXkbMapping);
+ while (iter.hasNext())
+ {
+ iter.next();
+
+ xkbToKeyMapping.insert(iter.value(), iter.key());
+ //qDebug() << "KEY: " << QString::number(iter.key(), 16);
+ //qDebug() << "VALUE: " << QString::number(iter.value(), 16);
+ }
+
+ //xkbToKeyMapping.insert(XKB_KEY_a, xkb_state_key_get_one_sym(state, KEY_W + evkey_offset));
+ //xkbToKeyMapping.insert(XKB_KEY_a, xkb_state_key_get_one_sym(state, KEY_W + evkey_offset));
+ }
+}
+
+void UInputHelper::insertKeyToXKBEntry(unsigned int inputKey)
+{
+ xkb_keysym_t sym = xkb_state_key_get_one_sym(state, inputKey + evkey_offset);
+ if (sym != XKB_KEY_NoSymbol)
+ {
+ keytoXkbMapping.insert(inputKey, sym);
+ }
+}
diff --git a/src/uinputhelper.h b/src/uinputhelper.h
index e8a1640..ae818b4 100644
--- a/src/uinputhelper.h
+++ b/src/uinputhelper.h
@@ -5,6 +5,10 @@
#include <QString>
#include <QHash>
+#include <xkbcommon/xkbcommon.h>
+#include <xkbcommon/xkbcommon-keysyms.h>
+#include <xkbcommon/xkbcommon-names.h>
+
class UInputHelper : public QObject
{
Q_OBJECT
@@ -14,16 +18,26 @@ public:
QString getDisplayString(unsigned int virtualkey);
unsigned int getVirtualKey(QString codestring);
+ unsigned int getInputKey(unsigned int virtualkey);
protected:
explicit UInputHelper(QObject *parent = 0);
~UInputHelper();
void populateKnownAliases();
+ void initializeXKBCommon();
+ void populateXKBMapping();
+ void insertKeyToXKBEntry(unsigned int inputKey);
static UInputHelper *_instance;
QHash<QString, unsigned int> knownAliasesX11SymVK;
QHash<unsigned int, QString> knownAliasesVKStrings;
+ QHash<unsigned int, unsigned int> xkbToKeyMapping;
+ QHash<unsigned int, unsigned int> keytoXkbMapping;
+
+ struct xkb_context *ctx;
+ struct xkb_keymap *keymap;
+ struct xkb_state *state;
signals:
diff --git a/src/x11info.cpp b/src/x11info.cpp
index 674ab4f..2710a34 100644
--- a/src/x11info.cpp
+++ b/src/x11info.cpp
@@ -1,4 +1,6 @@
+//#include <QDebug>
#include <unistd.h>
+#include <X11/Xatom.h>
#include "x11info.h"
@@ -339,3 +341,45 @@ QString X11Info::getXDisplayString()
{
return _customDisplayString;
}
+
+X11Info::xkblayout X11Info::findKeyboardLayout()
+{
+ Atom actual_type;
+ int actual_format = 0;
+ unsigned long nitems = 0;
+ unsigned long bytes_after = 0;
+ unsigned char *prop = 0;
+ int status = 0;
+
+ char* names[5] = {0, 0, 0, 0, 0};
+ xkblayout layoutRules;
+ Display *display = this->display();
+
+ Atom atom = XInternAtom(display, "_XKB_RULES_NAMES", True);
+ Window root = appRootWindow();
+ status = XGetWindowProperty(display, root, atom, 0, 1024, false, XA_STRING, &actual_type, &actual_format, &nitems, &bytes_after, &prop);
+ if (status == Success && actual_type == XA_STRING && actual_format == 8 && nitems > 2)
+ {
+
+ char *p = reinterpret_cast<char *>(prop), *end = p + nitems;
+ int i = 0;
+ do {
+ names[i++] = p;
+ p += qstrlen(p) + 1;
+ } while (p < end);
+
+ layoutRules.rules = names[0];
+ layoutRules.model = names[1];
+ layoutRules.layout = names[2];
+ layoutRules.variant = names[3];
+ layoutRules.variant = names[4];
+ }
+
+ if (prop)
+ {
+ XFree(prop);
+ prop = 0;
+ }
+
+ return layoutRules;
+}
diff --git a/src/x11info.h b/src/x11info.h
index dc1fc04..c31f97b 100644
--- a/src/x11info.h
+++ b/src/x11info.h
@@ -10,6 +10,14 @@ class X11Info : public QObject
{
Q_OBJECT
public:
+ typedef struct xkblayout {
+ QString rules;
+ QString model;
+ QString layout;
+ QString variant;
+ QString options;
+ } xkblayout;
+
~X11Info();
unsigned long appRootWindow(int screen = -1);
@@ -23,6 +31,7 @@ public:
void syncDisplay();
void syncDisplay(QString displayString);
QString getXDisplayString();
+ xkblayout findKeyboardLayout();
static X11Info* getInstance();
static void deleteInstance();
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment