windowpp 0.1.1

package/framework/src/Input/Linux/linux_key_utils.h

@@ -0,0 +1,135 @@
+#pragma once
+
+#if defined(__linux__)
+
+#include <X11/keysym.h>
+#include <xcb/xcb.h>
+#include <xcb/xcb_keysyms.h>
+
+#include <string>
+
+#include <windowpp/windowpp.h>
+
+namespace wpp::input::linux {
+
+inline Key key_from_keysym(xcb_keysym_t keysym) {
+    switch (keysym) {
+        case XK_a: case XK_A: return Key::A;
+        case XK_b: case XK_B: return Key::B;
+        case XK_c: case XK_C: return Key::C;
+        case XK_d: case XK_D: return Key::D;
+        case XK_e: case XK_E: return Key::E;
+        case XK_f: case XK_F: return Key::F;
+        case XK_g: case XK_G: return Key::G;
+        case XK_h: case XK_H: return Key::H;
+        case XK_i: case XK_I: return Key::I;
+        case XK_j: case XK_J: return Key::J;
+        case XK_k: case XK_K: return Key::K;
+        case XK_l: case XK_L: return Key::L;
+        case XK_m: case XK_M: return Key::M;
+        case XK_n: case XK_N: return Key::N;
+        case XK_o: case XK_O: return Key::O;
+        case XK_p: case XK_P: return Key::P;
+        case XK_q: case XK_Q: return Key::Q;
+        case XK_r: case XK_R: return Key::R;
+        case XK_s: case XK_S: return Key::S;
+        case XK_t: case XK_T: return Key::T;
+        case XK_u: case XK_U: return Key::U;
+        case XK_v: case XK_V: return Key::V;
+        case XK_w: case XK_W: return Key::W;
+        case XK_x: case XK_X: return Key::X;
+        case XK_y: case XK_Y: return Key::Y;
+        case XK_z: case XK_Z: return Key::Z;
+        case XK_0: return Key::Digit0;
+        case XK_1: return Key::Digit1;
+        case XK_2: return Key::Digit2;
+        case XK_3: return Key::Digit3;
+        case XK_4: return Key::Digit4;
+        case XK_5: return Key::Digit5;
+        case XK_6: return Key::Digit6;
+        case XK_7: return Key::Digit7;
+        case XK_8: return Key::Digit8;
+        case XK_9: return Key::Digit9;
+        case XK_space: return Key::Space;
+        case XK_Return: return Key::Enter;
+        case XK_Escape: return Key::Escape;
+        case XK_Tab: return Key::Tab;
+        case XK_BackSpace: return Key::Backspace;
+        case XK_Delete: return Key::Delete;
+        case XK_Insert: return Key::Insert;
+        case XK_Home: return Key::Home;
+        case XK_End: return Key::End;
+        case XK_Page_Up: return Key::PageUp;
+        case XK_Page_Down: return Key::PageDown;
+        case XK_Left: return Key::Left;
+        case XK_Right: return Key::Right;
+        case XK_Up: return Key::Up;
+        case XK_Down: return Key::Down;
+        case XK_Caps_Lock: return Key::CapsLock;
+        case XK_Shift_L: case XK_Shift_R: return Key::Shift;
+        case XK_Control_L: case XK_Control_R: return Key::Control;
+        case XK_Alt_L: case XK_Alt_R: case XK_Meta_L: case XK_Meta_R: return Key::Alt;
+        case XK_Super_L: case XK_Super_R: case XK_Hyper_L: case XK_Hyper_R: return Key::Meta;
+        case XK_F1: return Key::F1;
+        case XK_F2: return Key::F2;
+        case XK_F3: return Key::F3;
+        case XK_F4: return Key::F4;
+        case XK_F5: return Key::F5;
+        case XK_F6: return Key::F6;
+        case XK_F7: return Key::F7;
+        case XK_F8: return Key::F8;
+        case XK_F9: return Key::F9;
+        case XK_F10: return Key::F10;
+        case XK_F11: return Key::F11;
+        case XK_F12: return Key::F12;
+        default: return Key::Unknown;
+    }
+}
+
+inline xcb_keysym_t keysym_from_event(xcb_connection_t* connection, uint8_t detail, uint16_t state) {
+    xcb_key_symbols_t* symbols = xcb_key_symbols_alloc(connection);
+    if (!symbols) {
+        return 0;
+    }
+    const int column = (state & XCB_MOD_MASK_SHIFT) ? 1 : 0;
+    const xcb_keysym_t keysym = xcb_key_symbols_get_keysym(symbols, detail, column);
+    xcb_key_symbols_free(symbols);
+    return keysym;
+}
+
+inline std::string key_name_from_keysym(xcb_keysym_t keysym) {
+    const auto key = key_from_keysym(keysym);
+    if (key != Key::Unknown) {
+        return key_to_string(key);
+    }
+    if (keysym >= 32 && keysym <= 126) {
+        return std::string(1, static_cast<char>(keysym));
+    }
+    return "Unknown";
+}
+
+inline KeyEvent make_key_event(xcb_connection_t* connection,
+                               const xcb_key_press_event_t* native_event,
+                               KeyEventType type,
+                               const std::string& window_id) {
+    const auto keysym = keysym_from_event(connection, native_event->detail, native_event->state);
+
+    KeyEvent event{};
+    event.key = key_from_keysym(keysym);
+    event.type = type;
+    event.keycode = native_event->detail;
+    event.scancode = native_event->detail;
+    event.key_name = key_name_from_keysym(keysym);
+    event.ctrl = (native_event->state & XCB_MOD_MASK_CONTROL) != 0;
+    event.shift = (native_event->state & XCB_MOD_MASK_SHIFT) != 0;
+    event.alt = (native_event->state & XCB_MOD_MASK_1) != 0;
+    event.meta = (native_event->state & XCB_MOD_MASK_4) != 0;
+    event.is_repeat = false;
+    event.is_global = false;
+    event.window_id = window_id;
+    return event;
+}
+
+} // namespace wpp::input::linux
+
+#endif

