use std::time::{Duration, Instant}; use gpui::{AnyView, DismissEvent, Entity, FocusHandle, ManagedView, Subscription, Task};use ui::{animation::DefaultAnimations, prelude::*}; const DEFAULT_TOAST_DURATION: Duration = Duration::from_millis(2400);const MINIMUM_RESUME_DURATION: Duration = Duration::from_millis(800); pub trait ToastView: ManagedView {} trait ToastViewHandle {    fn view(&self) -> AnyView;} impl<V: ToastView> ToastViewHandle for Entity<V> {    fn view(&self) -> AnyView {        self.clone().into()    }} pub struct ActiveToast {    toast: Box<dyn ToastViewHandle>,    _subscriptions: [Subscription; 1],    focus_handle: FocusHandle,} struct DismissTimer {    instant_started: Instant,    _task: Task<()>,} pub struct ToastLayer {    active_toast: Option<ActiveToast>,    duration_remaining: Option<Duration>,    dismiss_timer: Option<DismissTimer>,} impl Default for ToastLayer {    fn default() -> Self {        Self::new()    }} impl ToastLayer {    pub fn new() -> Self {        Self {            active_toast: None,            duration_remaining: None,            dismiss_timer: None,        }    }     pub fn toggle_toast<V>(        &mut self,        window: &mut Window,        cx: &mut Context<Self>,        new_toast: Entity<V>,    ) where        V: ToastView,    {        if let Some(active_toast) = &self.active_toast {            let is_close = active_toast.toast.view().downcast::<V>().is_ok();            let did_close = self.hide_toast(window, cx);            if is_close || !did_close {                return;            }        }        self.show_toast(new_toast, window, cx);    }     pub fn show_toast<V>(        &mut self,        new_toast: Entity<V>,        window: &mut Window,        cx: &mut Context<Self>,    ) where        V: ToastView,    {        let focus_handle = cx.focus_handle();         self.active_toast = Some(ActiveToast {            toast: Box::new(new_toast.clone()),            _subscriptions: [cx.subscribe_in(                &new_toast,                window,                |this, _, _: &DismissEvent, window, cx| {                    this.hide_toast(window, cx);                },            )],            focus_handle,        });         self.start_dismiss_timer(DEFAULT_TOAST_DURATION, window, cx);         cx.notify();    }     pub fn hide_toast(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> bool {        cx.notify();         true    }     pub fn active_toast<V>(&self) -> Option<Entity<V>>    where        V: 'static,    {        let active_toast = self.active_toast.as_ref()?;        active_toast.toast.view().downcast::<V>().ok()    }     pub fn has_active_toast(&self) -> bool {        self.active_toast.is_some()    }     fn pause_dismiss_timer(&mut self) {        let Some(dismiss_timer) = self.dismiss_timer.take() else {            return;        };        let Some(duration_remaining) = self.duration_remaining.as_mut() else {            return;        };        *duration_remaining =            duration_remaining.saturating_sub(dismiss_timer.instant_started.elapsed());        if *duration_remaining < MINIMUM_RESUME_DURATION {            *duration_remaining = MINIMUM_RESUME_DURATION;        }    }     /// Starts a timer to automatically dismiss the toast after the specified duration    pub fn start_dismiss_timer(        &mut self,        duration: Duration,        _window: &mut Window,        cx: &mut Context<Self>,    ) {        self.clear_dismiss_timer(cx);         let instant_started = std::time::Instant::now();        let task = cx.spawn(|this, mut cx| async move {            cx.background_executor().timer(duration).await;             if let Some(this) = this.upgrade() {                this.update(&mut cx, |this, cx| {                    this.active_toast.take();                    cx.notify();                })                .ok();            }        });         self.duration_remaining = Some(duration);        self.dismiss_timer = Some(DismissTimer {            instant_started,            _task: task,        });        cx.notify();    }     /// Restarts the dismiss timer with a new duration    pub fn restart_dismiss_timer(&mut self, window: &mut Window, cx: &mut Context<Self>) {        let Some(duration) = self.duration_remaining else {            return;        };        self.start_dismiss_timer(duration, window, cx);        cx.notify();    }     /// Clears the dismiss timer if one exists    pub fn clear_dismiss_timer(&mut self, cx: &mut Context<Self>) {        self.dismiss_timer.take();        cx.notify();    }} impl Render for ToastLayer {    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {        let Some(active_toast) = &self.active_toast else {            return div();        };        let handle = cx.weak_entity();         div().absolute().size_full().bottom_0().left_0().child(            v_flex()                .id("toast-layer-container")                .absolute()                .w_full()                .bottom(px(0.))                .flex()                .flex_col()                .items_center()                .track_focus(&active_toast.focus_handle)                .child(                    h_flex()                        .id("active-toast-container")                        .occlude()                        .on_hover(move |hover_start, window, cx| {                            let Some(this) = handle.upgrade() else {                                return;                            };                            if *hover_start {                                this.update(cx, |this, _| this.pause_dismiss_timer());                            } else {                                this.update(cx, |this, cx| this.restart_dismiss_timer(window, cx));                            }                            cx.stop_propagation();                        })                        .on_click(|_, _, cx| {                            cx.stop_propagation();                        })                        .child(active_toast.toast.view()),                )                .animate_in(AnimationDirection::FromBottom, true),        )    }}