xgb-text-viewer: add a demo text viewer

More of a real application and just needs pictures in order to bring
the parts I have so far all together.

1 files changed, 538 insertions, 0 deletions

diff --git a/prototypes/xgb-text-viewer.go b/prototypes/xgb-text-viewer.go
new file mode 100644
index 0000000..e740138
--- /dev/null
+++ b/prototypes/xgb-text-viewer.go
@@ -0,0 +1,538 @@
+// This is an amalgamation of xgb-xrender.go and xgb-keys.go and more of a demo,
+// some comments have been stripped.
+package main
+
+import (
+	"github.com/BurntSushi/xgb"
+	"github.com/BurntSushi/xgb/render"
+	"github.com/BurntSushi/xgb/xproto"
+	"github.com/golang/freetype"
+	"github.com/golang/freetype/truetype"
+	"golang.org/x/image/font"
+	"golang.org/x/image/font/gofont/goregular"
+	"golang.org/x/image/math/fixed"
+	"image"
+	"image/draw"
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+)
+
+func glyphListBytes(buf []byte, runes []rune, size int) int {
+	b := 0
+	for _, r := range runes {
+		switch size {
+		default:
+			buf[b] = byte(r)
+			b += 1
+		case 2:
+			xgb.Put16(buf[b:], uint16(r))
+			b += 2
+		case 4:
+			xgb.Put32(buf[b:], uint32(r))
+			b += 4
+		}
+	}
+	return xgb.Pad(b)
+}
+
+// When the len is 255, a GLYPHABLE follows, otherwise a list of CARD8/16/32.
+func glyphEltHeaderBytes(buf []byte, len byte, deltaX, deltaY int16) int {
+	b := 0
+	buf[b] = len
+	b += 4
+	xgb.Put16(buf[b:], uint16(deltaX))
+	b += 2
+	xgb.Put16(buf[b:], uint16(deltaY))
+	b += 2
+	return xgb.Pad(b)
+}
+
+type xgbCookie interface{ Check() error }
+
+// compositeString makes an appropriate render.CompositeGlyphs request,
+// assuming that glyphs equal Unicode codepoints.
+func compositeString(c *xgb.Conn, op byte, src, dst render.Picture,
+	maskFormat render.Pictformat, glyphset render.Glyphset, srcX, srcY int16,
+	destX, destY int16, text string) xgbCookie {
+	runes := []rune(text)
+
+	var highest rune
+	for _, r := range runes {
+		if r > highest {
+			highest = r
+		}
+	}
+
+	size := 1
+	switch {
+	case highest > 1<<16:
+		size = 4
+	case highest > 1<<8:
+		size = 2
+	}
+
+	// They gave up on the XCB protocol API and we need to serialize explicitly.
+
+	// To spare us from caring about the padding, use the largest number lesser
+	// than 255 that is divisible by 4 (for size 2 and 4 the requirements are
+	// less strict but this works in the general case).
+	const maxPerChunk = 252
+
+	buf := make([]byte, (len(runes)+maxPerChunk-1)/maxPerChunk*8+len(runes)*size)
+	b := 0
+
+	for len(runes) > maxPerChunk {
+		b += glyphEltHeaderBytes(buf[b:], maxPerChunk, 0, 0)
+		b += glyphListBytes(buf[b:], runes[:maxPerChunk], size)
+		runes = runes[maxPerChunk:]
+	}
+	if len(runes) > 0 {
+		b += glyphEltHeaderBytes(buf[b:], byte(len(runes)), destX, destY)
+		b += glyphListBytes(buf[b:], runes, size)
+	}
+
+	switch size {
+	default:
+		return render.CompositeGlyphs8(c, op, src, dst, maskFormat, glyphset,
+			srcX, srcY, buf)
+	case 2:
+		return render.CompositeGlyphs16(c, op, src, dst, maskFormat, glyphset,
+			srcX, srcY, buf)
+	case 4:
+		return render.CompositeGlyphs32(c, op, src, dst, maskFormat, glyphset,
+			srcX, srcY, buf)
+	}
+}
+
+type textRenderer struct {
+	f    *truetype.Font
+	opts *truetype.Options
+	face font.Face
+
+	bounds fixed.Rectangle26_6 // outer bounds for all the font's glyph
+	buf    *image.RGBA         // rendering buffer
+
+	X      *xgb.Conn
+	gsid   render.Glyphset
+	loaded map[rune]bool
+}
+
+func newTextRenderer(X *xgb.Conn, ttf []byte, opts *truetype.Options) (
+	*textRenderer, error) {
+	pformats, err := render.QueryPictFormats(X).Reply()
+	if err != nil {
+		return nil, err
+	}
+
+	// We use RGBA here just so that lines are padded to 32 bits.
+	// Since there's no subpixel antialiasing and alpha is premultiplied,
+	// it doesn't even mater that RGBA is interpreted as ARGB or BGRA.
+	var rgbFormat render.Pictformat
+	for _, pf := range pformats.Formats {
+		if pf.Depth == 32 && pf.Direct.AlphaMask != 0 {
+			rgbFormat = pf.Id
+			break
+		}
+	}
+
+	tr := &textRenderer{opts: opts, X: X, loaded: make(map[rune]bool)}
+	if tr.f, err = freetype.ParseFont(goregular.TTF); err != nil {
+		return nil, err
+	}
+
+	tr.face = truetype.NewFace(tr.f, opts)
+	tr.bounds = tr.f.Bounds(fixed.Int26_6(opts.Size * float64(opts.DPI) *
+		(64.0 / 72.0)))
+
+	if tr.gsid, err = render.NewGlyphsetId(X); err != nil {
+		return nil, err
+	}
+	if err := render.CreateGlyphSetChecked(X, tr.gsid, rgbFormat).
+		Check(); err != nil {
+		return nil, err
+	}
+
+	tr.buf = image.NewRGBA(image.Rect(
+		+tr.bounds.Min.X.Floor(),
+		-tr.bounds.Min.Y.Floor(),
+		+tr.bounds.Max.X.Ceil(),
+		-tr.bounds.Max.Y.Ceil(),
+	))
+	return tr, nil
+}
+
+func (tr *textRenderer) addRune(r rune) bool {
+	dr, mask, maskp, advance, ok := tr.face.Glyph(
+		fixed.P(0, 0) /* subpixel destination location */, r)
+	if !ok {
+		return false
+	}
+
+	for i := 0; i < len(tr.buf.Pix); i++ {
+		tr.buf.Pix[i] = 0
+	}
+
+	// Copying, since there are absolutely no guarantees.
+	draw.Draw(tr.buf, dr, mask, maskp, draw.Src)
+
+	_ = render.AddGlyphs(tr.X, tr.gsid, 1, []uint32{uint32(r)},
+		[]render.Glyphinfo{{
+			Width:  uint16(tr.buf.Rect.Size().X),
+			Height: uint16(tr.buf.Rect.Size().Y),
+			X:      int16(-tr.bounds.Min.X.Floor()),
+			Y:      int16(+tr.bounds.Max.Y.Ceil()),
+			XOff:   int16(advance.Ceil()),
+			YOff:   int16(0),
+		}}, []byte(tr.buf.Pix))
+	return true
+}
+
+func (tr *textRenderer) render(src, dst render.Picture,
+	srcX, srcY, destX, destY int16, text string) xgbCookie {
+	// XXX: You're really supposed to handle tabs differently from this.
+	text = strings.Replace(text, "\t", "    ", -1)
+
+	for _, r := range text {
+		if !tr.loaded[r] {
+			tr.addRune(r)
+			tr.loaded[r] = true
+		}
+	}
+
+	return compositeString(tr.X, render.PictOpOver, src, dst,
+		0 /* TODO: mask Pictureformat? */, tr.gsid,
+		srcX, srcY, destX, destY, text)
+}
+
+const (
+	ksEscape     = 0xff1b
+	ksUp         = 0xff52
+	ksDown       = 0xff54
+	ksPageUp     = 0xff55
+	ksPageDown   = 0xff56
+	ksModeSwitch = 0xff7e
+)
+
+type keyMapper struct {
+	X       *xgb.Conn
+	setup   *xproto.SetupInfo
+	mapping *xproto.GetKeyboardMappingReply
+
+	modeSwitchMask uint16
+}
+
+func newKeyMapper(X *xgb.Conn) (*keyMapper, error) {
+	m := &keyMapper{X: X, setup: xproto.Setup(X)}
+	if err := m.update(); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (km *keyMapper) update() error {
+	var err error
+	km.mapping, err = xproto.GetKeyboardMapping(km.X, km.setup.MinKeycode,
+		byte(km.setup.MaxKeycode-km.setup.MinKeycode+1)).Reply()
+	if err != nil {
+		return err
+	}
+
+	km.modeSwitchMask = 0
+
+	// The order is "Shift, Lock, Control, Mod1, Mod2, Mod3, Mod4, and Mod5."
+	mm, err := xproto.GetModifierMapping(km.X).Reply()
+	if err != nil {
+		return err
+	}
+
+	perMod := int(mm.KeycodesPerModifier)
+	perKc := int(km.mapping.KeysymsPerKeycode)
+	for mod := 0; mod < 8; mod++ {
+		for _, kc := range mm.Keycodes[mod*perMod : (mod+1)*perMod] {
+			if kc == 0 {
+				continue
+			}
+
+			k := int(kc - km.setup.MinKeycode)
+			for _, ks := range km.mapping.Keysyms[k*perKc : (k+1)*perKc] {
+				if ks == ksModeSwitch {
+					km.modeSwitchMask |= 1 << uint(mod)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func (km *keyMapper) decode(e xproto.KeyPressEvent) (result xproto.Keysym) {
+	step := int(km.mapping.KeysymsPerKeycode)
+	from := int(e.Detail-km.setup.MinKeycode) * step
+	ks := km.mapping.Keysyms[from : from+step]
+
+	// Strip trailing NoSymbol entries.
+	for len(ks) > 0 && ks[len(ks)-1] == 0 {
+		ks = ks[:len(ks)-1]
+	}
+
+	// Expand back to at least 4.
+	switch {
+	case len(ks) == 1:
+		ks = append(ks, 0, ks[0], 0)
+	case len(ks) == 2:
+		ks = append(ks, ks[0], ks[1])
+	case len(ks) == 3:
+		ks = append(ks, 0)
+	}
+
+	// Other silly expansion rules, only applied to basic ASCII since we
+	// don't have translation tables to Unicode here for brevity.
+	if ks[1] == 0 {
+		ks[1] = ks[0]
+		if ks[0] >= 'A' && ks[0] <= 'Z' ||
+			ks[0] >= 'a' && ks[0] <= 'z' {
+			ks[0] = ks[0] | 32
+			ks[1] = ks[0] &^ 32
+		}
+	}
+
+	if ks[3] == 0 {
+		ks[3] = ks[2]
+		if ks[2] >= 'A' && ks[2] <= 'Z' ||
+			ks[2] >= 'a' && ks[2] <= 'z' {
+			ks[2] = ks[2] | 32
+			ks[3] = ks[2] &^ 32
+		}
+	}
+
+	offset := 0
+	if e.State&km.modeSwitchMask != 0 {
+		offset += 2
+	}
+
+	shift := e.State&xproto.ModMaskShift != 0
+	lock := e.State&xproto.ModMaskLock != 0
+	switch {
+	case !shift && !lock:
+		result = ks[offset+0]
+	case !shift && lock:
+		if ks[offset+0] >= 'a' && ks[offset+0] <= 'z' {
+			result = ks[offset+1]
+		} else {
+			result = ks[offset+0]
+		}
+	case shift && lock:
+		if ks[offset+1] >= 'a' && ks[offset+1] <= 'z' {
+			result = ks[offset+1] &^ 32
+		} else {
+			result = ks[offset+1]
+		}
+	case shift:
+		result = ks[offset+1]
+	}
+	return
+}
+
+func main() {
+	if len(os.Args) < 2 {
+		log.Fatalln("no filename given")
+	}
+
+	text, err := ioutil.ReadFile(os.Args[1])
+	if err != nil {
+		log.Fatalln(err)
+	}
+	lines := strings.Split(string(text), "\n")
+
+	X, err := xgb.NewConn()
+	if err != nil {
+		log.Fatalln(err)
+	}
+	if err := render.Init(X); err != nil {
+		log.Fatalln(err)
+	}
+
+	setup := xproto.Setup(X)
+	screen := setup.DefaultScreen(X)
+
+	visual, depth := screen.RootVisual, screen.RootDepth
+	// TODO: We should check that we find it, though we don't /need/ alpha here,
+	// it's just a minor improvement--affects the backpixel value.
+	for _, i := range screen.AllowedDepths {
+		// TODO: Could/should check other parameters.
+		for _, v := range i.Visuals {
+			if i.Depth == 32 && v.Class == xproto.VisualClassTrueColor {
+				visual, depth = v.VisualId, i.Depth
+				break
+			}
+		}
+	}
+
+	mid, err := xproto.NewColormapId(X)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	_ = xproto.CreateColormap(
+		X, xproto.ColormapAllocNone, mid, screen.Root, visual)
+
+	wid, err := xproto.NewWindowId(X)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	// Border pixel and colormap are required when depth differs from parent.
+	_ = xproto.CreateWindow(X, depth, wid, screen.Root,
+		0, 0, 500, 500, 0, xproto.WindowClassInputOutput,
+		visual, xproto.CwBackPixel|xproto.CwBorderPixel|xproto.CwEventMask|
+			xproto.CwColormap, []uint32{0xf0f0f0f0, 0,
+			xproto.EventMaskStructureNotify | xproto.EventMaskKeyPress |
+				/* KeymapNotify */ xproto.EventMaskKeymapState |
+				xproto.EventMaskExposure | xproto.EventMaskButtonPress,
+			uint32(mid)})
+
+	title := []byte("Viewer")
+	_ = xproto.ChangeProperty(X, xproto.PropModeReplace, wid, xproto.AtomWmName,
+		xproto.AtomString, 8, uint32(len(title)), title)
+
+	_ = xproto.MapWindow(X, wid)
+
+	pformats, err := render.QueryPictFormats(X).Reply()
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	// Similar to XRenderFindVisualFormat.
+	// The DefaultScreen is almost certain to be zero.
+	var pformat render.Pictformat
+	for _, pd := range pformats.Screens[X.DefaultScreen].Depths {
+		// This check seems to be slightly extraneous.
+		if pd.Depth != depth {
+			continue
+		}
+		for _, pv := range pd.Visuals {
+			if pv.Visual == visual {
+				pformat = pv.Format
+			}
+		}
+	}
+
+	pid, err := render.NewPictureId(X)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	render.CreatePicture(X, pid, xproto.Drawable(wid), pformat, 0, []uint32{})
+
+	blackid, err := render.NewPictureId(X)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	_ = render.CreateSolidFill(X, blackid, render.Color{Alpha: 0xffff})
+
+	tr, err := newTextRenderer(X, goregular.TTF, &truetype.Options{
+		Size: 10,
+		DPI: float64(screen.WidthInPixels) /
+			float64(screen.WidthInMillimeters) * 25.4,
+		Hinting: font.HintingFull,
+	})
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	scroll := 0 // index of the top line
+
+	var w, h uint16
+	redraw := func() {
+		y, ascent, step := 5, tr.bounds.Max.Y.Ceil(),
+			tr.bounds.Max.Y.Ceil()-tr.bounds.Min.Y.Floor()
+		for _, line := range lines[scroll:] {
+			if uint16(y) >= h {
+				break
+			}
+			_ = tr.render(blackid, pid, 0, 0, 5, int16(y+ascent), line)
+			y += step
+		}
+
+		vis := float64(h-10) / float64(step)
+		if vis < float64(len(lines)) {
+			length := float64(step) * (vis + 1) * vis / float64(len(lines))
+			start := float64(step) * float64(scroll) * vis / float64(len(lines))
+
+			_ = render.FillRectangles(X, render.PictOpSrc, pid,
+				render.Color{Alpha: 0xffff}, []xproto.Rectangle{{
+					X: int16(w - 15), Y: int16(start),
+					Width: 15, Height: uint16(length + 10)}})
+		}
+	}
+
+	km, err := newKeyMapper(X)
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	for {
+		ev, xerr := X.WaitForEvent()
+		if xerr != nil {
+			log.Printf("Error: %s\n", xerr)
+			return
+		}
+		if ev == nil {
+			return
+		}
+
+		switch e := ev.(type) {
+		case xproto.UnmapNotifyEvent:
+			return
+
+		case xproto.ConfigureNotifyEvent:
+			w, h = e.Width, e.Height
+
+		case xproto.MappingNotifyEvent:
+			_ = km.update()
+
+		case xproto.KeyPressEvent:
+			_ = xproto.ClearArea(X, true /* ExposeEvent */, wid, 0, 0, w, h)
+
+			const pageJump = 40
+			switch km.decode(e) {
+			case ksEscape:
+				return
+			case ksUp:
+				if scroll >= 1 {
+					scroll--
+				}
+			case ksDown:
+				if scroll+1 < len(lines) {
+					scroll++
+				}
+			case ksPageUp:
+				if scroll >= pageJump {
+					scroll -= pageJump
+				}
+			case ksPageDown:
+				if scroll+pageJump < len(lines) {
+					scroll += pageJump
+				}
+			}
+
+		case xproto.ButtonPressEvent:
+			_ = xproto.ClearArea(X, true /* ExposeEvent */, wid, 0, 0, w, h)
+
+			switch e.Detail {
+			case xproto.ButtonIndex4:
+				if scroll > 0 {
+					scroll--
+				}
+			case xproto.ButtonIndex5:
+				if scroll+1 < len(lines) {
+					scroll++
+				}
+			}
+
+		case xproto.ExposeEvent:
+			// FIXME: The window's context haven't necessarily been destroyed.
+			if e.Count == 0 {
+				redraw()
+			}
+		}
+	}
+}