package/framework/src/Input/MacOS/macos_key_utils.h

@@ -0,0 +1,137 @@
+#pragma once
+
+#import <Cocoa/Cocoa.h>
+
+#include <string>
+
+#include <windowpp/windowpp.h>
+
+namespace wpp::input::macos {
+
+inline Key key_from_keycode(unsigned short keycode) {
+    switch (keycode) {
+        case 0: return Key::A;
+        case 11: return Key::B;
+        case 8: return Key::C;
+        case 2: return Key::D;
+        case 14: return Key::E;
+        case 3: return Key::F;
+        case 5: return Key::G;
+        case 4: return Key::H;
+        case 34: return Key::I;
+        case 38: return Key::J;
+        case 40: return Key::K;
+        case 37: return Key::L;
+        case 46: return Key::M;
+        case 45: return Key::N;
+        case 31: return Key::O;
+        case 35: return Key::P;
+        case 12: return Key::Q;
+        case 15: return Key::R;
+        case 1: return Key::S;
+        case 17: return Key::T;
+        case 32: return Key::U;
+        case 9: return Key::V;
+        case 13: return Key::W;
+        case 7: return Key::X;
+        case 16: return Key::Y;
+        case 6: return Key::Z;
+        case 29: return Key::Digit0;
+        case 18: return Key::Digit1;
+        case 19: return Key::Digit2;
+        case 20: return Key::Digit3;
+        case 21: return Key::Digit4;
+        case 23: return Key::Digit5;
+        case 22: return Key::Digit6;
+        case 26: return Key::Digit7;
+        case 28: return Key::Digit8;
+        case 25: return Key::Digit9;
+        case 49: return Key::Space;
+        case 36: return Key::Enter;
+        case 53: return Key::Escape;
+        case 48: return Key::Tab;
+        case 51: return Key::Backspace;
+        case 117: return Key::Delete;
+        case 114: return Key::Insert;
+        case 115: return Key::Home;
+        case 119: return Key::End;
+        case 116: return Key::PageUp;
+        case 121: return Key::PageDown;
+        case 123: return Key::Left;
+        case 124: return Key::Right;
+        case 126: return Key::Up;
+        case 125: return Key::Down;
+        case 57: return Key::CapsLock;
+        case 56: case 60: return Key::Shift;
+        case 59: case 62: return Key::Control;
+        case 58: case 61: return Key::Alt;
+        case 55: case 54: return Key::Meta;
+        case 122: return Key::F1;
+        case 120: return Key::F2;
+        case 99: return Key::F3;
+        case 118: return Key::F4;
+        case 96: return Key::F5;
+        case 97: return Key::F6;
+        case 98: return Key::F7;
+        case 100: return Key::F8;
+        case 101: return Key::F9;
+        case 109: return Key::F10;
+        case 103: return Key::F11;
+        case 111: return Key::F12;
+        default: return Key::Unknown;
+    }
+}
+
+inline std::string key_name_from_event(NSEvent* event, Key key) {
+    if (key != Key::Unknown) {
+        return key_to_string(key);
+    }
+
+    NSString* characters = [event charactersIgnoringModifiers];
+    if (characters && characters.length > 0) {
+        return std::string([[characters uppercaseString] UTF8String]);
+    }
+    return "Unknown";
+}
+
+inline bool modifier_active(NSEventModifierFlags flags, Key key) {
+    switch (key) {
+        case Key::Shift: return (flags & NSEventModifierFlagShift) != 0;
+        case Key::Control: return (flags & NSEventModifierFlagControl) != 0;
+        case Key::Alt: return (flags & NSEventModifierFlagOption) != 0;
+        case Key::Meta: return (flags & NSEventModifierFlagCommand) != 0;
+        default: return false;
+    }
+}
+
+inline KeyEvent make_key_event(NSEvent* native_event,
+                               const std::string& window_id,
+                               KeyEventType type) {
+    const auto key = key_from_keycode(native_event.keyCode);
+    const auto flags = native_event.modifierFlags;
+
+    KeyEvent event{};
+    event.key = key;
+    event.type = type;
+    event.keycode = native_event.keyCode;
+    event.scancode = native_event.keyCode;
+    event.key_name = key_name_from_event(native_event, key);
+    event.ctrl = (flags & NSEventModifierFlagControl) != 0;
+    event.shift = (flags & NSEventModifierFlagShift) != 0;
+    event.alt = (flags & NSEventModifierFlagOption) != 0;
+    event.meta = (flags & NSEventModifierFlagCommand) != 0;
+    event.is_repeat = native_event.isARepeat;
+    event.is_global = false;
+    event.window_id = window_id;
+    return event;
+}
+
+inline KeyEvent make_flags_changed_event(NSEvent* native_event,
+                                         const std::string& window_id) {
+    const auto key = key_from_keycode(native_event.keyCode);
+    const auto flags = native_event.modifierFlags;
+    const auto type = modifier_active(flags, key) ? KeyEventType::KeyDown : KeyEventType::KeyUp;
+    return make_key_event(native_event, window_id, type);
+}
+
+} // namespace wpp::input::macos

