gilo/editor/draw.go

216 lines
4.6 KiB
Go
Raw Normal View History

2021-04-13 14:54:44 -04:00
// Package editor Editor methods involved in drawing to the console
2021-03-26 16:18:03 -04:00
package editor
import (
"fmt"
"strings"
2021-04-01 13:25:59 -04:00
"time"
2021-04-07 13:10:40 -04:00
"timshome.page/gilo/editor/highlight"
2021-04-13 14:54:44 -04:00
"timshome.page/gilo/internal/gilo"
2021-04-07 13:10:40 -04:00
"timshome.page/gilo/terminal"
2023-10-05 15:29:37 -04:00
"unicode"
2021-03-26 16:18:03 -04:00
)
// ----------------------------------------------------------------------------
// !Editor Methods
// ----------------------------------------------------------------------------
func (e *Editor) RefreshScreen() {
2021-03-31 09:43:47 -04:00
e.scroll()
2021-04-13 14:54:44 -04:00
ab := gilo.NewBuffer()
2021-03-26 16:18:03 -04:00
2021-04-02 13:11:54 -04:00
ab.Append(terminal.HideCursor)
ab.Append(terminal.ResetCursor)
2021-03-26 16:18:03 -04:00
e.drawRows(ab)
2021-04-01 09:41:16 -04:00
e.drawStatusBar(ab)
2021-04-01 13:25:59 -04:00
e.drawMessageBar(ab)
2021-04-01 09:41:16 -04:00
2021-04-02 14:52:44 -04:00
ab.Append(terminal.MoveCursor(e.renderX-e.offset.X, e.cursor.Y-e.offset.Y))
2021-03-26 16:18:03 -04:00
2021-04-02 13:11:54 -04:00
ab.Append(terminal.ShowCursor)
2021-03-26 16:18:03 -04:00
2021-04-02 13:11:54 -04:00
terminal.Write(ab.ToString())
2021-03-26 16:18:03 -04:00
}
func (e *Editor) scroll() {
2021-03-31 14:56:46 -04:00
e.renderX = 0
if e.cursor.Y < e.doc.RowCount() {
e.renderX = e.doc.GetRow(e.cursor.Y).CursorXToRenderX(e.cursor.X)
2021-03-31 14:56:46 -04:00
}
2021-04-02 14:52:44 -04:00
if e.cursor.Y < e.offset.Y {
e.offset.Y = e.cursor.Y
2021-03-31 09:43:47 -04:00
}
2021-04-02 14:52:44 -04:00
if e.cursor.Y >= e.offset.Y+e.screen.Rows {
e.offset.Y = e.cursor.Y - e.screen.Rows + 1
2021-03-31 09:43:47 -04:00
}
2021-04-02 14:52:44 -04:00
if e.renderX < e.offset.X {
e.offset.X = e.renderX
}
2021-04-02 14:52:44 -04:00
if e.renderX >= e.offset.X+e.screen.Cols {
e.offset.X = e.renderX - e.screen.Cols
}
2021-03-31 09:43:47 -04:00
}
2023-10-05 15:29:37 -04:00
// drawRows is the equivalent to editorDrawRows in kilo
func (e *Editor) drawRows(ab *gilo.Buffer) {
2021-04-01 16:17:13 -04:00
for y := 0; y < e.screen.Rows; y++ {
2021-04-02 14:52:44 -04:00
fileRow := y + e.offset.Y
2021-03-31 09:43:47 -04:00
if fileRow >= e.doc.RowCount() {
e.drawPlaceholderRow(y, ab)
2021-03-26 16:18:03 -04:00
} else {
rawRow := e.doc.GetRow(fileRow)
// If the column offset is greater than the length of the row,
// just display an empty row
2021-04-02 14:52:44 -04:00
if e.offset.X > rawRow.Size() {
2021-04-02 13:11:54 -04:00
ab.Append("")
continue
}
e.drawFileRow(fileRow, ab)
2021-03-26 16:18:03 -04:00
}
2021-04-02 13:11:54 -04:00
ab.AppendLn(terminal.ClearLine)
2021-03-26 16:18:03 -04:00
}
}
func (e *Editor) drawFileRow(fileRow int, ab *gilo.Buffer) {
currentColor := terminal.DefaultFGColor
row := e.doc.GetRow(fileRow)
// Because runes can be more than one byte, 🫵 render
// this by runes so that multibyte-characters (like emoji) can
// all be displayed
for i, ch := range row.RenderRune(e.offset) {
2023-10-05 15:29:37 -04:00
if unicode.IsControl(ch) {
sym := '?'
if ch <= 26 {
sym = '@' + ch
}
ab.Append(terminal.InvertColor)
ab.AppendRune(sym)
ab.Append(terminal.ResetColor)
if currentColor != terminal.DefaultFGColor {
ab.Append(currentColor)
}
} else if row.Hl[i] == highlight.Normal {
if currentColor != terminal.DefaultFGColor {
ab.Append(terminal.DefaultFGColor)
currentColor = terminal.DefaultFGColor
}
ab.AppendRune(ch)
} else {
color := highlight.SyntaxToColor(row.Hl[i])
if color != currentColor {
currentColor = color
ab.Append(color)
}
ab.AppendRune(ch)
}
}
ab.Append(terminal.DefaultFGColor)
}
func (e *Editor) drawPlaceholderRow(y int, ab *gilo.Buffer) {
if e.doc.RowCount() == 0 && y == e.screen.Rows/3 {
2021-04-13 14:54:44 -04:00
welcome := fmt.Sprintf("Gilo editor -- version %s", gilo.Version)
if len(welcome) > e.screen.Cols {
2021-04-13 14:54:44 -04:00
welcome = gilo.Truncate(welcome, e.screen.Cols)
}
padding := (e.screen.Cols - len(welcome)) / 2
if padding > 0 {
2021-04-02 13:11:54 -04:00
ab.AppendRune('~')
padding--
}
for padding > 0 {
padding--
2021-04-02 13:11:54 -04:00
ab.AppendRune(' ')
}
2021-04-02 13:11:54 -04:00
ab.Append(welcome)
} else {
2021-04-02 13:11:54 -04:00
ab.AppendRune('~')
}
}
func (e *Editor) drawStatusBar(ab *gilo.Buffer) {
cols := e.screen.Cols
2021-04-01 16:17:13 -04:00
2021-04-02 13:11:54 -04:00
ab.Append(terminal.InvertColor)
2021-04-01 09:41:16 -04:00
fileName := "[No Name]"
if e.doc.Filename != "" {
fileName = e.doc.Filename
}
2021-04-02 10:07:37 -04:00
modified := ""
if e.doc.IsDirty() {
2021-04-02 10:07:37 -04:00
modified = "(modified)"
}
leftStatus := fmt.Sprintf("%.20s - %d lines %s", fileName, e.doc.RowCount(), modified)
length := len(leftStatus)
if length > cols {
2021-04-13 14:54:44 -04:00
leftStatus = gilo.Truncate(leftStatus, cols)
2021-04-02 13:11:54 -04:00
ab.Append(leftStatus)
ab.Append(terminal.ResetColor)
return
}
2021-04-01 16:17:13 -04:00
syntaxName := "no filetype"
if e.doc.Syntax != nil {
syntaxName = e.doc.Syntax.FileType
}
rightStatus := fmt.Sprintf("%s | %d/%d", syntaxName, e.cursor.Y+1, e.doc.RowCount())
rlength := len(rightStatus)
statusLength := length + rlength
if statusLength <= cols {
paddingLength := cols - statusLength
padding := strings.Repeat(" ", paddingLength)
2021-04-02 13:11:54 -04:00
ab.Append(leftStatus)
ab.Append(padding)
ab.Append(rightStatus)
2021-04-02 13:11:54 -04:00
ab.Append(terminal.ResetColor)
return
}
2021-04-02 13:11:54 -04:00
ab.Append(leftStatus)
// Pad the rest of the status line
2021-04-01 16:17:13 -04:00
padding := strings.Repeat(" ", cols-length)
2021-04-02 13:11:54 -04:00
ab.Append(padding)
2021-04-02 13:11:54 -04:00
ab.Append(terminal.ResetColor)
2021-04-01 09:41:16 -04:00
}
2021-04-01 13:25:59 -04:00
2023-10-05 15:29:37 -04:00
// drawMessageBar is the equivalent of editorDrawMessageBar in kilo
func (e *Editor) drawMessageBar(ab *gilo.Buffer) {
2021-04-02 13:11:54 -04:00
ab.Append("\r\n")
ab.Append(terminal.ClearLine)
2021-04-01 13:25:59 -04:00
2021-04-13 14:54:44 -04:00
msg := gilo.Truncate(e.status.message, e.screen.Cols)
2021-04-01 13:25:59 -04:00
if len(msg) > 0 && time.Since(e.status.created).Seconds() < 5.0 {
2021-04-02 13:11:54 -04:00
ab.Append(msg)
2021-04-01 13:25:59 -04:00
}
}