use super::events::{Callback, Ev};
use crate::a11y::A11yProps;
use crate::backend::Kind;
use crate::types::*;
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
#[derive(Clone, Debug)]
pub struct LayoutProps {
pub expand: f32,
pub align: Align,
pub min: Size,
pub fixed: Option<Size>,
pub cell: Option<(usize, usize, usize, usize)>,
pub spacing: i32,
pub padding: i32,
pub cols: usize,
}
#[derive(Clone, Debug, Default)]
pub struct Batch {
pub freeze: u32,
pub pending: Option<Data>,
pub cells: Vec<(usize, usize)>,
}
#[derive(Clone, Debug, Default)]
pub struct Selection {
pub multi: bool,
pub items: Vec<usize>,
}
impl Selection {
pub fn first(&self) -> Option<usize> {
self.items.first().copied()
}
pub fn set_one(&mut self, i: Option<usize>) {
self.items.clear();
self.items.extend(i);
}
pub fn set_many(&mut self, v: &[usize], len: usize) {
self.items = v.iter().copied().filter(|i| *i < len).collect();
self.items.sort_unstable();
self.items.dedup();
if !self.multi {
self.items.truncate(1);
}
}
pub fn set_multi(&mut self, multi: bool) {
self.multi = multi;
if !multi {
self.items.truncate(1);
}
}
pub fn truncate_to(&mut self, len: usize) {
self.items.retain(|i| *i < len);
}
pub fn on_insert(&mut self, at: usize) {
for i in self.items.iter_mut().filter(|i| **i >= at) {
*i += 1;
}
}
pub fn on_remove(&mut self, at: usize) {
self.items.retain(|i| *i != at);
for i in self.items.iter_mut().filter(|i| **i > at) {
*i -= 1;
}
}
}
#[derive(Clone, Debug, Default)]
pub struct TableData {
pub columns: Vec<Column>,
pub rows: Vec<Vec<String>>,
pub sort: Option<(usize, bool)>,
pub sel: Selection,
pub batch: Batch,
}
#[derive(Clone, Debug)]
pub struct TreeNode {
pub text: String,
pub parent: Option<u64>,
pub children: Vec<u64>,
pub expanded: bool,
pub has_children: bool,
}
#[derive(Clone, Debug, Default)]
pub struct SplitData {
pub orient: Orientation,
pub pos: Option<i32>,
pub min: (i32, i32),
pub sash: Option<WidgetId>,
pub actual: i32,
pub area: Rect,
pub thick: i32,
pub laid_out: bool,
}
impl SplitData {
pub fn clamp(&self, want: i32, avail: i32) -> i32 {
let room = (avail - self.thick).max(0);
want.min(room.saturating_sub(self.min.1))
.max(self.min.0)
.min(room)
.max(0)
}
}
static NEXT_TREE_NODE: AtomicU64 = AtomicU64::new(1);
#[derive(Clone, Debug, Default)]
pub struct TreeData {
pub nodes: HashMap<u64, TreeNode>,
pub roots: Vec<u64>,
pub selected: Option<u64>,
pub batch: Batch,
}
impl TreeData {
pub fn insert(&mut self, parent: Option<u64>, index: usize, text: &str) -> u64 {
if parent.is_some_and(|p| !self.nodes.contains_key(&p)) {
return 0;
}
let id = NEXT_TREE_NODE.fetch_add(1, Ordering::Relaxed);
self.nodes.insert(
id,
TreeNode {
text: text.to_string(),
parent,
children: vec![],
expanded: false,
has_children: false,
},
);
let list = match parent {
Some(p) => self.nodes.get_mut(&p).map(|n| &mut n.children),
None => Some(&mut self.roots),
};
if let Some(l) = list {
let i = index.min(l.len());
l.insert(i, id);
}
id
}
pub fn remove(&mut self, id: u64) -> bool {
let Some(n) = self.nodes.get(&id) else {
return false;
};
match n.parent {
Some(p) => {
if let Some(pn) = self.nodes.get_mut(&p) {
pn.children.retain(|c| *c != id);
}
}
None => self.roots.retain(|c| *c != id),
}
let mut stack = vec![id];
while let Some(i) = stack.pop() {
if let Some(n) = self.nodes.remove(&i) {
stack.extend(n.children);
}
if self.selected == Some(i) {
self.selected = None;
}
}
true
}
pub fn clear(&mut self) {
self.nodes.clear();
self.roots.clear();
self.selected = None;
}
pub fn children_of(&self, parent: Option<u64>) -> &[u64] {
match parent {
Some(p) => self.nodes.get(&p).map_or(&[], |n| &n.children[..]),
None => &self.roots,
}
}
pub fn flatten(&self) -> Vec<TreeRow> {
let mut out = Vec::with_capacity(self.nodes.len());
let mut stack: Vec<(u64, u32)> = self.roots.iter().rev().map(|r| (*r, 0)).collect();
while let Some((id, depth)) = stack.pop() {
let Some(n) = self.nodes.get(&id) else {
continue;
};
out.push(TreeRow {
node: id,
depth,
text: n.text.clone(),
expanded: n.expanded,
has_children: n.has_children || !n.children.is_empty(),
});
stack.extend(n.children.iter().rev().map(|c| (*c, depth + 1)));
}
out
}
pub fn reveal(&mut self, id: u64) {
let mut cur = self.nodes.get(&id).and_then(|n| n.parent);
while let Some(p) = cur {
let Some(n) = self.nodes.get_mut(&p) else {
break;
};
n.expanded = true;
cur = n.parent;
}
}
}
pub struct Node {
pub kind: Kind,
pub parent: Option<WidgetId>,
pub children: Vec<WidgetId>,
pub text: String,
pub tooltip: String,
pub enabled: bool,
pub visible: bool,
pub bounds: Rect,
pub a11y: A11yProps,
pub lay: LayoutProps,
pub cbs: HashMap<Ev, Callback>,
pub context_menu: Option<WidgetId>,
pub data: NodeData,
}
pub enum NodeData {
Plain,
Window(Box<WindowData>),
Tabs(Option<usize>),
Check(CheckData),
MenuItem(MenuItemData),
Text(TextData),
Range(RangeData),
List(ListData),
Image(Option<ImageData>),
Table(Box<TableData>),
Tree(Box<TreeData>),
Split(Box<SplitData>),
Date(Date),
}
pub struct WindowData {
pub client: Size,
pub explicit_size: bool,
pub resizable: bool,
pub position: Option<(i32, i32)>,
pub on_close: Option<Box<dyn FnMut() -> bool>>,
}
pub struct CheckData {
pub checked: bool,
pub group: u32,
}
#[derive(Default)]
pub struct MenuItemData {
pub accel: String,
pub checked: bool,
}
pub struct TextData {
pub placeholder: String,
pub readonly: bool,
pub monospace: bool,
pub wrap: bool,
}
pub struct RangeData {
pub value: f64,
pub range: (f64, f64, f64),
pub indeterminate: bool,
}
#[derive(Default)]
pub struct ListData {
pub items: Vec<String>,
pub sel: Selection,
}
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum Data {
TableAll,
TableRows,
TableCells,
TableSelected,
TableSort,
TreeRows,
}
macro_rules! accessors {
($($get:ident, $get_mut:ident, $variant:ident, $ty:ty;)*) => {$(
#[allow(dead_code)]
pub fn $get(&self) -> Option<&$ty> {
match &self.data {
NodeData::$variant(d) => Some(d),
_ => None,
}
}
pub fn $get_mut(&mut self) -> Option<&mut $ty> {
match &mut self.data {
NodeData::$variant(d) => Some(d),
_ => None,
}
}
)*};
}
impl NodeData {
pub fn for_kind(kind: Kind) -> NodeData {
match kind {
Kind::Window => NodeData::Window(Box::new(WindowData {
client: Size::default(),
explicit_size: false,
resizable: true,
position: None,
on_close: None,
})),
Kind::Tabs => NodeData::Tabs(None),
Kind::CheckBox | Kind::RadioButton => NodeData::Check(CheckData {
checked: false,
group: 0,
}),
Kind::MenuItem | Kind::CheckMenuItem => NodeData::MenuItem(MenuItemData::default()),
Kind::TextInput | Kind::PasswordInput | Kind::TextArea => NodeData::Text(TextData {
placeholder: String::new(),
readonly: false,
monospace: false,
wrap: true,
}),
Kind::Slider | Kind::SpinBox | Kind::ProgressBar => NodeData::Range(RangeData {
value: 0.0,
range: match kind {
Kind::ProgressBar => (0.0, 1.0, 0.01),
_ => (0.0, 100.0, 1.0),
},
indeterminate: false,
}),
Kind::ComboBox | Kind::ListBox => NodeData::List(ListData::default()),
Kind::Image => NodeData::Image(None),
Kind::Table => NodeData::Table(Box::default()),
Kind::Tree => NodeData::Tree(Box::default()),
Kind::Splitter => NodeData::Split(Box::default()),
Kind::Calendar => NodeData::Date(super::today()),
_ => NodeData::Plain,
}
}
}
impl Node {
accessors! {
window, window_mut, Window, WindowData;
menu_item, menu_item_mut, MenuItem, MenuItemData;
check, check_mut, Check, CheckData;
text_data, text_data_mut, Text, TextData;
range, range_mut, Range, RangeData;
list, list_mut, List, ListData;
table, table_mut, Table, TableData;
tree, tree_mut, Tree, TreeData;
split, split_mut, Split, SplitData;
date, date_mut, Date, Date;
}
pub fn selection(&self) -> Option<usize> {
match &self.data {
NodeData::List(l) => l.sel.first(),
NodeData::Tabs(s) => *s,
NodeData::Table(t) => t.sel.first(),
_ => None,
}
}
pub fn sel(&self) -> Option<&Selection> {
match &self.data {
NodeData::List(l) => Some(&l.sel),
NodeData::Table(t) => Some(&t.sel),
_ => None,
}
}
pub fn sel_mut(&mut self) -> Option<&mut Selection> {
match &mut self.data {
NodeData::List(l) => Some(&mut l.sel),
NodeData::Table(t) => Some(&mut t.sel),
_ => None,
}
}
pub fn selectable_len(&self) -> usize {
match &self.data {
NodeData::List(l) => l.items.len(),
NodeData::Tabs(_) => self.children.len(),
NodeData::Table(t) => t.rows.len(),
_ => 0,
}
}
pub fn set_selection(&mut self, i: Option<usize>) {
match &mut self.data {
NodeData::List(l) => l.sel.set_one(i),
NodeData::Tabs(s) => *s = i,
NodeData::Table(t) => t.sel.set_one(i),
_ => {}
}
}
pub fn checked(&self) -> bool {
match &self.data {
NodeData::Check(c) => c.checked,
NodeData::MenuItem(m) => m.checked,
_ => false,
}
}
pub fn checked_mut(&mut self) -> Option<&mut bool> {
match &mut self.data {
NodeData::Check(c) => Some(&mut c.checked),
NodeData::MenuItem(m) => Some(&mut m.checked),
_ => None,
}
}
pub fn batch_mut(&mut self) -> Option<&mut Batch> {
match &mut self.data {
NodeData::Table(t) => Some(&mut t.batch),
NodeData::Tree(t) => Some(&mut t.batch),
_ => None,
}
}
pub(super) fn new(kind: Kind) -> Node {
let boxy = matches!(kind, Kind::Window | Kind::Page | Kind::GroupBox);
Node {
kind,
parent: None,
children: vec![],
text: String::new(),
tooltip: String::new(),
enabled: true,
visible: kind != Kind::Window,
bounds: Rect::default(),
a11y: A11yProps::default(),
lay: LayoutProps {
expand: 0.0,
align: Align::Fill,
min: Size::default(),
fixed: None,
cell: None,
spacing: 6,
padding: if boxy { 10 } else { 0 },
cols: 2,
},
cbs: HashMap::new(),
context_menu: None,
data: NodeData::for_kind(kind),
}
}
}