use super::model::{Node, NodeData, RangeData};
use super::props::read;
use super::splitter::panes_of;
use super::{post, set_error, wake, with};
use crate::backend::{Backend, Kind, Native as B, Prop};
use crate::types::*;
use std::sync::atomic::{AtomicU64, Ordering};
static NEXT_ID: AtomicU64 = AtomicU64::new(1);
pub const MAX_NESTING: usize = 128;
fn accepts(p: Kind, k: Kind) -> bool {
match k {
Kind::Window => false,
Kind::Page => p == Kind::Tabs,
Kind::MenuBar => p == Kind::Window,
Kind::Menu => matches!(p, Kind::MenuBar | Kind::Menu | Kind::PopupMenu),
Kind::MenuItem | Kind::CheckMenuItem | Kind::MenuSeparator => {
matches!(p, Kind::Menu | Kind::PopupMenu)
}
Kind::PopupMenu => false,
Kind::Sash => p == Kind::Splitter,
_ => k.in_layout() && p.is_layout_container(),
}
}
pub fn create(kind: Kind, parent: Option<WidgetId>, setup: impl FnOnce(&mut Node)) -> WidgetId {
let id = WidgetId(NEXT_ID.fetch_add(1, Ordering::Relaxed));
let made = with(|r| {
let mut native_parent = None;
if let Some(p) = parent {
let ok = r.nodes.get(&p).is_some_and(|n| {
accepts(n.kind, kind)
&& n.split().is_none_or(|sp| {
if kind == Kind::Sash {
sp.sash.is_none()
} else {
panes_of(r, n).len() < 2
}
})
});
if !ok {
return Err(Error::InvalidHandle);
}
if r.depth_of(p) > MAX_NESTING {
return Err(Error::LimitExceeded);
}
native_parent = r.native_of(p);
} else if kind != Kind::Window && kind != Kind::PopupMenu {
return Err(Error::InvalidHandle);
}
let mut n = Node::new(kind);
n.parent = parent;
setup(&mut n);
if kind == Kind::Page {
if let Some(t) = parent.and_then(|p| r.nodes.get_mut(&p)) {
if let NodeData::Tabs(sel @ None) = &mut t.data {
*sel = Some(0);
}
}
}
if let Some(c) = n.check().filter(|c| c.group != 0) {
r.radio_groups.entry(c.group).or_default().push(id);
}
r.nodes.insert(id, n);
if let Some(p) = parent.and_then(|p| r.nodes.get_mut(&p)) {
p.children.push(id);
if let Some(sp) = p.split_mut().filter(|_| kind == Kind::Sash) {
sp.sash = Some(id);
}
}
if kind == Kind::Window {
r.windows.push(id);
}
let wake = r.touch(id, true);
Ok((native_parent, wake))
});
let (native_parent, need_wake) = match made {
Some(Ok(x)) => x,
Some(Err(e)) => {
set_error(e);
return WidgetId::DEAD;
}
None => {
set_error(Error::NotInitialized);
return WidgetId::DEAD;
}
};
if kind.is_native() {
if let Err(e) = B::create(id, kind, native_parent) {
remove_nodes(id);
set_error(e);
return WidgetId::DEAD;
}
sync_initial(id);
}
if need_wake {
wake();
}
id
}
fn sync_initial(id: WidgetId) {
enum Init {
Nothing,
Text {
placeholder: String,
readonly: bool,
},
Range(RangeData),
List {
items: Vec<String>,
selected: Option<usize>,
},
Check(bool),
MenuItem {
accel: String,
checked: bool,
},
Image(Option<ImageData>),
Date(Date),
}
let Some((text, tooltip, enabled, init)) = with(|r| {
let n = r.nodes.get(&id)?;
let init = match &n.data {
NodeData::Text(t) => Init::Text {
placeholder: t.placeholder.clone(),
readonly: t.readonly,
},
NodeData::Range(r) => Init::Range(RangeData { ..*r }),
NodeData::List(l) => Init::List {
items: l.items.clone(),
selected: l.sel.first(),
},
NodeData::Check(c) => Init::Check(c.checked),
NodeData::MenuItem(m) => Init::MenuItem {
accel: m.accel.clone(),
checked: m.checked,
},
NodeData::Image(i) => Init::Image(i.clone()),
NodeData::Date(d) => Init::Date(*d),
_ => Init::Nothing,
};
Some((n.text.clone(), n.tooltip.clone(), n.enabled, init))
})
.flatten() else {
return;
};
if !text.is_empty() {
B::set(id, &Prop::Text(&text));
}
if !tooltip.is_empty() {
B::set(id, &Prop::Tooltip(&tooltip));
}
match &init {
Init::Nothing => {}
Init::Text {
placeholder,
readonly,
} => {
if !placeholder.is_empty() {
B::set(id, &Prop::Placeholder(placeholder));
}
if *readonly {
B::set(id, &Prop::ReadOnly(true));
}
}
Init::Range(r) => {
B::set(
id,
&Prop::Range {
min: r.range.0,
max: r.range.1,
step: r.range.2,
},
);
B::set(id, &Prop::Value(r.value));
if r.indeterminate {
B::set(id, &Prop::Indeterminate(true));
}
}
Init::List { items, selected } => {
if !items.is_empty() {
B::set(id, &Prop::Items(items));
}
if selected.is_some() {
B::set(id, &Prop::Selected(*selected));
}
}
Init::Check(checked) => {
if *checked {
B::set(id, &Prop::Checked(true));
}
}
Init::MenuItem { accel, checked } => {
if !accel.is_empty() {
B::set(id, &Prop::Accel(accel));
}
if *checked {
B::set(id, &Prop::Checked(true));
}
}
Init::Image(_) => {}
Init::Date(d) => B::set(id, &Prop::Date(*d)),
}
if !enabled {
B::set(id, &Prop::Enabled(false));
}
if let Init::Image(Some(img)) = &init {
B::set(id, &Prop::Image(Some(img)));
}
}
fn remove_nodes(id: WidgetId) -> Vec<WidgetId> {
with(|r| {
let mut order = vec![];
let mut stack = vec![id];
while let Some(i) = stack.pop() {
if let Some(n) = r.nodes.get(&i) {
stack.extend(n.children.iter().copied());
order.push(i);
}
}
let win = r.window_of(id);
let is_window = r.nodes.get(&id).is_some_and(|n| n.kind == Kind::Window);
if let Some(p) = r.nodes.get(&id).and_then(|n| n.parent) {
if let Some(pn) = r.nodes.get_mut(&p) {
if let Some(i) = pn.children.iter().position(|c| *c == id) {
pn.children.remove(i); }
}
if let Some(w) = win {
if w != id {
r.touch(w, true);
}
}
}
let mut natives = vec![];
for i in order.iter().rev() {
if let Some(n) = r.nodes.remove(i) {
if n.kind.is_native() {
natives.push(*i);
}
if let Some(g) = n.check().map(|c| c.group).filter(|g| *g != 0) {
if let Some(members) = r.radio_groups.get_mut(&g) {
members.retain(|m| m != i);
if members.is_empty() {
r.radio_groups.remove(&g);
}
}
}
}
if r.focus == Some(*i) {
r.focus = None;
}
}
if is_window {
r.windows.retain(|w| *w != id); }
r.dirty_layout.retain(|w| r.nodes.contains_key(w));
r.dirty_a11y.retain(|w| r.nodes.contains_key(w));
natives
})
.unwrap_or_default()
}
pub fn destroy(id: WidgetId) {
let was_window = read(id, |n| n.kind == Kind::Window).unwrap_or(false);
for n in remove_nodes(id) {
B::destroy(n);
}
if was_window && with(|r| r.windows.is_empty() && r.quit_on_last_close).unwrap_or(false) {
post(B::quit);
}
wake();
}