Struct Run 

pub struct Run {

    pub text: String,
    pub role: String,
    pub bold: bool,
    pub italic: bool,
    pub underline: bool,
    pub strike: bool,
    pub sup: bool,
    pub sub: bool,
    pub src: u32,
    pub sel: bool,
    pub hl: Option<String>,
    pub hl_color: Option<String>,
    pub mark_color: Option<String>,
}

One maximal span of same-styled glyphs on a visual row — the unit the Swift renderer turns into a single styled attributed-string run.

Fields

text: String

The run’s text, glyphs concatenated in column order.

role: String

The glyph’s semantic role as a renderer class id: body, h1…h6, code, link, mark, list, quote, rule.

bold: bool

italic: bool

underline: bool

strike: bool

sup: bool

Raised off the baseline and drawn smaller — a footnote reference’s [1], or an author’s ^x^. Mutually exclusive with sub; core’s Baseline is one value, and these are its two non-default cases flattened to the flag shape the rest of this record is spelled in.

sub: bool

Lowered off the baseline and drawn smaller — an author’s ~x~.

src: u32

The byte offset in the source this run’s first glyph came from.

What a run means, as opposed to how it looks: a link role says a span is drawn as a link but not where it points, and the only way back to that is the source. A frontend drawing part of the document somewhere the caret isn’t — a footnote’s text in a popover — pairs this with LeafDoc::link_destination_at or LeafDoc::footnote_at to make those runs followable.

The alternative was for a frontend to count its way along the row’s text and ask LeafDoc::offset_for_pos, which means converting between three units that only agree on ASCII: this is a byte offset, the run’s text is characters, and a row’s column is a display cell (a wide CJK glyph is two). Handing the offset over is exact, O(1), and needs none of that.

0 for the runs of the source view, whose rows are split from raw text rather than laid out from glyphs.

sel: bool

Whether this run lies inside the active selection — so the renderer can paint a selection background without re-deriving it from offsets.

hl: Option<String>

The id of the host highlight covering this run, if one does — see LeafDoc::set_highlights. A highlight splits a run the way the selection does, so a wash begins and ends exactly on its bytes.

hl_color: Option<String>

That highlight’s rendering hint (#RRGGBB, or None for the theme’s default wash), carried beside the id so a renderer needs no lookup.

mark_color: Option<String>

The colour the author named on a mark run — "red", "orange", "yellow", "green", "blue", "purple", "brown" — or absent for a plain ==highlight== and for every other role.

A name, unlike hl_color’s #RRGGBB, and that is the difference between the two: a host highlight’s colour is the host’s own choice and arrives as a value to paint, while this one is the document’s word for it and the renderer picks the wash. It rides beside role rather than folding into it ("mark-red") so a renderer that knows nothing about colours still draws the run as the highlight it is.

Trait Implementations

impl<UT> ConvertError<UT> for Run

fn try_convert_unexpected_callback_error( e: UnexpectedUniFFICallbackError, ) -> Result<Self>

impl<UT> FfiConverter<UT> for Run

const TYPE_ID_META: MetadataBuffer

Type ID metadata, serialized into a MetadataBuffer.

type FfiType = RustBuffer

The low-level type used for passing values of this type over the FFI.

fn lower(v: Self) -> RustBuffer

Lower a rust value of the target type, into an FFI value of type Self::FfiType.

fn try_lift(buf: RustBuffer) -> Result<Self>

Lift a rust value of the target type, from an FFI value of type Self::FfiType.

fn write(obj: Self, buf: &mut Vec<u8>)

Write a rust value into a buffer, to send over the FFI in serialized form.

fn try_read(buf: &mut &[u8]) -> Result<Self>

Read a rust value from a buffer, received over the FFI in serialized form.

impl<UT> Lift<UT> for Run

type FfiType = <Run as FfiConverter<UT>>::FfiType

fn try_lift(v: Self::FfiType) -> Result<Self>

fn try_read(buf: &mut &[u8]) -> Result<Self>

fn try_lift_from_rust_buffer(v: RustBuffer) -> Result<Self, Error>

Convenience method

impl<UT> LiftRef<UT> for Run

type LiftType = Run

impl<UT> LiftReturn<UT> for Run

type ReturnType = <Run as Lift<UT>>::FfiType

FFI return type for trait interfaces

fn try_lift_successful_return(v: Self::ReturnType) -> Result<Self>

Lift a successfully returned value from a trait interface

fn lift_foreign_return( ffi_return: Self::ReturnType, call_status: RustCallStatus, ) -> Self

Lift a foreign returned value from a trait interface

fn lift_error(_buf: RustBuffer) -> Self

Lift a Rust value for a callback interface method error result

fn handle_callback_unexpected_error(e: UnexpectedUniFFICallbackError) -> Self

Lift a Rust value for an unexpected callback interface error

impl<UT> Lower<UT> for Run

type FfiType = <Run as FfiConverter<UT>>::FfiType

fn lower(obj: Self) -> Self::FfiType

fn write(obj: Self, buf: &mut Vec<u8>)

fn lower_into_rust_buffer(obj: Self) -> RustBuffer

Convenience method

impl<UT> LowerError<UT> for Run

fn lower_error(obj: Self) -> RustBuffer

Lower this value for scaffolding function return

impl<UT> LowerReturn<UT> for Run

type ReturnType = <Run as Lower<UT>>::FfiType

The type that should be returned by scaffolding functions for this type.

fn lower_return(v: Self) -> Result<Self::ReturnType, RustCallError>

Lower the return value from an scaffolding call

fn handle_failed_lift( error: LiftArgsError, ) -> Result<Self::ReturnType, RustCallError>

Lower the return value for failed argument lifts

impl<UT> TypeId<UT> for Run

const TYPE_ID_META: MetadataBuffer