ranma 0.1.0

data/ext/ranma/src/dpi.rs

@@ -0,0 +1,227 @@
+use magnus::{function, method, prelude::*, Error, Ruby};
+
+#[magnus::wrap(class = "Ranma::PhysicalSize", free_immediately, size)]
+#[derive(Clone, Copy, Debug)]
+pub struct RbPhysicalSize {
+    pub width: u32,
+    pub height: u32,
+}
+
+impl RbPhysicalSize {
+    pub fn new(width: u32, height: u32) -> Self {
+        Self { width, height }
+    }
+
+    pub fn width(&self) -> u32 {
+        self.width
+    }
+
+    pub fn height(&self) -> u32 {
+        self.height
+    }
+
+    pub fn to_a(&self) -> (u32, u32) {
+        (self.width, self.height)
+    }
+
+    pub fn inspect(&self) -> String {
+        format!("#<Ranma::PhysicalSize {}x{}>", self.width, self.height)
+    }
+
+    pub fn to_s(&self) -> String {
+        format!("{}x{}", self.width, self.height)
+    }
+}
+
+impl From<tao::dpi::PhysicalSize<u32>> for RbPhysicalSize {
+    fn from(size: tao::dpi::PhysicalSize<u32>) -> Self {
+        Self {
+            width: size.width,
+            height: size.height,
+        }
+    }
+}
+
+impl From<RbPhysicalSize> for tao::dpi::PhysicalSize<u32> {
+    fn from(size: RbPhysicalSize) -> Self {
+        tao::dpi::PhysicalSize::new(size.width, size.height)
+    }
+}
+
+#[magnus::wrap(class = "Ranma::LogicalSize", free_immediately, size)]
+#[derive(Clone, Copy, Debug)]
+pub struct RbLogicalSize {
+    pub width: f64,
+    pub height: f64,
+}
+
+impl RbLogicalSize {
+    pub fn new(width: f64, height: f64) -> Self {
+        Self { width, height }
+    }
+
+    pub fn width(&self) -> f64 {
+        self.width
+    }
+
+    pub fn height(&self) -> f64 {
+        self.height
+    }
+
+    pub fn to_a(&self) -> (f64, f64) {
+        (self.width, self.height)
+    }
+
+    pub fn inspect(&self) -> String {
+        format!("#<Ranma::LogicalSize {}x{}>", self.width, self.height)
+    }
+
+    pub fn to_s(&self) -> String {
+        format!("{}x{}", self.width, self.height)
+    }
+}
+
+impl From<tao::dpi::LogicalSize<f64>> for RbLogicalSize {
+    fn from(size: tao::dpi::LogicalSize<f64>) -> Self {
+        Self {
+            width: size.width,
+            height: size.height,
+        }
+    }
+}
+
+impl From<RbLogicalSize> for tao::dpi::LogicalSize<f64> {
+    fn from(size: RbLogicalSize) -> Self {
+        tao::dpi::LogicalSize::new(size.width, size.height)
+    }
+}
+
+#[magnus::wrap(class = "Ranma::PhysicalPosition", free_immediately, size)]
+#[derive(Clone, Copy, Debug)]
+pub struct RbPhysicalPosition {
+    pub x: i32,
+    pub y: i32,
+}
+
+impl RbPhysicalPosition {
+    pub fn new(x: i32, y: i32) -> Self {
+        Self { x, y }
+    }
+
+    pub fn x(&self) -> i32 {
+        self.x
+    }
+
+    pub fn y(&self) -> i32 {
+        self.y
+    }
+
+    pub fn to_a(&self) -> (i32, i32) {
+        (self.x, self.y)
+    }
+
+    pub fn inspect(&self) -> String {
+        format!("#<Ranma::PhysicalPosition ({}, {})>", self.x, self.y)
+    }
+
+    pub fn to_s(&self) -> String {
+        format!("({}, {})", self.x, self.y)
+    }
+}
+
+impl From<tao::dpi::PhysicalPosition<i32>> for RbPhysicalPosition {
+    fn from(pos: tao::dpi::PhysicalPosition<i32>) -> Self {
+        Self { x: pos.x, y: pos.y }
+    }
+}
+
+impl From<RbPhysicalPosition> for tao::dpi::PhysicalPosition<i32> {
+    fn from(pos: RbPhysicalPosition) -> Self {
+        tao::dpi::PhysicalPosition::new(pos.x, pos.y)
+    }
+}
+
+#[magnus::wrap(class = "Ranma::LogicalPosition", free_immediately, size)]
+#[derive(Clone, Copy, Debug)]
+pub struct RbLogicalPosition {
+    pub x: f64,
+    pub y: f64,
+}
+
+impl RbLogicalPosition {
+    pub fn new(x: f64, y: f64) -> Self {
+        Self { x, y }
+    }
+
+    pub fn x(&self) -> f64 {
+        self.x
+    }
+
+    pub fn y(&self) -> f64 {
+        self.y
+    }
+
+    pub fn to_a(&self) -> (f64, f64) {
+        (self.x, self.y)
+    }
+
+    pub fn inspect(&self) -> String {
+        format!("#<Ranma::LogicalPosition ({}, {})>", self.x, self.y)
+    }
+
+    pub fn to_s(&self) -> String {
+        format!("({}, {})", self.x, self.y)
+    }
+}
+
+impl From<tao::dpi::LogicalPosition<f64>> for RbLogicalPosition {
+    fn from(pos: tao::dpi::LogicalPosition<f64>) -> Self {
+        Self { x: pos.x, y: pos.y }
+    }
+}
+
+impl From<RbLogicalPosition> for tao::dpi::LogicalPosition<f64> {
+    fn from(pos: RbLogicalPosition) -> Self {
+        tao::dpi::LogicalPosition::new(pos.x, pos.y)
+    }
+}
+
+pub fn define_dpi_classes(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    // PhysicalSize
+    let physical_size = module.define_class("PhysicalSize", ruby.class_object())?;
+    physical_size.define_singleton_method("new", function!(RbPhysicalSize::new, 2))?;
+    physical_size.define_method("width", method!(RbPhysicalSize::width, 0))?;
+    physical_size.define_method("height", method!(RbPhysicalSize::height, 0))?;
+    physical_size.define_method("to_a", method!(RbPhysicalSize::to_a, 0))?;
+    physical_size.define_method("inspect", method!(RbPhysicalSize::inspect, 0))?;
+    physical_size.define_method("to_s", method!(RbPhysicalSize::to_s, 0))?;
+
+    // LogicalSize
+    let logical_size = module.define_class("LogicalSize", ruby.class_object())?;
+    logical_size.define_singleton_method("new", function!(RbLogicalSize::new, 2))?;
+    logical_size.define_method("width", method!(RbLogicalSize::width, 0))?;
+    logical_size.define_method("height", method!(RbLogicalSize::height, 0))?;
+    logical_size.define_method("to_a", method!(RbLogicalSize::to_a, 0))?;
+    logical_size.define_method("inspect", method!(RbLogicalSize::inspect, 0))?;
+    logical_size.define_method("to_s", method!(RbLogicalSize::to_s, 0))?;
+
+    // PhysicalPosition
+    let physical_position = module.define_class("PhysicalPosition", ruby.class_object())?;
+    physical_position.define_singleton_method("new", function!(RbPhysicalPosition::new, 2))?;
+    physical_position.define_method("x", method!(RbPhysicalPosition::x, 0))?;
+    physical_position.define_method("y", method!(RbPhysicalPosition::y, 0))?;
+    physical_position.define_method("to_a", method!(RbPhysicalPosition::to_a, 0))?;
+    physical_position.define_method("inspect", method!(RbPhysicalPosition::inspect, 0))?;
+    physical_position.define_method("to_s", method!(RbPhysicalPosition::to_s, 0))?;
+
+    // LogicalPosition
+    let logical_position = module.define_class("LogicalPosition", ruby.class_object())?;
+    logical_position.define_singleton_method("new", function!(RbLogicalPosition::new, 2))?;
+    logical_position.define_method("x", method!(RbLogicalPosition::x, 0))?;
+    logical_position.define_method("y", method!(RbLogicalPosition::y, 0))?;
+    logical_position.define_method("to_a", method!(RbLogicalPosition::to_a, 0))?;
+    logical_position.define_method("inspect", method!(RbLogicalPosition::inspect, 0))?;
+    logical_position.define_method("to_s", method!(RbLogicalPosition::to_s, 0))?;
+
+    Ok(())
+}

