Struct rsvg::length::CssLength

pub struct CssLength<N: Normalize, V: Validate> {
    pub length: f64,
    pub unit: LengthUnit,
    orientation: PhantomData<N>,
    validation: PhantomData<V>,
}

A CSS length value.

This is equivalent to CSS lengths.

CssLength implements the Parse trait, so it can be parsed out of a [cssparser::Parser].

This type will be normally used through the type aliases Length and ULength

Examples of construction:

// Explicit type
let width: Length<Horizontal> = Length::new(42.0, LengthUnit::Cm);

// Inferred type
let height = Length::<Vertical>::new(42.0, LengthUnit::Cm);

// Parsed
let radius = ULength::<Both>::parse_str("5px").unwrap();

During the rendering phase, a CssLength needs to be converted to user-space coordinates with the CssLength::to_user method.

Fields

length: f64

Numeric part of the length

unit: LengthUnit

Unit part of the length

orientation: PhantomData<N>

Dummy; used internally for the type parameter N

validation: PhantomData<V>

Dummy; used internally for the type parameter V

Implementations

impl<N: Normalize, V: Validate> CssLength<N, V>

pub fn new(l: f64, unit: LengthUnit) -> CssLength<N, V>

Creates a CssLength.

The compiler needs to know the type parameters N and V which represents the length’s orientation and validation. You can specify them explicitly, or call the parametrized method:

// Explicit type
let width: Length<Horizontal> = Length::new(42.0, LengthUnit::Cm);

// Inferred type
let height = Length::<Vertical>::new(42.0, LengthUnit::Cm);

pub fn to_user(&self, params: &NormalizeParams) -> f64

Convert a Length with units into user-space coordinates.

Lengths may come with non-pixel units, and when rendering, they need to be normalized to pixels based on the current viewport (e.g. for lengths with percent units), and based on the current element’s set of ComputedValues (e.g. for lengths with Em units that need to be resolved against the current font size).

Those parameters can be obtained with NormalizeParams::new().

pub fn to_points(&self, params: &NormalizeParams) -> f64

Converts a Length to points. Pixels are taken to be respect with the DPI.

Panics

Will panic if the length is in Percent, Em, or Ex units.

pub fn to_inches(&self, params: &NormalizeParams) -> f64

pub fn to_cm(&self, params: &NormalizeParams) -> f64

pub fn to_mm(&self, params: &NormalizeParams) -> f64

pub fn to_picas(&self, params: &NormalizeParams) -> f64

Trait Implementations

impl<N: Clone + Normalize, V: Clone + Validate> Clone for CssLength<N, V>

fn clone(&self) -> CssLength<N, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug + Normalize, V: Debug + Validate> Debug for CssLength<N, V>

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

Formats the value using the given formatter.

impl<N: Normalize, V: Validate> Default for CssLength<N, V>

fn default() -> Self

Returns the “default value” for a type.

impl<N: Normalize, V: Validate> From<CssLength<N, V>> for RsvgLength

fn from(l: CssLength<N, V>) -> RsvgLength

Converts to this type from the input type.

impl<N: Normalize, V: Validate> Parse for CssLength<N, V>

fn parse<'i>( parser: &mut Parser<'i, '_>, ) -> Result<CssLength<N, V>, ParseError<'i>>

Parses a value out of the parser.

fn parse_str(s: &str) -> Result<Self, ParseError<'_>>

Convenience function to parse a value out of a &str.

impl<N: PartialEq + Normalize, V: PartialEq + Validate> PartialEq for CssLength<N, V>

fn eq(&self, other: &CssLength<N, V>) -> 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<N: Copy + Normalize, V: Copy + Validate> Copy for CssLength<N, V>

impl<N: Normalize, V: Validate> StructuralPartialEq for CssLength<N, V>