1use std::sync::mpsc::Receiver;
10use std::sync::Arc;
11
12use arc_swap::ArcSwap;
13use uzor::render::{RenderContext, TickRate};
14use uzor::tokens::Tokens;
15
16use crate::handle::{App, Handle, InitCx, IntentCx, Waker, INBOX_CAP};
17use crate::kernel::{Kernel, KernelConfig};
18use crate::types::anim::AnimPolicy;
19use crate::types::bus::InputEnvelope;
20use crate::types::command::{AppCommand, LayoutPolicy, WindowCmd};
21use crate::types::frame::{FrameRequest, Wake};
22use crate::types::ids::{Revision, Seconds, WindowId};
23use crate::types::snapshot::VisualSnapshot;
24use crate::types::spec::Spec;
25use crate::types::window::{ClosePolicy, WindowCommand, WindowSpec};
26
27pub const MAX_SETTLE: usize = 4;
31
32#[derive(Default)]
34pub struct TickOutput {
35 pub window_commands: Vec<(WindowId, WindowCommand)>,
37 pub frames: Vec<FrameRequest>,
39 pub wake: Wake,
41}
42
43pub struct RuntimeConfig {
45 pub windows: Vec<WindowSpec>,
48 pub tick: TickRate,
50 pub anim: AnimPolicy,
52 pub layout: LayoutPolicy,
54 pub tokens: Arc<Tokens>,
56 pub dark: bool,
58 pub close: ClosePolicy,
60}
61
62impl Default for RuntimeConfig {
63 fn default() -> Self {
64 Self {
65 windows: Vec::new(),
66 tick: TickRate::default(),
67 anim: AnimPolicy::default(),
68 layout: LayoutPolicy::default(),
69 tokens: Tokens::builtin(uzor::tokens::BuiltinSet::Dark),
70 dark: true,
71 close: ClosePolicy::default(),
72 }
73 }
74}
75
76pub struct Runtime<S: Spec, A: App<Spec = S>> {
79 app: A,
80 kernel: Kernel<S>,
81 rx: Receiver<AppCommand<S>>,
82 snap: Arc<ArcSwap<VisualSnapshot<S>>>,
83 inputs: Vec<InputEnvelope>,
85 cmds: Vec<AppCommand<S>>,
88 now: Seconds,
90 last_pass_changed: bool,
92 paint_wants_tick: bool,
94}
95
96impl<S: Spec, A: App<Spec = S>> Runtime<S, A> {
97 pub fn new(mut app: A, cfg: RuntimeConfig, waker: Waker) -> (Self, Handle<S>) {
101 let (tx, rx) = std::sync::mpsc::sync_channel(INBOX_CAP);
102 let snap = Arc::new(ArcSwap::from_pointee(VisualSnapshot::empty()));
103 let handle = Handle {
104 tx,
105 snap: Arc::clone(&snap),
106 waker,
107 };
108 let kernel = Kernel::new(&KernelConfig {
109 anim: cfg.anim,
110 layout: cfg.layout,
111 tokens: cfg.tokens,
112 dark: cfg.dark,
113 close: cfg.close,
114 tick: cfg.tick,
115 });
116 let mut cmds = Vec::new();
117 {
118 let mut cx = InitCx { out: &mut cmds, handle: &handle };
119 app.init(&mut cx);
120 }
121 for spec in cfg.windows {
122 cmds.push(AppCommand::Window(WindowCmd::Open(spec)));
123 }
124 let runtime = Self {
125 app,
126 kernel,
127 rx,
128 snap,
129 inputs: Vec::new(),
130 cmds,
131 now: Seconds::ZERO,
132 last_pass_changed: false,
133 paint_wants_tick: false,
134 };
135 (runtime, handle)
136 }
137
138 pub fn push_input(&mut self, input: InputEnvelope) {
140 self.inputs.push(input);
141 }
142
143 pub fn tick(&mut self, now: Seconds) -> TickOutput {
147 self.now = now;
148 while let Ok(cmd) = self.rx.try_recv() {
149 self.cmds.push(cmd);
150 }
151 let mut out = TickOutput::default();
152 self.pass(now, &mut out, true);
153 let mut settles = 0;
154 while (self.last_pass_changed || !self.cmds.is_empty()) && settles < MAX_SETTLE {
155 settles += 1;
156 self.pass(now, &mut out, false);
157 }
158 if self.last_pass_changed || !self.cmds.is_empty() {
161 out.wake = Wake::Immediate;
162 }
163 out
164 }
165
166 fn pass(&mut self, now: Seconds, out: &mut TickOutput, with_inputs: bool) {
168 let mut inputs = if with_inputs {
169 std::mem::take(&mut self.inputs)
170 } else {
171 Vec::new()
172 };
173 let mut cmds = std::mem::take(&mut self.cmds);
174 let before = self.kernel.engine_revisions();
175 self.kernel.step(now, &mut inputs, &mut cmds);
176 let published = self.kernel.publish(now);
177 out.window_commands.extend(published.window_commands);
178 out.frames.extend(published.frames);
179 out.wake = earliest(out.wake, published.wake);
180 if let Some(snapshot) = published.snapshot {
181 self.snap.store(Arc::new(snapshot));
182 }
183 let intents = self.kernel.take_intents();
186 self.last_pass_changed = !intents.is_empty() || before != self.kernel.engine_revisions();
187 if !intents.is_empty() {
188 let snapshot = self.snap.load_full();
189 let mut answers = Vec::new();
190 for intent in intents {
191 let mut cx = IntentCx {
192 view: &snapshot,
193 out: &mut answers,
194 };
195 self.app.intent(intent, &mut cx);
196 }
197 self.cmds.extend(answers);
198 }
199 }
200
201 pub fn paint(&mut self, req: &FrameRequest, ctx: &mut dyn RenderContext) {
204 let out = self
205 .kernel
206 .compose(self.now, req.window, &mut self.app, ctx);
207 self.paint_wants_tick |= out.wants_frame || !out.commands.is_empty();
208 self.cmds.extend(out.commands);
209 }
210
211 pub fn take_paint_wants_tick(&mut self) -> bool {
216 std::mem::take(&mut self.paint_wants_tick)
217 }
218
219 pub fn snapshot(&self) -> Arc<VisualSnapshot<S>> {
221 self.snap.load_full()
222 }
223
224 pub fn a11y_tree(&self, win: crate::types::ids::WindowId) -> uzor::a11y::A11yTree {
226 self.kernel.a11y_tree(win)
227 }
228
229 pub fn revision(&self) -> Revision {
231 self.snap.load().revision
232 }
233
234 pub fn should_exit(&self) -> bool {
236 self.kernel.exit_requested()
237 }
238
239 pub fn app(&self) -> &A {
241 &self.app
242 }
243
244 pub fn app_mut(&mut self) -> &mut A {
246 &mut self.app
247 }
248
249 #[allow(dead_code)]
252 pub(crate) fn kernel(&self) -> &Kernel<S> {
253 &self.kernel
254 }
255}
256
257fn earliest(a: Wake, b: Wake) -> Wake {
259 match (a, b) {
260 (Wake::Immediate, _) | (_, Wake::Immediate) => Wake::Immediate,
261 (Wake::At(x), Wake::At(y)) => Wake::At(if x.get() <= y.get() { x } else { y }),
262 (Wake::At(t), Wake::Idle) | (Wake::Idle, Wake::At(t)) => Wake::At(t),
263 (Wake::Idle, Wake::Idle) => Wake::Idle,
264 }
265}