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>>,
}
impl<S: Spec> Kernel<S> {
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(),
};
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 declared = app.chrome_model(win);
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 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)) = 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,
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)) = 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);
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,
layer,
},
view: &view,
time,
out: &mut hooks,
};
app.overlay_body(&mut cx);
}
hook_ops.append(&mut hooks.ops);
}
{
let ring = view.focused.as_ref().and_then(|id| {
self.input
.view()
.coordinator(win)
.and_then(|c| c.widget_rect(id))
});
super::furniture::paint_focus_ring(render, &tokens, ring);
}
let fx = self.input.apply(InputOp::EndFrame { win, now });
self.conduct_input(now, fx);
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),
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(&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.captured = input.captured;
view.clicked = iview.clicked(win).to_vec();
view.scroll = iview.pending_scroll(win);
view.open_overlays = self
.overlays
.view()
.snapshot(win)
.iter()
.map(|o| o.id)
.collect();
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))
}