Struct freetype_sys::FT_FaceRec

#[repr(C)]
pub struct FT_FaceRec {

    pub num_faces: FT_Long,
    pub face_index: FT_Long,
    pub face_flags: FT_Long,
    pub style_flags: FT_Long,
    pub num_glyphs: FT_Long,
    pub family_name: *mut FT_String,
    pub style_name: *mut FT_String,
    pub num_fixed_sizes: FT_Int,
    pub available_sizes: *mut FT_Bitmap_Size,
    pub num_charmaps: FT_Int,
    pub charmaps: *mut FT_CharMap,
    pub generic: FT_Generic,
    pub bbox: FT_BBox,
    pub units_per_EM: FT_UShort,
    pub ascender: FT_Short,
    pub descender: FT_Short,
    pub height: FT_Short,
    pub max_advance_width: FT_Short,
    pub max_advance_height: FT_Short,
    pub underline_position: FT_Short,
    pub underline_thickness: FT_Short,
    pub glyph: FT_GlyphSlot,
    pub size: FT_Size,
    pub charmap: FT_CharMap,
    pub driver: FT_Driver,
    pub memory: FT_Memory,
    pub stream: FT_Stream,
    pub sizes_list: FT_ListRec,
    pub autohint: FT_Generic,
    pub extensions: *mut c_void,
    pub internal: FT_Face_Internal,
}

Fields

num_faces: FT_Long

face_index: FT_Long

face_flags: FT_Long

style_flags: FT_Long

num_glyphs: FT_Long

family_name: *mut FT_String

style_name: *mut FT_String

num_fixed_sizes: FT_Int

available_sizes: *mut FT_Bitmap_Size

num_charmaps: FT_Int

charmaps: *mut FT_CharMap

generic: FT_Generic

bbox: FT_BBox

units_per_EM: FT_UShort

ascender: FT_Short

descender: FT_Short

height: FT_Short

max_advance_width: FT_Short

max_advance_height: FT_Short

underline_position: FT_Short

underline_thickness: FT_Short

glyph: FT_GlyphSlot

size: FT_Size

charmap: FT_CharMap

driver: FT_Driver

memory: FT_Memory

stream: FT_Stream

sizes_list: FT_ListRec

autohint: FT_Generic

extensions: *mut c_void

internal: FT_Face_Internal

Trait Implementations

impl Debug for FT_FaceRec

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

Formats the value using the given formatter.

impl Hash for FT_FaceRec

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 FT_FaceRec

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

impl Eq for FT_FaceRec

impl StructuralPartialEq for FT_FaceRec