incomplete fusion of keyboard and main

main.go

@@ -26,7 +26,7 @@ var (
 )
 
 // Visual options
-const (	
+const (
 	width      int     = 1080
 	height     int     = 1440 // TODO get from device instead of hardcoding
 	linewidth  float64 = 5
@@ -118,9 +118,8 @@ func main() {
 	}
 	var logger *log.Logger = log.New(logFile, "gemini", log.LstdFlags)
 	defer logFile.Close()
-	
 
-	/*
+
 	path := "/mnt/onboard/.adds/gemini/known-hosts" // TODO don't hardcode
 
 	// Reload or create known hosts file
@@ -137,7 +136,7 @@ func main() {
 	if err != nil {
 		fb.Println(err)
 		logger.Fatal(err)
-	}*/
+	}
 
 	// Load Fonts, Create font face
 	b, err := ioutil.ReadFile("/mnt/onboard/.adds/gemini/NotoSerif.ttf")
@@ -152,15 +151,23 @@ func main() {
 	}
 	face = truetype.NewFace(f, &truetype.Options{Size: 32})
 
-	err = drawOSK(fb, &fbinkOpts, &face)
+	str, err := GetInput(fb, &fbinkOpts, &face, t, "Test:")
 	if err != nil {
 		fb.Println("Error: ")
 		logger.Fatal(err)
 	}
-	
-	/*
-	url := "gemini://gemini.circumlunar.space"
-	req, err := gemini.NewRequest(url)
+
+	u, err := url.Parse(str)
+	if err != nil {
+		drawErrorBox(err, fb, t, &fbinkOpts, &face)
+		logger.Println(err)
+	}
+	if u.Scheme == "" {
+		u.Scheme = "gemini"
+	}
+	fmt.Println(u.String())
+
+	req, err := gemini.NewRequest(u.String())
 	if err != nil {
 		drawErrorBox(err, fb, t, &fbinkOpts, &face)
 		logger.Fatal(err)
@@ -180,22 +187,16 @@ func main() {
 			logger.Fatal(err)
 		}
 		fb.Println(string(body))
+		fmt.Println(string(body))
 	} else {
 		fb.Println(fmt.Sprintf("%d %s\n", resp.Status, resp.Meta))
 	}
-	*/
-
 	for {
-		x, y, err := t.GetInput()
-		if err != nil {
-			continue
-		}
-		fmt.Println(x,y)
+		x,y,_ := t.GetInput()
 		if x < 100 && y < 100 {
-			fb.Println("Exiting...")
 			break
 		}
-    }
-//	hostsfile.Close()
+	}
+	hostsfile.Close()
 
 }

ui.go

@@ -6,13 +6,21 @@ import (
 	"github.com/shermp/go-kobo-input/koboin"
     "golang.org/x/image/font"
     "image"
+    "fmt"
+    "strings"
 )
 
