ranma 0.1.0

data/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["ext/ranma"]
+resolver = "2"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yasushi Itoh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,293 @@
+# ranma
+
+> Ruby bindings for native windowing, GPU 2D rendering, and WebView — powered by Rust.
+> Wraps [tao](https://github.com/tauri-apps/tao), [wry](https://github.com/tauri-apps/wry),
+> [Vello](https://github.com/linebender/vello), [muda](https://github.com/tauri-apps/muda), and more.
+
+[![Gem Version](https://badge.fury.io/rb/ranma.svg)](https://badge.fury.io/rb/ranma)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+![Platform: macOS](https://img.shields.io/badge/platform-macOS-lightgrey)
+
+## Features
+
+- Native windows with full event handling (keyboard, mouse, IME, resize, DPI)
+- Native menu bar (via [muda](https://github.com/tauri-apps/muda))
+- System tray icon with menu (via [tray-icon](https://github.com/tauri-apps/tray-icon))
+- Embedded WebView (WKWebView on macOS, via [wry](https://github.com/tauri-apps/wry))
+- GPU-accelerated 2D graphics — rects, circles, arcs, paths, text, images
+  (via [Vello](https://github.com/linebender/vello) + wgpu)
+- Clipboard read/write (via [arboard](https://github.com/1Password/arboard))
+- Global hotkeys (via [global-hotkey](https://github.com/tauri-apps/global-hotkey))
+- System theme detection — dark/light mode (via [dark-light](https://github.com/rust-dark-light/dark-light))
+- Multi-monitor support (monitor enumeration, video modes, exclusive fullscreen)
+- IME preedit support (macOS)
+
+## Requirements
+
+- macOS (primary platform; tao also targets Linux and Windows but those are untested)
+- Ruby >= 3.0
+- Rust toolchain (`cargo`) — required to compile the native extension
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "ranma"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install ranma
+```
+
+## Quick Start
+
+```ruby
+require "ranma"
+
+Ranma::App.start do
+  window = Ranma::AppWindow.new(
+    title: "Hello Ranma!",
+    inner_size: Ranma::LogicalSize.new(800, 600)
+  )
+
+  window.on_event do |event|
+    case event[:type]
+    when :close_requested
+      Ranma::App.exit
+    end
+  end
+
+  window.visible = true
+end
+```
+
+## API
+
+### App Lifecycle
+
+```ruby
+Ranma::App.start { ... }    # Start the event loop; block runs before the loop begins
+Ranma::App.exit             # Request application exit
+Ranma::App.request_redraw   # Request a redraw of all windows
+```
+
+### Window (`Ranma::AppWindow`)
+
+```ruby
+window = Ranma::AppWindow.new(
+  title: "My App",
+  inner_size: Ranma::LogicalSize.new(800, 600)
+)
+
+window.on_event { |event| ... }   # Per-window event handler
+
+window.visible = true
+window.title = "New Title"
+window.resizable = true
+window.decorations = true
+window.inner_size                  # => Ranma::LogicalSize
+window.outer_position              # => Ranma::LogicalPosition
+window.scale_factor                # => Float
+
+window.set_fullscreen_borderless   # Borderless fullscreen
+window.set_fullscreen_exclusive(video_mode)  # Exclusive fullscreen
+window.set_ime_position([x, y])  # or Ranma::LogicalPosition.new(x, y)
+window.setup_ime_preedit           # Enable IME preedit events (macOS)
+```
+
+### Events (Hash with `:type` key)
+
+| Event type | Additional fields |
+|---|---|
+| `:close_requested` | — |
+| `:resized` | `:width`, `:height` |
+| `:moved` | `:x`, `:y` |
+| `:focused` | `:focused` (bool) |
+| `:keyboard_input` | `:state`, `:key_code`, `:modifiers` |
+| `:received_ime_text` | `:text` |
+| `:ime_preedit` | `:text`, `:cursor_start`, `:cursor_end` |
+| `:cursor_moved` | `:x`, `:y` |
+| `:mouse_input` | `:state`, `:button` |
+| `:mouse_wheel` | `:delta_x`, `:delta_y` |
+| `:scale_factor_changed` | `:scale_factor` |
+| `:theme_changed` | `:theme` (`:dark` or `:light`) |
+| `:redraw_requested` | — |
+
+### Menus
+
+```ruby
+menu = Ranma::Menu.new
+submenu = Ranma::Submenu.new("File", enabled: true)
+item = Ranma::MenuItem.new("Open", enabled: true, accelerator: "CmdOrCtrl+O")
+check = Ranma::CheckMenuItem.new("Show Toolbar", enabled: true, checked: true)
+sep = Ranma::PredefinedMenuItem.separator
+quit = Ranma::PredefinedMenuItem.quit
+
+submenu.append(item)
+submenu.append(check)
+submenu.append(sep)
+submenu.append(quit)
+menu.append(submenu)
+menu.init_for_nsapp   # macOS: set as the application menu
+
+Ranma::App.on_menu_event { |event| puts event[:id] }
+```
+
+### System Tray
+
+```ruby
+tray = Ranma::TrayIcon.new(icon_path: "icon.png", menu: menu)
+
+Ranma::App.on_tray_event { |event| puts event.inspect }
+```
+
+### WebView
+
+```ruby
+webview = Ranma::WebView.new(window, url: "https://example.com")
+# or
+webview = Ranma::WebView.new(window, html: "<h1>Hello</h1>")
+
+webview.load_url("https://example.com")
+webview.load_html("<h1>Hello</h1>")
+webview.evaluate_script("document.title")
+webview.reload
+webview.zoom(1.5)
+webview.set_bounds(0, 0, 800, 600)          # positional: (x, y, width, height)
+webview.set_visible(true)
+
+webview.on_ipc_message { |msg| puts msg }
+webview.on_navigation { |url| puts url }
+```
+
+### GPU 2D Graphics
+
+```ruby
+surface = Ranma::GpuSurface.new(window)
+painter = Ranma::Painter.new(surface)
+
+window.on_event do |event|
+  if event[:type] == :redraw_requested
+    painter.clear_all("#ffffff")
+
+    style = Ranma::PainterStyle.new(
+      fill_color: "#3366cc",
+      stroke_color: "#000000",
+      stroke_width: 2.0,
+      font_size: 24.0,
+      border_radius: 8.0
+    )
+    painter.style(style)
+
+    painter.fill_rect(10, 10, 200, 100)
+    painter.stroke_rect(10, 10, 200, 100)
+    painter.fill_circle(150, 150, 50)
+    painter.fill_text("Hello!", 50, 50, nil)   # 4th arg: max_width (Float or nil)
+
+    painter.save
+    painter.translate(100, 100)
+    painter.scale(2.0, 2.0)
+    painter.fill_rect(0, 0, 50, 50)
+    painter.restore
+
+    painter.flush
+  end
+end
+```
+
+#### Available drawing methods
+
+| Method | Description |
+|---|---|
+| `clear_all(color_hex = nil)` | Fill entire surface with a hex color (e.g. `"#ffffff"`); omit to clear to transparent |
+| `style(painter_style)` | Set the active `Ranma::PainterStyle` for subsequent draw calls |
+| `fill_rect(x, y, w, h)` | Filled rectangle (respects `border_radius` from active style) |
+| `stroke_rect(x, y, w, h)` | Stroked rectangle |
+| `fill_circle(cx, cy, r)` | Filled circle |
+| `fill_arc(cx, cy, r, start_angle, end_angle)` | Filled arc |
+| `stroke_arc(cx, cy, r, start_angle, end_angle)` | Stroked arc |
+| `fill_triangle(x1,y1, x2,y2, x3,y3)` | Filled triangle |
+| `fill_text(text, x, y, max_width)` | Text rendering; `max_width` is a Float or `nil` |
+| `measure_text(text)` | Returns `Ranma::PainterFontMetrics` |
+| `draw_image(path, x, y, w, h)` | Draw image from file |
+| `measure_image(path)` | Returns `[width, height]` |
+| `begin_path / path_move_to / path_line_to / fill_path` | Path drawing |
+| `save / restore` | Save/restore transform+clip state |
+| `translate(dx, dy) / scale(sx, sy)` | Transform |
+| `clip(x, y, w, h)` | Clip rectangle |
+| `flush` | Submit frame to GPU |
+
+### Clipboard
+
+```ruby
+Ranma::Clipboard.set_text("Hello, world!")
+text = Ranma::Clipboard.get_text
+Ranma::Clipboard.clear
+```
+
+### HotKey
+
+```ruby
+hotkey = Ranma::HotKey.new(modifiers: [:ctrl, :shift], key: :a)
+hotkey.register { puts "Ctrl+Shift+A pressed!" }
+hotkey.unregister
+```
+
+### Theme
+
+```ruby
+theme = Ranma::Theme.detect  # => :dark | :light | :unspecified
+```
+
+### DPI Types
+
+```ruby
+Ranma::LogicalSize.new(width, height)
+Ranma::PhysicalSize.new(width, height)
+Ranma::LogicalPosition.new(x, y)
+Ranma::PhysicalPosition.new(x, y)
+```
+
+## Examples
+
+The `examples/` directory contains runnable demonstrations:
+
+| File | Description |
+|---|---|
+| `basic_window.rb` | Minimal window using the high-level API |
+| `event_handling.rb` | Per-window event handling |
+| `low_level.rb` | Low-level `Ranma.run` API |
+| `menu_example.rb` | Native menu bar with menu events |
+| `full_featured.rb` | Full demo: menus, tray, IME, monitors |
+| `clipboard_example.rb` | Clipboard read/write operations |
+| `hotkey_example.rb` | Global hotkey registration |
+| `webview_example.rb` | Embedded WebView (wry) |
+| `painter_example.rb` | GPU-accelerated 2D drawing (Vello + Painter) |
+
+Run any example with:
+
+```bash
+bundle exec ruby examples/basic_window.rb
+```
+
+## Building from Source
+
+```bash
+git clone https://github.com/i2y/ranma
+cd ranma
+bundle install
+bundle exec rake compile
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE)

data/ext/ranma/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "ranma"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = "0.8"
+rb-sys = "*"
+tao = "0.34"
+muda = "0.17"
+tray-icon = "0.21"
+dark-light = "2.0"
+arboard = "3.6"
+global-hotkey = "0.7"
+wry = { version = "0.54", features = ["devtools"] }
+vello = "0.7"
+parley = "0.4"
+image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }
+pollster = "0.4"

data/ext/ranma/extconf.rb

@@ -0,0 +1,4 @@
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("ranma/ranma")

data/ext/ranma/src/app.rs

@@ -0,0 +1,231 @@
+use std::cell::RefCell;
+use std::sync::OnceLock;
+use magnus::{function, gc, prelude::*, block::Proc, Error, Ruby, Symbol, Value};
+use tao::event::{Event, StartCause};
+use tao::event_loop::{ControlFlow, EventLoopBuilder, EventLoopProxy, EventLoopWindowTarget};
+
+#[cfg(target_os = "macos")]
+use tao::platform::macos::{ActivationPolicy, EventLoopExtMacOS};
+
+use crate::events::convert_window_event;
+use crate::window_store;
+
+#[derive(Debug)]
+pub enum UserEvent {
+    Exit,
+    Redraw,
+    MenuEvent(muda::MenuEvent),
+    TrayEvent(tray_icon::TrayIconEvent),
+}
+
+static GLOBAL_PROXY: OnceLock<EventLoopProxy<UserEvent>> = OnceLock::new();
+
+fn sym(ruby: &Ruby, name: &str) -> Symbol {
+    ruby.sym_new(name).into()
+}
+
+thread_local! {
+    static EVENT_LOOP_TARGET: RefCell<Option<*const EventLoopWindowTarget<UserEvent>>> = const { RefCell::new(None) };
+    static EXIT_PROXY: RefCell<Option<tao::event_loop::EventLoopProxy<UserEvent>>> = const { RefCell::new(None) };
+    static APP_MENU_HANDLER: RefCell<Option<Value>> = const { RefCell::new(None) };
+}
+
+pub fn with_event_loop_target<F, R>(f: F) -> Option<R>
+where
+    F: FnOnce(&EventLoopWindowTarget<UserEvent>) -> R,
+{
+    EVENT_LOOP_TARGET.with(|cell| {
+        let borrow = cell.borrow();
+        borrow.map(|ptr| {
+            let target = unsafe { &*ptr };
+            f(target)
+        })
+    })
+}
+
+fn ranma_app_start(callback: Proc) -> Result<(), Error> {
+    let mut event_loop = EventLoopBuilder::with_user_event().build();
+
+    #[cfg(target_os = "macos")]
+    {
+        event_loop.set_activation_policy(ActivationPolicy::Regular);
+        event_loop.set_activate_ignoring_other_apps(true);
+    }
+
+    let proxy = event_loop.create_proxy();
+    EXIT_PROXY.with(|cell| {
+        *cell.borrow_mut() = Some(proxy);
+    });
+
+    let _ = GLOBAL_PROXY.set(event_loop.create_proxy());
+
+    // Set up muda menu event handler to forward events via the event loop proxy
+    let menu_proxy = event_loop.create_proxy();
+    muda::MenuEvent::set_event_handler(Some(move |event| {
+        let _ = menu_proxy.send_event(UserEvent::MenuEvent(event));
+    }));
+
+    // Set up tray-icon event handler to forward events via the event loop proxy
+    let tray_proxy = event_loop.create_proxy();
+    tray_icon::TrayIconEvent::set_event_handler(Some(move |event| {
+        let _ = tray_proxy.send_event(UserEvent::TrayEvent(event));
+    }));
+
+    // Set up the event loop target BEFORE calling the callback,
+    // so that AppWindow.new can use it to create windows.
+    EVENT_LOOP_TARGET.with(|cell| {
+        let target: &EventLoopWindowTarget<UserEvent> = &event_loop;
+        *cell.borrow_mut() = Some(target as *const _);
+    });
+
+    // Initialize hotkey manager before setup callback
+    crate::hotkey::init_manager();
+
+    // Call the setup callback BEFORE run().
+    let result = callback.call::<_, Value>(());
+    if let Err(e) = result {
+        eprintln!("Ranma: Error in App.start callback: {}", e);
+        return Err(e);
+    }
+
+    event_loop.run(move |event, event_loop_window_target, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        // Allow Ruby background threads (e.g. image downloaders) to run.
+        // Without this, the GVL is held continuously and other threads starve.
+        unsafe { rb_sys::rb_thread_schedule(); }
+
+        EVENT_LOOP_TARGET.with(|cell| {
+            *cell.borrow_mut() = Some(event_loop_window_target as *const _);
+        });
+
+        let ruby = unsafe { Ruby::get_unchecked() };
+
+        match event {
+            Event::NewEvents(StartCause::Init) => {
+                crate::tray::create_pending_trays();
+            }
+            Event::NewEvents(_) => {
+                while let Ok(event) = global_hotkey::GlobalHotKeyEvent::receiver().try_recv() {
+                    crate::hotkey::dispatch_hotkey_event(event.id());
+                }
+                crate::ime::dispatch_pending_preedit();
+            }
+            Event::UserEvent(UserEvent::Exit) => {
+                *control_flow = ControlFlow::Exit;
+            }
+            Event::UserEvent(UserEvent::Redraw) => {
+                window_store::request_redraw_all();
+            }
+            Event::UserEvent(UserEvent::MenuEvent(e)) => {
+                APP_MENU_HANDLER.with(|cell| {
+                    let borrow = cell.borrow();
+                    if let Some(ref handler) = *borrow {
+                        let hash = ruby.hash_new();
+                        let _ = hash.aset(sym(&ruby, "type"), sym(&ruby, "menu_event"));
+                        let _ = hash.aset(sym(&ruby, "menu_id"), e.id.0.clone());
+                        let result: Result<Value, _> = handler.funcall("call", (hash,));
+                        if let Err(err) = result {
+                            eprintln!("Ranma: Error in menu event handler: {}", err);
+                        }
+                    }
+                });
+            }
+            Event::UserEvent(UserEvent::TrayEvent(e)) => {
+                if let tray_icon::TrayIconEvent::Click {
+                    position,
+                    button,
+                    button_state: tray_icon::MouseButtonState::Up,
+                    ..
+                } = e
+                {
+                    if crate::tray::has_tray_event_handler() {
+                        let hash = ruby.hash_new();
+                        let _ = hash.aset(sym(&ruby, "type"), sym(&ruby, "tray_click"));
+                        let _ = hash.aset(sym(&ruby, "x"), position.x);
+                        let _ = hash.aset(sym(&ruby, "y"), position.y);
+                        let btn_sym = match button {
+                            tray_icon::MouseButton::Left => "left",
+                            tray_icon::MouseButton::Right => "right",
+                            tray_icon::MouseButton::Middle => "middle",
+                        };
+                        let _ = hash.aset(sym(&ruby, "button"), sym(&ruby, btn_sym));
+                        crate::tray::call_tray_event_handler(&ruby, hash);
+                    }
+                }
+            }
+            Event::WindowEvent {
+                event: ref win_event,
+                window_id,
+                ..
+            } => {
+                let event_hash = convert_window_event(&ruby, win_event);
+                window_store::dispatch_event(&ruby, &window_id, event_hash);
+            }
+            Event::RedrawRequested(window_id) => {
+                let hash = ruby.hash_new();
+                let type_key: Symbol = ruby.sym_new("type").into();
+                let type_val: Symbol = ruby.sym_new("redraw_requested").into();
+                let _ = hash.aset(type_key, type_val);
+                window_store::dispatch_event(&ruby, &window_id, hash);
+            }
+            Event::LoopDestroyed => {
+                EVENT_LOOP_TARGET.with(|cell| {
+                    *cell.borrow_mut() = None;
+                });
+                EXIT_PROXY.with(|cell| {
+                    *cell.borrow_mut() = None;
+                });
+                APP_MENU_HANDLER.with(|cell| {
+                    *cell.borrow_mut() = None;
+                });
+                window_store::clear_all();
+                crate::menu::clear_all();
+                crate::tray::clear_all();
+                crate::hotkey::clear_all();
+                crate::webview::clear_all();
+                crate::monitor::clear_video_modes();
+            }
+            _ => {}
+        }
+    });
+}
+
+fn ranma_app_exit() -> Result<(), Error> {
+    EXIT_PROXY.with(|cell| {
+        if let Some(proxy) = cell.borrow().as_ref() {
+            let _ = proxy.send_event(UserEvent::Exit);
+        }
+    });
+    Ok(())
+}
+
+fn ranma_app_request_redraw() -> Result<(), Error> {
+    if let Some(proxy) = GLOBAL_PROXY.get() {
+        let _ = proxy.send_event(UserEvent::Redraw);
+    }
+    Ok(())
+}
+
+fn ranma_app_on_menu_event(handler: Value) -> Result<(), Error> {
+    gc::register_mark_object(handler);
+    APP_MENU_HANDLER.with(|cell| {
+        *cell.borrow_mut() = Some(handler);
+    });
+    Ok(())
+}
+
+fn ranma_app_on_tray_event(handler: Value) -> Result<(), Error> {
+    crate::tray::set_tray_event_handler(handler);
+    Ok(())
+}
+
+pub fn define_app(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let app_class = module.define_class("App", ruby.class_object())?;
+    app_class.define_singleton_method("start", function!(ranma_app_start, 1))?;
+    app_class.define_singleton_method("exit", function!(ranma_app_exit, 0))?;
+    app_class.define_singleton_method("request_redraw", function!(ranma_app_request_redraw, 0))?;
+    app_class.define_singleton_method("on_menu_event", function!(ranma_app_on_menu_event, 1))?;
+    app_class.define_singleton_method("on_tray_event", function!(ranma_app_on_tray_event, 1))?;
+    Ok(())
+}

data/ext/ranma/src/blit.wgsl

@@ -0,0 +1,32 @@
+// Fullscreen triangle blit shader:
+// Copies Vello render_to_texture output (Rgba8Unorm) to surface texture.
+
+@group(0) @binding(0)
+var src_texture: texture_2d<f32>;
+@group(0) @binding(1)
+var src_sampler: sampler;
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertex_index: u32) -> VertexOutput {
+    // Fullscreen triangle: 3 vertices that cover the entire clip space [-1,1]
+    // vertex 0: (-1, -1), vertex 1: (3, -1), vertex 2: (-1, 3)
+    var out: VertexOutput;
+    let x = f32(i32(vertex_index & 1u)) * 4.0 - 1.0;
+    let y = f32(i32(vertex_index >> 1u)) * 4.0 - 1.0;
+    out.position = vec4<f32>(x, y, 0.0, 1.0);
+    out.uv = vec2<f32>(
+        (x + 1.0) * 0.5,
+        (1.0 - y) * 0.5,
+    );
+    return out;
+}
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    return textureSample(src_texture, src_sampler, in.uv);
+}

data/ext/ranma/src/clipboard.rs

@@ -0,0 +1,57 @@
+use magnus::{function, prelude::*, Error, Ruby};
+
+fn ranma_clipboard_get_text() -> Result<String, Error> {
+    let ruby = unsafe { Ruby::get_unchecked() };
+    let mut clipboard = arboard::Clipboard::new().map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to access clipboard: {}", e),
+        )
+    })?;
+    clipboard.get_text().map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to get clipboard text: {}", e),
+        )
+    })
+}
+
+fn ranma_clipboard_set_text(text: String) -> Result<(), Error> {
+    let ruby = unsafe { Ruby::get_unchecked() };
+    let mut clipboard = arboard::Clipboard::new().map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to access clipboard: {}", e),
+        )
+    })?;
+    clipboard.set_text(text).map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to set clipboard text: {}", e),
+        )
+    })
+}
+
+fn ranma_clipboard_clear() -> Result<(), Error> {
+    let ruby = unsafe { Ruby::get_unchecked() };
+    let mut clipboard = arboard::Clipboard::new().map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to access clipboard: {}", e),
+        )
+    })?;
+    clipboard.clear().map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to clear clipboard: {}", e),
+        )
+    })
+}
+
+pub fn define_clipboard_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("Clipboard", ruby.class_object())?;
+    class.define_singleton_method("get_text", function!(ranma_clipboard_get_text, 0))?;
+    class.define_singleton_method("set_text", function!(ranma_clipboard_set_text, 1))?;
+    class.define_singleton_method("clear", function!(ranma_clipboard_clear, 0))?;
+    Ok(())
+}