From f064f0482b653a1fbee4afbddcecf91e3a399004 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Thu, 16 Apr 2020 13:22:00 +0200 Subject: Introduce `Layer` trait --- native/src/user_interface.rs | 149 +++++++++++++++++++++++++++++++++---------- 1 file changed, 115 insertions(+), 34 deletions(-) (limited to 'native/src/user_interface.rs') diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs index b9646043..6758bce3 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,12 +19,17 @@ 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>>, bounds: Size, } +struct Layer { + root: T, + layout: layout::Node, + hash: u64, +} + impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> where Renderer: crate::Renderer, @@ -92,27 +97,45 @@ where cache: Cache, renderer: &mut Renderer, ) -> Self { - let root = root.into(); + let mut 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.hash && bounds == cache.bounds; - let layout = if layout_is_cached { - cache.layout - } else { - renderer.layout(&root, &layout::Limits::new(Size::ZERO, bounds)) + let layout = if layout_is_cached { + cache.layout + } else { + renderer.layout(&root, &layout::Limits::new(Size::ZERO, bounds)) + }; + + let overlay = root.overlay(Layout::new(&layout)); + + (Layer { root, layout, hash }, overlay) }; + let overlay = overlay.map(|root| { + let hash = { + let hasher = &mut crate::Hasher::default(); + root.hash_layout(hasher); + + hasher.finish() + }; + + let layout = root.layout(&renderer, bounds); + + Layer { root, layout, hash } + }); + UserInterface { - hash, - root, - layout, + base, + overlay, bounds, } } @@ -193,14 +216,42 @@ where let mut messages = Vec::new(); for event in events { - self.root.widget.on_event( - event, - Layout::new(&self.layout), - cursor_position, - &mut messages, - renderer, - clipboard, - ); + if let Some(overlay) = &mut self.overlay { + overlay.root.on_event( + event.clone(), + Layout::new(&overlay.layout), + cursor_position, + &mut messages, + renderer, + clipboard, + ); + + let base_cursor = + if overlay.layout.bounds().contains(cursor_position) { + // TODO: Encode cursor availability + Point::new(-1.0, -1.0) + } else { + cursor_position + }; + + self.base.root.widget.on_event( + event, + Layout::new(&self.base.layout), + base_cursor, + &mut messages, + renderer, + clipboard, + ); + } else { + self.base.root.widget.on_event( + event, + Layout::new(&self.base.layout), + cursor_position, + &mut messages, + renderer, + clipboard, + ); + } } messages @@ -280,12 +331,42 @@ where renderer: &mut Renderer, cursor_position: Point, ) -> Renderer::Output { - self.root.widget.draw( - renderer, - &Renderer::Defaults::default(), - Layout::new(&self.layout), - cursor_position, - ) + if let Some(overlay) = &self.overlay { + let overlay_bounds = overlay.layout.bounds(); + + let base_cursor = if overlay_bounds.contains(cursor_position) { + Point::new(-1.0, -1.0) + } else { + cursor_position + }; + + let base_primitives = self.base.root.widget.draw( + renderer, + &Renderer::Defaults::default(), + Layout::new(&self.base.layout), + base_cursor, + ); + + let overlay_primitives = overlay.root.draw( + renderer, + &Renderer::Defaults::default(), + Layout::new(&overlay.layout), + cursor_position, + ); + + renderer.overlay( + base_primitives, + overlay_primitives, + overlay_bounds, + ) + } else { + self.base.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,8 +376,8 @@ where /// [`UserInterface`]: struct.UserInterface.html pub fn into_cache(self) -> Cache { Cache { - hash: self.hash, - layout: self.layout, + hash: self.base.hash, + layout: self.base.layout, bounds: self.bounds, } } -- cgit From afd9274de26ccf65285df02007b4ddb697bea9a3 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Sat, 18 Apr 2020 14:42:48 +0200 Subject: Draft `ComboBox` and `Menu` layer --- native/src/user_interface.rs | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'native/src/user_interface.rs') diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs index 6758bce3..12cea684 100644 --- a/native/src/user_interface.rs +++ b/native/src/user_interface.rs @@ -217,6 +217,14 @@ where for event in events { if let Some(overlay) = &mut self.overlay { + let base_cursor = + if overlay.layout.bounds().contains(cursor_position) { + // TODO: Encode cursor availability + Point::new(-1.0, -1.0) + } else { + cursor_position + }; + overlay.root.on_event( event.clone(), Layout::new(&overlay.layout), @@ -226,14 +234,6 @@ where clipboard, ); - let base_cursor = - if overlay.layout.bounds().contains(cursor_position) { - // TODO: Encode cursor availability - Point::new(-1.0, -1.0) - } else { - cursor_position - }; - self.base.root.widget.on_event( event, Layout::new(&self.base.layout), -- cgit From 625979b6652a8a14a0eaf6bd62f1e9a8da0ae421 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Sun, 5 Jul 2020 05:44:10 +0200 Subject: Draft `Widget::overlay` idempotency --- native/src/user_interface.rs | 128 ++++++++++++++++++++++--------------------- 1 file changed, 67 insertions(+), 61 deletions(-) (limited to 'native/src/user_interface.rs') diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs index 12cea684..9ec6bb96 100644 --- a/native/src/user_interface.rs +++ b/native/src/user_interface.rs @@ -1,4 +1,4 @@ -use crate::{layout, Clipboard, Element, Event, Layout, Overlay, Point, Size}; +use crate::{layout, Clipboard, Element, Event, Layout, Point, Size}; use std::hash::Hasher; @@ -19,13 +19,13 @@ use std::hash::Hasher; /// [`UserInterface`]: struct.UserInterface.html #[allow(missing_debug_implementations)] pub struct UserInterface<'a, Message, Renderer> { - base: Layer>, - overlay: Option>>, + root: Element<'a, Message, Renderer>, + base: Layer, + overlay: Option, bounds: Size, } -struct Layer { - root: T, +struct Layer { layout: layout::Node, hash: u64, } @@ -97,9 +97,9 @@ where cache: Cache, renderer: &mut Renderer, ) -> Self { - let mut root = root.into(); + let root = root.into(); - let (base, overlay) = { + let base = { let hash = { let hasher = &mut crate::Hasher::default(); root.hash_layout(hasher); @@ -115,27 +115,13 @@ where renderer.layout(&root, &layout::Limits::new(Size::ZERO, bounds)) }; - let overlay = root.overlay(Layout::new(&layout)); - - (Layer { root, layout, hash }, overlay) + Layer { layout, hash } }; - let overlay = overlay.map(|root| { - let hash = { - let hasher = &mut crate::Hasher::default(); - root.hash_layout(hasher); - - hasher.finish() - }; - - let layout = root.layout(&renderer, bounds); - - Layer { root, layout, hash } - }); - UserInterface { + root, base, - overlay, + overlay: None, bounds, } } @@ -215,35 +201,49 @@ where ) -> Vec { let mut messages = Vec::new(); - for event in events { - if let Some(overlay) = &mut self.overlay { - let base_cursor = - if overlay.layout.bounds().contains(cursor_position) { - // TODO: Encode cursor availability - Point::new(-1.0, -1.0) - } else { - cursor_position - }; + let base_events = if let Some(mut overlay) = + self.root.overlay(Layout::new(&self.base.layout)) + { + let layer = { + let new_hash = { + let hasher = &mut crate::Hasher::default(); + overlay.hash_layout(hasher); - overlay.root.on_event( + hasher.finish() + }; + + let layout = match self.overlay.take() { + Some(Layer { hash, layout }) if new_hash == hash => layout, + _ => overlay.layout(&renderer, self.bounds), + }; + + Layer { + layout, + hash: new_hash, + } + }; + + for event in events { + overlay.on_event( event.clone(), - Layout::new(&overlay.layout), + Layout::new(&layer.layout), cursor_position, &mut messages, renderer, clipboard, ); + } - self.base.root.widget.on_event( - event, - Layout::new(&self.base.layout), - base_cursor, - &mut messages, - renderer, - clipboard, - ); - } else { - self.base.root.widget.on_event( + self.overlay = Some(layer); + + None + } else { + Some(events) + }; + + if let Some(events) = base_events { + for event in events { + self.root.widget.on_event( event, Layout::new(&self.base.layout), cursor_position, @@ -327,12 +327,12 @@ where /// } /// ``` pub fn draw( - &self, + &mut self, renderer: &mut Renderer, cursor_position: Point, ) -> Renderer::Output { - if let Some(overlay) = &self.overlay { - let overlay_bounds = overlay.layout.bounds(); + if let Some(layer) = &self.overlay { + let overlay_bounds = layer.layout.bounds(); let base_cursor = if overlay_bounds.contains(cursor_position) { Point::new(-1.0, -1.0) @@ -340,27 +340,33 @@ where cursor_position }; - let base_primitives = self.base.root.widget.draw( + let base_primitives = self.root.widget.draw( renderer, &Renderer::Defaults::default(), Layout::new(&self.base.layout), base_cursor, ); - let overlay_primitives = overlay.root.draw( - renderer, - &Renderer::Defaults::default(), - Layout::new(&overlay.layout), - cursor_position, - ); + if let Some(overlay) = + self.root.overlay(Layout::new(&self.base.layout)) + { + let overlay_primitives = overlay.draw( + renderer, + &Renderer::Defaults::default(), + Layout::new(&layer.layout), + cursor_position, + ); - renderer.overlay( - base_primitives, - overlay_primitives, - overlay_bounds, - ) + renderer.overlay( + base_primitives, + overlay_primitives, + overlay_bounds, + ) + } else { + base_primitives + } } else { - self.base.root.widget.draw( + self.root.widget.draw( renderer, &Renderer::Defaults::default(), Layout::new(&self.base.layout), -- cgit From aa0ec2821ef9439adb52a2712da553404eb11b4d Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Wed, 8 Jul 2020 08:09:14 +0200 Subject: Finish wiring overlays to `UserInterface` --- native/src/user_interface.rs | 194 +++++++++++++++++++++++++------------------ 1 file changed, 113 insertions(+), 81 deletions(-) (limited to 'native/src/user_interface.rs') diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs index 9ec6bb96..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; @@ -25,11 +25,6 @@ pub struct UserInterface<'a, Message, Renderer> { bounds: Size, } -struct Layer { - layout: layout::Node, - hash: u64, -} - impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> where Renderer: crate::Renderer, @@ -99,7 +94,7 @@ where ) -> Self { let root = root.into(); - let base = { + let (base, overlay) = { let hash = { let hasher = &mut crate::Hasher::default(); root.hash_layout(hasher); @@ -107,21 +102,28 @@ where 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 + let (layout, overlay) = if layout_is_cached { + (cache.base.layout, cache.overlay) } else { - renderer.layout(&root, &layout::Limits::new(Size::ZERO, bounds)) + ( + renderer.layout( + &root, + &layout::Limits::new(Size::ZERO, bounds), + ), + None, + ) }; - Layer { layout, hash } + (Layer { layout, hash }, overlay) }; UserInterface { root, base, - overlay: None, + overlay, bounds, } } @@ -178,7 +180,7 @@ where /// /// // Update the user interface /// let messages = user_interface.update( - /// events.drain(..), + /// &events, /// cursor_position, /// None, /// &renderer, @@ -194,34 +196,22 @@ where /// ``` pub fn update( &mut self, - events: impl IntoIterator, + events: &[Event], cursor_position: Point, clipboard: Option<&dyn Clipboard>, renderer: &Renderer, ) -> Vec { let mut messages = Vec::new(); - let base_events = if let Some(mut overlay) = + let base_cursor = if let Some(mut overlay) = self.root.overlay(Layout::new(&self.base.layout)) { - let layer = { - let new_hash = { - let hasher = &mut crate::Hasher::default(); - overlay.hash_layout(hasher); - - hasher.finish() - }; - - let layout = match self.overlay.take() { - Some(Layer { hash, layout }) if new_hash == hash => layout, - _ => overlay.layout(&renderer, self.bounds), - }; - - Layer { - layout, - hash: new_hash, - } - }; + let layer = Self::overlay_layer( + self.overlay.take(), + self.bounds, + &mut overlay, + renderer, + ); for event in events { overlay.on_event( @@ -234,24 +224,30 @@ where ); } + 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); - None + base_cursor } else { - Some(events) + cursor_position }; - if let Some(events) = base_events { - for event in events { - self.root.widget.on_event( - event, - Layout::new(&self.base.layout), - cursor_position, - &mut messages, - renderer, - clipboard, - ); - } + for event in events { + self.root.widget.on_event( + event.clone(), + Layout::new(&self.base.layout), + base_cursor, + &mut messages, + renderer, + clipboard, + ); } messages @@ -307,7 +303,7 @@ where /// ); /// /// let messages = user_interface.update( - /// events.drain(..), + /// &events, /// cursor_position, /// None, /// &renderer, @@ -331,9 +327,33 @@ where renderer: &mut Renderer, cursor_position: Point, ) -> Renderer::Output { - if let Some(layer) = &self.overlay { + 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 { @@ -347,24 +367,11 @@ where base_cursor, ); - if let Some(overlay) = - self.root.overlay(Layout::new(&self.base.layout)) - { - let overlay_primitives = overlay.draw( - renderer, - &Renderer::Defaults::default(), - Layout::new(&layer.layout), - cursor_position, - ); - - renderer.overlay( - base_primitives, - overlay_primitives, - overlay_bounds, - ) - } else { - base_primitives - } + renderer.overlay( + base_primitives, + overlay_primitives, + overlay_bounds, + ) } else { self.root.widget.draw( renderer, @@ -382,11 +389,41 @@ where /// [`UserInterface`]: struct.UserInterface.html pub fn into_cache(self) -> Cache { Cache { - hash: self.base.hash, - layout: self.base.layout, + base: self.base, + overlay: self.overlay, bounds: self.bounds, } } + + fn overlay_layer( + cache: Option, + 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`]. @@ -394,8 +431,8 @@ where /// [`UserInterface`]: struct.UserInterface.html #[derive(Debug, Clone)] pub struct Cache { - hash: u64, - layout: layout::Node, + base: Layer, + overlay: Option, bounds: Size, } @@ -409,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, } } @@ -421,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 {} -- cgit From 1070b61f3408539f6c9cb9d265f3295e6d055db7 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Fri, 10 Jul 2020 01:31:56 +0200 Subject: Rename `overlay::Content` trait to `Overlay` The `Overlay` struct is now `overlay::Element`. --- native/src/user_interface.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'native/src/user_interface.rs') diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs index 6e56f357..00a290f1 100644 --- a/native/src/user_interface.rs +++ b/native/src/user_interface.rs @@ -1,4 +1,4 @@ -use crate::{layout, Clipboard, Element, Event, Layout, Overlay, Point, Size}; +use crate::{layout, overlay, Clipboard, Element, Event, Layout, Point, Size}; use std::hash::Hasher; @@ -398,7 +398,7 @@ where fn overlay_layer( cache: Option, bounds: Size, - overlay: &mut Overlay<'_, Message, Renderer>, + overlay: &mut overlay::Element<'_, Message, Renderer>, renderer: &Renderer, ) -> Layer { let new_hash = { -- cgit