Timothy Warren
19ab06ac4f
All checks were successful
timw4mail/gilo/pipeline/head This commit looks good
257 lines
5.0 KiB
Go
257 lines
5.0 KiB
Go
package editor
|
|
|
|
import (
|
|
"timshome.page/gilo/internal/editor/document"
|
|
"timshome.page/gilo/internal/gilo"
|
|
"timshome.page/gilo/internal/key"
|
|
"timshome.page/gilo/internal/terminal"
|
|
)
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// !Constants representing input keys
|
|
// ----------------------------------------------------------------------------
|
|
|
|
const (
|
|
keyUp = "ARROW_UP"
|
|
keyDown = "ARROW_DOWN"
|
|
keyLeft = "ARROW_LEFT"
|
|
keyRight = "ARROW_RIGHT"
|
|
keyPageUp = "PAGE_UP"
|
|
keyPageDown = "PAGE_DOWN"
|
|
keyHome = "HOME"
|
|
keyEnd = "END"
|
|
keyDelete = "DELETE"
|
|
)
|
|
|
|
/**
|
|
* Determine what to do with an individual character of input
|
|
*/
|
|
func (e *editor) processKeypressChar(ch rune) bool {
|
|
switch ch {
|
|
case key.Ctrl('q'):
|
|
if e.document.IsDirty() && e.quitTimes > 0 {
|
|
e.SetStatusMessage("WARNING!!! File has unsaved changes. Press Ctrl-Q %d more tiems to quite.", e.quitTimes)
|
|
e.quitTimes -= 1
|
|
|
|
return true
|
|
}
|
|
|
|
// Clean up on exit
|
|
terminal.Write(terminal.ClearScreen + terminal.ResetCursor)
|
|
|
|
return false
|
|
|
|
case key.Ctrl('s'):
|
|
e.Save()
|
|
|
|
case key.Enter:
|
|
e.document.InsertNewline(e.cursor)
|
|
e.cursor.Y += 1
|
|
e.cursor.X = 0
|
|
|
|
case key.Backspace, key.Ctrl('h'):
|
|
e.delChar()
|
|
|
|
case key.Esc, key.Ctrl('l'):
|
|
// Modifier keys that return ANSI escape sequences
|
|
str := parseEscapeSequence()
|
|
|
|
// Don't swallow a character after ESC if it doesn't
|
|
// start an ANSI escape sequence
|
|
if len(str) == 1 {
|
|
return e.processKeypressChar(rune(str[0]))
|
|
}
|
|
|
|
e.processKeypressStr(str)
|
|
|
|
default:
|
|
e.insertChar(ch)
|
|
}
|
|
|
|
// Clear the quit message and restart the
|
|
// confirmation count if confirmation is not
|
|
// completed
|
|
if e.quitTimes != gilo.QuitTimes {
|
|
e.quitTimes = gilo.QuitTimes
|
|
e.SetStatusMessage("")
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* Determine what do do with a parsed ANSI escape sequence
|
|
*/
|
|
func (e *editor) processKeypressStr(key string) {
|
|
switch key {
|
|
case keyUp,
|
|
keyDown,
|
|
keyLeft,
|
|
keyRight,
|
|
keyPageUp,
|
|
keyPageDown,
|
|
keyHome,
|
|
keyEnd:
|
|
|
|
e.moveCursor(key)
|
|
|
|
case keyDelete:
|
|
e.moveCursor(keyRight)
|
|
e.delChar()
|
|
}
|
|
}
|
|
|
|
func (e *editor) moveCursor(key string) {
|
|
var row *document.Row
|
|
if e.cursor.Y >= e.document.RowCount() {
|
|
row = nil
|
|
} else {
|
|
row = e.document.Row(e.cursor.Y)
|
|
}
|
|
|
|
switch key {
|
|
case keyLeft:
|
|
if e.cursor.X != 0 {
|
|
e.cursor.X -= 1
|
|
}
|
|
|
|
// Move from beginning of current row to end of previous row
|
|
if e.cursor.Y > 0 {
|
|
e.cursor.Y -= 1
|
|
e.cursor.X = e.document.Row(e.cursor.Y).Size()
|
|
}
|
|
case keyRight:
|
|
if row != nil && e.cursor.X < row.Size() {
|
|
e.cursor.X += 1
|
|
}
|
|
|
|
// Move from end of current line to beginning of next line
|
|
if row != nil && e.cursor.X == row.Size() && e.cursor.Y < e.document.RowCount()-1 {
|
|
e.cursor.Y += 1
|
|
e.cursor.X = 0
|
|
}
|
|
case keyUp:
|
|
if e.cursor.Y != 0 {
|
|
e.cursor.Y -= 1
|
|
}
|
|
case keyDown:
|
|
if e.cursor.Y < e.document.RowCount() {
|
|
e.cursor.Y += 1
|
|
}
|
|
case keyPageUp:
|
|
if e.cursor.Y > e.screen.Rows {
|
|
e.cursor.Y -= e.screen.Rows
|
|
} else {
|
|
e.cursor.Y = 0
|
|
}
|
|
|
|
case keyPageDown:
|
|
if e.cursor.Y+e.screen.Rows > e.document.RowCount() {
|
|
e.cursor.Y += e.screen.Rows
|
|
} else {
|
|
e.cursor.Y = e.document.RowCount() - 1
|
|
}
|
|
|
|
case keyHome:
|
|
e.cursor.X = 0
|
|
case keyEnd:
|
|
if row != nil {
|
|
e.cursor.X = row.Size()
|
|
}
|
|
}
|
|
|
|
if e.cursor.Y < e.document.RowCount() {
|
|
row = e.document.Row(e.cursor.Y)
|
|
rowLen := row.Size()
|
|
|
|
// Snap to the end of a shorter line from a longer one
|
|
if e.cursor.X > rowLen {
|
|
e.cursor.X = rowLen
|
|
}
|
|
}
|
|
}
|
|
|
|
// Convert the raw ANSI escape sequences to the type of key input
|
|
func parseEscapeSequence() string {
|
|
// If we aren't starting an escape sequence,
|
|
// return the character
|
|
startChar, _ := terminal.ReadKey()
|
|
if startChar != '[' && startChar != 'O' {
|
|
return string(startChar)
|
|
}
|
|
|
|
// Read one or two characters after
|
|
// \e[ or \eO, which is the end of the
|
|
// handled escape sequences
|
|
runes := [2]rune{'\000', '\000'}
|
|
for i := 0; i < 2; i++ {
|
|
ch, size := terminal.ReadKey()
|
|
if size == 0 {
|
|
return string(rune(key.Esc))
|
|
}
|
|
runes[i] = ch
|
|
|
|
if i == 0 && runes[0] >= 'A' && runes[0] <= 'Z' {
|
|
return escSeqToKey([]rune{startChar, runes[0]})
|
|
}
|
|
|
|
// \e[*~
|
|
if i == 1 && startChar == '[' && runes[1] == '~' {
|
|
return escSeqToKey([]rune{startChar, runes[0], runes[1]})
|
|
}
|
|
}
|
|
|
|
return string(rune(key.Esc))
|
|
}
|
|
|
|
func escSeqToKey(seq []rune) string {
|
|
// \eO*
|
|
// \e[*
|
|
if len(seq) == 2 {
|
|
startChar, cmd := seq[0], seq[1]
|
|
if startChar == 'O' {
|
|
switch cmd {
|
|
case 'H':
|
|
return keyHome
|
|
case 'F':
|
|
return keyEnd
|
|
}
|
|
} else if startChar == '[' {
|
|
switch cmd {
|
|
case 'A':
|
|
return keyUp
|
|
case 'B':
|
|
return keyDown
|
|
case 'C':
|
|
return keyRight
|
|
case 'D':
|
|
return keyLeft
|
|
case 'H':
|
|
return keyHome
|
|
case 'F':
|
|
return keyEnd
|
|
}
|
|
}
|
|
} else if len(seq) == 3 { // \e[*~
|
|
cmd := seq[1]
|
|
switch cmd {
|
|
case '1':
|
|
return keyHome
|
|
case '3':
|
|
return keyDelete
|
|
case '4':
|
|
return keyEnd
|
|
case '5':
|
|
return keyPageUp
|
|
case '6':
|
|
return keyPageDown
|
|
case '7':
|
|
return keyHome
|
|
case '8':
|
|
return keyEnd
|
|
}
|
|
}
|
|
|
|
return string(rune(key.Esc))
|
|
}
|