ranma 0.1.0

data/ext/ranma/src/proxy.rs

@@ -0,0 +1,34 @@
+use magnus::{method, prelude::*, Error, Ruby};
+use tao::event_loop::EventLoopProxy;
+
+#[magnus::wrap(class = "Ranma::EventLoopProxy", free_immediately, size)]
+pub struct RbEventLoopProxy {
+    inner: EventLoopProxy<()>,
+}
+
+impl RbEventLoopProxy {
+    pub fn new(proxy: EventLoopProxy<()>) -> Self {
+        Self { inner: proxy }
+    }
+
+    pub fn wake(&self) -> Result<(), Error> {
+        self.inner.send_event(()).map_err(|_| {
+            Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                "Event loop no longer exists",
+            )
+        })
+    }
+
+    pub fn inspect(&self) -> String {
+        "#<Ranma::EventLoopProxy>".to_string()
+    }
+}
+
+pub fn define_proxy_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("EventLoopProxy", ruby.class_object())?;
+    class.define_method("wake", method!(RbEventLoopProxy::wake, 0))?;
+    class.define_method("inspect", method!(RbEventLoopProxy::inspect, 0))?;
+    class.define_method("to_s", method!(RbEventLoopProxy::inspect, 0))?;
+    Ok(())
+}

data/ext/ranma/src/surface.rs

