use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
use crate::{
app::ctx::Ctx,
node::{Element, Node},
};
static DECLARED_IN_USE: AtomicBool = AtomicBool::new(false);
pub(crate) type DeclaredMount = Arc<dyn Fn(&mut Ctx, Option<&str>) -> Element + Send + Sync>;
#[derive(Clone)]
pub(crate) struct DeclaredComponent {
pub(crate) mount: DeclaredMount,
pub(crate) key: Option<Arc<str>>,
}
pub(crate) type NodeDecoration = Arc<dyn Fn(Node) -> Node + Send + Sync>;
#[derive(Clone, Default)]
pub(crate) struct OuterDecoration {
id: Option<Arc<str>>,
key: Option<Arc<str>>,
classes: Vec<Arc<str>>,
decorations: Vec<NodeDecoration>,
theme: Option<crate::app::theme::Theme>,
declared: Option<DeclaredComponent>,
}
impl Node {
fn outer_decoration_mut(&mut self) -> Option<&mut OuterDecoration> {
if self.component_slot_id.is_none() && !self.declares_component() {
return None;
}
Some(self.outer_decoration.get_or_insert_with(Box::default))
}
pub(crate) fn declaring(component: DeclaredComponent) -> Self {
DECLARED_IN_USE.store(true, Ordering::Relaxed);
let mut node = Node::new();
node.outer_decoration = Some(Box::new(OuterDecoration {
declared: Some(component),
..OuterDecoration::default()
}));
node
}
pub(crate) fn declares_component(&self) -> bool {
self
.outer_decoration
.as_deref()
.is_some_and(|outer| outer.declared.is_some())
}
pub(crate) fn mount_declared_components(&mut self, ctx: &mut Ctx) {
if DECLARED_IN_USE.load(Ordering::Relaxed) {
self.replace_declared(ctx);
}
}
pub(crate) fn warn_of_declared_components(&self) {
if DECLARED_IN_USE.load(Ordering::Relaxed) && self.holds_declared() {
static SAID: std::sync::Once = std::sync::Once::new();
SAID.call_once(|| {
tracing::warn!(
"an element declares a component (`Element::component`) in a tree no component renders: it shows \
nothing. Give the window a root component (`Tree::mount_root`)."
);
});
}
}
fn holds_declared(&self) -> bool {
self.declares_component()
|| self.children.iter().any(Node::holds_declared)
|| self
.overlay_declaration
.as_deref()
.is_some_and(|overlay| overlay.node.holds_declared())
|| self
.modal_declaration
.as_deref()
.is_some_and(|modal| modal.node.holds_declared())
}
fn replace_declared(&mut self, ctx: &mut Ctx) {
let declared = self
.outer_decoration
.as_deref_mut()
.and_then(|outer| outer.declared.take());
if let Some(declared) = declared {
let marker = std::mem::take(self);
let key = declared
.key
.clone()
.or_else(|| marker.outer_decoration.as_deref().and_then(|outer| outer.key.clone()));
let mut output = ctx
.mount_holding(|ctx| (declared.mount)(ctx, key.as_deref()))
.into_node();
output.adopt_outer_decoration(&marker);
*self = output;
return;
}
if self.component_slot_id.is_some() {
return;
}
for child in &mut self.children {
child.replace_declared(ctx);
}
if let Some(overlay) = self.overlay_declaration.as_deref_mut() {
overlay.node.replace_declared(ctx);
}
if let Some(modal) = self.modal_declaration.as_deref_mut() {
modal.node.replace_declared(ctx);
}
}
pub(crate) fn record_outer_id(&mut self, id: &Arc<str>) {
if let Some(outer) = self.outer_decoration_mut() {
outer.id = Some(id.clone());
}
}
pub(crate) fn record_outer_key(&mut self, key: &Arc<str>) {
if let Some(outer) = self.outer_decoration_mut() {
outer.key = Some(key.clone());
}
}
pub(crate) fn record_outer_class(&mut self, class: &Arc<str>) {
if let Some(outer) = self.outer_decoration_mut()
&& !outer.classes.contains(class)
{
outer.classes.push(class.clone());
}
}
pub(crate) fn record_outer_theme(&mut self, theme: &crate::app::theme::Theme) {
if let Some(outer) = self.outer_decoration_mut() {
outer.theme = Some(theme.clone());
}
}
pub(crate) fn record_outer_decoration(&mut self, decorate: &NodeDecoration) {
if let Some(outer) = self.outer_decoration_mut() {
outer.decorations.push(decorate.clone());
}
}
pub(crate) fn same_plain_outer_decoration(&self, other: &Node) -> bool {
type Plain<'a> = (Option<&'a Arc<str>>, Option<&'a Arc<str>>, &'a [Arc<str>]);
fn plain(node: &Node) -> Option<Plain<'_>> {
match node.outer_decoration.as_deref() {
None => Some((None, None, &[])),
Some(outer) if outer.decorations.is_empty() && outer.declared.is_none() && outer.theme.is_none() => {
Some((outer.id.as_ref(), outer.key.as_ref(), outer.classes.as_slice()))
}
Some(_) => None,
}
}
matches!((plain(self), plain(other)), (Some(this), Some(that)) if this == that)
}
pub(crate) fn adopt_outer_decoration(&mut self, replaced: &Node) {
let Some(outer) = replaced.outer_decoration.as_deref() else {
return;
};
if let Some(id) = &outer.id {
self.element_id = Some(id.clone());
}
if let Some(key) = &outer.key {
self.component_key = Some(key.clone());
}
for class in &outer.classes {
self.push_class(class.clone());
}
for decorate in &outer.decorations {
*self = decorate(std::mem::take(self));
}
if let Some(theme) = &outer.theme {
self.theme_scope = Some(Box::new(theme.clone()));
}
self.outer_decoration = Some(Box::new(outer.clone()));
}
}