use crate::{    AnyElement, AnyEntity, AnyWeakEntity, App, Bounds, ContentMask, Context, Element, ElementId,    Entity, EntityId, GlobalElementId, 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 request_layout(        &mut self,        _id: Option<&GlobalElementId>,        window: &mut Window,        cx: &mut App,    ) -> (LayoutId, Self::RequestLayoutState) {        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)    }     fn prepaint(        &mut self,        _id: Option<&GlobalElementId>,        _: Bounds<Pixels>,        element: &mut Self::RequestLayoutState,        window: &mut Window,        cx: &mut App,    ) {        window.set_view_id(self.entity_id());        window.with_rendered_view(self.entity_id(), |window| element.prepaint(window, cx));    }     fn paint(        &mut self,        _id: Option<&GlobalElementId>,        _: Bounds<Pixels>,        element: &mut Self::RequestLayoutState,        _: &mut Self::PrepaintState,        window: &mut Window,        cx: &mut App,    ) {        window.with_rendered_view(self.entity_id(), |window| element.paint(window, cx));    }} /// A dynamically-typed handle to a view, which can be downcast to a [Entity] for a specific type.#[derive(Clone, Debug)]pub struct AnyView {    entity: AnyEntity,    render: fn(&AnyView, &mut Window, &mut App) -> AnyElement,    cached_style: Option<Rc<StyleRefinement>>,} impl<V: Render> From<Entity<V>> for AnyView {    fn from(value: Entity<V>) -> Self {        AnyView {            entity: value.into_any(),            render: any_view::render::<V>,            cached_style: None,        }    }} impl AnyView {    /// Indicate that this view should be cached when using it as an element.    /// 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.    /// The one exception is when [Window::refresh] is called, in which case caching is ignored.    pub fn cached(mut self, style: StyleRefinement) -> Self {        self.cached_style = Some(style.into());        self    }     /// Convert this to a weak handle.    pub fn downgrade(&self) -> AnyWeakView {        AnyWeakView {            entity: self.entity.downgrade(),            render: self.render,        }    }     /// Convert this to a [Entity] of a specific type.    /// If this handle does not contain a view of the specified type, returns itself in an `Err` variant.    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,                cached_style: self.cached_style,            }),        }    }     /// Gets the [TypeId] of the underlying view.    pub fn entity_type(&self) -> TypeId {        self.entity.entity_type    }     /// Gets the entity id of this handle.    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 request_layout(        &mut self,        _id: Option<&GlobalElementId>,        window: &mut Window,        cx: &mut App,    ) -> (LayoutId, Self::RequestLayoutState) {        window.with_rendered_view(self.entity_id(), |window| {            if let Some(style) = self.cached_style.as_ref() {                let mut root_style = Style::default();                root_style.refine(style);                let layout_id = window.request_layout(root_style, None, cx);                (layout_id, None)            } else {                let mut element = (self.render)(self, window, cx);                let layout_id = element.request_layout(window, cx);                (layout_id, Some(element))            }        })    }     fn prepaint(        &mut self,        global_id: Option<&GlobalElementId>,        bounds: Bounds<Pixels>,        element: &mut Self::RequestLayoutState,        window: &mut Window,        cx: &mut App,    ) -> Option<AnyElement> {        window.set_view_id(self.entity_id());        window.with_rendered_view(self.entity_id(), |window| {            if self.cached_style.is_some() {                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 {                            if 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,                                },                            },                        )                    },                )            } else {                let mut element = element.take().unwrap();                element.prepaint(window, cx);                 Some(element)            }        })    }     fn paint(        &mut self,        global_id: Option<&GlobalElementId>,        _bounds: Bounds<Pixels>,        _: &mut Self::RequestLayoutState,        element: &mut Self::PrepaintState,        window: &mut Window,        cx: &mut App,    ) {        window.with_rendered_view(self.entity_id(), |window| {            if self.cached_style.is_some() {                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);            }        });    }} 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    }} /// A weak, dynamically-typed view handle that does not prevent the view from being released.pub struct AnyWeakView {    entity: AnyWeakEntity,    render: fn(&AnyView, &mut Window, &mut App) -> AnyElement,} impl AnyWeakView {    /// Convert to a strongly-typed handle if the referenced view has not yet been released.    pub fn upgrade(&self) -> Option<AnyView> {        let entity = self.entity.upgrade()?;        Some(AnyView {            entity,            render: self.render,            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>,        }    }} 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())    }} /// A view that renders nothingpub struct EmptyView; impl Render for EmptyView {    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {        Empty    }}