-var keyboard [][]string = [][]string{
-	{"1","2","3","4","5","6","7","8","9","10"},
-	{"q","w","e","r","t","y","u","i","o","p","BKSP"},
-	{"a","s","d","f","g","h","j","k","l",";","ENTER"},
-	{"z","x","c","v","b","n","m",".","/",":","SHIFT"},
+var keyboardLowercase [][]string = [][]string{
+	{"1","2","3","4","5","6","7","8","9","10","BKSP"},
+	{"q","w","e","r","t","y","u","i","o","p","ENTER"},
+	{"a","s","d","f","g","h","j","k","l",";","SHIFT"},
+	{"z","x","c","v","b","n","m",".","/",":","SPACE"},
+}
+var keyboardUppercase [][]string = [][]string{
+	{"!","\"","£","$","%","^","&","*","(",")","BKSP"},
+	{"Q","W","E","R","T","Y","U","I","O","P","ENTER"},
+	{"A","S","D","F","G","H","J","K","L","?","SHIFT"},
+	{"Z","X","C","V","B","N","M",",","<",">","SPACE"},
 }
 
 // KeyLocation encodes a keyboard key and where it is on the screen, so input can be scanned.
@@ -22,8 +30,90 @@ type KeyLocation struct {
 	Keycode string
 }
 
+func touchingKey(x, y int, k KeyLocation) bool {
+	if x > k.X && x < k.X+k.W && y > k.Y && y < k.Y+k.H {
+		return true
+	} else {
+		return false
+	}
+}
+
+// Draws a simple dialog box
+func drawDialog(text string, fb *gofbink.FBInk, opts *gofbink.FBInkConfig, f *font.Face) {
+	boxheight := height / 4
+	boxwidth := width / 2
+	i := image.NewRGBA(image.Rect(0, 0, boxwidth, boxheight))
+	dc := gg.NewContextForRGBA(i)
+	if *f != nil {
+        dc.SetFontFace(*f)
+	}
+	dc.SetLineWidth(linewidth)
+	dc.DrawRectangle(0, 0, float64(boxwidth), float64(boxheight))
+	dc.SetRGB(1, 1, 1)
+	dc.FillPreserve()
+	dc.SetRGB(0, 0, 0)
+	dc.Stroke()
+	dc.SetRGB(0, 0, 0)
+	dc.DrawStringWrapped(text, float64(boxwidth/2), float64(boxheight/2), 0.5, 0.5, float64(boxwidth), 1.0, gg.AlignCenter)
+	dc.Fill()
+	fb.PrintRBGA(int16(width/2-(boxwidth/2)), int16(height/2-(boxheight/2)), i, opts)
+	
+}
+
+// GetInput draws an OSK and dialog then gets input from the user. It returns the inputted string and a potential error.
+// TODO: more feedback to the user
+func GetInput(fb *gofbink.FBInk, opts *gofbink.FBInkConfig, f *font.Face, t *koboin.TouchDevice, prompt string) (string, error) {
+	var s string
+	shifted := false
+	// Draw onscreen keyboard
+	board, err := drawOSK(fb, opts, f, keyboardLowercase)
+	if err != nil {
+		return "", err
+	}
+	drawDialog(prompt + "\n ", fb, opts, f)
+
+	// Handle input
+	for {
+		x, y, err := t.GetInput()
+		if err != nil {
+			fmt.Println(err)
+			continue
+		}
+		for _, key := range board {
+			if touchingKey(x,y, key) {
+				if key.Keycode == "ENTER" {
+					return s, nil
+				} else if key.Keycode == "BKSP" {
+					if len(s) >= 1 {
+						s = s[:len(s)-1]
+					}
+				} else if key.Keycode == "SHIFT" {
+					shifted = !shifted
+					//board, err = drawOSK(fb, opts, f, keyboardUppercase)
+					s = s + "^"
+					//if err != nil {
+				//		return "", err
+				//	}
+				} else if key.Keycode == "SPACE" {
+					s = s + " "
+				} else {
+					if shifted {
+						s = s[:len(s)-1]
+						s = s + strings.ToUpper(key.Keycode)
+						shifted = false
+					} else {
+						s = s + key.Keycode
+					}
+				}
+				drawDialog(prompt + "\n" + s, fb, opts, f)
+			}
+		}
+	}
+}
+
 // drawOSK draws an on-screen keyboard.
-func drawOSK(fb *gofbink.FBInk, opts *gofbink.FBInkConfig, f *font.Face) error {
+func drawOSK(fb *gofbink.FBInk, opts *gofbink.FBInkConfig, f *font.Face, keyboard [][]string) ([]KeyLocation, error) {
+	var board []KeyLocation
 	var keysw int // Keys wide
 	keysh := len(keyboard) // Keys high
 	for _, r := range keyboard {
@@ -51,10 +141,9 @@ func drawOSK(fb *gofbink.FBInk, opts *gofbink.FBInkConfig, f *font.Face) error {
 	for _, r := range keyboard {
 		xpos := oskpadding // padding
 		for _, k := range r {
-//			dc.DrawRectangle(xpos, ypos, xpos+keywidth-keyspacing, ypos+keyheight-keyspacing)
-//			dc.Stroke()
 			dc.DrawStringAnchored(k, xpos+keywidth/2, ypos+keyheight/2, 0.5, 0.5)
 			dc.Fill()
+			board = append(board, KeyLocation{X: int(xpos), Y: int(ypos)+(height/3)*2, W: int(keywidth), H: int(keyheight), Label: k, Keycode: k})
 			xpos += keywidth
 		}
 		ypos += keyheight
@@ -62,28 +151,13 @@ func drawOSK(fb *gofbink.FBInk, opts *gofbink.FBInkConfig, f *font.Face) error {
 	
 	err := fb.PrintRBGA(0, int16(height-oskheight), i, opts)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	return nil
+	return board, nil
 }
+
 // drawErrorBox prints the given error on screen, and only proceeds after touch input.
 func drawErrorBox(e error, fb *gofbink.FBInk, t *koboin.TouchDevice, opts *gofbink.FBInkConfig, f *font.Face) {
-	boxheight := height / 4
-	boxwidth := width / 2
-	i := image.NewRGBA(image.Rect(0, 0, boxwidth, boxheight))
-	dc := gg.NewContextForRGBA(i)
-	if *f != nil {
-        dc.SetFontFace(*f)
-	}
-	dc.SetLineWidth(linewidth)
-	dc.DrawRectangle(0, 0, float64(boxwidth), float64(boxheight))
-	dc.SetRGB(1, 1, 1)
-	dc.FillPreserve()
-	dc.SetRGB(0, 0, 0)
-	dc.Stroke()
-	dc.SetRGB(0, 0, 0)
-	dc.DrawStringWrapped("Error:\n"+e.Error(), float64(boxwidth/2), float64(boxheight/2), 0.5, 0.5, float64(boxwidth), 1.0, gg.AlignCenter)
-	dc.Fill()
-	fb.PrintRBGA(int16(width/2-(boxwidth/2)), int16(height/2-(boxheight/2)), i, opts)
+	drawDialog("Error:\n"+e.Error(), fb, opts, f)
 	t.GetInput()
 }