ranma 0.1.0

data/ext/ranma/src/hotkey.rs

@@ -0,0 +1,245 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use magnus::{function, gc, method, prelude::*, Error, RArray, Ruby, Symbol, Value};
+use global_hotkey::hotkey::{Code, Modifiers as GhModifiers};
+use global_hotkey::GlobalHotKeyManager;
+
+thread_local! {
+    static HOTKEY_MANAGER: RefCell<Option<GlobalHotKeyManager>> = const { RefCell::new(None) };
+    static HOTKEY_HANDLERS: RefCell<HashMap<u32, Value>> = RefCell::new(HashMap::new());
+}
+
+pub fn init_manager() {
+    let manager = GlobalHotKeyManager::new().expect("Failed to create GlobalHotKeyManager");
+    HOTKEY_MANAGER.with(|cell| {
+        *cell.borrow_mut() = Some(manager);
+    });
+}
+
+pub fn dispatch_hotkey_event(id: u32) {
+    HOTKEY_HANDLERS.with(|cell| {
+        let handlers = cell.borrow();
+        if let Some(handler) = handlers.get(&id) {
+            let result: Result<Value, _> = handler.funcall("call", ());
+            if let Err(e) = result {
+                eprintln!("Ranma: Error in hotkey handler: {}", e);
+            }
+        }
+    });
+}
+
+pub fn clear_all() {
+    HOTKEY_HANDLERS.with(|cell| {
+        cell.borrow_mut().clear();
+    });
+    HOTKEY_MANAGER.with(|cell| {
+        *cell.borrow_mut() = None;
+    });
+}
+
+fn symbol_to_code(ruby: &Ruby, sym: Symbol) -> Result<Code, Error> {
+    let name = unsafe { sym.to_s() }.map_err(|_| {
+        Error::new(ruby.exception_type_error(), "Expected a Symbol for key")
+    })?;
+    let code = match name.as_ref() {
+        "a" => Code::KeyA,
+        "b" => Code::KeyB,
+        "c" => Code::KeyC,
+        "d" => Code::KeyD,
+        "e" => Code::KeyE,
+        "f" => Code::KeyF,
+        "g" => Code::KeyG,
+        "h" => Code::KeyH,
+        "i" => Code::KeyI,
+        "j" => Code::KeyJ,
+        "k" => Code::KeyK,
+        "l" => Code::KeyL,
+        "m" => Code::KeyM,
+        "n" => Code::KeyN,
+        "o" => Code::KeyO,
+        "p" => Code::KeyP,
+        "q" => Code::KeyQ,
+        "r" => Code::KeyR,
+        "s" => Code::KeyS,
+        "t" => Code::KeyT,
+        "u" => Code::KeyU,
+        "v" => Code::KeyV,
+        "w" => Code::KeyW,
+        "x" => Code::KeyX,
+        "y" => Code::KeyY,
+        "z" => Code::KeyZ,
+        "0" => Code::Digit0,
+        "1" => Code::Digit1,
+        "2" => Code::Digit2,
+        "3" => Code::Digit3,
+        "4" => Code::Digit4,
+        "5" => Code::Digit5,
+        "6" => Code::Digit6,
+        "7" => Code::Digit7,
+        "8" => Code::Digit8,
+        "9" => Code::Digit9,
+        "f1" => Code::F1,
+        "f2" => Code::F2,
+        "f3" => Code::F3,
+        "f4" => Code::F4,
+        "f5" => Code::F5,
+        "f6" => Code::F6,
+        "f7" => Code::F7,
+        "f8" => Code::F8,
+        "f9" => Code::F9,
+        "f10" => Code::F10,
+        "f11" => Code::F11,
+        "f12" => Code::F12,
+        "up" => Code::ArrowUp,
+        "down" => Code::ArrowDown,
+        "left" => Code::ArrowLeft,
+        "right" => Code::ArrowRight,
+        "home" => Code::Home,
+        "end" => Code::End,
+        "page_up" => Code::PageUp,
+        "page_down" => Code::PageDown,
+        "backspace" => Code::Backspace,
+        "delete" => Code::Delete,
+        "insert" => Code::Insert,
+        "enter" => Code::Enter,
+        "tab" => Code::Tab,
+        "space" => Code::Space,
+        "escape" => Code::Escape,
+        "comma" => Code::Comma,
+        "period" => Code::Period,
+        "slash" => Code::Slash,
+        "backslash" => Code::Backslash,
+        "semicolon" => Code::Semicolon,
+        "quote" => Code::Quote,
+        "left_bracket" => Code::BracketLeft,
+        "right_bracket" => Code::BracketRight,
+        "minus" => Code::Minus,
+        "equal" => Code::Equal,
+        "backquote" => Code::Backquote,
+        "caps_lock" => Code::CapsLock,
+        "num_lock" => Code::NumLock,
+        "scroll_lock" => Code::ScrollLock,
+        "print_screen" => Code::PrintScreen,
+        "pause" => Code::Pause,
+        _ => {
+            return Err(Error::new(
+                ruby.exception_runtime_error(),
+                format!("Unknown key: :{}", name),
+            ));
+        }
+    };
+    Ok(code)
+}
+
+fn symbols_to_modifiers(ruby: &Ruby, arr: RArray) -> Result<GhModifiers, Error> {
+    let mut mods = GhModifiers::empty();
+    for val in arr.into_iter() {
+        let sym = Symbol::try_convert(val).map_err(|_| {
+            Error::new(ruby.exception_type_error(), "Expected Symbol in modifiers array")
+        })?;
+        let name = unsafe { sym.to_s() }.map_err(|_| {
+            Error::new(ruby.exception_type_error(), "Expected a Symbol for modifier")
+        })?;
+        match name.as_ref() {
+            "alt" => mods |= GhModifiers::ALT,
+            "shift" => mods |= GhModifiers::SHIFT,
+            "control" | "ctrl" => mods |= GhModifiers::CONTROL,
+            "super" | "meta" | "command" | "cmd" => mods |= GhModifiers::SUPER,
+            _ => {
+                return Err(Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Unknown modifier: :{}", name),
+                ));
+            }
+        }
+    }
+    Ok(mods)
+}
+
+#[magnus::wrap(class = "Ranma::HotKey", free_immediately, size)]
+pub struct RbHotKey {
+    hotkey: global_hotkey::hotkey::HotKey,
+}
+
+unsafe impl Send for RbHotKey {}
+
+impl RbHotKey {
+    fn new(modifiers: RArray, key: Symbol) -> Result<Self, Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let gh_mods = symbols_to_modifiers(&ruby, modifiers)?;
+        let code = symbol_to_code(&ruby, key)?;
+        let mods_opt = if gh_mods.is_empty() {
+            None
+        } else {
+            Some(gh_mods)
+        };
+        let hotkey = global_hotkey::hotkey::HotKey::new(mods_opt, code);
+        Ok(RbHotKey { hotkey })
+    }
+
+    fn id(&self) -> u32 {
+        self.hotkey.id()
+    }
+
+    fn register(&self, handler: Value) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        gc::register_mark_object(handler);
+        HOTKEY_MANAGER.with(|cell| {
+            let borrow = cell.borrow();
+            let manager = borrow.as_ref().ok_or_else(|| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    "GlobalHotKeyManager not initialized. Call App.start first.",
+                )
+            })?;
+            manager.register(self.hotkey).map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to register hotkey: {}", e),
+                )
+            })?;
+            HOTKEY_HANDLERS.with(|h| {
+                h.borrow_mut().insert(self.hotkey.id(), handler);
+            });
+            Ok(())
+        })
+    }
+
+    fn unregister(&self) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        HOTKEY_MANAGER.with(|cell| {
+            let borrow = cell.borrow();
+            let manager = borrow.as_ref().ok_or_else(|| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    "GlobalHotKeyManager not initialized.",
+                )
+            })?;
+            manager.unregister(self.hotkey).map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to unregister hotkey: {}", e),
+                )
+            })?;
+            HOTKEY_HANDLERS.with(|h| {
+                h.borrow_mut().remove(&self.hotkey.id());
+            });
+            Ok(())
+        })
+    }
+
+    fn inspect(&self) -> String {
+        format!("#<Ranma::HotKey id={}>", self.hotkey.id())
+    }
+}
+
+pub fn define_hotkey_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("HotKey", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RbHotKey::new, 2))?;
+    class.define_method("id", method!(RbHotKey::id, 0))?;
+    class.define_method("register", method!(RbHotKey::register, 1))?;
+    class.define_method("unregister", method!(RbHotKey::unregister, 0))?;
+    class.define_method("inspect", method!(RbHotKey::inspect, 0))?;
+    class.define_method("to_s", method!(RbHotKey::inspect, 0))?;
+    Ok(())
+}

