zaxis 0.0.5

An event-driven immediate mode GUI for desktop tools
Documentation
use std::collections::HashMap;
use zaxis::{Id, ImageSource, TreeChildren, TreeModel, TreeNode};
pub fn id(n: u64) -> Id {
    Id::new(n)
}
pub struct Object {
    pub label: String,
    pub parent: Option<Id>,
    pub children: Vec<Id>,
    pub kind: TreeChildren,
    pub enabled: bool,
}
pub struct Objects {
    pub revision: u64,
    pub roots: Vec<Id>,
    pub nodes: HashMap<Id, Object>,
    pub icon: ImageSource,
    pub next: u64,
}
impl Objects {
    pub fn new() -> Self {
        let mut model = Self {
            revision: 0,
            roots: vec![id(0), id(100)],
            nodes: HashMap::new(),
            icon: ImageSource::bytes(include_bytes!("../../assets/images/icon.svg")),
            next: 50_000,
        };
        model.insert(0, None, "Workspace", TreeChildren::Loaded);
        model.insert(1, Some(id(0)), "Objects", TreeChildren::Loaded);
        model.insert(2, Some(id(0)), "Remote", TreeChildren::Unloaded);
        model.insert(3, Some(id(0)), "Settings", TreeChildren::Leaf);
        model.insert(4, Some(id(1)), "Object", TreeChildren::Leaf);
        model.insert(5, Some(id(1)), "Object", TreeChildren::Leaf);
        model.insert(6, Some(id(1)), "Unavailable", TreeChildren::Loaded);
        model.nodes.get_mut(&id(6)).unwrap().enabled = false;
        model.insert(7, Some(id(6)), "Available child", TreeChildren::Leaf);
        model.insert(100, None, "10,000 objects", TreeChildren::Loaded);
        for n in 1000..11000 {
            model.insert(
                n,
                Some(id(100)),
                &format!("Object {}", n - 999),
                TreeChildren::Leaf,
            );
        }
        model
    }
    fn insert(&mut self, n: u64, parent: Option<Id>, label: &str, kind: TreeChildren) {
        self.nodes.insert(
            id(n),
            Object {
                label: label.into(),
                parent,
                children: Vec::new(),
                kind,
                enabled: true,
            },
        );
        if let Some(p) = parent {
            self.nodes.get_mut(&p).unwrap().children.push(id(n));
        }
    }
    pub fn add(&mut self) {
        let n = self.next;
        self.next += 1;
        self.insert(n, Some(id(1)), "Object", TreeChildren::Leaf);
        self.revision += 1;
    }
    pub fn remove(&mut self, selected: Id) {
        if self
            .nodes
            .get(&selected)
            .is_some_and(|n| n.kind == TreeChildren::Leaf)
        {
            let node = self.nodes.remove(&selected).unwrap();
            if let Some(p) = node.parent {
                self.nodes
                    .get_mut(&p)
                    .unwrap()
                    .children
                    .retain(|id| *id != selected);
            }
            self.revision += 1;
        }
    }
    pub fn load(&mut self, branch: Id) {
        if let Some(n) = self.nodes.get_mut(&branch) {
            n.kind = TreeChildren::Loading;
            self.revision += 1;
        }
    }
    pub fn finish_loading(&mut self) {
        if self.nodes[&id(2)].kind == TreeChildren::Loading {
            let n = self.next;
            self.next += 1;
            self.insert(n, Some(id(2)), "Remote object", TreeChildren::Leaf);
            self.nodes.get_mut(&id(2)).unwrap().kind = TreeChildren::Loaded;
            self.revision += 1;
        }
    }
}
impl TreeModel for Objects {
    fn revision(&self) -> u64 {
        self.revision
    }
    fn roots(&self) -> impl Iterator<Item = Id> {
        self.roots.iter().copied()
    }
    fn children(&self, id: Id) -> impl Iterator<Item = Id> {
        self.nodes
            .get(&id)
            .into_iter()
            .flat_map(|n| n.children.iter().copied())
    }
    fn node(&self, id: Id) -> Option<TreeNode<'_>> {
        self.nodes.get(&id).map(|n| {
            TreeNode::leaf(&n.label)
                .icon(&self.icon)
                .enabled(n.enabled)
                .children(n.kind)
        })
    }
    fn parent(&self, id: Id) -> Option<Id> {
        self.nodes.get(&id).and_then(|n| n.parent)
    }
}