Global hotkeys

.gitmodules

@@ -16,3 +16,6 @@
 [submodule "subprojects/qrcodegen"]
 	path = subprojects/qrcodegen
 	url = https://github.com/nayuki/QR-Code-generator
+[submodule "subprojects/libuiohook"]
+	path = subprojects/libuiohook
+	url = https://github.com/kwhat/libuiohook

CMakeLists.txt

@@ -113,6 +113,15 @@ endif ()
 find_package(spdlog REQUIRED)
 target_link_libraries(abaddon spdlog::spdlog)
 
+find_package(uiohook QUIET)
+if (NOT uiohook_FOUND)
+    message("uiohook was not found and will be included as a submodule")
+    add_subdirectory(subprojects/libuiohook)
+    target_link_libraries(abaddon uiohook)
+else ()
+    target_link_libraries(abaddon uiohook)
+endif ()
+
 target_link_libraries(abaddon ${SQLite3_LIBRARIES})
 target_link_libraries(abaddon ${GTKMM_LIBRARIES})
 target_link_libraries(abaddon ${ZLIB_LIBRARY})

README.md

@@ -35,6 +35,7 @@ Current features:
 * Emojis<sup>2</sup>
 * Thread support<sup>3</sup>
 * Animated avatars, server icons, emojis (can be turned off)
+* Global hotkeys support
 
 1 - Abaddon tries its best (though is not perfect) to make Discord think it's a legitimate web client. Some of the
 things done to do this
