use crate::{prelude::*, Checkbox, ListHeader}; use super::DropdownMenu; #[derive(PartialEq, Clone, Eq, Debug)]pub enum ToggleType {    Checkbox,    // Switch,} impl From<ToggleType> for SettingType {    fn from(toggle_type: ToggleType) -> Self {        SettingType::Toggle(toggle_type)    }} #[derive(Debug, Clone, PartialEq, Eq)]pub enum InputType {    Text,    Number,} impl From<InputType> for SettingType {    fn from(input_type: InputType) -> Self {        SettingType::Input(input_type)    }} #[derive(Debug, Clone, PartialEq, Eq)]pub enum SecondarySettingType {    Dropdown,} #[derive(Debug, Clone, PartialEq, Eq)]pub enum SettingType {    Toggle(ToggleType),    ToggleAnd(SecondarySettingType),    Input(InputType),    Dropdown,    Range,    Unsupported,} #[derive(Debug, Clone, IntoElement)]pub struct SettingsGroup {    pub name: String,    settings: Vec<SettingsItem>,} impl SettingsGroup {    pub fn new(name: impl Into<String>) -> Self {        Self {            name: name.into(),            settings: Vec::new(),        }    }     pub fn add_setting(mut self, setting: SettingsItem) -> Self {        self.settings.push(setting);        self    }} impl RenderOnce for SettingsGroup {    fn render(self, _cx: &mut WindowContext) -> impl IntoElement {        let empty_message = format!("No settings available for {}", self.name);         let header = ListHeader::new(self.name);         let settings = self.settings.clone().into_iter();         v_flex()            .p_1()            .gap_2()            .child(header)            .when(self.settings.len() == 0, |this| {                this.child(Label::new(empty_message))            })            .children(settings)    }} #[derive(Debug, Clone, PartialEq)]pub enum SettingLayout {    Stacked,    AutoWidth,    FullLine,    FullLineJustified,} #[derive(Debug, Clone, PartialEq)]pub struct SettingId(pub SharedString); impl From<SettingId> for ElementId {    fn from(id: SettingId) -> Self {        ElementId::Name(id.0)    }} impl From<&str> for SettingId {    fn from(id: &str) -> Self {        Self(id.to_string().into())    }} impl From<SharedString> for SettingId {    fn from(id: SharedString) -> Self {        Self(id)    }} #[derive(Debug, Clone, PartialEq)]pub struct SettingValue(pub SharedString); impl From<SharedString> for SettingValue {    fn from(value: SharedString) -> Self {        Self(value)    }} impl From<String> for SettingValue {    fn from(value: String) -> Self {        Self(value.into())    }} impl From<bool> for SettingValue {    fn from(value: bool) -> Self {        Self(value.to_string().into())    }} impl From<SettingValue> for bool {    fn from(value: SettingValue) -> Self {        value.0 == "true"    }} #[derive(Debug, Clone, IntoElement)]pub struct SettingsItem {    pub id: SettingId,    current_value: Option<SettingValue>,    disabled: bool,    hide_label: bool,    icon: Option<IconName>,    layout: SettingLayout,    name: SharedString,    // possible_values: Option<Vec<SettingValue>>,    setting_type: SettingType,    toggled: Option<bool>,} impl SettingsItem {    pub fn new(        id: impl Into<SettingId>,        name: SharedString,        setting_type: SettingType,        current_value: Option<SettingValue>,    ) -> Self {        let toggled = match setting_type {            SettingType::Toggle(_) | SettingType::ToggleAnd(_) => Some(false),            _ => None,        };         Self {            id: id.into(),            current_value,            disabled: false,            hide_label: false,            icon: None,            layout: SettingLayout::FullLine,            name,            // possible_values: None,            setting_type,            toggled,        }    }     pub fn layout(mut self, layout: SettingLayout) -> Self {        self.layout = layout;        self    }     pub fn toggled(mut self, toggled: bool) -> Self {        self.toggled = Some(toggled);        self    }     // pub fn hide_label(mut self, hide_label: bool) -> Self {    //     self.hide_label = hide_label;    //     self    // }     pub fn icon(mut self, icon: IconName) -> Self {        self.icon = Some(icon);        self    }     // pub fn disabled(mut self, disabled: bool) -> Self {    //     self.disabled = disabled;    //     self    // }} impl RenderOnce for SettingsItem {    fn render(self, cx: &mut WindowContext) -> impl IntoElement {        let id: ElementId = self.id.clone().into();         // When the setting is disabled or toggled off, we don't want any secondary elements to be interactable        let secondary_element_disabled = self.disabled || self.toggled == Some(false);         let full_width = match self.layout {            SettingLayout::FullLine | SettingLayout::FullLineJustified => true,            _ => false,        };         let hide_label = self.hide_label || self.icon.is_some();         let justified = match (self.layout.clone(), self.setting_type.clone()) {            (_, SettingType::ToggleAnd(_)) => true,            (SettingLayout::FullLineJustified, _) => true,            _ => false,        };         let (setting_type, current_value) = (self.setting_type.clone(), self.current_value.clone());        let current_string = if let Some(current_value) = current_value.clone() {            Some(current_value.0)        } else {            None        };         let toggleable = match setting_type {            SettingType::Toggle(_) => true,            SettingType::ToggleAnd(_) => true,            _ => false,        };         let setting_element = match setting_type {            SettingType::Toggle(_) => None,            SettingType::ToggleAnd(secondary_setting_type) => match secondary_setting_type {                SecondarySettingType::Dropdown => Some(                    DropdownMenu::new(id.clone(), &cx)                        .current_item(current_string)                        .disabled(secondary_element_disabled)                        .into_any_element(),                ),            },            SettingType::Input(input_type) => match input_type {                InputType::Text => Some(div().child("text").into_any_element()),                InputType::Number => Some(div().child("number").into_any_element()),            },            SettingType::Dropdown => Some(                DropdownMenu::new(id.clone(), &cx)                    .current_item(current_string)                    .full_width(true)                    .into_any_element(),            ),            SettingType::Range => Some(div().child("range").into_any_element()),            SettingType::Unsupported => None,        };         let checkbox = Checkbox::new(            ElementId::Name(format!("toggle-{}", self.id.0).to_string().into()),            self.toggled.into(),        )        .disabled(self.disabled);         let toggle_element = match (toggleable, self.setting_type.clone()) {            (true, SettingType::Toggle(toggle_type)) => match toggle_type {                ToggleType::Checkbox => Some(checkbox.into_any_element()),            },            (true, SettingType::ToggleAnd(_)) => Some(checkbox.into_any_element()),            (_, _) => None,        };         let item = if self.layout == SettingLayout::Stacked {            v_flex()        } else {            h_flex()        };         item.id(id)            .gap_2()            .w_full()            .when_some(self.icon, |this, icon| {                this.child(div().px_0p5().child(Icon::new(icon).color(Color::Muted)))            })            .children(toggle_element)            .children(if hide_label {                None            } else {                Some(Label::new(self.name.clone()))            })            .when(justified, |this| this.child(div().flex_1().size_full()))            .child(                h_flex()                    .when(full_width, |this| this.w_full())                    .when(self.layout == SettingLayout::FullLineJustified, |this| {                        this.justify_end()                    })                    .children(setting_element),            )            // help flex along when full width is disabled            //            // this probably isn't needed, but fighting with flex to            // get this right without inspection tools will be a pain            .when(!full_width, |this| this.child(div().size_full().flex_1()))    }} pub struct SettingsMenu {    name: SharedString,    groups: Vec<SettingsGroup>,} impl SettingsMenu {    pub fn new(name: impl Into<SharedString>) -> Self {        Self {            name: name.into(),            groups: Vec::new(),        }    }     pub fn add_group(mut self, group: SettingsGroup) -> Self {        self.groups.push(group);        self    }} impl Render for SettingsMenu {    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {        let is_empty = self.groups.is_empty();        v_flex()            .id(ElementId::Name(self.name.clone()))            .elevation_2(cx)            .min_w_56()            .max_w_96()            .max_h_2_3()            .px_2()            .when_else(                is_empty,                |empty| empty.py_1(),                |not_empty| not_empty.pt_0().pb_1(),            )            .gap_1()            .when(is_empty, |this| {                this.child(Label::new("No settings found").color(Color::Muted))            })            .children(self.groups.clone())    }}