fonts

type BitmapFormat uint8

type BitmapSize struct {
	Height, Width uint16
	XPpem, YPpem  uint16
}

type Cmap interface {
	// Iter returns a new iterator over the cmap
	// Multiple iterators may be used over the same cmap
	// The returned interface is guaranteed not to be nil
	Iter() CmapIter

	// Lookup avoid the construction of a map and provides
	// an alternative when only few runes need to be fetched.
	// It returns a default value and false when no glyph is provided.
	Lookup(rune) (GID, bool)
}

type CmapEncoding uint8

type CmapIter interface {
	// Next returns true if the iterator still has data to yield
	Next() bool

	// Char must be called only when `Next` has returned `true`
	Char() (rune, GID)
}

type CmapSimple map[rune]GID

type Face interface {
	FaceMetadata
	FaceMetrics
	FaceRenderer
	Subsetter
}

type FaceDescription struct {
	Family string
}

type FaceID struct {
	File string // The filename or identifier of the font file.

	// The index of the face in a collection. It is always 0 for single font
	// files.
	Index uint16

	// For variable fonts, stores 1 + the instance index.
	// (0 to ignore variations).
	Instance uint16
}

type FaceMetadata interface {
	// Cmap returns the mapping between input character codes
	// and glyph ids. The returned encoding identifies which system is used
	// to describe characters.
	Cmap() (Cmap, CmapEncoding)

	// PostscriptInfo returns the Postscript information,
	// or false is not available.
	PostscriptInfo() (PSInfo, bool)

	// PostscriptName returns the PostscriptName of the font,
	// or an empty string.
	PostscriptName() string

	// LoadSummary fetches global details about the font.
	// Conceptually, this method just returns it receiver, but this enables lazy loading.
	LoadSummary() (FontSummary, error)

	// LoadBitmaps returns the available bitmap sizes, or an empty
	// slice for outline fonts.
	LoadBitmaps() []BitmapSize
}

type FaceMetrics interface {
	// Upem returns the units per em of the font file.
	// If not found, should return 1000 as fallback value.
	// This value is only relevant for scalable fonts.
	Upem() uint16

	// GlyphName returns the name of the given glyph, or an empty
	// string if the glyph is invalid or has no name.
	GlyphName(gid GID) string

	// LineMetric returns the metric identified by `metric` (in fonts units), or
	// false if the font does not provide such information.
	LineMetric(metric LineMetric) (float32, bool)

	// FontHExtents returns the extents of the font for horizontal text, or false
	// it not available, in font units.
	// `varCoords` (in normalized coordinates) is only useful for variable fonts.
	FontHExtents() (FontExtents, bool)

	// FontVExtents is the same as `FontHExtents`, but for vertical text.
	FontVExtents() (FontExtents, bool)

	// NominalGlyph returns the glyph used to represent the given rune,
	// or false if not found.
	NominalGlyph(ch rune) (GID, bool)

	// HorizontalAdvance returns the horizontal advance in font units. When no
	// data is available but the glyph index is valid, this method should return
	// a default value (the upem number for example). If the glyph is invalid it
	// should return 0. `coords` is used by variable fonts, and is specified in
	// normalized coordinates.
	HorizontalAdvance(gid GID) float32

	// VerticalAdvance is the same as `HorizontalAdvance`, but for vertical advance.
	VerticalAdvance(gid GID) float32

	// GlyphHOrigin fetches the (X,Y) coordinates of the origin (in font units)
	// for a glyph ID, for horizontal text segments. Returns `false` if not
	// available.
	GlyphHOrigin(GID) (x, y int32, found bool)

	// GlyphVOrigin is the same as `GlyphHOrigin`, but for vertical text segments.
	GlyphVOrigin(GID) (x, y int32, found bool)

	// GlyphExtents retrieve the extents for a specified glyph, of false, if not
	// available. `coords` is used by variable fonts, and is specified in
	// normalized coordinates. For bitmap glyphs, the closest resolution to
	// `xPpem` and `yPpem` is selected.
	GlyphExtents(glyph GID, xPpem, yPpem uint16) (GlyphExtents, bool)
}

type FaceRenderer interface {
	// GlyphData loads the glyph content, or return nil
	// if 'gid' is not supported.
	// For bitmap glyphs, the closest resolution to `xPpem` and `yPpem` is selected.
	GlyphData(gid GID, xPpem, yPpem uint16) GlyphData
}

type Faces = []Face

type FontDescriptor interface {
	// Family queries the font family name.
	Family() string

	// Aspect queries the visual properties of the font.
	// If not found, zero values should be returned.
	Aspect() (Style, Weight, Stretch)

	// AdditionalStyle returns a description of the style of the font,
	// including information not found by Aspect()
	AdditionalStyle() string

	// Cmap returns the Unicode to Glyph mapping
	LoadCmap() (Cmap, error)
}

type FontExtents struct {
	Ascender  float32 // Typographic ascender.
	Descender float32 // Typographic descender.
	LineGap   float32 // Suggested line spacing gap.
}

type FontLoader = func(file Resource) (Faces, error)

type FontSummary struct {
	Family           string
	Style            string
	IsItalic, IsBold bool

	HasScalableGlyphs, HasBitmapGlyphs, HasColorGlyphs bool
}

type GID uint32

type GlyphBitmap struct {
	// The actual image content, whose interpretation depends
	// on the Format field.
	Data          []byte
	Format        BitmapFormat
	Width, Height int // number of columns and rows
}

type GlyphData interface {
	// contains filtered or unexported methods
}

type GlyphExtents struct {
	XBearing float32 // Left side of glyph from origin
	YBearing float32 // Top side of glyph from origin
	Width    float32 // Distance from left to right side
	Height   float32 // Distance from top to bottom side
}

type GlyphOutline struct {
	Segments []Segment
}

type GlyphSVG struct {
	// The SVG image content, decompressed if needed.
	// The actual glyph description is an SVG element
	// with id="glyph<GID>" (as in id="glyph12"),
	// and several glyphs may share the same Source
	Source []byte

	// According to the specification, a fallback outline
	// should be specified for each SVG glyphs
	Outline GlyphOutline
}

type LineMetric uint8

type PSInfo struct {
	FontName    string // Postscript font name.
	FullName    string // full name of the font.
	FamilyName  string // family name of the font.
	Version     string // font program version identifier (optional)
	Notice      string // font name trademark or copyright notice (optional)
	Weight      string // Weight of the font: normal, bold, etc.
	ItalicAngle int    // italic angle of the font, usually 0. or negative.

	IsFixedPitch bool // true if all the characters have the same width.

	UnderlinePosition  int
	UnderlineThickness int
}

type Resource interface {
	Read([]byte) (int, error)
	ReadAt([]byte, int64) (int, error)
	Seek(int64, int) (int64, error)
}

type Segment struct {
	Op SegmentOp
	// Args is up to three (x, y) coordinates, depending on the operation. The Y
	// axis increases up.
	Args [3]SegmentPoint
}

type SegmentOp uint8

type SegmentPoint struct {
	X, Y float32 // expressed in fonts units
}

type SliceType interface {
	~string | ~int | ~float64 | GID
}

type SortByGID []GID

type Stretch float32

type Style uint8

type Subsetter interface {
	Subset(codepoints []GID) error
	WriteSubset(w io.Writer) error
	WidthsPDF() string
	CMapPDF() string
	AscenderPDF() int
	DescenderPDF() int
	CapHeightPDF() int
	BoundingBoxPDF() string
	FlagsPDF() int
	ItalicAnglePDF() int
	StemVPDF() int
	XHeightPDF() int
	NamePDF() string
}

type Weight float32