From eecb4e626fdb8a3398bf2a2edf370c6de479d06d Mon Sep 17 00:00:00 2001
From: Nigel Tao <nigeltao@golang.org>
Date: Mon, 10 Aug 2015 18:34:31 +1000
Subject: [PATCH 2/7] shiny/font: new package for drawing text on an image.

Package font defines an interface for font faces.

Other packages provide font face implementations. For example, a
truetype package (not part of this CL) would provide one based on .ttf
font files.

This CL also introduces the golang.org/x/exp/shiny/font/plan9font
package, a concrete implementation of the font.Face interface for the
Plan 9 bitmap font format.

Change-Id: Iead8914caaa58c7562b18a86b45002ae47486903
Reviewed-on: https://go-review.googlesource.com/13463
Reviewed-by: Rob Pike <r@golang.org>
---
 example/font/main.go        |  84 ++++++++
 font/font.go                | 114 +++++++++++
 font/plan9font/plan9font.go | 388 ++++++++++++++++++++++++++++++++++++
 3 files changed, 586 insertions(+)
 create mode 100644 example/font/main.go
 create mode 100644 font/font.go
 create mode 100644 font/plan9font/plan9font.go

diff --git a/example/font/main.go b/example/font/main.go
new file mode 100644
index 0000000..34b16f6
--- /dev/null
+++ b/example/font/main.go
@@ -0,0 +1,84 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+//
+// This build tag means that "go install golang.org/x/exp/shiny/..." doesn't
+// install this example program. Use "go run main.go" to run it.
+
+// Font is a basic example of using fonts.
+package main
+
+import (
+	"flag"
+	"image"
+	"image/color"
+	"image/draw"
+	"image/png"
+	"io/ioutil"
+	"log"
+	"os"
+
+	"golang.org/x/exp/shiny/font"
+	"golang.org/x/exp/shiny/font/plan9font"
+	"golang.org/x/image/math/fixed"
+)
+
+var (
+	subfont   = flag.String("subfont", "", `filename of the Plan 9 subfont file, such as "lucsans/lsr.14"`)
+	firstRune = flag.Int("firstrune", 0, "the Unicode code point of the first rune in the subfont file")
+)
+
+func pt(p fixed.Point26_6) image.Point {
+	return image.Point{
+		X: int(p.X+32) >> 6,
+		Y: int(p.Y+32) >> 6,
+	}
+}
+
+func main() {
+	flag.Parse()
+
+	// TODO: mmap the file.
+	if *subfont == "" {
+		flag.Usage()
+		log.Fatal("no subfont specified")
+	}
+	fontData, err := ioutil.ReadFile(*subfont)
+	if err != nil {
+		log.Fatal(err)
+	}
+	face, err := plan9font.ParseSubfont(fontData, rune(*firstRune))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	dst := image.NewRGBA(image.Rect(0, 0, 800, 100))
+	draw.Draw(dst, dst.Bounds(), image.Black, image.Point{}, draw.Src)
+
+	d := &font.Drawer{
+		Dst:  dst,
+		Src:  image.White,
+		Face: face,
+		Dot: fixed.Point26_6{
+			X: 20 << 6,
+			Y: 80 << 6,
+		},
+	}
+	dot0 := pt(d.Dot)
+	d.DrawString("The quick brown fox jumps over the lazy dog.")
+	dot1 := pt(d.Dot)
+
+	dst.SetRGBA(dot0.X, dot0.Y, color.RGBA{0xff, 0x00, 0x00, 0xff})
+	dst.SetRGBA(dot1.X, dot1.Y, color.RGBA{0x00, 0x00, 0xff, 0xff})
+
+	out, err := os.Create("out.png")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer out.Close()
+	if err := png.Encode(out, dst); err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/font/font.go b/font/font.go
new file mode 100644
index 0000000..7698772
--- /dev/null
+++ b/font/font.go
@@ -0,0 +1,114 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package font defines an interface for font faces, for drawing text on an
+// image.
+//
+// Other packages provide font face implementations. For example, a truetype
+// package would provide one based on .ttf font files.
+package font
+
+// TODO: move this from golang.org/x/exp to golang.org/x/image ??
+
+import (
+	"image"
+	"image/draw"
+	"io"
+
+	"golang.org/x/image/math/fixed"
+)
+
+// TODO: who is responsible for caches (glyph images, glyph indices, kerns)?
+// The Drawer or the Face?
+
+// Face is a font face. Its glyphs are often derived from a font file, such as
+// "Comic_Sans_MS.ttf", but a face has a specific size, style, weight and
+// hinting. For example, the 12pt and 18pt versions of Comic Sans are two
+// different faces, even if derived from the same font file.
+//
+// A Face is not safe for concurrent use by multiple goroutines, as its methods
+// may re-use implementation-specific caches and mask image buffers.
+//
+// To create a Face, look to other packages that implement specific font file
+// formats.
+type Face interface {
+	io.Closer
+
+	// Glyph returns the draw.DrawMask parameters (dr, mask, maskp) to draw r's
+	// glyph at the sub-pixel destination location dot. It also returns the new
+	// dot after adding the glyph's advance width. It returns !ok if the face
+	// does not contain a glyph for r.
+	//
+	// The contents of the mask image returned by one Glyph call may change
+	// after the next Glyph call. Callers that want to cache the mask must make
+	// a copy.
+	Glyph(dot fixed.Point26_6, r rune) (
+		newDot fixed.Point26_6, dr image.Rectangle, mask image.Image, maskp image.Point, ok bool)
+
+	// Kern returns the horizontal adjustment for the kerning pair (r0, r1). A
+	// positive kern means to move the glyphs further apart.
+	Kern(r0, r1 rune) fixed.Int26_6
+
+	// TODO: per-font and per-glyph Metrics.
+	// TODO: ColoredGlyph for various emoji?
+	// TODO: Ligatures? Shaping?
+}
+
+type MultiFace struct {
+	// TODO.
+}
+
+// TODO: Drawer.Layout or Drawer.Measure methods to measure text without
+// drawing?
+
+// Drawer draws text on a destination image.
+//
+// A Drawer is not safe for concurrent use by multiple goroutines, since its
+// Face is not.
+type Drawer struct {
+	// Dst is the destination image.
+	Dst draw.Image
+	// Src is the source image.
+	Src image.Image
+	// Face provides the glyph mask images.
+	Face Face
+	// Dot is the baseline location to draw the next glyph. The majority of the
+	// affected pixels will be above and to the right of the dot, but some may
+	// be below or to the left. For example, drawing a 'j' in an italic face
+	// may affect pixels below and to the left of the dot.
+	Dot fixed.Point26_6
+
+	// TODO: Clip image.Image?
+	// TODO: SrcP image.Point for Src images other than *image.Uniform? How
+	// does it get updated during DrawString?
+}
+
+// TODO: should DrawString return the last rune drawn, so the next DrawString
+// call can kern beforehand? Or should that be the responsibility of the caller
+// if they really want to do that, since they have to explicitly shift d.Dot
+// anyway?
+//
+// In general, we'd have a DrawBytes([]byte) and DrawRuneReader(io.RuneReader)
+// and the last case can't assume that you can rewind the stream.
+//
+// TODO: how does this work with line breaking: drawing text up until a
+// vertical line? Should DrawString return the number of runes drawn?
+
+// DrawString draws s at the dot and advances the dot's location.
+func (d *Drawer) DrawString(s string) {
+	var prevC rune
+	for i, c := range s {
+		if i != 0 {
+			d.Dot.X += d.Face.Kern(prevC, c)
+		}
+		newDot, dr, mask, maskp, ok := d.Face.Glyph(d.Dot, c)
+		if !ok {
+			// TODO: is falling back on the U+FFFD glyph the responsibility of
+			// the Drawer or the Face?
+			continue
+		}
+		draw.DrawMask(d.Dst, dr, d.Src, image.Point{}, mask, maskp, draw.Over)
+		d.Dot, prevC = newDot, c
+	}
+}
diff --git a/font/plan9font/plan9font.go b/font/plan9font/plan9font.go
new file mode 100644
index 0000000..3193ec7
--- /dev/null
+++ b/font/plan9font/plan9font.go
@@ -0,0 +1,388 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package plan9font implements font faces for the Plan 9 font file format.
+package plan9font
+
+// TODO: have a face use an *image.Alpha instead of plan9Image implementing the
+// image.Image interface? The image/draw code has a fast path for *image.Alpha
+// masks.
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"image"
+	"image/color"
+	"io"
+	"strings"
+
+	"golang.org/x/exp/shiny/font"
+	"golang.org/x/image/math/fixed"
+)
+
+// fontchar describes one character glyph in a subfont.
+//
+// For more detail, look for "struct Fontchar" in
+// http://plan9.bell-labs.com/magic/man2html/2/cachechars
+type fontchar struct {
+	x      uint32 // X position in the image holding the glyphs.
+	top    uint8  // First non-zero scan line.
+	bottom uint8  // Last non-zero scan line.
+	left   int8   // Offset of baseline.
+	width  uint8  // Width of baseline.
+}
+
+func parseFontchars(p []byte) []fontchar {
+	fc := make([]fontchar, len(p)/6)
+	for i := range fc {
+		fc[i] = fontchar{
+			x:      uint32(p[0]) | uint32(p[1])<<8,
+			top:    uint8(p[2]),
+			bottom: uint8(p[3]),
+			left:   int8(p[4]),
+			width:  uint8(p[5]),
+		}
+		p = p[6:]
+	}
+	return fc
+}
+
+// face implements font.Face.
+type face struct {
+	firstRune rune        // First rune in the subfont.
+	n         int         // Number of characters in the subfont.
+	height    int         // Inter-line spacing.
+	ascent    int         // Height above the baseline.
+	fontchars []fontchar  // Character descriptions.
+	img       *plan9Image // Image holding the glyphs.
+}
+
+func (f *face) Close() error                   { return nil }
+func (f *face) Kern(r0, r1 rune) fixed.Int26_6 { return 0 }
+
+func (f *face) Glyph(dot fixed.Point26_6, r rune) (
+	newDot fixed.Point26_6, dr image.Rectangle, mask image.Image, maskp image.Point, ok bool) {
+
+	r -= f.firstRune
+	if r < 0 || f.n <= int(r) {
+		return fixed.Point26_6{}, image.Rectangle{}, nil, image.Point{}, false
+	}
+	i := &f.fontchars[r+0]
+	j := &f.fontchars[r+1]
+
+	newDot = fixed.Point26_6{
+		X: dot.X + fixed.Int26_6(i.width)<<6,
+		Y: dot.Y,
+	}
+	minX := int(dot.X+32)>>6 + int(i.left)
+	minY := int(dot.Y+32)>>6 + int(i.top) - f.ascent
+	dr = image.Rectangle{
+		Min: image.Point{
+			X: minX,
+			Y: minY,
+		},
+		Max: image.Point{
+			X: minX + int(j.x-i.x),
+			Y: minY + int(i.bottom) - int(i.top),
+		},
+	}
+	return newDot, dr, f.img, image.Point{int(i.x), int(i.top)}, true
+}
+
+// ParseFont parses a Plan 9 font file.
+func ParseFont(data []byte, openFunc func(name string) (io.ReadCloser, error)) (*font.MultiFace, error) {
+	panic("TODO")
+}
+
+// ParseSubfont parses a Plan 9 subfont file.
+//
+// firstRune is the first rune in the subfont file. For example, the
+// Phonetic.6.0 subfont, containing glyphs in the range U+0250 to U+02E9, would
+// set firstRune to '\u0250'.
+func ParseSubfont(data []byte, firstRune rune) (font.Face, error) {
+	data, m, err := parseImage(data)
+	if err != nil {
+		return nil, err
+	}
+	if len(data) < 3*12 {
+		return nil, errors.New("plan9font: invalid subfont: header too short")
+	}
+	n := atoi(data[0*12:])
+	height := atoi(data[1*12:])
+	ascent := atoi(data[2*12:])
+	data = data[3*12:]
+	if len(data) != 6*(n+1) {
+		return nil, errors.New("plan9font: invalid subfont: data length mismatch")
+	}
+	return &face{
+		firstRune: firstRune,
+		n:         n,
+		height:    height,
+		ascent:    ascent,
+		fontchars: parseFontchars(data),
+		img:       m,
+	}, nil
+}
+
+// plan9Image implements that subset of the Plan 9 image feature set that is
+// used by this font file format.
+//
+// Some features, such as the repl bit and a clip rectangle, are omitted for
+// simplicity.
+type plan9Image struct {
+	depth int             // Depth of the pixels in bits.
+	width int             // Width in bytes of a single scan line.
+	rect  image.Rectangle // Extent of the image.
+	pix   []byte          // Pixel bits.
+}
+
+func (m *plan9Image) byteoffset(x, y int) int {
+	a := y * m.width
+	if m.depth < 8 {
+		// We need to always round down, but Go rounds toward zero.
+		np := 8 / m.depth
+		if x < 0 {
+			return a + (x-np+1)/np
+		}
+		return a + x/np
+	}
+	return a + x*(m.depth/8)
+}
+
+func (m *plan9Image) Bounds() image.Rectangle { return m.rect }
+func (m *plan9Image) ColorModel() color.Model { return color.AlphaModel }
+
+func (m *plan9Image) At(x, y int) color.Color {
+	if (image.Point{x, y}).In(m.rect) {
+		b := m.pix[m.byteoffset(x, y)]
+		switch m.depth {
+		case 1:
+			// CGrey, 1.
+			mask := uint8(1 << uint8(7-x&7))
+			if (b & mask) != 0 {
+				return color.Alpha{0xff}
+			}
+			return color.Alpha{0x00}
+		case 2:
+			// CGrey, 2.
+			shift := uint(x&3) << 1
+			// Place pixel at top of word.
+			y := b << shift
+			y &= 0xc0
+			// Replicate throughout.
+			y |= y >> 2
+			y |= y >> 4
+			return color.Alpha{y}
+		}
+	}
+	return color.Alpha{0x00}
+}
+
+var compressed = []byte("compressed\n")
+
+func parseImage(data []byte) (remainingData []byte, m *plan9Image, retErr error) {
+	if !bytes.HasPrefix(data, compressed) {
+		return nil, nil, errors.New("plan9font: unsupported uncompressed format")
+	}
+	data = data[len(compressed):]
+
+	const hdrSize = 5 * 12
+	if len(data) < hdrSize {
+		return nil, nil, errors.New("plan9font: invalid image: header too short")
+	}
+	hdr, data := data[:hdrSize], data[hdrSize:]
+
+	// Distinguish new channel descriptor from old ldepth. Channel descriptors
+	// have letters as well as numbers, while ldepths are a single digit
+	// formatted as %-11d.
+	new := false
+	for m := 0; m < 10; m++ {
+		if hdr[m] != ' ' {
+			new = true
+			break
+		}
+	}
+	if hdr[11] != ' ' {
+		return nil, nil, errors.New("plan9font: invalid image: bad header")
+	}
+	if !new {
+		return nil, nil, errors.New("plan9font: unsupported ldepth format")
+	}
+
+	depth := 0
+	switch s := strings.TrimSpace(string(hdr[:1*12])); s {
+	default:
+		return nil, nil, fmt.Errorf("plan9font: unsupported pixel format %q", s)
+	case "k1":
+		depth = 1
+	case "k2":
+		depth = 2
+	}
+	r := ator(hdr[1*12:])
+	if r.Min.X > r.Max.X || r.Min.Y > r.Max.Y {
+		return nil, nil, errors.New("plan9font: invalid image: bad rectangle")
+	}
+
+	width := bytesPerLine(r, depth)
+	m = &plan9Image{
+		depth: depth,
+		width: width,
+		rect:  r,
+		pix:   make([]byte, width*r.Dy()),
+	}
+
+	miny := r.Min.Y
+	for miny != r.Max.Y {
+		if len(data) < 2*12 {
+			return nil, nil, errors.New("plan9font: invalid image: data band too short")
+		}
+		maxy := atoi(data[0*12:])
+		nb := atoi(data[1*12:])
+		data = data[2*12:]
+
+		if len(data) < nb {
+			return nil, nil, errors.New("plan9font: invalid image: data band length mismatch")
+		}
+		buf := data[:nb]
+		data = data[nb:]
+
+		if maxy <= miny || r.Max.Y < maxy {
+			return nil, nil, fmt.Errorf("plan9font: bad maxy %d", maxy)
+		}
+		// An old-format image would flip the bits here, but we don't support
+		// the old format.
+		rr := r
+		rr.Min.Y = miny
+		rr.Max.Y = maxy
+		if err := decompress(m, rr, buf); err != nil {
+			return nil, nil, err
+		}
+		miny = maxy
+	}
+	return data, m, nil
+}
+
+// Compressed data are sequences of byte codes. If the first byte b has the
+// 0x80 bit set, the next (b^0x80)+1 bytes are data. Otherwise, these two bytes
+// specify a previous string to repeat.
+const (
+	compShortestMatch = 3    // shortest match possible.
+	compWindowSize    = 1024 // window size.
+)
+
+var (
+	errDecompressBufferTooSmall = errors.New("plan9font: decompress: buffer too small")
+	errDecompressPhaseError     = errors.New("plan9font: decompress: phase error")
+)
+
+func decompress(m *plan9Image, r image.Rectangle, data []byte) error {
+	if !r.In(m.rect) {
+		return errors.New("plan9font: decompress: bad rectangle")
+	}
+	bpl := bytesPerLine(r, m.depth)
+	mem := make([]byte, compWindowSize)
+	memi := 0
+	omemi := -1
+	y := r.Min.Y
+	linei := m.byteoffset(r.Min.X, y)
+	eline := linei + bpl
+	datai := 0
+	for {
+		if linei == eline {
+			y++
+			if y == r.Max.Y {
+				break
+			}
+			linei = m.byteoffset(r.Min.X, y)
+			eline = linei + bpl
+		}
+		if datai == len(data) {
+			return errDecompressBufferTooSmall
+		}
+		c := data[datai]
+		datai++
+		if c >= 128 {
+			for cnt := c - 128 + 1; cnt != 0; cnt-- {
+				if datai == len(data) {
+					return errDecompressBufferTooSmall
+				}
+				if linei == eline {
+					return errDecompressPhaseError
+				}
+				m.pix[linei] = data[datai]
+				linei++
+				mem[memi] = data[datai]
+				memi++
+				datai++
+				if memi == len(mem) {
+					memi = 0
+				}
+			}
+		} else {
+			if datai == len(data) {
+				return errDecompressBufferTooSmall
+			}
+			offs := int(data[datai]) + ((int(c) & 3) << 8) + 1
+			datai++
+			if memi < offs {
+				omemi = memi + (compWindowSize - offs)
+			} else {
+				omemi = memi - offs
+			}
+			for cnt := (c >> 2) + compShortestMatch; cnt != 0; cnt-- {
+				if linei == eline {
+					return errDecompressPhaseError
+				}
+				m.pix[linei] = mem[omemi]
+				linei++
+				mem[memi] = mem[omemi]
+				memi++
+				omemi++
+				if omemi == len(mem) {
+					omemi = 0
+				}
+				if memi == len(mem) {
+					memi = 0
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func ator(b []byte) image.Rectangle {
+	return image.Rectangle{atop(b), atop(b[2*12:])}
+}
+
+func atop(b []byte) image.Point {
+	return image.Pt(atoi(b), atoi(b[12:]))
+}
+
+func atoi(b []byte) int {
+	i := 0
+	for ; i < len(b) && b[i] == ' '; i++ {
+	}
+	n := 0
+	for ; i < len(b) && '0' <= b[i] && b[i] <= '9'; i++ {
+		n = n*10 + int(b[i]) - '0'
+	}
+	return n
+}
+
+func bytesPerLine(r image.Rectangle, depth int) int {
+	if depth <= 0 || 32 < depth {
+		panic("invalid depth")
+	}
+	var l int
+	if r.Min.X >= 0 {
+		l = (r.Max.X*depth + 7) / 8
+		l -= (r.Min.X * depth) / 8
+	} else {
+		// Make positive before divide.
+		t := (-r.Min.X*depth + 7) / 8
+		l = t + (r.Max.X*depth+7)/8
+	}
+	return l
+}

From e87ffe258cc601c14401f40382a54665841852cb Mon Sep 17 00:00:00 2001
From: Nigel Tao <nigeltao@golang.org>
Date: Tue, 11 Aug 2015 17:49:26 +1000
Subject: [PATCH 3/7] shiny/font/plan9font: implement ParseFont.

Also delete font.MultiFace. We can resurrect a font.MultiFace type if we
need it in the future, but for now, it's simpler if it lives in the
plan9font package.

Change-Id: I1493b47696c323424e7d91cb7fac15505bfdd023
Reviewed-on: https://go-review.googlesource.com/13520
Reviewed-by: Rob Pike <r@golang.org>
---
 example/font/main.go        |  67 ++++++++++------
 font/font.go                |   4 -
 font/plan9font/plan9font.go | 154 ++++++++++++++++++++++++++++++++----
 3 files changed, 184 insertions(+), 41 deletions(-)

diff --git a/example/font/main.go b/example/font/main.go
index 34b16f6..10909f4 100644
--- a/example/font/main.go
+++ b/example/font/main.go
@@ -19,6 +19,8 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
+	"path/filepath"
+	"strings"
 
 	"golang.org/x/exp/shiny/font"
 	"golang.org/x/exp/shiny/font/plan9font"
@@ -26,8 +28,9 @@ import (
 )
 
 var (
-	subfont   = flag.String("subfont", "", `filename of the Plan 9 subfont file, such as "lucsans/lsr.14"`)
-	firstRune = flag.Int("firstrune", 0, "the Unicode code point of the first rune in the subfont file")
+	fontFlag = flag.String("font", "",
+		`filename of the Plan 9 font or subfont file, such as "lucsans/unicode.8.font" or "lucsans/lsr.14"`)
+	firstRuneFlag = flag.Int("firstrune", 0, "the Unicode code point of the first rune in the subfont file")
 )
 
 func pt(p fixed.Point26_6) image.Point {
@@ -40,38 +43,56 @@ func pt(p fixed.Point26_6) image.Point {
 func main() {
 	flag.Parse()
 
-	// TODO: mmap the file.
-	if *subfont == "" {
+	// TODO: mmap the files.
+	if *fontFlag == "" {
 		flag.Usage()
-		log.Fatal("no subfont specified")
+		log.Fatal("no font specified")
 	}
-	fontData, err := ioutil.ReadFile(*subfont)
-	if err != nil {
-		log.Fatal(err)
-	}
-	face, err := plan9font.ParseSubfont(fontData, rune(*firstRune))
-	if err != nil {
-		log.Fatal(err)
+	var face font.Face
+	if strings.HasSuffix(*fontFlag, ".font") {
+		fontData, err := ioutil.ReadFile(*fontFlag)
+		if err != nil {
+			log.Fatal(err)
+		}
+		dir := filepath.Dir(*fontFlag)
+		face, err = plan9font.ParseFont(fontData, func(name string) ([]byte, error) {
+			return ioutil.ReadFile(filepath.Join(dir, filepath.FromSlash(name)))
+		})
+		if err != nil {
+			log.Fatal(err)
+		}
+	} else {
+		fontData, err := ioutil.ReadFile(*fontFlag)
+		if err != nil {
+			log.Fatal(err)
+		}
+		face, err = plan9font.ParseSubfont(fontData, rune(*firstRuneFlag))
+		if err != nil {
+			log.Fatal(err)
+		}
 	}
 
-	dst := image.NewRGBA(image.Rect(0, 0, 800, 100))
+	dst := image.NewRGBA(image.Rect(0, 0, 800, 300))
 	draw.Draw(dst, dst.Bounds(), image.Black, image.Point{}, draw.Src)
 
 	d := &font.Drawer{
 		Dst:  dst,
 		Src:  image.White,
 		Face: face,
-		Dot: fixed.Point26_6{
-			X: 20 << 6,
-			Y: 80 << 6,
-		},
 	}
-	dot0 := pt(d.Dot)
-	d.DrawString("The quick brown fox jumps over the lazy dog.")
-	dot1 := pt(d.Dot)
-
-	dst.SetRGBA(dot0.X, dot0.Y, color.RGBA{0xff, 0x00, 0x00, 0xff})
-	dst.SetRGBA(dot1.X, dot1.Y, color.RGBA{0x00, 0x00, 0xff, 0xff})
+	ss := []string{
+		"The quick brown fox jumps over the lazy dog.",
+		"Hello, 世界.",
+		"U+FFFD is \ufffd.",
+	}
+	for i, s := range ss {
+		d.Dot = fixed.P(20, 100*i+80)
+		dot0 := pt(d.Dot)
+		d.DrawString(s)
+		dot1 := pt(d.Dot)
+		dst.SetRGBA(dot0.X, dot0.Y, color.RGBA{0xff, 0x00, 0x00, 0xff})
+		dst.SetRGBA(dot1.X, dot1.Y, color.RGBA{0x00, 0x00, 0xff, 0xff})
+	}
 
 	out, err := os.Create("out.png")
 	if err != nil {
diff --git a/font/font.go b/font/font.go
index 7698772..b3647f5 100644
--- a/font/font.go
+++ b/font/font.go
@@ -55,10 +55,6 @@ type Face interface {
 	// TODO: Ligatures? Shaping?
 }
 
-type MultiFace struct {
-	// TODO.
-}
-
 // TODO: Drawer.Layout or Drawer.Measure methods to measure text without
 // drawing?
 
diff --git a/font/plan9font/plan9font.go b/font/plan9font/plan9font.go
index 3193ec7..35d6ee8 100644
--- a/font/plan9font/plan9font.go
+++ b/font/plan9font/plan9font.go
@@ -2,12 +2,14 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package plan9font implements font faces for the Plan 9 font file format.
+// Package plan9font implements font faces for the Plan 9 font and subfont file
+// formats. These formats are described at
+// http://plan9.bell-labs.com/magic/man2html/6/font
 package plan9font
 
-// TODO: have a face use an *image.Alpha instead of plan9Image implementing the
-// image.Image interface? The image/draw code has a fast path for *image.Alpha
-// masks.
+// TODO: have a subface use an *image.Alpha instead of plan9Image implementing
+// the image.Image interface? The image/draw code has a fast path for
+// *image.Alpha masks.
 
 import (
 	"bytes"
@@ -15,7 +17,8 @@ import (
 	"fmt"
 	"image"
 	"image/color"
-	"io"
+	"log"
+	"strconv"
 	"strings"
 
 	"golang.org/x/exp/shiny/font"
@@ -49,8 +52,8 @@ func parseFontchars(p []byte) []fontchar {
 	return fc
 }
 
-// face implements font.Face.
-type face struct {
+// subface implements font.Face for a Plan 9 subfont.
+type subface struct {
 	firstRune rune        // First rune in the subfont.
 	n         int         // Number of characters in the subfont.
 	height    int         // Inter-line spacing.
@@ -59,10 +62,10 @@ type face struct {
 	img       *plan9Image // Image holding the glyphs.
 }
 
-func (f *face) Close() error                   { return nil }
-func (f *face) Kern(r0, r1 rune) fixed.Int26_6 { return 0 }
+func (f *subface) Close() error                   { return nil }
+func (f *subface) Kern(r0, r1 rune) fixed.Int26_6 { return 0 }
 
-func (f *face) Glyph(dot fixed.Point26_6, r rune) (
+func (f *subface) Glyph(dot fixed.Point26_6, r rune) (
 	newDot fixed.Point26_6, dr image.Rectangle, mask image.Image, maskp image.Point, ok bool) {
 
 	r -= f.firstRune
@@ -91,9 +94,132 @@ func (f *face) Glyph(dot fixed.Point26_6, r rune) (
 	return newDot, dr, f.img, image.Point{int(i.x), int(i.top)}, true
 }
 
-// ParseFont parses a Plan 9 font file.
-func ParseFont(data []byte, openFunc func(name string) (io.ReadCloser, error)) (*font.MultiFace, error) {
-	panic("TODO")
+// runeRange maps a single rune range [lo, hi] to a lazily loaded subface. Both
+// ends of the range are inclusive.
+type runeRange struct {
+	lo, hi      rune
+	offset      rune // subfont index that the lo rune maps to.
+	relFilename string
+	subface     *subface
+	bad         bool
+}
+
+// face implements font.Face for a Plan 9 font.
+//
+// It maps multiple rune ranges to *subface values. Rune ranges may overlap;
+// the first match wins.
+type face struct {
+	height     int
+	ascent     int
+	readFile   func(relFilename string) ([]byte, error)
+	runeRanges []runeRange
+}
+
+func (f *face) Close() error                   { return nil }
+func (f *face) Kern(r0, r1 rune) fixed.Int26_6 { return 0 }
+
+func (f *face) Glyph(dot fixed.Point26_6, r rune) (
+	newDot fixed.Point26_6, dr image.Rectangle, mask image.Image, maskp image.Point, ok bool) {
+
+	// Fall back on U+FFFD if we can't find r.
+	for _, rr := range [2]rune{r, '\ufffd'} {
+		// We have to do linear, not binary search. plan9port's
+		// lucsans/unicode.8.font says:
+		//	0x2591  0x2593  ../luc/Altshades.7.0
+		//	0x2500  0x25ee  ../luc/FormBlock.7.0
+		// and the rune ranges overlap.
+		for i := range f.runeRanges {
+			x := &f.runeRanges[i]
+			if rr < x.lo || x.hi < rr || x.bad {
+				continue
+			}
+			if x.subface == nil {
+				data, err := f.readFile(x.relFilename)
+				if err != nil {
+					log.Printf("plan9font: couldn't read subfont %q: %v", x.relFilename, err)
+					x.bad = true
+					continue
+				}
+				sub, err := ParseSubfont(data, x.lo-x.offset)
+				if err != nil {
+					log.Printf("plan9font: couldn't parse subfont %q: %v", x.relFilename, err)
+					x.bad = true
+					continue
+				}
+				x.subface = sub.(*subface)
+			}
+			return x.subface.Glyph(dot, rr)
+		}
+	}
+	return fixed.Point26_6{}, image.Rectangle{}, nil, image.Point{}, false
+}
+
+// ParseFont parses a Plan 9 font file. data is the contents of that font file,
+// which gives relative filenames for subfont files. readFile returns the
+// contents of those subfont files. It is similar to io/ioutil's ReadFile
+// function, except that it takes a relative filename instead of an absolute
+// one.
+func ParseFont(data []byte, readFile func(relFilename string) ([]byte, error)) (font.Face, error) {
+	f := &face{
+		readFile: readFile,
+	}
+	// TODO: don't use strconv, to avoid the conversions from []byte to string?
+	for first := true; len(data) > 0; first = false {
+		i := bytes.IndexByte(data, '\n')
+		if i < 0 {
+			return nil, errors.New("plan9font: invalid font: no final newline")
+		}
+		row := string(data[:i])
+		data = data[i+1:]
+		if first {
+			height, s, ok := nextInt32(row)
+			if !ok {
+				return nil, fmt.Errorf("plan9font: invalid font: invalid header %q", row)
+			}
+			ascent, s, ok := nextInt32(s)
+			if !ok {
+				return nil, fmt.Errorf("plan9font: invalid font: invalid header %q", row)
+			}
+			if height < 0 || 0xffff < height || ascent < 0 || 0xffff < ascent {
+				return nil, fmt.Errorf("plan9font: invalid font: invalid header %q", row)
+			}
+			f.height, f.ascent = int(height), int(ascent)
+			continue
+		}
+		lo, s, ok := nextInt32(row)
+		if !ok {
+			return nil, fmt.Errorf("plan9font: invalid font: invalid row %q", row)
+		}
+		hi, s, ok := nextInt32(s)
+		if !ok {
+			return nil, fmt.Errorf("plan9font: invalid font: invalid row %q", row)
+		}
+		offset, s, _ := nextInt32(s)
+
+		f.runeRanges = append(f.runeRanges, runeRange{
+			lo:          lo,
+			hi:          hi,
+			offset:      offset,
+			relFilename: s,
+		})
+	}
+	return f, nil
+}
+
+func nextInt32(s string) (ret int32, remaining string, ok bool) {
+	i := 0
+	for ; i < len(s) && s[i] <= ' '; i++ {
+	}
+	j := i
+	for ; j < len(s) && s[j] > ' '; j++ {
+	}
+	n, err := strconv.ParseInt(s[i:j], 0, 32)
+	if err != nil {
+		return 0, s, false
+	}
+	for ; j < len(s) && s[j] <= ' '; j++ {
+	}
+	return int32(n), s[j:], true
 }
 
 // ParseSubfont parses a Plan 9 subfont file.
@@ -116,7 +242,7 @@ func ParseSubfont(data []byte, firstRune rune) (font.Face, error) {
 	if len(data) != 6*(n+1) {
 		return nil, errors.New("plan9font: invalid subfont: data length mismatch")
 	}
-	return &face{
+	return &subface{
 		firstRune: firstRune,
 		n:         n,
 		height:    height,

From ab08d42a8a37c5f1d5a4481aca35e70bd05b643a Mon Sep 17 00:00:00 2001
From: Nigel Tao <nigeltao@golang.org>
Date: Wed, 19 Aug 2015 16:33:39 +1000
Subject: [PATCH 4/7] shiny/font: add Hinting, Stretch, Style and Weight option
 types.

These will be used by other vector font packages, such as the truetype
package, to select specific faces.

Change-Id: I3db8c97335089c2076811e8f85d9a8868fc900bd
Reviewed-on: https://go-review.googlesource.com/13714
Reviewed-by: Rob Pike <r@golang.org>
---
 font/font.go | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/font/font.go b/font/font.go
index b3647f5..c370986 100644
--- a/font/font.go
+++ b/font/font.go
@@ -108,3 +108,59 @@ func (d *Drawer) DrawString(s string) {
 		d.Dot, prevC = newDot, c
 	}
 }
+
+// Hinting selects how to quantize a vector font's glyph nodes.
+//
+// Not all fonts support hinting.
+type Hinting int
+
+const (
+	HintingNone Hinting = iota
+	HintingVertical
+	HintingFull
+)
+
+// Stretch selects a normal, condensed, or expanded face.
+//
+// Not all fonts support stretches.
+type Stretch int
+
+const (
+	StretchUltraCondensed Stretch = -4
+	StretchExtraCondensed Stretch = -3
+	StretchCondensed      Stretch = -2
+	StretchSemiCondensed  Stretch = -1
+	StretchNormal         Stretch = +0
+	StretchSemiExpanded   Stretch = +1
+	StretchExpanded       Stretch = +2
+	StretchExtraExpanded  Stretch = +3
+	StretchUltraExpanded  Stretch = +4
+)
+
+// Style selects a normal, italic, or oblique face.
+//
+// Not all fonts support styles.
+type Style int
+
+const (
+	StyleNormal Style = iota
+	StyleItalic
+	StyleOblique
+)
+
+// Weight selects a normal, light or bold face.
+//
+// Not all fonts support weights.
+type Weight int
+
+const (
+	WeightThin       Weight = 100
+	WeightExtraLight Weight = 200
+	WeightLight      Weight = 300
+	WeightNormal     Weight = 400
+	WeightMedium     Weight = 500
+	WeightSemiBold   Weight = 600
+	WeightBold       Weight = 700
+	WeightExtraBold  Weight = 800
+	WeightBlack      Weight = 900
+)

From 627898392a4c6304ded005afc7bc944fe674391a Mon Sep 17 00:00:00 2001
From: Nigel Tao <nigeltao@golang.org>
Date: Mon, 24 Aug 2015 14:01:27 +1000
Subject: [PATCH 5/7] shiny/font: add per-glyph metrics.

Change-Id: Ie5c7e29b4eb7bd87b8e99de941f2f94b042e268f
Reviewed-on: https://go-review.googlesource.com/13827
Reviewed-by: Rob Pike <r@golang.org>
---
 font/font.go                | 43 ++++++++++++++++++++++++++++---
 font/plan9font/plan9font.go | 50 +++++++++++++++++++++++++++++++++++--
 2 files changed, 88 insertions(+), 5 deletions(-)

diff --git a/font/font.go b/font/font.go
index c370986..8f8f4c1 100644
--- a/font/font.go
+++ b/font/font.go
@@ -37,8 +37,9 @@ type Face interface {
 
 	// Glyph returns the draw.DrawMask parameters (dr, mask, maskp) to draw r's
 	// glyph at the sub-pixel destination location dot. It also returns the new
-	// dot after adding the glyph's advance width. It returns !ok if the face
-	// does not contain a glyph for r.
+	// dot after adding the glyph's advance width.
+	//
+	// It returns !ok if the face does not contain a glyph for r.
 	//
 	// The contents of the mask image returned by one Glyph call may change
 	// after the next Glyph call. Callers that want to cache the mask must make
@@ -46,11 +47,26 @@ type Face interface {
 	Glyph(dot fixed.Point26_6, r rune) (
 		newDot fixed.Point26_6, dr image.Rectangle, mask image.Image, maskp image.Point, ok bool)
 
+	// GlyphBounds returns the bounding box of r's glyph, drawn at a dot equal
+	// to the origin, and that glyph's advance width.
+	//
+	// It returns !ok if the face does not contain a glyph for r.
+	//
+	// The glyph's ascent and descent equal -bounds.Min.Y and +bounds.Max.Y. A
+	// visual depiction of what these metrics are is at
+	// https://developer.apple.com/library/mac/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png
+	GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool)
+
+	// GlyphAdvance returns the advance width of r's glyph.
+	//
+	// It returns !ok if the face does not contain a glyph for r.
+	GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool)
+
 	// Kern returns the horizontal adjustment for the kerning pair (r0, r1). A
 	// positive kern means to move the glyphs further apart.
 	Kern(r0, r1 rune) fixed.Int26_6
 
-	// TODO: per-font and per-glyph Metrics.
+	// TODO: per-font Metrics.
 	// TODO: ColoredGlyph for various emoji?
 	// TODO: Ligatures? Shaping?
 }
@@ -102,6 +118,7 @@ func (d *Drawer) DrawString(s string) {
 		if !ok {
 			// TODO: is falling back on the U+FFFD glyph the responsibility of
 			// the Drawer or the Face?
+			// TODO: set prevC = '\ufffd'?
 			continue
 		}
 		draw.DrawMask(d.Dst, dr, d.Src, image.Point{}, mask, maskp, draw.Over)
@@ -109,6 +126,26 @@ func (d *Drawer) DrawString(s string) {
 	}
 }
 
+// MeasureString returns how far dot would advance by drawing s.
+func (d *Drawer) MeasureString(s string) (advance fixed.Int26_6) {
+	var prevC rune
+	for i, c := range s {
+		if i != 0 {
+			advance += d.Face.Kern(prevC, c)
+		}
+		a, ok := d.Face.GlyphAdvance(c)
+		if !ok {
+			// TODO: is falling back on the U+FFFD glyph the responsibility of
+			// the Drawer or the Face?
+			// TODO: set prevC = '\ufffd'?
+			continue
+		}
+		advance += a
+		prevC = c
+	}
+	return advance
+}
+
 // Hinting selects how to quantize a vector font's glyph nodes.
 //
 // Not all fonts support hinting.
diff --git a/font/plan9font/plan9font.go b/font/plan9font/plan9font.go
index 35d6ee8..abcc655 100644
--- a/font/plan9font/plan9font.go
+++ b/font/plan9font/plan9font.go
@@ -94,6 +94,31 @@ func (f *subface) Glyph(dot fixed.Point26_6, r rune) (
 	return newDot, dr, f.img, image.Point{int(i.x), int(i.top)}, true
 }
 
+func (f *subface) GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) {
+	r -= f.firstRune
+	if r < 0 || f.n <= int(r) {
+		return fixed.Rectangle26_6{}, 0, false
+	}
+	i := &f.fontchars[r+0]
+	j := &f.fontchars[r+1]
+
+	bounds = fixed.R(
+		int(i.left),
+		int(i.top)-f.ascent,
+		int(i.left)+int(j.x-i.x),
+		int(i.bottom)-f.ascent,
+	)
+	return bounds, fixed.Int26_6(i.width) << 6, true
+}
+
+func (f *subface) GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool) {
+	r -= f.firstRune
+	if r < 0 || f.n <= int(r) {
+		return 0, false
+	}
+	return fixed.Int26_6(f.fontchars[r].width) << 6, true
+}
+
 // runeRange maps a single rune range [lo, hi] to a lazily loaded subface. Both
 // ends of the range are inclusive.
 type runeRange struct {
@@ -121,6 +146,27 @@ func (f *face) Kern(r0, r1 rune) fixed.Int26_6 { return 0 }
 func (f *face) Glyph(dot fixed.Point26_6, r rune) (
 	newDot fixed.Point26_6, dr image.Rectangle, mask image.Image, maskp image.Point, ok bool) {
 
+	if s, rr := f.subface(r); s != nil {
+		return s.Glyph(dot, rr)
+	}
+	return fixed.Point26_6{}, image.Rectangle{}, nil, image.Point{}, false
+}
+
+func (f *face) GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) {
+	if s, rr := f.subface(r); s != nil {
+		return s.GlyphBounds(rr)
+	}
+	return fixed.Rectangle26_6{}, 0, false
+}
+
+func (f *face) GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool) {
+	if s, rr := f.subface(r); s != nil {
+		return s.GlyphAdvance(rr)
+	}
+	return 0, false
+}
+
+func (f *face) subface(r rune) (*subface, rune) {
 	// Fall back on U+FFFD if we can't find r.
 	for _, rr := range [2]rune{r, '\ufffd'} {
 		// We have to do linear, not binary search. plan9port's
@@ -148,10 +194,10 @@ func (f *face) Glyph(dot fixed.Point26_6, r rune) (
 				}
 				x.subface = sub.(*subface)
 			}
-			return x.subface.Glyph(dot, rr)
+			return x.subface, rr
 		}
 	}
-	return fixed.Point26_6{}, image.Rectangle{}, nil, image.Point{}, false
+	return nil, 0
 }
 
 // ParseFont parses a Plan 9 font file. data is the contents of that font file,

From 5ae59125bffc3d2011a3872bb2ae76f29fa0d072 Mon Sep 17 00:00:00 2001
From: Nigel Tao <nigeltao@golang.org>
Date: Mon, 31 Aug 2015 11:16:53 +1000
Subject: [PATCH 6/7] shiny/font: have Face.Glyph return an advance width, not
 a new dot.

This is consistent with Face.GlyphBounds and Face.GlyphAdvance.

Change-Id: I9da6b4f2fdb8f093fc9567c717e8fbbecc624e30
Reviewed-on: https://go-review.googlesource.com/14090
Reviewed-by: David Symonds <dsymonds@golang.org>
---
 font/font.go                | 11 ++++++-----
 font/plan9font/plan9font.go | 14 +++++---------
 2 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/font/font.go b/font/font.go
index 8f8f4c1..a9b9729 100644
--- a/font/font.go
+++ b/font/font.go
@@ -36,8 +36,8 @@ type Face interface {
 	io.Closer
 
 	// Glyph returns the draw.DrawMask parameters (dr, mask, maskp) to draw r's
-	// glyph at the sub-pixel destination location dot. It also returns the new
-	// dot after adding the glyph's advance width.
+	// glyph at the sub-pixel destination location dot, and that glyph's
+	// advance width.
 	//
 	// It returns !ok if the face does not contain a glyph for r.
 	//
@@ -45,7 +45,7 @@ type Face interface {
 	// after the next Glyph call. Callers that want to cache the mask must make
 	// a copy.
 	Glyph(dot fixed.Point26_6, r rune) (
-		newDot fixed.Point26_6, dr image.Rectangle, mask image.Image, maskp image.Point, ok bool)
+		dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool)
 
 	// GlyphBounds returns the bounding box of r's glyph, drawn at a dot equal
 	// to the origin, and that glyph's advance width.
@@ -114,7 +114,7 @@ func (d *Drawer) DrawString(s string) {
 		if i != 0 {
 			d.Dot.X += d.Face.Kern(prevC, c)
 		}
-		newDot, dr, mask, maskp, ok := d.Face.Glyph(d.Dot, c)
+		dr, mask, maskp, advance, ok := d.Face.Glyph(d.Dot, c)
 		if !ok {
 			// TODO: is falling back on the U+FFFD glyph the responsibility of
 			// the Drawer or the Face?
@@ -122,7 +122,8 @@ func (d *Drawer) DrawString(s string) {
 			continue
 		}
 		draw.DrawMask(d.Dst, dr, d.Src, image.Point{}, mask, maskp, draw.Over)
-		d.Dot, prevC = newDot, c
+		d.Dot.X += advance
+		prevC = c
 	}
 }
 
diff --git a/font/plan9font/plan9font.go b/font/plan9font/plan9font.go
index abcc655..89f0a2d 100644
--- a/font/plan9font/plan9font.go
+++ b/font/plan9font/plan9font.go
@@ -66,19 +66,15 @@ func (f *subface) Close() error                   { return nil }
 func (f *subface) Kern(r0, r1 rune) fixed.Int26_6 { return 0 }
 
 func (f *subface) Glyph(dot fixed.Point26_6, r rune) (
-	newDot fixed.Point26_6, dr image.Rectangle, mask image.Image, maskp image.Point, ok bool) {
+	dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool) {
 
 	r -= f.firstRune
 	if r < 0 || f.n <= int(r) {
-		return fixed.Point26_6{}, image.Rectangle{}, nil, image.Point{}, false
+		return image.Rectangle{}, nil, image.Point{}, 0, false
 	}
 	i := &f.fontchars[r+0]
 	j := &f.fontchars[r+1]
 
-	newDot = fixed.Point26_6{
-		X: dot.X + fixed.Int26_6(i.width)<<6,
-		Y: dot.Y,
-	}
 	minX := int(dot.X+32)>>6 + int(i.left)
 	minY := int(dot.Y+32)>>6 + int(i.top) - f.ascent
 	dr = image.Rectangle{
@@ -91,7 +87,7 @@ func (f *subface) Glyph(dot fixed.Point26_6, r rune) (
 			Y: minY + int(i.bottom) - int(i.top),
 		},
 	}
-	return newDot, dr, f.img, image.Point{int(i.x), int(i.top)}, true
+	return dr, f.img, image.Point{int(i.x), int(i.top)}, fixed.Int26_6(i.width) << 6, true
 }
 
 func (f *subface) GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) {
@@ -144,12 +140,12 @@ func (f *face) Close() error                   { return nil }
 func (f *face) Kern(r0, r1 rune) fixed.Int26_6 { return 0 }
 
 func (f *face) Glyph(dot fixed.Point26_6, r rune) (
-	newDot fixed.Point26_6, dr image.Rectangle, mask image.Image, maskp image.Point, ok bool) {
+	dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool) {
 
 	if s, rr := f.subface(r); s != nil {
 		return s.Glyph(dot, rr)
 	}
-	return fixed.Point26_6{}, image.Rectangle{}, nil, image.Point{}, false
+	return image.Rectangle{}, nil, image.Point{}, 0, false
 }
 
 func (f *face) GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) {

From b53870fbcf2dabd111ee3c99562452b9f4f72dc3 Mon Sep 17 00:00:00 2001
From: Nigel Tao <nigeltao@golang.org>
Date: Wed, 26 Aug 2015 11:28:38 +1000
Subject: [PATCH 7/7] shiny/font/plan9font: add an example test.

The testdata/fixed font files come from the Plan 9 Port, and were all
marked as public domain. The total size of the new testdata is 112K.

Change-Id: I8cf5de4e5abd1aec7e6550d330271f2acdc12402
Reviewed-on: https://go-review.googlesource.com/13888
Reviewed-by: Rob Pike <r@golang.org>
---
 font/plan9font/example_test.go        |  93 ++++++++++++++++++++++++++
 font/testdata/fixed/7x13.0000         | Bin 0 -> 3136 bytes
 font/testdata/fixed/7x13.0100         | Bin 0 -> 3908 bytes
 font/testdata/fixed/7x13.0200         | Bin 0 -> 3095 bytes
 font/testdata/fixed/7x13.0300         | Bin 0 -> 2631 bytes
 font/testdata/fixed/7x13.0400         | Bin 0 -> 3623 bytes
 font/testdata/fixed/7x13.0500         | Bin 0 -> 2492 bytes
 font/testdata/fixed/7x13.0E00         | Bin 0 -> 1235 bytes
 font/testdata/fixed/7x13.1000         | Bin 0 -> 2354 bytes
 font/testdata/fixed/7x13.1600         | Bin 0 -> 1825 bytes
 font/testdata/fixed/7x13.1E00         | Bin 0 -> 3713 bytes
 font/testdata/fixed/7x13.1F00         | Bin 0 -> 3012 bytes
 font/testdata/fixed/7x13.2000         | Bin 0 -> 2310 bytes
 font/testdata/fixed/7x13.2100         | Bin 0 -> 3206 bytes
 font/testdata/fixed/7x13.2200         | Bin 0 -> 3532 bytes
 font/testdata/fixed/7x13.2300         | Bin 0 -> 1613 bytes
 font/testdata/fixed/7x13.2400         | Bin 0 -> 1013 bytes
 font/testdata/fixed/7x13.2500         | Bin 0 -> 2747 bytes
 font/testdata/fixed/7x13.2600         | Bin 0 -> 1765 bytes
 font/testdata/fixed/7x13.2700         | Bin 0 -> 1762 bytes
 font/testdata/fixed/7x13.2800         | Bin 0 -> 1918 bytes
 font/testdata/fixed/7x13.2A00         | Bin 0 -> 620 bytes
 font/testdata/fixed/7x13.3000         | Bin 0 -> 569 bytes
 font/testdata/fixed/7x13.FB00         | Bin 0 -> 912 bytes
 font/testdata/fixed/7x13.FE00         | Bin 0 -> 387 bytes
 font/testdata/fixed/7x13.FF00         | Bin 0 -> 1687 bytes
 font/testdata/fixed/README            |   9 +++
 font/testdata/fixed/unicode.7x13.font |  68 +++++++++++++++++++
 28 files changed, 170 insertions(+)
 create mode 100644 font/plan9font/example_test.go
 create mode 100644 font/testdata/fixed/7x13.0000
 create mode 100644 font/testdata/fixed/7x13.0100
 create mode 100644 font/testdata/fixed/7x13.0200
 create mode 100644 font/testdata/fixed/7x13.0300
 create mode 100644 font/testdata/fixed/7x13.0400
 create mode 100644 font/testdata/fixed/7x13.0500
 create mode 100644 font/testdata/fixed/7x13.0E00
 create mode 100644 font/testdata/fixed/7x13.1000
 create mode 100644 font/testdata/fixed/7x13.1600
 create mode 100644 font/testdata/fixed/7x13.1E00
 create mode 100644 font/testdata/fixed/7x13.1F00
 create mode 100644 font/testdata/fixed/7x13.2000
 create mode 100644 font/testdata/fixed/7x13.2100
 create mode 100644 font/testdata/fixed/7x13.2200
 create mode 100644 font/testdata/fixed/7x13.2300
 create mode 100644 font/testdata/fixed/7x13.2400
 create mode 100644 font/testdata/fixed/7x13.2500
 create mode 100644 font/testdata/fixed/7x13.2600
 create mode 100644 font/testdata/fixed/7x13.2700
 create mode 100644 font/testdata/fixed/7x13.2800
 create mode 100644 font/testdata/fixed/7x13.2A00
 create mode 100644 font/testdata/fixed/7x13.3000
 create mode 100644 font/testdata/fixed/7x13.FB00
 create mode 100644 font/testdata/fixed/7x13.FE00
 create mode 100644 font/testdata/fixed/7x13.FF00
 create mode 100644 font/testdata/fixed/README
 create mode 100644 font/testdata/fixed/unicode.7x13.font

diff --git a/font/plan9font/example_test.go b/font/plan9font/example_test.go
new file mode 100644
index 0000000..071fcfa
--- /dev/null
+++ b/font/plan9font/example_test.go
@@ -0,0 +1,93 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package plan9font_test
+
+import (
+	"image"
+	"image/draw"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+
+	"golang.org/x/exp/shiny/font"
+	"golang.org/x/exp/shiny/font/plan9font"
+	"golang.org/x/image/math/fixed"
+)
+
+func ExampleParseFont() {
+	readFile := func(name string) ([]byte, error) {
+		return ioutil.ReadFile(filepath.FromSlash(path.Join("../testdata/fixed", name)))
+	}
+	fontData, err := readFile("unicode.7x13.font")
+	if err != nil {
+		log.Fatal(err)
+	}
+	face, err := plan9font.ParseFont(fontData, readFile)
+	if err != nil {
+		log.Fatal(err)
+	}
+	// TODO: derive the ascent from the face's metrics.
+	const ascent = 11
+
+	dst := image.NewRGBA(image.Rect(0, 0, 4*7, 13))
+	draw.Draw(dst, dst.Bounds(), image.Black, image.Point{}, draw.Src)
+	d := &font.Drawer{
+		Dst:  dst,
+		Src:  image.White,
+		Face: face,
+		Dot:  fixed.P(0, ascent),
+	}
+	// Draw:
+	// 	- U+0053 LATIN CAPITAL LETTER S
+	//	- U+03A3 GREEK CAPITAL LETTER SIGMA
+	//	- U+222B INTEGRAL
+	//	- U+3055 HIRAGANA LETTER SA
+	// The testdata does not contain the CJK subfont files, so U+3055 HIRAGANA
+	// LETTER SA (さ) should be rendered as U+FFFD REPLACEMENT CHARACTER (�).
+	//
+	// The missing subfont file will trigger an "open
+	// ../testdata/shinonome/k12.3000: no such file or directory" log message.
+	// This is expected and can be ignored.
+	d.DrawString("SΣ∫さ")
+
+	// Convert the dst image to ASCII art.
+	var out []byte
+	b := dst.Bounds()
+	for y := b.Min.Y; y < b.Max.Y; y++ {
+		out = append(out, '0'+byte(y%10), ' ')
+		for x := b.Min.X; x < b.Max.X; x++ {
+			if dst.RGBAAt(x, y).R > 0 {
+				out = append(out, 'X')
+			} else {
+				out = append(out, '.')
+			}
+		}
+		// Highlight the last row before the baseline. Glyphs like 'S' without
+		// descenders should not affect any pixels whose Y coordinate is >= the
+		// baseline.
+		if y == ascent-1 {
+			out = append(out, '_')
+		}
+		out = append(out, '\n')
+	}
+	os.Stdout.Write(out)
+
+	// Output:
+	// 0 ..................X.........
+	// 1 .................X.X........
+	// 2 .XXXX..XXXXXX....X.....XXX..
+	// 3 X....X.X.........X....XX.XX.
+	// 4 X.......X........X....X.X.X.
+	// 5 X........X.......X....XXX.X.
+	// 6 .XXXX.....X......X....XX.XX.
+	// 7 .....X...X.......X....XX.XX.
+	// 8 .....X..X........X....XXXXX.
+	// 9 X....X.X.........X....XX.XX.
+	// 0 .XXXX..XXXXXX....X.....XXX.._
+	// 1 ...............X.X..........
+	// 2 ................X...........
+}
diff --git a/font/testdata/fixed/7x13.0000 b/font/testdata/fixed/7x13.0000
new file mode 100644
index 0000000000000000000000000000000000000000..9509cdf97f478dc67f631cc67d25490eef825a10
GIT binary patch
literal 3136
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

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.0100 b/font/testdata/fixed/7x13.0100
new file mode 100644
index 0000000000000000000000000000000000000000..0a79f555cff079a442586a27129f77f59710d04a
GIT binary patch
literal 3908
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
S@91gtL-Z2*84Bsr5Aa{3E_&qv

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.0200 b/font/testdata/fixed/7x13.0200
new file mode 100644
index 0000000000000000000000000000000000000000..e25247ecc749f4c6a9d76644593ead99e2b08db0
GIT binary patch
literal 3095
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

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.0300 b/font/testdata/fixed/7x13.0300
new file mode 100644
index 0000000000000000000000000000000000000000..86eb33f42fb587cc7a9f356f8a344a775fd56dcb
GIT binary patch
literal 2631
zcmdVadu$X%90%~<-fi2x<!I-&ix$*6cOH60)D|k9+Q8m&)lxNpG@2+H<dI;gp@NTU
zPP2PA$DI|9YZaoXg)JqB8edU^iH3_53L4*-XfTnN8ckG6P^s3(^qZj35aVAa-XEX)
z<u|{X-^^xr7A?Q6W5tq{E0-+R`N`k1hLe%}uRm4XP(Q8l&wRtwQ^gJS4RK!NJYi8t
zi!De*(t4D2&}4FbzIv9T6vb&Rv-)xy3tEizC49P(%-7du6gAkZRj?{YZArS3r21U@
zQZ>>>CavNY`E-iMPs>nsm{I0=eLbc2uGn=|UCr=`!SCMdO^Jo(Meoi?jSRDVYi}gU
zxNSOdI$Cj{f~b=!4%8%awqSf_rEZca&U9vwW9=-nLdF5*@a|G&aJgGccRUvK_xiML
z<h4$$YxAO68lX8I%P(r=tjBi3p*^jhy7NK7oTQ>Dq&XzU$2CD`q`SvWqAOfsss64~
z)(S@~+YA#Ug~;`&L$(T*cR3Uw-VzQc9a|OIqQ{Dhrm13;#ryiZyy;_?Ws>ChRN<%>
zZzyQpsuts<(I#5$l$vE(!c0(YQ%XJJhAAb=Lzxl<YDlc%B5!AvsKPw9splg(ooix;
zmi+4T0ro^HIdo`Dz8JYPU{q}EZMyGRDB0T0#4+RiDiLeD{dla3ryh3su2wH%9W~Nx
zx~;ZI^`Pt3b_mBgE8xaEHL+$`IWKee4p!>fx3$=l@{M_6v+iki6Hbe=&33bH24@$e
zYXYG?v%+@KHu}2Ov8--9<Ek;X&1hjw))pl^QEu~|SqFXT(0o=GjafT*d*-bDPE}cf
zgmb?VaD0J4&RoEHEY9t+z`9UiAj&+uE-;|A6l2+dq0I_g`5IApa;~beZP(@*x3&yN
zmXJs%yL=>aHXBaH$ZJZ8AnDaPp3&^A&s61jw{9v0*Rn`tbA}e0pq2&Fb-EnM#Istz
zDul2NPv^p!M`Cs7fIg>h*T&kUZmP{BTyH?`kGBhBL3wphI05-^HJN!JC}cXZ$0kvj
zWJZfy7KU_FYw3w*ACc=eSmIh)Xvo5T-y=%Ey|U<!WsSMqa(&8nO=QF8#w?F77|9U%
ze`3|;)$5yDI!a=dJ?#H+^hM6<@<leR5w6_XH+4GOd*qy|@$=cx;XPLdBiW@h2Oqew
zsWW`=jhr6r96C6&lEj9Nem<L9s!=>|t>QZ}bok4`$|e>WH<<6OZ5naXRG%H5o6rhV
zOvB~ryOV0v-|GLt;r`h)nC8UGnw>Pil#I0FSZaC2OXfI7t@yB!3W<cOsVu)KoeN$4
z%Wo&DwmPL$#uQE|DCFD6gJinG<~*&G{QhG>L3N?_Oi6xjC$EGljnhtsod4yfXy8ON
zmMUbiv=WYkXTo#fB-jAsa0a{rUIW|Ujc_5n6?VY8;r+51(SM*kOBNkh!-wDo=)ou9
zbMO`TIvjv+!4Kdk@BsW0eha_HSx%|!K7!GIsjT-aqt9QL*A&tJPPy|C_Fsej|7Xg+
zXQS`A=zB_K%>@|!n=;>s{68pbF30*doCW8=>*39C3D%Ly`gX)p8Lx!*LKo)YTDTrQ
z0sG<8@J0A4EWtte4*Upy3J=4t;SfB5?o!$PH(2f)jmJV0o&h7U4%Wj<;B?pwuZHvB
z4e%DY6fTE%!TX?q55gY!DBJ|M!e`;j@HMy-z6sxlAH&b!7w{W+9R3V_{?T&<AcLpF
zS~w9-_K$u|Qdv0_UIr7e1<r=o!JFV>%=$w)cNy|4;62cRIaq+};Nx&Jd<wn*x5FK9
jH+&oJgZtqj_!T?~e}uonGIjJ6L0AnZz%Y!dqbL0xAtlEc

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.0400 b/font/testdata/fixed/7x13.0400
new file mode 100644
index 0000000000000000000000000000000000000000..43300ad95b2403fb4b379059e12b8167c54ee023
GIT binary patch
literal 3623
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

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.0500 b/font/testdata/fixed/7x13.0500
new file mode 100644
index 0000000000000000000000000000000000000000..2d9326708ee6d54b5ee9048b8fc00271a80a2172
GIT binary patch
literal 2492
zcmeIxe{2(F7zgm@+H-x|6?Pq6EYNJ%T1HtWb}(dOowrK|bwSt42%w4la7*?^4O56#
zt>(Jj)+-FQArcgZ?Le)XXe7}{qCnh~O;p6iL=zLHBM?k94AEea=<S;fV?vB3{>gjE
z=bk+GzVF@p-1|Pb@sYO2S~hKJX?Dm{?V+lv$h?QH8P`-V{wrU#@S1T=%_3Q&Brc)^
zb%+wN<eVgF^h)o<piv};6AqD;Wm#e@Fz5+|6ORtEy3%k+Q;zA3No}c*X<nB=B9TR=
zf-YtuFB3GUqRC|KV5?~;v?|=6?sEj9QdZT8?=6s}&KXSy45zBU9x&>BYE=6!*ua>q
zsR6~y(^j2{<ab*nh4J=gA(G(4Q;oe&ZrFXSQyR(|Gl*y0MqE~-sd%tKxTBpc`{`(h
zK(?c7REyAPN|uPzlf=`78nK8Fv2Nzu`YduZc39OfpPnAena_LDOjh;R+{1BM2~EU<
z%f!HtMPd7@-~R1D;jXgE^%N-VsZ1JGuH%L)e8}Pdw9!);Ie)r?N}1I6z3oJI?Umhw
zXHOgngckm~@zjn$a$?1q&-SnY@&48#pVIGeJ7PImbOj7UR>k1Xe7sZ{&cuW2wCx`{
za?3|7&CWIc1-_Asm9c|<!&O`vDN#Ri`13KNqJ=eSPGVBjN1D#+gNm&5RY<PlKr~Y<
z+T;F6MvA8UCeB9%S$SFHsr?G^b}gDCZZzi`1w~B7hdq2-B;yFMxZm$<2n1sT#5<*+
zTB3G3`Ia^IrVgetYLzt)*NR2nu{`65FrFgP4>38aiaaekV*Tq9#cq-7!z^OdiM)L!
zYY6hxiUFBxQ5w}UPOjAv*KEQbqgU1pU94wByxT9i{N>6PF=9XISEycpp5*9SiEmAL
zjAFN8<kV2%Y0J~PqHE*BZr+uRWM(z9m27lpYkZ)5w<}~sORD>3ZOAto6<6#{G*@Sm
z;Zr1@s&kqDR8^F2OT_MCJljI@vfjhV-4|>lJwn0e*+1KCrK;2JPN()M39W8!dV0;k
z4M%Fb&+Q++*X#G)HkiL>U`eZVlEn(yd*^a_rE8XQetex-!I2A$_gtd6U1js7iL|zs
z)vmUWGtNj8Y+jqEe6QO(<5o?iydIQD_KEZ87R#BGBv^%Z*^q>+M%K3Ae6o_aofPJo
z>7{B{n0JO6zaV+0xYQcnGA4`_rAmoHMv?eZl24t+1=WkDLRtRXA+3_>di!@3m_{}m
zk?C|;0=@7iSOKeG4ZIUBg?Gayct6|#Ic$SZz-M76?1s<57hw+O;al)s_yHV($KjXo
z8#o5f!k^$T@ONkxCfDT<CJS*@Gvh+u1Iu7Jyct%*+cC=2?61PRU<|H;55N}qFx&*6
zf+=Xg9=Hqk!vpXQcn}_fN8vH}Is6KK3&-IPZ~|U}f4~CE<kwDvZa5qI;XD|Ei(xIS
zhs!OKRWdbaSOM=t=DPo>0%rBrqi&{V+=}?BW@aNY|BL2qkK--RKpk#{JKzg23txqA
z!gt{Na1ee1Pr|R^DR>6{2rt6R&|;ljogGT>Mpz2xz)I`nj`|1985W}F5?BYLun}Yb
E1dQH-2LJ#7

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.0E00 b/font/testdata/fixed/7x13.0E00
new file mode 100644
index 0000000000000000000000000000000000000000..7c51a1e511a5919063c2bc729f41ed9815e67342
GIT binary patch
literal 1235
zcmZwFe`s4(6bJB=_d@%YzIBPFBh)ybuQ4QD#U%aVHnW=5q-5cWVa>Xd)q$P;qgu7B
zf4Ge>^3o<**0C(vGS;zQ)kYGcv{fny4jlAX5L9G>ihoqXR_IVRwt>iCCSM3c==tMw
z&$(PK=UndLk3JYVGB`Rq_^w8(#{2eaR$grz<{h@3PxtMu8|Lk89a5M=<foX><Wp)y
zqv@Ft1t@m!#Uwv2YAcnV!Y<;KJyAowqVf|TA(Bk8pCVdvkyW4wM*=zG<!g9;?Z<1R
zjbEoNmxqaFh3CUIQ@dez%Z!UD#EV;^{3>Z>y=A+?sns@xD0g(dXX$**c|U#5{MNS4
zytQd5>F6v@Y;6h7I~NnB<>WT!!h??GWUI;)UKRUebLwl&>SI5dSgf72QgD{ekKesz
z?T>YB`gA()pK?7~pSJqvT_QW%wRlQz@lSOv)^%78-EgQjiQf_%R~psPoYpr{T25bb
z9-ZsCd3BZw3zq!__a}`jXVY14%K4HtTj-k%c@uhzFEik&TWac4f`K8~%oHaHB8&5X
zsw@2qy7+{C`~Ive?7LOV6)5K}W(wYPV^OEiucREF^=!eLl20b|d0$3$ugInqCD=c?
z?=z-wea1<NO$1))&9aM{z!3L2W!#B|=Ki$iZC%4(hB=4l_`^I)$(IFoX5hAP*xWa^
z&s|JUdliR~jm2(`)fgvFNxk#z;(G@^jO6Hwd!%GOST7E*u6^<Qyy&_6m6@fC!y~2c
zsAk~TdukSQ>?rEqh;z~%6H~P&lI@+LQTdKXOA<xYGtIl~nrBTkR?}v<F0^$2Ti&e8
z^oCf3GaAHW<+>U>9o0;d{`aHo5>;a})z%V~t%nWJ2%BItw8I_nb=VExgaLRE4!|Ke
z0zZZ)U=*H)=intc1#@r)ehqKH1^7Mu8U6-W;TrrKK7x-Sud2+YfjVe_FF-SV8MeXK
zU>DpA{qO)h1P9?T9EHcB0#Cvuyr8N)@rIVWx`H#)umHb=-@xzSGW-Gl0{?&|xDM~b
jf8Y~X!&Ro<4E69iC_^i>!B=4?^gsrCU=Y5;Ri^k4X&(gZ

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.1000 b/font/testdata/fixed/7x13.1000
new file mode 100644
index 0000000000000000000000000000000000000000..019698c8d105992723c6ad0e43f181a62e703908
GIT binary patch
literal 2354
zcmeIyacCP=90%~<y<FDI*=Bd?72=Hb?wV|6Oi1RcqJuV<*X~-}nudY{i_~rfMa5uI
zTPfouxoa-kHOaKyR#1{{V8K7?h6?*bj4}|ks0{r>5NVr=;va5x45n`A^#?_S{^fr{
z-@)g;+&v!ezC7;O3(u!t932}QJua%7<Js6|a_`YCbH{-P|9KvJV9Weav_oYu>0Vjz
z)b{x&V<E^$M;jZ?-3c7J_Cqvy$CLkRDK;W|)^gcay_;Ju7PS*A0O3O*L4@)A-l_HL
z1VD{~rwC#cq7@7L6d=a{&S`<TlakuKgqZ<Zmx*HcX@*TCCs{SBgoG&zLMIc!GtY^@
zF-|oBhM~m--+%?20UU1tIPrjCrX<rlvXAD$NosnP@KDGL!(9Dy28}>%=<=(*??GXv
z#XRFnS<F8KuoiEG*D_J6CgzTKOXq(E%I*bvy1&|U@(<6olBQ@YYsaY|l!&qifbcU`
zyc8Zcd1|FCAJ|Z^CvG*bG{Ow~nySXxKCkdi|5bT+i?{h=^^uoEeqm>)paq-H7llyi
zH>K@lD>?e-N+LVozSLV;b;@1V@8lgPV_1@u$gm8PfPP%=<IlWlrsQ3-BA+1|@rwK+
zRFnuvnlh!!ru=ED8u~yCR0e0mOX5HznIF3ByLqMCKV+%(ALC4*Ioaf&cDG2%BL4|c
z#}@elRP+dOGpA3OlAfx%`Silztp2{3j0_Y;Y+vAlp&3?M>3$5DCD3d;FSuotdCIB+
z%_{||(iI^p7tHE*RG`cTI%m%6mah^%QZQ_xVs&eVDJY3)D31rnYKA|^3&)(pGi3P2
z4Grkxgs(2_?CiRmt7$@O$R>(5eac|#t9w{EWI0k8rVQ(PCFi_-@V3~Tal3xG=XIv4
zcV(?r1^gK!4PstkU^%DSO0XmA?u}$^PLw!+Nt%Okx$fDOIVgb08lWkceyY~LF)IPQ
zY^^T?gUyq@zhnPqRMmeS_?QaYW4nRv2L8_tG(kfHfU6&EK|^R8x)+V152KxE4|*6K
zM4v!M&}Yyz`U-jiwb5zx4Rju@q6_FE`XTxedIkLgy^4N^E~7u8zoIwM+o*@z_%6}?
z;Q{<--4$e9Cy3sM?nduN51@~t2HJ}z(Z|sz(NXj{bPRnJ&7cliMCZ`A&<p6h=q2<r
pT0=iWzeK-9zenrnFX%dY3;he-K{lFcLKXBLveD9(x-)fr`!_gx5w!pS

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.1600 b/font/testdata/fixed/7x13.1600
new file mode 100644
index 0000000000000000000000000000000000000000..f69a977459368f631a22f67f6b2bda33ab1d7cfb
GIT binary patch
literal 1825
zcmeH@KWGzC9LHblv$-6p<ivnrc)UBWaAdlqZRiqAuSbXh;V!s2`KN=Zc-X-qP%b60
zJ=^*Rw-!oo>n1Kjhc4>YrMkJbE^cn(>d!CaiJ^2C@`lg*@_FBTy!+jK{3v>|xU{r*
zPnU!Bpgc&lyQk*L%<NxZo<22Ks;-RLLl&`Z`*@x=H{5z+^gOQRllEB7uw;_&w|W*6
z&zx83#HQ{r5&KMRUjE!Z_xwuL4UL6WUS(o?=C#ppP1;d#Vz+qlQre!nUMM-{MRS~&
znAmX=qp_wt%^+<wcqt!$yR92lJA5~v;TDs->uwTG<+5(m4Er7zT`$!-t3g+PVdYtU
zT_&NgYmOhJ6Cb%)Suk}bSgku=;58;*_OhDo2PfyfUNPA9%q$bU6Bl@gUdc7h@)Lu9
z;F^0>&(*l#`#BLy+JCLA)lIGQCq?x4gW*)B=LS*Ae`Z#eY_vub7){`Rp1>r_Wbl3>
z<qKc|Mv;6GMv=@_G)rI^r)QA*bLbE$Uqc=u`36pJfH%=0lD~zlNahZVBANRziew@f
zMKVuu+cMb4DUtjJ@({_tfmbB61v5nQDel?BsUrEeFp6Z}qj>;+0uRA2;8*k&secS}
O2C4HM-~Ir9qW>F8LVdab

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.1E00 b/font/testdata/fixed/7x13.1E00
new file mode 100644
index 0000000000000000000000000000000000000000..3bc5068cfbdcf5a47f9af710fee2b583184d9da6
GIT binary patch
literal 3713
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

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.1F00 b/font/testdata/fixed/7x13.1F00
new file mode 100644
index 0000000000000000000000000000000000000000..43b320be121764eaa703e070c1514324f44573f5
GIT binary patch
literal 3012
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

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.2000 b/font/testdata/fixed/7x13.2000
new file mode 100644
index 0000000000000000000000000000000000000000..f9244e1cf9f08933d03d080bd3ddb875f53b8fa6
GIT binary patch
literal 2310
zcmdVae{2(F7zgm@uJ6{P>$)43P;e=?GDv{|9h*?yaGey=MbI(kFN{XCGngSv-b4rT
z<9)B|R$%NG&WM@P%_WS1Vn`G*kZr+*L=#aGBPJ$bh}IZ2Tf*WHGrfM3X-tSQ{$cd~
z_}rT}_dM_Oy!YNcwe8vZ?X{fOMjgh~RaZ1MvhIOfj_+Jn^2dBp@h!)}z#WF5UF0Td
zo7gosL`{Ys%4%(AdUi~0w~q#WO)+v#-=e(j$%(V+H5Kzh&Mavc#N^mjEvs31L{;-V
z^&y%rH6yS}_zRp(yCy=;^@Dq8YxBU-^6r&4ei{udj#nu*auyI5Qh!cH8r?kRA0>_K
zFEQa;v%#uB*(fq~L+_~|m#!CvTN-Ypu8G{Tp#;rM9HBNd)M{g?ggVfl><xE1^&n43
z(v}w}hIO0W?5If;^c$T?a)<@ab6rf#J60o>kb0^q(-Y7uRyC8ZSNX#S<w7?Lb@-AA
zx?ahG#525%nzZEbS~Z<=pGj<agbt;KJlZC)&pFdn^h%9)GSWnTewA3VdsH<Y%x@%z
zSxRiS@|~+@j5_uv4}4qTU{Qm|^e2Y*6EESO<I<j|)d@BCXH)a}iA%-h=8fYGs+q&M
zvene}h!x*c-RH`l<$H5-(Me~fPv>T^;VR>zleo95@j~0+-pM>Jb6%$mF=RzE=Jp4O
zcd#;j>?_~;Ifdg5ie2^SMulTl3E%&DG;8qeCj%#<b6VWo3?J6r{Na?$>DI0YmOV43
zsg-^;`+!PihVX@}75{jHe}x&6cJIjk9o6wx$06g`<cXzuDKmVg-p$Ln$fV51%hY`F
z6_z72*5%A+DaK_kX<Vo!-0U%>ccdl1H_jY`$-aRT1rDc&%Y6Z>{$AoWTuQs^w0Pf{
zQZ8ycW2GV_*o)G?dugqi6sC9NVE#ZCyRXCOt8R%_vh6c2ih5g}nH-K14{*6*LMe|C
zMaXs}u0{H3+5@vs$NdH~ST2RMRA7afl!}#P<=EF*Egi;t)i>WrG;Ue6NcM)U_|hzw
zNz@*=O(?FX<&c9itm9f%9HXR};T;hQWw6z=zISU)_VVrq#X6v+*6|NjDfjBf7>|%y
zao#FWyX5RE<U}z+_R*=YXW6pg)X*^g^idTVM3hZ-J9NPrFb~d!3t<rq!g9C<uCr1Q
z{e@Qk8a(+Zd=fqb>){J<4~)YWcnH1<dtg623Eze1;0N#{cnN+1ufi1k5sstUzo}LE
zFNm@!>0NTbT<C#w;C#3kmcUYY53Gb$@FDm(tc6=3hdZH!3D^c-hOfascpRRBXW$UL
z06$jJP5uL|9zR3ue@d&WFVWXE)b_j9{CAiigA?#qn5m}US2lFR+o2CGfC0Dy-VIm7
zwQvL62sgpaa2tFc?uL!f`bAkQcEZCjsixn;zo515QLOkDd<UL|=i!I&Q+OF(f#1L%
z;B|Nts<w15)1Yokck#d0>SZQ+@xpnq5EjF`U<Hi8`{9G|F&Kq)a68-q1#E_`unTr$
G-+lwjC6>bg

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.2100 b/font/testdata/fixed/7x13.2100
new file mode 100644
index 0000000000000000000000000000000000000000..c565abb7d261646173a5c30caa7f1a325b4c534c
GIT binary patch
literal 3206
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

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.2200 b/font/testdata/fixed/7x13.2200
new file mode 100644
index 0000000000000000000000000000000000000000..a992d3521af0e7ef6bdc2571c9464ab4685208d1
GIT binary patch
literal 3532
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
JL(-$4=s)CzBGUi>

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.2300 b/font/testdata/fixed/7x13.2300
new file mode 100644
index 0000000000000000000000000000000000000000..8ff099d19e02f6fad93292917f7803c5b6424aad
GIT binary patch
literal 1613
zcmeIyKWGzC90%~<yT00=;nWw1SR|NB0>V!yG$cqxAt3~<5NXA3F16Z0L@XB3rS-kb
zwY4Zl(8<j|pqox^f=D(e-Q21UZUqMiF@rB(2r7hbf<tfk+>dv^_q%()dw1urTwb_3
zzqmMmAr<wHOQn9~&*KB*a{2J@@lttU+{>{Pk~Lbdu^|&_CJJ25(Qsm@Op5lc6ezbr
zv`XqrN6`+Fc0;j=OtHfUG>_I?s3or1fJIMIrPWZhlTvr%fQ>N)&4K2qSB@lZzpZ8@
z6v{Luxz)&1;>U7t$Wh*iQ;POmJ|;0yH$3Air$cc;x+#|FntjaTCf7+;b8NnSrX(xt
zdFz59PIqg*ieG}*2U=Q&)7)ILi7whX7W*`mnP*9CtS>3Nq-Bj_&CI4gA-1l6##FWL
z<qv*u?@dd~<?M2LN=+pv+QhT!iSxb4-j4O2K;MXJ=K?*hMHhMt4M~3*-c(~w`)0*a
zP4&8^?5xd*z1eSc>Bt}N<*)viA|l#FBP0Gq<n{4x#9Qcd_98P2i|`O;4b<nCaP=SQ
z>rdbrs_-~Gg*$GcpEZNbv&h_by957i2mD^0!(P1z7vOcc3|HVCcppB5kKl9o0=|N;
tVF$j0AK*v00l&gc_#JlPkm~&<QZNliVGbUIW3U2`!a6(&r&aHh`vpuUr{w?u

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.2400 b/font/testdata/fixed/7x13.2400
new file mode 100644
index 0000000000000000000000000000000000000000..99927a11fc7459a59dbee7018775d7b108a4d0a1
GIT binary patch
literal 1013
zcmd7P&r1|x7zglY*4NqBX<goIjY&3prxqEVlHJraDw-XCWI-^5wLwsuCMHr@5?<EW
zS$Aedg;tCRPcESu5@AH(A!wwa2rpe?PpuHtDT3$_M6^AidFT)5J$&9T56|IwczUi~
z8NAUuG}L=Z;_Gi9vYv{6_@B9<X;VGY@V94EZrp!>CxJpT?h^;WdEsXKL1rdYfQ6ig
zP^QLRgB<h8VRuyY$t)gqMXx_>UbJ){RQt(T>qlJx&6>4f=X{HqGe{fbdd{$=0M{)K
zAxt%`Xi^dsiHsTZuH_MUYF1A}Y$oBZcpS#~(y6%<cdHUpR)@1aY(}qxR7N#>E^5`C
z=DFJYUVl(zIm44?lr43?ny9Smd|1*>DpXVHiAxd(ZB%#iY0wr`b8W?;^6G`<o2yT*
zzJGA$QFGtGh&vowU98D3XSY;jY2wG%^jT8ZmA$8$ddjAZQLYH>BoOMH>g^b>KXTcH
zZ?^-rObCprZ3;`uMD5CwH`AqJkkYVX*`zw4#^;=g`ol})gDoFqLMa8!shHi71?bF>
zfNB;}Y2u5)uMAr=QesHeVXw`~?kHtIwWL6_3<)wGZ6z|%CJnzxWUd&aVkoQ#{o|~>
zZ|ya0X;Zcpip?U#Qc)u_@)V%_b7D7vjT1IEZA8B5nmiKWP;3UT7xkl+Xb|0l)}ax!
z1wD#(peNBT^c>oa_M?O7FnSBM(Mfa~ok4Tx0{R$zhCWAMqHoc6XdW$~pU^Mpcl0M(
nBK+A-LbnRVUEx2pIH8Oa?m}zOeP|<k2sO~-sENkV^SIY<JN~KR

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.2500 b/font/testdata/fixed/7x13.2500
new file mode 100644
index 0000000000000000000000000000000000000000..60dc224cdc4131023a0934f1a81f178ca1995ab9
GIT binary patch
literal 2747
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

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.2600 b/font/testdata/fixed/7x13.2600
new file mode 100644
index 0000000000000000000000000000000000000000..1b393c28ba2753ccfd5a68b0b683f35979da9d16
GIT binary patch
literal 1765
zcmaLWeN0nV6aetk#{=4~mIt=32(gb+W@((E2+B4rr61brHbF{sI#+aJG-I>VxakD;
z`tdBS4k$7weo<?UQX(!Iwz!Y949$kdDVr{0mRP7tW-<jgvm!E9PePU@X7`WZJ-NB}
zo}8O|-roGKbxZZut<~%K^wfAqH5J9@yl2J>=Fj_gUG?nvrGf&Qfj5ESauXSGRaPx9
z-~`}=nPQPA;Q<4gMRbG#zF>nuY;y^XTAL&fNL!L%&S91+1scEwpu5cg@q}C$KR7Y|
zkURYoAgRUhvEJ$pr@)%+l6kvGV>{RSJ_URC(T0j>6+qER!UsU#yu2~2nGsr*2Qw*f
zIRuhYo~jgF6bu>&l5~;_Sq9jQd>SsFBRP-Cj2@GoZgw2%>T_D7cdr~&*NlD6@7~t;
z!~Ve@NVir#7Bx#7^|6FV1X4G!W7)@~r|LJxIL|R8jJUNL`$bV{dX=4NG20&IXi07Z
zXGlXfX0jP7t%kHTrqPG{)rwejFn#WIQO9(F<!twjypMx9S!vm}J9Oo8(SB2^KKRi0
zGVrx5PcCl{)o&Vz*cl;L0RhI&oB2kr|0sBKua@eUwNuSo#6F!=$twF7gQZ!(N$ru|
z@1tmjUEOuPaP~>TA5Nkpe`hOL_GZC_Id#ja29rX5njcuh_h_A7(&8@OF*bN%5h<#z
zg3vDRr`1cdE@(OpF<r#Pr+uC@jZ@5Jl~<eECnpOhL@jAc)U|$}YhZ3)_3TT-mk+9I
z2gnfPCquy|Lw;pN#ObC)oqT_rxFlfoW@o3&D&8LJy<-x~YDdkCU2@jYCOZ*6t{BnJ
zNEA}O4w+6M%w&W8ue;t$HBi44Jio+5t@E*~x_+x%u`~WMUyc=SYt5kt&zJLL<{@zK
zh=O3tQ6BK+#^xS*)2!mW9nsrmA%ETDd%DJ=QA4hk)f_j2KAr33x4Px>mJB6(NwrK@
z!!yu@D^r|mN)@(A<dXvT$TaC^i8s&e4Cc@pXL*UttOch#(cF2!@793D=9Q6_mhEHF
zA-7mvG+LH?B=wld<g<Z;;^@<fukCxbTmy?!#xBjD&9$^q4auaEQu-Ww0+V`cbofg9
z{F;F?0b{#~C}Gc+bL7+zSo|_`kO-K9UM<TPDJ-G-iSZFz63L~i77rguaFy?-Z9sH*
z?g9u8ak6^_QZ+HzDzn9s>%!s{VPPgE^D!w>(^rrnupH_B*(Ky!tr|xoN3PI~IHZT<
zryl!wmGs{e<9|K4MOy5mJpc<l5bYIkh_yV9mZ`YLBqe)ODws7!I>qE9Bp~6GX%oJ)
z0|&~0A*F6cxv~U+QGjQ?l!2+HR;dc6LYn?hf2(K!m<Gwos1OySnP@huL{(@J8cz~G
zwFrF;HKVK1b?7G4ihhXJqb#~7o*3YNjNiW(cOF2Gq9@VQ=ojd>=y~)K`V%^UM$lpO
zKKclKf+ldDR>4P8Q3)zVUqD|(3(!|kEowr`&=u%gXf;}cZbd&rZD<49gziHRqXD!N
zJ%gS@!|3<ukLY#uS2T*=Lr2jVI*BF`Ppg}TiqH&HhUTJq=mJ!Y8qinK3Un2^7Tt($
tMn6F7P$#+@Z9&^mA9@1qLc7s#&|dT++K=8qZ=rY5-_bwOapLKp`3K2Tw4eY0

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.2700 b/font/testdata/fixed/7x13.2700
new file mode 100644
index 0000000000000000000000000000000000000000..c39a57206f4b8bfe8470e0614a93a150a966e81a
GIT binary patch
literal 1762
zcmYe!&n+lQEiO(?;ZlHsY(p3eNE={f8yZ?7#0`zHvn?zY8W?mKT55hMF^0(SwFGE5
zGIh!DiSV^4I504<oDk>>&}e97<zUfpP;@fnIKsif*D1i{^8fP_gZckd`T{f=yqNa?
z|Iff9|Np_ke>$=aE(X>Hkp|@kQw<nkHX50l!I%mPC=M}HU>F6XAut*OqaiRF0<;VP
zUIun{1_mI>2PQ?qqzsr;29sJ~+sPn-W*UM`umF?xVA2gt`hv+2Fc}RdlfYyqm@EL3
H<zRaO_whI?

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.2800 b/font/testdata/fixed/7x13.2800
new file mode 100644
index 0000000000000000000000000000000000000000..c7572de4731279eda4abdb659142f62a728ceaed
GIT binary patch
literal 1918
zcmZwHWmHr_7>DtpE`qy?4PvZ;9lNApp{|YHii#2jAPCqOB@`3v#O^Na1RE6<6AZxa
zZn4-0SKu7(d+u-kGw00Q^UjCs8Q>on<Q*LB?PadgKfW4$${N-AWsQ@wZO*#JF5hfx
z@1P13a;|a}(IVbRD1=&(V&{<*=_o66N|7teO06<9BWJ5tL<xgPAuQDvQk23f&Lbh#
z(L$1~_2vFQ=~lGXdG`ttE-6H&RuYEcK1l{<T1j@wu8@CY_Dm~<rse*oEZjtdM?$2D
zi!7-n*~U$Z@Jo#|iD8x~r^`~-n=U73otKz<pZ+#%9US#hrOI<j8kG=2DNIeV5SG9)
zSP5&O2J2yCY=P~tEB3*GI0OT66pqJ9I0NV65?qBFaR=_hqj(B0;8je;419`j@H75I
zBLiJ`=2!$Ru{>76+GvmUu_?C3j@SeHp*Q+rFpkA=oPslP0WQO}xCM9PL5#<<cnNRd
zU3`cy@I8LRKPVaMx>I6tw8n~99o6WBjj%boVHfO;18^_~;7AO`i8vkS;9^{f8*n@B
z#UpqU&to#CU^+g**Z2uD(a=cOml;}MDJ+LJSPSjY1)E?i?10^|FM6Rb2H_YC!^s$f
z^KmJz!Oge}58!b;gGqQD@8AP`j_>d*{zemHU3UsBhNZCrR>QjJhz(JTZLu@<LJu5-
z!*B%37>UzxHZH;yxE{CR9z2XEFcGidElk75_zFMb4>T~*^;G~1V@WKFm9Zw;qBFW;
zOKgwb&>cN-C=SQbI02(D8s}jwuEtHc6ZhjWJdGFe8s5hH_zd6T7yO0BlCHagSQM>L
zg;lW*I$#5AhHbDD_Qd|^gZ>zT<1hlJ;w)T<%W)lU#W*~K33v`K<4wGWkMJda!0#xs
Ie*HrH1wPyIyZ`_I

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.2A00 b/font/testdata/fixed/7x13.2A00
new file mode 100644
index 0000000000000000000000000000000000000000..71791ace691545674d3417fe10dbcdc5b74d48b2
GIT binary patch
literal 620
zcmYe!&n+lQEiO(?;ZlHsY(p3eNE={hn<I%E8Y9#ovn?$Z8W=<vIw}gDXxJ}wVqoZK
zSt+7nu+WL|PE*UuEesq@DlHvNt!isnI2zA%G;LM$0SZZM>1f{i&qtGkqp?*@fTN{V
zZSDFGEXvI-E4QxXFlBIOkZN*b{L@-d@c8(J{S1*33~;;6OyEofWM>!}DljlG@G`Ko
ugGoLxDGDZKz@##m)B=-+K&1=}a1yA?0xUvj5@@eI*xq440{!9!_6q=D;Yn2h

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.3000 b/font/testdata/fixed/7x13.3000
new file mode 100644
index 0000000000000000000000000000000000000000..fb830f4fbf7ba957f62b83c140db986580d02159
GIT binary patch
literal 569
zcmYe!&n+lQEiO(?;ZlHsY(p3eNE={h8=E4;4UMt0O)L}|7+4ruL>)grU}(`;=&=3(
z154wY1C0TJKw*}~)eemdG#OYpI5~tlWI5D13^^F!2AP?_nF=W88!9kR26!3R*%=ss
bBp=uus*^yIMZxCFfXyFfB+z%tV1EGsfPW_N

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.FB00 b/font/testdata/fixed/7x13.FB00
new file mode 100644
index 0000000000000000000000000000000000000000..3a0b30a999c61c749a6c9717f8dcaa15a132f69c
GIT binary patch
literal 912
zcmd7OO=uHA6bJCxb+D7g)XlOLtHEs6nbs79Y-=GxsZH3*Hc?q5hf)uUwud5OwFe^<
z*|v$c5HYD2?X8FSfd}!@o1Xjtdr<1hn;%GTeo#b%6`cN|nu8Z_F6?jqJl+hCck1k!
zvGXJ2<0HeGweg*HHj+G(f6ZOVh90NuPftVc+}~{lWP%X+Q&Qr|W%t(R)V4t7TP77!
z8XD-nH>weB$|f_OD6(kk94UHfb2dQ*8_efw-hg>Gv2*c|a<rD6GrZ5!D^Fu>$@=Pt
z>DaEG>gto@<(`R))|Is%-#-0(XK*TR&hFrPUtfmWI@9fR#CAPhctuKQDl8WmOq7<c
z@_oKVM7hIfRo>rX=M#SIITgW6CMp^+<F9TXnX|n}yg#ejgt(W}5sg;$cAA?ESxn4l
zADMB3d(}=?_uY(U6Q;XqL!}{|GZE-iEbMte3ibETuC<ck?-e(r_L9)s(u=5CsGn%R
zQS2>zsU&hiw3Ua$fnsjuWU86zzWBYrRKvO(R%tnoCHEL6O--;Fw!kRd4LhJCTM7BE
zl#{10+X2k>Ps+OoarZFH!(;Fy9ED@>0=xuEune!mdANWXr1IrE@IG9G58-3<NM+9w
pvQ*|}_!<?dth|9Ms7PhyBm4^2;3j3guE7Z04r8zl?p4;G_ywSxj1m9<

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.FE00 b/font/testdata/fixed/7x13.FE00
new file mode 100644
index 0000000000000000000000000000000000000000..3989d26732112050483cde6595dfa39d44e4c49b
GIT binary patch
literal 387
zcmYe!&n+lQEiO(?;ZlHsY(p3eNE={h8(AR44UMt0jZGAq<sbY|Xiku1KhVIyz`%k9
k!nGQk!I=suCK@ULwGMT_%fQagzyKuqz@#XclmYt+0LKIxUjP6A

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/7x13.FF00 b/font/testdata/fixed/7x13.FF00
new file mode 100644
index 0000000000000000000000000000000000000000..78ed39865be634d5cc9f1c2865269860501cc1a2
GIT binary patch
literal 1687
zcmYe!&n+lQEiO(?;ZlHsY(p3eNE_f_n<K;xjj^+h%oG|JfY72Lry-=F1W4vI)Bv#s
pNED{U$kYVJR8T-M$xwk|6pV(zXb6mkz-S1Jj1b^uU}p#W6adBZ9>V|t

literal 0
HcmV?d00001

diff --git a/font/testdata/fixed/README b/font/testdata/fixed/README
new file mode 100644
index 0000000..a39f8a5
--- /dev/null
+++ b/font/testdata/fixed/README
@@ -0,0 +1,9 @@
+These font files were copied from the Plan 9 Port's font/fixed directory. The
+README in that directory states that: "These fonts are converted from the BDFs
+in the XFree86 distribution. They were all marked as public domain."
+
+The Plan 9 Port is at https://github.com/9fans/plan9port and the copy was made
+from commit a78b1841 (2015-08-18).
+
+The unicode.7x13.font file also refers to a ../shinonome directory, but this
+testdata does not include those subfont files.
diff --git a/font/testdata/fixed/unicode.7x13.font b/font/testdata/fixed/unicode.7x13.font
new file mode 100644
index 0000000..337b428
--- /dev/null
+++ b/font/testdata/fixed/unicode.7x13.font
@@ -0,0 +1,68 @@
+13 10
+0x0000 0x001F 7x13.2400
+0x0000 0x00FF 7x13.0000
+0x0100 0x01FF 7x13.0100
+0x0200 0x02FF 7x13.0200
+0x0300 0x03FF 7x13.0300
+0x0400 0x04FF 7x13.0400
+0x0500 0x05FF 7x13.0500
+0x0E00 0x0EFF 7x13.0E00
+0x1000 0x10FF 7x13.1000
+0x1600 0x16FF 7x13.1600
+0x1E00 0x1EFF 7x13.1E00
+0x1F00 0x1FFF 7x13.1F00
+0x2000 0x20FF 7x13.2000
+0x2100 0x21FF 7x13.2100
+0x2200 0x22FF 7x13.2200
+0x2300 0x23FF 7x13.2300
+0x2400 0x24FF 7x13.2400
+0x2500 0x25FF 7x13.2500
+0x2600 0x26FF 7x13.2600
+0x2700 0x27FF 7x13.2700
+0x2800 0x28FF 7x13.2800
+0x2A00 0x2AFF 7x13.2A00
+0x3000 0x30fe ../shinonome/k12.3000
+0x4e00 0x4ffe ../shinonome/k12.4e00
+0x5005 0x51fe ../shinonome/k12.5005
+0x5200 0x53fa ../shinonome/k12.5200
+0x5401 0x55fe ../shinonome/k12.5401
+0x5606 0x57fc ../shinonome/k12.5606
+0x5800 0x59ff ../shinonome/k12.5800
+0x5a01 0x5bff ../shinonome/k12.5a01
+0x5c01 0x5dfe ../shinonome/k12.5c01
+0x5e02 0x5fff ../shinonome/k12.5e02
+0x600e 0x61ff ../shinonome/k12.600e
+0x6200 0x63fa ../shinonome/k12.6200
+0x6406 0x65fb ../shinonome/k12.6406
+0x6602 0x67ff ../shinonome/k12.6602
+0x6802 0x69ff ../shinonome/k12.6802
+0x6a02 0x6bf3 ../shinonome/k12.6a02
+0x6c08 0x6dfb ../shinonome/k12.6c08
+0x6e05 0x6ffe ../shinonome/k12.6e05
+0x7001 0x71ff ../shinonome/k12.7001
+0x7206 0x73fe ../shinonome/k12.7206
+0x7403 0x75ff ../shinonome/k12.7403
+0x7601 0x77fc ../shinonome/k12.7601
+0x7802 0x79fb ../shinonome/k12.7802
+0x7a00 0x7bf7 ../shinonome/k12.7a00
+0x7c00 0x7dfb ../shinonome/k12.7c00
+0x7e01 0x7ffc ../shinonome/k12.7e01
+0x8000 0x81fe ../shinonome/k12.8000
+0x8201 0x83fd ../shinonome/k12.8201
+0x8403 0x85fe ../shinonome/k12.8403
+0x8602 0x87fe ../shinonome/k12.8602
+0x8805 0x89f8 ../shinonome/k12.8805
+0x8a00 0x8b9a ../shinonome/k12.8a00
+0x8c37 0x8dff ../shinonome/k12.8c37
+0x8e08 0x8ffd ../shinonome/k12.8e08
+0x9000 0x91ff ../shinonome/k12.9000
+0x920d 0x93e8 ../shinonome/k12.920d
+0x9403 0x95e5 ../shinonome/k12.9403
+0x961c 0x97ff ../shinonome/k12.961c
+0x9801 0x99ff ../shinonome/k12.9801
+0x9a01 0x9bf5 ../shinonome/k12.9a01
+0x9c04 0x9dfd ../shinonome/k12.9c04
+0x9e1a 0x9fa0 ../shinonome/k12.9e1a
+0xFB00 0xFBFF 7x13.FB00
+0xFE00 0xFEFF 7x13.FE00
+0xFF00 0xFFFF 7x13.FF00