Functions — github.com/ReTeX/ReX

hub / github.com/ReTeX/ReX / functions

Functions222 in github.com/ReTeX/ReX

⨍ Functions 222◇ Types & classes 71

↓ 51 callersMethodscaled

(self, config: LayoutSettings)

src/layout/convert.rs:116

↓ 49 callersMethodadd_node

(&mut self, node: LayoutNode)

src/layout/builders.rs:19

↓ 41 callersMethodexpect

(&self, expected: Token<'a>)

src/lexer.rs:40

↓ 34 callersMethodnext

Advanced to the next token to be processed, and return it. This will also modify `Lexer.current`.

src/lexer.rs:96

↓ 29 callersFunctionglyph_metrics

(code: u32)

fonts/stix/src/lib.rs:19

↓ 18 callersMethodconsume_whitespace

If the current token being processed from the lexer is a `WhiteSpace` then continue to call `.next()` until `lex.current` is the first non-whitespace

src/lexer.rs:117

↓ 14 callersMethodas_layout

(&self, config: LayoutSettings)

src/layout/convert.rs:21

↓ 12 callersFunctionlayout

Entry point to our recursive algorithm

src/layout/engine.rs:21

↓ 11 callersMethodas_node

(self)

src/layout.rs:43

↓ 10 callersFunctionrequired_argument

This method expects to parse a single macro argument. A macro argument will consume a single token, unless the next token starts a group `{<expression

src/parser/engine.rs:274

↓ 8 callersMethodbuild

(mut self)

src/layout/builders.rs:29

↓ 8 callersFunctionkern_from

(gly: Glyph, height: FontUnit, side: Corner)

src/font/kerning.rs:72

↓ 8 callersMethodsettings

(&self)

src/render/svg.rs:48

↓ 8 callersMethodvert_variant

(&self, size: FontUnit)

src/font/variant.rs:18

↓ 8 callersMethodwith_family

(self, fam: Family)

fonts/types/src/lib.rs:136

↓ 7 callersMethodatom_type

(&self)

src/parser/nodes.rs:160

↓ 7 callersMethodis_symbol

(&self)

src/parser/nodes.rs:148

↓ 6 callersMethodcentered

(mut self, new_width: FontUnit)

src/layout.rs:77

↓ 5 callersMethodbbox

(&self, _out: &mut Self::Out, _pos: Cursor, _width: FontUnit, _height: FontUnit, _color: &str)

src/render.rs:131

↓ 5 callersFunctionis_symbol

(contents: &[ParseNode])

src/parser/nodes.rs:190

↓ 5 callersFunctionmatrix_with

(lex: &mut Lexer, style: Style, left_delimiter: char, right_delim

src/environments.rs:139

↓ 5 callersFunctionscale

(n: T, config: LayoutSettings)

src/layout/convert.rs:90

↓ 5 callersFunctionstyle_lookup

(lut: &[u32], codepoint: u32, style: Style)

fonts/stix/src/style.rs:89

↓ 5 callersFunctionstyle_lookup

(lut: &[u32], codepoint: u32, style: Style)

fonts/stix2/src/style.rs:89

↓ 5 callersMethodup

(self, dy: FontUnit)

src/render.rs:52

↓ 4 callersMethodcurrent_char

(&mut self)

src/lexer.rs:234

↓ 4 callersMethodexpect_symbol

(self, expected: char)

src/lexer.rs:52

↓ 4 callersFunctionexpression

This function is served as an entry point to parsing input. It can also be used to parse sub-expressions (or more formally known as `mathlists`) which

src/parser/engine.rs:70

↓ 4 callersFunctionmax_overlap

(left: FontUnit, right: &GlyphPart)

src/font/variant.rs:327

↓ 4 callersFunctionrequired_argument_with

This method is similar to `required_argument`, but instead uses a custom parser. For instance, `\color{#012345}{<expression>}` uses a custom parser to

src/parser/engine.rs:294

↓ 3 callersMethodadvance_while_whitespace

This method is the same as [consume_whitespace], except that it does not process the next token.

src/lexer.rs:127

↓ 3 callersFunctionis_symbol

(contents: &[LayoutNode])

src/layout.rs:247

↓ 3 callersMethodrender

(&self, tex: &str)

src/render.rs:264

↓ 3 callersMethodrender_to

(&self, out: &mut Self::Out, tex: &str)

src/render.rs:237

↓ 3 callersMethodset_offset

(&mut self, offset: FontUnit)

src/layout/builders.rs:25

↓ 3 callersFunctionsymbol

Parse a symbol. Symbols can be found from a TeX command (like `\infty`) or from a character input. Note: there are some `char` inputs that don't wor

src/parser/engine.rs:242

↓ 2 callersFunctionadvance_with_optional

Calculate the advance of the smallest variant with exactly one set of optional connectors. This returns a tuple: the first element states the advance

src/font/variant.rs:284

↓ 2 callersFunctionadvance_without_optional

(parts: &[GlyphPart])

src/font/variant.rs:312

↓ 2 callersMethodalphanumeric

Match a segment of alphanumeric characters. This method will return an empty string if there are no alphanumeric characters.

src/lexer.rs:195

↓ 2 callersFunctionarray_body

(lex: &mut Lexer, style: Style)

src/environments.rs:243

↓ 2 callersFunctioncollect_tests

(path: P)

tests/layout.rs:38

↓ 2 callersFunctionconstruct_glyphs

( parts: &[GlyphPart], repeats: u16, diff_ratio: FontUnit)

src/font/variant.rs:150

↓ 2 callersMethodcramped

(self)

src/layout.rs:278

↓ 2 callersMethoddepth

(&self)

fonts/types/src/lib.rs:100

↓ 2 callersMethoddimension

This method will parse a dimension. It assumes that the lexer is currently pointed to the first valid character in a dimension. So it may be necessa

src/lexer.rs:171

↓ 2 callersFunctiondispatch

(lay: &mut Layout, config: LayoutSettings, node: &ParseNode, next: AtomType)

src/layout/engine.rs:81

↓ 2 callersMethoddown

(self, dy: FontUnit)

src/render.rs:58

↓ 2 callersFunctionexpression_until_opt

(lex: &mut Lexer, local: Style, end: Option<Token>)

src/parser/engine.rs:14

↓ 2 callersMethodfinalize

(mut self)

src/layout.rs:71

↓ 2 callersMethodfont_size

(self, size: u16)

src/render.rs:85

↓ 2 callersMethodfont_src

(self, src: &str)

src/render.rs:91

↓ 2 callersMethodheight

(&self)

fonts/types/src/lib.rs:95

↓ 2 callersFunctionlayout_recurse

(nodes: &[ParseNode], mut config: LayoutSettings, parent_next: AtomType)

src/layout/engine.rs:27

↓ 2 callersFunctionmatrix_common

(lex: &mut Lexer, style: Style, left_delimiter: Option<char>,

src/environments.rs:147

↓ 2 callersMethodnext_char

(&mut self)

src/lexer.rs:224

↓ 2 callersMethodparse

(self, lex: &mut Lexer, local: Style)

src/functions.rs:49

↓ 2 callersMethodrender_hbox

(&self, out: &mut Self::Out, mut pos: Cursor, nodes:

src/render.rs:136

↓ 2 callersFunctionrender_styles

()

tests/style.rs:73

↓ 2 callersFunctionrender_tests

(tests: Tests)

tests/layout.rs:55

↓ 2 callersFunctionrequired_group_with

(lex: &mut Lexer, local: Style, f: F)

src/parser/engine.rs:311

↓ 2 callersMethodrule

(&self, out: &mut W, pos: Cursor, width: FontUnit, height: FontUnit)

src/render/svg.rs:112

↓ 2 callersMethodset_atom_type

(&mut self, at: AtomType)

src/parser/nodes.rs:134

↓ 2 callersFunctionstate_change

Theses commands may change the state of the parser. This includes font style and weight changes.

src/parser/engine.rs:138

↓ 2 callersMethodsubscript_variant

(self)

src/layout.rs:298

↓ 2 callersMethodsuperscript_variant

(self)

src/layout.rs:288

↓ 2 callersMethodsymbol

(&self, out: &mut W, pos: Cursor, symbol: u32, scale: Float)

src/render/svg.rs:92

↓ 2 callersFunctionwrite

(path: P, eqs: &[Equation])

tests/common/svg.rs:40

↓ 2 callersFunctionwrite_diff

(path: P, diff: Vec<(Equation, Equation)>)

tests/common/svg_diff.rs:107

↓ 2 callersFunctionwrite_objects

(f: &mut W, objects: &[Object])

tests/common/svg_diff.rs:66

↓ 1 callersFunctionaccent

(result: &mut Layout, acc: &Accent, config: LayoutSettings)

src/layout/engine.rs:131

↓ 1 callersFunctionarray

Parse an array environment. This method assumes that the lexer is currently positioned after the `\begin{array}` declaration.

src/environments.rs:277

↓ 1 callersFunctionarray

(result: &mut Layout, array: &Array, config: LayoutSettings)

src/layout/engine.rs:627

↓ 1 callersFunctionatom_change

(lex: &mut Lexer, local: Style, at: AtomType)

src/functions.rs:245

↓ 1 callersFunctionatom_space

(left: AtomType, right: AtomType, style: Style)

src/layout/spacing.rs:5

↓ 1 callersFunctioncodepoint_atom_type

Helper function for determining an atomtype based on a given codepoint. This is primarily used for characters while processing, so may give false nega

src/parser/engine.rs:404

↓ 1 callersFunctioncolor

(lex: &mut Lexer, local: Style)

src/functions.rs:201

↓ 1 callersMethodcolor

(&mut self)

src/lexer.rs:220

↓ 1 callersFunctioncolor_lit

(lex: &mut Lexer, local: Style, color: RGBA)

src/functions.rs:207

↓ 1 callersMethodcontrol_sequence

Lex a control sequence. This method assumes that `self.pos` points to the first character after `\`. The cursor will advance through the control sequ

src/lexer.rs:142

↓ 1 callersMethoddebug

(self, debug: bool)

src/render.rs:115

↓ 1 callersFunctiondelimited

(result: &mut Layout, delim: &Delimited, config: LayoutSettings)

src/layout/engine.rs:185

↓ 1 callersFunctiondelimiter_size

(lex: &mut Lexer, local: Style, _: u8, atom_type: AtomType)

src/functions.rs:232

↓ 1 callersMethoddenominator

(self)

src/layout.rs:349

↓ 1 callersMethodends_expression

(self)

src/lexer.rs:28

↓ 1 callersFunctionequation_diffs

(old: &[Equation], new: &[Equation])

tests/layout.rs:80

↓ 1 callersFunctionequation_diffs

(old: &[Equation], new: &[Equation])

tests/common/mod.rs:22

↓ 1 callersMethodexpect_command

(self, expected: &'static str)

src/lexer.rs:48

↓ 1 callersMethodexpect_left

(self)

src/parser/nodes.rs:108

↓ 1 callersMethodexpect_right

(self)

src/parser/nodes.rs:121

↓ 1 callersFunctionexpect_type

This method expects that the current token has a given atom type. This method will frist strip all whitespaces first before inspecting the current to

src/parser/engine.rs:351

↓ 1 callersFunctionexpression_until

(lex: &mut Lexer, local: Style, end: Token)

src/parser/engine.rs:63

↓ 1 callersMethodfinish

(&self, _out: &mut Self::Out)

src/render.rs:235

↓ 1 callersFunctionfrac

(result: &mut Layout, frac: &GenFraction, config: LayoutSettings)

src/layout/engine.rs:433

↓ 1 callersFunctionfraction

(lex: &mut Lexer, local: Style, left_delimiter: Option<Symbol>, right_deli

src/functions.rs:212

↓ 1 callersFunctiongreatest_lower_bound

Measure the _largest_ a glyph construction _smaller_ than the given size. If all constructions are larger than the given size, return `None`. Otherwis

src/font/variant.rs:236

↓ 1 callersMethodhas_alpha

(&self)

src/parser/color.rs:8

↓ 1 callersMethodhorz_variant

(&self, size: FontUnit)

src/font/variant.rs:64

↓ 1 callersMethodis_cramped

(&self)

src/layout.rs:334

↓ 1 callersMethodis_symbol

(&self)

src/layout.rs:83

↓ 1 callersFunctionkerning

(_: &mut Lexer, _: Style, unit: Unit)

src/functions.rs:237

next →1–100 of 222, ranked by callers