path: root/liust-50/cmd/liustsim/simulator.go

package main

import (
	"bufio"
	"image"
	"image/color"
	"log"
	"os"
	"strconv"
	"strings"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/canvas"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/layout"
	"fyne.io/fyne/v2/theme"
	"fyne.io/fyne/v2/widget"

	"janouch.name/desktop-tools/liust-50/charset"
)

const (
	displayWidth  = 20
	displayHeight = 2
	charWidth     = 5 + 1
	charHeight    = 7 + 1
	magnification = 5
)

// TODO(p): See how this works exactly, and implement it.
const (
	cursorModeOff = iota
	cursorModeBlink
	cursorModeLightUp
)

type Display struct {
	chars      [displayHeight][displayWidth]uint8
	charset    uint8
	cursorX    int
	cursorY    int
	cursorMode int
}

func NewDisplay() *Display {
	return &Display{charset: 2}
}

func (d *Display) Clear() {
	for y := 0; y < displayHeight; y++ {
		for x := 0; x < displayWidth; x++ {
			d.chars[y][x] = 0x20 // space
		}
	}
}

func (d *Display) ClearToEnd() {
	for x := d.cursorX; x < displayWidth; x++ {
		d.chars[d.cursorY][x] = 0x20 // space
	}
}

func (d *Display) drawCharacter(
	img *image.RGBA, charImg image.Image, cx, cy int) {
	if charImg == nil {
		return
	}

	bounds := charImg.Bounds()
	width, height := bounds.Dx(), bounds.Dy()
	for dy := 0; dy < height; dy++ {
		for dx := 0; dx < width; dx++ {
			var c color.RGBA
			if r, _, _, _ := charImg.At(
				bounds.Min.X+dx, bounds.Min.Y+dy).RGBA(); r >= 0x8000 {
				c = color.RGBA{0x00, 0xFF, 0xC0, 0xFF}
			} else {
				c = color.RGBA{0x20, 0x20, 0x20, 0xFF}
			}
			img.SetRGBA(1+cx*charWidth+dx, 1+cy*charHeight+dy, c)
		}
	}
}

func (d *Display) Render() image.Image {
	// XXX: The VFD display doesn't have rectangular pixels,
	// they are rather elongated in a 3:4 ratio.
	width := 1 + displayWidth*charWidth
	height := 1 + displayHeight*charHeight

	// XXX: Not sure if we rather don't want to provide double buffering,
	// meaning we would cycle between two internal buffers.
	img := image.NewRGBA(image.Rect(0, 0, width, height))

	black := [4]uint8{0x00, 0x00, 0x00, 0xFF}
	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ {
			copy(img.Pix[img.PixOffset(x, y):], black[:])
		}
	}

	for cy := 0; cy < displayHeight; cy++ {
		for cx := 0; cx < displayWidth; cx++ {
			charImg := charset.ResolveCharToImage(d.chars[cy][cx], d.charset)
			d.drawCharacter(img, charImg, cx, cy)
		}
	}

	return img
}

func (d *Display) PutChar(ch uint8) {
	if d.cursorX >= displayWidth || d.cursorY >= displayHeight {
		return
	}

	d.chars[d.cursorY][d.cursorX] = ch
	d.cursorX++
	if d.cursorX >= displayWidth {
		d.cursorX = displayWidth - 1
	}
}

func (d *Display) LineFeed() {
	d.cursorY++
	if d.cursorY >= displayHeight {
		d.cursorY = displayHeight - 1

		// XXX: This relies on displayHeight being exactly 2.
		d.chars[0] = d.chars[1]
		for x := 0; x < displayWidth; x++ {
			d.chars[1][x] = 0x20
		}
	}
}

func (d *Display) CarriageReturn() {
	d.cursorX = 0
}

func (d *Display) Backspace() {
	if d.cursorX > 0 {
		d.cursorX--
	}
}

