use gpui::{elements::SafeStylable, Action}; use crate::{Interactive, Toggleable}; use self::{action_button::ButtonStyle, disclosure::Disclosable, svg::SvgStyle, toggle::Toggle}; pub type IconButtonStyle = Interactive<ButtonStyle<SvgStyle>>;pub type ToggleIconButtonStyle = Toggleable<IconButtonStyle>; pub trait ComponentExt<C: SafeStylable> {    fn toggleable(self, active: bool) -> Toggle<C, ()>;    fn disclosable(self, disclosed: Option<bool>, action: Box<dyn Action>) -> Disclosable<C, ()>;} impl<C: SafeStylable> ComponentExt<C> for C {    fn toggleable(self, active: bool) -> Toggle<C, ()> {        Toggle::new(self, active)    }     /// Some(True) => disclosed => content is visible    /// Some(false) => closed => content is hidden    /// None => No disclosure button, but reserve disclosure spacing    fn disclosable(self, disclosed: Option<bool>, action: Box<dyn Action>) -> Disclosable<C, ()> {        Disclosable::new(disclosed, self, action)    }} pub mod disclosure {     use gpui::{        elements::{Component, ContainerStyle, Empty, Flex, ParentElement, SafeStylable},        Action, Element,    };    use schemars::JsonSchema;    use serde_derive::Deserialize;     use super::{action_button::Button, svg::Svg, IconButtonStyle};     #[derive(Clone, Default, Deserialize, JsonSchema)]    pub struct DisclosureStyle<S> {        pub button: IconButtonStyle,        #[serde(flatten)]        pub container: ContainerStyle,        pub spacing: f32,        #[serde(flatten)]        content: S,    }     impl<S> DisclosureStyle<S> {        pub fn button_space(&self) -> f32 {            self.spacing + self.button.button_width.unwrap()        }    }     pub struct Disclosable<C, S> {        disclosed: Option<bool>,        action: Box<dyn Action>,        id: usize,        content: C,        style: S,    }     impl Disclosable<(), ()> {        pub fn new<C>(            disclosed: Option<bool>,            content: C,            action: Box<dyn Action>,        ) -> Disclosable<C, ()> {            Disclosable {                disclosed,                content,                action,                id: 0,                style: (),            }        }    }     impl<C> Disclosable<C, ()> {        pub fn with_id(mut self, id: usize) -> Disclosable<C, ()> {            self.id = id;            self        }    }     impl<C: SafeStylable> SafeStylable for Disclosable<C, ()> {        type Style = DisclosureStyle<C::Style>;         type Output = Disclosable<C, Self::Style>;         fn with_style(self, style: Self::Style) -> Self::Output {            Disclosable {                disclosed: self.disclosed,                action: self.action,                content: self.content,                id: self.id,                style,            }        }    }     impl<C: SafeStylable> Component for Disclosable<C, DisclosureStyle<C::Style>> {        fn render<V: 'static>(self, cx: &mut gpui::ViewContext<V>) -> gpui::AnyElement<V> {            Flex::row()                .with_spacing(self.style.spacing)                .with_child(if let Some(disclosed) = self.disclosed {                    Button::dynamic_action(self.action)                        .with_id(self.id)                        .with_contents(Svg::new(if disclosed {                            "icons/file_icons/chevron_down.svg"                        } else {                            "icons/file_icons/chevron_right.svg"                        }))                        .with_style(self.style.button)                        .element()                        .into_any()                } else {                    Empty::new()                        .into_any()                        .constrained()                        // TODO: Why is this optional at all?                        .with_width(self.style.button.button_width.unwrap())                        .into_any()                })                .with_child(                    self.content                        .with_style(self.style.content)                        .render(cx)                        .flex(1., true),                )                .align_children_center()                .contained()                .with_style(self.style.container)                .into_any()        }    }} pub mod toggle {    use gpui::elements::{Component, SafeStylable};     use crate::Toggleable;     pub struct Toggle<C, S> {        style: S,        active: bool,        component: C,    }     impl<C: SafeStylable> Toggle<C, ()> {        pub fn new(component: C, active: bool) -> Self {            Toggle {                active,                component,                style: (),            }        }    }     impl<C: SafeStylable> SafeStylable for Toggle<C, ()> {        type Style = Toggleable<C::Style>;         type Output = Toggle<C, Self::Style>;         fn with_style(self, style: Self::Style) -> Self::Output {            Toggle {                active: self.active,                component: self.component,                style,            }        }    }     impl<C: SafeStylable> Component for Toggle<C, Toggleable<C::Style>> {        fn render<V: 'static>(self, cx: &mut gpui::ViewContext<V>) -> gpui::AnyElement<V> {            self.component                .with_style(self.style.in_state(self.active).clone())                .render(cx)        }    }} pub mod action_button {    use std::borrow::Cow;     use gpui::{        elements::{Component, ContainerStyle, MouseEventHandler, SafeStylable, TooltipStyle},        platform::{CursorStyle, MouseButton},        Action, Element, TypeTag,    };    use schemars::JsonSchema;    use serde_derive::Deserialize;     use crate::Interactive;     #[derive(Clone, Deserialize, Default, JsonSchema)]    pub struct ButtonStyle<C> {        #[serde(flatten)]        pub container: ContainerStyle,        // TODO: These are incorrect for the intended usage of the buttons.        // The size should be constant, but putting them here duplicates them        // across the states the buttons can be in        pub button_width: Option<f32>,        pub button_height: Option<f32>,        #[serde(flatten)]        contents: C,    }     pub struct Button<C, S> {        action: Box<dyn Action>,        tooltip: Option<(Cow<'static, str>, TooltipStyle)>,        tag: TypeTag,        id: usize,        contents: C,        style: Interactive<S>,    }     impl Button<(), ()> {        pub fn dynamic_action(action: Box<dyn Action>) -> Button<(), ()> {            Self {                contents: (),                tag: action.type_tag(),                action,                style: Interactive::new_blank(),                tooltip: None,                id: 0,            }        }         pub fn action<A: Action + Clone>(action: A) -> Self {            Self::dynamic_action(Box::new(action))        }         pub fn with_tooltip(            mut self,            tooltip: impl Into<Cow<'static, str>>,            tooltip_style: TooltipStyle,        ) -> Self {            self.tooltip = Some((tooltip.into(), tooltip_style));            self        }         pub fn with_id(mut self, id: usize) -> Self {            self.id = id;            self        }         pub fn with_contents<C: SafeStylable>(self, contents: C) -> Button<C, ()> {            Button {                action: self.action,                tag: self.tag,                style: self.style,                tooltip: self.tooltip,                id: self.id,                contents,            }        }    }     impl<C: SafeStylable> SafeStylable for Button<C, ()> {        type Style = Interactive<ButtonStyle<C::Style>>;        type Output = Button<C, ButtonStyle<C::Style>>;         fn with_style(self, style: Self::Style) -> Self::Output {            Button {                action: self.action,                tag: self.tag,                contents: self.contents,                tooltip: self.tooltip,                id: self.id,                style,            }        }    }     impl<C: SafeStylable> Component for Button<C, ButtonStyle<C::Style>> {        fn render<V: 'static>(self, cx: &mut gpui::ViewContext<V>) -> gpui::AnyElement<V> {            let mut button = MouseEventHandler::new_dynamic(self.tag, self.id, cx, |state, cx| {                let style = self.style.style_for(state);                let mut contents = self                    .contents                    .with_style(style.contents.to_owned())                    .render(cx)                    .contained()                    .with_style(style.container)                    .constrained();                 if let Some(height) = style.button_height {                    contents = contents.with_height(height);                }                 if let Some(width) = style.button_width {                    contents = contents.with_width(width);                }                 contents.into_any()            })            .on_click(MouseButton::Left, {                let action = self.action.boxed_clone();                move |_, _, cx| {                    let window = cx.window();                    let view = cx.view_id();                    let action = action.boxed_clone();                    cx.spawn(|_, mut cx| async move {                        window.dispatch_action(view, action.as_ref(), &mut cx)                    })                    .detach();                }            })            .with_cursor_style(CursorStyle::PointingHand)            .into_any();             if let Some((tooltip, style)) = self.tooltip {                button = button                    .with_dynamic_tooltip(self.tag, 0, tooltip, Some(self.action), style, cx)                    .into_any()            }             button        }    }} pub mod svg {    use std::borrow::Cow;     use gpui::{        elements::{Component, Empty, SafeStylable},        Element,    };    use schemars::JsonSchema;    use serde::Deserialize;     #[derive(Clone, Default, JsonSchema)]    pub struct SvgStyle {        icon_width: f32,        icon_height: f32,        color: gpui::color::Color,    }     impl<'de> Deserialize<'de> for SvgStyle {        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>        where            D: serde::Deserializer<'de>,        {            #[derive(Deserialize)]            #[serde(untagged)]            pub enum IconSize {                IconSize { icon_size: f32 },                Dimensions { width: f32, height: f32 },                IconDimensions { icon_width: f32, icon_height: f32 },            }             #[derive(Deserialize)]            struct SvgStyleHelper {                #[serde(flatten)]                size: IconSize,                color: gpui::color::Color,            }             let json = SvgStyleHelper::deserialize(deserializer)?;            let color = json.color;             let result = match json.size {                IconSize::IconSize { icon_size } => SvgStyle {                    icon_width: icon_size,                    icon_height: icon_size,                    color,                },                IconSize::Dimensions { width, height } => SvgStyle {                    icon_width: width,                    icon_height: height,                    color,                },                IconSize::IconDimensions {                    icon_width,                    icon_height,                } => SvgStyle {                    icon_width,                    icon_height,                    color,                },            };             Ok(result)        }    }     pub struct Svg<S> {        path: Option<Cow<'static, str>>,        style: S,    }     impl Svg<()> {        pub fn new(path: impl Into<Cow<'static, str>>) -> Self {            Self {                path: Some(path.into()),                style: (),            }        }         pub fn optional(path: Option<impl Into<Cow<'static, str>>>) -> Self {            Self {                path: path.map(Into::into),                style: (),            }        }    }     impl SafeStylable for Svg<()> {        type Style = SvgStyle;         type Output = Svg<SvgStyle>;         fn with_style(self, style: Self::Style) -> Self::Output {            Svg {                path: self.path,                style,            }        }    }     impl Component for Svg<SvgStyle> {        fn render<V: 'static>(self, _: &mut gpui::ViewContext<V>) -> gpui::AnyElement<V> {            if let Some(path) = self.path {                gpui::elements::Svg::new(path)                    .with_color(self.style.color)                    .constrained()            } else {                Empty::new().constrained()            }            .constrained()            .with_width(self.style.icon_width)            .with_height(self.style.icon_height)            .into_any()        }    }} pub mod label {    use std::borrow::Cow;     use gpui::{        elements::{Component, LabelStyle, SafeStylable},        fonts::TextStyle,        Element,    };     pub struct Label<S> {        text: Cow<'static, str>,        style: S,    }     impl Label<()> {        pub fn new(text: impl Into<Cow<'static, str>>) -> Self {            Self {                text: text.into(),                style: (),            }        }    }     impl SafeStylable for Label<()> {        type Style = TextStyle;         type Output = Label<LabelStyle>;         fn with_style(self, style: Self::Style) -> Self::Output {            Label {                text: self.text,                style: style.into(),            }        }    }     impl Component for Label<LabelStyle> {        fn render<V: 'static>(self, _: &mut gpui::ViewContext<V>) -> gpui::AnyElement<V> {            gpui::elements::Label::new(self.text, self.style).into_any()        }    }}