textmeasure

type MarkdownColorRole ¶ added in v0.9.0

type MarkdownColorRole string

MarkdownColorRole is a semantic Markdown color. It mirrors the roles used by github-markdown.css without coupling text measurement to a D2 theme.

const (
	MarkdownColorNone             MarkdownColorRole = ""
	MarkdownColorForeground       MarkdownColorRole = "foreground"
	MarkdownColorForegroundStroke MarkdownColorRole = "foreground-stroke"
	MarkdownColorMuted            MarkdownColorRole = "muted"
	MarkdownColorMutedStroke      MarkdownColorRole = "muted-stroke"
	MarkdownColorAccent           MarkdownColorRole = "accent"
	MarkdownColorBorder           MarkdownColorRole = "border"
	MarkdownColorBorderMuted      MarkdownColorRole = "border-muted"
	MarkdownColorCanvas           MarkdownColorRole = "canvas"
	MarkdownColorCanvasSubtle     MarkdownColorRole = "canvas-subtle"
	MarkdownColorNeutralMuted     MarkdownColorRole = "neutral-muted"
)

type MarkdownFontRole ¶ added in v0.9.0

type MarkdownFontRole string

MarkdownFontRole lets an SVG renderer select the correct embedded D2 font. Font sizes are kept separately on each primitive.

const (
	MarkdownFontRegular      MarkdownFontRole = "regular"
	MarkdownFontSemibold     MarkdownFontRole = "semibold"
	MarkdownFontBold         MarkdownFontRole = "bold"
	MarkdownFontItalic       MarkdownFontRole = "italic"
	MarkdownFontMono         MarkdownFontRole = "mono"
	MarkdownFontMonoSemibold MarkdownFontRole = "mono-semibold"
	MarkdownFontMonoBold     MarkdownFontRole = "mono-bold"
	MarkdownFontMonoItalic   MarkdownFontRole = "mono-italic"
)

type MarkdownLayout ¶ added in v0.9.0

type MarkdownLayout struct {
	Width, Height int
	Primitives    []MarkdownPrimitive
	// Corpus contains the visible source text used by the primitives. Renderers
	// embedding subset fonts should include it.
	Corpus string
}

MarkdownLayout contains the exact dimensions used by D2 layout and the positioned primitives used to paint those dimensions. MeasureMarkdown calls LayoutMarkdown, ensuring measurement and rendering share one code path.

func LayoutMarkdown(mdText string, ruler *Ruler, fontFamily *d2fonts.FontFamily, monoFontFamily *d2fonts.FontFamily, fontSize int) (*MarkdownLayout, error)

func (l *MarkdownLayout) SVG(opts MarkdownSVGOptions) string

type MarkdownPrimitive ¶ added in v0.9.0

type MarkdownPrimitive struct {
	Kind MarkdownPrimitiveKind

	X, Y, X2, Y2        float64
	Width, Height       float64
	Radius, StrokeWidth float64

	Text       string
	Font       MarkdownFontRole
	FontSize   float64
	FillRole   MarkdownColorRole
	StrokeRole MarkdownColorRole
	Link       string
	LinkTitle  string
	Decoration MarkdownTextDecoration
	// SyntheticBold/SyntheticItalic preserve inherited CSS axes when the
	// innermost Markdown element selects a different concrete D2 font family.
	// For example, em > strong uses the bold face with a synthetic slant, while
	// strong > em uses the italic face with synthetic weight.
	SyntheticBold   bool
	SyntheticItalic bool
	// TextLength fits the glyphs to Width. CSS paints a discretionary soft
	// hyphen at one third of an em even inside D2's monospace code face.
	TextLength bool
}

MarkdownPrimitive is a serializer-neutral native SVG drawing operation.

Text uses X/Y as the baseline origin and Width/Height as its measured box. Rect uses X/Y/Width/Height/Radius. Line uses X/Y and X2/Y2. FillRole and StrokeRole are semantic so light/dark themes can serialize the same layout.

type MarkdownPrimitiveKind ¶ added in v0.9.0

