gomuks/ui/widget/advanced-inputfield.go
2018-03-23 01:20:26 +02:00

516 lines
15 KiB
Go

// gomuks - A terminal Matrix client written in Go.
// Copyright (C) 2018 Tulir Asokan
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Based on https://github.com/rivo/tview/blob/master/inputfield.go
package widget
import (
"math"
"regexp"
"strings"
"unicode/utf8"
"github.com/gdamore/tcell"
"github.com/mattn/go-runewidth"
"github.com/zyedidia/clipboard"
"maunium.net/go/tview"
)
// AdvancedInputField is a multi-line user-editable text area.
//
// Use SetMaskCharacter() to hide input from onlookers (e.g. for password
// input).
type AdvancedInputField struct {
*tview.Box
// Cursor position
cursorOffset int
viewOffset int
// The text that was entered.
text string
// The text to be displayed before the input area.
label string
// The text to be displayed in the input area when "text" is empty.
placeholder string
// The label color.
labelColor tcell.Color
// The background color of the input area.
fieldBackgroundColor tcell.Color
// The text color of the input area.
fieldTextColor tcell.Color
// The text color of the placeholder.
placeholderTextColor tcell.Color
// The screen width of the input area. A value of 0 means extend as much as
// possible.
fieldWidth int
// A character to mask entered text (useful for password fields). A value of 0
// disables masking.
maskCharacter rune
// Whether or not to enable vim-style keybindings.
vimBindings bool
// An optional function which may reject the last character that was entered.
accept func(text string, ch rune) bool
// An optional function which is called when the input has changed.
changed func(text string)
// An optional function which is called when the user indicated that they
// are done entering text. The key which was pressed is provided (enter, tab, backtab or escape).
done func(tcell.Key)
// An optional function which is called when the user presses tab.
tabComplete func(text string, cursorOffset int) string
}
// NewAdvancedInputField returns a new input field.
func NewAdvancedInputField() *AdvancedInputField {
return &AdvancedInputField{
Box: tview.NewBox(),
labelColor: tview.Styles.SecondaryTextColor,
fieldBackgroundColor: tview.Styles.ContrastBackgroundColor,
fieldTextColor: tview.Styles.PrimaryTextColor,
placeholderTextColor: tview.Styles.ContrastSecondaryTextColor,
}
}
// SetText sets the current text of the input field.
func (field *AdvancedInputField) SetText(text string) *AdvancedInputField {
field.text = text
if field.changed != nil {
field.changed(text)
}
return field
}
// GetText returns the current text of the input field.
func (field *AdvancedInputField) GetText() string {
return field.text
}
// SetLabel sets the text to be displayed before the input area.
func (field *AdvancedInputField) SetLabel(label string) *AdvancedInputField {
field.label = label
return field
}
// GetLabel returns the text to be displayed before the input area.
func (field *AdvancedInputField) GetLabel() string {
return field.label
}
// SetPlaceholder sets the text to be displayed when the input text is empty.
func (field *AdvancedInputField) SetPlaceholder(text string) *AdvancedInputField {
field.placeholder = text
return field
}
// SetLabelColor sets the color of the label.
func (field *AdvancedInputField) SetLabelColor(color tcell.Color) *AdvancedInputField {
field.labelColor = color
return field
}
// SetFieldBackgroundColor sets the background color of the input area.
func (field *AdvancedInputField) SetFieldBackgroundColor(color tcell.Color) *AdvancedInputField {
field.fieldBackgroundColor = color
return field
}
// SetFieldTextColor sets the text color of the input area.
func (field *AdvancedInputField) SetFieldTextColor(color tcell.Color) *AdvancedInputField {
field.fieldTextColor = color
return field
}
// SetPlaceholderExtColor sets the text color of placeholder text.
func (field *AdvancedInputField) SetPlaceholderExtColor(color tcell.Color) *AdvancedInputField {
field.placeholderTextColor = color
return field
}
// SetFormAttributes sets attributes shared by all form items.
func (field *AdvancedInputField) SetFormAttributes(label string, labelColor, bgColor, fieldTextColor, fieldBgColor tcell.Color) tview.FormItem {
field.label = label
field.labelColor = labelColor
field.SetBackgroundColor(bgColor)
field.fieldTextColor = fieldTextColor
field.fieldBackgroundColor = fieldBgColor
return field
}
// SetFieldWidth sets the screen width of the input area. A value of 0 means
// extend as much as possible.
func (field *AdvancedInputField) SetFieldWidth(width int) *AdvancedInputField {
field.fieldWidth = width
return field
}
// GetFieldWidth returns this primitive's field width.
func (field *AdvancedInputField) GetFieldWidth() int {
return field.fieldWidth
}
// SetMaskCharacter sets a character that masks user input on a screen. A value
// of 0 disables masking.
func (field *AdvancedInputField) SetMaskCharacter(mask rune) *AdvancedInputField {
field.maskCharacter = mask
return field
}
// SetAcceptanceFunc sets a handler which may reject the last character that was
// entered (by returning false).
//
// This package defines a number of variables Prefixed with AdvancedInputField which may
// be used for common input (e.g. numbers, maximum text length).
func (field *AdvancedInputField) SetAcceptanceFunc(handler func(textToCheck string, lastChar rune) bool) *AdvancedInputField {
field.accept = handler
return field
}
// SetChangedFunc sets a handler which is called whenever the text of the input
// field has changed. It receives the current text (after the change).
func (field *AdvancedInputField) SetChangedFunc(handler func(text string)) *AdvancedInputField {
field.changed = handler
return field
}
// SetDoneFunc sets a handler which is called when the user is done entering
// text. The callback function is provided with the key that was pressed, which
// is one of the following:
//
// - KeyEnter: Done entering text.
// - KeyEscape: Abort text input.
// - KeyTab: Tab
// - KeyBacktab: Shift + Tab
func (field *AdvancedInputField) SetDoneFunc(handler func(key tcell.Key)) *AdvancedInputField {
field.done = handler
return field
}
func (field *AdvancedInputField) SetTabCompleteFunc(handler func(text string, cursorOffset int) string) *AdvancedInputField {
field.tabComplete = handler
return field
}
// SetFinishedFunc calls SetDoneFunc().
func (field *AdvancedInputField) SetFinishedFunc(handler func(key tcell.Key)) tview.FormItem {
return field.SetDoneFunc(handler)
}
// drawInput calculates the field width and draws the background.
func (field *AdvancedInputField) drawInput(screen tcell.Screen, rightLimit, x, y int) (fieldWidth int) {
fieldWidth = field.fieldWidth
if fieldWidth == 0 {
fieldWidth = math.MaxInt32
}
if rightLimit-x < fieldWidth {
fieldWidth = rightLimit - x
}
fieldStyle := tcell.StyleDefault.Background(field.fieldBackgroundColor)
for index := 0; index < fieldWidth; index++ {
screen.SetContent(x+index, y, ' ', nil, fieldStyle)
}
return
}
// prepareText prepares the text to be displayed and recalculates the view and cursor offsets.
func (field *AdvancedInputField) prepareText(screen tcell.Screen, fieldWidth, x, y int) (text string) {
text = field.text
if text == "" && field.placeholder != "" {
tview.Print(screen, field.placeholder, x, y, fieldWidth, tview.AlignLeft, field.placeholderTextColor)
}
if field.maskCharacter > 0 {
text = strings.Repeat(string(field.maskCharacter), utf8.RuneCountInString(field.text))
}
textWidth := runewidth.StringWidth(text)
if field.cursorOffset >= textWidth {
fieldWidth--
}
if field.cursorOffset < field.viewOffset {
field.viewOffset = field.cursorOffset
} else if field.cursorOffset > field.viewOffset+fieldWidth {
field.viewOffset = field.cursorOffset - fieldWidth
} else if textWidth-field.viewOffset < fieldWidth {
field.viewOffset = textWidth - fieldWidth
}
if field.viewOffset < 0 {
field.viewOffset = 0
}
return
}
// drawText draws the text and the cursor.
func (field *AdvancedInputField) drawText(screen tcell.Screen, fieldWidth, x, y int, text string) {
runes := []rune(text)
relPos := 0
for pos := field.viewOffset; pos <= fieldWidth+field.viewOffset && pos < len(runes); pos++ {
ch := runes[pos]
w := runewidth.RuneWidth(ch)
_, _, style, _ := screen.GetContent(x+relPos, y)
style = style.Foreground(field.fieldTextColor)
for w > 0 {
screen.SetContent(x+relPos, y, ch, nil, style)
relPos++
w--
}
}
// Set cursor.
if field.GetFocusable().HasFocus() {
field.setCursor(screen)
}
}
// Draw draws this primitive onto the screen.
func (field *AdvancedInputField) Draw(screen tcell.Screen) {
field.Box.Draw(screen)
x, y, width, height := field.GetInnerRect()
rightLimit := x + width
if height < 1 || rightLimit <= x {
return
}
_, drawnWidth := tview.Print(screen, field.label, x, y, rightLimit-x, tview.AlignLeft, field.labelColor)
x += drawnWidth
fieldWidth := field.drawInput(screen, rightLimit, x, y)
text := field.prepareText(screen, fieldWidth, x, y)
field.drawText(screen, fieldWidth, x, y, text)
}
func (field *AdvancedInputField) GetCursorOffset() int {
return field.cursorOffset
}
func (field *AdvancedInputField) SetCursorOffset(offset int) *AdvancedInputField {
if offset < 0 {
offset = 0
} else {
width := runewidth.StringWidth(field.text)
if offset >= width {
offset = width
}
}
field.cursorOffset = offset
return field
}
// setCursor sets the cursor position.
func (field *AdvancedInputField) setCursor(screen tcell.Screen) {
x, y, width, _ := field.GetRect()
origX, origY := x, y
rightLimit := x + width
if field.HasBorder() {
x++
y++
rightLimit -= 2
}
x = x + tview.StringWidth(field.label) + field.cursorOffset - field.viewOffset
if x >= rightLimit {
x = rightLimit - 1
} else if x < origX {
x = origY
}
screen.ShowCursor(x, y)
}
var (
lastWord = regexp.MustCompile(`\S+\s*$`)
firstWord = regexp.MustCompile(`^\s*\S+`)
)
func SubstringBefore(s string, w int) string {
return runewidth.Truncate(s, w, "")
}
func (field *AdvancedInputField) TypeRune(ch rune) {
leftPart := SubstringBefore(field.text, field.cursorOffset)
newText := leftPart + string(ch) + field.text[len(leftPart):]
if field.accept != nil {
if !field.accept(newText, ch) {
return
}
}
field.text = newText
field.cursorOffset += runewidth.RuneWidth(ch)
}
func (field *AdvancedInputField) PasteClipboard() {
clip, _ := clipboard.ReadAll("clipboard")
leftPart := SubstringBefore(field.text, field.cursorOffset)
field.text = leftPart + clip + field.text[len(leftPart):]
field.cursorOffset += runewidth.StringWidth(clip)
}
func (field *AdvancedInputField) MoveCursorLeft(moveWord bool) {
before := SubstringBefore(field.text, field.cursorOffset)
if moveWord {
found := lastWord.FindString(before)
field.cursorOffset -= runewidth.StringWidth(found)
} else if len(before) > 0 {
beforeRunes := []rune(before)
char := beforeRunes[len(beforeRunes)-1]
field.cursorOffset -= runewidth.RuneWidth(char)
}
}
func (field *AdvancedInputField) MoveCursorRight(moveWord bool) {
before := SubstringBefore(field.text, field.cursorOffset)
after := field.text[len(before):]
if moveWord {
found := firstWord.FindString(after)
field.cursorOffset += runewidth.StringWidth(found)
} else if len(after) > 0 {
char := []rune(after)[0]
field.cursorOffset += runewidth.RuneWidth(char)
}
}
func (field *AdvancedInputField) RemoveNextCharacter() {
if field.cursorOffset >= runewidth.StringWidth(field.text) {
return
}
leftPart := SubstringBefore(field.text, field.cursorOffset)
// Take everything after the left part minus the first character.
rightPart := string([]rune(field.text[len(leftPart):])[1:])
field.text = leftPart + rightPart
}
func (field *AdvancedInputField) Clear() {
field.text = ""
field.cursorOffset = 0
}
func (field *AdvancedInputField) RemovePreviousWord() {
leftPart := SubstringBefore(field.text, field.cursorOffset)
rightPart := field.text[len(leftPart):]
replacement := lastWord.ReplaceAllString(leftPart, "")
field.text = replacement + rightPart
field.cursorOffset -= runewidth.StringWidth(leftPart) - runewidth.StringWidth(replacement)
}
func (field *AdvancedInputField) RemovePreviousCharacter() {
if field.cursorOffset == 0 {
return
}
leftPart := SubstringBefore(field.text, field.cursorOffset)
rightPart := field.text[len(leftPart):]
// Take everything before the right part minus the last character.
leftPartRunes := []rune(leftPart)
leftPartRunes = leftPartRunes[0 : len(leftPartRunes)-1]
leftPart = string(leftPartRunes)
// Figure out what character was removed to correctly decrease cursorOffset.
removedChar := field.text[len(leftPart) : len(field.text)-len(rightPart)]
field.text = leftPart + rightPart
field.cursorOffset -= runewidth.StringWidth(removedChar)
}
func (field *AdvancedInputField) TriggerTabComplete() bool {
if field.tabComplete != nil {
oldWidth := runewidth.StringWidth(field.text)
field.text = field.tabComplete(field.text, field.cursorOffset)
newWidth := runewidth.StringWidth(field.text)
if oldWidth != newWidth {
field.cursorOffset += newWidth - oldWidth
}
return true
}
return false
}
func (field *AdvancedInputField) handleInputChanges(originalText string) {
// Trigger changed events.
if field.text != originalText && field.changed != nil {
field.changed(field.text)
}
// Make sure cursor offset is valid
if field.cursorOffset < 0 {
field.cursorOffset = 0
}
width := runewidth.StringWidth(field.text)
if field.cursorOffset > width {
field.cursorOffset = width
}
}
// InputHandler returns the handler for this primitive.
func (field *AdvancedInputField) InputHandler() func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
return field.WrapInputHandler(field.inputHandler)
}
func (field *AdvancedInputField) inputHandler(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
defer field.handleInputChanges(field.text)
// Process key event.
switch key := event.Key(); key {
case tcell.KeyRune:
field.TypeRune(event.Rune())
case tcell.KeyCtrlV:
field.PasteClipboard()
case tcell.KeyLeft:
field.MoveCursorLeft(event.Modifiers() == tcell.ModCtrl)
case tcell.KeyRight:
field.MoveCursorRight(event.Modifiers() == tcell.ModCtrl)
case tcell.KeyDelete:
field.RemoveNextCharacter()
case tcell.KeyCtrlU:
if field.vimBindings {
field.Clear()
}
case tcell.KeyCtrlW:
if field.vimBindings {
field.RemovePreviousWord()
}
case tcell.KeyBackspace:
field.RemovePreviousWord()
case tcell.KeyBackspace2:
field.RemovePreviousCharacter()
case tcell.KeyTab:
if field.TriggerTabComplete() {
break
}
fallthrough
case tcell.KeyEnter, tcell.KeyEscape, tcell.KeyBacktab:
if field.done != nil {
field.done(key)
}
}
}