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

Implement basic cursor availability

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2023-06-08 20:11:59 +02:00
parent c15f1b5f65
commit 34451bff18
No known key found for this signature in database
GPG key ID: 140CC052C94F138E
55 changed files with 731 additions and 886 deletions
Download patch file Download diff file Expand all files Collapse all files

39
widget/src/button.rs
View file

@ -187,7 +187,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -196,7 +196,7 @@ where
&mut tree.children[0],
event.clone(),
layout.children().next().unwrap(),
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -204,14 +204,9 @@ where
return event::Status::Captured;
}
update(
event,
layout,
cursor_position,
shell,
&self.on_press,
|| tree.state.downcast_mut::<State>(),
)
update(event, layout, cursor, shell, &self.on_press, || {
tree.state.downcast_mut::<State>()
})
}
fn draw(
@ -221,7 +216,7 @@ where
theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
let bounds = layout.bounds();
@ -230,7 +225,7 @@ where
let styling = draw(
renderer,
bounds,
cursor_position,
cursor,
self.on_press.is_some(),
theme,
&self.style,
@ -245,7 +240,7 @@ where
text_color: styling.text_color,
},
content_layout,
cursor_position,
cursor,
&bounds,
);
}
@ -254,11 +249,11 @@ where
&self,
_tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
mouse_interaction(layout, cursor_position, self.on_press.is_some())
mouse_interaction(layout, cursor, self.on_press.is_some())
}
fn overlay<'b>(
@ -305,7 +300,7 @@ impl State {
pub fn update<'a, Message: Clone>(
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
shell: &mut Shell<'_, Message>,
on_press: &Option<Message>,
state: impl FnOnce() -> &'a mut State,
@ -316,7 +311,7 @@ pub fn update<'a, Message: Clone>(
if on_press.is_some() {
let bounds = layout.bounds();
if bounds.contains(cursor_position) {
if cursor.is_over(&bounds) {
let state = state();
state.is_pressed = true;
@ -335,7 +330,7 @@ pub fn update<'a, Message: Clone>(
let bounds = layout.bounds();
if bounds.contains(cursor_position) {
if cursor.is_over(&bounds) {
shell.publish(on_press);
}
@ -358,7 +353,7 @@ pub fn update<'a, Message: Clone>(
pub fn draw<'a, Renderer: crate::core::Renderer>(
renderer: &mut Renderer,
bounds: Rectangle,
cursor_position: Point,
cursor: mouse::Cursor,
is_enabled: bool,
style_sheet: &dyn StyleSheet<
Style = <Renderer::Theme as StyleSheet>::Style,
@ -369,7 +364,7 @@ pub fn draw<'a, Renderer: crate::core::Renderer>(
where
Renderer::Theme: StyleSheet,
{
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.is_over(&bounds);
let styling = if !is_enabled {
style_sheet.disabled(style)
@ -442,10 +437,10 @@ pub fn layout<Renderer>(
/// Returns the [`mouse::Interaction`] of a [`Button`].
pub fn mouse_interaction(
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
is_enabled: bool,
) -> mouse::Interaction {
let is_mouse_over = layout.bounds().contains(cursor_position);
let is_mouse_over = cursor.is_over(&layout.bounds());
if is_mouse_over && is_enabled {
mouse::Interaction::Pointer

19
widget/src/canvas.rs
View file

@ -1,10 +1,8 @@
//! Draw 2D graphics for your users.
pub mod event;
mod cursor;
mod program;
pub use cursor::Cursor;
pub use event::Event;
pub use program::Program;
@ -17,7 +15,7 @@ use crate::core::mouse;
use crate::core::renderer;
use crate::core::widget::tree::{self, Tree};
use crate::core::{Clipboard, Element, Shell, Widget};
use crate::core::{Length, Point, Rectangle, Size, Vector};
use crate::core::{Length, Rectangle, Size, Vector};
use crate::graphics::geometry;
use std::marker::PhantomData;
@ -28,8 +26,9 @@ use std::marker::PhantomData;
/// If you want to get a quick overview, here's how we can draw a simple circle:
///
/// ```no_run
/// # use iced_widget::canvas::{self, Canvas, Cursor, Fill, Frame, Geometry, Path, Program};
/// # use iced_widget::canvas::{self, Canvas, Fill, Frame, Geometry, Path, Program};
/// # use iced_widget::core::{Color, Rectangle};
/// # use iced_widget::core::mouse;
/// # use iced_widget::style::Theme;
/// #
/// # pub type Renderer = iced_widget::renderer::Renderer<Theme>;
@ -43,7 +42,7 @@ use std::marker::PhantomData;
/// impl Program<()> for Circle {
/// type State = ();
///
/// fn draw(&self, _state: &(), renderer: &Renderer, _theme: &Theme, bounds: Rectangle, _cursor: Cursor) -> Vec<Geometry>{
/// fn draw(&self, _state: &(), renderer: &Renderer, _theme: &Theme, bounds: Rectangle, _cursor: mouse::Cursor) -> Vec<Geometry>{
/// // We prepare a new `Frame`
/// let mut frame = Frame::new(renderer, bounds.size());
///
@ -144,7 +143,7 @@ where
tree: &mut Tree,
event: core::Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_renderer: &Renderer,
_clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -160,8 +159,6 @@ where
_ => None,
};
let cursor = Cursor::from_window_position(cursor_position);
if let Some(canvas_event) = canvas_event {
let state = tree.state.downcast_mut::<P::State>();
@ -182,12 +179,11 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
let bounds = layout.bounds();
let cursor = Cursor::from_window_position(cursor_position);
let state = tree.state.downcast_ref::<P::State>();
self.program.mouse_interaction(state, bounds, cursor)
@ -200,7 +196,7 @@ where
theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
let bounds = layout.bounds();
@ -209,7 +205,6 @@ where
return;
}
let cursor = Cursor::from_window_position(cursor_position);
let state = tree.state.downcast_ref::<P::State>();
renderer.with_translation(

64
widget/src/canvas/cursor.rs
View file

@ -1,64 +0,0 @@
use crate::core::{Point, Rectangle};
/// The mouse cursor state.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Cursor {
/// The cursor has a defined position.
Available(Point),
/// The cursor is currently unavailable (i.e. out of bounds or busy).
Unavailable,
}
impl Cursor {
// TODO: Remove this once this type is used in `iced_native` to encode
// proper cursor availability
pub(crate) fn from_window_position(position: Point) -> Self {
if position.x < 0.0 || position.y < 0.0 {
Cursor::Unavailable
} else {
Cursor::Available(position)
}
}
/// Returns the absolute position of the [`Cursor`], if available.
pub fn position(&self) -> Option<Point> {
match self {
Cursor::Available(position) => Some(*position),
Cursor::Unavailable => None,
}
}
/// Returns the relative position of the [`Cursor`] inside the given bounds,
/// if available.
///
/// If the [`Cursor`] is not over the provided bounds, this method will
/// return `None`.
pub fn position_in(&self, bounds: &Rectangle) -> Option<Point> {
if self.is_over(bounds) {
self.position_from(bounds.position())
} else {
None
}
}
/// Returns the relative position of the [`Cursor`] from the given origin,
/// if available.
pub fn position_from(&self, origin: Point) -> Option<Point> {
match self {
Cursor::Available(position) => {
Some(Point::new(position.x - origin.x, position.y - origin.y))
}
Cursor::Unavailable => None,
}
}
/// Returns whether the [`Cursor`] is currently over the provided bounds
/// or not.
pub fn is_over(&self, bounds: &Rectangle) -> bool {
match self {
Cursor::Available(position) => bounds.contains(*position),
Cursor::Unavailable => false,
}
}
}

13
widget/src/canvas/program.rs
View file

@ -1,6 +1,5 @@
use crate::canvas::event::{self, Event};
use crate::canvas::mouse;
use crate::canvas::Cursor;
use crate::core::Rectangle;
use crate::graphics::geometry::{self, Geometry};
@ -33,7 +32,7 @@ where
_state: &mut Self::State,
_event: Event,
_bounds: Rectangle,
_cursor: Cursor,
_cursor: mouse::Cursor,
) -> (event::Status, Option<Message>) {
(event::Status::Ignored, None)
}
@ -51,7 +50,7 @@ where
renderer: &Renderer,
theme: &Renderer::Theme,
bounds: Rectangle,
cursor: Cursor,
cursor: mouse::Cursor,
) -> Vec<Geometry>;
/// Returns the current mouse interaction of the [`Program`].
@ -64,7 +63,7 @@ where
&self,
_state: &Self::State,
_bounds: Rectangle,
_cursor: Cursor,
_cursor: mouse::Cursor,
) -> mouse::Interaction {
mouse::Interaction::default()
}
@ -82,7 +81,7 @@ where
state: &mut Self::State,
event: Event,
bounds: Rectangle,
cursor: Cursor,
cursor: mouse::Cursor,
) -> (event::Status, Option<Message>) {
T::update(self, state, event, bounds, cursor)
}
@ -93,7 +92,7 @@ where
renderer: &Renderer,
theme: &Renderer::Theme,
bounds: Rectangle,
cursor: Cursor,
cursor: mouse::Cursor,
) -> Vec<Geometry> {
T::draw(self, state, renderer, theme, bounds, cursor)
}
@ -102,7 +101,7 @@ where
&self,
state: &Self::State,
bounds: Rectangle,
cursor: Cursor,
cursor: mouse::Cursor,
) -> mouse::Interaction {
T::mouse_interaction(self, state, bounds, cursor)
}

17
widget/src/checkbox.rs
View file

@ -8,8 +8,8 @@ use crate::core::text;
use crate::core::touch;
use crate::core::widget::Tree;
use crate::core::{
Alignment, Clipboard, Element, Layout, Length, Pixels, Point, Rectangle,
Shell, Widget,
Alignment, Clipboard, Element, Layout, Length, Pixels, Rectangle, Shell,
Widget,
};
use crate::{Row, Text};
@ -204,7 +204,7 @@ where
_tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_renderer: &Renderer,
_clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -212,7 +212,7 @@ where
match event {
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
| Event::Touch(touch::Event::FingerPressed { .. }) => {
let mouse_over = layout.bounds().contains(cursor_position);
let mouse_over = cursor.is_over(&layout.bounds());
if mouse_over {
shell.publish((self.on_toggle)(!self.is_checked));
@ -230,11 +230,11 @@ where
&self,
_tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
if layout.bounds().contains(cursor_position) {
if cursor.is_over(&layout.bounds()) {
mouse::Interaction::Pointer
} else {
mouse::Interaction::default()
@ -248,11 +248,10 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
let bounds = layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.is_over(&layout.bounds());
let mut children = layout.children();

30
widget/src/column.rs
View file

@ -6,8 +6,8 @@ use crate::core::overlay;
use crate::core::renderer;
use crate::core::widget::{Operation, Tree};
use crate::core::{
Alignment, Clipboard, Element, Layout, Length, Padding, Pixels, Point,
Rectangle, Shell, Widget,
Alignment, Clipboard, Element, Layout, Length, Padding, Pixels, Rectangle,
Shell, Widget,
};
/// A container that distributes its contents vertically.
@ -166,7 +166,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -180,7 +180,7 @@ where
state,
event.clone(),
layout,
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -193,7 +193,7 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
@ -203,11 +203,7 @@ where
.zip(layout.children())
.map(|((child, state), layout)| {
child.as_widget().mouse_interaction(
state,
layout,
cursor_position,
viewport,
renderer,
state, layout, cursor, viewport, renderer,
)
})
.max()
@ -221,7 +217,7 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
for ((child, state), layout) in self
@ -230,15 +226,9 @@ where
.zip(&tree.children)
.zip(layout.children())
{
child.as_widget().draw(
state,
renderer,
theme,
style,
layout,
cursor_position,
viewport,
);
child
.as_widget()
.draw(state, renderer, theme, style, layout, cursor, viewport);
}
}

12
widget/src/container.rs
View file

@ -196,7 +196,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -205,7 +205,7 @@ where
&mut tree.children[0],
event,
layout.children().next().unwrap(),
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -216,14 +216,14 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
self.content.as_widget().mouse_interaction(
&tree.children[0],
layout.children().next().unwrap(),
cursor_position,
cursor,
viewport,
renderer,
)
@ -236,7 +236,7 @@ where
theme: &Renderer::Theme,
renderer_style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
let style = theme.appearance(&self.style);
@ -253,7 +253,7 @@ where
.unwrap_or(renderer_style.text_color),
},
layout.children().next().unwrap(),
cursor_position,
cursor,
viewport,
);
}

5
widget/src/image.rs
View file

@ -4,10 +4,11 @@ pub use viewer::Viewer;
use crate::core::image;
use crate::core::layout;
use crate::core::mouse;
use crate::core::renderer;
use crate::core::widget::Tree;
use crate::core::{
ContentFit, Element, Layout, Length, Point, Rectangle, Size, Vector, Widget,
ContentFit, Element, Layout, Length, Rectangle, Size, Vector, Widget,
};
use std::hash::Hash;
@ -186,7 +187,7 @@ where
_theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
_cursor_position: Point,
_cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
draw(renderer, layout, &self.handle, self.content_fit)

25
widget/src/image/viewer.rs
View file

@ -144,18 +144,19 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
_clipboard: &mut dyn Clipboard,
_shell: &mut Shell<'_, Message>,
) -> event::Status {
let bounds = layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
match event {
Event::Mouse(mouse::Event::WheelScrolled { delta })
if is_mouse_over =>
{
Event::Mouse(mouse::Event::WheelScrolled { delta }) => {
let Some(cursor_position) = cursor.position() else {
return event::Status::Ignored;
};
match delta {
mouse::ScrollDelta::Lines { y, .. }
| mouse::ScrollDelta::Pixels { y, .. } => {
@ -205,9 +206,11 @@ where
event::Status::Captured
}
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
if is_mouse_over =>
{
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
let Some(cursor_position) = cursor.position() else {
return event::Status::Ignored;
};
let state = tree.state.downcast_mut::<State>();
state.cursor_grabbed_at = Some(cursor_position);
@ -277,13 +280,13 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
let state = tree.state.downcast_ref::<State>();
let bounds = layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.is_over(&bounds);
if state.is_cursor_grabbed() {
mouse::Interaction::Grabbing
@ -301,7 +304,7 @@ where
_theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
_cursor_position: Point,
_cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
let state = tree.state.downcast_ref::<State>();

36
widget/src/lazy.rs
View file

@ -181,7 +181,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -191,7 +191,7 @@ where
&mut tree.children[0],
event,
layout,
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -203,7 +203,7 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
@ -211,7 +211,7 @@ where
element.as_widget().mouse_interaction(
&tree.children[0],
layout,
cursor_position,
cursor,
viewport,
renderer,
)
@ -225,7 +225,7 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
self.with_element(|element| {
@ -235,7 +235,7 @@ where
theme,
style,
layout,
cursor_position,
cursor,
viewport,
)
})
@ -342,27 +342,22 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
) {
let _ = self.with_overlay_maybe(|overlay| {
overlay.draw(renderer, theme, style, layout, cursor_position);
overlay.draw(renderer, theme, style, layout, cursor);
});
}
fn mouse_interaction(
&self,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
self.with_overlay_maybe(|overlay| {
overlay.mouse_interaction(
layout,
cursor_position,
viewport,
renderer,
)
overlay.mouse_interaction(layout, cursor, viewport, renderer)
})
.unwrap_or_default()
}
@ -371,20 +366,13 @@ where
&mut self,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
) -> event::Status {
self.with_overlay_mut_maybe(|overlay| {
overlay.on_event(
event,
layout,
cursor_position,
renderer,
clipboard,
shell,
)
overlay.on_event(event, layout, cursor, renderer, clipboard, shell)
})
.unwrap_or(event::Status::Ignored)
}

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

@ -265,7 +265,7 @@ where
tree: &mut Tree,
event: core::Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -279,7 +279,7 @@ where
&mut t.borrow_mut().as_mut().unwrap().children[0],
event,
layout,
cursor_position,
cursor,
renderer,
clipboard,
&mut local_shell,
@ -397,7 +397,7 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
let tree = tree.state.downcast_ref::<Rc<RefCell<Option<Tree>>>>();
@ -408,7 +408,7 @@ where
theme,
style,
layout,
cursor_position,
cursor,
viewport,
);
});
@ -418,7 +418,7 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
@ -427,7 +427,7 @@ where
element.as_widget().mouse_interaction(
&tree.borrow().as_ref().unwrap().children[0],
layout,
cursor_position,
cursor,
viewport,
renderer,
)
@ -569,27 +569,22 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
) {
let _ = self.with_overlay_maybe(|overlay| {
overlay.draw(renderer, theme, style, layout, cursor_position);
overlay.draw(renderer, theme, style, layout, cursor);
});
}
fn mouse_interaction(
&self,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
self.with_overlay_maybe(|overlay| {
overlay.mouse_interaction(
layout,
cursor_position,
viewport,
renderer,
)
overlay.mouse_interaction(layout, cursor, viewport, renderer)
})
.unwrap_or_default()
}
@ -598,7 +593,7 @@ where
&mut self,
event: core::Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -611,7 +606,7 @@ where
overlay.on_event(
event,
layout,
cursor_position,
cursor,
renderer,
clipboard,
&mut local_shell,

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

@ -177,7 +177,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -198,7 +198,7 @@ where
tree,
event,
layout,
cursor_position,
cursor,
renderer,
clipboard,
&mut local_shell,
@ -222,7 +222,7 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
let state = tree.state.downcast_ref::<State>();
@ -235,13 +235,7 @@ where
&self.view,
|tree, renderer, layout, element| {
element.as_widget().draw(
tree,
renderer,
theme,
style,
layout,
cursor_position,
viewport,
tree, renderer, theme, style, layout, cursor, viewport,
)
},
)
@ -251,7 +245,7 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
@ -264,13 +258,9 @@ where
layout,
&self.view,
|tree, renderer, layout, element| {
element.as_widget().mouse_interaction(
tree,
layout,
cursor_position,
viewport,
renderer,
)
element
.as_widget()
.mouse_interaction(tree, layout, cursor, viewport, renderer)
},
)
}
@ -384,27 +374,22 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
) {
let _ = self.with_overlay_maybe(|overlay| {
overlay.draw(renderer, theme, style, layout, cursor_position);
overlay.draw(renderer, theme, style, layout, cursor);
});
}
fn mouse_interaction(
&self,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
self.with_overlay_maybe(|overlay| {
overlay.mouse_interaction(
layout,
cursor_position,
viewport,
renderer,
)
overlay.mouse_interaction(layout, cursor, viewport, renderer)
})
.unwrap_or_default()
}
@ -413,20 +398,13 @@ where
&mut self,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
) -> event::Status {
self.with_overlay_mut_maybe(|overlay| {
overlay.on_event(
event,
layout,
cursor_position,
renderer,
clipboard,
shell,
)
overlay.on_event(event, layout, cursor, renderer, clipboard, shell)
})
.unwrap_or(event::Status::Ignored)
}