package/framework/src/Input/Windows/win32_key_utils.h

@@ -0,0 +1,199 @@
+#pragma once
+
+#include <windows.h>
+
+#include <string>
+
+#include <windowpp/windowpp.h>
+
+namespace wpp::input::win32 {
+
+inline Key key_from_virtual_key(UINT vk) {
+    if (vk >= 'A' && vk <= 'Z') {
+        return static_cast<Key>(static_cast<int>(Key::A) + static_cast<int>(vk - 'A'));
+    }
+    if (vk >= '0' && vk <= '9') {
+        return static_cast<Key>(static_cast<int>(Key::Digit0) + static_cast<int>(vk - '0'));
+    }
+
+    switch (vk) {
+        case VK_SPACE: return Key::Space;
+        case VK_RETURN: return Key::Enter;
+        case VK_ESCAPE: return Key::Escape;
+        case VK_TAB: return Key::Tab;
+        case VK_BACK: return Key::Backspace;
+        case VK_DELETE: return Key::Delete;
+        case VK_INSERT: return Key::Insert;
+        case VK_HOME: return Key::Home;
+        case VK_END: return Key::End;
+        case VK_PRIOR: return Key::PageUp;
+        case VK_NEXT: return Key::PageDown;
+        case VK_LEFT: return Key::Left;
+        case VK_RIGHT: return Key::Right;
+        case VK_UP: return Key::Up;
+        case VK_DOWN: return Key::Down;
+        case VK_CAPITAL: return Key::CapsLock;
+        case VK_SHIFT:
+        case VK_LSHIFT:
+        case VK_RSHIFT:
+            return Key::Shift;
+        case VK_CONTROL:
+        case VK_LCONTROL:
+        case VK_RCONTROL:
+            return Key::Control;
+        case VK_MENU:
+        case VK_LMENU:
+        case VK_RMENU:
+            return Key::Alt;
+        case VK_LWIN:
+        case VK_RWIN:
+            return Key::Meta;
+        case VK_F1: return Key::F1;
+        case VK_F2: return Key::F2;
+        case VK_F3: return Key::F3;
+        case VK_F4: return Key::F4;
+        case VK_F5: return Key::F5;
+        case VK_F6: return Key::F6;
+        case VK_F7: return Key::F7;
+        case VK_F8: return Key::F8;
+        case VK_F9: return Key::F9;
+        case VK_F10: return Key::F10;
+        case VK_F11: return Key::F11;
+        case VK_F12: return Key::F12;
+        default: return Key::Unknown;
+    }
+}
+
+inline UINT virtual_key_from_key(Key key) {
+    switch (key) {
+        case Key::A: return 'A';
+        case Key::B: return 'B';
+        case Key::C: return 'C';
+        case Key::D: return 'D';
+        case Key::E: return 'E';
+        case Key::F: return 'F';
+        case Key::G: return 'G';
+        case Key::H: return 'H';
+        case Key::I: return 'I';
+        case Key::J: return 'J';
+        case Key::K: return 'K';
+        case Key::L: return 'L';
+        case Key::M: return 'M';
+        case Key::N: return 'N';
+        case Key::O: return 'O';
+        case Key::P: return 'P';
+        case Key::Q: return 'Q';
+        case Key::R: return 'R';
+        case Key::S: return 'S';
+        case Key::T: return 'T';
+        case Key::U: return 'U';
+        case Key::V: return 'V';
+        case Key::W: return 'W';
+        case Key::X: return 'X';
+        case Key::Y: return 'Y';
+        case Key::Z: return 'Z';
+        case Key::Digit0: return '0';
+        case Key::Digit1: return '1';
+        case Key::Digit2: return '2';
+        case Key::Digit3: return '3';
+        case Key::Digit4: return '4';
+        case Key::Digit5: return '5';
+        case Key::Digit6: return '6';
+        case Key::Digit7: return '7';
+        case Key::Digit8: return '8';
+        case Key::Digit9: return '9';
+        case Key::Space: return VK_SPACE;
+        case Key::Enter: return VK_RETURN;
+        case Key::Escape: return VK_ESCAPE;
+        case Key::Tab: return VK_TAB;
+        case Key::Backspace: return VK_BACK;
+        case Key::Delete: return VK_DELETE;
+        case Key::Insert: return VK_INSERT;
+        case Key::Home: return VK_HOME;
+        case Key::End: return VK_END;
+        case Key::PageUp: return VK_PRIOR;
+        case Key::PageDown: return VK_NEXT;
+        case Key::Left: return VK_LEFT;
+        case Key::Right: return VK_RIGHT;
+        case Key::Up: return VK_UP;
+        case Key::Down: return VK_DOWN;
+        case Key::CapsLock: return VK_CAPITAL;
+        case Key::F1: return VK_F1;
+        case Key::F2: return VK_F2;
+        case Key::F3: return VK_F3;
+        case Key::F4: return VK_F4;
+        case Key::F5: return VK_F5;
+        case Key::F6: return VK_F6;
+        case Key::F7: return VK_F7;
+        case Key::F8: return VK_F8;
+        case Key::F9: return VK_F9;
+        case Key::F10: return VK_F10;
+        case Key::F11: return VK_F11;
+        case Key::F12: return VK_F12;
+        default: return 0;
+    }
+}
+
+inline std::string key_name_from_message(UINT vk, LPARAM lparam) {
+    if (const auto key = key_from_virtual_key(vk); key != Key::Unknown) {
+        return key_to_string(key);
+    }
+
+    LONG scan = static_cast<LONG>((lparam >> 16) & 0xFF);
+    if ((lparam & 0x01000000) != 0) {
+        scan |= 0x100;
+    }
+    wchar_t buffer[64] = {};
+    if (GetKeyNameTextW(scan << 16, buffer, static_cast<int>(std::size(buffer))) > 0) {
+        int needed = WideCharToMultiByte(CP_UTF8, 0, buffer, -1, nullptr, 0, nullptr, nullptr);
+        if (needed > 1) {
+            std::string utf8(static_cast<size_t>(needed - 1), '\0');
+            WideCharToMultiByte(CP_UTF8, 0, buffer, -1, utf8.data(), needed, nullptr, nullptr);
+            return utf8;
+        }
+    }
+    return "Unknown";
+}
+
+inline bool is_vk_down(int vk) {
+    return (GetAsyncKeyState(vk) & 0x8000) != 0;
+}
+
+inline bool modifier_down_for_event(Key key, KeyEventType type, bool current_state, Key modifier) {
+    if (key == modifier) {
+        return type == KeyEventType::KeyDown;
+    }
+    return current_state;
+}
+
+inline KeyEvent make_key_event(UINT msg, WPARAM wparam, LPARAM lparam, const std::string& window_id) {
+    KeyEvent event{};
+    event.key = key_from_virtual_key(static_cast<UINT>(wparam));
+    event.type = (msg == WM_KEYUP || msg == WM_SYSKEYUP) ? KeyEventType::KeyUp : KeyEventType::KeyDown;
+    event.keycode = static_cast<int>(wparam);
+    event.scancode = static_cast<uint32_t>((lparam >> 16) & 0xFF);
+    event.key_name = key_name_from_message(static_cast<UINT>(wparam), lparam);
+    event.ctrl = modifier_down_for_event(event.key, event.type, is_vk_down(VK_CONTROL), Key::Control);
+    event.shift = modifier_down_for_event(event.key, event.type, is_vk_down(VK_SHIFT), Key::Shift);
+    event.alt = modifier_down_for_event(event.key, event.type, is_vk_down(VK_MENU), Key::Alt);
+    event.meta = modifier_down_for_event(event.key, event.type, is_vk_down(VK_LWIN) || is_vk_down(VK_RWIN), Key::Meta);
+    event.is_repeat = (lparam & 0x40000000) != 0 && event.type == KeyEventType::KeyDown;
+    event.is_global = false;
+    event.window_id = window_id;
+    return event;
+}
+
+inline UINT hotkey_modifiers_from_shortcut(const Shortcut& shortcut) {
+    UINT modifiers = 0;
+    if (shortcut.ctrl) modifiers |= MOD_CONTROL;
+    if (shortcut.shift) modifiers |= MOD_SHIFT;
+    if (shortcut.alt) modifiers |= MOD_ALT;
+    if (shortcut.meta) modifiers |= MOD_WIN;
+    return modifiers;
+}
+
+inline bool is_modifier_key(Key key) {
+    return key == Key::Shift || key == Key::Control || key == Key::Alt || key == Key::Meta;
+}
+
+} // namespace wpp::input::win32

