Struct glifparser::point::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 apply_matrix(&mut self, matrix: Affine)

Examples found in repository

src/component.rs (line 163)

fn apply_component_rect<PD: PointData>(last: &Node<Component<PD>>, minx: &mut f32, miny: &mut f32, maxx: &mut f32, maxy: &mut f32, final_outline: &mut Outline<PD>) {
    let mut matrices = vec![];
    matrices.push((*last).data().matrix);

    // Climb the tree, building a Vec of matrices for this component
    let mut pt = last.parent();
    while let Some(parent) = pt {
        matrices.push(parent.data().matrix);
        pt = parent.parent();
    }

    match (*last).data().glif.outline {
        Some(ref o) => {
            let mut to_transform = o.clone();
            for i in 0..to_transform.len() {
                for j in 0..to_transform[i].len() {
                    let is_first = i == 0 && j == 0;
                    let mut p = to_transform[i][j].clone();
                    if p.x < *minx || is_first { *minx = p.x; }
                    if p.y < *miny || is_first { *miny = p.y; }
                    if p.x > *maxx || is_first { *maxx = p.x; }
                    if p.y > *maxy || is_first { *maxy = p.y; }

                    for m in &matrices {
                        p.apply_matrix(*m);
                    }

                    to_transform[i][j] = p;
                }
            }
            final_outline.extend(to_transform);
        },
        None => {}
    }
}

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

Examples found in repository

src/point.rs (line 213)

    pub fn handle_or_colocated(
        &self,
        which: WhichHandle,
        transform_x: &dyn Fn(f32) -> f32,
        transform_y: &dyn Fn(f32) -> f32,
    ) -> (f32, f32) {
        let handle = self.handle(which);
        match handle {
            Handle::At(x, y) => (transform_x(x), transform_y(y)),
            Handle::Colocated => (transform_x(self.x), transform_y(self.y)),
        }
    }

    pub fn handle_as_gpoint(
        &self,
        which: WhichHandle,
    ) -> GlifPoint {
        let handle = self.handle(which);
        let (x, y) = match handle {
            Handle::At(x, y) => (x, y),
            Handle::Colocated => (self.x, self.y),
        };
        GlifPoint::from_x_y_type((x, y), PointType::OffCurve)
    }

src/point/valid.rs (line 48)

    fn is_valid(&self) -> bool {
        if let Some(pd) = self.data.as_ref() {
            if !pd.is_valid() {
                return false;
            }
        }

        if self.ptype == PointType::Undefined {
            return false;
        }
        if self.x.is_nan() || self.y.is_subnormal() {
            return false;
        }
        for handle in [self.handle(WhichHandle::A), self.handle(WhichHandle::B)] {
            if let Handle::At(hx, hy) = handle {
                if hx.is_nan() || hy.is_subnormal() {
                    return false;
                }
            }
        }
        true
    }

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.

Examples found in repository

src/point/conv.rs (line 15)

    pub fn from_handle<PD: PointData>(point: &Point<PD>, wh: WhichHandle) -> Self {
        let (x, y) = point.handle_or_colocated(wh, &|f| f, &|f| f);
        GlifPoint::from_x_y_type((x, y), PointType::OffCurve)
    }

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

Examples found in repository

src/point.rs (line 233)

    pub fn handle_as_point(&self, which: WhichHandle) -> Self {
        (&self.handle_as_gpoint(which)).into()
    }

    pub fn handle_as_kpoint(
        &self,
        which: WhichHandle,
    ) -> KurboPoint {
        let p = self.handle_as_gpoint(which);
        KurboPoint::new(f64::from(p.x), f64::from(p.y))
    }

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: Clone + PointData> Clone for Point<PD>

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

Returns a copy 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: PartialEq + PointData> PartialEq<Point<PD>> for Point<PD>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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>