Removed function from Floating elements

examples/floating_element/src/main.rs

@@ -101,21 +101,20 @@ impl Application for FloatingElementExample {
  .max_width(400)
  .max_height(600)
  .style(theme::Container::Box),
- || {
- Button::new(
- Text::new("+")
- .width(Length::Shrink)
- .height(Length::Shrink)
- .size(30),
- )
- //.style(iced_aw::style::button::Primary),
- .on_press(Message::ButtonPressed)
- .padding(5)
- .style(theme::Button::Custom(Box::new(CircleButtonStyle::new(
- theme::Button::Primary,
- ))))
- .into()
- },
+ Button::new(
+ Text::new(Icon::Plus.to_string())
+ .width(Length::Shrink)
+ .height(Length::Shrink)
+ .font(ICON_FONT)
+ .size(39)
+ .line_height(0.2)
+ .shaping(text::Shaping::Advanced),
+ )
+ .on_press(Message::ButtonPressed)
+ .padding(5)
+ .style(theme::Button::Custom(Box::new(
+ CircleButtonStyle::new(theme::Button::Primary),
+ ))),
  )
  .anchor(Anchor::SouthEast)
  .offset(20.0)

src/native/floating_element.rs

@@ -41,9 +41,8 @@ use super::overlay::floating_element::FloatingElementOverlay;
 /// );
 /// ```
 #[allow(missing_debug_implementations)]
-pub struct FloatingElement<'a, B, Message, Renderer = crate::Renderer>
+pub struct FloatingElement<'a, Message, Renderer = crate::Renderer>
 where
- B: Fn() -> Element<'a, Message, Renderer>,
  Renderer: core::Renderer,
 {
  /// The anchor of the element.
@@ -55,12 +54,11 @@ where
  /// The underlying element.
  underlay: Element<'a, Message, Renderer>,
  /// The floating element of the [`FloatingElementOverlay`](FloatingElementOverlay).
- element: B,
+ element: Element<'a, Message, Renderer>,
 }
 
-impl<'a, B, Message, Renderer> FloatingElement<'a, B, Message, Renderer>
+impl<'a, Message, Renderer> FloatingElement<'a, Message, Renderer>
 where
- B: Fn() -> Element<'a, Message, Renderer>,
  Renderer: core::Renderer,
 {
  /// Creates a new [`FloatingElement`](FloatingElement) over some content,
@@ -70,16 +68,17 @@ where
  /// * the underlay [`Element`](iced_native::Element) on which this [`FloatingElement`](FloatingElement)
  /// will be wrapped around.
  /// * a function that will lazy create the [`Element`](iced_native::Element) for the overlay.
- pub fn new<U>(underlay: U, element: B) -> Self
+ pub fn new<U, B>(underlay: U, element: B) -> Self
  where
  U: Into<Element<'a, Message, Renderer>>,
+ B: Into<Element<'a, Message, Renderer>>,
  {
  FloatingElement {
  anchor: Anchor::SouthEast,
  offset: 5.0.into(),
  hidden: false,
  underlay: underlay.into(),
- element,
+ element: element.into(),
  }
  }
 
@@ -109,19 +108,17 @@ where
  }
 }
 
-impl<'a, B, Message, Renderer> Widget<Message, Renderer>
- for FloatingElement<'a, B, Message, Renderer>
+impl<'a, Message, Renderer> Widget<Message, Renderer> for FloatingElement<'a, Message, Renderer>
 where
- B: Fn() -> Element<'a, Message, Renderer>,
  Message: 'a,
- Renderer: 'a + core::Renderer,
+ Renderer: core::Renderer,
 {
  fn children(&self) -> Vec<Tree> {
- vec![Tree::new(&self.underlay), Tree::new(&(self.element)())]
+ vec![Tree::new(&self.underlay), Tree::new(&self.element)]
  }
 
  fn diff(&self, tree: &mut Tree) {
- tree.diff_children(&[&self.underlay, &(self.element)()]);
+ tree.diff_children(&[&self.underlay, &self.element]);
  }
 
  fn width(&self) -> Length {
@@ -238,29 +235,28 @@ where
 
  let position = Point::new(bounds.x + position.x, bounds.y + position.y);
 
- Some(
- FloatingElementOverlay::new(
+ Some(overlay::Element::new(
+ position,
+ Box::new(FloatingElementOverlay::new(
  &mut state.children[1],
- (self.element)(),
+ &mut self.element,
  &self.anchor,
  &self.offset,
- )
- .overlay(position),
- )
+ )),
+ ))
  } else {
  None
  }
  }
 }
 
-impl<'a, B, Message, Renderer> From<FloatingElement<'a, B, Message, Renderer>>
+impl<'a, Message, Renderer> From<FloatingElement<'a, Message, Renderer>>
  for Element<'a, Message, Renderer>
 where
- B: 'a + Fn() -> Element<'a, Message, Renderer>,
  Message: 'a,
  Renderer: 'a + core::Renderer,
 {
- fn from(floating_element: FloatingElement<'a, B, Message, Renderer>) -> Self {
+ fn from(floating_element: FloatingElement<'a, Message, Renderer>) -> Self {
  Element::new(floating_element)
  }
 }

src/native/helpers.rs

@@ -143,14 +143,13 @@ where
 
 #[cfg(feature = "floating_element")]
 /// Shortcut helper to create a Card Widget.
-pub fn floating_element<'a, Message, Renderer, B>(
+pub fn floating_element<'a, Message, Renderer>(
  underlay: impl Into<Element<'a, Message, Renderer>>,
- element: B,
-) -> crate::FloatingElement<'a, B, Message, Renderer>
+ element: impl Into<Element<'a, Message, Renderer>>,
+) -> crate::FloatingElement<'a, Message, Renderer>
 where
  Message: 'a + Clone,
  Renderer: core::Renderer,
