Struct Tbox 

pub struct Tbox {
    pub text: SymStr,
    pub font: Rc<Font>,
    pub locator: Option<Locator>,
    pub properties: SymHashMap<Stored>,
    pub tokens: Tokens,
}

Box is a Rust keyword, so we use “Tbox” instead, as in “TeX Box”

Fields

text: SymStr

plain-text content

font: Rc<Font>

associated font for text

locator: Option<Locator>

source location where the box originated (None = unknown)

properties: SymHashMap<Stored>

misc properties, such as sizing information

tokens: Tokens

a Tokens list containing the TeX that created (or could have) the Tbox.

Implementations

impl Tbox

pub fn new( text: SymStr, font_opt: Option<Rc<Font>>, locator_opt: Option<Locator>, tokens_opt: Tokens, properties: HashMap<Stored>, ) -> Self

creates a new Tbox. If font_opt or locator_opt are None, they are obtained from the currently active state? Note that text can be empty, which contributes nothing to the generated document, but does record the TeX code (in the tokens).

pub fn is_empty(&self) -> bool

checks if the text content is empty

pub fn is_math(&self) -> bool

Whether this box is in math mode. Perl: Box.pm::isMath (L79-81): ($mode || 'restricted_horizontal') =~ /math$/. Matches “math”, “inline_math”, “display_math”.

pub fn set_properties<I>(&mut self, entries: I)

where I: IntoIterator<Item = (&'static str, Stored)>,

Batch-insert properties. Equivalent to calling set_property for each entry, but avoids re-looking up the properties map per call. Perl: Box.pm::setProperties (L171-175).

pub fn total_height(&self) -> Dimension

height + depth of this box (the TeX “total height”). Returns Dimension::default() (0pt) when either component is absent. Perl: Box.pm::getTotalHeight (L202-210).

Trait Implementations

impl BoxOps for Tbox

fn get_tokens(&self) -> Option<&Tokens>

get the underlying tokens (preceding digestion)

fn get_properties(&self) -> &HashMap<Stored>

deprecated: get the map of named properties. This can not be usable as long as we have any data behind a RefCell wrapper. Use with_properties instead.

fn get_property(&self, key: &str) -> Option<Cow<'_, Stored>>

get a single named property (with special “isSpace” check)

fn with_properties<R, FnR>(&self, caller: FnR) -> R

where FnR: FnOnce(&HashMap<Stored>) -> R,

execute a function using this object’s named properties

fn get_properties_mut(&mut self) -> &mut HashMap<Stored>

get a mutable reference to the map of named properties

fn get_string(&self) -> Result<Cow<'_, str>>

build a string representation of the underlying digested data

fn be_absorbed(&self, document: &mut Document) -> Result<Vec<Node>>

absorb the current object into the Document XML - returning the corresponding nodes

fn get_font(&self) -> Result<Option<Rc<Font>>>

gets the associated font, if any

fn compute_size( &self, options: HashMap<Stored>, ) -> Result<(Dimension, Dimension, Dimension)>

computes and returns the size of a box-like object

fn unlist(&self) -> Vec<Digested>

If composite, unwrap into the contained digested objects (or return self)

fn unlist_ref(&self) -> Vec<Cow<'_, Digested>>

fn be_absorbed_mut(&mut self, _document: &mut Document) -> Result<Vec<Node>>

be_absorbed but with allowed side-effects on the carrier (for Alignment only)

fn set_property<T: Into<Stored>>(&mut self, key: &str, value: T)

set a named property (allows all Stored types for values)

fn get_property_string(&self, key: &str) -> String

fn get_property_mut(&mut self, key: &str) -> Option<&mut Stored>

get a mutable reference to a single named property (does NOT have the “isSpace” check)

fn has_property(&self, key: &str) -> bool

checks if a property key has been set

fn get_property_bool(&self, key: &str) -> bool

obtains a boolean property value (false unless Stored::Bool)

fn get_body(&self) -> Result<Option<Digested>>

obtains the “body” of a digested object which captured it

fn set_font(&mut self, _font: Rc<Font>)

sets an associated font

fn set_width<T: Into<Stored>>(&mut self, width: T)

sets a “width” property, for sizing

fn get_width( &self, options: Option<HashMap<Stored>>, ) -> Result<Option<RegisterValue>>

gets the “width” property value, if any

fn set_height<T: Into<Stored>>(&mut self, width: T)

sets a “height” property value, for sizing

fn get_height(&self) -> Option<RegisterValue>

gets the “height” property value, if any. Checks “height”, then “cached_height”, then computes from font if needed.

fn set_depth<T: Into<Stored>>(&mut self, width: T)

sets a “depth” property value, for sizing

fn get_depth(&self) -> Option<RegisterValue>

gets the “depth” property value, if any. Checks “depth”, then “cached_depth”, then computes from font if needed.

fn get_size( &mut self, options: Option<HashMap<Stored>>, ) -> Result<(Dimension, Dimension, Dimension, Dimension, Dimension, Dimension)>

gets the box size as a triple of (width, height, depth) the generic implementation is immutable and will recompute the size on each call see Digested::get_size for a variant with interior mutability which caches the box size

fn compute_size_and_cache( &mut self, options: HashMap<Stored>, ) -> Result<(Dimension, Dimension, Dimension)>

computes and caches (via named properties) the size of a box-like object. Perl #2798 (S5, padding slice): after computing the size, add any requested pad{top,bottom,left,right} to the computed dimensions. This is the SAFE part of computeSizeStore — additive and inert until the app layer sets a pad* property (display math \abovedisplayskip/\belowdisplayskip, \overline/\underline 2pt, items/equations). The riskier requested-vs- computed merge + full-spec bypass + isEmpty are deliberately NOT included here — a mechanical port of those regressed (Rust boxes don’t use width/height/depth uniformly as “requested box size”); see SYNC_STATUS U2.

impl Clone for Tbox

fn clone(&self) -> Tbox

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tbox

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

Formats the value using the given formatter.

impl Default for Tbox

fn default() -> Self

Returns the “default value” for a type.

impl Display for Tbox

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

Formats the value using the given formatter.

impl From<Tbox> for Digested

fn from(value: Tbox) -> Digested

Converts to this type from the input type.

impl From<Tbox> for Result<Vec<Digested>>

fn from(tbox: Tbox) -> Result<Vec<Digested>>

Converts to this type from the input type.

impl From<Tbox> for Option<Digested>

fn from(tbox: Tbox) -> Option<Digested>

Converts to this type from the input type.

impl IntoDigestedResult<Result<Vec<Digested>, Error>> for Tbox

fn into_digested_result(self) -> Result<Vec<Digested>>

Performs the conversion, used for DefPrimitive return values etc

impl Object for Tbox

fn get_locator(&self) -> Option<Locator>

The object’s stored source locator, if it has one. None is the honest “no recorded source position” (replacing the old Locator::default() file!()/line!() sentinel). For “where the parser is now” (error reporting, box creation), use the free fn gullet::get_locator().

fn revert(&self) -> Result<Tokens>

each concrete object needs to provide its own path back to tokens

fn stringify(&self) -> String

fn isa_box(&self) -> bool

fn is_expandable(&self) -> bool

fn is_definition(&self) -> bool

fn is_comment(&self) -> bool

fn be_digested(self) -> Result<Digested>

where Self: Sized + Debug,

impl PartialEq for Tbox

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.