ranma 0.1.0

data/ext/ranma/src/monitor.rs

@@ -0,0 +1,149 @@
+use std::cell::RefCell;
+use magnus::{method, prelude::*, Error, RArray, Ruby};
+use tao::monitor::MonitorHandle;
+use crate::dpi::{RbPhysicalSize, RbPhysicalPosition};
+
+thread_local! {
+    static VIDEO_MODES: RefCell<Vec<tao::monitor::VideoMode>> = RefCell::new(Vec::new());
+}
+
+fn store_video_mode(vm: tao::monitor::VideoMode) -> usize {
+    VIDEO_MODES.with(|cell| {
+        let mut modes = cell.borrow_mut();
+        let index = modes.len();
+        modes.push(vm);
+        index
+    })
+}
+
+pub fn get_tao_video_mode(index: usize) -> Option<tao::monitor::VideoMode> {
+    VIDEO_MODES.with(|cell| {
+        let modes = cell.borrow();
+        modes.get(index).cloned()
+    })
+}
+
+pub fn clear_video_modes() {
+    VIDEO_MODES.with(|cell| {
+        cell.borrow_mut().clear();
+    });
+}
+
+#[magnus::wrap(class = "Ranma::VideoMode", free_immediately, size)]
+pub struct RbVideoMode {
+    width: u32,
+    height: u32,
+    bit_depth: u16,
+    refresh_rate: u16,
+    index: usize,
+}
+
+impl RbVideoMode {
+    pub fn width(&self) -> u32 {
+        self.width
+    }
+
+    pub fn height(&self) -> u32 {
+        self.height
+    }
+
+    pub fn bit_depth(&self) -> u16 {
+        self.bit_depth
+    }
+
+    pub fn refresh_rate(&self) -> u16 {
+        self.refresh_rate
+    }
+
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    pub fn inspect(&self) -> String {
+        format!(
+            "#<Ranma::VideoMode {}x{} {}bit @{}Hz>",
+            self.width, self.height, self.bit_depth, self.refresh_rate
+        )
+    }
+}
+
+#[magnus::wrap(class = "Ranma::MonitorHandle", free_immediately, size)]
+pub struct RbMonitorHandle {
+    inner: MonitorHandle,
+}
+
+impl RbMonitorHandle {
+    pub fn new(handle: MonitorHandle) -> Self {
+        Self { inner: handle }
+    }
+
+    pub fn inner_clone(&self) -> MonitorHandle {
+        self.inner.clone()
+    }
+
+    pub fn name(&self) -> Option<String> {
+        self.inner.name()
+    }
+
+    pub fn size(&self) -> RbPhysicalSize {
+        self.inner.size().into()
+    }
+
+    pub fn position(&self) -> RbPhysicalPosition {
+        self.inner.position().into()
+    }
+
+    pub fn scale_factor(&self) -> f64 {
+        self.inner.scale_factor()
+    }
+
+    pub fn video_modes(&self) -> RArray {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let arr = ruby.ary_new();
+        for vm in self.inner.video_modes() {
+            let size = vm.size();
+            let bit_depth = vm.bit_depth();
+            let refresh_rate = vm.refresh_rate();
+            let index = store_video_mode(vm);
+            let rb_vm = RbVideoMode {
+                width: size.width,
+                height: size.height,
+                bit_depth,
+                refresh_rate,
+                index,
+            };
+            let _ = arr.push(rb_vm);
+        }
+        arr
+    }
+
+    pub fn inspect(&self) -> String {
+        format!(
+            "#<Ranma::MonitorHandle name={:?} size={:?} scale_factor={}>",
+            self.inner.name(),
+            self.inner.size(),
+            self.inner.scale_factor()
+        )
+    }
+}
+
+pub fn define_monitor_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("MonitorHandle", ruby.class_object())?;
+    class.define_method("name", method!(RbMonitorHandle::name, 0))?;
+    class.define_method("size", method!(RbMonitorHandle::size, 0))?;
+    class.define_method("position", method!(RbMonitorHandle::position, 0))?;
+    class.define_method("scale_factor", method!(RbMonitorHandle::scale_factor, 0))?;
+    class.define_method("video_modes", method!(RbMonitorHandle::video_modes, 0))?;
+    class.define_method("inspect", method!(RbMonitorHandle::inspect, 0))?;
+    class.define_method("to_s", method!(RbMonitorHandle::inspect, 0))?;
+
+    let vm_class = module.define_class("VideoMode", ruby.class_object())?;
+    vm_class.define_method("width", method!(RbVideoMode::width, 0))?;
+    vm_class.define_method("height", method!(RbVideoMode::height, 0))?;
+    vm_class.define_method("bit_depth", method!(RbVideoMode::bit_depth, 0))?;
+    vm_class.define_method("refresh_rate", method!(RbVideoMode::refresh_rate, 0))?;
+    vm_class.define_method("inspect", method!(RbVideoMode::inspect, 0))?;
+    vm_class.define_method("to_s", method!(RbVideoMode::inspect, 0))?;
+
+    Ok(())
+}