use crate::persistence::model::DockData;use crate::{DraggedDock, Event, ModalLayer, Pane};use crate::{Workspace, status_bar::StatusItemView};use anyhow::Context as _;use client::proto;use gpui::{    Action, AnyView, App, Axis, Context, Corner, Entity, EntityId, EventEmitter, FocusHandle,    Focusable, IntoElement, KeyContext, MouseButton, MouseDownEvent, MouseUpEvent, ParentElement,    Render, SharedString, StyleRefinement, Styled, Subscription, WeakEntity, Window, deferred, div,    px,};use schemars::JsonSchema;use serde::{Deserialize, Serialize};use settings::SettingsStore;use std::sync::Arc;use ui::{ContextMenu, Divider, DividerColor, IconButton, Tooltip, h_flex};use ui::{prelude::*, right_click_menu}; pub(crate) const RESIZE_HANDLE_SIZE: Pixels = Pixels(6.); pub enum PanelEvent {    ZoomIn,    ZoomOut,    Activate,    Close,} pub use proto::PanelId; pub trait Panel: Focusable + EventEmitter<PanelEvent> + Render + Sized {    fn persistent_name() -> &'static str;    fn position(&self, window: &Window, cx: &App) -> DockPosition;    fn position_is_valid(&self, position: DockPosition) -> bool;    fn set_position(&mut self, position: DockPosition, window: &mut Window, cx: &mut Context<Self>);    fn size(&self, window: &Window, cx: &App) -> Pixels;    fn set_size(&mut self, size: Option<Pixels>, window: &mut Window, cx: &mut Context<Self>);    fn icon(&self, window: &Window, cx: &App) -> Option<ui::IconName>;    fn icon_tooltip(&self, window: &Window, cx: &App) -> Option<&'static str>;    fn toggle_action(&self) -> Box<dyn Action>;    fn icon_label(&self, _window: &Window, _: &App) -> Option<String> {        None    }    fn is_zoomed(&self, _window: &Window, _cx: &App) -> bool {        false    }    fn starts_open(&self, _window: &Window, _cx: &App) -> bool {        false    }    fn set_zoomed(&mut self, _zoomed: bool, _window: &mut Window, _cx: &mut Context<Self>) {}    fn set_active(&mut self, _active: bool, _window: &mut Window, _cx: &mut Context<Self>) {}    fn pane(&self) -> Option<Entity<Pane>> {        None    }    fn remote_id() -> Option<proto::PanelId> {        None    }    fn activation_priority(&self) -> u32;    fn enabled(&self, _cx: &App) -> bool {        true    }} pub trait PanelHandle: Send + Sync {    fn panel_id(&self) -> EntityId;    fn persistent_name(&self) -> &'static str;    fn position(&self, window: &Window, cx: &App) -> DockPosition;    fn position_is_valid(&self, position: DockPosition, cx: &App) -> bool;    fn set_position(&self, position: DockPosition, window: &mut Window, cx: &mut App);    fn is_zoomed(&self, window: &Window, cx: &App) -> bool;    fn set_zoomed(&self, zoomed: bool, window: &mut Window, cx: &mut App);    fn set_active(&self, active: bool, window: &mut Window, cx: &mut App);    fn remote_id(&self) -> Option<proto::PanelId>;    fn pane(&self, cx: &App) -> Option<Entity<Pane>>;    fn size(&self, window: &Window, cx: &App) -> Pixels;    fn set_size(&self, size: Option<Pixels>, window: &mut Window, cx: &mut App);    fn icon(&self, window: &Window, cx: &App) -> Option<ui::IconName>;    fn icon_tooltip(&self, window: &Window, cx: &App) -> Option<&'static str>;    fn toggle_action(&self, window: &Window, cx: &App) -> Box<dyn Action>;    fn icon_label(&self, window: &Window, cx: &App) -> Option<String>;    fn panel_focus_handle(&self, cx: &App) -> FocusHandle;    fn to_any(&self) -> AnyView;    fn activation_priority(&self, cx: &App) -> u32;    fn enabled(&self, cx: &App) -> bool;    fn move_to_next_position(&self, window: &mut Window, cx: &mut App) {        let current_position = self.position(window, cx);        let next_position = [            DockPosition::Left,            DockPosition::Bottom,            DockPosition::Right,        ]        .into_iter()        .filter(|position| self.position_is_valid(*position, cx))        .skip_while(|valid_position| *valid_position != current_position)        .nth(1)        .unwrap_or(DockPosition::Left);         self.set_position(next_position, window, cx);    }} impl<T> PanelHandle for Entity<T>where    T: Panel,{    fn panel_id(&self) -> EntityId {        Entity::entity_id(self)    }     fn persistent_name(&self) -> &'static str {        T::persistent_name()    }     fn position(&self, window: &Window, cx: &App) -> DockPosition {        self.read(cx).position(window, cx)    }     fn position_is_valid(&self, position: DockPosition, cx: &App) -> bool {        self.read(cx).position_is_valid(position)    }     fn set_position(&self, position: DockPosition, window: &mut Window, cx: &mut App) {        self.update(cx, |this, cx| this.set_position(position, window, cx))    }     fn is_zoomed(&self, window: &Window, cx: &App) -> bool {        self.read(cx).is_zoomed(window, cx)    }     fn set_zoomed(&self, zoomed: bool, window: &mut Window, cx: &mut App) {        self.update(cx, |this, cx| this.set_zoomed(zoomed, window, cx))    }     fn set_active(&self, active: bool, window: &mut Window, cx: &mut App) {        self.update(cx, |this, cx| this.set_active(active, window, cx))    }     fn pane(&self, cx: &App) -> Option<Entity<Pane>> {        self.read(cx).pane()    }     fn remote_id(&self) -> Option<PanelId> {        T::remote_id()    }     fn size(&self, window: &Window, cx: &App) -> Pixels {        self.read(cx).size(window, cx)    }     fn set_size(&self, size: Option<Pixels>, window: &mut Window, cx: &mut App) {        self.update(cx, |this, cx| this.set_size(size, window, cx))    }     fn icon(&self, window: &Window, cx: &App) -> Option<ui::IconName> {        self.read(cx).icon(window, cx)    }     fn icon_tooltip(&self, window: &Window, cx: &App) -> Option<&'static str> {        self.read(cx).icon_tooltip(window, cx)    }     fn toggle_action(&self, _: &Window, cx: &App) -> Box<dyn Action> {        self.read(cx).toggle_action()    }     fn icon_label(&self, window: &Window, cx: &App) -> Option<String> {        self.read(cx).icon_label(window, cx)    }     fn to_any(&self) -> AnyView {        self.clone().into()    }     fn panel_focus_handle(&self, cx: &App) -> FocusHandle {        self.read(cx).focus_handle(cx).clone()    }     fn activation_priority(&self, cx: &App) -> u32 {        self.read(cx).activation_priority()    }     fn enabled(&self, cx: &App) -> bool {        self.read(cx).enabled(cx)    }} impl From<&dyn PanelHandle> for AnyView {    fn from(val: &dyn PanelHandle) -> Self {        val.to_any()    }} /// A container with a fixed [`DockPosition`] adjacent to a certain widown edge./// Can contain multiple panels and show/hide itself with all contents.pub struct Dock {    position: DockPosition,    panel_entries: Vec<PanelEntry>,    workspace: WeakEntity<Workspace>,    is_open: bool,    active_panel_index: Option<usize>,    focus_handle: FocusHandle,    pub(crate) serialized_dock: Option<DockData>,    zoom_layer_open: bool,    modal_layer: Entity<ModalLayer>,    _subscriptions: [Subscription; 2],} impl Focusable for Dock {    fn focus_handle(&self, _: &App) -> FocusHandle {        self.focus_handle.clone()    }} #[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]#[serde(rename_all = "lowercase")]pub enum DockPosition {    Left,    Bottom,    Right,} impl DockPosition {    fn label(&self) -> &'static str {        match self {            Self::Left => "left",            Self::Bottom => "bottom",            Self::Right => "right",        }    }     pub fn axis(&self) -> Axis {        match self {            Self::Left | Self::Right => Axis::Horizontal,            Self::Bottom => Axis::Vertical,        }    }} struct PanelEntry {    panel: Arc<dyn PanelHandle>,    _subscriptions: [Subscription; 3],} pub struct PanelButtons {    dock: Entity<Dock>,} impl Dock {    pub fn new(        position: DockPosition,        modal_layer: Entity<ModalLayer>,        window: &mut Window,        cx: &mut Context<Workspace>,    ) -> Entity<Self> {        let focus_handle = cx.focus_handle();        let workspace = cx.entity().clone();        let dock = cx.new(|cx| {            let focus_subscription =                cx.on_focus(&focus_handle, window, |dock: &mut Dock, window, cx| {                    if let Some(active_entry) = dock.active_panel_entry() {                        active_entry.panel.panel_focus_handle(cx).focus(window)                    }                });            let zoom_subscription = cx.subscribe(&workspace, |dock, workspace, e: &Event, cx| {                if matches!(e, Event::ZoomChanged) {                    let is_zoomed = workspace.read(cx).zoomed.is_some();                    dock.zoom_layer_open = is_zoomed;                }            });            Self {                position,                workspace: workspace.downgrade(),                panel_entries: Default::default(),                active_panel_index: None,                is_open: false,                focus_handle: focus_handle.clone(),                _subscriptions: [focus_subscription, zoom_subscription],                serialized_dock: None,                zoom_layer_open: false,                modal_layer,            }        });         cx.on_focus_in(&focus_handle, window, {            let dock = dock.downgrade();            move |workspace, window, cx| {                let Some(dock) = dock.upgrade() else {                    return;                };                let Some(panel) = dock.read(cx).active_panel() else {                    return;                };                if panel.is_zoomed(window, cx) {                    workspace.zoomed = Some(panel.to_any().downgrade());                    workspace.zoomed_position = Some(position);                } else {                    workspace.zoomed = None;                    workspace.zoomed_position = None;                }                cx.emit(Event::ZoomChanged);                workspace.dismiss_zoomed_items_to_reveal(Some(position), window, cx);                workspace.update_active_view_for_followers(window, cx)            }        })        .detach();         cx.observe_in(&dock, window, move |workspace, dock, window, cx| {            if dock.read(cx).is_open() {                if let Some(panel) = dock.read(cx).active_panel() {                    if panel.is_zoomed(window, cx) {                        workspace.zoomed = Some(panel.to_any().downgrade());                        workspace.zoomed_position = Some(position);                        cx.emit(Event::ZoomChanged);                        return;                    }                }            }            if workspace.zoomed_position == Some(position) {                workspace.zoomed = None;                workspace.zoomed_position = None;                cx.emit(Event::ZoomChanged);            }        })        .detach();         dock    }     pub fn position(&self) -> DockPosition {        self.position    }     pub fn is_open(&self) -> bool {        self.is_open    }     fn resizable(&self, cx: &App) -> bool {        !(self.zoom_layer_open || self.modal_layer.read(cx).has_active_modal())    }     pub fn panel<T: Panel>(&self) -> Option<Entity<T>> {        self.panel_entries            .iter()            .find_map(|entry| entry.panel.to_any().clone().downcast().ok())    }     pub fn panel_index_for_type<T: Panel>(&self) -> Option<usize> {        self.panel_entries            .iter()            .position(|entry| entry.panel.to_any().downcast::<T>().is_ok())    }     pub fn panel_index_for_persistent_name(&self, ui_name: &str, _cx: &App) -> Option<usize> {        self.panel_entries            .iter()            .position(|entry| entry.panel.persistent_name() == ui_name)    }     pub fn panel_index_for_proto_id(&self, panel_id: PanelId) -> Option<usize> {        self.panel_entries            .iter()            .position(|entry| entry.panel.remote_id() == Some(panel_id))    }     pub fn first_enabled_panel_idx(&mut self, cx: &mut Context<Self>) -> anyhow::Result<usize> {        self.panel_entries            .iter()            .position(|entry| entry.panel.enabled(cx))            .with_context(|| {                format!(                    "Couldn't find any enabled panel for the {} dock.",                    self.position.label()                )            })    }     fn active_panel_entry(&self) -> Option<&PanelEntry> {        self.active_panel_index            .and_then(|index| self.panel_entries.get(index))    }     pub fn active_panel_index(&self) -> Option<usize> {        self.active_panel_index    }     pub fn set_open(&mut self, open: bool, window: &mut Window, cx: &mut Context<Self>) {        if open != self.is_open {            self.is_open = open;            if let Some(active_panel) = self.active_panel_entry() {                active_panel.panel.set_active(open, window, cx);            }             cx.notify();        }    }     pub fn set_panel_zoomed(        &mut self,        panel: &AnyView,        zoomed: bool,        window: &mut Window,        cx: &mut Context<Self>,    ) {        for entry in &mut self.panel_entries {            if entry.panel.panel_id() == panel.entity_id() {                if zoomed != entry.panel.is_zoomed(window, cx) {                    entry.panel.set_zoomed(zoomed, window, cx);                }            } else if entry.panel.is_zoomed(window, cx) {                entry.panel.set_zoomed(false, window, cx);            }        }         self.workspace            .update(cx, |workspace, cx| {                workspace.serialize_workspace(window, cx);            })            .ok();        cx.notify();    }     pub fn zoom_out(&mut self, window: &mut Window, cx: &mut Context<Self>) {        for entry in &mut self.panel_entries {            if entry.panel.is_zoomed(window, cx) {                entry.panel.set_zoomed(false, window, cx);            }        }    }     pub(crate) fn add_panel<T: Panel>(        &mut self,        panel: Entity<T>,        workspace: WeakEntity<Workspace>,        window: &mut Window,        cx: &mut Context<Self>,    ) -> usize {        let subscriptions = [            cx.observe(&panel, |_, _, cx| cx.notify()),            cx.observe_global_in::<SettingsStore>(window, {                let workspace = workspace.clone();                let panel = panel.clone();                 move |this, window, cx| {                    let new_position = panel.read(cx).position(window, cx);                    if new_position == this.position {                        return;                    }                     let Ok(new_dock) = workspace.update(cx, |workspace, cx| {                        if panel.is_zoomed(window, cx) {                            workspace.zoomed_position = Some(new_position);                        }                        match new_position {                            DockPosition::Left => &workspace.left_dock,                            DockPosition::Bottom => &workspace.bottom_dock,                            DockPosition::Right => &workspace.right_dock,                        }                        .clone()                    }) else {                        return;                    };                     let was_visible = this.is_open()                        && this.visible_panel().map_or(false, |active_panel| {                            active_panel.panel_id() == Entity::entity_id(&panel)                        });                     this.remove_panel(&panel, window, cx);                     new_dock.update(cx, |new_dock, cx| {                        new_dock.remove_panel(&panel, window, cx);                        let index =                            new_dock.add_panel(panel.clone(), workspace.clone(), window, cx);                        if was_visible {                            new_dock.set_open(true, window, cx);                            new_dock.activate_panel(index, window, cx);                        }                    });                }            }),            cx.subscribe_in(                &panel,                window,                move |this, panel, event, window, cx| match event {                    PanelEvent::ZoomIn => {                        this.set_panel_zoomed(&panel.to_any(), true, window, cx);                        if !PanelHandle::panel_focus_handle(panel, cx).contains_focused(window, cx)                        {                            window.focus(&panel.focus_handle(cx));                        }                        workspace                            .update(cx, |workspace, cx| {                                workspace.zoomed = Some(panel.downgrade().into());                                workspace.zoomed_position =                                    Some(panel.read(cx).position(window, cx));                                cx.emit(Event::ZoomChanged);                            })                            .ok();                    }                    PanelEvent::ZoomOut => {                        this.set_panel_zoomed(&panel.to_any(), false, window, cx);

Lines 1–500 of 1025. Load more