ranma 0.1.0

data/ext/ranma/src/menu.rs

@@ -0,0 +1,588 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use magnus::{function, method, prelude::*, Error, Ruby, Value, TryConvert};
+
+thread_local! {
+    static MENUS: RefCell<HashMap<String, muda::Menu>> = RefCell::new(HashMap::new());
+    static SUBMENUS: RefCell<HashMap<String, muda::Submenu>> = RefCell::new(HashMap::new());
+    static MENU_ITEMS: RefCell<HashMap<String, muda::MenuItem>> = RefCell::new(HashMap::new());
+    static CHECK_MENU_ITEMS: RefCell<HashMap<String, muda::CheckMenuItem>> = RefCell::new(HashMap::new());
+    static PREDEFINED_ITEMS: RefCell<HashMap<String, muda::PredefinedMenuItem>> = RefCell::new(HashMap::new());
+}
+
+pub fn with_menu<F, R>(id: &str, f: F) -> Option<R>
+where
+    F: FnOnce(&muda::Menu) -> R,
+{
+    MENUS.with(|cell| {
+        let menus = cell.borrow();
+        menus.get(id).map(f)
+    })
+}
+
+pub fn clear_all() {
+    MENUS.with(|cell| cell.borrow_mut().clear());
+    SUBMENUS.with(|cell| cell.borrow_mut().clear());
+    MENU_ITEMS.with(|cell| cell.borrow_mut().clear());
+    CHECK_MENU_ITEMS.with(|cell| cell.borrow_mut().clear());
+    PREDEFINED_ITEMS.with(|cell| cell.borrow_mut().clear());
+}
+
+fn append_item_to_menu(menu: &muda::Menu, item: Value) -> Result<(), Error> {
+    let ruby = unsafe { Ruby::get_unchecked() };
+
+    if let Ok(submenu) = <&RbSubmenu>::try_convert(item) {
+        let id = submenu.menu_id.clone();
+        return SUBMENUS.with(|cell| {
+            let subs = cell.borrow();
+            if let Some(s) = subs.get(&id) {
+                menu.append(s).map_err(|e| {
+                    Error::new(ruby.exception_runtime_error(), format!("Failed to append submenu: {}", e))
+                })
+            } else {
+                Err(Error::new(ruby.exception_runtime_error(), "Submenu not found in registry"))
+            }
+        });
+    }
+    if let Ok(menu_item) = <&RbMenuItem>::try_convert(item) {
+        let id = menu_item.menu_id.clone();
+        return MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            if let Some(i) = items.get(&id) {
+                menu.append(i).map_err(|e| {
+                    Error::new(ruby.exception_runtime_error(), format!("Failed to append menu item: {}", e))
+                })
+            } else {
+                Err(Error::new(ruby.exception_runtime_error(), "MenuItem not found in registry"))
+            }
+        });
+    }
+    if let Ok(check_item) = <&RbCheckMenuItem>::try_convert(item) {
+        let id = check_item.menu_id.clone();
+        return CHECK_MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            if let Some(i) = items.get(&id) {
+                menu.append(i).map_err(|e| {
+                    Error::new(ruby.exception_runtime_error(), format!("Failed to append check menu item: {}", e))
+                })
+            } else {
+                Err(Error::new(ruby.exception_runtime_error(), "CheckMenuItem not found in registry"))
+            }
+        });
+    }
+    if let Ok(predefined) = <&RbPredefinedMenuItem>::try_convert(item) {
+        let id = predefined.menu_id.clone();
+        return PREDEFINED_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            if let Some(i) = items.get(&id) {
+                menu.append(i).map_err(|e| {
+                    Error::new(ruby.exception_runtime_error(), format!("Failed to append predefined item: {}", e))
+                })
+            } else {
+                Err(Error::new(ruby.exception_runtime_error(), "PredefinedMenuItem not found in registry"))
+            }
+        });
+    }
+
+    Err(Error::new(ruby.exception_type_error(), "Expected Submenu, MenuItem, CheckMenuItem, or PredefinedMenuItem"))
+}
+
+fn append_item_to_submenu(submenu: &muda::Submenu, item: Value) -> Result<(), Error> {
+    let ruby = unsafe { Ruby::get_unchecked() };
+
+    if let Ok(sub) = <&RbSubmenu>::try_convert(item) {
+        let id = sub.menu_id.clone();
+        return SUBMENUS.with(|cell| {
+            let subs = cell.borrow();
+            if let Some(s) = subs.get(&id) {
+                submenu.append(s).map_err(|e| {
+                    Error::new(ruby.exception_runtime_error(), format!("Failed to append submenu: {}", e))
+                })
+            } else {
+                Err(Error::new(ruby.exception_runtime_error(), "Submenu not found in registry"))
+            }
+        });
+    }
+    if let Ok(menu_item) = <&RbMenuItem>::try_convert(item) {
+        let id = menu_item.menu_id.clone();
+        return MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            if let Some(i) = items.get(&id) {
+                submenu.append(i).map_err(|e| {
+                    Error::new(ruby.exception_runtime_error(), format!("Failed to append menu item: {}", e))
+                })
+            } else {
+                Err(Error::new(ruby.exception_runtime_error(), "MenuItem not found in registry"))
+            }
+        });
+    }
+    if let Ok(check_item) = <&RbCheckMenuItem>::try_convert(item) {
+        let id = check_item.menu_id.clone();
+        return CHECK_MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            if let Some(i) = items.get(&id) {
+                submenu.append(i).map_err(|e| {
+                    Error::new(ruby.exception_runtime_error(), format!("Failed to append check menu item: {}", e))
+                })
+            } else {
+                Err(Error::new(ruby.exception_runtime_error(), "CheckMenuItem not found in registry"))
+            }
+        });
+    }
+    if let Ok(predefined) = <&RbPredefinedMenuItem>::try_convert(item) {
+        let id = predefined.menu_id.clone();
+        return PREDEFINED_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            if let Some(i) = items.get(&id) {
+                submenu.append(i).map_err(|e| {
+                    Error::new(ruby.exception_runtime_error(), format!("Failed to append predefined item: {}", e))
+                })
+            } else {
+                Err(Error::new(ruby.exception_runtime_error(), "PredefinedMenuItem not found in registry"))
+            }
+        });
+    }
+
+    Err(Error::new(ruby.exception_type_error(), "Expected Submenu, MenuItem, CheckMenuItem, or PredefinedMenuItem"))
+}
+
+// --- Menu ---
+
+#[magnus::wrap(class = "Ranma::Menu", free_immediately, size)]
+pub struct RbMenu {
+    menu_id: String,
+}
+
+impl RbMenu {
+    fn new() -> Self {
+        let menu = muda::Menu::new();
+        let id = menu.id().0.clone();
+        MENUS.with(|cell| {
+            cell.borrow_mut().insert(id.clone(), menu);
+        });
+        RbMenu { menu_id: id }
+    }
+
+    fn append(&self, item: Value) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        MENUS.with(|cell| {
+            let menus = cell.borrow();
+            if let Some(menu) = menus.get(&self.menu_id) {
+                append_item_to_menu(menu, item)
+            } else {
+                Err(Error::new(ruby.exception_runtime_error(), "Menu not found in registry"))
+            }
+        })
+    }
+
+    fn init_for_nsapp(&self) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        MENUS.with(|cell| {
+            let menus = cell.borrow();
+            if let Some(menu) = menus.get(&self.menu_id) {
+                menu.init_for_nsapp();
+                Ok(())
+            } else {
+                Err(Error::new(ruby.exception_runtime_error(), "Menu not found in registry"))
+            }
+        })
+    }
+
+    fn id(&self) -> String {
+        self.menu_id.clone()
+    }
+
+    fn inspect(&self) -> String {
+        format!("#<Ranma::Menu id={}>", self.menu_id)
+    }
+}
+
+// --- Submenu ---
+
+#[magnus::wrap(class = "Ranma::Submenu", free_immediately, size)]
+pub struct RbSubmenu {
+    menu_id: String,
+}
+
+impl RbSubmenu {
+    fn new(text: String, enabled: bool) -> Self {
+        let submenu = muda::Submenu::new(&text, enabled);
+        let id = submenu.id().0.clone();
+        SUBMENUS.with(|cell| {
+            cell.borrow_mut().insert(id.clone(), submenu);
+        });
+        RbSubmenu { menu_id: id }
+    }
+
+    fn append(&self, item: Value) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        SUBMENUS.with(|cell| {
+            let subs = cell.borrow();
+            if let Some(submenu) = subs.get(&self.menu_id) {
+                append_item_to_submenu(submenu, item)
+            } else {
+                Err(Error::new(ruby.exception_runtime_error(), "Submenu not found in registry"))
+            }
+        })
+    }
+
+    fn text(&self) -> String {
+        SUBMENUS.with(|cell| {
+            let subs = cell.borrow();
+            subs.get(&self.menu_id).map(|s| s.text()).unwrap_or_default()
+        })
+    }
+
+    fn set_text(&self, text: String) {
+        SUBMENUS.with(|cell| {
+            let subs = cell.borrow();
+            if let Some(s) = subs.get(&self.menu_id) {
+                s.set_text(&text);
+            }
+        });
+    }
+
+    fn is_enabled(&self) -> bool {
+        SUBMENUS.with(|cell| {
+            let subs = cell.borrow();
+            subs.get(&self.menu_id).map(|s| s.is_enabled()).unwrap_or(false)
+        })
+    }
+
+    fn set_enabled(&self, enabled: bool) {
+        SUBMENUS.with(|cell| {
+            let subs = cell.borrow();
+            if let Some(s) = subs.get(&self.menu_id) {
+                s.set_enabled(enabled);
+            }
+        });
+    }
+
+    fn set_as_windows_menu_for_nsapp(&self) {
+        SUBMENUS.with(|cell| {
+            let subs = cell.borrow();
+            if let Some(s) = subs.get(&self.menu_id) {
+                s.set_as_windows_menu_for_nsapp();
+            }
+        });
+    }
+
+    fn id(&self) -> String {
+        self.menu_id.clone()
+    }
+
+    fn inspect(&self) -> String {
+        let text = self.text();
+        format!("#<Ranma::Submenu id={} text={:?}>", self.menu_id, text)
+    }
+}
+
+// --- MenuItem ---
+
+#[magnus::wrap(class = "Ranma::MenuItem", free_immediately, size)]
+pub struct RbMenuItem {
+    menu_id: String,
+}
+
+impl RbMenuItem {
+    fn new(text: String, enabled: bool) -> Self {
+        let item = muda::MenuItem::new(&text, enabled, None);
+        let id = item.id().0.clone();
+        MENU_ITEMS.with(|cell| {
+            cell.borrow_mut().insert(id.clone(), item);
+        });
+        RbMenuItem { menu_id: id }
+    }
+
+    fn text(&self) -> String {
+        MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            items.get(&self.menu_id).map(|i| i.text()).unwrap_or_default()
+        })
+    }
+
+    fn set_text(&self, text: String) {
+        MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            if let Some(i) = items.get(&self.menu_id) {
+                i.set_text(&text);
+            }
+        });
+    }
+
+    fn is_enabled(&self) -> bool {
+        MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            items.get(&self.menu_id).map(|i| i.is_enabled()).unwrap_or(false)
+        })
+    }
+
+    fn set_enabled(&self, enabled: bool) {
+        MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            if let Some(i) = items.get(&self.menu_id) {
+                i.set_enabled(enabled);
+            }
+        });
+    }
+
+    fn id(&self) -> String {
+        self.menu_id.clone()
+    }
+
+    fn inspect(&self) -> String {
+        let text = self.text();
+        format!("#<Ranma::MenuItem id={} text={:?}>", self.menu_id, text)
+    }
+}
+
+// --- CheckMenuItem ---
+
+#[magnus::wrap(class = "Ranma::CheckMenuItem", free_immediately, size)]
+pub struct RbCheckMenuItem {
+    menu_id: String,
+}
+
+impl RbCheckMenuItem {
+    fn new(text: String, enabled: bool, checked: bool) -> Self {
+        let item = muda::CheckMenuItem::new(&text, enabled, checked, None);
+        let id = item.id().0.clone();
+        CHECK_MENU_ITEMS.with(|cell| {
+            cell.borrow_mut().insert(id.clone(), item);
+        });
+        RbCheckMenuItem { menu_id: id }
+    }
+
+    fn text(&self) -> String {
+        CHECK_MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            items.get(&self.menu_id).map(|i| i.text()).unwrap_or_default()
+        })
+    }
+
+    fn set_text(&self, text: String) {
+        CHECK_MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            if let Some(i) = items.get(&self.menu_id) {
+                i.set_text(&text);
+            }
+        });
+    }
+
+    fn is_enabled(&self) -> bool {
+        CHECK_MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            items.get(&self.menu_id).map(|i| i.is_enabled()).unwrap_or(false)
+        })
+    }
+
+    fn set_enabled(&self, enabled: bool) {
+        CHECK_MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            if let Some(i) = items.get(&self.menu_id) {
+                i.set_enabled(enabled);
+            }
+        });
+    }
+
+    fn is_checked(&self) -> bool {
+        CHECK_MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            items.get(&self.menu_id).map(|i| i.is_checked()).unwrap_or(false)
+        })
+    }
+
+    fn set_checked(&self, checked: bool) {
+        CHECK_MENU_ITEMS.with(|cell| {
+            let items = cell.borrow();
+            if let Some(i) = items.get(&self.menu_id) {
+                i.set_checked(checked);
+            }
+        });
+    }
+
+    fn id(&self) -> String {
+        self.menu_id.clone()
+    }
+
+    fn inspect(&self) -> String {
+        let text = self.text();
+        let checked = self.is_checked();
+        format!("#<Ranma::CheckMenuItem id={} text={:?} checked={}>", self.menu_id, text, checked)
+    }
+}
+
+// --- PredefinedMenuItem ---
+
+#[magnus::wrap(class = "Ranma::PredefinedMenuItem", free_immediately, size)]
+pub struct RbPredefinedMenuItem {
+    menu_id: String,
+}
+
+impl RbPredefinedMenuItem {
+    fn register(item: muda::PredefinedMenuItem) -> Self {
+        let id = item.id().0.clone();
+        PREDEFINED_ITEMS.with(|cell| {
+            cell.borrow_mut().insert(id.clone(), item);
+        });
+        RbPredefinedMenuItem { menu_id: id }
+    }
+
+    fn separator() -> Self {
+        Self::register(muda::PredefinedMenuItem::separator())
+    }
+
+    fn copy(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::copy(text.as_deref()))
+    }
+
+    fn cut(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::cut(text.as_deref()))
+    }
+
+    fn paste(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::paste(text.as_deref()))
+    }
+
+    fn select_all(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::select_all(text.as_deref()))
+    }
+
+    fn undo(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::undo(text.as_deref()))
+    }
+
+    fn redo(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::redo(text.as_deref()))
+    }
+
+    fn minimize(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::minimize(text.as_deref()))
+    }
+
+    fn maximize(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::maximize(text.as_deref()))
+    }
+
+    fn fullscreen(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::fullscreen(text.as_deref()))
+    }
+
+    fn hide(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::hide(text.as_deref()))
+    }
+
+    fn hide_others(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::hide_others(text.as_deref()))
+    }
+
+    fn show_all(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::show_all(text.as_deref()))
+    }
+
+    fn close_window(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::close_window(text.as_deref()))
+    }
+
+    fn quit(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::quit(text.as_deref()))
+    }
+
+    fn about(text: Option<String>) -> Self {
+        let metadata = text.as_ref().map(|t| muda::AboutMetadata {
+            name: Some(t.clone()),
+            ..Default::default()
+        });
+        Self::register(muda::PredefinedMenuItem::about(text.as_deref(), metadata))
+    }
+
+    fn services(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::services(text.as_deref()))
+    }
+
+    fn bring_all_to_front(text: Option<String>) -> Self {
+        Self::register(muda::PredefinedMenuItem::bring_all_to_front(text.as_deref()))
+    }
+
+    fn id(&self) -> String {
+        self.menu_id.clone()
+    }
+
+    fn inspect(&self) -> String {
+        format!("#<Ranma::PredefinedMenuItem id={}>", self.menu_id)
+    }
+}
+
+pub fn define_menu_classes(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    // Menu
+    let menu_class = module.define_class("Menu", ruby.class_object())?;
+    menu_class.define_singleton_method("new", function!(RbMenu::new, 0))?;
+    menu_class.define_method("append", method!(RbMenu::append, 1))?;
+    menu_class.define_method("init_for_nsapp", method!(RbMenu::init_for_nsapp, 0))?;
+    menu_class.define_method("id", method!(RbMenu::id, 0))?;
+    menu_class.define_method("inspect", method!(RbMenu::inspect, 0))?;
+    menu_class.define_method("to_s", method!(RbMenu::inspect, 0))?;
+
+    // Submenu
+    let submenu_class = module.define_class("Submenu", ruby.class_object())?;
+    submenu_class.define_singleton_method("new", function!(RbSubmenu::new, 2))?;
+    submenu_class.define_method("append", method!(RbSubmenu::append, 1))?;
+    submenu_class.define_method("text", method!(RbSubmenu::text, 0))?;
+    submenu_class.define_method("text=", method!(RbSubmenu::set_text, 1))?;
+    submenu_class.define_method("enabled?", method!(RbSubmenu::is_enabled, 0))?;
+    submenu_class.define_method("enabled=", method!(RbSubmenu::set_enabled, 1))?;
+    submenu_class.define_method("set_as_windows_menu_for_nsapp", method!(RbSubmenu::set_as_windows_menu_for_nsapp, 0))?;
+    submenu_class.define_method("id", method!(RbSubmenu::id, 0))?;
+    submenu_class.define_method("inspect", method!(RbSubmenu::inspect, 0))?;
+    submenu_class.define_method("to_s", method!(RbSubmenu::inspect, 0))?;
+
+    // MenuItem
+    let menu_item_class = module.define_class("MenuItem", ruby.class_object())?;
+    menu_item_class.define_singleton_method("new", function!(RbMenuItem::new, 2))?;
+    menu_item_class.define_method("text", method!(RbMenuItem::text, 0))?;
+    menu_item_class.define_method("text=", method!(RbMenuItem::set_text, 1))?;
+    menu_item_class.define_method("enabled?", method!(RbMenuItem::is_enabled, 0))?;
+    menu_item_class.define_method("enabled=", method!(RbMenuItem::set_enabled, 1))?;
+    menu_item_class.define_method("id", method!(RbMenuItem::id, 0))?;
+    menu_item_class.define_method("inspect", method!(RbMenuItem::inspect, 0))?;
+    menu_item_class.define_method("to_s", method!(RbMenuItem::inspect, 0))?;
+
+    // CheckMenuItem
+    let check_item_class = module.define_class("CheckMenuItem", ruby.class_object())?;
+    check_item_class.define_singleton_method("new", function!(RbCheckMenuItem::new, 3))?;
+    check_item_class.define_method("text", method!(RbCheckMenuItem::text, 0))?;
+    check_item_class.define_method("text=", method!(RbCheckMenuItem::set_text, 1))?;
+    check_item_class.define_method("enabled?", method!(RbCheckMenuItem::is_enabled, 0))?;
+    check_item_class.define_method("enabled=", method!(RbCheckMenuItem::set_enabled, 1))?;
+    check_item_class.define_method("checked?", method!(RbCheckMenuItem::is_checked, 0))?;
+    check_item_class.define_method("checked=", method!(RbCheckMenuItem::set_checked, 1))?;
+    check_item_class.define_method("id", method!(RbCheckMenuItem::id, 0))?;
+    check_item_class.define_method("inspect", method!(RbCheckMenuItem::inspect, 0))?;
+    check_item_class.define_method("to_s", method!(RbCheckMenuItem::inspect, 0))?;
+
+    // PredefinedMenuItem
+    let predefined_class = module.define_class("PredefinedMenuItem", ruby.class_object())?;
+    predefined_class.define_singleton_method("separator", function!(RbPredefinedMenuItem::separator, 0))?;
+    predefined_class.define_singleton_method("copy", function!(RbPredefinedMenuItem::copy, 1))?;
+    predefined_class.define_singleton_method("cut", function!(RbPredefinedMenuItem::cut, 1))?;
+    predefined_class.define_singleton_method("paste", function!(RbPredefinedMenuItem::paste, 1))?;
+    predefined_class.define_singleton_method("select_all", function!(RbPredefinedMenuItem::select_all, 1))?;
+    predefined_class.define_singleton_method("undo", function!(RbPredefinedMenuItem::undo, 1))?;
+    predefined_class.define_singleton_method("redo", function!(RbPredefinedMenuItem::redo, 1))?;
+    predefined_class.define_singleton_method("minimize", function!(RbPredefinedMenuItem::minimize, 1))?;
+    predefined_class.define_singleton_method("maximize", function!(RbPredefinedMenuItem::maximize, 1))?;
+    predefined_class.define_singleton_method("fullscreen", function!(RbPredefinedMenuItem::fullscreen, 1))?;
+    predefined_class.define_singleton_method("hide", function!(RbPredefinedMenuItem::hide, 1))?;
+    predefined_class.define_singleton_method("hide_others", function!(RbPredefinedMenuItem::hide_others, 1))?;
+    predefined_class.define_singleton_method("show_all", function!(RbPredefinedMenuItem::show_all, 1))?;
+    predefined_class.define_singleton_method("close_window", function!(RbPredefinedMenuItem::close_window, 1))?;
+    predefined_class.define_singleton_method("quit", function!(RbPredefinedMenuItem::quit, 1))?;
+    predefined_class.define_singleton_method("about", function!(RbPredefinedMenuItem::about, 1))?;
+    predefined_class.define_singleton_method("services", function!(RbPredefinedMenuItem::services, 1))?;
+    predefined_class.define_singleton_method("bring_all_to_front", function!(RbPredefinedMenuItem::bring_all_to_front, 1))?;
+    predefined_class.define_method("id", method!(RbPredefinedMenuItem::id, 0))?;
+    predefined_class.define_method("inspect", method!(RbPredefinedMenuItem::inspect, 0))?;
+    predefined_class.define_method("to_s", method!(RbPredefinedMenuItem::inspect, 0))?;
+
+    Ok(())
+}