1use crate::{
2 AnyElement, AnyEntity, AnyWeakEntity, App, Bounds, ContentMask, Context, Element, ElementId,
3 Entity, EntityId, GlobalElementId, IntoElement, LayoutId, PaintIndex, Pixels,
4 PrepaintStateIndex, Render, Style, StyleRefinement, TextStyle, WeakEntity,
5};
6use crate::{Empty, Window};
7use anyhow::Result;
8use collections::FxHashSet;
9use refineable::Refineable;
10use std::mem;
11use std::{any::TypeId, fmt, ops::Range};
12
13struct AnyViewState {
14 prepaint_range: Range<PrepaintStateIndex>,
15 paint_range: Range<PaintIndex>,
16 cache_key: ViewCacheKey,
17 accessed_entities: FxHashSet<EntityId>,
18}
19
20#[derive(Default)]
21struct ViewCacheKey {
22 bounds: Bounds<Pixels>,
23 content_mask: ContentMask<Pixels>,
24 text_style: TextStyle,
25}
26
27impl<V: Render> Element for Entity<V> {
28 type RequestLayoutState = AnyElement;
29 type PrepaintState = ();
30
31 fn id(&self) -> Option<ElementId> {
32 Some(ElementId::View(self.entity_id()))
33 }
34
35 fn request_layout(
36 &mut self,
37 _id: Option<&GlobalElementId>,
38 window: &mut Window,
39 cx: &mut App,
40 ) -> (LayoutId, Self::RequestLayoutState) {
41 let mut element = self.update(cx, |view, cx| view.render(window, cx).into_any_element());
42 let layout_id = element.request_layout(window, cx);
43 (layout_id, element)
44 }
45
46 fn prepaint(
47 &mut self,
48 _id: Option<&GlobalElementId>,
49 _: Bounds<Pixels>,
50 element: &mut Self::RequestLayoutState,
51 window: &mut Window,
52 cx: &mut App,
53 ) {
54 window.set_view_id(self.entity_id());
55 element.prepaint(window, cx);
56 }
57
58 fn paint(
59 &mut self,
60 _id: Option<&GlobalElementId>,
61 _: Bounds<Pixels>,
62 element: &mut Self::RequestLayoutState,
63 _: &mut Self::PrepaintState,
64 window: &mut Window,
65 cx: &mut App,
66 ) {
67 element.paint(window, cx);
68 }
69}
70
71/// A dynamically-typed handle to a view, which can be downcast to a [Entity] for a specific type.
72#[derive(Clone, Debug)]
73pub struct AnyView {
74 entity: AnyEntity,
75 render: fn(&AnyView, &mut Window, &mut App) -> AnyElement,
76 cached_style: Option<StyleRefinement>,
77}
78
79impl<V: Render> From<Entity<V>> for AnyView {
80 fn from(value: Entity<V>) -> Self {
81 AnyView {
82 entity: value.into_any(),
83 render: any_view::render::<V>,
84 cached_style: None,
85 }
86 }
87}
88
89impl AnyView {
90 /// Indicate that this view should be cached when using it as an element.
91 /// When using this method, the view's previous layout and paint will be recycled from the previous frame if [Context::notify] has not been called since it was rendered.
92 /// The one exception is when [Window::refresh] is called, in which case caching is ignored.
93 pub fn cached(mut self, style: StyleRefinement) -> Self {
94 self.cached_style = Some(style);
95 self
96 }
97
98 /// Convert this to a weak handle.
99 pub fn downgrade(&self) -> AnyWeakView {
100 AnyWeakView {
101 entity: self.entity.downgrade(),
102 render: self.render,
103 }
104 }
105
106 /// Convert this to a [Entity] of a specific type.
107 /// If this handle does not contain a view of the specified type, returns itself in an `Err` variant.
108 pub fn downcast<T: 'static>(self) -> Result<Entity<T>, Self> {
109 match self.entity.downcast() {
110 Ok(entity) => Ok(entity),
111 Err(entity) => Err(Self {
112 entity,
113 render: self.render,
114 cached_style: self.cached_style,
115 }),
116 }
117 }
118
119 /// Gets the [TypeId] of the underlying view.
120 pub fn entity_type(&self) -> TypeId {
121 self.entity.entity_type
122 }
123
124 /// Gets the entity id of this handle.
125 pub fn entity_id(&self) -> EntityId {
126 self.entity.entity_id()
127 }
128}
129
130impl PartialEq for AnyView {
131 fn eq(&self, other: &Self) -> bool {
132 self.entity == other.entity
133 }
134}
135
136impl Eq for AnyView {}
137
138impl Element for AnyView {
139 type RequestLayoutState = Option<AnyElement>;
140 type PrepaintState = Option<AnyElement>;
141
142 fn id(&self) -> Option<ElementId> {
143 Some(ElementId::View(self.entity_id()))
144 }
145
146 fn request_layout(
147 &mut self,
148 _id: Option<&GlobalElementId>,
149 window: &mut Window,
150 cx: &mut App,
151 ) -> (LayoutId, Self::RequestLayoutState) {
152 if let Some(style) = self.cached_style.as_ref() {
153 let mut root_style = Style::default();
154 root_style.refine(style);
155 let layout_id = window.request_layout(root_style, None, cx);
156 (layout_id, None)
157 } else {
158 window.with_rendered_view(self.entity_id(), |window| {
159 let mut element = (self.render)(self, window, cx);
160 let layout_id = element.request_layout(window, cx);
161 (layout_id, Some(element))
162 })
163 }
164 }
165
166 fn prepaint(
167 &mut self,
168 global_id: Option<&GlobalElementId>,
169 bounds: Bounds<Pixels>,
170 element: &mut Self::RequestLayoutState,
171 window: &mut Window,
172 cx: &mut App,
173 ) -> Option<AnyElement> {
174 window.set_view_id(self.entity_id());
175 if self.cached_style.is_some() {
176 window.with_element_state::<AnyViewState, _>(
177 global_id.unwrap(),
178 |element_state, window| {
179 let content_mask = window.content_mask();
180 let text_style = window.text_style();
181
182 if let Some(mut element_state) = element_state {
183 if element_state.cache_key.bounds == bounds
184 && element_state.cache_key.content_mask == content_mask
185 && element_state.cache_key.text_style == text_style
186 && !window.dirty_views.contains(&self.entity_id())
187 && !window.refreshing
188 {
189 let prepaint_start = window.prepaint_index();
190 window.reuse_prepaint(element_state.prepaint_range.clone());
191 cx.entities
192 .extend_accessed(&element_state.accessed_entities);
193 let prepaint_end = window.prepaint_index();
194 element_state.prepaint_range = prepaint_start..prepaint_end;
195
196 return (None, element_state);
197 }
198 }
199
200 let refreshing = mem::replace(&mut window.refreshing, true);
201 let prepaint_start = window.prepaint_index();
202 let (mut element, accessed_entities) =
203 window.with_rendered_view(self.entity_id(), |window| {
204 cx.detect_accessed_entities(|cx| {
205 let mut element = (self.render)(self, window, cx);
206 element.layout_as_root(bounds.size.into(), window, cx);
207 element.prepaint_at(bounds.origin, window, cx);
208 element
209 })
210 });
211
212 let prepaint_end = window.prepaint_index();
213 window.refreshing = refreshing;
214
215 (
216 Some(element),
217 AnyViewState {
218 accessed_entities,
219 prepaint_range: prepaint_start..prepaint_end,
220 paint_range: PaintIndex::default()..PaintIndex::default(),
221 cache_key: ViewCacheKey {
222 bounds,
223 content_mask,
224 text_style,
225 },
226 },
227 )
228 },
229 )
230 } else {
231 let mut element = element.take().unwrap();
232 window.with_rendered_view(self.entity_id(), |window| {
233 element.prepaint(window, cx);
234 });
235
236 Some(element)
237 }
238 }
239
240 fn paint(
241 &mut self,
242 global_id: Option<&GlobalElementId>,
243 _bounds: Bounds<Pixels>,
244 _: &mut Self::RequestLayoutState,
245 element: &mut Self::PrepaintState,
246 window: &mut Window,
247 cx: &mut App,
248 ) {
249 if self.cached_style.is_some() {
250 window.with_element_state::<AnyViewState, _>(
251 global_id.unwrap(),
252 |element_state, window| {
253 let mut element_state = element_state.unwrap();
254
255 let paint_start = window.paint_index();
256
257 if let Some(element) = element {
258 let refreshing = mem::replace(&mut window.refreshing, true);
259 window.with_rendered_view(self.entity_id(), |window| {
260 element.paint(window, cx);
261 });
262 window.refreshing = refreshing;
263 } else {
264 window.reuse_paint(element_state.paint_range.clone());
265 }
266
267 let paint_end = window.paint_index();
268 element_state.paint_range = paint_start..paint_end;
269
270 ((), element_state)
271 },
272 )
273 } else {
274 element.as_mut().unwrap().paint(window, cx);
275 }
276 }
277}
278
279impl<V: 'static + Render> IntoElement for Entity<V> {
280 type Element = Entity<V>;
281
282 fn into_element(self) -> Self::Element {
283 self
284 }
285}
286
287impl IntoElement for AnyView {
288 type Element = Self;
289
290 fn into_element(self) -> Self::Element {
291 self
292 }
293}
294
295/// A weak, dynamically-typed view handle that does not prevent the view from being released.
296pub struct AnyWeakView {
297 entity: AnyWeakEntity,
298 render: fn(&AnyView, &mut Window, &mut App) -> AnyElement,
299}
300
301impl AnyWeakView {
302 /// Convert to a strongly-typed handle if the referenced view has not yet been released.
303 pub fn upgrade(&self) -> Option<AnyView> {
304 let entity = self.entity.upgrade()?;
305 Some(AnyView {
306 entity,
307 render: self.render,
308 cached_style: None,
309 })
310 }
311}
312
313impl<V: 'static + Render> From<WeakEntity<V>> for AnyWeakView {
314 fn from(view: WeakEntity<V>) -> Self {
315 AnyWeakView {
316 entity: view.into(),
317 render: any_view::render::<V>,
318 }
319 }
320}
321
322impl PartialEq for AnyWeakView {
323 fn eq(&self, other: &Self) -> bool {
324 self.entity == other.entity
325 }
326}
327
328impl std::fmt::Debug for AnyWeakView {
329 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
330 f.debug_struct("AnyWeakView")
331 .field("entity_id", &self.entity.entity_id)
332 .finish_non_exhaustive()
333 }
334}
335
336mod any_view {
337 use crate::{AnyElement, AnyView, App, IntoElement, Render, Window};
338
339 pub(crate) fn render<V: 'static + Render>(
340 view: &AnyView,
341 window: &mut Window,
342 cx: &mut App,
343 ) -> AnyElement {
344 let view = view.clone().downcast::<V>().unwrap();
345 view.update(cx, |view, cx| view.render(window, cx).into_any_element())
346 }
347}
348
349/// A view that renders nothing
350pub struct EmptyView;
351
352impl Render for EmptyView {
353 fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
354 Empty
355 }
356}