325 lines
12 KiB
Rust
325 lines
12 KiB
Rust
//! Object-to-visual dependencies. Cached results never own VM references.
|
|
use crate::{
|
|
block::{self, Kind},
|
|
ui_bridge::{UiKind, UiNode},
|
|
};
|
|
use endor_core::{ChangeBatch, ChangeKey, ObjectRef, ObjectStore, Value, VmError};
|
|
use std::{
|
|
collections::{HashMap, HashSet, VecDeque},
|
|
sync::Arc,
|
|
};
|
|
|
|
#[derive(Debug)]
|
|
struct Cached {
|
|
node: Arc<UiNode>,
|
|
dependencies: Vec<Dependency>,
|
|
children: Vec<ObjectRef>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
struct Dependency {
|
|
object: ObjectRef,
|
|
property: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
pub struct RenderCache {
|
|
entries: HashMap<ObjectRef, Cached>,
|
|
dependents: HashMap<Dependency, HashSet<ObjectRef>>,
|
|
parents: HashMap<ObjectRef, HashSet<ObjectRef>>,
|
|
dirty: HashSet<ObjectRef>,
|
|
pub last_invalidation: String,
|
|
pub visited: usize,
|
|
pub reused: usize,
|
|
}
|
|
|
|
impl RenderCache {
|
|
pub fn invalidate(&mut self, batch: ChangeBatch) {
|
|
let mut queue = VecDeque::new();
|
|
if batch.rescan_required {
|
|
self.last_invalidation = "change journal overflow".into();
|
|
queue.extend(self.entries.keys().copied());
|
|
} else {
|
|
for change in batch.changes {
|
|
let key = Dependency {
|
|
object: change.object,
|
|
property: match change.key {
|
|
ChangeKey::Attribute(name) => Some(name),
|
|
ChangeKey::Contents => None,
|
|
},
|
|
};
|
|
if let Some(owners) = self.dependents.get(&key) {
|
|
self.last_invalidation = format!("{} {:?}", key.object, key.property);
|
|
queue.extend(owners);
|
|
}
|
|
}
|
|
}
|
|
self.invalidate_objects(queue);
|
|
}
|
|
|
|
pub fn invalidate_objects(&mut self, objects: impl IntoIterator<Item = ObjectRef>) {
|
|
let mut queue: VecDeque<_> = objects.into_iter().collect();
|
|
while let Some(block) = queue.pop_front() {
|
|
if self.dirty.insert(block)
|
|
&& let Some(parents) = self.parents.get(&block)
|
|
{
|
|
queue.extend(parents);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn remove(&mut self, block: ObjectRef) -> Option<Cached> {
|
|
let old = self.entries.remove(&block)?;
|
|
for source in &old.dependencies {
|
|
if let Some(owners) = self.dependents.get_mut(source) {
|
|
owners.remove(&block);
|
|
if owners.is_empty() {
|
|
self.dependents.remove(source);
|
|
}
|
|
}
|
|
}
|
|
for child in &old.children {
|
|
if let Some(parents) = self.parents.get_mut(child) {
|
|
parents.remove(&block);
|
|
if parents.is_empty() {
|
|
self.parents.remove(child);
|
|
}
|
|
}
|
|
}
|
|
Some(old)
|
|
}
|
|
|
|
pub fn prune(&mut self, store: &ObjectStore) {
|
|
let dead: Vec<_> = self
|
|
.entries
|
|
.keys()
|
|
.filter(|v| store.object(**v).is_err())
|
|
.copied()
|
|
.collect();
|
|
for block in dead {
|
|
self.remove(block);
|
|
self.dirty.remove(&block);
|
|
}
|
|
}
|
|
|
|
pub fn snapshot(
|
|
&mut self,
|
|
store: &ObjectStore,
|
|
root: ObjectRef,
|
|
) -> Result<Arc<UiNode>, VmError> {
|
|
self.visited = 0;
|
|
self.reused = 0;
|
|
let mut work = vec![(root, false)];
|
|
let mut path = HashSet::new();
|
|
let mut values = Vec::<Arc<UiNode>>::new();
|
|
while let Some((block, finish)) = work.pop() {
|
|
if !finish {
|
|
if !self.dirty.contains(&block)
|
|
&& let Some(cached) = self.entries.get(&block)
|
|
{
|
|
self.reused += 1;
|
|
values.push(cached.node.clone());
|
|
continue;
|
|
}
|
|
self.visited += 1;
|
|
if self.visited > 10_000 {
|
|
return Err(VmError::ExecutionLimit("expanded Block graph"));
|
|
}
|
|
}
|
|
store.check_typed_instance_storage(block)?;
|
|
let (data_ref, raw_data, raw_dependencies) = block::resolve_tracked(store, block)?;
|
|
let data = block::visual_data(store, raw_data)?;
|
|
let mut dependencies: Vec<_> = raw_dependencies
|
|
.into_iter()
|
|
.map(|object| Dependency {
|
|
object,
|
|
property: None,
|
|
})
|
|
.collect();
|
|
let storage = *store
|
|
.attribute_path(block)?
|
|
.last()
|
|
.expect("nonempty attribute path");
|
|
for name in store.typed_method_names(block)? {
|
|
dependencies.push(Dependency {
|
|
object: storage,
|
|
property: Some(name),
|
|
});
|
|
}
|
|
if let Some(properties) = data.properties {
|
|
for (name, _) in block::native_properties(&data) {
|
|
dependencies.push(Dependency {
|
|
object: properties,
|
|
property: Some(name.into()),
|
|
});
|
|
}
|
|
}
|
|
if !finish {
|
|
if !path.insert(data_ref) {
|
|
return Err(VmError::InvalidArgument("cyclic Block composition"));
|
|
}
|
|
work.push((block, true));
|
|
for child in data.children.iter().rev() {
|
|
work.push((child.block, false));
|
|
}
|
|
continue;
|
|
}
|
|
path.remove(&data_ref);
|
|
let mut protocol_key = String::new();
|
|
let mut custom_event = false;
|
|
if let Some(definition) = store.type_of(block)? {
|
|
protocol_key.push_str(&definition.to_string());
|
|
for name in ["measure", "arrange", "paint", "hitTest", "onEvent"] {
|
|
if let Some(method) = store.lookup_method(definition, name)? {
|
|
let version = store.change_version(method)?;
|
|
protocol_key.push_str(&format!("/{method}:{version}"));
|
|
dependencies.push(Dependency {
|
|
object: method,
|
|
property: None,
|
|
});
|
|
}
|
|
}
|
|
let event = store.lookup_method(definition, "onEvent")?;
|
|
let mut current = Some(definition);
|
|
while let Some(definition) = current {
|
|
dependencies.push(Dependency {
|
|
object: definition,
|
|
property: None,
|
|
});
|
|
let item = store.payload::<endor_core::EndorTypeObject>(definition, "Type")?;
|
|
current = item.base();
|
|
}
|
|
custom_event = event
|
|
.map(|function| {
|
|
crate::ui_bridge::is_intrinsic_event(store, function).map(|native| !native)
|
|
})
|
|
.transpose()?
|
|
.unwrap_or(false);
|
|
}
|
|
let mut click_connection = false;
|
|
for connection in &data.subscriptions {
|
|
dependencies.push(Dependency {
|
|
object: *connection,
|
|
property: None,
|
|
});
|
|
let item = store
|
|
.payload::<crate::event_dispatch::Connection>(*connection, "Connection")?;
|
|
click_connection |= item.kind == "click" && item.handler.is_some();
|
|
}
|
|
let children = values.split_off(values.len() - data.children.len());
|
|
let kind = match &data.kind {
|
|
Kind::Text { value, size, color } => {
|
|
let value = if let Some((source, field)) = &data.text_binding {
|
|
let storage = store.attribute_path(*source)?;
|
|
for (index, object) in storage.iter().enumerate() {
|
|
dependencies.push(Dependency {
|
|
object: *object,
|
|
property: (index + 1 == storage.len()).then(|| field.clone()),
|
|
});
|
|
}
|
|
match store.get_attr(*source, field)? {
|
|
Value::Nil => "nil".into(),
|
|
Value::Bool(v) => v.to_string(),
|
|
Value::Number(v) => v.to_string(),
|
|
Value::Text(v) => v,
|
|
Value::Object(v) => {
|
|
dependencies.push(Dependency {
|
|
object: v,
|
|
property: None,
|
|
});
|
|
store.str(v)?
|
|
}
|
|
}
|
|
} else {
|
|
value.clone()
|
|
};
|
|
UiKind::Text {
|
|
value,
|
|
size: *size,
|
|
color: color.clone(),
|
|
}
|
|
}
|
|
Kind::Rect {
|
|
width,
|
|
height,
|
|
radius,
|
|
color,
|
|
} => UiKind::Rect {
|
|
width: *width,
|
|
height: *height,
|
|
radius: *radius,
|
|
color: color.clone(),
|
|
},
|
|
Kind::Scroll { width, height } => UiKind::Scroll {
|
|
axis: data.scroll_axis,
|
|
width: *width,
|
|
height: *height,
|
|
padding: data.padding,
|
|
gap: data.gap,
|
|
children,
|
|
},
|
|
Kind::Spacer(size) => UiKind::Spacer(*size),
|
|
Kind::Row => UiKind::Row {
|
|
padding: data.padding,
|
|
gap: data.gap,
|
|
children,
|
|
},
|
|
Kind::Column | Kind::Page => UiKind::Column {
|
|
padding: data.padding,
|
|
gap: data.gap,
|
|
children,
|
|
},
|
|
Kind::Button => UiKind::Button {
|
|
padding: data.padding,
|
|
gap: data.gap,
|
|
children,
|
|
},
|
|
};
|
|
let next = UiNode {
|
|
flex: data.flex,
|
|
flex_policy: data.flex_policy,
|
|
main_align: data.main_align,
|
|
block_id: block.to_string(),
|
|
protocol_key,
|
|
slots: data.children.iter().map(|c| c.slot).collect(),
|
|
interactive: matches!(&data.kind, Kind::Button)
|
|
|| data.click.is_some()
|
|
|| click_connection
|
|
|| custom_event,
|
|
kind,
|
|
};
|
|
let old = self.remove(block);
|
|
let node = if let Some(old) = old.as_ref().filter(|old| old.node.shallow_eq(&next)) {
|
|
old.node.clone()
|
|
} else {
|
|
Arc::new(next)
|
|
};
|
|
dependencies.sort_unstable();
|
|
dependencies.dedup();
|
|
let child_refs: Vec<_> = data.children.iter().map(|child| child.block).collect();
|
|
for source in &dependencies {
|
|
self.dependents
|
|
.entry(source.clone())
|
|
.or_default()
|
|
.insert(block);
|
|
}
|
|
for child in &child_refs {
|
|
self.parents.entry(*child).or_default().insert(block);
|
|
}
|
|
self.entries.insert(
|
|
block,
|
|
Cached {
|
|
node: node.clone(),
|
|
dependencies,
|
|
children: child_refs,
|
|
},
|
|
);
|
|
self.dirty.remove(&block);
|
|
values.push(node);
|
|
}
|
|
values
|
|
.pop()
|
|
.ok_or(VmError::InvalidArgument("empty Block snapshot"))
|
|
}
|
|
}
|