use std::sync::mpsc::Receiver;
use std::sync::Arc;
use arc_swap::ArcSwap;
use uzor::render::{RenderContext, TickRate};
use uzor::tokens::Tokens;
use crate::handle::{App, Handle, InitCx, IntentCx, Waker, INBOX_CAP};
use crate::kernel::{Kernel, KernelConfig};
use crate::types::anim::AnimPolicy;
use crate::types::bus::InputEnvelope;
use crate::types::command::{AppCommand, LayoutPolicy, WindowCmd};
use crate::types::frame::{FrameRequest, Wake};
use crate::types::ids::{Revision, Seconds, WindowId};
use crate::types::snapshot::VisualSnapshot;
use crate::types::spec::Spec;
use crate::types::window::{ClosePolicy, WindowCommand, WindowSpec};
pub const MAX_SETTLE: usize = 4;
#[derive(Default)]
pub struct TickOutput {
pub window_commands: Vec<(WindowId, WindowCommand)>,
pub frames: Vec<FrameRequest>,
pub wake: Wake,
}
pub struct RuntimeConfig {
pub windows: Vec<WindowSpec>,
pub tick: TickRate,
pub anim: AnimPolicy,
pub layout: LayoutPolicy,
pub tokens: Arc<Tokens>,
pub dark: bool,
pub close: ClosePolicy,
}
impl Default for RuntimeConfig {
fn default() -> Self {
Self {
windows: Vec::new(),
tick: TickRate::default(),
anim: AnimPolicy::default(),
layout: LayoutPolicy::default(),
tokens: Tokens::builtin(uzor::tokens::BuiltinSet::Dark),
dark: true,
close: ClosePolicy::default(),
}
}
}
pub struct Runtime<S: Spec, A: App<Spec = S>> {
app: A,
kernel: Kernel<S>,
rx: Receiver<AppCommand<S>>,
snap: Arc<ArcSwap<VisualSnapshot<S>>>,
inputs: Vec<InputEnvelope>,
cmds: Vec<AppCommand<S>>,
now: Seconds,
last_pass_changed: bool,
paint_wants_tick: bool,
}
impl<S: Spec, A: App<Spec = S>> Runtime<S, A> {
pub fn new(mut app: A, cfg: RuntimeConfig, waker: Waker) -> (Self, Handle<S>) {
let (tx, rx) = std::sync::mpsc::sync_channel(INBOX_CAP);
let snap = Arc::new(ArcSwap::from_pointee(VisualSnapshot::empty()));
let handle = Handle {
tx,
snap: Arc::clone(&snap),
waker,
};
let kernel = Kernel::new(&KernelConfig {
anim: cfg.anim,
layout: cfg.layout,
tokens: cfg.tokens,
dark: cfg.dark,
close: cfg.close,
tick: cfg.tick,
});
let mut cmds = Vec::new();
{
let mut cx = InitCx { out: &mut cmds, handle: &handle };
app.init(&mut cx);
}
for spec in cfg.windows {
cmds.push(AppCommand::Window(WindowCmd::Open(spec)));
}
let runtime = Self {
app,
kernel,
rx,
snap,
inputs: Vec::new(),
cmds,
now: Seconds::ZERO,
last_pass_changed: false,
paint_wants_tick: false,
};
(runtime, handle)
}
pub fn push_input(&mut self, input: InputEnvelope) {
self.inputs.push(input);
}
pub fn tick(&mut self, now: Seconds) -> TickOutput {
self.now = now;
while let Ok(cmd) = self.rx.try_recv() {
self.cmds.push(cmd);
}
let mut out = TickOutput::default();
self.pass(now, &mut out, true);
let mut settles = 0;
while (self.last_pass_changed || !self.cmds.is_empty()) && settles < MAX_SETTLE {
settles += 1;
self.pass(now, &mut out, false);
}
if self.last_pass_changed || !self.cmds.is_empty() {
out.wake = Wake::Immediate;
}
out
}
fn pass(&mut self, now: Seconds, out: &mut TickOutput, with_inputs: bool) {
let mut inputs = if with_inputs {
std::mem::take(&mut self.inputs)
} else {
Vec::new()
};
let mut cmds = std::mem::take(&mut self.cmds);
let before = self.kernel.engine_revisions();
self.kernel.step(now, &mut inputs, &mut cmds);
let published = self.kernel.publish(now);
out.window_commands.extend(published.window_commands);
out.frames.extend(published.frames);
out.wake = earliest(out.wake, published.wake);
if let Some(snapshot) = published.snapshot {
self.snap.store(Arc::new(snapshot));
}
let intents = self.kernel.take_intents();
self.last_pass_changed = !intents.is_empty() || before != self.kernel.engine_revisions();
if !intents.is_empty() {
let snapshot = self.snap.load_full();
let mut answers = Vec::new();
for intent in intents {
let mut cx = IntentCx {
view: &snapshot,
out: &mut answers,
};
self.app.intent(intent, &mut cx);
}
self.cmds.extend(answers);
}
}
pub fn paint(&mut self, req: &FrameRequest, ctx: &mut dyn RenderContext) {
let out = self
.kernel
.compose(self.now, req.window, &mut self.app, ctx);
self.paint_wants_tick |= out.wants_frame || !out.commands.is_empty();
self.cmds.extend(out.commands);
}
pub fn take_paint_wants_tick(&mut self) -> bool {
std::mem::take(&mut self.paint_wants_tick)
}
pub fn snapshot(&self) -> Arc<VisualSnapshot<S>> {
self.snap.load_full()
}
pub fn a11y_tree(&self, win: crate::types::ids::WindowId) -> uzor::a11y::A11yTree {
self.kernel.a11y_tree(win)
}
pub fn widget_snapshot(&self, win: crate::types::ids::WindowId) -> Vec<uzor::input::core::WidgetInfo> {
self.kernel.widget_snapshot(win)
}
pub fn revision(&self) -> Revision {
self.snap.load().revision
}
pub fn should_exit(&self) -> bool {
self.kernel.exit_requested()
}
pub fn app(&self) -> &A {
&self.app
}
pub fn app_mut(&mut self) -> &mut A {
&mut self.app
}
#[allow(dead_code)]
pub(crate) fn kernel(&self) -> &Kernel<S> {
&self.kernel
}
}
fn earliest(a: Wake, b: Wake) -> Wake {
match (a, b) {
(Wake::Immediate, _) | (_, Wake::Immediate) => Wake::Immediate,
(Wake::At(x), Wake::At(y)) => Wake::At(if x.get() <= y.get() { x } else { y }),
(Wake::At(t), Wake::Idle) | (Wake::Idle, Wake::At(t)) => Wake::At(t),
(Wake::Idle, Wake::Idle) => Wake::Idle,
}
}