use std::{
collections::{HashMap, HashSet},
sync::{
Arc,
atomic::{AtomicBool, Ordering},
},
};
use super::node::{Node, SyntheticNodeRole};
static HELD_IN_USE: AtomicBool = AtomicBool::new(false);
#[derive(Default)]
struct Held<'a> {
stands: Option<&'a Node>,
root: Option<&'a Node>,
count: (usize, usize),
declared: bool,
}
impl Node {
pub(crate) fn is_component_slot_placeholder(&self) -> bool {
self.has_synthetic_role(SyntheticNodeRole::ComponentSlot)
}
fn component_slot_placeholder(&self) -> Node {
let mut placeholder = Node::new();
placeholder.component_slot_id = self.component_slot_id;
placeholder.component_key = self.component_key.clone();
placeholder.outer_decoration = self.outer_decoration.clone();
placeholder.synthetic_role = Some(SyntheticNodeRole::ComponentSlot);
placeholder
}
pub(crate) fn clone_own_output(&self, own: &dyn Fn(u64) -> bool) -> Box<Node> {
Box::new(self.clone_with_component_roots(&mut |root: &Node| {
own(root.component_slot_id?).then(|| root.component_slot_placeholder())
}))
}
pub(crate) fn clone_with_component_roots(&self, component_root: &mut dyn FnMut(&Node) -> Option<Node>) -> Node {
let overlay_declaration = self
.overlay_declaration
.as_ref()
.map(|spec| Box::new(spec.clone_with_node(spec.node.clone_below(component_root))));
let modal_declaration = self
.modal_declaration
.as_ref()
.map(|spec| Box::new(spec.clone_with_node(spec.node.clone_below(component_root))));
let mut children = Vec::with_capacity(self.children.len());
for child in &self.children {
children.push(child.clone_below(component_root));
}
self.clone_around(overlay_declaration, modal_declaration, children)
}
pub(crate) fn held_component(slot: u64, key: Option<&str>) -> Node {
HELD_IN_USE.store(true, Ordering::Relaxed);
let mut held = Node::new();
held.component_slot_id = Some(slot);
held.component_key = key.map(Arc::from);
held.synthetic_role = Some(SyntheticNodeRole::HeldComponent);
held
}
pub(crate) fn is_held_component(&self) -> bool {
self.has_synthetic_role(SyntheticNodeRole::HeldComponent)
}
pub(crate) fn settle_held_components(
&mut self,
old: &Node,
cached: &dyn Fn(u64) -> Option<Box<Node>>,
) -> HashSet<u64> {
if !HELD_IN_USE.load(Ordering::Relaxed) {
return HashSet::new();
}
let moved = {
let mut held = HashMap::new();
self.find_held(false, &mut held);
if held.is_empty() {
return HashSet::new();
}
old.find_held_roots(false, &mut held);
held
.into_iter()
.filter(|(_, held)| {
held.count == (1, 1)
&& !held.declared
&& matches!((held.stands, held.root), (Some(stands), Some(root)) if stands.same_plain_outer_decoration(root))
})
.map(|(slot, _)| slot)
.collect::<HashSet<u64>>()
};
self.make_held(&moved, cached);
moved
}
pub(crate) fn take_held_components_from(&mut self, old: &mut Node, moved: HashSet<u64>) {
if moved.is_empty() {
return;
}
let mut taken = HashMap::with_capacity(moved.len());
old.take_roots(&moved, &mut taken);
self.put_held(&mut taken);
}
fn find_held<'a>(&'a self, declared: bool, held: &mut HashMap<u64, Held<'a>>) {
if self.is_held_component() {
if let Some(slot) = self.component_slot_id {
let entry = held.entry(slot).or_default();
entry.stands = Some(self);
entry.count.0 += 1;
entry.declared |= declared;
}
return;
}
for child in &self.children {
child.find_held(declared, held);
}
if let Some(spec) = self.overlay_declaration.as_deref() {
spec.node.find_held(true, held);
}
if let Some(spec) = self.modal_declaration.as_deref() {
spec.node.find_held(true, held);
}
}
fn find_held_roots<'a>(&'a self, declared: bool, held: &mut HashMap<u64, Held<'a>>) {
if let Some(entry) = self.component_slot_id.and_then(|slot| held.get_mut(&slot)) {
entry.root = Some(self);
entry.count.1 += 1;
entry.declared |= declared;
return;
}
for child in &self.children {
child.find_held_roots(declared, held);
}
if let Some(spec) = self.overlay_declaration.as_deref() {
spec.node.find_held_roots(true, held);
}
if let Some(spec) = self.modal_declaration.as_deref() {
spec.node.find_held_roots(true, held);
}
}
fn make_held(&mut self, moved: &HashSet<u64>, cached: &dyn Fn(u64) -> Option<Box<Node>>) {
if self.is_held_component() {
let Some(slot) = self.component_slot_id else {
return;
};
if moved.contains(&slot) {
return;
}
if let Some(mut output) = cached(slot) {
output.adopt_outer_decoration(self);
output.make_held(&HashSet::new(), cached);
*self = *output;
}
return;
}
for child in &mut self.children {
child.make_held(moved, cached);
}
if let Some(spec) = self.overlay_declaration.as_deref_mut() {
spec.node.make_held(moved, cached);
}
if let Some(spec) = self.modal_declaration.as_deref_mut() {
spec.node.make_held(moved, cached);
}
}
fn take_roots(&mut self, moved: &HashSet<u64>, taken: &mut HashMap<u64, Node>) {
if let Some(slot) = self.component_slot_id
&& moved.contains(&slot)
{
taken.insert(slot, std::mem::take(self));
return;
}
for child in &mut self.children {
child.take_roots(moved, taken);
}
}
fn put_held(&mut self, taken: &mut HashMap<u64, Node>) {
if self.is_held_component() {
if let Some(mut root) = self.component_slot_id.and_then(|slot| taken.remove(&slot)) {
if let Some(theme) = self.theme_scope.as_deref() {
root.set_theme_scope(theme);
}
*self = root;
}
return;
}
if taken.is_empty() {
return;
}
for child in &mut self.children {
child.put_held(taken);
}
}
fn clone_below(&self, component_root: &mut dyn FnMut(&Node) -> Option<Node>) -> Node {
if self.component_slot_id.is_some()
&& let Some(node) = component_root(self)
{
return node;
}
self.clone_with_component_roots(component_root)
}
}