451 lines
12 KiB
Rust
451 lines
12 KiB
Rust
//! Allow your users to perform actions by pressing a button.
|
|
//!
|
|
//! A [`Button`] has some local [`State`].
|
|
use crate::core::event::{self, Event};
|
|
use crate::core::layout;
|
|
use crate::core::mouse;
|
|
use crate::core::overlay;
|
|
use crate::core::renderer;
|
|
use crate::core::touch;
|
|
use crate::core::widget::tree::{self, Tree};
|
|
use crate::core::widget::Operation;
|
|
use crate::core::{
|
|
Background, Clipboard, Color, Element, Layout, Length, Padding, Rectangle,
|
|
Shell, Size, Vector, Widget,
|
|
};
|
|
|
|
pub use crate::style::button::{Appearance, StyleSheet};
|
|
|
|
/// A generic widget that produces a message when pressed.
|
|
///
|
|
/// ```no_run
|
|
/// # type Button<'a, Message> =
|
|
/// # iced_widget::Button<'a, Message, iced_widget::style::Theme, iced_widget::renderer::Renderer>;
|
|
/// #
|
|
/// #[derive(Clone)]
|
|
/// enum Message {
|
|
/// ButtonPressed,
|
|
/// }
|
|
///
|
|
/// let button = Button::new("Press me!").on_press(Message::ButtonPressed);
|
|
/// ```
|
|
///
|
|
/// If a [`Button::on_press`] handler is not set, the resulting [`Button`] will
|
|
/// be disabled:
|
|
///
|
|
/// ```
|
|
/// # type Button<'a, Message> =
|
|
/// # iced_widget::Button<'a, Message, iced_widget::style::Theme, iced_widget::renderer::Renderer>;
|
|
/// #
|
|
/// #[derive(Clone)]
|
|
/// enum Message {
|
|
/// ButtonPressed,
|
|
/// }
|
|
///
|
|
/// fn disabled_button<'a>() -> Button<'a, Message> {
|
|
/// Button::new("I'm disabled!")
|
|
/// }
|
|
///
|
|
/// fn enabled_button<'a>() -> Button<'a, Message> {
|
|
/// disabled_button().on_press(Message::ButtonPressed)
|
|
/// }
|
|
/// ```
|
|
#[allow(missing_debug_implementations)]
|
|
pub struct Button<'a, Message, Theme = crate::Theme, Renderer = crate::Renderer>
|
|
where
|
|
Theme: StyleSheet,
|
|
Renderer: crate::core::Renderer,
|
|
{
|
|
content: Element<'a, Message, Theme, Renderer>,
|
|
on_press: Option<Message>,
|
|
width: Length,
|
|
height: Length,
|
|
padding: Padding,
|
|
clip: bool,
|
|
style: Theme::Style,
|
|
}
|
|
|
|
impl<'a, Message, Theme, Renderer> Button<'a, Message, Theme, Renderer>
|
|
where
|
|
Theme: StyleSheet,
|
|
Renderer: crate::core::Renderer,
|
|
{
|
|
/// Creates a new [`Button`] with the given content.
|
|
pub fn new(
|
|
content: impl Into<Element<'a, Message, Theme, Renderer>>,
|
|
) -> Self {
|
|
let content = content.into();
|
|
let size = content.as_widget().size_hint();
|
|
|
|
Button {
|
|
content,
|
|
on_press: None,
|
|
width: size.width.fluid(),
|
|
height: size.height.fluid(),
|
|
padding: Padding::new(5.0),
|
|
clip: false,
|
|
style: Theme::Style::default(),
|
|
}
|
|
}
|
|
|
|
/// Sets the width of the [`Button`].
|
|
pub fn width(mut self, width: impl Into<Length>) -> Self {
|
|
self.width = width.into();
|
|
self
|
|
}
|
|
|
|
/// Sets the height of the [`Button`].
|
|
pub fn height(mut self, height: impl Into<Length>) -> Self {
|
|
self.height = height.into();
|
|
self
|
|
}
|
|
|
|
/// Sets the [`Padding`] of the [`Button`].
|
|
pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
|
|
self.padding = padding.into();
|
|
self
|
|
}
|
|
|
|
/// Sets the message that will be produced when the [`Button`] is pressed.
|
|
///
|
|
/// Unless `on_press` is called, the [`Button`] will be disabled.
|
|
pub fn on_press(mut self, on_press: Message) -> Self {
|
|
self.on_press = Some(on_press);
|
|
self
|
|
}
|
|
|
|
/// Sets the message that will be produced when the [`Button`] is pressed,
|
|
/// if `Some`.
|
|
///
|
|
/// If `None`, the [`Button`] will be disabled.
|
|
pub fn on_press_maybe(mut self, on_press: Option<Message>) -> Self {
|
|
self.on_press = on_press;
|
|
self
|
|
}
|
|
|
|
/// Sets the style variant of this [`Button`].
|
|
pub fn style(mut self, style: impl Into<Theme::Style>) -> Self {
|
|
self.style = style.into();
|
|
self
|
|
}
|
|
|
|
/// Sets whether the contents of the [`Button`] should be clipped on
|
|
/// overflow.
|
|
pub fn clip(mut self, clip: bool) -> Self {
|
|
self.clip = clip;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
|
|
for Button<'a, Message, Theme, Renderer>
|
|
where
|
|
Message: 'a + Clone,
|
|
Theme: StyleSheet,
|
|
Renderer: 'a + crate::core::Renderer,
|
|
{
|
|
fn tag(&self) -> tree::Tag {
|
|
tree::Tag::of::<State>()
|
|
}
|
|
|
|
fn state(&self) -> tree::State {
|
|
tree::State::new(State::new())
|
|
}
|
|
|
|
fn children(&self) -> Vec<Tree> {
|
|
vec![Tree::new(&self.content)]
|
|
}
|
|
|
|
fn diff(&self, tree: &mut Tree) {
|
|
tree.diff_children(std::slice::from_ref(&self.content));
|
|
}
|
|
|
|
fn size(&self) -> Size<Length> {
|
|
Size {
|
|
width: self.width,
|
|
height: self.height,
|
|
}
|
|
}
|
|
|
|
fn layout(
|
|
&self,
|
|
tree: &mut Tree,
|
|
renderer: &Renderer,
|
|
limits: &layout::Limits,
|
|
) -> layout::Node {
|
|
layout(limits, self.width, self.height, self.padding, |limits| {
|
|
self.content.as_widget().layout(
|
|
&mut tree.children[0],
|
|
renderer,
|
|
limits,
|
|
)
|
|
})
|
|
}
|
|
|
|
fn operate(
|
|
&self,
|
|
tree: &mut Tree,
|
|
layout: Layout<'_>,
|
|
renderer: &Renderer,
|
|
operation: &mut dyn Operation<Message>,
|
|
) {
|
|
operation.container(None, layout.bounds(), &mut |operation| {
|
|
self.content.as_widget().operate(
|
|
&mut tree.children[0],
|
|
layout.children().next().unwrap(),
|
|
renderer,
|
|
operation,
|
|
);
|
|
});
|
|
}
|
|
|
|
fn on_event(
|
|
&mut self,
|
|
tree: &mut Tree,
|
|
event: Event,
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
renderer: &Renderer,
|
|
clipboard: &mut dyn Clipboard,
|
|
shell: &mut Shell<'_, Message>,
|
|
viewport: &Rectangle,
|
|
) -> event::Status {
|
|
if let event::Status::Captured = self.content.as_widget_mut().on_event(
|
|
&mut tree.children[0],
|
|
event.clone(),
|
|
layout.children().next().unwrap(),
|
|
cursor,
|
|
renderer,
|
|
clipboard,
|
|
shell,
|
|
viewport,
|
|
) {
|
|
return event::Status::Captured;
|
|
}
|
|
|
|
update(event, layout, cursor, shell, &self.on_press, || {
|
|
tree.state.downcast_mut::<State>()
|
|
})
|
|
}
|
|
|
|
fn draw(
|
|
&self,
|
|
tree: &Tree,
|
|
renderer: &mut Renderer,
|
|
theme: &Theme,
|
|
_style: &renderer::Style,
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
viewport: &Rectangle,
|
|
) {
|
|
let bounds = layout.bounds();
|
|
let content_layout = layout.children().next().unwrap();
|
|
|
|
let styling = draw(
|
|
renderer,
|
|
bounds,
|
|
cursor,
|
|
self.on_press.is_some(),
|
|
theme,
|
|
&self.style,
|
|
|| tree.state.downcast_ref::<State>(),
|
|
);
|
|
|
|
let viewport = if self.clip {
|
|
bounds.intersection(viewport).unwrap_or(*viewport)
|
|
} else {
|
|
*viewport
|
|
};
|
|
|
|
self.content.as_widget().draw(
|
|
&tree.children[0],
|
|
renderer,
|
|
theme,
|
|
&renderer::Style {
|
|
text_color: styling.text_color,
|
|
},
|
|
content_layout,
|
|
cursor,
|
|
&viewport,
|
|
);
|
|
}
|
|
|
|
fn mouse_interaction(
|
|
&self,
|
|
_tree: &Tree,
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
_viewport: &Rectangle,
|
|
_renderer: &Renderer,
|
|
) -> mouse::Interaction {
|
|
mouse_interaction(layout, cursor, self.on_press.is_some())
|
|
}
|
|
|
|
fn overlay<'b>(
|
|
&'b mut self,
|
|
tree: &'b mut Tree,
|
|
layout: Layout<'_>,
|
|
renderer: &Renderer,
|
|
translation: Vector,
|
|
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
|
|
self.content.as_widget_mut().overlay(
|
|
&mut tree.children[0],
|
|
layout.children().next().unwrap(),
|
|
renderer,
|
|
translation,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl<'a, Message, Theme, Renderer> From<Button<'a, Message, Theme, Renderer>>
|
|
for Element<'a, Message, Theme, Renderer>
|
|
where
|
|
Message: Clone + 'a,
|
|
Theme: StyleSheet + 'a,
|
|
Renderer: crate::core::Renderer + 'a,
|
|
{
|
|
fn from(button: Button<'a, Message, Theme, Renderer>) -> Self {
|
|
Self::new(button)
|
|
}
|
|
}
|
|
|
|
/// The local state of a [`Button`].
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
|
pub struct State {
|
|
is_pressed: bool,
|
|
}
|
|
|
|
impl State {
|
|
/// Creates a new [`State`].
|
|
pub fn new() -> State {
|
|
State::default()
|
|
}
|
|
}
|
|
|
|
/// Processes the given [`Event`] and updates the [`State`] of a [`Button`]
|
|
/// accordingly.
|
|
pub fn update<'a, Message: Clone>(
|
|
event: Event,
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
shell: &mut Shell<'_, Message>,
|
|
on_press: &Option<Message>,
|
|
state: impl FnOnce() -> &'a mut State,
|
|
) -> event::Status {
|
|
match event {
|
|
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
|
|
| Event::Touch(touch::Event::FingerPressed { .. }) => {
|
|
if on_press.is_some() {
|
|
let bounds = layout.bounds();
|
|
|
|
if cursor.is_over(bounds) {
|
|
let state = state();
|
|
|
|
state.is_pressed = true;
|
|
|
|
return event::Status::Captured;
|
|
}
|
|
}
|
|
}
|
|
Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left))
|
|
| Event::Touch(touch::Event::FingerLifted { .. }) => {
|
|
if let Some(on_press) = on_press.clone() {
|
|
let state = state();
|
|
|
|
if state.is_pressed {
|
|
state.is_pressed = false;
|
|
|
|
let bounds = layout.bounds();
|
|
|
|
if cursor.is_over(bounds) {
|
|
shell.publish(on_press);
|
|
}
|
|
|
|
return event::Status::Captured;
|
|
}
|
|
}
|
|
}
|
|
Event::Touch(touch::Event::FingerLost { .. }) => {
|
|
let state = state();
|
|
|
|
state.is_pressed = false;
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
event::Status::Ignored
|
|
}
|
|
|
|
/// Draws a [`Button`].
|
|
pub fn draw<'a, Theme, Renderer: crate::core::Renderer>(
|
|
renderer: &mut Renderer,
|
|
bounds: Rectangle,
|
|
cursor: mouse::Cursor,
|
|
is_enabled: bool,
|
|
theme: &Theme,
|
|
style: &Theme::Style,
|
|
state: impl FnOnce() -> &'a State,
|
|
) -> Appearance
|
|
where
|
|
Theme: StyleSheet,
|
|
{
|
|
let is_mouse_over = cursor.is_over(bounds);
|
|
|
|
let styling = if !is_enabled {
|
|
theme.disabled(style)
|
|
} else if is_mouse_over {
|
|
let state = state();
|
|
|
|
if state.is_pressed {
|
|
theme.pressed(style)
|
|
} else {
|
|
theme.hovered(style)
|
|
}
|
|
} else {
|
|
theme.active(style)
|
|
};
|
|
|
|
if styling.background.is_some()
|
|
|| styling.border.width > 0.0
|
|
|| styling.shadow.color.a > 0.0
|
|
{
|
|
renderer.fill_quad(
|
|
renderer::Quad {
|
|
bounds,
|
|
border: styling.border,
|
|
shadow: styling.shadow,
|
|
},
|
|
styling
|
|
.background
|
|
.unwrap_or(Background::Color(Color::TRANSPARENT)),
|
|
);
|
|
}
|
|
|
|
styling
|
|
}
|
|
|
|
/// Computes the layout of a [`Button`].
|
|
pub fn layout(
|
|
limits: &layout::Limits,
|
|
width: Length,
|
|
height: Length,
|
|
padding: Padding,
|
|
layout_content: impl FnOnce(&layout::Limits) -> layout::Node,
|
|
) -> layout::Node {
|
|
layout::padded(limits, width, height, padding, layout_content)
|
|
}
|
|
|
|
/// Returns the [`mouse::Interaction`] of a [`Button`].
|
|
pub fn mouse_interaction(
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
is_enabled: bool,
|
|
) -> mouse::Interaction {
|
|
let is_mouse_over = cursor.is_over(layout.bounds());
|
|
|
|
if is_mouse_over && is_enabled {
|
|
mouse::Interaction::Pointer
|
|
} else {
|
|
mouse::Interaction::default()
|
|
}
|
|
}
|