me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Remove position from overlay::Element

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2024-02-01 01:08:21 +01:00
parent 7bbe450217
commit 738aa47547
No known key found for this signature in database
GPG key ID: 7CC46565708259A7
27 changed files with 230 additions and 283 deletions
Download patch file Download diff file Expand all files Collapse all files

4
widget/src/button.rs
View file

@ -11,7 +11,7 @@ use crate::core::widget::tree::{self, Tree};
use crate::core::widget::Operation;
use crate::core::{
Background, Clipboard, Color, Element, Layout, Length, Padding, Rectangle,
Shell, Size, Widget,
Shell, Size, Vector, Widget,
};
pub use crate::style::button::{Appearance, StyleSheet};
@ -271,11 +271,13 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
self.content.as_widget_mut().overlay(
&mut tree.children[0],
layout.children().next().unwrap(),
renderer,
translation,
)
}
}

11
widget/src/column.rs
View file

@ -7,7 +7,7 @@ use crate::core::renderer;
use crate::core::widget::{Operation, Tree};
use crate::core::{
Alignment, Clipboard, Element, Layout, Length, Padding, Pixels, Rectangle,
Shell, Size, Widget,
Shell, Size, Vector, Widget,
};
/// A container that distributes its contents vertically.
@ -259,8 +259,15 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
overlay::from_children(&mut self.children, tree, layout, renderer)
overlay::from_children(
&mut self.children,
tree,
layout,
renderer,
translation,
)
}
}

5
widget/src/combo_box.rs
View file

@ -10,7 +10,7 @@ use crate::core::text;
use crate::core::time::Instant;
use crate::core::widget::{self, Widget};
use crate::core::{
Clipboard, Element, Length, Padding, Rectangle, Shell, Size,
Clipboard, Element, Length, Padding, Rectangle, Shell, Size, Vector,
};
use crate::overlay::menu;
use crate::text::LineHeight;
@ -657,6 +657,7 @@ where
tree: &'b mut widget::Tree,
layout: Layout<'_>,
_renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
let is_focused = {
let text_input_state = tree.children[0]
@ -705,7 +706,7 @@ where
menu = menu.text_size(size);
}
Some(menu.overlay(layout.position(), bounds.height))
Some(menu.overlay(layout.position() + translation, bounds.height))
} else {
None
}

2
widget/src/container.rs
View file

@ -279,11 +279,13 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
self.content.as_widget_mut().overlay(
tree,
layout.children().next().unwrap(),
renderer,
translation,
)
}
}

11
widget/src/keyed/column.rs
View file

@ -8,7 +8,7 @@ use crate::core::widget::tree::{self, Tree};
use crate::core::widget::Operation;
use crate::core::{
Alignment, Clipboard, Element, Layout, Length, Padding, Pixels, Rectangle,
Shell, Size, Widget,
Shell, Size, Vector, Widget,
};
/// A container that distributes its contents vertically.
@ -316,8 +316,15 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
overlay::from_children(&mut self.children, tree, layout, renderer)
overlay::from_children(
&mut self.children,
tree,
layout,
renderer,
translation,
)
}
}

23
widget/src/lazy.rs
View file

