Struct truetype::glyph_data::ComponentFlags

pub struct ComponentFlags(pub u16);

Component flags.

Tuple Fields

0: u16

Implementations

impl ComponentFlags

pub fn are_arguments_words(&self) -> bool

Examples found in repository

src/glyph_data.rs (line 305)

    fn read<T: Tape>(tape: &mut T, flags: ComponentFlags) -> Result<Self> {
        match (flags.are_arguments_words(), flags.are_arguments_xy()) {
            (true, true) => {
                let x = tape.take::<i16>()?;
                let y = tape.take::<i16>()?;
                Ok(Arguments::Offsets(x, y))
            }
            (false, true) => {
                let x = tape.take::<i8>()? as i16;
                let y = tape.take::<i8>()? as i16;
                Ok(Arguments::Offsets(x, y))
            }
            (true, false) => {
                let i = tape.take::<u16>()?;
                let j = tape.take::<u16>()?;
                Ok(Arguments::Indices(i, j))
            }
            (false, false) => {
                let i = tape.take::<u8>()? as u16;
                let j = tape.take::<u8>()? as u16;
                Ok(Arguments::Indices(i, j))
            }
        }
    }

pub fn are_arguments_xy(&self) -> bool

Examples found in repository

src/glyph_data.rs (line 305)

    fn read<T: Tape>(tape: &mut T, flags: ComponentFlags) -> Result<Self> {
        match (flags.are_arguments_words(), flags.are_arguments_xy()) {
            (true, true) => {
                let x = tape.take::<i16>()?;
                let y = tape.take::<i16>()?;
                Ok(Arguments::Offsets(x, y))
            }
            (false, true) => {
                let x = tape.take::<i8>()? as i16;
                let y = tape.take::<i8>()? as i16;
                Ok(Arguments::Offsets(x, y))
            }
            (true, false) => {
                let i = tape.take::<u16>()?;
                let j = tape.take::<u16>()?;
                Ok(Arguments::Indices(i, j))
            }
            (false, false) => {
                let i = tape.take::<u8>()? as u16;
                let j = tape.take::<u8>()? as u16;
                Ok(Arguments::Indices(i, j))
            }
        }
    }

pub fn should_round_xy_to_grid(&self) -> bool

pub fn has_scalar_scale(&self) -> bool

Examples found in repository

src/glyph_data.rs (line 341)

    fn read<T: Tape>(tape: &mut T, flags: ComponentFlags) -> Result<Self> {
        if flags.has_scalar_scale() {
            Ok(Options::Scalar(tape.take()?))
        } else if flags.has_vector_scale() {
            Ok(Options::Vector(tape.take()?, tape.take()?))
        } else if flags.has_matrix_scale() {
            Ok(Options::Matrix(
                tape.take()?,
                tape.take()?,
                tape.take()?,
                tape.take()?,
            ))
        } else {
            Ok(Options::None)
        }
    }

pub fn has_more_components(&self) -> bool

Examples found in repository

src/glyph_data.rs (line 210)

    fn read<T: Tape>(tape: &mut T, contour_count: i16) -> Result<Self> {
        if contour_count < -1 {
            raise!("found a malformed glyph");
        }
        if contour_count >= 0 {
            return Ok(Description::Simple(
                tape.take_given(contour_count as usize)?,
            ));
        }
        let mut components = vec![];
        let mut component_count = 0;
        let mut has_more_components = true;
        let mut has_instructions = false;
        while has_more_components {
            components.push(tape.take::<Component>()?);
            has_instructions |= components[component_count].flags.has_instructions();
            has_more_components = components[component_count].flags.has_more_components();
            component_count += 1;
        }
        let instruction_size = if has_instructions {
            tape.take::<u16>()?
        } else {
            0
        };
        let instructions = tape.take_bytes(instruction_size as usize)?;
        Ok(Description::Composite(CompositeDescription {
            components: components,
            instruction_size: instruction_size,
            instructions: instructions,
        }))
    }

pub fn has_vector_scale(&self) -> bool

Examples found in repository

src/glyph_data.rs (line 343)

    fn read<T: Tape>(tape: &mut T, flags: ComponentFlags) -> Result<Self> {
        if flags.has_scalar_scale() {
            Ok(Options::Scalar(tape.take()?))
        } else if flags.has_vector_scale() {
            Ok(Options::Vector(tape.take()?, tape.take()?))
        } else if flags.has_matrix_scale() {
            Ok(Options::Matrix(
                tape.take()?,
                tape.take()?,
                tape.take()?,
                tape.take()?,
            ))
        } else {
            Ok(Options::None)
        }
    }

pub fn has_matrix_scale(&self) -> bool

Examples found in repository

src/glyph_data.rs (line 345)

    fn read<T: Tape>(tape: &mut T, flags: ComponentFlags) -> Result<Self> {
        if flags.has_scalar_scale() {
            Ok(Options::Scalar(tape.take()?))
        } else if flags.has_vector_scale() {
            Ok(Options::Vector(tape.take()?, tape.take()?))
        } else if flags.has_matrix_scale() {
            Ok(Options::Matrix(
                tape.take()?,
                tape.take()?,
                tape.take()?,
                tape.take()?,
            ))
        } else {
            Ok(Options::None)
        }
    }

pub fn has_instructions(&self) -> bool

Examples found in repository

src/glyph_data.rs (line 209)

    fn read<T: Tape>(tape: &mut T, contour_count: i16) -> Result<Self> {
        if contour_count < -1 {
            raise!("found a malformed glyph");
        }
        if contour_count >= 0 {
            return Ok(Description::Simple(
                tape.take_given(contour_count as usize)?,
            ));
        }
        let mut components = vec![];
        let mut component_count = 0;
        let mut has_more_components = true;
        let mut has_instructions = false;
        while has_more_components {
            components.push(tape.take::<Component>()?);
            has_instructions |= components[component_count].flags.has_instructions();
            has_more_components = components[component_count].flags.has_more_components();
            component_count += 1;
        }
        let instruction_size = if has_instructions {
            tape.take::<u16>()?
        } else {
            0
        };
        let instructions = tape.take_bytes(instruction_size as usize)?;
        Ok(Description::Composite(CompositeDescription {
            components: components,
            instruction_size: instruction_size,
            instructions: instructions,
        }))
    }

pub fn should_use_metrics(&self) -> bool

pub fn has_overlap(&self) -> bool

pub fn is_offset_scaled(&self) -> bool

pub fn is_offset_unscaled(&self) -> bool

pub fn is_invalid(&self) -> bool

Trait Implementations

impl Clone for ComponentFlags

fn clone(&self) -> ComponentFlags

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ComponentFlags

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

Formats the value using the given formatter.

impl Default for ComponentFlags

fn default() -> ComponentFlags

Returns the “default value” for a type.

impl Display for ComponentFlags

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

Formats the value using the given formatter.

impl From<ComponentFlags> for u16

fn from(flags: ComponentFlags) -> u16

Converts to this type from the input type.

impl PartialEq<ComponentFlags> for ComponentFlags

fn eq(&self, other: &ComponentFlags) -> 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 Value for ComponentFlags

fn read<T: Tape>(tape: &mut T) -> Result<Self>

Read a value.

impl Copy for ComponentFlags

impl Eq for ComponentFlags

impl StructuralEq for ComponentFlags

impl StructuralPartialEq for ComponentFlags