plusui-native-core 0.1.101 → 0.1.103

package/Core/Features/Window/window.cpp

@@ -17,15 +17,18 @@
 #include <wrl.h>
 using namespace Microsoft::WRL;
 #pragma warning(pop)
-#elif defined(__APPLE__)
-#include <Cocoa/Cocoa.h>
-#import <WebKit/WebKit.h>
-#include <objc/objc-runtime.h>
-
-#else
-#include <gtk/gtk.h>
-#include <webkit2/webkit2.h>
-#endif
+#elif defined(__APPLE__)
+#include <Cocoa/Cocoa.h>
+#import <AppKit/AppKit.h>
+#import <Carbon/Carbon.h>
+#import <WebKit/WebKit.h>
+#include <objc/objc-runtime.h>
+
+#else
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+#include <webkit2/webkit2.h>
+#endif
 
 #include <stb_image.h>
 
@@ -82,6 +85,42 @@ static std::string jsonEscape(const std::string &input) {
   return out;
 }
 
+// Map Windows VK code to PlusUI KeyCode (GLFW-style values)
+static int vkToPlusUIKeyCode(WPARAM vk) {
+  if (vk >= 'A' && vk <= 'Z') return (int)vk;           // A=65…Z=90
+  if (vk >= '0' && vk <= '9') return (int)vk;           // 0=48…9=57
+  if (vk >= VK_F1 && vk <= VK_F12) return 290 + (int)(vk - VK_F1); // F1=290…F12=301
+  switch (vk) {
+    case VK_SPACE:   return 32;
+    case VK_ESCAPE:  return 256;
+    case VK_RETURN:  return 257;
+    case VK_TAB:     return 258;
+    case VK_BACK:    return 259;
+    case VK_DELETE:  return 261;
+    case VK_RIGHT:   return 262;
+    case VK_LEFT:    return 263;
+    case VK_DOWN:    return 264;
+    case VK_UP:      return 265;
+    case VK_SHIFT:
+    case VK_LSHIFT:  return 340;
+    case VK_CONTROL:
+    case VK_LCONTROL:return 341;
+    case VK_MENU:
+    case VK_LMENU:   return 342;
+    default:         return 0;
+  }
+}
+
+// Build the KeyMod flags from current modifier key states
+static int currentKeyMods() {
+  int mods = 0;
+  if (GetKeyState(VK_SHIFT)   & 0x8000) mods |= 1; // KeyMod::Shift
+  if (GetKeyState(VK_CONTROL) & 0x8000) mods |= 2; // KeyMod::Control
+  if (GetKeyState(VK_MENU)    & 0x8000) mods |= 4; // KeyMod::Alt
+  if ((GetKeyState(VK_LWIN) | GetKeyState(VK_RWIN)) & 0x8000) mods |= 8; // KeyMod::Super
+  return mods;
+}
+
 static std::string mimeTypeFromPath(const std::string &path) {
   size_t dot = path.find_last_of('.');
   if (dot == std::string::npos)
@@ -105,10 +144,43 @@ static std::string mimeTypeFromPath(const std::string &path) {
     return "application/json";
   if (ext == ".pdf")
     return "application/pdf";
-  return "application/octet-stream";
-}
-#endif
-} // namespace
+  return "application/octet-stream";
+}
+#endif // _WIN32
+
+#if !defined(_WIN32)
+// Build the JS snippet that dispatches plusui:keyboard:keydown/keyup.
+// Used by macOS (NSEvent monitor) and Linux (GDK key signals).
+static std::string buildKeyEventScript(int keyCode, int scancode, int mods,
+                                       bool pressed, bool repeat) {
+  std::string evtName = pressed ? "plusui:keyboard:keydown"
+                                : "plusui:keyboard:keyup";
+  return
+    "(function(){"
+    "var e={key:" + std::to_string(keyCode) +
+    ",scancode:" + std::to_string(scancode) +
+    ",mods:" + std::to_string(mods) +
+    ",pressed:" + (pressed ? "true" : "false") +
+    ",repeat:" + (repeat ? "true" : "false") +
+    ",keyName:\"\"};"
+    "window.dispatchEvent(new CustomEvent('" + evtName + "',{detail:e}));"
+    "})();";
+}
+
+// Build the JS snippet that dispatches plusui:keyboard:shortcut and calls handler.
+static std::string buildShortcutScript(const std::string& id) {
+  return
+    "(function(){"
+    "var id=\"" + id + "\";"
+    "window.dispatchEvent(new CustomEvent('plusui:keyboard:shortcut',{detail:{id:id}}));"
+    "if(window.__plusui_shortcut_handlers__&&window.__plusui_shortcut_handlers__[id]){"
+    "window.__plusui_shortcut_handlers__[id]();"
+    "}"
+    "})();";
+}
+#endif // !_WIN32
+
+} // namespace
 
 struct Window::Impl {
   void *nativeWindow = nullptr;
@@ -137,8 +209,9 @@ struct Window::Impl {
   ErrorCallback errorCallback;
   ConsoleCallback consoleCallback;
   MessageCallback messageCallback;
-  FileDropCallback fileDropCallback;
-  std::map<std::string, JSCallback> bindings;
+  FileDropCallback fileDropCallback;
+  std::map<std::string, JSCallback> bindings;
+  std::map<int, std::string> hotkeys; // hotkey id -> shortcut id
 
   std::vector<MoveCallback> moveCallbacks;
   std::vector<ResizeCallback> resizeCallbacks;
@@ -257,12 +330,16 @@ struct Window::Impl {
           targetImpl->fileDropCallback(filesJson);
         }
 
-        // Build the event script that dispatches to the frontend.
-        // We always fire the global CustomEvent so any listener can react.
-        // If the drop lands on a [data-dropzone] element we also call the
-        // zone-specific callback (__plusui_fileDrop__).
-        int dpx = dropPoint.x;
-        int dpy = dropPoint.y;
+        // DragQueryPoint returns physical (device) pixels relative to the
+        // client area.  document.elementFromPoint uses CSS (logical) pixels.
+        // Divide by the DPI scale factor so the hit-test is correct on HiDPI
+        // displays (e.g. 150% scaling → divide by 1.5).
+        double dpiScale = 1.0;
+        UINT dpi = GetDpiForWindow(hwnd);
+        if (dpi > 0) dpiScale = static_cast<double>(dpi) / 96.0;
+
+        int dpx = static_cast<int>(dropPoint.x / dpiScale);
+        int dpy = static_cast<int>(dropPoint.y / dpiScale);
 
         std::string eventScript =
             "(function(){"
@@ -273,7 +350,7 @@ struct Window::Impl {
             "window.dispatchEvent(new "
             "CustomEvent('plusui:fileDrop.filesDropped',"
             " { detail: { files: files } }));"
-            // Zone-specific delivery
+            // Zone-specific delivery via DPI-corrected hit test
             "var el=document.elementFromPoint(" +
             std::to_string(dpx) + "," + std::to_string(dpy) +
             ");"
@@ -282,10 +359,9 @@ struct Window::Impl {
             "if(zoneName&&window.__plusui_fileDrop__){"
             "window.__plusui_fileDrop__(zoneName,files);"
             "}"
-            // If no zone matched but there is only one registered zone,
-            // deliver there anyway so a simple single-zone app always works.
-            "if(!zoneName&&window.__plusui_fileDrop__&&"
-            "window.__plusui_fileDrop_default__){"
+            // If no zone matched deliver to all registered zones so a
+            // single-zone app always works regardless of hit-test accuracy.
+            "if(!zoneName&&window.__plusui_fileDrop_default__){"
             "window.__plusui_fileDrop_default__(files);"
             "}"
             "})();";
@@ -295,20 +371,70 @@ struct Window::Impl {
             nullptr);
         return 0;
       }
-      case WM_SETFOCUS:
-        impl->state.isFocused = true;
-        for (auto &cb : impl->focusCallbacks)
-          cb(true);
-        break;
-      case WM_KILLFOCUS:
-        impl->state.isFocused = false;
-        for (auto &cb : impl->focusCallbacks)
-          cb(false);
-        break;
-      }
-    }
-    return DefWindowProc(hwnd, msg, wp, lp);
-  }
+      case WM_HOTKEY: {
+        int hotKeyId = (int)wp;
+        auto it = impl->hotkeys.find(hotKeyId);
+        if (it != impl->hotkeys.end() && impl->webview) {
+          std::string shortcutId = it->second;
+          // Fire keyboard:shortcut event and also trigger any registered
+          // shortcutHandlers on the JS side
+          std::string script =
+            "(function(){"
+            "var id=" + std::string("\"") + shortcutId + "\";"
+            "window.dispatchEvent(new CustomEvent('plusui:keyboard:shortcut',{detail:{id:id}}));"
+            "if(window.__plusui_shortcut_handlers__&&window.__plusui_shortcut_handlers__[id]){"
+            "window.__plusui_shortcut_handlers__[id]();"
+            "}"
+            "})();";
+          impl->webview->ExecuteScript(
+            std::wstring(script.begin(), script.end()).c_str(), nullptr);
+        }
+        return 0;
+      }
+      case WM_KEYDOWN:
+      case WM_SYSKEYDOWN:
+      case WM_KEYUP:
+      case WM_SYSKEYUP: {
+        if (impl->webview) {
+          bool pressed = (msg == WM_KEYDOWN || msg == WM_SYSKEYDOWN);
+          bool repeat  = pressed && ((lp & 0x40000000) != 0);
+          int keyCode  = vkToPlusUIKeyCode(wp);
+          if (keyCode != 0) {
+            int mods = currentKeyMods();
+            // Build a KeyEvent JSON object and dispatch as CustomEvent
+            std::string evtName = pressed
+              ? "plusui:keyboard:keydown"
+              : "plusui:keyboard:keyup";
+            std::string script =
+              "(function(){"
+              "var e={key:" + std::to_string(keyCode) +
+              ",scancode:" + std::to_string((int)((lp >> 16) & 0xFF)) +
+              ",mods:" + std::to_string(mods) +
+              ",pressed:" + (pressed ? "true" : "false") +
+              ",repeat:" + (repeat ? "true" : "false") +
+              ",keyName:\"\"};"
+              "window.dispatchEvent(new CustomEvent('" + evtName + "',{detail:e}));"
+              "})();";
+            impl->webview->ExecuteScript(
+              std::wstring(script.begin(), script.end()).c_str(), nullptr);
+          }
+        }
+        break;
+      }
+      case WM_SETFOCUS:
+        impl->state.isFocused = true;
+        for (auto &cb : impl->focusCallbacks)
+          cb(true);
+        break;
+      case WM_KILLFOCUS:
+        impl->state.isFocused = false;
+        for (auto &cb : impl->focusCallbacks)
+          cb(false);
+        break;
+      }
+    }
+    return DefWindowProc(hwnd, msg, wp, lp);
+  }
 #elif defined(__APPLE__)
   WKWebView *wkWebView = nullptr;
 #else
