summaryrefslogtreecommitdiffstats
path: root/core/src/overlay
diff options
context:
space:
mode:
Diffstat (limited to 'core/src/overlay')
-rw-r--r--core/src/overlay/element.rs270
-rw-r--r--core/src/overlay/group.rs172
2 files changed, 442 insertions, 0 deletions
diff --git a/core/src/overlay/element.rs b/core/src/overlay/element.rs
new file mode 100644
index 00000000..237d25d1
--- /dev/null
+++ b/core/src/overlay/element.rs
@@ -0,0 +1,270 @@
+pub use crate::Overlay;
+
+use crate::event::{self, Event};
+use crate::layout;
+use crate::mouse;
+use crate::renderer;
+use crate::widget;
+use crate::{Clipboard, Layout, Point, Rectangle, Shell, Size, Vector};
+
+use std::any::Any;
+
+/// A generic [`Overlay`].
+#[allow(missing_debug_implementations)]
+pub struct Element<'a, Message, Renderer> {
+ position: Point,
+ overlay: Box<dyn Overlay<Message, Renderer> + 'a>,
+}
+
+impl<'a, Message, Renderer> Element<'a, Message, Renderer>
+where
+ Renderer: crate::Renderer,
+{
+ /// Creates a new [`Element`] containing the given [`Overlay`].
+ pub fn new(
+ position: Point,
+ overlay: Box<dyn Overlay<Message, Renderer> + 'a>,
+ ) -> Self {
+ Self { position, overlay }
+ }
+
+ /// Returns the position of the [`Element`].
+ pub fn position(&self) -> Point {
+ self.position
+ }
+
+ /// Translates the [`Element`].
+ pub fn translate(mut self, translation: Vector) -> Self {
+ self.position = self.position + translation;
+ self
+ }
+
+ /// Applies a transformation to the produced message of the [`Element`].
+ pub fn map<B>(self, f: &'a dyn Fn(Message) -> B) -> Element<'a, B, Renderer>
+ where
+ Message: 'a,
+ Renderer: 'a,
+ B: 'a,
+ {
+ Element {
+ position: self.position,
+ overlay: Box::new(Map::new(self.overlay, f)),
+ }
+ }
+
+ /// Computes the layout of the [`Element`] in the given bounds.
+ pub fn layout(
+ &self,
+ renderer: &Renderer,
+ bounds: Size,
+ translation: Vector,
+ ) -> layout::Node {
+ self.overlay
+ .layout(renderer, bounds, self.position + translation)
+ }
+
+ /// Processes a runtime [`Event`].
+ pub fn on_event(
+ &mut self,
+ event: Event,
+ layout: Layout<'_>,
+ cursor_position: Point,
+ renderer: &Renderer,
+ clipboard: &mut dyn Clipboard,
+ shell: &mut Shell<'_, Message>,
+ ) -> event::Status {
+ self.overlay.on_event(
+ event,
+ layout,
+ cursor_position,
+ renderer,
+ clipboard,
+ shell,
+ )
+ }
+
+ /// Returns the current [`mouse::Interaction`] of the [`Element`].
+ pub fn mouse_interaction(
+ &self,
+ layout: Layout<'_>,
+ cursor_position: Point,
+ viewport: &Rectangle,
+ renderer: &Renderer,
+ ) -> mouse::Interaction {
+ self.overlay.mouse_interaction(
+ layout,
+ cursor_position,
+ viewport,
+ renderer,
+ )
+ }
+
+ /// Draws the [`Element`] and its children using the given [`Layout`].
+ pub fn draw(
+ &self,
+ renderer: &mut Renderer,
+ theme: &Renderer::Theme,
+ style: &renderer::Style,
+ layout: Layout<'_>,
+ cursor_position: Point,
+ ) {
+ self.overlay
+ .draw(renderer, theme, style, layout, cursor_position)
+ }
+
+ /// Applies a [`widget::Operation`] to the [`Element`].
+ pub fn operate(
+ &mut self,
+ layout: Layout<'_>,
+ renderer: &Renderer,
+ operation: &mut dyn widget::Operation<Message>,
+ ) {
+ self.overlay.operate(layout, renderer, operation);
+ }
+
+ /// Returns true if the cursor is over the [`Element`].
+ pub fn is_over(&self, layout: Layout<'_>, cursor_position: Point) -> bool {
+ self.overlay.is_over(layout, cursor_position)
+ }
+}
+
+struct Map<'a, A, B, Renderer> {
+ content: Box<dyn Overlay<A, Renderer> + 'a>,
+ mapper: &'a dyn Fn(A) -> B,
+}
+
+impl<'a, A, B, Renderer> Map<'a, A, B, Renderer> {
+ pub fn new(
+ content: Box<dyn Overlay<A, Renderer> + 'a>,
+ mapper: &'a dyn Fn(A) -> B,
+ ) -> Map<'a, A, B, Renderer> {
+ Map { content, mapper }
+ }
+}
+
+impl<'a, A, B, Renderer> Overlay<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 operate(
+ &mut self,
+ layout: Layout<'_>,
+ renderer: &Renderer,
+ operation: &mut dyn widget::Operation<B>,
+ ) {
+ struct MapOperation<'a, B> {
+ operation: &'a mut dyn widget::Operation<B>,
+ }
+
+ impl<'a, T, B> widget::Operation<T> for MapOperation<'a, B> {
+ fn container(
+ &mut self,
+ id: Option<&widget::Id>,
+ operate_on_children: &mut dyn FnMut(
+ &mut dyn widget::Operation<T>,
+ ),
+ ) {
+ self.operation.container(id, &mut |operation| {
+ operate_on_children(&mut MapOperation { operation });
+ });
+ }
+
+ fn focusable(
+ &mut self,
+ state: &mut dyn widget::operation::Focusable,
+ id: Option<&widget::Id>,
+ ) {
+ self.operation.focusable(state, id);
+ }
+
+ fn scrollable(
+ &mut self,
+ state: &mut dyn widget::operation::Scrollable,
+ id: Option<&widget::Id>,
+ ) {
+ self.operation.scrollable(state, id);
+ }
+
+ fn text_input(
+ &mut self,
+ state: &mut dyn widget::operation::TextInput,
+ id: Option<&widget::Id>,
+ ) {
+ self.operation.text_input(state, id)
+ }
+
+ fn custom(&mut self, state: &mut dyn Any, id: Option<&widget::Id>) {
+ self.operation.custom(state, id);
+ }
+ }
+
+ self.content
+ .operate(layout, renderer, &mut MapOperation { operation });
+ }
+
+ fn on_event(
+ &mut self,
+ event: Event,
+ layout: Layout<'_>,
+ cursor_position: Point,
+ renderer: &Renderer,
+ clipboard: &mut dyn Clipboard,
+ shell: &mut Shell<'_, B>,
+ ) -> event::Status {
+ let mut local_messages = Vec::new();
+ let mut local_shell = Shell::new(&mut local_messages);
+
+ let event_status = self.content.on_event(
+ event,
+ layout,
+ cursor_position,
+ renderer,
+ clipboard,
+ &mut local_shell,
+ );
+
+ shell.merge(local_shell, self.mapper);
+
+ event_status
+ }
+
+ fn mouse_interaction(
+ &self,
+ layout: Layout<'_>,
+ cursor_position: Point,
+ viewport: &Rectangle,
+ renderer: &Renderer,
+ ) -> mouse::Interaction {
+ self.content.mouse_interaction(
+ layout,
+ cursor_position,
+ viewport,
+ renderer,
+ )
+ }
+
+ fn draw(
+ &self,
+ renderer: &mut Renderer,
+ theme: &Renderer::Theme,
+ style: &renderer::Style,
+ layout: Layout<'_>,
+ cursor_position: Point,
+ ) {
+ self.content
+ .draw(renderer, theme, style, layout, cursor_position)
+ }
+
+ fn is_over(&self, layout: Layout<'_>, cursor_position: Point) -> bool {
+ self.content.is_over(layout, cursor_position)
+ }
+}
diff --git a/core/src/overlay/group.rs b/core/src/overlay/group.rs
new file mode 100644
index 00000000..0c48df34
--- /dev/null
+++ b/core/src/overlay/group.rs
@@ -0,0 +1,172 @@
+use crate::event;
+use crate::layout;
+use crate::mouse;
+use crate::overlay;
+use crate::renderer;
+use crate::widget;
+use crate::{Clipboard, Event, Layout, Overlay, Point, Rectangle, Shell, Size};
+
+/// An [`Overlay`] container that displays multiple overlay [`overlay::Element`]
+/// children.
+#[allow(missing_debug_implementations)]
+pub struct Group<'a, Message, Renderer> {
+ children: Vec<overlay::Element<'a, Message, Renderer>>,
+}
+
+impl<'a, Message, Renderer> Group<'a, Message, Renderer>
+where
+ Renderer: 'a + crate::Renderer,
+ Message: 'a,
+{
+ /// Creates an empty [`Group`].
+ pub fn new() -> Self {
+ Self::default()
+ }
+
+ /// Creates a [`Group`] with the given elements.
+ pub fn with_children(
+ children: Vec<overlay::Element<'a, Message, Renderer>>,
+ ) -> Self {
+ Group { children }
+ }
+
+ /// Adds an [`overlay::Element`] to the [`Group`].
+ pub fn push(
+ mut self,
+ child: impl Into<overlay::Element<'a, Message, Renderer>>,
+ ) -> Self {
+ self.children.push(child.into());
+ self
+ }
+
+ /// Turns the [`Group`] into an overlay [`overlay::Element`].
+ pub fn overlay(self) -> overlay::Element<'a, Message, Renderer> {
+ overlay::Element::new(Point::ORIGIN, Box::new(self))
+ }
+}
+
+impl<'a, Message, Renderer> Default for Group<'a, Message, Renderer>
+where
+ Renderer: 'a + crate::Renderer,
+ Message: 'a,
+{
+ fn default() -> Self {
+ Self::with_children(Vec::new())
+ }
+}
+
+impl<'a, Message, Renderer> Overlay<Message, Renderer>
+ for Group<'a, Message, Renderer>
+where
+ Renderer: crate::Renderer,
+{
+ fn layout(
+ &self,
+ renderer: &Renderer,
+ bounds: Size,
+ position: Point,
+ ) -> layout::Node {
+ let translation = position - Point::ORIGIN;
+
+ layout::Node::with_children(
+ bounds,
+ self.children
+ .iter()
+ .map(|child| child.layout(renderer, bounds, translation))
+ .collect(),
+ )
+ }
+
+ fn on_event(
+ &mut self,
+ event: Event,
+ layout: Layout<'_>,
+ cursor_position: Point,
+ renderer: &Renderer,
+ clipboard: &mut dyn Clipboard,
+ shell: &mut Shell<'_, Message>,
+ ) -> event::Status {
+ self.children
+ .iter_mut()
+ .zip(layout.children())
+ .map(|(child, layout)| {
+ child.on_event(
+ event.clone(),
+ layout,
+ cursor_position,
+ renderer,
+ clipboard,
+ shell,
+ )
+ })
+ .fold(event::Status::Ignored, event::Status::merge)
+ }
+
+ fn draw(
+ &self,
+ renderer: &mut Renderer,
+ theme: &<Renderer as crate::Renderer>::Theme,
+ style: &renderer::Style,
+ layout: Layout<'_>,
+ cursor_position: Point,
+ ) {
+ for (child, layout) in self.children.iter().zip(layout.children()) {
+ child.draw(renderer, theme, style, layout, cursor_position);
+ }
+ }
+
+ fn mouse_interaction(
+ &self,
+ layout: Layout<'_>,
+ cursor_position: Point,
+ viewport: &Rectangle,
+ renderer: &Renderer,
+ ) -> mouse::Interaction {
+ self.children
+ .iter()
+ .zip(layout.children())
+ .map(|(child, layout)| {
+ child.mouse_interaction(
+ layout,
+ cursor_position,
+ viewport,
+ renderer,
+ )
+ })
+ .max()
+ .unwrap_or_default()
+ }
+
+ fn operate(
+ &mut self,
+ layout: Layout<'_>,
+ renderer: &Renderer,
+ operation: &mut dyn widget::Operation<Message>,
+ ) {
+ operation.container(None, &mut |operation| {
+ self.children.iter_mut().zip(layout.children()).for_each(
+ |(child, layout)| {
+ child.operate(layout, renderer, operation);
+ },
+ )
+ });
+ }
+
+ fn is_over(&self, layout: Layout<'_>, cursor_position: Point) -> bool {
+ self.children
+ .iter()
+ .zip(layout.children())
+ .any(|(child, layout)| child.is_over(layout, cursor_position))
+ }
+}
+
+impl<'a, Message, Renderer> From<Group<'a, Message, Renderer>>
+ for overlay::Element<'a, Message, Renderer>
+where
+ Renderer: 'a + crate::Renderer,
+ Message: 'a,
+{
+ fn from(group: Group<'a, Message, Renderer>) -> Self {
+ group.overlay()
+ }
+}
generated by cgit (git 2.34.1) at 2025-04-18 22:02:48 +0000