Struct Point 

#[repr(C)]
pub struct Point<T: Clone + Debug + Default + PartialEq> {
    pub x: T,
    pub y: T,
}

Describes a location in a 2D cartesian space.

It holds two public fields, x and y, which represent the coordinates in the space. The type T for the coordinates can be any type that implements Default, Clone, and Debug.

Examples

let point = Point { x: 10, y: 20 };
println!("{:?}", point); // Outputs: Point { x: 10, y: 20 }

Fields

x: T

The x coordinate of the point.

y: T

The y coordinate of the point.

Implementations

impl<T: Clone + Debug + Default + PartialEq> Point<T>

pub const fn new(x: T, y: T) -> Self

Creates a new Point with the specified x and y coordinates.

Arguments

• x - The horizontal coordinate of the point.
• y - The vertical coordinate of the point.

Examples

use gpui::Point;
let p = Point::new(10, 20);
assert_eq!(p.x, 10);
assert_eq!(p.y, 20);

pub fn map<U: Clone + Debug + Default + PartialEq>( &self, f: impl Fn(T) -> U, ) -> Point<U>

Transforms the point to a Point<U> by applying the given function to both coordinates.

This method allows for converting a Point<T> to a Point<U> by specifying a closure that defines how to convert between the two types. The closure is applied to both the x and y coordinates, resulting in a new point of the desired type.

Arguments

• f - A closure that takes a value of type T and returns a value of type U.

Examples

let p = Point { x: 3, y: 4 };
let p_float = p.map(|coord| coord as f32);
assert_eq!(p_float, Point { x: 3.0, y: 4.0 });

impl Point<Pixels>

pub fn scale(&self, factor: f32) -> Point<ScaledPixels>

Scales the point by a given factor, which is typically derived from the resolution of a target display to ensure proper sizing of UI elements.

Arguments

• factor - The scaling factor to apply to both the x and y coordinates.

Examples

let p = Point { x: Pixels::from(10.0), y: Pixels::from(20.0) };
let scaled_p = p.scale(1.5);
assert_eq!(scaled_p, Point { x: ScaledPixels::from(15.0), y: ScaledPixels::from(30.0) });

pub fn magnitude(&self) -> f64

Calculates the Euclidean distance from the origin (0, 0) to this point.

Examples

let p = Point { x: Pixels::from(3.0), y: Pixels::from(4.0) };
assert_eq!(p.magnitude(), 5.0);

impl<T> Point<T>

where T: Sub<T, Output = T> + Clone + Debug + Default + PartialEq,

pub fn relative_to(&self, origin: &Point<T>) -> Point<T>

Get the position of this point, relative to the given origin

impl<T> Point<T>

where T: PartialOrd + Clone + Debug + Default + PartialEq,

pub fn max(&self, other: &Self) -> Self

Returns a new point with the maximum values of each dimension from self and other.

Arguments

• other - A reference to another Point to compare with self.

Examples

let p1 = Point { x: 3, y: 7 };
let p2 = Point { x: 5, y: 2 };
let max_point = p1.max(&p2);
assert_eq!(max_point, Point { x: 5, y: 7 });

pub fn min(&self, other: &Self) -> Self

Returns a new point with the minimum values of each dimension from self and other.

Arguments

• other - A reference to another Point to compare with self.

Examples

let p1 = Point { x: 3, y: 7 };
let p2 = Point { x: 5, y: 2 };
let min_point = p1.min(&p2);
assert_eq!(min_point, Point { x: 3, y: 2 });

pub fn clamp(&self, min: &Self, max: &Self) -> Self

Clamps the point to a specified range.

Given a minimum point and a maximum point, this method constrains the current point such that its coordinates do not exceed the range defined by the minimum and maximum points. If the current point’s coordinates are less than the minimum, they are set to the minimum. If they are greater than the maximum, they are set to the maximum.

Arguments

• min - A reference to a Point representing the minimum allowable coordinates.
• max - A reference to a Point representing the maximum allowable coordinates.

Examples

let p = Point { x: 10, y: 20 };
let min = Point { x: 0, y: 5 };
let max = Point { x: 15, y: 25 };
let clamped_p = p.clamp(&min, &max);
assert_eq!(clamped_p, Point { x: 10, y: 20 });

let p_out_of_bounds = Point { x: -5, y: 30 };
let clamped_p_out_of_bounds = p_out_of_bounds.clamp(&min, &max);
assert_eq!(clamped_p_out_of_bounds, Point { x: 0, y: 25 });

Trait Implementations

impl<T> Add<Point<T>> for Bounds<T>

where T: Add<T, Output = T> + Clone + Debug + Default + PartialEq,

type Output = Bounds<T>

The resulting type after applying the + operator.

fn add(self, rhs: Point<T>) -> Self

Performs the + operation.

impl<T: Clone + Debug + Default + PartialEq + Add<Output = T>> Add for Point<T>

type Output = Point<T>

The resulting type after applying the + operator.

fn add(self, rhs: Point<T>) -> Point<T>

Performs the + operation.

impl<T: Clone + Debug + Default + PartialEq + AddAssign> AddAssign for Point<T>

fn add_assign(&mut self, rhs: Point<T>)

Performs the += operation.

impl<T: Clone + Debug + Default + PartialEq> Along for Point<T>

type Unit = T

The unit associated with this type

fn along(&self, axis: Axis) -> T

