(root: Component, props: P, mut cfg: Config) {
- let mut dom = VirtualDom::new_with_props(root, props);
+pub fn launch_with_props(root: Component, props: P, cfg: Config) {
+ let mut _dom = VirtualDom::new_with_props(root, props);
- let event_loop = EventLoop::with_user_event();
+ let event_loop = EventLoop::::with_user_event();
let proxy = event_loop.create_proxy();
@@ -118,23 +121,26 @@ pub fn launch_with_props(root: Component, props: P, mut cfg: Conf
// We enter the runtime but we poll futures manually, circumventing the per-task runtime budget
let _guard = rt.enter();
- // We want to poll the virtualdom and the event loop at the same time, so the waker will be connected to both
- let waker = waker::tao_waker(&proxy);
-
// We only have one webview right now, but we'll have more later
// Store them in a hashmap so we can remove them when they're closed
- let mut webviews = HashMap::new();
+ let mut webviews = HashMap::::new();
+
+ let queue = Rc::new(RefCell::new(vec![(_dom, cfg)]));
event_loop.run(move |window_event, event_loop, control_flow| {
*control_flow = ControlFlow::Wait;
match window_event {
- Event::UserEvent(UserWindowEvent::CloseWindow) => *control_flow = ControlFlow::Exit,
-
Event::WindowEvent {
event, window_id, ..
} => match event {
- WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+ WindowEvent::CloseRequested => {
+ webviews.remove(&window_id);
+
+ if webviews.is_empty() {
+ *control_flow = ControlFlow::Exit
+ }
+ }
WindowEvent::Destroyed { .. } => {
webviews.remove(&window_id);
@@ -145,78 +151,118 @@ pub fn launch_with_props(root: Component, props: P, mut cfg: Conf
_ => {}
},
- Event::NewEvents(StartCause::Init) => {
- let window = webview::build(&mut cfg, event_loop, proxy.clone());
+ Event::NewEvents(StartCause::Init)
+ | Event::UserEvent(UserWindowEvent(EventData::NewWindow, _)) => {
+ for (dom, mut cfg) in queue.borrow_mut().drain(..) {
+ let webview = webview::build(&mut cfg, event_loop, proxy.clone());
- dom.base_scope()
- .provide_context(DesktopContext::new(window.clone(), proxy.clone()));
+ dom.base_scope().provide_context(DesktopContext::new(
+ webview.clone(),
+ proxy.clone(),
+ queue.clone(),
+ ));
- webviews.insert(window.window().id(), window);
+ let id = webview.window().id();
- _ = proxy.send_event(UserWindowEvent::Poll);
- }
+ // We want to poll the virtualdom and the event loop at the same time, so the waker will be connected to both
+ let waker = waker::tao_waker(&proxy, id);
- Event::UserEvent(UserWindowEvent::Poll) => {
- poll_vdom(&waker, &mut dom, &mut webviews);
- }
+ let handler = WebviewHandler {
+ webview,
+ waker,
+ dom,
+ };
- Event::UserEvent(UserWindowEvent::Ipc(msg)) if msg.method() == "user_event" => {
- let evt = match serde_json::from_value::(msg.params()) {
- Ok(value) => value,
- Err(_) => return,
- };
+ webviews.insert(id, handler);
- dom.handle_event(&evt.name, evt.data.into_any(), evt.element, evt.bubbles);
-
- send_edits(dom.render_immediate(), &mut webviews);
- }
-
- Event::UserEvent(UserWindowEvent::Ipc(msg)) if msg.method() == "initialize" => {
- send_edits(dom.rebuild(), &mut webviews);
- }
-
- // When the webview chirps back with the result of the eval, we send it to the active receiver
- //
- // This currently doesn't perform any targeting to the callsite, so if you eval multiple times at once,
- // you might the wrong result. This should be fixed
- Event::UserEvent(UserWindowEvent::Ipc(msg)) if msg.method() == "eval_result" => {
- dom.base_scope()
- .consume_context::()
- .unwrap()
- .eval
- .send(msg.params())
- .unwrap();
- }
-
- Event::UserEvent(UserWindowEvent::Ipc(msg)) if msg.method() == "browser_open" => {
- if let Some(temp) = msg.params().as_object() {
- if temp.contains_key("href") {
- let open = webbrowser::open(temp["href"].as_str().unwrap());
- if let Err(e) = open {
- log::error!("Open Browser error: {:?}", e);
- }
- }
+ _ = proxy.send_event(UserWindowEvent(EventData::Poll, id));
}
}
+ Event::UserEvent(event) => match event.0 {
+ EventData::CloseWindow => {
+ webviews.remove(&event.1);
+
+ if webviews.is_empty() {
+ *control_flow = ControlFlow::Exit
+ }
+ }
+
+ EventData::Poll => {
+ if let Some(view) = webviews.get_mut(&event.1) {
+ poll_vdom(view);
+ }
+ }
+
+ EventData::Ipc(msg) if msg.method() == "user_event" => {
+ let evt = match serde_json::from_value::(msg.params()) {
+ Ok(value) => value,
+ Err(_) => return,
+ };
+
+ let view = webviews.get_mut(&event.1).unwrap();
+
+ view.dom
+ .handle_event(&evt.name, evt.data.into_any(), evt.element, evt.bubbles);
+
+ send_edits(view.dom.render_immediate(), &view.webview);
+ }
+
+ EventData::Ipc(msg) if msg.method() == "initialize" => {
+ let view = webviews.get_mut(&event.1).unwrap();
+ send_edits(view.dom.rebuild(), &view.webview);
+ }
+
+ // When the webview chirps back with the result of the eval, we send it to the active receiver
+ //
+ // This currently doesn't perform any targeting to the callsite, so if you eval multiple times at once,
+ // you might the wrong result. This should be fixed
+ EventData::Ipc(msg) if msg.method() == "eval_result" => {
+ webviews[&event.1]
+ .dom
+ .base_scope()
+ .consume_context::()
+ .unwrap()
+ .eval
+ .send(msg.params())
+ .unwrap();
+ }
+
+ EventData::Ipc(msg) if msg.method() == "browser_open" => {
+ if let Some(temp) = msg.params().as_object() {
+ if temp.contains_key("href") {
+ let open = webbrowser::open(temp["href"].as_str().unwrap());
+ if let Err(e) = open {
+ log::error!("Open Browser error: {:?}", e);
+ }
+ }
+ }
+ }
+
+ _ => {}
+ },
_ => {}
}
})
}
-type Webviews = HashMap>;
+struct WebviewHandler {
+ dom: VirtualDom,
+ webview: Rc,
+ waker: Waker,
+}
/// Poll the virtualdom until it's pending
///
/// The waker we give it is connected to the event loop, so it will wake up the event loop when it's ready to be polled again
///
/// All IO is done on the tokio runtime we started earlier
-fn poll_vdom(waker: &Waker, dom: &mut VirtualDom, webviews: &mut Webviews) {
- let mut cx = std::task::Context::from_waker(waker);
+fn poll_vdom(view: &mut WebviewHandler) {
+ let mut cx = std::task::Context::from_waker(&view.waker);
loop {
{
- let fut = dom.wait_for_work();
+ let fut = view.dom.wait_for_work();
pin_mut!(fut);
match fut.poll_unpin(&mut cx) {
@@ -225,16 +271,14 @@ fn poll_vdom(waker: &Waker, dom: &mut VirtualDom, webviews: &mut Webviews) {
}
}
- send_edits(dom.render_immediate(), webviews);
+ send_edits(view.dom.render_immediate(), &view.webview);
}
}
/// Send a list of mutations to the webview
-fn send_edits(edits: Mutations, webviews: &mut Webviews) {
+fn send_edits(edits: Mutations, webview: &WebView) {
let serialized = serde_json::to_string(&edits).unwrap();
- let (_id, view) = webviews.iter_mut().next().unwrap();
-
// todo: use SSE and binary data to send the edits with lower overhead
- _ = view.evaluate_script(&format!("window.interpreter.handleEdits({})", serialized));
+ _ = webview.evaluate_script(&format!("window.interpreter.handleEdits({})", serialized));
}
diff --git a/packages/desktop/src/waker.rs b/packages/desktop/src/waker.rs
index a2586ffed..1e34baffc 100644
--- a/packages/desktop/src/waker.rs
+++ b/packages/desktop/src/waker.rs
@@ -1,15 +1,18 @@
-use crate::desktop_context::UserWindowEvent;
+use crate::desktop_context::{EventData, UserWindowEvent};
use futures_util::task::ArcWake;
use std::sync::Arc;
-use wry::application::event_loop::EventLoopProxy;
+use wry::application::{event_loop::EventLoopProxy, window::WindowId};
/// Create a waker that will send a poll event to the event loop.
///
/// This lets the VirtualDom "come up for air" and process events while the main thread is blocked by the WebView.
///
/// All other IO lives in the Tokio runtime,
-pub fn tao_waker(proxy: &EventLoopProxy) -> std::task::Waker {
- struct DomHandle(EventLoopProxy);
+pub fn tao_waker(proxy: &EventLoopProxy, id: WindowId) -> std::task::Waker {
+ struct DomHandle {
+ proxy: EventLoopProxy,
+ id: WindowId,
+ }
// this should be implemented by most platforms, but ios is missing this until
// https://github.com/tauri-apps/wry/issues/830 is resolved
@@ -18,9 +21,14 @@ pub fn tao_waker(proxy: &EventLoopProxy) -> std::task::Waker {
impl ArcWake for DomHandle {
fn wake_by_ref(arc_self: &Arc) {
- _ = arc_self.0.send_event(UserWindowEvent::Poll);
+ _ = arc_self
+ .proxy
+ .send_event(UserWindowEvent(EventData::Poll, arc_self.id));
}
}
- futures_util::task::waker(Arc::new(DomHandle(proxy.clone())))
+ futures_util::task::waker(Arc::new(DomHandle {
+ id,
+ proxy: proxy.clone(),
+ }))
}
diff --git a/packages/desktop/src/webview.rs b/packages/desktop/src/webview.rs
index 4a270bfab..721f37d94 100644
--- a/packages/desktop/src/webview.rs
+++ b/packages/desktop/src/webview.rs
@@ -1,5 +1,6 @@
use std::rc::Rc;
+use crate::desktop_context::EventData;
use crate::protocol;
use crate::{desktop_context::UserWindowEvent, Config};
use tao::event_loop::{EventLoopProxy, EventLoopWindowTarget};
@@ -38,10 +39,10 @@ pub fn build(
.with_transparent(cfg.window.window.transparent)
.with_url("dioxus://index.html/")
.unwrap()
- .with_ipc_handler(move |_window: &Window, payload: String| {
+ .with_ipc_handler(move |window: &Window, payload: String| {
// defer the event to the main thread
if let Ok(message) = serde_json::from_str(&payload) {
- _ = proxy.send_event(UserWindowEvent::Ipc(message));
+ _ = proxy.send_event(UserWindowEvent(EventData::Ipc(message), window.id()));
}
})
.with_custom_protocol(String::from("dioxus"), move |r| {