@@ -978,16 +1104,18 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                         Window::Impl::embeddedWebviewByParent[parentHwnd] =
                             pImpl.get();
 
-                        // Always allow external drops at the WebView2 level
-                        // so that WM_DROPFILES on the parent HWND fires.
-                        // Browser-level drop behavior (navigating to the file)
-                        // is blocked by the injected JS below instead.
+                        // Disable WebView2's internal drop handling so the OS
+                        // drop message (WM_DROPFILES) propagates to our WndProc.
+                        // When AllowExternalDrop is TRUE, WebView2 consumes the
+                        // drop event itself and WM_DROPFILES never fires.
+                        // Visual drag feedback (dropzone-active CSS class) is
+                        // still handled by the injected JS via dragenter/dragover.
                         ComPtr<ICoreWebView2Controller4> controller4;
                         if (controller &&
                             SUCCEEDED(controller->QueryInterface(
                                 IID_PPV_ARGS(&controller4))) &&
                             controller4) {
-                          controller4->put_AllowExternalDrop(TRUE);
+                          controller4->put_AllowExternalDrop(FALSE);
                         }
 
                         pImpl->nativeWebView = pImpl->webview.Get();
@@ -1054,7 +1182,7 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                               var zone = findDropZone(e);
                               updateActiveZone(zone);
                               if (e.dataTransfer) {
-                                try { e.dataTransfer.dropEffect = zone ? 'copy' : 'none'; } catch(_) {}
+                                try { e.dataTransfer.dropEffect = zone ? 'move' : 'none'; } catch(_) {}
                               }
                             }, true);
 
