termui: use a forked gocui to fix large character handling

11 files changed, 2169 insertions, 0 deletions

diff --git a/vendor/github.com/MichaelMure/gocui/.gitignore b/vendor/github.com/MichaelMure/gocui/.gitignore
new file mode 100644
index 00000000..1377554e
--- /dev/null
+++ b/vendor/github.com/MichaelMure/gocui/.gitignore
@@ -0,0 +1 @@
+*.swp
diff --git a/vendor/github.com/MichaelMure/gocui/AUTHORS b/vendor/github.com/MichaelMure/gocui/AUTHORS
new file mode 100644
index 00000000..43ec4cec
--- /dev/null
+++ b/vendor/github.com/MichaelMure/gocui/AUTHORS
@@ -0,0 +1,30 @@
+# This is the official list of gocui authors for copyright purposes.
+
+# Names should be added to this file as
+#	Name or Organization <email address> contribution
+#		Contribution
+# The email address is not required for organizations.
+
+Roi Martin <jroi.martin@gmail.com>
+	Main developer
+
+Ryan Sullivan <kayoticsully@gmail.com>
+	Toggleable view frames
+
+Matthieu Rakotojaona <matthieu.rakotojaona@gmail.com>
+	Wrapped views
+
+Harry Lawrence <hazbo@gmx.com>
+	Basic mouse support
+
+Danny Tylman <dtylman@gmail.com>
+	Masked views
+
+Frederik Deweerdt <frederik.deweerdt@gmail.com>
+	Colored fonts
+
+Henri Koski <henri.t.koski@gmail.com>
+	Custom current view color
+
+Dustin Willis Webber <dustin.webber@gmail.com>
+	256-colors output mode support
diff --git a/vendor/github.com/MichaelMure/gocui/LICENSE b/vendor/github.com/MichaelMure/gocui/LICENSE
new file mode 100644
index 00000000..8cb28215
--- /dev/null
+++ b/vendor/github.com/MichaelMure/gocui/LICENSE
@@ -0,0 +1,23 @@
+Copyright (c) 2014 The gocui Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the gocui Authors nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/MichaelMure/gocui/README.md b/vendor/github.com/MichaelMure/gocui/README.md
new file mode 100644
index 00000000..d7b55a3b
--- /dev/null
+++ b/vendor/github.com/MichaelMure/gocui/README.md
@@ -0,0 +1,110 @@
+# GOCUI - Go Console User Interface
+
+[![GoDoc](https://godoc.org/github.com/jroimartin/gocui?status.svg)](https://godoc.org/github.com/jroimartin/gocui)
+
+Minimalist Go package aimed at creating Console User Interfaces.
+
+## Features
+
+* Minimalist API.
+* Views (the "windows" in the GUI) implement the interface io.ReadWriter.
+* Support for overlapping views.
+* The GUI can be modified at runtime (concurrent-safe).
+* Global and view-level keybindings.
+* Mouse support.
+* Colored text.
+* Customizable edition mode.
+* Easy to build reusable widgets, complex layouts...
+
+## Installation
+
+Execute:
+
+```
+$ go get github.com/jroimartin/gocui
+```
+
+## Documentation
+
+Execute:
+
+```
+$ go doc github.com/jroimartin/gocui
+```
+
+Or visit [godoc.org](https://godoc.org/github.com/jroimartin/gocui) to read it
+online.
+
+## Example
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/jroimartin/gocui"
+)
+
+func main() {
+	g, err := gocui.NewGui(gocui.OutputNormal)
+	if err != nil {
+		log.Panicln(err)
+	}
+	defer g.Close()
+
+	g.SetManagerFunc(layout)
+
+	if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
+		log.Panicln(err)
+	}
+
+	if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
+		log.Panicln(err)
+	}
+}
+
+func layout(g *gocui.Gui) error {
+	maxX, maxY := g.Size()
+	if v, err := g.SetView("hello", maxX/2-7, maxY/2, maxX/2+7, maxY/2+2); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		fmt.Fprintln(v, "Hello world!")
+	}
+	return nil
+}
+
+func quit(g *gocui.Gui, v *gocui.View) error {
+	return gocui.ErrQuit
+}
+```
+
+## Screenshots
+
+![r2cui](https://cloud.githubusercontent.com/assets/1223476/19418932/63645052-93ce-11e6-867c-da5e97e37237.png)
+
+![_examples/demo.go](https://cloud.githubusercontent.com/assets/1223476/5992750/720b84f0-aa36-11e4-88ec-296fa3247b52.png)
+
+![_examples/dynamic.go](https://cloud.githubusercontent.com/assets/1223476/5992751/76ad5cc2-aa36-11e4-8204-6a90269db827.png)
+
+## Projects using gocui
+
+* [komanda-cli](https://github.com/mephux/komanda-cli): IRC Client For Developers.
+* [vuls](https://github.com/future-architect/vuls): Agentless vulnerability scanner for Linux/FreeBSD.
+* [wuzz](https://github.com/asciimoo/wuzz): Interactive cli tool for HTTP inspection.
+* [httplab](https://github.com/gchaincl/httplab): Interactive web server.
+* [domainr](https://github.com/MichaelThessel/domainr): Tool that checks the availability of domains based on keywords.
+* [gotime](https://github.com/nanohard/gotime): Time tracker for projects and tasks.
+* [claws](https://github.com/thehowl/claws): Interactive command line client for testing websockets.
+* [terminews](http://github.com/antavelos/terminews): Terminal based RSS reader.
+* [diagram](https://github.com/esimov/diagram): Tool to convert ascii arts into hand drawn diagrams.
+* [pody](https://github.com/JulienBreux/pody): CLI app to manage Pods in a Kubernetes cluster.
+* [kubexp](https://github.com/alitari/kubexp): Kubernetes client.
+* [kcli](https://github.com/cswank/kcli): Tool for inspecting kafka topics/partitions/messages.
+* [fac](https://github.com/mkchoi212/fac): git merge conflict resolver
+* [jsonui](https://github.com/gulyasm/jsonui): Interactive JSON explorer for your terminal.
+* [cointop](https://github.com/miguelmota/cointop): Interactive terminal based UI application for tracking cryptocurrencies.
+
+Note: if your project is not listed here, let us know! :)
diff --git a/vendor/github.com/MichaelMure/gocui/attribute.go b/vendor/github.com/MichaelMure/gocui/attribute.go
new file mode 100644
index 00000000..bad758a1
--- /dev/null
+++ b/vendor/github.com/MichaelMure/gocui/attribute.go
@@ -0,0 +1,32 @@
+// Copyright 2014 The gocui Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gocui
+
+import "github.com/nsf/termbox-go"
+
+// Attribute represents a terminal attribute, like color, font style, etc. They
+// can be combined using bitwise OR (|). Note that it is not possible to
+// combine multiple color attributes.
+type Attribute termbox.Attribute
+
+// Color attributes.
+const (
+	ColorDefault Attribute = Attribute(termbox.ColorDefault)
+	ColorBlack             = Attribute(termbox.ColorBlack)
+	ColorRed               = Attribute(termbox.ColorRed)
+	ColorGreen             = Attribute(termbox.ColorGreen)
+	ColorYellow            = Attribute(termbox.ColorYellow)
+	ColorBlue              = Attribute(termbox.ColorBlue)
+	ColorMagenta           = Attribute(termbox.ColorMagenta)
+	ColorCyan              = Attribute(termbox.ColorCyan)
+	ColorWhite             = Attribute(termbox.ColorWhite)
+)
+
+// Text style attributes.
+const (
+	AttrBold      Attribute = Attribute(termbox.AttrBold)
+	AttrUnderline           = Attribute(termbox.AttrUnderline)
+	AttrReverse             = Attribute(termbox.AttrReverse)
+)
diff --git a/vendor/github.com/MichaelMure/gocui/doc.go b/vendor/github.com/MichaelMure/gocui/doc.go
new file mode 100644
index 00000000..fe128afb
--- /dev/null
+++ b/vendor/github.com/MichaelMure/gocui/doc.go
@@ -0,0 +1,118 @@
+// Copyright 2014 The gocui Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package gocui allows to create console user interfaces.
+
+Create a new GUI:
+
+	g, err := gocui.NewGui(gocui.OutputNormal)
+	if err != nil {
+		// handle error
+	}
+	defer g.Close()
+
+	// Set GUI managers and key bindings
+	// ...
+
+	if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
+		// handle error
+	}
+
+Set GUI managers:
+
+	g.SetManager(mgr1, mgr2)
+
+Managers are in charge of GUI's layout and can be used to build widgets. On
+each iteration of the GUI's main loop, the Layout function of each configured
+manager is executed. Managers are used to set-up and update the application's
+main views, being possible to freely change them during execution. Also, it is
+important to mention that a main loop iteration is executed on each reported
+event (key-press, mouse event, window resize, etc).
+
+GUIs are composed by Views, you can think of it as buffers. Views implement the
+io.ReadWriter interface, so you can just write to them if you want to modify
+their content. The same is valid for reading.
+
+Create and initialize a view with absolute coordinates:
+
+	if v, err := g.SetView("viewname", 2, 2, 22, 7); err != nil {
+		if err != gocui.ErrUnknownView {
+			// handle error
+		}
+		fmt.Fprintln(v, "This is a new view")
+		// ...
+	}
+
+Views can also be created using relative coordinates:
+
+	maxX, maxY := g.Size()
+	if v, err := g.SetView("viewname", maxX/2-30, maxY/2, maxX/2+30, maxY/2+2); err != nil {
+		// ...
+	}
+
+Configure keybindings:
+
+	if err := g.SetKeybinding("viewname", gocui.KeyEnter, gocui.ModNone, fcn); err != nil {
+		// handle error
+	}
+
+gocui implements full mouse support that can be enabled with:
+
+	g.Mouse = true
+
+Mouse events are handled like any other keybinding:
+
+	if err := g.SetKeybinding("viewname", gocui.MouseLeft, gocui.ModNone, fcn); err != nil {
+		// handle error
+	}
+
+IMPORTANT: Views can only be created, destroyed or updated in three ways: from
+the Layout function within managers, from keybinding callbacks or via
+*Gui.Update(). The reason for this is that it allows gocui to be
+concurrent-safe. So, if you want to update your GUI from a goroutine, you must
+use *Gui.Update(). For example:
+
+	g.Update(func(g *gocui.Gui) error {
+		v, err := g.View("viewname")
+		if err != nil {
+			// handle error
+		}
+		v.Clear()
+		fmt.Fprintln(v, "Writing from different goroutines")
+		return nil
+	})
+
+By default, gocui provides a basic edition mode. This mode can be extended
+and customized creating a new Editor and assigning it to *View.Editor:
+
+	type Editor interface {
+		Edit(v *View, key Key, ch rune, mod Modifier)
+	}
+
+DefaultEditor can be taken as example to create your own custom Editor:
+
+	var DefaultEditor Editor = EditorFunc(simpleEditor)
+
+	func simpleEditor(v *View, key Key, ch rune, mod Modifier) {
+		switch {
+		case ch != 0 && mod == 0:
+			v.EditWrite(ch)
+		case key == KeySpace:
+			v.EditWrite(' ')
+		case key == KeyBackspace || key == KeyBackspace2:
+			v.EditDelete(true)
+		// ...
+		}
+	}
+
+Colored text:
+
+Views allow to add colored text using ANSI colors. For example:
+
+	fmt.Fprintln(v, "\x1b[0;31mHello world")
+
+For more information, see the examples in folder "_examples/".
+*/
+package gocui
diff --git a/vendor/github.com/MichaelMure/gocui/edit.go b/vendor/github.com/MichaelMure/gocui/edit.go
new file mode 100644
index 00000000..de86580f
--- /dev/null
+++ b/vendor/github.com/MichaelMure/gocui/edit.go
@@ -0,0 +1,349 @@
+// Copyright 2014 The gocui Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gocui
+
+import (
+	"errors"
+
+	"github.com/mattn/go-runewidth"
+)
+
+const maxInt = int(^uint(0) >> 1)
+
+// Editor interface must be satisfied by gocui editors.
+type Editor interface {
+	Edit(v *View, key Key, ch rune, mod Modifier)
+}
+
+// The EditorFunc type is an adapter to allow the use of ordinary functions as
+// Editors. If f is a function with the appropriate signature, EditorFunc(f)
+// is an Editor object that calls f.
+type EditorFunc func(v *View, key Key, ch rune, mod Modifier)
+
+// Edit calls f(v, key, ch, mod)
+func (f EditorFunc) Edit(v *View, key Key, ch rune, mod Modifier) {
+	f(v, key, ch, mod)
+}
+
+// DefaultEditor is the default editor.
+var DefaultEditor Editor = EditorFunc(simpleEditor)
+
+// simpleEditor is used as the default gocui editor.
+func simpleEditor(v *View, key Key, ch rune, mod Modifier) {
+	switch {
+	case ch != 0 && mod == 0:
+		v.EditWrite(ch)
+	case key == KeySpace:
+		v.EditWrite(' ')
+	case key == KeyBackspace || key == KeyBackspace2:
+		v.EditDelete(true)
+	case key == KeyDelete:
+		v.EditDelete(false)
+	case key == KeyInsert:
+		v.Overwrite = !v.Overwrite
+	case key == KeyEnter:
+		v.EditNewLine()
+	case key == KeyArrowDown:
+		v.MoveCursor(0, 1, false)
+	case key == KeyArrowUp:
+		v.MoveCursor(0, -1, false)
+	case key == KeyArrowLeft:
+		v.MoveCursor(-1, 0, false)
+	case key == KeyArrowRight:
+		v.MoveCursor(1, 0, false)
+	}
+}
+
+// EditWrite writes a rune at the cursor position.
+func (v *View) EditWrite(ch rune) {
+	v.writeRune(v.cx, v.cy, ch)
+	v.MoveCursor(runewidth.RuneWidth(ch), 0, true)
+}
+
+// EditDelete deletes a rune at the cursor position. back determines the
+// direction.
+func (v *View) EditDelete(back bool) {
+	x, y := v.ox+v.cx, v.oy+v.cy
+	if y < 0 {
+		return
+	} else if y >= len(v.viewLines) {
+		v.MoveCursor(-1, 0, true)
+		return
+	}
+
+	maxX, _ := v.Size()
+	if back {
+		if x == 0 { // start of the line
+			if y < 1 {
+				return
+			}
+
+			var maxPrevWidth int
+			if v.Wrap {
+				maxPrevWidth = maxX
+			} else {
+				maxPrevWidth = maxInt
+			}
+
+			if v.viewLines[y].linesX == 0 { // regular line
+				v.mergeLines(v.cy - 1)
+				if len(v.viewLines[y-1].line) < maxPrevWidth {
+					v.MoveCursor(-1, 0, true)
+				}
+			} else { // wrapped line
+				ch, _ := v.deleteRune(len(v.viewLines[y-1].line)-1, v.cy-1)
+				v.MoveCursor(0-runewidth.RuneWidth(ch), 0, true)
+			}
+		} else { // middle/end of the line
+			ch, _ := v.deleteRune(v.cx-1, v.cy)
+			v.MoveCursor(0-runewidth.RuneWidth(ch), 0, true)
+		}
+	} else {
+		if x == len(v.viewLines[y].line) { // end of the line
+			v.mergeLines(v.cy)
+		} else { // start/middle of the line
+			v.deleteRune(v.cx, v.cy)
+		}
+	}
+}
+
+// EditNewLine inserts a new line under the cursor.
+func (v *View) EditNewLine() {
+	v.breakLine(v.cx, v.cy)
+	v.ox = 0
+	v.cx = 0
+	v.MoveCursor(0, 1, true)
+}
+
+// MoveCursor moves the cursor taking into account the width of the line/view,
+// displacing the origin if necessary.
+func (v *View) MoveCursor(dx, dy int, writeMode bool) {
+	maxX, maxY := v.Size()
+	cx, cy := v.cx+dx, v.cy+dy
+	x, y := v.ox+cx, v.oy+cy
+
+	var curLineWidth, prevLineWidth int
+	// get the width of the current line
+	if writeMode {
+		if v.Wrap {
+			curLineWidth = maxX - 1
+		} else {
+			curLineWidth = maxInt
+		}
+	} else {
+		if y >= 0 && y < len(v.viewLines) {
+			curLineWidth = len(v.viewLines[y].line)
+			if v.Wrap && curLineWidth >= maxX {
+				curLineWidth = maxX - 1
+			}
+		} else {
+			curLineWidth = 0
+		}
+	}
+	// get the width of the previous line
+	if y-1 >= 0 && y-1 < len(v.viewLines) {
+		prevLineWidth = len(v.viewLines[y-1].line)
+	} else {
+		prevLineWidth = 0
+	}
+
+	// adjust cursor's x position and view's x origin
+	if x > curLineWidth { // move to next line
+		if dx > 0 { // horizontal movement
+			cy++
+			if writeMode || v.oy+cy < len(v.viewLines) {
+				if !v.Wrap {
+					v.ox = 0
+				}
+				v.cx = 0
+			}
+		} else { // vertical movement
+			if curLineWidth > 0 { // move cursor to the EOL
+				if v.Wrap {
+					v.cx = curLineWidth
+				} else {
+					ncx := curLineWidth - v.ox
+					if ncx < 0 {
+						v.ox += ncx
+						if v.ox < 0 {
+							v.ox = 0
+						}
+						v.cx = 0
+					} else {
+						v.cx = ncx
+					}
+				}
+			} else {
+				if writeMode || v.oy+cy < len(v.viewLines) {
+					if !v.Wrap {
+						v.ox = 0
+					}
+					v.cx = 0
+				}
+			}
+		}
+	} else if cx < 0 {
+		if !v.Wrap && v.ox > 0 { // move origin to the left
+			v.ox += cx
+			v.cx = 0
+		} else { // move to previous line
+			cy--
+			if prevLineWidth > 0 {
+				if !v.Wrap { // set origin so the EOL is visible
+					nox := prevLineWidth - maxX + 1
+					if nox < 0 {
+						v.ox = 0
+					} else {
+						v.ox = nox
+					}
+				}
+				v.cx = prevLineWidth
+			} else {
+				if !v.Wrap {
+					v.ox = 0
+				}
+				v.cx = 0
+			}
+		}
+	} else { // stay on the same line
+		if v.Wrap {
+			v.cx = cx
+		} else {
+			if cx >= maxX {
+				v.ox += cx - maxX + 1
+				v.cx = maxX
+			} else {
+				v.cx = cx
+			}
+		}
+	}
+
+	// adjust cursor's y position and view's y origin
+	if cy < 0 {
+		if v.oy > 0 {
+			v.oy--
+		}
+	} else if writeMode || v.oy+cy < len(v.viewLines) {
+		if cy >= maxY {
+			v.oy++
+		} else {
+			v.cy = cy
+		}
+	}
+}
+
+// writeRune writes a rune into the view's internal buffer, at the
+// position corresponding to the point (x, y). The length of the internal
+// buffer is increased if the point is out of bounds. Overwrite mode is
+// governed by the value of View.overwrite.
+func (v *View) writeRune(x, y int, ch rune) error {
+	v.tainted = true
+
+	x, y, err := v.realPosition(x, y)
+	if err != nil {
+		return err
+	}
+
+	if x < 0 || y < 0 {
+		return errors.New("invalid point")
+	}
+
+	if y >= len(v.lines) {
+		s := make([][]cell, y-len(v.lines)+1)
+		v.lines = append(v.lines, s...)
+	}
+
+	olen := len(v.lines[y])
+
+	var s []cell
+	if x >= len(v.lines[y]) {
+		s = make([]cell, x-len(v.lines[y])+1)
+	} else if !v.Overwrite {
+		s = make([]cell, 1)
+	}
+	v.lines[y] = append(v.lines[y], s...)
+
+	if !v.Overwrite || (v.Overwrite && x >= olen-1) {
+		copy(v.lines[y][x+1:], v.lines[y][x:])
+	}
+	v.lines[y][x] = cell{
+		fgColor: v.FgColor,
+		bgColor: v.BgColor,
+		chr:     ch,
+	}
+
+	return nil
+}
+
+// deleteRune removes a rune from the view's internal buffer, at the
+// position corresponding to the point (x, y).
+func (v *View) deleteRune(x, y int) (ch rune, err error) {
+	v.tainted = true
+
+	x, y, err = v.realPosition(x, y)
+	if err != nil {
+		return 0, err
+	}
+
+	if x < 0 || y < 0 || y >= len(v.lines) || x >= len(v.lines[y]) {
+		return 0, errors.New("invalid point")
+	}
+	chx := v.lines[y][x]
+	v.lines[y] = append(v.lines[y][:x], v.lines[y][x+1:]...)
+	return chx.chr, nil
+}
+
+// mergeLines merges the lines "y" and "y+1" if possible.
+func (v *View) mergeLines(y int) error {
+	v.tainted = true
+
+	_, y, err := v.realPosition(0, y)
+	if err != nil {
+		return err
+	}
+
+	if y < 0 || y >= len(v.lines) {
+		return errors.New("invalid point")
+	}
+
+	if y < len(v.lines)-1 { // otherwise we don't need to merge anything
+		v.lines[y] = append(v.lines[y], v.lines[y+1]...)
+		v.lines = append(v.lines[:y+1], v.lines[y+2:]...)
+	}
+	return nil
+}
+
+// breakLine breaks a line of the internal buffer at the position corresponding
+// to the point (x, y).
+func (v *View) breakLine(x, y int) error {
+	v.tainted = true
+
+	x, y, err := v.realPosition(x, y)
+	if err != nil {
+		return err
+	}
+
+	if y < 0 || y >= len(v.lines) {
+		return errors.New("invalid point")
+	}
+
+	var left, right []cell
+	if x < len(v.lines[y]) { // break line
+		left = make([]cell, len(v.lines[y][:x]))
+		copy(left, v.lines[y][:x])
+		right = make([]cell, len(v.lines[y][x:]))
+		copy(right, v.lines[y][x:])
+	} else { // new empty line
+		left = v.lines[y]
+	}
+
+	lines := make([][]cell, len(v.lines)+1)
+	lines[y] = left
+	lines[y+1] = right
+	copy(lines, v.lines[:y])
+	copy(lines[y+2:], v.lines[y+1:])
+	v.lines = lines
+	return nil
+}
diff --git a/vendor/github.com/MichaelMure/gocui/escape.go b/vendor/github.com/MichaelMure/gocui/escape.go
new file mode 100644
index 00000000..ec31bbe0
--- /dev/null
+++ b/vendor/github.com/MichaelMure/gocui/escape.go
@@ -0,0 +1,229 @@
+// Copyright 2014 The gocui Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gocui
+
+import (
+	"errors"
+	"strconv"
+)
+
+type escapeInterpreter struct {
+	state                  escapeState
+	curch                  rune
+	csiParam               []string
+	curFgColor, curBgColor Attribute
+	mode                   OutputMode
+}
+
+type escapeState int
+
+const (
+	stateNone escapeState = iota
+	stateEscape
+	stateCSI
+	stateParams
+)
+
+var (
+	errNotCSI        = errors.New("Not a CSI escape sequence")
+	errCSIParseError = errors.New("CSI escape sequence parsing error")
+	errCSITooLong    = errors.New("CSI escape sequence is too long")
+)
+
+// runes in case of error will output the non-parsed runes as a string.
+func (ei *escapeInterpreter) runes() []rune {
+	switch ei.state {
+	case stateNone:
+		return []rune{0x1b}
+	case stateEscape:
+		return []rune{0x1b, ei.curch}
+	case stateCSI:
+		return []rune{0x1b, '[', ei.curch}
+	case stateParams:
+		ret := []rune{0x1b, '['}
+		for _, s := range ei.csiParam {
+			ret = append(ret, []rune(s)...)
+			ret = append(ret, ';')
+		}
+		return append(ret, ei.curch)
+	}
+	return nil
+}
+
+// newEscapeInterpreter returns an escapeInterpreter that will be able to parse
+// terminal escape sequences.
+func newEscapeInterpreter(mode OutputMode) *escapeInterpreter {
+	ei := &escapeInterpreter{
+		state:      stateNone,
+		curFgColor: ColorDefault,
+		curBgColor: ColorDefault,
+		mode:       mode,
+	}
+	return ei
+}
+
+// reset sets the escapeInterpreter in initial state.
+func (ei *escapeInterpreter) reset() {
+	ei.state = stateNone
+	ei.curFgColor = ColorDefault
+	ei.curBgColor = ColorDefault
+	ei.csiParam = nil
+}
+
+// parseOne parses a rune. If isEscape is true, it means that the rune is part
+// of an escape sequence, and as such should not be printed verbatim. Otherwise,
+// it's not an escape sequence.
+func (ei *escapeInterpreter) parseOne(ch rune) (isEscape bool, err error) {
+	// Sanity checks
+	if len(ei.csiParam) > 20 {
+		return false, errCSITooLong
+	}
+	if len(ei.csiParam) > 0 && len(ei.csiParam[len(ei.csiParam)-1]) > 255 {
+		return false, errCSITooLong
+	}
+
+	ei.curch = ch
+
+	switch ei.state {
+	case stateNone:
+		if ch == 0x1b {
+			ei.state = stateEscape
+			return true, nil
+		}
+		return false, nil
+	case stateEscape:
+		if ch == '[' {
+			ei.state = stateCSI
+			return true, nil
+		}
+		return false, errNotCSI
+	case stateCSI:
+		switch {
+		case ch >= '0' && ch <= '9':
+			ei.csiParam = append(ei.csiParam, "")
+		case ch == 'm':
+			ei.csiParam = append(ei.csiParam, "0")
+		default:
+			return false, errCSIParseError
+		}
+		ei.state = stateParams
+		fallthrough
+	case stateParams:
+		switch {
+		case ch >= '0' && ch <= '9':
+			ei.csiParam[len(ei.csiParam)-1] += string(ch)
+			return true, nil
+		case ch == ';':
+			ei.csiParam = append(ei.csiParam, "")
+			return true, nil
+		case ch == 'm':
+			var err error
+			switch ei.mode {
+			case OutputNormal:
+				err = ei.outputNormal()
+			case Output256:
+				err = ei.output256()
+			}
+			if err != nil {
+				return false, errCSIParseError
+			}
+
+			ei.state = stateNone
+			ei.csiParam = nil
+			return true, nil
+		default:
+			return false, errCSIParseError
+		}
+	}
+	return false, nil
+}
+
+// outputNormal provides 8 different colors:
+//   black, red, green, yellow, blue, magenta, cyan, white
+func (ei *escapeInterpreter) outputNormal() error {
+	for _, param := range ei.csiParam {
+		p, err := strconv.Atoi(param)
+		if err != nil {
+			return errCSIParseError
+		}
+
+		switch {
+		case p >= 30 && p <= 37:
+			ei.curFgColor = Attribute(p - 30 + 1)
+		case p == 39:
+			ei.curFgColor = ColorDefault
+		case p >= 40 && p <= 47:
+			ei.curBgColor = Attribute(p - 40 + 1)
+		case p == 49:
+			ei.curBgColor = ColorDefault
+		case p == 1:
+			ei.curFgColor |= AttrBold
+		case p == 4:
+			ei.curFgColor |= AttrUnderline
+		case p == 7:
+			ei.curFgColor |= AttrReverse
+		case p == 0:
+			ei.curFgColor = ColorDefault
+			ei.curBgColor = ColorDefault
+		}
+	}
+
+	return nil
+}
+
+// output256 allows you to leverage the 256-colors terminal mode:
+//   0x01 - 0x08: the 8 colors as in OutputNormal
+//   0x09 - 0x10: Color* | AttrBold
+//   0x11 - 0xe8: 216 different colors
+//   0xe9 - 0x1ff: 24 different shades of grey
+func (ei *escapeInterpreter) output256() error {
+	if len(ei.csiParam) < 3 {
+		return ei.outputNormal()
+	}
+
+	mode, err := strconv.Atoi(ei.csiParam[1])
+	if err != nil {
+		return errCSIParseError
+	}
+	if mode != 5 {
+		return ei.outputNormal()
+	}
+
+	fgbg, err := strconv.Atoi(ei.csiParam[0])
+	if err != nil {
+		return errCSIParseError
+	}
+	color, err := strconv.Atoi(ei.csiParam[2])
+	if err != nil {
+		return errCSIParseError
+	}
+
+	switch fgbg {
+	case 38:
+		ei.curFgColor = Attribute(color + 1)
+
+		for _, param := range ei.csiParam[3:] {
+			p, err := strconv.Atoi(param)
+			if err != nil {
+				return errCSIParseError
+			}
+
+			switch {
+			case p == 1:
+				ei.curFgColor |= AttrBold
+			case p == 4:
+				ei.curFgColor |= AttrUnderline
+			case p == 7:
+				ei.curFgColor |= AttrReverse
+			}
+		}
+	case 48:
+		ei.curBgColor = Attribute(color + 1)
+	default:
+		return errCSIParseError
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/MichaelMure/gocui/gui.go b/vendor/github.com/MichaelMure/gocui/gui.go
new file mode 100644
index 00000000..9499d3c3
--- /dev/null
+++ b/vendor/github.com/MichaelMure/gocui/gui.go
@@ -0,0 +1,636 @@
+// Copyright 2014 The gocui Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gocui
+
+import (
+	"errors"
+
+	"github.com/nsf/termbox-go"
+)
+
+var (
+	// ErrQuit is used to decide if the MainLoop finished successfully.
+	ErrQuit = errors.New("quit")
+
+	// ErrUnknownView allows to assert if a View must be initialized.
+	ErrUnknownView = errors.New("unknown view")
+)
+
+// OutputMode represents the terminal's output mode (8 or 256 colors).
+type OutputMode termbox.OutputMode
+
+const (
+	// OutputNormal provides 8-colors terminal mode.
+	OutputNormal = OutputMode(termbox.OutputNormal)
+
+	// Output256 provides 256-colors terminal mode.
+	Output256 = OutputMode(termbox.Output256)
+)
+
+// Gui represents the whole User Interface, including the views, layouts
+// and keybindings.
+type Gui struct {
+	tbEvents    chan termbox.Event
+	userEvents  chan userEvent
+	views       []*View
+	currentView *View
+	managers    []Manager
+	keybindings []*keybinding
+	maxX, maxY  int
+	outputMode  OutputMode
+
+	// BgColor and FgColor allow to configure the background and foreground
+	// colors of the GUI.
+	BgColor, FgColor Attribute
+
+	// SelBgColor and SelFgColor allow to configure the background and
+	// foreground colors of the frame of the current view.
+	SelBgColor, SelFgColor Attribute
+
+	// If Highlight is true, Sel{Bg,Fg}Colors will be used to draw the
+	// frame of the current view.
+	Highlight bool
+
+	// If Cursor is true then the cursor is enabled.
+	Cursor bool
+
+	// If Mouse is true then mouse events will be enabled.
+	Mouse bool
+
+	// If InputEsc is true, when ESC sequence is in the buffer and it doesn't
+	// match any known sequence, ESC means KeyEsc.
+	InputEsc bool
+
+	// If ASCII is true then use ASCII instead of unicode to draw the
+	// interface. Using ASCII is more portable.
+	ASCII bool
+}
+
+// NewGui returns a new Gui object with a given output mode.
+func NewGui(mode OutputMode) (*Gui, error) {
+	if err := termbox.Init(); err != nil {
+		return nil, err
+	}
+
+	g := &Gui{}
+
+	g.outputMode = mode
+	termbox.SetOutputMode(termbox.OutputMode(mode))
+
+	g.tbEvents = make(chan termbox.Event, 20)
+	g.userEvents = make(chan userEvent, 20)
+
+	g.maxX, g.maxY = termbox.Size()
+
+	g.BgColor, g.FgColor = ColorDefault, ColorDefault
+	g.SelBgColor, g.SelFgColor = ColorDefault, ColorDefault
+
+	return g, nil
+}
+
+// Close finalizes the library. It should be called after a successful
+// initialization and when gocui is not needed anymore.
+func (g *Gui) Close() {
+	termbox.Close()
+}
+
+// Size returns the terminal's size.
+func (g *Gui) Size() (x, y int) {
+	return g.maxX, g.maxY
+}
+
+// SetRune writes a rune at the given point, relative to the top-left
+// corner of the terminal. It checks if the position is valid and applies
+// the given colors.
+func (g *Gui) SetRune(x, y int, ch rune, fgColor, bgColor Attribute) error {
+	if x < 0 || y < 0 || x >= g.maxX || y >= g.maxY {
+		return errors.New("invalid point")
+	}
+	termbox.SetCell(x, y, ch, termbox.Attribute(fgColor), termbox.Attribute(bgColor))
+	return nil
+}
+
+// Rune returns the rune contained in the cell at the given position.
+// It checks if the position is valid.
+func (g *Gui) Rune(x, y int) (rune, error) {
+	if x < 0 || y < 0 || x >= g.maxX || y >= g.maxY {
+		return ' ', errors.New("invalid point")
+	}
+	c := termbox.CellBuffer()[y*g.maxX+x]
+	return c.Ch, nil
+}
+
+// SetView creates a new view with its top-left corner at (x0, y0)
+// and the bottom-right one at (x1, y1). If a view with the same name
+// already exists, its dimensions are updated; otherwise, the error
+// ErrUnknownView is returned, which allows to assert if the View must
+// be initialized. It checks if the position is valid.
+func (g *Gui) SetView(name string, x0, y0, x1, y1 int) (*View, error) {
+	if x0 >= x1 || y0 >= y1 {
+		return nil, errors.New("invalid dimensions")
+	}
+	if name == "" {
+		return nil, errors.New("invalid name")
+	}
+
+	if v, err := g.View(name); err == nil {
+		v.x0 = x0
+		v.y0 = y0
+		v.x1 = x1
+		v.y1 = y1
+		v.tainted = true
+		return v, nil
+	}
+
+	v := newView(name, x0, y0, x1, y1, g.outputMode)
+	v.BgColor, v.FgColor = g.BgColor, g.FgColor
+	v.SelBgColor, v.SelFgColor = g.SelBgColor, g.SelFgColor
+	g.views = append(g.views, v)
+	return v, ErrUnknownView
+}
+
+// SetViewOnTop sets the given view on top of the existing ones.
+func (g *Gui) SetViewOnTop(name string) (*View, error) {
+	for i, v := range g.views {
+		if v.name == name {
+			s := append(g.views[:i], g.views[i+1:]...)
+			g.views = append(s, v)
+			return v, nil
+		}
+	}
+	return nil, ErrUnknownView
+}
+
+// SetViewOnBottom sets the given view on bottom of the existing ones.
+func (g *Gui) SetViewOnBottom(name string) (*View, error) {
+	for i, v := range g.views {
+		if v.name == name {
+			s := append(g.views[:i], g.views[i+1:]...)
+			g.views = append([]*View{v}, s...)
+			return v, nil
+		}
+	}
+	return nil, ErrUnknownView
+}
+
+// Views returns all the views in the GUI.
+func (g *Gui) Views() []*View {
+	return g.views
+}
+
+// View returns a pointer to the view with the given name, or error
+// ErrUnknownView if a view with that name does not exist.
+func (g *Gui) View(name string) (*View, error) {
+	for _, v := range g.views {
+		if v.name == name {
+			return v, nil
+		}
+	}
+	return nil, ErrUnknownView
+}
+
+// ViewByPosition returns a pointer to a view matching the given position, or
+// error ErrUnknownView if a view in that position does not exist.
+func (g *Gui) ViewByPosition(x, y int) (*View, error) {
+	// traverse views in reverse order checking top views first
+	for i := len(g.views); i > 0; i-- {
+		v := g.views[i-1]
+		if x > v.x0 && x < v.x1 && y > v.y0 && y < v.y1 {
+			return v, nil
+		}
+	}
+	return nil, ErrUnknownView
+}
+
+// ViewPosition returns the coordinates of the view with the given name, or
+// error ErrUnknownView if a view with that name does not exist.
+func (g *Gui) ViewPosition(name string) (x0, y0, x1, y1 int, err error) {
+	for _, v := range g.views {
+		if v.name == name {
+			return v.x0, v.y0, v.x1, v.y1, nil
+		}
+	}
+	return 0, 0, 0, 0, ErrUnknownView
+}
+
+// DeleteView deletes a view by name.
+func (g *Gui) DeleteView(name string) error {
+	for i, v := range g.views {
+		if v.name == name {
+			g.views = append(g.views[:i], g.views[i+1:]...)
+			return nil
+		}
+	}
+	return ErrUnknownView
+}
+
+// SetCurrentView gives the focus to a given view.
+func (g *Gui) SetCurrentView(name string) (*View, error) {
+	for _, v := range g.views {
+		if v.name == name {
+			g.currentView = v
+			return v, nil
+		}
+	}
+	return nil, ErrUnknownView
+}
+
+// CurrentView returns the currently focused view, or nil if no view
+// owns the focus.
+func (g *Gui) CurrentView() *View {
+	return g.currentView
+}
+
+// SetKeybinding creates a new keybinding. If viewname equals to ""
+// (empty string) then the keybinding will apply to all views. key must
+// be a rune or a Key.
+func (g *Gui) SetKeybinding(viewname string, key interface{}, mod Modifier, handler func(*Gui, *View) error) error {
+	var kb *keybinding
+
+	k, ch, err := getKey(key)
+	if err != nil {
+		return err
+	}
+	kb = newKeybinding(viewname, k, ch, mod, handler)
+	g.keybindings = append(g.keybindings, kb)
+	return nil
+}
+
+// DeleteKeybinding deletes a keybinding.
+func (g *Gui) DeleteKeybinding(viewname string, key interface{}, mod Modifier) error {
+	k, ch, err := getKey(key)
+	if err != nil {
+		return err
+	}
+
+	for i, kb := range g.keybindings {
+		if kb.viewName == viewname && kb.ch == ch && kb.key == k && kb.mod == mod {
+			g.keybindings = append(g.keybindings[:i], g.keybindings[i+1:]...)
+			return nil
+		}
+	}
+	return errors.New("keybinding not found")
+}
+
+// DeleteKeybindings deletes all keybindings of view.
+func (g *Gui) DeleteKeybindings(viewname string) {
+	var s []*keybinding
+	for _, kb := range g.keybindings {
+		if kb.viewName != viewname {
+			s = append(s, kb)
+		}
+	}
+	g.keybindings = s
+}
+
+// getKey takes an empty interface with a key and returns the corresponding
+// typed Key or rune.
+func getKey(key interface{}) (Key, rune, error) {
+	switch t := key.(type) {
+	case Key:
+		return t, 0, nil
+	case rune:
+		return 0, t, nil
+	default:
+		return 0, 0, errors.New("unknown type")
+	}
+}
+
+// userEvent represents an event triggered by the user.
+type userEvent struct {
+	f func(*Gui) error
+}
+
+// Update executes the passed function. This method can be called safely from a
+// goroutine in order to update the GUI. It is important to note that the
+// passed function won't be executed immediately, instead it will be added to
+// the user events queue. Given that Update spawns a goroutine, the order in
+// which the user events will be handled is not guaranteed.
+func (g *Gui) Update(f func(*Gui) error) {
+	go func() { g.userEvents <- userEvent{f: f} }()
+}
+
+// A Manager is in charge of GUI's layout and can be used to build widgets.
+type Manager interface {
+	// Layout is called every time the GUI is redrawn, it must contain the
+	// base views and its initializations.
+	Layout(*Gui) error
+}
+
+// The ManagerFunc type is an adapter to allow the use of ordinary functions as
+// Managers. If f is a function with the appropriate signature, ManagerFunc(f)
+// is an Manager object that calls f.
+type ManagerFunc func(*Gui) error
+
+// Layout calls f(g)
+func (f ManagerFunc) Layout(g *Gui) error {
+	return f(g)
+}
+
+// SetManager sets the given GUI managers. It deletes all views and
+// keybindings.
+func (g *Gui) SetManager(managers ...Manager) {
+	g.managers = managers
+	g.currentView = nil
+	g.views = nil
+	g.keybindings = nil
+
+	go func() { g.tbEvents <- termbox.Event{Type: termbox.EventResize} }()
+}
+
+// SetManagerFunc sets the given manager function. It deletes all views and
+// keybindings.
+func (g *Gui) SetManagerFunc(manager func(*Gui) error) {
+	g.SetManager(ManagerFunc(manager))
+}
+
+// MainLoop runs the main loop until an error is returned. A successful
+// finish should return ErrQuit.
+func (g *Gui) MainLoop() error {
+	go func() {
+		for {
+			g.tbEvents <- termbox.PollEvent()
+		}
+	}()
+
+	inputMode := termbox.InputAlt
+	if g.InputEsc {
+		inputMode = termbox.InputEsc
+	}
+	if g.Mouse {
+		inputMode |= termbox.InputMouse
+	}
+	termbox.SetInputMode(inputMode)
+
+	if err := g.flush(); err != nil {
+		return err
+	}
+	for {
+		select {
+		case ev := <-g.tbEvents:
+			if err := g.handleEvent(&ev); err != nil {
+				return err
+			}
+		case ev := <-g.userEvents:
+			if err := ev.f(g); err != nil {
+				return err
+			}
+		}
+		if err := g.consumeevents(); err != nil {
+			return err
+		}
+		if err := g.flush(); err != nil {
+			return err
+		}
+	}
+}
+
+// consumeevents handles the remaining events in the events pool.
+func (g *Gui) consumeevents() error {
+	for {
+		select {
+		case ev := <-g.tbEvents:
+			if err := g.handleEvent(&ev); err != nil {
+				return err
+			}
+		case ev := <-g.userEvents:
+			if err := ev.f(g); err != nil {
+				return err
+			}
+		default:
+			return nil
+		}
+	}
+}
+
+// handleEvent handles an event, based on its type (key-press, error,
+// etc.)
+func (g *Gui) handleEvent(ev *termbox.Event) error {
+	switch ev.Type {
+	case termbox.EventKey, termbox.EventMouse:
+		return g.onKey(ev)
+	case termbox.EventError:
+		return ev.Err
+	default:
+		return nil
+	}
+}
+
+// flush updates the gui, re-drawing frames and buffers.
+func (g *Gui) flush() error {
+	termbox.Clear(termbox.Attribute(g.FgColor), termbox.Attribute(g.BgColor))
+
+	maxX, maxY := termbox.Size()
+	// if GUI's size has changed, we need to redraw all views
+	if maxX != g.maxX || maxY != g.maxY {
+		for _, v := range g.views {
+			v.tainted = true
+		}
+	}
+	g.maxX, g.maxY = maxX, maxY
+
+	for _, m := range g.managers {
+		if err := m.Layout(g); err != nil {
+			return err
+		}
+	}
+	for _, v := range g.views {
+		if v.Frame {
+			var fgColor, bgColor Attribute
+			if g.Highlight && v == g.currentView {
+				fgColor = g.SelFgColor
+				bgColor = g.SelBgColor
+			} else {
+				fgColor = g.FgColor
+				bgColor = g.BgColor
+			}
+
+			if err := g.drawFrameEdges(v, fgColor, bgColor); err != nil {
+				return err
+			}
+			if err := g.drawFrameCorners(v, fgColor, bgColor); err != nil {
+				return err
+			}
+			if v.Title != "" {
+				if err := g.drawTitle(v, fgColor, bgColor); err != nil {
+					return err
+				}
+			}
+		}
+		if err := g.draw(v); err != nil {
+			return err
+		}
+	}
+	termbox.Flush()
+	return nil
+}
+
+// drawFrameEdges draws the horizontal and vertical edges of a view.
+func (g *Gui) drawFrameEdges(v *View, fgColor, bgColor Attribute) error {
+	runeH, runeV := '─', '│'
+	if g.ASCII {
+		runeH, runeV = '-', '|'
+	}
+
+	for x := v.x0 + 1; x < v.x1 && x < g.maxX; x++ {
+		if x < 0 {
+			continue
+		}
+		if v.y0 > -1 && v.y0 < g.maxY {
+			if err := g.SetRune(x, v.y0, runeH, fgColor, bgColor); err != nil {
+				return err
+			}
+		}
+		if v.y1 > -1 && v.y1 < g.maxY {
+			if err := g.SetRune(x, v.y1, runeH, fgColor, bgColor); err != nil {
+				return err
+			}
+		}
+	}
+	for y := v.y0 + 1; y < v.y1 && y < g.maxY; y++ {
+		if y < 0 {
+			continue
+		}
+		if v.x0 > -1 && v.x0 < g.maxX {
+			if err := g.SetRune(v.x0, y, runeV, fgColor, bgColor); err != nil {
+				return err
+			}
+		}
+		if v.x1 > -1 && v.x1 < g.maxX {
+			if err := g.SetRune(v.x1, y, runeV, fgColor, bgColor); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// drawFrameCorners draws the corners of the view.
+func (g *Gui) drawFrameCorners(v *View, fgColor, bgColor Attribute) error {
+	runeTL, runeTR, runeBL, runeBR := '┌', '┐', '└', '┘'
+	if g.ASCII {
+		runeTL, runeTR, runeBL, runeBR = '+', '+', '+', '+'
+	}
+
+	corners := []struct {
+		x, y int
+		ch   rune
+	}{{v.x0, v.y0, runeTL}, {v.x1, v.y0, runeTR}, {v.x0, v.y1, runeBL}, {v.x1, v.y1, runeBR}}
+
+	for _, c := range corners {
+		if c.x >= 0 && c.y >= 0 && c.x < g.maxX && c.y < g.maxY {
+			if err := g.SetRune(c.x, c.y, c.ch, fgColor, bgColor); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// drawTitle draws the title of the view.
+func (g *Gui) drawTitle(v *View, fgColor, bgColor Attribute) error {
+	if v.y0 < 0 || v.y0 >= g.maxY {
+		return nil
+	}
+
+	for i, ch := range v.Title {
+		x := v.x0 + i + 2
+		if x < 0 {
+			continue
+		} else if x > v.x1-2 || x >= g.maxX {
+			break
+		}
+		if err := g.SetRune(x, v.y0, ch, fgColor, bgColor); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// draw manages the cursor and calls the draw function of a view.
+func (g *Gui) draw(v *View) error {
+	if g.Cursor {
+		if curview := g.currentView; curview != nil {
+			vMaxX, vMaxY := curview.Size()
+			if curview.cx < 0 {
+				curview.cx = 0
+			} else if curview.cx >= vMaxX {
+				curview.cx = vMaxX - 1
+			}
+			if curview.cy < 0 {
+				curview.cy = 0
+			} else if curview.cy >= vMaxY {
+				curview.cy = vMaxY - 1
+			}
+
+			gMaxX, gMaxY := g.Size()
+			cx, cy := curview.x0+curview.cx+1, curview.y0+curview.cy+1
+			if cx >= 0 && cx < gMaxX && cy >= 0 && cy < gMaxY {
+				termbox.SetCursor(cx, cy)
+			} else {
+				termbox.HideCursor()
+			}
+		}
+	} else {
+		termbox.HideCursor()
+	}
+
+	v.clearRunes()
+	if err := v.draw(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// onKey manages key-press events. A keybinding handler is called when
+// a key-press or mouse event satisfies a configured keybinding. Furthermore,
+// currentView's internal buffer is modified if currentView.Editable is true.
+func (g *Gui) onKey(ev *termbox.Event) error {
+	switch ev.Type {
+	case termbox.EventKey:
+		matched, err := g.execKeybindings(g.currentView, ev)
+		if err != nil {
+			return err
+		}
+		if matched {
+			break
+		}
+		if g.currentView != nil && g.currentView.Editable && g.currentView.Editor != nil {
+			g.currentView.Editor.Edit(g.currentView, Key(ev.Key), ev.Ch, Modifier(ev.Mod))
+		}
+	case termbox.EventMouse:
+		mx, my := ev.MouseX, ev.MouseY
+		v, err := g.ViewByPosition(mx, my)
+		if err != nil {
+			break
+		}
+		if err := v.SetCursor(mx-v.x0-1, my-v.y0-1); err != nil {
+			return err
+		}
+		if _, err := g.execKeybindings(v, ev); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// execKeybindings executes the keybinding handlers that match the passed view
+// and event. The value of matched is true if there is a match and no errors.
+func (g *Gui) execKeybindings(v *View, ev *termbox.Event) (matched bool, err error) {
+	matched = false
+	for _, kb := range g.keybindings {
+		if kb.handler == nil {
+			continue
+		}
+		if kb.matchKeypress(Key(ev.Key), ev.Ch, Modifier(ev.Mod)) && kb.matchView(v) {
+			if err := kb.handler(g, v); err != nil {
+				return false, err
+			}
+			matched = true
+		}
+	}
+	return matched, nil
+}
diff --git a/vendor/github.com/MichaelMure/gocui/keybinding.go b/vendor/github.com/MichaelMure/gocui/keybinding.go
new file mode 100644
index 00000000..03fe677c
--- /dev/null
+++ b/vendor/github.com/MichaelMure/gocui/keybinding.go
@@ -0,0 +1,137 @@
+// Copyright 2014 The gocui Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gocui
+
+import "github.com/nsf/termbox-go"
+
+// Keybidings are used to link a given key-press event with a handler.
+type keybinding struct {
+	viewName string
+	key      Key
+	ch       rune
+	mod      Modifier
+	handler  func(*Gui, *View) error
+}
+
+// newKeybinding returns a new Keybinding object.
+func newKeybinding(viewname string, key Key, ch rune, mod Modifier, handler func(*Gui, *View) error) (kb *keybinding) {
+	kb = &keybinding{
+		viewName: viewname,
+		key:      key,
+		ch:       ch,
+		mod:      mod,
+		handler:  handler,
+	}
+	return kb
+}
+
+// matchKeypress returns if the keybinding matches the keypress.
+func (kb *keybinding) matchKeypress(key Key, ch rune, mod Modifier) bool {
+	return kb.key == key && kb.ch == ch && kb.mod == mod
+}
+
+// matchView returns if the keybinding matches the current view.
+func (kb *keybinding) matchView(v *View) bool {
+	if kb.viewName == "" {
+		return true
+	}
+	return v != nil && kb.viewName == v.name
+}
+
+// Key represents special keys or keys combinations.
+type Key termbox.Key
+
+// Special keys.
+const (
+	KeyF1         Key = Key(termbox.KeyF1)
+	KeyF2             = Key(termbox.KeyF2)
+	KeyF3             = Key(termbox.KeyF3)
+	KeyF4             = Key(termbox.KeyF4)
+	KeyF5             = Key(termbox.KeyF5)
+	KeyF6             = Key(termbox.KeyF6)
+	KeyF7             = Key(termbox.KeyF7)
+	KeyF8             = Key(termbox.KeyF8)
+	KeyF9             = Key(termbox.KeyF9)
+	KeyF10            = Key(termbox.KeyF10)
+	KeyF11            = Key(termbox.KeyF11)
+	KeyF12            = Key(termbox.KeyF12)
+	KeyInsert         = Key(termbox.KeyInsert)
+	KeyDelete         = Key(termbox.KeyDelete)
+	KeyHome           = Key(termbox.KeyHome)
+	KeyEnd            = Key(termbox.KeyEnd)
+	KeyPgup           = Key(termbox.KeyPgup)
+	KeyPgdn           = Key(termbox.KeyPgdn)
+	KeyArrowUp        = Key(termbox.KeyArrowUp)
+	KeyArrowDown      = Key(termbox.KeyArrowDown)
+	KeyArrowLeft      = Key(termbox.KeyArrowLeft)
+	KeyArrowRight     = Key(termbox.KeyArrowRight)
+
+	MouseLeft      = Key(termbox.MouseLeft)
+	MouseMiddle    = Key(termbox.MouseMiddle)
+	MouseRight     = Key(termbox.MouseRight)
+	MouseRelease   = Key(termbox.MouseRelease)
+	MouseWheelUp   = Key(termbox.MouseWheelUp)
+	MouseWheelDown = Key(termbox.MouseWheelDown)
+)
+
+// Keys combinations.
+const (
+	KeyCtrlTilde      Key = Key(termbox.KeyCtrlTilde)
+	KeyCtrl2              = Key(termbox.KeyCtrl2)
+	KeyCtrlSpace          = Key(termbox.KeyCtrlSpace)
+	KeyCtrlA              = Key(termbox.KeyCtrlA)
+	KeyCtrlB              = Key(termbox.KeyCtrlB)
+	KeyCtrlC              = Key(termbox.KeyCtrlC)
+	KeyCtrlD              = Key(termbox.KeyCtrlD)
+	KeyCtrlE              = Key(termbox.KeyCtrlE)
+	KeyCtrlF              = Key(termbox.KeyCtrlF)
+	KeyCtrlG              = Key(termbox.KeyCtrlG)
+	KeyBackspace          = Key(termbox.KeyBackspace)
+	KeyCtrlH              = Key(termbox.KeyCtrlH)
+	KeyTab                = Key(termbox.KeyTab)
+	KeyCtrlI              = Key(termbox.KeyCtrlI)
+	KeyCtrlJ              = Key(termbox.KeyCtrlJ)
+	KeyCtrlK              = Key(termbox.KeyCtrlK)
+	KeyCtrlL              = Key(termbox.KeyCtrlL)
+	KeyEnter              = Key(termbox.KeyEnter)
+	KeyCtrlM              = Key(termbox.KeyCtrlM)
+	KeyCtrlN              = Key(termbox.KeyCtrlN)
+	KeyCtrlO              = Key(termbox.KeyCtrlO)
+	KeyCtrlP              = Key(termbox.KeyCtrlP)
+	KeyCtrlQ              = Key(termbox.KeyCtrlQ)
+	KeyCtrlR              = Key(termbox.KeyCtrlR)
+	KeyCtrlS              = Key(termbox.KeyCtrlS)
+	KeyCtrlT              = Key(termbox.KeyCtrlT)
+	KeyCtrlU              = Key(termbox.KeyCtrlU)
+	KeyCtrlV              = Key(termbox.KeyCtrlV)
+	KeyCtrlW              = Key(termbox.KeyCtrlW)
+	KeyCtrlX              = Key(termbox.KeyCtrlX)
+	KeyCtrlY              = Key(termbox.KeyCtrlY)
+	KeyCtrlZ              = Key(termbox.KeyCtrlZ)
+	KeyEsc                = Key(termbox.KeyEsc)
+	KeyCtrlLsqBracket     = Key(termbox.KeyCtrlLsqBracket)
+	KeyCtrl3              = Key(termbox.KeyCtrl3)
+	KeyCtrl4              = Key(termbox.KeyCtrl4)
+	KeyCtrlBackslash      = Key(termbox.KeyCtrlBackslash)
+	KeyCtrl5              = Key(termbox.KeyCtrl5)
+	KeyCtrlRsqBracket     = Key(termbox.KeyCtrlRsqBracket)
+	KeyCtrl6              = Key(termbox.KeyCtrl6)
+	KeyCtrl7              = Key(termbox.KeyCtrl7)
+	KeyCtrlSlash          = Key(termbox.KeyCtrlSlash)
+	KeyCtrlUnderscore     = Key(termbox.KeyCtrlUnderscore)
+	KeySpace              = Key(termbox.KeySpace)
+	KeyBackspace2         = Key(termbox.KeyBackspace2)
+	KeyCtrl8              = Key(termbox.KeyCtrl8)
+)
+
+// Modifier allows to define special keys combinations. They can be used
+// in combination with Keys or Runes when a new keybinding is defined.
+type Modifier termbox.Modifier
+
+// Modifiers.
+const (
+	ModNone Modifier = Modifier(0)
+	ModAlt           = Modifier(termbox.ModAlt)
+)
diff --git a/vendor/github.com/MichaelMure/gocui/view.go b/vendor/github.com/MichaelMure/gocui/view.go
new file mode 100644
index 00000000..d7943497
--- /dev/null
+++ b/vendor/github.com/MichaelMure/gocui/view.go
@@ -0,0 +1,504 @@
+// Copyright 2014 The gocui Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gocui
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"strings"
+
+	"github.com/mattn/go-runewidth"
+	"github.com/nsf/termbox-go"
+)
+
+// A View is a window. It maintains its own internal buffer and cursor
+// position.
+type View struct {
+	name           string
+	x0, y0, x1, y1 int
+	ox, oy         int
+	cx, cy         int
+	lines          [][]cell
+	readOffset     int
+	readCache      string
+
+	tainted   bool       // marks if the viewBuffer must be updated
+	viewLines []viewLine // internal representation of the view's buffer
+
+	ei *escapeInterpreter // used to decode ESC sequences on Write
+
+	// BgColor and FgColor allow to configure the background and foreground
+	// colors of the View.
+	BgColor, FgColor Attribute
+
+	// SelBgColor and SelFgColor are used to configure the background and
+	// foreground colors of the selected line, when it is highlighted.
+	SelBgColor, SelFgColor Attribute
+
+	// If Editable is true, keystrokes will be added to the view's internal
+	// buffer at the cursor position.
+	Editable bool
+
+	// Editor allows to define the editor that manages the edition mode,
+	// including keybindings or cursor behaviour. DefaultEditor is used by
+	// default.
+	Editor Editor
+
+	// Overwrite enables or disables the overwrite mode of the view.
+	Overwrite bool
+
+	// If Highlight is true, Sel{Bg,Fg}Colors will be used
+	// for the line under the cursor position.
+	Highlight bool
+
+	// If Frame is true, a border will be drawn around the view.
+	Frame bool
+
+	// If Wrap is true, the content that is written to this View is
+	// automatically wrapped when it is longer than its width. If true the
+	// view's x-origin will be ignored.
+	Wrap bool
+
+	// If Autoscroll is true, the View will automatically scroll down when the
+	// text overflows. If true the view's y-origin will be ignored.
+	Autoscroll bool
+
+	// If Frame is true, Title allows to configure a title for the view.
+	Title string
+
+	// If Mask is true, the View will display the mask instead of the real
+	// content
+	Mask rune
+}
+
+type viewLine struct {
+	linesX, linesY int // coordinates relative to v.lines
+	line           []cell
+}
+
+type cell struct {
+	chr              rune
+	bgColor, fgColor Attribute
+}
+
+type lineType []cell
+
+// String returns a string from a given cell slice.
+func (l lineType) String() string {
+	str := ""
+	for _, c := range l {
+		str += string(c.chr)
+	}
+	return str
+}
+
+// newView returns a new View object.
+func newView(name string, x0, y0, x1, y1 int, mode OutputMode) *View {
+	v := &View{
+		name:    name,
+		x0:      x0,
+		y0:      y0,
+		x1:      x1,
+		y1:      y1,
+		Frame:   true,
+		Editor:  DefaultEditor,
+		tainted: true,
+		ei:      newEscapeInterpreter(mode),
+	}
+	return v
+}
+
+// Size returns the number of visible columns and rows in the View.
+func (v *View) Size() (x, y int) {
+	return v.x1 - v.x0 - 1, v.y1 - v.y0 - 1
+}
+
+// Name returns the name of the view.
+func (v *View) Name() string {
+	return v.name
+}
+
+// setRune sets a rune at the given point relative to the view. It applies the
+// specified colors, taking into account if the cell must be highlighted. Also,
+// it checks if the position is valid.
+func (v *View) setRune(x, y int, ch rune, fgColor, bgColor Attribute) error {
+	maxX, maxY := v.Size()
+	if x < 0 || x >= maxX || y < 0 || y >= maxY {
+		return errors.New("invalid point")
+	}
+
+	var (
+		ry, rcy int
+		err     error
+	)
+	if v.Highlight {
+		_, ry, err = v.realPosition(x, y)
+		if err != nil {
+			return err
+		}
+		_, rcy, err = v.realPosition(v.cx, v.cy)
+		if err != nil {
+			return err
+		}
+	}
+
+	if v.Mask != 0 {
+		fgColor = v.FgColor
+		bgColor = v.BgColor
+		ch = v.Mask
+	} else if v.Highlight && ry == rcy {
+		fgColor = v.SelFgColor
+		bgColor = v.SelBgColor
+	}
+
+	termbox.SetCell(v.x0+x+1, v.y0+y+1, ch,
+		termbox.Attribute(fgColor), termbox.Attribute(bgColor))
+
+	return nil
+}
+
+// SetCursor sets the cursor position of the view at the given point,
+// relative to the view. It checks if the position is valid.
+func (v *View) SetCursor(x, y int) error {
+	maxX, maxY := v.Size()
+	if x < 0 || x >= maxX || y < 0 || y >= maxY {
+		return errors.New("invalid point")
+	}
+	v.cx = x
+	v.cy = y
+	return nil
+}
+
+// Cursor returns the cursor position of the view.
+func (v *View) Cursor() (x, y int) {
+	return v.cx, v.cy
+}
+
+// SetOrigin sets the origin position of the view's internal buffer,
+// so the buffer starts to be printed from this point, which means that
+// it is linked with the origin point of view. It can be used to
+// implement Horizontal and Vertical scrolling with just incrementing
+// or decrementing ox and oy.
+func (v *View) SetOrigin(x, y int) error {
+	if x < 0 || y < 0 {
+		return errors.New("invalid point")
+	}
+	v.ox = x
+	v.oy = y
+	return nil
+}
+
+// Origin returns the origin position of the view.
+func (v *View) Origin() (x, y int) {
+	return v.ox, v.oy
+}
+
+// Write appends a byte slice into the view's internal buffer. Because
+// View implements the io.Writer interface, it can be passed as parameter
+// of functions like fmt.Fprintf, fmt.Fprintln, io.Copy, etc. Clear must
+// be called to clear the view's buffer.
+func (v *View) Write(p []byte) (n int, err error) {
+	v.tainted = true
+
+	for _, ch := range bytes.Runes(p) {
+		switch ch {
+		case '\n':
+			v.lines = append(v.lines, nil)
+		case '\r':
+			nl := len(v.lines)
+			if nl > 0 {
+				v.lines[nl-1] = nil
+			} else {
+				v.lines = make([][]cell, 1)
+			}
+		default:
+			cells := v.parseInput(ch)
+			if cells == nil {
+				continue
+			}
+
+			nl := len(v.lines)
+			if nl > 0 {
+				v.lines[nl-1] = append(v.lines[nl-1], cells...)
+			} else {
+				v.lines = append(v.lines, cells)
+			}
+		}
+	}
+	return len(p), nil
+}
+
+// parseInput parses char by char the input written to the View. It returns nil
+// while processing ESC sequences. Otherwise, it returns a cell slice that
+// contains the processed data.
+func (v *View) parseInput(ch rune) []cell {
+	cells := []cell{}
+
+	isEscape, err := v.ei.parseOne(ch)
+	if err != nil {
+		for _, r := range v.ei.runes() {
+			c := cell{
+				fgColor: v.FgColor,
+				bgColor: v.BgColor,
+				chr:     r,
+			}
+			cells = append(cells, c)
+		}
+		v.ei.reset()
+	} else {
+		if isEscape {
+			return nil
+		}
+		c := cell{
+			fgColor: v.ei.curFgColor,
+			bgColor: v.ei.curBgColor,
+			chr:     ch,
+		}
+		cells = append(cells, c)
+	}
+
+	return cells
+}
+
+// Read reads data into p. It returns the number of bytes read into p.
+// At EOF, err will be io.EOF. Calling Read() after Rewind() makes the
+// cache to be refreshed with the contents of the view.
+func (v *View) Read(p []byte) (n int, err error) {
+	if v.readOffset == 0 {
+		v.readCache = v.Buffer()
+	}
+	if v.readOffset < len(v.readCache) {
+		n = copy(p, v.readCache[v.readOffset:])
+		v.readOffset += n
+	} else {
+		err = io.EOF
+	}
+	return
+}
+
+// Rewind sets the offset for the next Read to 0, which also refresh the
+// read cache.
+func (v *View) Rewind() {
+	v.readOffset = 0
+}
+
+// draw re-draws the view's contents.
+func (v *View) draw() error {
+	maxX, maxY := v.Size()
+
+	if v.Wrap {
+		if maxX == 0 {
+			return errors.New("X size of the view cannot be 0")
+		}
+		v.ox = 0
+	}
+	if v.tainted {
+		v.viewLines = nil
+		for i, line := range v.lines {
+			if v.Wrap {
+				if len(line) < maxX {
+					vline := viewLine{linesX: 0, linesY: i, line: line}
+					v.viewLines = append(v.viewLines, vline)
+					continue
+				} else {
+					for n := 0; n <= len(line); n += maxX {
+						if len(line[n:]) <= maxX {
+							vline := viewLine{linesX: n, linesY: i, line: line[n:]}
+							v.viewLines = append(v.viewLines, vline)
+						} else {
+							vline := viewLine{linesX: n, linesY: i, line: line[n : n+maxX]}
+							v.viewLines = append(v.viewLines, vline)
+						}
+					}
+				}
+			} else {
+				vline := viewLine{linesX: 0, linesY: i, line: line}
+				v.viewLines = append(v.viewLines, vline)
+			}
+		}
+		v.tainted = false
+	}
+
+	if v.Autoscroll && len(v.viewLines) > maxY {
+		v.oy = len(v.viewLines) - maxY
+	}
+	y := 0
+	for i, vline := range v.viewLines {
+		if i < v.oy {
+			continue
+		}
+		if y >= maxY {
+			break
+		}
+		x := 0
+		for j, c := range vline.line {
+			if j < v.ox {
+				continue
+			}
+			if x >= maxX {
+				break
+			}
+
+			fgColor := c.fgColor
+			if fgColor == ColorDefault {
+				fgColor = v.FgColor
+			}
+			bgColor := c.bgColor
+			if bgColor == ColorDefault {
+				bgColor = v.BgColor
+			}
+
+			if err := v.setRune(x, y, c.chr, fgColor, bgColor); err != nil {
+				return err
+			}
+			x += runewidth.RuneWidth(c.chr)
+		}
+		y++
+	}
+	return nil
+}
+
+// realPosition returns the position in the internal buffer corresponding to the
+// point (x, y) of the view.
+func (v *View) realPosition(vx, vy int) (x, y int, err error) {
+	vx = v.ox + vx
+	vy = v.oy + vy
+
+	if vx < 0 || vy < 0 {
+		return 0, 0, errors.New("invalid point")
+	}
+
+	if len(v.viewLines) == 0 {
+		return vx, vy, nil
+	}
+
+	if vy < len(v.viewLines) {
+		vline := v.viewLines[vy]
+		x = vline.linesX + vx
+		y = vline.linesY
+	} else {
+		vline := v.viewLines[len(v.viewLines)-1]
+		x = vx
+		y = vline.linesY + vy - len(v.viewLines) + 1
+	}
+
+	return x, y, nil
+}
+
+// Clear empties the view's internal buffer.
+func (v *View) Clear() {
+	v.tainted = true
+
+	v.lines = nil
+	v.viewLines = nil
+	v.readOffset = 0
+	v.clearRunes()
+}
+
+// clearRunes erases all the cells in the view.
+func (v *View) clearRunes() {
+	maxX, maxY := v.Size()
+	for x := 0; x < maxX; x++ {
+		for y := 0; y < maxY; y++ {
+			termbox.SetCell(v.x0+x+1, v.y0+y+1, ' ',
+				termbox.Attribute(v.FgColor), termbox.Attribute(v.BgColor))
+		}
+	}
+}
+
+// BufferLines returns the lines in the view's internal
+// buffer.
+func (v *View) BufferLines() []string {
+	lines := make([]string, len(v.lines))
+	for i, l := range v.lines {
+		str := lineType(l).String()
+		str = strings.Replace(str, "\x00", " ", -1)
+		lines[i] = str
+	}
+	return lines
+}
+
+// Buffer returns a string with the contents of the view's internal
+// buffer.
+func (v *View) Buffer() string {
+	str := ""
+	for _, l := range v.lines {
+		str += lineType(l).String() + "\n"
+	}
+	return strings.Replace(str, "\x00", " ", -1)
+}
+
+// ViewBufferLines returns the lines in the view's internal
+// buffer that is shown to the user.
+func (v *View) ViewBufferLines() []string {
+	lines := make([]string, len(v.viewLines))
+	for i, l := range v.viewLines {
+		str := lineType(l.line).String()
+		str = strings.Replace(str, "\x00", " ", -1)
+		lines[i] = str
+	}
+	return lines
+}
+
+// ViewBuffer returns a string with the contents of the view's buffer that is
+// shown to the user.
+func (v *View) ViewBuffer() string {
+	str := ""
+	for _, l := range v.viewLines {
+		str += lineType(l.line).String() + "\n"
+	}
+	return strings.Replace(str, "\x00", " ", -1)
+}
+
+// Line returns a string with the line of the view's internal buffer
+// at the position corresponding to the point (x, y).
+func (v *View) Line(y int) (string, error) {
+	_, y, err := v.realPosition(0, y)
+	if err != nil {
+		return "", err
+	}
+
+	if y < 0 || y >= len(v.lines) {
+		return "", errors.New("invalid point")
+	}
+
+	return lineType(v.lines[y]).String(), nil
+}
+
+// Word returns a string with the word of the view's internal buffer
+// at the position corresponding to the point (x, y).
+func (v *View) Word(x, y int) (string, error) {
+	x, y, err := v.realPosition(x, y)
+	if err != nil {
+		return "", err
+	}
+
+	if x < 0 || y < 0 || y >= len(v.lines) || x >= len(v.lines[y]) {
+		return "", errors.New("invalid point")
+	}
+
+	str := lineType(v.lines[y]).String()
+
+	nl := strings.LastIndexFunc(str[:x], indexFunc)
+	if nl == -1 {
+		nl = 0
+	} else {
+		nl = nl + 1
+	}
+	nr := strings.IndexFunc(str[x:], indexFunc)
+	if nr == -1 {
+		nr = len(str)
+	} else {
+		nr = nr + x
+	}
+	return string(str[nl:nr]), nil
+}
+
+// indexFunc allows to split lines by words taking into account spaces
+// and 0.
+func indexFunc(r rune) bool {
+	return r == ' ' || r == 0
+}