@ -259,6 +259,7 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'_, Message, Theme, Renderer>> {
let overlay = Overlay(Some(
InnerBuilder {
@ -275,18 +276,14 @@ where
overlay_builder: |element, tree| {
element
.as_widget_mut()
.overlay(tree, layout, renderer)
.overlay(tree, layout, renderer, translation)
.map(|overlay| RefCell::new(Nested::new(overlay)))
},
}
.build(),
));
let has_overlay =
overlay.with_overlay_maybe(|overlay| overlay.position());
has_overlay
.map(|position| overlay::Element::new(position, Box::new(overlay)))
Some(overlay::Element::new(Box::new(overlay)))
}
}
@ -339,17 +336,9 @@ impl<'a, Message, Theme, Renderer> overlay::Overlay<Message, Theme, Renderer>
where
Renderer: core::Renderer,
{
fn layout(
&mut self,
renderer: &Renderer,
bounds: Size,
position: Point,
translation: Vector,
) -> layout::Node {
self.with_overlay_maybe(|overlay| {
overlay.layout(renderer, bounds, position, translation)
})
.unwrap_or_default()
fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
self.with_overlay_maybe(|overlay| overlay.layout(renderer, bounds))
.unwrap_or_default()
}
fn draw(

31
widget/src/lazy/component.rs
View file

@ -462,6 +462,7 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
self.rebuild_element_if_necessary();
let tree = tree
@ -486,6 +487,7 @@ where
&mut tree.children[0],
layout,
renderer,
translation,
)
.map(|overlay| {
RefCell::new(Nested::new(overlay))
@ -497,18 +499,9 @@ where
.build(),
));
let has_overlay = overlay.0.as_ref().unwrap().with_overlay(|overlay| {
overlay.as_ref().map(|nested| nested.borrow().position())
});
has_overlay.map(|position| {
overlay::Element::new(
position,
Box::new(OverlayInstance {
overlay: Some(overlay),
}),
)
})
Some(overlay::Element::new(Box::new(OverlayInstance {
overlay: Some(overlay),
})))
}
}
@ -582,17 +575,9 @@ where
Renderer: core::Renderer,
S: 'static + Default,
{
fn layout(
&mut self,
renderer: &Renderer,
bounds: Size,
position: Point,
translation: Vector,
) -> layout::Node {
self.with_overlay_maybe(|overlay| {
overlay.layout(renderer, bounds, position, translation)
})
.unwrap_or_default()
fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
self.with_overlay_maybe(|overlay| overlay.layout(renderer, bounds))
.unwrap_or_default()
}
fn draw(

23
widget/src/lazy/responsive.rs
View file

@ -279,6 +279,7 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
use std::ops::DerefMut;
@ -309,17 +310,13 @@ where
element
.as_widget_mut()
.overlay(tree, content_layout, renderer)
.overlay(tree, content_layout, renderer, translation)
.map(|overlay| RefCell::new(Nested::new(overlay)))
},
}
.build();
let has_overlay =
overlay.with_overlay_maybe(|overlay| overlay.position());
has_overlay
.map(|position| overlay::Element::new(position, Box::new(overlay)))
Some(overlay::Element::new(Box::new(overlay)))
}
}
@ -375,17 +372,9 @@ impl<'a, 'b, Message, Theme, Renderer>
where
Renderer: core::Renderer,
{
fn layout(
&mut self,
renderer: &Renderer,
bounds: Size,
position: Point,
translation: Vector,
) -> layout::Node {
self.with_overlay_maybe(|overlay| {
overlay.layout(renderer, bounds, position, translation)
})
.unwrap_or_default()
fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
self.with_overlay_maybe(|overlay| overlay.layout(renderer, bounds))
.unwrap_or_default()
}
fn draw(

4
widget/src/mouse_area.rs
View file

@ -8,7 +8,7 @@ use crate::core::renderer;
use crate::core::touch;
use crate::core::widget::{tree, Operation, Tree};
use crate::core::{
Clipboard, Element, Layout, Length, Rectangle, Shell, Size, Widget,
Clipboard, Element, Layout, Length, Rectangle, Shell, Size, Vector, Widget,
};
/// Emit messages on mouse events.
@ -217,11 +217,13 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
self.content.as_widget_mut().overlay(
&mut tree.children[0],
layout,
renderer,
translation,
)
}
}

29
widget/src/overlay/menu.rs
View file