- B: Fn() -> Element<'a, Message, Renderer>,
 {
  crate::FloatingElement::new(underlay, element)
 }

src/native/mod.rs

@@ -53,8 +53,8 @@ pub use selection_list::List;
 pub mod floating_element;
 #[cfg(feature = "floating_element")]
 /// A floating element floating over some content.
-pub type FloatingElement<'a, B, Message, Renderer> =
- floating_element::FloatingElement<'a, B, Message, Renderer>;
+pub type FloatingElement<'a, Message, Renderer> =
+ floating_element::FloatingElement<'a, Message, Renderer>;
 
 #[cfg(feature = "grid")]
 pub mod grid;

src/native/overlay/floating_element.rs

@@ -7,58 +7,50 @@ use iced_widget::core::{
  mouse::{self, Cursor},
  overlay, renderer,
  widget::Tree,
- Clipboard, Element, Event, Layout, Point, Rectangle, Shell, Size,
+ BorderRadius, Clipboard, Color, Element, Event, Layout, Point, Rectangle, Shell, Size,
 };
 
 use crate::native::floating_element::{Anchor, Offset};
 
 /// The internal overlay of a [`FloatingElement`](crate::FloatingElement) for
 /// rendering a [`Element`](iced_widget::core::Element) as an overlay.
 #[allow(missing_debug_implementations)]
-pub struct FloatingElementOverlay<'a, Message, Renderer: core::Renderer> {
+pub struct FloatingElementOverlay<'a, 'b, Message, Renderer: core::Renderer> {
  /// The state of the element.
- state: &'a mut Tree,
+ state: &'b mut Tree,
  /// The floating element
- element: Element<'a, Message, Renderer>,
+ element: &'b mut Element<'a, Message, Renderer>,
  /// The anchor of the element.
- anchor: &'a Anchor,
+ anchor: &'b Anchor,
  /// The offset of the element.
- offset: &'a Offset,
+ offset: &'b Offset,
 }
 
-impl<'a, Message, Renderer> FloatingElementOverlay<'a, Message, Renderer>
+impl<'a, 'b, Message, Renderer> FloatingElementOverlay<'a, 'b, Message, Renderer>
 where
- Message: 'a,
- Renderer: core::Renderer + 'a,
+ Renderer: core::Renderer,
 {
  /// Creates a new [`FloatingElementOverlay`] containing the given
  /// [`Element`](iced_widget::core::Element).
- pub fn new<B>(state: &'a mut Tree, element: B, anchor: &'a Anchor, offset: &'a Offset) -> Self
- where
- B: Into<Element<'a, Message, Renderer>>,
- {
+ pub fn new(
+ state: &'b mut Tree,
+ element: &'b mut Element<'a, Message, Renderer>,
+ anchor: &'b Anchor,
+ offset: &'b Offset,
+ ) -> Self {
  FloatingElementOverlay {
  state,
- element: element.into(),
+ element,
  anchor,
  offset,
  }
  }
-
- /// Turns the [`FloatingElementOverlay`](FloatingElementOverlay) into an
- /// overlay [`Element`](iced_widget::core::Element) at the given target
- /// position.
- #[must_use]
- pub fn overlay(self, position: Point) -> overlay::Element<'a, Message, Renderer> {
- overlay::Element::new(position, Box::new(self))
- }
 }
 
-impl<'a, Message, Renderer> core::Overlay<Message, Renderer>
- for FloatingElementOverlay<'a, Message, Renderer>
+impl<'a, 'b, Message, Renderer> core::Overlay<Message, Renderer>
+ for FloatingElementOverlay<'a, 'b, Message, Renderer>
 where
- Message: 'a,
- Renderer: core::Renderer + 'a,
+ Renderer: core::Renderer,
 {
  fn layout(&self, renderer: &Renderer, bounds: Size, position: Point) -> layout::Node {
  let limits = layout::Limits::new(Size::ZERO, bounds);
@@ -143,14 +135,38 @@ where
  layout: Layout<'_>,
  cursor: Cursor,
  ) {
- self.element.as_widget().draw(
- self.state,
- renderer,
- theme,
- style,
- layout,
- cursor,
- &layout.bounds(),
+ let bounds = layout.bounds();
+
+ renderer.fill_quad(
+ renderer::Quad {
+ bounds: Rectangle {
+ x: 0.0,
+ y: 0.0,
+ width: 800.0,
+ height: 800.0,
+ },
+ border_radius: BorderRadius::default(),
+ border_width: 0.0,
+ border_color: Color::BLACK,
+ },
+ Color {
+ a: 0.80,
+ ..Color::BLACK
+ },
  );
+
+ self.element
+ .as_widget()
+ .draw(self.state, renderer, theme, style, layout, cursor, &bounds);
+ }
+
+ fn overlay<'c>(
+ &'c mut self,
+ layout: Layout<'_>,
+ renderer: &Renderer,
+ ) -> Option<overlay::Element<'c, Message, Renderer>> {
+ self.element
+ .as_widget_mut()
+ .overlay(self.state, layout, renderer)
  }
 }