@@ -1063,7 +1191,7 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                               var zone = findDropZone(e);
                               updateActiveZone(zone);
                               if (e.dataTransfer) {
-                                try { e.dataTransfer.dropEffect = zone ? 'copy' : 'none'; } catch(_) {}
+                                try { e.dataTransfer.dropEffect = zone ? 'move' : 'none'; } catch(_) {}
                               }
                             }, true);
 
@@ -1700,15 +1828,255 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
       [[WKWebView alloc] initWithFrame:parentView.bounds configuration:config];
   [parentView addSubview:win.pImpl->wkWebView];
 
-  win.pImpl->nativeWebView = (__bridge void *)win.pImpl->wkWebView;
-
-#endif
-
-  win.pImpl->trayManager = std::make_unique<TrayManager>();
-  win.pImpl->trayManager->setWindowHandle(windowHandle);
-
-  return win;
-}
+  win.pImpl->nativeWebView = (__bridge void *)win.pImpl->wkWebView;
+
+  // ── macOS key event forwarding ─────────────────────────────────────────────
+  // NSEvent local monitor: fires for every keyDown/keyUp that goes through
+  // the app's event queue while any app window is key.  We convert to
+  // PlusUI KeyCode and dispatch as CustomEvents into the WebView.
+  {
+    WKWebView * __weak wv = win.pImpl->wkWebView;
+
+    // Map macOS virtual keycode + character to PlusUI KeyCode (GLFW style)
+    auto macVKToPlusUI = [](unsigned short vk, unsigned short ch) -> int {
+      if (ch >= 'a' && ch <= 'z') return (int)(ch - 'a' + 65); // A-Z
+      if (ch >= 'A' && ch <= 'Z') return (int)ch;
+      if (ch >= '0' && ch <= '9') return (int)ch;               // 0-9
+      static const struct { unsigned short vk; int code; } fkeys[] = {
+        {122,290},{120,291},{99,292},{118,293},{96,294},{97,295},
+        {98,296},{100,297},{101,298},{109,299},{103,300},{111,301}
+      };
+      for (auto& f : fkeys) if (vk == f.vk) return f.code;
+      switch (vk) {
+        case 49:  return 32;  // Space
+        case 53:  return 256; // Escape
+        case 36:  return 257; // Return
+        case 48:  return 258; // Tab
+        case 51:  return 259; // Backspace
+        case 117: return 261; // Forward Delete
+        case 124: return 262; // Right
+        case 123: return 263; // Left
+        case 125: return 264; // Down
+        case 126: return 265; // Up
+        case 56:  return 340; // Left Shift
+        case 59:  return 341; // Left Control
+        case 58:  return 342; // Left Option/Alt
+        default:  return 0;
+      }
+    };
+
+    auto buildMods = [](NSEventModifierFlags f) -> int {
+      int m = 0;
+      if (f & NSEventModifierFlagShift)   m |= 1;
+      if (f & NSEventModifierFlagControl) m |= 2;
+      if (f & NSEventModifierFlagOption)  m |= 4;
+      if (f & NSEventModifierFlagCommand) m |= 8;
+      return m;
+    };
+
+    [NSEvent addLocalMonitorForEventsMatchingMask:
+        NSEventMaskKeyDown | NSEventMaskKeyUp
+        handler:^NSEvent*(NSEvent* event) {
+          if (!wv) return event;
+          unsigned short vk = [event keyCode];
+          unsigned short ch = 0;
+          NSString *chars = [event charactersIgnoringModifiers];
+          if (chars.length > 0) ch = (unsigned short)[chars characterAtIndex:0];
+          int keyCode = macVKToPlusUI(vk, ch);
+          if (keyCode != 0) {
+            bool pressed = ([event type] == NSEventTypeKeyDown);
+            bool repeat  = pressed && [event isARepeat];
+            int mods     = buildMods([event modifierFlags]);
+            std::string script = buildKeyEventScript(keyCode, (int)vk, mods, pressed, repeat);
+            NSString* js = [NSString stringWithUTF8String:script.c_str()];
+            [wv evaluateJavaScript:js completionHandler:nil];
+          }
+          return event;
+        }];
+
+    // Wire Carbon global hotkey fired callback → evaluateJavaScript.
+    // setShortcutFiredCallback is defined in keyboard_macos.cpp (compiled via
+    // #include in keyboard.cpp) and lives in the same plusui namespace.
+    void setShortcutFiredCallback(std::function<void(const std::string&)>);
+    setShortcutFiredCallback([wv](const std::string& id) {
+      if (!wv) return;
+      std::string script = buildShortcutScript(id);
+      NSString* js = [NSString stringWithUTF8String:script.c_str()];
+      [wv evaluateJavaScript:js completionHandler:nil];
+    });
+  }
+
+#else
+  // ── Linux / GTK + WebKit2 WebView ─────────────────────────────────────────
+  {
+    GtkWidget *gtkParent = static_cast<GtkWidget*>(windowHandle);
+    WebKitWebView *webView =
+        WEBKIT_WEB_VIEW(webkit_web_view_new());
+    gtk_container_add(GTK_CONTAINER(gtkParent), GTK_WIDGET(webView));
+    gtk_widget_show(GTK_WIDGET(webView));
+    win.pImpl->gtkWebView = webView;
+    win.pImpl->nativeWebView = static_cast<void*>(webView);
+
+    // Inject the native bridge script on every page load
+    WebKitUserContentManager *mgr =
+        webkit_web_view_get_user_content_manager(webView);
+    WebKitUserScript *bridgeScript = webkit_user_script_new(
+        "window.__native_invoke__ = function(req) {"
+        "  window.webkit.messageHandlers.plusui.postMessage(req);"
+        "};",
+        WEBKIT_USER_CONTENT_INJECT_TOP_FRAME,
+        WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,
+        nullptr, nullptr);
+    webkit_user_content_manager_add_script(mgr, bridgeScript);
+    webkit_user_script_unref(bridgeScript);
+
+    // Helper to run JS in this WebView
+    auto runJS = [webView](const std::string& script) {
+      webkit_web_view_run_javascript(webView, script.c_str(),
+                                     nullptr, nullptr, nullptr);
+    };
+
+    // GDK keyval → PlusUI KeyCode
+    auto gdkKeyToPlusUI = [](guint keyval) -> int {
+      if (keyval >= GDK_KEY_a && keyval <= GDK_KEY_z)
+        return (int)(keyval - GDK_KEY_a + 65);
+      if (keyval >= GDK_KEY_A && keyval <= GDK_KEY_Z)
+        return (int)(keyval - GDK_KEY_A + 65);
+      if (keyval >= GDK_KEY_0 && keyval <= GDK_KEY_9)
+        return (int)(keyval - GDK_KEY_0 + 48);
+      if (keyval >= GDK_KEY_F1 && keyval <= GDK_KEY_F12)
+        return 290 + (int)(keyval - GDK_KEY_F1);
+      switch (keyval) {
+        case GDK_KEY_space:     return 32;
+        case GDK_KEY_Escape:    return 256;
+        case GDK_KEY_Return:    return 257;
+        case GDK_KEY_Tab:       return 258;
+        case GDK_KEY_BackSpace: return 259;
+        case GDK_KEY_Delete:    return 261;
+        case GDK_KEY_Right:     return 262;
+        case GDK_KEY_Left:      return 263;
+        case GDK_KEY_Down:      return 264;
+        case GDK_KEY_Up:        return 265;
+        case GDK_KEY_Shift_L:
+        case GDK_KEY_Shift_R:   return 340;
+        case GDK_KEY_Control_L:
+        case GDK_KEY_Control_R: return 341;
+        case GDK_KEY_Alt_L:
+        case GDK_KEY_Alt_R:     return 342;
+        default: return 0;
+      }
+    };
+
+    auto buildGdkMods = [](GdkModifierType state) -> int {
+      int m = 0;
+      if (state & GDK_SHIFT_MASK)   m |= 1;
+      if (state & GDK_CONTROL_MASK) m |= 2;
+      if (state & GDK_MOD1_MASK)    m |= 4; // Alt
+      if (state & GDK_SUPER_MASK)   m |= 8;
+      return m;
+    };
+
+    // Key-press callback: capture by value via malloc'd context struct
+    struct KeyCtx {
+      WebKitWebView* webView;
+      std::function<int(guint, int, int, bool, bool)> dispatch;
+    };
+    auto* ctx = new KeyCtx();
+    ctx->webView = webView;
+
+    // key-press-event
+    g_signal_connect(gtkParent, "key-press-event",
+      G_CALLBACK(+[](GtkWidget*, GdkEventKey* ev, gpointer data) -> gboolean {
+        auto* c = static_cast<KeyCtx*>(data);
+        // gdkKeyToPlusUI re-implemented inline (lambda not capturable in C cb)
+        guint kv = ev->keyval;
+        int kc = 0;
+        if (kv >= GDK_KEY_a && kv <= GDK_KEY_z) kc = (int)(kv-GDK_KEY_a+65);
+        else if (kv >= GDK_KEY_A && kv <= GDK_KEY_Z) kc = (int)(kv-GDK_KEY_A+65);
+        else if (kv >= GDK_KEY_0 && kv <= GDK_KEY_9) kc = (int)(kv-GDK_KEY_0+48);
+        else if (kv >= GDK_KEY_F1 && kv <= GDK_KEY_F12) kc = 290+(int)(kv-GDK_KEY_F1);
+        else switch (kv) {
+          case GDK_KEY_space:     kc=32;  break;
+          case GDK_KEY_Escape:    kc=256; break;
+          case GDK_KEY_Return:    kc=257; break;
+          case GDK_KEY_Tab:       kc=258; break;
+          case GDK_KEY_BackSpace: kc=259; break;
+          case GDK_KEY_Delete:    kc=261; break;
+          case GDK_KEY_Right:     kc=262; break;
+          case GDK_KEY_Left:      kc=263; break;
+          case GDK_KEY_Down:      kc=264; break;
+          case GDK_KEY_Up:        kc=265; break;
+          case GDK_KEY_Shift_L: case GDK_KEY_Shift_R:   kc=340; break;
+          case GDK_KEY_Control_L: case GDK_KEY_Control_R: kc=341; break;
+          case GDK_KEY_Alt_L: case GDK_KEY_Alt_R:       kc=342; break;
+        }
+        if (!kc) return FALSE;
+        int mods = 0;
+        if (ev->state & GDK_SHIFT_MASK)   mods |= 1;
+        if (ev->state & GDK_CONTROL_MASK) mods |= 2;
+        if (ev->state & GDK_MOD1_MASK)    mods |= 4;
+        if (ev->state & GDK_SUPER_MASK)   mods |= 8;
+        bool repeat = (ev->send_event == FALSE &&
+                       (ev->state & GDK_KEY_PRESS) != 0); // best-effort
+        std::string script = buildKeyEventScript(kc, (int)ev->hardware_keycode, mods, true, repeat);
+        webkit_web_view_run_javascript(c->webView, script.c_str(), nullptr, nullptr, nullptr);
+        return FALSE; // don't consume — let WebKit still receive it
+      }),
+      ctx);
+
+    // key-release-event
+    g_signal_connect(gtkParent, "key-release-event",
+      G_CALLBACK(+[](GtkWidget*, GdkEventKey* ev, gpointer data) -> gboolean {
+        auto* c = static_cast<KeyCtx*>(data);
+        guint kv = ev->keyval;
+        int kc = 0;
+        if (kv >= GDK_KEY_a && kv <= GDK_KEY_z) kc = (int)(kv-GDK_KEY_a+65);
+        else if (kv >= GDK_KEY_A && kv <= GDK_KEY_Z) kc = (int)(kv-GDK_KEY_A+65);
+        else if (kv >= GDK_KEY_0 && kv <= GDK_KEY_9) kc = (int)(kv-GDK_KEY_0+48);
+        else if (kv >= GDK_KEY_F1 && kv <= GDK_KEY_F12) kc = 290+(int)(kv-GDK_KEY_F1);
+        else switch (kv) {
+          case GDK_KEY_space:     kc=32;  break;
+          case GDK_KEY_Escape:    kc=256; break;
+          case GDK_KEY_Return:    kc=257; break;
+          case GDK_KEY_Tab:       kc=258; break;
+          case GDK_KEY_BackSpace: kc=259; break;
+          case GDK_KEY_Delete:    kc=261; break;
+          case GDK_KEY_Right:     kc=262; break;
+          case GDK_KEY_Left:      kc=263; break;
+          case GDK_KEY_Down:      kc=264; break;
+          case GDK_KEY_Up:        kc=265; break;
+          case GDK_KEY_Shift_L: case GDK_KEY_Shift_R:   kc=340; break;
+          case GDK_KEY_Control_L: case GDK_KEY_Control_R: kc=341; break;
+          case GDK_KEY_Alt_L: case GDK_KEY_Alt_R:       kc=342; break;
+        }
+        if (!kc) return FALSE;
+        int mods = 0;
+        if (ev->state & GDK_SHIFT_MASK)   mods |= 1;
+        if (ev->state & GDK_CONTROL_MASK) mods |= 2;
+        if (ev->state & GDK_MOD1_MASK)    mods |= 4;
+        if (ev->state & GDK_SUPER_MASK)   mods |= 8;
+        std::string script = buildKeyEventScript(kc, (int)ev->hardware_keycode, mods, false, false);
+        webkit_web_view_run_javascript(c->webView, script.c_str(), nullptr, nullptr, nullptr);
+        return FALSE;
+      }),
+      ctx);
+
+    // Wire XGrabKey global shortcut fired callback → webkit_web_view_run_javascript.
+    // g_shortcutFiredFn is defined in keyboard_linux.cpp (compiled via #include).
+    extern std::function<void(const std::string&)> g_shortcutFiredFn;
+    g_shortcutFiredFn = [webView](const std::string& id) {
+      std::string script = buildShortcutScript(id);
+      webkit_web_view_run_javascript(webView, script.c_str(), nullptr, nullptr, nullptr);
+    };
+  }
+
+#endif
+
+  win.pImpl->trayManager = std::make_unique<TrayManager>();
+  win.pImpl->trayManager->setWindowHandle(windowHandle);
+
+  return win;
+}
 
 TrayManager &Window::tray() { return *pImpl->trayManager; }