ranma 0.1.0

data/ext/ranma/src/window.rs

@@ -0,0 +1,691 @@
+use std::cell::RefCell;
+use magnus::{function, method, prelude::*, Error, Ruby, RArray, RHash, Value, TryConvert};
+use tao::window::{Window, WindowBuilder, WindowId};
+use tao::event_loop::EventLoopWindowTarget;
+use tao::dpi::{LogicalSize, Size, Position, LogicalPosition};
+use crate::dpi::{RbPhysicalSize, RbLogicalSize, RbPhysicalPosition, RbLogicalPosition};
+use crate::monitor::{RbMonitorHandle, RbVideoMode, get_tao_video_mode};
+use crate::app;
+use crate::window_store;
+
+#[magnus::wrap(class = "Ranma::Window", free_immediately, size)]
+pub struct RbWindow {
+    inner: RefCell<Option<Window>>,
+}
+
+impl RbWindow {
+    pub fn new_from_tao(window: Window) -> Self {
+        Self {
+            inner: RefCell::new(Some(window)),
+        }
+    }
+
+    fn with_window<F, R>(&self, f: F) -> Result<R, Error>
+    where
+        F: FnOnce(&Window) -> R,
+    {
+        let borrow = self.inner.borrow();
+        match borrow.as_ref() {
+            Some(w) => Ok(f(w)),
+            None => Err(Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                "Window has been destroyed",
+            )),
+        }
+    }
+
+    pub fn id(&self) -> Result<String, Error> {
+        self.with_window(|w| format!("{:?}", w.id()))
+    }
+
+    pub fn title(&self) -> Result<String, Error> {
+        self.with_window(|w| w.title())
+    }
+
+    pub fn set_title(&self, title: String) -> Result<(), Error> {
+        self.with_window(|w| w.set_title(&title))
+    }
+
+    pub fn inner_size(&self) -> Result<RbPhysicalSize, Error> {
+        self.with_window(|w| w.inner_size().into())
+    }
+
+    pub fn outer_size(&self) -> Result<RbPhysicalSize, Error> {
+        self.with_window(|w| w.outer_size().into())
+    }
+
+    pub fn set_inner_size(&self, size: Value) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let s = value_to_size(&ruby, size)?;
+        self.with_window(|w| w.set_inner_size(s))
+    }
+
+    pub fn outer_position(&self) -> Result<RbPhysicalPosition, Error> {
+        self.with_window(|w| {
+            w.outer_position()
+                .map(|p| p.into())
+                .unwrap_or(RbPhysicalPosition::new(0, 0))
+        })
+    }
+
+    pub fn set_outer_position(&self, pos: Value) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let p = value_to_position(&ruby, pos)?;
+        self.with_window(|w| w.set_outer_position(p))
+    }
+
+    pub fn set_visible(&self, visible: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_visible(visible))
+    }
+
+    pub fn is_visible(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_visible())
+    }
+
+    pub fn set_resizable(&self, resizable: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_resizable(resizable))
+    }
+
+    pub fn is_resizable(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_resizable())
+    }
+
+    pub fn set_decorations(&self, decorations: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_decorations(decorations))
+    }
+
+    pub fn is_decorated(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_decorated())
+    }
+
+    pub fn set_always_on_top(&self, always_on_top: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_always_on_top(always_on_top))
+    }
+
+    pub fn is_always_on_top(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_always_on_top())
+    }
+
+    pub fn set_maximized(&self, maximized: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_maximized(maximized))
+    }
+
+    pub fn is_maximized(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_maximized())
+    }
+
+    pub fn set_minimized(&self, minimized: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_minimized(minimized))
+    }
+
+    pub fn is_minimized(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_minimized())
+    }
+
+    pub fn set_fullscreen(&self, fullscreen: bool) -> Result<(), Error> {
+        self.with_window(|w| {
+            if fullscreen {
+                w.set_fullscreen(Some(tao::window::Fullscreen::Borderless(None)));
+            } else {
+                w.set_fullscreen(None);
+            }
+        })
+    }
+
+    pub fn is_fullscreen(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.fullscreen().is_some())
+    }
+
+    pub fn set_cursor_visible(&self, visible: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_cursor_visible(visible))
+    }
+
+    pub fn request_redraw(&self) -> Result<(), Error> {
+        self.with_window(|w| w.request_redraw())
+    }
+
+    pub fn scale_factor(&self) -> Result<f64, Error> {
+        self.with_window(|w| w.scale_factor())
+    }
+
+    pub fn set_focus(&self) -> Result<(), Error> {
+        self.with_window(|w| w.set_focus())
+    }
+
+    pub fn is_focused(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_focused())
+    }
+
+    pub fn drag_window(&self) -> Result<(), Error> {
+        self.with_window(|w| {
+            let _ = w.drag_window();
+        })
+    }
+
+    pub fn destroy(&self) -> Result<(), Error> {
+        let mut borrow = self.inner.borrow_mut();
+        *borrow = None;
+        Ok(())
+    }
+
+    pub fn inspect(&self) -> String {
+        let borrow = self.inner.borrow();
+        match borrow.as_ref() {
+            Some(w) => format!("#<Ranma::Window id={:?} title={:?}>", w.id(), w.title()),
+            None => "#<Ranma::Window (destroyed)>".to_string(),
+        }
+    }
+}
+
+pub fn value_to_size(_ruby: &Ruby, value: Value) -> Result<Size, Error> {
+    if let Ok(ls) = <&RbLogicalSize>::try_convert(value) {
+        return Ok(Size::Logical((*ls).into()));
+    }
+    if let Ok(ps) = <&RbPhysicalSize>::try_convert(value) {
+        return Ok(Size::Physical((*ps).into()));
+    }
+    if let Ok(arr) = <(f64, f64)>::try_convert(value) {
+        return Ok(Size::Logical(LogicalSize::new(arr.0, arr.1)));
+    }
+    Err(Error::new(
+        unsafe { Ruby::get_unchecked() }.exception_type_error(),
+        "Expected PhysicalSize, LogicalSize, or [width, height]",
+    ))
+}
+
+pub fn value_to_position(_ruby: &Ruby, value: Value) -> Result<Position, Error> {
+    if let Ok(lp) = <&RbLogicalPosition>::try_convert(value) {
+        return Ok(Position::Logical((*lp).into()));
+    }
+    if let Ok(pp) = <&RbPhysicalPosition>::try_convert(value) {
+        return Ok(Position::Physical((*pp).into()));
+    }
+    if let Ok(arr) = <(f64, f64)>::try_convert(value) {
+        return Ok(Position::Logical(LogicalPosition::new(arr.0, arr.1)));
+    }
+    Err(Error::new(
+        unsafe { Ruby::get_unchecked() }.exception_type_error(),
+        "Expected PhysicalPosition, LogicalPosition, or [x, y]",
+    ))
+}
+
+pub fn create_window_from_hash(
+    ruby: &Ruby,
+    target: &EventLoopWindowTarget<()>,
+    opts: Option<RHash>,
+) -> Result<RbWindow, Error> {
+    let mut builder = WindowBuilder::new();
+
+    if let Some(opts) = opts {
+        if let Some(title) = opts.get(ruby.sym_new("title")) {
+            if let Ok(t) = String::try_convert(title) {
+                builder = builder.with_title(t);
+            }
+        }
+        if let Some(size) = opts.get(ruby.sym_new("inner_size")) {
+            let s = value_to_size(ruby, size)?;
+            builder = builder.with_inner_size(s);
+        }
+        if let Some(min_size) = opts.get(ruby.sym_new("min_inner_size")) {
+            let s = value_to_size(ruby, min_size)?;
+            builder = builder.with_min_inner_size(s);
+        }
+        if let Some(max_size) = opts.get(ruby.sym_new("max_inner_size")) {
+            let s = value_to_size(ruby, max_size)?;
+            builder = builder.with_max_inner_size(s);
+        }
+        if let Some(pos) = opts.get(ruby.sym_new("position")) {
+            let p = value_to_position(ruby, pos)?;
+            builder = builder.with_position(p);
+        }
+        if let Some(resizable) = opts.get(ruby.sym_new("resizable")) {
+            if let Ok(r) = bool::try_convert(resizable) {
+                builder = builder.with_resizable(r);
+            }
+        }
+        if let Some(visible) = opts.get(ruby.sym_new("visible")) {
+            if let Ok(v) = bool::try_convert(visible) {
+                builder = builder.with_visible(v);
+            }
+        }
+        if let Some(decorations) = opts.get(ruby.sym_new("decorations")) {
+            if let Ok(d) = bool::try_convert(decorations) {
+                builder = builder.with_decorations(d);
+            }
+        }
+        if let Some(transparent) = opts.get(ruby.sym_new("transparent")) {
+            if let Ok(t) = bool::try_convert(transparent) {
+                builder = builder.with_transparent(t);
+            }
+        }
+        if let Some(maximized) = opts.get(ruby.sym_new("maximized")) {
+            if let Ok(m) = bool::try_convert(maximized) {
+                builder = builder.with_maximized(m);
+            }
+        }
+        if let Some(always_on_top) = opts.get(ruby.sym_new("always_on_top")) {
+            if let Ok(a) = bool::try_convert(always_on_top) {
+                builder = builder.with_always_on_top(a);
+            }
+        }
+        if let Some(focused) = opts.get(ruby.sym_new("focused")) {
+            if let Ok(f) = bool::try_convert(focused) {
+                builder = builder.with_focused(f);
+            }
+        }
+    }
+
+    let window = builder.build(target).map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to create window: {}", e),
+        )
+    })?;
+
+    Ok(RbWindow::new_from_tao(window))
+}
+
+pub fn define_window_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("Window", ruby.class_object())?;
+    class.define_method("id", method!(RbWindow::id, 0))?;
+    class.define_method("title", method!(RbWindow::title, 0))?;
+    class.define_method("title=", method!(RbWindow::set_title, 1))?;
+    class.define_method("inner_size", method!(RbWindow::inner_size, 0))?;
+    class.define_method("outer_size", method!(RbWindow::outer_size, 0))?;
+    class.define_method("set_inner_size", method!(RbWindow::set_inner_size, 1))?;
+    class.define_method("outer_position", method!(RbWindow::outer_position, 0))?;
+    class.define_method("set_outer_position", method!(RbWindow::set_outer_position, 1))?;
+    class.define_method("visible=", method!(RbWindow::set_visible, 1))?;
+    class.define_method("visible?", method!(RbWindow::is_visible, 0))?;
+    class.define_method("resizable=", method!(RbWindow::set_resizable, 1))?;
+    class.define_method("resizable?", method!(RbWindow::is_resizable, 0))?;
+    class.define_method("decorations=", method!(RbWindow::set_decorations, 1))?;
+    class.define_method("decorated?", method!(RbWindow::is_decorated, 0))?;
+    class.define_method("always_on_top=", method!(RbWindow::set_always_on_top, 1))?;
+    class.define_method("always_on_top?", method!(RbWindow::is_always_on_top, 0))?;
+    class.define_method("maximized=", method!(RbWindow::set_maximized, 1))?;
+    class.define_method("maximized?", method!(RbWindow::is_maximized, 0))?;
+    class.define_method("minimized=", method!(RbWindow::set_minimized, 1))?;
+    class.define_method("minimized?", method!(RbWindow::is_minimized, 0))?;
+    class.define_method("fullscreen=", method!(RbWindow::set_fullscreen, 1))?;
+    class.define_method("fullscreen?", method!(RbWindow::is_fullscreen, 0))?;
+    class.define_method("cursor_visible=", method!(RbWindow::set_cursor_visible, 1))?;
+    class.define_method("request_redraw", method!(RbWindow::request_redraw, 0))?;
+    class.define_method("scale_factor", method!(RbWindow::scale_factor, 0))?;
+    class.define_method("focus", method!(RbWindow::set_focus, 0))?;
+    class.define_method("focused?", method!(RbWindow::is_focused, 0))?;
+    class.define_method("drag", method!(RbWindow::drag_window, 0))?;
+    class.define_method("destroy", method!(RbWindow::destroy, 0))?;
+    class.define_method("inspect", method!(RbWindow::inspect, 0))?;
+    class.define_method("to_s", method!(RbWindow::inspect, 0))?;
+    Ok(())
+}
+
+// --- High-level API: RbAppWindow ---
+
+#[magnus::wrap(class = "Ranma::AppWindow", free_immediately, size)]
+pub struct RbAppWindow {
+    window_id: WindowId,
+}
+
+unsafe impl Send for RbAppWindow {}
+
+impl RbAppWindow {
+    fn with_window<F, R>(&self, f: F) -> Result<R, Error>
+    where
+        F: FnOnce(&Window) -> R,
+    {
+        window_store::with_window(&self.window_id, f).ok_or_else(|| {
+            Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                "Window has been destroyed",
+            )
+        })
+    }
+
+    pub fn new(opts: Option<RHash>) -> Result<Self, Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+
+        let tao_window = app::with_event_loop_target(|target| {
+            let mut builder = WindowBuilder::new().with_visible(false);
+
+            if let Some(opts) = opts {
+                if let Some(title) = opts.get(ruby.sym_new("title")) {
+                    if let Ok(t) = String::try_convert(title) {
+                        builder = builder.with_title(t);
+                    }
+                }
+                if let Some(size) = opts.get(ruby.sym_new("inner_size")) {
+                    if let Ok(s) = value_to_size(&ruby, size) {
+                        builder = builder.with_inner_size(s);
+                    }
+                }
+                if let Some(min_size) = opts.get(ruby.sym_new("min_inner_size")) {
+                    if let Ok(s) = value_to_size(&ruby, min_size) {
+                        builder = builder.with_min_inner_size(s);
+                    }
+                }
+                if let Some(max_size) = opts.get(ruby.sym_new("max_inner_size")) {
+                    if let Ok(s) = value_to_size(&ruby, max_size) {
+                        builder = builder.with_max_inner_size(s);
+                    }
+                }
+                if let Some(pos) = opts.get(ruby.sym_new("position")) {
+                    if let Ok(p) = value_to_position(&ruby, pos) {
+                        builder = builder.with_position(p);
+                    }
+                }
+                if let Some(resizable) = opts.get(ruby.sym_new("resizable")) {
+                    if let Ok(r) = bool::try_convert(resizable) {
+                        builder = builder.with_resizable(r);
+                    }
+                }
+                if let Some(visible) = opts.get(ruby.sym_new("visible")) {
+                    if let Ok(v) = bool::try_convert(visible) {
+                        builder = builder.with_visible(v);
+                    }
+                }
+                if let Some(decorations) = opts.get(ruby.sym_new("decorations")) {
+                    if let Ok(d) = bool::try_convert(decorations) {
+                        builder = builder.with_decorations(d);
+                    }
+                }
+                if let Some(transparent) = opts.get(ruby.sym_new("transparent")) {
+                    if let Ok(t) = bool::try_convert(transparent) {
+                        builder = builder.with_transparent(t);
+                    }
+                }
+                if let Some(maximized) = opts.get(ruby.sym_new("maximized")) {
+                    if let Ok(m) = bool::try_convert(maximized) {
+                        builder = builder.with_maximized(m);
+                    }
+                }
+                if let Some(always_on_top) = opts.get(ruby.sym_new("always_on_top")) {
+                    if let Ok(a) = bool::try_convert(always_on_top) {
+                        builder = builder.with_always_on_top(a);
+                    }
+                }
+                if let Some(focused) = opts.get(ruby.sym_new("focused")) {
+                    if let Ok(f) = bool::try_convert(focused) {
+                        builder = builder.with_focused(f);
+                    }
+                }
+            }
+
+            builder.build(target)
+        })
+        .ok_or_else(|| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                "Cannot create window: event loop is not running. Call App.start first.",
+            )
+        })?
+        .map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to create window: {}", e),
+            )
+        })?;
+
+        let window_id = tao_window.id();
+        window_store::register(window_id, tao_window);
+
+        Ok(RbAppWindow { window_id })
+    }
+
+    pub fn raw_window_id(&self) -> WindowId {
+        self.window_id
+    }
+
+    pub fn on_event(&self, handler: Value) -> Result<(), Error> {
+        window_store::set_event_handler(&self.window_id, handler);
+        Ok(())
+    }
+
+    pub fn id(&self) -> String {
+        format!("{:?}", self.window_id)
+    }
+
+    pub fn title(&self) -> Result<String, Error> {
+        self.with_window(|w| w.title())
+    }
+
+    pub fn set_title(&self, title: String) -> Result<(), Error> {
+        self.with_window(|w| w.set_title(&title))
+    }
+
+    pub fn inner_size(&self) -> Result<RbPhysicalSize, Error> {
+        self.with_window(|w| w.inner_size().into())
+    }
+
+    pub fn outer_size(&self) -> Result<RbPhysicalSize, Error> {
+        self.with_window(|w| w.outer_size().into())
+    }
+
+    pub fn set_inner_size(&self, size: Value) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let s = value_to_size(&ruby, size)?;
+        self.with_window(|w| w.set_inner_size(s))
+    }
+
+    pub fn outer_position(&self) -> Result<RbPhysicalPosition, Error> {
+        self.with_window(|w| {
+            w.outer_position()
+                .map(|p| p.into())
+                .unwrap_or(RbPhysicalPosition::new(0, 0))
+        })
+    }
+
+    pub fn set_outer_position(&self, pos: Value) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let p = value_to_position(&ruby, pos)?;
+        self.with_window(|w| w.set_outer_position(p))
+    }
+
+    pub fn set_visible(&self, visible: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_visible(visible))
+    }
+
+    pub fn is_visible(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_visible())
+    }
+
+    pub fn set_resizable(&self, resizable: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_resizable(resizable))
+    }
+
+    pub fn is_resizable(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_resizable())
+    }
+
+    pub fn set_decorations(&self, decorations: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_decorations(decorations))
+    }
+
+    pub fn is_decorated(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_decorated())
+    }
+
+    pub fn set_always_on_top(&self, always_on_top: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_always_on_top(always_on_top))
+    }
+
+    pub fn is_always_on_top(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_always_on_top())
+    }
+
+    pub fn set_maximized(&self, maximized: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_maximized(maximized))
+    }
+
+    pub fn is_maximized(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_maximized())
+    }
+
+    pub fn set_minimized(&self, minimized: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_minimized(minimized))
+    }
+
+    pub fn is_minimized(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_minimized())
+    }
+
+    pub fn set_fullscreen(&self, fullscreen: bool) -> Result<(), Error> {
+        self.with_window(|w| {
+            if fullscreen {
+                w.set_fullscreen(Some(tao::window::Fullscreen::Borderless(None)));
+            } else {
+                w.set_fullscreen(None);
+            }
+        })
+    }
+
+    pub fn is_fullscreen(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.fullscreen().is_some())
+    }
+
+    pub fn set_cursor_visible(&self, visible: bool) -> Result<(), Error> {
+        self.with_window(|w| w.set_cursor_visible(visible))
+    }
+
+    pub fn request_redraw(&self) -> Result<(), Error> {
+        self.with_window(|w| w.request_redraw())
+    }
+
+    pub fn scale_factor(&self) -> Result<f64, Error> {
+        self.with_window(|w| w.scale_factor())
+    }
+
+    pub fn set_focus(&self) -> Result<(), Error> {
+        self.with_window(|w| w.set_focus())
+    }
+
+    pub fn is_focused(&self) -> Result<bool, Error> {
+        self.with_window(|w| w.is_focused())
+    }
+
+    pub fn drag_window(&self) -> Result<(), Error> {
+        self.with_window(|w| {
+            let _ = w.drag_window();
+        })
+    }
+
+    pub fn set_ime_position(&self, pos: Value) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let p = value_to_position(&ruby, pos)?;
+        self.with_window(|w| w.set_ime_position(p))
+    }
+
+    pub fn current_monitor(&self) -> Result<Option<RbMonitorHandle>, Error> {
+        self.with_window(|w| w.current_monitor().map(RbMonitorHandle::new))
+    }
+
+    pub fn available_monitors(&self) -> Result<RArray, Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_window(|w| {
+            let arr = ruby.ary_new();
+            for mon in w.available_monitors() {
+                let _ = arr.push(RbMonitorHandle::new(mon));
+            }
+            arr
+        })
+    }
+
+    pub fn primary_monitor(&self) -> Result<Option<RbMonitorHandle>, Error> {
+        self.with_window(|w| w.primary_monitor().map(RbMonitorHandle::new))
+    }
+
+    pub fn set_fullscreen_exclusive(&self, video_mode: &RbVideoMode) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let tao_vm = get_tao_video_mode(video_mode.index()).ok_or_else(|| {
+            Error::new(ruby.exception_runtime_error(), "VideoMode not found")
+        })?;
+        self.with_window(|w| {
+            w.set_fullscreen(Some(tao::window::Fullscreen::Exclusive(tao_vm)));
+        })
+    }
+
+    pub fn set_fullscreen_borderless(&self, monitor: Option<&RbMonitorHandle>) -> Result<(), Error> {
+        let mon = monitor.map(|m| m.inner_clone());
+        self.with_window(|w| {
+            w.set_fullscreen(Some(tao::window::Fullscreen::Borderless(mon)));
+        })
+    }
+
+    #[cfg(target_os = "macos")]
+    pub fn ns_view(&self) -> Result<usize, Error> {
+        use tao::platform::macos::WindowExtMacOS;
+        self.with_window(|w| w.ns_view() as usize)
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    pub fn ns_view(&self) -> Result<usize, Error> {
+        Ok(0)
+    }
+
+    pub fn setup_ime_preedit(&self) -> Result<(), Error> {
+        let ns_view = self.ns_view()?;
+        crate::ime::setup_ime_swizzle(self.window_id, ns_view);
+        Ok(())
+    }
+
+    pub fn destroy(&self) -> Result<(), Error> {
+        window_store::remove(&self.window_id);
+        Ok(())
+    }
+
+    pub fn inspect(&self) -> Result<String, Error> {
+        match window_store::with_window(&self.window_id, |w| {
+            format!("#<Ranma::AppWindow id={:?} title={:?}>", w.id(), w.title())
+        }) {
+            Some(s) => Ok(s),
+            None => Ok("#<Ranma::AppWindow (destroyed)>".to_string()),
+        }
+    }
+}
+
+pub fn define_app_window_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("AppWindow", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RbAppWindow::new, 1))?;
+    class.define_method("on_event", method!(RbAppWindow::on_event, 1))?;
+    class.define_method("id", method!(RbAppWindow::id, 0))?;
+    class.define_method("title", method!(RbAppWindow::title, 0))?;
+    class.define_method("title=", method!(RbAppWindow::set_title, 1))?;
+    class.define_method("inner_size", method!(RbAppWindow::inner_size, 0))?;
+    class.define_method("outer_size", method!(RbAppWindow::outer_size, 0))?;
+    class.define_method("set_inner_size", method!(RbAppWindow::set_inner_size, 1))?;
+    class.define_method("outer_position", method!(RbAppWindow::outer_position, 0))?;
+    class.define_method("set_outer_position", method!(RbAppWindow::set_outer_position, 1))?;
+    class.define_method("visible=", method!(RbAppWindow::set_visible, 1))?;
+    class.define_method("visible?", method!(RbAppWindow::is_visible, 0))?;
+    class.define_method("resizable=", method!(RbAppWindow::set_resizable, 1))?;
+    class.define_method("resizable?", method!(RbAppWindow::is_resizable, 0))?;
+    class.define_method("decorations=", method!(RbAppWindow::set_decorations, 1))?;
+    class.define_method("decorated?", method!(RbAppWindow::is_decorated, 0))?;
+    class.define_method("always_on_top=", method!(RbAppWindow::set_always_on_top, 1))?;
+    class.define_method("always_on_top?", method!(RbAppWindow::is_always_on_top, 0))?;
+    class.define_method("maximized=", method!(RbAppWindow::set_maximized, 1))?;
+    class.define_method("maximized?", method!(RbAppWindow::is_maximized, 0))?;
+    class.define_method("minimized=", method!(RbAppWindow::set_minimized, 1))?;
+    class.define_method("minimized?", method!(RbAppWindow::is_minimized, 0))?;
+    class.define_method("fullscreen=", method!(RbAppWindow::set_fullscreen, 1))?;
+    class.define_method("fullscreen?", method!(RbAppWindow::is_fullscreen, 0))?;
+    class.define_method("cursor_visible=", method!(RbAppWindow::set_cursor_visible, 1))?;
+    class.define_method("request_redraw", method!(RbAppWindow::request_redraw, 0))?;
+    class.define_method("scale_factor", method!(RbAppWindow::scale_factor, 0))?;
+    class.define_method("focus", method!(RbAppWindow::set_focus, 0))?;
+    class.define_method("focused?", method!(RbAppWindow::is_focused, 0))?;
+    class.define_method("drag", method!(RbAppWindow::drag_window, 0))?;
+    class.define_method("set_ime_position", method!(RbAppWindow::set_ime_position, 1))?;
+    class.define_method("current_monitor", method!(RbAppWindow::current_monitor, 0))?;
+    class.define_method("available_monitors", method!(RbAppWindow::available_monitors, 0))?;
+    class.define_method("primary_monitor", method!(RbAppWindow::primary_monitor, 0))?;
+    class.define_method("set_fullscreen_exclusive", method!(RbAppWindow::set_fullscreen_exclusive, 1))?;
+    class.define_method("set_fullscreen_borderless", method!(RbAppWindow::set_fullscreen_borderless, 1))?;
+    class.define_method("ns_view", method!(RbAppWindow::ns_view, 0))?;
+    class.define_method("setup_ime_preedit", method!(RbAppWindow::setup_ime_preedit, 0))?;
+    class.define_method("destroy", method!(RbAppWindow::destroy, 0))?;
+    class.define_method("inspect", method!(RbAppWindow::inspect, 0))?;
+    class.define_method("to_s", method!(RbAppWindow::inspect, 0))?;
+    Ok(())
+}