use std::time::Instant; use anyhow::Result;use gpui::{    div, AppContext, InteractiveElement as _, Render, StatefulInteractiveElement as _,    Subscription, ViewContext, VisualContext,};use schemars::JsonSchema;use serde::{Deserialize, Serialize};use settings::{Settings, SettingsSources, SettingsStore};use workspace::{    ui::{Label, LabelCommon, LabelSize, Tooltip},    ItemHandle, StatusItemView, Workspace,}; const SHOW_STARTUP_TIME_DURATION: std::time::Duration = std::time::Duration::from_secs(5); pub fn init(cx: &mut AppContext) {    PerformanceSettings::register(cx);     let mut enabled = PerformanceSettings::get_global(cx)        .show_in_status_bar        .unwrap_or(false);    let start_time = Instant::now();    let mut _observe_workspaces = toggle_status_bar_items(enabled, start_time, cx);     cx.observe_global::<SettingsStore>(move |cx| {        let new_value = PerformanceSettings::get_global(cx)            .show_in_status_bar            .unwrap_or(false);        if new_value != enabled {            enabled = new_value;            _observe_workspaces = toggle_status_bar_items(enabled, start_time, cx);        }    })    .detach();} fn toggle_status_bar_items(    enabled: bool,    start_time: Instant,    cx: &mut AppContext,) -> Option<Subscription> {    for window in cx.windows() {        if let Some(workspace) = window.downcast::<Workspace>() {            workspace                .update(cx, |workspace, cx| {                    toggle_status_bar_item(workspace, enabled, start_time, cx);                })                .ok();        }    }     if enabled {        log::info!("performance metrics display enabled");        Some(cx.observe_new_views::<Workspace>(move |workspace, cx| {            toggle_status_bar_item(workspace, true, start_time, cx);        }))    } else {        log::info!("performance metrics display disabled");        None    }} struct PerformanceStatusBarItem {    display_mode: DisplayMode,} #[derive(Copy, Clone, Debug)]enum DisplayMode {    StartupTime,    Fps,} impl PerformanceStatusBarItem {    fn new(start_time: Instant, cx: &mut ViewContext<Self>) -> Self {        let now = Instant::now();        let display_mode = if now < start_time + SHOW_STARTUP_TIME_DURATION {            DisplayMode::StartupTime        } else {            DisplayMode::Fps        };         let this = Self { display_mode };         if let DisplayMode::StartupTime = display_mode {            cx.spawn(|this, mut cx| async move {                let now = Instant::now();                let remaining_duration =                    (start_time + SHOW_STARTUP_TIME_DURATION).saturating_duration_since(now);                cx.background_executor().timer(remaining_duration).await;                this.update(&mut cx, |this, cx| {                    this.display_mode = DisplayMode::Fps;                    cx.notify();                })                .ok();            })            .detach();        }         this    }} impl Render for PerformanceStatusBarItem {    fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> impl gpui::IntoElement {        let text = match self.display_mode {            DisplayMode::StartupTime => cx                .time_to_first_window_draw()                .map_or("Pending".to_string(), |duration| {                    format!("{}ms", duration.as_millis())                }),            DisplayMode::Fps => cx.fps().map_or("".to_string(), |fps| {                format!("{:3} FPS", fps.round() as u32)            }),        };         use gpui::ParentElement;        let display_mode = self.display_mode;        div()            .id("performance status")            .child(Label::new(text).size(LabelSize::Small))            .tooltip(move |cx| match display_mode {                DisplayMode::StartupTime => Tooltip::text("Time to first window draw", cx),                DisplayMode::Fps => cx                    .new_view(|cx| {                        let tooltip = Tooltip::new("Current FPS");                        if let Some(time_to_first) = cx.time_to_first_window_draw() {                            tooltip.meta(format!(                                "Time to first window draw: {}ms",                                time_to_first.as_millis()                            ))                        } else {                            tooltip                        }                    })                    .into(),            })    }} impl StatusItemView for PerformanceStatusBarItem {    fn set_active_pane_item(        &mut self,        _active_pane_item: Option<&dyn ItemHandle>,        _cx: &mut gpui::ViewContext<Self>,    ) {        // This is not currently used.    }} fn toggle_status_bar_item(    workspace: &mut Workspace,    enabled: bool,    start_time: Instant,    cx: &mut ViewContext<Workspace>,) {    if enabled {        workspace.status_bar().update(cx, |bar, cx| {            bar.add_right_item(                cx.new_view(|cx| PerformanceStatusBarItem::new(start_time, cx)),                cx,            )        });    } else {        workspace.status_bar().update(cx, |bar, cx| {            bar.remove_items_of_type::<PerformanceStatusBarItem>(cx);        });    }} /// Configuration of the display of performance details.#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]pub struct PerformanceSettings {    /// Display the time to first window draw and frame rate in the status bar.    ///    /// Default: false    pub show_in_status_bar: Option<bool>,} impl Settings for PerformanceSettings {    const KEY: Option<&'static str> = Some("performance");     type FileContent = Self;     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {        sources.json_merge()    }}