Enum GenericFamily 

#[repr(u8)]
pub enum GenericFamily {
    Serif = 0,
    SansSerif = 1,
    Monospace = 2,
    Cursive = 3,
    Fantasy = 4,
    SystemUi = 5,
    UiSerif = 6,
    UiSansSerif = 7,
    UiMonospace = 8,
    UiRounded = 9,
    Emoji = 10,
    Math = 11,
    FangSong = 12,
}

Describes a generic font family.

Variants

Serif = 0

Glyphs have finishing strokes, flared or tapering ends, or have actual serifed endings.

SansSerif = 1

Glyphs have stroke endings that are plain.

Monospace = 2

All glyphs have the same fixed width.

Cursive = 3

Glyphs in cursive fonts generally have either joining strokes or other cursive characteristics beyond those of italic typefaces. The glyphs are partially or completely connected, and the result looks more like handwritten pen or brush writing than printed letter work.

Fantasy = 4

Fantasy fonts are primarily decorative fonts that contain playful representations of characters

SystemUi = 5

Glyphs are taken from the default user interface font on a given platform.

UiSerif = 6

The default user interface serif font.

UiSansSerif = 7

The default user interface sans-serif font.

UiMonospace = 8

The default user interface monospace font.

UiRounded = 9

The default user interface font that has rounded features.

Emoji = 10

Fonts that are specifically designed to render emoji.

Math = 11

This is for the particular stylistic concerns of representing mathematics: superscript and subscript, brackets that cross several lines, nesting expressions, and double struck glyphs with distinct meanings.

FangSong = 12

A particular style of Chinese characters that are between serif-style Song and cursive-style Kai forms. This style is often used for government documents.

Implementations

impl GenericFamily

pub fn parse(s: &str) -> Option<GenericFamily>

Parses a generic family from a CSS generic family name.

Example

assert_eq!(GenericFamily::parse("sans-serif"), Some(GenericFamily::SansSerif));
assert_eq!(GenericFamily::parse("Arial"), None);

pub const fn all() -> &'static [GenericFamily]

Returns a slice containing all generic family variants.

Trait Implementations

impl CheckedBitPattern for GenericFamily

type Bits = u8

Self must have the same layout as the specified Bits except for the possible invalid bit patterns being checked during is_valid_bit_pattern.

fn is_valid_bit_pattern(bits: &u8) -> bool

If this function returns true, then it must be valid to reinterpret bits as &Self.

impl Clone for GenericFamily

fn clone(&self) -> GenericFamily

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Contiguous for GenericFamily

const MIN_VALUE: u8

The lower inclusive bound for valid instances of this type.

const MAX_VALUE: u8

The upper inclusive bound for valid instances of this type.

type Int = u8

The primitive integer type with an identical representation to this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl Debug for GenericFamily

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

Formats the value using the given formatter.

impl Display for GenericFamily

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

Formats the value using the given formatter.

impl From<GenericFamily> for FamilyName

fn from(gf: GenericFamily) -> Self

Converts to this type from the input type.

impl Hash for GenericFamily

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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 GenericFamily

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

fn zeroed() -> Self

Calls zeroed.

impl Copy for GenericFamily

impl Eq for GenericFamily

impl NoUninit for GenericFamily

impl StructuralPartialEq for GenericFamily