summaryrefslogtreecommitdiffstats
path: root/core/src/widget
diff options
context:
space:
mode:
Diffstat (limited to 'core/src/widget')
-rw-r--r--core/src/widget/id.rs43
-rw-r--r--core/src/widget/operation.rs226
-rw-r--r--core/src/widget/operation/focusable.rs203
-rw-r--r--core/src/widget/operation/scrollable.rs93
-rw-r--r--core/src/widget/operation/text_input.rs131
-rw-r--r--core/src/widget/text.rs304
-rw-r--r--core/src/widget/tree.rs187
7 files changed, 1187 insertions, 0 deletions
diff --git a/core/src/widget/id.rs b/core/src/widget/id.rs
new file mode 100644
index 00000000..ae739bb7
--- /dev/null
+++ b/core/src/widget/id.rs
@@ -0,0 +1,43 @@
+use std::borrow;
+use std::sync::atomic::{self, AtomicUsize};
+
+static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
+
+/// The identifier of a generic widget.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Id(Internal);
+
+impl Id {
+ /// Creates a custom [`Id`].
+ pub fn new(id: impl Into<borrow::Cow<'static, str>>) -> Self {
+ Self(Internal::Custom(id.into()))
+ }
+
+ /// Creates a unique [`Id`].
+ ///
+ /// This function produces a different [`Id`] every time it is called.
+ pub fn unique() -> Self {
+ let id = NEXT_ID.fetch_add(1, atomic::Ordering::Relaxed);
+
+ Self(Internal::Unique(id))
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+enum Internal {
+ Unique(usize),
+ Custom(borrow::Cow<'static, str>),
+}
+
+#[cfg(test)]
+mod tests {
+ use super::Id;
+
+ #[test]
+ fn unique_generates_different_ids() {
+ let a = Id::unique();
+ let b = Id::unique();
+
+ assert_ne!(a, b);
+ }
+}
diff --git a/core/src/widget/operation.rs b/core/src/widget/operation.rs
new file mode 100644
index 00000000..ad188c36
--- /dev/null
+++ b/core/src/widget/operation.rs
@@ -0,0 +1,226 @@
+//! Query or update internal widget state.
+pub mod focusable;
+pub mod scrollable;
+pub mod text_input;
+
+pub use focusable::Focusable;
+pub use scrollable::Scrollable;
+pub use text_input::TextInput;
+
+use crate::widget::Id;
+
+use std::any::Any;
+use std::fmt;
+use std::rc::Rc;
+
+/// A piece of logic that can traverse the widget tree of an application in
+/// order to query or update some widget state.
+pub trait Operation<T> {
+ /// Operates on a widget that contains other widgets.
+ ///
+ /// The `operate_on_children` function can be called to return control to
+ /// the widget tree and keep traversing it.
+ fn container(
+ &mut self,
+ id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+ );
+
+ /// Operates on a widget that can be focused.
+ fn focusable(&mut self, _state: &mut dyn Focusable, _id: Option<&Id>) {}
+
+ /// Operates on a widget that can be scrolled.
+ fn scrollable(&mut self, _state: &mut dyn Scrollable, _id: Option<&Id>) {}
+
+ /// Operates on a widget that has text input.
+ fn text_input(&mut self, _state: &mut dyn TextInput, _id: Option<&Id>) {}
+
+ /// Operates on a custom widget with some state.
+ fn custom(&mut self, _state: &mut dyn Any, _id: Option<&Id>) {}
+
+ /// Finishes the [`Operation`] and returns its [`Outcome`].
+ fn finish(&self) -> Outcome<T> {
+ Outcome::None
+ }
+}
+
+/// The result of an [`Operation`].
+pub enum Outcome<T> {
+ /// The [`Operation`] produced no result.
+ None,
+
+ /// The [`Operation`] produced some result.
+ Some(T),
+
+ /// The [`Operation`] needs to be followed by another [`Operation`].
+ Chain(Box<dyn Operation<T>>),
+}
+
+impl<T> fmt::Debug for Outcome<T>
+where
+ T: fmt::Debug,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::None => write!(f, "Outcome::None"),
+ Self::Some(output) => write!(f, "Outcome::Some({output:?})"),
+ Self::Chain(_) => write!(f, "Outcome::Chain(...)"),
+ }
+ }
+}
+
+/// Maps the output of an [`Operation`] using the given function.
+pub fn map<A, B>(
+ operation: Box<dyn Operation<A>>,
+ f: impl Fn(A) -> B + 'static,
+) -> impl Operation<B>
+where
+ A: 'static,
+ B: 'static,
+{
+ #[allow(missing_debug_implementations)]
+ struct Map<A, B> {
+ operation: Box<dyn Operation<A>>,
+ f: Rc<dyn Fn(A) -> B>,
+ }
+
+ impl<A, B> Operation<B> for Map<A, B>
+ where
+ A: 'static,
+ B: 'static,
+ {
+ fn container(
+ &mut self,
+ id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<B>),
+ ) {
+ struct MapRef<'a, A> {
+ operation: &'a mut dyn Operation<A>,
+ }
+
+ impl<'a, A, B> Operation<B> for MapRef<'a, A> {
+ fn container(
+ &mut self,
+ id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<B>),
+ ) {
+ let Self { operation, .. } = self;
+
+ operation.container(id, &mut |operation| {
+ operate_on_children(&mut MapRef { operation });
+ });
+ }
+
+ fn scrollable(
+ &mut self,
+ state: &mut dyn Scrollable,
+ id: Option<&Id>,
+ ) {
+ self.operation.scrollable(state, id);
+ }
+
+ fn focusable(
+ &mut self,
+ state: &mut dyn Focusable,
+ id: Option<&Id>,
+ ) {
+ self.operation.focusable(state, id);
+ }
+
+ fn text_input(
+ &mut self,
+ state: &mut dyn TextInput,
+ id: Option<&Id>,
+ ) {
+ self.operation.text_input(state, id);
+ }
+
+ fn custom(&mut self, state: &mut dyn Any, id: Option<&Id>) {
+ self.operation.custom(state, id);
+ }
+ }
+
+ let Self { operation, .. } = self;
+
+ MapRef {
+ operation: operation.as_mut(),
+ }
+ .container(id, operate_on_children);
+ }
+
+ fn focusable(&mut self, state: &mut dyn Focusable, id: Option<&Id>) {
+ self.operation.focusable(state, id);
+ }
+
+ fn scrollable(&mut self, state: &mut dyn Scrollable, id: Option<&Id>) {
+ self.operation.scrollable(state, id);
+ }
+
+ fn text_input(&mut self, state: &mut dyn TextInput, id: Option<&Id>) {
+ self.operation.text_input(state, id);
+ }
+
+ fn custom(&mut self, state: &mut dyn Any, id: Option<&Id>) {
+ self.operation.custom(state, id);
+ }
+
+ fn finish(&self) -> Outcome<B> {
+ match self.operation.finish() {
+ Outcome::None => Outcome::None,
+ Outcome::Some(output) => Outcome::Some((self.f)(output)),
+ Outcome::Chain(next) => Outcome::Chain(Box::new(Map {
+ operation: next,
+ f: self.f.clone(),
+ })),
+ }
+ }
+ }
+
+ Map {
+ operation,
+ f: Rc::new(f),
+ }
+}
+
+/// Produces an [`Operation`] that applies the given [`Operation`] to the
+/// children of a container with the given [`Id`].
+pub fn scope<T: 'static>(
+ target: Id,
+ operation: impl Operation<T> + 'static,
+) -> impl Operation<T> {
+ struct ScopedOperation<Message> {
+ target: Id,
+ operation: Box<dyn Operation<Message>>,
+ }
+
+ impl<Message: 'static> Operation<Message> for ScopedOperation<Message> {
+ fn container(
+ &mut self,
+ id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<Message>),
+ ) {
+ if id == Some(&self.target) {
+ operate_on_children(self.operation.as_mut());
+ } else {
+ operate_on_children(self);
+ }
+ }
+
+ fn finish(&self) -> Outcome<Message> {
+ match self.operation.finish() {
+ Outcome::Chain(next) => {
+ Outcome::Chain(Box::new(ScopedOperation {
+ target: self.target.clone(),
+ operation: next,
+ }))
+ }
+ outcome => outcome,
+ }
+ }
+ }
+
+ ScopedOperation {
+ target,
+ operation: Box::new(operation),
+ }
+}
diff --git a/core/src/widget/operation/focusable.rs b/core/src/widget/operation/focusable.rs
new file mode 100644
index 00000000..312e4894
--- /dev/null
+++ b/core/src/widget/operation/focusable.rs
@@ -0,0 +1,203 @@
+//! Operate on widgets that can be focused.
+use crate::widget::operation::{Operation, Outcome};
+use crate::widget::Id;
+
+/// The internal state of a widget that can be focused.
+pub trait Focusable {
+ /// Returns whether the widget is focused or not.
+ fn is_focused(&self) -> bool;
+
+ /// Focuses the widget.
+ fn focus(&mut self);
+
+ /// Unfocuses the widget.
+ fn unfocus(&mut self);
+}
+
+/// A summary of the focusable widgets present on a widget tree.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct Count {
+ /// The index of the current focused widget, if any.
+ pub focused: Option<usize>,
+
+ /// The total amount of focusable widgets.
+ pub total: usize,
+}
+
+/// Produces an [`Operation`] that focuses the widget with the given [`Id`].
+pub fn focus<T>(target: Id) -> impl Operation<T> {
+ struct Focus {
+ target: Id,
+ }
+
+ impl<T> Operation<T> for Focus {
+ fn focusable(&mut self, state: &mut dyn Focusable, id: Option<&Id>) {
+ match id {
+ Some(id) if id == &self.target => {
+ state.focus();
+ }
+ _ => {
+ state.unfocus();
+ }
+ }
+ }
+
+ fn container(
+ &mut self,
+ _id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+ ) {
+ operate_on_children(self)
+ }
+ }
+
+ Focus { target }
+}
+
+/// Produces an [`Operation`] that generates a [`Count`] and chains it with the
+/// provided function to build a new [`Operation`].
+pub fn count<T, O>(f: fn(Count) -> O) -> impl Operation<T>
+where
+ O: Operation<T> + 'static,
+{
+ struct CountFocusable<O> {
+ count: Count,
+ next: fn(Count) -> O,
+ }
+
+ impl<T, O> Operation<T> for CountFocusable<O>
+ where
+ O: Operation<T> + 'static,
+ {
+ fn focusable(&mut self, state: &mut dyn Focusable, _id: Option<&Id>) {
+ if state.is_focused() {
+ self.count.focused = Some(self.count.total);
+ }
+
+ self.count.total += 1;
+ }
+
+ fn container(
+ &mut self,
+ _id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+ ) {
+ operate_on_children(self)
+ }
+
+ fn finish(&self) -> Outcome<T> {
+ Outcome::Chain(Box::new((self.next)(self.count)))
+ }
+ }
+
+ CountFocusable {
+ count: Count::default(),
+ next: f,
+ }
+}
+
+/// Produces an [`Operation`] that searches for the current focused widget, and
+/// - if found, focuses the previous focusable widget.
+/// - if not found, focuses the last focusable widget.
+pub fn focus_previous<T>() -> impl Operation<T> {
+ struct FocusPrevious {
+ count: Count,
+ current: usize,
+ }
+
+ impl<T> Operation<T> for FocusPrevious {
+ fn focusable(&mut self, state: &mut dyn Focusable, _id: Option<&Id>) {
+ if self.count.total == 0 {
+ return;
+ }
+
+ match self.count.focused {
+ None if self.current == self.count.total - 1 => state.focus(),
+ Some(0) if self.current == 0 => state.unfocus(),
+ Some(0) => {}
+ Some(focused) if focused == self.current => state.unfocus(),
+ Some(focused) if focused - 1 == self.current => state.focus(),
+ _ => {}
+ }
+
+ self.current += 1;
+ }
+
+ fn container(
+ &mut self,
+ _id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+ ) {
+ operate_on_children(self)
+ }
+ }
+
+ count(|count| FocusPrevious { count, current: 0 })
+}
+
+/// Produces an [`Operation`] that searches for the current focused widget, and
+/// - if found, focuses the next focusable widget.
+/// - if not found, focuses the first focusable widget.
+pub fn focus_next<T>() -> impl Operation<T> {
+ struct FocusNext {
+ count: Count,
+ current: usize,
+ }
+
+ impl<T> Operation<T> for FocusNext {
+ fn focusable(&mut self, state: &mut dyn Focusable, _id: Option<&Id>) {
+ match self.count.focused {
+ None if self.current == 0 => state.focus(),
+ Some(focused) if focused == self.current => state.unfocus(),
+ Some(focused) if focused + 1 == self.current => state.focus(),
+ _ => {}
+ }
+
+ self.current += 1;
+ }
+
+ fn container(
+ &mut self,
+ _id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+ ) {
+ operate_on_children(self)
+ }
+ }
+
+ count(|count| FocusNext { count, current: 0 })
+}
+
+/// Produces an [`Operation`] that searches for the current focused widget
+/// and stores its ID. This ignores widgets that do not have an ID.
+pub fn find_focused() -> impl Operation<Id> {
+ struct FindFocused {
+ focused: Option<Id>,
+ }
+
+ impl Operation<Id> for FindFocused {
+ fn focusable(&mut self, state: &mut dyn Focusable, id: Option<&Id>) {
+ if state.is_focused() && id.is_some() {
+ self.focused = id.cloned();
+ }
+ }
+
+ fn container(
+ &mut self,
+ _id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<Id>),
+ ) {
+ operate_on_children(self)
+ }
+
+ fn finish(&self) -> Outcome<Id> {
+ if let Some(id) = &self.focused {
+ Outcome::Some(id.clone())
+ } else {
+ Outcome::None
+ }
+ }
+ }
+
+ FindFocused { focused: None }
+}
diff --git a/core/src/widget/operation/scrollable.rs b/core/src/widget/operation/scrollable.rs
new file mode 100644
index 00000000..f947344d
--- /dev/null
+++ b/core/src/widget/operation/scrollable.rs
@@ -0,0 +1,93 @@
+//! Operate on widgets that can be scrolled.
+use crate::widget::{Id, Operation};
+
+/// The internal state of a widget that can be scrolled.
+pub trait Scrollable {
+ /// Snaps the scroll of the widget to the given `percentage` along the horizontal & vertical axis.
+ fn snap_to(&mut self, offset: RelativeOffset);
+
+ /// Scroll the widget to the given [`AbsoluteOffset`] along the horizontal & vertical axis.
+ fn scroll_to(&mut self, offset: AbsoluteOffset);
+}
+
+/// Produces an [`Operation`] that snaps the widget with the given [`Id`] to
+/// the provided `percentage`.
+pub fn snap_to<T>(target: Id, offset: RelativeOffset) -> impl Operation<T> {
+ struct SnapTo {
+ target: Id,
+ offset: RelativeOffset,
+ }
+
+ impl<T> Operation<T> for SnapTo {
+ fn container(
+ &mut self,
+ _id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+ ) {
+ operate_on_children(self)
+ }
+
+ fn scrollable(&mut self, state: &mut dyn Scrollable, id: Option<&Id>) {
+ if Some(&self.target) == id {
+ state.snap_to(self.offset);
+ }
+ }
+ }
+
+ SnapTo { target, offset }
+}
+
+/// Produces an [`Operation`] that scrolls the widget with the given [`Id`] to
+/// the provided [`AbsoluteOffset`].
+pub fn scroll_to<T>(target: Id, offset: AbsoluteOffset) -> impl Operation<T> {
+ struct ScrollTo {
+ target: Id,
+ offset: AbsoluteOffset,
+ }
+
+ impl<T> Operation<T> for ScrollTo {
+ fn container(
+ &mut self,
+ _id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+ ) {
+ operate_on_children(self)
+ }
+
+ fn scrollable(&mut self, state: &mut dyn Scrollable, id: Option<&Id>) {
+ if Some(&self.target) == id {
+ state.scroll_to(self.offset);
+ }
+ }
+ }
+
+ ScrollTo { target, offset }
+}
+
+/// The amount of absolute offset in each direction of a [`Scrollable`].
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct AbsoluteOffset {
+ /// The amount of horizontal offset
+ pub x: f32,
+ /// The amount of vertical offset
+ pub y: f32,
+}
+
+/// The amount of relative offset in each direction of a [`Scrollable`].
+///
+/// A value of `0.0` means start, while `1.0` means end.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct RelativeOffset {
+ /// The amount of horizontal offset
+ pub x: f32,
+ /// The amount of vertical offset
+ pub y: f32,
+}
+
+impl RelativeOffset {
+ /// A relative offset that points to the top-left of a [`Scrollable`].
+ pub const START: Self = Self { x: 0.0, y: 0.0 };
+
+ /// A relative offset that points to the bottom-right of a [`Scrollable`].
+ pub const END: Self = Self { x: 1.0, y: 1.0 };
+}
diff --git a/core/src/widget/operation/text_input.rs b/core/src/widget/operation/text_input.rs
new file mode 100644
index 00000000..4c773e99
--- /dev/null
+++ b/core/src/widget/operation/text_input.rs
@@ -0,0 +1,131 @@
+//! Operate on widgets that have text input.
+use crate::widget::operation::Operation;
+use crate::widget::Id;
+
+/// The internal state of a widget that has text input.
+pub trait TextInput {
+ /// Moves the cursor of the text input to the front of the input text.
+ fn move_cursor_to_front(&mut self);
+ /// Moves the cursor of the text input to the end of the input text.
+ fn move_cursor_to_end(&mut self);
+ /// Moves the cursor of the text input to an arbitrary location.
+ fn move_cursor_to(&mut self, position: usize);
+ /// Selects all the content of the text input.
+ fn select_all(&mut self);
+}
+
+/// Produces an [`Operation`] that moves the cursor of the widget with the given [`Id`] to the
+/// front.
+pub fn move_cursor_to_front<T>(target: Id) -> impl Operation<T> {
+ struct MoveCursor {
+ target: Id,
+ }
+
+ impl<T> Operation<T> for MoveCursor {
+ fn text_input(&mut self, state: &mut dyn TextInput, id: Option<&Id>) {
+ match id {
+ Some(id) if id == &self.target => {
+ state.move_cursor_to_front();
+ }
+ _ => {}
+ }
+ }
+
+ fn container(
+ &mut self,
+ _id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+ ) {
+ operate_on_children(self)
+ }
+ }
+
+ MoveCursor { target }
+}
+
+/// Produces an [`Operation`] that moves the cursor of the widget with the given [`Id`] to the
+/// end.
+pub fn move_cursor_to_end<T>(target: Id) -> impl Operation<T> {
+ struct MoveCursor {
+ target: Id,
+ }
+
+ impl<T> Operation<T> for MoveCursor {
+ fn text_input(&mut self, state: &mut dyn TextInput, id: Option<&Id>) {
+ match id {
+ Some(id) if id == &self.target => {
+ state.move_cursor_to_end();
+ }
+ _ => {}
+ }
+ }
+
+ fn container(
+ &mut self,
+ _id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+ ) {
+ operate_on_children(self)
+ }
+ }
+
+ MoveCursor { target }
+}
+
+/// Produces an [`Operation`] that moves the cursor of the widget with the given [`Id`] to the
+/// provided position.
+pub fn move_cursor_to<T>(target: Id, position: usize) -> impl Operation<T> {
+ struct MoveCursor {
+ target: Id,
+ position: usize,
+ }
+
+ impl<T> Operation<T> for MoveCursor {
+ fn text_input(&mut self, state: &mut dyn TextInput, id: Option<&Id>) {
+ match id {
+ Some(id) if id == &self.target => {
+ state.move_cursor_to(self.position);
+ }
+ _ => {}
+ }
+ }
+
+ fn container(
+ &mut self,
+ _id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+ ) {
+ operate_on_children(self)
+ }
+ }
+
+ MoveCursor { target, position }
+}
+
+/// Produces an [`Operation`] that selects all the content of the widget with the given [`Id`].
+pub fn select_all<T>(target: Id) -> impl Operation<T> {
+ struct MoveCursor {
+ target: Id,
+ }
+
+ impl<T> Operation<T> for MoveCursor {
+ fn text_input(&mut self, state: &mut dyn TextInput, id: Option<&Id>) {
+ match id {
+ Some(id) if id == &self.target => {
+ state.select_all();
+ }
+ _ => {}
+ }
+ }
+
+ fn container(
+ &mut self,
+ _id: Option<&Id>,
+ operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+ ) {
+ operate_on_children(self)
+ }
+ }
+
+ MoveCursor { target }
+}
diff --git a/core/src/widget/text.rs b/core/src/widget/text.rs
new file mode 100644
index 00000000..79df2b02
--- /dev/null
+++ b/core/src/widget/text.rs
@@ -0,0 +1,304 @@
+//! Write some text for your users to read.
+use crate::alignment;
+use crate::layout;
+use crate::mouse;
+use crate::renderer;
+use crate::text;
+use crate::widget::Tree;
+use crate::{Color, Element, Layout, Length, Pixels, Rectangle, Widget};
+
+use std::borrow::Cow;
+
+pub use text::{LineHeight, Shaping};
+
+/// A paragraph of text.
+#[allow(missing_debug_implementations)]
+pub struct Text<'a, Renderer>
+where
+ Renderer: text::Renderer,
+ Renderer::Theme: StyleSheet,
+{
+ content: Cow<'a, str>,
+ size: Option<f32>,
+ line_height: LineHeight,
+ width: Length,
+ height: Length,
+ horizontal_alignment: alignment::Horizontal,
+ vertical_alignment: alignment::Vertical,
+ font: Option<Renderer::Font>,
+ shaping: Shaping,
+ style: <Renderer::Theme as StyleSheet>::Style,
+}
+
+impl<'a, Renderer> Text<'a, Renderer>
+where
+ Renderer: text::Renderer,
+ Renderer::Theme: StyleSheet,
+{
+ /// Create a new fragment of [`Text`] with the given contents.
+ pub fn new(content: impl Into<Cow<'a, str>>) -> Self {
+ Text {
+ content: content.into(),
+ size: None,
+ line_height: LineHeight::default(),
+ font: None,
+ width: Length::Shrink,
+ height: Length::Shrink,
+ horizontal_alignment: alignment::Horizontal::Left,
+ vertical_alignment: alignment::Vertical::Top,
+ shaping: Shaping::Basic,
+ style: Default::default(),
+ }
+ }
+
+ /// Sets the size of the [`Text`].
+ pub fn size(mut self, size: impl Into<Pixels>) -> Self {
+ self.size = Some(size.into().0);
+ self
+ }
+
+ /// Sets the [`LineHeight`] of the [`Text`].
+ pub fn line_height(mut self, line_height: impl Into<LineHeight>) -> Self {
+ self.line_height = line_height.into();
+ self
+ }
+
+ /// Sets the [`Font`] of the [`Text`].
+ ///
+ /// [`Font`]: crate::text::Renderer::Font
+ pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
+ self.font = Some(font.into());
+ self
+ }
+
+ /// Sets the style of the [`Text`].
+ pub fn style(
+ mut self,
+ style: impl Into<<Renderer::Theme as StyleSheet>::Style>,
+ ) -> Self {
+ self.style = style.into();
+ self
+ }
+
+ /// Sets the width of the [`Text`] boundaries.
+ pub fn width(mut self, width: impl Into<Length>) -> Self {
+ self.width = width.into();
+ self
+ }
+
+ /// Sets the height of the [`Text`] boundaries.
+ pub fn height(mut self, height: impl Into<Length>) -> Self {
+ self.height = height.into();
+ self
+ }
+
+ /// Sets the [`alignment::Horizontal`] of the [`Text`].
+ pub fn horizontal_alignment(
+ mut self,
+ alignment: alignment::Horizontal,
+ ) -> Self {
+ self.horizontal_alignment = alignment;
+ self
+ }
+
+ /// Sets the [`alignment::Vertical`] of the [`Text`].
+ pub fn vertical_alignment(
+ mut self,
+ alignment: alignment::Vertical,
+ ) -> Self {
+ self.vertical_alignment = alignment;
+ self
+ }
+
+ /// Sets the [`Shaping`] strategy of the [`Text`].
+ pub fn shaping(mut self, shaping: Shaping) -> Self {
+ self.shaping = shaping;
+ self
+ }
+}
+
+impl<'a, Message, Renderer> Widget<Message, Renderer> for Text<'a, Renderer>
+where
+ Renderer: text::Renderer,
+ Renderer::Theme: StyleSheet,
+{
+ fn width(&self) -> Length {
+ self.width
+ }
+
+ fn height(&self) -> Length {
+ self.height
+ }
+
+ fn layout(
+ &self,
+ renderer: &Renderer,
+ limits: &layout::Limits,
+ ) -> layout::Node {
+ let limits = limits.width(self.width).height(self.height);
+
+ let size = self.size.unwrap_or_else(|| renderer.default_size());
+
+ let bounds = renderer.measure(
+ &self.content,
+ size,
+ self.line_height,
+ self.font.unwrap_or_else(|| renderer.default_font()),
+ limits.max(),
+ self.shaping,
+ );
+
+ let size = limits.resolve(bounds);
+
+ layout::Node::new(size)
+ }
+
+ fn draw(
+ &self,
+ _state: &Tree,
+ renderer: &mut Renderer,
+ theme: &Renderer::Theme,
+ style: &renderer::Style,
+ layout: Layout<'_>,
+ _cursor_position: mouse::Cursor,
+ _viewport: &Rectangle,
+ ) {
+ draw(
+ renderer,
+ style,
+ layout,
+ &self.content,
+ self.size,
+ self.line_height,
+ self.font,
+ theme.appearance(self.style.clone()),
+ self.horizontal_alignment,
+ self.vertical_alignment,
+ self.shaping,
+ );
+ }
+}
+
+/// Draws text using the same logic as the [`Text`] widget.
+///
+/// Specifically:
+///
+/// * If no `size` is provided, the default text size of the `Renderer` will be
+/// used.
+/// * If no `color` is provided, the [`renderer::Style::text_color`] will be
+/// used.
+/// * The alignment attributes do not affect the position of the bounds of the
+/// [`Layout`].
+pub fn draw<Renderer>(
+ renderer: &mut Renderer,
+ style: &renderer::Style,
+ layout: Layout<'_>,
+ content: &str,
+ size: Option<f32>,
+ line_height: LineHeight,
+ font: Option<Renderer::Font>,
+ appearance: Appearance,
+ horizontal_alignment: alignment::Horizontal,
+ vertical_alignment: alignment::Vertical,
+ shaping: Shaping,
+) where
+ Renderer: text::Renderer,
+{
+ let bounds = layout.bounds();
+
+ let x = match horizontal_alignment {
+ alignment::Horizontal::Left => bounds.x,
+ alignment::Horizontal::Center => bounds.center_x(),
+ alignment::Horizontal::Right => bounds.x + bounds.width,
+ };
+
+ let y = match vertical_alignment {
+ alignment::Vertical::Top => bounds.y,
+ alignment::Vertical::Center => bounds.center_y(),
+ alignment::Vertical::Bottom => bounds.y + bounds.height,
+ };
+
+ let size = size.unwrap_or_else(|| renderer.default_size());
+
+ renderer.fill_text(crate::Text {
+ content,
+ size,
+ line_height,
+ bounds: Rectangle { x, y, ..bounds },
+ color: appearance.color.unwrap_or(style.text_color),
+ font: font.unwrap_or_else(|| renderer.default_font()),
+ horizontal_alignment,
+ vertical_alignment,
+ shaping,
+ });
+}
+
+impl<'a, Message, Renderer> From<Text<'a, Renderer>>
+ for Element<'a, Message, Renderer>
+where
+ Renderer: text::Renderer + 'a,
+ Renderer::Theme: StyleSheet,
+{
+ fn from(text: Text<'a, Renderer>) -> Element<'a, Message, Renderer> {
+ Element::new(text)
+ }
+}
+
+impl<'a, Renderer> Clone for Text<'a, Renderer>
+where
+ Renderer: text::Renderer,
+ Renderer::Theme: StyleSheet,
+{
+ fn clone(&self) -> Self {
+ Self {
+ content: self.content.clone(),
+ size: self.size,
+ line_height: self.line_height,
+ width: self.width,
+ height: self.height,
+ horizontal_alignment: self.horizontal_alignment,
+ vertical_alignment: self.vertical_alignment,
+ font: self.font,
+ style: self.style.clone(),
+ shaping: self.shaping,
+ }
+ }
+}
+
+impl<'a, Renderer> From<&'a str> for Text<'a, Renderer>
+where
+ Renderer: text::Renderer,
+ Renderer::Theme: StyleSheet,
+{
+ fn from(content: &'a str) -> Self {
+ Self::new(content)
+ }
+}
+
+impl<'a, Message, Renderer> From<&'a str> for Element<'a, Message, Renderer>
+where
+ Renderer: text::Renderer + 'a,
+ Renderer::Theme: StyleSheet,
+{
+ fn from(content: &'a str) -> Self {
+ Text::from(content).into()
+ }
+}
+
+/// The style sheet of some text.
+pub trait StyleSheet {
+ /// The supported style of the [`StyleSheet`].
+ type Style: Default + Clone;
+
+ /// Produces the [`Appearance`] of some text.
+ fn appearance(&self, style: Self::Style) -> Appearance;
+}
+
+/// The apperance of some text.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Appearance {
+ /// The [`Color`] of the text.
+ ///
+ /// The default, `None`, means using the inherited color.
+ pub color: Option<Color>,
+}
diff --git a/core/src/widget/tree.rs b/core/src/widget/tree.rs
new file mode 100644
index 00000000..da269632
--- /dev/null
+++ b/core/src/widget/tree.rs
@@ -0,0 +1,187 @@
+//! Store internal widget state in a state tree to ensure continuity.
+use crate::Widget;
+
+use std::any::{self, Any};
+use std::borrow::Borrow;
+use std::fmt;
+
+/// A persistent state widget tree.
+///
+/// A [`Tree`] is normally associated with a specific widget in the widget tree.
+#[derive(Debug)]
+pub struct Tree {
+ /// The tag of the [`Tree`].
+ pub tag: Tag,
+
+ /// The [`State`] of the [`Tree`].
+ pub state: State,
+
+ /// The children of the root widget of the [`Tree`].
+ pub children: Vec<Tree>,
+}
+
+impl Tree {
+ /// Creates an empty, stateless [`Tree`] with no children.
+ pub fn empty() -> Self {
+ Self {
+ tag: Tag::stateless(),
+ state: State::None,
+ children: Vec::new(),
+ }
+ }
+
+ /// Creates a new [`Tree`] for the provided [`Widget`].
+ pub fn new<'a, Message, Renderer>(
+ widget: impl Borrow<dyn Widget<Message, Renderer> + 'a>,
+ ) -> Self
+ where
+ Renderer: crate::Renderer,
+ {
+ let widget = widget.borrow();
+
+ Self {
+ tag: widget.tag(),
+ state: widget.state(),
+ children: widget.children(),
+ }
+ }
+
+ /// Reconciliates the current tree with the provided [`Widget`].
+ ///
+ /// If the tag of the [`Widget`] matches the tag of the [`Tree`], then the
+ /// [`Widget`] proceeds with the reconciliation (i.e. [`Widget::diff`] is called).
+ ///
+ /// Otherwise, the whole [`Tree`] is recreated.
+ ///
+ /// [`Widget::diff`]: crate::Widget::diff
+ pub fn diff<'a, Message, Renderer>(
+ &mut self,
+ new: impl Borrow<dyn Widget<Message, Renderer> + 'a>,
+ ) where
+ Renderer: crate::Renderer,
+ {
+ if self.tag == new.borrow().tag() {
+ new.borrow().diff(self)
+ } else {
+ *self = Self::new(new);
+ }
+ }
+
+ /// Reconciles the children of the tree with the provided list of widgets.
+ pub fn diff_children<'a, Message, Renderer>(
+ &mut self,
+ new_children: &[impl Borrow<dyn Widget<Message, Renderer> + 'a>],
+ ) where
+ Renderer: crate::Renderer,
+ {
+ self.diff_children_custom(
+ new_children,
+ |tree, widget| tree.diff(widget.borrow()),
+ |widget| Self::new(widget.borrow()),
+ )
+ }
+
+ /// Reconciliates the children of the tree with the provided list of widgets using custom
+ /// logic both for diffing and creating new widget state.
+ pub fn diff_children_custom<T>(
+ &mut self,
+ new_children: &[T],
+ diff: impl Fn(&mut Tree, &T),
+ new_state: impl Fn(&T) -> Self,
+ ) {
+ if self.children.len() > new_children.len() {
+ self.children.truncate(new_children.len());
+ }
+
+ for (child_state, new) in
+ self.children.iter_mut().zip(new_children.iter())
+ {
+ diff(child_state, new);
+ }
+
+ if self.children.len() < new_children.len() {
+ self.children.extend(
+ new_children[self.children.len()..].iter().map(new_state),
+ );
+ }
+ }
+}
+
+/// The identifier of some widget state.
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub struct Tag(any::TypeId);
+
+impl Tag {
+ /// Creates a [`Tag`] for a state of type `T`.
+ pub fn of<T>() -> Self
+ where
+ T: 'static,
+ {
+ Self(any::TypeId::of::<T>())
+ }
+
+ /// Creates a [`Tag`] for a stateless widget.
+ pub fn stateless() -> Self {
+ Self::of::<()>()
+ }
+}
+
+/// The internal [`State`] of a widget.
+pub enum State {
+ /// No meaningful internal state.
+ None,
+
+ /// Some meaningful internal state.
+ Some(Box<dyn Any>),
+}
+
+impl State {
+ /// Creates a new [`State`].
+ pub fn new<T>(state: T) -> Self
+ where
+ T: 'static,
+ {
+ State::Some(Box::new(state))
+ }
+
+ /// Downcasts the [`State`] to `T` and returns a reference to it.
+ ///
+ /// # Panics
+ /// This method will panic if the downcast fails or the [`State`] is [`State::None`].
+ pub fn downcast_ref<T>(&self) -> &T
+ where
+ T: 'static,
+ {
+ match self {
+ State::None => panic!("Downcast on stateless state"),
+ State::Some(state) => {
+ state.downcast_ref().expect("Downcast widget state")
+ }
+ }
+ }
+
+ /// Downcasts the [`State`] to `T` and returns a mutable reference to it.
+ ///
+ /// # Panics
+ /// This method will panic if the downcast fails or the [`State`] is [`State::None`].
+ pub fn downcast_mut<T>(&mut self) -> &mut T
+ where
+ T: 'static,
+ {
+ match self {
+ State::None => panic!("Downcast on stateless state"),
+ State::Some(state) => {
+ state.downcast_mut().expect("Downcast widget state")
+ }
+ }
+ }
+}
+
+impl fmt::Debug for State {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::None => write!(f, "State::None"),
+ Self::Some(_) => write!(f, "State::Some"),
+ }
+ }
+}
generated by cgit (git 2.34.1) at 2025-04-16 19:55:02 +0000