20
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, Point, Rectangle, Shell, Widget,
Clipboard, Element, Layout, Length, Rectangle, Shell, Widget,
};
/// Emit messages on mouse events.
@ -146,7 +146,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -155,7 +155,7 @@ where
&mut tree.children[0],
event.clone(),
layout,
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -163,21 +163,21 @@ where
return event::Status::Captured;
}
update(self, &event, layout, cursor_position, shell)
update(self, &event, layout, cursor, shell)
}
fn mouse_interaction(
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
self.content.as_widget().mouse_interaction(
&tree.children[0],
layout,
cursor_position,
cursor,
viewport,
renderer,
)
@ -190,7 +190,7 @@ where
theme: &Renderer::Theme,
renderer_style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
self.content.as_widget().draw(
@ -199,7 +199,7 @@ where
theme,
renderer_style,
layout,
cursor_position,
cursor,
viewport,
);
}
@ -237,10 +237,10 @@ fn update<Message: Clone, Renderer>(
widget: &mut MouseArea<'_, Message, Renderer>,
event: &Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
shell: &mut Shell<'_, Message>,
) -> event::Status {
if !layout.bounds().contains(cursor_position) {
if !cursor.is_over(&layout.bounds()) {
return event::Status::Ignored;
}

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

@ -259,36 +259,25 @@ where
&mut self,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
) -> event::Status {
self.container.on_event(
self.state,
event,
layout,
cursor_position,
renderer,
clipboard,
shell,
self.state, event, layout, cursor, renderer, clipboard, shell,
)
}
fn mouse_interaction(
&self,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
self.container.mouse_interaction(
self.state,
layout,
cursor_position,
viewport,
renderer,
)
self.container
.mouse_interaction(self.state, layout, cursor, viewport, renderer)
}
fn draw(
@ -297,7 +286,7 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
) {
let appearance = theme.appearance(&self.style);
let bounds = layout.bounds();
@ -312,15 +301,8 @@ where
appearance.background,
);
self.container.draw(
self.state,
renderer,
theme,
style,
layout,
cursor_position,
&bounds,
);
self.container
.draw(self.state, renderer, theme, style, layout, cursor, &bounds);
}
}
@ -387,7 +369,7 @@ where
_state: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
_clipboard: &mut dyn Clipboard,
_shell: &mut Shell<'_, Message>,
@ -396,7 +378,7 @@ where
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
let bounds = layout.bounds();
if bounds.contains(cursor_position) {
if cursor.is_over(&bounds) {
if let Some(index) = *self.hovered_option {
if let Some(option) = self.options.get(index) {
*self.last_selection = Some(option.clone());
@ -405,9 +387,9 @@ where
}
}
Event::Mouse(mouse::Event::CursorMoved { .. }) => {
let bounds = layout.bounds();
if bounds.contains(cursor_position) {
if let Some(cursor_position) =
cursor.position_in(&layout.bounds())
{
let text_size = self
.text_size
.unwrap_or_else(|| renderer.default_size());
@ -416,16 +398,14 @@ where
self.text_line_height.to_absolute(Pixels(text_size)),
) + self.padding.vertical();
*self.hovered_option = Some(
((cursor_position.y - bounds.y) / option_height)
as usize,
);
*self.hovered_option =
Some((cursor_position.y / option_height) as usize);
}
}
Event::Touch(touch::Event::FingerPressed { .. }) => {
let bounds = layout.bounds();
if bounds.contains(cursor_position) {
if let Some(cursor_position) =
cursor.position_in(&layout.bounds())
{
let text_size = self
.text_size
.unwrap_or_else(|| renderer.default_size());
@ -434,10 +414,8 @@ where
self.text_line_height.to_absolute(Pixels(text_size)),
) + self.padding.vertical();
*self.hovered_option = Some(
((cursor_position.y - bounds.y) / option_height)
as usize,
);
*self.hovered_option =
Some((cursor_position.y / option_height) as usize);
if let Some(index) = *self.hovered_option {
if let Some(option) = self.options.get(index) {
@ -456,11 +434,11 @@ where
&self,
_state: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
let is_mouse_over = layout.bounds().contains(cursor_position);
let is_mouse_over = cursor.is_over(&layout.bounds());
if is_mouse_over {
mouse::Interaction::Pointer
@ -476,7 +454,7 @@ where
theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
_cursor_position: Point,
_cursor: mouse::Cursor,
viewport: &Rectangle,
) {
let appearance = theme.appearance(&self.style);

150
widget/src/pane_grid.rs
View file

@ -313,7 +313,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -331,7 +331,7 @@ where
self.contents.layout(),
&event,
layout,
cursor_position,
cursor,
shell,
self.spacing,
self.contents.iter(),
@ -353,7 +353,7 @@ where
tree,
event.clone(),
layout,
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -367,7 +367,7 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
@ -375,7 +375,7 @@ where
tree.state.downcast_ref(),
self.contents.layout(),
layout,
cursor_position,
cursor,
self.spacing,
self.on_resize.as_ref().map(|(leeway, _)| *leeway),
)
@ -388,7 +388,7 @@ where
content.mouse_interaction(
tree,
layout,
cursor_position,
cursor,
viewport,
renderer,
self.drag_enabled(),
@ -406,14 +406,14 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
draw(
tree.state.downcast_ref(),
self.contents.layout(),
layout,
cursor_position,
cursor,
renderer,
theme,
style,
@ -425,20 +425,9 @@ where
.iter()
.zip(&tree.children)
.map(|((pane, content), tree)| (pane, (content, tree))),
|(content, tree),
renderer,
style,
layout,
cursor_position,
rectangle| {
|(content, tree), renderer, style, layout, cursor, rectangle| {
content.draw(
tree,
renderer,
theme,
style,
layout,
cursor_position,
rectangle,
tree, renderer, theme, style, layout, cursor, rectangle,
);
},
)
@ -520,7 +509,7 @@ pub fn update<'a, Message, T: Draggable>(
node: &Node,
event: &Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
shell: &mut Shell<'_, Message>,
spacing: f32,
contents: impl Iterator<Item = (Pane, T)>,
@ -535,7 +524,7 @@ pub fn update<'a, Message, T: Draggable>(
| Event::Touch(touch::Event::FingerPressed { .. }) => {
let bounds = layout.bounds();
if bounds.contains(cursor_position) {
if let Some(cursor_position) = cursor.position_over(&bounds) {
event_status = event::Status::Captured;
match on_resize {
@ -592,14 +581,18 @@ pub fn update<'a, Message, T: Draggable>(
| Event::Touch(touch::Event::FingerLost { .. }) => {
if let Some((pane, _)) = action.picked_pane() {
if let Some(on_drag) = on_drag {
let mut dropped_region = contents
.zip(layout.children())
.filter_map(|(target, layout)| {
layout_region(layout, cursor_position)
.map(|region| (target, region))
let dropped_region =
cursor.position().and_then(|cursor_position| {
contents
.zip(layout.children())
.filter_map(|(target, layout)| {
layout_region(layout, cursor_position)
.map(|region| (target, region))
})
.next()
});
let event = match dropped_region.next() {
let event = match dropped_region {
Some(((target, _), region)) if pane != target => {
DragEvent::Dropped {
pane,
@ -634,24 +627,32 @@ pub fn update<'a, Message, T: Draggable>(
);
if let Some((axis, rectangle, _)) = splits.get(&split) {
let ratio = match axis {
Axis::Horizontal => {
let position =
cursor_position.y - bounds.y - rectangle.y;
if let Some(cursor_position) = cursor.position() {
let ratio = match axis {
Axis::Horizontal => {
let position = cursor_position.y
- bounds.y
- rectangle.y;
(position / rectangle.height).clamp(0.1, 0.9)
}
Axis::Vertical => {
let position =
cursor_position.x - bounds.x - rectangle.x;
(position / rectangle.height)
.clamp(0.1, 0.9)
}
Axis::Vertical => {
let position = cursor_position.x
- bounds.x
- rectangle.x;
(position / rectangle.width).clamp(0.1, 0.9)
}
};
(position / rectangle.width).clamp(0.1, 0.9)
}
};
shell.publish(on_resize(ResizeEvent { split, ratio }));
shell.publish(on_resize(ResizeEvent {
split,
ratio,
}));
event_status = event::Status::Captured;
event_status = event::Status::Captured;
}
}
}
}
@ -724,7 +725,7 @@ pub fn mouse_interaction(
action: &state::Action,
node: &Node,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
spacing: f32,
resize_leeway: Option<f32>,
) -> Option<mouse::Interaction> {
@ -735,6 +736,7 @@ pub fn mouse_interaction(
let resize_axis =
action.picked_split().map(|(_, axis)| axis).or_else(|| {
resize_leeway.and_then(|leeway| {
let cursor_position = cursor.position()?;
let bounds = layout.bounds();
let splits = node.split_regions(spacing, bounds.size());
@ -764,7 +766,7 @@ pub fn draw<Renderer, T>(
action: &state::Action,
node: &Node,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &mut Renderer,
theme: &Renderer::Theme,
default_style: &renderer::Style,
@ -778,7 +780,7 @@ pub fn draw<Renderer, T>(
&mut Renderer,
&renderer::Style,
Layout<'_>,
Point,
mouse::Cursor,
&Rectangle,
),
) where
@ -802,6 +804,7 @@ pub fn draw<Renderer, T>(
})
.or_else(|| match resize_leeway {
Some(leeway) => {
let cursor_position = cursor.position()?;
let bounds = layout.bounds();
let relative_cursor = Point::new(
@ -822,12 +825,10 @@ pub fn draw<Renderer, T>(
None => None,
});
let pane_cursor_position = if picked_pane.is_some() {
// TODO: Remove once cursor availability is encoded in the type
// system
Point::new(-1.0, -1.0)
let pane_cursor = if picked_pane.is_some() {
mouse::Cursor::Unavailable
} else {
cursor_position
cursor
};
let mut render_picked_pane = None;
@ -843,12 +844,15 @@ pub fn draw<Renderer, T>(
renderer,
default_style,
layout,
pane_cursor_position,
pane_cursor,
viewport,
);
if picked_pane.is_some() {
if let Some(region) = layout_region(layout, cursor_position)
if let Some(region) =
cursor.position().and_then(|cursor_position| {
layout_region(layout, cursor_position)
})
{
let bounds = layout_region_bounds(layout, region);
let hovered_region_style = theme.hovered_region(style);
@ -872,7 +876,7 @@ pub fn draw<Renderer, T>(
renderer,
default_style,
layout,
pane_cursor_position,
pane_cursor,
viewport,
);
}
@ -881,25 +885,27 @@ pub fn draw<Renderer, T>(
// Render picked pane last
if let Some((pane, origin, layout)) = render_picked_pane {
let bounds = layout.bounds();
if let Some(cursor_position) = cursor.position() {
let bounds = layout.bounds();
renderer.with_translation(
cursor_position
- Point::new(bounds.x + origin.x, bounds.y + origin.y),
|renderer| {
renderer.with_layer(bounds, |renderer| {
draw_pane(
pane,
renderer,
default_style,
layout,
pane_cursor_position,
viewport,
);
});
},
);
};
renderer.with_translation(
cursor_position
- Point::new(bounds.x + origin.x, bounds.y + origin.y),
|renderer| {
renderer.with_layer(bounds, |renderer| {
draw_pane(
pane,
renderer,
default_style,
layout,
pane_cursor,
viewport,
);
});
},
);
}
}
if let Some((axis, split_region, is_picked)) = picked_split {
let highlight = if is_picked {

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

@ -95,7 +95,7 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
use container::StyleSheet;
@ -113,7 +113,7 @@ where
let title_bar_layout = children.next().unwrap();
let body_layout = children.next().unwrap();
let show_controls = bounds.contains(cursor_position);
let show_controls = cursor.is_over(&bounds);
self.body.as_widget().draw(
&tree.children[0],
@ -121,7 +121,7 @@ where
theme,
style,
body_layout,
cursor_position,
cursor,
viewport,
);
@ -131,7 +131,7 @@ where
theme,
style,
title_bar_layout,
cursor_position,
cursor,
viewport,
show_controls,
);
@ -142,7 +142,7 @@ where
theme,
style,
layout,
cursor_position,
cursor,
viewport,
);
}
@ -218,7 +218,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -233,7 +233,7 @@ where
&mut tree.children[1],
event.clone(),
children.next().unwrap(),
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -251,7 +251,7 @@ where
&mut tree.children[0],
event,
body_layout,
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -265,42 +265,48 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
drag_enabled: bool,
) -> mouse::Interaction {
let (body_layout, title_bar_interaction) =
if let Some(title_bar) = &self.title_bar {
let mut children = layout.children();
let title_bar_layout = children.next().unwrap();
let (body_layout, title_bar_interaction) = if let Some(title_bar) =
&self.title_bar
{
let mut children = layout.children();
let title_bar_layout = children.next().unwrap();
let is_over_pick_area = title_bar
.is_over_pick_area(title_bar_layout, cursor_position);
let is_over_pick_area = cursor
.position()
.map(|cursor_position| {
title_bar
.is_over_pick_area(title_bar_layout, cursor_position)
})
.unwrap_or_default();
if is_over_pick_area && drag_enabled {
return mouse::Interaction::Grab;
}
if is_over_pick_area && drag_enabled {
return mouse::Interaction::Grab;
}
let mouse_interaction = title_bar.mouse_interaction(
&tree.children[1],
title_bar_layout,
cursor_position,
viewport,
renderer,
);
let mouse_interaction = title_bar.mouse_interaction(
&tree.children[1],
title_bar_layout,
cursor,
viewport,
renderer,
);
(children.next().unwrap(), mouse_interaction)
} else {
(layout, mouse::Interaction::default())
};
(children.next().unwrap(), mouse_interaction)
} else {
(layout, mouse::Interaction::default())
};
self.body
.as_widget()
.mouse_interaction(
&tree.children[0],
body_layout,
cursor_position,
cursor,
viewport,
renderer,
)

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

@ -4,9 +4,5 @@ use crate::core::{Layout, Point};
pub trait Draggable {
/// Returns whether the [`Draggable`] with the given [`Layout`] can be picked
/// at the provided cursor position.
fn can_be_dragged_at(
&self,
layout: Layout<'_>,
cursor_position: Point,
) -> bool;
fn can_be_dragged_at(&self, layout: Layout<'_>, cursor: Point) -> bool;
}

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

@ -122,7 +122,7 @@ where
theme: &Renderer::Theme,
inherited_style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
show_controls: bool,
) {
@ -158,7 +158,7 @@ where
theme,
&inherited_style,
controls_layout,
cursor_position,
cursor,
viewport,
);
}
@ -171,7 +171,7 @@ where
theme,
&inherited_style,
title_layout,
cursor_position,
cursor,
viewport,
);
}
@ -300,7 +300,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -324,7 +324,7 @@ where
&mut tree.children[1],
event.clone(),
controls_layout,
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -338,7 +338,7 @@ where
&mut tree.children[0],
event,
title_layout,
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -354,7 +354,7 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
@ -367,7 +367,7 @@ where
let title_interaction = self.content.as_widget().mouse_interaction(
&tree.children[0],
title_layout,
cursor_position,
cursor,
viewport,
renderer,
);
@ -377,7 +377,7 @@ where
let controls_interaction = controls.as_widget().mouse_interaction(
&tree.children[1],
controls_layout,
cursor_position,
cursor,
viewport,
renderer,
);

30
widget/src/pick_list.rs
View file

@ -11,8 +11,8 @@ use crate::core::text::{self, Text};
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,
Clipboard, Element, Layout, Length, Padding, Pixels, Rectangle, Shell,
Size, Widget,
};
use crate::overlay::menu::{self, Menu};
use crate::scrollable;
@ -196,7 +196,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_renderer: &Renderer,
_clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -204,7 +204,7 @@ where
update(
event,
layout,
cursor_position,
cursor,
shell,
self.on_selected.as_ref(),
self.selected.as_ref(),
@ -217,11 +217,11 @@ where
&self,
_tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
mouse_interaction(layout, cursor_position)
mouse_interaction(layout, cursor)
}
fn draw(
@ -231,7 +231,7 @@ where
theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
let font = self.font.unwrap_or_else(|| renderer.default_font());
@ -239,7 +239,7 @@ where
renderer,
theme,
layout,
cursor_position,
cursor,
self.padding,
self.text_size,
self.text_line_height,
@ -431,7 +431,7 @@ where
pub fn update<'a, T, Message>(
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
shell: &mut Shell<'_, Message>,
on_selected: &dyn Fn(T) -> Message,
selected: Option<&T>,
@ -452,7 +452,7 @@ where
state.is_open = false;
event::Status::Captured
} else if layout.bounds().contains(cursor_position) {
} else if cursor.is_over(&layout.bounds()) {
state.is_open = true;
state.hovered_option =
options.iter().position(|option| Some(option) == selected);
@ -478,7 +478,7 @@ where
let state = state();
if state.keyboard_modifiers.command()
&& layout.bounds().contains(cursor_position)
&& cursor.is_over(&layout.bounds())
&& !state.is_open
{
fn find_next<'a, T: PartialEq>(
@ -529,10 +529,10 @@ where
/// Returns the current [`mouse::Interaction`] of a [`PickList`].
pub fn mouse_interaction(
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
) -> mouse::Interaction {
let bounds = layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.is_over(&bounds);
if is_mouse_over {
mouse::Interaction::Pointer
@ -593,7 +593,7 @@ pub fn draw<'a, T, Renderer>(
renderer: &mut Renderer,
theme: &Renderer::Theme,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
padding: Padding,
text_size: Option<f32>,
text_line_height: text::LineHeight,
@ -610,7 +610,7 @@ pub fn draw<'a, T, Renderer>(
T: ToString + 'a,
{
let bounds = layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.is_over(&bounds);
let is_selected = selected.is_some();
let style = if is_mouse_over {

7
widget/src/progress_bar.rs
View file

@ -1,10 +1,9 @@
//! Provide progress feedback to your users.
use crate::core::layout;
use crate::core::mouse;
use crate::core::renderer;
use crate::core::widget::Tree;
use crate::core::{
Color, Element, Layout, Length, Point, Rectangle, Size, Widget,
};
use crate::core::{Color, Element, Layout, Length, Rectangle, Size, Widget};
use std::ops::RangeInclusive;
@ -115,7 +114,7 @@ where
theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
_cursor_position: Point,
_cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
let bounds = layout.bounds();

3
widget/src/qr_code.rs
View file

@ -1,6 +1,7 @@
//! Encode and display information in a QR code.
use crate::canvas;
use crate::core::layout;
use crate::core::mouse;
use crate::core::renderer::{self, Renderer as _};
use crate::core::widget::Tree;
use crate::core::{
@ -74,7 +75,7 @@ impl<'a, Message, Theme> Widget<Message, Renderer<Theme>> for QRCode<'a> {
_theme: &Theme,
_style: &renderer::Style,
layout: Layout<'_>,
_cursor_position: Point,
_cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
let bounds = layout.bounds();

17
widget/src/radio.rs
View file

@ -8,8 +8,8 @@ use crate::core::text;
use crate::core::touch;
use crate::core::widget::Tree;
use crate::core::{
Alignment, Clipboard, Color, Element, Layout, Length, Pixels, Point,
Rectangle, Shell, Widget,
Alignment, Clipboard, Color, Element, Layout, Length, Pixels, Rectangle,
Shell, Widget,
};
use crate::{Row, Text};
@ -229,7 +229,7 @@ where
_state: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_renderer: &Renderer,
_clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -237,7 +237,7 @@ where
match event {
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
| Event::Touch(touch::Event::FingerPressed { .. }) => {
if layout.bounds().contains(cursor_position) {
if cursor.is_over(&layout.bounds()) {
shell.publish(self.on_click.clone());
return event::Status::Captured;
@ -253,11 +253,11 @@ where
&self,
_state: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
if layout.bounds().contains(cursor_position) {
if cursor.is_over(&layout.bounds()) {
mouse::Interaction::Pointer
} else {
mouse::Interaction::default()
@ -271,11 +271,10 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
let bounds = layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.is_over(&layout.bounds());
let mut children = layout.children();

30
widget/src/row.rs
View file

@ -6,8 +6,8 @@ use crate::core::overlay;
use crate::core::renderer;
use crate::core::widget::{Operation, Tree};
use crate::core::{
Alignment, Clipboard, Element, Length, Padding, Pixels, Point, Rectangle,
Shell, Widget,
Alignment, Clipboard, Element, Length, Padding, Pixels, Rectangle, Shell,
Widget,
};
/// A container that distributes its contents horizontally.
@ -155,7 +155,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -169,7 +169,7 @@ where
state,
event.clone(),
layout,
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -182,7 +182,7 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
@ -192,11 +192,7 @@ where
.zip(layout.children())
.map(|((child, state), layout)| {
child.as_widget().mouse_interaction(
state,
layout,
cursor_position,
viewport,
renderer,
state, layout, cursor, viewport, renderer,
)
})
.max()
@ -210,7 +206,7 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
for ((child, state), layout) in self
@ -219,15 +215,9 @@ where
.zip(&tree.children)
.zip(layout.children())
{
child.as_widget().draw(
state,
renderer,
theme,
style,
layout,
cursor_position,
viewport,
);
child
.as_widget()
.draw(state, renderer, theme, style, layout, cursor, viewport);
}
}

5
widget/src/rule.rs
View file

@ -1,9 +1,10 @@
//! Display a horizontal or vertical rule for dividing content.
use crate::core::layout;
use crate::core::mouse;
use crate::core::renderer;
use crate::core::widget::Tree;
use crate::core::{
Color, Element, Layout, Length, Pixels, Point, Rectangle, Size, Widget,
Color, Element, Layout, Length, Pixels, Rectangle, Size, Widget,
};
pub use crate::style::rule::{Appearance, FillMode, StyleSheet};
@ -86,7 +87,7 @@ where
theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
_cursor_position: Point,
_cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
let bounds = layout.bounds();

252
widget/src/scrollable.rs
View file

@ -222,7 +222,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -231,18 +231,18 @@ where
tree.state.downcast_mut::<State>(),
event,
layout,
cursor_position,
cursor,
clipboard,
shell,
&self.vertical,
self.horizontal.as_ref(),
&self.on_scroll,
|event, layout, cursor_position, clipboard, shell| {
|event, layout, cursor, clipboard, shell| {
self.content.as_widget_mut().on_event(
&mut tree.children[0],
event,
layout,
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -258,7 +258,7 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
draw(
@ -266,18 +266,18 @@ where
renderer,
theme,
layout,
cursor_position,
cursor,
&self.vertical,
self.horizontal.as_ref(),
&self.style,
|renderer, layout, cursor_position, viewport| {
|renderer, layout, cursor, viewport| {
self.content.as_widget().draw(
&tree.children[0],
renderer,
theme,
style,
layout,
cursor_position,
cursor,
viewport,
)
},
@ -288,21 +288,21 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
mouse_interaction(
tree.state.downcast_ref::<State>(),
layout,
cursor_position,
cursor,
&self.vertical,
self.horizontal.as_ref(),
|layout, cursor_position, viewport| {
|layout, cursor, viewport| {
self.content.as_widget().mouse_interaction(
&tree.children[0],
layout,
cursor_position,
cursor,
viewport,
renderer,
)
@ -428,7 +428,7 @@ pub fn update<Message>(
state: &mut State,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
vertical: &Properties,
@ -437,13 +437,13 @@ pub fn update<Message>(
update_content: impl FnOnce(
Event,
Layout<'_>,
Point,
mouse::Cursor,
&mut dyn Clipboard,
&mut Shell<'_, Message>,
) -> event::Status,
) -> event::Status {
let bounds = layout.bounds();
let mouse_over_scrollable = bounds.contains(cursor_position);
let cursor_over_scrollable = cursor.position_over(&bounds);
let content = layout.children().next().unwrap();
let content_bounds = content.bounds();
@ -452,28 +452,21 @@ pub fn update<Message>(
Scrollbars::new(state, vertical, horizontal, bounds, content_bounds);
let (mouse_over_y_scrollbar, mouse_over_x_scrollbar) =
scrollbars.is_mouse_over(cursor_position);
scrollbars.is_mouse_over(cursor);
let event_status = {
let cursor_position = if mouse_over_scrollable
&& !(mouse_over_y_scrollbar || mouse_over_x_scrollbar)
{
cursor_position + state.offset(bounds, content_bounds)
} else {
// TODO: Make `cursor_position` an `Option<Point>` so we can encode
// cursor availability.
// This will probably happen naturally once we add multi-window
// support.
Point::new(-1.0, -1.0)
let cursor = match cursor_over_scrollable {
Some(cursor_position)
if !(mouse_over_x_scrollbar || mouse_over_y_scrollbar) =>
{
mouse::Cursor::Available(
cursor_position + state.offset(bounds, content_bounds),
)
}
_ => mouse::Cursor::Unavailable,
};
update_content(
event.clone(),
content,
cursor_position,
clipboard,
shell,
)
update_content(event.clone(), content, cursor, clipboard, shell)
};
if let event::Status::Captured = event_status {
@ -487,76 +480,71 @@ pub fn update<Message>(
return event::Status::Ignored;
}
if mouse_over_scrollable {
match event {
Event::Mouse(mouse::Event::WheelScrolled { delta }) => {
let delta = match delta {
mouse::ScrollDelta::Lines { x, y } => {
// TODO: Configurable speed/friction (?)
let movement = if state.keyboard_modifiers.shift() {
Vector::new(y, x)
} else {
Vector::new(x, y)
};
let Some(cursor_position) = cursor_over_scrollable else {
return event::Status::Ignored
};
movement * 60.0
}
mouse::ScrollDelta::Pixels { x, y } => Vector::new(x, y),
};
match event {
Event::Mouse(mouse::Event::WheelScrolled { delta }) => {
let delta = match delta {
mouse::ScrollDelta::Lines { x, y } => {
// TODO: Configurable speed/friction (?)
let movement = if state.keyboard_modifiers.shift() {
Vector::new(y, x)
} else {
Vector::new(x, y)
};
state.scroll(delta, bounds, content_bounds);
movement * 60.0
}
mouse::ScrollDelta::Pixels { x, y } => Vector::new(x, y),
};
notify_on_scroll(
state,
on_scroll,
bounds,
content_bounds,
shell,
);
state.scroll(delta, bounds, content_bounds);
notify_on_scroll(state, on_scroll, bounds, content_bounds, shell);
return event::Status::Captured;
}
Event::Touch(event)
if state.scroll_area_touched_at.is_some()
|| !mouse_over_y_scrollbar && !mouse_over_x_scrollbar =>
{
match event {
touch::Event::FingerPressed { .. } => {
state.scroll_area_touched_at = Some(cursor_position);
}
touch::Event::FingerMoved { .. } => {
if let Some(scroll_box_touched_at) =
state.scroll_area_touched_at
{
let delta = Vector::new(
cursor_position.x - scroll_box_touched_at.x,
cursor_position.y - scroll_box_touched_at.y,
);
state.scroll(delta, bounds, content_bounds);
return event::Status::Captured;
}
Event::Touch(event)
if state.scroll_area_touched_at.is_some()
|| !mouse_over_y_scrollbar && !mouse_over_x_scrollbar =>
{
match event {
touch::Event::FingerPressed { .. } => {
state.scroll_area_touched_at = Some(cursor_position);
}
touch::Event::FingerMoved { .. } => {
if let Some(scroll_box_touched_at) =
state.scroll_area_touched_at
{
let delta = Vector::new(
cursor_position.x - scroll_box_touched_at.x,
cursor_position.y - scroll_box_touched_at.y,
);
state.scroll(delta, bounds, content_bounds);
state.scroll_area_touched_at =
Some(cursor_position);
notify_on_scroll(
state,
on_scroll,
bounds,
content_bounds,
shell,
);
}
}
touch::Event::FingerLifted { .. }
| touch::Event::FingerLost { .. } => {
state.scroll_area_touched_at = None;
notify_on_scroll(
state,
on_scroll,
bounds,
content_bounds,
shell,
);
}
}
return event::Status::Captured;
touch::Event::FingerLifted { .. }
| touch::Event::FingerLost { .. } => {
state.scroll_area_touched_at = None;
}
}
_ => {}
return event::Status::Captured;
}
_ => {}
}
if let Some(scroller_grabbed_at) = state.y_scroller_grabbed_at {
@ -700,17 +688,17 @@ pub fn update<Message>(
pub fn mouse_interaction(
state: &State,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
vertical: &Properties,
horizontal: Option<&Properties>,
content_interaction: impl FnOnce(
Layout<'_>,
Point,
mouse::Cursor,
&Rectangle,
) -> mouse::Interaction,
) -> mouse::Interaction {
let bounds = layout.bounds();
let mouse_over_scrollable = bounds.contains(cursor_position);
let cursor_over_scrollable = cursor.position_over(&bounds);
let content_layout = layout.children().next().unwrap();
let content_bounds = content_layout.bounds();
@ -719,7 +707,7 @@ pub fn mouse_interaction(
Scrollbars::new(state, vertical, horizontal, bounds, content_bounds);
let (mouse_over_y_scrollbar, mouse_over_x_scrollbar) =
scrollbars.is_mouse_over(cursor_position);
scrollbars.is_mouse_over(cursor);
if (mouse_over_x_scrollbar || mouse_over_y_scrollbar)
|| state.scrollers_grabbed()
@ -728,17 +716,18 @@ pub fn mouse_interaction(
} else {
let offset = state.offset(bounds, content_bounds);
let cursor_position = if mouse_over_scrollable
&& !(mouse_over_y_scrollbar || mouse_over_x_scrollbar)
{
cursor_position + offset
} else {
Point::new(-1.0, -1.0)
let cursor = match cursor_over_scrollable {
Some(cursor_position)
if !(mouse_over_x_scrollbar || mouse_over_y_scrollbar) =>
{
mouse::Cursor::Available(cursor_position + offset)
}
_ => mouse::Cursor::Unavailable,
};
content_interaction(
content_layout,
cursor_position,
cursor,
&Rectangle {
y: bounds.y + offset.y,
x: bounds.x + offset.x,
@ -754,11 +743,11 @@ pub fn draw<Renderer>(
renderer: &mut Renderer,
theme: &Renderer::Theme,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
vertical: &Properties,
horizontal: Option<&Properties>,
style: &<Renderer::Theme as StyleSheet>::Style,
draw_content: impl FnOnce(&mut Renderer, Layout<'_>, Point, &Rectangle),
draw_content: impl FnOnce(&mut Renderer, Layout<'_>, mouse::Cursor, &Rectangle),
) where
Renderer: crate::core::Renderer,
Renderer::Theme: StyleSheet,
@ -770,18 +759,19 @@ pub fn draw<Renderer>(
let scrollbars =
Scrollbars::new(state, vertical, horizontal, bounds, content_bounds);
let mouse_over_scrollable = bounds.contains(cursor_position);
let cursor_over_scrollable = cursor.position_over(&bounds);
let (mouse_over_y_scrollbar, mouse_over_x_scrollbar) =
scrollbars.is_mouse_over(cursor_position);
scrollbars.is_mouse_over(cursor);
let offset = state.offset(bounds, content_bounds);
let cursor_position = if mouse_over_scrollable
&& !(mouse_over_x_scrollbar || mouse_over_y_scrollbar)
{
cursor_position + offset
} else {
Point::new(-1.0, -1.0)
let cursor = match cursor_over_scrollable {
Some(cursor_position)
if !(mouse_over_x_scrollbar || mouse_over_y_scrollbar) =>
{
mouse::Cursor::Available(cursor_position + offset)
}
_ => mouse::Cursor::Unavailable,
};
// Draw inner content
@ -793,7 +783,7 @@ pub fn draw<Renderer>(
draw_content(
renderer,
content_layout,
cursor_position,
cursor,
&Rectangle {
y: bounds.y + offset.y,
x: bounds.x + offset.x,
@ -858,7 +848,7 @@ pub fn draw<Renderer>(
if let Some(scrollbar) = scrollbars.y {
let style = if state.y_scroller_grabbed_at.is_some() {
theme.dragging(style)
} else if mouse_over_scrollable {
} else if cursor_over_scrollable.is_some() {
theme.hovered(style, mouse_over_y_scrollbar)
} else {
theme.active(style)
@ -871,7 +861,7 @@ pub fn draw<Renderer>(
if let Some(scrollbar) = scrollbars.x {
let style = if state.x_scroller_grabbed_at.is_some() {
theme.dragging_horizontal(style)
} else if mouse_over_scrollable {
} else if cursor_over_scrollable.is_some() {
theme.hovered_horizontal(style, mouse_over_x_scrollbar)
} else {
theme.active_horizontal(style)
@ -885,7 +875,7 @@ pub fn draw<Renderer>(
draw_content(
renderer,
content_layout,
cursor_position,
cursor,
&Rectangle {
x: bounds.x + offset.x,
y: bounds.y + offset.y,
@ -1283,17 +1273,21 @@ impl Scrollbars {
}
}
fn is_mouse_over(&self, cursor_position: Point) -> (bool, bool) {
(
self.y
.as_ref()
.map(|scrollbar| scrollbar.is_mouse_over(cursor_position))
.unwrap_or(false),
self.x
.as_ref()
.map(|scrollbar| scrollbar.is_mouse_over(cursor_position))
.unwrap_or(false),
)
fn is_mouse_over(&self, cursor: mouse::Cursor) -> (bool, bool) {
if let Some(cursor_position) = cursor.position() {
(
self.y
.as_ref()
.map(|scrollbar| scrollbar.is_mouse_over(cursor_position))
.unwrap_or(false),
self.x
.as_ref()
.map(|scrollbar| scrollbar.is_mouse_over(cursor_position))
.unwrap_or(false),
)
} else {
(false, false)
}
}
fn grab_y_scroller(&self, cursor_position: Point) -> Option<f32> {

36
widget/src/slider.rs
View file

@ -183,7 +183,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_renderer: &Renderer,
_clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -191,7 +191,7 @@ where
update(
event,
layout,
cursor_position,
cursor,
shell,
tree.state.downcast_mut::<State>(),
&mut self.value,
@ -209,13 +209,13 @@ where
theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
draw(
renderer,
layout,
cursor_position,
cursor,
tree.state.downcast_ref::<State>(),
self.value,
&self.range,
@ -228,15 +228,11 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
mouse_interaction(
layout,
cursor_position,
tree.state.downcast_ref::<State>(),
)
mouse_interaction(layout, cursor, tree.state.downcast_ref::<State>())
}
}
@ -260,7 +256,7 @@ where
pub fn update<Message, T>(
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
shell: &mut Shell<'_, Message>,
state: &mut State,
value: &mut T,
@ -275,7 +271,7 @@ where
{
let is_dragging = state.is_dragging;
let mut change = || {
let mut change = |cursor_position: Point| {
let bounds = layout.bounds();
let new_value = if cursor_position.x <= bounds.x {
*range.start()
@ -309,8 +305,10 @@ where
match event {
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
| Event::Touch(touch::Event::FingerPressed { .. }) => {
if layout.bounds().contains(cursor_position) {
change();
if let Some(cursor_position) =
cursor.position_over(&layout.bounds())
{
change(cursor_position);
state.is_dragging = true;
return event::Status::Captured;
@ -331,7 +329,7 @@ where
Event::Mouse(mouse::Event::CursorMoved { .. })
| Event::Touch(touch::Event::FingerMoved { .. }) => {
if is_dragging {
change();
let _ = cursor.position().map(change);
return event::Status::Captured;
}
@ -346,7 +344,7 @@ where
pub fn draw<T, R>(
renderer: &mut R,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
state: &State,
value: T,
range: &RangeInclusive<T>,
@ -358,7 +356,7 @@ pub fn draw<T, R>(
R::Theme: StyleSheet,
{
let bounds = layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.is_over(&bounds);
let style = if state.is_dragging {
style_sheet.dragging(style)
@ -444,11 +442,11 @@ pub fn draw<T, R>(
/// Computes the current [`mouse::Interaction`] of a [`Slider`].
pub fn mouse_interaction(
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
state: &State,
) -> mouse::Interaction {
let bounds = layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.is_over(&bounds);
if state.is_dragging {
mouse::Interaction::Grabbing

5
widget/src/space.rs
View file

@ -1,9 +1,10 @@
//! Distribute content vertically.
use crate::core;
use crate::core::layout;
use crate::core::mouse;
use crate::core::renderer;
use crate::core::widget::Tree;
use crate::core::{Element, Layout, Length, Point, Rectangle, Size, Widget};
use crate::core::{Element, Layout, Length, Rectangle, Size, Widget};
/// An amount of empty space.
///
@ -69,7 +70,7 @@ where
_theme: &Renderer::Theme,
_style: &renderer::Style,
_layout: Layout<'_>,
_cursor_position: Point,
_cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
}

5
widget/src/svg.rs
View file

@ -1,10 +1,11 @@
//! Display vector graphics in your application.
use crate::core::layout;
use crate::core::mouse;
use crate::core::renderer;
use crate::core::svg;
use crate::core::widget::Tree;
use crate::core::{
ContentFit, Element, Layout, Length, Point, Rectangle, Size, Vector, Widget,
ContentFit, Element, Layout, Length, Rectangle, Size, Vector, Widget,
};
use std::path::PathBuf;
@ -143,7 +144,7 @@ where
theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
_cursor_position: Point,
_cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
let Size { width, height } = renderer.dimensions(&self.handle);

38
widget/src/text_input.rs
View file

@ -207,14 +207,14 @@ where
renderer: &mut Renderer,
theme: &Renderer::Theme,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
value: Option<&Value>,
) {
draw(
renderer,
theme,
layout,
cursor_position,
cursor,
tree.state.downcast_ref::<State>(),
value.unwrap_or(&self.value),
&self.placeholder,
@ -298,7 +298,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -306,7 +306,7 @@ where
update(
event,
layout,
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -329,14 +329,14 @@ where
theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
draw(
renderer,
theme,
layout,
cursor_position,
cursor,
tree.state.downcast_ref::<State>(),
&self.value,
&self.placeholder,
@ -354,11 +354,11 @@ where
&self,
_state: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
mouse_interaction(layout, cursor_position, self.on_input.is_none())
mouse_interaction(layout, cursor, self.on_input.is_none())
}
}
@ -528,7 +528,7 @@ where
pub fn update<'a, Message, Renderer>(
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -550,10 +550,14 @@ where
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
| Event::Touch(touch::Event::FingerPressed { .. }) => {
let state = state();
let is_clicked =
layout.bounds().contains(cursor_position) && on_input.is_some();
state.is_focused = if is_clicked {
let click_position = if on_input.is_some() {
cursor.position_over(&layout.bounds())
} else {
None
};
state.is_focused = if click_position.is_some() {
state.is_focused.or_else(|| {
let now = Instant::now();
@ -566,7 +570,7 @@ where
None
};
if is_clicked {
if let Some(cursor_position) = click_position {
let text_layout = layout.children().next().unwrap();
let target = cursor_position.x - text_layout.bounds().x;
@ -944,7 +948,7 @@ pub fn draw<Renderer>(
renderer: &mut Renderer,
theme: &Renderer::Theme,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
state: &State,
value: &Value,
placeholder: &str,
@ -967,7 +971,7 @@ pub fn draw<Renderer>(
let mut children_layout = layout.children();
let text_bounds = children_layout.next().unwrap().bounds();
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.is_over(&bounds);
let appearance = if is_disabled {
theme.disabled(style)
@ -1154,10 +1158,10 @@ pub fn draw<Renderer>(
/// Computes the current [`mouse::Interaction`] of the [`TextInput`].
pub fn mouse_interaction(
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
is_disabled: bool,
) -> mouse::Interaction {
if layout.bounds().contains(cursor_position) {
if cursor.is_over(&layout.bounds()) {
if is_disabled {
mouse::Interaction::NotAllowed
} else {

16
widget/src/toggler.rs
View file

@ -7,8 +7,8 @@ use crate::core::renderer;
use crate::core::text;
use crate::core::widget::Tree;
use crate::core::{
Alignment, Clipboard, Element, Event, Layout, Length, Pixels, Point,
Rectangle, Shell, Widget,
Alignment, Clipboard, Element, Event, Layout, Length, Pixels, Rectangle,
Shell, Widget,
};
use crate::{Row, Text};
@ -202,14 +202,14 @@ where
_state: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_renderer: &Renderer,
_clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
) -> event::Status {
match event {
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
let mouse_over = layout.bounds().contains(cursor_position);
let mouse_over = cursor.is_over(&layout.bounds());
if mouse_over {
shell.publish((self.on_toggle)(!self.is_toggled));
@ -227,11 +227,11 @@ where
&self,
_state: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
if layout.bounds().contains(cursor_position) {
if cursor.is_over(&layout.bounds()) {
mouse::Interaction::Pointer
} else {
mouse::Interaction::default()
@ -245,7 +245,7 @@ where
theme: &Renderer::Theme,
style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
/// Makes sure that the border radius of the toggler looks good at every size.
@ -278,7 +278,7 @@ where
let toggler_layout = children.next().unwrap();
let bounds = toggler_layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.is_over(&layout.bounds());
let style = if is_mouse_over {
theme.hovered(&self.style, self.is_toggled)

33
widget/src/tooltip.rs
View file

@ -9,7 +9,7 @@ use crate::core::renderer;
use crate::core::text;
use crate::core::widget::Tree;
use crate::core::{
Clipboard, Element, Length, Padding, Pixels, Point, Rectangle, Shell, Size,
Clipboard, Element, Length, Padding, Pixels, Rectangle, Shell, Size,
Vector, Widget,
};
use crate::Text;
@ -136,7 +136,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
renderer: &Renderer,
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -145,7 +145,7 @@ where
&mut tree.children[0],
event,
layout,
cursor_position,
cursor,
renderer,
clipboard,
shell,
@ -156,14 +156,14 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
self.content.as_widget().mouse_interaction(
&tree.children[0],
layout,
cursor_position,
cursor,
viewport,
renderer,
)
@ -176,7 +176,7 @@ where
theme: &Renderer::Theme,
inherited_style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
self.content.as_widget().draw(
@ -185,7 +185,7 @@ where
theme,
inherited_style,
layout,
cursor_position,
cursor,
viewport,
);
@ -196,7 +196,7 @@ where
theme,
inherited_style,
layout,
cursor_position,
cursor,
viewport,
self.position,
self.gap,
@ -206,7 +206,7 @@ where
|renderer, limits| {
Widget::<(), Renderer>::layout(tooltip, renderer, limits)
},
|renderer, defaults, layout, cursor_position, viewport| {
|renderer, defaults, layout, viewport| {
Widget::<(), Renderer>::draw(
tooltip,
&Tree::empty(),
@ -214,7 +214,7 @@ where
theme,
defaults,
layout,
cursor_position,
cursor,
viewport,
);
},
@ -270,7 +270,7 @@ pub fn draw<Renderer>(
theme: &Renderer::Theme,
inherited_style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
viewport: &Rectangle,
position: Position,
gap: f32,
@ -278,13 +278,7 @@ pub fn draw<Renderer>(
snap_within_viewport: bool,
style: &<Renderer::Theme as container::StyleSheet>::Style,
layout_text: impl FnOnce(&Renderer, &layout::Limits) -> layout::Node,
draw_text: impl FnOnce(
&mut Renderer,
&renderer::Style,
Layout<'_>,
Point,
&Rectangle,
),
draw_text: impl FnOnce(&mut Renderer, &renderer::Style, Layout<'_>, &Rectangle),
) where
Renderer: core::Renderer,
Renderer::Theme: container::StyleSheet,
@ -293,7 +287,7 @@ pub fn draw<Renderer>(
let bounds = layout.bounds();
if bounds.contains(cursor_position) {
if let Some(cursor_position) = cursor.position_over(&bounds) {
let style = theme.appearance(style);
let defaults = renderer::Style {
@ -380,7 +374,6 @@ pub fn draw<Renderer>(
),
&text_layout,
),
cursor_position,
viewport,
)
});

37
widget/src/vertical_slider.rs
View file

@ -180,7 +180,7 @@ where
tree: &mut Tree,
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_renderer: &Renderer,
_clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
@ -188,7 +188,7 @@ where
update(
event,
layout,
cursor_position,
cursor,
shell,
tree.state.downcast_mut::<State>(),
&mut self.value,
@ -206,13 +206,13 @@ where
theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
draw(
renderer,
layout,
cursor_position,
cursor,
tree.state.downcast_ref::<State>(),
self.value,
&self.range,
@ -225,15 +225,11 @@ where
&self,
tree: &Tree,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
_viewport: &Rectangle,
_renderer: &Renderer,
) -> mouse::Interaction {
mouse_interaction(
layout,
cursor_position,
tree.state.downcast_ref::<State>(),
)
mouse_interaction(layout, cursor, tree.state.downcast_ref::<State>())
}
}
@ -257,7 +253,7 @@ where
pub fn update<Message, T>(
event: Event,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
shell: &mut Shell<'_, Message>,
state: &mut State,
value: &mut T,
@ -272,8 +268,9 @@ where
{
let is_dragging = state.is_dragging;
let mut change = || {
let mut change = |cursor_position: Point| {
let bounds = layout.bounds();
let new_value = if cursor_position.y >= bounds.y + bounds.height {
*range.start()
} else if cursor_position.y <= bounds.y {
@ -307,8 +304,10 @@ where
match event {
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
| Event::Touch(touch::Event::FingerPressed { .. }) => {
if layout.bounds().contains(cursor_position) {
change();
if let Some(cursor_position) =
cursor.position_over(&layout.bounds())
{
change(cursor_position);
state.is_dragging = true;
return event::Status::Captured;
@ -329,7 +328,7 @@ where
Event::Mouse(mouse::Event::CursorMoved { .. })
| Event::Touch(touch::Event::FingerMoved { .. }) => {
if is_dragging {
change();
let _ = cursor.position().map(change);
return event::Status::Captured;
}
@ -344,7 +343,7 @@ where
pub fn draw<T, R>(
renderer: &mut R,
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
state: &State,
value: T,
range: &RangeInclusive<T>,
@ -356,7 +355,7 @@ pub fn draw<T, R>(
R::Theme: StyleSheet,
{
let bounds = layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.position_over(&bounds).is_some();
let style = if state.is_dragging {
style_sheet.dragging(style)
@ -442,11 +441,11 @@ pub fn draw<T, R>(
/// Computes the current [`mouse::Interaction`] of a [`VerticalSlider`].
pub fn mouse_interaction(
layout: Layout<'_>,
cursor_position: Point,
cursor: mouse::Cursor,
state: &State,
) -> mouse::Interaction {
let bounds = layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over = cursor.position_over(&bounds).is_some();
if state.is_dragging {
mouse::Interaction::Grabbing