Struct PdfQuadPoints 

pub struct PdfQuadPoints { /* private fields */ }

A set of four coordinates expressed in PdfPoints that outline the bounds of a four-sided quadrilateral. The coordinates specify the quadrilateral’s four vertices in counter-clockwise order:

(x4, y4)                     (x3, y3)
       ._____________________.
       |                     |
       |                     |
       !_____________________!
(x1, y1)                     (x2, y2)

More information on quad points can be found in Section 8.30 of the PDF Reference Manual, version 1.7, on page 634.

Implementations

impl PdfQuadPoints

pub const ZERO: PdfQuadPoints

A PdfQuadPoints object with the identity value (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0).

pub const fn new( x1: PdfPoints, y1: PdfPoints, x2: PdfPoints, y2: PdfPoints, x3: PdfPoints, y3: PdfPoints, x4: PdfPoints, y4: PdfPoints, ) -> Self

Creates a new PdfQuadPoints object from the given PdfPoints coordinate pairs.

The coordinate space of a PdfPage has its origin (0,0) at the bottom left of the page, with x values increasing as coordinates move horizontally to the right and y values increasing as coordinates move vertically up.

pub const fn new_from_values( x1: f32, y1: f32, x2: f32, y2: f32, x3: f32, y3: f32, x4: f32, y4: f32, ) -> Self

Creates a new PdfQuadPoints object from the given raw points values.

The coordinate space of a PdfPage has its origin (0,0) at the bottom left of the page, with x values increasing as coordinates move horizontally to the right and y values increasing as coordinates move vertically up.

pub const fn zero() -> Self

Creates a new PdfQuadPoints object with all values set to 0.0.

Consider using the compile-time constant value PdfQuadPoints::ZERO rather than calling this function directly.

pub fn from_rect(rect: &PdfRect) -> Self

Creates a new PdfQuadPoints from the given PdfRect.

pub fn x1(&self) -> PdfPoints

Returns the x1 point of this PdfQuadPoints.

pub fn y1(&self) -> PdfPoints

Returns the y1 point of this PdfQuadPoints.

pub fn x2(&self) -> PdfPoints

Returns the x2 point of this PdfQuadPoints.

pub fn y2(&self) -> PdfPoints

Returns the y2 point of this PdfQuadPoints.

pub fn x3(&self) -> PdfPoints

Returns the x3 point of this PdfQuadPoints.

pub fn y3(&self) -> PdfPoints

Returns the y3 point of this PdfQuadPoints.

pub fn x4(&self) -> PdfPoints

Returns the x4 point of this PdfQuadPoints.

pub fn y4(&self) -> PdfPoints

Returns the y4 point of this PdfQuadPoints.

pub fn left(&self) -> PdfPoints

Returns the left-most extent of this PdfQuadPoints.

pub fn right(&self) -> PdfPoints

Returns the right-most extent of this PdfQuadPoints.

pub fn bottom(&self) -> PdfPoints

Returns the bottom-most extent of this PdfQuadPoints.

pub fn top(&self) -> PdfPoints

Returns the top-most extent of this PdfQuadPoints.

pub fn width(&self) -> PdfPoints

Returns the width of this PdfQuadPoints.

pub fn height(&self) -> PdfPoints

Returns the height of this PdfQuadPoints.

pub fn transform(&self, matrix: PdfMatrix) -> PdfQuadPoints

Returns the result of applying the given PdfMatrix to each corner point

pub fn to_rect(&self) -> PdfRect

Returns the smallest PdfRect that can completely enclose the quadrilateral outlined by this PdfQuadPoints.

Trait Implementations

impl Clone for PdfQuadPoints

fn clone(&self) -> PdfQuadPoints

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for PdfQuadPoints

impl Debug for PdfQuadPoints

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

Formats the value using the given formatter.

impl Display for PdfQuadPoints

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

Formats the value using the given formatter.

impl Eq for PdfQuadPoints

impl Hash for PdfQuadPoints

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 PartialEq for PdfQuadPoints

fn eq(&self, other: &Self) -> 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.