use crate::types::vecmap::VecMap;
use std::fmt;
use smallvec::SmallVec;
use uzor::input::KeyCode;
use uzor::layout::{
ClickDispatcher, ContextMenuHandle, DispatchEvent, DropdownHandle, ModalHandle, OverlayKind,
OverlayStack, PopupHandle, ZLayerTable,
};
use uzor::render::InvalidateBits;
use uzor::ui::widgets::composite::context_menu::input::register_context_menu_dispatch;
use uzor::ui::widgets::composite::context_menu::ContextMenuState;
use uzor::ui::widgets::composite::dropdown::input::{
self as dropdown_input, register_dropdown_dispatch,
};
use uzor::ui::widgets::composite::dropdown::DropdownState;
use uzor::ui::widgets::composite::modal::input::{self as modal_input, register_modal_dispatch};
use uzor::ui::widgets::composite::modal::ModalState;
use uzor::ui::widgets::composite::popup::input::{self as popup_input, register_popup_dispatch};
use uzor::ui::widgets::composite::popup::PopupState;
use uzor::{Rect, WidgetId};
use crate::types::bus::{KeyInput, KeyState, PointerInput};
use crate::types::command::{OverlayCmd, OverlayPolicy, OverlaySize};
use crate::types::ids::{OverlaySlot, Revision, Seconds, WindowId};
use crate::types::intent::{CloseCause, OverlayIntent};
use crate::types::ops::{
Intercepted, KeyRoute, OverlayEffect, OverlayOp, PointerRoute, ScopeOwner,
};
use crate::types::snapshot::OverlayView;
use crate::types::window::Point;
pub type OverlayEffects<O> = SmallVec<[OverlayEffect<O>; 2]>;
#[derive(Clone, Debug)]
pub enum OverlayBody {
Modal(ModalState),
Popup(PopupState),
Dropdown(DropdownState),
ContextMenu(ContextMenuState),
Tooltip,
Custom,
}
impl OverlayBody {
fn for_kind(kind: OverlayKind, rect: Rect, anchor: Option<Rect>) -> Self {
match kind {
OverlayKind::Modal => Self::Modal(ModalState {
position: (rect.x, rect.y),
..ModalState::default()
}),
OverlayKind::Popup => {
let mut s = PopupState::default();
s.open_at((rect.x, rect.y));
Self::Popup(s)
}
OverlayKind::Dropdown => {
let mut s = DropdownState::default();
match anchor {
Some(a) => s.open_below(a, 0.0),
None => s.open_at(rect.x, rect.y),
}
Self::Dropdown(s)
}
OverlayKind::ContextMenu => {
let mut s = ContextMenuState::default();
s.open_raw(rect.x, rect.y, None);
Self::ContextMenu(s)
}
OverlayKind::Tooltip | OverlayKind::Toast => Self::Tooltip,
OverlayKind::ColorPicker => Self::Custom,
}
}
fn set_origin(&mut self, x: f64, y: f64) {
match self {
Self::Modal(s) => s.position = (x, y),
Self::Popup(s) => s.position = (x, y),
Self::Dropdown(s) => {
s.origin = (x, y);
s.open_position_override = Some((x, y));
}
Self::ContextMenu(s) => {
s.x = x;
s.y = y;
}
Self::Tooltip | Self::Custom => {}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
struct ZKey {
tier: u8,
band: u32,
raised: bool,
z: i32,
seq: u64,
}
#[derive(Clone, Debug)]
#[allow(dead_code)]
struct Entry<O> {
id: O,
slot: OverlaySlot,
kind: OverlayKind,
key: ZKey,
rect: Rect,
anchor: Option<Rect>,
size: OverlaySize,
policy: OverlayPolicy,
body: OverlayBody,
host: WidgetId,
opened: Seconds,
}
impl<O> Entry<O> {
fn transparent(&self) -> bool {
matches!(self.kind, OverlayKind::Tooltip | OverlayKind::Toast)
}
fn scope(&self) -> Option<ScopeOwner> {
(!self.transparent()).then_some(ScopeOwner::Overlay(self.slot))
}
fn contains(&self, p: Point) -> bool {
self.rect.contains(p.x, p.y)
}
fn owns(&self, widget: &WidgetId) -> bool {
widget
.as_str()
.strip_prefix(self.host.as_str())
.is_some_and(|rest| rest.starts_with(':'))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Press {
Outside(OverlaySlot),
Inside(OverlaySlot),
}
#[derive(Clone)]
struct Stack<O> {
entries: Vec<Entry<O>>,
viewport: Option<Rect>,
dispatch: ClickDispatcher,
press: Option<Press>,
}
impl<O> Default for Stack<O> {
fn default() -> Self {
Self {
entries: Vec::new(),
viewport: None,
dispatch: ClickDispatcher::new(),
press: None,
}
}
}
impl<O: fmt::Debug> fmt::Debug for Stack<O> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Stack")
.field("entries", &self.entries)
.field("viewport", &self.viewport)
.field("press", &self.press)
.finish_non_exhaustive()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum OverlayHit<O> {
Overlay {
id: O,
slot: OverlaySlot,
kind: OverlayKind,
},
Shielded {
id: O,
slot: OverlaySlot,
},
None,
}
impl<O> OverlayHit<O> {
fn route(self) -> PointerRoute<O> {
match self {
Self::Overlay { id, slot, .. } => PointerRoute::Overlay { id, slot },
Self::Shielded { .. } => PointerRoute::Consumed,
Self::None => PointerRoute::Pass,
}
}
}
#[derive(Clone, Debug)]
pub struct OverlayEngine<O> {
windows: VecMap<WindowId, Stack<O>>,
z: ZLayerTable,
next_slot: u64,
next_seq: u64,
rev: Revision,
}
impl<O> Default for OverlayEngine<O> {
fn default() -> Self {
Self::with_z(ZLayerTable::default())
}
}
impl<O> OverlayEngine<O> {
pub fn new() -> Self {
Self::default()
}
pub fn with_z(z: ZLayerTable) -> Self {
Self {
windows: VecMap::new(),
z,
next_slot: 1,
next_seq: 0,
rev: Revision::ZERO,
}
}
}
impl<O: Copy + Eq> OverlayEngine<O> {
pub fn apply(&mut self, op: OverlayOp<O>) -> OverlayEffects<O> {
let mut fx = OverlayEffects::new();
let changed = match op {
OverlayOp::Cmd { cmd, now } => self.cmd(cmd, now, &mut fx),
OverlayOp::Resize {
win,
id,
width,
height,
} => self.resize(win, id, width, height, &mut fx),
OverlayOp::Intercept { win, event } => self.intercept(win, event, &mut fx),
OverlayOp::Click {
win,
widget,
cursor,
} => self.click(win, &widget, cursor, &mut fx),
OverlayOp::Captured { win, slot, input } => self.captured(win, slot, input, &mut fx),
OverlayOp::Reclamp { win, viewport } => self.reclamp(win, viewport, &mut fx),
OverlayOp::Fire { win, slot } => self.windows.get_mut(&win).is_some_and(|s| {
match s.entries.iter().position(|e| e.slot == slot) {
Some(i) => {
close_at(win, s, i, CloseCause::Timer, &mut fx);
true
}
None => false,
}
}),
OverlayOp::CloseWindow(win) => match self.windows.remove(&win) {
Some(mut s) => {
let had = !s.entries.is_empty();
uzor::sort::sort_by_key(&mut s.entries, |e| std::cmp::Reverse(e.key.seq));
for e in &s.entries {
fx.push(closed(win, e, CloseCause::WindowClosed));
}
had || s.viewport.is_some()
}
None => false,
},
};
if changed {
self.rev.bump();
}
fx
}
#[allow(dead_code)]
pub fn hit(&self, win: WindowId, p: Point) -> OverlayHit<O> {
self.windows
.get(&win)
.map_or(OverlayHit::None, |s| hit_walk(s, p))
}
#[allow(dead_code)]
pub fn topmost_at(&self, win: WindowId, p: Point) -> Option<OverlayEntryView<'_, O>> {
let s = self.windows.get(&win)?;
match hit_walk(s, p) {
OverlayHit::Overlay { slot, .. } => s
.entries
.iter()
.find(|e| e.slot == slot)
.map(|e| OverlayEntryView { e }),
_ => None,
}
}
#[allow(dead_code)]
pub fn body_state_mut(&mut self, win: WindowId, slot: OverlaySlot) -> Option<&mut OverlayBody> {
let s = self.windows.get_mut(&win)?;
s.entries
.iter_mut()
.find(|e| e.slot == slot)
.map(|e| &mut e.body)
}
pub fn revision(&self) -> Revision {
self.rev
}
pub fn view(&self) -> OverlayEngineView<'_, O> {
OverlayEngineView { e: self }
}
fn cmd(&mut self, cmd: OverlayCmd<O>, now: Seconds, fx: &mut OverlayEffects<O>) -> bool {
match cmd {
OverlayCmd::Open {
win,
id,
kind,
anchor,
size,
policy,
} => {
self.open(win, id, kind, anchor, size, policy, now, fx);
true
}
OverlayCmd::Close { win, id } => self.close_id(win, id, CloseCause::Command, fx),
OverlayCmd::CloseTop { win } => {
self.windows
.get_mut(&win)
.is_some_and(|s| match top_index(s) {
Some(i) => {
close_at(win, s, i, CloseCause::Command, fx);
true
}
None => false,
})
}
OverlayCmd::Toggle {
win,
id,
kind,
anchor,
size,
policy,
} => {
if !self.close_id(win, id, CloseCause::Command, fx) {
self.open(win, id, kind, anchor, size, policy, now, fx);
}
true
}
OverlayCmd::Move { win, id, to } => {
let Some(s) = self.windows.get_mut(&win) else {
return false;
};
let viewport = s.viewport;
let Some(e) = s.entries.iter_mut().find(|e| e.id == id) else {
return false;
};
let moved = Rect::new(to.x, to.y, e.rect.width, e.rect.height);
set_rect(win, e, moved, viewport, fx)
}
}
}
#[allow(clippy::too_many_arguments)]
fn open(
&mut self,
win: WindowId,
id: O,
kind: OverlayKind,
anchor: Option<Rect>,
size: OverlaySize,
policy: Option<OverlayPolicy>,
now: Seconds,
fx: &mut OverlayEffects<O>,
) {
let policy = policy.unwrap_or(OverlayPolicy::for_kind(kind));
let s = self.windows.entry(win).or_default();
if let Some(i) = s.entries.iter().position(|e| e.id == id) {
close_at(win, s, i, CloseCause::Replaced, fx);
}
let modals = s.entries.iter().filter(|e| e.policy.modal).count() as u32;
let (band, raised) = if policy.modal {
(modals + 1, false)
} else {
(modals, true)
};
let key = ZKey {
tier: u8::from(matches!(kind, OverlayKind::Toast | OverlayKind::Tooltip)),
band,
raised,
z: self.z.z_for(kind),
seq: self.next_seq,
};
self.next_seq += 1;
let slot = OverlaySlot(self.next_slot);
self.next_slot += 1;
let rect = place(anchor, size, s.viewport);
let entry = Entry {
id,
slot,
kind,
key,
rect,
anchor,
size,
policy,
body: OverlayBody::for_kind(kind, rect, anchor),
host: WidgetId::from(format!("overlay-{}", slot.0)),
opened: now,
};
fx.push(OverlayEffect::Opened {
win,
id,
slot,
kind,
scope: entry.scope(),
modal: policy.modal,
keymap_scope: policy.keymap_scope,
auto_close_at: policy.auto_close_after.map(|d| now.after(d)),
});
let at = s.entries.partition_point(|e| e.key < key);
s.entries.insert(at, entry);
rebuild_dispatch(s);
}
fn close_id(
&mut self,
win: WindowId,
id: O,
cause: CloseCause,
fx: &mut OverlayEffects<O>,
) -> bool {
let Some(s) = self.windows.get_mut(&win) else {
return false;
};
match s.entries.iter().position(|e| e.id == id) {
Some(i) => {
close_at(win, s, i, cause, fx);
true
}
None => false,
}
}
fn resize(
&mut self,
win: WindowId,
id: O,
width: f64,
height: f64,
fx: &mut OverlayEffects<O>,
) -> bool {
let Some(s) = self.windows.get_mut(&win) else {
return false;
};
let viewport = s.viewport;
let Some(e) = s.entries.iter_mut().find(|e| e.id == id) else {
return false;
};
let r = Rect::new(e.rect.x, e.rect.y, finite(width), finite(height));
set_rect(win, e, r, viewport, fx)
}
fn reclamp(&mut self, win: WindowId, viewport: Rect, fx: &mut OverlayEffects<O>) -> bool {
let s = self.windows.entry(win).or_default();
let mut changed = s.viewport != Some(viewport);
s.viewport = Some(viewport);
let mut geometry = false;
for e in &mut s.entries {
let r = OverlayStack::clamp_to_viewport(e.rect, viewport);
if r != e.rect {
e.rect = r;
e.body.set_origin(r.x, r.y);
geometry = true;
}
}
if geometry {
changed = true;
fx.push(OverlayEffect::Invalidate {
win,
bits: InvalidateBits::GEOMETRY,
});
}
changed
}
fn intercept(&mut self, win: WindowId, event: Intercepted, fx: &mut OverlayEffects<O>) -> bool {
let Some(s) = self.windows.get_mut(&win) else {
match event {
Intercepted::Key(_) => fx.push(OverlayEffect::Key {
win,
route: KeyRoute::Pass {
top_overlay: None,
modal_open: false,
},
}),
_ => fx.push(OverlayEffect::Pointer {
win,
route: PointerRoute::Pass,
}),
}
return false;
};
match event {
Intercepted::Pointer(input) => {
let (route, changed) = pointer(win, s, input, fx);
fx.push(OverlayEffect::Pointer { win, route });
changed
}
Intercepted::Wheel(w) => {
let route = hit_walk(s, w.pos).route();
fx.push(OverlayEffect::Pointer { win, route });
false
}
Intercepted::Key(k) => {
let changed = escape(win, s, &k, fx);
let route = if changed {
KeyRoute::Consumed
} else {
key_pass(s)
};
fx.push(OverlayEffect::Key { win, route });
changed
}
}
}
fn click(
&mut self,
win: WindowId,
widget: &WidgetId,
cursor: Point,
fx: &mut OverlayEffects<O>,
) -> bool {
let Some(s) = self.windows.get_mut(&win) else {
return false;
};
let Some(ev) = s.dispatch.dispatch(widget) else {
return false;
};
let Some(i) = s.entries.iter().position(|e| e.owns(widget)) else {
return false;
};
let viewport = s.viewport;
let e = &mut s.entries[i];
let (id, slot) = (e.id, e.slot);
match ev {
DispatchEvent::ModalCloseRequested(_) => {
close_at(win, s, i, CloseCause::Item, fx);
true
}
DispatchEvent::ModalTabClicked { index, .. } => {
fx.push(OverlayEffect::Intent(OverlayIntent::ModalTab {
win,
id,
index,
}));
match &mut e.body {
OverlayBody::Modal(m) if m.active_tab != index => {
m.set_active_tab(index);
fx.push(OverlayEffect::Invalidate {
win,
bits: InvalidateBits::MATERIAL,
});
true
}
_ => false,
}
}
DispatchEvent::DropdownItemClicked { item_id, .. } => {
if let OverlayBody::Dropdown(d) = &mut e.body {
d.select(item_id.clone());
}
fx.push(OverlayEffect::Intent(OverlayIntent::DropdownItem {
win,
id,
item: WidgetId::from(item_id),
}));
close_at(win, s, i, CloseCause::Item, fx);
true
}
DispatchEvent::ContextMenuItemClicked { item_index, .. } => {
fx.push(OverlayEffect::Intent(OverlayIntent::ContextMenuItem {
win,
id,
index: item_index,
}));
close_at(win, s, i, CloseCause::Item, fx);
true
}
DispatchEvent::ModalWizardNext(_)
| DispatchEvent::ModalWizardBack(_)
| DispatchEvent::Unhandled(_) => false,
ev => {
let starts_drag = matches!(
ev,
DispatchEvent::ResizeHandleDragStarted { .. }
| DispatchEvent::ScrollbarThumbDragStarted { .. }
);
let vp = viewport.unwrap_or(e.rect);
let (c, r, v) = ((cursor.x, cursor.y), e.rect, (vp.width, vp.height));
let host = &e.host;
let rest = match &mut e.body {
OverlayBody::Modal(m) => modal_input::consume_event(
ev,
m,
host,
modal_input::ConsumeEventCtx {
cursor: c,
frame_rect: r,
viewport: v,
},
),
OverlayBody::Popup(p) => popup_input::consume_event(
ev,
p,
host,
popup_input::ConsumeEventCtx {
cursor: c,
frame_rect: r,
viewport: v,
},
),
OverlayBody::Dropdown(d) => dropdown_input::consume_event(
ev,
d,
host,
dropdown_input::ConsumeEventCtx {
cursor: c,
frame_rect: r,
viewport: v,
},
),
OverlayBody::ContextMenu(_) | OverlayBody::Tooltip | OverlayBody::Custom => {
Some(ev)
}
};
if rest.is_some() {
return false;
}
fx.push(OverlayEffect::Invalidate {
win,
bits: InvalidateBits::MATERIAL,
});
if starts_drag {
fx.push(OverlayEffect::Capture {
win,
slot: Some(slot),
});
}
true
}
}
}
fn captured(
&mut self,
win: WindowId,
slot: OverlaySlot,
input: PointerInput,
fx: &mut OverlayEffects<O>,
) -> bool {
let Some(s) = self.windows.get_mut(&win) else {
return false;
};
let viewport = s.viewport;
let Some(e) = s.entries.iter_mut().find(|e| e.slot == slot) else {
return false;
};
match input {
PointerInput::Moved { pos, .. } => {
let (resized, scrolled) = match &mut e.body {
OverlayBody::Modal(m) => {
let scrolling = m.scroll.is_dragging;
m.update_resize((pos.x, pos.y));
if scrolling {
m.update_body_scroll_drag(pos.y);
}
(m.resize_drag.and(m.resized_rect), scrolling)
}
OverlayBody::Popup(p) => {
let scrolling = p.scroll.is_dragging;
p.update_resize((pos.x, pos.y));
if scrolling {
p.update_body_scroll_drag(pos.y);
}
(p.resize_drag.and(p.resized_rect), scrolling)
}
_ => (None, false),
};
let mut changed = scrolled;
if scrolled {
fx.push(OverlayEffect::Invalidate {
win,
bits: InvalidateBits::MATERIAL,
});
}
if let Some(r) = resized {
changed |= set_rect(win, e, r, viewport, fx);
}
changed
}
PointerInput::Up { .. } | PointerInput::Cancelled => {
let was = match &mut e.body {
OverlayBody::Modal(m) => {
let was = m.resize_drag.is_some() || m.scroll.is_dragging;
m.end_resize();
m.end_body_scroll_drag();
was
}
OverlayBody::Popup(p) => {
let was = p.is_dragging_any();
p.end_resize();
p.end_body_scroll_drag();
was
}
_ => false,
};
fx.push(OverlayEffect::Capture { win, slot: None });
was
}
_ => false,
}
}
}
fn pointer<O: Copy + Eq>(
win: WindowId,
s: &mut Stack<O>,
input: PointerInput,
fx: &mut OverlayEffects<O>,
) -> (PointerRoute<O>, bool) {
match input {
PointerInput::Down { pos, .. } => {
s.press = None;
if let Some(t) = top_index(s) {
let e = &s.entries[t];
if e.policy.dismiss_on_outside && !e.contains(pos) {
s.press = Some(Press::Outside(e.slot));
return (PointerRoute::Consumed, false);
}
}
let hit = hit_walk(s, pos);
if let OverlayHit::Overlay { slot, .. } = hit {
s.press = Some(Press::Inside(slot));
}
(hit.route(), false)
}
PointerInput::Up { pos, .. } => match s.press.take() {
Some(Press::Outside(slot)) => {
let dismiss = top_index(s).filter(|&t| {
let e = &s.entries[t];
e.slot == slot && !e.contains(pos)
});
match dismiss {
Some(t) => {
close_at(win, s, t, CloseCause::Outside, fx);
(PointerRoute::Consumed, true)
}
None => (PointerRoute::Consumed, false),
}
}
Some(Press::Inside(slot)) => match s.entries.iter().find(|e| e.slot == slot) {
Some(e) => (PointerRoute::Overlay { id: e.id, slot }, false),
None => (hit_walk(s, pos).route(), false),
},
None => (hit_walk(s, pos).route(), false),
},
PointerInput::Moved { pos, .. } => (hit_walk(s, pos).route(), false),
PointerInput::Cancelled => {
s.press = None;
(PointerRoute::Pass, false)
}
PointerInput::Entered | PointerInput::Left | PointerInput::RawDelta { .. } => {
(PointerRoute::Pass, false)
}
}
}
fn escape<O: Copy + Eq>(
win: WindowId,
s: &mut Stack<O>,
k: &KeyInput,
fx: &mut OverlayEffects<O>,
) -> bool {
if k.code != KeyCode::Escape || k.state != KeyState::Down {
return false;
}
let mut target = None;
for (i, e) in s.entries.iter().enumerate().rev() {
if e.policy.dismiss_on_escape {
target = Some(i);
break;
}
if e.policy.modal {
break;
}
}
match target {
Some(i) => {
close_at(win, s, i, CloseCause::Escape, fx);
true
}
None => false,
}
}
fn key_pass<O: Copy>(s: &Stack<O>) -> KeyRoute<O> {
let top_overlay = top_index(s)
.map(|i| &s.entries[i])
.filter(|e| e.policy.keymap_scope)
.map(|e| e.id);
KeyRoute::Pass {
top_overlay,
modal_open: s.entries.iter().any(|e| e.policy.modal),
}
}
fn hit_walk<O: Copy>(s: &Stack<O>, p: Point) -> OverlayHit<O> {
for e in s.entries.iter().rev().filter(|e| !e.transparent()) {
if e.contains(p) {
return OverlayHit::Overlay {
id: e.id,
slot: e.slot,
kind: e.kind,
};
}
if e.policy.modal {
return OverlayHit::Shielded {
id: e.id,
slot: e.slot,
};
}
}
OverlayHit::None
}
fn top_index<O>(s: &Stack<O>) -> Option<usize> {
s.entries.iter().rposition(|e| !e.transparent())
}
fn close_at<O: Copy>(
win: WindowId,
s: &mut Stack<O>,
i: usize,
cause: CloseCause,
fx: &mut OverlayEffects<O>,
) {
if s.entries[i].policy.modal {
let band = s.entries[i].key.band;
let mut above = s.entries.split_off(i + 1);
let (keep, mut above): (Vec<_>, Vec<_>) = above.drain(..).partition(|e| e.key.tier == 1 && (e.kind == OverlayKind::Toast || e.key.band < band));
uzor::sort::sort_by_key(&mut above, |e| std::cmp::Reverse(e.key.seq));
for e in above {
forget_press(s, e.slot);
fx.push(closed(win, &e, cause));
}
s.entries.extend(keep);
}
let e = s.entries.remove(i);
forget_press(s, e.slot);
fx.push(closed(win, &e, cause));
rebuild_dispatch(s);
}
fn forget_press<O>(s: &mut Stack<O>, slot: OverlaySlot) {
if matches!(s.press, Some(Press::Outside(p) | Press::Inside(p)) if p == slot) {
s.press = None;
}
}
fn closed<O: Copy>(win: WindowId, e: &Entry<O>, cause: CloseCause) -> OverlayEffect<O> {
OverlayEffect::Closed {
win,
id: e.id,
slot: e.slot,
scope: e.scope(),
cause,
restore_focus: e.policy.restore_focus,
auto_close: e.policy.auto_close_after.is_some(),
}
}
fn rebuild_dispatch<O>(s: &mut Stack<O>) {
s.dispatch.clear();
for e in &s.entries {
match e.body {
OverlayBody::Modal(_) => {
register_modal_dispatch(&mut s.dispatch, &ModalHandle::new(e.host.clone()), true)
}
OverlayBody::Popup(_) => {
register_popup_dispatch(&mut s.dispatch, &PopupHandle::new(e.host.clone()))
}
OverlayBody::Dropdown(_) => {
register_dropdown_dispatch(&mut s.dispatch, &DropdownHandle::new(e.host.clone()))
}
OverlayBody::ContextMenu(_) => register_context_menu_dispatch(
&mut s.dispatch,
&ContextMenuHandle::new(e.host.clone()),
),
OverlayBody::Tooltip | OverlayBody::Custom => {}
}
}
}
fn set_rect<O>(
win: WindowId,
e: &mut Entry<O>,
r: Rect,
viewport: Option<Rect>,
fx: &mut OverlayEffects<O>,
) -> bool {
let r = viewport.map_or(r, |v| OverlayStack::clamp_to_viewport(r, v));
if r == e.rect {
return false;
}
e.rect = r;
e.body.set_origin(r.x, r.y);
fx.push(OverlayEffect::Invalidate {
win,
bits: InvalidateBits::GEOMETRY,
});
true
}
fn place(anchor: Option<Rect>, size: OverlaySize, viewport: Option<Rect>) -> Rect {
let (w, h) = match size {
OverlaySize::Fixed { width, height } => (finite(width), finite(height)),
OverlaySize::Auto => (0.0, 0.0),
};
if let (Some(a), Some(v)) = (anchor, viewport) {
return uzor::layout::place_anchored(a, w, h, v, uzor::layout::Side::Below, 0.0, 0.0, 0.0);
}
let (x, y) = match (anchor, viewport) {
(Some(a), _) => (a.x, a.y + a.height),
(None, Some(v)) => (v.x + (v.width - w) / 2.0, v.y + (v.height - h) / 2.0),
(None, None) => (0.0, 0.0),
};
let r = Rect::new(x, y, w, h);
viewport.map_or(r, |v| OverlayStack::clamp_to_viewport(r, v))
}
fn finite(v: f64) -> f64 {
if v.is_finite() {
v.max(0.0)
} else {
0.0
}
}
#[derive(Debug)]
pub struct OverlayEngineView<'a, O> {
e: &'a OverlayEngine<O>,
}
impl<O> Clone for OverlayEngineView<'_, O> {
fn clone(&self) -> Self {
*self
}
}
impl<O> Copy for OverlayEngineView<'_, O> {}
#[allow(dead_code)]
impl<'a, O: Copy + Eq> OverlayEngineView<'a, O> {
pub fn stack(&self, win: WindowId) -> impl Iterator<Item = OverlayEntryView<'a, O>> + 'a {
self.e
.windows
.get(&win)
.into_iter()
.flat_map(|s| s.entries.iter().map(|e| OverlayEntryView { e }))
}
pub fn len(&self, win: WindowId) -> usize {
self.e.windows.get(&win).map_or(0, |s| s.entries.len())
}
pub fn is_empty(&self, win: WindowId) -> bool {
self.len(win) == 0
}
pub fn get(&self, win: WindowId, id: O) -> Option<OverlayEntryView<'a, O>> {
let s = self.e.windows.get(&win)?;
s.entries
.iter()
.find(|e| e.id == id)
.map(|e| OverlayEntryView { e })
}
pub fn top(&self, win: WindowId) -> Option<OverlayEntryView<'a, O>> {
let s = self.e.windows.get(&win)?;
top_index(s).map(|i| OverlayEntryView { e: &s.entries[i] })
}
pub fn modal_open(&self, win: WindowId) -> bool {
self.e
.windows
.get(&win)
.is_some_and(|s| s.entries.iter().any(|e| e.policy.modal))
}
pub fn key_context(&self, win: WindowId) -> KeyRoute<O> {
self.e.windows.get(&win).map_or(
KeyRoute::Pass {
top_overlay: None,
modal_open: false,
},
key_pass,
)
}
pub fn hit(&self, win: WindowId, p: Point) -> OverlayHit<O> {
self.e.hit(win, p)
}
pub fn topmost_at(&self, win: WindowId, p: Point) -> Option<OverlayEntryView<'a, O>> {
self.e.topmost_at(win, p)
}
pub fn viewport(&self, win: WindowId) -> Option<Rect> {
self.e.windows.get(&win).and_then(|s| s.viewport)
}
pub fn dispatcher(&self, win: WindowId) -> Option<&'a ClickDispatcher> {
self.e.windows.get(&win).map(|s| &s.dispatch)
}
pub fn z_table(&self) -> &'a ZLayerTable {
&self.e.z
}
pub fn snapshot(&self, win: WindowId) -> Vec<OverlayView<O>> {
let Some(s) = self.e.windows.get(&win) else {
return Vec::new();
};
let mut scoped: Vec<(u64, OverlaySlot)> = s
.entries
.iter()
.filter(|e| !e.transparent())
.map(|e| (e.key.seq, e.slot))
.collect();
uzor::sort::sort(&mut scoped);
s.entries
.iter()
.map(|e| OverlayView {
id: e.id,
slot: e.slot,
kind: e.kind,
rect: e.rect,
modal: e.policy.modal,
scope_depth: if e.transparent() {
0
} else {
scoped
.iter()
.position(|&(_, sl)| sl == e.slot)
.map_or(0, |p| p + 1)
},
})
.collect()
}
}
#[derive(Debug)]
#[allow(dead_code)]
pub struct OverlayEntryView<'a, O> {
e: &'a Entry<O>,
}
impl<O> Clone for OverlayEntryView<'_, O> {
fn clone(&self) -> Self {
*self
}
}
impl<O> Copy for OverlayEntryView<'_, O> {}
#[allow(dead_code)]
impl<'a, O: Copy> OverlayEntryView<'a, O> {
pub fn id(&self) -> O {
self.e.id
}
pub fn slot(&self) -> OverlaySlot {
self.e.slot
}
pub fn kind(&self) -> OverlayKind {
self.e.kind
}
pub fn rect(&self) -> Rect {
self.e.rect
}
pub fn anchor(&self) -> Option<Rect> {
self.e.anchor
}
pub fn size(&self) -> OverlaySize {
self.e.size
}
pub fn policy(&self) -> OverlayPolicy {
self.e.policy
}
pub fn body(&self) -> &'a OverlayBody {
&self.e.body
}
pub fn host_id(&self) -> &'a WidgetId {
&self.e.host
}
pub fn opened_at(&self) -> Seconds {
self.e.opened
}
pub fn z(&self) -> i32 {
self.e.key.z
}
pub fn band(&self) -> u32 {
self.e.key.band
}
pub fn is_transparent(&self) -> bool {
self.e.transparent()
}
}
#[cfg(test)]
mod tests;