reivilibre/iced-mobile
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Introduce Cursor type in canvas

Browse Source
This commit is contained in:
Héctor Ramón Jiménez 2020-04-29 04:25:49 +02:00
parent 5586034d66
commit dc51080328
6 changed files with 169 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
examples/bezier_tool/src/main.rs
View File

@ -69,15 +69,13 @@ impl Sandbox for Example {
mod bezier {
use iced::{
canvas::{self, Canvas, Event, Frame, Geometry, Path, Stroke},
canvas::{self, Canvas, Cursor, Event, Frame, Geometry, Path, Stroke},
mouse, ButtonState, Element, Length, MouseCursor, Point, Rectangle,
Size,
};
#[derive(Default)]
pub struct State {
pending: Option<Pending>,
cursor_position: Point,
cache: canvas::Cache,
}
@ -106,64 +104,62 @@ mod bezier {
}
impl<'a> canvas::Program<Curve> for Bezier<'a> {
fn update(&mut self, event: Event, bounds: Size) -> Option<Curve> {
fn update(
&mut self,
event: Event,
bounds: Rectangle,
cursor: Cursor,
) -> Option<Curve> {
let cursor_position = cursor.internal_position(&bounds)?;
match event {
Event::Mouse(mouse_event) => match mouse_event {
mouse::Event::CursorMoved { x, y } => {
self.state.cursor_position = Point::new(x, y);
None
}
mouse::Event::Input {
button: mouse::Button::Left,
state: ButtonState::Pressed,
} if Rectangle::with_size(bounds)
.contains(self.state.cursor_position) =>
{
match self.state.pending {
None => {
self.state.pending = Some(Pending::One {
from: self.state.cursor_position,
});
None
}
Some(Pending::One { from }) => {
self.state.pending = Some(Pending::Two {
from,
to: self.state.cursor_position,
});
None
}
Some(Pending::Two { from, to }) => {
self.state.pending = None;
Some(Curve {
from,
to,
control: self.state.cursor_position,
})
}
} => match self.state.pending {
None => {
self.state.pending = Some(Pending::One {
from: cursor_position,
});
None
}
}
Some(Pending::One { from }) => {
self.state.pending = Some(Pending::Two {
from,
to: cursor_position,
});
None
}
Some(Pending::Two { from, to }) => {
self.state.pending = None;
Some(Curve {
from,
to,
control: cursor_position,
})
}
},
_ => None,
},
}
}
fn draw(&self, bounds: Size) -> Vec<Geometry> {
let content = self.state.cache.draw(bounds, |frame: &mut Frame| {
Curve::draw_all(self.curves, frame);
fn draw(&self, bounds: Rectangle, cursor: Cursor) -> Vec<Geometry> {
let content =
self.state.cache.draw(bounds.size(), |frame: &mut Frame| {
Curve::draw_all(self.curves, frame);
frame.stroke(
&Path::rectangle(Point::ORIGIN, frame.size()),
Stroke::default(),
);
});
frame.stroke(
&Path::rectangle(Point::ORIGIN, frame.size()),
Stroke::default(),
);
});
if let Some(pending) = &self.state.pending {
let pending_curve =
pending.draw(bounds, self.state.cursor_position);
let pending_curve = pending.draw(bounds, cursor);
vec![content, pending_curve]
} else {
@ -171,9 +167,12 @@ mod bezier {
}
}
fn mouse_cursor(&self, bounds: Size) -> MouseCursor {
if Rectangle::with_size(bounds).contains(self.state.cursor_position)
{
fn mouse_cursor(
&self,
bounds: Rectangle,
cursor: Cursor,
) -> MouseCursor {
if cursor.is_over(&bounds) {
MouseCursor::Crosshair
} else {
MouseCursor::default()
@ -208,24 +207,26 @@ mod bezier {
}
impl Pending {
fn draw(&self, bounds: Size, cursor_position: Point) -> Geometry {
let mut frame = Frame::new(bounds);
fn draw(&self, bounds: Rectangle, cursor: Cursor) -> Geometry {
let mut frame = Frame::new(bounds.size());
match *self {
Pending::One { from } => {
let line = Path::line(from, cursor_position);
frame.stroke(&line, Stroke::default().with_width(2.0));
}
Pending::Two { from, to } => {
let curve = Curve {
from,
to,
control: cursor_position,
};
if let Some(cursor_position) = cursor.internal_position(&bounds) {
match *self {
Pending::One { from } => {
let line = Path::line(from, cursor_position);
frame.stroke(&line, Stroke::default().with_width(2.0));
}
Pending::Two { from, to } => {
let curve = Curve {
from,
to,
control: cursor_position,
};
Curve::draw_all(&[curve], &mut frame);
}
};
Curve::draw_all(&[curve], &mut frame);
}
};
}
frame.into_geometry()
}

8
examples/clock/src/main.rs
View File

@ -1,7 +1,7 @@
use iced::{
canvas::{self, Cache, Canvas, Geometry, LineCap, Path, Stroke},
canvas::{self, Cache, Canvas, Cursor, Geometry, LineCap, Path, Stroke},
executor, Application, Color, Command, Container, Element, Length, Point,
Settings, Size, Subscription, Vector,
Rectangle, Settings, Subscription, Vector,
};
pub fn main() {
@ -75,10 +75,10 @@ impl Application for Clock {
}
impl canvas::Program<Message> for Clock {
fn draw(&self, bounds: Size) -> Vec<Geometry> {
fn draw(&self, bounds: Rectangle, _cursor: Cursor) -> Vec<Geometry> {
use chrono::Timelike;
let clock = self.clock.draw(bounds, |frame| {
let clock = self.clock.draw(bounds.size(), |frame| {
let center = frame.center();
let radius = frame.width().min(frame.height()) / 2.0;

16
examples/solar_system/src/main.rs
View File

@ -7,8 +7,9 @@
//!
//! [1]: https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API/Tutorial/Basic_animations#An_animated_solar_system
use iced::{
canvas, executor, window, Application, Canvas, Color, Command, Element,
Length, Point, Settings, Size, Subscription, Vector,
canvas::{self, Cursor, Path, Stroke},
executor, window, Application, Canvas, Color, Command, Element, Length,
Point, Rectangle, Settings, Size, Subscription, Vector,
};
use std::time::Instant;
@ -132,11 +133,14 @@ impl State {
}
impl<Message> canvas::Program<Message> for State {
fn draw(&self, bounds: Size) -> Vec<canvas::Geometry> {
use canvas::{Path, Stroke};
fn draw(
&self,
bounds: Rectangle,
_cursor: Cursor,
) -> Vec<canvas::Geometry> {
use std::f32::consts::PI;
let background = self.space_cache.draw(bounds, |frame| {
let background = self.space_cache.draw(bounds.size(), |frame| {
let space = Path::rectangle(Point::new(0.0, 0.0), frame.size());
let stars = Path::new(|path| {
@ -151,7 +155,7 @@ impl<Message> canvas::Program<Message> for State {
frame.fill(&stars, Color::WHITE);
});
let system = self.system_cache.draw(bounds, |frame| {
let system = self.system_cache.draw(bounds.size(), |frame| {
let center = frame.center();
let sun = Path::circle(center, Self::SUN_RADIUS);

38
wgpu/src/widget/canvas.rs
View File

@ -9,8 +9,8 @@
use crate::{Defaults, Primitive, Renderer};
use iced_native::{
input::mouse, layout, Clipboard, Element, Hasher, Layout, Length,
MouseCursor, Point, Size, Vector, Widget,
layout, Clipboard, Element, Hasher, Layout, Length, MouseCursor, Point,
Size, Vector, Widget,
};
use std::hash::Hash;
use std::marker::PhantomData;
@ -18,6 +18,7 @@ use std::marker::PhantomData;
pub mod path;
mod cache;
mod cursor;
mod event;
mod fill;
mod frame;
@ -27,6 +28,7 @@ mod stroke;
mod text;
pub use cache::Cache;
pub use cursor::Cursor;
pub use event::Event;
pub use fill::Fill;
pub use frame::Frame;
@ -59,10 +61,10 @@ pub use text::Text;
/// ```no_run
/// # mod iced {
/// # pub use iced_wgpu::canvas;
/// # pub use iced_native::{Color, Size};
/// # pub use iced_native::{Color, Rectangle};
/// # }
/// use iced::canvas::{self, Cache, Canvas, Fill, Frame, Geometry, Path, Program};
/// use iced::{Color, Size};
/// use iced::canvas::{self, Canvas, Cursor, Fill, Frame, Geometry, Path, Program};
/// use iced::{Color, Rectangle};
///
/// // First, we define the data we need for drawing
/// #[derive(Debug)]
@ -72,9 +74,9 @@ pub use text::Text;
///
/// // Then, we implement the `Program` trait
/// impl Program<()> for Circle {
/// fn draw(&self, bounds: Size) -> Vec<Geometry>{
/// fn draw(&self, bounds: Rectangle, _cursor: Cursor) -> Vec<Geometry>{
/// // We prepare a new `Frame`
/// let mut frame = Frame::new(bounds);
/// let mut frame = Frame::new(bounds.size());
///
/// // We create a `Path` representing a simple circle
/// let circle = Path::circle(frame.center(), self.radius);
@ -165,22 +167,16 @@ impl<Message, P: Program<Message>> Widget<Message, Renderer>
let canvas_event = match event {
iced_native::Event::Mouse(mouse_event) => {
Some(Event::Mouse(match mouse_event {
mouse::Event::CursorMoved { .. } => {
mouse::Event::CursorMoved {
x: cursor_position.x - bounds.x,
y: cursor_position.y - bounds.y,
}
}
_ => mouse_event,
}))
Some(Event::Mouse(mouse_event))
}
_ => None,
};
let cursor = Cursor::from_window_position(cursor_position);
if let Some(canvas_event) = canvas_event {
if let Some(message) =
self.program.update(canvas_event, bounds.size())
self.program.update(canvas_event, bounds, cursor)
{
messages.push(message);
}
@ -192,11 +188,11 @@ impl<Message, P: Program<Message>> Widget<Message, Renderer>
_renderer: &mut Renderer,
_defaults: &Defaults,
layout: Layout<'_>,
_cursor_position: Point,
cursor_position: Point,
) -> (Primitive, MouseCursor) {
let bounds = layout.bounds();
let translation = Vector::new(bounds.x, bounds.y);
let size = Size::new(bounds.width, bounds.height);
let cursor = Cursor::from_window_position(cursor_position);
(
Primitive::Translate {
@ -204,13 +200,13 @@ impl<Message, P: Program<Message>> Widget<Message, Renderer>
content: Box::new(Primitive::Group {
primitives: self
.program
.draw(size)
.draw(bounds, cursor)
.into_iter()
.map(Geometry::into_primitive)
.collect(),
}),
},
self.program.mouse_cursor(size),
self.program.mouse_cursor(bounds, cursor),
)
}

50
wgpu/src/widget/canvas/cursor.rs Normal file
View File

@ -0,0 +1,50 @@
use iced_native::{Point, Rectangle};
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Cursor {
Available(Point),
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)
}
}
pub fn position(&self) -> Option<Point> {
match self {
Cursor::Available(position) => Some(*position),
Cursor::Unavailable => None,
}
}
pub fn relative_position(&self, bounds: &Rectangle) -> Option<Point> {
match self {
Cursor::Available(position) => {
Some(Point::new(position.x - bounds.x, position.y - bounds.y))
}
_ => None,
}
}
pub fn internal_position(&self, bounds: &Rectangle) -> Option<Point> {
if self.is_over(bounds) {
self.relative_position(bounds)
} else {
None
}
}
pub fn is_over(&self, bounds: &Rectangle) -> bool {
match self {
Cursor::Available(position) => bounds.contains(*position),
Cursor::Unavailable => false,
}
}
}

32
wgpu/src/widget/canvas/program.rs
View File

@ -1,14 +1,19 @@
use crate::canvas::{Event, Geometry, Size};
use iced_native::MouseCursor;
use crate::canvas::{Cursor, Event, Geometry};
use iced_native::{MouseCursor, Rectangle};
pub trait Program<Message> {
fn update(&mut self, _event: Event, _bounds: Size) -> Option<Message> {
fn update(
&mut self,
_event: Event,
_bounds: Rectangle,
_cursor: Cursor,
) -> Option<Message> {
None
}
fn draw(&self, bounds: Size) -> Vec<Geometry>;
fn draw(&self, bounds: Rectangle, cursor: Cursor) -> Vec<Geometry>;
fn mouse_cursor(&self, _bounds: Size) -> MouseCursor {
fn mouse_cursor(&self, _bounds: Rectangle, _cursor: Cursor) -> MouseCursor {
MouseCursor::default()
}
}
@ -17,15 +22,20 @@ impl<T, Message> Program<Message> for &mut T
where
T: Program<Message>,
{
fn update(&mut self, event: Event, bounds: Size) -> Option<Message> {
T::update(self, event, bounds)
fn update(
&mut self,
event: Event,
bounds: Rectangle,
cursor: Cursor,
) -> Option<Message> {
T::update(self, event, bounds, cursor)
}
fn draw(&self, bounds: Size) -> Vec<Geometry> {
T::draw(self, bounds)
fn draw(&self, bounds: Rectangle, cursor: Cursor) -> Vec<Geometry> {
T::draw(self, bounds, cursor)
}
fn mouse_cursor(&self, bounds: Size) -> MouseCursor {
T::mouse_cursor(self, bounds)
fn mouse_cursor(&self, bounds: Rectangle, cursor: Cursor) -> MouseCursor {
T::mouse_cursor(self, bounds, cursor)
}
}