package/framework/src/Input/input_bridge.h

@@ -0,0 +1,192 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "input_service.h"
+#include "../FileSystem/filesystem_json.h"
+
+namespace wpp::input {
+
+using EvalFn = std::function<void(const std::string& js)>;
+using DispatchFn = std::function<void(std::function<void()>)>;
+
+class InputBridge {
+public:
+    InputBridge(EvalFn eval_fn, DispatchFn dispatch_fn, std::string window_id)
+        : eval_(std::move(eval_fn)), dispatch_(std::move(dispatch_fn)), window_id_(std::move(window_id)) {
+        listener_id_ = Service::instance().add_key_listener([this](const KeyEvent& event) {
+            if (!stream_enabled_) {
+                return;
+            }
+            if (!event.is_global && event.window_id != window_id_) {
+                return;
+            }
+            emit_event("key", key_event_to_json(event));
+        });
+    }
+
+    ~InputBridge() {
+        if (listener_id_ != 0) {
+            Service::instance().remove_key_listener(listener_id_);
+        }
+    }
+
+    void dispatch(const std::string& raw) {
+        std::string id;
+        std::string method;
+        std::vector<wpp::fs::JsonValue> params;
+
+        try {
+            auto env = wpp::fs::JsonValue::parse(raw);
+            id = env["id"].as_string();
+            method = env["method"].as_string();
+            params = env["params"].as_array();
+        } catch (...) {
+            return;
+        }
+
+        if (method.rfind("input:", 0) != 0) {
+            return;
+        }
+
+        auto reply_ok = [this, &id](const std::string& json_result) {
+            eval_("window.__response__(" + wpp::fs::JsonValue::to_js_argument(id) + "," + json_result + ")");
+        };
+
+        auto reply_err = [this, &id](const std::string& msg) {
+            eval_(
+                "window.__response__(" + wpp::fs::JsonValue::to_js_argument(id) + ",null," +
+                wpp::fs::JsonValue::to_js_argument(msg) + ")");
+        };
+
+        try {
+            if (method == "input:setEventStreamEnabled") {
+                stream_enabled_ = !params.empty() && params[0].as_bool();
+                reply_ok("null");
+
+            } else if (method == "input:getPressedKeys") {
+                const auto pressed = Service::instance().pressed_keys();
+                std::string json = "[";
+                for (size_t index = 0; index < pressed.size(); ++index) {
+                    if (index > 0) {
+                        json += ',';
+                    }
+                    json += wpp::fs::JsonValue::dump_value(key_to_string(pressed[index]));
+                }
+                json += "]";
+                reply_ok(json);
+
+            } else if (method == "input:isPressed") {
+                if (params.empty()) {
+                    throw std::runtime_error("Missing key parameter");
+                }
+                const auto shortcut = Service::instance().parse_shortcut(params[0].as_string());
+                reply_ok(Service::instance().is_pressed(shortcut.key) ? "true" : "false");
+
+            } else if (method == "input:registerLocalShortcut") {
+                if (params.size() < 2) {
+                    throw std::runtime_error("Expected id and shortcut");
+                }
+                const auto shortcut_id = params[0].as_string();
+                const auto shortcut_text = params[1].as_string();
+                Service::instance().register_shortcut(
+                    shortcut_id,
+                    shortcut_text,
+                    [this, shortcut_id](const KeyEvent& event) {
+                        emit_event("shortcut", shortcut_event_to_json(shortcut_id, event));
+                    },
+                    ShortcutOptions{false, false, false, window_id_});
+                reply_ok("null");
+
+            } else if (method == "input:registerGlobalHotkey") {
+                if (params.size() < 2) {
+                    throw std::runtime_error("Expected id and shortcut");
+                }
+                const auto shortcut_id = params[0].as_string();
+                const auto shortcut_text = params[1].as_string();
+                Service::instance().register_shortcut(
+                    shortcut_id,
+                    shortcut_text,
+                    [this, shortcut_id](const KeyEvent& event) {
+                        emit_event("shortcut", shortcut_event_to_json(shortcut_id, event));
+                    },
+                    ShortcutOptions{true, false, false, {}});
+                reply_ok("null");
+
+            } else if (method == "input:unregisterShortcut") {
+                if (params.empty()) {
+                    throw std::runtime_error("Expected id");
+                }
+                Service::instance().unregister_shortcut(params[0].as_string());
+                reply_ok("null");
+
+            } else if (method == "input:clearShortcuts") {
+                Service::instance().clear_shortcuts();
+                reply_ok("null");
+            }
+        } catch (const std::exception& e) {
+            reply_err(e.what());
+        } catch (...) {
+            reply_err("Unknown error in input bridge");
+        }
+    }
+
+private:
+    std::string key_event_to_json(const KeyEvent& event) const {
+        std::string json = "{";
+        json += "\"type\":" + wpp::fs::JsonValue::dump_value(event.type == KeyEventType::KeyDown ? std::string("keydown") : std::string("keyup"));
+        json += ",\"key\":" + wpp::fs::JsonValue::dump_value(key_to_string(event.key));
+        json += ",\"keyName\":" + wpp::fs::JsonValue::dump_value(event.key_name);
+        json += ",\"keycode\":" + std::to_string(event.keycode);
+        json += ",\"scancode\":" + std::to_string(event.scancode);
+        json += ",\"ctrl\":" + std::string(event.ctrl ? "true" : "false");
+        json += ",\"shift\":" + std::string(event.shift ? "true" : "false");
+        json += ",\"alt\":" + std::string(event.alt ? "true" : "false");
+        json += ",\"meta\":" + std::string(event.meta ? "true" : "false");
+        json += ",\"repeat\":" + std::string(event.is_repeat ? "true" : "false");
+        json += ",\"global\":" + std::string(event.is_global ? "true" : "false");
+        json += ",\"windowId\":" + wpp::fs::JsonValue::dump_value(event.window_id);
+        json += ",\"pressedKeys\":[";
+        for (size_t index = 0; index < event.pressed_keys.size(); ++index) {
+            if (index > 0) {
+                json += ',';
+            }
+            json += wpp::fs::JsonValue::dump_value(key_to_string(event.pressed_keys[index]));
+        }
+        json += "]";
+        json += "}";
+        return json;
+    }
+
+    std::string shortcut_event_to_json(const std::string& id, const KeyEvent& event) const {
+        std::string json = "{";
+        json += "\"id\":" + wpp::fs::JsonValue::dump_value(id);
+        json += ",\"event\":" + key_event_to_json(event);
+        json += "}";
+        return json;
+    }
+
+    void emit_event(const std::string& event_name, const std::string& json_payload) {
+        std::string script = "window.__wpp_input_event__ && window.__wpp_input_event__(" +
+                             wpp::fs::JsonValue::to_js_argument(event_name) + "," +
+                             json_payload + ")";
+        if (dispatch_) {
+            dispatch_([eval = eval_, script = std::move(script)]() {
+                eval(script);
+            });
+            return;
+        }
+        eval_(script);
+    }
+
+    EvalFn eval_;
+    DispatchFn dispatch_;
+    std::string window_id_;
+    Service::ListenerId listener_id_ = 0;
+    bool stream_enabled_ = false;
+};
+
+} // namespace wpp::input