aylis_core/post.rs
1//! Rodar código na thread da interface a partir de outra thread.
2//!
3//! ```
4//! # use aylis_core::Ui;
5//! let mut ui = Ui::new();
6//! let poster = ui.poster(); // pode ir para outra thread
7//! std::thread::spawn(move || {
8//! poster.post(|ui| ui.request_repaint());
9//! })
10//! .join()
11//! .unwrap();
12//! assert_eq!(ui.process_posted(), 1);
13//! ```
14//!
15//! A plataforma instala a função que acorda a interface ([`Ui::set_wake`]) e chama
16//! [`Ui::process_posted`] quando acorda.
17
18use std::collections::VecDeque;
19use std::sync::{Arc, Mutex};
20
21use crate::ui::Ui;
22
23/// Uma função para rodar na thread da interface.
24pub type Job = Box<dyn FnOnce(&mut Ui) + Send>;
25
26/// Acorda a interface (vem da plataforma; pode ser chamada de qualquer thread).
27pub type WakeFn = Arc<dyn Fn() + Send + Sync>;
28
29#[derive(Default)]
30pub(crate) struct PostQueue {
31 jobs: Mutex<VecDeque<Job>>,
32 wake: Mutex<Option<WakeFn>>,
33}
34
35/// Entrega funções para a thread da interface. Barato de clonar; vale de qualquer thread.
36#[derive(Clone)]
37pub struct Poster(pub(crate) Arc<PostQueue>);
38
39impl Poster {
40 /// Agenda `job` para rodar na thread da interface e acorda a interface.
41 pub fn post(&self, job: impl FnOnce(&mut Ui) + Send + 'static) {
42 if let Ok(mut jobs) = self.0.jobs.lock() {
43 jobs.push_back(Box::new(job));
44 }
45 self.wake();
46 }
47
48 /// Só acorda a interface (ela repinta se algo mudou, e roda o que estiver agendado).
49 pub fn wake(&self) {
50 let wake = self.0.wake.lock().ok().and_then(|w| w.clone());
51 if let Some(wake) = wake {
52 wake();
53 }
54 }
55}
56
57impl Ui {
58 /// Um [`Poster`] para esta interface (para threads de trabalho, áudio, vídeo, rede).
59 pub fn poster(&self) -> Poster {
60 Poster(self.posted.clone())
61 }
62
63 /// A plataforma diz como acordar a interface.
64 pub fn set_wake(&mut self, wake: WakeFn) {
65 if let Ok(mut w) = self.posted.wake.lock() {
66 *w = Some(wake);
67 }
68 }
69
70 /// Roda o que outras threads agendaram. Devolve quantas funções rodaram.
71 pub fn process_posted(&mut self) -> usize {
72 let mut count = 0;
73 loop {
74 let job = self.posted.jobs.lock().ok().and_then(|mut jobs| jobs.pop_front());
75 let Some(job) = job else { break };
76 job(self);
77 count += 1;
78 }
79 // Também os eventos que sobraram da volta anterior (veja `process_events`).
80 if count > 0 || self.has_pending_events() {
81 self.process_events();
82 }
83 count
84 }
85}