uzor_framework/host/
headless.rs1use std::sync::Arc;
11
12use uzor::testing::RecordingRenderContext;
13
14use crate::runtime::{Runtime, RuntimeConfig, TickOutput};
15use crate::types::bus::{HostCaps, InputEnvelope, InputEvent, WindowInput};
16use crate::types::command::{AppCommand, WindowCmd};
17use crate::types::ids::{Seconds, WindowId};
18use crate::types::snapshot::VisualSnapshot;
19use crate::types::spec::Spec;
20use crate::types::window::{SizePx, WindowCommand, WindowSpec};
21use crate::{App, Handle, Waker};
22
23pub struct HeadlessHost<S: Spec, A: App<Spec = S>> {
25 rt: Runtime<S, A>,
26 handle: Handle<S>,
27 now: Seconds,
28 pub caps: HostCaps,
30 pub dpr: f64,
32 pub ctx: RecordingRenderContext,
36 last: TickOutput,
37 command_log: Vec<(WindowId, WindowCommand)>,
38}
39
40impl<S: Spec, A: App<Spec = S>> HeadlessHost<S, A> {
41 pub fn new(app: A, cfg: RuntimeConfig) -> (Self, Handle<S>) {
43 let (rt, handle) = Runtime::new(app, cfg, Waker::noop());
44 let host = Self {
45 rt,
46 handle: handle.clone(),
47 now: Seconds::ZERO,
48 caps: HostCaps {
49 multi_window: true,
50 os_resize_bezel: false,
51 clipboard_async: false,
52 },
53 dpr: 1.0,
54 ctx: RecordingRenderContext::new(),
55 last: TickOutput::default(),
56 command_log: Vec::new(),
57 };
58 (host, handle)
59 }
60
61 pub fn open_window(&mut self, size: SizePx, dpr: f64) -> WindowId {
65 let n = self.snapshot().windows.len();
66 let key = format!("win-{n}");
67 let mut spec = WindowSpec::new(key, "headless", size);
68 let _ = &mut spec; self.handle
70 .dispatch(AppCommand::Window(WindowCmd::Open(spec)))
71 .unwrap_or_else(|e| panic!("headless inbox: {e}"));
72 self.dpr = dpr;
73 self.advance(0.0);
74 self.snapshot()
75 .windows
76 .last()
77 .unwrap_or_else(|| panic!("window did not open"))
78 .id
79 }
80
81 pub fn input(&mut self, win: WindowId, event: InputEvent) {
83 self.rt.push_input(InputEnvelope {
84 window: win,
85 t: self.now,
86 event,
87 });
88 }
89
90 pub fn advance(&mut self, dt: f64) -> &TickOutput {
95 self.now = self.now.after(Seconds(dt));
96 let mut out = self.rt.tick(self.now);
97
98 let mut echoes = Vec::new();
101 for (win, cmd) in &out.window_commands {
102 match cmd {
103 WindowCommand::Spawn(spec) => echoes.push((
104 *win,
105 WindowInput::Created {
106 size: spec.inner_size,
107 dpr: self.dpr,
108 position: Some((100, 100)),
111 caps: self.caps,
112 },
113 )),
114 WindowCommand::Close => echoes.push((*win, WindowInput::Destroyed)),
115 _ => {}
116 }
117 }
118 if !echoes.is_empty() {
119 for (win, event) in echoes {
120 self.rt.push_input(InputEnvelope {
121 window: win,
122 t: self.now,
123 event: InputEvent::Window(event),
124 });
125 }
126 let more = self.rt.tick(self.now);
127 out.window_commands.extend(more.window_commands);
128 out.frames.extend(more.frames);
129 out.wake = earliest(out.wake, more.wake);
130 }
131
132 let frames = std::mem::take(&mut out.frames);
133 for req in &frames {
134 self.rt.paint(req, &mut self.ctx);
135 }
136 out.frames = frames;
137 self.command_log.extend(out.window_commands.iter().cloned());
138 self.last = out;
139 &self.last
140 }
141
142 pub fn snapshot(&self) -> Arc<VisualSnapshot<S>> {
144 self.rt.snapshot()
145 }
146
147 pub fn window_commands(&self) -> &[(WindowId, WindowCommand)] {
149 &self.last.window_commands
150 }
151
152 pub fn command_log(&self) -> &[(WindowId, WindowCommand)] {
156 &self.command_log
157 }
158
159 pub fn runtime(&self) -> &Runtime<S, A> {
161 &self.rt
162 }
163
164 pub fn runtime_mut(&mut self) -> &mut Runtime<S, A> {
166 &mut self.rt
167 }
168}
169
170fn earliest(
172 a: crate::types::frame::Wake,
173 b: crate::types::frame::Wake,
174) -> crate::types::frame::Wake {
175 use crate::types::frame::Wake;
176 match (a, b) {
177 (Wake::Immediate, _) | (_, Wake::Immediate) => Wake::Immediate,
178 (Wake::At(x), Wake::At(y)) => Wake::At(if x.get() <= y.get() { x } else { y }),
179 (Wake::At(x), Wake::Idle) | (Wake::Idle, Wake::At(x)) => Wake::At(x),
180 (Wake::Idle, Wake::Idle) => Wake::Idle,
181 }
182}