data/ext/ranma/src/ime.rs

@@ -0,0 +1,318 @@
+//! macOS IME preedit support via ObjC runtime method swizzling.
+//!
+//! tao 0.34 only emits `ReceivedImeText` for committed text.
+//! This module swizzles `setMarkedText:selectedRange:replacementRange:`
+//! and `unmarkText` on tao's NSView to capture preedit (composition) text.
+//!
+//! When a candidate is selected from the IME candidate window,
+//! macOS calls `unmarkText` WITHOUT calling `insertText:replacementRange:`.
+//! This module detects that case and generates a commit event from the
+//! last preedit text.
+//!
+//! The swizzled methods do NOT touch Ruby. They only store the preedit text
+//! in a thread-local queue. Events are dispatched from the event loop via
+//! `dispatch_pending_preedit()`.
+
+#[cfg(target_os = "macos")]
+use std::cell::RefCell;
+#[cfg(target_os = "macos")]
+use std::ffi::{c_char, c_void, CStr};
+#[cfg(target_os = "macos")]
+use std::sync::atomic::{AtomicBool, Ordering};
+
+#[cfg(target_os = "macos")]
+use magnus::{Ruby, Symbol};
+#[cfg(target_os = "macos")]
+use tao::window::WindowId;
+
+// --- ObjC runtime FFI ---
+
+#[cfg(target_os = "macos")]
+type Id = *mut c_void;
+#[cfg(target_os = "macos")]
+type Sel = *mut c_void;
+#[cfg(target_os = "macos")]
+type Class = *mut c_void;
+#[cfg(target_os = "macos")]
+type Method = *mut c_void;
+#[cfg(target_os = "macos")]
+type Imp = *mut c_void;
+
+#[cfg(target_os = "macos")]
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct NSRange {
+    location: u64,
+    length: u64,
+}
+
+#[cfg(target_os = "macos")]
+extern "C" {
+    fn sel_registerName(name: *const c_char) -> Sel;
+    fn object_getClass(obj: Id) -> Class;
+    fn class_getInstanceMethod(cls: Class, sel: Sel) -> Method;
+    fn method_getImplementation(method: Method) -> Imp;
+    fn method_setImplementation(method: Method, imp: Imp) -> Imp;
+    fn objc_msgSend();
+}
+
+// --- Original IMPs ---
+
+#[cfg(target_os = "macos")]
+static mut ORIGINAL_SET_MARKED_TEXT: Option<
+    unsafe extern "C" fn(Id, Sel, Id, NSRange, NSRange),
+> = None;
+
+#[cfg(target_os = "macos")]
+static mut ORIGINAL_UNMARK_TEXT: Option<unsafe extern "C" fn(Id, Sel)> = None;
+
+#[cfg(target_os = "macos")]
+static mut ORIGINAL_INSERT_TEXT: Option<
+    unsafe extern "C" fn(Id, Sel, Id, NSRange),
+> = None;
+
+// --- Pending preedit queue ---
+
+#[cfg(target_os = "macos")]
+thread_local! {
+    static IME_WINDOW_ID: RefCell<Option<WindowId>> = RefCell::new(None);
+    static PENDING_PREEDIT: RefCell<Option<(String, usize)>> = RefCell::new(None);
+    static LAST_PREEDIT_TEXT: RefCell<String> = RefCell::new(String::new());
+    static INSERT_TEXT_CALLED: RefCell<bool> = RefCell::new(false);
+    static PENDING_COMMIT: RefCell<Option<String>> = RefCell::new(None);
+}
+
+#[cfg(target_os = "macos")]
+static SWIZZLED: AtomicBool = AtomicBool::new(false);
+
+// --- NSString helpers ---
+
+#[cfg(target_os = "macos")]
+unsafe fn nsstring_to_rust(obj: Id) -> String {
+    if obj.is_null() {
+        return String::new();
+    }
+
+    let string_sel = sel_registerName(b"string\0".as_ptr() as *const c_char);
+    let responds_sel =
+        sel_registerName(b"respondsToSelector:\0".as_ptr() as *const c_char);
+
+    let responds_fn: unsafe extern "C" fn(Id, Sel, Sel) -> bool =
+        std::mem::transmute(objc_msgSend as *const ());
+    let has_string = responds_fn(obj, responds_sel, string_sel);
+
+    let ns_string = if has_string {
+        let get_string: unsafe extern "C" fn(Id, Sel) -> Id =
+            std::mem::transmute(objc_msgSend as *const ());
+        let s = get_string(obj, string_sel);
+        if s.is_null() {
+            return String::new();
+        }
+        s
+    } else {
+        obj
+    };
+
+    let utf8_sel = sel_registerName(b"UTF8String\0".as_ptr() as *const c_char);
+    let get_utf8: unsafe extern "C" fn(Id, Sel) -> *const c_char =
+        std::mem::transmute(objc_msgSend as *const ());
+    let utf8_ptr = get_utf8(ns_string, utf8_sel);
+
+    if utf8_ptr.is_null() {
+        return String::new();
+    }
+
+    CStr::from_ptr(utf8_ptr).to_string_lossy().into_owned()
+}
+
+// --- Swizzled methods (NO Ruby access!) ---
+
+#[cfg(target_os = "macos")]
+unsafe extern "C" fn swizzled_set_marked_text(
+    this: Id,
+    cmd: Sel,
+    string: Id,
+    selected_range: NSRange,
+    replacement_range: NSRange,
+) {
+    let text = nsstring_to_rust(string);
+    let cursor_pos = (selected_range.location + selected_range.length) as usize;
+
+    LAST_PREEDIT_TEXT.with(|cell| {
+        *cell.borrow_mut() = text.clone();
+    });
+    INSERT_TEXT_CALLED.with(|cell| {
+        *cell.borrow_mut() = false;
+    });
+
+    if let Some(original) = ORIGINAL_SET_MARKED_TEXT {
+        original(this, cmd, string, selected_range, replacement_range);
+    }
+
+    PENDING_PREEDIT.with(|cell| {
+        *cell.borrow_mut() = Some((text, cursor_pos));
+    });
+}
+
+#[cfg(target_os = "macos")]
+unsafe extern "C" fn swizzled_unmark_text(this: Id, cmd: Sel) {
+    let insert_was_called = INSERT_TEXT_CALLED.with(|cell| *cell.borrow());
+    let last_text = LAST_PREEDIT_TEXT.with(|cell| cell.borrow().clone());
+
+    if !insert_was_called && !last_text.is_empty() {
+        PENDING_COMMIT.with(|cell| {
+            *cell.borrow_mut() = Some(last_text);
+        });
+    }
+
+    PENDING_PREEDIT.with(|cell| {
+        *cell.borrow_mut() = Some((String::new(), 0));
+    });
+
+    LAST_PREEDIT_TEXT.with(|cell| {
+        cell.borrow_mut().clear();
+    });
+    INSERT_TEXT_CALLED.with(|cell| {
+        *cell.borrow_mut() = false;
+    });
+
+    if let Some(original) = ORIGINAL_UNMARK_TEXT {
+        original(this, cmd);
+    }
+}
+
+#[cfg(target_os = "macos")]
+unsafe extern "C" fn swizzled_insert_text(
+    this: Id,
+    cmd: Sel,
+    string: Id,
+    replacement_range: NSRange,
+) {
+    INSERT_TEXT_CALLED.with(|cell| {
+        *cell.borrow_mut() = true;
+    });
+    LAST_PREEDIT_TEXT.with(|cell| {
+        cell.borrow_mut().clear();
+    });
+
+    if let Some(original) = ORIGINAL_INSERT_TEXT {
+        original(this, cmd, string, replacement_range);
+    }
+}
+
+// --- Public API ---
+
+#[cfg(target_os = "macos")]
+pub fn setup_ime_swizzle(window_id: WindowId, ns_view_ptr: usize) {
+    if SWIZZLED.load(Ordering::Relaxed) {
+        IME_WINDOW_ID.with(|cell| {
+            *cell.borrow_mut() = Some(window_id);
+        });
+        return;
+    }
+
+    unsafe {
+        let view = ns_view_ptr as Id;
+        if view.is_null() {
+            return;
+        }
+
+        let class = object_getClass(view);
+
+        // --- setMarkedText:selectedRange:replacementRange: ---
+        let smt_sel = sel_registerName(
+            b"setMarkedText:selectedRange:replacementRange:\0".as_ptr()
+                as *const c_char,
+        );
+        let smt_method = class_getInstanceMethod(class, smt_sel);
+        if !smt_method.is_null() {
+            let original_imp = method_getImplementation(smt_method);
+            ORIGINAL_SET_MARKED_TEXT = Some(std::mem::transmute(original_imp));
+
+            let new_imp: unsafe extern "C" fn(Id, Sel, Id, NSRange, NSRange) =
+                swizzled_set_marked_text;
+            method_setImplementation(smt_method, new_imp as Imp);
+        }
+
+        // --- unmarkText ---
+        let umt_sel =
+            sel_registerName(b"unmarkText\0".as_ptr() as *const c_char);
+        let umt_method = class_getInstanceMethod(class, umt_sel);
+        if !umt_method.is_null() {
+            let original_imp = method_getImplementation(umt_method);
+            ORIGINAL_UNMARK_TEXT = Some(std::mem::transmute(original_imp));
+
+            let new_imp: unsafe extern "C" fn(Id, Sel) = swizzled_unmark_text;
+            method_setImplementation(umt_method, new_imp as Imp);
+        }
+
+        // --- insertText:replacementRange: ---
+        let it_sel = sel_registerName(
+            b"insertText:replacementRange:\0".as_ptr() as *const c_char,
+        );
+        let it_method = class_getInstanceMethod(class, it_sel);
+        if !it_method.is_null() {
+            let original_imp = method_getImplementation(it_method);
+            ORIGINAL_INSERT_TEXT = Some(std::mem::transmute(original_imp));
+
+            let new_imp: unsafe extern "C" fn(Id, Sel, Id, NSRange) =
+                swizzled_insert_text;
+            method_setImplementation(it_method, new_imp as Imp);
+        }
+
+        IME_WINDOW_ID.with(|cell| {
+            *cell.borrow_mut() = Some(window_id);
+        });
+
+        SWIZZLED.store(true, Ordering::Relaxed);
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn sym(ruby: &Ruby, name: &str) -> Symbol {
+    ruby.sym_new(name).into()
+}
+
+#[cfg(target_os = "macos")]
+pub fn dispatch_pending_preedit() {
+    let ruby = unsafe { Ruby::get_unchecked() };
+
+    // Dispatch pending preedit (composition text display)
+    PENDING_PREEDIT.with(|cell| {
+        if let Some((text, cursor_pos)) = cell.borrow_mut().take() {
+            IME_WINDOW_ID.with(|wid_cell| {
+                if let Some(window_id) = *wid_cell.borrow() {
+                    let hash = ruby.hash_new();
+                    let _ = hash.aset(sym(&ruby, "type"), sym(&ruby, "ime_preedit"));
+                    let _ = hash.aset(sym(&ruby, "text"), text);
+                    let _ = hash.aset(sym(&ruby, "cursor_pos"), cursor_pos);
+                    crate::window_store::dispatch_event(&ruby, &window_id, hash);
+                }
+            });
+        }
+    });
+
+    // Dispatch pending committed text (from candidate window selection)
+    PENDING_COMMIT.with(|cell| {
+        if let Some(text) = cell.borrow_mut().take() {
+            IME_WINDOW_ID.with(|wid_cell| {
+                if let Some(window_id) = *wid_cell.borrow() {
+                    let hash = ruby.hash_new();
+                    let _ = hash.aset(sym(&ruby, "type"), sym(&ruby, "received_ime_text"));
+                    let _ = hash.aset(sym(&ruby, "text"), text);
+                    crate::window_store::dispatch_event(&ruby, &window_id, hash);
+                }
+            });
+        }
+    });
+}
+
+#[cfg(not(target_os = "macos"))]
+pub fn setup_ime_swizzle(
+    _window_id: tao::window::WindowId,
+    _ns_view_ptr: usize,
+) {
+}
+
+#[cfg(not(target_os = "macos"))]
+pub fn dispatch_pending_preedit() {}

data/ext/ranma/src/lib.rs

@@ -0,0 +1,42 @@
+mod app;
+mod clipboard;
+mod dpi;
+mod event_loop;
+mod events;
+mod hotkey;
+mod ime;
+mod menu;
+mod monitor;
+mod painter;
+mod proxy;
+mod surface;
+mod theme;
+mod tray;
+mod webview;
+mod window;
+mod window_store;
+
+use magnus::{Error, Ruby};
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("Ranma")?;
+
+    dpi::define_dpi_classes(ruby, &module)?;
+    window::define_window_class(ruby, &module)?;
+    window::define_app_window_class(ruby, &module)?;
+    event_loop::define_event_loop(ruby, &module)?;
+    proxy::define_proxy_class(ruby, &module)?;
+    monitor::define_monitor_class(ruby, &module)?;
+    app::define_app(ruby, &module)?;
+    menu::define_menu_classes(ruby, &module)?;
+    tray::define_tray_class(ruby, &module)?;
+    theme::define_theme_class(ruby, &module)?;
+    clipboard::define_clipboard_class(ruby, &module)?;
+    hotkey::define_hotkey_class(ruby, &module)?;
+    webview::define_webview_class(ruby, &module)?;
+    surface::define_surface_class(ruby, &module)?;
+    painter::define_painter_classes(ruby, &module)?;
+
+    Ok(())
+}