use std::any::{Any, TypeId};
#[cfg(feature = "async-await")]
use std::future::Future;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, OnceLock};
use std::thread::{JoinHandle, Result as ThreadResult};
use thiserror::Error;
use winit::event_loop::EventLoopProxy;
use winit::window::WindowId;
#[cfg(feature = "devtools")]
use crate::devtools::DevToolsCommand;
use crate::{WindowCommand, component::Component, control::WindowToken};
#[cfg(feature = "a11y-winit")]
use accesskit_winit;
pub type UpdateFn = Box<dyn FnOnce(&mut dyn Any) + Send + 'static>;
pub enum UserEvent {
Command {
token: WindowToken,
command: WindowCommand,
},
#[cfg(feature = "a11y-winit")]
Access(accesskit_winit::Event),
UpdateUI(Box<dyn FnOnce() + Send + 'static>),
#[cfg(feature = "devtools")]
DevTools(DevToolsCommand),
Action {
f: UpdateFn,
target: std::any::TypeId,
token: Option<WindowToken>,
},
DeferredMinimize {
window_id: WindowId,
},
}
impl std::fmt::Debug for UserEvent {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Command { token, command } => f
.debug_struct("Command")
.field("token", token)
.field("command", command)
.finish(),
#[cfg(feature = "a11y-winit")]
Self::Access(event) => f.debug_tuple("Access").field(event).finish(),
Self::UpdateUI(_) => f.debug_struct("UpdateUI").field("f", &"<closure>").finish(),
#[cfg(feature = "devtools")]
Self::DevTools(cmd) => f.debug_tuple("DevTools").field(cmd).finish(),
Self::Action {
f: _,
target,
token,
} => f
.debug_struct("Action")
.field("f", &"<closure>")
.field("target", target)
.field("token", token)
.finish(),
Self::DeferredMinimize { window_id } => f
.debug_struct("DeferredMinimize")
.field("window_id", window_id)
.finish(),
}
}
}
#[cfg(feature = "a11y-winit")]
impl From<accesskit_winit::Event> for UserEvent {
fn from(event: accesskit_winit::Event) -> Self {
Self::Access(event)
}
}
#[derive(Debug, Error)]
pub enum TaskError {
#[error("the event loop is not running")]
NotRunning,
#[error("the event loop is closed")]
Closed,
#[error("the event loop proxy is already installed")]
AlreadyInstalled,
}
#[derive(Debug, Clone)]
pub struct TaskContext {
cancel_flag: Arc<AtomicBool>,
}
impl TaskContext {
pub fn is_cancelled(&self) -> bool {
self.cancel_flag.load(Ordering::SeqCst)
}
}
#[must_use]
pub struct TaskHandle {
inner: JoinHandle<()>,
cancel_flag: Arc<AtomicBool>,
}
impl TaskHandle {
pub fn abort(&self) {
self.cancel_flag.store(true, Ordering::SeqCst);
}
pub fn join(self) -> ThreadResult<()> {
self.inner.join()
}
pub fn cancel_flag(&self) -> Arc<AtomicBool> {
self.cancel_flag.clone()
}
}
pub(crate) static UI_PROXY: OnceLock<EventLoopProxy<UserEvent>> = OnceLock::new();
pub(crate) fn install_proxy(proxy: EventLoopProxy<UserEvent>) -> Result<(), TaskError> {
UI_PROXY.set(proxy).map_err(|_| TaskError::AlreadyInstalled)
}
pub fn spawn<F>(f: F) -> TaskHandle
where
F: FnOnce(TaskContext) + Send + 'static,
{
let cancel_flag = Arc::new(AtomicBool::new(false));
let ctx = TaskContext {
cancel_flag: cancel_flag.clone(),
};
let inner = std::thread::Builder::new()
.name("light-async".into())
.spawn(move || f(ctx))
.expect("thread spawn should not fail");
TaskHandle { inner, cancel_flag }
}
#[cfg(feature = "async-await")]
pub fn spawn_async<F, Fut>(f: F) -> TaskHandle
where
F: FnOnce(TaskContext) -> Fut + Send + 'static,
Fut: Future<Output = ()> + Send + 'static,
{
let cancel_flag = Arc::new(AtomicBool::new(false));
let ctx = TaskContext {
cancel_flag: cancel_flag.clone(),
};
let inner = std::thread::Builder::new()
.name("light-async-await".into())
.spawn(move || {
futures::executor::block_on(f(ctx));
})
.expect("thread spawn should not fail");
TaskHandle { inner, cancel_flag }
}
pub fn post_to_ui<F>(f: F) -> Result<(), TaskError>
where
F: FnOnce() + Send + 'static,
{
let proxy = match UI_PROXY.get() {
Some(proxy) => proxy,
None => return Err(TaskError::NotRunning),
};
proxy
.send_event(UserEvent::UpdateUI(Box::new(f)))
.map_err(|_| TaskError::Closed)
}
pub fn post_update<C: Component + 'static>(
f: impl FnOnce(&mut C) + Send + 'static,
) -> Result<(), TaskError> {
post_update_impl(None, f)
}
fn post_update_impl<C: Component + 'static>(
token: Option<WindowToken>,
f: impl FnOnce(&mut C) + Send + 'static,
) -> Result<(), TaskError> {
let proxy = match UI_PROXY.get() {
Some(proxy) => proxy,
None => return Err(TaskError::NotRunning),
};
let action = UserEvent::Action {
f: Box::new(move |any: &mut dyn Any| {
if let Some(component) = any.downcast_mut::<C>() {
f(component);
}
}),
target: std::any::TypeId::of::<C>(),
token,
};
proxy.send_event(action).map_err(|_| TaskError::Closed)
}
#[cfg(feature = "async-runtime")]
pub fn apply_action<'a>(
windows: impl Iterator<Item = (WindowToken, TypeId, &'a mut dyn Component)>,
token: Option<WindowToken>,
target: TypeId,
f: UpdateFn,
) -> Option<WindowToken> {
for (window_token, type_id, component) in windows {
let matched = match token {
Some(t) => window_token == t,
None => type_id == target,
};
if matched {
f(component.as_any_mut());
return Some(window_token);
}
}
None
}
pub fn post_update_to<C: Component + 'static>(
token: WindowToken,
f: impl FnOnce(&mut C) + Send + 'static,
) -> Result<(), TaskError> {
post_update_impl(Some(token), f)
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
#[test]
fn post_to_ui_without_install_errors() {
let result = post_to_ui(|| {});
match result {
Err(TaskError::NotRunning) => {}
other => panic!("expected NotRunning, got {other:?}"),
}
}
#[test]
fn spawn_runs_closure() {
static RAN: AtomicBool = AtomicBool::new(false);
let handle = spawn(|_ctx| RAN.store(true, Ordering::SeqCst));
handle.join().expect("spawned thread must not panic");
assert!(RAN.load(Ordering::SeqCst), "closure should have run");
}
#[test]
fn spawn_returns_joinable_handle() {
let handle = spawn(|_ctx| {});
handle.join().expect("empty closure must not panic");
}
#[test]
fn abort_stops_task() {
static CANCELLED: AtomicBool = AtomicBool::new(false);
let handle = spawn(|ctx| {
while !ctx.is_cancelled() {
std::thread::sleep(Duration::from_millis(1));
}
CANCELLED.store(true, Ordering::SeqCst);
});
handle.abort();
handle.join().expect("aborted thread must finish");
assert!(
CANCELLED.load(Ordering::SeqCst),
"task should observe cancellation"
);
}
#[test]
fn post_update_without_install_errors() {
struct S;
impl crate::Component for S {
fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
self
}
fn render(&self) -> crate::VElement {
crate::VElement::leaf(
"",
crate::NodeKind::Text {
content: "noop".into(),
},
)
}
}
let result = post_update::<S>(|_| {});
match result {
Err(TaskError::NotRunning) => {}
other => panic!("expected NotRunning, got {other:?}"),
}
}
#[test]
fn action_debug_contains_action_and_target() {
let action = UserEvent::Action {
f: Box::new(|_any: &mut dyn Any| {}),
target: std::any::TypeId::of::<u8>(),
token: None,
};
let s = format!("{action:?}");
assert!(s.contains("Action"), "Debug must name the variant: {s}");
assert!(
s.contains("target"),
"Debug must include the `target` field: {s}"
);
assert!(
s.contains("<closure>"),
"Debug must render the closure placeholder: {s}"
);
}
#[test]
fn task_error_enum_unchanged() {
let not_running = TaskError::NotRunning;
let closed = TaskError::Closed;
let already = TaskError::AlreadyInstalled;
assert_eq!(not_running.to_string(), "the event loop is not running");
assert_eq!(closed.to_string(), "the event loop is closed");
assert_eq!(
already.to_string(),
"the event loop proxy is already installed"
);
}
}