Struct cosmic_text::Attrs

source ·

pub struct Attrs<'a> {
    pub color_opt: Option<Color>,
    pub family: Family<'a>,
    pub monospaced: bool,
    pub stretch: Stretch,
    pub style: Style,
    pub weight: Weight,
    pub metadata: usize,
}

Expand description

Text attributes

Fields§

§color_opt: Option<Color>§family: Family<'a>§monospaced: bool§stretch: Stretch§style: Style§weight: Weight§metadata: usize

Implementations§

source §

impl<'a> Attrs<'a>

source

pub fn new() -> Self

Create a new set of attributes with sane defaults

This defaults to a regular Sans-Serif font.

Examples found in repository ?

src/buffer.rs (line 177)

    pub fn new(
        font_system: &'a FontSystem,
        metrics: Metrics,
    ) -> Self {
        let mut buffer = Self {
            font_system,
            lines: Vec::new(),
            metrics,
            width: 0,
            height: 0,
            scroll: 0,
            redraw: false,
        };
        buffer.set_text("", Attrs::new());
        buffer
    }

source

pub fn color(self, color: Color) -> Self

Set Color

source

pub fn family(self, family: Family<'a>) -> Self

Set Family

source

pub fn monospaced(self, monospaced: bool) -> Self

Set monospaced

source

pub fn metadata(self, metadata: usize) -> Self

Set metadata

source

pub fn matches(&self, face: &FaceInfo) -> bool

Check if font matches

Examples found in repository ?

src/font/system/std.rs (line 100)

    pub fn get_font_matches<'a>(&'a self, attrs: Attrs) -> Arc<FontMatches<'a>> {
        self.0.with(|fields| {
            let mut font_matches_cache = fields.font_matches_cache.lock().expect("failed to lock font matches cache");
            //TODO: do not create AttrsOwned unless entry does not already exist
            font_matches_cache.entry(AttrsOwned::new(attrs)).or_insert_with(|| {
                let now = std::time::Instant::now();

                let mut fonts = Vec::new();
                for face in fields.db.faces() {
                    if !attrs.matches(face) {
                        continue;
                    }

                    if let Some(font) = get_font(&fields, face.id) {
                        fonts.push(font);
                    }
                }

                let font_matches = Arc::new(FontMatches {
                    locale: fields.locale,
                    default_family: fields.db.family_name(&attrs.family).to_string(),
                    fonts
                });

                let elapsed = now.elapsed();
                log::debug!("font matches for {:?} in {:?}", attrs, elapsed);

                font_matches
            }).clone()
        })
    }

source

pub fn compatible(&self, other: &Self) -> bool

Check if this set of attributes can be shaped with another

Examples found in repository ?

src/shape.rs (line 310)

    pub fn new<'a>(
        font_system: &'a FontSystem,
        line: &str,
        attrs_list: &AttrsList,
        word_range: Range<usize>,
        level: unicode_bidi::Level,
        blank: bool,
    ) -> Self {
        let word = &line[word_range.clone()];

        log::trace!(
            "      Word{}: '{}'",
            if blank { " BLANK" } else { "" },
            word
        );

        let mut glyphs = Vec::new();
        let span_rtl = level.is_rtl();

        let mut start_run = word_range.start;
        let mut attrs = attrs_list.defaults();
        for (egc_i, _egc) in word.grapheme_indices(true) {
            let start_egc = word_range.start + egc_i;
            let attrs_egc = attrs_list.get_span(start_egc);
            if ! attrs.compatible(&attrs_egc) {
                //TODO: more efficient
                glyphs.append(&mut shape_run(
                    font_system,
                    line,
                    attrs_list,
                    start_run,
                    start_egc,
                    span_rtl
                ));

                start_run = start_egc;
                attrs = attrs_egc;
            }
        }
        if start_run < word_range.end {
            //TODO: more efficient
            glyphs.append(&mut shape_run(
                font_system,
                line,
                attrs_list,
                start_run,
                word_range.end,
                span_rtl
            ));
        }

        let mut x_advance = 0.0;
        let mut y_advance = 0.0;
        for glyph in &glyphs {
            x_advance += glyph.x_advance;
            y_advance += glyph.y_advance;
        }

        Self { blank, glyphs, x_advance, y_advance}
    }