@@ -173,6 +174,7 @@ spam filter's wrath:
 * [libopus](https://opus-codec.org/) (optional, required for voice)
 * [libsodium](https://doc.libsodium.org/) (optional, required for voice)
 * [rnnoise](https://gitlab.xiph.org/xiph/rnnoise) (optional, provided as submodule, noise suppression and improved VAD)
+* [libuiohook](https://github.com/kwhat/libuiohook) (provided as submodule, global hotkeys)
 
 ### TODO:
 

cmake/Finduiohook.cmake

@@ -0,0 +1,46 @@
+function(add_imported_library library headers)
+    add_library(uiohook::uiohook UNKNOWN IMPORTED)
+    set_target_properties(uiohook::uiohook PROPERTIES
+        IMPORTED_LOCATION "${library}"
+        INTERFACE_INCLUDE_DIRECTORIES "${headers}"
+    )
+
+    set(uiohook_FOUND 1 CACHE INTERNAL "uiohook found" FORCE)
+    set(uiohook_LIBRARIES "${library}" CACHE STRING "Path to uiohook library" FORCE)
+    set(uiohook_INCLUDES "${headers}" CACHE STRING "Path to uiohook headers" FORCE)
+    mark_as_advanced(FORCE uiohook_LIBRARIES)
+    mark_as_advanced(FORCE uiohook_INCLUDES)
+endfunction()
+
+if(uiohook_LIBRARIES AND uiohook_INCLUDES)
+    add_imported_library(${uiohook_LIBRARIES} ${uiohook_INCLUDES})
+    return()
+endif()
+
+set(_uiohook_DIR "${CMAKE_CURRENT_SOURCE_DIR}/subprojects/libuiohook")
+
+find_library(uiohook_LIBRARY_PATH
+    NAMES libuiohook uiohook
+    PATHS
+        "${_uiohook_DIR}/lib"
+        /usr/lib
+)
+
+find_path(uiohook_HEADER_PATH
+    NAMES uiohook.h
+    PATHS
+        "${_uiohook_DIR}/include"
+        /usr/include
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+    uiohook DEFAULT_MSG uiohook_LIBRARY_PATH uiohook_HEADER_PATH
+)
+
+if(uiohook_FOUND)
+    add_imported_library(
+        "${uiohook_LIBRARY_PATH}"
+        "${uiohook_HEADER_PATH}"
+    )
+endif()

src/misc/GlobalHotkeyManager.cpp

@@ -0,0 +1,74 @@
+#include "GlobalHotkeyManager.hpp"
+#include <iostream>
+
+// Singleton instance
+GlobalHotkeyManager& GlobalHotkeyManager::instance() {
+    static GlobalHotkeyManager instance;
+    return instance;
+}
+
+GlobalHotkeyManager::GlobalHotkeyManager() : m_nextId(1) {
+    hook_set_dispatch_proc(&GlobalHotkeyManager::hook_callback);
+
+    // Run hook in separate thread to not block gtk
+    std::thread([this]() {
+        if (hook_run() != UIOHOOK_SUCCESS) {
+            std::cerr << "Failed to start libuiohook" << std::endl;
+        }
+    }).detach();
+}
+
+GlobalHotkeyManager::~GlobalHotkeyManager()
+{
+    hook_stop();
+}
+
+struct GlobalHotkeyManager::Hotkey {
+    uint16_t keycode;
+    uint32_t modifiers;
+    HotkeyCallback callback;
+};
+
+int GlobalHotkeyManager::registerHotkey(uint16_t keycode, uint32_t modifiers, HotkeyCallback callback) {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    int id = m_nextId++;
+    m_callbacks[id] = {
+        .keycode = keycode,
+        .modifiers = modifiers,
+        .callback = callback
+    };
+
+    return id;
+}
+
+GlobalHotkeyManager::Hotkey* GlobalHotkeyManager::find_hotkey(uint16_t keycode, uint32_t modifiers) {
+    auto it = std::find_if(m_callbacks.begin(), m_callbacks.end(),
+        [keycode, modifiers](const auto& pair) {
+            return pair.second.keycode == keycode && (modifiers & pair.second.modifiers);
+        });
+
+    if (it != m_callbacks.end()) {
+        return &it->second;
+    }
+
+    return nullptr;
+}
+
+void GlobalHotkeyManager::unregisterHotkey(int id) {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_callbacks.erase(id);
+}
+
+void GlobalHotkeyManager::hook_callback(uiohook_event* const event) {
+    GlobalHotkeyManager::instance().handleEvent(event);
+}
+
+void GlobalHotkeyManager::handleEvent(uiohook_event* const event) {
+    if (event->type == EVENT_KEY_PRESSED) {
+        Hotkey *hk = find_hotkey(event->data.keyboard.keycode, event->mask);
+        if (hk != nullptr) {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            hk->callback();
+        }
+    }
+}

src/misc/GlobalHotkeyManager.hpp

@@ -0,0 +1,40 @@
+#ifndef GLOBALHOTKEYMANAGER_H
+#define GLOBALHOTKEYMANAGER_H
+
+#pragma once
+
+#include <map>
+#include <functional>
+#include <mutex>
+#include "uiohook.h"
+
+// hotkey callback type
+using HotkeyCallback = std::function<void(void)>;
+
+class GlobalHotkeyManager
+{
+public:
+    static GlobalHotkeyManager& instance();
+    int registerHotkey(uint16_t keycode, uint32_t modifiers, HotkeyCallback callback);
+    void unregisterHotkey(int id);
+
+private:
+    GlobalHotkeyManager();
+    ~GlobalHotkeyManager();
+
+    // no copy/move
+    GlobalHotkeyManager(const GlobalHotkeyManager&) = delete;
+    GlobalHotkeyManager& operator=(const GlobalHotkeyManager&) = delete;
+
+    struct Hotkey;
+    Hotkey* find_hotkey(uint16_t keycode, uint32_t modifiers);
+
+    static void hook_callback(uiohook_event* const event);
+    void handleEvent(uiohook_event* const event);
+
+    std::mutex m_mutex;
+    std::map<int, Hotkey> m_callbacks;
+    int m_nextId;
+};
+
+#endif

src/windows/voice/voicewindow.cpp

@@ -1,3 +1,5 @@
+#include "misc/GlobalHotkeyManager.hpp"
+#include "uiohook.h"
 #include "util.hpp"
 #ifdef WITH_VOICE
 
@@ -11,6 +13,7 @@
 #include "voicewindowaudiencelistentry.hpp"
 #include "voicewindowspeakerlistentry.hpp"
 #include "windows/voicesettingswindow.hpp"
+#include "misc/GlobalHotkeyManager.hpp"
 
 // clang-format on
 
@@ -54,6 +57,16 @@ VoiceWindow::VoiceWindow(Snowflake channel_id)
     m_mute.signal_toggled().connect(sigc::mem_fun(*this, &VoiceWindow::OnMuteChanged));
     m_deafen.signal_toggled().connect(sigc::mem_fun(*this, &VoiceWindow::OnDeafenChanged));
 
+    // TODO: Load shortcuts from config file
+    m_mute_hotkey = GlobalHotkeyManager::instance().registerHotkey(VC_M, MASK_ALT, [this]() {
+        // This is probably stupid there is for sure some way to call event
+        // but I'm not really familiar with gtk and this works well.
+        m_mute.set_active( !m_mute.get_active() );
+    });
+    m_deafen_hotkey = GlobalHotkeyManager::instance().registerHotkey(VC_D, MASK_ALT, [this]() {
+        m_deafen.set_active( !m_deafen.get_active() );
+    });
+
     m_scroll.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
     m_scroll.set_hexpand(true);
     m_scroll.set_vexpand(true);
@@ -271,6 +284,11 @@ VoiceWindow::VoiceWindow(Snowflake channel_id)
     UpdateStageCommand();
 }
 
+VoiceWindow::~VoiceWindow() {
+    GlobalHotkeyManager::instance().unregisterHotkey(m_mute_hotkey);
+    GlobalHotkeyManager::instance().unregisterHotkey(m_deafen_hotkey);
+}
+
 void VoiceWindow::SetUsers(const std::unordered_set<Snowflake> &user_ids) {
     auto &discord = Abaddon::Get().GetDiscordClient();
     const auto me = discord.GetUserData().ID;

src/windows/voice/voicewindow.hpp

@@ -21,6 +21,7 @@
 class VoiceWindow : public Gtk::Window {
 public:
     VoiceWindow(Snowflake channel_id);
+    ~VoiceWindow();
 
 private:
     void SetUsers(const std::unordered_set<Snowflake> &user_ids);
@@ -49,7 +50,9 @@ class VoiceWindow : public Gtk::Window {
     Gtk::Box m_controls;
 
     Gtk::CheckButton m_mute;
+    int m_mute_hotkey;
     Gtk::CheckButton m_deafen;
+    int m_deafen_hotkey;
 
     Gtk::ScrolledWindow m_scroll;
     Gtk::VBox m_listing;