sklad/bdf/bdf.go

356 lines
8.8 KiB
Go

package bdf
import (
"bufio"
"encoding/hex"
"fmt"
"image"
"image/color"
"image/draw"
"io"
"strconv"
)
// glyph is a singular bitmap glyph to be used as a mask, assumed to directly
// correspond to a rune. A zero value is also valid and drawable.
type glyph struct {
// Coordinates are relative to the origin, on the baseline.
// The ascent is thus negative, unlike the usual model.
bounds image.Rectangle
bitmap []byte
advance int
}
// ColorModel implements image.Image.
func (g *glyph) ColorModel() color.Model { return color.Alpha16Model }
// Bounds implements image.Image.
func (g *glyph) Bounds() image.Rectangle { return g.bounds }
// At implements image.Image. This is going to be somewhat slow.
func (g *glyph) At(x, y int) color.Color {
x -= g.bounds.Min.X
y -= g.bounds.Min.Y
dx, dy := g.bounds.Dx(), g.bounds.Dy()
if x < 0 || y < 0 || x >= dx || y >= dy {
return color.Transparent
}
stride, offset, bit := (dx+7)/8, x/8, byte(1<<uint(7-x%8))
if g.bitmap[y*stride+offset]&bit == 0 {
return color.Transparent
}
return color.Opaque
}
// -----------------------------------------------------------------------------
// Font represents a particular bitmap font.
type Font struct {
Name string
Ascent int // needn't be present in the font
Descent int // needn't be present in the font
glyphs map[rune]glyph
fallback glyph
}
// FindGlyph returns the best glyph to use for the given rune.
// The returned boolean indicates whether a fallback has been used.
func (f *Font) FindGlyph(r rune) (glyph, bool) {
if g, ok := f.glyphs[r]; ok {
return g, true
}
return f.fallback, false
}
// DrawString draws the specified text string onto dst horizontally along
// the baseline starting at dp, using black color.
func (f *Font) DrawString(dst draw.Image, dp image.Point,
color color.Color, s string) {
src := image.NewUniform(color)
for _, r := range s {
g, _ := f.FindGlyph(r)
draw.DrawMask(dst, g.bounds.Add(dp),
src, image.ZP, &g, g.bounds.Min, draw.Over)
dp.X += g.advance
}
}
// BoundString measures the text's bounds when drawn along the X axis
// for the baseline. Also returns the total advance.
func (f *Font) BoundString(s string) (image.Rectangle, int) {
var (
bounds image.Rectangle
dot image.Point
)
for _, r := range s {
g, _ := f.FindGlyph(r)
bounds = bounds.Union(g.bounds.Add(dot))
dot.X += g.advance
}
return bounds, dot.X
}
// -----------------------------------------------------------------------------
func latin1ToUTF8(latin1 []byte) string {
buf := make([]rune, len(latin1))
for i, b := range latin1 {
buf[i] = rune(b)
}
return string(buf)
}
// tokenize splits a BDF line into tokens. Quoted strings may start anywhere
// on the line. We only enforce that they must end somewhere.
func tokenize(s string) (tokens []string, err error) {
token, quotes, escape := []rune{}, false, false
for _, r := range s {
switch {
case escape:
switch r {
case '"':
escape = false
token = append(token, r)
case ' ', '\t':
quotes, escape = false, false
tokens = append(tokens, string(token))
token = nil
default:
quotes, escape = false, false
token = append(token, r)
}
case quotes:
switch r {
case '"':
escape = true
default:
token = append(token, r)
}
default:
switch r {
case '"':
// We could also enable quote processing on demand,
// so that it is only turned on in properties.
if len(tokens) < 1 || tokens[0] != "COMMENT" {
quotes = true
} else {
token = append(token, r)
}
case ' ', '\t':
if len(token) > 0 {
tokens = append(tokens, string(token))
token = nil
}
default:
token = append(token, r)
}
}
}
if quotes && !escape {
return nil, fmt.Errorf("strings may not contain newlines")
}
if quotes || len(token) > 0 {
tokens = append(tokens, string(token))
}
return tokens, nil
}
// -----------------------------------------------------------------------------
// bdfParser is a basic and rather lenient parser of
// Bitmap Distribution Format (BDF) files.
type bdfParser struct {
scanner *bufio.Scanner // input reader
line int // current line number
tokens []string // tokens on the current line
font *Font // glyph storage
defaultBounds image.Rectangle
defaultAdvance int
defaultChar int
}
// readLine reads the next line and splits it into tokens.
// Panics on error, returns false if the end of file has been reached normally.
func (p *bdfParser) readLine() bool {
p.line++
if !p.scanner.Scan() {
if err := p.scanner.Err(); err != nil {
panic(err)
}
p.line--
return false
}
var err error
if p.tokens, err = tokenize(latin1ToUTF8(p.scanner.Bytes())); err != nil {
panic(err)
}
// Eh, it would be nicer iteratively, this may overrun the stack.
if len(p.tokens) == 0 {
return p.readLine()
}
return true
}
func (p *bdfParser) readIntegerArgument() int {
if len(p.tokens) < 2 {
panic("insufficient arguments")
}
if i, err := strconv.Atoi(p.tokens[1]); err != nil {
panic(err)
} else {
return i
}
}
// Some fonts even use -1 for things outside the encoding.
func (p *bdfParser) readCharEncoding() int { return p.readIntegerArgument() }
// XXX: Ignoring vertical advance since we only expect purely horizontal fonts.
func (p *bdfParser) readDwidth() int { return p.readIntegerArgument() }
func (p *bdfParser) parseProperties() {
// The wording in the specification suggests that the argument
// with the number of properties to follow isn't reliable.
for p.readLine() && p.tokens[0] != "ENDPROPERTIES" {
switch p.tokens[0] {
case "DEFAULT_CHAR":
p.defaultChar = p.readCharEncoding()
case "FONT_ASCENT":
p.font.Ascent = p.readIntegerArgument()
case "FONT_DESCENT":
p.font.Descent = p.readIntegerArgument()
}
}
}
func (p *bdfParser) readBBX() image.Rectangle {
if len(p.tokens) < 5 {
panic("insufficient arguments")
}
w, e1 := strconv.Atoi(p.tokens[1])
h, e2 := strconv.Atoi(p.tokens[2])
x, e3 := strconv.Atoi(p.tokens[3])
y, e4 := strconv.Atoi(p.tokens[4])
if e1 != nil || e2 != nil || e3 != nil || e4 != nil {
panic("invalid arguments")
}
if w < 0 || h < 0 {
panic("bounding boxes may not have negative dimensions")
}
return image.Rectangle{
Min: image.Point{x, -(y + h)},
Max: image.Point{x + w, -y},
}
}
func (p *bdfParser) parseChar() {
g := glyph{bounds: p.defaultBounds, advance: p.defaultAdvance}
bitmap, rows, encoding := false, 0, -1
for p.readLine() && p.tokens[0] != "ENDCHAR" {
if bitmap {
b, err := hex.DecodeString(p.tokens[0])
if err != nil {
panic(err)
}
if len(b) != (g.bounds.Dx()+7)/8 {
panic("invalid bitmap data, width mismatch")
}
g.bitmap = append(g.bitmap, b...)
rows++
} else {
switch p.tokens[0] {
case "ENCODING":
encoding = p.readCharEncoding()
case "DWIDTH":
g.advance = p.readDwidth()
case "BBX":
g.bounds = p.readBBX()
case "BITMAP":
bitmap = true
}
}
}
if rows != g.bounds.Dy() {
panic("invalid bitmap data, height mismatch")
}
// XXX: We don't try to convert encodings, since we'd need x/text/encoding
// for the conversion tables, though most fonts are at least going to use
// supersets of ASCII. Use ISO10646-1 X11 fonts for proper Unicode support.
if encoding >= 0 {
p.font.glyphs[rune(encoding)] = g
}
if encoding == p.defaultChar {
p.font.fallback = g
}
}
// https://en.wikipedia.org/wiki/Glyph_Bitmap_Distribution_Format
// https://www.adobe.com/content/dam/acom/en/devnet/font/pdfs/5005.BDF_Spec.pdf
func (p *bdfParser) parse() {
if !p.readLine() || len(p.tokens) != 2 || p.tokens[0] != "STARTFONT" {
panic("invalid header")
}
if p.tokens[1] != "2.1" && p.tokens[1] != "2.2" {
panic("unsupported version number")
}
for p.readLine() && p.tokens[0] != "ENDFONT" {
switch p.tokens[0] {
case "FONT":
if len(p.tokens) < 2 {
panic("insufficient arguments")
}
p.font.Name = p.tokens[1]
case "FONTBOUNDINGBOX":
// There's no guarantee that this includes all BBXs.
p.defaultBounds = p.readBBX()
case "METRICSSET":
if len(p.tokens) < 2 {
panic("insufficient arguments")
}
if p.tokens[1] == "1" {
panic("purely vertical fonts are unsupported")
}
case "DWIDTH":
p.defaultAdvance = p.readDwidth()
case "STARTPROPERTIES":
p.parseProperties()
case "STARTCHAR":
p.parseChar()
}
}
if p.font.Name == "" {
panic("the font file doesn't contain the font's name")
}
if len(p.font.glyphs) == 0 {
panic("the font file doesn't seem to contain any glyphs")
}
}
func NewFromBDF(r io.Reader) (f *Font, err error) {
p := bdfParser{
scanner: bufio.NewScanner(r),
font: &Font{glyphs: make(map[rune]glyph)},
defaultChar: -1,
}
defer func() {
if r := recover(); r != nil {
var ok bool
if err, ok = r.(error); !ok {
err = fmt.Errorf("%v", r)
}
}
if err != nil {
err = fmt.Errorf("line %d: %s", p.line, err)
}
}()
p.parse()
return p.font, nil
}