use uzor::input::driver::CoordinatorDriver;
use uzor::input::{LayerId, Sense};
use uzor::render::{InvalidateBits, RenderContext};
use crate::handle::{App, FrameTime, HookOp, HookOps, OverlayCx, PanelCx, VisualView, Widgets};
use crate::types::command::{AppCommand, LayoutCmd};
use crate::types::ids::{Seconds, WindowId};
use crate::types::ops::{FocusOp, InputOp, LayoutOp, OverlayOp, ScopeOwner, WindowOp};
use crate::types::overlay_model::OverlayModel;
use crate::types::spec::Spec;
use crate::types::window::{Point, WindowCommand};
use super::{Kernel, Phase};
pub(crate) struct ComposeOut<S: Spec> {
pub commands: Vec<AppCommand<S>>,
pub wants_frame: bool,
}
impl<S: Spec> Kernel<S> {
pub(crate) fn a11y_tree(&self, win: WindowId) -> uzor::a11y::A11yTree {
let v = self.input.view();
let mut t = v.coordinator(win).map(|c| c.a11y_tree()).unwrap_or_default();
t.set_focus(v.focused(win));
t
}
pub(crate) fn widget_snapshot(&self, win: WindowId) -> Vec<uzor::input::core::WidgetInfo> {
self.input.view().coordinator(win).map(|c| c.widget_snapshot()).unwrap_or_default()
}
pub(crate) fn compose(
&mut self,
now: Seconds,
win: WindowId,
app: &mut impl App<Spec = S>,
render: &mut dyn RenderContext,
) -> ComposeOut<S> {
self.clock.begin(Phase::Compose);
let mut out = ComposeOut {
commands: Vec::new(),
wants_frame: false,
};
let mut hook_ops: Vec<HookOp<S>> = Vec::new();
let Some(dpr) = self.windows.view().window(win).map(|w| w.geometry().scale) else {
self.clock.idle();
return out;
};
let tokens = self.windows.view().tokens().clone();
let view = self.visual_view(win);
let mut declared = app.chrome_model(win);
if !crate::types::controls::HOST_HAS_WINDOW_CONTROLS {
declared.floating = None;
}
let same = self
.layout
.view()
.window(win)
.is_some_and(|wv| wv.chrome_model().same_as(&declared));
if !same {
let fx = self.layout.apply(LayoutOp::Cmd(LayoutCmd::SetChromeModel {
win,
model: declared,
}));
self.conduct_layout(now, fx);
}
let time = FrameTime {
now,
dt: now.get() - self.last_frame.get(&win).copied().unwrap_or(now).get(),
};
let fx = self.input.apply(InputOp::BeginFrame { win, now });
self.conduct_input(now, fx);
let shape = self
.layout
.view()
.window(win)
.and_then(|wv| wv.chrome_model().floating.clone())
.map(|fc| {
let (vp, maxed) = self
.windows
.view()
.window(win)
.map_or_else(Default::default, |w| (w.geometry().viewport, w.geometry().maximized));
fc.begin_clip(render, vp, maxed);
})
.is_some();
{
let lview = self.layout.view();
if let Some(wv) = lview.window(win) {
super::furniture::paint_chrome(render, wv, &tokens);
let leaves = wv.dock_view().leaves;
for leaf_view in &leaves {
if leaf_view.hidden {
continue;
}
let Some(leaf) = wv.dock().tree().leaf(leaf_view.leaf) else {
continue;
};
let Some(panel) = leaf.active_panel() else {
continue;
};
let mut hooks = HookOps::default();
{
let Some((coord, states, selectables)) = self.input.compose_parts(win) else {
break;
};
let mut cx = PanelCx {
window: win,
leaf: leaf_view.leaf,
panel,
index: leaf.active_tab,
rect: leaf_view.rect,
dpr,
tokens: &tokens,
render: &mut *render,
widgets: Widgets {
coord,
states,
selectables,
layer: LayerId::main(),
},
view: &view,
time,
out: &mut hooks,
};
app.panel(&mut cx);
}
hook_ops.append(&mut hooks.ops);
}
super::furniture::paint_dock(render, wv, &tokens);
}
}
let overlays = self.overlays.view().snapshot(win);
for (z, ov) in overlays.iter().enumerate() {
let model = app.overlay_model(win, ov.id);
let layer = overlay_layer(ov.slot);
let mut hooks = HookOps::default();
{
let Some((coord, states, selectables)) = self.input.compose_parts(win) else {
break;
};
coord.push_layer(layer.clone(), 1 + z as u32, ov.modal);
if let OverlayModel::Modal(m) = &model {
if m.backdrop {
let viewport = self
.windows
.view()
.window(win)
.map_or_else(Default::default, |w| w.geometry().viewport);
render.set_fill_color_alpha("#000000", 0.35);
render.fill_rect(0.0, 0.0, viewport.width, viewport.height);
}
}
coord.register_on_layer(ov_host_id(ov.slot), ov.rect, Sense::CLICK, &layer);
if !matches!(model, OverlayModel::Custom) {
let css = tokens.semantic.surface_floating.to_css();
render.set_fill_color(&css);
render.fill_rect(ov.rect.x, ov.rect.y, ov.rect.width, ov.rect.height);
}
let mut cx = OverlayCx {
window: win,
id: ov.id,
body: ov.rect,
rect: ov.rect,
dpr,
tokens: &tokens,
render: &mut *render,
widgets: Widgets {
coord,
states,
selectables,
layer,
},
view: &view,
time,
out: &mut hooks,
};
app.overlay_body(&mut cx);
}
hook_ops.append(&mut hooks.ops);
}
{
let lview = self.layout.view();
if let Some(fc) = lview.window(win).and_then(|wv| wv.chrome_model().floating.clone()) {
let (viewport, maximized) = self
.windows
.view()
.window(win)
.map_or_else(Default::default, |w| (w.geometry().viewport, w.geometry().maximized));
let hover = view.pointer.and_then(|p| fc.button_at(viewport, p));
fc.paint(render, viewport, maximized, hover, view.button_down);
}
}
if shape {
render.restore();
}
{
let ring = view.focused.as_ref().filter(|_| view.focus_visible).and_then(|id| {
self.input
.view()
.coordinator(win)
.filter(|c| c.text_fields().field_state(id).is_none())
.and_then(|c| c.widget_rect(id).map(|r| (r, c.focus_radius(id))))
});
super::furniture::paint_focus_ring(render, &tokens, ring);
}
#[cfg(feature = "inspector")]
self.paint_inspector(win, &view, render);
let hover_before = self.input.view().window(win).and_then(|v| v.hovered);
let focus_before = self.input.view().window(win).map(|v| (v.focused.clone(), v.focus_visible));
let fx = self.input.apply(InputOp::EndFrame { win, now });
self.conduct_input(now, fx);
if self.input.view().window(win).map(|v| (v.focused.clone(), v.focus_visible)) != focus_before {
self.invalidate(win, None, InvalidateBits::ALL);
out.wants_frame = true;
}
if self.input.view().window(win).and_then(|v| v.hovered) != hover_before {
self.invalidate(win, None, InvalidateBits::ALL);
out.wants_frame = true;
}
if !self.input.view().clicked(win).is_empty() {
self.invalidate(win, None, InvalidateBits::ALL);
out.wants_frame = true;
}
for ov in &overlays {
if ov.scope_depth == 0 {
continue;
}
let members = self
.input
.view()
.coordinator(win)
.map(|c| c.focusable_ids(Some(&overlay_layer(ov.slot))))
.unwrap_or_default();
let fx = self.input.apply(InputOp::Focus {
win,
now,
op: FocusOp::SetMembers {
owner: ScopeOwner::Overlay(ov.slot),
members,
},
});
self.conduct_input(now, fx);
}
let clicked: Vec<_> = self.input.view().clicked(win).to_vec();
if !clicked.is_empty() {
let cursor = self
.input
.view()
.coordinator(win)
.and_then(|c| c.pointer_pos())
.map_or_else(Point::default, |(x, y)| Point::new(x, y));
for (widget, _count) in clicked {
let fx = self.overlays.apply(OverlayOp::Click {
win,
widget,
cursor,
});
self.conduct_overlay(now, fx);
}
}
for op in hook_ops {
match op {
HookOp::RequestFrame => {
self.invalidate(win, None, InvalidateBits::ALL);
out.wants_frame = true;
}
HookOp::ImeArea(rect) => {
let fx = self.windows.apply(WindowOp::Enqueue {
win,
cmd: WindowCommand::SetImeCursorArea(rect),
});
self.conduct_window_all(now, fx);
}
HookOp::Command(cmd) => out.commands.push(cmd),
}
}
self.last_frame.insert(win, now);
self.clock.idle();
out
}
fn visual_view(&mut self, win: WindowId) -> VisualView<S> {
let iview = self.input.view();
let input = iview.window(win).unwrap_or_default();
let mut view = VisualView::<S>::default();
view.hovered = input.hovered;
view.pressed = input.pressed;
view.focused = input.focused;
view.focus_visible = input.focus_visible;
view.captured = input.captured;
view.clicked = iview.clicked(win).to_vec();
if let Some(coord) = iview.coordinator(win) {
view.hover_path = view.hovered.as_ref().map(|h| coord.path_of(h)).unwrap_or_default();
view.click_paths = view.clicked.iter().map(|(w, _)| coord.path_of(w)).collect();
view.focus_path = view.focused.as_ref().map(|f| coord.path_of(f)).unwrap_or_default();
}
view.scroll = iview.pending_scroll(win);
view.scroll_precise = iview.pending_scroll_precise(win);
(view.pointer, view.button_down) = iview.pointer(win);
view.press_origin = iview.press_origin(win);
view.context = iview.context_click(win);
view.selections = iview.selections(win).map(<[_]>::to_vec).unwrap_or_default();
view.open_overlays = self
.overlays
.view()
.snapshot(win)
.iter()
.map(|o| o.id)
.collect();
view.prev_hover_path = self.hover_paths.insert(win, view.hover_path.clone()).unwrap_or_default();
view.prev_focus_path = self.focus_paths.insert(win, view.focus_path.clone()).unwrap_or_default();
view
}
}
fn overlay_layer(slot: crate::types::ids::OverlaySlot) -> LayerId {
LayerId::new(&format!("overlay:{}", slot.0))
}
fn ov_host_id(slot: crate::types::ids::OverlaySlot) -> uzor::WidgetId {
uzor::WidgetId::from(format!("overlay-{}", slot.0))
}
#[cfg(feature = "inspector")]
impl<S: Spec> Kernel<S> {
fn paint_inspector(&mut self, win: WindowId, view: &VisualView<S>, render: &mut dyn RenderContext) {
use uzor::ui::inspector::InspectBox;
if !self.inspector.enabled {
uzor::ui::inspector::take_noted();
return;
}
self.inspector.begin_frame();
let widgets = self.input.view().coordinator(win).map(|c| c.widget_snapshot()).unwrap_or_default();
for w in widgets {
let mut b = InspectBox::new(w.id.as_str(), format!("{:?}", w.kind), w.rect);
if let Some(p) = &w.parent {
b.notes.push(format!("parent {}", p.as_str()));
}
for a in uzor::ui::style::trace::of(w.id.as_str()).unwrap_or_default() {
b.notes.push(format!("{}: {} <- {}", a.property, a.value, a.selector));
}
self.inspector.record(b);
}
for mut b in uzor::ui::inspector::take_noted() {
for a in uzor::ui::style::trace::of(&b.id).unwrap_or_default() {
b.notes.push(format!("{}: {} <- {}", a.property, a.value, a.selector));
}
self.inspector.record(b);
}
if let Some(p) = view.pointer {
self.inspector.pointer_move(p.0, p.1);
}
let vp = self.windows.view().window(win).map_or_else(Default::default, |w| w.geometry().viewport);
self.inspector.paint(render, uzor::Rect::new(0.0, 0.0, vp.width, vp.height));
}
}