From 8f0839e786f8d521f7319dd0e188d43284f526b7 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 9 Feb 2022 19:42:15 +0700 Subject: Draft `iced_virtual` subcrate The idea here is to expose a set of "virtual widgets" that can be used with a `Virtual` widget and its `virtual::State`. A virtual widget is a widget that does not contain any state, but instead is a "virtual" representation of the "real" widget. The real widgets are stored in the `virtual::State`. Every time a new virtual widget tree is created during `view`, it is compared to the previous one and "real" widgets are added / removed to the `virtual::State`. Effectively, this removes the need to keep track of local widget state in the application state and allows `view` to take an immutable reference to `self`. To summarize, using this crate should allow users to remove `State` structs in their application state. Eventually, the strategy used here may be adopted generally and, as a result, all of the widgets in `iced_native` would be replaced! --- virtual/src/element.rs | 37 +++++++++++++++++++++++++ virtual/src/lib.rs | 61 +++++++++++++++++++++++++++++++++++++++++ virtual/src/widget.rs | 52 +++++++++++++++++++++++++++++++++++ virtual/src/widget/button.rs | 64 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 214 insertions(+) create mode 100644 virtual/src/element.rs create mode 100644 virtual/src/lib.rs create mode 100644 virtual/src/widget.rs create mode 100644 virtual/src/widget/button.rs (limited to 'virtual/src') diff --git a/virtual/src/element.rs b/virtual/src/element.rs new file mode 100644 index 00000000..ecdb0677 --- /dev/null +++ b/virtual/src/element.rs @@ -0,0 +1,37 @@ +use crate::Widget; + +pub struct Element { + widget: Box>, +} + +impl Element { + pub fn new(widget: impl Descriptor + 'static) -> Self { + Self { + widget: Box::new(widget), + } + } +} + +pub trait Descriptor { + fn tag(&self) -> std::any::TypeId; + + fn build(&self) -> Box>; + + fn children(&self) -> &[Element]; + + fn clone(&self) -> Box>; +} + +impl Clone for Box> { + fn clone(&self) -> Self { + self.as_ref().clone() + } +} + +impl Clone for Element { + fn clone(&self) -> Self { + Element { + widget: self.widget.clone(), + } + } +} diff --git a/virtual/src/lib.rs b/virtual/src/lib.rs new file mode 100644 index 00000000..80953872 --- /dev/null +++ b/virtual/src/lib.rs @@ -0,0 +1,61 @@ +mod element; +pub mod widget; + +pub use element::Element; +pub use widget::Widget; + +use iced_native::layout::{self, Layout}; +use iced_native::renderer; +use iced_native::{Hasher, Length, Point, Rectangle}; + +pub struct Virtual<'a, Message, Renderer> { + state: &'a mut State, +} + +pub struct State { + widget_tree: widget::Tree, + last_element: Element, +} + +impl<'a, Message, Renderer> iced_native::Widget + for Virtual<'a, Message, Renderer> +where + Renderer: iced_native::Renderer, +{ + fn width(&self) -> Length { + self.state.widget_tree.width() + } + + fn height(&self) -> Length { + self.state.widget_tree.height() + } + + fn layout( + &self, + renderer: &Renderer, + limits: &layout::Limits, + ) -> layout::Node { + self.state.widget_tree.layout(renderer, limits) + } + + fn hash_layout(&self, state: &mut Hasher) { + self.state.widget_tree.hash_layout(state) + } + + fn draw( + &self, + renderer: &mut Renderer, + style: &renderer::Style, + layout: Layout<'_>, + cursor_position: Point, + viewport: &Rectangle, + ) { + self.state.widget_tree.draw( + renderer, + style, + layout, + cursor_position, + viewport, + ) + } +} diff --git a/virtual/src/widget.rs b/virtual/src/widget.rs new file mode 100644 index 00000000..f8697bc0 --- /dev/null +++ b/virtual/src/widget.rs @@ -0,0 +1,52 @@ +mod button; + +pub use button::Button; + +use iced_native::layout::{self, Layout}; +use iced_native::renderer; +use iced_native::{Hasher, Length, Point, Rectangle}; + +pub trait Widget {} + +pub(crate) enum Tree { + Node { + widget: Box>, + children: Vec>, + }, + Leaf { + widget: Box>, + }, +} + +impl Tree { + pub fn width(&self) -> Length { + unimplemented! {} + } + + pub fn height(&self) -> Length { + unimplemented! {} + } + + pub fn hash_layout(&self, state: &mut Hasher) { + unimplemented! {} + } + + pub fn layout( + &self, + renderer: &Renderer, + limits: &layout::Limits, + ) -> layout::Node { + unimplemented! {} + } + + pub fn draw( + &self, + renderer: &mut Renderer, + style: &renderer::Style, + layout: Layout<'_>, + cursor_position: Point, + viewport: &Rectangle, + ) { + unimplemented! {} + } +} diff --git a/virtual/src/widget/button.rs b/virtual/src/widget/button.rs new file mode 100644 index 00000000..115be80b --- /dev/null +++ b/virtual/src/widget/button.rs @@ -0,0 +1,64 @@ +use crate::element::{self, Element}; +use crate::Widget; + +pub struct Button { + content: Element, + on_press: Option, +} + +impl Button { + pub fn new( + content: impl element::Descriptor + 'static, + ) -> Self { + Button { + content: Element::new(content), + on_press: None, + } + } + + pub fn on_press(mut self, on_press: Message) -> Self { + self.on_press = Some(on_press); + self + } +} + +impl element::Descriptor + for Button +where + Message: 'static + Clone, + Renderer: 'static, +{ + fn tag(&self) -> std::any::TypeId { + std::any::TypeId::of::() + } + + fn build(&self) -> Box> { + Box::new(State { is_pressed: false }) + } + + fn children(&self) -> &[Element] { + std::slice::from_ref(&self.content) + } + + fn clone(&self) -> Box> { + Box::new(Clone::clone(self)) + } +} + +impl Clone for Button +where + Message: Clone, +{ + fn clone(&self) -> Self { + Self { + content: self.content.clone(), + on_press: self.on_press.clone(), + } + } +} + +pub struct State { + is_pressed: bool, +} + +impl Widget for State {} -- cgit