use super::lifecycle::destroy;
use super::post::layout_window;
use super::props::{is_alive, modify, read};
use super::splitter::{sash_event, sash_key_event};
use super::{guarded, post, wake_if_scheduled, with};
use crate::backend::{Backend, Event, Kind, Native as B, Prop};
use crate::types::*;
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
pub enum Ev {
Click,
Text,
Toggled,
Selected,
Value,
Activated,
Resized,
Focus,
ColumnClicked,
TreeSelected,
TreeActivated,
TreeExpanded,
ContextMenu,
SashMoved,
Moved,
Selection,
Submit,
Cancel,
Date,
}
impl Ev {
fn of(e: &Event) -> Option<Ev> {
Some(match e {
Event::Click => Ev::Click,
Event::Text(_) => Ev::Text,
Event::Toggled(_) => Ev::Toggled,
Event::Selected(_) => Ev::Selected,
Event::Value(_) => Ev::Value,
Event::Activated(_) => Ev::Activated,
Event::Resized { .. } => Ev::Resized,
Event::Focus(_) => Ev::Focus,
Event::ColumnClicked(_) => Ev::ColumnClicked,
Event::TreeSelected(_) => Ev::TreeSelected,
Event::TreeActivated(_) => Ev::TreeActivated,
Event::TreeExpanded(..) => Ev::TreeExpanded,
Event::ContextMenu { .. } => Ev::ContextMenu,
Event::SashDragged(_) | Event::SashKey(_) => Ev::SashMoved,
Event::Moved { .. } => Ev::Moved,
Event::Selection(_) => Ev::Selection,
Event::Submit => Ev::Submit,
Event::Cancel => Ev::Cancel,
Event::DateChanged(_) => Ev::Date,
#[allow(unreachable_patterns)]
_ => return None,
})
}
}
pub type Callback = Box<dyn FnMut(&Event)>;
pub fn set_callback(id: WidgetId, ev: Ev, cb: Callback) {
modify(id, |n| {
n.cbs.insert(ev, cb);
});
}
pub fn event(id: WidgetId, ev: Event) {
let Some(key) = Ev::of(&ev) else { return };
if let Event::ContextMenu { x, y } = ev {
context_menu_event(id, x, y, &ev);
return;
}
if let Event::SashDragged(pos) = ev {
sash_event(id, pos);
return;
}
if let Event::SashKey(k) = ev {
sash_key_event(id, k);
return;
}
let mut unchecked = vec![];
let go = with(|r| {
let (kind, group) = {
let n = r.nodes.get_mut(&id)?;
match &ev {
Event::Text(s) => n.text = s.clone(),
Event::Toggled(b) => {
if let Some(c) = n.checked_mut() {
*c = *b
}
}
Event::Selected(s) => {
if s.is_some_and(|i| i >= n.selectable_len()) {
return None;
}
n.set_selection(*s);
}
Event::Selection(v) => {
let len = n.selectable_len();
if v.iter().any(|i| *i >= len) {
return None;
}
n.sel_mut()?.set_many(v, len);
}
Event::Activated(i) => {
if n.table().is_some_and(|t| *i >= t.rows.len()) {
return None;
}
}
Event::ColumnClicked(c) => {
if n.table().is_none_or(|t| *c >= t.columns.len()) {
return None;
}
}
Event::TreeSelected(s) => {
let t = n.tree_mut()?;
if s.is_some_and(|x| !t.nodes.contains_key(&x)) {
return None;
}
t.selected = *s;
}
Event::TreeActivated(x) => {
if !n.tree()?.nodes.contains_key(x) {
return None;
}
}
Event::TreeExpanded(x, b) => {
n.tree_mut()?.nodes.get_mut(x)?.expanded = *b;
}
Event::Value(v) => {
if let Some(r) = n.range_mut() {
r.value = *v
}
}
Event::DateChanged(d) => {
if !d.is_valid() {
return None;
}
*n.date_mut()? = *d;
}
Event::Moved { x, y } => {
n.window_mut()?.position = Some((*x, *y));
}
Event::Resized { w, h } => {
let sz = Size::new((*w).clamp(0, MAX_WINDOW_PX), (*h).clamp(0, MAX_WINDOW_PX));
let win = n.window_mut()?;
let same = win.client == sz;
win.client = sz;
win.explicit_size = true;
if !same {
r.dirty_layout.insert(id);
}
return Some(!same);
}
_ => {}
}
(n.kind, n.check().map_or(0, |c| c.group))
};
match ev {
Event::Focus(true) => r.focus = Some(id),
Event::Focus(false) if r.focus == Some(id) => r.focus = None,
Event::Toggled(true) if kind == Kind::RadioButton && group != 0 => {
unchecked = r.checked_in_group(group, id);
for k in &unchecked {
if let Some(c) = r.nodes.get_mut(k).and_then(|n| n.check_mut()) {
c.checked = false;
}
}
}
_ => {}
}
Some(true)
})
.flatten();
if go != Some(true) {
return;
}
for u in unchecked {
B::set(u, &Prop::Checked(false));
}
if key == Ev::Resized {
layout_window(id);
}
if matches!(ev, Event::Selected(_) | Event::Selection(_)) {
let both = read(id, |n| n.sel().map(|s| (s.first(), s.items.clone()))).flatten();
if let Some((first, all)) = both {
fire(id, Ev::Selected, &Event::Selected(first));
fire(id, Ev::Selection, &Event::Selection(all));
wake_if_scheduled();
return;
}
}
fire(id, key, &ev);
wake_if_scheduled();
}
fn fire(id: WidgetId, key: Ev, ev: &Event) {
let cb = with(|r| r.nodes.get_mut(&id).and_then(|n| n.cbs.remove(&key))).flatten();
if let Some(mut cb) = cb {
guarded(|| cb(ev));
with(|r| {
if let Some(n) = r.nodes.get_mut(&id) {
n.cbs.entry(key).or_insert(cb);
}
});
}
}
fn context_menu_event(id: WidgetId, x: i32, y: i32, ev: &Event) {
let target = with(|r| {
let mut cur = Some(id);
while let Some(i) = cur {
let n = r.nodes.get(&i)?;
if !n.enabled {
return None;
}
if n.context_menu.is_some() || n.cbs.contains_key(&Ev::ContextMenu) {
return Some(i);
}
cur = n.parent;
}
None
})
.flatten();
let Some(target) = target else { return };
let cb = with(|r| {
r.nodes
.get_mut(&target)
.and_then(|n| n.cbs.remove(&Ev::ContextMenu))
})
.flatten();
if let Some(mut cb) = cb {
guarded(|| cb(ev));
with(|r| {
if let Some(n) = r.nodes.get_mut(&target) {
n.cbs.entry(Ev::ContextMenu).or_insert(cb);
}
});
}
let menu = read(target, |n| n.context_menu).flatten();
if let Some(m) = menu {
let win = with(|r| r.window_of(target)).flatten();
popup_menu(m, win, Some((x, y)));
}
wake_if_scheduled();
}
pub fn popup_menu(menu: WidgetId, parent_window: Option<WidgetId>, at: Option<(i32, i32)>) {
if read(menu, |n| n.kind == Kind::PopupMenu) != Some(true) {
return;
}
let win = parent_window.filter(|w| read(*w, |n| n.kind == Kind::Window) == Some(true));
B::popup_menu(menu, win, at);
wake_if_scheduled();
}
pub fn close_requested(id: WidgetId) {
let cb = with(|r| {
r.nodes
.get_mut(&id)
.and_then(|n| n.window_mut()?.on_close.take())
})
.flatten();
let mut allow = true;
if let Some(mut cb) = cb {
guarded(|| allow = cb());
with(|r| {
if let Some(w) = r.nodes.get_mut(&id).and_then(|n| n.window_mut()) {
if w.on_close.is_none() {
w.on_close = Some(cb);
}
}
});
}
if allow && is_alive(id) {
post(move || destroy(id));
}
}
pub fn run_modal(id: WidgetId, parent: Option<WidgetId>) {
let running = with(|r| {
if r.nodes.get(&id)?.kind != Kind::Window || r.modal.contains(&id) {
return None;
}
r.modal.push(id);
Some(())
})
.flatten();
if running.is_none() {
return;
}
let parent = parent.filter(|p| *p != id && read(*p, |n| n.kind == Kind::Window) == Some(true));
super::props::set_flag(id, true, true);
if read(id, |n| n.visible) == Some(true) {
B::run_modal(id, parent);
}
with(|r| r.modal.retain(|w| *w != id));
wake_if_scheduled();
}
pub fn today() -> Date {
B::today().filter(Date::is_valid).unwrap_or_else(|| {
let secs = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_secs() as i64);
Date::from_unix_utc(secs)
})
}