Enum zng::layout::TextSegmentKind

pub enum TextSegmentKind {
    LeftToRight,
    RightToLeft,
    ArabicLetter,
    EuropeanNumber,
    EuropeanSeparator,
    EuropeanTerminator,
    ArabicNumber,
    CommonSeparator,
    NonSpacingMark,
    BoundaryNeutral,
    Emoji,
    LineBreak,
    Tab,
    Space,
    OtherNeutral,
    Bracket(char),
    BidiCtrl(char),
}

The type of an inline/text segment.

Variants

LeftToRight

Any strong left-to-right character.

RightToLeft

Any strong right-to-left (non-Arabic-type) character.

ArabicLetter

Any strong right-to-left (Arabic-type) character.

EuropeanNumber

Any ASCII digit or Eastern Arabic-Indic digit.

EuropeanSeparator

Plus and minus signs.

EuropeanTerminator

A terminator in a numeric format context, includes currency signs.

ArabicNumber

Any Arabic-Indic digit.

CommonSeparator

Commas, colons, and slashes.

NonSpacingMark

Any non-spacing mark.

BoundaryNeutral

Most format characters, control codes, or non-characters.

Emoji

Emoji chars, components and zero-width-joiner between emoji.

LineBreak

Various newline characters.

Tab

A sequence of '\t', '\v' or '\u{1F}'.

Space

Spaces.

OtherNeutral

Most other symbols and punctuation marks.

Bracket(char)

Open or close bidi bracket.

Can be any chars in https://unicode.org/Public/UNIDATA/BidiBrackets.txt.

BidiCtrl(char)

Bidi control character.

Chars can be:

• \u{202A}: The LR embedding control.

• \u{202D}: The LR override control.

• \u{202B}: The RL embedding control.

• \u{202E}: The RL override control.

• \u{202C}: Terminates an embedding or override control.

• \u{2066}: The LR isolate control.

• \u{2067}: The RL isolate control.

• \u{2068}: The first strong isolate control.

• \u{2069}: Terminates an isolate control.

Implementations

impl TextSegmentKind

pub fn is_word(self) -> bool

Returns true if the segment can be considered part of a word for the purpose of inserting letter spacing.

pub fn is_space(self) -> bool

Returns true if the segment can be considered part of space between words for the purpose of inserting word spacing.

pub fn is_line_break(self) -> bool

Returns true if the segment terminates the current line.

Line break segments are the last segment of their line and explicitly start a new line.

pub fn can_merge(self) -> bool

If multiple segments of this same kind can be represented by a single segment in the Unicode bidi algorithm.

pub fn bracket_info(self) -> Option<BidiMatchedOpeningBracket>

Get more info about the bracket char if self is Bracket(_) with a valid char.

pub fn strong_direction(self) -> Option<LayoutDirection>

Gets the layout direction this segment will always be in, independent of the base direction.

Returns None if the segment direction depends on the line context.

Trait Implementations

impl Clone for TextSegmentKind

fn clone(&self) -> TextSegmentKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TextSegmentKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TextSegmentKind

fn deserialize<__D>( __deserializer: __D, ) -> Result<TextSegmentKind, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<BidiClass> for TextSegmentKind

fn from(value: BidiClass) -> TextSegmentKind

Converts to this type from the input type.

impl From<char> for TextSegmentKind

fn from(c: char) -> TextSegmentKind

Converts to this type from the input type.

impl Hash for TextSegmentKind

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 TextSegmentKind

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for TextSegmentKind

impl Eq for TextSegmentKind

impl StructuralPartialEq for TextSegmentKind