Struct truetype::glyph_data::PointFlags

source ·

pub struct PointFlags(pub u8);

Expand description

Point flags.

Tuple Fields§

§0: u8

Implementations§

source §

pub fn is_repeated(&self) -> bool

Examples found in repository ?

src/glyph_data.rs (line 251)

    fn read<T: Tape>(tape: &mut T, contour_count: usize) -> Result<Self> {
        macro_rules! reject(() => (raise!("found a malformed glyph description")));

        let end_points = tape.take_given::<Vec<u16>>(contour_count)?;
        for i in 1..contour_count {
            if end_points[i - 1] > end_points[i] {
                reject!();
            }
        }
        let point_count = end_points.last().map(|&i| i as usize + 1).unwrap_or(0);

        let instruction_size = tape.take()?;
        let instructions = tape.take_bytes(instruction_size as usize)?;

        let mut flags = Vec::with_capacity(point_count);
        let mut flag_count = 0;
        while flag_count < point_count {
            let flag = tape.take::<PointFlags>()?;
            if flag.is_invalid() {
                reject!();
            }
            let count = 1 + if flag.is_repeated() {
                tape.take::<u8>()? as usize
            } else {
                0
            };
            if flag_count + count > point_count {
                reject!();
            }
            for _ in 0..count {
                flags.push(flag);
            }
            flag_count += count;
        }

        macro_rules! read_coordinates(
            ($is_short:ident, $is_positive:ident, $is_same:ident) => ({
                let mut values = Vec::with_capacity(point_count);
                for i in 0..point_count {
                    let value = if flags[i].$is_short() {
                        let value = tape.take::<u8>()? as i16;
                        if flags[i].$is_positive() { value } else { -value }
                    } else {
                        if flags[i].$is_same() { 0 } else { tape.take::<i16>()? }
                    };
                    values.push(value);
                }
                values
            });
        );
        let x = read_coordinates!(is_x_short, is_x_positive, is_x_same);
        let y = read_coordinates!(is_y_short, is_y_positive, is_y_same);

        Ok(SimpleDescription {
            end_points: end_points,
            instruction_size: instruction_size,
            instructions: instructions,
            flags: flags,
            x: x,
            y: y,
        })
    }

source

pub fn is_x_positive(&self) -> bool

source

pub fn is_x_same(&self) -> bool

source

pub fn is_y_positive(&self) -> bool

source

pub fn is_y_same(&self) -> bool

source

pub fn is_overlap_simple(&self) -> bool

source

pub fn is_invalid(&self) -> bool

Examples found in repository ?

src/glyph_data.rs (line 248)

    fn read<T: Tape>(tape: &mut T, contour_count: usize) -> Result<Self> {
        macro_rules! reject(() => (raise!("found a malformed glyph description")));

        let end_points = tape.take_given::<Vec<u16>>(contour_count)?;
        for i in 1..contour_count {
            if end_points[i - 1] > end_points[i] {
                reject!();
            }
        }
        let point_count = end_points.last().map(|&i| i as usize + 1).unwrap_or(0);

        let instruction_size = tape.take()?;
        let instructions = tape.take_bytes(instruction_size as usize)?;

        let mut flags = Vec::with_capacity(point_count);
        let mut flag_count = 0;
        while flag_count < point_count {
            let flag = tape.take::<PointFlags>()?;
            if flag.is_invalid() {
                reject!();
            }
            let count = 1 + if flag.is_repeated() {
                tape.take::<u8>()? as usize
            } else {
                0
            };
            if flag_count + count > point_count {
                reject!();
            }
            for _ in 0..count {
                flags.push(flag);
            }
            flag_count += count;
        }

        macro_rules! read_coordinates(
            ($is_short:ident, $is_positive:ident, $is_same:ident) => ({
                let mut values = Vec::with_capacity(point_count);
                for i in 0..point_count {
                    let value = if flags[i].$is_short() {
                        let value = tape.take::<u8>()? as i16;
                        if flags[i].$is_positive() { value } else { -value }
                    } else {
                        if flags[i].$is_same() { 0 } else { tape.take::<i16>()? }
                    };
                    values.push(value);
                }
                values
            });
        );
        let x = read_coordinates!(is_x_short, is_x_positive, is_x_same);
        let y = read_coordinates!(is_y_short, is_y_positive, is_y_same);

        Ok(SimpleDescription {
            end_points: end_points,
            instruction_size: instruction_size,
            instructions: instructions,
            flags: flags,
            x: x,
            y: y,
        })
    }