data/ext/ranma/src/event_loop.rs

@@ -0,0 +1,145 @@
+use std::cell::RefCell;
+use magnus::{function, method, prelude::*, block::Proc, Error, Ruby, RHash, RArray, Symbol, Value, TryConvert, IntoValue};
+use tao::event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget};
+use tao::platform::run_return::EventLoopExtRunReturn;
+use crate::events::convert_event;
+use crate::window::{RbWindow, create_window_from_hash};
+use crate::monitor::RbMonitorHandle;
+
+#[magnus::wrap(class = "Ranma::EventLoopTarget", free_immediately, size)]
+pub struct RbEventLoopTarget {
+    ptr: RefCell<Option<*const EventLoopWindowTarget<()>>>,
+}
+
+unsafe impl Send for RbEventLoopTarget {}
+
+impl RbEventLoopTarget {
+    pub fn new(target: &EventLoopWindowTarget<()>) -> Self {
+        Self {
+            ptr: RefCell::new(Some(target as *const _)),
+        }
+    }
+
+    pub fn invalidate(&self) {
+        *self.ptr.borrow_mut() = None;
+    }
+
+    fn with_target<F, R>(&self, f: F) -> Result<R, Error>
+    where
+        F: FnOnce(&EventLoopWindowTarget<()>) -> R,
+    {
+        let borrow = self.ptr.borrow();
+        match *borrow {
+            Some(ptr) => Ok(f(unsafe { &*ptr })),
+            None => Err(Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                "EventLoopTarget is only valid inside the Ranma.run callback",
+            )),
+        }
+    }
+
+    pub fn create_window(&self, opts: Option<RHash>) -> Result<RbWindow, Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let borrow = self.ptr.borrow();
+        match *borrow {
+            Some(ptr) => {
+                let target = unsafe { &*ptr };
+                create_window_from_hash(&ruby, target, opts)
+            }
+            None => Err(Error::new(
+                ruby.exception_runtime_error(),
+                "EventLoopTarget is only valid inside the Ranma.run callback",
+            )),
+        }
+    }
+
+    pub fn available_monitors(&self) -> Result<RArray, Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_target(|t| {
+            let arr = ruby.ary_new();
+            for m in t.available_monitors() {
+                let _ = arr.push(RbMonitorHandle::new(m));
+            }
+            arr
+        })
+    }
+
+    pub fn primary_monitor(&self) -> Result<Option<RbMonitorHandle>, Error> {
+        self.with_target(|t| {
+            t.primary_monitor().map(|m| RbMonitorHandle::new(m))
+        })
+    }
+}
+
+fn parse_control_flow(value: Value) -> ControlFlow {
+    if value.is_nil() {
+        return ControlFlow::Wait;
+    }
+
+    if let Ok(sym) = Symbol::try_convert(value) {
+        let name: String = sym.funcall("to_s", ()).unwrap_or_default();
+        return match name.as_str() {
+            "wait" => ControlFlow::Wait,
+            "poll" => ControlFlow::Poll,
+            "exit" => ControlFlow::Exit,
+            _ => ControlFlow::Wait,
+        };
+    }
+
+    if let Ok(arr) = <(Symbol, i32)>::try_convert(value) {
+        let name: String = arr.0.funcall("to_s", ()).unwrap_or_default();
+        if name == "exit" {
+            return ControlFlow::ExitWithCode(arr.1);
+        }
+    }
+
+    ControlFlow::Wait
+}
+
+pub fn ranma_run(callback: Proc) -> Result<i32, Error> {
+    let mut event_loop = EventLoop::new();
+
+    let exit_code = event_loop.run_return(|event, target, control_flow| {
+        let ruby = unsafe { Ruby::get_unchecked() };
+
+        *control_flow = ControlFlow::Wait;
+
+        let rb_event = match convert_event(&ruby, &event) {
+            Some(e) => e,
+            None => return,
+        };
+
+        let rb_target = RbEventLoopTarget::new(target);
+        let rb_target_value = rb_target.into_value_with(&ruby);
+
+        let result = callback.call::<_, Value>((rb_event, rb_target_value));
+
+        // Invalidate the target so it can't be used outside the callback
+        if let Ok(target_ref) = <&RbEventLoopTarget>::try_convert(rb_target_value) {
+            target_ref.invalidate();
+        }
+
+        match result {
+            Ok(val) => {
+                *control_flow = parse_control_flow(val);
+            }
+            Err(e) => {
+                eprintln!("Ranma: Error in event callback: {}", e);
+                *control_flow = ControlFlow::ExitWithCode(1);
+            }
+        }
+    });
+
+    Ok(exit_code)
+}
+
+pub fn define_event_loop(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    module.define_module_function("run", function!(ranma_run, 1))?;
+
+    let target_class = module.define_class("EventLoopTarget", ruby.class_object())?;
+    target_class.define_method("create_window", method!(RbEventLoopTarget::create_window, 1))?;
+    target_class.define_method("available_monitors", method!(RbEventLoopTarget::available_monitors, 0))?;
+    target_class.define_method("primary_monitor", method!(RbEventLoopTarget::primary_monitor, 0))?;
+
+    Ok(())
+}

