Updated, decrease memory usage/garbage.

door/benchmark.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+go test -bench=BenchmarkLine -benchmem -memprofile memory.out -cpuprofile cpu.out
+echo go tool pprof memory.out
+echo go tool pprof cpu.out
+

door/box.go

@@ -85,7 +85,7 @@ func (b *Box) Bottom() string {
 
 func AlertBox(text string, style int) []string {
 	var results []string
-	b := Box{Width: StringLen(text), Style: style}
+	b := Box{Width: StringLen([]byte(text)), Style: style}
 	results = append(results, b.Top())
 	results = append(results, b.Row(text))
 	results = append(results, b.Bottom())

door/door.go

@@ -42,6 +42,8 @@ const DEBUG_OUTPUT bool = false
 
 // See door_test.go for DEBUG test const
 
+// Right now these are strings.  Should they be []byte ?
+
 const SavePos = "\x1b[s"              // Save Cursor Position
 const RestorePos = "\x1b[u"           // Restore Cursor Position
 const CRNL = "\r\n"                   // BBS Line Ending
@@ -64,14 +66,14 @@ var Height int                                                  // Screen height
 var Width int                                                   // Screen width detected
 var Inactivity time.Duration = time.Duration(120) * time.Second // Inactivity timeout
 
-type ColorRender func([]byte) []byte
-type Update func() []byte
+type ColorRender func(*bytes.Buffer, []byte) []byte
+type Updater func(*bytes.Buffer)
 
-type Updater interface {
-	Updater() bool
+type UpdaterI interface {
+	Update() bool
 }
 
-type Output interface {
+type OutputI interface {
 	Output() []byte
 }
 
@@ -433,6 +435,10 @@ func Goto(x int, y int) []byte {
 	return output
 }
 
+func GotoS(x int, y int) string {
+	return fmt.Sprintf("\x1b[%d;%dH", y, x)
+}
+
 func (d *Door) setupChannels() {
 	d.wg.Add(1)
 	go Reader(d)

door/line.go

@@ -78,11 +78,17 @@ and outputs the new time.
 Line of text to display.
 */
 type Line struct {
-	Text         bytes.Buffer // Text to be displayed
-	DefaultColor string       // Default Color to use
-	RenderF      ColorRender  // Render function (displays string with colors)
-	UpdateF      Update       // Update function updates the text
-	Width        int          // Line length
+	Text         *bytes.Buffer // Text to be displayed
+	update       *bytes.Buffer // Buffer for updates
+	DefaultColor string        // Default Color to use
+	RenderF      ColorRender   // Render function (displays string with colors)
+	render       *bytes.Buffer // Buffer for rendering
+	UpdateF      Updater       // Update function updates the text
+	Width        int           // Line length
+}
+
+func NewLine(text string) Line {
+	return Line{Text: bytes.NewBuffer([]byte(text))}
 }
 
 /*
@@ -90,17 +96,23 @@ Line Update - This calls the UpdateF if present.
 
 Returns true if the line has been updated, and there's an Update function.
 */
-func (l *Line) Updater() bool {
+func (l *Line) Update() bool {
+	if l.Text == nil {
+		l.Text = &bytes.Buffer{}
+	}
 	if l.UpdateF == nil {
 		return false
 	}
+	if l.update == nil {
+		l.update = &bytes.Buffer{}
+	}
+	l.update.Reset()
+	l.UpdateF(l.update)
 
-	var NewText bytes.Buffer
-	NewText.Write(l.UpdateF())
-	l.LineLength(&NewText)
-	if bytes.Compare(NewText.Bytes(), l.Text.Bytes()) != 0 {
+	l.LineLength(l.update)
+	if bytes.Compare(l.update.Bytes(), l.Text.Bytes()) != 0 {
 		l.Text.Reset()
-		l.Text.Write(NewText.Bytes())
+		l.Text.Write(l.update.Bytes())
 		return true
 	}
 	return false
@@ -111,14 +123,23 @@ func (l *Line) LineLength(text *bytes.Buffer) {
 	if l.Width == 0 {
 		return
 	}
-	var length int = text.Len() // StringLen(*text)
-	/*
-		if Unicode {
-			length = len([]rune(*text))
-		} else {
-			length = len([]byte(*text))
+	var length int
+
+	if Unicode {
+		var ubuff *bytes.Buffer = bytes.NewBuffer(text.Bytes())
+		var e error
+		var r rune
+		for {
+			r, _, e = ubuff.ReadRune()
+			if e != nil {
+				break
+			}
+			length += UnicodeWidth(r)
 		}
-	*/
+	} else {
+		length = text.Len()
+	}
+
 	if length > l.Width {
 		log.Printf("ERROR: Line Width %d: Have %d\n", l.Width, length)
 	} else {
@@ -138,105 +159,24 @@ to RenderF and return what it returns.
 */
 func (l *Line) Output() []byte {
 	if l.UpdateF == nil {
-		l.LineLength(&l.Text)
+		l.LineLength(l.Text)
+	}
+	if l.render == nil {
+		l.render = &bytes.Buffer{}
 	}
 	if l.RenderF == nil {
-		var output bytes.Buffer
-		output.WriteString(l.DefaultColor)
-		output.Write(l.Text.Bytes())
-		return output.Bytes()
+		l.render.Reset()
+		l.render.WriteString(l.DefaultColor)
+		l.render.Write(l.Text.Bytes())
+		return l.render.Bytes()
 		// return l.DefaultColor + l.Text
 	} else {
-		return l.RenderF(l.Text.Bytes())
-	}
-}
-
-/*
-door.Render - Helper for Line RenderF (Render Function)
-
-Example:
-
-	// RenderStatus - KEY_COLOR[key] COLON_COLOR[:] VALUE_COLOR[value]
-	func RenderStatus(text string) string {
-		var r door.Render = Render{Line: text}
-		var bool inValue = false
-		var key string = door.ColorText("BLUE")
-		var colon string = door.ColorText("BRIGHT WHITE")
-		var value string = door.ColorText("MAGENTA")
-
-		for _, letter := range text {
-			if letter == ':' {
-				r.Append(colon, 1)
-				inValue = true
-			} else {
-				if inValue {
-					r.Append(value, 1)
-				} else {
-					r.Append(key, 1)
-				}
-			}
-		}
-		return r.Result
-	}
-*/
-type Render struct {
-	Line      string // Original Text
-	Result    string // Output Result
-	Pos       int    // Current Position
-	LastColor string // LastColor code sent
-}
-
-/*
-Render.Append - Output len number of characters in the color.
-
-This uses Render.LastColor to tell if we've already sent that color before.
-*/
-func (r *Render) Append(color string, len int) {
-	if color != r.LastColor {
-		r.LastColor = color
-		r.Result += color
-	}
-
-	if Unicode {
-		// Treat unicode as []rune.
-		r.Result += string([]rune(r.Line)[r.Pos : r.Pos+len])
-	} else {
-		r.Result += r.Line[r.Pos : r.Pos+len]
+		return l.RenderF(l.render, l.Text.Bytes())
 	}
-	r.Pos += len
 }
 
-// RenderBlueYellow - Uppercase is Bold Blue, everything else is Yellow.
-// This is an example of using the door.Render routines.
-func RenderBlueYellowOld(text string) string {
-	var r Render = Render{Line: text}
-
-	var blue string = ColorText("BOLD BLUE")
-	var yellow string = ColorText("BOLD YELLOW")
-
-	for _, letter := range text {
-		if unicode.IsUpper(letter) {
-			r.Append(blue, 1)
-		} else {
-			r.Append(yellow, 1)
-		}
-	}
-	return r.Result
-}
-
-/*
-var RenderPool = sync.Pool{
-	New: func() any {
-		return new(strings.Builder)
-	},
-}
-*/
-
-// Render is the old way of doing things...
-// Using strings.Builder ...
-
-func RenderBlueYellow(text []byte) []byte {
-	var output bytes.Buffer
+func RenderBlueYellow(output *bytes.Buffer, text []byte) []byte {
+	output.Reset()
 
 	// var output = RenderPool.Get().(*strings.Builder)
 	// output.Reset()

door/line_test.go

@@ -3,13 +3,12 @@ package door
 import (
 	"bytes"
 	"fmt"
-	"strconv"
 	"testing"
 	"unicode"
 )
 
 func TestLine(t *testing.T) {
-	var textBuff bytes.Buffer
+	var textBuff *bytes.Buffer = &bytes.Buffer{}
 	textBuff.WriteString("Test Me")
 	var line Line = Line{Text: textBuff}
 	var output string = string(line.Output())
@@ -19,7 +18,7 @@ func TestLine(t *testing.T) {
 		t.Errorf("Line: Expected %#v, got %#v", expect, output)
 	}
 
-	if line.Updater() {
+	if line.Update() {
 		t.Error("Line: No updater, should return false")
 	}
 
@@ -48,13 +47,12 @@ func TestLine(t *testing.T) {
 
 func TestLineUpdate(t *testing.T) {
 	var counter int = 0
-	uf := func() []byte {
-		var output []byte
-		output = fmt.Appendf(output, "Count: %d", counter)
-		return output
+	uf := func(u *bytes.Buffer) {
+		u.Reset()
+		fmt.Fprintf(u, "Count: %d", counter)
 	}
 	var line Line = Line{UpdateF: uf}
-	line.Updater()
+	line.Update()
 	var output string = string(line.Output())
 	var expect string = "Count: 0"
 
@@ -62,13 +60,13 @@ func TestLineUpdate(t *testing.T) {
 		t.Errorf("LineUpdate: Expected %#v, got %#v", expect, output)
 	}
 
-	if line.Updater() {
+	if line.Update() {
 		t.Error("Unexpected Update: should have returned false. (no change)")
 	}
 
 	counter++
 
-	if !line.Updater() {
+	if !line.Update() {
 		t.Error("Missing Update: value was changed, Text should have changed")
 	}
 
@@ -82,14 +80,14 @@ func TestLineUpdate(t *testing.T) {
 func TestLineUnicode(t *testing.T) {
 	Unicode = true
 	// code point > FFFF, use \U00000000 (not \u).
-	var lineBuff bytes.Buffer
+	var lineBuff *bytes.Buffer = &bytes.Buffer{}
 	lineBuff.WriteString("Howdy \U0001f920")
 	var line Line = Line{Text: lineBuff}
-	var output string = string(line.Output())
-	var expect string = "Howdy 🤠"
+	var output []byte = line.Output()
+	var expect []byte = []byte("Howdy 🤠")
 
-	if output != expect {
-		t.Errorf("LineUnicode: Expected %#v, got %#v", expect, output)
+	if bytes.Compare(output, expect) != 0 {
+		t.Errorf("LineUnicode: Expected %s, got %s", expect, output)
 	}
 
 	if StringLen(expect) != 8 {
@@ -98,10 +96,10 @@ func TestLineUnicode(t *testing.T) {
 
 	// 🤠 = 2 chars.
 	line.Width = 9
-	output = string(line.Output())
-	expect = "Howdy 🤠 "
+	output = line.Output()
+	expect = []byte("Howdy 🤠 ")
 
-	if output != expect {
+	if bytes.Compare(output, expect) != 0 {
 		t.Errorf("LineUnicode: Expected %#v, got %#v", expect, output)
 	}
 }
@@ -111,7 +109,7 @@ func TestLineCP437(t *testing.T) {
 	var tests []string = []string{"\xdb TEXT \xdb",
 		"\xf1 F1", "\xf2 F2", "\xf3 F3"}
 	for _, test := range tests {
-		var lineBuff bytes.Buffer
+		var lineBuff *bytes.Buffer = &bytes.Buffer{}
 		lineBuff.WriteString(test)
 		var line Line = Line{Text: lineBuff}
 		var output string = string(line.Output())
@@ -132,7 +130,7 @@ func BenchmarkLine(b *testing.B) {
 	Unicode = false
 
 	for n := 0; n < b.N; n++ {
-		var lineBuff bytes.Buffer
+		var lineBuff *bytes.Buffer = &bytes.Buffer{}
 		lineBuff.WriteString(fmt.Sprintf("Line %d of %d", n, b.N))
 		var line Line = Line{Text: lineBuff}
 		var output string = string(line.Output())
@@ -144,7 +142,7 @@ func BenchmarkLineRender(b *testing.B) {
 	Unicode = false
 
 	for n := 0; n < b.N; n++ {
-		var lineBuff bytes.Buffer
+		var lineBuff *bytes.Buffer = &bytes.Buffer{}
 		lineBuff.WriteString(fmt.Sprintf("Line %d of %d", n, b.N))
 		var line Line = Line{Text: lineBuff, RenderF: RenderBlueYellow}
 		var output string = string(line.Output())
@@ -156,8 +154,8 @@ func BenchmarkLineRender(b *testing.B) {
 
 func BenchmarkLineColor(b *testing.B) {
 
-	var render = func(text []byte) []byte {
-		var output bytes.Buffer
+	var render = func(output *bytes.Buffer, text []byte) []byte {
+		output.Reset()
 		var last *string
 		// var r Render = Render{Line: text}
 
@@ -199,27 +197,21 @@ func BenchmarkLineColor(b *testing.B) {
 		// return r.Result
 	}
 
+	var up int
+	var updater = func(u *bytes.Buffer) {
+		u.Reset()
+		fmt.Fprintf(u, "The Value: %d", up)
+		// u.WriteString("The Value: ")
+		// u.WriteString(strconv.Itoa(up))
+		up++
+		// return fmt.Sprintf("The Value: %d", up)
+	}
+	var line Line = Line{UpdateF: updater,
+		RenderF: render,
+		Width:   18}
+
 	for i := 0; i < b.N; i++ {
-		var up = 0
-		var updater = func() []byte {
-			var output bytes.Buffer
-			output.WriteString("The Value: ")
-			output.WriteString(strconv.Itoa(up))
-			up++
-			return output.Bytes()
-			// return fmt.Sprintf("The Value: %d", up)
-		}
-		var lineBuff bytes.Buffer
-		lineBuff.Write(updater())
-		var line Line = Line{Text: lineBuff,
-			UpdateF: updater,
-			RenderF: render,
-			Width:   18}
+		line.Update()
 		line.Output()
-		for l := 0; l < 10; l++ {
-			if line.Updater() {
-				line.Output()
-			}
-		}
 	}
 }

door/menu.go

@@ -25,8 +25,8 @@ type Menu struct {
 }
 
 func MakeMenuRender(bracketColor, optionColor, upperColor, lowerColor string) ColorRender {
-	f := func(text []byte) []byte {
-		var output bytes.Buffer
+	f := func(output *bytes.Buffer, text []byte) []byte {
+		output.Reset()
 		var lastColor *string
 		option := true
 		for _, c := range text {
@@ -75,7 +75,7 @@ func (m *Menu) AddSelection(key string, text string) {
 		log.Panicf("Menu (not wide enough) Width %d : text size %d + 4 = %d\n", m.Width, len(text), len(text)+4)
 	}
 
-	var linetext bytes.Buffer
+	var linetext *bytes.Buffer = &bytes.Buffer{}
 	linetext.WriteString("[" + key + "] " + text + strings.Repeat(" ", m.Width-(4+len(text))))
 	m.Lines = append(m.Lines, Line{Text: linetext, RenderF: m.UnselectedR})
 }

door/menu_test.go

@@ -22,7 +22,8 @@ func TestMenuRender(t *testing.T) {
 
 	// Fake menu line
 	var input string = "[X] BUGZ test"
-	var got string = string(render([]byte(input)))
+	var buff *bytes.Buffer = &bytes.Buffer{}
+	var got string = string(render(buff, []byte(input)))
 	var expected string = bracket + "[" + option + "X" + bracket + "]"
 	expected += lower + " " + upper + "BUGZ" + lower + " test"
 
@@ -152,14 +153,14 @@ func TestMenuConnection(t *testing.T) {
 	}}
 
 	// Use simple renders for testing
-	m.SelectedR = func(text []byte) []byte {
-		var output bytes.Buffer
+	m.SelectedR = func(output *bytes.Buffer, text []byte) []byte {
+		output.Reset()
 		output.WriteString(ColorText("BLACK ON WHITE"))
 		output.Write(text)
 		return output.Bytes()
 	}
-	m.UnselectedR = func(text []byte) []byte {
-		var output bytes.Buffer
+	m.UnselectedR = func(output *bytes.Buffer, text []byte) []byte {
+		output.Reset()
 		output.WriteString(ColorText("WHI ON BLA"))
 		output.Write(text)
 		return output.Bytes()

door/nomoresecrets.go

@@ -13,6 +13,7 @@ No More Secrets - from "Sneakers"
 https://github.com/bartobri/no-more-secrets
 */
 const NORANDOM bool = false
+const DEBUG_NMS bool = true
 
 type NoMoreSecretsConfig struct {
 	Jumble_Sec        int    // in sec
@@ -221,8 +222,10 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 		}
 
 		// jumble loop
+		var renderResults *bytes.Buffer = &bytes.Buffer{}
+
 		var renderF func() []byte = func() []byte {
-			var result bytes.Buffer
+			renderResults.Reset()
 			var lastcolor *string
 			var pos int = 0
 
@@ -236,7 +239,7 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 					// This is a character
 					if chartime[pos] != 0 && char != ' ' {
 						if lastcolor != &config.Color {
-							result.WriteString(config.Color)
+							renderResults.WriteString(config.Color)
 							lastcolor = &config.Color
 						}
 					} else {
@@ -252,14 +255,14 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 						}
 
 						if lastcolor != &best {
-							result.WriteString(best)
+							renderResults.WriteString(best)
 							lastcolor = &best
 						}
 					}
 				}
-				result.WriteRune(char)
+				renderResults.WriteRune(char)
 			}
-			return result.Bytes()
+			return renderResults.Bytes()
 		}
 
 		for i := 0; (i < (config.Jumble_Sec*1000)/config.Jumble_Loop_Speed) && (!keyAbort); i++ {
@@ -423,9 +426,10 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 			}
 		}
 
+		var renderResults *bytes.Buffer = &bytes.Buffer{}
 		// jumble loop
 		var renderF func() []byte = func() []byte {
-			var result bytes.Buffer
+			renderResults.Reset()
 			var lastcolor *string
 			var pos int = 0
 
@@ -439,7 +443,7 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 
 					if chartime[pos] != 0 && char != ' ' {
 						if lastcolor != &config.Color {
-							result.WriteString(config.Color)
+							renderResults.WriteString(config.Color)
 							lastcolor = &config.Color
 						}
 					} else {
@@ -454,14 +458,14 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 						}
 
 						if lastcolor != &best {
-							result.WriteString(best)
+							renderResults.WriteString(best)
 							lastcolor = &best
 						}
 					}
 				}
-				result.WriteByte(char)
+				renderResults.WriteByte(char)
 			}
-			return result.Bytes()
+			return renderResults.Bytes()
 		}
 
 		for i := 0; (i < (config.Jumble_Sec*1000)/config.Jumble_Loop_Speed) && (!keyAbort); i++ {

door/panel.go

@@ -26,6 +26,7 @@ type Panel struct {
 	Title       string
 	TitleColor  string
 	TitleOffset int
+	output      *bytes.Buffer
 }
 
 /*
@@ -108,37 +109,43 @@ func (p *Panel) Clicked(m Mouse, onBorder bool) (bool, int) {
 // Clear out the panel
 func (p *Panel) Clear() []byte {
 	var style int = int(p.Style)
-	var output bytes.Buffer
+	if p.output == nil {
+		p.output = &bytes.Buffer{}
+	}
+	p.output.Reset()
 	var row int = p.Y
-	var blank string
+	var blank []byte
 
 	if style > 0 {
-		blank = strings.Repeat(" ", p.Width+2)
-		output.Write(Goto(p.X, row))
-		output.WriteString(blank)
+		blank = bytes.Repeat([]byte{' '}, p.Width+2)
+		p.output.Write(Goto(p.X, row))
+		p.output.Write(blank)
 		row++
 	} else {
-		blank = strings.Repeat(" ", p.Width)
+		blank = bytes.Repeat([]byte{' '}, p.Width)
 	}
 
 	for _ = range p.Lines {
-		output.Write(Goto(p.X, row))
-		output.WriteString(blank)
+		p.output.Write(Goto(p.X, row))
+		p.output.Write(blank)
 		row++
 	}
 
 	if style > 0 {
-		output.Write(Goto(p.X, row))
-		output.WriteString(blank)
+		p.output.Write(Goto(p.X, row))
+		p.output.Write(blank)
 	}
-	return output.Bytes()
+	return p.output.Bytes()
 }
 
 // Output the panel
 func (p *Panel) Output() []byte {
 	var style int = int(p.Style)
 	var box_style *BoxStyle
-	var output bytes.Buffer
+	if p.output == nil {
+		p.output = &bytes.Buffer{}
+	}
+	p.output.Reset()
 
 	if style > 0 {
 		box_style = &BOXES[style-1]
@@ -147,24 +154,24 @@ func (p *Panel) Output() []byte {
 	var row int = p.Y
 	if style > 0 {
 		// Top line / border
-		output.Write(Goto(p.X, row))
-		output.WriteString(p.BorderColor)
-		output.WriteString(box_style.Top_Left)
+		p.output.Write(Goto(p.X, row))
+		p.output.WriteString(p.BorderColor)
+		p.output.WriteString(box_style.Top_Left)
 		if p.Title != "" {
 			if p.TitleOffset+len(p.Title) > p.Width {
 				log.Panicf("Panel (not wide enough) Width %d : Title size %d + offset %d = %d\n",
 					p.Width, len(p.Title), p.TitleOffset, p.TitleOffset+len(p.Title))
 			}
-			output.WriteString(strings.Repeat(box_style.Top, p.TitleOffset))
-			output.WriteString(p.TitleColor + p.Title + p.BorderColor)
+			p.output.WriteString(strings.Repeat(box_style.Top, p.TitleOffset))
+			p.output.WriteString(p.TitleColor + p.Title + p.BorderColor)
 		}
-		output.WriteString(strings.Repeat(box_style.Top, p.Width-(p.TitleOffset+len(p.Title))) + box_style.Top_Right)
+		p.output.WriteString(strings.Repeat(box_style.Top, p.Width-(p.TitleOffset+len(p.Title))) + box_style.Top_Right)
 		row++
 	}
 
 	for _, line := range p.Lines {
-		output.Write(Goto(p.X, row))
-		line.LineLength(&line.Text)
+		p.output.Write(Goto(p.X, row))
+		line.LineLength(line.Text)
 
 		var joined bool = false
 
@@ -172,20 +179,20 @@ func (p *Panel) Output() []byte {
 			top := box_style.Top
 			if bytes.Compare(line.Text.Bytes()[0:len(top)], []byte(top)) == 0 {
 				// Yes, this line needs to be joined...
-				output.WriteString(p.BorderColor + box_style.Middle_Left)
-				output.Write(line.Output())
-				output.WriteString(p.BorderColor + box_style.Middle_Right)
+				p.output.WriteString(p.BorderColor + box_style.Middle_Left)
+				p.output.Write(line.Output())
+				p.output.WriteString(p.BorderColor + box_style.Middle_Right)
 				joined = true
 			}
 		}
 
 		if !joined {
 			if style > 0 {
-				output.WriteString(p.BorderColor + box_style.Side)
+				p.output.WriteString(p.BorderColor + box_style.Side)
 			}
-			output.Write(line.Output())
+			p.output.Write(line.Output())
 			if style > 0 {
-				output.WriteString(p.BorderColor + box_style.Side)
+				p.output.WriteString(p.BorderColor + box_style.Side)
 			}
 		}
 
@@ -194,16 +201,19 @@ func (p *Panel) Output() []byte {
 
 	if style > 0 {
 		// Bottom / border
-		output.Write(Goto(p.X, row))
-		output.WriteString(p.BorderColor + box_style.Bottom_Left)
-		output.WriteString(strings.Repeat(box_style.Top, p.Width) + box_style.Bottom_Right)
+		p.output.Write(Goto(p.X, row))
+		p.output.WriteString(p.BorderColor + box_style.Bottom_Left)
+		p.output.WriteString(strings.Repeat(box_style.Top, p.Width) + box_style.Bottom_Right)
 	}
-	return output.Bytes()
+	return p.output.Bytes()
 }
 
 // Output anything that has updated
-func (p *Panel) Updater() []byte {
-	var output bytes.Buffer
+func (p *Panel) Update() []byte {
+	if p.output == nil {
+		p.output = &bytes.Buffer{}
+	}
+	p.output.Reset()
 	var style int = int(p.Style)
 	var row, col int
 
@@ -215,22 +225,25 @@ func (p *Panel) Updater() []byte {
 	}
 
 	for idx := range p.Lines {
-		if p.Lines[idx].Updater() {
+		if p.Lines[idx].Update() {
 			// Yes, line was updated
-			output.Write(Goto(col, row))
-			output.Write(p.Lines[idx].Output())
+			p.output.Write(Goto(col, row))
+			p.output.Write(p.Lines[idx].Output())
 		}
 		row++
 	}
-	return output.Bytes()
+	return p.output.Bytes()
 }
 
 // Output the updated line
 func (p *Panel) UpdateLine(index int) []byte {
-	var output bytes.Buffer
+	if p.output == nil {
+		p.output = &bytes.Buffer{}
+	}
+	p.output.Reset()
 	var style int = int(p.Style)
 
-	p.Lines[index].Updater()
+	p.Lines[index].Update()
 	var row, col int
 
 	row = p.Y + index
@@ -240,9 +253,9 @@ func (p *Panel) UpdateLine(index int) []byte {
 		col++
 	}
 	var line *Line = &p.Lines[index]
-	output.Write(Goto(col, row))
-	output.Write(line.Output())
-	return output.Bytes()
+	p.output.Write(Goto(col, row))
+	p.output.Write(line.Output())
+	return p.output.Bytes()
 }
 
 // Position Cursor at the "end" of the panel
@@ -263,7 +276,7 @@ func Single(bs BorderStyle) bool {
 
 // Create a spacer line that will be connected maybe to the sides.
 func (p *Panel) Spacer() Line {
-	var l Line = Line{}
+	var l Line = Line{Text: &bytes.Buffer{}}
 	var pos int
 
 	if Single(p.Style) {

door/panel_test.go

@@ -9,12 +9,8 @@ import (
 
 func TestPanel(t *testing.T) {
 	var p Panel = Panel{X: 5, Y: 7, Width: 10, Style: DOUBLE, Title: "Test"}
-	var test1 bytes.Buffer
-	test1.WriteString("1234567890")
-	p.Lines = append(p.Lines, Line{Text: test1})
-	var test2 bytes.Buffer
-	test2.WriteString("abcdefghij")
-	p.Lines = append(p.Lines, Line{Text: test2})
+	p.Lines = append(p.Lines, NewLine("1234567890"))
+	p.Lines = append(p.Lines, NewLine("abcdefghij"))
 
 	var expected string = string(Goto(5, 7)) + "╔Test══════╗" +
 		string(Goto(5, 8)) + "║1234567890║" +
@@ -59,13 +55,12 @@ func TestPanelUpdate(t *testing.T) {
 	var TestY int = 2
 	var p Panel = Panel{X: TestX, Y: TestY, Width: 3, Style: DOUBLE_SINGLE}
 	var x int = 0
-	var updater Update = func() []byte {
-		var output []byte
-		output = fmt.Appendf(output, "%3d", x)
-		return output
+	var updater Updater = func(u *bytes.Buffer) {
+		u.Reset()
+		fmt.Fprintf(u, "%3d", x)
 	}
 	var l Line = Line{UpdateF: updater}
-	l.Updater()
+	l.Update()
 	p.Lines = append(p.Lines, l)
 
 	var expected string = string(Goto(TestX, TestY)) + "╒═══╕" +
@@ -78,14 +73,14 @@ func TestPanelUpdate(t *testing.T) {
 	}
 
 	x += 3
-	got = string(p.Updater())
+	got = string(p.Update())
 	expected = string(Goto(TestX+1, TestY+1)) + "  3"
 
 	if expected != got {
 		t.Errorf("Panel Update expected %#v, got %#v", expected, got)
 	}
 
-	got = string(p.Updater())
+	got = string(p.Update())
 
 	if got != "" {
 		t.Errorf("Panel Update expected '', got %#v", got)

door/screen.go

@@ -18,10 +18,10 @@ func (s *Screen) Output() []byte {
 	return result.Bytes()
 }
 
-func (s *Screen) Updater() []byte {
+func (s *Screen) Update() []byte {
 	var result bytes.Buffer
 	for idx := range s.Panels {
-		result.Write(s.Panels[idx].Updater())
+		result.Write(s.Panels[idx].Update())
 	}
 	return result.Bytes()
 }

door/spinrite.go

@@ -1,19 +1,22 @@
 package door
 
-import "strings"
+import (
+	"bytes"
+)
 
 type SpinRite struct {
-	Width     uint8   // Width of the animation (must be odd)
-	Length    uint8   // Width of the worm (must be odd)
-	Color     string  // Color (default CYAN ON BLUE)
-	OutputB   []byte  // Output CP437/bytes (Width)
-	OutputR   []rune  // Output Unicode (Width)
-	Buffer    []uint8 // Output calculate buffer (Width)
-	Runes     []rune  // blank, center, top, bottom, both
-	Bytes     []byte  // blank, center, top, bottom, both
-	CenterPos uint8   // Center Position (Width - 1) / 2
-	StartPos  uint8   // Starting Position (Length -1) / 2
-	Index     uint8   // Index of current iteration
+	Width     uint8         // Width of the animation (must be odd)
+	Length    uint8         // Width of the worm (must be odd)
+	Color     string        // Color (default CYAN ON BLUE)
+	OutputB   []byte        // Output CP437/bytes (Width)
+	OutputR   []rune        // Output Unicode (Width)
+	Buffer    []uint8       // Output calculate buffer (Width)
+	Runes     []rune        // blank, center, top, bottom, both
+	Bytes     []byte        // blank, center, top, bottom, both
+	CenterPos uint8         // Center Position (Width - 1) / 2
+	StartPos  uint8         // Starting Position (Length -1) / 2
+	Index     uint8         // Index of current iteration
+	output    *bytes.Buffer // Buffer for output
 }
 
 /*
@@ -56,7 +59,8 @@ func SpinRiteInit(width uint8, length uint8, color string) SpinRite {
 		CenterPos: center,
 		StartPos:  start,
 		Buffer:    make([]uint8, width),
-		Index:     0}
+		Index:     0,
+		output:    &bytes.Buffer{}}
 	if Unicode {
 		result.OutputR = make([]rune, width)
 		result.Runes = []rune{' ', '\u221e', '\u2580', '\u2584', '\u2588'}
@@ -171,11 +175,11 @@ func (sr *SpinRite) Calculate() {
 	}
 }
 
-func (sr *SpinRite) Output() string {
+func (sr *SpinRite) Output() []byte {
 	// var result string
-	var result strings.Builder
+	sr.output.Reset()
 	// sr.Result.Reset()
-	result.WriteString(sr.Color)
+	sr.output.WriteString(sr.Color)
 
 	sr.Calculate()
 	if Unicode {
@@ -185,15 +189,15 @@ func (sr *SpinRite) Output() string {
 				result.WriteRune(r)
 			}
 		*/
-		result.WriteString(string(sr.OutputR))
+		sr.output.WriteString(string(sr.OutputR))
 	} else {
 		//result = string(sr.OutputB)
-		result.WriteString(string(sr.OutputB))
+		sr.output.Write(sr.OutputB)
 	}
 	sr.Index++
 
 	// return sr.Color + result
-	return result.String()
+	return sr.output.Bytes()
 }
 
 type SpinRiteMsg struct {
@@ -230,20 +234,21 @@ func (sr *SpinRiteMsg) Output() string {
 		sr.Next = true
 	}
 	// Place message
-	var msg string = sr.Messages[sr.MsgIndex]
+	var message string = sr.Messages[sr.MsgIndex]
+	var msg []rune = []rune(message)
 	var pos int = int(sr.CenterPos)
 
 	// Bug:  If we're changing to next message (sr.Next == True) ... but the
 	// message is > SpinRite.Length, it shows the text beyond what it should.
 
-	var texthalf int = StringLen(msg) / 2
+	var texthalf int = StringLen([]byte(message)) / 2
 
 	// Place text center, outwards.  Stopping if there's no space.
 
 	for i := 0; i < texthalf+1; i++ {
 		if Unicode {
 			if sr.OutputR[pos+i] == ' ' {
-				if texthalf+i < StringLen(msg) {
+				if texthalf+i < StringLen([]byte(message)) {
 					sr.OutputR[pos+i] = []rune(msg)[texthalf+i]
 				}
 			} else {
@@ -258,7 +263,7 @@ func (sr *SpinRiteMsg) Output() string {
 			}
 		} else {
 			if sr.OutputB[pos+i] == ' ' {
-				if texthalf+i < StringLen(msg) {
+				if texthalf+i < StringLen([]byte(message)) {
 					sr.OutputB[pos+i] = byte(msg[texthalf+i])
 				}
 			} else {

door/utilities.go

@@ -1,6 +1,7 @@
 package door
 
 import (
+	"bytes"
 	"strconv"
 	"strings"
 
@@ -70,14 +71,19 @@ func SplitToInt(input string, sep string) []int {
 // This finds the actual length.
 
 // Calculate the length of the given line, dealing with unicode.
-func StringLen(s string) int {
+func StringLen(s []byte) int {
 	if Unicode {
 		var len int
-		for _, r := range s {
+		var ubuff *bytes.Buffer = bytes.NewBuffer(s)
+		for {
+			r, _, err := ubuff.ReadRune()
+			if err != nil {
+				break
+			}
 			len += UnicodeWidth(r)
 		}
 		return len
 	} else {
-		return len([]byte(s))
+		return len(s)
 	}
 }

door/wopr.go

@@ -3,6 +3,7 @@ package door
 import (
 	"bytes"
 	"fmt"
+	"log"
 	"strings"
 	"time"
 )
@@ -39,8 +40,11 @@ type WOPR struct {
 	Index          int
 	Ticker         *time.Ticker
 	StopIt         chan bool
+	output         *bytes.Buffer
 }
 
+const DEBUG_WOPR bool = true
+
 func (w *WOPR) Clear() []byte {
 	var output bytes.Buffer
 	output.Write(w.ElapsedPanel.Clear())
@@ -55,6 +59,7 @@ func (w *WOPR) Init(elapsed time.Time, remaining time.Time, color string) {
 	if color == "" {
 		color = ColorText("BLACK ON CYAN")
 	}
+	w.output = &bytes.Buffer{}
 	w.Elapsed = elapsed
 	w.Remaining = remaining
 	w.Index = 0
@@ -62,97 +67,86 @@ func (w *WOPR) Init(elapsed time.Time, remaining time.Time, color string) {
 		BorderColor: color,
 		Style:       SINGLE}
 
-	var gameBuff bytes.Buffer
-	gameBuff.WriteString("      GAME      ")
-	w.ElapsedPanel.Lines = append(w.ElapsedPanel.Lines, Line{Text: gameBuff})
-	var elapsedBuff bytes.Buffer
-	elapsedBuff.WriteString("  TIME ELAPSED  ")
-	w.ElapsedPanel.Lines = append(w.ElapsedPanel.Lines, Line{Text: elapsedBuff})
+	w.ElapsedPanel.Lines = append(w.ElapsedPanel.Lines, NewLine("      GAME      "))
+	w.ElapsedPanel.Lines = append(w.ElapsedPanel.Lines, NewLine("  TIME ELAPSED  "))
 
 	var ehour Line = Line{}
-	ehour.UpdateF = func() []byte {
+	ehour.UpdateF = func(u *bytes.Buffer) {
 		var hours int = int(w.ElapsedD.Hours())
-		var output []byte
-		fmt.Append(output, "     %02d HRS     ", hours%100)
-		return output
+		u.Reset()
+		fmt.Fprintf(u, "     %02d HRS     ", hours%100)
 	}
-	ehour.Text.Write(ehour.UpdateF())
+	ehour.Update()
+	// ehour.Text.Write(ehour.update)
 	w.ElapsedPanel.Lines = append(w.ElapsedPanel.Lines, ehour)
 
 	var eminsec Line = Line{}
-	eminsec.UpdateF = func() []byte {
+	eminsec.UpdateF = func(u *bytes.Buffer) {
 		var mins int = int(w.ElapsedD.Minutes()) % 60
 		var secs int = int(w.ElapsedD.Seconds()) % 60
-		var output []byte
-		output = fmt.Appendf(output, " %02d MIN  %02d SEC ", mins, secs)
-		return output
+		u.Reset()
+		fmt.Fprintf(u, " %02d MIN  %02d SEC ", mins, secs)
 	}
-	eminsec.Text.Write(eminsec.UpdateF())
+	eminsec.Update() // Text.Write(eminsec.UpdateF())
 	w.ElapsedPanel.Lines = append(w.ElapsedPanel.Lines, eminsec)
 
 	var eanimate Line = Line{}
-	eanimate.UpdateF = func() []byte {
-		var output bytes.Buffer
+	eanimate.UpdateF = func(u *bytes.Buffer) {
+		u.Reset()
 		// Left to Right
 		if Unicode {
 			var buffer []rune = []rune(strings.Repeat(" ", 16))
 			buffer[w.Index] = '\u25a0'
-			output.WriteString(string(buffer))
+			u.WriteString(string(buffer))
 		} else {
 			var buffer []byte = bytes.Repeat([]byte(" "), 16)
 			buffer[w.Index] = '\xfe'
-			output.WriteString(string(buffer))
+			u.WriteString(string(buffer))
 		}
-		return output.Bytes()
 	}
-	eanimate.Text.Write(eanimate.UpdateF())
+	eanimate.Update() // Text.Write(eanimate.UpdateF())
 	w.ElapsedPanel.Lines = append(w.ElapsedPanel.Lines, eanimate)
 
 	w.RemainingPanel = Panel{Width: 16,
 		BorderColor: color,
 		Style:       SINGLE}
-	w.RemainingPanel.Lines = append(w.RemainingPanel.Lines, Line{Text: gameBuff})
-	var remainBuff bytes.Buffer
-	remainBuff.WriteString(" TIME REMAINING ")
-	w.RemainingPanel.Lines = append(w.RemainingPanel.Lines, Line{Text: remainBuff})
+	w.RemainingPanel.Lines = append(w.RemainingPanel.Lines, NewLine("      GAME      "))
+	w.RemainingPanel.Lines = append(w.RemainingPanel.Lines, NewLine(" TIME REMAINING "))
 
 	var rhour Line = Line{}
-	rhour.UpdateF = func() []byte {
+	rhour.UpdateF = func(u *bytes.Buffer) {
 		var hours int = int(w.RemainingD.Hours())
-		var output []byte
-		output = fmt.Appendf(output, "     %02d HRS     ", hours%100)
-		return output
+		u.Reset()
+		fmt.Fprintf(u, "     %02d HRS     ", hours%100)
 	}
-	rhour.Text.Write(rhour.UpdateF())
+	rhour.Update() // Text.Write(rhour.UpdateF())
 	w.RemainingPanel.Lines = append(w.RemainingPanel.Lines, rhour)
 
 	var rminsec Line = Line{}
-	rminsec.UpdateF = func() []byte {
+	rminsec.UpdateF = func(u *bytes.Buffer) {
 		var mins int = int(w.RemainingD.Minutes()) % 60
 		var secs int = int(w.RemainingD.Seconds()) % 60
-		var output []byte
-		output = fmt.Appendf(output, " %02d MIN  %02d SEC ", mins, secs)
-		return output
+		u.Reset()
+		fmt.Fprintf(u, " %02d MIN  %02d SEC ", mins, secs)
 	}
-	rminsec.Text.Write(rminsec.UpdateF())
+	rminsec.Update() // Text.Write(rminsec.UpdateF())
 	w.RemainingPanel.Lines = append(w.RemainingPanel.Lines, rminsec)
 
 	var ranimate Line = Line{}
-	ranimate.UpdateF = func() []byte {
-		var output bytes.Buffer
+	ranimate.UpdateF = func(u *bytes.Buffer) {
+		u.Reset()
 		// Left to Right
 		if Unicode {
 			var buffer []rune = []rune(strings.Repeat(" ", 16))
 			buffer[15-w.Index] = '\u25a0'
-			output.WriteString(string(buffer))
+			u.WriteString(string(buffer))
 		} else {
 			var buffer []byte = bytes.Repeat([]byte(" "), 16)
 			buffer[15-w.Index] = '\xfe'
-			output.WriteString(string(buffer))
+			u.WriteString(string(buffer))
 		}
-		return output.Bytes()
 	}
-	ranimate.Text.Write(ranimate.UpdateF())
+	ranimate.Update() // Text.Write(ranimate.UpdateF())
 	w.RemainingPanel.Lines = append(w.RemainingPanel.Lines, ranimate)
 }
 
@@ -160,8 +154,8 @@ func (w *WOPR) Inc() {
 	w.Index++
 	if w.Index == 16 {
 		w.Index = 0
-		w.ElapsedPanel.Updater()
-		w.RemainingPanel.Updater()
+		w.ElapsedPanel.Update()
+		w.RemainingPanel.Update()
 
 		w.RemainingD = time.Duration(w.RemainingD.Seconds()-1) * time.Second
 		w.ElapsedD = time.Duration(w.ElapsedD.Seconds()+1) * time.Second
@@ -187,7 +181,7 @@ func (w *WOPR) Animate(d *Door) {
 	w.RemainingD = time.Until(w.Remaining)
 	w.StopIt = make(chan bool)
 
-	go func(d *Door) {
+	go func(d *Door, output *bytes.Buffer) {
 		// til := time.Now().UnixNano() % int64(time.Second)
 
 		sec16 := int64(time.Second) / 16
@@ -202,7 +196,7 @@ func (w *WOPR) Animate(d *Door) {
 		// time.Second / 16
 		w.Ticker = time.NewTicker(time.Duration(sec16))
 
-		var output bytes.Buffer
+		// var output bytes.Buffer
 
 		for {
 			select {
@@ -210,13 +204,21 @@ func (w *WOPR) Animate(d *Door) {
 				return
 
 			case <-w.Ticker.C:
-				w.ElapsedPanel.Updater()
-				w.RemainingPanel.Updater()
+				w.ElapsedPanel.Update()
+				w.RemainingPanel.Update()
+				var using int
+				using = output.Cap()
 				output.Reset()
 				output.WriteString(SavePos)
 				output.Write(w.ElapsedPanel.Output())
 				output.Write(w.RemainingPanel.Output())
 				output.WriteString(RestorePos)
+				if DEBUG_WOPR {
+					if output.Cap() > using {
+						using = output.Cap()
+						log.Printf("WOPR: now %d\n", using)
+					}
+				}
 				if !d.Writer.IsClosed() {
 					d.Write(output.Bytes())
 					output.Reset()
@@ -228,7 +230,7 @@ func (w *WOPR) Animate(d *Door) {
 				w.Inc()
 			}
 		}
-	}(d)
+	}(d, w.output)
 }
 
 func (w *WOPR) Stop() {

door/write.go

@@ -143,6 +143,28 @@ func (d *Door) Update(output []byte) {
 	// d.Write(SAVE_POS + output + RESTORE_POS)
 }
 
+func (d *Door) WriteS(output string) {
+	d.Write([]byte(output))
+}
+
+func (d *Door) WriteA(a ...interface{}) {
+	d.Writer.Mutex.Lock()
+	defer d.Writer.Mutex.Unlock()
+
+	for _, item := range a {
+		switch item.(type) {
+		case string:
+			d.Writer.OSWrite([]byte(item.(string)))
+		case []byte:
+			d.Writer.OSWrite(item.([]byte))
+		case *bytes.Buffer:
+			d.Writer.OSWrite(item.(*bytes.Buffer).Bytes())
+		default:
+			log.Printf("Unknown/unsupported type: %T\n", item)
+		}
+	}
+}
+
 func (d *Door) Write(output []byte) {
 	if len(output) == 0 {
 		return

door/write_linux.go

@@ -11,7 +11,7 @@ import (
 // This assumes that d.writerMutex is locked.
 
 type OSWriter struct {
-	mutex  sync.Mutex // Writer mutex
+	Mutex  sync.Mutex // Writer mutex
 	Closed bool
 	Handle int
 }
@@ -24,7 +24,7 @@ func (ow *OSWriter) Init(d *Door) {
 // The low-lever writer function
 func (ow *OSWriter) OSWrite(buffer []byte) (int, error) {
 	if DEBUG_DOOR {
-		if ow.mutex.TryLock() {
+		if ow.Mutex.TryLock() {
 			log.Panic("OSWrite: mutex was NOT locked.")
 		}
 	}
@@ -41,8 +41,8 @@ func (ow *OSWriter) OSWrite(buffer []byte) (int, error) {
 }
 
 func (ow *OSWriter) Write(buffer []byte) (int, error) {
-	ow.mutex.Lock()
-	defer ow.mutex.Unlock()
+	ow.Mutex.Lock()
+	defer ow.Mutex.Unlock()
 	if ow.Closed {
 		return 0, ErrDisconnected
 	}
@@ -63,15 +63,15 @@ func (ow *OSWriter) Write(buffer []byte) (int, error) {
 }
 
 func (ow *OSWriter) Stop() {
-	ow.mutex.Lock()
-	defer ow.mutex.Unlock()
+	ow.Mutex.Lock()
+	defer ow.Mutex.Unlock()
 	ow.Closed = true
 }
 
 // Safe way to check if OSWriter is closed
 func (ow *OSWriter) IsClosed() bool {
-	ow.mutex.Lock()
-	defer ow.mutex.Unlock()
+	ow.Mutex.Lock()
+	defer ow.Mutex.Unlock()
 	return ow.Closed
 }