smw/deskflow
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: conform EiKeyState to coding standards

Browse source
This commit is contained in:
sithlord48 2025-06-19 20:16:02 -04:00 committed by Nick Bolton
parent 0691d586e7
commit b8124107aa
3 changed files with 59 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

92
src/lib/platform/EiKeyState.cpp
View file

@ -22,28 +22,28 @@ namespace deskflow {
EiKeyState::EiKeyState(EiScreen *screen, IEventQueue *events)
: KeyState(events, AppUtil::instance().getKeyboardLayoutList(), ClientApp::instance().args().m_enableLangSync),
screen_{screen}
m_screen{screen}
{
xkb_ = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
m_xkb = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
// FIXME: PrimaryClient->enable() calls into our keymap, so we must have
// one during initial startup - even before we know what our actual keymap is.
// Once we get the actual keymap from EIS, we swap it out so hopefully that's
// enough.
init_default_keymap();
initDefaultKeymap();
}
void EiKeyState::init_default_keymap()
void EiKeyState::initDefaultKeymap()
{
if (xkb_keymap_) {
xkb_keymap_unref(xkb_keymap_);
if (m_xkbKeymap) {
xkb_keymap_unref(m_xkbKeymap);
}
xkb_keymap_ = xkb_keymap_new_from_names(xkb_, nullptr, XKB_KEYMAP_COMPILE_NO_FLAGS);
m_xkbKeymap = xkb_keymap_new_from_names(m_xkb, nullptr, XKB_KEYMAP_COMPILE_NO_FLAGS);
if (xkb_state_) {
xkb_state_unref(xkb_state_);
if (m_xkbState) {
xkb_state_unref(m_xkbState);
}
xkb_state_ = xkb_state_new(xkb_keymap_);
m_xkbState = xkb_state_new(m_xkbKeymap);
}
void EiKeyState::init(int fd, size_t len)
@ -62,30 +62,30 @@ void EiKeyState::init(int fd, size_t len)
// whole thing as string.
buffer[len] = '\0'; // guarantee null-termination
auto keymap = xkb_keymap_new_from_string(xkb_, buffer.get(), XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
auto keymap = xkb_keymap_new_from_string(m_xkb, buffer.get(), XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
if (!keymap) {
LOG_WARN("failed to compile keymap, falling back to defaults");
// Falling back to layout "us" is a lot more useful than segfaulting
init_default_keymap();
initDefaultKeymap();
return;
}
if (xkb_keymap_) {
xkb_keymap_unref(xkb_keymap_);
if (m_xkbKeymap) {
xkb_keymap_unref(m_xkbKeymap);
}
xkb_keymap_ = keymap;
m_xkbKeymap = keymap;
if (xkb_state_) {
xkb_state_unref(xkb_state_);
if (m_xkbState) {
xkb_state_unref(m_xkbState);
}
xkb_state_ = xkb_state_new(xkb_keymap_);
m_xkbState = xkb_state_new(m_xkbKeymap);
}
EiKeyState::~EiKeyState()
{
xkb_context_unref(xkb_);
xkb_keymap_unref(xkb_keymap_);
xkb_state_unref(xkb_state_);
xkb_context_unref(m_xkb);
xkb_keymap_unref(m_xkbKeymap);
xkb_state_unref(m_xkbState);
}
bool EiKeyState::fakeCtrlAltDel()
@ -96,13 +96,13 @@ bool EiKeyState::fakeCtrlAltDel()
KeyModifierMask EiKeyState::pollActiveModifiers() const
{
std::uint32_t xkb_mask = xkb_state_serialize_mods(xkb_state_, XKB_STATE_MODS_EFFECTIVE);
return convert_mod_mask(xkb_mask);
std::uint32_t xkb_mask = xkb_state_serialize_mods(m_xkbState, XKB_STATE_MODS_EFFECTIVE);
return convertModMask(xkb_mask);
}
std::int32_t EiKeyState::pollActiveGroup() const
{
return xkb_state_serialize_layout(xkb_state_, XKB_STATE_LAYOUT_EFFECTIVE);
return xkb_state_serialize_layout(m_xkbState, XKB_STATE_LAYOUT_EFFECTIVE);
}
void EiKeyState::pollPressedKeys(KeyButtonSet &pressedKeys) const
@ -111,15 +111,15 @@ void EiKeyState::pollPressedKeys(KeyButtonSet &pressedKeys) const
return;
}
std::uint32_t EiKeyState::convert_mod_mask(std::uint32_t xkb_mask) const
std::uint32_t EiKeyState::convertModMask(std::uint32_t xkb_mask) const
{
std::uint32_t barrier_mask = 0;
for (xkb_mod_index_t xkbmod = 0; xkbmod < xkb_keymap_num_mods(xkb_keymap_); xkbmod++) {
for (xkb_mod_index_t xkbmod = 0; xkbmod < xkb_keymap_num_mods(m_xkbKeymap); xkbmod++) {
if ((xkb_mask & (1 << xkbmod)) == 0)
continue;
const char *name = xkb_keymap_mod_get_name(xkb_keymap_, xkbmod);
const char *name = xkb_keymap_mod_get_name(m_xkbKeymap, xkbmod);
if (strcmp(XKB_MOD_NAME_SHIFT, name) == 0)
barrier_mask |= (1 << kKeyModifierBitShift);
else if (strcmp(XKB_MOD_NAME_CAPS, name) == 0)
@ -138,13 +138,13 @@ std::uint32_t EiKeyState::convert_mod_mask(std::uint32_t xkb_mask) const
// Only way to figure out whether a key is a modifier key is to press it,
// check if a modifier changed state and then release it again.
// Luckily xkbcommon allows us to do this in a separate state.
void EiKeyState::assign_generated_modifiers(std::uint32_t keycode, deskflow::KeyMap::KeyItem &item)
void EiKeyState::assignGeneratedModifiers(std::uint32_t keycode, deskflow::KeyMap::KeyItem &item)
{
std::uint32_t mods_generates = 0;
auto state = xkb_state_new(xkb_keymap_);
auto state = xkb_state_new(m_xkbKeymap);
if (enum xkb_state_component changed = xkb_state_update_key(state, keycode, XKB_KEY_DOWN); changed) {
for (xkb_mod_index_t m = 0; m < xkb_keymap_num_mods(xkb_keymap_); m++) {
for (xkb_mod_index_t m = 0; m < xkb_keymap_num_mods(m_xkbKeymap); m++) {
if (xkb_state_mod_index_is_active(state, m, XKB_STATE_MODS_LOCKED))
item.m_lock = true;
@ -156,27 +156,27 @@ void EiKeyState::assign_generated_modifiers(std::uint32_t keycode, deskflow::Key
xkb_state_update_key(state, keycode, XKB_KEY_UP);
xkb_state_unref(state);
item.m_generates = convert_mod_mask(mods_generates);
item.m_generates = convertModMask(mods_generates);
}
void EiKeyState::getKeyMap(deskflow::KeyMap &keyMap)
{
auto min_keycode = xkb_keymap_min_keycode(xkb_keymap_);
auto max_keycode = xkb_keymap_max_keycode(xkb_keymap_);
auto min_keycode = xkb_keymap_min_keycode(m_xkbKeymap);
auto max_keycode = xkb_keymap_max_keycode(m_xkbKeymap);
// X keycodes are evdev keycodes + 8 (libei gives us evdev keycodes)
for (auto keycode = min_keycode; keycode <= max_keycode; keycode++) {
// skip keys with no groups (they generate no symbols)
if (xkb_keymap_num_layouts_for_key(xkb_keymap_, keycode) == 0)
if (xkb_keymap_num_layouts_for_key(m_xkbKeymap, keycode) == 0)
continue;
for (auto group = 0U; group < xkb_keymap_num_layouts(xkb_keymap_); group++) {
for (auto level = 0U; level < xkb_keymap_num_levels_for_key(xkb_keymap_, keycode, group); level++) {
for (auto group = 0U; group < xkb_keymap_num_layouts(m_xkbKeymap); group++) {
for (auto level = 0U; level < xkb_keymap_num_levels_for_key(m_xkbKeymap, keycode, group); level++) {
const xkb_keysym_t *syms;
xkb_mod_mask_t masks[64];
auto nmasks = xkb_keymap_key_get_mods_for_level(xkb_keymap_, keycode, group, level, masks, 64);
auto nsyms = xkb_keymap_key_get_syms_by_level(xkb_keymap_, keycode, group, level, &syms);
auto nmasks = xkb_keymap_key_get_mods_for_level(m_xkbKeymap, keycode, group, level, masks, 64);
auto nsyms = xkb_keymap_key_get_syms_by_level(m_xkbKeymap, keycode, group, level, &syms);
if (nsyms == 0)
continue;
@ -200,15 +200,15 @@ void EiKeyState::getKeyMap(deskflow::KeyMap &keyMap)
for (auto n = 0U; n < nmasks; n++) {
mods_sensitive |= masks[n];
}
item.m_sensitive = convert_mod_mask(mods_sensitive);
item.m_sensitive = convertModMask(mods_sensitive);
uint32_t mods_required = 0;
for (std::size_t m = 0; m < nmasks; m++) {
mods_required |= masks[m];
}
item.m_required = convert_mod_mask(mods_required);
item.m_required = convertModMask(mods_required);
assign_generated_modifiers(keycode, item);
assignGeneratedModifiers(keycode, item);
// add capslock version of key is sensitive to capslock
if (item.m_sensitive & KeyModifierShift && item.m_sensitive & KeyModifierCapsLock) {
@ -236,17 +236,17 @@ void EiKeyState::fakeKey(const Keystroke &keystroke)
"fake key: %03x (%08x) %s", keystroke.m_data.m_button.m_button, keystroke.m_data.m_button.m_client,
keystroke.m_data.m_button.m_press ? "down" : "up"
);
screen_->fakeKey(keystroke.m_data.m_button.m_button, keystroke.m_data.m_button.m_press);
m_screen->fakeKey(keystroke.m_data.m_button.m_button, keystroke.m_data.m_button.m_press);
break;
default:
break;
}
}
KeyID EiKeyState::map_key_from_keyval(uint32_t keyval) const
KeyID EiKeyState::mapKeyFromKeyval(uint32_t keyval) const
{
// FIXME: That might be a bit crude...?
xkb_keysym_t xkb_keysym = xkb_state_key_get_one_sym(xkb_state_, keyval);
xkb_keysym_t xkb_keysym = xkb_state_key_get_one_sym(m_xkbState, keyval);
auto keysym = static_cast<KeySym>(xkb_keysym);
KeyID keyid = XWindowsUtil::mapKeySymToKeyID(keysym);
@ -255,10 +255,10 @@ KeyID EiKeyState::map_key_from_keyval(uint32_t keyval) const
return keyid;
}
void EiKeyState::update_xkb_state(uint32_t keyval, bool is_pressed)
void EiKeyState::updateXkbState(uint32_t keyval, bool is_pressed)
{
LOG_DEBUG1("update key state: keyval=%d pressed=%i", keyval, is_pressed);
xkb_state_update_key(xkb_state_, keyval, is_pressed ? XKB_KEY_DOWN : XKB_KEY_UP);
xkb_state_update_key(m_xkbState, keyval, is_pressed ? XKB_KEY_DOWN : XKB_KEY_UP);
}
} // namespace deskflow

18
src/lib/platform/EiKeyState.h
View file

@ -24,15 +24,15 @@ public:
~EiKeyState() override;
void init(int fd, std::size_t len);
void init_default_keymap();
void initDefaultKeymap();
// IKeyState overrides
bool fakeCtrlAltDel() override;
KeyModifierMask pollActiveModifiers() const override;
std::int32_t pollActiveGroup() const override;
void pollPressedKeys(KeyButtonSet &pressedKeys) const override;
KeyID map_key_from_keyval(std::uint32_t keyval) const;
void update_xkb_state(std::uint32_t keyval, bool is_pressed);
KeyID mapKeyFromKeyval(std::uint32_t keyval) const;
void updateXkbState(std::uint32_t keyval, bool is_pressed);
protected:
// KeyState overrides
@ -40,14 +40,14 @@ protected:
void fakeKey(const Keystroke &keystroke) override;
private:
std::uint32_t convert_mod_mask(std::uint32_t xkb_mask) const;
void assign_generated_modifiers(std::uint32_t keycode, KeyMap::KeyItem &item);
std::uint32_t convertModMask(std::uint32_t xkb_mask) const;
void assignGeneratedModifiers(std::uint32_t keycode, KeyMap::KeyItem &item);
EiScreen *screen_ = nullptr;
EiScreen *m_screen = nullptr;
xkb_context *xkb_ = nullptr;
xkb_keymap *xkb_keymap_ = nullptr;
xkb_state *xkb_state_ = nullptr;
xkb_context *m_xkb = nullptr;
xkb_keymap *m_xkbKeymap = nullptr;
xkb_state *m_xkbState = nullptr;
};
} // namespace deskflow

8
src/lib/platform/EiScreen.cpp
View file

@ -308,7 +308,7 @@ void EiScreen::fakeKey(uint32_t keycode, bool is_down) const
return;
auto xkb_keycode = keycode + 8;
key_state_->update_xkb_state(xkb_keycode, is_down);
key_state_->updateXkbState(xkb_keycode, is_down);
ei_device_keyboard_key(ei_keyboard_, keycode, is_down);
ei_device_frame(ei_keyboard_, ei_now(ei_));
}
@ -468,7 +468,7 @@ void EiScreen::add_device(struct ei_device *device)
// whatever libxkbcommon thinks is default. At least this way we can
// influence with env vars what we get
LOG_WARN("keyboard device %s does not have a keymap, we are guessing", ei_device_get_name(device));
key_state_->init_default_keymap();
key_state_->initDefaultKeymap();
}
key_state_->updateKeyMap();
}
@ -556,10 +556,10 @@ void EiScreen::on_key_event(ei_event *event)
auto keycode = ei_event_keyboard_get_key(event);
uint32_t keyval = keycode + 8;
bool pressed = ei_event_keyboard_get_key_is_press(event);
KeyID keyid = key_state_->map_key_from_keyval(keyval);
KeyID keyid = key_state_->mapKeyFromKeyval(keyval);
auto keybutton = static_cast<KeyButton>(keyval);
key_state_->update_xkb_state(keyval, pressed);
key_state_->updateXkbState(keyval, pressed);
KeyModifierMask mask = key_state_->pollActiveModifiers();
LOG_DEBUG1("event: key %s keycode=%d keyid=%d mask=0x%x", pressed ? "press" : "release", keycode, keyid, mask);