@@ -0,0 +1,389 @@
+use std::cell::RefCell;
+use magnus::{function, method, prelude::*, Error, Ruby};
+use vello::wgpu;
+use vello::{RenderParams, Renderer, RendererOptions, Scene};
+
+use crate::window::RbAppWindow;
+use crate::window_store;
+
+struct Inner {
+    device: wgpu::Device,
+    queue: wgpu::Queue,
+    surface: wgpu::Surface<'static>,
+    config: wgpu::SurfaceConfiguration,
+    renderer: Renderer,
+    target_texture: wgpu::Texture,
+    target_view: wgpu::TextureView,
+    blit_pipeline: wgpu::RenderPipeline,
+    blit_bind_group_layout: wgpu::BindGroupLayout,
+    blit_sampler: wgpu::Sampler,
+    width: u32,
+    height: u32,
+}
+
+#[magnus::wrap(class = "Ranma::GpuSurface", free_immediately, size)]
+pub struct RbGpuSurface {
+    inner: RefCell<Inner>,
+}
+
+unsafe impl Send for RbGpuSurface {}
+
+fn create_target_texture(
+    device: &wgpu::Device,
+    width: u32,
+    height: u32,
+) -> (wgpu::Texture, wgpu::TextureView) {
+    let texture = device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("vello_target"),
+        size: wgpu::Extent3d {
+            width: width.max(1),
+            height: height.max(1),
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba8Unorm,
+        usage: wgpu::TextureUsages::STORAGE_BINDING | wgpu::TextureUsages::TEXTURE_BINDING,
+        view_formats: &[],
+    });
+    let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+    (texture, view)
+}
+
+fn create_blit_pipeline(
+    device: &wgpu::Device,
+    surface_format: wgpu::TextureFormat,
+) -> (
+    wgpu::RenderPipeline,
+    wgpu::BindGroupLayout,
+    wgpu::Sampler,
+) {
+    let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        label: Some("blit_shader"),
+        source: wgpu::ShaderSource::Wgsl(include_str!("blit.wgsl").into()),
+    });
+
+    let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+        label: Some("blit_bind_group_layout"),
+        entries: &[
+            wgpu::BindGroupLayoutEntry {
+                binding: 0,
+                visibility: wgpu::ShaderStages::FRAGMENT,
+                ty: wgpu::BindingType::Texture {
+                    sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                    view_dimension: wgpu::TextureViewDimension::D2,
+                    multisampled: false,
+                },
+                count: None,
+            },
+            wgpu::BindGroupLayoutEntry {
+                binding: 1,
+                visibility: wgpu::ShaderStages::FRAGMENT,
+                ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                count: None,
+            },
+        ],
+    });
+
+    let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+        label: Some("blit_pipeline_layout"),
+        bind_group_layouts: &[&bind_group_layout],
+        push_constant_ranges: &[],
+    });
+
+    let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: Some("blit_pipeline"),
+        layout: Some(&pipeline_layout),
+        vertex: wgpu::VertexState {
+            module: &shader,
+            entry_point: Some("vs_main"),
+            buffers: &[],
+            compilation_options: wgpu::PipelineCompilationOptions::default(),
+        },
+        fragment: Some(wgpu::FragmentState {
+            module: &shader,
+            entry_point: Some("fs_main"),
+            targets: &[Some(wgpu::ColorTargetState {
+                format: surface_format,
+                blend: Some(wgpu::BlendState::REPLACE),
+                write_mask: wgpu::ColorWrites::ALL,
+            })],
+            compilation_options: wgpu::PipelineCompilationOptions::default(),
+        }),
+        primitive: wgpu::PrimitiveState {
+            topology: wgpu::PrimitiveTopology::TriangleList,
+            ..Default::default()
+        },
+        depth_stencil: None,
+        multisample: wgpu::MultisampleState::default(),
+        multiview: None,
+        cache: None,
+    });
+
+    let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+        label: Some("blit_sampler"),
+        mag_filter: wgpu::FilterMode::Linear,
+        min_filter: wgpu::FilterMode::Linear,
+        ..Default::default()
+    });
+
+    (pipeline, bind_group_layout, sampler)
+}
+
+impl RbGpuSurface {
+    fn new(window: &RbAppWindow) -> Result<Self, Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let window_id = window.raw_window_id();
+
+        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+            backends: wgpu::Backends::all(),
+            ..Default::default()
+        });
+
+        let surface = window_store::with_window(&window_id, |tao_window| {
+            let target =
+                unsafe { wgpu::SurfaceTargetUnsafe::from_window(tao_window) }.map_err(|e| {
+                    Error::new(
+                        ruby.exception_runtime_error(),
+                        format!("Failed to create surface target: {}", e),
+                    )
+                })?;
+            let surface = unsafe { instance.create_surface_unsafe(target) }.map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to create surface: {}", e),
+                )
+            })?;
+            Ok::<_, Error>(surface)
+        })
+        .ok_or_else(|| {
+            Error::new(ruby.exception_runtime_error(), "Window not found")
+        })??;
+
+        let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
+            power_preference: wgpu::PowerPreference::HighPerformance,
+            compatible_surface: Some(&surface),
+            force_fallback_adapter: false,
+        }))
+        .map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("No suitable GPU adapter found: {}", e),
+            )
+        })?;
+
+        let (device, queue) = pollster::block_on(adapter.request_device(
+            &wgpu::DeviceDescriptor {
+                label: Some("ranma_device"),
+                required_features: wgpu::Features::empty(),
+                required_limits: wgpu::Limits::default(),
+                memory_hints: wgpu::MemoryHints::default(),
+                ..Default::default()
+            },
+        ))
+        .map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to create device: {}", e),
+            )
+        })?;
+
+        let (width, height) = window_store::with_window(&window_id, |tao_window| {
+            let size = tao_window.inner_size();
+            (size.width.max(1), size.height.max(1))
+        })
+        .unwrap_or((800, 600));
+
+        let surface_caps = surface.get_capabilities(&adapter);
+        let surface_format = surface_caps
+            .formats
+            .iter()
+            .find(|f| !f.is_srgb())
+            .copied()
+            .unwrap_or(surface_caps.formats[0]);
+
+        let config = wgpu::SurfaceConfiguration {
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+            format: surface_format,
+            width,
+            height,
+            present_mode: wgpu::PresentMode::AutoVsync,
+            alpha_mode: surface_caps.alpha_modes[0],
+            view_formats: vec![],
+            desired_maximum_frame_latency: 2,
+        };
+        surface.configure(&device, &config);
+
+        let renderer = Renderer::new(
+            &device,
+            RendererOptions {
+                use_cpu: false,
+                antialiasing_support: vello::AaSupport::area_only(),
+                num_init_threads: None,
+                pipeline_cache: None,
+            },
+        )
+        .map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to create Vello renderer: {:?}", e),
+            )
+        })?;
+
+        let (target_texture, target_view) = create_target_texture(&device, width, height);
+        let (blit_pipeline, blit_bind_group_layout, blit_sampler) =
+            create_blit_pipeline(&device, surface_format);
+
+        Ok(RbGpuSurface {
+            inner: RefCell::new(Inner {
+                device,
+                queue,
+                surface,
+                config,
+                renderer,
+                target_texture,
+                target_view,
+                blit_pipeline,
+                blit_bind_group_layout,
+                blit_sampler,
+                width,
+                height,
+            }),
+        })
+    }
+
+    fn resize(&self, width: u32, height: u32) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let width = width.max(1);
+        let height = height.max(1);
+        if width == inner.width && height == inner.height {
+            return Ok(());
+        }
+        inner.width = width;
+        inner.height = height;
+        inner.config.width = width;
+        inner.config.height = height;
+        inner.surface.configure(&inner.device, &inner.config);
+
+        let (texture, view) = create_target_texture(&inner.device, width, height);
+        inner.target_texture = texture;
+        inner.target_view = view;
+        Ok(())
+    }
+
+    fn width(&self) -> u32 {
+        self.inner.borrow().width
+    }
+
+    fn height(&self) -> u32 {
+        self.inner.borrow().height
+    }
+}
+
+impl RbGpuSurface {
+    pub fn render_and_present(&self, scene: &Scene) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let mut inner = self.inner.borrow_mut();
+
+        let width = inner.width;
+        let height = inner.height;
+
+        let Inner {
+            ref device,
+            ref queue,
+            ref mut renderer,
+            ref surface,
+            ref target_view,
+            ref blit_pipeline,
+            ref blit_bind_group_layout,
+            ref blit_sampler,
+            ..
+        } = *inner;
+
+        renderer
+            .render_to_texture(
+                device,
+                queue,
+                scene,
+                target_view,
+                &RenderParams {
+                    base_color: vello::peniko::Color::TRANSPARENT,
+                    width,
+                    height,
+                    antialiasing_method: vello::AaConfig::Area,
+                },
+            )
+            .map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Vello render failed: {:?}", e),
+                )
+            })?;
+
+        let output = surface.get_current_texture().map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to get surface texture: {}", e),
+            )
+        })?;
+        let output_view = output
+            .texture
+            .create_view(&wgpu::TextureViewDescriptor::default());
+
+        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("blit_bind_group"),
+            layout: blit_bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(target_view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::Sampler(blit_sampler),
+                },
+            ],
+        });
+
+        let mut encoder = device
+            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
+                label: Some("blit_encoder"),
+            });
+
+        {
+            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("blit_pass"),
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &output_view,
+                    depth_slice: None,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: None,
+                timestamp_writes: None,
+                occlusion_query_set: None,
+            });
+            rpass.set_pipeline(blit_pipeline);
+            rpass.set_bind_group(0, &bind_group, &[]);
+            rpass.draw(0..3, 0..1);
+        }
+
+        queue.submit(std::iter::once(encoder.finish()));
+        output.present();
+
+        Ok(())
+    }
+}
+
+pub fn define_surface_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("GpuSurface", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RbGpuSurface::new, 1))?;
+    class.define_method("resize", method!(RbGpuSurface::resize, 2))?;
+    class.define_method("width", method!(RbGpuSurface::width, 0))?;
+    class.define_method("height", method!(RbGpuSurface::height, 0))?;
+    Ok(())
+}

