mathtext

type Layout ¶

type Layout struct {
	// Runs are the pieces of text, each with its own font and position. There
	// is one per run of characters at one size; a superscript is a run of its
	// own because it is set smaller.
	Runs []Run
	// Rules are the filled rectangles notation is made of: a fraction bar, the
	// bar over a radical. They are rectangles rather than strokes because
	// that is what a rule is — a thin filled box — and it needs no line width,
	// cap or join to be decided somewhere else.
	Rules []ir.Rect

	Width           float32
	Ascent, Descent float32
}

Layout is a typeset label: the pieces of text to draw and the rules to fill, with the box they occupy.

Positions are relative to an origin on the baseline of the outermost row. Width, Ascent and Descent describe the whole expression, so that a caller can centre it, right-align it or stack it exactly as it would a text run — ir.TextMetrics carries the same three, and means the same thing by them.

func (l Layout) Empty() bool

func (l Layout) Metrics() ir.TextMetrics

type Measurer ¶

type Measurer interface {
	// Measure reports the metrics of a run. See [ir.Backend.Measure].
	Measure(run ir.TextRun) ir.TextMetrics
}

Measurer is the part of ir.Backend a typesetter is given: the ability to ask the font stack that will draw a run how wide it is.

type Plainer ¶

type Plainer interface {
	// Plain returns src with its notation written as readable text. ok is
	// false when there was no notation in it, in which case src is already
	// what to say.
	Plain(src string) (string, bool)
}

Plainer is implemented by a typesetter that can also write its notation as readable text.

A description that will be read aloud cannot contain markup: a screen reader asked to announce `$\frac{\sigma^2}{\sqrt{n}}$` says "dollar backslash frac". So a chart being described asks its typesetter for the same expression in words-and-characters, and falls back to the label as written when the typesetter has no opinion.

It is optional, like every other interface figure extends a type through: a typesetter that does not implement it is still a typesetter.

type Request ¶

type Request struct {
	// Src is the label as the caller wrote it, delimiters and all.
	Src string
	// Font is the font the surrounding text is set in. A typesetter picks its
	// own sizes and styles relative to it.
	Font ir.FontRef
	// Measurer measures a run in that font. It is the backend, so a
	// typesetter measures in the same place the text will be drawn.
	Measurer Measurer
}

Request is what Typesetter.Typeset is asked to set.

It is a struct rather than three parameters because a Typesetter is implemented outside this module and so never gains one, and because setting notation has more inputs than these three the day it needs them: a writing direction, a language, a size the caller wants the result to fit. ADR 0060 is the record.

type Run ¶

type Run struct {
	Text string
	Font ir.FontRef
	At   ir.Point
}

Run is one piece of text in a layout: what to draw, in what font, with its baseline start at At.

type TeXOption ¶

type TeXOption func(*tex)

TeXOption configures the built-in typesetter.

func Italic(on bool) TeXOption

func ScriptScale(f float64) TeXOption

type Typesetter ¶

type Typesetter interface {
	Typeset(req Request) (l Layout, ok bool)
}

Typesetter lays out a label that may contain notation.

It is given the whole label, not the notation inside it, so that a typesetter decides for itself what its delimiters are — TeX reads TeX's dollar signs, and another may read something else. A label with nothing to typeset in it returns ok false, and the caller draws it as ordinary text: that is the common case, and it must stay free.

A typesetter never fails a render. Notation it cannot parse comes back as ok false too, so the label is drawn exactly as it was written — which is what a reader needs in order to see what is wrong with it.

A Typesetter is implemented outside this module, so it never gains a method.

func TeX(opts ...TeXOption) Typesetter