Delegate keyboard grab until a button has been pressed if the device says its a mouse

README.md

@@ -31,7 +31,7 @@ These are the dependencies needed to build GPU Screen Recorder UI:
 ## Runtime dependencies
 There are also additional dependencies needed at runtime:
 
-* [GPU Screen Recorder](https://git.dec05eba.com/gpu-screen-recorder/) (version 5.0.0 or greater)
+* [GPU Screen Recorder](https://git.dec05eba.com/gpu-screen-recorder/) (version 5.0.0 or later)
 * [GPU Screen Recorder Notification](https://git.dec05eba.com/gpu-screen-recorder-notification/)
 
 ## Program behavior notes
@@ -45,8 +45,8 @@ This software is licensed under GPL3.0-only. Files under `fonts/` directory belo
 [![Click here to watch a demo video on youtube](https://img.youtube.com/vi/SOqXusCTXXA/0.jpg)](https://www.youtube.com/watch?v=SOqXusCTXXA)
 
 # Screenshots
-![](https://dec05eba.com/images/gsr-overlay-screenshot-front.webp)
+![](https://dec05eba.com/images/front_page.jpg)
-![](https://dec05eba.com/images/gsr-overlay-screenshot-settings.webp)
+![](https://dec05eba.com/images/settings_page.jpg)
 
 # Donations
 If you want to donate you can donate via bitcoin or monero.

include/Config.hpp

@@ -90,6 +90,7 @@ namespace gsr {
         RecordOptions record_options;
         std::string turn_on_replay_automatically_mode = "dont_turn_on_automatically";
         bool save_video_in_game_folder = false;
+        bool restart_replay_on_save = false;
         bool show_replay_started_notifications = true;
         bool show_replay_stopped_notifications = true;
         bool show_replay_saved_notifications = true;

include/GsrInfo.hpp

@@ -2,6 +2,7 @@
 
 #include <string>
 #include <vector>
+#include <stdint.h>
 
 #include <mglpp/system/vec.hpp>
 
@@ -24,6 +25,21 @@ namespace gsr {
         mgl::vec2i size;
     };
 
+    struct GsrVersion {
+        uint8_t major = 0;
+        uint8_t minor = 0;
+        uint8_t patch = 0;
+
+        bool operator>(const GsrVersion &other) const;
+        bool operator>=(const GsrVersion &other) const;
+        bool operator<(const GsrVersion &other) const;
+        bool operator<=(const GsrVersion &other) const;
+        bool operator==(const GsrVersion &other) const;
+        bool operator!=(const GsrVersion &other) const;
+
+        std::string to_string() const;
+    };
+
     struct SupportedCaptureOptions {
         bool window = false;
         bool focused = false;
@@ -40,6 +56,7 @@ namespace gsr {
     struct SystemInfo {
         DisplayServer display_server = DisplayServer::UNKNOWN;
         bool supports_app_audio = false;
+        GsrVersion gsr_version;
     };
 
     enum class GpuVendor {

include/gui/GlobalSettingsPage.hpp

@@ -92,5 +92,6 @@ namespace gsr {
         ConfigureHotkeyType configure_hotkey_type = ConfigureHotkeyType::NONE;
 
         CustomRendererWidget *hotkey_overlay_ptr = nullptr;
+        std::string hotkey_configure_action_name;
     };
 }

include/gui/SettingsPage.hpp

@@ -97,6 +97,7 @@ namespace gsr {
         std::unique_ptr<List> create_replay_time();
         std::unique_ptr<RadioButton> create_start_replay_automatically();
         std::unique_ptr<CheckBox> create_save_replay_in_game_folder();
+        std::unique_ptr<CheckBox> create_restart_replay_on_save();
         std::unique_ptr<Label> create_estimated_replay_file_size();
         void update_estimated_replay_file_size();
         std::unique_ptr<CheckBox> create_save_recording_in_game_folder();
@@ -170,6 +171,7 @@ namespace gsr {
         List *stream_url_list_ptr = nullptr;
         List *container_list_ptr = nullptr;
         CheckBox *save_replay_in_game_folder_ptr = nullptr;
+        CheckBox *restart_replay_on_save = nullptr;
         Label *estimated_file_size_ptr = nullptr;
         CheckBox *show_replay_started_notification_checkbox_ptr = nullptr;
         CheckBox *show_replay_stopped_notification_checkbox_ptr = nullptr;

meson.build

@@ -1,4 +1,4 @@
-project('gsr-ui', ['c', 'cpp'], version : '1.1.0', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
+project('gsr-ui', ['c', 'cpp'], version : '1.1.4', default_options : ['warning_level=2', 'cpp_std=c++17'], subproject_dir : 'depends')
 
 if get_option('buildtype') == 'debug'
     add_project_arguments('-g3', language : ['c', 'cpp'])
@@ -52,7 +52,7 @@ datadir = get_option('datadir')
 gsr_ui_resources_path = join_paths(prefix, datadir, 'gsr-ui')
 
 add_project_arguments('-DGSR_UI_VERSION="' + meson.project_version() + '"', language: ['c', 'cpp'])
-add_project_arguments('-DGSR_FLATPAK_VERSION="5.1.0"', language: ['c', 'cpp'])
+add_project_arguments('-DGSR_FLATPAK_VERSION="5.1.2"', language: ['c', 'cpp'])
 
 executable(
     meson.project_name(),

project.conf

@@ -1,7 +1,7 @@
 [package]
 name = "gsr-ui"
 type = "executable"
-version = "1.1.0"
+version = "1.1.4"
 platforms = ["posix"]
 
 [lang.cpp]

src/Config.cpp

@@ -6,7 +6,6 @@
 #include <limits.h>
 #include <inttypes.h>
 #include <libgen.h>
-#include <iostream>
 #include <mglpp/window/Keyboard.hpp>
 
 #define FORMAT_I32 "%" PRIi32
@@ -149,6 +148,7 @@ namespace gsr {
             {"replay.record_options.restore_portal_session", &config.replay_config.record_options.restore_portal_session},
             {"replay.turn_on_replay_automatically_mode", &config.replay_config.turn_on_replay_automatically_mode},
             {"replay.save_video_in_game_folder", &config.replay_config.save_video_in_game_folder},
+            {"replay.restart_replay_on_save", &config.replay_config.restart_replay_on_save},
             {"replay.show_replay_started_notifications", &config.replay_config.show_replay_started_notifications},
             {"replay.show_replay_stopped_notifications", &config.replay_config.show_replay_stopped_notifications},
             {"replay.show_replay_saved_notifications", &config.replay_config.show_replay_saved_notifications},

src/GlobalHotkeysJoystick.cpp

@@ -84,6 +84,8 @@ namespace gsr {
     }
 
     bool GlobalHotkeysJoystick::bind_action(const std::string &id, GlobalHotkeyCallback callback) {
+        if(num_poll_fd == 0)
+            return false;
         return bound_actions_by_id.insert(std::make_pair(id, std::move(callback))).second;
     }
 

src/GlobalHotkeysLinux.cpp

@@ -166,6 +166,9 @@ namespace gsr {
     }
 
     bool GlobalHotkeysLinux::bind_key_press(Hotkey hotkey, const std::string &id, GlobalHotkeyCallback callback) {
+        if(process_id <= 0)
+            return false;
+
         if(bound_actions_by_id.find(id) != bound_actions_by_id.end())
             return false;
 
@@ -202,6 +205,9 @@ namespace gsr {
     }
 
     void GlobalHotkeysLinux::unbind_all_keys() {
+        if(process_id <= 0)
+            return;
+
         if(bound_actions_by_id.empty())
             return;
 

src/GsrInfo.cpp

@@ -6,6 +6,93 @@
 #include <string.h>
 
 namespace gsr {
+    bool GsrVersion::operator>(const GsrVersion &other) const {
+        return major > other.major || (major == other.major && minor > other.minor) || (major == other.major && minor == other.minor && patch > other.patch);
+    }
+
+    bool GsrVersion::operator>=(const GsrVersion &other) const {
+        return major >= other.major || (major == other.major && minor >= other.minor) || (major == other.major && minor == other.minor && patch >= other.patch);
+    }
+
+    bool GsrVersion::operator<(const GsrVersion &other) const {
+        return !operator>=(other);
+    }
+
+    bool GsrVersion::operator<=(const GsrVersion &other) const {
+        return !operator>(other);
+    }
+
+    bool GsrVersion::operator==(const GsrVersion &other) const {
+        return major == other.major && minor == other.minor && patch == other.patch;
+    }
+
+    bool GsrVersion::operator!=(const GsrVersion &other) const {
+        return !operator==(other);
+    }
+
+    std::string GsrVersion::to_string() const {
+        std::string result;
+        if(major == 0 && minor == 0 && patch == 0)
+            result = "Unknown";
+        else
+            result = std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(patch);
+        return result;
+    }
+
+    /* Returns -1 on error */
+    static int parse_u8(const char *str, int size) {
+        if(size <= 0)
+            return -1;
+
+        int result = 0;
+        for(int i = 0; i < size; ++i) {
+            char c = str[i];
+            if(c >= '0' && c <= '9') {
+                result = result * 10 + (c - '0');
+                if(result > 255)
+                    return -1;
+            } else {
+                return -1;
+            }
+        }
+        return result;
+    }
+
+    static GsrVersion parse_gsr_version(const std::string_view str) {
+        GsrVersion result;
+        uint8_t numbers[3];
+        int number_index = 0;
+
+        size_t index = 0;
+        while(true) {
+            size_t next_index = str.find('.', index);
+            if(next_index == std::string::npos)
+                next_index = str.size();
+
+            const int number = parse_u8(str.data() + index, next_index - index);
+            if(number == -1) {
+                fprintf(stderr, "Error: gpu-screen-recorder --info contains invalid gsr version: %.*s\n", (int)str.size(), str.data());
+                return {0, 0, 0};
+            }
+
+            if(number_index >= 3) {
+                fprintf(stderr, "Error: gpu-screen-recorder --info contains invalid gsr version: %.*s\n", (int)str.size(), str.data());
+                return {0, 0, 0};
+            }
+
+            numbers[number_index] = number;
+            ++number_index;
+            index = next_index + 1;
+            if(next_index == str.size())
+                break;
+        }
+
+        result.major = numbers[0];
+        result.minor = numbers[1];
+        result.patch = numbers[2];
+        return result;
+    }
+
     static std::optional<KeyValue> parse_key_value(std::string_view line) {
         const size_t space_index = line.find('|');
         if(space_index == std::string_view::npos)
@@ -25,6 +112,8 @@ namespace gsr {
                 gsr_info->system_info.display_server = DisplayServer::WAYLAND;
         } else if(key_value->key == "supports_app_audio") {
             gsr_info->system_info.supports_app_audio = key_value->value == "yes";
+        } else if(key_value->key == "gsr_version") {
+            gsr_info->system_info.gsr_version = parse_gsr_version(key_value->value);
         }
     }
 

src/Overlay.cpp

@@ -1866,6 +1866,11 @@ namespace gsr {
             "-o", output_directory.c_str()
         };
 
+        if(config.replay_config.restart_replay_on_save && gsr_info.system_info.gsr_version >= GsrVersion{5, 0, 3}) {
+            args.push_back("-restart-replay-on-save");
+            args.push_back("yes");
+        }
+
         add_common_gpu_screen_recorder_args(args, config.replay_config.record_options, audio_tracks, video_bitrate, region, audio_tracks_merged);
 
         args.push_back(nullptr);

src/gui/DropdownButton.cpp

@@ -20,7 +20,7 @@ namespace gsr {
     {
         if(icon_texture && icon_texture->is_valid()) {
             icon_sprite.set_texture(icon_texture);
-            icon_sprite.set_height((int)(size.y * 0.5f));
+            icon_sprite.set_height((int)(size.y * 0.45f));
         }
         this->description.set_color(mgl::Color(150, 150, 150));
     }
@@ -242,4 +242,4 @@ namespace gsr {
         update_if_dirty();
         return size;
     }
-}
+}

src/gui/GlobalSettingsPage.cpp

@@ -24,11 +24,11 @@ extern "C" {
 #include <mglpp/graphics/Text.hpp>
 
 #ifndef GSR_UI_VERSION
-#define GSR_UI_VERSION "unknown"
+#define GSR_UI_VERSION "Unknown"
 #endif
 
 #ifndef GSR_FLATPAK_VERSION
-#define GSR_FLATPAK_VERSION "unknown"
+#define GSR_FLATPAK_VERSION "Unknown"
 #endif
 
 namespace gsr {
@@ -132,7 +132,7 @@ namespace gsr {
             if(!configure_hotkey_button)
                 return;
 
-            mgl::Text title_text("Press a key combination to use for the hotkey \"Start/stop recording\":", get_theme().title_font);
+            mgl::Text title_text("Press a key combination to use for the hotkey \"" + hotkey_configure_action_name + "\":", get_theme().title_font);
             mgl::Text hotkey_text(configure_hotkey_button->get_text(), get_theme().top_bar_font);
             mgl::Text description_text("The hotkey has to contain one or more of these keys: Alt, Ctrl, Shift and Super. Press Esc to cancel.", get_theme().body_font);
             const float text_max_width = std::max(title_text.get_bounds().size.x, std::max(hotkey_text.get_bounds().size.x, description_text.get_bounds().size.x));
@@ -153,11 +153,14 @@ namespace gsr {
             title_text.set_position(mgl::vec2f(bg_rect.get_position() + mgl::vec2f(bg_rect.get_size().x*0.5f - title_text.get_bounds().size.x*0.5f, padding_vertical)).floor());
             window.draw(title_text);
 
-            //const float description_bottom = description_text.get_position().y + description_text.get_bounds().size.y;
-            //const float remaining_height = (bg_rect.get_position().y + bg_rect.get_size().y) - description_bottom;
             hotkey_text.set_position(mgl::vec2f(bg_rect.get_position() + bg_rect.get_size()*0.5f - hotkey_text.get_bounds().size*0.5f).floor());
             window.draw(hotkey_text);
 
+            const float caret_padding_x = int(0.001f * get_theme().window_height);
+            const mgl::vec2f caret_size = mgl::vec2f(std::max(2.0f, 0.002f * get_theme().window_height), hotkey_text.get_bounds().size.y).floor();
+            mgl::Rectangle caret_rect(hotkey_text.get_position() + mgl::vec2f(hotkey_text.get_bounds().size.x + caret_padding_x, hotkey_text.get_bounds().size.y*0.5f - caret_size.y*0.5f).floor(), caret_size);
+            window.draw(caret_rect);
+
             description_text.set_position(mgl::vec2f(bg_rect.get_position() + mgl::vec2f(bg_rect.get_size().x*0.5f - description_text.get_bounds().size.x*0.5f, bg_rect.get_size().y - description_text.get_bounds().size.y - padding_vertical)).floor());
             window.draw(description_text);
         };
@@ -253,7 +256,6 @@ namespace gsr {
             configure_hotkey_start(ConfigureHotkeyType::SHOW_HIDE);
         };
 
-
         return list;
     }
 
@@ -403,7 +405,11 @@ namespace gsr {
         auto list = std::make_unique<List>(List::Orientation::VERTICAL);
 
         char str[128];
-        snprintf(str, sizeof(str), "UI version: %s", GSR_UI_VERSION);
+        const std::string gsr_version = gsr_info->system_info.gsr_version.to_string();
+        snprintf(str, sizeof(str), "GSR version: %s", gsr_version.c_str());
+        list->add_widget(std::make_unique<Label>(&get_theme().body_font, str, get_color_theme().text_color));
+
+        snprintf(str, sizeof(str), "GSR-UI version: %s", GSR_UI_VERSION);
         list->add_widget(std::make_unique<Label>(&get_theme().body_font, str, get_color_theme().text_color));
 
         if(inside_flatpak) {
@@ -577,6 +583,31 @@ namespace gsr {
         content_page_ptr->set_visible(false);
         hotkey_overlay_ptr->set_visible(true);
         overlay->unbind_all_keyboard_hotkeys();
+        configure_hotkey_get_button_by_active_type()->set_text("");
+
+        switch(hotkey_type) {
+            case ConfigureHotkeyType::NONE:
+                hotkey_configure_action_name = "";
+                break;
+            case ConfigureHotkeyType::REPLAY_START_STOP:
+                hotkey_configure_action_name = "Turn replay on/off";
+                break;
+            case ConfigureHotkeyType::REPLAY_SAVE:
+                hotkey_configure_action_name = "Save replay";
+                break;
+            case ConfigureHotkeyType::RECORD_START_STOP:
+                hotkey_configure_action_name = "Start/stop recording";
+                break;
+            case ConfigureHotkeyType::RECORD_PAUSE_UNPAUSE:
+                hotkey_configure_action_name = "Pause/unpause recording";
+                break;
+            case ConfigureHotkeyType::STREAM_START_STOP:
+                hotkey_configure_action_name = "Start/stop streaming";
+                break;
+            case ConfigureHotkeyType::SHOW_HIDE:
+                hotkey_configure_action_name = "Show/hide UI";
+                break;
+        }
     }
 
     void GlobalSettingsPage::configure_hotkey_cancel() {
@@ -619,4 +650,4 @@ namespace gsr {
         hotkey_overlay_ptr->set_visible(false);
         overlay->rebind_all_keyboard_hotkeys();
     }
-}
+}

src/gui/SettingsPage.cpp

@@ -664,6 +664,12 @@ namespace gsr {
         return checkbox;
     }
 
+    std::unique_ptr<CheckBox> SettingsPage::create_restart_replay_on_save() {
+        auto checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Restart replay on save");
+        restart_replay_on_save = checkbox.get();
+        return checkbox;
+    }
+
     std::unique_ptr<Label> SettingsPage::create_estimated_replay_file_size() {
         auto label = std::make_unique<Label>(&get_theme().body_font, "Estimated video max file size in RAM: 57.60MB", get_color_theme().text_color);
         estimated_file_size_ptr = label.get();
@@ -693,6 +699,8 @@ namespace gsr {
         auto general_list = std::make_unique<List>(List::Orientation::VERTICAL);
         general_list->add_widget(create_start_replay_automatically());
         general_list->add_widget(create_save_replay_in_game_folder());
+        if(gsr_info->system_info.gsr_version >= GsrVersion{5, 0, 3})
+            general_list->add_widget(create_restart_replay_on_save());
         settings_list_ptr->add_widget(std::make_unique<Subsection>("General", std::move(general_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
 
         auto checkboxes_list = std::make_unique<List>(List::Orientation::VERTICAL);
@@ -1065,6 +1073,8 @@ namespace gsr {
         load_common(config.replay_config.record_options);
         turn_on_replay_automatically_mode_ptr->set_selected_item(config.replay_config.turn_on_replay_automatically_mode);
         save_replay_in_game_folder_ptr->set_checked(config.replay_config.save_video_in_game_folder);
+        if(restart_replay_on_save)
+            restart_replay_on_save->set_checked(config.replay_config.restart_replay_on_save);
         show_replay_started_notification_checkbox_ptr->set_checked(config.replay_config.show_replay_started_notifications);
         show_replay_stopped_notification_checkbox_ptr->set_checked(config.replay_config.show_replay_stopped_notifications);
         show_replay_saved_notification_checkbox_ptr->set_checked(config.replay_config.show_replay_saved_notifications);
@@ -1193,6 +1203,8 @@ namespace gsr {
         save_common(config.replay_config.record_options);
         config.replay_config.turn_on_replay_automatically_mode = turn_on_replay_automatically_mode_ptr->get_selected_id();
         config.replay_config.save_video_in_game_folder = save_replay_in_game_folder_ptr->is_checked();
+        if(restart_replay_on_save)
+            config.replay_config.restart_replay_on_save = restart_replay_on_save->is_checked();
         config.replay_config.show_replay_started_notifications = show_replay_started_notification_checkbox_ptr->is_checked();
         config.replay_config.show_replay_stopped_notifications = show_replay_stopped_notification_checkbox_ptr->is_checked();
         config.replay_config.show_replay_saved_notifications = show_replay_saved_notification_checkbox_ptr->is_checked();

tools/gsr-global-hotkeys/keyboard_event.c

@@ -81,19 +81,19 @@ static void keyboard_event_fetch_update_key_states(keyboard_event *self, event_e
     }
 }
 
-static void keyboard_event_process_key_state_change(keyboard_event *self, struct input_event event, event_extra_data *extra_data, int fd) {
+static void keyboard_event_process_key_state_change(keyboard_event *self, const struct input_event *event, event_extra_data *extra_data, int fd) {
-    if(event.type != EV_KEY)
+    if(event->type != EV_KEY)
         return;
 
-    if(!extra_data->key_states || event.code >= KEY_STATES_SIZE * 8)
+    if(!extra_data->key_states || event->code >= KEY_STATES_SIZE * 8)
         return;
 
-    const unsigned int byte_index = event.code / 8;
+    const unsigned int byte_index = event->code / 8;
-    const unsigned char bit_index = event.code % 8;
+    const unsigned char bit_index = event->code % 8;
     unsigned char key_byte_state = extra_data->key_states[byte_index];
     const bool prev_key_pressed = (key_byte_state & (1 << bit_index)) != KEY_RELEASE;
 
-    if(event.value == KEY_RELEASE) {
+    if(event->value == KEY_RELEASE) {
         key_byte_state &= ~(1 << bit_index);
         if(prev_key_pressed)
             --extra_data->num_keys_pressed;
@@ -154,6 +154,12 @@ static uint32_t keycode_to_modifier_bit(uint32_t keycode) {
     return 0;
 }
 
+static bool key_is_mouse_button(uint32_t keycode) {
+    return (keycode >= BTN_MISC && keycode <= BTN_GEAR_UP)
+        || (keycode >= BTN_TRIGGER_HAPPY && keycode <= BTN_TRIGGER_HAPPY40)
+        || (keycode >= BTN_DPAD_UP && keycode <= BTN_DPAD_RIGHT);
+}
+
 static void keyboard_event_process_input_event_data(keyboard_event *self, event_extra_data *extra_data, int fd) {
     struct input_event event;
     if(read(fd, &event, sizeof(event)) != sizeof(event)) {
@@ -171,8 +177,8 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
         //fprintf(stderr, "fd: %d, type: %d, pressed %d, value: %d\n", fd, event.type, event.code, event.value);
     //}
 
-    if(event.type == EV_KEY) {
+    if(event.type == EV_KEY && !key_is_mouse_button(event.code)) {
-        keyboard_event_process_key_state_change(self, event, extra_data, fd);
+        keyboard_event_process_key_state_change(self, &event, extra_data, fd);
         const uint32_t modifier_bit = keycode_to_modifier_bit(event.code);
         if(modifier_bit == 0) {
             if(keyboard_event_on_key_pressed(self, &event, self->modifier_button_states))
@@ -286,7 +292,7 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
 
     unsigned long evbit = 0;
     ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), &evbit);
-    const bool is_keyboard = evbit & (1 << EV_KEY);
+    const bool is_keyboard = (evbit & (1 << EV_SYN)) && (evbit & (1 << EV_KEY)) && (evbit & (1 << EV_MSC)) && (evbit & (1 << EV_REP));
 
     if(is_keyboard && strcmp(device_name, GSR_UI_VIRTUAL_KEYBOARD_NAME) != 0) {
         unsigned char key_bits[KEY_MAX/8 + 1] = {0};
@@ -297,7 +303,7 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
         //const bool supports_touch_events    = key_bits[BTN_TOUCH/8]    & (1 << (BTN_TOUCH % 8));
         const bool supports_joystick_events = key_bits[BTN_JOYSTICK/8] & (1 << (BTN_JOYSTICK % 8));
         const bool supports_wheel_events    = key_bits[BTN_WHEEL/8]    & (1 << (BTN_WHEEL % 8));
-        if(supports_key_events && !supports_mouse_events && !supports_joystick_events && !supports_wheel_events) {
+        if(supports_key_events && !supports_joystick_events && !supports_wheel_events) {
             unsigned char *key_states = calloc(1, KEY_STATES_SIZE);
             if(key_states && self->num_event_polls < MAX_EVENT_POLLS) {
                 //fprintf(stderr, "%s (%s) supports key inputs\n", dev_input_filepath, device_name);
@@ -314,9 +320,16 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
                     .num_keys_pressed = 0
                 };
 
-                keyboard_event_fetch_update_key_states(self, &self->event_extra_data[self->num_event_polls], fd);
+                if(supports_mouse_events) {
-                if(self->event_extra_data[self->num_event_polls].num_keys_pressed > 0)
+                    fprintf(stderr, "Info: device not grabbed yet because it might be a mouse: /dev/input/event%d\n", dev_input_id);
-                    fprintf(stderr, "Info: device not grabbed yet because some keys are still being pressed: /dev/input/event%d\n", dev_input_id);
+                    fsync(fd);
+                    if(ioctl(fd, EVIOCGKEY(KEY_STATES_SIZE), self->event_extra_data[self->num_event_polls].key_states) == -1)
+                        fprintf(stderr, "Warning: failed to fetch key states for device: /dev/input/event%d\n", dev_input_id);
+                } else {
+                    keyboard_event_fetch_update_key_states(self, &self->event_extra_data[self->num_event_polls], fd);
+                    if(self->event_extra_data[self->num_event_polls].num_keys_pressed > 0)
+                        fprintf(stderr, "Info: device not grabbed yet because some keys are still being pressed: /dev/input/event%d\n", dev_input_id);
+                }
 
                 ++self->num_event_polls;
                 return true;
@@ -389,14 +402,20 @@ static int setup_virtual_keyboard_input(const char *name) {
     success &= (ioctl(fd, UI_SET_EVBIT, EV_SYN) != -1);
     success &= (ioctl(fd, UI_SET_EVBIT, EV_MSC) != -1);
     success &= (ioctl(fd, UI_SET_EVBIT, EV_KEY) != -1);
+    success &= (ioctl(fd, UI_SET_EVBIT, EV_REP) != -1);
+    success &= (ioctl(fd, UI_SET_EVBIT, EV_REL) != -1);
+    success &= (ioctl(fd, UI_SET_EVBIT, EV_LED) != -1);
+
+    success &= (ioctl(fd, UI_SET_MSCBIT, MSC_SCAN) != -1);
     for(int i = 1; i < KEY_MAX; ++i) {
         success &= (ioctl(fd, UI_SET_KEYBIT, i) != -1);
     }
-
+    for(int i = 0; i < REL_MAX; ++i) {
-    success &= (ioctl(fd, UI_SET_EVBIT, EV_REL) != -1);
+        success &= (ioctl(fd, UI_SET_RELBIT, i) != -1);
-    success &= (ioctl(fd, UI_SET_RELBIT, REL_X) != -1);
+    }
-    success &= (ioctl(fd, UI_SET_RELBIT, REL_Y) != -1);
+    for(int i = 0; i < LED_MAX; ++i) {
-    success &= (ioctl(fd, UI_SET_RELBIT, REL_Z) != -1);
+        success &= (ioctl(fd, UI_SET_LEDBIT, i) != -1);
+    }
 
     // success &= (ioctl(fd, UI_SET_EVBIT, EV_ABS) != -1);
     // success &= (ioctl(fd, UI_SET_ABSBIT, ABS_X) != -1);
@@ -638,13 +657,13 @@ static void keyboard_event_parse_stdin_command(keyboard_event *self, const char
             .modifiers = modifiers
         };
         ++self->num_global_hotkeys;
-        fprintf(stderr, "Info: bound hotkey: %s\n", action);
+        fprintf(stderr, "Info: binded hotkey: %s\n", action);
     } else if(strncmp(command, "unbind_all", 10) == 0) {
         for(int i = 0; i < self->num_global_hotkeys; ++i) {
             free(self->global_hotkeys[i].action);
         }
         self->num_global_hotkeys = 0;
-        fprintf(stderr, "Info: unbound all hotkeys\n");
+        fprintf(stderr, "Info: unbinded all hotkeys\n");
     } else {
         fprintf(stderr, "Warning: got invalid command: \"%s\", expected command to start with either \"bind\" or \"unbind_all\"\n", command);
     }