data/ext/ranma/src/events.rs

@@ -0,0 +1,305 @@
+use magnus::{Ruby, RHash, Symbol};
+use tao::event::{Event, WindowEvent, StartCause, DeviceEvent, ElementState, MouseButton, TouchPhase, MouseScrollDelta};
+use tao::keyboard::KeyCode;
+
+fn sym(ruby: &Ruby, name: &str) -> Symbol {
+    ruby.sym_new(name).into()
+}
+
+pub fn start_cause_to_symbol(ruby: &Ruby, cause: &StartCause) -> Symbol {
+    match cause {
+        StartCause::ResumeTimeReached { .. } => sym(ruby, "resume_time_reached"),
+        StartCause::WaitCancelled { .. } => sym(ruby, "wait_cancelled"),
+        StartCause::Poll => sym(ruby, "poll"),
+        StartCause::Init => sym(ruby, "init"),
+        _ => sym(ruby, "unknown"),
+    }
+}
+
+pub fn element_state_to_symbol(ruby: &Ruby, state: &ElementState) -> Symbol {
+    match state {
+        ElementState::Pressed => sym(ruby, "pressed"),
+        ElementState::Released => sym(ruby, "released"),
+        _ => sym(ruby, "unknown"),
+    }
+}
+
+pub fn mouse_button_to_symbol(ruby: &Ruby, button: &MouseButton) -> Symbol {
+    match button {
+        MouseButton::Left => sym(ruby, "left"),
+        MouseButton::Right => sym(ruby, "right"),
+        MouseButton::Middle => sym(ruby, "middle"),
+        MouseButton::Other(n) => sym(ruby, &format!("other_{}", n)),
+        _ => sym(ruby, "unknown"),
+    }
+}
+
+pub fn key_code_to_symbol(ruby: &Ruby, key: &KeyCode) -> Symbol {
+    let name = match key {
+        KeyCode::KeyA => "a",
+        KeyCode::KeyB => "b",
+        KeyCode::KeyC => "c",
+        KeyCode::KeyD => "d",
+        KeyCode::KeyE => "e",
+        KeyCode::KeyF => "f",
+        KeyCode::KeyG => "g",
+        KeyCode::KeyH => "h",
+        KeyCode::KeyI => "i",
+        KeyCode::KeyJ => "j",
+        KeyCode::KeyK => "k",
+        KeyCode::KeyL => "l",
+        KeyCode::KeyM => "m",
+        KeyCode::KeyN => "n",
+        KeyCode::KeyO => "o",
+        KeyCode::KeyP => "p",
+        KeyCode::KeyQ => "q",
+        KeyCode::KeyR => "r",
+        KeyCode::KeyS => "s",
+        KeyCode::KeyT => "t",
+        KeyCode::KeyU => "u",
+        KeyCode::KeyV => "v",
+        KeyCode::KeyW => "w",
+        KeyCode::KeyX => "x",
+        KeyCode::KeyY => "y",
+        KeyCode::KeyZ => "z",
+        KeyCode::Digit0 => "0",
+        KeyCode::Digit1 => "1",
+        KeyCode::Digit2 => "2",
+        KeyCode::Digit3 => "3",
+        KeyCode::Digit4 => "4",
+        KeyCode::Digit5 => "5",
+        KeyCode::Digit6 => "6",
+        KeyCode::Digit7 => "7",
+        KeyCode::Digit8 => "8",
+        KeyCode::Digit9 => "9",
+        KeyCode::Escape => "escape",
+        KeyCode::F1 => "f1",
+        KeyCode::F2 => "f2",
+        KeyCode::F3 => "f3",
+        KeyCode::F4 => "f4",
+        KeyCode::F5 => "f5",
+        KeyCode::F6 => "f6",
+        KeyCode::F7 => "f7",
+        KeyCode::F8 => "f8",
+        KeyCode::F9 => "f9",
+        KeyCode::F10 => "f10",
+        KeyCode::F11 => "f11",
+        KeyCode::F12 => "f12",
+        KeyCode::Backspace => "backspace",
+        KeyCode::Tab => "tab",
+        KeyCode::Enter => "enter",
+        KeyCode::Space => "space",
+        KeyCode::ArrowUp => "up",
+        KeyCode::ArrowDown => "down",
+        KeyCode::ArrowLeft => "left",
+        KeyCode::ArrowRight => "right",
+        KeyCode::ShiftLeft => "left_shift",
+        KeyCode::ShiftRight => "right_shift",
+        KeyCode::ControlLeft => "left_control",
+        KeyCode::ControlRight => "right_control",
+        KeyCode::AltLeft => "left_alt",
+        KeyCode::AltRight => "right_alt",
+        KeyCode::SuperLeft => "left_super",
+        KeyCode::SuperRight => "right_super",
+        KeyCode::Delete => "delete",
+        KeyCode::Home => "home",
+        KeyCode::End => "end",
+        KeyCode::PageUp => "page_up",
+        KeyCode::PageDown => "page_down",
+        KeyCode::Insert => "insert",
+        KeyCode::CapsLock => "caps_lock",
+        KeyCode::NumLock => "num_lock",
+        KeyCode::ScrollLock => "scroll_lock",
+        KeyCode::PrintScreen => "print_screen",
+        KeyCode::Pause => "pause",
+        KeyCode::Minus => "minus",
+        KeyCode::Equal => "equal",
+        KeyCode::BracketLeft => "left_bracket",
+        KeyCode::BracketRight => "right_bracket",
+        KeyCode::Backslash => "backslash",
+        KeyCode::Semicolon => "semicolon",
+        KeyCode::Quote => "quote",
+        KeyCode::Backquote => "backquote",
+        KeyCode::Comma => "comma",
+        KeyCode::Period => "period",
+        KeyCode::Slash => "slash",
+        _ => "unknown",
+    };
+    sym(ruby, name)
+}
+
+pub fn convert_window_event<'a>(ruby: &Ruby, event: &WindowEvent<'a>) -> RHash {
+    let hash = ruby.hash_new();
+    match event {
+        WindowEvent::Resized(size) => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "resized"));
+            let _ = hash.aset(sym(ruby, "width"), size.width);
+            let _ = hash.aset(sym(ruby, "height"), size.height);
+        }
+        WindowEvent::Moved(pos) => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "moved"));
+            let _ = hash.aset(sym(ruby, "x"), pos.x);
+            let _ = hash.aset(sym(ruby, "y"), pos.y);
+        }
+        WindowEvent::CloseRequested => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "close_requested"));
+        }
+        WindowEvent::Destroyed => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "destroyed"));
+        }
+        WindowEvent::DroppedFile(path) => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "dropped_file"));
+            let _ = hash.aset(sym(ruby, "path"), path.to_string_lossy().to_string());
+        }
+        WindowEvent::HoveredFile(path) => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "hovered_file"));
+            let _ = hash.aset(sym(ruby, "path"), path.to_string_lossy().to_string());
+        }
+        WindowEvent::HoveredFileCancelled => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "hovered_file_cancelled"));
+        }
+        WindowEvent::Focused(focused) => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "focused"));
+            let _ = hash.aset(sym(ruby, "focused"), *focused);
+        }
+        WindowEvent::KeyboardInput { event, is_synthetic, .. } => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "keyboard_input"));
+            let _ = hash.aset(sym(ruby, "state"), element_state_to_symbol(ruby, &event.state));
+            let _ = hash.aset(sym(ruby, "key_code"), key_code_to_symbol(ruby, &event.physical_key));
+            let _ = hash.aset(sym(ruby, "is_synthetic"), *is_synthetic);
+        }
+        WindowEvent::CursorMoved { position, .. } => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "cursor_moved"));
+            let _ = hash.aset(sym(ruby, "x"), position.x);
+            let _ = hash.aset(sym(ruby, "y"), position.y);
+        }
+        WindowEvent::CursorEntered { .. } => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "cursor_entered"));
+        }
+        WindowEvent::CursorLeft { .. } => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "cursor_left"));
+        }
+        WindowEvent::MouseWheel { delta, phase, .. } => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "mouse_wheel"));
+            match delta {
+                MouseScrollDelta::LineDelta(x, y) => {
+                    let _ = hash.aset(sym(ruby, "delta_type"), sym(ruby, "line"));
+                    let _ = hash.aset(sym(ruby, "delta_x"), *x as f64);
+                    let _ = hash.aset(sym(ruby, "delta_y"), *y as f64);
+                }
+                MouseScrollDelta::PixelDelta(pos) => {
+                    let _ = hash.aset(sym(ruby, "delta_type"), sym(ruby, "pixel"));
+                    let _ = hash.aset(sym(ruby, "delta_x"), pos.x);
+                    let _ = hash.aset(sym(ruby, "delta_y"), pos.y);
+                }
+                _ => {}
+            }
+            let phase_sym = match phase {
+                TouchPhase::Started => "started",
+                TouchPhase::Moved => "moved",
+                TouchPhase::Ended => "ended",
+                TouchPhase::Cancelled => "cancelled",
+                _ => "unknown",
+            };
+            let _ = hash.aset(sym(ruby, "phase"), sym(ruby, phase_sym));
+        }
+        WindowEvent::MouseInput { state, button, .. } => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "mouse_input"));
+            let _ = hash.aset(sym(ruby, "state"), element_state_to_symbol(ruby, state));
+            let _ = hash.aset(sym(ruby, "button"), mouse_button_to_symbol(ruby, button));
+        }
+        WindowEvent::ScaleFactorChanged { scale_factor, new_inner_size } => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "scale_factor_changed"));
+            let _ = hash.aset(sym(ruby, "scale_factor"), *scale_factor);
+            let _ = hash.aset(sym(ruby, "new_width"), new_inner_size.width);
+            let _ = hash.aset(sym(ruby, "new_height"), new_inner_size.height);
+        }
+        WindowEvent::ModifiersChanged(modifiers) => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "modifiers_changed"));
+            let _ = hash.aset(sym(ruby, "shift"), modifiers.shift_key());
+            let _ = hash.aset(sym(ruby, "ctrl"), modifiers.control_key());
+            let _ = hash.aset(sym(ruby, "alt"), modifiers.alt_key());
+            let _ = hash.aset(sym(ruby, "logo"), modifiers.super_key());
+        }
+        WindowEvent::ThemeChanged(theme) => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "theme_changed"));
+            let theme_sym = match theme {
+                tao::window::Theme::Light => "light",
+                tao::window::Theme::Dark => "dark",
+                _ => "unknown",
+            };
+            let _ = hash.aset(sym(ruby, "theme"), sym(ruby, theme_sym));
+        }
+        WindowEvent::ReceivedImeText(text) => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "received_ime_text"));
+            let _ = hash.aset(sym(ruby, "text"), text.clone());
+        }
+        WindowEvent::DecorationsClick => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "decorations_click"));
+        }
+        _ => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "unknown"));
+        }
+    }
+    hash
+}
+
+pub fn convert_event<'a>(ruby: &Ruby, event: &Event<'a, ()>) -> Option<RHash> {
+    let hash = ruby.hash_new();
+    match event {
+        Event::NewEvents(cause) => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "new_events"));
+            let _ = hash.aset(sym(ruby, "cause"), start_cause_to_symbol(ruby, cause));
+            Some(hash)
+        }
+        Event::WindowEvent { window_id, event, .. } => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "window_event"));
+            let _ = hash.aset(sym(ruby, "window_id"), format!("{:?}", window_id));
+            let _ = hash.aset(sym(ruby, "event"), convert_window_event(ruby, event));
+            Some(hash)
+        }
+        Event::DeviceEvent { event, .. } => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "device_event"));
+            match event {
+                DeviceEvent::MouseMotion { delta, .. } => {
+                    let inner = ruby.hash_new();
+                    let _ = inner.aset(sym(ruby, "type"), sym(ruby, "mouse_motion"));
+                    let _ = inner.aset(sym(ruby, "delta_x"), delta.0);
+                    let _ = inner.aset(sym(ruby, "delta_y"), delta.1);
+                    let _ = hash.aset(sym(ruby, "event"), inner);
+                }
+                _ => {
+                    let inner = ruby.hash_new();
+                    let _ = inner.aset(sym(ruby, "type"), sym(ruby, "unknown"));
+                    let _ = hash.aset(sym(ruby, "event"), inner);
+                }
+            }
+            Some(hash)
+        }
+        Event::MainEventsCleared => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "main_events_cleared"));
+            Some(hash)
+        }
+        Event::RedrawRequested(_window_id) => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "redraw_requested"));
+            Some(hash)
+        }
+        Event::RedrawEventsCleared => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "redraw_events_cleared"));
+            Some(hash)
+        }
+        Event::LoopDestroyed => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "loop_destroyed"));
+            Some(hash)
+        }
+        Event::Suspended => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "suspended"));
+            Some(hash)
+        }
+        Event::Resumed => {
+            let _ = hash.aset(sym(ruby, "type"), sym(ruby, "resumed"));
+            Some(hash)
+        }
+        _ => None,
+    }
+}