diff options
81 files changed, 2577 insertions, 2710 deletions
@@ -3,7 +3,7 @@ name = "iced" version = "0.1.0-alpha" authors = ["Héctor Ramón Jiménez <hector0193@gmail.com>"] edition = "2018" -description = "A GUI runtime, heavily inspired by Elm." +description = "A cross-platform GUI library inspired by Elm" license = "MIT" repository = "https://github.com/hecrj/iced" documentation = "https://docs.rs/iced" @@ -14,18 +14,10 @@ categories = ["gui"] [badges] maintenance = { status = "actively-developed" } -[package.metadata.docs.rs] -features = ["winit"] - -[dependencies] -stretch = "0.2" -twox-hash = "1.5" - -# Enable to obtain conversion traits -winit = { version = "0.20.0-alpha3", optional = true } - [workspace] members = [ + "core", + "native", "web", "examples/tour", ] diff --git a/core/Cargo.toml b/core/Cargo.toml new file mode 100644 index 00000000..40a8bcfb --- /dev/null +++ b/core/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "iced_core" +version = "0.1.0-alpha" +authors = ["Héctor Ramón Jiménez <hector0193@gmail.com>"] +edition = "2018" +description = "The essential concepts of Iced" +license = "MIT" +repository = "https://github.com/hecrj/iced" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +stretch = { version = "0.2", optional = true } diff --git a/core/src/align.rs b/core/src/align.rs new file mode 100644 index 00000000..5876e0f8 --- /dev/null +++ b/core/src/align.rs @@ -0,0 +1,47 @@ +/// Alignment on the cross axis of a container. +/// +/// * On a [`Column`], it describes __horizontal__ alignment. +/// * On a [`Row`], it describes __vertical__ alignment. +/// +/// [`Column`]: widget/struct.Column.html +/// [`Row`]: widget/struct.Row.html +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum Align { + /// Align at the start of the cross axis. + Start, + + /// Align at the center of the cross axis. + Center, + + /// Align at the end of the cross axis. + End, + + /// Stretch over the cross axis. + Stretch, +} + +#[cfg(feature = "stretch")] +#[doc(hidden)] +impl From<Align> for stretch::style::AlignItems { + fn from(align: Align) -> Self { + match align { + Align::Start => stretch::style::AlignItems::FlexStart, + Align::Center => stretch::style::AlignItems::Center, + Align::End => stretch::style::AlignItems::FlexEnd, + Align::Stretch => stretch::style::AlignItems::Stretch, + } + } +} + +#[cfg(feature = "stretch")] +#[doc(hidden)] +impl From<Align> for stretch::style::AlignSelf { + fn from(align: Align) -> Self { + match align { + Align::Start => stretch::style::AlignSelf::FlexStart, + Align::Center => stretch::style::AlignSelf::Center, + Align::End => stretch::style::AlignSelf::FlexEnd, + Align::Stretch => stretch::style::AlignSelf::Stretch, + } + } +} diff --git a/src/color.rs b/core/src/color.rs index 5cc3a084..5cc3a084 100644 --- a/src/color.rs +++ b/core/src/color.rs diff --git a/core/src/justify.rs b/core/src/justify.rs new file mode 100644 index 00000000..878573b0 --- /dev/null +++ b/core/src/justify.rs @@ -0,0 +1,44 @@ +/// Distribution on the main axis of a container. +/// +/// * On a [`Column`], it describes __vertical__ distribution. +/// * On a [`Row`], it describes __horizontal__ distribution. +/// +/// [`Column`]: widget/struct.Column.html +/// [`Row`]: widget/struct.Row.html +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum Justify { + /// Place items at the start of the main axis. + Start, + + /// Place items at the center of the main axis. + Center, + + /// Place items at the end of the main axis. + End, + + /// Place items with space between. + SpaceBetween, + + /// Place items with space around. + SpaceAround, + + /// Place items with evenly distributed space. + SpaceEvenly, +} + +#[cfg(feature = "stretch")] +#[doc(hidden)] +impl From<Justify> for stretch::style::JustifyContent { + fn from(justify: Justify) -> Self { + match justify { + Justify::Start => stretch::style::JustifyContent::FlexStart, + Justify::Center => stretch::style::JustifyContent::Center, + Justify::End => stretch::style::JustifyContent::FlexEnd, + Justify::SpaceBetween => { + stretch::style::JustifyContent::SpaceBetween + } + Justify::SpaceAround => stretch::style::JustifyContent::SpaceAround, + Justify::SpaceEvenly => stretch::style::JustifyContent::SpaceEvenly, + } + } +} diff --git a/core/src/length.rs b/core/src/length.rs new file mode 100644 index 00000000..3547b246 --- /dev/null +++ b/core/src/length.rs @@ -0,0 +1,6 @@ +#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] +pub enum Length { + Fill, + Shrink, + Units(u16), +} diff --git a/core/src/lib.rs b/core/src/lib.rs new file mode 100644 index 00000000..1f43b2b7 --- /dev/null +++ b/core/src/lib.rs @@ -0,0 +1,18 @@ +pub mod widget; + +mod align; +mod color; +mod justify; +mod length; +mod point; +mod rectangle; +mod vector; + +pub use align::Align; +pub use color::Color; +pub use justify::Justify; +pub use length::Length; +pub use point::Point; +pub use rectangle::Rectangle; +pub use vector::Vector; +pub use widget::*; diff --git a/src/point.rs b/core/src/point.rs index 183998dd..183998dd 100644 --- a/src/point.rs +++ b/core/src/point.rs diff --git a/src/rectangle.rs b/core/src/rectangle.rs index 95c2570c..95c2570c 100644 --- a/src/rectangle.rs +++ b/core/src/rectangle.rs diff --git a/src/vector.rs b/core/src/vector.rs index f45daab9..f45daab9 100644 --- a/src/vector.rs +++ b/core/src/vector.rs diff --git a/core/src/widget.rs b/core/src/widget.rs new file mode 100644 index 00000000..4700be0e --- /dev/null +++ b/core/src/widget.rs @@ -0,0 +1,27 @@ +//! Use the essential widgets. +//! +//! # Re-exports +//! For convenience, the contents of this module are available at the root +//! module. Therefore, you can directly type: +//! +//! ``` +//! use iced_core::{button, Button}; +//! ``` +mod column; +mod row; + +pub mod button; +pub mod checkbox; +pub mod image; +pub mod radio; +pub mod slider; +pub mod text; + +pub use button::Button; +pub use checkbox::Checkbox; +pub use column::Column; +pub use image::Image; +pub use radio::Radio; +pub use row::Row; +pub use slider::Slider; +pub use text::Text; diff --git a/core/src/widget/button.rs b/core/src/widget/button.rs new file mode 100644 index 00000000..b98bb443 --- /dev/null +++ b/core/src/widget/button.rs @@ -0,0 +1,158 @@ +//! Allow your users to perform actions by pressing a button. +//! +//! A [`Button`] has some local [`State`]. +//! +//! [`Button`]: struct.Button.html +//! [`State`]: struct.State.html + +use crate::{Align, Length}; + +/// A generic widget that produces a message when clicked. +/// +/// # Example +/// +/// ``` +/// use iced_core::{button, Button}; +/// +/// pub enum Message { +/// ButtonClicked, +/// } +/// +/// let state = &mut button::State::new(); +/// +/// Button::new(state, "Click me!") +/// .on_press(Message::ButtonClicked); +/// ``` +/// +///  +pub struct Button<'a, Message> { + /// The current state of the button + pub state: &'a mut State, + + /// The label of the button + pub label: String, + + /// The message to produce when the button is pressed + pub on_press: Option<Message>, + + pub class: Class, + + pub width: Length, + + pub align_self: Option<Align>, +} + +impl<'a, Message> std::fmt::Debug for Button<'a, Message> +where + Message: std::fmt::Debug, +{ + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Button") + .field("state", &self.state) + .field("label", &self.label) + .field("on_press", &self.on_press) + .finish() + } +} + +impl<'a, Message> Button<'a, Message> { + /// Creates a new [`Button`] with some local [`State`] and the given label. + /// + /// [`Button`]: struct.Button.html + /// [`State`]: struct.State.html + pub fn new(state: &'a mut State, label: &str) -> Self { + Button { + state, + label: String::from(label), + on_press: None, + class: Class::Primary, + width: Length::Shrink, + align_self: None, + } + } + + /// Sets the width of the [`Button`]. + /// + /// [`Button`]: struct.Button.html + pub fn width(mut self, width: Length) -> Self { + self.width = width; + self + } + + /// Sets the alignment of the [`Button`] itself. + /// + /// This is useful if you want to override the default alignment given by + /// the parent container. + /// + /// [`Button`]: struct.Button.html + pub fn align_self(mut self, align: Align) -> Self { + self.align_self = Some(align); + self + } + + /// Sets the [`Class`] of the [`Button`]. + /// + /// + /// [`Button`]: struct.Button.html + /// [`Class`]: enum.Class.html + pub fn class(mut self, class: Class) -> Self { + self.class = class; + self + } + + /// Sets the message that will be produced when the [`Button`] is pressed. + /// + /// [`Button`]: struct.Button.html + pub fn on_press(mut self, msg: Message) -> Self { + self.on_press = Some(msg); + self + } +} + +/// The local state of a [`Button`]. +/// +/// [`Button`]: struct.Button.html +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct State { + pub is_pressed: bool, +} + +impl State { + /// Creates a new [`State`]. + /// + /// [`State`]: struct.State.html + pub fn new() -> State { + State::default() + } + + /// Returns whether the associated [`Button`] is currently being pressed or + /// not. + /// + /// [`Button`]: struct.Button.html + pub fn is_pressed(&self) -> bool { + self.is_pressed + } +} + +/// The type of a [`Button`]. +/// +///  +/// +/// [`Button`]: struct.Button.html +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Class { + /// The [`Button`] performs the main action. + /// + /// [`Button`]: struct.Button.html + Primary, + + /// The [`Button`] performs an alternative action. + /// + /// [`Button`]: struct.Button.html + Secondary, + + /// The [`Button`] performs a productive action. + /// + /// [`Button`]: struct.Button.html + Positive, +} diff --git a/core/src/widget/checkbox.rs b/core/src/widget/checkbox.rs new file mode 100644 index 00000000..1f0a0c04 --- /dev/null +++ b/core/src/widget/checkbox.rs @@ -0,0 +1,78 @@ +//! Show toggle controls using checkboxes. +use crate::Color; + +/// A box that can be checked. +/// +/// # Example +/// +/// ``` +/// use iced_core::Checkbox; +/// +/// pub enum Message { +/// CheckboxToggled(bool), +/// } +/// +/// let is_checked = true; +/// +/// Checkbox::new(is_checked, "Toggle me!", Message::CheckboxToggled); +/// ``` +/// +///  +pub struct Checkbox<Message> { + /// Whether the checkbox is checked or not + pub is_checked: bool, + + /// Function to call when checkbox is toggled to produce a __message__. + /// + /// The function should be provided `true` when the checkbox is checked + /// and `false` otherwise. + pub on_toggle: Box<dyn Fn(bool) -> Message>, + + /// The label of the checkbox + pub label: String, + + /// The color of the label + pub label_color: Option<Color>, +} + +impl<Message> std::fmt::Debug for Checkbox<Message> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Checkbox") + .field("is_checked", &self.is_checked) + .field("label", &self.label) + .field("label_color", &self.label_color) + .finish() + } +} + +impl<Message> Checkbox<Message> { + /// Creates a new [`Checkbox`]. + /// + /// It expects: + /// * a boolean describing whether the [`Checkbox`] is checked or not + /// * the label of the [`Checkbox`] + /// * a function that will be called when the [`Checkbox`] is toggled. + /// It will receive the new state of the [`Checkbox`] and must produce + /// a `Message`. + /// + /// [`Checkbox`]: struct.Checkbox.html + pub fn new<F>(is_checked: bool, label: &str, f: F) -> Self + where + F: 'static + Fn(bool) -> Message, + { + Checkbox { + is_checked, + on_toggle: Box::new(f), + label: String::from(label), + label_color: None, + } + } + + /// Sets the color of the label of the [`Checkbox`]. + /// + /// [`Checkbox`]: struct.Checkbox.html + pub fn label_color<C: Into<Color>>(mut self, color: C) -> Self { + self.label_color = Some(color.into()); + self + } +} diff --git a/core/src/widget/column.rs b/core/src/widget/column.rs new file mode 100644 index 00000000..2df327a0 --- /dev/null +++ b/core/src/widget/column.rs @@ -0,0 +1,147 @@ +use crate::{Align, Justify, Length}; + +/// A container that distributes its contents vertically. +/// +/// A [`Column`] will try to fill the horizontal space of its container. +/// +/// [`Column`]: struct.Column.html +pub struct Column<Element> { + pub spacing: u16, + pub padding: u16, + pub width: Length, + pub height: Length, + pub max_width: Length, + pub max_height: Length, + pub align_self: Option<Align>, + pub align_items: Align, + pub justify_content: Justify, + pub children: Vec<Element>, +} + +impl<Element> Column<Element> { + /// Creates an empty [`Column`]. + /// + /// [`Column`]: struct.Column.html + pub fn new() -> Self { + Column { + spacing: 0, + padding: 0, + width: Length::Fill, + height: Length::Shrink, + max_width: Length::Shrink, + max_height: Length::Shrink, + align_self: None, + align_items: Align::Start, + justify_content: Justify::Start, + children: Vec::new(), + } + } + + /// Sets the vertical spacing _between_ elements. + /// + /// Custom margins per element do not exist in Iced. You should use this + /// method instead! While less flexible, it helps you keep spacing between + /// elements consistent. + pub fn spacing(mut self, units: u16) -> Self { + self.spacing = units; + self + } + + /// Sets the padding of the [`Column`]. + /// + /// [`Column`]: struct.Column.html + pub fn padding(mut self, units: u16) -> Self { + self.padding = units; + self + } + + /// Sets the width of the [`Column`]. + /// + /// [`Column`]: struct.Column.html + pub fn width(mut self, width: Length) -> Self { + self.width = width; + self + } + + /// Sets the height of the [`Column`]. + /// + /// [`Column`]: struct.Column.html + pub fn height(mut self, height: Length) -> Self { + self.height = height; + self + } + + /// Sets the maximum width of the [`Column`]. + /// + /// [`Column`]: struct.Column.html + pub fn max_width(mut self, max_width: Length) -> Self { + self.max_width = max_width; + self + } + + /// Sets the maximum height of the [`Column`] in pixels. + /// + /// [`Column`]: struct.Column.html + pub fn max_height(mut self, max_height: Length) -> Self { + self.max_height = max_height; + self + } + + /// Sets the alignment of the [`Column`] itself. + /// + /// This is useful if you want to override the default alignment given by + /// the parent container. + /// + /// [`Column`]: struct.Column.html + pub fn align_self(mut self, align: Align) -> Self { + self.align_self = Some(align); + self + } + + /// Sets the horizontal alignment of the contents of the [`Column`] . + /// + /// [`Column`]: struct.Column.html + pub fn align_items(mut self, align: Align) -> Self { + self.align_items = align; + self + } + + /// Sets the vertical distribution strategy for the contents of the + /// [`Column`] . + /// + /// [`Column`]: struct.Column.html + pub fn justify_content(mut self, justify: Justify) -> Self { + self.justify_content = justify; + self + } + + /// Adds an element to the [`Column`]. + /// + /// [`Column`]: struct.Column.html + pub fn push<E>(mut self, child: E) -> Column<Element> + where + E: Into<Element>, + { + self.children.push(child.into()); + self + } +} + +impl<Element> Default for Column<Element> { + fn default() -> Self { + Self::new() + } +} + +impl<Element> std::fmt::Debug for Column<Element> +where + Element: std::fmt::Debug, +{ + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + // TODO: Complete once stabilized + f.debug_struct("Column") + .field("spacing", &self.spacing) + .field("children", &self.children) + .finish() + } +} diff --git a/core/src/widget/image.rs b/core/src/widget/image.rs new file mode 100644 index 00000000..110ba99a --- /dev/null +++ b/core/src/widget/image.rs @@ -0,0 +1,89 @@ +//! Display images in your user interface. + +use crate::{Align, Length, Rectangle}; + +/// A frame that displays an image while keeping aspect ratio. +/// +/// # Example +/// +/// ``` +/// use iced_core::Image; +/// +/// # let my_handle = String::from("some_handle"); +/// let image = Image::new(my_handle); +/// ``` +pub struct Image<I> { + /// The image handle + pub handle: I, + + /// The part of the image to show + pub clip: Option<Rectangle<u16>>, + + /// The width of the image + pub width: Length, + + /// The height of the image + pub height: Length, + + pub align_self: Option<Align>, +} + +impl<I> std::fmt::Debug for Image<I> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Image") + .field("clip", &self.clip) + .field("width", &self.width) + .field("height", &self.height) + .finish() + } +} + +impl<I> Image<I> { + /// Creates a new [`Image`] with given image handle. + /// + /// [`Image`]: struct.Image.html + pub fn new(handle: I) -> Self { + Image { + handle, + clip: None, + width: Length::Shrink, + height: Length::Shrink, + align_self: None, + } + } + + /// Sets the portion of the [`Image`] to draw. + /// + /// [`Image`]: struct.Image.html + pub fn clip(mut self, clip: Rectangle<u16>) -> Self { + self.clip = Some(clip); + self + } + + /// Sets the width of the [`Image`] boundaries. + /// + /// [`Image`]: struct.Image.html + pub fn width(mut self, width: Length) -> Self { + self.width = width; + self + } + + /// Sets the height of the [`Image`] boundaries. + /// + /// [`Image`]: struct.Image.html + pub fn height(mut self, height: Length) -> Self { + self.height = height; + self + } + + /// Sets the alignment of the [`Image`] itself. + /// + /// This is useful if you want to override the default alignment given by + /// the parent container. + /// + /// [`Image`]: struct.Image.html + pub fn align_self(mut self, align: Align) -> Self { + self.align_self = Some(align); + self + } +} diff --git a/core/src/widget/radio.rs b/core/src/widget/radio.rs new file mode 100644 index 00000000..9765e928 --- /dev/null +++ b/core/src/widget/radio.rs @@ -0,0 +1,88 @@ +//! Create choices using radio buttons. +use crate::Color; + +/// A circular button representing a choice. +/// +/// # Example +/// ``` +/// use iced_core::Radio; +/// +/// #[derive(Debug, Clone, Copy, PartialEq, Eq)] +/// pub enum Choice { +/// A, +/// B, +/// } +/// +/// #[derive(Debug, Clone, Copy)] +/// pub enum Message { +/// RadioSelected(Choice), +/// } +/// +/// let selected_choice = Some(Choice::A); +/// +/// Radio::new(Choice::A, "This is A", selected_choice, Message::RadioSelected); +/// +/// Radio::new(Choice::B, "This is B", selected_choice, Message::RadioSelected); +/// ``` +/// +///  +pub struct Radio<Message> { + /// Whether the radio button is selected or not + pub is_selected: bool, + + /// The message to produce when the radio button is clicked + pub on_click: Message, + + /// The label of the radio button + pub label: String, + + /// The color of the label + pub label_color: Option<Color>, +} + +impl<Message> std::fmt::Debug for Radio<Message> +where + Message: std::fmt::Debug, +{ + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Radio") + .field("is_selected", &self.is_selected) + .field("on_click", &self.on_click) + .field("label", &self.label) + .field("label_color", &self.label_color) + .finish() + } +} + +impl<Message> Radio<Message> { + /// Creates a new [`Radio`] button. + /// + /// It expects: + /// * the value related to the [`Radio`] button + /// * the label of the [`Radio`] button + /// * the current selected value + /// * a function that will be called when the [`Radio`] is selected. It + /// receives the value of the radio and must produce a `Message`. + /// + /// [`Radio`]: struct.Radio.html + pub fn new<F, V>(value: V, label: &str, selected: Option<V>, f: F) -> Self + where + V: Eq + Copy, + F: 'static + Fn(V) -> Message, + { + Radio { + is_selected: Some(value) == selected, + on_click: f(value), + label: String::from(label), + label_color: None, + } + } + + /// Sets the `Color` of the label of the [`Radio`]. + /// + /// [`Radio`]: struct.Radio.html + pub fn label_color<C: Into<Color>>(mut self, color: C) -> Self { + self.label_color = Some(color.into()); + self + } +} diff --git a/core/src/widget/row.rs b/core/src/widget/row.rs new file mode 100644 index 00000000..6bdb4ed2 --- /dev/null +++ b/core/src/widget/row.rs @@ -0,0 +1,142 @@ +use crate::{Align, Justify, Length}; + +/// A container that distributes its contents horizontally. +/// +/// A [`Row`] will try to fill the horizontal space of its container. +/// +/// [`Row`]: struct.Row.html +pub struct Row<Element> { + pub spacing: u16, + pub padding: u16, + pub width: Length, + pub height: Length, + pub max_width: Length, + pub max_height: Length, + pub align_self: Option<Align>, + pub align_items: Align, + pub justify_content: Justify, + pub children: Vec<Element>, +} + +impl<Element> Row<Element> { + /// Creates an empty [`Row`]. + /// + /// [`Row`]: struct.Row.html + pub fn new() -> Self { + Row { + spacing: 0, + padding: 0, + width: Length::Fill, + height: Length::Shrink, + max_width: Length::Shrink, + max_height: Length::Shrink, + align_self: None, + align_items: Align::Start, + justify_content: Justify::Start, + children: Vec::new(), + } + } + + /// Sets the horizontal spacing _between_ elements. + /// + /// Custom margins per element do not exist in Iced. You should use this + /// method instead! While less flexible, it helps you keep spacing between + /// elements consistent. + pub fn spacing(mut self, units: u16) -> Self { + self.spacing = units; + self + } + + /// Sets the padding of the [`Row`]. + /// + /// [`Row`]: struct.Row.html + pub fn padding(mut self, units: u16) -> Self { + self.padding = units; + self + } + + /// Sets the width of the [`Row`]. + /// + /// [`Row`]: struct.Row.html + pub fn width(mut self, width: Length) -> Self { + self.width = width; + self + } + + /// Sets the height of the [`Row`]. + /// + /// [`Row`]: struct.Row.html + pub fn height(mut self, height: Length) -> Self { + self.height = height; + self + } + + /// Sets the maximum width of the [`Row`]. + /// + /// [`Row`]: struct.Row.html + pub fn max_width(mut self, max_width: Length) -> Self { + self.max_width = max_width; + self + } + + /// Sets the maximum height of the [`Row`]. + /// + /// [`Row`]: struct.Row.html + pub fn max_height(mut self, max_height: Length) -> Self { + self.max_height = max_height; + self + } + + /// Sets the alignment of the [`Row`] itself. + /// + /// This is useful if you want to override the default alignment given by + /// the parent container. + /// + /// [`Row`]: struct.Row.html + pub fn align_self(mut self, align: Align) -> Self { + self.align_self = Some(align); + self + } + + /// Sets the vertical alignment of the contents of the [`Row`] . + /// + /// [`Row`]: struct.Row.html + pub fn align_items(mut self, align: Align) -> Self { + self.align_items = align; + self + } + + /// Sets the horizontal distribution strategy for the contents of the + /// [`Row`] . + /// + /// [`Row`]: struct.Row.html + pub fn justify_content(mut self, justify: Justify) -> Self { + self.justify_content = justify; + self + } + + /// Adds an [`Element`] to the [`Row`]. + /// + /// [`Element`]: ../struct.Element.html + /// [`Row`]: struct.Row.html + pub fn push<E>(mut self, child: E) -> Row<Element> + where + E: Into<Element>, + { + self.children.push(child.into()); + self + } +} + +impl<Element> std::fmt::Debug for Row<Element> +where + Element: std::fmt::Debug, +{ + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + // TODO: Complete once stabilized + f.debug_struct("Row") + .field("spacing", &self.spacing) + .field("children", &self.children) + .finish() + } +} diff --git a/core/src/widget/slider.rs b/core/src/widget/slider.rs new file mode 100644 index 00000000..b65e3991 --- /dev/null +++ b/core/src/widget/slider.rs @@ -0,0 +1,123 @@ +//! Display an interactive selector of a single value from a range of values. +//! +//! A [`Slider`] has some local [`State`]. +//! +//! [`Slider`]: struct.Slider.html +//! [`State`]: struct.State.html +use crate::Length; + +use std::ops::RangeInclusive; +use std::rc::Rc; + +/// An horizontal bar and a handle that selects a single value from a range of +/// values. +/// +/// A [`Slider`] will try to fill the horizontal space of its container. +/// +/// [`Slider`]: struct.Slider.html +/// +/// # Example +/// ``` +/// use iced_core::{slider, Slider}; +/// +/// pub enum Message { +/// SliderChanged(f32), +/// } +/// +/// let state = &mut slider::State::new(); +/// let value = 50.0; +/// +/// Slider::new(state, 0.0..=100.0, value, Message::SliderChanged); +/// ``` +/// +///  +pub struct Slider<'a, Message> { + /// The state of the slider + pub state: &'a mut State, + + /// The range of the slider + pub range: RangeInclusive<f32>, + + /// The current value of the slider + pub value: f32, + + /// The function to produce messages on change + pub on_change: Rc<Box<dyn Fn(f32) -> Message>>, + + pub width: Length, +} + +impl<'a, Message> std::fmt::Debug for Slider<'a, Message> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Slider") + .field("state", &self.state) + .field("range", &self.range) + .field("value", &self.value) + .finish() + } +} + +impl<'a, Message> Slider<'a, Message> { + /// Creates a new [`Slider`]. + /// + /// It expects: + /// * the local [`State`] of the [`Slider`] + /// * an inclusive range of possible values + /// * the current value of the [`Slider`] + /// * a function that will be called when the [`Slider`] is dragged. + /// It receives the new value of the [`Slider`] and must produce a + /// `Message`. + /// + /// [`Slider`]: struct.Slider.html + /// [`State`]: struct.State.html + pub fn new<F>( + state: &'a mut State, + range: RangeInclusive<f32>, + value: f32, + on_change: F, + ) -> Self + where + F: 'static + Fn(f32) -> Message, + { + Slider { + state, + value: value.max(*range.start()).min(*range.end()), + range, + on_change: Rc::new(Box::new(on_change)), + width: Length::Fill, + } + } + + /// Sets the width of the [`Slider`]. + /// + /// [`Slider`]: struct.Slider.html + pub fn width(mut self, width: Length) -> Self { + self.width = width; + self + } +} + +/// The local state of a [`Slider`]. +/// +/// [`Slider`]: struct.Slider.html +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct State { + pub is_dragging: bool, +} + +impl State { + /// Creates a new [`State`]. + /// + /// [`State`]: struct.State.html + pub fn new() -> State { + State::default() + } + + /// Returns whether the associated [`Slider`] is currently being dragged or + /// not. + /// + /// [`Slider`]: struct.Slider.html + pub fn is_dragging(&self) -> bool { + self.is_dragging + } +} diff --git a/core/src/widget/text.rs b/core/src/widget/text.rs new file mode 100644 index 00000000..427d9471 --- /dev/null +++ b/core/src/widget/text.rs @@ -0,0 +1,119 @@ +//! Write some text for your users to read. +use crate::{Color, Length}; + +/// A paragraph of text. +/// +/// # Example +/// +/// ``` +/// use iced_core::Text; +/// +/// Text::new("I <3 iced!") +/// .size(40); +/// ``` +#[derive(Debug, Clone)] +pub struct Text { + pub content: String, + pub size: Option<u16>, + pub color: Option<Color>, + pub width: Length, + pub height: Length, + pub horizontal_alignment: HorizontalAlignment, + pub vertical_alignment: VerticalAlignment, +} + +impl Text { + /// Create a new fragment of [`Text`] with the given contents. + /// + /// [`Text`]: struct.Text.html + pub fn new(label: &str) -> Self { + Text { + content: String::from(label), + size: None, + color: None, + width: Length::Fill, + height: Length::Shrink, + horizontal_alignment: HorizontalAlignment::Left, + vertical_alignment: VerticalAlignment::Top, + } + } + + /// Sets the size of the [`Text`]. + /// + /// [`Text`]: struct.Text.html + pub fn size(mut self, size: u16) -> Self { + self.size = Some(size); + self + } + + /// Sets the `Color` of the [`Text`]. + /// + /// [`Text`]: struct.Text.html + pub fn color<C: Into<Color>>(mut self, color: C) -> Self { + self.color = Some(color.into()); + self + } + + /// Sets the width of the [`Text`] boundaries. + /// + /// [`Text`]: struct.Text.html + pub fn width(mut self, width: Length) -> Self { + self.width = width; + self + } + + /// Sets the height of the [`Text`] boundaries. + /// + /// [`Text`]: struct.Text.html + pub fn height(mut self, height: Length) -> Self { + self.height = height; + self + } + + /// Sets the [`HorizontalAlignment`] of the [`Text`]. + /// + /// [`Text`]: struct.Text.html + /// [`HorizontalAlignment`]: enum.HorizontalAlignment.html + pub fn horizontal_alignment( + mut self, + alignment: HorizontalAlignment, + ) -> Self { + self.horizontal_alignment = alignment; + self + } + + /// Sets the [`VerticalAlignment`] of the [`Text`]. + /// + /// [`Text`]: struct.Text.html + /// [`VerticalAlignment`]: enum.VerticalAlignment.html + pub fn vertical_alignment(mut self, alignment: VerticalAlignment) -> Self { + self.vertical_alignment = alignment; + self + } +} + +/// The horizontal alignment of some resource. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum HorizontalAlignment { + /// Align left + Left, + + /// Horizontally centered + Center, + + /// Align right + Right, +} + +/// The vertical alignment of some resource. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum VerticalAlignment { + /// Align top + Top, + + /// Vertically centered + Center, + + /// Align bottom + Bottom, +} diff --git a/examples/tour/Cargo.toml b/examples/tour/Cargo.toml index 08d108d9..a0e3eee8 100644 --- a/examples/tour/Cargo.toml +++ b/examples/tour/Cargo.toml @@ -16,7 +16,7 @@ path = "src/iced_ggez/main.rs" futures-preview = "=0.3.0-alpha.18" [target.'cfg(not(target_arch = "wasm32"))'.dependencies] -iced = { path = "../.." } +iced_native = { version = "0.1.0-alpha", path = "../../native" } # A personal `ggez` fork that introduces a `FontCache` type to measure text # efficiently and fixes HiDPI issues. ggez = { version = "0.5", git = "https://github.com/hecrj/ggez.git" } diff --git a/examples/tour/src/iced_ggez/main.rs b/examples/tour/src/iced_ggez/main.rs index a8cf09e5..72774d38 100644 --- a/examples/tour/src/iced_ggez/main.rs +++ b/examples/tour/src/iced_ggez/main.rs @@ -35,8 +35,8 @@ struct Game { images: iced_ggez::ImageCache, tour: Tour, - events: Vec<iced::Event>, - cache: Option<iced::Cache>, + events: Vec<iced_native::Event>, + cache: Option<iced_native::Cache>, } impl Game { @@ -52,7 +52,7 @@ impl Game { tour: Tour::new(), events: Vec::new(), - cache: Some(iced::Cache::default()), + cache: Some(iced_native::Cache::default()), }) } } @@ -69,10 +69,10 @@ impl event::EventHandler for Game { _x: f32, _y: f32, ) { - self.events.push(iced::Event::Mouse( - iced::input::mouse::Event::Input { - state: iced::input::ButtonState::Pressed, - button: iced::input::mouse::Button::Left, // TODO: Map `button` + self.events.push(iced_native::Event::Mouse( + iced_native::input::mouse::Event::Input { + state: iced_native::input::ButtonState::Pressed, + button: iced_native::input::mouse::Button::Left, // TODO: Map `button` }, )); } @@ -84,10 +84,10 @@ impl event::EventHandler for Game { _x: f32, _y: f32, ) { - self.events.push(iced::Event::Mouse( - iced::input::mouse::Event::Input { - state: iced::input::ButtonState::Released, - button: iced::input::mouse::Button::Left, // TODO: Map `button` + self.events.push(iced_native::Event::Mouse( + iced_native::input::mouse::Event::Input { + state: iced_native::input::ButtonState::Released, + button: iced_native::input::mouse::Button::Left, // TODO: Map `button` }, )); } @@ -100,8 +100,8 @@ impl event::EventHandler for Game { _dx: f32, _dy: f32, ) { - self.events.push(iced::Event::Mouse( - iced::input::mouse::Event::CursorMoved { x, y }, + self.events.push(iced_native::Event::Mouse( + iced_native::input::mouse::Event::CursorMoved { x, y }, )); } @@ -132,11 +132,11 @@ impl event::EventHandler for Game { let view = self.tour.view(); let content = iced_ggez::Column::new() - .width(screen.w as u16) - .height(screen.h as u16) + .width(iced_native::Length::Units(screen.w as u16)) + .height(iced_native::Length::Units(screen.h as u16)) .padding(20) - .align_items(iced::Align::Center) - .justify_content(iced::Justify::Center) + .align_items(iced_native::Align::Center) + .justify_content(iced_native::Justify::Center) .push(view); let renderer = &mut iced_ggez::Renderer::new( @@ -146,7 +146,7 @@ impl event::EventHandler for Game { self.font, ); - let mut ui = iced::UserInterface::build( + let mut ui = iced_native::UserInterface::build( content, self.cache.take().unwrap(), renderer, @@ -177,13 +177,13 @@ impl event::EventHandler for Game { } } -fn into_cursor_type(cursor: iced::MouseCursor) -> mouse::MouseCursor { +fn into_cursor_type(cursor: iced_native::MouseCursor) -> mouse::MouseCursor { match cursor { - iced::MouseCursor::OutOfBounds => mouse::MouseCursor::Default, - iced::MouseCursor::Idle => mouse::MouseCursor::Default, - iced::MouseCursor::Pointer => mouse::MouseCursor::Hand, - iced::MouseCursor::Working => mouse::MouseCursor::Progress, - iced::MouseCursor::Grab => mouse::MouseCursor::Grab, - iced::MouseCursor::Grabbing => mouse::MouseCursor::Grabbing, + iced_native::MouseCursor::OutOfBounds => mouse::MouseCursor::Default, + iced_native::MouseCursor::Idle => mouse::MouseCursor::Default, + iced_native::MouseCursor::Pointer => mouse::MouseCursor::Hand, + iced_native::MouseCursor::Working => mouse::MouseCursor::Progress, + iced_native::MouseCursor::Grab => mouse::MouseCursor::Grab, + iced_native::MouseCursor::Grabbing => mouse::MouseCursor::Grabbing, } } diff --git a/examples/tour/src/iced_ggez/renderer.rs b/examples/tour/src/iced_ggez/renderer.rs index e3181eaa..c0e6d559 100644 --- a/examples/tour/src/iced_ggez/renderer.rs +++ b/examples/tour/src/iced_ggez/renderer.rs @@ -67,7 +67,7 @@ impl<'a> Renderer<'a> { } } -pub fn into_color(color: iced::Color) -> graphics::Color { +pub fn into_color(color: iced_native::Color) -> graphics::Color { graphics::Color { r: color.r, g: color.g, diff --git a/examples/tour/src/iced_ggez/renderer/button.rs b/examples/tour/src/iced_ggez/renderer/button.rs index 486e07ed..78a5de07 100644 --- a/examples/tour/src/iced_ggez/renderer/button.rs +++ b/examples/tour/src/iced_ggez/renderer/button.rs @@ -2,7 +2,7 @@ use super::Renderer; use ggez::graphics::{ self, Align, Color, DrawParam, Rect, Scale, Text, TextFragment, WHITE, }; -use iced::{button, MouseCursor}; +use iced_native::{button, Button, Layout, Length, MouseCursor, Node, Style}; const LEFT: Rect = Rect { x: 0.0, @@ -26,20 +26,29 @@ const RIGHT: Rect = Rect { }; impl button::Renderer for Renderer<'_> { - fn draw( + fn node<Message>(&self, button: &Button<'_, Message>) -> Node { + let style = Style::default() + .width(button.width) + .height(Length::Units(LEFT.h as u16)) + .min_width(Length::Units(100)) + .align_self(button.align_self); + + Node::new(style) + } + + fn draw<Message>( &mut self, - cursor_position: iced::Point, - mut bounds: iced::Rectangle, - state: &button::State, - label: &str, - class: button::Class, + button: &Button<'_, Message>, + layout: Layout<'_>, + cursor_position: iced_native::Point, ) -> MouseCursor { + let mut bounds = layout.bounds(); let mouse_over = bounds.contains(cursor_position); let mut state_offset = 0.0; if mouse_over { - if state.is_pressed() { + if button.state.is_pressed() { bounds.y += 4.0; state_offset = RIGHT.x + RIGHT.w; } else { @@ -47,7 +56,7 @@ impl button::Renderer for Renderer<'_> { } } - let class_index = match class { + let class_index = match button.class { button::Class::Primary => 0, button::Class::Secondary => 1, button::Class::Positive => 2, @@ -103,7 +112,7 @@ impl button::Renderer for Renderer<'_> { }); let mut text = Text::new(TextFragment { - text: String::from(label), + text: button.label.clone(), font: Some(self.font), scale: Some(Scale { x: 20.0, y: 20.0 }), ..Default::default() diff --git a/examples/tour/src/iced_ggez/renderer/checkbox.rs b/examples/tour/src/iced_ggez/renderer/checkbox.rs index 20a91be5..807185d9 100644 --- a/examples/tour/src/iced_ggez/renderer/checkbox.rs +++ b/examples/tour/src/iced_ggez/renderer/checkbox.rs @@ -1,7 +1,10 @@ use super::Renderer; use ggez::graphics::{DrawParam, Rect}; -use iced::{checkbox, MouseCursor}; +use iced_native::{ + checkbox, text, Align, Checkbox, Column, Layout, Length, MouseCursor, Node, + Row, Text, Widget, +}; const SPRITE: Rect = Rect { x: 98.0, @@ -10,14 +13,41 @@ const SPRITE: Rect = Rect { h: 28.0, }; -impl checkbox::Renderer for Renderer<'_> { - fn draw( +impl checkbox::Renderer for Renderer<'_> +where + Self: text::Renderer, +{ + fn node<Message>(&mut self, checkbox: &Checkbox<Message>) -> Node { + Row::<(), Self>::new() + .spacing(15) + .align_items(Align::Center) + .push( + Column::new() + .width(Length::Units(SPRITE.w as u16)) + .height(Length::Units(SPRITE.h as u16)), + ) + .push(Text::new(&checkbox.label)) + .node(self) + } + + fn draw<Message>( &mut self, - cursor_position: iced::Point, - bounds: iced::Rectangle, - text_bounds: iced::Rectangle, - is_checked: bool, + checkbox: &Checkbox<Message>, + layout: Layout<'_>, + cursor_position: iced_native::Point, ) -> MouseCursor { + let bounds = layout.bounds(); + let children: Vec<_> = layout.children().collect(); + let text_bounds = children[1].bounds(); + + let mut text = Text::new(&checkbox.label); + + if let Some(label_color) = checkbox.label_color { + text = text.color(label_color); + } + + text::Renderer::draw(self, &text, children[1]); + let mouse_over = bounds.contains(cursor_position) || text_bounds.contains(cursor_position); @@ -39,7 +69,7 @@ impl checkbox::Renderer for Renderer<'_> { ..DrawParam::default() }); - if is_checked { + if checkbox.is_checked { self.sprites.add(DrawParam { src: Rect { x: (SPRITE.x + SPRITE.w * 2.0) / width, diff --git a/examples/tour/src/iced_ggez/renderer/debugger.rs b/examples/tour/src/iced_ggez/renderer/debugger.rs index eba03ebf..ffb658af 100644 --- a/examples/tour/src/iced_ggez/renderer/debugger.rs +++ b/examples/tour/src/iced_ggez/renderer/debugger.rs @@ -1,8 +1,12 @@ use super::{into_color, Renderer}; use ggez::graphics::{DrawMode, MeshBuilder, Rect}; -impl iced::renderer::Debugger for Renderer<'_> { - fn explain(&mut self, layout: &iced::Layout<'_>, color: iced::Color) { +impl iced_native::renderer::Debugger for Renderer<'_> { + fn explain( + &mut self, + layout: &iced_native::Layout<'_>, + color: iced_native::Color, + ) { let bounds = layout.bounds(); let mut debug_mesh = diff --git a/examples/tour/src/iced_ggez/renderer/image.rs b/examples/tour/src/iced_ggez/renderer/image.rs index 17c6a56e..b12b65c3 100644 --- a/examples/tour/src/iced_ggez/renderer/image.rs +++ b/examples/tour/src/iced_ggez/renderer/image.rs @@ -1,7 +1,7 @@ use super::Renderer; use ggez::{graphics, nalgebra}; -use iced::image; +use iced_native::{image, Image, Layout, Length, Style}; pub struct Cache { images: std::collections::HashMap<String, graphics::Image>, @@ -35,39 +35,29 @@ impl Cache { } impl<'a> image::Renderer<&'a str> for Renderer<'_> { - fn node( - &mut self, - style: iced::Style, - name: &&'a str, - width: Option<u16>, - height: Option<u16>, - _source: Option<iced::Rectangle<u16>>, - ) -> iced::Node { - let image = self.images.get(name, self.context); + fn node(&mut self, image: &Image<&'a str>) -> iced_native::Node { + let ggez_image = self.images.get(image.handle, self.context); + + let aspect_ratio = + ggez_image.width() as f32 / ggez_image.height() as f32; - let aspect_ratio = image.width() as f32 / image.height() as f32; + let mut style = Style::default().align_self(image.align_self); - let style = match (width, height) { - (Some(width), Some(height)) => style.width(width).height(height), - (Some(width), None) => style - .width(width) - .height((width as f32 / aspect_ratio).round() as u16), - (None, Some(height)) => style - .height(height) - .width((height as f32 * aspect_ratio).round() as u16), - (None, None) => style.width(image.width()).height(image.height()), + style = match (image.width, image.height) { + (Length::Units(width), _) => style.width(image.width).height( + Length::Units((width as f32 / aspect_ratio).round() as u16), + ), + (_, _) => style + .width(Length::Units(ggez_image.width())) + .height(Length::Units(ggez_image.height())), }; - iced::Node::new(style) + iced_native::Node::new(style) } - fn draw( - &mut self, - name: &&'a str, - bounds: iced::Rectangle, - _source: Option<iced::Rectangle<u16>>, - ) { - let image = self.images.get(name, self.context); + fn draw(&mut self, image: &Image<&'a str>, layout: Layout<'_>) { + let image = self.images.get(image.handle, self.context); + let bounds = layout.bounds(); // We should probably use batches to draw images efficiently and keep // draw side-effect free, but this is good enough for the example. diff --git a/examples/tour/src/iced_ggez/renderer/radio.rs b/examples/tour/src/iced_ggez/renderer/radio.rs index 0f7815d6..dbd29ecd 100644 --- a/examples/tour/src/iced_ggez/renderer/radio.rs +++ b/examples/tour/src/iced_ggez/renderer/radio.rs @@ -1,7 +1,10 @@ use super::Renderer; use ggez::graphics::{DrawParam, Rect}; -use iced::{radio, MouseCursor, Point, Rectangle}; +use iced_native::{ + radio, text, Align, Column, Layout, Length, MouseCursor, Node, Point, + Radio, Row, Text, Widget, +}; const SPRITE: Rect = Rect { x: 98.0, @@ -10,15 +13,41 @@ const SPRITE: Rect = Rect { h: 28.0, }; -impl radio::Renderer for Renderer<'_> { - fn draw( +impl radio::Renderer for Renderer<'_> +where + Self: text::Renderer, +{ + fn node<Message>(&mut self, radio: &Radio<Message>) -> Node { + Row::<(), Self>::new() + .spacing(15) + .align_items(Align::Center) + .push( + Column::new() + .width(Length::Units(SPRITE.w as u16)) + .height(Length::Units(SPRITE.h as u16)), + ) + .push(Text::new(&radio.label)) + .node(self) + } + + fn draw<Message>( &mut self, + radio: &Radio<Message>, + layout: Layout<'_>, cursor_position: Point, - bounds: Rectangle, - bounds_with_label: Rectangle, - is_selected: bool, ) -> MouseCursor { - let mouse_over = bounds_with_label.contains(cursor_position); + let children: Vec<_> = layout.children().collect(); + + let mut text = Text::new(&radio.label); + + if let Some(label_color) = radio.label_color { + text = text.color(label_color); + } + + text::Renderer::draw(self, &text, children[1]); + + let bounds = layout.bounds(); + let mouse_over = bounds.contains(cursor_position); let width = self.spritesheet.width() as f32; let height = self.spritesheet.height() as f32; @@ -38,7 +67,7 @@ impl radio::Renderer for Renderer<'_> { ..DrawParam::default() }); - if is_selected { + if radio.is_selected { self.sprites.add(DrawParam { src: Rect { x: (SPRITE.x + SPRITE.w * 2.0) / width, diff --git a/examples/tour/src/iced_ggez/renderer/slider.rs b/examples/tour/src/iced_ggez/renderer/slider.rs index 146cee18..60c40c55 100644 --- a/examples/tour/src/iced_ggez/renderer/slider.rs +++ b/examples/tour/src/iced_ggez/renderer/slider.rs @@ -1,8 +1,9 @@ use super::Renderer; use ggez::graphics::{DrawParam, Rect}; -use iced::{slider, MouseCursor, Point, Rectangle}; -use std::ops::RangeInclusive; +use iced_native::{ + slider, Layout, Length, MouseCursor, Node, Point, Slider, Style, +}; const RAIL: Rect = Rect { x: 98.0, @@ -19,14 +20,22 @@ const MARKER: Rect = Rect { }; impl slider::Renderer for Renderer<'_> { - fn draw( + fn node<Message>(&self, slider: &Slider<'_, Message>) -> Node { + let style = Style::default() + .width(slider.width) + .height(Length::Units(25)) + .min_width(Length::Units(100)); + + Node::new(style) + } + + fn draw<Message>( &mut self, + slider: &Slider<'_, Message>, + layout: Layout<'_>, cursor_position: Point, - bounds: Rectangle, - state: &slider::State, - range: RangeInclusive<f32>, - value: f32, ) -> MouseCursor { + let bounds = layout.bounds(); let width = self.spritesheet.width() as f32; let height = self.spritesheet.height() as f32; @@ -48,13 +57,14 @@ impl slider::Renderer for Renderer<'_> { ..DrawParam::default() }); - let (range_start, range_end) = range.into_inner(); + let (range_start, range_end) = slider.range.clone().into_inner(); let marker_offset = (bounds.width - MARKER.w as f32) - * ((value - range_start) / (range_end - range_start).max(1.0)); + * ((slider.value - range_start) + / (range_end - range_start).max(1.0)); let mouse_over = bounds.contains(cursor_position); - let is_active = state.is_dragging() || mouse_over; + let is_active = slider.state.is_dragging() || mouse_over; self.sprites.add(DrawParam { src: Rect { @@ -66,12 +76,13 @@ impl slider::Renderer for Renderer<'_> { }, dest: ggez::mint::Point2 { x: bounds.x + marker_offset.round(), - y: bounds.y + (if state.is_dragging() { 2.0 } else { 0.0 }), + y: bounds.y + + (if slider.state.is_dragging() { 2.0 } else { 0.0 }), }, ..DrawParam::default() }); - if state.is_dragging() { + if slider.state.is_dragging() { MouseCursor::Grabbing } else if mouse_over { MouseCursor::Grab diff --git a/examples/tour/src/iced_ggez/renderer/text.rs b/examples/tour/src/iced_ggez/renderer/text.rs index 450ca2cd..b51cc220 100644 --- a/examples/tour/src/iced_ggez/renderer/text.rs +++ b/examples/tour/src/iced_ggez/renderer/text.rs @@ -1,20 +1,15 @@ use super::{into_color, Renderer}; use ggez::graphics::{self, mint, Align, Scale, Text, TextFragment}; -use iced::text; +use iced_native::{text, Layout, Node, Style}; use std::cell::RefCell; use std::f32; impl text::Renderer for Renderer<'_> { - fn node( - &self, - style: iced::Style, - content: &str, - size: Option<u16>, - ) -> iced::Node { + fn node(&self, text: &iced_native::Text) -> Node { let font = self.font; let font_cache = graphics::font_cache(self.context); - let content = String::from(content); + let content = String::from(&text.content); // TODO: Investigate why stretch tries to measure this MANY times // with every ancestor's bounds. @@ -23,20 +18,22 @@ impl text::Renderer for Renderer<'_> { // I noticed that the first measure is the one that matters in // practice. Here, we use a RefCell to store the cached measurement. let measure = RefCell::new(None); - let size = size.map(f32::from).unwrap_or(self.font_size); + let size = text.size.map(f32::from).unwrap_or(self.font_size); - iced::Node::with_measure(style, move |bounds| { + let style = Style::default().width(text.width); + + iced_native::Node::with_measure(style, move |bounds| { let mut measure = measure.borrow_mut(); if measure.is_none() { let bounds = ( match bounds.width { - iced::Number::Undefined => f32::INFINITY, - iced::Number::Defined(w) => w, + iced_native::Number::Undefined => f32::INFINITY, + iced_native::Number::Defined(w) => w, }, match bounds.height { - iced::Number::Undefined => f32::INFINITY, - iced::Number::Defined(h) => h, + iced_native::Number::Undefined => f32::INFINITY, + iced_native::Number::Defined(h) => h, }, ); @@ -57,7 +54,7 @@ impl text::Renderer for Renderer<'_> { let (width, height) = font_cache.dimensions(&text); - let size = iced::Size { + let size = iced_native::Size { width: width as f32, height: height as f32, }; @@ -75,30 +72,23 @@ impl text::Renderer for Renderer<'_> { }) } - fn draw( - &mut self, - bounds: iced::Rectangle, - content: &str, - size: Option<u16>, - color: Option<iced::Color>, - horizontal_alignment: text::HorizontalAlignment, - _vertical_alignment: text::VerticalAlignment, - ) { - let size = size.map(f32::from).unwrap_or(self.font_size); - - let mut text = Text::new(TextFragment { - text: String::from(content), + fn draw(&mut self, text: &iced_native::Text, layout: Layout<'_>) { + let size = text.size.map(f32::from).unwrap_or(self.font_size); + let bounds = layout.bounds(); + + let mut ggez_text = Text::new(TextFragment { + text: text.content.clone(), font: Some(self.font), scale: Some(Scale { x: size, y: size }), ..Default::default() }); - text.set_bounds( + ggez_text.set_bounds( mint::Point2 { x: bounds.width, y: bounds.height, }, - match horizontal_alignment { + match text.horizontal_alignment { text::HorizontalAlignment::Left => graphics::Align::Left, text::HorizontalAlignment::Center => graphics::Align::Center, text::HorizontalAlignment::Right => graphics::Align::Right, @@ -107,12 +97,14 @@ impl text::Renderer for Renderer<'_> { graphics::queue_text( self.context, - &text, + &ggez_text, mint::Point2 { x: bounds.x, y: bounds.y, }, - color.or(Some(iced::Color::BLACK)).map(into_color), + text.color + .or(Some(iced_native::Color::BLACK)) + .map(into_color), ); } } diff --git a/examples/tour/src/iced_ggez/widget.rs b/examples/tour/src/iced_ggez/widget.rs index c9f857f6..948f9fc6 100644 --- a/examples/tour/src/iced_ggez/widget.rs +++ b/examples/tour/src/iced_ggez/widget.rs @@ -1,11 +1,12 @@ use super::Renderer; -pub use iced::{ - button, slider, text, Align, Button, Checkbox, Color, Radio, Slider, Text, +pub use iced_native::{ + button, slider, text, Align, Button, Checkbox, Color, Length, Radio, + Slider, Text, }; -pub type Image<'a> = iced::Image<&'a str>; +pub type Image<'a> = iced_native::Image<&'a str>; -pub type Column<'a, Message> = iced::Column<'a, Message, Renderer<'a>>; -pub type Row<'a, Message> = iced::Row<'a, Message, Renderer<'a>>; -pub type Element<'a, Message> = iced::Element<'a, Message, Renderer<'a>>; +pub type Column<'a, Message> = iced_native::Column<'a, Message, Renderer<'a>>; +pub type Row<'a, Message> = iced_native::Row<'a, Message, Renderer<'a>>; +pub type Element<'a, Message> = iced_native::Element<'a, Message, Renderer<'a>>; diff --git a/examples/tour/src/tour.rs b/examples/tour/src/tour.rs index 4bd7c8a3..fd9c2dde 100644 --- a/examples/tour/src/tour.rs +++ b/examples/tour/src/tour.rs @@ -1,6 +1,6 @@ use crate::widget::{ button, slider, text::HorizontalAlignment, Align, Button, Checkbox, Color, - Column, Element, Image, Radio, Row, Slider, Text, + Column, Element, Image, Length, Radio, Row, Slider, Text, }; pub struct Tour { @@ -16,7 +16,7 @@ impl Tour { steps: Steps::new(), back_button: button::State::new(), next_button: button::State::new(), - debug: false, + debug: true, } } @@ -61,7 +61,7 @@ impl Tour { } let element: Element<_> = Column::new() - .max_width(500) + .max_width(Length::Units(500)) .spacing(20) .push(steps.view(self.debug).map(Message::StepMessage)) .push(controls) @@ -478,7 +478,7 @@ impl<'a> Step { .push(Text::new("An image that tries to keep its aspect ratio.")) .push( Image::new("resources/ferris.png") - .width(width) + .width(Length::Units(width)) .align_self(Align::Center), ) .push(Slider::new( diff --git a/native/Cargo.toml b/native/Cargo.toml new file mode 100644 index 00000000..1dbccdee --- /dev/null +++ b/native/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "iced_native" +version = "0.1.0-alpha" +authors = ["Héctor Ramón Jiménez <hector0193@gmail.com>"] +edition = "2018" +description = "A renderer-agnostic library for native GUIs" +license = "MIT" +repository = "https://github.com/hecrj/iced" + +[package.metadata.docs.rs] +features = ["winit"] + +[dependencies] +iced_core = { version = "0.1.0-alpha", features = ["stretch"], path = "../core" } +stretch = "0.2" +twox-hash = "1.5" + +# Enable to obtain conversion traits +winit = { version = "0.20.0-alpha3", optional = true } diff --git a/src/element.rs b/native/src/element.rs index f6276fbf..dd5ce621 100644 --- a/src/element.rs +++ b/native/src/element.rs @@ -87,7 +87,7 @@ impl<'a, Message, Renderer> Element<'a, Message, Renderer> { /// /// ``` /// # mod counter { - /// # use iced::{button, Button}; + /// # use iced_native::{button, Button}; /// # /// # #[derive(Debug, Clone, Copy)] /// # pub enum Message {} @@ -101,19 +101,21 @@ impl<'a, Message, Renderer> Element<'a, Message, Renderer> { /// # } /// # /// # mod iced_wgpu { - /// # use iced::{ - /// # button, MouseCursor, Node, Point, Rectangle, Style, + /// # use iced_native::{ + /// # button, Button, MouseCursor, Node, Point, Rectangle, Style, Layout /// # }; /// # pub struct Renderer; /// # /// # impl button::Renderer for Renderer { - /// # fn draw( + /// # fn node<Message>(&self, _button: &Button<'_, Message>) -> Node { + /// # Node::new(Style::default()) + /// # } + /// # + /// # fn draw<Message>( /// # &mut self, + /// # _button: &Button<'_, Message>, + /// # _layout: Layout<'_>, /// # _cursor_position: Point, - /// # _bounds: Rectangle, - /// # _state: &button::State, - /// # _label: &str, - /// # _class: button::Class, /// # ) -> MouseCursor { /// # MouseCursor::OutOfBounds /// # } @@ -130,7 +132,7 @@ impl<'a, Message, Renderer> Element<'a, Message, Renderer> { /// # pub enum Message { /// # Counter(usize, counter::Message) /// # } - /// use iced::{Element, Row}; + /// use iced_native::{Element, Row}; /// use iced_wgpu::Renderer; /// /// impl ManyCounters { diff --git a/src/event.rs b/native/src/event.rs index 71f06006..71f06006 100644 --- a/src/event.rs +++ b/native/src/event.rs diff --git a/src/hasher.rs b/native/src/hasher.rs index 9f6aacce..9f6aacce 100644 --- a/src/hasher.rs +++ b/native/src/hasher.rs diff --git a/src/input.rs b/native/src/input.rs index 097fa730..097fa730 100644 --- a/src/input.rs +++ b/native/src/input.rs diff --git a/src/input/button_state.rs b/native/src/input/button_state.rs index e9dc05d7..e9dc05d7 100644 --- a/src/input/button_state.rs +++ b/native/src/input/button_state.rs diff --git a/src/input/keyboard.rs b/native/src/input/keyboard.rs index 57c24484..57c24484 100644 --- a/src/input/keyboard.rs +++ b/native/src/input/keyboard.rs diff --git a/src/input/keyboard/event.rs b/native/src/input/keyboard/event.rs index 8118f112..8118f112 100644 --- a/src/input/keyboard/event.rs +++ b/native/src/input/keyboard/event.rs diff --git a/src/input/keyboard/key_code.rs b/native/src/input/keyboard/key_code.rs index 207ddeac..207ddeac 100644 --- a/src/input/keyboard/key_code.rs +++ b/native/src/input/keyboard/key_code.rs diff --git a/src/input/mouse.rs b/native/src/input/mouse.rs index d37f5b96..d37f5b96 100644 --- a/src/input/mouse.rs +++ b/native/src/input/mouse.rs diff --git a/src/input/mouse/button.rs b/native/src/input/mouse/button.rs index 6320d701..6320d701 100644 --- a/src/input/mouse/button.rs +++ b/native/src/input/mouse/button.rs diff --git a/src/input/mouse/event.rs b/native/src/input/mouse/event.rs index 7b68208f..7b68208f 100644 --- a/src/input/mouse/event.rs +++ b/native/src/input/mouse/event.rs diff --git a/src/layout.rs b/native/src/layout.rs index de284a43..32630f35 100644 --- a/src/layout.rs +++ b/native/src/layout.rs @@ -12,7 +12,7 @@ use crate::{Point, Rectangle, Vector}; /// [`Widget::on_event`]: widget/trait.Widget.html#method.on_event /// [`Widget::draw`]: widget/trait.Widget.html#tymethod.draw /// [`Widget::node`]: widget/trait.Widget.html#tymethod.node -#[derive(Debug)] +#[derive(Debug, Clone, Copy)] pub struct Layout<'a> { layout: &'a result::Layout, position: Point, diff --git a/native/src/lib.rs b/native/src/lib.rs new file mode 100644 index 00000000..39da4943 --- /dev/null +++ b/native/src/lib.rs @@ -0,0 +1,228 @@ +//! Iced is a renderer-agnostic GUI library focused on simplicity and +//! type-safety. Inspired by [Elm]. +//! +//! # Features +//! * Simple, easy-to-use, renderer-agnostic API +//! * Responsive, flexbox-based layouting +//! * Type-safe, reactive programming model +//! * Built-in widgets +//! * Custom widget support +//! +//! Check out the [repository] and the [examples] for more details! +//! +//! [examples]: https://github.com/hecrj/iced/tree/0.1.0/examples +//! [repository]: https://github.com/hecrj/iced +//! +//! # Usage +//! Inspired by [The Elm Architecture], Iced expects you to split user interfaces +//! into four different concepts: +//! +//! * __State__ — the state of your application +//! * __Messages__ — user interactions or meaningful events that you care +//! about +//! * __View logic__ — a way to display your __state__ as widgets that +//! may produce __messages__ on user interaction +//! * __Update logic__ — a way to react to __messages__ and update your +//! __state__ +//! +//! We can build something to see how this works! Let's say we want a simple counter +//! that can be incremented and decremented using two buttons. +//! +//! We start by modelling the __state__ of our application: +//! +//! ``` +//! use iced_native::button; +//! +//! struct Counter { +//! // The counter value +//! value: i32, +//! +//! // The local state of the two buttons +//! increment_button: button::State, +//! decrement_button: button::State, +//! } +//! ``` +//! +//! Next, we need to define the possible user interactions of our counter: +//! the button presses. These interactions are our __messages__: +//! +//! ``` +//! #[derive(Debug, Clone, Copy)] +//! pub enum Message { +//! IncrementPressed, +//! DecrementPressed, +//! } +//! ``` +//! +//! Now, let's show the actual counter by putting it all together in our +//! __view logic__: +//! +//! ``` +//! # use iced_native::button; +//! # +//! # struct Counter { +//! # // The counter value +//! # value: i32, +//! # +//! # // The local state of the two buttons +//! # increment_button: button::State, +//! # decrement_button: button::State, +//! # } +//! # +//! # #[derive(Debug, Clone, Copy)] +//! # pub enum Message { +//! # IncrementPressed, +//! # DecrementPressed, +//! # } +//! # +//! # mod iced_wgpu { +//! # use iced_native::{ +//! # button, text, Button, Text, +//! # MouseCursor, Node, Point, Rectangle, Style, Color, Layout +//! # }; +//! # +//! # pub struct Renderer {} +//! # +//! # impl button::Renderer for Renderer { +//! # fn node<Message>( +//! # &self, +//! # _button: &Button<'_, Message> +//! # ) -> Node { +//! # Node::new(Style::default()) +//! # } +//! # +//! # fn draw<Message>( +//! # &mut self, +//! # _button: &Button<'_, Message>, +//! # _layout: Layout<'_>, +//! # _cursor_position: Point, +//! # ) -> MouseCursor { +//! # MouseCursor::OutOfBounds +//! # } +//! # } +//! # +//! # impl text::Renderer for Renderer { +//! # fn node(&self, _text: &Text) -> Node { +//! # Node::new(Style::default()) +//! # } +//! # +//! # fn draw( +//! # &mut self, +//! # _text: &Text, +//! # _layout: Layout<'_>, +//! # ) { +//! # } +//! # } +//! # } +//! use iced_native::{Button, Column, Text}; +//! use iced_wgpu::Renderer; // Iced does not include a renderer! We need to bring our own! +//! +//! impl Counter { +//! pub fn view(&mut self) -> Column<Message, Renderer> { +//! // We use a column: a simple vertical layout +//! Column::new() +//! .push( +//! // The increment button. We tell it to produce an +//! // `IncrementPressed` message when pressed +//! Button::new(&mut self.increment_button, "+") +//! .on_press(Message::IncrementPressed), +//! ) +//! .push( +//! // We show the value of the counter here +//! Text::new(&self.value.to_string()).size(50), +//! ) +//! .push( +//! // The decrement button. We tell it to produce a +//! // `DecrementPressed` message when pressed +//! Button::new(&mut self.decrement_button, "-") +//! .on_press(Message::DecrementPressed), +//! ) +//! } +//! } +//! ``` +//! +//! Finally, we need to be able to react to any produced __messages__ and change +//! our __state__ accordingly in our __update logic__: +//! +//! ``` +//! # use iced_native::button; +//! # +//! # struct Counter { +//! # // The counter value +//! # value: i32, +//! # +//! # // The local state of the two buttons +//! # increment_button: button::State, +//! # decrement_button: button::State, +//! # } +//! # +//! # #[derive(Debug, Clone, Copy)] +//! # pub enum Message { +//! # IncrementPressed, +//! # DecrementPressed, +//! # } +//! impl Counter { +//! // ... +//! +//! pub fn update(&mut self, message: Message) { +//! match message { +//! Message::IncrementPressed => { +//! self.value += 1; +//! } +//! Message::DecrementPressed => { +//! self.value -= 1; +//! } +//! } +//! } +//! } +//! ``` +//! +//! And that's everything! We just wrote a whole user interface. Iced is now able +//! to: +//! +//! 1. Take the result of our __view logic__ and layout its widgets. +//! 1. Process events from our system and produce __messages__ for our +//! __update logic__. +//! 1. Draw the resulting user interface using our chosen __renderer__. +//! +//! Check out the [`UserInterface`] type to learn how to wire everything up! +//! +//! [Elm]: https://elm-lang.org/ +//! [The Elm Architecture]: https://guide.elm-lang.org/architecture/ +//! [documentation]: https://docs.rs/iced +//! [examples]: https://github.com/hecrj/iced/tree/master/examples +//! [`UserInterface`]: struct.UserInterface.html +#![deny(missing_docs)] +#![deny(missing_debug_implementations)] +#![deny(unused_results)] +#![deny(unsafe_code)] +#![deny(rust_2018_idioms)] +pub mod input; +pub mod renderer; +pub mod widget; + +mod element; +mod event; +mod hasher; +mod layout; +mod mouse_cursor; +mod node; +mod style; +mod user_interface; + +pub(crate) use iced_core::Vector; + +pub use iced_core::{Align, Color, Justify, Length, Point, Rectangle}; + +#[doc(no_inline)] +pub use stretch::{geometry::Size, number::Number}; + +pub use element::Element; +pub use event::Event; +pub use hasher::Hasher; +pub use layout::Layout; +pub use mouse_cursor::MouseCursor; +pub use node::Node; +pub use style::Style; +pub use user_interface::{Cache, UserInterface}; +pub use widget::*; diff --git a/src/mouse_cursor.rs b/native/src/mouse_cursor.rs index 4ef6361a..4ef6361a 100644 --- a/src/mouse_cursor.rs +++ b/native/src/mouse_cursor.rs diff --git a/src/node.rs b/native/src/node.rs index 1db10d7f..1db10d7f 100644 --- a/src/node.rs +++ b/native/src/node.rs diff --git a/src/renderer.rs b/native/src/renderer.rs index 2244f00b..2244f00b 100644 --- a/src/renderer.rs +++ b/native/src/renderer.rs diff --git a/native/src/style.rs b/native/src/style.rs new file mode 100644 index 00000000..3a75c925 --- /dev/null +++ b/native/src/style.rs @@ -0,0 +1,170 @@ +use crate::{Align, Justify, Length}; + +use std::hash::{Hash, Hasher}; +use stretch::{geometry, style}; + +/// The appearance of a [`Node`]. +/// +/// [`Node`]: struct.Node.html +#[derive(Debug, Clone, Copy)] +pub struct Style(pub(crate) style::Style); + +impl Style { + /// Defines the width of a [`Node`]. + /// + /// [`Node`]: struct.Node.html + pub fn width(mut self, width: Length) -> Self { + self.0.size.width = length_to_dimension(width); + self + } + + /// Defines the height of a [`Node`]. + /// + /// [`Node`]: struct.Node.html + pub fn height(mut self, height: Length) -> Self { + self.0.size.height = length_to_dimension(height); + self + } + + /// Defines the minimum width of a [`Node`]. + /// + /// [`Node`]: struct.Node.html + pub fn min_width(mut self, min_width: Length) -> Self { + self.0.min_size.width = length_to_dimension(min_width); + self + } + + /// Defines the maximum width of a [`Node`]. + /// + /// [`Node`]: struct.Node.html + pub fn max_width(mut self, max_width: Length) -> Self { + self.0.max_size.width = length_to_dimension(max_width); + self + } + + /// Defines the minimum height of a [`Node`]. + /// + /// [`Node`]: struct.Node.html + pub fn min_height(mut self, min_height: Length) -> Self { + self.0.min_size.height = length_to_dimension(min_height); + self + } + + /// Defines the maximum height of a [`Node`]. + /// + /// [`Node`]: struct.Node.html + pub fn max_height(mut self, max_height: Length) -> Self { + self.0.max_size.height = length_to_dimension(max_height); + self + } + + pub(crate) fn align_items(mut self, align: Align) -> Self { + self.0.align_items = align.into(); + self + } + + pub(crate) fn justify_content(mut self, justify: Justify) -> Self { + self.0.justify_content = justify.into(); + self + } + + /// Sets the alignment of a [`Node`]. + /// + /// If the [`Node`] is inside a... + /// + /// * [`Column`], this setting will affect its __horizontal__ alignment. + /// * [`Row`], this setting will affect its __vertical__ alignment. + /// + /// [`Node`]: struct.Node.html + /// [`Column`]: widget/struct.Column.html + /// [`Row`]: widget/struct.Row.html + pub fn align_self(mut self, align: Option<Align>) -> Self { + self.0.align_self = match align { + Some(align) => align.into(), + None => stretch::style::AlignSelf::Auto, + }; + + self + } + + /// Sets the padding of a [`Node`]. + /// + /// [`Node`]: struct.Node.html + pub fn padding(mut self, units: u16) -> Self { + self.0.padding = stretch::geometry::Rect { + start: style::Dimension::Points(units as f32), + end: style::Dimension::Points(units as f32), + top: style::Dimension::Points(units as f32), + bottom: style::Dimension::Points(units as f32), + }; + + self + } +} + +fn length_to_dimension(length: Length) -> style::Dimension { + match length { + Length::Shrink => style::Dimension::Undefined, + Length::Fill => style::Dimension::Percent(1.0), + Length::Units(units) => style::Dimension::Points(units as f32), + } +} + +impl Default for Style { + fn default() -> Style { + Style(style::Style { + align_items: style::AlignItems::FlexStart, + justify_content: style::JustifyContent::FlexStart, + ..style::Style::default() + }) + } +} + +impl Hash for Style { + fn hash<H: Hasher>(&self, state: &mut H) { + hash_size(&self.0.size, state); + hash_size(&self.0.min_size, state); + hash_size(&self.0.max_size, state); + + hash_rect(&self.0.margin, state); + + (self.0.flex_direction as u8).hash(state); + (self.0.align_items as u8).hash(state); + (self.0.justify_content as u8).hash(state); + (self.0.align_self as u8).hash(state); + (self.0.flex_grow as u32).hash(state); + } +} + +fn hash_size<H: Hasher>( + size: &geometry::Size<style::Dimension>, + state: &mut H, +) { + hash_dimension(size.width, state); + hash_dimension(size.height, state); +} + +fn hash_rect<H: Hasher>( + rect: &geometry::Rect<style::Dimension>, + state: &mut H, +) { + hash_dimension(rect.start, state); + hash_dimension(rect.end, state); + hash_dimension(rect.top, state); + hash_dimension(rect.bottom, state); +} + +fn hash_dimension<H: Hasher>(dimension: style::Dimension, state: &mut H) { + match dimension { + style::Dimension::Undefined => state.write_u8(0), + style::Dimension::Auto => state.write_u8(1), + style::Dimension::Points(points) => { + state.write_u8(2); + (points as u32).hash(state); + } + style::Dimension::Percent(percent) => { + state.write_u8(3); + (percent as u32).hash(state); + } + } +} diff --git a/src/user_interface.rs b/native/src/user_interface.rs index 6a69f81a..4bfacb2e 100644 --- a/src/user_interface.rs +++ b/native/src/user_interface.rs @@ -35,7 +35,7 @@ impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> { /// is naive way to set up our application loop: /// /// ```no_run - /// use iced::{UserInterface, Cache}; + /// use iced_native::{UserInterface, Cache}; /// use iced_wgpu::Renderer; /// /// # mod iced_wgpu { @@ -46,7 +46,7 @@ impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> { /// # } /// # } /// # - /// # use iced::Column; + /// # use iced_native::Column; /// # /// # pub struct Counter; /// # @@ -118,7 +118,7 @@ impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> { /// [the previous example](#example): /// /// ```no_run - /// use iced::{UserInterface, Cache}; + /// use iced_native::{UserInterface, Cache}; /// use iced_wgpu::Renderer; /// /// # mod iced_wgpu { @@ -129,7 +129,7 @@ impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> { /// # } /// # } /// # - /// # use iced::Column; + /// # use iced_native::Column; /// # /// # pub struct Counter; /// # @@ -203,7 +203,7 @@ impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> { /// [completing the last example](#example-1): /// /// ```no_run - /// use iced::{UserInterface, Cache}; + /// use iced_native::{UserInterface, Cache}; /// use iced_wgpu::Renderer; /// /// # mod iced_wgpu { @@ -214,7 +214,7 @@ impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> { /// # } /// # } /// # - /// # use iced::Column; + /// # use iced_native::Column; /// # /// # pub struct Counter; /// # diff --git a/src/widget.rs b/native/src/widget.rs index 45451f47..9b770454 100644 --- a/src/widget.rs +++ b/native/src/widget.rs @@ -15,7 +15,7 @@ //! module. Therefore, you can directly type: //! //! ``` -//! use iced::{button, Button, Widget}; +//! use iced_native::{button, Button, Widget}; //! ``` //! //! [`Widget`]: trait.Widget.html @@ -26,19 +26,25 @@ mod row; pub mod button; pub mod checkbox; pub mod image; -//pub mod progress_bar; pub mod radio; pub mod slider; pub mod text; +#[doc(no_inline)] pub use button::Button; +#[doc(no_inline)] pub use checkbox::Checkbox; +#[doc(no_inline)] pub use column::Column; +#[doc(no_inline)] pub use image::Image; -//pub use progress_bar::ProgressBar; +#[doc(no_inline)] pub use radio::Radio; +#[doc(no_inline)] pub use row::Row; +#[doc(no_inline)] pub use slider::Slider; +#[doc(no_inline)] pub use text::Text; use crate::{Event, Hasher, Layout, MouseCursor, Node, Point}; diff --git a/native/src/widget/button.rs b/native/src/widget/button.rs new file mode 100644 index 00000000..c9436dc4 --- /dev/null +++ b/native/src/widget/button.rs @@ -0,0 +1,111 @@ +//! Allow your users to perform actions by pressing a button. +//! +//! A [`Button`] has some local [`State`] and a [`Class`]. +//! +//! [`Button`]: struct.Button.html +//! [`State`]: struct.State.html +//! [`Class`]: enum.Class.html + +use crate::input::{mouse, ButtonState}; +use crate::{ + Element, Event, Hasher, Layout, MouseCursor, Node, Point, Rectangle, Widget, +}; +use std::hash::Hash; + +pub use iced_core::button::*; + +impl<'a, Message, Renderer> Widget<Message, Renderer> for Button<'a, Message> +where + Renderer: self::Renderer, + Message: Copy + std::fmt::Debug, +{ + fn node(&self, renderer: &mut Renderer) -> Node { + renderer.node(&self) + } + + fn on_event( + &mut self, + event: Event, + layout: Layout<'_>, + cursor_position: Point, + messages: &mut Vec<Message>, + ) { + match event { + Event::Mouse(mouse::Event::Input { + button: mouse::Button::Left, + state, + }) => { + if let Some(on_press) = self.on_press { + let bounds = layout.bounds(); + + match state { + ButtonState::Pressed => { + self.state.is_pressed = + bounds.contains(cursor_position); + } + ButtonState::Released => { + let is_clicked = self.state.is_pressed + && bounds.contains(cursor_position); + + self.state.is_pressed = false; + + if is_clicked { + messages.push(on_press); + } + } + } + } + } + _ => {} + } + } + + fn draw( + &self, + renderer: &mut Renderer, + layout: Layout<'_>, + cursor_position: Point, + ) -> MouseCursor { + renderer.draw(&self, layout, cursor_position) + } + + fn hash_layout(&self, state: &mut Hasher) { + self.width.hash(state); + } +} + +/// The renderer of a [`Button`]. +/// +/// Your [renderer] will need to implement this trait before being +/// able to use a [`Button`] in your user interface. +/// +/// [`Button`]: struct.Button.html +/// [renderer]: ../../renderer/index.html +pub trait Renderer { + /// Creates a [`Node`] for the provided [`Button`]. + /// + /// [`Node`]: ../../struct.Node.html + /// [`Button`]: struct.Button.html + fn node<Message>(&self, button: &Button<'_, Message>) -> Node; + + /// Draws a [`Button`]. + /// + /// [`Button`]: struct.Button.html + fn draw<Message>( + &mut self, + button: &Button<'_, Message>, + layout: Layout<'_>, + cursor_position: Point, + ) -> MouseCursor; +} + +impl<'a, Message, Renderer> From<Button<'a, Message>> + for Element<'a, Message, Renderer> +where + Renderer: self::Renderer, + Message: 'static + Copy + std::fmt::Debug, +{ + fn from(button: Button<'a, Message>) -> Element<'a, Message, Renderer> { + Element::new(button) + } +} diff --git a/native/src/widget/checkbox.rs b/native/src/widget/checkbox.rs new file mode 100644 index 00000000..3e307f64 --- /dev/null +++ b/native/src/widget/checkbox.rs @@ -0,0 +1,95 @@ +//! Show toggle controls using checkboxes. +use std::hash::Hash; + +use crate::input::{mouse, ButtonState}; +use crate::{Element, Event, Hasher, Layout, MouseCursor, Node, Point, Widget}; + +pub use iced_core::Checkbox; + +impl<Message, Renderer> Widget<Message, Renderer> for Checkbox<Message> +where + Renderer: self::Renderer, +{ + fn node(&self, renderer: &mut Renderer) -> Node { + renderer.node(&self) + } + + fn on_event( + &mut self, + event: Event, + layout: Layout<'_>, + cursor_position: Point, + messages: &mut Vec<Message>, + ) { + match event { + Event::Mouse(mouse::Event::Input { + button: mouse::Button::Left, + state: ButtonState::Pressed, + }) => { + let mouse_over = layout + .children() + .any(|child| child.bounds().contains(cursor_position)); + + if mouse_over { + messages.push((self.on_toggle)(!self.is_checked)); + } + } + _ => {} + } + } + + fn draw( + &self, + renderer: &mut Renderer, + layout: Layout<'_>, + cursor_position: Point, + ) -> MouseCursor { + renderer.draw(&self, layout, cursor_position) + } + + fn hash_layout(&self, state: &mut Hasher) { + self.label.hash(state); + } +} + +/// The renderer of a [`Checkbox`]. +/// +/// Your [renderer] will need to implement this trait before being +/// able to use a [`Checkbox`] in your user interface. +/// +/// [`Checkbox`]: struct.Checkbox.html +/// [renderer]: ../../renderer/index.html +pub trait Renderer { + /// Creates a [`Node`] for the provided [`Checkbox`]. + /// + /// [`Node`]: ../../struct.Node.html + /// [`Checkbox`]: struct.Checkbox.html + fn node<Message>(&mut self, checkbox: &Checkbox<Message>) -> Node; + + /// Draws a [`Checkbox`]. + /// + /// It receives: + /// * the current cursor position + /// * the bounds of the [`Checkbox`] + /// * the bounds of the label of the [`Checkbox`] + /// * whether the [`Checkbox`] is checked or not + /// + /// [`Checkbox`]: struct.Checkbox.html + fn draw<Message>( + &mut self, + checkbox: &Checkbox<Message>, + layout: Layout<'_>, + cursor_position: Point, + ) -> MouseCursor; +} + +impl<'a, Message, Renderer> From<Checkbox<Message>> + for Element<'a, Message, Renderer> +where + Renderer: self::Renderer, + Message: 'static, +{ + fn from(checkbox: Checkbox<Message>) -> Element<'a, Message, Renderer> { + Element::new(checkbox) + } +} diff --git a/native/src/widget/column.rs b/native/src/widget/column.rs new file mode 100644 index 00000000..9da2e161 --- /dev/null +++ b/native/src/widget/column.rs @@ -0,0 +1,118 @@ +use std::hash::Hash; + +use crate::{ + Element, Event, Hasher, Layout, MouseCursor, Node, Point, Style, Widget, +}; + +/// A container that distributes its contents vertically. +pub type Column<'a, Message, Renderer> = + iced_core::Column<Element<'a, Message, Renderer>>; + +impl<'a, Message, Renderer> Widget<Message, Renderer> + for Column<'a, Message, Renderer> +{ + fn node(&self, renderer: &mut Renderer) -> Node { + let mut children: Vec<Node> = self + .children + .iter() + .map(|child| { + let mut node = child.widget.node(renderer); + + let mut style = node.0.style(); + style.margin.bottom = + stretch::style::Dimension::Points(f32::from(self.spacing)); + + node.0.set_style(style); + node + }) + .collect(); + + if let Some(node) = children.last_mut() { + let mut style = node.0.style(); + style.margin.bottom = stretch::style::Dimension::Undefined; + + node.0.set_style(style); + } + + let mut style = Style::default() + .width(self.width) + .height(self.height) + .max_width(self.max_width) + .max_height(self.max_height) + .padding(self.padding) + .align_self(self.align_self) + .align_items(self.align_items) + .justify_content(self.justify_content); + + style.0.flex_direction = stretch::style::FlexDirection::Column; + + Node::with_children(style, children) + } + + fn on_event( + &mut self, + event: Event, + layout: Layout<'_>, + cursor_position: Point, + messages: &mut Vec<Message>, + ) { + self.children.iter_mut().zip(layout.children()).for_each( + |(child, layout)| { + child + .widget + .on_event(event, layout, cursor_position, messages) + }, + ); + } + + fn draw( + &self, + renderer: &mut Renderer, + layout: Layout<'_>, + cursor_position: Point, + ) -> MouseCursor { + let mut cursor = MouseCursor::OutOfBounds; + + self.children.iter().zip(layout.children()).for_each( + |(child, layout)| { + let new_cursor = + child.widget.draw(renderer, layout, cursor_position); + + if new_cursor != MouseCursor::OutOfBounds { + cursor = new_cursor; + } + }, + ); + + cursor + } + + fn hash_layout(&self, state: &mut Hasher) { + 0.hash(state); + self.width.hash(state); + self.height.hash(state); + self.max_width.hash(state); + self.max_height.hash(state); + self.align_self.hash(state); + self.align_items.hash(state); + self.justify_content.hash(state); + self.spacing.hash(state); + + for child in &self.children { + child.widget.hash_layout(state); + } + } +} + +impl<'a, Message, Renderer> From<Column<'a, Message, Renderer>> + for Element<'a, Message, Renderer> +where + Renderer: 'a, + Message: 'static, +{ + fn from( + column: Column<'a, Message, Renderer>, + ) -> Element<'a, Message, Renderer> { + Element::new(column) + } +} diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs new file mode 100644 index 00000000..17f06ebe --- /dev/null +++ b/native/src/widget/image.rs @@ -0,0 +1,67 @@ +//! Display images in your user interface. + +use crate::{ + Element, Hasher, Layout, MouseCursor, Node, Point, Rectangle, Widget, +}; + +use std::hash::Hash; + +pub use iced_core::Image; + +impl<I, Message, Renderer> Widget<Message, Renderer> for Image<I> +where + Renderer: self::Renderer<I>, + I: Clone, +{ + fn node(&self, renderer: &mut Renderer) -> Node { + renderer.node(&self) + } + + fn draw( + &self, + renderer: &mut Renderer, + layout: Layout<'_>, + _cursor_position: Point, + ) -> MouseCursor { + renderer.draw(&self, layout); + + MouseCursor::OutOfBounds + } + + fn hash_layout(&self, state: &mut Hasher) { + self.width.hash(state); + self.height.hash(state); + } +} + +/// The renderer of an [`Image`]. +/// +/// Your [renderer] will need to implement this trait before being able to use +/// an [`Image`] in your user interface. +/// +/// [`Image`]: struct.Image.html +/// [renderer]: ../../renderer/index.html +pub trait Renderer<I> { + /// Creates a [`Node`] for the provided [`Image`]. + /// + /// You should probably keep the original aspect ratio, if possible. + /// + /// [`Node`]: ../../struct.Node.html + /// [`Image`]: struct.Image.html + fn node(&mut self, image: &Image<I>) -> Node; + + /// Draws an [`Image`]. + /// + /// [`Image`]: struct.Image.html + fn draw(&mut self, image: &Image<I>, layout: Layout<'_>); +} + +impl<'a, I, Message, Renderer> From<Image<I>> for Element<'a, Message, Renderer> +where + Renderer: self::Renderer<I>, + I: Clone + 'a, +{ + fn from(image: Image<I>) -> Element<'a, Message, Renderer> { + Element::new(image) + } +} diff --git a/native/src/widget/radio.rs b/native/src/widget/radio.rs new file mode 100644 index 00000000..33d42e61 --- /dev/null +++ b/native/src/widget/radio.rs @@ -0,0 +1,92 @@ +//! Create choices using radio buttons. +use crate::input::{mouse, ButtonState}; +use crate::{Element, Event, Hasher, Layout, MouseCursor, Node, Point, Widget}; + +use std::hash::Hash; + +pub use iced_core::Radio; + +impl<Message, Renderer> Widget<Message, Renderer> for Radio<Message> +where + Renderer: self::Renderer, + Message: Copy + std::fmt::Debug, +{ + fn node(&self, renderer: &mut Renderer) -> Node { + renderer.node(&self) + } + + fn on_event( + &mut self, + event: Event, + layout: Layout<'_>, + cursor_position: Point, + messages: &mut Vec<Message>, + ) { + match event { + Event::Mouse(mouse::Event::Input { + button: mouse::Button::Left, + state: ButtonState::Pressed, + }) => { + if layout.bounds().contains(cursor_position) { + messages.push(self.on_click); + } + } + _ => {} + } + } + + fn draw( + &self, + renderer: &mut Renderer, + layout: Layout<'_>, + cursor_position: Point, + ) -> MouseCursor { + renderer.draw(&self, layout, cursor_position) + } + + fn hash_layout(&self, state: &mut Hasher) { + self.label.hash(state); + } +} + +/// The renderer of a [`Radio`] button. +/// +/// Your [renderer] will need to implement this trait before being +/// able to use a [`Radio`] button in your user interface. +/// +/// [`Radio`]: struct.Radio.html +/// [renderer]: ../../renderer/index.html +pub trait Renderer { + /// Creates a [`Node`] for the provided [`Radio`]. + /// + /// [`Node`]: ../../struct.Node.html + /// [`Radio`]: struct.Radio.html + fn node<Message>(&mut self, radio: &Radio<Message>) -> Node; + + /// Draws a [`Radio`] button. + /// + /// It receives: + /// * the current cursor position + /// * the bounds of the [`Radio`] + /// * the bounds of the label of the [`Radio`] + /// * whether the [`Radio`] is selected or not + /// + /// [`Radio`]: struct.Radio.html + fn draw<Message>( + &mut self, + radio: &Radio<Message>, + layout: Layout<'_>, + cursor_position: Point, + ) -> MouseCursor; +} + +impl<'a, Message, Renderer> From<Radio<Message>> + for Element<'a, Message, Renderer> +where + Renderer: self::Renderer, + Message: 'static + Copy + std::fmt::Debug, +{ + fn from(checkbox: Radio<Message>) -> Element<'a, Message, Renderer> { + Element::new(checkbox) + } +} diff --git a/native/src/widget/row.rs b/native/src/widget/row.rs new file mode 100644 index 00000000..3cd451b7 --- /dev/null +++ b/native/src/widget/row.rs @@ -0,0 +1,117 @@ +use std::hash::Hash; + +use crate::{ + Element, Event, Hasher, Layout, MouseCursor, Node, Point, Style, Widget, +}; + +/// A container that distributes its contents horizontally. +pub type Row<'a, Message, Renderer> = + iced_core::Row<Element<'a, Message, Renderer>>; + +impl<'a, Message, Renderer> Widget<Message, Renderer> + for Row<'a, Message, Renderer> +{ + fn node(&self, renderer: &mut Renderer) -> Node { + let mut children: Vec<Node> = self + .children + .iter() + .map(|child| { + let mut node = child.widget.node(renderer); + + let mut style = node.0.style(); + style.margin.end = + stretch::style::Dimension::Points(f32::from(self.spacing)); + + node.0.set_style(style); + node + }) + .collect(); + + if let Some(node) = children.last_mut() { + let mut style = node.0.style(); + style.margin.end = stretch::style::Dimension::Undefined; + + node.0.set_style(style); + } + + let mut style = Style::default() + .width(self.width) + .height(self.height) + .max_width(self.max_width) + .max_height(self.max_height) + .padding(self.padding) + .align_self(self.align_self) + .align_items(self.align_items) + .justify_content(self.justify_content); + + style.0.flex_direction = stretch::style::FlexDirection::Row; + + Node::with_children(style, children) + } + + fn on_event( + &mut self, + event: Event, + layout: Layout<'_>, + cursor_position: Point, + messages: &mut Vec<Message>, + ) { + self.children.iter_mut().zip(layout.children()).for_each( + |(child, layout)| { + child + .widget + .on_event(event, layout, cursor_position, messages) + }, + ); + } + + fn draw( + &self, + renderer: &mut Renderer, + layout: Layout<'_>, + cursor_position: Point, + ) -> MouseCursor { + let mut cursor = MouseCursor::OutOfBounds; + + self.children.iter().zip(layout.children()).for_each( + |(child, layout)| { + let new_cursor = + child.widget.draw(renderer, layout, cursor_position); + + if new_cursor != MouseCursor::OutOfBounds { + cursor = new_cursor; + } + }, + ); + + cursor + } + + fn hash_layout(&self, state: &mut Hasher) { + 1.hash(state); + self.width.hash(state); + self.height.hash(state); + self.max_width.hash(state); + self.max_height.hash(state); + self.align_self.hash(state); + self.align_items.hash(state); + self.justify_content.hash(state); + self.spacing.hash(state); + self.spacing.hash(state); + + for child in &self.children { + child.widget.hash_layout(state); + } + } +} + +impl<'a, Message, Renderer> From<Row<'a, Message, Renderer>> + for Element<'a, Message, Renderer> +where + Renderer: 'a, + Message: 'static, +{ + fn from(row: Row<'a, Message, Renderer>) -> Element<'a, Message, Renderer> { + Element::new(row) + } +} diff --git a/native/src/widget/slider.rs b/native/src/widget/slider.rs new file mode 100644 index 00000000..481296bd --- /dev/null +++ b/native/src/widget/slider.rs @@ -0,0 +1,126 @@ +//! Display an interactive selector of a single value from a range of values. +//! +//! A [`Slider`] has some local [`State`]. +//! +//! [`Slider`]: struct.Slider.html +//! [`State`]: struct.State.html +use std::hash::Hash; + +use crate::input::{mouse, ButtonState}; +use crate::{Element, Event, Hasher, Layout, MouseCursor, Node, Point, Widget}; + +pub use iced_core::slider::*; + +impl<'a, Message, Renderer> Widget<Message, Renderer> for Slider<'a, Message> +where + Renderer: self::Renderer, +{ + fn node(&self, renderer: &mut Renderer) -> Node { + renderer.node(&self) + } + + fn on_event( + &mut self, + event: Event, + layout: Layout<'_>, + cursor_position: Point, + messages: &mut Vec<Message>, + ) { + let mut change = || { + let bounds = layout.bounds(); + + if cursor_position.x <= bounds.x { + messages.push((self.on_change)(*self.range.start())); + } else if cursor_position.x >= bounds.x + bounds.width { + messages.push((self.on_change)(*self.range.end())); + } else { + let percent = (cursor_position.x - bounds.x) / bounds.width; + let value = (self.range.end() - self.range.start()) * percent + + self.range.start(); + + messages.push((self.on_change)(value)); + } + }; + + match event { + Event::Mouse(mouse::Event::Input { + button: mouse::Button::Left, + state, + }) => match state { + ButtonState::Pressed => { + if layout.bounds().contains(cursor_position) { + change(); + self.state.is_dragging = true; + } + } + ButtonState::Released => { + self.state.is_dragging = false; + } + }, + Event::Mouse(mouse::Event::CursorMoved { .. }) => { + if self.state.is_dragging { + change(); + } + } + _ => {} + } + } + + fn draw( + &self, + renderer: &mut Renderer, + layout: Layout<'_>, + cursor_position: Point, + ) -> MouseCursor { + renderer.draw(&self, layout, cursor_position) + } + + fn hash_layout(&self, state: &mut Hasher) { + self.width.hash(state); + } +} + +/// The renderer of a [`Slider`]. +/// +/// Your [renderer] will need to implement this trait before being +/// able to use a [`Slider`] in your user interface. +/// +/// [`Slider`]: struct.Slider.html +/// [renderer]: ../../renderer/index.html +pub trait Renderer { + /// Creates a [`Node`] for the provided [`Radio`]. + /// + /// [`Node`]: ../../struct.Node.html + /// [`Radio`]: struct.Radio.html + fn node<Message>(&self, slider: &Slider<'_, Message>) -> Node; + + /// Draws a [`Slider`]. + /// + /// It receives: + /// * the current cursor position + /// * the bounds of the [`Slider`] + /// * the local state of the [`Slider`] + /// * the range of values of the [`Slider`] + /// * the current value of the [`Slider`] + /// + /// [`Slider`]: struct.Slider.html + /// [`State`]: struct.State.html + /// [`Class`]: enum.Class.html + fn draw<Message>( + &mut self, + slider: &Slider<'_, Message>, + layout: Layout<'_>, + cursor_position: Point, + ) -> MouseCursor; +} + +impl<'a, Message, Renderer> From<Slider<'a, Message>> + for Element<'a, Message, Renderer> +where + Renderer: self::Renderer, + Message: 'static, +{ + fn from(slider: Slider<'a, Message>) -> Element<'a, Message, Renderer> { + Element::new(slider) + } +} diff --git a/native/src/widget/text.rs b/native/src/widget/text.rs new file mode 100644 index 00000000..affdfd64 --- /dev/null +++ b/native/src/widget/text.rs @@ -0,0 +1,77 @@ +//! Write some text for your users to read. +use crate::{Element, Hasher, Layout, MouseCursor, Node, Point, Widget}; + +use std::hash::Hash; + +pub use iced_core::text::*; + +impl<Message, Renderer> Widget<Message, Renderer> for Text +where + Renderer: self::Renderer, +{ + fn node(&self, renderer: &mut Renderer) -> Node { + renderer.node(&self) + } + + fn draw( + &self, + renderer: &mut Renderer, + layout: Layout<'_>, + _cursor_position: Point, + ) -> MouseCursor { + renderer.draw(&self, layout); + + MouseCursor::OutOfBounds + } + + fn hash_layout(&self, state: &mut Hasher) { + self.content.hash(state); + self.size.hash(state); + } +} + +/// The renderer of a [`Text`] fragment. +/// +/// Your [renderer] will need to implement this trait before being +/// able to use [`Text`] in your [`UserInterface`]. +/// +/// [`Text`]: struct.Text.html +/// [renderer]: ../../renderer/index.html +/// [`UserInterface`]: ../../struct.UserInterface.html +pub trait Renderer { + /// Creates a [`Node`] with the given [`Style`] for the provided [`Text`] + /// contents and size. + /// + /// You should probably use [`Node::with_measure`] to allow [`Text`] to + /// adapt to the dimensions of its container. + /// + /// [`Node`]: ../../struct.Node.html + /// [`Style`]: ../../struct.Style.html + /// [`Text`]: struct.Text.html + /// [`Node::with_measure`]: ../../struct.Node.html#method.with_measure + fn node(&self, text: &Text) -> Node; + + /// Draws a [`Text`] fragment. + /// + /// It receives: + /// * the bounds of the [`Text`] + /// * the contents of the [`Text`] + /// * the size of the [`Text`] + /// * the color of the [`Text`] + /// * the [`HorizontalAlignment`] of the [`Text`] + /// * the [`VerticalAlignment`] of the [`Text`] + /// + /// [`Text`]: struct.Text.html + /// [`HorizontalAlignment`]: enum.HorizontalAlignment.html + /// [`VerticalAlignment`]: enum.VerticalAlignment.html + fn draw(&mut self, text: &Text, layout: Layout<'_>); +} + +impl<'a, Message, Renderer> From<Text> for Element<'a, Message, Renderer> +where + Renderer: self::Renderer, +{ + fn from(text: Text) -> Element<'a, Message, Renderer> { + Element::new(text) + } +} @@ -1,231 +0,0 @@ -//! Iced is a renderer-agnostic GUI library focused on simplicity and -//! type-safety. Inspired by [Elm]. -//! -//! # Features -//! * Simple, easy-to-use, renderer-agnostic API -//! * Responsive, flexbox-based layouting -//! * Type-safe, reactive programming model -//! * Built-in widgets -//! * Custom widget support -//! -//! Check out the [repository] and the [examples] for more details! -//! -//! [examples]: https://github.com/hecrj/iced/tree/0.1.0/examples -//! [repository]: https://github.com/hecrj/iced -//! -//! # Usage -//! Inspired by [The Elm Architecture], Iced expects you to split user interfaces -//! into four different concepts: -//! -//! * __State__ — the state of your application -//! * __Messages__ — user interactions or meaningful events that you care -//! about -//! * __View logic__ — a way to display your __state__ as widgets that -//! may produce __messages__ on user interaction -//! * __Update logic__ — a way to react to __messages__ and update your -//! __state__ -//! -//! We can build something to see how this works! Let's say we want a simple counter -//! that can be incremented and decremented using two buttons. -//! -//! We start by modelling the __state__ of our application: -//! -//! ``` -//! use iced::button; -//! -//! struct Counter { -//! // The counter value -//! value: i32, -//! -//! // The local state of the two buttons -//! increment_button: button::State, -//! decrement_button: button::State, -//! } -//! ``` -//! -//! Next, we need to define the possible user interactions of our counter: -//! the button presses. These interactions are our __messages__: -//! -//! ``` -//! #[derive(Debug, Clone, Copy)] -//! pub enum Message { -//! IncrementPressed, -//! DecrementPressed, -//! } -//! ``` -//! -//! Now, let's show the actual counter by putting it all together in our -//! __view logic__: -//! -//! ``` -//! # use iced::button; -//! # -//! # struct Counter { -//! # // The counter value -//! # value: i32, -//! # -//! # // The local state of the two buttons -//! # increment_button: button::State, -//! # decrement_button: button::State, -//! # } -//! # -//! # #[derive(Debug, Clone, Copy)] -//! # pub enum Message { -//! # IncrementPressed, -//! # DecrementPressed, -//! # } -//! # -//! # mod iced_wgpu { -//! # use iced::{ -//! # button, text, text::HorizontalAlignment, text::VerticalAlignment, -//! # MouseCursor, Node, Point, Rectangle, Style, Color -//! # }; -//! # -//! # pub struct Renderer {} -//! # -//! # impl button::Renderer for Renderer { -//! # fn draw( -//! # &mut self, -//! # _cursor_position: Point, -//! # _bounds: Rectangle, -//! # _state: &button::State, -//! # _label: &str, -//! # _class: button::Class, -//! # ) -> MouseCursor { -//! # MouseCursor::OutOfBounds -//! # } -//! # } -//! # -//! # impl text::Renderer for Renderer { -//! # fn node(&self, style: Style, _content: &str, _size: Option<u16>) -> Node { -//! # Node::new(style) -//! # } -//! # -//! # fn draw( -//! # &mut self, -//! # _bounds: Rectangle, -//! # _content: &str, -//! # _size: Option<u16>, -//! # _color: Option<Color>, -//! # _horizontal_alignment: HorizontalAlignment, -//! # _vertical_alignment: VerticalAlignment, -//! # ) { -//! # } -//! # } -//! # } -//! use iced::{Button, Column, Text}; -//! use iced_wgpu::Renderer; // Iced does not include a renderer! We need to bring our own! -//! -//! impl Counter { -//! pub fn view(&mut self) -> Column<Message, Renderer> { -//! // We use a column: a simple vertical layout -//! Column::new() -//! .push( -//! // The increment button. We tell it to produce an -//! // `IncrementPressed` message when pressed -//! Button::new(&mut self.increment_button, "+") -//! .on_press(Message::IncrementPressed), -//! ) -//! .push( -//! // We show the value of the counter here -//! Text::new(&self.value.to_string()).size(50), -//! ) -//! .push( -//! // The decrement button. We tell it to produce a -//! // `DecrementPressed` message when pressed -//! Button::new(&mut self.decrement_button, "-") -//! .on_press(Message::DecrementPressed), -//! ) -//! } -//! } -//! ``` -//! -//! Finally, we need to be able to react to any produced __messages__ and change -//! our __state__ accordingly in our __update logic__: -//! -//! ``` -//! # use iced::button; -//! # -//! # struct Counter { -//! # // The counter value -//! # value: i32, -//! # -//! # // The local state of the two buttons -//! # increment_button: button::State, -//! # decrement_button: button::State, -//! # } -//! # -//! # #[derive(Debug, Clone, Copy)] -//! # pub enum Message { -//! # IncrementPressed, -//! # DecrementPressed, -//! # } -//! impl Counter { -//! // ... -//! -//! pub fn update(&mut self, message: Message) { -//! match message { -//! Message::IncrementPressed => { -//! self.value += 1; -//! } -//! Message::DecrementPressed => { -//! self.value -= 1; -//! } -//! } -//! } -//! } -//! ``` -//! -//! And that's everything! We just wrote a whole user interface. Iced is now able -//! to: -//! -//! 1. Take the result of our __view logic__ and layout its widgets. -//! 1. Process events from our system and produce __messages__ for our -//! __update logic__. -//! 1. Draw the resulting user interface using our chosen __renderer__. -//! -//! Check out the [`UserInterface`] type to learn how to wire everything up! -//! -//! [Elm]: https://elm-lang.org/ -//! [The Elm Architecture]: https://guide.elm-lang.org/architecture/ -//! [documentation]: https://docs.rs/iced -//! [examples]: https://github.com/hecrj/iced/tree/master/examples -//! [`UserInterface`]: struct.UserInterface.html -#![deny(missing_docs)] -#![deny(missing_debug_implementations)] -#![deny(unused_results)] -#![deny(unsafe_code)] -#![deny(rust_2018_idioms)] -pub mod input; -pub mod renderer; -pub mod widget; - -mod color; -mod element; -mod event; -mod hasher; -mod layout; -mod mouse_cursor; -mod node; -mod point; -mod rectangle; -mod style; -mod user_interface; -mod vector; - -#[doc(no_inline)] -pub use stretch::{geometry::Size, number::Number}; - -pub use color::Color; -pub use element::Element; -pub use event::Event; -pub use hasher::Hasher; -pub use layout::Layout; -pub use mouse_cursor::MouseCursor; -pub use node::Node; -pub use point::Point; -pub use rectangle::Rectangle; -pub use style::{Align, Justify, Style}; -pub use user_interface::{Cache, UserInterface}; -pub(crate) use vector::Vector; -pub use widget::*; diff --git a/src/style.rs b/src/style.rs deleted file mode 100644 index 575ea366..00000000 --- a/src/style.rs +++ /dev/null @@ -1,262 +0,0 @@ -use std::hash::{Hash, Hasher}; -use stretch::{geometry, style}; - -/// The appearance of a [`Node`]. -/// -/// [`Node`]: struct.Node.html -#[derive(Debug, Clone, Copy)] -pub struct Style(pub(crate) style::Style); - -impl Style { - /// Defines the width of a [`Node`] in pixels. - /// - /// [`Node`]: struct.Node.html - pub fn width(mut self, width: u16) -> Self { - self.0.size.width = style::Dimension::Points(width as f32); - self - } - - /// Defines the height of a [`Node`] in pixels. - /// - /// [`Node`]: struct.Node.html - pub fn height(mut self, height: u16) -> Self { - self.0.size.height = style::Dimension::Points(height as f32); - self - } - - /// Defines the minimum width of a [`Node`] in pixels. - /// - /// [`Node`]: struct.Node.html - pub fn min_width(mut self, min_width: u16) -> Self { - self.0.min_size.width = style::Dimension::Points(min_width as f32); - self - } - - /// Defines the maximum width of a [`Node`] in pixels. - /// - /// [`Node`]: struct.Node.html - pub fn max_width(mut self, max_width: u16) -> Self { - self.0.max_size.width = style::Dimension::Points(max_width as f32); - self.fill_width() - } - - /// Defines the minimum height of a [`Node`] in pixels. - /// - /// [`Node`]: struct.Node.html - pub fn min_height(mut self, min_height: u16) -> Self { - self.0.min_size.height = - style::Dimension::Points(f32::from(min_height)); - self - } - - /// Defines the maximum height of a [`Node`] in pixels. - /// - /// [`Node`]: struct.Node.html - pub fn max_height(mut self, max_height: u16) -> Self { - self.0.max_size.height = - style::Dimension::Points(f32::from(max_height)); - self.fill_height() - } - - /// Makes a [`Node`] fill all the horizontal available space. - /// - /// [`Node`]: struct.Node.html - pub fn fill_width(mut self) -> Self { - self.0.size.width = stretch::style::Dimension::Percent(1.0); - self - } - - /// Makes a [`Node`] fill all the vertical available space. - /// - /// [`Node`]: struct.Node.html - pub fn fill_height(mut self) -> Self { - self.0.size.height = stretch::style::Dimension::Percent(1.0); - self - } - - pub(crate) fn align_items(mut self, align: Align) -> Self { - self.0.align_items = align.into(); - self - } - - pub(crate) fn justify_content(mut self, justify: Justify) -> Self { - self.0.justify_content = justify.into(); - self - } - - /// Sets the alignment of a [`Node`]. - /// - /// If the [`Node`] is inside a... - /// - /// * [`Column`], this setting will affect its __horizontal__ alignment. - /// * [`Row`], this setting will affect its __vertical__ alignment. - /// - /// [`Node`]: struct.Node.html - /// [`Column`]: widget/struct.Column.html - /// [`Row`]: widget/struct.Row.html - pub fn align_self(mut self, align: Align) -> Self { - self.0.align_self = align.into(); - self - } - - /// Sets the padding of a [`Node`] in pixels. - /// - /// [`Node`]: struct.Node.html - pub fn padding(mut self, px: u16) -> Self { - self.0.padding = stretch::geometry::Rect { - start: style::Dimension::Points(px as f32), - end: style::Dimension::Points(px as f32), - top: style::Dimension::Points(px as f32), - bottom: style::Dimension::Points(px as f32), - }; - - self - } -} - -impl Default for Style { - fn default() -> Style { - Style(style::Style { - align_items: style::AlignItems::FlexStart, - justify_content: style::JustifyContent::FlexStart, - ..style::Style::default() - }) - } -} - -impl Hash for Style { - fn hash<H: Hasher>(&self, state: &mut H) { - hash_size(&self.0.size, state); - hash_size(&self.0.min_size, state); - hash_size(&self.0.max_size, state); - - hash_rect(&self.0.margin, state); - - (self.0.flex_direction as u8).hash(state); - (self.0.align_items as u8).hash(state); - (self.0.justify_content as u8).hash(state); - (self.0.align_self as u8).hash(state); - (self.0.flex_grow as u32).hash(state); - } -} - -fn hash_size<H: Hasher>( - size: &geometry::Size<style::Dimension>, - state: &mut H, -) { - hash_dimension(size.width, state); - hash_dimension(size.height, state); -} - -fn hash_rect<H: Hasher>( - rect: &geometry::Rect<style::Dimension>, - state: &mut H, -) { - hash_dimension(rect.start, state); - hash_dimension(rect.end, state); - hash_dimension(rect.top, state); - hash_dimension(rect.bottom, state); -} - -fn hash_dimension<H: Hasher>(dimension: style::Dimension, state: &mut H) { - match dimension { - style::Dimension::Undefined => state.write_u8(0), - style::Dimension::Auto => state.write_u8(1), - style::Dimension::Points(points) => { - state.write_u8(2); - (points as u32).hash(state); - } - style::Dimension::Percent(percent) => { - state.write_u8(3); - (percent as u32).hash(state); - } - } -} - -/// Alignment on the cross axis of a container. -/// -/// * On a [`Column`], it describes __horizontal__ alignment. -/// * On a [`Row`], it describes __vertical__ alignment. -/// -/// [`Column`]: widget/struct.Column.html -/// [`Row`]: widget/struct.Row.html -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum Align { - /// Align at the start of the cross axis. - Start, - - /// Align at the center of the cross axis. - Center, - - /// Align at the end of the cross axis. - End, - - /// Stretch over the cross axis. - Stretch, -} - -#[doc(hidden)] -impl From<Align> for style::AlignItems { - fn from(align: Align) -> Self { - match align { - Align::Start => style::AlignItems::FlexStart, - Align::Center => style::AlignItems::Center, - Align::End => style::AlignItems::FlexEnd, - Align::Stretch => style::AlignItems::Stretch, - } - } -} - -#[doc(hidden)] -impl From<Align> for style::AlignSelf { - fn from(align: Align) -> Self { - match align { - Align::Start => style::AlignSelf::FlexStart, - Align::Center => style::AlignSelf::Center, - Align::End => style::AlignSelf::FlexEnd, - Align::Stretch => style::AlignSelf::Stretch, - } - } -} - -/// Distribution on the main axis of a container. -/// -/// * On a [`Column`], it describes __vertical__ distribution. -/// * On a [`Row`], it describes __horizontal__ distribution. -/// -/// [`Column`]: widget/struct.Column.html -/// [`Row`]: widget/struct.Row.html -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum Justify { - /// Place items at the start of the main axis. - Start, - - /// Place items at the center of the main axis. - Center, - - /// Place items at the end of the main axis. - End, - - /// Place items with space between. - SpaceBetween, - - /// Place items with space around. - SpaceAround, - - /// Place items with evenly distributed space. - SpaceEvenly, -} - -#[doc(hidden)] -impl From<Justify> for style::JustifyContent { - fn from(justify: Justify) -> Self { - match justify { - Justify::Start => style::JustifyContent::FlexStart, - Justify::Center => style::JustifyContent::Center, - Justify::End => style::JustifyContent::FlexEnd, - Justify::SpaceBetween => style::JustifyContent::SpaceBetween, - Justify::SpaceAround => style::JustifyContent::SpaceAround, - Justify::SpaceEvenly => style::JustifyContent::SpaceEvenly, - } - } -} diff --git a/src/widget/button.rs b/src/widget/button.rs deleted file mode 100644 index d2ea70e4..00000000 --- a/src/widget/button.rs +++ /dev/null @@ -1,284 +0,0 @@ -//! Allow your users to perform actions by pressing a button. -//! -//! A [`Button`] has some local [`State`] and a [`Class`]. -//! -//! [`Button`]: struct.Button.html -//! [`State`]: struct.State.html -//! [`Class`]: enum.Class.html - -use crate::input::{mouse, ButtonState}; -use crate::{ - Align, Element, Event, Hasher, Layout, MouseCursor, Node, Point, Rectangle, - Style, Widget, -}; - -use std::hash::Hash; - -/// A generic widget that produces a message when clicked. -/// -/// It implements [`Widget`] when the associated `Renderer` implements the -/// [`button::Renderer`] trait. -/// -/// [`Widget`]: ../trait.Widget.html -/// [`button::Renderer`]: trait.Renderer.html -/// -/// # Example -/// -/// ``` -/// use iced::{button, Button}; -/// -/// pub enum Message { -/// ButtonClicked, -/// } -/// -/// let state = &mut button::State::new(); -/// -/// Button::new(state, "Click me!") -/// .on_press(Message::ButtonClicked); -/// ``` -/// -///  -pub struct Button<'a, Message> { - state: &'a mut State, - /// The label of the button. - pub label: String, - class: Class, - /// The message to produce when the button is pressed - pub on_press: Option<Message>, - style: Style, -} - -impl<'a, Message> std::fmt::Debug for Button<'a, Message> -where - Message: std::fmt::Debug, -{ - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("Button") - .field("state", &self.state) - .field("label", &self.label) - .field("class", &self.class) - .field("on_press", &self.on_press) - .field("style", &self.style) - .finish() - } -} - -impl<'a, Message> Button<'a, Message> { - /// Creates a new [`Button`] with some local [`State`] and the given label. - /// - /// The default [`Class`] of a new [`Button`] is [`Class::Primary`]. - /// - /// [`Button`]: struct.Button.html - /// [`State`]: struct.State.html - /// [`Class`]: enum.Class.html - /// [`Class::Primary`]: enum.Class.html#variant.Primary - pub fn new(state: &'a mut State, label: &str) -> Self { - Button { - state, - label: String::from(label), - class: Class::Primary, - on_press: None, - style: Style::default().min_width(100), - } - } - - /// Sets the width of the [`Button`] in pixels. - /// - /// [`Button`]: struct.Button.html - pub fn width(mut self, width: u16) -> Self { - self.style = self.style.width(width); - self - } - - /// Makes the [`Button`] fill the horizontal space of its container. - /// - /// [`Button`]: struct.Button.html - pub fn fill_width(mut self) -> Self { - self.style = self.style.fill_width(); - self - } - - /// Sets the alignment of the [`Button`] itself. - /// - /// This is useful if you want to override the default alignment given by - /// the parent container. - /// - /// [`Button`]: struct.Button.html - pub fn align_self(mut self, align: Align) -> Self { - self.style = self.style.align_self(align); - self - } - - /// Sets the [`Class`] of the [`Button`]. - /// - /// - /// [`Button`]: struct.Button.html - /// [`Class`]: enum.Class.html - pub fn class(mut self, class: Class) -> Self { - self.class = class; - self - } - - /// Sets the message that will be produced when the [`Button`] is pressed. - /// - /// [`Button`]: struct.Button.html - pub fn on_press(mut self, msg: Message) -> Self { - self.on_press = Some(msg); - self - } -} - -impl<'a, Message, Renderer> Widget<Message, Renderer> for Button<'a, Message> -where - Renderer: self::Renderer, - Message: Copy + std::fmt::Debug, -{ - fn node(&self, _renderer: &mut Renderer) -> Node { - Node::new(self.style.height(50)) - } - - fn on_event( - &mut self, - event: Event, - layout: Layout<'_>, - cursor_position: Point, - messages: &mut Vec<Message>, - ) { - match event { - Event::Mouse(mouse::Event::Input { - button: mouse::Button::Left, - state, - }) => { - if let Some(on_press) = self.on_press { - let bounds = layout.bounds(); - - match state { - ButtonState::Pressed => { - self.state.is_pressed = - bounds.contains(cursor_position); - } - ButtonState::Released => { - let is_clicked = self.state.is_pressed - && bounds.contains(cursor_position); - - self.state.is_pressed = false; - - if is_clicked { - messages.push(on_press); - } - } - } - } - } - _ => {} - } - } - - fn draw( - &self, - renderer: &mut Renderer, - layout: Layout<'_>, - cursor_position: Point, - ) -> MouseCursor { - renderer.draw( - cursor_position, - layout.bounds(), - self.state, - &self.label, - self.class, - ) - } - - fn hash_layout(&self, state: &mut Hasher) { - self.style.hash(state); - } -} - -/// The local state of a [`Button`]. -/// -/// [`Button`]: struct.Button.html -#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] -pub struct State { - is_pressed: bool, -} - -impl State { - /// Creates a new [`State`]. - /// - /// [`State`]: struct.State.html - pub fn new() -> State { - State::default() - } - - /// Returns whether the associated [`Button`] is currently being pressed or - /// not. - /// - /// [`Button`]: struct.Button.html - pub fn is_pressed(&self) -> bool { - self.is_pressed - } -} - -/// The type of a [`Button`]. -/// -///  -/// -/// [`Button`]: struct.Button.html -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum Class { - /// The [`Button`] performs the main action. - /// - /// [`Button`]: struct.Button.html - Primary, - - /// The [`Button`] performs an alternative action. - /// - /// [`Button`]: struct.Button.html - Secondary, - - /// The [`Button`] performs a productive action. - /// - /// [`Button`]: struct.Button.html - Positive, -} - -/// The renderer of a [`Button`]. -/// -/// Your [renderer] will need to implement this trait before being -/// able to use a [`Button`] in your user interface. -/// -/// [`Button`]: struct.Button.html -/// [renderer]: ../../renderer/index.html -pub trait Renderer { - /// Draws a [`Button`]. - /// - /// It receives: - /// * the current cursor position - /// * the bounds of the [`Button`] - /// * the local state of the [`Button`] - /// * the label of the [`Button`] - /// * the [`Class`] of the [`Button`] - /// - /// [`Button`]: struct.Button.html - /// [`State`]: struct.State.html - /// [`Class`]: enum.Class.html - fn draw( - &mut self, - cursor_position: Point, - bounds: Rectangle, - state: &State, - label: &str, - class: Class, - ) -> MouseCursor; -} - -impl<'a, Message, Renderer> From<Button<'a, Message>> - for Element<'a, Message, Renderer> -where - Renderer: self::Renderer, - Message: 'static + Copy + std::fmt::Debug, -{ - fn from(button: Button<'a, Message>) -> Element<'a, Message, Renderer> { - Element::new(button) - } -} diff --git a/src/widget/checkbox.rs b/src/widget/checkbox.rs deleted file mode 100644 index 48400fae..00000000 --- a/src/widget/checkbox.rs +++ /dev/null @@ -1,199 +0,0 @@ -//! Show toggle controls using checkboxes. -use std::hash::Hash; - -use crate::input::{mouse, ButtonState}; -use crate::widget::{text, Column, Row, Text}; -use crate::{ - Align, Color, Element, Event, Hasher, Layout, MouseCursor, Node, Point, - Rectangle, Widget, -}; - -/// A box that can be checked. -/// -/// It implements [`Widget`] when the associated `Renderer` implements the -/// [`checkbox::Renderer`] trait. -/// -/// [`Widget`]: ../trait.Widget.html -/// [`checkbox::Renderer`]: trait.Renderer.html -/// -/// # Example -/// -/// ``` -/// use iced::{Checkbox, Color}; -/// -/// pub enum Message { -/// CheckboxToggled(bool), -/// } -/// -/// let is_checked = true; -/// -/// Checkbox::new(is_checked, "Toggle me!", Message::CheckboxToggled); -/// ``` -/// -///  -pub struct Checkbox<Message> { - /// Whether the checkbox is checked or not - pub is_checked: bool, - - /// Function to call when checkbox is toggled to produce a __message__. - /// - /// The function should be provided `true` when the checkbox is checked - /// and `false` otherwise. - pub on_toggle: Box<dyn Fn(bool) -> Message>, - - /// The label of the checkbox - pub label: String, - - /// The color of the label - pub label_color: Option<Color>, -} - -impl<Message> std::fmt::Debug for Checkbox<Message> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("Checkbox") - .field("is_checked", &self.is_checked) - .field("label", &self.label) - .field("label_color", &self.label_color) - .finish() - } -} - -impl<Message> Checkbox<Message> { - /// Creates a new [`Checkbox`]. - /// - /// It expects: - /// * a boolean describing whether the [`Checkbox`] is checked or not - /// * the label of the [`Checkbox`] - /// * a function that will be called when the [`Checkbox`] is toggled. - /// It will receive the new state of the [`Checkbox`] and must produce - /// a `Message`. - /// - /// [`Checkbox`]: struct.Checkbox.html - pub fn new<F>(is_checked: bool, label: &str, f: F) -> Self - where - F: 'static + Fn(bool) -> Message, - { - Checkbox { - is_checked, - on_toggle: Box::new(f), - label: String::from(label), - label_color: None, - } - } - - /// Sets the color of the label of the [`Checkbox`]. - /// - /// [`Checkbox`]: struct.Checkbox.html - pub fn label_color<C: Into<Color>>(mut self, color: C) -> Self { - self.label_color = Some(color.into()); - self - } -} - -impl<Message, Renderer> Widget<Message, Renderer> for Checkbox<Message> -where - Renderer: self::Renderer + text::Renderer, -{ - fn node(&self, renderer: &mut Renderer) -> Node { - Row::<(), Renderer>::new() - .spacing(15) - .align_items(Align::Center) - .push(Column::new().width(28).height(28)) - .push(Text::new(&self.label)) - .node(renderer) - } - - fn on_event( - &mut self, - event: Event, - layout: Layout<'_>, - cursor_position: Point, - messages: &mut Vec<Message>, - ) { - match event { - Event::Mouse(mouse::Event::Input { - button: mouse::Button::Left, - state: ButtonState::Pressed, - }) => { - let mouse_over = layout - .children() - .any(|child| child.bounds().contains(cursor_position)); - - if mouse_over { - messages.push((self.on_toggle)(!self.is_checked)); - } - } - _ => {} - } - } - - fn draw( - &self, - renderer: &mut Renderer, - layout: Layout<'_>, - cursor_position: Point, - ) -> MouseCursor { - let children: Vec<_> = layout.children().collect(); - - let text_bounds = children[1].bounds(); - - text::Renderer::draw( - renderer, - text_bounds, - &self.label, - None, - self.label_color, - text::HorizontalAlignment::Left, - text::VerticalAlignment::Top, - ); - - self::Renderer::draw( - renderer, - cursor_position, - children[0].bounds(), - text_bounds, - self.is_checked, - ) - } - - fn hash_layout(&self, state: &mut Hasher) { - self.label.hash(state); - } -} - -/// The renderer of a [`Checkbox`]. -/// -/// Your [renderer] will need to implement this trait before being -/// able to use a [`Checkbox`] in your user interface. -/// -/// [`Checkbox`]: struct.Checkbox.html -/// [renderer]: ../../renderer/index.html -pub trait Renderer { - /// Draws a [`Checkbox`]. - /// - /// It receives: - /// * the current cursor position - /// * the bounds of the [`Checkbox`] - /// * the bounds of the label of the [`Checkbox`] - /// * whether the [`Checkbox`] is checked or not - /// - /// [`Checkbox`]: struct.Checkbox.html - fn draw( - &mut self, - cursor_position: Point, - bounds: Rectangle, - label_bounds: Rectangle, - is_checked: bool, - ) -> MouseCursor; -} - -impl<'a, Message, Renderer> From<Checkbox<Message>> - for Element<'a, Message, Renderer> -where - Renderer: self::Renderer + text::Renderer, - Message: 'static, -{ - fn from(checkbox: Checkbox<Message>) -> Element<'a, Message, Renderer> { - Element::new(checkbox) - } -} diff --git a/src/widget/column.rs b/src/widget/column.rs deleted file mode 100644 index 831f5b8f..00000000 --- a/src/widget/column.rs +++ /dev/null @@ -1,224 +0,0 @@ -use std::hash::Hash; - -use crate::{ - Align, Element, Event, Hasher, Justify, Layout, MouseCursor, Node, Point, - Style, Widget, -}; - -/// A container that distributes its contents vertically. -/// -/// A [`Column`] will try to fill the horizontal space of its container. -/// -/// [`Column`]: struct.Column.html -#[derive(Default)] -pub struct Column<'a, Message, Renderer> { - style: Style, - spacing: u16, - children: Vec<Element<'a, Message, Renderer>>, -} - -impl<'a, Message, Renderer> std::fmt::Debug for Column<'a, Message, Renderer> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("Column") - .field("style", &self.style) - .field("spacing", &self.spacing) - .field("children", &self.children) - .finish() - } -} - -impl<'a, Message, Renderer> Column<'a, Message, Renderer> { - /// Creates an empty [`Column`]. - /// - /// [`Column`]: struct.Column.html - pub fn new() -> Self { - let mut style = Style::default().fill_width(); - style.0.flex_direction = stretch::style::FlexDirection::Column; - - Column { - style, - spacing: 0, - children: Vec::new(), - } - } - - /// Sets the vertical spacing _between_ elements in pixels. - /// - /// Custom margins per element do not exist in Iced. You should use this - /// method instead! While less flexible, it helps you keep spacing between - /// elements consistent. - pub fn spacing(mut self, px: u16) -> Self { - self.spacing = px; - self - } - - /// Sets the padding of the [`Column`] in pixels. - /// - /// [`Column`]: struct.Column.html - pub fn padding(mut self, px: u16) -> Self { - self.style = self.style.padding(px); - self - } - - /// Sets the width of the [`Column`] in pixels. - /// - /// [`Column`]: struct.Column.html - pub fn width(mut self, width: u16) -> Self { - self.style = self.style.width(width); - self - } - - /// Sets the height of the [`Column`] in pixels. - /// - /// [`Column`]: struct.Column.html - pub fn height(mut self, height: u16) -> Self { - self.style = self.style.height(height); - self - } - - /// Sets the maximum width of the [`Column`] in pixels. - /// - /// [`Column`]: struct.Column.html - pub fn max_width(mut self, max_width: u16) -> Self { - self.style = self.style.max_width(max_width); - self - } - - /// Sets the maximum height of the [`Column`] in pixels. - /// - /// [`Column`]: struct.Column.html - pub fn max_height(mut self, max_height: u16) -> Self { - self.style = self.style.max_height(max_height); - self - } - - /// Sets the alignment of the [`Column`] itself. - /// - /// This is useful if you want to override the default alignment given by - /// the parent container. - /// - /// [`Column`]: struct.Column.html - pub fn align_self(mut self, align: Align) -> Self { - self.style = self.style.align_self(align); - self - } - - /// Sets the horizontal alignment of the contents of the [`Column`] . - /// - /// [`Column`]: struct.Column.html - pub fn align_items(mut self, align: Align) -> Self { - self.style = self.style.align_items(align); - self - } - - /// Sets the vertical distribution strategy for the contents of the - /// [`Column`] . - /// - /// [`Column`]: struct.Column.html - pub fn justify_content(mut self, justify: Justify) -> Self { - self.style = self.style.justify_content(justify); - self - } - - /// Adds an [`Element`] to the [`Column`]. - /// - /// [`Element`]: ../struct.Element.html - /// [`Column`]: struct.Column.html - pub fn push<E>(mut self, child: E) -> Column<'a, Message, Renderer> - where - E: Into<Element<'a, Message, Renderer>>, - { - self.children.push(child.into()); - self - } -} - -impl<'a, Message, Renderer> Widget<Message, Renderer> - for Column<'a, Message, Renderer> -{ - fn node(&self, renderer: &mut Renderer) -> Node { - let mut children: Vec<Node> = self - .children - .iter() - .map(|child| { - let mut node = child.widget.node(renderer); - - let mut style = node.0.style(); - style.margin.bottom = - stretch::style::Dimension::Points(f32::from(self.spacing)); - - node.0.set_style(style); - node - }) - .collect(); - - if let Some(node) = children.last_mut() { - let mut style = node.0.style(); - style.margin.bottom = stretch::style::Dimension::Undefined; - - node.0.set_style(style); - } - - Node::with_children(self.style, children) - } - - fn on_event( - &mut self, - event: Event, - layout: Layout<'_>, - cursor_position: Point, - messages: &mut Vec<Message>, - ) { - self.children.iter_mut().zip(layout.children()).for_each( - |(child, layout)| { - child - .widget - .on_event(event, layout, cursor_position, messages) - }, - ); - } - - fn draw( - &self, - renderer: &mut Renderer, - layout: Layout<'_>, - cursor_position: Point, - ) -> MouseCursor { - let mut cursor = MouseCursor::OutOfBounds; - - self.children.iter().zip(layout.children()).for_each( - |(child, layout)| { - let new_cursor = - child.widget.draw(renderer, layout, cursor_position); - - if new_cursor != MouseCursor::OutOfBounds { - cursor = new_cursor; - } - }, - ); - - cursor - } - - fn hash_layout(&self, state: &mut Hasher) { - self.style.hash(state); - self.spacing.hash(state); - - for child in &self.children { - child.widget.hash_layout(state); - } - } -} - -impl<'a, Message, Renderer> From<Column<'a, Message, Renderer>> - for Element<'a, Message, Renderer> -where - Renderer: 'a, - Message: 'static, -{ - fn from( - column: Column<'a, Message, Renderer>, - ) -> Element<'a, Message, Renderer> { - Element::new(column) - } -} diff --git a/src/widget/image.rs b/src/widget/image.rs deleted file mode 100644 index 1601234e..00000000 --- a/src/widget/image.rs +++ /dev/null @@ -1,180 +0,0 @@ -//! Display images in your user interface. - -use crate::{ - Align, Element, Hasher, Layout, MouseCursor, Node, Point, Rectangle, Style, - Widget, -}; - -use std::hash::Hash; - -/// A frame that displays an image while keeping aspect ratio. -/// -/// It implements [`Widget`] when the associated `Renderer` implements the -/// [`image::Renderer`] trait. -/// -/// [`Widget`]: ../../core/trait.Widget.html -/// [`image::Renderer`]: trait.Renderer.html -/// -/// # Example -/// -/// ``` -/// use iced::Image; -/// -/// # let my_handle = String::from("some_handle"); -/// let image = Image::new(my_handle); -/// ``` -pub struct Image<I> { - /// The image handle - pub image: I, - source: Option<Rectangle<u16>>, - /// The width of the image - pub width: Option<u16>, - height: Option<u16>, - style: Style, -} - -impl<I> std::fmt::Debug for Image<I> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("Image") - .field("source", &self.source) - .field("width", &self.width) - .field("height", &self.height) - .field("style", &self.style) - .finish() - } -} - -impl<I> Image<I> { - /// Creates a new [`Image`] with given image handle. - /// - /// [`Image`]: struct.Image.html - pub fn new(image: I) -> Self { - Image { - image, - source: None, - width: None, - height: None, - style: Style::default(), - } - } - - /// Sets the portion of the [`Image`] to draw. - /// - /// [`Image`]: struct.Image.html - pub fn clip(mut self, source: Rectangle<u16>) -> Self { - self.source = Some(source); - self - } - - /// Sets the width of the [`Image`] boundaries in pixels. - /// - /// [`Image`]: struct.Image.html - pub fn width(mut self, width: u16) -> Self { - self.width = Some(width); - self - } - - /// Sets the height of the [`Image`] boundaries in pixels. - /// - /// [`Image`]: struct.Image.html - pub fn height(mut self, height: u16) -> Self { - self.height = Some(height); - self - } - - /// Sets the alignment of the [`Image`] itself. - /// - /// This is useful if you want to override the default alignment given by - /// the parent container. - /// - /// [`Image`]: struct.Image.html - pub fn align_self(mut self, align: Align) -> Self { - self.style = self.style.align_self(align); - self - } -} - -impl<I, Message, Renderer> Widget<Message, Renderer> for Image<I> -where - Renderer: self::Renderer<I>, - I: Clone, -{ - fn node(&self, renderer: &mut Renderer) -> Node { - renderer.node( - self.style, - &self.image, - self.width, - self.height, - self.source, - ) - } - - fn draw( - &self, - renderer: &mut Renderer, - layout: Layout<'_>, - _cursor_position: Point, - ) -> MouseCursor { - renderer.draw(&self.image, layout.bounds(), self.source); - - MouseCursor::OutOfBounds - } - - fn hash_layout(&self, state: &mut Hasher) { - self.style.hash(state); - self.width.hash(state); - self.height.hash(state); - } -} - -/// The renderer of an [`Image`]. -/// -/// Your [renderer] will need to implement this trait before being able to use -/// an [`Image`] in your user interface. -/// -/// [`Image`]: struct.Image.html -/// [renderer]: ../../renderer/index.html -pub trait Renderer<I> { - /// Creates a [`Node`] with the given [`Style`] for the provided [`Image`] - /// and its size. - /// - /// You should probably keep the original aspect ratio, if possible. - /// - /// [`Node`]: ../../struct.Node.html - /// [`Style`]: ../../struct.Style.html - /// [`Image`]: struct.Image.html - fn node( - &mut self, - style: Style, - image: &I, - width: Option<u16>, - height: Option<u16>, - source: Option<Rectangle<u16>>, - ) -> Node; - - /// Draws an [`Image`]. - /// - /// It receives: - /// * the bounds of the [`Image`] - /// * the handle of the loaded [`Image`] - /// * the portion of the image to draw. If not specified, the entire image - /// should be drawn. - /// - /// [`Image`]: struct.Image.html - fn draw( - &mut self, - image: &I, - bounds: Rectangle<f32>, - source: Option<Rectangle<u16>>, - ); -} - -impl<'a, I, Message, Renderer> From<Image<I>> for Element<'a, Message, Renderer> -where - Renderer: self::Renderer<I>, - I: Clone + 'a, -{ - fn from(image: Image<I>) -> Element<'a, Message, Renderer> { - Element::new(image) - } -} diff --git a/src/widget/panel.rs b/src/widget/panel.rs deleted file mode 100644 index d43d6fb6..00000000 --- a/src/widget/panel.rs +++ /dev/null @@ -1,94 +0,0 @@ -use std::hash::Hash; - -use crate::graphics::{Point, Rectangle}; -use crate::ui::core::{ - Event, Hasher, Layout, MouseCursor, Node, Style, Widget, -}; - -pub struct Panel<'a, Message, Renderer> { - style: Style, - content: Box<Widget<Message, Renderer> + 'a>, -} - -impl<'a, Message, Renderer> Panel<'a, Message, Renderer> { - pub fn new(content: impl Widget<Message, Renderer> + 'a) -> Self { - Panel { - style: Style::default().padding(20), - content: Box::new(content), - } - } - - pub fn width(mut self, width: u32) -> Self { - self.style = self.style.width(width); - self - } - - pub fn max_width(mut self, max_width: u32) -> Self { - self.style = self.style.max_width(max_width); - self - } -} - -impl<'a, Message, Renderer> Widget<Message, Renderer> - for Panel<'a, Message, Renderer> -where - Renderer: self::Renderer, -{ - fn node(&self, renderer: &Renderer) -> Node { - Node::with_children(self.style, vec![self.content.node(renderer)]) - } - - fn on_event( - &mut self, - event: Event, - layout: Layout, - cursor_position: Point, - messages: &mut Vec<Message>, - ) { - [&mut self.content] - .iter_mut() - .zip(layout.children()) - .for_each(|(child, layout)| { - child.on_event(event, layout, cursor_position, messages) - }); - } - - fn draw( - &self, - renderer: &mut Renderer, - layout: Layout, - cursor_position: Point, - ) -> MouseCursor { - let bounds = layout.bounds(); - let mut cursor = MouseCursor::OutOfBounds; - renderer.draw(bounds); - - [&self.content].iter().zip(layout.children()).for_each( - |(child, layout)| { - let new_cursor = child.draw(renderer, layout, cursor_position); - - if new_cursor != MouseCursor::OutOfBounds { - cursor = new_cursor; - } - }, - ); - - if cursor == MouseCursor::OutOfBounds { - if bounds.contains(cursor_position) { - MouseCursor::Idle - } else { - MouseCursor::OutOfBounds - } - } else { - cursor - } - } - - fn hash(&self, state: &mut Hasher) { - self.style.hash(state); - } -} - -pub trait Renderer { - fn draw(&mut self, bounds: Rectangle); -} diff --git a/src/widget/progress_bar.rs b/src/widget/progress_bar.rs deleted file mode 100644 index d4499160..00000000 --- a/src/widget/progress_bar.rs +++ /dev/null @@ -1,106 +0,0 @@ -//! Provide visual feedback to your users when performing a slow task. - -use crate::{ - Element, Hasher, Layout, MouseCursor, Node, Point, Rectangle, Style, Widget, -}; - -use std::hash::Hash; - -/// A bar that is filled based on an amount of progress. -/// -/// It implements [`Widget`] when the associated `Renderer` implements the -/// [`progress_bar::Renderer`] trait. -/// -/// [`Widget`]: ../trait.Widget.html -/// [`progress_bar::Renderer`]: trait.Renderer.html -/// -/// # Example -/// -/// ``` -/// use iced::ProgressBar; -/// -/// let progress = 0.75; -/// -/// ProgressBar::new(progress); -/// ``` -#[derive(Debug)] -pub struct ProgressBar { - progress: f32, - style: Style, -} - -impl ProgressBar { - /// Creates a new [`ProgressBar`] filled based on the given amount of - /// progress. - /// - /// The progress should be in the `0.0..=1.0` range. `0` meaning no work - /// done, and `1` meaning work finished. - /// - /// [`ProgressBar`]: struct.ProgressBar.html - pub fn new(progress: f32) -> Self { - ProgressBar { - progress, - style: Style::default().fill_width(), - } - } - - /// Sets the width of the [`ProgressBar`] in pixels. - /// - /// [`ProgressBar`]: struct.ProgressBar.html - pub fn width(mut self, width: u16) -> Self { - self.style = self.style.width(width); - self - } -} - -impl<Message, Renderer> Widget<Message, Renderer> for ProgressBar -where - Renderer: self::Renderer, -{ - fn node(&self, _renderer: &Renderer) -> Node { - Node::new(self.style.height(50)) - } - - fn draw( - &self, - renderer: &mut Renderer, - layout: Layout<'_>, - _cursor_position: Point, - ) -> MouseCursor { - renderer.draw(layout.bounds(), self.progress); - - MouseCursor::OutOfBounds - } - - fn hash_layout(&self, state: &mut Hasher) { - self.style.hash(state); - } -} - -/// The renderer of a [`ProgressBar`]. -/// -/// Your [renderer] will need to implement this trait before being able to use -/// a [`ProgressBar`] in your user interface. -/// -/// [`ProgressBar`]: struct.ProgressBar.html -/// [renderer]: ../../renderer/index.html -pub trait Renderer { - /// Draws a [`ProgressBar`]. - /// - /// It receives: - /// * the bounds of the [`ProgressBar`] - /// * the current progress of the [`ProgressBar`], in the `0.0..=1.0` - /// range. - /// - /// [`ProgressBar`]: struct.ProgressBar.html - fn draw(&mut self, bounds: Rectangle, progress: f32); -} - -impl<'a, Message, Renderer> From<ProgressBar> for Element<'a, Message, Renderer> -where - Renderer: self::Renderer, -{ - fn from(progress_bar: ProgressBar) -> Element<'a, Message, Renderer> { - Element::new(progress_bar) - } -} diff --git a/src/widget/radio.rs b/src/widget/radio.rs deleted file mode 100644 index 048aea94..00000000 --- a/src/widget/radio.rs +++ /dev/null @@ -1,207 +0,0 @@ -//! Create choices using radio buttons. -use crate::input::{mouse, ButtonState}; -use crate::widget::{text, Column, Row, Text}; -use crate::{ - Align, Color, Element, Event, Hasher, Layout, MouseCursor, Node, Point, - Rectangle, Widget, -}; - -use std::hash::Hash; - -/// A circular button representing a choice. -/// -/// It implements [`Widget`] when the associated `Renderer` implements the -/// [`radio::Renderer`] trait. -/// -/// [`Widget`]: ../trait.Widget.html -/// [`radio::Renderer`]: trait.Renderer.html -/// -/// # Example -/// ``` -/// use iced::Radio; -/// -/// #[derive(Debug, Clone, Copy, PartialEq, Eq)] -/// pub enum Choice { -/// A, -/// B, -/// } -/// -/// #[derive(Debug, Clone, Copy)] -/// pub enum Message { -/// RadioSelected(Choice), -/// } -/// -/// let selected_choice = Some(Choice::A); -/// -/// Radio::new(Choice::A, "This is A", selected_choice, Message::RadioSelected); -/// -/// Radio::new(Choice::B, "This is B", selected_choice, Message::RadioSelected); -/// ``` -/// -///  -pub struct Radio<Message> { - /// Whether the radio button is selected or not - pub is_selected: bool, - - /// The message to produce when the radio button is clicked - pub on_click: Message, - - /// The label of the radio button - pub label: String, - - /// The color of the label - pub label_color: Option<Color>, -} - -impl<Message> std::fmt::Debug for Radio<Message> -where - Message: std::fmt::Debug, -{ - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("Radio") - .field("is_selected", &self.is_selected) - .field("on_click", &self.on_click) - .field("label", &self.label) - .field("label_color", &self.label_color) - .finish() - } -} - -impl<Message> Radio<Message> { - /// Creates a new [`Radio`] button. - /// - /// It expects: - /// * the value related to the [`Radio`] button - /// * the label of the [`Radio`] button - /// * the current selected value - /// * a function that will be called when the [`Radio`] is selected. It - /// receives the value of the radio and must produce a `Message`. - /// - /// [`Radio`]: struct.Radio.html - pub fn new<F, V>(value: V, label: &str, selected: Option<V>, f: F) -> Self - where - V: Eq + Copy, - F: 'static + Fn(V) -> Message, - { - Radio { - is_selected: Some(value) == selected, - on_click: f(value), - label: String::from(label), - label_color: None, - } - } - - /// Sets the `Color` of the label of the [`Radio`]. - /// - /// [`Radio`]: struct.Radio.html - pub fn label_color<C: Into<Color>>(mut self, color: C) -> Self { - self.label_color = Some(color.into()); - self - } -} - -impl<Message, Renderer> Widget<Message, Renderer> for Radio<Message> -where - Renderer: self::Renderer + text::Renderer, - Message: Copy + std::fmt::Debug, -{ - fn node(&self, renderer: &mut Renderer) -> Node { - Row::<(), Renderer>::new() - .spacing(15) - .align_items(Align::Center) - .push(Column::new().width(28).height(28)) - .push(Text::new(&self.label)) - .node(renderer) - } - - fn on_event( - &mut self, - event: Event, - layout: Layout<'_>, - cursor_position: Point, - messages: &mut Vec<Message>, - ) { - match event { - Event::Mouse(mouse::Event::Input { - button: mouse::Button::Left, - state: ButtonState::Pressed, - }) => { - if layout.bounds().contains(cursor_position) { - messages.push(self.on_click); - } - } - _ => {} - } - } - - fn draw( - &self, - renderer: &mut Renderer, - layout: Layout<'_>, - cursor_position: Point, - ) -> MouseCursor { - let children: Vec<_> = layout.children().collect(); - - let mut text_bounds = children[1].bounds(); - text_bounds.y -= 2.0; - - text::Renderer::draw( - renderer, - text_bounds, - &self.label, - None, - self.label_color, - text::HorizontalAlignment::Left, - text::VerticalAlignment::Top, - ); - - self::Renderer::draw( - renderer, - cursor_position, - children[0].bounds(), - layout.bounds(), - self.is_selected, - ) - } - - fn hash_layout(&self, state: &mut Hasher) { - self.label.hash(state); - } -} - -/// The renderer of a [`Radio`] button. -/// -/// Your [renderer] will need to implement this trait before being -/// able to use a [`Radio`] button in your user interface. -/// -/// [`Radio`]: struct.Radio.html -/// [renderer]: ../../renderer/index.html -pub trait Renderer { - /// Draws a [`Radio`] button. - /// - /// It receives: - /// * the current cursor position - /// * the bounds of the [`Radio`] - /// * the bounds of the label of the [`Radio`] - /// * whether the [`Radio`] is selected or not - /// - /// [`Radio`]: struct.Radio.html - fn draw( - &mut self, - cursor_position: Point, - bounds: Rectangle, - label_bounds: Rectangle, - is_selected: bool, - ) -> MouseCursor; -} - -impl<'a, Message, Renderer> From<Radio<Message>> - for Element<'a, Message, Renderer> -where - Renderer: self::Renderer + text::Renderer, - Message: 'static + Copy + std::fmt::Debug, -{ - fn from(checkbox: Radio<Message>) -> Element<'a, Message, Renderer> { - Element::new(checkbox) - } -} diff --git a/src/widget/row.rs b/src/widget/row.rs deleted file mode 100644 index 181020e3..00000000 --- a/src/widget/row.rs +++ /dev/null @@ -1,219 +0,0 @@ -use std::hash::Hash; - -use crate::{ - Align, Element, Event, Hasher, Justify, Layout, MouseCursor, Node, Point, - Style, Widget, -}; - -/// A container that distributes its contents horizontally. -/// -/// A [`Row`] will try to fill the horizontal space of its container. -/// -/// [`Row`]: struct.Row.html -#[derive(Default)] -pub struct Row<'a, Message, Renderer> { - style: Style, - spacing: u16, - children: Vec<Element<'a, Message, Renderer>>, -} - -impl<'a, Message, Renderer> std::fmt::Debug for Row<'a, Message, Renderer> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("Row") - .field("style", &self.style) - .field("spacing", &self.spacing) - .field("children", &self.children) - .finish() - } -} - -impl<'a, Message, Renderer> Row<'a, Message, Renderer> { - /// Creates an empty [`Row`]. - /// - /// [`Row`]: struct.Row.html - pub fn new() -> Self { - Row { - style: Style::default().fill_width(), - spacing: 0, - children: Vec::new(), - } - } - - /// Sets the horizontal spacing _between_ elements in pixels. - /// - /// Custom margins per element do not exist in Iced. You should use this - /// method instead! While less flexible, it helps you keep spacing between - /// elements consistent. - pub fn spacing(mut self, px: u16) -> Self { - self.spacing = px; - self - } - - /// Sets the padding of the [`Row`] in pixels. - /// - /// [`Row`]: struct.Row.html - pub fn padding(mut self, px: u16) -> Self { - self.style = self.style.padding(px); - self - } - - /// Sets the width of the [`Row`] in pixels. - /// - /// [`Row`]: struct.Row.html - pub fn width(mut self, width: u16) -> Self { - self.style = self.style.width(width); - self - } - - /// Sets the height of the [`Row`] in pixels. - /// - /// [`Row`]: struct.Row.html - pub fn height(mut self, height: u16) -> Self { - self.style = self.style.height(height); - self - } - - /// Sets the maximum width of the [`Row`] in pixels. - /// - /// [`Row`]: struct.Row.html - pub fn max_width(mut self, max_width: u16) -> Self { - self.style = self.style.max_width(max_width); - self - } - - /// Sets the maximum height of the [`Row`] in pixels. - /// - /// [`Row`]: struct.Row.html - pub fn max_height(mut self, max_height: u16) -> Self { - self.style = self.style.max_height(max_height); - self - } - - /// Sets the alignment of the [`Row`] itself. - /// - /// This is useful if you want to override the default alignment given by - /// the parent container. - /// - /// [`Row`]: struct.Row.html - pub fn align_self(mut self, align: Align) -> Self { - self.style = self.style.align_self(align); - self - } - - /// Sets the vertical alignment of the contents of the [`Row`] . - /// - /// [`Row`]: struct.Row.html - pub fn align_items(mut self, align: Align) -> Self { - self.style = self.style.align_items(align); - self - } - - /// Sets the horizontal distribution strategy for the contents of the - /// [`Row`] . - /// - /// [`Row`]: struct.Row.html - pub fn justify_content(mut self, justify: Justify) -> Self { - self.style = self.style.justify_content(justify); - self - } - - /// Adds an [`Element`] to the [`Row`]. - /// - /// [`Element`]: ../struct.Element.html - /// [`Row`]: struct.Row.html - pub fn push<E>(mut self, child: E) -> Row<'a, Message, Renderer> - where - E: Into<Element<'a, Message, Renderer>>, - { - self.children.push(child.into()); - self - } -} - -impl<'a, Message, Renderer> Widget<Message, Renderer> - for Row<'a, Message, Renderer> -{ - fn node(&self, renderer: &mut Renderer) -> Node { - let mut children: Vec<Node> = self - .children - .iter() - .map(|child| { - let mut node = child.widget.node(renderer); - - let mut style = node.0.style(); - style.margin.end = - stretch::style::Dimension::Points(f32::from(self.spacing)); - - node.0.set_style(style); - node - }) - .collect(); - - if let Some(node) = children.last_mut() { - let mut style = node.0.style(); - style.margin.end = stretch::style::Dimension::Undefined; - - node.0.set_style(style); - } - - Node::with_children(self.style, children) - } - - fn on_event( - &mut self, - event: Event, - layout: Layout<'_>, - cursor_position: Point, - messages: &mut Vec<Message>, - ) { - self.children.iter_mut().zip(layout.children()).for_each( - |(child, layout)| { - child - .widget - .on_event(event, layout, cursor_position, messages) - }, - ); - } - - fn draw( - &self, - renderer: &mut Renderer, - layout: Layout<'_>, - cursor_position: Point, - ) -> MouseCursor { - let mut cursor = MouseCursor::OutOfBounds; - - self.children.iter().zip(layout.children()).for_each( - |(child, layout)| { - let new_cursor = - child.widget.draw(renderer, layout, cursor_position); - - if new_cursor != MouseCursor::OutOfBounds { - cursor = new_cursor; - } - }, - ); - - cursor - } - - fn hash_layout(&self, state: &mut Hasher) { - self.style.hash(state); - self.spacing.hash(state); - - for child in &self.children { - child.widget.hash_layout(state); - } - } -} - -impl<'a, Message, Renderer> From<Row<'a, Message, Renderer>> - for Element<'a, Message, Renderer> -where - Renderer: 'a, - Message: 'static, -{ - fn from(row: Row<'a, Message, Renderer>) -> Element<'a, Message, Renderer> { - Element::new(row) - } -} diff --git a/src/widget/slider.rs b/src/widget/slider.rs deleted file mode 100644 index fb6db8c9..00000000 --- a/src/widget/slider.rs +++ /dev/null @@ -1,245 +0,0 @@ -//! Display an interactive selector of a single value from a range of values. -//! -//! A [`Slider`] has some local [`State`]. -//! -//! [`Slider`]: struct.Slider.html -//! [`State`]: struct.State.html -use std::hash::Hash; -use std::ops::RangeInclusive; -use std::rc::Rc; - -use crate::input::{mouse, ButtonState}; -use crate::{ - Element, Event, Hasher, Layout, MouseCursor, Node, Point, Rectangle, Style, - Widget, -}; - -/// An horizontal bar and a handle that selects a single value from a range of -/// values. -/// -/// A [`Slider`] will try to fill the horizontal space of its container. -/// -/// It implements [`Widget`] when the associated `Renderer` implements the -/// [`slider::Renderer`] trait. -/// -/// [`Slider`]: struct.Slider.html -/// [`Widget`]: ../trait.Widget.html -/// [`slider::Renderer`]: trait.Renderer.html -/// -/// # Example -/// ``` -/// use iced::{slider, Slider}; -/// -/// pub enum Message { -/// SliderChanged(f32), -/// } -/// -/// let state = &mut slider::State::new(); -/// let value = 50.0; -/// -/// Slider::new(state, 0.0..=100.0, value, Message::SliderChanged); -/// ``` -/// -///  -pub struct Slider<'a, Message> { - state: &'a mut State, - /// The range of the slider - pub range: RangeInclusive<f32>, - /// The current value of the slider - pub value: f32, - /// The function to produce messages on change - pub on_change: Rc<Box<dyn Fn(f32) -> Message>>, - style: Style, -} - -impl<'a, Message> std::fmt::Debug for Slider<'a, Message> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("Slider") - .field("state", &self.state) - .field("range", &self.range) - .field("value", &self.value) - .field("style", &self.style) - .finish() - } -} - -impl<'a, Message> Slider<'a, Message> { - /// Creates a new [`Slider`]. - /// - /// It expects: - /// * the local [`State`] of the [`Slider`] - /// * an inclusive range of possible values - /// * the current value of the [`Slider`] - /// * a function that will be called when the [`Slider`] is dragged. - /// It receives the new value of the [`Slider`] and must produce a - /// `Message`. - /// - /// [`Slider`]: struct.Slider.html - /// [`State`]: struct.State.html - pub fn new<F>( - state: &'a mut State, - range: RangeInclusive<f32>, - value: f32, - on_change: F, - ) -> Self - where - F: 'static + Fn(f32) -> Message, - { - Slider { - state, - value: value.max(*range.start()).min(*range.end()), - range, - on_change: Rc::new(Box::new(on_change)), - style: Style::default().min_width(100).fill_width(), - } - } - - /// Sets the width of the [`Slider`] in pixels. - /// - /// [`Slider`]: struct.Slider.html - pub fn width(mut self, width: u16) -> Self { - self.style = self.style.width(width); - self - } -} - -impl<'a, Message, Renderer> Widget<Message, Renderer> for Slider<'a, Message> -where - Renderer: self::Renderer, -{ - fn node(&self, _renderer: &mut Renderer) -> Node { - Node::new(self.style.height(25)) - } - - fn on_event( - &mut self, - event: Event, - layout: Layout<'_>, - cursor_position: Point, - messages: &mut Vec<Message>, - ) { - let mut change = || { - let bounds = layout.bounds(); - - if cursor_position.x <= bounds.x { - messages.push((self.on_change)(*self.range.start())); - } else if cursor_position.x >= bounds.x + bounds.width { - messages.push((self.on_change)(*self.range.end())); - } else { - let percent = (cursor_position.x - bounds.x) / bounds.width; - let value = (self.range.end() - self.range.start()) * percent - + self.range.start(); - - messages.push((self.on_change)(value)); - } - }; - - match event { - Event::Mouse(mouse::Event::Input { - button: mouse::Button::Left, - state, - }) => match state { - ButtonState::Pressed => { - if layout.bounds().contains(cursor_position) { - change(); - self.state.is_dragging = true; - } - } - ButtonState::Released => { - self.state.is_dragging = false; - } - }, - Event::Mouse(mouse::Event::CursorMoved { .. }) => { - if self.state.is_dragging { - change(); - } - } - _ => {} - } - } - - fn draw( - &self, - renderer: &mut Renderer, - layout: Layout<'_>, - cursor_position: Point, - ) -> MouseCursor { - renderer.draw( - cursor_position, - layout.bounds(), - self.state, - self.range.clone(), - self.value, - ) - } - - fn hash_layout(&self, state: &mut Hasher) { - self.style.hash(state); - } -} - -/// The local state of a [`Slider`]. -/// -/// [`Slider`]: struct.Slider.html -#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] -pub struct State { - is_dragging: bool, -} - -impl State { - /// Creates a new [`State`]. - /// - /// [`State`]: struct.State.html - pub fn new() -> State { - State::default() - } - - /// Returns whether the associated [`Slider`] is currently being dragged or - /// not. - /// - /// [`Slider`]: struct.Slider.html - pub fn is_dragging(&self) -> bool { - self.is_dragging - } -} - -/// The renderer of a [`Slider`]. -/// -/// Your [renderer] will need to implement this trait before being -/// able to use a [`Slider`] in your user interface. -/// -/// [`Slider`]: struct.Slider.html -/// [renderer]: ../../renderer/index.html -pub trait Renderer { - /// Draws a [`Slider`]. - /// - /// It receives: - /// * the current cursor position - /// * the bounds of the [`Slider`] - /// * the local state of the [`Slider`] - /// * the range of values of the [`Slider`] - /// * the current value of the [`Slider`] - /// - /// [`Slider`]: struct.Slider.html - /// [`State`]: struct.State.html - /// [`Class`]: enum.Class.html - fn draw( - &mut self, - cursor_position: Point, - bounds: Rectangle, - state: &State, - range: RangeInclusive<f32>, - value: f32, - ) -> MouseCursor; -} - -impl<'a, Message, Renderer> From<Slider<'a, Message>> - for Element<'a, Message, Renderer> -where - Renderer: self::Renderer, - Message: 'static, -{ - fn from(slider: Slider<'a, Message>) -> Element<'a, Message, Renderer> { - Element::new(slider) - } -} diff --git a/src/widget/text.rs b/src/widget/text.rs deleted file mode 100644 index 4ef10d52..00000000 --- a/src/widget/text.rs +++ /dev/null @@ -1,218 +0,0 @@ -//! Write some text for your users to read. -use crate::{ - Color, Element, Hasher, Layout, MouseCursor, Node, Point, Rectangle, Style, - Widget, -}; - -use std::hash::Hash; - -/// A paragraph of text. -/// -/// It implements [`Widget`] when the associated `Renderer` implements the -/// [`text::Renderer`] trait. -/// -/// [`Widget`]: ../trait.Widget.html -/// [`text::Renderer`]: trait.Renderer.html -/// -/// # Example -/// -/// ``` -/// use iced::{Text, Color}; -/// -/// Text::new("I <3 iced!") -/// .size(40); -/// ``` -#[derive(Debug, Clone)] -pub struct Text { - /// The text contents - pub content: String, - /// The text size - pub size: Option<u16>, - color: Option<Color>, - style: Style, - horizontal_alignment: HorizontalAlignment, - vertical_alignment: VerticalAlignment, -} - -impl Text { - /// Create a new fragment of [`Text`] with the given contents. - /// - /// [`Text`]: struct.Text.html - pub fn new(label: &str) -> Self { - Text { - content: String::from(label), - size: None, - color: None, - style: Style::default().fill_width(), - horizontal_alignment: HorizontalAlignment::Left, - vertical_alignment: VerticalAlignment::Top, - } - } - - /// Sets the size of the [`Text`] in pixels. - /// - /// [`Text`]: struct.Text.html - pub fn size(mut self, size: u16) -> Self { - self.size = Some(size); - self - } - - /// Sets the `Color` of the [`Text`]. - /// - /// [`Text`]: struct.Text.html - pub fn color<C: Into<Color>>(mut self, color: C) -> Self { - self.color = Some(color.into()); - self - } - - /// Sets the width of the [`Text`] boundaries in pixels. - /// - /// [`Text`]: struct.Text.html - pub fn width(mut self, width: u16) -> Self { - self.style = self.style.width(width); - self - } - - /// Sets the height of the [`Text`] boundaries in pixels. - /// - /// [`Text`]: struct.Text.html - pub fn height(mut self, height: u16) -> Self { - self.style = self.style.height(height); - self - } - - /// Sets the [`HorizontalAlignment`] of the [`Text`]. - /// - /// [`Text`]: struct.Text.html - /// [`HorizontalAlignment`]: enum.HorizontalAlignment.html - pub fn horizontal_alignment( - mut self, - alignment: HorizontalAlignment, - ) -> Self { - self.horizontal_alignment = alignment; - self - } - - /// Sets the [`VerticalAlignment`] of the [`Text`]. - /// - /// [`Text`]: struct.Text.html - /// [`VerticalAlignment`]: enum.VerticalAlignment.html - pub fn vertical_alignment(mut self, alignment: VerticalAlignment) -> Self { - self.vertical_alignment = alignment; - self - } -} - -impl<Message, Renderer> Widget<Message, Renderer> for Text -where - Renderer: self::Renderer, -{ - fn node(&self, renderer: &mut Renderer) -> Node { - renderer.node(self.style, &self.content, self.size) - } - - fn draw( - &self, - renderer: &mut Renderer, - layout: Layout<'_>, - _cursor_position: Point, - ) -> MouseCursor { - renderer.draw( - layout.bounds(), - &self.content, - self.size, - self.color, - self.horizontal_alignment, - self.vertical_alignment, - ); - - MouseCursor::OutOfBounds - } - - fn hash_layout(&self, state: &mut Hasher) { - self.style.hash(state); - - self.content.hash(state); - self.size.hash(state); - } -} - -/// The renderer of a [`Text`] fragment. -/// -/// Your [renderer] will need to implement this trait before being -/// able to use [`Text`] in your [`UserInterface`]. -/// -/// [`Text`]: struct.Text.html -/// [renderer]: ../../renderer/index.html -/// [`UserInterface`]: ../../struct.UserInterface.html -pub trait Renderer { - /// Creates a [`Node`] with the given [`Style`] for the provided [`Text`] - /// contents and size. - /// - /// You should probably use [`Node::with_measure`] to allow [`Text`] to - /// adapt to the dimensions of its container. - /// - /// [`Node`]: ../../struct.Node.html - /// [`Style`]: ../../struct.Style.html - /// [`Text`]: struct.Text.html - /// [`Node::with_measure`]: ../../struct.Node.html#method.with_measure - fn node(&self, style: Style, content: &str, size: Option<u16>) -> Node; - - /// Draws a [`Text`] fragment. - /// - /// It receives: - /// * the bounds of the [`Text`] - /// * the contents of the [`Text`] - /// * the size of the [`Text`] - /// * the color of the [`Text`] - /// * the [`HorizontalAlignment`] of the [`Text`] - /// * the [`VerticalAlignment`] of the [`Text`] - /// - /// [`Text`]: struct.Text.html - /// [`HorizontalAlignment`]: enum.HorizontalAlignment.html - /// [`VerticalAlignment`]: enum.VerticalAlignment.html - fn draw( - &mut self, - bounds: Rectangle, - content: &str, - size: Option<u16>, - color: Option<Color>, - horizontal_alignment: HorizontalAlignment, - vertical_alignment: VerticalAlignment, - ); -} - -impl<'a, Message, Renderer> From<Text> for Element<'a, Message, Renderer> -where - Renderer: self::Renderer, -{ - fn from(text: Text) -> Element<'a, Message, Renderer> { - Element::new(text) - } -} - -/// The horizontal alignment of some resource. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum HorizontalAlignment { - /// Align left - Left, - - /// Horizontally centered - Center, - - /// Align right - Right, -} - -/// The vertical alignment of some resource. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum VerticalAlignment { - /// Align top - Top, - - /// Vertically centered - Center, - - /// Align bottom - Bottom, -} diff --git a/web/Cargo.toml b/web/Cargo.toml index 43377d46..d5a987b0 100644 --- a/web/Cargo.toml +++ b/web/Cargo.toml @@ -15,7 +15,7 @@ categories = ["web-programming"] maintenance = { status = "actively-developed" } [dependencies] -iced = { version = "0.1.0-alpha", path = ".." } +iced_core = { version = "0.1.0-alpha", path = "../core" } dodrio = "0.1.0" futures-preview = "=0.3.0-alpha.18" wasm-bindgen = "0.2.50" diff --git a/web/src/lib.rs b/web/src/lib.rs index a6dc2b79..09ca3460 100644 --- a/web/src/lib.rs +++ b/web/src/lib.rs @@ -8,7 +8,7 @@ mod widget; pub use bus::Bus; pub use element::Element; -pub use iced::{Align, Color}; +pub use iced_core::{Align, Color, Length}; pub use widget::*; pub trait UserInterface { diff --git a/web/src/widget/button.rs b/web/src/widget/button.rs index 63c0262a..36b35901 100644 --- a/web/src/widget/button.rs +++ b/web/src/widget/button.rs @@ -1,9 +1,8 @@ use crate::{Bus, Element, Widget}; -pub use iced::button::{Class, State}; use dodrio::bumpalo; -pub type Button<'a, Message> = iced::Button<'a, Message>; +pub type Button<'a, Message> = iced_core::Button<'a, Message>; impl<'a, Message> Widget<Message> for Button<'a, Message> where diff --git a/web/src/widget/checkbox.rs b/web/src/widget/checkbox.rs index 5aadd65d..34995781 100644 --- a/web/src/widget/checkbox.rs +++ b/web/src/widget/checkbox.rs @@ -2,7 +2,7 @@ use crate::{Bus, Element, Widget}; use dodrio::bumpalo; -pub use iced::Checkbox; +pub use iced_core::Checkbox; impl<Message> Widget<Message> for Checkbox<Message> where diff --git a/web/src/widget/column.rs b/web/src/widget/column.rs index a2b8232e..99491647 100644 --- a/web/src/widget/column.rs +++ b/web/src/widget/column.rs @@ -1,42 +1,8 @@ -use crate::{Align, Bus, Element, Widget}; +use crate::{Bus, Element, Widget}; use dodrio::bumpalo; -pub struct Column<'a, Message> { - children: Vec<Element<'a, Message>>, -} - -impl<'a, Message> Column<'a, Message> { - pub fn new() -> Self { - Self { - children: Vec::new(), - } - } - - pub fn spacing(self, _spacing: u16) -> Self { - self - } - - pub fn padding(self, _padding: u16) -> Self { - self - } - - pub fn max_width(self, _max_width: u16) -> Self { - self - } - - pub fn align_items(self, _align: Align) -> Self { - self - } - - pub fn push<E>(mut self, element: E) -> Self - where - E: Into<Element<'a, Message>>, - { - self.children.push(element.into()); - self - } -} +pub type Column<'a, Message> = iced_core::Column<Element<'a, Message>>; impl<'a, Message> Widget<Message> for Column<'a, Message> { fn node<'b>( diff --git a/web/src/widget/image.rs b/web/src/widget/image.rs index a882faff..48ff539f 100644 --- a/web/src/widget/image.rs +++ b/web/src/widget/image.rs @@ -1,8 +1,8 @@ -use crate::{Bus, Element, Widget}; +use crate::{Bus, Element, Length, Widget}; use dodrio::bumpalo; -pub type Image<'a> = iced::Image<&'a str>; +pub type Image<'a> = iced_core::Image<&'a str>; impl<'a, Message> Widget<Message> for Image<'a> { fn node<'b>( @@ -12,13 +12,21 @@ impl<'a, Message> Widget<Message> for Image<'a> { ) -> dodrio::Node<'b> { use dodrio::builder::*; - let src = bumpalo::format!(in bump, "{}", self.image); + let src = bumpalo::format!(in bump, "{}", self.handle); let mut image = img(bump).attr("src", src.into_bump_str()); - if let Some(width) = self.width { - let width = bumpalo::format!(in bump, "{}", width); - image = image.attr("width", width.into_bump_str()); + match self.width { + Length::Shrink => {} + Length::Fill => { + image = image.attr("width", "100%"); + } + Length::Units(px) => { + image = image.attr( + "width", + bumpalo::format!(in bump, "{}px", px).into_bump_str(), + ); + } } image.finish() diff --git a/web/src/widget/radio.rs b/web/src/widget/radio.rs index e762ae28..9063770a 100644 --- a/web/src/widget/radio.rs +++ b/web/src/widget/radio.rs @@ -2,7 +2,7 @@ use crate::{Bus, Element, Widget}; use dodrio::bumpalo; -pub use iced::Radio; +pub use iced_core::Radio; impl<Message> Widget<Message> for Radio<Message> where diff --git a/web/src/widget/row.rs b/web/src/widget/row.rs index 71532245..d4f4c4a0 100644 --- a/web/src/widget/row.rs +++ b/web/src/widget/row.rs @@ -2,29 +2,7 @@ use crate::{Bus, Element, Widget}; use dodrio::bumpalo; -pub struct Row<'a, Message> { - children: Vec<Element<'a, Message>>, -} - -impl<'a, Message> Row<'a, Message> { - pub fn new() -> Self { - Self { - children: Vec::new(), - } - } - - pub fn spacing(self, _spacing: u16) -> Self { - self - } - - pub fn push<E>(mut self, element: E) -> Self - where - E: Into<Element<'a, Message>>, - { - self.children.push(element.into()); - self - } -} +pub type Row<'a, Message> = iced_core::Row<Element<'a, Message>>; impl<'a, Message> Widget<Message> for Row<'a, Message> { fn node<'b>( diff --git a/web/src/widget/slider.rs b/web/src/widget/slider.rs index 31bfcbf3..19668025 100644 --- a/web/src/widget/slider.rs +++ b/web/src/widget/slider.rs @@ -2,9 +2,9 @@ use crate::{Bus, Element, Widget}; use dodrio::bumpalo; -pub type Slider<'a, Message> = iced::Slider<'a, Message>; +pub type Slider<'a, Message> = iced_core::Slider<'a, Message>; -pub use iced::slider::State; +pub use iced_core::slider::State; impl<'a, Message> Widget<Message> for Slider<'a, Message> where diff --git a/web/src/widget/text.rs b/web/src/widget/text.rs index a5709775..ef9170ef 100644 --- a/web/src/widget/text.rs +++ b/web/src/widget/text.rs @@ -1,7 +1,7 @@ use crate::{Bus, Element, Widget}; use dodrio::bumpalo; -pub use iced::text::*; +pub use iced_core::text::*; impl<'a, Message> Widget<Message> for Text { fn node<'b>( |