data/ext/ranma/src/theme.rs

@@ -0,0 +1,20 @@
+use magnus::{function, prelude::*, Error, Ruby, Symbol};
+
+fn sym(ruby: &Ruby, name: &str) -> Symbol {
+    ruby.sym_new(name).into()
+}
+
+fn ranma_theme_detect() -> Symbol {
+    let ruby = unsafe { Ruby::get_unchecked() };
+    match dark_light::detect() {
+        Ok(dark_light::Mode::Dark) => sym(&ruby, "dark"),
+        Ok(dark_light::Mode::Light) => sym(&ruby, "light"),
+        _ => sym(&ruby, "unspecified"),
+    }
+}
+
+pub fn define_theme_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let theme_class = module.define_class("Theme", ruby.class_object())?;
+    theme_class.define_singleton_method("detect", function!(ranma_theme_detect, 0))?;
+    Ok(())
+}

data/ext/ranma/src/tray.rs

@@ -0,0 +1,251 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use magnus::{function, gc, method, prelude::*, Error, Ruby, RHash, Value};
+use tray_icon::TrayIconBuilder;
+
+struct PendingTray {
+    id: String,
+    tooltip: Option<String>,
+    icon: Option<(Vec<u8>, u32, u32)>,
+    menu_id: Option<String>,
+    visible: bool,
+}
+
+thread_local! {
+    static TRAY_ICONS: RefCell<HashMap<String, tray_icon::TrayIcon>> = RefCell::new(HashMap::new());
+    static PENDING_TRAYS: RefCell<Vec<PendingTray>> = RefCell::new(Vec::new());
+    static TRAY_EVENT_HANDLER: RefCell<Option<Value>> = const { RefCell::new(None) };
+}
+
+pub fn set_tray_event_handler(handler: Value) {
+    gc::register_mark_object(handler);
+    TRAY_EVENT_HANDLER.with(|cell| {
+        *cell.borrow_mut() = Some(handler);
+    });
+}
+
+pub fn call_tray_event_handler(_ruby: &Ruby, hash: RHash) {
+    TRAY_EVENT_HANDLER.with(|cell| {
+        let borrow = cell.borrow();
+        if let Some(ref handler) = *borrow {
+            let result: Result<Value, _> = handler.funcall("call", (hash,));
+            if let Err(e) = result {
+                eprintln!("Ranma: Error in tray event handler: {}", e);
+            }
+        }
+    });
+}
+
+pub fn has_tray_event_handler() -> bool {
+    TRAY_EVENT_HANDLER.with(|cell| cell.borrow().is_some())
+}
+
+pub fn create_pending_trays() {
+    PENDING_TRAYS.with(|cell| {
+        let pending: Vec<PendingTray> = cell.borrow_mut().drain(..).collect();
+        for tray_cfg in pending {
+            let mut builder = TrayIconBuilder::new().with_id(tray_cfg.id.clone());
+            if let Some(ref tooltip) = tray_cfg.tooltip {
+                builder = builder.with_tooltip(tooltip);
+            }
+            if let Some((rgba, width, height)) = tray_cfg.icon {
+                if let Ok(icon) = tray_icon::Icon::from_rgba(rgba, width, height) {
+                    builder = builder.with_icon(icon);
+                }
+            }
+            if let Some(ref menu_id) = tray_cfg.menu_id {
+                let menu_id_clone = menu_id.clone();
+                crate::menu::with_menu(&menu_id_clone, |menu| {
+                    // We need to take ownership of builder temporarily
+                    builder = std::mem::replace(&mut builder, TrayIconBuilder::new())
+                        .with_menu(Box::new(menu.clone()));
+                });
+            }
+            match builder.build() {
+                Ok(tray_icon) => {
+                    if !tray_cfg.visible {
+                        let _ = tray_icon.set_visible(false);
+                    }
+                    TRAY_ICONS.with(|icons| {
+                        icons.borrow_mut().insert(tray_cfg.id, tray_icon);
+                    });
+                }
+                Err(e) => eprintln!("Ranma: Failed to create tray icon: {}", e),
+            }
+        }
+    });
+}
+
+pub fn clear_all() {
+    TRAY_ICONS.with(|cell| cell.borrow_mut().clear());
+    PENDING_TRAYS.with(|cell| cell.borrow_mut().clear());
+    TRAY_EVENT_HANDLER.with(|cell| *cell.borrow_mut() = None);
+}
+
+#[magnus::wrap(class = "Ranma::TrayIcon", free_immediately, size)]
+pub struct RbTrayIcon {
+    tray_id: String,
+}
+
+fn default_icon_rgba() -> (Vec<u8>, u32, u32) {
+    // 22x22 simple filled circle icon (suitable for macOS menu bar)
+    let size: u32 = 22;
+    let mut rgba = vec![0u8; (size * size * 4) as usize];
+    let center = size as f64 / 2.0;
+    let radius = center - 2.0;
+    for y in 0..size {
+        for x in 0..size {
+            let dx = x as f64 - center;
+            let dy = y as f64 - center;
+            let dist = (dx * dx + dy * dy).sqrt();
+            let idx = ((y * size + x) * 4) as usize;
+            if dist <= radius {
+                // Dark gray filled circle
+                rgba[idx] = 80;     // R
+                rgba[idx + 1] = 80; // G
+                rgba[idx + 2] = 80; // B
+                rgba[idx + 3] = 255; // A
+            }
+        }
+    }
+    (rgba, size, size)
+}
+
+impl RbTrayIcon {
+    fn new() -> Self {
+        let id = format!("tray_{}", uuid_simple());
+        let default_icon = default_icon_rgba();
+        PENDING_TRAYS.with(|cell| {
+            cell.borrow_mut().push(PendingTray {
+                id: id.clone(),
+                tooltip: None,
+                icon: Some(default_icon),
+                menu_id: None,
+                visible: true,
+            });
+        });
+        RbTrayIcon { tray_id: id }
+    }
+
+    fn set_tooltip(&self, text: String) {
+        let updated = TRAY_ICONS.with(|cell| {
+            let icons = cell.borrow();
+            if let Some(icon) = icons.get(&self.tray_id) {
+                let _ = icon.set_tooltip(Some(&text));
+                true
+            } else {
+                false
+            }
+        });
+        if !updated {
+            PENDING_TRAYS.with(|cell| {
+                let mut pending = cell.borrow_mut();
+                if let Some(p) = pending.iter_mut().find(|p| p.id == self.tray_id) {
+                    p.tooltip = Some(text);
+                }
+            });
+        }
+    }
+
+    fn set_icon(&self, rgba: Vec<u8>, width: u32, height: u32) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let updated = TRAY_ICONS.with(|cell| {
+            let icons = cell.borrow();
+            if let Some(icon) = icons.get(&self.tray_id) {
+                match tray_icon::Icon::from_rgba(rgba.clone(), width, height) {
+                    Ok(tray_icon_icon) => {
+                        let _ = icon.set_icon(Some(tray_icon_icon));
+                        Ok(true)
+                    }
+                    Err(e) => Err(Error::new(
+                        ruby.exception_runtime_error(),
+                        format!("Invalid icon data: {}", e),
+                    )),
+                }
+            } else {
+                Ok(false)
+            }
+        })?;
+        if !updated {
+            PENDING_TRAYS.with(|cell| {
+                let mut pending = cell.borrow_mut();
+                if let Some(p) = pending.iter_mut().find(|p| p.id == self.tray_id) {
+                    p.icon = Some((rgba, width, height));
+                }
+            });
+        }
+        Ok(())
+    }
+
+    fn set_menu(&self, menu_id: String) {
+        let updated = TRAY_ICONS.with(|cell| {
+            let icons = cell.borrow();
+            if let Some(icon) = icons.get(&self.tray_id) {
+                crate::menu::with_menu(&menu_id, |menu| {
+                    let _ = icon.set_menu(Some(Box::new(menu.clone())));
+                });
+                true
+            } else {
+                false
+            }
+        });
+        if !updated {
+            PENDING_TRAYS.with(|cell| {
+                let mut pending = cell.borrow_mut();
+                if let Some(p) = pending.iter_mut().find(|p| p.id == self.tray_id) {
+                    p.menu_id = Some(menu_id);
+                }
+            });
+        }
+    }
+
+    fn set_visible(&self, visible: bool) {
+        let updated = TRAY_ICONS.with(|cell| {
+            let icons = cell.borrow();
+            if let Some(icon) = icons.get(&self.tray_id) {
+                let _ = icon.set_visible(visible);
+                true
+            } else {
+                false
+            }
+        });
+        if !updated {
+            PENDING_TRAYS.with(|cell| {
+                let mut pending = cell.borrow_mut();
+                if let Some(p) = pending.iter_mut().find(|p| p.id == self.tray_id) {
+                    p.visible = visible;
+                }
+            });
+        }
+    }
+
+    fn id(&self) -> String {
+        self.tray_id.clone()
+    }
+
+    fn inspect(&self) -> String {
+        format!("#<Ranma::TrayIcon id={}>", self.tray_id)
+    }
+}
+
+fn uuid_simple() -> String {
+    use std::time::{SystemTime, UNIX_EPOCH};
+    let t = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos();
+    format!("{:x}", t)
+}
+
+pub fn define_tray_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("TrayIcon", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RbTrayIcon::new, 0))?;
+    class.define_method("set_tooltip", method!(RbTrayIcon::set_tooltip, 1))?;
+    class.define_method("set_icon", method!(RbTrayIcon::set_icon, 3))?;
+    class.define_method("set_menu", method!(RbTrayIcon::set_menu, 1))?;
+    class.define_method("set_visible", method!(RbTrayIcon::set_visible, 1))?;
+    class.define_method("id", method!(RbTrayIcon::id, 0))?;
+    class.define_method("inspect", method!(RbTrayIcon::inspect, 0))?;
+    class.define_method("to_s", method!(RbTrayIcon::inspect, 0))?;
+    Ok(())
+}