Revert "Update dependencies"

vendor/github.com/rivo/tview/README.md

@@ -65,8 +65,6 @@ Add your issue here on GitHub. Feel free to get in touch if you have any questio
 
 (There are no corresponding tags in the project. I only keep such a history in this README.)
 
-- v0.19 (2018-10-28)
-  - Added `QueueUpdate()` and `QueueEvent()` to `Application` to help with modifications to primitives from goroutines.
 - v0.18 (2018-10-18)
   - `InputField` elements can now be navigated freely.
 - v0.17 (2018-06-20)

vendor/github.com/rivo/tview/application.go

@@ -1,34 +1,25 @@
 package tview
 
 import (
+	"fmt"
+	"os"
 	"sync"
 
 	"github.com/gdamore/tcell"
 )
 
-// The size of the event/update/redraw channels.
-const queueSize = 100
-
 // Application represents the top node of an application.
 //
 // It is not strictly required to use this class as none of the other classes
 // depend on it. However, it provides useful tools to set up an application and
 // plays nicely with all widgets.
-//
-// The following command displays a primitive p on the screen until Ctrl-C is
-// pressed:
-//
-//   if err := tview.NewApplication().SetRoot(p, true).Run(); err != nil {
-//       panic(err)
-//   }
 type Application struct {
 	sync.RWMutex
 
 	// The application's screen.
 	screen tcell.Screen
 
-	// Indicates whether the application's screen is currently active. This is
-	// false during suspended mode.
+	// Indicates whether the application's screen is currently active.
 	running bool
 
 	// The primitive which currently has the keyboard focus.
@@ -53,23 +44,13 @@ type Application struct {
 	// was drawn.
 	afterDraw func(screen tcell.Screen)
 
-	// Used to send screen events from separate goroutine to main event loop
-	events chan tcell.Event
-
-	// Functions queued from goroutines, used to serialize updates to primitives.
-	updates chan func()
-
-	// A channel which signals the end of the suspended mode.
-	suspendToken chan struct{}
+	// Halts the event loop during suspended mode.
+	suspendMutex sync.Mutex
 }
 
 // NewApplication creates and returns a new application.
 func NewApplication() *Application {
-	return &Application{
-		events:       make(chan tcell.Event, queueSize),
-		updates:      make(chan func(), queueSize),
-		suspendToken: make(chan struct{}, 1),
-	}
+	return &Application{}
 }
 
 // SetInputCapture sets a function which captures all key events before they are
@@ -153,105 +134,65 @@ func (a *Application) Run() error {
 
 	// Draw the screen for the first time.
 	a.Unlock()
-	a.draw()
-
-	// Separate loop to wait for screen events.
-	var wg sync.WaitGroup
-	wg.Add(1)
-	a.suspendToken <- struct{}{} // We need this to get started.
-	go func() {
-		defer wg.Done()
-		for range a.suspendToken {
-			for {
-				a.RLock()
-				screen := a.screen
-				a.RUnlock()
-				if screen == nil {
-					// We have no screen. We might need to stop.
-					break
-				}
-
-				// Wait for next event and queue it.
-				event := screen.PollEvent()
-				if event != nil {
-					// Regular event. Queue.
-					a.QueueEvent(event)
-					continue
-				}
-
-				// A screen was finalized (event is nil).
-				a.RLock()
-				running := a.running
-				a.RUnlock()
-				if running {
-					// The application was stopped. End the event loop.
-					a.QueueEvent(nil)
-					return
-				}
-
-				// We're in suspended mode (running is false). Pause and wait for new
-				// token.
-				break
-			}
-		}
-	}()
+	a.Draw()
 
 	// Start event loop.
-EventLoop:
 	for {
-		select {
-		case event := <-a.events:
-			if event == nil {
-				break EventLoop
+		// Do not poll events during suspend mode
+		a.suspendMutex.Lock()
+		a.RLock()
+		screen := a.screen
+		a.RUnlock()
+		if screen == nil {
+			a.suspendMutex.Unlock()
+			break
+		}
+
+		// Wait for next event.
+		event := a.screen.PollEvent()
+		a.suspendMutex.Unlock()
+		if event == nil {
+			// The screen was finalized. Exit the loop.
+			break
+		}
+
+		switch event := event.(type) {
+		case *tcell.EventKey:
+			a.RLock()
+			p := a.focus
+			a.RUnlock()
+
+			// Intercept keys.
+			if a.inputCapture != nil {
+				event = a.inputCapture(event)
+				if event == nil {
+					break // Don't forward event.
+				}
 			}
 
-			switch event := event.(type) {
-			case *tcell.EventKey:
-				a.RLock()
-				p := a.focus
-				inputCapture := a.inputCapture
-				a.RUnlock()
-
-				// Intercept keys.
-				if inputCapture != nil {
-					event = inputCapture(event)
-					if event == nil {
-						continue // Don't forward event.
-					}
-				}
-
-				// Ctrl-C closes the application.
-				if event.Key() == tcell.KeyCtrlC {
-					a.Stop()
-				}
-
-				// Pass other key events to the currently focused primitive.
-				if p != nil {
-					if handler := p.InputHandler(); handler != nil {
-						handler(event, func(p Primitive) {
-							a.SetFocus(p)
-						})
-						a.draw()
-					}
-				}
-			case *tcell.EventResize:
-				a.RLock()
-				screen := a.screen
-				a.RUnlock()
-				screen.Clear()
-				a.draw()
+			// Ctrl-C closes the application.
+			if event.Key() == tcell.KeyCtrlC {
+				a.Stop()
 			}
 
-		// If we have updates, now is the time to execute them.
-		case updater := <-a.updates:
-			updater()
+			// Pass other key events to the currently focused primitive.
+			if p != nil {
+				if handler := p.InputHandler(); handler != nil {
+					handler(event, func(p Primitive) {
+						a.SetFocus(p)
+					})
+					a.Draw()
+				}
+			}
+		case *tcell.EventResize:
+			a.RLock()
+			screen := a.screen
+			a.RUnlock()
+			screen.Clear()
+			a.Draw()
 		}
 	}
 
-	a.running = false
-	close(a.suspendToken)
-	wg.Wait()
-
 	return nil
 }
 
@@ -259,13 +200,12 @@ EventLoop:
 func (a *Application) Stop() {
 	a.Lock()
 	defer a.Unlock()
-	screen := a.screen
-	if screen == nil {
+	if a.screen == nil {
 		return
 	}
+	a.screen.Fini()
 	a.screen = nil
-	screen.Fini()
-	// a.running is still true, the main loop will clean up.
+	a.running = false
 }
 
 // Suspend temporarily suspends the application by exiting terminal UI mode and
@@ -276,26 +216,32 @@ func (a *Application) Stop() {
 // was called. If false is returned, the application was already suspended,
 // terminal UI mode was not exited, and "f" was not called.
 func (a *Application) Suspend(f func()) bool {
-	a.Lock()
+	a.RLock()
 
-	screen := a.screen
-	if screen == nil {
+	if a.screen == nil {
 		// Screen has not yet been initialized.
-		a.Unlock()
+		a.RUnlock()
 		return false
 	}
 
-	// Enter suspended mode. Make a new screen here already so our event loop can
-	// continue.
-	a.screen = nil
-	a.running = false
-	screen.Fini()
-	a.Unlock()
+	// Enter suspended mode.
+	a.suspendMutex.Lock()
+	defer a.suspendMutex.Unlock()
+	a.RUnlock()
+	a.Stop()
+
+	// Deal with panics during suspended mode. Exit the program.
+	defer func() {
+		if p := recover(); p != nil {
+			fmt.Println(p)
+			os.Exit(1)
+		}
+	}()
 
 	// Wait for "f" to return.
 	f()
 
-	// Initialize our new screen and draw the contents.
+	// Make a new screen and redraw.
 	a.Lock()
 	var err error
 	a.screen, err = tcell.NewScreen()
@@ -309,26 +255,15 @@ func (a *Application) Suspend(f func()) bool {
 	}
 	a.running = true
 	a.Unlock()
-	a.draw()
-	a.suspendToken <- struct{}{}
-	// One key event will get lost, see https://github.com/gdamore/tcell/issues/194
+	a.Draw()
 
 	// Continue application loop.
 	return true
 }
 
-// Draw refreshes the screen (during the next update cycle). It calls the Draw()
-// function of the application's root primitive and then syncs the screen
-// buffer.
+// Draw refreshes the screen. It calls the Draw() function of the application's
+// root primitive and then syncs the screen buffer.
 func (a *Application) Draw() *Application {
-	a.QueueUpdate(func() {
-		a.draw()
-	})
-	return a
-}
-
-// draw actually does what Draw() promises to do.
-func (a *Application) draw() *Application {
 	a.Lock()
 	defer a.Unlock()
 
@@ -469,35 +404,3 @@ func (a *Application) GetFocus() Primitive {
 	defer a.RUnlock()
 	return a.focus
 }
-
-// QueueUpdate is used to synchronize access to primitives from non-main
-// goroutines. The provided function will be executed as part of the event loop
-// and thus will not cause race conditions with other such update functions or
-// the Draw() function.
-//
-// Note that Draw() is not implicitly called after the execution of f as that
-// may not be desirable. You can call Draw() from f if the screen should be
-// refreshed after each update. Alternatively, use QueueUpdateDraw() to follow
-// up with an immediate refresh of the screen.
-func (a *Application) QueueUpdate(f func()) *Application {
-	a.updates <- f
-	return a
-}
-
-// QueueUpdateDraw works like QueueUpdate() except it refreshes the screen
-// immediately after executing f.
-func (a *Application) QueueUpdateDraw(f func()) *Application {
-	a.QueueUpdate(func() {
-		f()
-		a.draw()
-	})
-	return a
-}
-
-// QueueEvent sends an event to the Application event loop.
-//
-// It is not recommended for event to be nil.
-func (a *Application) QueueEvent(event tcell.Event) *Application {
-	a.events <- event
-	return a
-}

vendor/github.com/rivo/tview/doc.go

@@ -137,27 +137,6 @@ Unicode Support
 
 This package supports unicode characters including wide characters.
 
-Concurrency
-
-Many functions in this package are not thread-safe. For many applications, this
-may not be an issue: If your code makes changes in response to key events, it
-will execute in the main goroutine and thus will not cause any race conditions.
-
-If you access your primitives from other goroutines, however, you will need to
-synchronize execution. The easiest way to do this is to call
-Application.QueueUpdate() or Application.QueueUpdateDraw() (see the function
-documentation for details):
-
-  go func() {
-    app.QueueUpdateDraw(func() {
-      table.SetCellSimple(0, 0, "Foo bar")
-    })
-  }()
-
-One exception to this is the io.Writer interface implemented by TextView. You
-can safely write to a TextView from any goroutine. See the TextView
-documentation for details.
-
 Type Hierarchy
 
 All widgets listed above contain the Box type. All of Box's functions are

vendor/github.com/rivo/tview/inputfield.go

@@ -102,7 +102,6 @@ func NewInputField() *InputField {
 // SetText sets the current text of the input field.
 func (i *InputField) SetText(text string) *InputField {
 	i.text = text
-	i.cursorPos = len(text)
 	if i.changed != nil {
 		i.changed(text)
 	}
@@ -360,22 +359,21 @@ func (i *InputField) InputHandler() func(event *tcell.EventKey, setFocus func(p
 			i.cursorPos = len(i.text) - len(regexp.MustCompile(`^\s*\S+\s*`).ReplaceAllString(i.text[i.cursorPos:], ""))
 		}
 
-		// Add character function. Returns whether or not the rune character is
-		// accepted.
-		add := func(r rune) bool {
-			newText := i.text[:i.cursorPos] + string(r) + i.text[i.cursorPos:]
-			if i.accept != nil {
-				return i.accept(newText, r)
-			}
-			i.text = newText
-			i.cursorPos += len(string(r))
-			return true
-		}
-
 		// Process key event.
 		switch key := event.Key(); key {
 		case tcell.KeyRune: // Regular character.
-			if event.Modifiers()&tcell.ModAlt > 0 {
+			modifiers := event.Modifiers()
+			if modifiers == tcell.ModNone {
+				ch := string(event.Rune())
+				newText := i.text[:i.cursorPos] + ch + i.text[i.cursorPos:]
+				if i.accept != nil {
+					if !i.accept(newText, event.Rune()) {
+						break
+					}
+				}
+				i.text = newText
+				i.cursorPos += len(ch)
+			} else if modifiers&tcell.ModAlt > 0 {
 				// We accept some Alt- key combinations.
 				switch event.Rune() {
 				case 'a': // Home.
@@ -387,11 +385,6 @@ func (i *InputField) InputHandler() func(event *tcell.EventKey, setFocus func(p
 				case 'f': // Move word right.
 					moveWordRight()
 				}
-			} else {
-				// Other keys are simply accepted as regular characters.
-				if !add(event.Rune()) {
-					break
-				}
 			}
 		case tcell.KeyCtrlU: // Delete all.
 			i.text = ""

vendor/github.com/rivo/tview/table.go

@@ -389,7 +389,7 @@ func (t *Table) SetDoneFunc(handler func(key tcell.Key)) *Table {
 }
 
 // SetCell sets the content of a cell the specified position. It is ok to
-// directly instantiate a TableCell object. If the cell has content, at least
+// directly instantiate a TableCell object. If the cell has contain, at least
 // the Text and Color fields should be set.
 //
 // Note that setting cells in previously unknown rows and columns will
@@ -422,7 +422,7 @@ func (t *Table) SetCellSimple(row, column int, text string) *Table {
 }
 
 // GetCell returns the contents of the cell at the specified position. A valid
-// TableCell object is always returned but it will be uninitialized if the cell
+// TableCell object is always returns but it will be uninitialized if the cell
 // was not previously set.
 func (t *Table) GetCell(row, column int) *TableCell {
 	if row >= len(t.cells) || column >= len(t.cells[row]) {
@@ -431,31 +431,6 @@ func (t *Table) GetCell(row, column int) *TableCell {
 	return t.cells[row][column]
 }
 
-// RemoveRow removes the row at the given position from the table. If there is
-// no such row, this has no effect.
-func (t *Table) RemoveRow(row int) *Table {
-	if row < 0 || row >= len(t.cells) {
-		return t
-	}
-
-	t.cells = append(t.cells[:row], t.cells[row+1:]...)
-
-	return t
-}
-
-// RemoveColumn removes the column at the given position from the table. If
-// there is no such column, this has no effect.
-func (t *Table) RemoveColumn(column int) *Table {
-	for row := range t.cells {
-		if column < 0 || column >= len(t.cells[row]) {
-			continue
-		}
-		t.cells[row] = append(t.cells[row][:column], t.cells[row][column+1:]...)
-	}
-
-	return t
-}
-
 // GetRowCount returns the number of rows in the table.
 func (t *Table) GetRowCount() int {
 	return len(t.cells)

vendor/github.com/rivo/tview/textview.go

@@ -31,7 +31,7 @@ type textViewIndex struct {
 // TextView is a box which displays text. It implements the io.Writer interface
 // so you can stream text to it. This does not trigger a redraw automatically
 // but if a handler is installed via SetChangedFunc(), you can cause it to be
-// redrawn. (See SetChangedFunc() for more details.)
+// redrawn.
 //
 // Navigation
 //
@@ -260,20 +260,8 @@ func (t *TextView) SetRegions(regions bool) *TextView {
 }
 
 // SetChangedFunc sets a handler function which is called when the text of the
-// text view has changed. This is useful when text is written to this io.Writer
-// in a separate goroutine. This does not automatically cause the screen to be
-// refreshed so you may want to use the "changed" handler to redraw the screen.
-//
-// Note that to avoid race conditions or deadlocks, there are a few rules you
-// should follow:
-//
-//   - You can call Application.Draw() from this handler.
-//   - You can call TextView.HasFocus() from this handler.
-//   - During the execution of this handler, access to any other variables from
-//     this primitive or any other primitive should be queued using
-//     Application.QueueUpdate().
-//
-// See package description for details on dealing with concurrency.
+// text view has changed. This is typically used to cause the application to
+// redraw the screen.
 func (t *TextView) SetChangedFunc(handler func()) *TextView {
 	t.changed = handler
 	return t
@@ -453,33 +441,13 @@ func (t *TextView) GetRegionText(regionID string) string {
 	return escapePattern.ReplaceAllString(buffer.String(), `[$1$2]`)
 }
 
-// Focus is called when this primitive receives focus.
-func (t *TextView) Focus(delegate func(p Primitive)) {
-	// Implemented here with locking because this is used by layout primitives.
-	t.Lock()
-	defer t.Unlock()
-	t.hasFocus = true
-}
-
-// HasFocus returns whether or not this primitive has focus.
-func (t *TextView) HasFocus() bool {
-	// Implemented here with locking because this may be used in the "changed"
-	// callback.
-	t.Lock()
-	defer t.Unlock()
-	return t.hasFocus
-}
-
 // Write lets us implement the io.Writer interface. Tab characters will be
 // replaced with TabSize space characters. A "\n" or "\r\n" will be interpreted
 // as a new line.
 func (t *TextView) Write(p []byte) (n int, err error) {
 	// Notify at the end.
-	t.Lock()
-	changed := t.changed
-	t.Unlock()
-	if changed != nil {
-		defer changed() // Deadlocks may occur if we lock here.
+	if t.changed != nil {
+		defer t.changed()
 	}
 
 	t.Lock()
@@ -872,21 +840,18 @@ func (t *TextView) Draw(screen tcell.Screen) {
 		// Print the line.
 		var colorPos, regionPos, escapePos, tagOffset, skipped int
 		iterateString(strippedText, func(main rune, comb []rune, textPos, textWidth, screenPos, screenWidth int) bool {
-			// Process tags.
-			for {
-				if colorPos < len(colorTags) && textPos+tagOffset >= colorTagIndices[colorPos][0] && textPos+tagOffset < colorTagIndices[colorPos][1] {
-					// Get the color.
-					foregroundColor, backgroundColor, attributes = styleFromTag(foregroundColor, backgroundColor, attributes, colorTags[colorPos])
-					tagOffset += colorTagIndices[colorPos][1] - colorTagIndices[colorPos][0]
-					colorPos++
-				} else if regionPos < len(regionIndices) && textPos+tagOffset >= regionIndices[regionPos][0] && textPos+tagOffset < regionIndices[regionPos][1] {
-					// Get the region.
-					regionID = regions[regionPos][1]
-					tagOffset += regionIndices[regionPos][1] - regionIndices[regionPos][0]
-					regionPos++
-				} else {
-					break
-				}
+			// Get the color.
+			if colorPos < len(colorTags) && textPos+tagOffset >= colorTagIndices[colorPos][0] && textPos+tagOffset < colorTagIndices[colorPos][1] {
+				foregroundColor, backgroundColor, attributes = styleFromTag(foregroundColor, backgroundColor, attributes, colorTags[colorPos])
+				tagOffset += colorTagIndices[colorPos][1] - colorTagIndices[colorPos][0]
+				colorPos++
+			}
+
+			// Get the region.
+			if regionPos < len(regionIndices) && textPos+tagOffset >= regionIndices[regionPos][0] && textPos+tagOffset < regionIndices[regionPos][1] {
+				regionID = regions[regionPos][1]
+				tagOffset += regionIndices[regionPos][1] - regionIndices[regionPos][0]
+				regionPos++
 			}
 
 			// Skip the second-to-last character of an escape tag.
@@ -929,7 +894,7 @@ func (t *TextView) Draw(screen tcell.Screen) {
 			}
 
 			// Stop at the right border.
-			if posX+screenWidth > width {
+			if posX+screenWidth >= width {
 				return true
 			}
 

vendor/github.com/rivo/tview/treeview.go

@@ -569,7 +569,7 @@ func (t *TreeView) Draw(screen tcell.Screen) {
 
 	// Draw the tree.
 	posY := y
-	lineStyle := tcell.StyleDefault.Background(t.backgroundColor).Foreground(t.graphicsColor)
+	lineStyle := tcell.StyleDefault.Foreground(t.graphicsColor)
 	for index, node := range t.nodes {
 		// Skip invisible parts.
 		if posY >= y+height+1 {