termui: migrate to awesome-gocui instead of the old fork I had

1 files changed, 0 insertions, 529 deletions

diff --git a/vendor/github.com/nsf/termbox-go/termbox.go b/vendor/github.com/nsf/termbox-go/termbox.go
deleted file mode 100644
index fbe4c3de..00000000
--- a/vendor/github.com/nsf/termbox-go/termbox.go
+++ /dev/null
@@ -1,529 +0,0 @@
-// +build !windows
-
-package termbox
-
-import "unicode/utf8"
-import "bytes"
-import "syscall"
-import "unsafe"
-import "strings"
-import "strconv"
-import "os"
-import "io"
-
-// private API
-
-const (
-	t_enter_ca = iota
-	t_exit_ca
-	t_show_cursor
-	t_hide_cursor
-	t_clear_screen
-	t_sgr0
-	t_underline
-	t_bold
-	t_blink
-	t_reverse
-	t_enter_keypad
-	t_exit_keypad
-	t_enter_mouse
-	t_exit_mouse
-	t_max_funcs
-)
-
-const (
-	coord_invalid = -2
-	attr_invalid  = Attribute(0xFFFF)
-)
-
-type input_event struct {
-	data []byte
-	err  error
-}
-
-type extract_event_res int
-
-const (
-	event_not_extracted extract_event_res = iota
-	event_extracted
-	esc_wait
-)
-
-var (
-	// term specific sequences
-	keys  []string
-	funcs []string
-
-	// termbox inner state
-	orig_tios      syscall_Termios
-	back_buffer    cellbuf
-	front_buffer   cellbuf
-	termw          int
-	termh          int
-	input_mode     = InputEsc
-	output_mode    = OutputNormal
-	out            *os.File
-	in             int
-	lastfg         = attr_invalid
-	lastbg         = attr_invalid
-	lastx          = coord_invalid
-	lasty          = coord_invalid
-	cursor_x       = cursor_hidden
-	cursor_y       = cursor_hidden
-	foreground     = ColorDefault
-	background     = ColorDefault
-	inbuf          = make([]byte, 0, 64)
-	outbuf         bytes.Buffer
-	sigwinch       = make(chan os.Signal, 1)
-	sigio          = make(chan os.Signal, 1)
-	quit           = make(chan int)
-	input_comm     = make(chan input_event)
-	interrupt_comm = make(chan struct{})
-	intbuf         = make([]byte, 0, 16)
-
-	// grayscale indexes
-	grayscale = []Attribute{
-		0, 17, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244,
-		245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 232,
-	}
-)
-
-func write_cursor(x, y int) {
-	outbuf.WriteString("\033[")
-	outbuf.Write(strconv.AppendUint(intbuf, uint64(y+1), 10))
-	outbuf.WriteString(";")
-	outbuf.Write(strconv.AppendUint(intbuf, uint64(x+1), 10))
-	outbuf.WriteString("H")
-}
-
-func write_sgr_fg(a Attribute) {
-	switch output_mode {
-	case Output256, Output216, OutputGrayscale:
-		outbuf.WriteString("\033[38;5;")
-		outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10))
-		outbuf.WriteString("m")
-	default:
-		outbuf.WriteString("\033[3")
-		outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10))
-		outbuf.WriteString("m")
-	}
-}
-
-func write_sgr_bg(a Attribute) {
-	switch output_mode {
-	case Output256, Output216, OutputGrayscale:
-		outbuf.WriteString("\033[48;5;")
-		outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10))
-		outbuf.WriteString("m")
-	default:
-		outbuf.WriteString("\033[4")
-		outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10))
-		outbuf.WriteString("m")
-	}
-}
-
-func write_sgr(fg, bg Attribute) {
-	switch output_mode {
-	case Output256, Output216, OutputGrayscale:
-		outbuf.WriteString("\033[38;5;")
-		outbuf.Write(strconv.AppendUint(intbuf, uint64(fg-1), 10))
-		outbuf.WriteString("m")
-		outbuf.WriteString("\033[48;5;")
-		outbuf.Write(strconv.AppendUint(intbuf, uint64(bg-1), 10))
-		outbuf.WriteString("m")
-	default:
-		outbuf.WriteString("\033[3")
-		outbuf.Write(strconv.AppendUint(intbuf, uint64(fg-1), 10))
-		outbuf.WriteString(";4")
-		outbuf.Write(strconv.AppendUint(intbuf, uint64(bg-1), 10))
-		outbuf.WriteString("m")
-	}
-}
-
-type winsize struct {
-	rows    uint16
-	cols    uint16
-	xpixels uint16
-	ypixels uint16
-}
-
-func get_term_size(fd uintptr) (int, int) {
-	var sz winsize
-	_, _, _ = syscall.Syscall(syscall.SYS_IOCTL,
-		fd, uintptr(syscall.TIOCGWINSZ), uintptr(unsafe.Pointer(&sz)))
-	return int(sz.cols), int(sz.rows)
-}
-
-func send_attr(fg, bg Attribute) {
-	if fg == lastfg && bg == lastbg {
-		return
-	}
-
-	outbuf.WriteString(funcs[t_sgr0])
-
-	var fgcol, bgcol Attribute
-
-	switch output_mode {
-	case Output256:
-		fgcol = fg & 0x1FF
-		bgcol = bg & 0x1FF
-	case Output216:
-		fgcol = fg & 0xFF
-		bgcol = bg & 0xFF
-		if fgcol > 216 {
-			fgcol = ColorDefault
-		}
-		if bgcol > 216 {
-			bgcol = ColorDefault
-		}
-		if fgcol != ColorDefault {
-			fgcol += 0x10
-		}
-		if bgcol != ColorDefault {
-			bgcol += 0x10
-		}
-	case OutputGrayscale:
-		fgcol = fg & 0x1F
-		bgcol = bg & 0x1F
-		if fgcol > 26 {
-			fgcol = ColorDefault
-		}
-		if bgcol > 26 {
-			bgcol = ColorDefault
-		}
-		if fgcol != ColorDefault {
-			fgcol = grayscale[fgcol]
-		}
-		if bgcol != ColorDefault {
-			bgcol = grayscale[bgcol]
-		}
-	default:
-		fgcol = fg & 0x0F
-		bgcol = bg & 0x0F
-	}
-
-	if fgcol != ColorDefault {
-		if bgcol != ColorDefault {
-			write_sgr(fgcol, bgcol)
-		} else {
-			write_sgr_fg(fgcol)
-		}
-	} else if bgcol != ColorDefault {
-		write_sgr_bg(bgcol)
-	}
-
-	if fg&AttrBold != 0 {
-		outbuf.WriteString(funcs[t_bold])
-	}
-	if bg&AttrBold != 0 {
-		outbuf.WriteString(funcs[t_blink])
-	}
-	if fg&AttrUnderline != 0 {
-		outbuf.WriteString(funcs[t_underline])
-	}
-	if fg&AttrReverse|bg&AttrReverse != 0 {
-		outbuf.WriteString(funcs[t_reverse])
-	}
-
-	lastfg, lastbg = fg, bg
-}
-
-func send_char(x, y int, ch rune) {
-	var buf [8]byte
-	n := utf8.EncodeRune(buf[:], ch)
-	if x-1 != lastx || y != lasty {
-		write_cursor(x, y)
-	}
-	lastx, lasty = x, y
-	outbuf.Write(buf[:n])
-}
-
-func flush() error {
-	_, err := io.Copy(out, &outbuf)
-	outbuf.Reset()
-	return err
-}
-
-func send_clear() error {
-	send_attr(foreground, background)
-	outbuf.WriteString(funcs[t_clear_screen])
-	if !is_cursor_hidden(cursor_x, cursor_y) {
-		write_cursor(cursor_x, cursor_y)
-	}
-
-	// we need to invalidate cursor position too and these two vars are
-	// used only for simple cursor positioning optimization, cursor
-	// actually may be in the correct place, but we simply discard
-	// optimization once and it gives us simple solution for the case when
-	// cursor moved
-	lastx = coord_invalid
-	lasty = coord_invalid
-
-	return flush()
-}
-
-func update_size_maybe() error {
-	w, h := get_term_size(out.Fd())
-	if w != termw || h != termh {
-		termw, termh = w, h
-		back_buffer.resize(termw, termh)
-		front_buffer.resize(termw, termh)
-		front_buffer.clear()
-		return send_clear()
-	}
-	return nil
-}
-
-func tcsetattr(fd uintptr, termios *syscall_Termios) error {
-	r, _, e := syscall.Syscall(syscall.SYS_IOCTL,
-		fd, uintptr(syscall_TCSETS), uintptr(unsafe.Pointer(termios)))
-	if r != 0 {
-		return os.NewSyscallError("SYS_IOCTL", e)
-	}
-	return nil
-}
-
-func tcgetattr(fd uintptr, termios *syscall_Termios) error {
-	r, _, e := syscall.Syscall(syscall.SYS_IOCTL,
-		fd, uintptr(syscall_TCGETS), uintptr(unsafe.Pointer(termios)))
-	if r != 0 {
-		return os.NewSyscallError("SYS_IOCTL", e)
-	}
-	return nil
-}
-
-func parse_mouse_event(event *Event, buf string) (int, bool) {
-	if strings.HasPrefix(buf, "\033[M") && len(buf) >= 6 {
-		// X10 mouse encoding, the simplest one
-		// \033 [ M Cb Cx Cy
-		b := buf[3] - 32
-		switch b & 3 {
-		case 0:
-			if b&64 != 0 {
-				event.Key = MouseWheelUp
-			} else {
-				event.Key = MouseLeft
-			}
-		case 1:
-			if b&64 != 0 {
-				event.Key = MouseWheelDown
-			} else {
-				event.Key = MouseMiddle
-			}
-		case 2:
-			event.Key = MouseRight
-		case 3:
-			event.Key = MouseRelease
-		default:
-			return 6, false
-		}
-		event.Type = EventMouse // KeyEvent by default
-		if b&32 != 0 {
-			event.Mod |= ModMotion
-		}
-
-		// the coord is 1,1 for upper left
-		event.MouseX = int(buf[4]) - 1 - 32
-		event.MouseY = int(buf[5]) - 1 - 32
-		return 6, true
-	} else if strings.HasPrefix(buf, "\033[<") || strings.HasPrefix(buf, "\033[") {
-		// xterm 1006 extended mode or urxvt 1015 extended mode
-		// xterm: \033 [ < Cb ; Cx ; Cy (M or m)
-		// urxvt: \033 [ Cb ; Cx ; Cy M
-
-		// find the first M or m, that's where we stop
-		mi := strings.IndexAny(buf, "Mm")
-		if mi == -1 {
-			return 0, false
-		}
-
-		// whether it's a capital M or not
-		isM := buf[mi] == 'M'
-
-		// whether it's urxvt or not
-		isU := false
-
-		// buf[2] is safe here, because having M or m found means we have at
-		// least 3 bytes in a string
-		if buf[2] == '<' {
-			buf = buf[3:mi]
-		} else {
-			isU = true
-			buf = buf[2:mi]
-		}
-
-		s1 := strings.Index(buf, ";")
-		s2 := strings.LastIndex(buf, ";")
-		// not found or only one ';'
-		if s1 == -1 || s2 == -1 || s1 == s2 {
-			return 0, false
-		}
-
-		n1, err := strconv.ParseInt(buf[0:s1], 10, 64)
-		if err != nil {
-			return 0, false
-		}
-		n2, err := strconv.ParseInt(buf[s1+1:s2], 10, 64)
-		if err != nil {
-			return 0, false
-		}
-		n3, err := strconv.ParseInt(buf[s2+1:], 10, 64)
-		if err != nil {
-			return 0, false
-		}
-
-		// on urxvt, first number is encoded exactly as in X10, but we need to
-		// make it zero-based, on xterm it is zero-based already
-		if isU {
-			n1 -= 32
-		}
-		switch n1 & 3 {
-		case 0:
-			if n1&64 != 0 {
-				event.Key = MouseWheelUp
-			} else {
-				event.Key = MouseLeft
-			}
-		case 1:
-			if n1&64 != 0 {
-				event.Key = MouseWheelDown
-			} else {
-				event.Key = MouseMiddle
-			}
-		case 2:
-			event.Key = MouseRight
-		case 3:
-			event.Key = MouseRelease
-		default:
-			return mi + 1, false
-		}
-		if !isM {
-			// on xterm mouse release is signaled by lowercase m
-			event.Key = MouseRelease
-		}
-
-		event.Type = EventMouse // KeyEvent by default
-		if n1&32 != 0 {
-			event.Mod |= ModMotion
-		}
-
-		event.MouseX = int(n2) - 1
-		event.MouseY = int(n3) - 1
-		return mi + 1, true
-	}
-
-	return 0, false
-}
-
-func parse_escape_sequence(event *Event, buf []byte) (int, bool) {
-	bufstr := string(buf)
-	for i, key := range keys {
-		if strings.HasPrefix(bufstr, key) {
-			event.Ch = 0
-			event.Key = Key(0xFFFF - i)
-			return len(key), true
-		}
-	}
-
-	// if none of the keys match, let's try mouse sequences
-	return parse_mouse_event(event, bufstr)
-}
-
-func extract_raw_event(data []byte, event *Event) bool {
-	if len(inbuf) == 0 {
-		return false
-	}
-
-	n := len(data)
-	if n == 0 {
-		return false
-	}
-
-	n = copy(data, inbuf)
-	copy(inbuf, inbuf[n:])
-	inbuf = inbuf[:len(inbuf)-n]
-
-	event.N = n
-	event.Type = EventRaw
-	return true
-}
-
-func extract_event(inbuf []byte, event *Event, allow_esc_wait bool) extract_event_res {
-	if len(inbuf) == 0 {
-		event.N = 0
-		return event_not_extracted
-	}
-
-	if inbuf[0] == '\033' {
-		// possible escape sequence
-		if n, ok := parse_escape_sequence(event, inbuf); n != 0 {
-			event.N = n
-			if ok {
-				return event_extracted
-			} else {
-				return event_not_extracted
-			}
-		}
-
-		// possible partially read escape sequence; trigger a wait if appropriate
-		if enable_wait_for_escape_sequence() && allow_esc_wait {
-			event.N = 0
-			return esc_wait
-		}
-
-		// it's not escape sequence, then it's Alt or Esc, check input_mode
-		switch {
-		case input_mode&InputEsc != 0:
-			// if we're in escape mode, fill Esc event, pop buffer, return success
-			event.Ch = 0
-			event.Key = KeyEsc
-			event.Mod = 0
-			event.N = 1
-			return event_extracted
-		case input_mode&InputAlt != 0:
-			// if we're in alt mode, set Alt modifier to event and redo parsing
-			event.Mod = ModAlt
-			status := extract_event(inbuf[1:], event, false)
-			if status == event_extracted {
-				event.N++
-			} else {
-				event.N = 0
-			}
-			return status
-		default:
-			panic("unreachable")
-		}
-	}
-
-	// if we're here, this is not an escape sequence and not an alt sequence
-	// so, it's a FUNCTIONAL KEY or a UNICODE character
-
-	// first of all check if it's a functional key
-	if Key(inbuf[0]) <= KeySpace || Key(inbuf[0]) == KeyBackspace2 {
-		// fill event, pop buffer, return success
-		event.Ch = 0
-		event.Key = Key(inbuf[0])
-		event.N = 1
-		return event_extracted
-	}
-
-	// the only possible option is utf8 rune
-	if r, n := utf8.DecodeRune(inbuf); r != utf8.RuneError {
-		event.Ch = r
-		event.Key = 0
-		event.N = n
-		return event_extracted
-	}
-
-	return event_not_extracted
-}
-
-func fcntl(fd int, cmd int, arg int) (val int, err error) {
-	r, _, e := syscall.Syscall(syscall.SYS_FCNTL, uintptr(fd), uintptr(cmd),
-		uintptr(arg))
-	val = int(r)
-	if e != 0 {
-		err = e
-	}
-	return
-}