type MarkdownPrimitiveKind string

MarkdownPrimitiveKind identifies the kind of native SVG primitive in a MarkdownLayout. The layout package intentionally does not choose concrete colors so that renderers can map the semantic roles to their active theme.

const (
	MarkdownTextPrimitive MarkdownPrimitiveKind = "text"
	MarkdownRectPrimitive MarkdownPrimitiveKind = "rect"
	MarkdownLinePrimitive MarkdownPrimitiveKind = "line"
)

type MarkdownSVGOptions ¶ added in v0.9.0

type MarkdownSVGOptions struct {
	Class       string
	RolePaint   map[MarkdownColorRole]MarkdownSVGPaint
	FontClasses map[MarkdownFontRole]string
	// DisableLinks emits linked text without inner <a> elements. d2svg uses
	// this when a Markdown label is already wrapped by a shape/connection link.
	DisableLinks bool
	// Underline applies D2's style.underline to every Markdown text primitive.
	Underline bool
}

MarkdownSVGOptions controls native SVG serialization without affecting layout. A renderer can override role paints and font classes to match its theme/font embedding scheme.

type MarkdownSVGPaint ¶ added in v0.9.0

type MarkdownSVGPaint struct {
	Class string
	Color string
}

MarkdownSVGPaint controls how a semantic role is emitted by SVG. Class is optional; Color is an SVG paint value such as "currentColor", "#fff", or a CSS variable.

type MarkdownTextDecoration ¶ added in v0.9.0

type MarkdownTextDecoration string

const (
	MarkdownTextDecorationNone        MarkdownTextDecoration = ""
	MarkdownTextDecorationLineThrough MarkdownTextDecoration = "line-through"
)

type Ruler ¶

type Ruler struct {
	// Orig specifies the text origin, usually the top-left dot position. Dot is always aligned
	// to Orig when writing newlines.
	Orig *geo.Point

	// Dot is the position where the next character will be written. Dot is automatically moved
	// when writing to a Ruler object, but you can also manipulate it manually
	Dot *geo.Point

	// lineHeight is the vertical distance between two lines of text.
	//
	// Example:
	//   txt.lineHeight = 1.5 * txt.atlas.lineHeight
	LineHeightFactor float64
	// contains filtered or unexported fields
}

Ruler allows for effiecient and convenient text drawing.

To create a Ruler object, use the New constructor:

txt := text.New(pixel.ZV, text.NewAtlas(face, text.ASCII))

As suggested by the constructor, a Ruler object is always associated with one font face and a fixed set of runes. For example, the Ruler we created above can draw text using the font face contained in the face variable and is capable of drawing ASCII characters.

Here we create a Ruler object which can draw ASCII and Katakana characters:

txt := text.New(0, text.NewAtlas(face, text.ASCII, text.RangeTable(unicode.Katakana)))

Similarly to IMDraw, Ruler functions as a buffer. It implements io.Writer interface, so writing text to it is really simple:

fmt.Print(txt, "Hello, world!")

Newlines, tabs and carriage returns are supported.

Finally, if we want the written text to show up on some other Target, we can draw it:

txt.Draw(target)

Ruler exports two important fields: Orig and Dot. Dot is the position where the next character will be written. Dot is automatically moved when writing to a Ruler object, but you can also manipulate it manually. Orig specifies the text origin, usually the top-left dot position. Dot is always aligned to Orig when writing newlines. The Clear method resets the Dot to Orig.

func NewRuler() (*Ruler, error)

ttf, err := parseFont(goregular.TTF)
if err != nil {
    panic(err)
}
face := ttf.newFace(14)
txt := text.New(orig, text.NewAtlas(face, text.ASCII))

func (r *Ruler) HasFontFamilyLoaded(fontFamily *d2fonts.FontFamily) bool

func (t *Ruler) Measure(font d2fonts.Font, s string) (width, height int)

func (t *Ruler) MeasureMono(font d2fonts.Font, s string) (width, height int)

func (t *Ruler) MeasurePrecise(font d2fonts.Font, s string) (width, height float64)