Returns the unit along the given axis.

fn apply_along(&self, axis: Axis, f: impl FnOnce(T) -> T) -> Point<T>

Applies the given function to the unit along the given axis and returns a new value.

impl<T: Clone + Debug + Default + PartialEq> Clone for Point<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Clone + Debug + Default + PartialEq> Debug for Point<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default + Clone + Debug + Default + PartialEq> Default for Point<T>

fn default() -> Point<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Point<T>

where T: Deserialize<'de> + Clone + Debug + Default + PartialEq,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Clone + Debug + Default + PartialEq + Display> Display for Point<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, S> Div<S> for Point<T>

where T: Div<S, Output = T> + Clone + Debug + Default + PartialEq, S: Clone,

type Output = Point<T>

The resulting type after applying the / operator.

fn div(self, rhs: S) -> Self::Output

Performs the / operation.

impl From<Point<Pixels>> for Point2D<f32, Pixels>

fn from(p: Point<Pixels>) -> Self

Converts to this type from the input type.

impl From<Point<Pixels>> for Point

fn from(p: Point<Pixels>) -> Self

Converts to this type from the input type.

impl From<Point<Pixels>> for Vector

fn from(p: Point<Pixels>) -> Self

Converts to this type from the input type.

impl<T, T2> From<Point<T>> for Point<T2>

where T: Into<T2>, T2: Clone + Debug + Default + PartialEq,

fn from(point: TaffyPoint<T>) -> Point<T2>

Converts to this type from the input type.

impl<T, T2> From<Point<T>> for Point<T2>

where T: Into<T2> + Clone + Debug + Default + PartialEq,

fn from(val: Point<T>) -> Self

Converts to this type from the input type.

impl<T: Clone + Debug + Default + PartialEq> From<Point<T>> for Size<T>

fn from(point: Point<T>) -> Self

Converts to this type from the input type.

impl From<Point<u32>> for Vector2I

fn from(size: Point<u32>) -> Self

Converts to this type from the input type.

impl From<Point2D<f32, UnknownUnit>> for Point<Pixels>

fn from(p: Point) -> Self

Converts to this type from the input type.

impl From<Point2D<i32, UnknownUnit>> for Point<DevicePixels>

fn from(value: Point) -> Self

Converts to this type from the input type.

impl<T: Clone + Debug + Default + PartialEq> From<PointRefinement<T>> for Point<T>

where Option<T>: Clone,

fn from(value: PointRefinement<T>) -> Self

Converts to this type from the input type.

impl<T: Hash + Clone + Debug + Default + PartialEq> Hash for Point<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: IsZero + Clone + Debug + Default + PartialEq> IsZero for Point<T>

fn is_zero(&self) -> bool

Determines if the value is zero.

impl<T> JsonSchema for Point<T>

where T: JsonSchema + Clone + Debug + Default + PartialEq,

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl<T, Rhs> Mul<Rhs> for Point<T>

where T: Mul<Rhs, Output = T> + Clone + Debug + Default + PartialEq, Rhs: Clone + Debug,

type Output = Point<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Rhs) -> Self::Output

Performs the * operation.

impl<T, S> MulAssign<S> for Point<T>

where T: Mul<S, Output = T> + Clone + Debug + Default + PartialEq, S: Clone,

fn mul_assign(&mut self, rhs: S)

Performs the *= operation.

impl<T: Clone + Debug + Default + PartialEq + Negate> Negate for Point<T>

fn negate(self) -> Self

Returns the negation of the given value

impl<T: PartialEq + Clone + Debug + Default + PartialEq> PartialEq for Point<T>

fn eq(&self, other: &Point<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Clone + Debug + Default + PartialEq> Refineable for Point<T>

where Option<T>: Clone,

type Refinement = PointRefinement<T>

fn refine(&mut self, refinement: &Self::Refinement)

Applies the given refinement to this instance, modifying it in place.

fn refined(self, refinement: Self::Refinement) -> Self

Returns a new instance with the refinement applied, equivalent to cloning self and calling refine on it.

fn is_superset_of(&self, refinement: &Self::Refinement) -> bool

Returns true if this instance would contain all values from the refinement.

fn subtract(&self, refinement: &Self::Refinement) -> Self::Refinement

Returns a refinement that represents the difference between this instance and the given refinement.

fn from_cascade(cascade: &Cascade<Self>) -> Self

where Self: Sized + Default,

Creates an instance from a cascade by merging all refinements atop the default value.

impl<T> Serialize for Point<T>

where T: Serialize + Clone + Debug + Default + PartialEq,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Sub<Point<T>> for Bounds<T>

where T: Sub<T, Output = T> + Clone + Debug + Default + PartialEq,

type Output = Bounds<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<T>) -> Self

Performs the - operation.

impl<T: Clone + Debug + Default + PartialEq + Sub<Output = T>> Sub for Point<T>

type Output = Point<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<T>) -> Point<T>

Performs the - operation.

impl<T: Clone + Debug + Default + PartialEq + SubAssign> SubAssign for Point<T>

fn sub_assign(&mut self, rhs: Point<T>)

Performs the -= operation.

impl<T: Copy + Clone + Debug + Default + PartialEq> Copy for Point<T>

impl<T: Eq + Clone + Debug + Default + PartialEq> Eq for Point<T>

impl<T: Clone + Debug + Default + PartialEq> StructuralPartialEq for Point<T>