ranma 0.1.0

data/ext/ranma/src/webview.rs

@@ -0,0 +1,334 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use magnus::{function, gc, method, prelude::*, Error, RHash, Ruby, TryConvert, Value};
+use wry::dpi::{LogicalPosition, LogicalSize};
+use wry::{Rect, WebViewBuilder};
+
+use crate::window::RbAppWindow;
+use crate::window_store;
+
+thread_local! {
+    static WEBVIEWS: RefCell<HashMap<u64, wry::WebView>> = RefCell::new(HashMap::new());
+    static WEBVIEW_HANDLERS: RefCell<HashMap<u64, WebViewHandlers>> = RefCell::new(HashMap::new());
+    static NEXT_WEBVIEW_ID: RefCell<u64> = const { RefCell::new(1) };
+}
+
+struct WebViewHandlers {
+    ipc_handler: Option<Value>,
+    navigation_handler: Option<Value>,
+}
+
+#[magnus::wrap(class = "Ranma::WebView", free_immediately, size)]
+pub struct RbWebView {
+    webview_id: u64,
+}
+
+unsafe impl Send for RbWebView {}
+
+impl RbWebView {
+    fn with_wry<F, R>(&self, f: F) -> Result<R, Error>
+    where
+        F: FnOnce(&wry::WebView) -> R,
+    {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        WEBVIEWS.with(|cell| {
+            let wvs = cell.borrow();
+            wvs.get(&self.webview_id)
+                .map(|wv| f(wv))
+                .ok_or_else(|| {
+                    Error::new(ruby.exception_runtime_error(), "WebView not found")
+                })
+        })
+    }
+
+    fn new(window: &RbAppWindow, opts: Option<RHash>) -> Result<Self, Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let window_id = window.raw_window_id();
+
+        let webview_id = NEXT_WEBVIEW_ID.with(|cell| {
+            let mut id = cell.borrow_mut();
+            let current = *id;
+            *id += 1;
+            current
+        });
+
+        let mut url_str: Option<String> = None;
+        let mut html_str: Option<String> = None;
+
+        if let Some(opts) = opts {
+            if let Some(u) = opts.get(ruby.sym_new("url")) {
+                if let Ok(s) = String::try_convert(u) {
+                    url_str = Some(s);
+                }
+            }
+            if let Some(h) = opts.get(ruby.sym_new("html")) {
+                if let Ok(s) = String::try_convert(h) {
+                    html_str = Some(s);
+                }
+            }
+        }
+
+        let wv_id_ipc = webview_id;
+        let wv_id_nav = webview_id;
+
+        let webview = window_store::with_window(&window_id, |tao_window| {
+            let mut builder = WebViewBuilder::new()
+                .with_visible(false)
+                .with_ipc_handler(move |request| {
+                    let body = request.body().clone();
+                    WEBVIEW_HANDLERS.with(|cell| {
+                        let handlers = cell.borrow();
+                        if let Some(h) = handlers.get(&wv_id_ipc) {
+                            if let Some(ref handler) = h.ipc_handler {
+                                let result: Result<Value, _> = handler.funcall("call", (body,));
+                                if let Err(e) = result {
+                                    eprintln!("Ranma: Error in IPC handler: {}", e);
+                                }
+                            }
+                        }
+                    });
+                })
+                .with_navigation_handler(move |url: String| -> bool {
+                    WEBVIEW_HANDLERS.with(|cell| {
+                        let handlers = cell.borrow();
+                        if let Some(h) = handlers.get(&wv_id_nav) {
+                            if let Some(ref handler) = h.navigation_handler {
+                                let result: Result<Value, _> = handler.funcall("call", (url,));
+                                match result {
+                                    Ok(val) => bool::try_convert(val).unwrap_or(true),
+                                    Err(e) => {
+                                        eprintln!("Ranma: Error in navigation handler: {}", e);
+                                        true
+                                    }
+                                }
+                            } else {
+                                true
+                            }
+                        } else {
+                            true
+                        }
+                    })
+                });
+
+            if let Some(ref u) = url_str {
+                builder = builder.with_url(u);
+            } else if let Some(ref h) = html_str {
+                builder = builder.with_html(h);
+            }
+
+            builder.build_as_child(tao_window)
+        })
+        .ok_or_else(|| {
+            Error::new(ruby.exception_runtime_error(), "Window not found")
+        })?
+        .map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to create WebView: {}", e),
+            )
+        })?;
+
+        WEBVIEWS.with(|cell| {
+            cell.borrow_mut().insert(webview_id, webview);
+        });
+
+        WEBVIEW_HANDLERS.with(|cell| {
+            cell.borrow_mut().insert(
+                webview_id,
+                WebViewHandlers {
+                    ipc_handler: None,
+                    navigation_handler: None,
+                },
+            );
+        });
+
+        Ok(RbWebView { webview_id })
+    }
+
+    fn load_url(&self, url: String) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_wry(|wv| {
+            wv.load_url(&url).map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to load URL: {}", e),
+                )
+            })
+        })?
+    }
+
+    fn load_html(&self, html: String) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_wry(|wv| {
+            wv.load_html(&html).map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to load HTML: {}", e),
+                )
+            })
+        })?
+    }
+
+    fn evaluate_script(&self, js: String) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_wry(|wv| {
+            wv.evaluate_script(&js).map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to evaluate script: {}", e),
+                )
+            })
+        })?
+    }
+
+    fn set_visible(&self, visible: bool) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_wry(|wv| {
+            wv.set_visible(visible).map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to set visibility: {}", e),
+                )
+            })
+        })?
+    }
+
+    fn set_bounds(&self, x: f64, y: f64, w: f64, h: f64) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_wry(|wv| {
+            wv.set_bounds(Rect {
+                position: wry::dpi::Position::Logical(LogicalPosition::new(x, y)),
+                size: wry::dpi::Size::Logical(LogicalSize::new(w, h)),
+            })
+            .map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to set bounds: {}", e),
+                )
+            })
+        })?
+    }
+
+    fn url(&self) -> Result<String, Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_wry(|wv| {
+            wv.url().map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to get URL: {}", e),
+                )
+            })
+        })?
+    }
+
+    fn set_devtools(&self, open: bool) -> Result<(), Error> {
+        self.with_wry(|wv| {
+            if open {
+                wv.open_devtools();
+            } else {
+                wv.close_devtools();
+            }
+        })
+    }
+
+    fn set_background_color(&self, r: u8, g: u8, b: u8, a: u8) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_wry(|wv| {
+            wv.set_background_color((r, g, b, a)).map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to set background color: {}", e),
+                )
+            })
+        })?
+    }
+
+    fn on_ipc_message(&self, handler: Value) -> Result<(), Error> {
+        gc::register_mark_object(handler);
+        let id = self.webview_id;
+        WEBVIEW_HANDLERS.with(|cell| {
+            if let Some(h) = cell.borrow_mut().get_mut(&id) {
+                h.ipc_handler = Some(handler);
+            }
+        });
+        Ok(())
+    }
+
+    fn on_navigation(&self, handler: Value) -> Result<(), Error> {
+        gc::register_mark_object(handler);
+        let id = self.webview_id;
+        WEBVIEW_HANDLERS.with(|cell| {
+            if let Some(h) = cell.borrow_mut().get_mut(&id) {
+                h.navigation_handler = Some(handler);
+            }
+        });
+        Ok(())
+    }
+
+    fn focus(&self) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_wry(|wv| {
+            wv.focus().map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to focus: {}", e),
+                )
+            })
+        })?
+    }
+
+    fn reload(&self) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_wry(|wv| {
+            wv.reload().map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to reload: {}", e),
+                )
+            })
+        })?
+    }
+
+    fn zoom(&self, factor: f64) -> Result<(), Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        self.with_wry(|wv| {
+            wv.zoom(factor).map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to zoom: {}", e),
+                )
+            })
+        })?
+    }
+
+    fn inspect(&self) -> String {
+        format!("#<Ranma::WebView id={}>", self.webview_id)
+    }
+}
+
+pub fn clear_all() {
+    WEBVIEW_HANDLERS.with(|cell| cell.borrow_mut().clear());
+    WEBVIEWS.with(|cell| cell.borrow_mut().clear());
+}
+
+pub fn define_webview_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("WebView", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RbWebView::new, 2))?;
+    class.define_method("load_url", method!(RbWebView::load_url, 1))?;
+    class.define_method("load_html", method!(RbWebView::load_html, 1))?;
+    class.define_method("evaluate_script", method!(RbWebView::evaluate_script, 1))?;
+    class.define_method("set_visible", method!(RbWebView::set_visible, 1))?;
+    class.define_method("visible=", method!(RbWebView::set_visible, 1))?;
+    class.define_method("set_bounds", method!(RbWebView::set_bounds, 4))?;
+    class.define_method("url", method!(RbWebView::url, 0))?;
+    class.define_method("set_devtools", method!(RbWebView::set_devtools, 1))?;
+    class.define_method("set_background_color", method!(RbWebView::set_background_color, 4))?;
+    class.define_method("on_ipc_message", method!(RbWebView::on_ipc_message, 1))?;
+    class.define_method("on_navigation", method!(RbWebView::on_navigation, 1))?;
+    class.define_method("focus", method!(RbWebView::focus, 0))?;
+    class.define_method("reload", method!(RbWebView::reload, 0))?;
+    class.define_method("zoom", method!(RbWebView::zoom, 1))?;
+    class.define_method("inspect", method!(RbWebView::inspect, 0))?;
+    class.define_method("to_s", method!(RbWebView::inspect, 0))?;
+    Ok(())
+}