Struct GlyphFlags 

pub struct GlyphFlags(/* private fields */);

Flags that describe the properties of a glyph.

Implementations

impl GlyphFlags

pub const UNSAFE_TO_BREAK: GlyphFlags

Indicates that if input text is broken at the beginning of the cluster this glyph is part of, then both sides need to be re-shaped, as the result might be different.

On the flip side, it means that when this flag is not present, then it’s safe to break the glyph-run at the beginning of this cluster, and the two sides represent the exact same result one would get if breaking input text at the beginning of this cluster and shaping the two sides separately. This can be used to optimize paragraph layout, by avoiding re-shaping of each line after line-breaking, or limiting the reshaping to a small piece around the breaking point only.

pub const UNSAFE_TO_CONCAT: GlyphFlags

Indicates that if input text is changed on one side of the beginning of the cluster this glyph is part of, then the shaping results for the other side might change. Note that the absence of this flag will NOT by itself mean that it IS safe to concat text. Only two pieces of text both of which clear of this flag can be concatenated safely.

This can be used to optimize paragraph layout, by avoiding re-shaping of each line after line-breaking, by limiting the reshaping to a small piece around the breaking position only, even if the breaking position carries the unsafe-to-break flag or when hyphenation or other text transformation happens at line-break position, in the following way:

1. Iterate back from the line-break position until the first cluster start position that is NOT unsafe-to-concat.
2. Shape the segment from there till the end of line.
3. Check whether the resulting glyph-run also is clear of the unsafe-to-concat at its start-of-text position; if it is, just splice it into place and the line is shaped; If not, move on to a position further back that is clear of unsafe-to-concat and retry from there, and repeat.

At the start of next line a similar algorithm can be implemented. That is:

1. Iterate forward from the line-break position until the first cluster start position that is NOT unsafe-to-concat.
2. Shape the segment from beginning of the line to that position.
3. Check whether the resulting glyph-run also is clear of the unsafe-to-concat at its end-of-text position; if it is, just splice it into place and the beginning is shaped; If not, move on to a position further forward that is clear of unsafe-to-concat and retry up to there, and repeat. A slight complication will arise in the implementation of the algorithm above, because while our buffer API has a way to return flags for position corresponding to start-of-text, there is currently no position corresponding to end-of-text. This limitation can be alleviated by shaping more text than needed and looking for unsafe-to-concat flag within text clusters. The unsafe-to-break flag will always imply this flag. To use this flag, you must enable the buffer flag BufferFlags::PRODUCE_UNSAFE_TO_CONCAT during shaping, otherwise the buffer flag will not be reliably produced.

pub const SAFE_TO_INSERT_TATWEEL: GlyphFlags

In scripts that use elongation (Arabic, Mongolian, Syriac, etc.), this flag signifies that it is safe to insert a U+0640 TATWEEL character before this cluster for elongation. This flag does not determine the script-specific elongation places, but only when it is safe to do the elongation without interrupting text shaping.

pub const ALL: GlyphFlags

All the currently defined flags.

pub const fn from_bits_truncate(bits: u32) -> GlyphFlags

Creates a GlyphFlags from the given bits, ignoring any bits that are not defined.

pub const fn to_bits(self) -> u32

Returns the underlying flag bits.

pub const fn is_unsafe_to_break(self) -> bool

Indicates that if input text is broken at the beginning of the cluster this glyph is part of, then both sides need to be re-shaped, as the result might be different.

See Self::UNSAFE_TO_BREAK for more details.

pub const fn is_unsafe_to_concat(self) -> bool

Indicates that if input text is changed on one side of the beginning of the cluster this glyph is part of, then the shaping results for the other side might change.

See Self::UNSAFE_TO_CONCAT for more details.

pub const fn is_safe_to_insert_tatweel(self) -> bool

In scripts that use elongation (Arabic, Mongolian, Syriac, etc.), this flag signifies that it is safe to insert a U+0640 TATWEEL character before this cluster for elongation.

See Self::SAFE_TO_INSERT_TATWEEL for more details.

pub const fn contains(self, other: GlyphFlags) -> bool

Returns true if all of the flags in other are contained within self.

pub const fn intersects(self, other: GlyphFlags) -> bool

Returns true if any of the flags in other are contained within self.

Trait Implementations

impl BitAnd for GlyphFlags

type Output = GlyphFlags

The resulting type after applying the & operator.

fn bitand(self, rhs: GlyphFlags) -> <GlyphFlags as BitAnd>::Output

Performs the & operation.

impl BitAndAssign for GlyphFlags

fn bitand_assign(&mut self, rhs: GlyphFlags)

Performs the &= operation.

impl BitOr for GlyphFlags

type Output = GlyphFlags

The resulting type after applying the | operator.

fn bitor(self, rhs: GlyphFlags) -> <GlyphFlags as BitOr>::Output

Performs the | operation.

impl BitOrAssign for GlyphFlags

fn bitor_assign(&mut self, rhs: GlyphFlags)

Performs the |= operation.

impl Clone for GlyphFlags

fn clone(&self) -> GlyphFlags

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GlyphFlags

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

Formats the value using the given formatter.

impl Hash for GlyphFlags

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 Not for GlyphFlags

type Output = GlyphFlags

The resulting type after applying the ! operator.

fn not(self) -> <GlyphFlags as Not>::Output

Performs the unary ! operation.

impl PartialEq for GlyphFlags

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

impl Eq for GlyphFlags

impl StructuralPartialEq for GlyphFlags