diff options
Diffstat (limited to 'native')
27 files changed, 1179 insertions, 86 deletions
diff --git a/native/src/element.rs b/native/src/element.rs index 73e39012..b00f9e55 100644 --- a/native/src/element.rs +++ b/native/src/element.rs @@ -1,6 +1,8 @@ use crate::{ - layout, Clipboard, Color, Event, Hasher, Layout, Length, Point, Widget, + layout, Clipboard, Color, Event, Hasher, Layout, Length, Overlay, Point, + Widget, }; +use std::rc::Rc; /// A generic [`Widget`]. /// @@ -15,7 +17,7 @@ use crate::{ /// [`Element`]: struct.Element.html #[allow(missing_debug_implementations)] pub struct Element<'a, Message, Renderer> { - pub(crate) widget: Box<dyn Widget<Message, Renderer> + 'a>, + pub(crate) widget: Box<dyn Widget<'a, Message, Renderer> + 'a>, } impl<'a, Message, Renderer> Element<'a, Message, Renderer> @@ -27,7 +29,7 @@ where /// [`Element`]: struct.Element.html /// [`Widget`]: widget/trait.Widget.html pub fn new( - widget: impl Widget<Message, Renderer> + 'a, + widget: impl Widget<'a, Message, Renderer> + 'a, ) -> Element<'a, Message, Renderer> { Element { widget: Box::new(widget), @@ -270,16 +272,23 @@ where pub fn hash_layout(&self, state: &mut Hasher) { self.widget.hash_layout(state); } + + pub fn overlay<'b>( + &'b mut self, + layout: Layout<'_>, + ) -> Option<Overlay<'b, Message, Renderer>> { + self.widget.overlay(layout) + } } struct Map<'a, A, B, Renderer> { - widget: Box<dyn Widget<A, Renderer> + 'a>, - mapper: Box<dyn Fn(A) -> B>, + widget: Box<dyn Widget<'a, A, Renderer> + 'a>, + mapper: Rc<dyn Fn(A) -> B>, } impl<'a, A, B, Renderer> Map<'a, A, B, Renderer> { pub fn new<F>( - widget: Box<dyn Widget<A, Renderer> + 'a>, + widget: Box<dyn Widget<'a, A, Renderer> + 'a>, mapper: F, ) -> Map<'a, A, B, Renderer> where @@ -287,14 +296,16 @@ impl<'a, A, B, Renderer> Map<'a, A, B, Renderer> { { Map { widget, - mapper: Box::new(mapper), + mapper: Rc::new(mapper), } } } -impl<'a, A, B, Renderer> Widget<B, Renderer> for Map<'a, A, B, Renderer> +impl<'a, A, B, Renderer> Widget<'a, B, Renderer> for Map<'a, A, B, Renderer> where - Renderer: crate::Renderer, + Renderer: crate::Renderer + 'a, + A: 'static, + B: 'static, { fn width(&self) -> Length { self.widget.width() @@ -351,6 +362,17 @@ where fn hash_layout(&self, state: &mut Hasher) { self.widget.hash_layout(state); } + + fn overlay( + &mut self, + layout: Layout<'_>, + ) -> Option<Overlay<'_, B, Renderer>> { + let mapper = self.mapper.clone(); + + self.widget + .overlay(layout) + .map(move |overlay| overlay.map(mapper)) + } } struct Explain<'a, Message, Renderer: crate::Renderer> { @@ -367,7 +389,7 @@ where } } -impl<'a, Message, Renderer> Widget<Message, Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for Explain<'a, Message, Renderer> where Renderer: crate::Renderer + layout::Debugger, @@ -426,4 +448,11 @@ where fn hash_layout(&self, state: &mut Hasher) { self.element.widget.hash_layout(state); } + + fn overlay( + &mut self, + layout: Layout<'_>, + ) -> Option<Overlay<'_, Message, Renderer>> { + self.element.overlay(layout) + } } diff --git a/native/src/layout/debugger.rs b/native/src/layout/debugger.rs index e4b21609..9c58f4f1 100644 --- a/native/src/layout/debugger.rs +++ b/native/src/layout/debugger.rs @@ -18,7 +18,7 @@ pub trait Debugger: Renderer { fn explain<Message>( &mut self, defaults: &Self::Defaults, - widget: &dyn Widget<Message, Self>, + widget: &dyn Widget<'_, Message, Self>, layout: Layout<'_>, cursor_position: Point, color: Color, diff --git a/native/src/lib.rs b/native/src/lib.rs index b67ff2a1..ea328592 100644 --- a/native/src/lib.rs +++ b/native/src/lib.rs @@ -30,14 +30,15 @@ //! [`Widget`]: widget/trait.Widget.html //! [`UserInterface`]: struct.UserInterface.html //! [renderer]: renderer/index.html -#![deny(missing_docs)] -#![deny(missing_debug_implementations)] +//#![deny(missing_docs)] +//#![deny(missing_debug_implementations)] #![deny(unused_results)] #![forbid(unsafe_code)] #![forbid(rust_2018_idioms)] pub mod keyboard; pub mod layout; pub mod mouse; +pub mod overlay; pub mod program; pub mod renderer; pub mod subscription; @@ -75,6 +76,7 @@ pub use element::Element; pub use event::Event; pub use hasher::Hasher; pub use layout::Layout; +pub use overlay::Overlay; pub use program::Program; pub use renderer::Renderer; pub use runtime::Runtime; diff --git a/native/src/overlay.rs b/native/src/overlay.rs new file mode 100644 index 00000000..b8c8bb48 --- /dev/null +++ b/native/src/overlay.rs @@ -0,0 +1,150 @@ +mod content; + +pub mod menu; + +pub use content::Content; +pub use menu::Menu; + +use crate::{layout, Clipboard, Event, Hasher, Layout, Point, Size, Vector}; +use std::rc::Rc; + +#[allow(missing_debug_implementations)] +pub struct Overlay<'a, Message, Renderer> { + position: Point, + content: Box<dyn Content<Message, Renderer> + 'a>, +} + +impl<'a, Message, Renderer> Overlay<'a, Message, Renderer> +where + Renderer: crate::Renderer, +{ + pub fn new( + position: Point, + content: Box<dyn Content<Message, Renderer> + 'a>, + ) -> Self { + Self { position, content } + } + + pub fn translate(mut self, translation: Vector) -> Self { + self.position = self.position + translation; + self + } + + pub fn map<B>(self, f: Rc<dyn Fn(Message) -> B>) -> Overlay<'a, B, Renderer> + where + Message: 'a, + Renderer: 'a, + B: 'static, + { + Overlay { + position: self.position, + content: Box::new(Map::new(self.content, f)), + } + } + + pub fn layout(&self, renderer: &Renderer, bounds: Size) -> layout::Node { + self.content.layout(renderer, bounds, self.position) + } + + pub fn draw( + &self, + renderer: &mut Renderer, + defaults: &Renderer::Defaults, + layout: Layout<'_>, + cursor_position: Point, + ) -> Renderer::Output { + self.content + .draw(renderer, defaults, layout, cursor_position) + } + + pub fn hash_layout(&self, state: &mut Hasher) { + self.content.hash_layout(state, self.position); + } + + pub fn on_event( + &mut self, + event: Event, + layout: Layout<'_>, + cursor_position: Point, + messages: &mut Vec<Message>, + renderer: &Renderer, + clipboard: Option<&dyn Clipboard>, + ) { + self.content.on_event( + event, + layout, + cursor_position, + messages, + renderer, + clipboard, + ) + } +} + +struct Map<'a, A, B, Renderer> { + content: Box<dyn Content<A, Renderer> + 'a>, + mapper: Rc<dyn Fn(A) -> B>, +} + +impl<'a, A, B, Renderer> Map<'a, A, B, Renderer> { + pub fn new( + content: Box<dyn Content<A, Renderer> + 'a>, + mapper: Rc<dyn Fn(A) -> B + 'static>, + ) -> Map<'a, A, B, Renderer> { + Map { content, mapper } + } +} + +impl<'a, A, B, Renderer> Content<B, Renderer> for Map<'a, A, B, Renderer> +where + Renderer: crate::Renderer, +{ + fn layout( + &self, + renderer: &Renderer, + bounds: Size, + position: Point, + ) -> layout::Node { + self.content.layout(renderer, bounds, position) + } + + fn on_event( + &mut self, + event: Event, + layout: Layout<'_>, + cursor_position: Point, + messages: &mut Vec<B>, + renderer: &Renderer, + clipboard: Option<&dyn Clipboard>, + ) { + let mut original_messages = Vec::new(); + + self.content.on_event( + event, + layout, + cursor_position, + &mut original_messages, + renderer, + clipboard, + ); + + original_messages + .drain(..) + .for_each(|message| messages.push((self.mapper)(message))); + } + + fn draw( + &self, + renderer: &mut Renderer, + defaults: &Renderer::Defaults, + layout: Layout<'_>, + cursor_position: Point, + ) -> Renderer::Output { + self.content + .draw(renderer, defaults, layout, cursor_position) + } + + fn hash_layout(&self, state: &mut Hasher, position: Point) { + self.content.hash_layout(state, position); + } +} diff --git a/native/src/overlay/content.rs b/native/src/overlay/content.rs new file mode 100644 index 00000000..5259c4b8 --- /dev/null +++ b/native/src/overlay/content.rs @@ -0,0 +1,34 @@ +use crate::{layout, Clipboard, Event, Hasher, Layout, Point, Size}; + +pub trait Content<Message, Renderer> +where + Renderer: crate::Renderer, +{ + fn layout( + &self, + renderer: &Renderer, + bounds: Size, + position: Point, + ) -> layout::Node; + + fn draw( + &self, + renderer: &mut Renderer, + defaults: &Renderer::Defaults, + layout: Layout<'_>, + cursor_position: Point, + ) -> Renderer::Output; + + fn hash_layout(&self, state: &mut Hasher, position: Point); + + fn on_event( + &mut self, + _event: Event, + _layout: Layout<'_>, + _cursor_position: Point, + _messages: &mut Vec<Message>, + _renderer: &Renderer, + _clipboard: Option<&dyn Clipboard>, + ) { + } +} diff --git a/native/src/overlay/menu.rs b/native/src/overlay/menu.rs new file mode 100644 index 00000000..a192e389 --- /dev/null +++ b/native/src/overlay/menu.rs @@ -0,0 +1,406 @@ +use crate::{ + container, layout, mouse, overlay, scrollable, text, Clipboard, Container, + Element, Event, Hasher, Layout, Length, Point, Rectangle, Scrollable, Size, + Vector, Widget, +}; + +pub struct Menu<'a, T, Message, Renderer: self::Renderer> { + state: &'a mut State, + options: &'a [T], + on_selected: &'a dyn Fn(T) -> Message, + width: u16, + padding: u16, + text_size: Option<u16>, + font: Renderer::Font, + style: <Renderer as self::Renderer>::Style, +} + +impl<'a, T, Message, Renderer> Menu<'a, T, Message, Renderer> +where + T: ToString + Clone, + Message: 'a, + Renderer: self::Renderer + 'a, +{ + pub fn new( + state: &'a mut State, + options: &'a [T], + on_selected: &'a dyn Fn(T) -> Message, + ) -> Self { + Menu { + state, + options, + on_selected, + width: 0, + padding: 0, + text_size: None, + font: Default::default(), + style: Default::default(), + } + } + + pub fn width(mut self, width: u16) -> Self { + self.width = width; + self + } + + pub fn padding(mut self, padding: u16) -> Self { + self.padding = padding; + self + } + + pub fn text_size(mut self, text_size: u16) -> Self { + self.text_size = Some(text_size); + self + } + + pub fn font(mut self, font: Renderer::Font) -> Self { + self.font = font; + self + } + + pub fn style( + mut self, + style: impl Into<<Renderer as self::Renderer>::Style>, + ) -> Self { + self.style = style.into(); + self + } + + pub fn overlay( + self, + position: Point, + target_height: f32, + ) -> overlay::Overlay<'a, Message, Renderer> { + overlay::Overlay::new( + position, + Box::new(Overlay::new(self, target_height)), + ) + } +} + +#[derive(Default)] +pub struct State { + scrollable: scrollable::State, + hovered_option: Option<usize>, + is_open: bool, +} + +impl State { + pub fn is_open(&self) -> bool { + self.is_open + } + + pub fn open(&mut self, hovered_option: Option<usize>) { + self.is_open = true; + self.hovered_option = hovered_option; + } +} + +struct Overlay<'a, Message, Renderer: self::Renderer> { + container: Container<'a, Message, Renderer>, + is_open: &'a mut bool, + width: u16, + target_height: f32, + style: <Renderer as self::Renderer>::Style, +} + +impl<'a, Message, Renderer: self::Renderer> Overlay<'a, Message, Renderer> +where + Message: 'a, + Renderer: 'a, +{ + pub fn new<T>( + menu: Menu<'a, T, Message, Renderer>, + target_height: f32, + ) -> Self + where + T: Clone + ToString, + { + let Menu { + state, + options, + on_selected, + width, + padding, + font, + text_size, + style, + } = menu; + + let container = + Container::new(Scrollable::new(&mut state.scrollable).push(List { + options, + hovered_option: &mut state.hovered_option, + on_selected, + font, + text_size, + padding, + style: style.clone(), + })) + .padding(1); + + Self { + container, + is_open: &mut state.is_open, + width: width, + target_height, + style: style, + } + } +} + +impl<'a, Message, Renderer> overlay::Content<Message, Renderer> + for Overlay<'a, Message, Renderer> +where + Renderer: self::Renderer, +{ + fn layout( + &self, + renderer: &Renderer, + bounds: Size, + position: Point, + ) -> layout::Node { + let space_below = bounds.height - (position.y + self.target_height); + let space_above = position.y; + + let limits = layout::Limits::new( + Size::ZERO, + Size::new( + bounds.width - position.x, + if space_below > space_above { + space_below + } else { + space_above + }, + ), + ) + .width(Length::Units(self.width)); + + let mut node = self.container.layout(renderer, &limits); + + node.move_to(if space_below > space_above { + position + Vector::new(0.0, self.target_height) + } else { + position - Vector::new(0.0, node.size().height) + }); + + node + } + + fn hash_layout(&self, state: &mut Hasher, position: Point) { + use std::hash::Hash; + + struct Marker; + std::any::TypeId::of::<Marker>().hash(state); + + (position.x as u32).hash(state); + (position.y as u32).hash(state); + } + + fn on_event( + &mut self, + event: Event, + layout: Layout<'_>, + cursor_position: Point, + messages: &mut Vec<Message>, + renderer: &Renderer, + clipboard: Option<&dyn Clipboard>, + ) { + let bounds = layout.bounds(); + let current_messages = messages.len(); + + self.container.on_event( + event.clone(), + layout, + cursor_position, + messages, + renderer, + clipboard, + ); + + let option_was_selected = current_messages < messages.len(); + + match event { + Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) + if !bounds.contains(cursor_position) || option_was_selected => + { + *self.is_open = false; + } + _ => {} + } + } + + fn draw( + &self, + renderer: &mut Renderer, + defaults: &Renderer::Defaults, + layout: Layout<'_>, + cursor_position: Point, + ) -> Renderer::Output { + let primitives = + self.container + .draw(renderer, defaults, layout, cursor_position); + + renderer.decorate( + layout.bounds(), + cursor_position, + &self.style, + primitives, + ) + } +} + +struct List<'a, T, Message, Renderer: self::Renderer> { + options: &'a [T], + hovered_option: &'a mut Option<usize>, + on_selected: &'a dyn Fn(T) -> Message, + padding: u16, + text_size: Option<u16>, + font: Renderer::Font, + style: <Renderer as self::Renderer>::Style, +} + +impl<'a, T, Message, Renderer: self::Renderer> Widget<'a, Message, Renderer> + for List<'a, T, Message, Renderer> +where + T: Clone + ToString, + Renderer: self::Renderer, +{ + fn width(&self) -> Length { + Length::Fill + } + + fn height(&self) -> Length { + Length::Shrink + } + + fn layout( + &self, + renderer: &Renderer, + limits: &layout::Limits, + ) -> layout::Node { + use std::f32; + + let limits = limits.width(Length::Fill).height(Length::Shrink); + let text_size = self.text_size.unwrap_or(renderer.default_size()); + + let size = { + let intrinsic = Size::new( + 0.0, + f32::from(text_size + self.padding * 2) + * self.options.len() as f32, + ); + + limits.resolve(intrinsic) + }; + + layout::Node::new(size) + } + + fn hash_layout(&self, state: &mut Hasher) { + use std::hash::Hash as _; + + struct Marker; + std::any::TypeId::of::<Marker>().hash(state); + + self.options.len().hash(state); + self.text_size.hash(state); + self.padding.hash(state); + } + + fn on_event( + &mut self, + event: Event, + layout: Layout<'_>, + cursor_position: Point, + messages: &mut Vec<Message>, + renderer: &Renderer, + _clipboard: Option<&dyn Clipboard>, + ) { + match event { + Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => { + let bounds = layout.bounds(); + + if bounds.contains(cursor_position) { + if let Some(index) = *self.hovered_option { + if let Some(option) = self.options.get(index) { + messages.push((self.on_selected)(option.clone())); + } + } + } + } + Event::Mouse(mouse::Event::CursorMoved { .. }) => { + let bounds = layout.bounds(); + let text_size = + self.text_size.unwrap_or(renderer.default_size()); + + if bounds.contains(cursor_position) { + *self.hovered_option = Some( + ((cursor_position.y - bounds.y) + / f32::from(text_size + self.padding * 2)) + as usize, + ); + } + } + _ => {} + } + } + + fn draw( + &self, + renderer: &mut Renderer, + _defaults: &Renderer::Defaults, + layout: Layout<'_>, + cursor_position: Point, + ) -> Renderer::Output { + self::Renderer::draw( + renderer, + layout.bounds(), + cursor_position, + self.options, + *self.hovered_option, + self.padding, + self.text_size.unwrap_or(renderer.default_size()), + self.font, + &self.style, + ) + } +} + +pub trait Renderer: + scrollable::Renderer + container::Renderer + text::Renderer +{ + type Style: Default + Clone; + + fn decorate( + &mut self, + bounds: Rectangle, + cursor_position: Point, + style: &<Self as Renderer>::Style, + primitive: Self::Output, + ) -> Self::Output; + + fn draw<T: ToString>( + &mut self, + bounds: Rectangle, + cursor_position: Point, + options: &[T], + hovered_option: Option<usize>, + padding: u16, + text_size: u16, + font: Self::Font, + style: &<Self as Renderer>::Style, + ) -> Self::Output; +} + +impl<'a, T, Message, Renderer> Into<Element<'a, Message, Renderer>> + for List<'a, T, Message, Renderer> +where + T: ToString + Clone, + Message: 'a, + Renderer: 'a + self::Renderer, +{ + fn into(self) -> Element<'a, Message, Renderer> { + Element::new(self) + } +} diff --git a/native/src/program/state.rs b/native/src/program/state.rs index fdc42e8b..95e6b60c 100644 --- a/native/src/program/state.rs +++ b/native/src/program/state.rs @@ -35,7 +35,7 @@ where renderer: &mut P::Renderer, debug: &mut Debug, ) -> Self { - let user_interface = build_user_interface( + let mut user_interface = build_user_interface( &mut program, Cache::default(), renderer, @@ -121,12 +121,14 @@ where debug.event_processing_started(); let mut messages = user_interface.update( - self.queued_events.drain(..), + &self.queued_events, cursor_position, clipboard, renderer, ); messages.extend(self.queued_messages.drain(..)); + + self.queued_events.clear(); debug.event_processing_finished(); if messages.is_empty() { @@ -153,7 +155,7 @@ where command })); - let user_interface = build_user_interface( + let mut user_interface = build_user_interface( &mut self.program, temp_cache, renderer, diff --git a/native/src/renderer.rs b/native/src/renderer.rs index a16df72b..29a091a4 100644 --- a/native/src/renderer.rs +++ b/native/src/renderer.rs @@ -25,7 +25,7 @@ mod null; #[cfg(debug_assertions)] pub use null::Null; -use crate::{layout, Element}; +use crate::{layout, Element, Rectangle}; /// A component that can take the state of a user interface and produce an /// output for its users. @@ -56,4 +56,11 @@ pub trait Renderer: Sized { ) -> layout::Node { element.layout(self, limits) } + + fn overlay( + &mut self, + base: Self::Output, + overlay: Self::Output, + overlay_bounds: Rectangle, + ) -> Self::Output; } diff --git a/native/src/renderer/null.rs b/native/src/renderer/null.rs index 580f58f8..07f79319 100644 --- a/native/src/renderer/null.rs +++ b/native/src/renderer/null.rs @@ -23,6 +23,9 @@ impl Null { impl Renderer for Null { type Output = (); type Defaults = (); + + fn overlay(&mut self, _base: (), _overlay: (), _overlay_bounds: Rectangle) { + } } impl column::Renderer for Null { diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs index b9646043..6e56f357 100644 --- a/native/src/user_interface.rs +++ b/native/src/user_interface.rs @@ -1,4 +1,4 @@ -use crate::{layout, Clipboard, Element, Event, Layout, Point, Size}; +use crate::{layout, Clipboard, Element, Event, Layout, Overlay, Point, Size}; use std::hash::Hasher; @@ -19,9 +19,9 @@ use std::hash::Hasher; /// [`UserInterface`]: struct.UserInterface.html #[allow(missing_debug_implementations)] pub struct UserInterface<'a, Message, Renderer> { - hash: u64, root: Element<'a, Message, Renderer>, - layout: layout::Node, + base: Layer, + overlay: Option<Layer>, bounds: Size, } @@ -94,25 +94,36 @@ where ) -> Self { let root = root.into(); - let hash = { - let hasher = &mut crate::Hasher::default(); - root.hash_layout(hasher); + let (base, overlay) = { + let hash = { + let hasher = &mut crate::Hasher::default(); + root.hash_layout(hasher); - hasher.finish() - }; + hasher.finish() + }; - let layout_is_cached = hash == cache.hash && bounds == cache.bounds; + let layout_is_cached = + hash == cache.base.hash && bounds == cache.bounds; - let layout = if layout_is_cached { - cache.layout - } else { - renderer.layout(&root, &layout::Limits::new(Size::ZERO, bounds)) + let (layout, overlay) = if layout_is_cached { + (cache.base.layout, cache.overlay) + } else { + ( + renderer.layout( + &root, + &layout::Limits::new(Size::ZERO, bounds), + ), + None, + ) + }; + + (Layer { layout, hash }, overlay) }; UserInterface { - hash, root, - layout, + base, + overlay, bounds, } } @@ -169,7 +180,7 @@ where /// /// // Update the user interface /// let messages = user_interface.update( - /// events.drain(..), + /// &events, /// cursor_position, /// None, /// &renderer, @@ -185,18 +196,54 @@ where /// ``` pub fn update( &mut self, - events: impl IntoIterator<Item = Event>, + events: &[Event], cursor_position: Point, clipboard: Option<&dyn Clipboard>, renderer: &Renderer, ) -> Vec<Message> { let mut messages = Vec::new(); + let base_cursor = if let Some(mut overlay) = + self.root.overlay(Layout::new(&self.base.layout)) + { + let layer = Self::overlay_layer( + self.overlay.take(), + self.bounds, + &mut overlay, + renderer, + ); + + for event in events { + overlay.on_event( + event.clone(), + Layout::new(&layer.layout), + cursor_position, + &mut messages, + renderer, + clipboard, + ); + } + + let base_cursor = if layer.layout.bounds().contains(cursor_position) + { + // TODO: Type-safe cursor availability + Point::new(-1.0, -1.0) + } else { + cursor_position + }; + + self.overlay = Some(layer); + + base_cursor + } else { + cursor_position + }; + for event in events { self.root.widget.on_event( - event, - Layout::new(&self.layout), - cursor_position, + event.clone(), + Layout::new(&self.base.layout), + base_cursor, &mut messages, renderer, clipboard, @@ -256,7 +303,7 @@ where /// ); /// /// let messages = user_interface.update( - /// events.drain(..), + /// &events, /// cursor_position, /// None, /// &renderer, @@ -276,16 +323,63 @@ where /// } /// ``` pub fn draw( - &self, + &mut self, renderer: &mut Renderer, cursor_position: Point, ) -> Renderer::Output { - self.root.widget.draw( - renderer, - &Renderer::Defaults::default(), - Layout::new(&self.layout), - cursor_position, - ) + let overlay = if let Some(mut overlay) = + self.root.overlay(Layout::new(&self.base.layout)) + { + let layer = Self::overlay_layer( + self.overlay.take(), + self.bounds, + &mut overlay, + renderer, + ); + + let overlay_bounds = layer.layout.bounds(); + + let overlay_primitives = overlay.draw( + renderer, + &Renderer::Defaults::default(), + Layout::new(&layer.layout), + cursor_position, + ); + + self.overlay = Some(layer); + + Some((overlay_primitives, overlay_bounds)) + } else { + None + }; + + if let Some((overlay_primitives, overlay_bounds)) = overlay { + let base_cursor = if overlay_bounds.contains(cursor_position) { + Point::new(-1.0, -1.0) + } else { + cursor_position + }; + + let base_primitives = self.root.widget.draw( + renderer, + &Renderer::Defaults::default(), + Layout::new(&self.base.layout), + base_cursor, + ); + + renderer.overlay( + base_primitives, + overlay_primitives, + overlay_bounds, + ) + } else { + self.root.widget.draw( + renderer, + &Renderer::Defaults::default(), + Layout::new(&self.base.layout), + cursor_position, + ) + } } /// Extract the [`Cache`] of the [`UserInterface`], consuming it in the @@ -295,11 +389,41 @@ where /// [`UserInterface`]: struct.UserInterface.html pub fn into_cache(self) -> Cache { Cache { - hash: self.hash, - layout: self.layout, + base: self.base, + overlay: self.overlay, bounds: self.bounds, } } + + fn overlay_layer( + cache: Option<Layer>, + bounds: Size, + overlay: &mut Overlay<'_, Message, Renderer>, + renderer: &Renderer, + ) -> Layer { + let new_hash = { + let hasher = &mut crate::Hasher::default(); + overlay.hash_layout(hasher); + + hasher.finish() + }; + + let layout = match cache { + Some(Layer { hash, layout }) if new_hash == hash => layout, + _ => overlay.layout(renderer, bounds), + }; + + Layer { + layout, + hash: new_hash, + } + } +} + +#[derive(Debug, Clone)] +struct Layer { + layout: layout::Node, + hash: u64, } /// Reusable data of a specific [`UserInterface`]. @@ -307,8 +431,8 @@ where /// [`UserInterface`]: struct.UserInterface.html #[derive(Debug, Clone)] pub struct Cache { - hash: u64, - layout: layout::Node, + base: Layer, + overlay: Option<Layer>, bounds: Size, } @@ -322,8 +446,11 @@ impl Cache { /// [`UserInterface`]: struct.UserInterface.html pub fn new() -> Cache { Cache { - hash: 0, - layout: layout::Node::new(Size::new(0.0, 0.0)), + base: Layer { + layout: layout::Node::new(Size::new(0.0, 0.0)), + hash: 0, + }, + overlay: None, bounds: Size::ZERO, } } @@ -334,11 +461,3 @@ impl Default for Cache { Cache::new() } } - -impl PartialEq for Cache { - fn eq(&self, other: &Cache) -> bool { - self.hash == other.hash - } -} - -impl Eq for Cache {} diff --git a/native/src/widget.rs b/native/src/widget.rs index 4453145b..4bca7722 100644 --- a/native/src/widget.rs +++ b/native/src/widget.rs @@ -23,6 +23,7 @@ pub mod button; pub mod checkbox; pub mod column; +pub mod combo_box; pub mod container; pub mod image; pub mod pane_grid; @@ -43,6 +44,8 @@ pub use checkbox::Checkbox; #[doc(no_inline)] pub use column::Column; #[doc(no_inline)] +pub use combo_box::ComboBox; +#[doc(no_inline)] pub use container::Container; #[doc(no_inline)] pub use image::Image; @@ -67,7 +70,7 @@ pub use text::Text; #[doc(no_inline)] pub use text_input::TextInput; -use crate::{layout, Clipboard, Event, Hasher, Layout, Length, Point}; +use crate::{layout, Clipboard, Event, Hasher, Layout, Length, Overlay, Point}; /// A component that displays information and allows interaction. /// @@ -94,7 +97,7 @@ use crate::{layout, Clipboard, Event, Hasher, Layout, Length, Point}; /// [`geometry`]: https://github.com/hecrj/iced/tree/0.1/examples/geometry /// [`lyon`]: https://github.com/nical/lyon /// [`iced_wgpu`]: https://github.com/hecrj/iced/tree/0.1/wgpu -pub trait Widget<Message, Renderer> +pub trait Widget<'a, Message, Renderer> where Renderer: crate::Renderer, { @@ -175,4 +178,11 @@ where _clipboard: Option<&dyn Clipboard>, ) { } + + fn overlay<'b>( + &'b mut self, + _layout: Layout<'_>, + ) -> Option<Overlay<'b, Message, Renderer>> { + None + } } diff --git a/native/src/widget/button.rs b/native/src/widget/button.rs index c932da2b..72db808b 100644 --- a/native/src/widget/button.rs +++ b/native/src/widget/button.rs @@ -139,7 +139,7 @@ impl State { } } -impl<'a, Message, Renderer> Widget<Message, Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for Button<'a, Message, Renderer> where Renderer: self::Renderer, diff --git a/native/src/widget/checkbox.rs b/native/src/widget/checkbox.rs index 44962288..82fd6d1f 100644 --- a/native/src/widget/checkbox.rs +++ b/native/src/widget/checkbox.rs @@ -106,7 +106,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer> } } -impl<Message, Renderer> Widget<Message, Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for Checkbox<Message, Renderer> where Renderer: self::Renderer + text::Renderer + row::Renderer, diff --git a/native/src/widget/column.rs b/native/src/widget/column.rs index 259a7e6e..e83ef93d 100644 --- a/native/src/widget/column.rs +++ b/native/src/widget/column.rs @@ -2,8 +2,8 @@ use std::hash::Hash; use crate::{ - layout, Align, Clipboard, Element, Event, Hasher, Layout, Length, Point, - Widget, + layout, Align, Clipboard, Element, Event, Hasher, Layout, Length, Overlay, + Point, Widget, }; use std::u32; @@ -121,7 +121,7 @@ impl<'a, Message, Renderer> Column<'a, Message, Renderer> { } } -impl<'a, Message, Renderer> Widget<Message, Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for Column<'a, Message, Renderer> where Renderer: self::Renderer, @@ -204,6 +204,17 @@ where child.widget.hash_layout(state); } } + + fn overlay( + &mut self, + layout: Layout<'_>, + ) -> Option<Overlay<'_, Message, Renderer>> { + self.children + .iter_mut() + .zip(layout.children()) + .filter_map(|(child, layout)| child.widget.overlay(layout)) + .next() + } } /// The renderer of a [`Column`]. diff --git a/native/src/widget/combo_box.rs b/native/src/widget/combo_box.rs new file mode 100644 index 00000000..9447b9dd --- /dev/null +++ b/native/src/widget/combo_box.rs @@ -0,0 +1,282 @@ +use crate::{ + layout, mouse, + overlay::menu::{self, Menu}, + scrollable, text, Clipboard, Element, Event, Hasher, Layout, Length, + Overlay, Point, Rectangle, Size, Widget, +}; +use std::borrow::Cow; + +pub struct ComboBox<'a, T, Message, Renderer: self::Renderer> +where + [T]: ToOwned<Owned = Vec<T>>, +{ + menu: &'a mut menu::State, + on_selected: Box<dyn Fn(T) -> Message>, + options: Cow<'a, [T]>, + selected: Option<T>, + width: Length, + padding: u16, + text_size: Option<u16>, + font: Renderer::Font, + style: <Renderer as self::Renderer>::Style, + is_open: bool, +} + +#[derive(Default)] +pub struct State { + menu: menu::State, +} + +impl<'a, T: 'a, Message, Renderer: self::Renderer> + ComboBox<'a, T, Message, Renderer> +where + T: ToString, + [T]: ToOwned<Owned = Vec<T>>, +{ + pub fn new( + state: &'a mut State, + options: impl Into<Cow<'a, [T]>>, + selected: Option<T>, + on_selected: impl Fn(T) -> Message + 'static, + ) -> Self { + let is_open = state.menu.is_open(); + + Self { + menu: &mut state.menu, + on_selected: Box::new(on_selected), + options: options.into(), + selected, + width: Length::Shrink, + text_size: None, + padding: Renderer::DEFAULT_PADDING, + font: Default::default(), + style: Default::default(), + is_open, + } + } + + /// Sets the width of the [`ComboBox`]. + /// + /// [`ComboBox`]: struct.Button.html + pub fn width(mut self, width: Length) -> Self { + self.width = width; + self + } + + /// Sets the padding of the [`ComboBox`]. + /// + /// [`ComboBox`]: struct.Button.html + pub fn padding(mut self, padding: u16) -> Self { + self.padding = padding; + self + } + + pub fn text_size(mut self, size: u16) -> Self { + self.text_size = Some(size); + self + } + + pub fn font(mut self, font: Renderer::Font) -> Self { + self.font = font; + self + } + + /// Sets the style of the [`ComboBox`]. + /// + /// [`ComboBox`]: struct.ComboBox.html + pub fn style( + mut self, + style: impl Into<<Renderer as self::Renderer>::Style>, + ) -> Self { + self.style = style.into(); + self + } +} + +impl<'a, T: 'a, Message, Renderer> Widget<'a, Message, Renderer> + for ComboBox<'a, T, Message, Renderer> +where + T: Clone + ToString + Eq, + [T]: ToOwned<Owned = Vec<T>>, + Message: 'static, + Renderer: self::Renderer + scrollable::Renderer + 'a, +{ + fn width(&self) -> Length { + Length::Shrink + } + + fn height(&self) -> Length { + Length::Shrink + } + + fn layout( + &self, + renderer: &Renderer, + limits: &layout::Limits, + ) -> layout::Node { + use std::f32; + + let limits = limits + .width(self.width) + .height(Length::Shrink) + .pad(f32::from(self.padding)); + + let text_size = self.text_size.unwrap_or(renderer.default_size()); + + let max_width = match self.width { + Length::Shrink => { + let labels = self.options.iter().map(ToString::to_string); + + labels + .map(|label| { + let (width, _) = renderer.measure( + &label, + text_size, + Renderer::Font::default(), + Size::new(f32::INFINITY, f32::INFINITY), + ); + + width.round() as u32 + }) + .max() + .unwrap_or(100) + } + _ => 0, + }; + + let size = { + let intrinsic = Size::new( + max_width as f32 + + f32::from(text_size) + + f32::from(self.padding), + f32::from(text_size), + ); + + limits.resolve(intrinsic).pad(f32::from(self.padding)) + }; + + layout::Node::new(size) + } + + fn hash_layout(&self, state: &mut Hasher) { + use std::hash::Hash as _; + + match self.width { + Length::Shrink => { + self.options + .iter() + .map(ToString::to_string) + .for_each(|label| label.hash(state)); + } + _ => { + self.width.hash(state); + } + } + } + + fn on_event( + &mut self, + event: Event, + layout: Layout<'_>, + cursor_position: Point, + _messages: &mut Vec<Message>, + _renderer: &Renderer, + _clipboard: Option<&dyn Clipboard>, + ) { + if !self.is_open { + match event { + Event::Mouse(mouse::Event::ButtonPressed( + mouse::Button::Left, + )) => { + if layout.bounds().contains(cursor_position) { + let selected = self.selected.as_ref(); + + self.menu.open( + self.options + .iter() + .position(|option| Some(option) == selected), + ); + } + } + _ => {} + } + } + } + + fn draw( + &self, + renderer: &mut Renderer, + _defaults: &Renderer::Defaults, + layout: Layout<'_>, + cursor_position: Point, + ) -> Renderer::Output { + self::Renderer::draw( + renderer, + layout.bounds(), + cursor_position, + self.selected.as_ref().map(ToString::to_string), + self.padding, + self.text_size.unwrap_or(renderer.default_size()), + self.font, + &self.style, + ) + } + + fn overlay( + &mut self, + layout: Layout<'_>, + ) -> Option<Overlay<'_, Message, Renderer>> { + if self.menu.is_open() { + let bounds = layout.bounds(); + + let mut menu = + Menu::new(&mut self.menu, &self.options, &self.on_selected) + .width(bounds.width.round() as u16) + .padding(self.padding) + .font(self.font) + .style(Renderer::menu_style(&self.style)); + + if let Some(text_size) = self.text_size { + menu = menu.text_size(text_size); + } + + Some(menu.overlay(layout.position(), bounds.height)) + } else { + None + } + } +} + +pub trait Renderer: text::Renderer + menu::Renderer { + type Style: Default; + + const DEFAULT_PADDING: u16; + + fn menu_style( + style: &<Self as Renderer>::Style, + ) -> <Self as menu::Renderer>::Style; + + fn draw( + &mut self, + bounds: Rectangle, + cursor_position: Point, + selected: Option<String>, + padding: u16, + text_size: u16, + font: Self::Font, + style: &<Self as Renderer>::Style, + ) -> Self::Output; +} + +impl<'a, T: 'a, Message, Renderer> Into<Element<'a, Message, Renderer>> + for ComboBox<'a, T, Message, Renderer> +where + T: Clone + ToString + Eq, + [T]: ToOwned<Owned = Vec<T>>, + Renderer: self::Renderer + 'a, + Message: 'static, +{ + fn into(self) -> Element<'a, Message, Renderer> { + Element::new(self) + } +} diff --git a/native/src/widget/container.rs b/native/src/widget/container.rs index 2590fe3b..4ab10837 100644 --- a/native/src/widget/container.rs +++ b/native/src/widget/container.rs @@ -2,8 +2,8 @@ use std::hash::Hash; use crate::{ - layout, Align, Clipboard, Element, Event, Hasher, Layout, Length, Point, - Rectangle, Widget, + layout, Align, Clipboard, Element, Event, Hasher, Layout, Length, Overlay, + Point, Rectangle, Widget, }; use std::u32; @@ -129,7 +129,7 @@ where } } -impl<'a, Message, Renderer> Widget<Message, Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for Container<'a, Message, Renderer> where Renderer: self::Renderer, @@ -214,6 +214,13 @@ where self.content.hash_layout(state); } + + fn overlay( + &mut self, + layout: Layout<'_>, + ) -> Option<Overlay<'_, Message, Renderer>> { + self.content.overlay(layout.children().next().unwrap()) + } } /// The renderer of a [`Container`]. diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs index 132f249d..b7c8f4ff 100644 --- a/native/src/widget/image.rs +++ b/native/src/widget/image.rs @@ -54,7 +54,7 @@ impl Image { } } -impl<Message, Renderer> Widget<Message, Renderer> for Image +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for Image where Renderer: self::Renderer, { diff --git a/native/src/widget/pane_grid.rs b/native/src/widget/pane_grid.rs index c472d043..8fc423af 100644 --- a/native/src/widget/pane_grid.rs +++ b/native/src/widget/pane_grid.rs @@ -402,7 +402,7 @@ pub struct KeyPressEvent { pub modifiers: keyboard::ModifiersState, } -impl<'a, Message, Renderer> Widget<Message, Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for PaneGrid<'a, Message, Renderer> where Renderer: self::Renderer + container::Renderer, diff --git a/native/src/widget/progress_bar.rs b/native/src/widget/progress_bar.rs index 5ab76d47..93d86371 100644 --- a/native/src/widget/progress_bar.rs +++ b/native/src/widget/progress_bar.rs @@ -70,7 +70,8 @@ impl<Renderer: self::Renderer> ProgressBar<Renderer> { } } -impl<Message, Renderer> Widget<Message, Renderer> for ProgressBar<Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> + for ProgressBar<Renderer> where Renderer: self::Renderer, { diff --git a/native/src/widget/radio.rs b/native/src/widget/radio.rs index 5b8d00e9..0d88c740 100644 --- a/native/src/widget/radio.rs +++ b/native/src/widget/radio.rs @@ -121,7 +121,8 @@ impl<Message, Renderer: self::Renderer + text::Renderer> } } -impl<Message, Renderer> Widget<Message, Renderer> for Radio<Message, Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> + for Radio<Message, Renderer> where Renderer: self::Renderer + text::Renderer + row::Renderer, Message: Clone, diff --git a/native/src/widget/row.rs b/native/src/widget/row.rs index 31f7472f..1cfe2d66 100644 --- a/native/src/widget/row.rs +++ b/native/src/widget/row.rs @@ -2,8 +2,8 @@ use std::hash::Hash; use crate::{ - layout, Align, Clipboard, Element, Event, Hasher, Layout, Length, Point, - Widget, + layout, Align, Clipboard, Element, Event, Hasher, Layout, Length, Overlay, + Point, Widget, }; use std::u32; @@ -122,7 +122,7 @@ impl<'a, Message, Renderer> Row<'a, Message, Renderer> { } } -impl<'a, Message, Renderer> Widget<Message, Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for Row<'a, Message, Renderer> where Renderer: self::Renderer, @@ -206,6 +206,17 @@ where child.widget.hash_layout(state); } } + + fn overlay( + &mut self, + layout: Layout<'_>, + ) -> Option<Overlay<'_, Message, Renderer>> { + self.children + .iter_mut() + .zip(layout.children()) + .filter_map(|(child, layout)| child.widget.overlay(layout)) + .next() + } } /// The renderer of a [`Row`]. diff --git a/native/src/widget/scrollable.rs b/native/src/widget/scrollable.rs index 3c8e5e5b..87871e28 100644 --- a/native/src/widget/scrollable.rs +++ b/native/src/widget/scrollable.rs @@ -1,7 +1,7 @@ //! Navigate an endless amount of content with a scrollbar. use crate::{ column, layout, mouse, Align, Clipboard, Column, Element, Event, Hasher, - Layout, Length, Point, Rectangle, Size, Widget, + Layout, Length, Overlay, Point, Rectangle, Size, Vector, Widget, }; use std::{f32, hash::Hash, u32}; @@ -110,10 +110,10 @@ impl<'a, Message, Renderer: self::Renderer> Scrollable<'a, Message, Renderer> { } } -impl<'a, Message, Renderer> Widget<Message, Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for Scrollable<'a, Message, Renderer> where - Renderer: self::Renderer + column::Renderer, + Renderer: self::Renderer, { fn width(&self) -> Length { Widget::<Message, Renderer>::width(&self.content) @@ -315,6 +315,24 @@ where self.content.hash_layout(state) } + + fn overlay( + &mut self, + layout: Layout<'_>, + ) -> Option<Overlay<'_, Message, Renderer>> { + let Self { content, state, .. } = self; + + content + .overlay(layout.children().next().unwrap()) + .map(|overlay| { + let bounds = layout.bounds(); + let content_layout = layout.children().next().unwrap(); + let content_bounds = content_layout.bounds(); + let offset = state.offset(bounds, content_bounds); + + overlay.translate(Vector::new(0.0, -(offset as f32))) + }) + } } /// The local state of a [`Scrollable`]. @@ -454,7 +472,7 @@ pub struct Scroller { /// /// [`Scrollable`]: struct.Scrollable.html /// [renderer]: ../../renderer/index.html -pub trait Renderer: crate::Renderer + Sized { +pub trait Renderer: column::Renderer + Sized { /// The style supported by this renderer. type Style: Default; @@ -502,7 +520,7 @@ pub trait Renderer: crate::Renderer + Sized { impl<'a, Message, Renderer> From<Scrollable<'a, Message, Renderer>> for Element<'a, Message, Renderer> where - Renderer: 'a + self::Renderer + column::Renderer, + Renderer: 'a + self::Renderer, Message: 'a, { fn from( diff --git a/native/src/widget/slider.rs b/native/src/widget/slider.rs index 70f2b6ac..e0193342 100644 --- a/native/src/widget/slider.rs +++ b/native/src/widget/slider.rs @@ -154,7 +154,7 @@ impl State { } } -impl<'a, T, Message, Renderer> Widget<Message, Renderer> +impl<'a, T, Message, Renderer> Widget<'a, Message, Renderer> for Slider<'a, T, Message, Renderer> where T: Copy + Into<f64> + num_traits::FromPrimitive, diff --git a/native/src/widget/space.rs b/native/src/widget/space.rs index e56a8fe1..8ada40ed 100644 --- a/native/src/widget/space.rs +++ b/native/src/widget/space.rs @@ -43,7 +43,7 @@ impl Space { } } -impl<'a, Message, Renderer> Widget<Message, Renderer> for Space +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for Space where Renderer: self::Renderer, { diff --git a/native/src/widget/svg.rs b/native/src/widget/svg.rs index 114d5e41..3e45aaf6 100644 --- a/native/src/widget/svg.rs +++ b/native/src/widget/svg.rs @@ -60,7 +60,7 @@ impl Svg { } } -impl<Message, Renderer> Widget<Message, Renderer> for Svg +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for Svg where Renderer: self::Renderer, { diff --git a/native/src/widget/text.rs b/native/src/widget/text.rs index 48a69e34..7f75eb9c 100644 --- a/native/src/widget/text.rs +++ b/native/src/widget/text.rs @@ -112,7 +112,7 @@ impl<Renderer: self::Renderer> Text<Renderer> { } } -impl<Message, Renderer> Widget<Message, Renderer> for Text<Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for Text<Renderer> where Renderer: self::Renderer, { diff --git a/native/src/widget/text_input.rs b/native/src/widget/text_input.rs index 3f415101..63be6019 100644 --- a/native/src/widget/text_input.rs +++ b/native/src/widget/text_input.rs @@ -165,7 +165,7 @@ impl<'a, Message, Renderer: self::Renderer> TextInput<'a, Message, Renderer> { } } -impl<'a, Message, Renderer> Widget<Message, Renderer> +impl<'a, Message, Renderer> Widget<'a, Message, Renderer> for TextInput<'a, Message, Renderer> where Renderer: self::Renderer, |