@ -134,10 +134,11 @@ where
position: Point,
target_height: f32,
) -> overlay::Element<'a, Message, Theme, Renderer> {
overlay::Element::new(
overlay::Element::new(Box::new(Overlay::new(
position,
Box::new(Overlay::new(self, target_height)),
)
self,
target_height,
)))
}
}
@ -167,6 +168,7 @@ where
Theme: StyleSheet + container::StyleSheet,
Renderer: crate::core::Renderer,
{
position: Point,
state: &'a mut Tree,
container: Container<'a, Message, Theme, Renderer>,
width: f32,
@ -181,6 +183,7 @@ where
Renderer: text::Renderer + 'a,
{
pub fn new<T>(
position: Point,
menu: Menu<'a, T, Message, Theme, Renderer>,
target_height: f32,
) -> Self
@ -218,6 +221,7 @@ where
state.tree.diff(&container as &dyn Widget<_, _, _>);
Self {
position,
state: &mut state.tree,
container,
width,
@ -234,20 +238,15 @@ where
Theme: StyleSheet + container::StyleSheet,
Renderer: text::Renderer,
{
fn layout(
&mut self,
renderer: &Renderer,
bounds: Size,
position: Point,
_translation: Vector,
) -> layout::Node {
let space_below = bounds.height - (position.y + self.target_height);
let space_above = position.y;
fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
let space_below =
bounds.height - (self.position.y + self.target_height);
let space_above = self.position.y;
let limits = layout::Limits::new(
Size::ZERO,
Size::new(
bounds.width - position.x,
bounds.width - self.position.x,
if space_below > space_above {
space_below
} else {
@ -261,9 +260,9 @@ where
let size = node.size();
node.move_to(if space_below > space_above {
position + Vector::new(0.0, self.target_height)
self.position + Vector::new(0.0, self.target_height)
} else {
position - Vector::new(0.0, size.height)
self.position - Vector::new(0.0, size.height)
})
}

3
widget/src/pane_grid.rs
View file

@ -447,6 +447,7 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'_, Message, Theme, Renderer>> {
let children = self
.contents
@ -454,7 +455,7 @@ where
.zip(&mut tree.children)
.zip(layout.children())
.filter_map(|(((_, content), state), layout)| {
content.overlay(state, layout, renderer)
content.overlay(state, layout, renderer, translation)
})
.collect::<Vec<_>>();

15
widget/src/pane_grid/content.rs
View file

@ -5,7 +5,9 @@ use crate::core::mouse;
use crate::core::overlay;
use crate::core::renderer;
use crate::core::widget::{self, Tree};
use crate::core::{Clipboard, Element, Layout, Point, Rectangle, Shell, Size};
use crate::core::{
Clipboard, Element, Layout, Point, Rectangle, Shell, Size, Vector,
};
use crate::pane_grid::{Draggable, TitleBar};
/// The content of a [`Pane`].
@ -330,6 +332,7 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
if let Some(title_bar) = self.title_bar.as_mut() {
let mut children = layout.children();
@ -339,13 +342,18 @@ where
let body_state = states.next().unwrap();
let title_bar_state = states.next().unwrap();
match title_bar.overlay(title_bar_state, title_bar_layout, renderer)
{
match title_bar.overlay(
title_bar_state,
title_bar_layout,
renderer,
translation,
) {
Some(overlay) => Some(overlay),
None => self.body.as_widget_mut().overlay(
body_state,
children.next()?,
renderer,
translation,
),
}
} else {
@ -353,6 +361,7 @@ where
&mut tree.children[0],
layout,
renderer,
translation,
)
}
}

6
widget/src/pane_grid/title_bar.rs
View file

@ -6,7 +6,7 @@ use crate::core::overlay;
use crate::core::renderer;
use crate::core::widget::{self, Tree};
use crate::core::{
Clipboard, Element, Layout, Padding, Point, Rectangle, Shell, Size,
Clipboard, Element, Layout, Padding, Point, Rectangle, Shell, Size, Vector,
};
/// The title bar of a [`Pane`].
@ -405,6 +405,7 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
let mut children = layout.children();
let padded = children.next()?;
@ -422,7 +423,7 @@ where
content
.as_widget_mut()
.overlay(title_state, title_layout, renderer)
.overlay(title_state, title_layout, renderer, translation)
.or_else(move || {
controls.as_mut().and_then(|controls| {
let controls_layout = children.next()?;
@ -431,6 +432,7 @@ where
controls_state,
controls_layout,
renderer,
translation,
)
})
})

7
widget/src/pick_list.rs
View file

@ -12,7 +12,7 @@ use crate::core::touch;
use crate::core::widget::tree::{self, Tree};
use crate::core::{
Clipboard, Element, Layout, Length, Padding, Pixels, Point, Rectangle,
Shell, Size, Widget,
Shell, Size, Vector, Widget,
};
use crate::overlay::menu::{self, Menu};
use crate::scrollable;
@ -265,11 +265,13 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
let state = tree.state.downcast_mut::<State<Renderer::Paragraph>>();
overlay(
layout,
translation,
state,
self.padding,
self.text_size,
@ -573,6 +575,7 @@ pub fn mouse_interaction(
/// Returns the current overlay of a [`PickList`].
pub fn overlay<'a, T, Message, Theme, Renderer>(
layout: Layout<'_>,
translation: Vector,
state: &'a mut State<Renderer::Paragraph>,
padding: Padding,
text_size: Option<Pixels>,
@ -617,7 +620,7 @@ where
menu = menu.text_size(text_size);
}
Some(menu.overlay(layout.position(), bounds.height))
Some(menu.overlay(layout.position() + translation, bounds.height))
} else {
None
}

11
widget/src/row.rs
View file

@ -7,7 +7,7 @@ use crate::core::renderer;
use crate::core::widget::{Operation, Tree};
use crate::core::{
Alignment, Clipboard, Element, Length, Padding, Pixels, Rectangle, Shell,
Size, Widget,
Size, Vector, Widget,
};
/// A container that distributes its contents horizontally.
@ -248,8 +248,15 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
overlay::from_children(&mut self.children, tree, layout, renderer)
overlay::from_children(
&mut self.children,
tree,
layout,
renderer,
translation,
)
}
}

33
widget/src/scrollable.rs
View file

@ -385,25 +385,24 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
self.content
.as_widget_mut()
.overlay(
&mut tree.children[0],
layout.children().next().unwrap(),
renderer,
)
.map(|overlay| {
let bounds = layout.bounds();
let content_layout = layout.children().next().unwrap();
let content_bounds = content_layout.bounds();
let translation = tree
.state
.downcast_ref::<State>()
.translation(self.direction, bounds, content_bounds);
let bounds = layout.bounds();
let content_layout = layout.children().next().unwrap();
let content_bounds = content_layout.bounds();
overlay.translate(Vector::new(-translation.x, -translation.y))
})
let offset = tree.state.downcast_ref::<State>().translation(
self.direction,
bounds,
content_bounds,
);
self.content.as_widget_mut().overlay(
&mut tree.children[0],
layout.children().next().unwrap(),
renderer,
translation - offset,
)
}
}

19
widget/src/themer.rs
View file

@ -141,6 +141,7 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, AnyTheme, Renderer>> {
struct Overlay<'a, Message, Theme, Renderer> {
theme: &'a Theme,
@ -157,14 +158,8 @@ where
&mut self,
renderer: &Renderer,
bounds: Size,
position: Point,
translation: Vector,
) -> layout::Node {
self.content.layout(
renderer,
bounds,
translation + (position - Point::ORIGIN),
)
self.content.layout(renderer, bounds)
}
fn draw(
@ -233,22 +228,18 @@ where
theme: self.theme,
content,
})
.map(|overlay| {
overlay::Element::new(Point::ORIGIN, Box::new(overlay))
})
.map(|overlay| overlay::Element::new(Box::new(overlay)))
}
}
self.content
.as_widget_mut()
.overlay(tree, layout, renderer)
.overlay(tree, layout, renderer, translation)
.map(|content| Overlay {
theme: &self.theme,
content,
})
.map(|overlay| {
overlay::Element::new(Point::ORIGIN, Box::new(overlay))
})
.map(|overlay| overlay::Element::new(Box::new(overlay)))
}
}

