Skip to main content

wgame_app/
windowed_task.rs

1use crate::{
2    Window,
3    executor::TaskId,
4    output::{CallOutput, Terminated},
5    runtime::{CallbackTrigger, Runtime, Task},
6    window::create_window,
7};
8use futures::{FutureExt, future::FusedFuture};
9use std::{
10    cell::{Cell, RefCell},
11    pin::Pin,
12    rc::Rc,
13    task::{Context, Poll, Waker},
14};
15use thiserror::Error;
16use winit::{error::OsError, window::WindowAttributes};
17
18pub fn create_windowed_task<T, F>(
19    rt: &Runtime,
20    attributes: WindowAttributes,
21    window_fn: F,
22) -> WindowedTask<T>
23where
24    T: 'static,
25    F: AsyncFnOnce(Window<'_>) -> T + 'static,
26{
27    let app = rt.clone();
28    let cancelled = Rc::new(Cell::new(false));
29    let token = cancelled.clone();
30    let output = rt.run_within_event_loop(
31        move |event_loop| {
32            if token.get() {
33                Ok(None)
34            } else {
35                create_window(app, attributes, event_loop, window_fn).map(Some)
36            }
37        },
38        CallbackTrigger::PollResumed,
39    );
40    WindowedTask(Rc::new(RefCell::new(State {
41        stage: Stage::Create(output),
42        cancelled,
43        finished: false,
44        waker: None,
45    })))
46}
47#[derive(Debug, Error)]
48pub enum WindowError {
49    #[error("Cannot create window: {0}")]
50    Creation(OsError),
51    #[error("Application suspended")]
52    Suspended,
53    #[error("Window task terminated")]
54    Terminated,
55}
56/// Single-consumer window task. Dropping it detaches the task.
57/// Clone [`Self::handle`] for cancellation access. Cancellation before creation
58/// resolves without waiting for OS resume and prevents queued window creation.
59/// Suspension cancels the window function and reports [`WindowError::Suspended`];
60/// a manually managed caller decides whether to recreate the window.
61pub struct WindowedTask<T>(Rc<RefCell<State<T>>>);
62/// Clonable cancellation access without access to the result.
63pub struct WindowTaskHandle<T>(Rc<RefCell<State<T>>>);
64impl<T> Clone for WindowTaskHandle<T> {
65    fn clone(&self) -> Self {
66        Self(self.0.clone())
67    }
68}
69impl<T> WindowTaskHandle<T> {
70    pub fn terminate(&self) {
71        let waker = {
72            let mut state = self.0.borrow_mut();
73            if state.finished {
74                return;
75            }
76            state.cancelled.set(true);
77            match &state.stage {
78                Stage::Run(task) => task.terminate(),
79                Stage::Create(output) => output.with_ready(|result| {
80                    if let Ok(Some(task)) = result {
81                        task.terminate();
82                    }
83                }),
84            }
85            state.waker.take()
86        };
87        if let Some(waker) = waker {
88            waker.wake();
89        }
90    }
91}
92struct State<T> {
93    stage: Stage<T>,
94    cancelled: Rc<Cell<bool>>,
95    finished: bool,
96    waker: Option<Waker>,
97}
98enum Stage<T> {
99    Create(CallOutput<Result<Option<Task<T>>, OsError>>),
100    Run(Task<T>),
101}
102impl<T> WindowedTask<T> {
103    pub fn id(&self) -> Option<TaskId> {
104        match &self.0.borrow().stage {
105            Stage::Run(task) => Some(task.id()),
106            _ => None,
107        }
108    }
109    pub fn handle(&self) -> WindowTaskHandle<T> {
110        WindowTaskHandle(self.0.clone())
111    }
112    pub fn terminate(&self) {
113        self.handle().terminate();
114    }
115}
116impl<T> Future for WindowedTask<T> {
117    type Output = Result<T, WindowError>;
118    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
119        let mut state = self.0.borrow_mut();
120        assert!(!state.finished, "Window task result already consumed");
121        state.waker = Some(cx.waker().clone());
122        if state.cancelled.get() {
123            if let Stage::Create(output) = &state.stage
124                && let Some(Ok(Some(task))) = output.try_take()
125            {
126                task.terminate();
127            }
128            state.finished = true;
129            return Poll::Ready(Err(WindowError::Terminated));
130        }
131        if let Stage::Create(output) = &mut state.stage {
132            match output.poll_unpin(cx) {
133                Poll::Pending => return Poll::Pending,
134                Poll::Ready(Ok(Some(task))) => state.stage = Stage::Run(task),
135                Poll::Ready(Ok(None)) => {
136                    state.finished = true;
137                    return Poll::Ready(Err(WindowError::Terminated));
138                }
139                Poll::Ready(Err(err)) => {
140                    state.finished = true;
141                    return Poll::Ready(Err(WindowError::Creation(err)));
142                }
143            }
144        }
145        let Stage::Run(task) = &mut state.stage else {
146            unreachable!()
147        };
148        match task.poll_unpin(cx) {
149            Poll::Pending => Poll::Pending,
150            Poll::Ready(result) => {
151                state.finished = true;
152                Poll::Ready(result.map_err(|Terminated| WindowError::Suspended))
153            }
154        }
155    }
156}
157impl<T> FusedFuture for WindowedTask<T> {
158    fn is_terminated(&self) -> bool {
159        self.0.borrow().finished
160    }
161}
162
163#[cfg(test)]
164mod tests {
165    use super::*;
166    #[test]
167    fn cancelling_detached_creation_also_cancels_created_task() {
168        let mut executor = crate::executor::Executor::with_waker_factory(|_| Waker::noop().clone());
169        let rt = Runtime {
170            state: Default::default(),
171            executor: executor.proxy(),
172            timers: Default::default(),
173            callbacks: Default::default(),
174        };
175        let task = rt.create_task(async {
176            panic!("cancelled window ran");
177        });
178        let output = CallOutput::default();
179        output.set_ready(Ok(Some(task)));
180        let window = WindowedTask(Rc::new(RefCell::new(State {
181            stage: Stage::Create(output),
182            cancelled: Rc::new(Cell::new(false)),
183            finished: false,
184            waker: None,
185        })));
186        let handle = window.handle();
187        drop(window);
188        handle.terminate();
189        assert!(executor.poll().is_ready());
190    }
191    #[test]
192    fn cancel_before_creation_completes_without_resume() {
193        let mut task: WindowedTask<()> = WindowedTask(Rc::new(RefCell::new(State {
194            stage: Stage::Create(CallOutput::default()),
195            cancelled: Rc::new(Cell::new(false)),
196            finished: false,
197            waker: None,
198        })));
199        let mut cx = Context::from_waker(Waker::noop());
200        assert!(Pin::new(&mut task).poll(&mut cx).is_pending());
201        task.handle().terminate();
202        assert!(matches!(
203            Pin::new(&mut task).poll(&mut cx),
204            Poll::Ready(Err(WindowError::Terminated))
205        ));
206        assert!(task.is_terminated());
207    }
208}