mirror of
https://github.com/TomHarte/CLK.git
synced 2024-08-21 19:29:08 +00:00
203 lines
6.6 KiB
C++
203 lines
6.6 KiB
C++
#include "keyboard.h"
|
|
|
|
#include <QDebug>
|
|
#include <QGuiApplication>
|
|
|
|
// Qt is the worst.
|
|
//
|
|
// Assume your keyboard has a key labelled both . and >, as on US and UK keyboards. Call it the dot key.
|
|
// Perform the following:
|
|
// 1. press dot key;
|
|
// 2. press shift key;
|
|
// 3. release dot key;
|
|
// 4. release shift key.
|
|
//
|
|
// Per empirical testing, and key repeat aside, on both macOS and Ubuntu 19.04 that sequence will result in
|
|
// _three_ keypress events, but only _two_ key release events. You'll get presses for Qt::Key_Period, Qt::Key_Greater
|
|
// and Qt::Key_Shift. You'll get releases only for Qt::Key_Greater and Qt::Key_Shift.
|
|
//
|
|
// How can you detect at runtime that Key_Greater and Key_Period are the same physical key?
|
|
//
|
|
// You can't. On Ubuntu they have the same values for QKeyEvent::nativeScanCode(), which are unique to the key,
|
|
// but they have different ::nativeVirtualKey()s.
|
|
//
|
|
// On macOS they have the same ::nativeScanCode() only because on macOS [almost] all keys have the same
|
|
// ::nativeScanCode(). So that's not usable. They have the same ::nativeVirtualKey()s, but since that isn't true
|
|
// on Ubuntu, that's also not usable.
|
|
//
|
|
// So how can you track the physical keys on a keyboard via Qt?
|
|
//
|
|
// You can't. Qt is the worst. SDL doesn't have this problem, including in X11, but I don't want the non-Qt dependency.
|
|
|
|
#ifdef Q_OS_LINUX
|
|
#define HAS_X11
|
|
#endif
|
|
|
|
#ifdef HAS_X11
|
|
#include <QX11Info>
|
|
|
|
#include <X11/Xutil.h>
|
|
#include <X11/keysym.h>
|
|
#endif
|
|
|
|
KeyboardMapper::KeyboardMapper() {
|
|
#ifdef HAS_X11
|
|
struct DesiredMapping {
|
|
KeySym source = 0;
|
|
Inputs::Keyboard::Key destination;
|
|
};
|
|
|
|
using Key = Inputs::Keyboard::Key;
|
|
constexpr DesiredMapping mappings[] = {
|
|
{XK_Escape, Key::Escape},
|
|
{XK_F1, Key::F1}, {XK_F2, Key::F2}, {XK_F3, Key::F3}, {XK_F4, Key::F4}, {XK_F5, Key::F5},
|
|
{XK_F6, Key::F6}, {XK_F7, Key::F7}, {XK_F8, Key::F8}, {XK_F9, Key::F9}, {XK_F10, Key::F10},
|
|
{XK_F11, Key::F11}, {XK_F12, Key::F12},
|
|
{XK_Sys_Req, Key::PrintScreen},
|
|
{XK_Scroll_Lock, Key::ScrollLock},
|
|
{XK_Pause, Key::Pause},
|
|
|
|
{XK_grave, Key::BackTick},
|
|
{XK_1, Key::k1}, {XK_2, Key::k2}, {XK_3, Key::k3}, {XK_4, Key::k4}, {XK_5, Key::k5},
|
|
{XK_6, Key::k6}, {XK_7, Key::k7}, {XK_8, Key::k8}, {XK_9, Key::k9}, {XK_0, Key::k0},
|
|
{XK_minus, Key::Hyphen},
|
|
{XK_equal, Key::Equals},
|
|
{XK_BackSpace, Key::Backspace},
|
|
|
|
{XK_Tab, Key::Tab},
|
|
{XK_Q, Key::Q}, {XK_W, Key::W}, {XK_E, Key::E}, {XK_R, Key::R}, {XK_T, Key::T},
|
|
{XK_Y, Key::Y}, {XK_U, Key::U}, {XK_I, Key::I}, {XK_O, Key::O}, {XK_P, Key::P},
|
|
{XK_bracketleft, Key::OpenSquareBracket},
|
|
{XK_bracketright, Key::CloseSquareBracket},
|
|
{XK_backslash, Key::Backslash},
|
|
|
|
{XK_Caps_Lock, Key::CapsLock},
|
|
{XK_A, Key::A}, {XK_S, Key::S}, {XK_D, Key::D}, {XK_F, Key::F}, {XK_G, Key::G},
|
|
{XK_H, Key::H}, {XK_J, Key::J}, {XK_K, Key::K}, {XK_L, Key::L},
|
|
{XK_semicolon, Key::Semicolon},
|
|
{XK_apostrophe, Key::Quote},
|
|
{XK_Return, Key::Enter},
|
|
|
|
{XK_Shift_L, Key::LeftShift},
|
|
{XK_Z, Key::Z}, {XK_X, Key::X}, {XK_C, Key::C}, {XK_V, Key::V},
|
|
{XK_B, Key::B}, {XK_N, Key::N}, {XK_M, Key::M},
|
|
{XK_comma, Key::Comma},
|
|
{XK_period, Key::FullStop},
|
|
{XK_slash, Key::ForwardSlash},
|
|
{XK_Shift_R, Key::RightShift},
|
|
|
|
{XK_Control_L, Key::LeftControl},
|
|
{XK_Control_R, Key::RightControl},
|
|
{XK_Alt_L, Key::LeftOption},
|
|
{XK_Alt_R, Key::RightOption},
|
|
{XK_Meta_L, Key::LeftMeta},
|
|
{XK_Meta_R, Key::RightMeta},
|
|
{XK_space, Key::Space},
|
|
|
|
{XK_Left, Key::Left}, {XK_Right, Key::Right}, {XK_Up, Key::Up}, {XK_Down, Key::Down},
|
|
|
|
{XK_Insert, Key::Insert},
|
|
{XK_Delete, Key::Delete},
|
|
{XK_Home, Key::Home},
|
|
{XK_End, Key::End},
|
|
|
|
{XK_Num_Lock, Key::NumLock},
|
|
|
|
{XK_KP_Divide, Key::KeypadSlash},
|
|
{XK_KP_Multiply, Key::KeypadAsterisk},
|
|
{XK_KP_Delete, Key::KeypadDelete},
|
|
{XK_KP_7, Key::Keypad7}, {XK_KP_8, Key::Keypad8}, {XK_KP_9, Key::Keypad9}, {XK_KP_Add, Key::KeypadPlus},
|
|
{XK_KP_4, Key::Keypad4}, {XK_KP_5, Key::Keypad5}, {XK_KP_6, Key::Keypad6}, {XK_KP_Subtract, Key::KeypadMinus},
|
|
{XK_KP_1, Key::Keypad1}, {XK_KP_2, Key::Keypad2}, {XK_KP_3, Key::Keypad3}, {XK_KP_Enter, Key::KeypadEnter},
|
|
{XK_KP_0, Key::Keypad0},
|
|
{XK_KP_Decimal, Key::KeypadDecimalPoint},
|
|
{XK_KP_Equal, Key::KeypadEquals},
|
|
|
|
{XK_Help, Key::Help},
|
|
|
|
{}
|
|
};
|
|
|
|
// Extra level of nonsense here:
|
|
//
|
|
// (1) assume a PC-esque keyboard, with a close-to-US/UK layout;
|
|
// (2) from there, use any of the X11 KeySyms I'd expect to be achievable from each physical key to
|
|
// look up the X11 KeyCode;
|
|
// (3) henceforth, map from X11 KeyCode to the Inputs::Keyboard::Key.
|
|
const DesiredMapping *mapping = mappings;
|
|
while(mapping->source != 0) {
|
|
const auto code = XKeysymToKeycode(QX11Info::display(), mapping->source);
|
|
keyByKeySym[code] = mapping->destination;
|
|
++mapping;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
std::optional<Inputs::Keyboard::Key> KeyboardMapper::keyForEvent(QKeyEvent *event) {
|
|
#ifdef HAS_X11
|
|
if(QGuiApplication::platformName() == QLatin1String("xcb")) {
|
|
const auto key = keyByKeySym.find(event->nativeScanCode());
|
|
if(key == keyByKeySym.end()) return std::nullopt;
|
|
return key->second;
|
|
}
|
|
#endif
|
|
|
|
// Fall back on a limited, faulty adaptation.
|
|
#define BIND2(qtKey, clkKey) case Qt::qtKey: return Inputs::Keyboard::Key::clkKey;
|
|
#define BIND(key) BIND2(Key_##key, key)
|
|
|
|
switch(event->key()) {
|
|
default: return {};
|
|
|
|
BIND(Escape);
|
|
BIND(F1); BIND(F2); BIND(F3); BIND(F4); BIND(F5); BIND(F6);
|
|
BIND(F7); BIND(F8); BIND(F9); BIND(F10); BIND(F11); BIND(F12);
|
|
BIND2(Key_Print, PrintScreen);
|
|
BIND(ScrollLock); BIND(Pause);
|
|
|
|
BIND2(Key_AsciiTilde, BackTick);
|
|
BIND2(Key_1, k1); BIND2(Key_2, k2); BIND2(Key_3, k3); BIND2(Key_4, k4); BIND2(Key_5, k5);
|
|
BIND2(Key_6, k6); BIND2(Key_7, k7); BIND2(Key_8, k8); BIND2(Key_9, k9); BIND2(Key_0, k0);
|
|
BIND2(Key_Minus, Hyphen);
|
|
BIND2(Key_Plus, Equals);
|
|
BIND(Backspace);
|
|
|
|
BIND(Tab); BIND(Q); BIND(W); BIND(E); BIND(R); BIND(T); BIND(Y);
|
|
BIND(U); BIND(I); BIND(O); BIND(P);
|
|
BIND2(Key_BraceLeft, OpenSquareBracket);
|
|
BIND2(Key_BraceRight, CloseSquareBracket);
|
|
BIND(Backslash);
|
|
|
|
BIND(CapsLock); BIND(A); BIND(S); BIND(D); BIND(F); BIND(G);
|
|
BIND(H); BIND(J); BIND(K); BIND(L);
|
|
BIND(Semicolon);
|
|
BIND2(Key_Apostrophe, Quote);
|
|
BIND2(Key_QuoteDbl, Quote);
|
|
// TODO: something to hash?
|
|
BIND2(Key_Return, Enter);
|
|
|
|
BIND2(Key_Shift, LeftShift);
|
|
BIND(Z); BIND(X); BIND(C); BIND(V);
|
|
BIND(B); BIND(N); BIND(M);
|
|
BIND(Comma);
|
|
BIND2(Key_Period, FullStop);
|
|
BIND2(Key_Slash, ForwardSlash);
|
|
// Omitted: right shift.
|
|
|
|
BIND2(Key_Control, LeftControl);
|
|
BIND2(Key_Alt, LeftOption);
|
|
BIND2(Key_Meta, LeftMeta);
|
|
BIND(Space);
|
|
BIND2(Key_AltGr, RightOption);
|
|
|
|
BIND(Left); BIND(Right); BIND(Up); BIND(Down);
|
|
|
|
BIND(Insert); BIND(Home); BIND(PageUp); BIND(Delete); BIND(End); BIND(PageDown);
|
|
|
|
BIND(NumLock);
|
|
}
|
|
|
|
#undef BIND
|
|
#undef BIND2
|
|
}
|