64
widget/src/tooltip.rs
View file

@ -231,6 +231,7 @@ where
tree: &'b mut widget::Tree,
layout: Layout<'_>,
renderer: &Renderer,
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
let state = tree.state.downcast_ref::<State>();
@ -240,23 +241,22 @@ where
children.next().unwrap(),
layout,
renderer,
translation,
);
let tooltip = if let State::Hovered { cursor_position } = *state {
Some(overlay::Element::new(
layout.position(),
Box::new(Overlay {
tooltip: &self.tooltip,
state: children.next().unwrap(),
cursor_position,
content_bounds: layout.bounds(),
snap_within_viewport: self.snap_within_viewport,
position: self.position,
gap: self.gap,
padding: self.padding,
style: &self.style,
}),
))
Some(overlay::Element::new(Box::new(Overlay {
position: layout.position() + translation,
tooltip: &self.tooltip,
state: children.next().unwrap(),
cursor_position,
content_bounds: layout.bounds(),
snap_within_viewport: self.snap_within_viewport,
positioning: self.position,
gap: self.gap,
padding: self.padding,
style: &self.style,
})))
} else {
None
};
@ -317,12 +317,13 @@ where
Theme: container::StyleSheet + widget::text::StyleSheet,
Renderer: text::Renderer,
{
position: Point,
tooltip: &'b Text<'a, Theme, Renderer>,
state: &'b mut widget::Tree,
cursor_position: Point,
content_bounds: Rectangle,
snap_within_viewport: bool,
position: Position,
positioning: Position,
gap: f32,
padding: f32,
style: &'b <Theme as container::StyleSheet>::Style,
@ -335,13 +336,7 @@ where
Theme: container::StyleSheet + widget::text::StyleSheet,
Renderer: text::Renderer,
{
fn layout(
&mut self,
renderer: &Renderer,
bounds: Size,
position: Point,
_translation: Vector,
) -> layout::Node {
fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
let viewport = Rectangle::with_size(bounds);
let text_layout = Widget::<(), Theme, Renderer>::layout(
@ -358,37 +353,44 @@ where
);
let text_bounds = text_layout.bounds();
let x_center =
position.x + (self.content_bounds.width - text_bounds.width) / 2.0;
let y_center = position.y
let x_center = self.position.x
+ (self.content_bounds.width - text_bounds.width) / 2.0;
let y_center = self.position.y
+ (self.content_bounds.height - text_bounds.height) / 2.0;
let mut tooltip_bounds = {
let offset = match self.position {
let offset = match self.positioning {
Position::Top => Vector::new(
x_center,
position.y - text_bounds.height - self.gap - self.padding,
self.position.y
- text_bounds.height
- self.gap
- self.padding,
),
Position::Bottom => Vector::new(
x_center,
position.y
self.position.y
+ self.content_bounds.height
+ self.gap
+ self.padding,
),
Position::Left => Vector::new(
position.x - text_bounds.width - self.gap - self.padding,
self.position.x
- text_bounds.width
- self.gap
- self.padding,
y_center,
),
Position::Right => Vector::new(
position.x
self.position.x
+ self.content_bounds.width
+ self.gap
+ self.padding,
y_center,
),
Position::FollowCursor => {
let translation = position - self.content_bounds.position();
let translation =
self.position - self.content_bounds.position();
Vector::new(
self.cursor_position.x,