Struct Point

pub struct Point {
    pub x: f64,
    pub y: f64,
}

Expand description

Tracks scroll events on Scroll views for testing.

This helper records viewport changes from scroll events, making it easy to verify scroll behavior in tests.

§Example

let scroll_tracker = ScrollTracker::new();

let content = Empty::new().style(|s| s.size(200.0, 400.0));
let scroll_view = scroll_tracker.track(Scroll::new(content));

let mut harness = HeadlessHarness::new_with_size(scroll_view, 100.0, 100.0);
harness.scroll_vertical(50.0, 50.0, 50.0);

let viewport = scroll_tracker.last_viewport().unwrap();
assert!(viewport.y0 > 0.0, "Should have scrolled down");

Kurbo types re-exported for convenience. A 2D point.

This type represents a point in 2D space. It has the same layout as [Vec2], but its meaning is different: Vec2 represents a change in location (for example velocity).

In general, kurbo overloads math operators where it makes sense, for example implementing Affine * Point as the point under the affine transformation. However Point + Point and f64 * Point are not implemented, because the operations do not make geometric sense. If you need to apply these operations, then 1) check what you’re doing makes geometric sense, then 2) use Point::to_vec2 to convert the point to a Vec2.

Fields§

§x: f64

The x coordinate.

§y: f64

The y coordinate.

Implementations§

§

impl Point

pub const ZERO: Point

The point (0, 0).

pub const ORIGIN: Point

The point at the origin; (0, 0).

pub const fn new(x: f64, y: f64) -> Point

Create a new Point with the provided x and y coordinates.

pub const fn to_vec2(self) -> Vec2

Convert this point into a Vec2.

pub fn lerp(self, other: Point, t: f64) -> Point

Linearly interpolate between two points.

pub const fn midpoint(self, other: Point) -> Point

Determine the midpoint of two points.

pub fn distance(self, other: Point) -> f64

Euclidean distance.

See [Vec2::hypot] for the same operation on [Vec2].

pub fn distance_squared(self, other: Point) -> f64

Squared Euclidean distance.

See [Vec2::hypot2] for the same operation on [Vec2].

pub fn round(self) -> Point

Returns a new Point, with x and y rounded to the nearest integer.

§Examples

use kurbo::Point;
let a = Point::new(3.3, 3.6).round();
let b = Point::new(3.0, -3.1).round();
assert_eq!(a.x, 3.0);
assert_eq!(a.y, 4.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -3.0);

pub fn ceil(self) -> Point

Returns a new Point, with x and y rounded up to the nearest integer, unless they are already an integer.

§Examples

use kurbo::Point;
let a = Point::new(3.3, 3.6).ceil();
let b = Point::new(3.0, -3.1).ceil();
assert_eq!(a.x, 4.0);
assert_eq!(a.y, 4.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -3.0);

pub fn floor(self) -> Point

Returns a new Point, with x and y rounded down to the nearest integer, unless they are already an integer.

§Examples

use kurbo::Point;
let a = Point::new(3.3, 3.6).floor();
let b = Point::new(3.0, -3.1).floor();
assert_eq!(a.x, 3.0);
assert_eq!(a.y, 3.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -4.0);

pub fn expand(self) -> Point

Returns a new Point, with x and y rounded away from zero to the nearest integer, unless they are already an integer.

§Examples

use kurbo::Point;
let a = Point::new(3.3, 3.6).expand();
let b = Point::new(3.0, -3.1).expand();
assert_eq!(a.x, 4.0);
assert_eq!(a.y, 4.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -4.0);

pub fn trunc(self) -> Point

Returns a new Point, with x and y rounded towards zero to the nearest integer, unless they are already an integer.

§Examples

use kurbo::Point;
let a = Point::new(3.3, 3.6).trunc();
let b = Point::new(3.0, -3.1).trunc();
assert_eq!(a.x, 3.0);
assert_eq!(a.y, 3.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -3.0);