793 lines
23 KiB
Rust
793 lines
23 KiB
Rust
//! Togglers let users make binary choices by toggling a switch.
|
|
//!
|
|
//! # Example
|
|
//! ```no_run
|
|
//! # mod iced { pub mod widget { pub use iced_widget::*; } pub use iced_widget::Renderer; pub use iced_widget::core::*; }
|
|
//! # pub type Element<'a, Message> = iced_widget::core::Element<'a, Message, iced_widget::Theme, iced_widget::Renderer>;
|
|
//! #
|
|
//! use iced::widget::toggler;
|
|
//!
|
|
//! struct State {
|
|
//! is_checked: bool,
|
|
//! }
|
|
//!
|
|
//! enum Message {
|
|
//! TogglerToggled(bool),
|
|
//! }
|
|
//!
|
|
//! fn view(state: &State) -> Element<'_, Message> {
|
|
//! toggler(state.is_checked)
|
|
//! .label("Toggle me!")
|
|
//! .on_toggle(Message::TogglerToggled)
|
|
//! .into()
|
|
//! }
|
|
//!
|
|
//! fn update(state: &mut State, message: Message) {
|
|
//! match message {
|
|
//! Message::TogglerToggled(is_checked) => {
|
|
//! state.is_checked = is_checked;
|
|
//! }
|
|
//! }
|
|
//! }
|
|
//! ```
|
|
//! Show toggle controls using togglers.
|
|
#[cfg(feature = "a11y")]
|
|
use std::borrow::Cow;
|
|
|
|
use iced_runtime::core::border::Radius;
|
|
|
|
use crate::core::alignment;
|
|
use crate::core::border;
|
|
use crate::core::layout;
|
|
use crate::core::mouse;
|
|
use crate::core::renderer;
|
|
use crate::core::text;
|
|
use crate::core::touch;
|
|
use crate::core::widget::tree::{self, Tree};
|
|
use crate::core::{
|
|
Background, Border, Clipboard, Color, Element, Event, Layout, Length,
|
|
Pixels, Rectangle, Shell, Size, Theme, Widget, id,
|
|
};
|
|
use crate::core::{
|
|
widget::{self, Id},
|
|
window,
|
|
};
|
|
|
|
/// A toggler widget.
|
|
///
|
|
/// # Example
|
|
/// ```no_run
|
|
/// # mod iced { pub mod widget { pub use iced_widget::*; } pub use iced_widget::Renderer; pub use iced_widget::core::*; }
|
|
/// # pub type Element<'a, Message> = iced_widget::core::Element<'a, Message, iced_widget::Theme, iced_widget::Renderer>;
|
|
/// #
|
|
/// use iced::widget::toggler;
|
|
///
|
|
/// struct State {
|
|
/// is_checked: bool,
|
|
/// }
|
|
///
|
|
/// enum Message {
|
|
/// TogglerToggled(bool),
|
|
/// }
|
|
///
|
|
/// fn view(state: &State) -> Element<'_, Message> {
|
|
/// toggler(state.is_checked)
|
|
/// .label("Toggle me!")
|
|
/// .on_toggle(Message::TogglerToggled)
|
|
/// .into()
|
|
/// }
|
|
///
|
|
/// fn update(state: &mut State, message: Message) {
|
|
/// match message {
|
|
/// Message::TogglerToggled(is_checked) => {
|
|
/// state.is_checked = is_checked;
|
|
/// }
|
|
/// }
|
|
/// }
|
|
/// ```
|
|
pub struct Toggler<
|
|
'a,
|
|
Message,
|
|
Theme = crate::Theme,
|
|
Renderer = crate::Renderer,
|
|
> where
|
|
Theme: Catalog,
|
|
Renderer: text::Renderer,
|
|
{
|
|
id: Id,
|
|
label_id: Option<Id>,
|
|
#[cfg(feature = "a11y")]
|
|
name: Option<Cow<'a, str>>,
|
|
#[cfg(feature = "a11y")]
|
|
description: Option<iced_accessibility::Description<'a>>,
|
|
#[cfg(feature = "a11y")]
|
|
labeled_by_widget: Option<Vec<iced_accessibility::accesskit::NodeId>>,
|
|
is_toggled: bool,
|
|
on_toggle: Option<Box<dyn Fn(bool) -> Message + 'a>>,
|
|
label: Option<text::Fragment<'a>>,
|
|
width: Length,
|
|
size: f32,
|
|
text_size: Option<Pixels>,
|
|
text_line_height: text::LineHeight,
|
|
text_alignment: text::Alignment,
|
|
text_shaping: text::Shaping,
|
|
text_wrapping: text::Wrapping,
|
|
spacing: f32,
|
|
font: Option<Renderer::Font>,
|
|
class: Theme::Class<'a>,
|
|
last_status: Option<Status>,
|
|
}
|
|
|
|
impl<'a, Message, Theme, Renderer> Toggler<'a, Message, Theme, Renderer>
|
|
where
|
|
Theme: Catalog,
|
|
Renderer: text::Renderer,
|
|
{
|
|
/// The default size of a [`Toggler`].
|
|
pub const DEFAULT_SIZE: f32 = 16.0;
|
|
|
|
/// Creates a new [`Toggler`].
|
|
///
|
|
/// It expects:
|
|
/// * a boolean describing whether the [`Toggler`] is checked or not
|
|
/// * An optional label for the [`Toggler`]
|
|
pub fn new(is_toggled: bool) -> Self {
|
|
Toggler {
|
|
id: Id::unique(),
|
|
label_id: None,
|
|
#[cfg(feature = "a11y")]
|
|
name: None,
|
|
#[cfg(feature = "a11y")]
|
|
description: None,
|
|
#[cfg(feature = "a11y")]
|
|
labeled_by_widget: None,
|
|
is_toggled,
|
|
on_toggle: None,
|
|
label: None,
|
|
width: Length::Shrink,
|
|
size: Self::DEFAULT_SIZE,
|
|
text_size: None,
|
|
text_line_height: text::LineHeight::default(),
|
|
text_alignment: text::Alignment::Default,
|
|
text_wrapping: text::Wrapping::default(),
|
|
spacing: Self::DEFAULT_SIZE / 2.0,
|
|
text_shaping: text::Shaping::Advanced,
|
|
font: None,
|
|
class: Theme::default(),
|
|
last_status: None,
|
|
}
|
|
}
|
|
|
|
/// Sets the label of the [`Toggler`].
|
|
pub fn label(mut self, label: impl text::IntoFragment<'a>) -> Self {
|
|
self.label = Some(label.into_fragment());
|
|
self.label_id = Some(Id::unique());
|
|
self
|
|
}
|
|
|
|
/// Sets the message that should be produced when a user toggles
|
|
/// the [`Toggler`].
|
|
///
|
|
/// If this method is not called, the [`Toggler`] will be disabled.
|
|
pub fn on_toggle(
|
|
mut self,
|
|
on_toggle: impl Fn(bool) -> Message + 'a,
|
|
) -> Self {
|
|
self.on_toggle = Some(Box::new(on_toggle));
|
|
self
|
|
}
|
|
|
|
/// Sets the message that should be produced when a user toggles
|
|
/// the [`Toggler`], if `Some`.
|
|
///
|
|
/// If `None`, the [`Toggler`] will be disabled.
|
|
pub fn on_toggle_maybe(
|
|
mut self,
|
|
on_toggle: Option<impl Fn(bool) -> Message + 'a>,
|
|
) -> Self {
|
|
self.on_toggle = on_toggle.map(|on_toggle| Box::new(on_toggle) as _);
|
|
self
|
|
}
|
|
|
|
/// Sets the size of the [`Toggler`].
|
|
pub fn size(mut self, size: impl Into<Pixels>) -> Self {
|
|
self.size = size.into().0;
|
|
self
|
|
}
|
|
|
|
/// Sets the width of the [`Toggler`].
|
|
pub fn width(mut self, width: impl Into<Length>) -> Self {
|
|
self.width = width.into();
|
|
self
|
|
}
|
|
|
|
/// Sets the text size o the [`Toggler`].
|
|
pub fn text_size(mut self, text_size: impl Into<Pixels>) -> Self {
|
|
self.text_size = Some(text_size.into());
|
|
self
|
|
}
|
|
|
|
/// Sets the text [`text::LineHeight`] of the [`Toggler`].
|
|
pub fn text_line_height(
|
|
mut self,
|
|
line_height: impl Into<text::LineHeight>,
|
|
) -> Self {
|
|
self.text_line_height = line_height.into();
|
|
self
|
|
}
|
|
|
|
/// Sets the horizontal alignment of the text of the [`Toggler`]
|
|
pub fn text_alignment(
|
|
mut self,
|
|
alignment: impl Into<text::Alignment>,
|
|
) -> Self {
|
|
self.text_alignment = alignment.into();
|
|
self
|
|
}
|
|
|
|
/// Sets the [`text::Shaping`] strategy of the [`Toggler`].
|
|
pub fn text_shaping(mut self, shaping: text::Shaping) -> Self {
|
|
self.text_shaping = shaping;
|
|
self
|
|
}
|
|
|
|
/// Sets the [`text::Wrapping`] strategy of the [`Toggler`].
|
|
pub fn text_wrapping(mut self, wrapping: text::Wrapping) -> Self {
|
|
self.text_wrapping = wrapping;
|
|
self
|
|
}
|
|
|
|
/// Sets the spacing between the [`Toggler`] and the text.
|
|
pub fn spacing(mut self, spacing: impl Into<Pixels>) -> Self {
|
|
self.spacing = spacing.into().0;
|
|
self
|
|
}
|
|
|
|
/// Sets the [`Renderer::Font`] of the text of the [`Toggler`]
|
|
///
|
|
/// [`Renderer::Font`]: crate::core::text::Renderer
|
|
pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
|
|
self.font = Some(font.into());
|
|
self
|
|
}
|
|
|
|
/// Sets the style of the [`Toggler`].
|
|
#[must_use]
|
|
pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> Self
|
|
where
|
|
Theme::Class<'a>: From<StyleFn<'a, Theme>>,
|
|
{
|
|
self.class = (Box::new(style) as StyleFn<'a, Theme>).into();
|
|
self
|
|
}
|
|
|
|
/// Sets the style class of the [`Toggler`].
|
|
#[cfg(feature = "advanced")]
|
|
#[must_use]
|
|
pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
|
|
self.class = class.into();
|
|
self
|
|
}
|
|
|
|
#[cfg(feature = "a11y")]
|
|
/// Sets the name of the [`Toggler`].
|
|
pub fn name(mut self, name: impl Into<Cow<'a, str>>) -> Self {
|
|
self.name = Some(name.into());
|
|
self
|
|
}
|
|
|
|
#[cfg(feature = "a11y")]
|
|
/// Sets the description of the [`Toggler`].
|
|
pub fn description_widget<T: iced_accessibility::Describes>(
|
|
mut self,
|
|
description: &T,
|
|
) -> Self {
|
|
self.description = Some(iced_accessibility::Description::Id(
|
|
description.description(),
|
|
));
|
|
self
|
|
}
|
|
|
|
#[cfg(feature = "a11y")]
|
|
/// Sets the description of the [`Toggler`].
|
|
pub fn description(mut self, description: impl Into<Cow<'a, str>>) -> Self {
|
|
self.description =
|
|
Some(iced_accessibility::Description::Text(description.into()));
|
|
self
|
|
}
|
|
|
|
#[cfg(feature = "a11y")]
|
|
/// Sets the label of the [`Toggler`] using another widget.
|
|
pub fn labeled_by_widget(
|
|
mut self,
|
|
label: &dyn iced_accessibility::Labels,
|
|
) -> Self {
|
|
self.labeled_by_widget =
|
|
Some(label.label().into_iter().map(|l| l.into()).collect());
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer>
|
|
for Toggler<'_, Message, Theme, Renderer>
|
|
where
|
|
Theme: Catalog,
|
|
Renderer: text::Renderer,
|
|
{
|
|
fn tag(&self) -> tree::Tag {
|
|
tree::Tag::of::<widget::text::State<Renderer::Paragraph>>()
|
|
}
|
|
|
|
fn state(&self) -> tree::State {
|
|
tree::State::new(widget::text::State::<Renderer::Paragraph>::default())
|
|
}
|
|
|
|
fn size(&self) -> Size<Length> {
|
|
Size {
|
|
width: self.width,
|
|
height: Length::Shrink,
|
|
}
|
|
}
|
|
|
|
fn layout(
|
|
&mut self,
|
|
tree: &mut Tree,
|
|
renderer: &Renderer,
|
|
limits: &layout::Limits,
|
|
) -> layout::Node {
|
|
let limits = limits.width(self.width);
|
|
|
|
layout::next_to_each_other(
|
|
&limits,
|
|
self.spacing,
|
|
|_| layout::Node::new(crate::core::Size::new(48., 24.)),
|
|
|limits| {
|
|
if let Some(label) = self.label.as_deref() {
|
|
let state = tree
|
|
.state
|
|
.downcast_mut::<widget::text::State<Renderer::Paragraph>>();
|
|
|
|
widget::text::layout(
|
|
state,
|
|
renderer,
|
|
limits,
|
|
label,
|
|
widget::text::Format {
|
|
width: self.width,
|
|
height: Length::Shrink,
|
|
line_height: self.text_line_height,
|
|
size: self.text_size,
|
|
font: self.font,
|
|
align_x: self.text_alignment,
|
|
align_y: alignment::Vertical::Top,
|
|
shaping: self.text_shaping,
|
|
wrapping: self.text_wrapping,
|
|
},
|
|
)
|
|
} else {
|
|
layout::Node::new(crate::core::Size::ZERO)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
|
|
fn update(
|
|
&mut self,
|
|
_tree: &mut Tree,
|
|
event: &Event,
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
_renderer: &Renderer,
|
|
_clipboard: &mut dyn Clipboard,
|
|
shell: &mut Shell<'_, Message>,
|
|
_viewport: &Rectangle,
|
|
) {
|
|
let Some(on_toggle) = &self.on_toggle else {
|
|
return;
|
|
};
|
|
|
|
match event {
|
|
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
|
|
| Event::Touch(touch::Event::FingerPressed { .. }) => {
|
|
let mouse_over = cursor.is_over(layout.bounds());
|
|
|
|
if mouse_over {
|
|
shell.publish(on_toggle(!self.is_toggled));
|
|
shell.capture_event();
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
let current_status = if self.on_toggle.is_none() {
|
|
Status::Disabled {
|
|
is_toggled: self.is_toggled,
|
|
}
|
|
} else if cursor.is_over(layout.bounds()) {
|
|
Status::Hovered {
|
|
is_toggled: self.is_toggled,
|
|
}
|
|
} else {
|
|
Status::Active {
|
|
is_toggled: self.is_toggled,
|
|
}
|
|
};
|
|
|
|
if let Event::Window(window::Event::RedrawRequested(_now)) = event {
|
|
self.last_status = Some(current_status);
|
|
} else if self
|
|
.last_status
|
|
.is_some_and(|status| status != current_status)
|
|
{
|
|
shell.request_redraw();
|
|
}
|
|
}
|
|
|
|
fn mouse_interaction(
|
|
&self,
|
|
_tree: &Tree,
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
_viewport: &Rectangle,
|
|
_renderer: &Renderer,
|
|
) -> mouse::Interaction {
|
|
if cursor.is_over(layout.bounds()) {
|
|
if self.on_toggle.is_some() {
|
|
mouse::Interaction::Pointer
|
|
} else {
|
|
mouse::Interaction::NotAllowed
|
|
}
|
|
} else {
|
|
mouse::Interaction::default()
|
|
}
|
|
}
|
|
|
|
fn draw(
|
|
&self,
|
|
tree: &Tree,
|
|
renderer: &mut Renderer,
|
|
theme: &Theme,
|
|
defaults: &renderer::Style,
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
viewport: &Rectangle,
|
|
) {
|
|
let mut children = layout.children();
|
|
let toggler_layout = children.next().unwrap();
|
|
|
|
let style = theme.style(
|
|
&self.class,
|
|
self.last_status.unwrap_or(Status::Disabled {
|
|
is_toggled: self.is_toggled,
|
|
}),
|
|
);
|
|
|
|
if self.label.is_some() {
|
|
let label_layout = children.next().unwrap();
|
|
let state: &widget::text::State<Renderer::Paragraph> =
|
|
tree.state.downcast_ref();
|
|
|
|
crate::text::draw(
|
|
renderer,
|
|
defaults,
|
|
label_layout.bounds(),
|
|
state.raw(),
|
|
crate::text::Style {
|
|
color: style.text_color,
|
|
},
|
|
viewport,
|
|
);
|
|
}
|
|
|
|
let bounds = toggler_layout.bounds();
|
|
let is_mouse_over = cursor.is_over(layout.bounds());
|
|
|
|
let status = if self.on_toggle.is_none() {
|
|
Status::Disabled {
|
|
is_toggled: self.is_toggled,
|
|
}
|
|
} else if is_mouse_over {
|
|
Status::Hovered {
|
|
is_toggled: self.is_toggled,
|
|
}
|
|
} else {
|
|
Status::Active {
|
|
is_toggled: self.is_toggled,
|
|
}
|
|
};
|
|
|
|
let style = theme.style(&self.class, status);
|
|
|
|
let space = style.handle_margin;
|
|
|
|
let toggler_background_bounds = Rectangle {
|
|
x: bounds.x,
|
|
y: bounds.y,
|
|
width: bounds.width,
|
|
height: bounds.height,
|
|
};
|
|
|
|
renderer.fill_quad(
|
|
renderer::Quad {
|
|
bounds,
|
|
border: Border {
|
|
radius: style.border_radius,
|
|
width: style.background_border_width,
|
|
color: style.background_border_color,
|
|
},
|
|
..renderer::Quad::default()
|
|
},
|
|
style.background,
|
|
);
|
|
|
|
let padding = (style.padding_ratio * bounds.height).round();
|
|
let toggler_foreground_bounds = Rectangle {
|
|
x: bounds.x
|
|
+ if self.is_toggled {
|
|
bounds.width - space - (bounds.height - (2.0 * space))
|
|
} else {
|
|
space
|
|
},
|
|
y: bounds.y + space,
|
|
width: bounds.height - (2.0 * space),
|
|
height: bounds.height - (2.0 * space),
|
|
};
|
|
|
|
renderer.fill_quad(
|
|
renderer::Quad {
|
|
bounds: toggler_foreground_bounds,
|
|
border: Border {
|
|
radius: style.handle_radius,
|
|
width: style.foreground_border_width,
|
|
color: style.foreground_border_color,
|
|
},
|
|
..renderer::Quad::default()
|
|
},
|
|
style.foreground,
|
|
);
|
|
}
|
|
|
|
#[cfg(feature = "a11y")]
|
|
/// get the a11y nodes for the widget
|
|
fn a11y_nodes(
|
|
&self,
|
|
layout: Layout<'_>,
|
|
_state: &Tree,
|
|
cursor: mouse::Cursor,
|
|
) -> iced_accessibility::A11yTree {
|
|
use iced_accessibility::{
|
|
A11yNode, A11yTree,
|
|
accesskit::{Action, Node, NodeId, Rect, Role},
|
|
};
|
|
|
|
let bounds = layout.bounds();
|
|
let is_hovered = cursor.is_over(bounds);
|
|
let Rectangle {
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
} = bounds;
|
|
|
|
let bounds = Rect::new(
|
|
x as f64,
|
|
y as f64,
|
|
(x + width) as f64,
|
|
(y + height) as f64,
|
|
);
|
|
|
|
let mut node = Node::new(Role::Switch);
|
|
node.add_action(Action::Focus);
|
|
node.add_action(Action::Click);
|
|
node.set_bounds(bounds);
|
|
if let Some(name) = self.name.as_ref() {
|
|
node.set_label(name.clone());
|
|
}
|
|
match self.description.as_ref() {
|
|
Some(iced_accessibility::Description::Id(id)) => {
|
|
node.set_described_by(
|
|
id.iter()
|
|
.cloned()
|
|
.map(|id| NodeId::from(id))
|
|
.collect::<Vec<_>>(),
|
|
);
|
|
}
|
|
Some(iced_accessibility::Description::Text(text)) => {
|
|
node.set_description(text.clone());
|
|
}
|
|
None => {}
|
|
}
|
|
node.set_selected(self.is_toggled);
|
|
// TODO hover
|
|
// if is_hovered {
|
|
// node.set_hovered();
|
|
// }
|
|
node.add_action(Action::Click);
|
|
if let Some(label) = self.label.as_ref() {
|
|
let mut label_node = Node::new(Role::Label);
|
|
|
|
label_node.set_label(label.clone());
|
|
// TODO proper label bounds for the label
|
|
label_node.set_bounds(bounds);
|
|
|
|
A11yTree::node_with_child_tree(
|
|
A11yNode::new(node, self.id.clone()),
|
|
A11yTree::leaf(label_node, self.label_id.clone().unwrap()),
|
|
)
|
|
} else {
|
|
if let Some(labeled_by_widget) = self.labeled_by_widget.as_ref() {
|
|
node.set_labelled_by(labeled_by_widget.clone());
|
|
}
|
|
A11yTree::leaf(node, self.id.clone())
|
|
}
|
|
}
|
|
|
|
fn id(&self) -> Option<Id> {
|
|
if self.label.is_some() {
|
|
Some(Id(iced_runtime::core::id::Internal::Set(vec![
|
|
self.id.0.clone(),
|
|
self.label_id.clone().unwrap().0,
|
|
])))
|
|
} else {
|
|
Some(self.id.clone())
|
|
}
|
|
}
|
|
|
|
fn set_id(&mut self, id: Id) {
|
|
if let Id(id::Internal::Set(list)) = id {
|
|
if list.len() == 2 && self.label.is_some() {
|
|
self.id.0 = list[0].clone();
|
|
self.label_id = Some(Id(list[1].clone()));
|
|
}
|
|
} else if self.label.is_none() {
|
|
self.id = id;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a, Message, Theme, Renderer> From<Toggler<'a, Message, Theme, Renderer>>
|
|
for Element<'a, Message, Theme, Renderer>
|
|
where
|
|
Message: 'a,
|
|
Theme: Catalog + 'a,
|
|
Renderer: text::Renderer + 'a,
|
|
{
|
|
fn from(
|
|
toggler: Toggler<'a, Message, Theme, Renderer>,
|
|
) -> Element<'a, Message, Theme, Renderer> {
|
|
Element::new(toggler)
|
|
}
|
|
}
|
|
|
|
/// The possible status of a [`Toggler`].
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum Status {
|
|
/// The [`Toggler`] can be interacted with.
|
|
Active {
|
|
/// Indicates whether the [`Toggler`] is toggled.
|
|
is_toggled: bool,
|
|
},
|
|
/// The [`Toggler`] is being hovered.
|
|
Hovered {
|
|
/// Indicates whether the [`Toggler`] is toggled.
|
|
is_toggled: bool,
|
|
},
|
|
/// The [`Toggler`] is disabled.
|
|
Disabled {
|
|
/// Indicates whether the [`Toggler`] is toggled.
|
|
is_toggled: bool,
|
|
},
|
|
}
|
|
|
|
/// The appearance of a toggler.
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
pub struct Style {
|
|
/// The background [`Color`] of the toggler.
|
|
pub background: Background,
|
|
/// The width of the background border of the toggler.
|
|
pub background_border_width: f32,
|
|
/// The [`Color`] of the background border of the toggler.
|
|
pub background_border_color: Color,
|
|
/// The foreground [`Color`] of the toggler.
|
|
pub foreground: Background,
|
|
/// The width of the foreground border of the toggler.
|
|
pub foreground_border_width: f32,
|
|
/// The [`Color`] of the foreground border of the toggler.
|
|
pub foreground_border_color: Color,
|
|
/// The border radius of the toggler.
|
|
pub border_radius: Radius,
|
|
/// the radius of the handle of the toggler
|
|
pub handle_radius: Radius,
|
|
/// the space between the handle and the border of the toggler
|
|
pub handle_margin: f32,
|
|
/// The ratio of separation between the background and the toggle in relative height.
|
|
pub padding_ratio: f32,
|
|
/// The text [`Color`] of the toggler.
|
|
pub text_color: Option<Color>,
|
|
}
|
|
|
|
/// The theme catalog of a [`Toggler`].
|
|
pub trait Catalog: Sized {
|
|
/// The item class of the [`Catalog`].
|
|
type Class<'a>;
|
|
|
|
/// The default class produced by the [`Catalog`].
|
|
fn default<'a>() -> Self::Class<'a>;
|
|
|
|
/// The [`Style`] of a class with the given status.
|
|
fn style(&self, class: &Self::Class<'_>, status: Status) -> Style;
|
|
}
|
|
|
|
/// A styling function for a [`Toggler`].
|
|
///
|
|
/// This is just a boxed closure: `Fn(&Theme, Status) -> Style`.
|
|
pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme, Status) -> Style + 'a>;
|
|
|
|
impl Catalog for Theme {
|
|
type Class<'a> = StyleFn<'a, Self>;
|
|
|
|
fn default<'a>() -> Self::Class<'a> {
|
|
Box::new(default)
|
|
}
|
|
|
|
fn style(&self, class: &Self::Class<'_>, status: Status) -> Style {
|
|
class(self, status)
|
|
}
|
|
}
|
|
|
|
/// The default style of a [`Toggler`].
|
|
pub fn default(theme: &Theme, status: Status) -> Style {
|
|
let palette = theme.extended_palette();
|
|
|
|
let background = match status {
|
|
Status::Active { is_toggled } | Status::Hovered { is_toggled } => {
|
|
if is_toggled {
|
|
palette.primary.base.color
|
|
} else {
|
|
palette.background.strong.color
|
|
}
|
|
}
|
|
Status::Disabled { is_toggled } => {
|
|
if is_toggled {
|
|
palette.background.strong.color
|
|
} else {
|
|
palette.background.weak.color
|
|
}
|
|
}
|
|
};
|
|
|
|
let foreground = match status {
|
|
Status::Active { is_toggled } => {
|
|
if is_toggled {
|
|
palette.primary.base.text
|
|
} else {
|
|
palette.background.base.color
|
|
}
|
|
}
|
|
Status::Hovered { is_toggled } => {
|
|
if is_toggled {
|
|
Color {
|
|
a: 0.5,
|
|
..palette.primary.base.text
|
|
}
|
|
} else {
|
|
palette.background.weak.color
|
|
}
|
|
}
|
|
Status::Disabled { .. } => palette.background.weakest.color,
|
|
};
|
|
|
|
Style {
|
|
background: background.into(),
|
|
foreground: foreground.into(),
|
|
foreground_border_width: 0.0,
|
|
foreground_border_color: Color::TRANSPARENT,
|
|
background_border_width: 0.0,
|
|
background_border_color: Color::TRANSPARENT,
|
|
border_radius: Radius::from(8.0),
|
|
handle_radius: Radius::from(8.0),
|
|
handle_margin: 2.0,
|
|
padding_ratio: 0.1,
|
|
text_color: None,
|
|
}
|
|
}
|