feat: Added monitor stdlib

Cargo.lock

@@ -1461,6 +1461,7 @@ dependencies = [
  "chrono",
  "colored",
  "ewwii_shared_util",
+ "gtk",
  "log",
  "once_cell",
  "rhai",

crates/iirhai/Cargo.toml

@@ -12,6 +12,7 @@ homepage = "https://github.com/byson94/ewwii"
 rhai = { version = "1.22.2", features = ["internals"] }
 ewwii_shared_util.workspace = true
 anyhow.workspace = true
+gtk.workspace = true
 tokio-util.workspace = true
 tokio = { workspace = true, features = ["full"] }
 log.workspace = true
@@ -24,4 +25,4 @@ serde = { workspace = true, features = ["derive"] }
 chrono.workspace = true
 textwrap.workspace =true
 termsize.workspace = true
-ahash.workspace = true
+ahash.workspace = true

crates/iirhai/src/providers/stdlib/mod.rs

@@ -1,12 +1,13 @@
 pub mod env;
 pub mod text;
+pub mod monitor;
 
 use crate::module_resolver::{ChainedResolver, SimpleFileResolver};
 use rhai::module_resolvers::StaticModuleResolver;
 use rhai::{exported_module, Engine};
 
 pub fn register_stdlib(engine: &mut Engine) {
-    use crate::providers::stdlib::{env::env, text::text};
+    use crate::providers::stdlib::{env::env, text::text, monitor::monitor};
 
     let mut resolver = StaticModuleResolver::new();
 
@@ -15,10 +16,12 @@ pub fn register_stdlib(engine: &mut Engine) {
     // adding modules
     let text_mod = exported_module!(text);
     let env_mod = exported_module!(env);
+    let monitor_mod = exported_module!(monitor);
 
     // inserting modules
     resolver.insert("std::text", text_mod);
     resolver.insert("std::env", env_mod);
+    resolver.insert("std::env", monitor_mod);
 
     // Register the resolver
     engine.set_module_resolver(chained);

crates/iirhai/src/providers/stdlib/monitor.rs

@@ -0,0 +1,76 @@
+use rhai::plugin::*;
+use gtk::prelude::*;
+use gtk::gdk;
+
+#[export_module]
+pub mod monitor {
+    pub fn count() -> i64 {
+        get_monitor_count()
+    }
+
+    pub fn primary_resolution() -> (i64, i64) {
+        get_primary_monitor_resolution()
+    }
+
+    pub fn all_resolutions() -> Vec<(i64, i64)> {
+        get_all_monitor_resolutions()
+    }
+
+    pub fn dimensions(index: i64) -> (i64, i64, i64, i64) {
+        get_monitor_dimensions(index as usize)
+    }
+
+    pub fn dpi(index: i64) -> f64 {
+        get_monitor_dpi(index as usize)
+    }
+}
+
+fn get_monitor_count() -> i64 {
+    let display = gdk::Display::default().expect("No display found");
+    display.n_monitors() as i64
+}
+
+fn get_primary_monitor_resolution() -> (i64, i64) {
+    let display = gdk::Display::default().expect("No display found");
+    if let Some(primary) = display.primary_monitor() {
+        let rect = primary.geometry();
+        (rect.width() as i64, rect.height() as i64)
+    } else {
+        (0, 0)
+    }
+}
+
+fn get_all_monitor_resolutions() -> Vec<(i64, i64)> {
+    let display = gdk::Display::default().expect("No display found");
+    (0..display.n_monitors())
+        .filter_map(|i| display.monitor(i))
+        .map(|m| {
+            let rect = m.geometry();
+            (rect.width() as i64, rect.height() as i64)
+        })
+        .collect()
+}
+
+fn get_monitor_dimensions(index: usize) -> (i64, i64, i64, i64) {
+    let display = gdk::Display::default().expect("No display found");
+    if let Some(m) = display.monitor(index as i32) {
+        let geom = m.geometry();
+        (
+            geom.x() as i64,
+            geom.y() as i64,
+            geom.width() as i64,
+            geom.height() as i64,
+        )
+    } else {
+        (0, 0, 0, 0)
+    }
+}
+
+fn get_monitor_dpi(index: usize) -> f64 {
+    let display = gdk::Display::default().expect("No display found");
+    if let Some(m) = display.monitor(index as i32) {
+        m.scale_factor() as f64 * 96.0 // base DPI * scale factor
+    } else {
+        0.0
+    }
+}