use crate::{
AnyElement, AnyEntity, AnyWeakEntity, App, Bounds, ContentMask, Context, Element, ElementId,
Entity, EntityId, GlobalElementId, InspectorElementId, IntoElement, LayoutId, PaintIndex,
Pixels, PrepaintStateIndex, Render, Style, StyleRefinement, TextStyle, WeakEntity,
};
use crate::{Empty, Window};
use anyhow::Result;
use collections::FxHashSet;
use refineable::Refineable;
use std::mem;
use std::rc::Rc;
use std::{any::TypeId, fmt, ops::Range};
struct AnyViewState {
prepaint_range: Range<PrepaintStateIndex>,
paint_range: Range<PaintIndex>,
cache_key: ViewCacheKey,
accessed_entities: FxHashSet<EntityId>,
}
#[derive(Default)]
struct ViewCacheKey {
bounds: Bounds<Pixels>,
content_mask: ContentMask<Pixels>,
text_style: TextStyle,
}
impl<V: Render> Element for Entity<V> {
type RequestLayoutState = AnyElement;
type PrepaintState = ();
fn id(&self) -> Option<ElementId> {
Some(ElementId::View(self.entity_id()))
}
fn source_location(&self) -> Option<&'static std::panic::Location<'static>> {
None
}
fn request_layout(
&mut self,
_id: Option<&GlobalElementId>,
_inspector_id: Option<&InspectorElementId>,
window: &mut Window,
cx: &mut App,
) -> (LayoutId, Self::RequestLayoutState) {
#[cfg(feature = "profiler")]
let profile_start = window.window_profiler.begin_view();
let profile_result = {
let mut element =
self.update(cx, |view, cx| view.render(window, cx).into_any_element());
let layout_id = window.with_rendered_view(self.entity_id(), |window| {
element.request_layout(window, cx)
});
(layout_id, element)
};
#[cfg(feature = "profiler")]
window.window_profiler.end_view(
profile_start,
std::any::type_name::<V>(),
crate::profiler::ViewPhase::RequestLayout,
);
profile_result
}
fn prepaint(
&mut self,
_id: Option<&GlobalElementId>,
_inspector_id: Option<&InspectorElementId>,
_: Bounds<Pixels>,
element: &mut Self::RequestLayoutState,
window: &mut Window,
cx: &mut App,
) {
#[cfg(feature = "profiler")]
let profile_start = window.window_profiler.begin_view();
window.set_view_id(self.entity_id());
window.with_rendered_view(self.entity_id(), |window| element.prepaint(window, cx));
#[cfg(feature = "profiler")]
window.window_profiler.end_view(
profile_start,
std::any::type_name::<V>(),
crate::profiler::ViewPhase::Prepaint,
);
}
fn paint(
&mut self,
_id: Option<&GlobalElementId>,
_inspector_id: Option<&InspectorElementId>,
_: Bounds<Pixels>,
element: &mut Self::RequestLayoutState,
_: &mut Self::PrepaintState,
window: &mut Window,
cx: &mut App,
) {
#[cfg(feature = "profiler")]
let profile_start = window.window_profiler.begin_view();
window.with_rendered_view(self.entity_id(), |window| element.paint(window, cx));
#[cfg(feature = "profiler")]
window.window_profiler.end_view(
profile_start,
std::any::type_name::<V>(),
crate::profiler::ViewPhase::Paint,
);
}
}
#[derive(Clone, Debug)]
pub struct AnyView {
entity: AnyEntity,
render: fn(&AnyView, &mut Window, &mut App) -> AnyElement,
view_type_name: &'static str,
cached_style: Option<Rc<StyleRefinement>>,
}
impl<V: Render> Entity<V> {
pub fn cached(self, style: StyleRefinement) -> AnyView {
AnyView::from(self).cached(style)
}
}
impl<V: Render> From<Entity<V>> for AnyView {
fn from(value: Entity<V>) -> Self {
AnyView {
entity: value.into_any(),
render: any_view::render::<V>,
view_type_name: std::any::type_name::<V>(),
cached_style: None,
}
}
}
impl AnyView {
pub fn cached(mut self, style: StyleRefinement) -> Self {
self.cached_style = Some(style.into());
self
}
pub fn downgrade(&self) -> AnyWeakView {
AnyWeakView {
entity: self.entity.downgrade(),
render: self.render,
view_type_name: self.view_type_name,
}
}
pub fn downcast<T: 'static>(self) -> Result<Entity<T>, Self> {
match self.entity.downcast() {
Ok(entity) => Ok(entity),
Err(entity) => Err(Self {
entity,
render: self.render,
view_type_name: self.view_type_name,
cached_style: self.cached_style,
}),
}
}
pub fn entity_type(&self) -> TypeId {
self.entity.entity_type
}
pub fn entity_id(&self) -> EntityId {
self.entity.entity_id()
}
}
impl PartialEq for AnyView {
fn eq(&self, other: &Self) -> bool {
self.entity == other.entity
}
}
impl Eq for AnyView {}
impl Element for AnyView {
type RequestLayoutState = Option<AnyElement>;
type PrepaintState = Option<AnyElement>;
fn id(&self) -> Option<ElementId> {
Some(ElementId::View(self.entity_id()))
}
fn source_location(&self) -> Option<&'static core::panic::Location<'static>> {
None
}
fn request_layout(
&mut self,
_id: Option<&GlobalElementId>,
_inspector_id: Option<&InspectorElementId>,
window: &mut Window,
cx: &mut App,
) -> (LayoutId, Self::RequestLayoutState) {
#[cfg(feature = "profiler")]
let profile_start = window.window_profiler.begin_view();
let profile_result = {
window.with_rendered_view(self.entity_id(), |window| {
let caching_disabled = window.is_inspector_picking(cx) || window.is_a11y_active();
match self.cached_style.as_ref() {
Some(style) if !caching_disabled => {
let mut root_style = Style::default();
root_style.refine(style);
let layout_id = window.request_layout(root_style, None, cx);
(layout_id, None)
}
_ => {
let mut element = (self.render)(self, window, cx);
let layout_id = element.request_layout(window, cx);
(layout_id, Some(element))
}
}
})
};
#[cfg(feature = "profiler")]
window.window_profiler.end_view(
profile_start,
self.view_type_name,
crate::profiler::ViewPhase::RequestLayout,
);
profile_result
}
fn prepaint(
&mut self,
global_id: Option<&GlobalElementId>,
_inspector_id: Option<&InspectorElementId>,
bounds: Bounds<Pixels>,
element: &mut Self::RequestLayoutState,
window: &mut Window,
cx: &mut App,
) -> Option<AnyElement> {
#[cfg(feature = "profiler")]
let profile_start = window.window_profiler.begin_view();
let profile_result = {
window.set_view_id(self.entity_id());
window.with_rendered_view(self.entity_id(), |window| {
if let Some(mut element) = element.take() {
element.prepaint(window, cx);
return Some(element);
}
window.with_element_state::<AnyViewState, _>(
global_id.unwrap(),
|element_state, window| {
let content_mask = window.content_mask();
let text_style = window.text_style();
if let Some(mut element_state) = element_state
&& element_state.cache_key.bounds == bounds
&& element_state.cache_key.content_mask == content_mask
&& element_state.cache_key.text_style == text_style
&& !window.dirty_views.contains(&self.entity_id())
&& !window.refreshing
{
let prepaint_start = window.prepaint_index();
window.reuse_prepaint(element_state.prepaint_range.clone());
cx.entities
.extend_accessed(&element_state.accessed_entities);
let prepaint_end = window.prepaint_index();
element_state.prepaint_range = prepaint_start..prepaint_end;
return (None, element_state);
}
let refreshing = mem::replace(&mut window.refreshing, true);
let prepaint_start = window.prepaint_index();
let (mut element, accessed_entities) = cx.detect_accessed_entities(|cx| {
let mut element = (self.render)(self, window, cx);
element.layout_as_root(bounds.size.into(), window, cx);
element.prepaint_at(bounds.origin, window, cx);
element
});
let prepaint_end = window.prepaint_index();
window.refreshing = refreshing;
(
Some(element),
AnyViewState {
accessed_entities,
prepaint_range: prepaint_start..prepaint_end,
paint_range: PaintIndex::default()..PaintIndex::default(),
cache_key: ViewCacheKey {
bounds,
content_mask,
text_style,
},
},
)
},
)
})
};
#[cfg(feature = "profiler")]
window.window_profiler.end_view(
profile_start,
self.view_type_name,
crate::profiler::ViewPhase::Prepaint,
);
profile_result
}
fn paint(
&mut self,
global_id: Option<&GlobalElementId>,
_inspector_id: Option<&InspectorElementId>,
_bounds: Bounds<Pixels>,
_: &mut Self::RequestLayoutState,
element: &mut Self::PrepaintState,
window: &mut Window,
cx: &mut App,
) {
#[cfg(feature = "profiler")]
let profile_start = window.window_profiler.begin_view();
window.with_rendered_view(self.entity_id(), |window| {
let caching_disabled = window.is_inspector_picking(cx) || window.is_a11y_active();
if self.cached_style.is_some() && !caching_disabled {
window.with_element_state::<AnyViewState, _>(
global_id.unwrap(),
|element_state, window| {
let mut element_state = element_state.unwrap();
let paint_start = window.paint_index();
if let Some(element) = element {
let refreshing = mem::replace(&mut window.refreshing, true);
element.paint(window, cx);
window.refreshing = refreshing;
} else {
window.reuse_paint(element_state.paint_range.clone());
}
let paint_end = window.paint_index();
element_state.paint_range = paint_start..paint_end;
((), element_state)
},
)
} else {
element.as_mut().unwrap().paint(window, cx);
}
});
#[cfg(feature = "profiler")]
window.window_profiler.end_view(
profile_start,
self.view_type_name,
crate::profiler::ViewPhase::Paint,
);
}
}
impl<V: 'static + Render> IntoElement for Entity<V> {
type Element = Entity<V>;
fn into_element(self) -> Self::Element {
self
}
}
impl IntoElement for AnyView {
type Element = Self;
fn into_element(self) -> Self::Element {
self
}
}
pub struct AnyWeakView {
entity: AnyWeakEntity,
render: fn(&AnyView, &mut Window, &mut App) -> AnyElement,
view_type_name: &'static str,
}
impl AnyWeakView {
pub fn upgrade(&self) -> Option<AnyView> {
let entity = self.entity.upgrade()?;
Some(AnyView {
entity,
render: self.render,
view_type_name: self.view_type_name,
cached_style: None,
})
}
}
impl<V: 'static + Render> From<WeakEntity<V>> for AnyWeakView {
fn from(view: WeakEntity<V>) -> Self {
AnyWeakView {
entity: view.into(),
render: any_view::render::<V>,
view_type_name: std::any::type_name::<V>(),
}
}
}
impl PartialEq for AnyWeakView {
fn eq(&self, other: &Self) -> bool {
self.entity == other.entity
}
}
impl std::fmt::Debug for AnyWeakView {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("AnyWeakView")
.field("entity_id", &self.entity.entity_id)
.finish_non_exhaustive()
}
}
mod any_view {
use crate::{AnyElement, AnyView, App, IntoElement, Render, Window};
pub(crate) fn render<V: 'static + Render>(
view: &AnyView,
window: &mut Window,
cx: &mut App,
) -> AnyElement {
let view = view.clone().downcast::<V>().unwrap();
view.update(cx, |view, cx| view.render(window, cx).into_any_element())
}
}
pub struct EmptyView;
impl Render for EmptyView {
fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
Empty
}
}
#[cfg(test)]
mod cached_debug_bounds_tests {
use super::*;
use crate::{
AppContext as _, InteractiveElement, ParentElement, Styled, TestAppContext, div, px,
};
use std::cell::Cell;
struct CachedChild {
selector: &'static str,
renders: Rc<Cell<usize>>,
}
impl Render for CachedChild {
fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
self.renders.set(self.renders.get() + 1);
let selector = self.selector;
div().size_full().debug_selector(move || selector.into())
}
}
struct CachedRoot {
first: Entity<CachedChild>,
second: Entity<CachedChild>,
show_second: bool,
}
impl Render for CachedRoot {
fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
let mut content = div().size_full().flex().flex_col().child(
self.first
.clone()
.cached(StyleRefinement::default().size(px(40.))),
);
if self.show_second {
content = content.child(
self.second
.clone()
.cached(StyleRefinement::default().size(px(40.))),
);
}
content
}
}
#[wgpui::test]
fn cached_selectors_replay_only_while_their_subtree_is_present(cx: &mut TestAppContext) {
let first_renders = Rc::new(Cell::new(0));
let second_renders = Rc::new(Cell::new(0));
let (root, cx) = cx.add_window_view(|_, cx| CachedRoot {
first: cx.new(|_| CachedChild {
selector: "first-cached-child",
renders: first_renders.clone(),
}),
second: cx.new(|_| CachedChild {
selector: "second-cached-child",
renders: second_renders.clone(),
}),
show_second: true,
});
let first_bounds = cx
.debug_bounds("first-cached-child")
.expect("first painted selector");
let second_bounds = cx
.debug_bounds("second-cached-child")
.expect("second painted selector");
let rendered = (first_renders.get(), second_renders.get());
for _ in 0..3 {
cx.update(|window, cx| window.draw(cx).clear());
assert_eq!(cx.debug_bounds("first-cached-child"), Some(first_bounds));
assert_eq!(cx.debug_bounds("second-cached-child"), Some(second_bounds));
assert_eq!((first_renders.get(), second_renders.get()), rendered);
}
root.update(cx, |root, cx| {
root.show_second = false;
cx.notify();
});
cx.update(|window, cx| window.draw(cx).clear());
assert_eq!(cx.debug_bounds("first-cached-child"), Some(first_bounds));
assert_eq!(cx.debug_bounds("second-cached-child"), None);
assert_eq!((first_renders.get(), second_renders.get()), rendered);
}
}