Struct Point 

pub struct Point<PD: PointData> {
    pub x: f32,
    pub y: f32,
    pub a: Handle,
    pub b: Handle,
    pub name: Option<String>,
    pub ptype: PointType,
    pub smooth: bool,
    pub data: Option<PD>,
}

A Skia-friendly point

Fields

x: f32

y: f32

a: Handle

b: Handle

name: Option<String>

ptype: PointType

smooth: bool

data: Option<PD>

Implementations

impl<PD: PointData> Point<PD>

pub fn new() -> Point<PD>

pub fn from_x_y_type((x, y): (f32, f32), ptype: PointType) -> Point<PD>

Make a point from its x and y position and type

pub fn from_x_y_a_b_type( (x, y): (f32, f32), (a, b): (Handle, Handle), ptype: PointType, ) -> Point<PD>

Make a point from its x and y position, handles and type

pub fn from_fields( (x, y): (f32, f32), (a, b): (Handle, Handle), smooth: bool, ptype: PointType, name: Option<String>, data: Option<PD>, ) -> Point<PD>

Make a point from its x and y position, handles and type

pub fn handle(&self, which: WhichHandle) -> Handle

pub fn handle_or_colocated( &self, which: WhichHandle, transform_x: &dyn Fn(f32) -> f32, transform_y: &dyn Fn(f32) -> f32, ) -> (f32, f32)

Return an x, y position for a point, or one of its handles. If called with WhichHandle::Neither, return position for point.

pub fn handle_as_gpoint(&self, which: WhichHandle) -> GlifPoint

pub fn handle_as_point(&self, which: WhichHandle) -> Self

pub fn handle_as_kpoint(&self, which: WhichHandle) -> KurboPoint

pub fn set_handle(&mut self, which: WhichHandle, handle: Handle)

This function is intended for use by generic functions that can work on either handle, to decrease the use of macros like move_mirror!(a, b).

Trait Implementations

impl<PD: PointData> ApplyMatrix for Point<PD>

fn apply_matrix(&mut self, matrix: Affine)

impl<PD: Clone + PointData> Clone for Point<PD>

fn clone(&self) -> Point<PD>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<PD: Debug + PointData> Debug for Point<PD>

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

Formats the value using the given formatter.

impl<PD: Default + PointData> Default for Point<PD>

fn default() -> Point<PD>

Returns the “default value” for a type.

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

where PD: Deserialize<'de> + Default + PointData,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<PD: PointData> From<&GlifPoint> for Point<PD>

fn from(gp: &GlifPoint) -> Self

Converts to this type from the input type.

impl<PD: PointData> From<&Point<PD>> for GlifPoint

Warning: you lose handles with this.

fn from(p: &Point<PD>) -> GlifPoint

Converts to this type from the input type.

impl<PD: PointData> From<&Point<PD>> for Handle

fn from(p: &Point<PD>) -> Handle

Converts to this type from the input type.

impl<PD: PointData> IsValid for Point<PD>

fn is_valid(&self) -> bool

validate_data parameter allows you to define an is_valid (or whatever) impl on your PointData struct’s. You can then pass the function while validating the point as e.g. Some(MyPointData::is_valid). It takes an Option<&PD> so that you have the choice as to whether it’s valid or not for your type not to be defined; Point.data should probably not be defined as an Option, but removing that’s TODO. This API will change when that does and should be considered unstable/testing.

fn expect_valid(&self)

impl<PD: PointData> MFEKPointCommon<PD> for Point<PD>

fn has_handle(&self, _handle: WhichHandle) -> bool

fn get_handle(&self, handle: WhichHandle) -> Option<Handle>

fn get_handle_position(&self, handle: WhichHandle) -> Option<(f32, f32)>

fn set_handle_position(&mut self, handle: WhichHandle, x: f32, y: f32)

fn set_handle(&mut self, wh: WhichHandle, handle: Handle)

fn get_position(&self) -> (f32, f32)

fn set_position(&mut self, x: f32, y: f32)

fn set_position_no_handles(&mut self, x: f32, y: f32)

fn x(&self) -> f32

fn y(&self) -> f32

fn get_name(&self) -> Option<String>

fn set_name(&mut self, name: String)

fn cubic(&self) -> Option<&Point<PD>>

fn quad(&self) -> Option<&QPoint<PD>>

fn hyper(&self) -> Option<&HyperPoint<PD>>

fn colocate_handle(&mut self, wh: WhichHandle)

impl<PD: PartialEq + PointData> PartialEq for Point<PD>

fn eq(&self, other: &Point<PD>) -> 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<PD: PointData> PointLike for Point<PD>

fn x(&self) -> IntegerOrFloat

fn y(&self) -> IntegerOrFloat

fn set_x(&mut self, x: IntegerOrFloat)

fn set_y(&mut self, y: IntegerOrFloat)

fn x32(&self) -> f32

fn y32(&self) -> f32

fn x64(&self) -> f64

fn y64(&self) -> f64

fn as_kpoint(&self) -> KurboPoint

impl<PD: PointData> RoundToInt for Point<PD>

fn round_to_int(&mut self)

impl<PD> Serialize for Point<PD>

where PD: Serialize + PointData,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<PD: PointData> StructuralPartialEq for Point<PD>