termui: use a forked gocui to fix large character handling

11 files changed, 0 insertions, 2163 deletions

diff --git a/vendor/github.com/jroimartin/gocui/.gitignore b/vendor/github.com/jroimartin/gocui/.gitignore
deleted file mode 100644
index 1377554e..00000000
--- a/vendor/github.com/jroimartin/gocui/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-*.swp
diff --git a/vendor/github.com/jroimartin/gocui/AUTHORS b/vendor/github.com/jroimartin/gocui/AUTHORS
deleted file mode 100644
index 43ec4cec..00000000
--- a/vendor/github.com/jroimartin/gocui/AUTHORS
+++ /dev/null
@@ -1,30 +0,0 @@
-# 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/jroimartin/gocui/LICENSE b/vendor/github.com/jroimartin/gocui/LICENSE
deleted file mode 100644
index 8cb28215..00000000
--- a/vendor/github.com/jroimartin/gocui/LICENSE
+++ /dev/null
@@ -1,23 +0,0 @@
-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/jroimartin/gocui/README.md b/vendor/github.com/jroimartin/gocui/README.md
deleted file mode 100644
index d7b55a3b..00000000
--- a/vendor/github.com/jroimartin/gocui/README.md
+++ /dev/null
@@ -1,110 +0,0 @@
-# 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/jroimartin/gocui/attribute.go b/vendor/github.com/jroimartin/gocui/attribute.go
deleted file mode 100644
index bad758a1..00000000
--- a/vendor/github.com/jroimartin/gocui/attribute.go
+++ /dev/null
@@ -1,32 +0,0 @@
-// 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/jroimartin/gocui/doc.go b/vendor/github.com/jroimartin/gocui/doc.go
deleted file mode 100644
index fe128afb..00000000
--- a/vendor/github.com/jroimartin/gocui/doc.go
+++ /dev/null
@@ -1,118 +0,0 @@
-// 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/jroimartin/gocui/edit.go b/vendor/github.com/jroimartin/gocui/edit.go
deleted file mode 100644
index e1b19c20..00000000
--- a/vendor/github.com/jroimartin/gocui/edit.go
+++ /dev/null
@@ -1,344 +0,0 @@
-// 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"
-
-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(1, 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
-				v.deleteRune(len(v.viewLines[y-1].line)-1, v.cy-1)
-				v.MoveCursor(-1, 0, true)
-			}
-		} else { // middle/end of the line
-			v.deleteRune(v.cx-1, v.cy)
-			v.MoveCursor(-1, 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) error {
-	v.tainted = true
-
-	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")
-	}
-	v.lines[y] = append(v.lines[y][:x], v.lines[y][x+1:]...)
-	return 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/jroimartin/gocui/escape.go b/vendor/github.com/jroimartin/gocui/escape.go
deleted file mode 100644
index ec31bbe0..00000000
--- a/vendor/github.com/jroimartin/gocui/escape.go
+++ /dev/null
@@ -1,229 +0,0 @@
-// 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/jroimartin/gocui/gui.go b/vendor/github.com/jroimartin/gocui/gui.go
deleted file mode 100644
index 9499d3c3..00000000
--- a/vendor/github.com/jroimartin/gocui/gui.go
+++ /dev/null
@@ -1,636 +0,0 @@
-// 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/jroimartin/gocui/keybinding.go b/vendor/github.com/jroimartin/gocui/keybinding.go
deleted file mode 100644
index 03fe677c..00000000
--- a/vendor/github.com/jroimartin/gocui/keybinding.go
+++ /dev/null
@@ -1,137 +0,0 @@
-// 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/jroimartin/gocui/view.go b/vendor/github.com/jroimartin/gocui/view.go
deleted file mode 100644
index 42082f8c..00000000
--- a/vendor/github.com/jroimartin/gocui/view.go
+++ /dev/null
@@ -1,503 +0,0 @@
-// 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/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++
-		}
-		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
-}