use std::sync::atomic::{AtomicU64, Ordering};
use super::Tree;
use crate::{
app::window::WindowWaker,
core::IdGenerator,
images::{ImageKey, ImageLoadState, ImageSizeCap, decoded_images},
layout::{Size, layout_kind::LayoutKind},
node::{node::Node, node_kind::NodeKind},
};
static LOADING_IMAGES_BUILT: AtomicU64 = AtomicU64::new(0);
pub(crate) fn note_loading_image_built() {
LOADING_IMAGES_BUILT.fetch_add(1, Ordering::AcqRel);
}
impl Tree {
pub(super) fn resolve_loading_images(&mut self) -> bool {
let built = LOADING_IMAGES_BUILT.load(Ordering::Acquire);
if self.pending_images.is_empty() && self.loading_images_built_seen == built {
return false;
}
self.loading_images_built_seen = built;
let Some(root) = &mut self.root else {
return false;
};
let wake = self
.loading_image_waker
.get_or_insert_with(|| self.window.loop_waker())
.clone();
let mut pending = Vec::new();
let changed = resolve_recursive(root, &wake, &mut pending, &self.id_gen);
self.pending_images = pending;
if changed {
self.needs_redraw = true;
}
changed
}
pub(super) fn notice_decoded_images(&mut self) {
if self.pending_images.is_empty() {
return;
}
let cache = decoded_images();
let ended = self
.pending_images
.iter()
.any(|(key, cap)| !cache.state(*key, *cap).is_some_and(|state| state.is_loading()));
if ended {
self.needs_redraw = true;
}
}
}
fn resolve_recursive(
node: &mut Node,
wake: &WindowWaker,
pending: &mut Vec<(ImageKey, Option<ImageSizeCap>)>,
id_gen: &IdGenerator,
) -> bool {
#[cfg(test)]
crate::core::layout_dirty::visit();
if !node.prepare_layout_tracking().loading_images {
return false;
}
let mut layout_dirty = false;
if let NodeKind::LoadingImage { request } = &mut node.node_kind {
let state = decoded_images().load(request.key, request.cap, || request.source.clone(), Some(wake.clone()));
match state {
ImageLoadState::Loading => {
if request.failed {
request.failed = false;
node.children = request
.placeholder_view
.as_ref()
.map(|view| view().into_node())
.into_iter()
.collect();
for child in &mut node.children {
child.assign_ids(id_gen);
}
layout_dirty = true;
}
pending.push((request.key, request.cap));
}
ImageLoadState::Ready(data) => {
let fit = request.fit;
node.intrinsic_size = Some(Size::new(data.width() as f32, data.height() as f32));
node.layout_kind = LayoutKind::Leaf;
node.children.clear();
node.node_kind = NodeKind::Image { data, fit };
layout_dirty = true;
}
ImageLoadState::Failed(error) => {
if !request.failed {
request.failed = true;
node.children = request
.error_view
.as_ref()
.map(|view| view(&error).into_node())
.into_iter()
.collect();
for child in &mut node.children {
child.assign_ids(id_gen);
}
layout_dirty = true;
}
}
}
}
for child in &mut node.children {
if resolve_recursive(child, wake, pending, id_gen) {
layout_dirty = true;
}
}
if layout_dirty {
node.layout_cache.invalidate();
}
layout_dirty
}