func (d *Display) SetCursor(x, y int) {
	if x >= 0 && x < displayWidth {
		d.cursorX = x
	}
	if y >= 0 && y < displayHeight {
		d.cursorY = y
	}
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

func parseANSI(input string) (command string, params []int) {
	if !strings.HasPrefix(input, "\x1b[") {
		return "", nil
	}

	input = input[2:]
	if len(input) == 0 {
		return "", nil
	}

	cmdIdx := len(input) - 1
	command = string(input[cmdIdx])

	paramStr := input[:cmdIdx]
	if paramStr == "" {
		return command, []int{}
	}

	parts := strings.Split(paramStr, ";")
	for _, p := range parts {
		p = strings.TrimSpace(p)
		if val, err := strconv.Atoi(p); err == nil {
			params = append(params, val)
		}
	}
	return command, params
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

type protocolParser struct {
	seq     strings.Builder
	inEsc   bool
	inCSI   bool
	display *Display
}

func newProtocolParser(d *Display) *protocolParser {
	return &protocolParser{display: d}
}

func (pp *protocolParser) reset() {
	pp.inEsc = false
	pp.inCSI = false
	pp.seq.Reset()
}

func (pp *protocolParser) handleCSICommand() bool {
	cmd, params := parseANSI(pp.seq.String())

	switch cmd {
	case "J": // Clear display
		// XXX: The no params case is unverified.
		if len(params) == 0 || params[0] == 2 {
			pp.display.Clear()
		}
	case "K": // Delete to end of line
		// XXX: The no params case is unverified (but it should work).
		if len(params) == 0 || params[0] == 0 {
			pp.display.ClearToEnd()
		}
	case "H": // Cursor position
		y, x := 0, 0
		if len(params) >= 1 {
			y = params[0] - 1 // 1-indexed to 0-indexed
		}
		if len(params) >= 2 {
			x = params[1] - 1
		}
		pp.display.SetCursor(x, y)
	}
	return true
}

func (pp *protocolParser) handleEscapeSequence(b byte) bool {
	pp.seq.WriteByte(b)

	if pp.seq.Len() == 2 && b == '[' {
		pp.inCSI = true
		return false
	}

	if pp.seq.Len() == 3 && pp.seq.String()[1] == 'R' {
		pp.display.charset = b
		pp.reset()
		return true
	}

	if pp.inCSI && (b >= 'A' && b <= 'Z' || b >= 'a' && b <= 'z') {
		refresh := pp.handleCSICommand()
		pp.reset()
		return refresh
	}

	if pp.seq.Len() == 6 && pp.seq.String()[1:5] == "\\?LC" {
		pp.display.cursorMode = int(pp.seq.String()[5])
		return true
	}

	return false
}

func (pp *protocolParser) handleCharacter(b byte) bool {
	switch b {
	case 0x0A: // LF
		pp.display.LineFeed()
		return true
	case 0x0D: // CR
		pp.display.CarriageReturn()
		return true
	case 0x08: // BS
		pp.display.Backspace()
		return true
	default:
		if b >= 0x20 {
			pp.display.PutChar(b)
			return true
		}
	}
	return false
}

func (pp *protocolParser) handleByte(b byte) (needsRefresh bool) {
	if b == 0x1b { // ESC
		pp.reset()
		pp.inEsc = true
		pp.seq.WriteByte(b)
		return false
	}
	if pp.inEsc {
		return pp.handleEscapeSequence(b)
	}

	return pp.handleCharacter(b)
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

type DisplayWidget struct {
	widget.BaseWidget
	display *Display
}

type DisplayRenderer struct {
	image *canvas.Image
	label *canvas.Text

	objects       []fyne.CanvasObject
	displayWidget *DisplayWidget
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

func main() {
	a := app.New()
	a.Settings().SetTheme(theme.DarkTheme())
	window := a.NewWindow("Toshiba Tec LIUST-50 Simulator")

	display := NewDisplay()
	display.Clear()

	// TODO(p): It makes the most sense to create a custom widget.
	//
	//  - How does Fyne render text?
	//     - Do I need to give it a left top position and pixel size, or?
	//     - canvas.NewText → canvas.Text
	//
	//  - How does the Fyne model work?
	//     - All Windows have a Canvas.
	//     - Everything drawn, including Widgets, is a CanvasObject.
	//     - After CanvasObject updates, call Refresh on them.
	//        - It seems like this does not work hierarchically,
	//          and there's a generic canvas.Refresh() function,
	//          and Refresh() methods generally just invoke that.
	//     - window.SetContent() takes a CanvasObject.
	//     - How do WidgetRenderers work?
	//     - How would a widget that renders itself stretched work?
	//
	//  - What the heck do I need?
	//     - *canvas.Image, *canvas.Text
	//
	//  - Behaviour:
	//     - Requesting a minimum size:
	//        - Return the pixel size of the display,
	//          and at the bottom add the label.
	//        - For a character 84 pixels tall,
	//          the TOSHIBA label is 35 pixels tall.
	//          That means the TOSHIBA label is 3 pixels tall.
	//     - Given a size allocation:
	//        - How does the API work?
	//     - Rendering:
	//        - This should really be the work of two CanvasObject subobjects.
	//        - The bitmap will be rendered pixel-stretched.
	//        - Below it, the text will be rendered.
	//
	//  _______________________
	// |                      |
	// |       VFD 2x20       |
	// |______________________|
	// |________Label_________|
	//
	//  -
	//
	img := canvas.NewImageFromImage(display.Render())
	img.FillMode = canvas.ImageFillOriginal
	img.ScaleMode = canvas.ImageScalePixels

	c := container.New(layout.NewVBoxLayout(), layout.NewSpacer(), img, layout.NewSpacer())

	window.SetContent(c)

	window.Resize(fyne.NewSize(600, 100))

	go func() {
		reader := bufio.NewReader(os.Stdin)
		parser := newProtocolParser(display)

		for {
			b, err := reader.ReadByte()
			if err != nil {
				log.Println(err)
				return
			}

			if parser.handleByte(b) {
				fyne.DoAndWait(func() {
					img.Image = display.Render()
					img.Refresh()
				})
			}
		}
	}()

	window.ShowAndRun()
}