447 lines
12 KiB
Go
447 lines
12 KiB
Go
package tea
|
|
|
|
import (
|
|
"fmt"
|
|
"image/color"
|
|
"io"
|
|
"strings"
|
|
"sync"
|
|
|
|
"github.com/charmbracelet/colorprofile"
|
|
uv "github.com/charmbracelet/ultraviolet"
|
|
"github.com/charmbracelet/x/ansi"
|
|
"github.com/lucasb-eyer/go-colorful"
|
|
)
|
|
|
|
type cursedRenderer struct {
|
|
w io.Writer
|
|
scr *uv.TerminalRenderer
|
|
buf uv.ScreenBuffer
|
|
lastFrame *string
|
|
lastCur *Cursor
|
|
env []string
|
|
term string // the terminal type $TERM
|
|
width, height int
|
|
lastFrameHeight int // the height of the last rendered frame, used to determine if we need to resize the screen buffer
|
|
mu sync.Mutex
|
|
profile colorprofile.Profile
|
|
cursor Cursor
|
|
method ansi.Method
|
|
logger uv.Logger
|
|
layer Layer // the last rendered layer
|
|
setCc, setFg, setBg color.Color
|
|
windowTitleSet string // the last set window title
|
|
windowTitle string // the desired title of the terminal window
|
|
altScreen bool
|
|
cursorHidden bool
|
|
hardTabs bool // whether to use hard tabs to optimize cursor movements
|
|
backspace bool // whether to use backspace to optimize cursor movements
|
|
mapnl bool
|
|
}
|
|
|
|
var _ renderer = &cursedRenderer{}
|
|
|
|
func newCursedRenderer(w io.Writer, env []string, width, height int, hardTabs, backspace, mapnl bool, logger uv.Logger) (s *cursedRenderer) {
|
|
s = new(cursedRenderer)
|
|
s.w = w
|
|
s.env = env
|
|
s.term = uv.Environ(env).Getenv("TERM")
|
|
s.logger = logger
|
|
s.hardTabs = hardTabs
|
|
s.backspace = backspace
|
|
s.mapnl = mapnl
|
|
s.width, s.height = width, height // This needs to happen before [cursedRenderer.reset].
|
|
s.buf = uv.NewScreenBuffer(s.width, s.height)
|
|
reset(s)
|
|
return
|
|
}
|
|
|
|
// close implements renderer.
|
|
func (s *cursedRenderer) close() (err error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
// Go to the bottom of the screen.
|
|
s.scr.MoveTo(0, s.buf.Height()-1)
|
|
|
|
// Exit the altScreen and show cursor before closing. It's important that
|
|
// we don't change the [cursedRenderer] altScreen and cursorHidden states
|
|
// so that we can restore them when we start the renderer again. This is
|
|
// used when the user suspends the program and then resumes it.
|
|
if s.altScreen {
|
|
s.scr.ExitAltScreen()
|
|
}
|
|
if s.cursorHidden {
|
|
s.scr.ShowCursor()
|
|
s.cursorHidden = false
|
|
}
|
|
|
|
if err := s.scr.Flush(); err != nil {
|
|
return fmt.Errorf("bubbletea: error closing screen writer: %w", err)
|
|
}
|
|
|
|
x, y := s.scr.Position()
|
|
|
|
// We want to clear the renderer state but not the cursor position. This is
|
|
// because we might be putting the tea process in the background, run some
|
|
// other process, and then return to the tea process. We want to keep the
|
|
// cursor position so that we can continue where we left off.
|
|
reset(s)
|
|
s.scr.SetPosition(x, y)
|
|
|
|
// Reset cursor style state so that we can restore it again when we start
|
|
// the renderer again.
|
|
s.cursor = Cursor{}
|
|
|
|
return nil
|
|
}
|
|
|
|
// writeString implements renderer.
|
|
func (s *cursedRenderer) writeString(str string) (int, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
return s.scr.WriteString(str)
|
|
}
|
|
|
|
// flush implements renderer.
|
|
func (s *cursedRenderer) flush(p *Program) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
// Set window title.
|
|
if s.windowTitle != s.windowTitleSet {
|
|
_, _ = s.scr.WriteString(ansi.SetWindowTitle(s.windowTitle))
|
|
s.windowTitleSet = s.windowTitle
|
|
}
|
|
// Set terminal colors.
|
|
for _, c := range []struct {
|
|
rendererColor *color.Color
|
|
programColor *color.Color
|
|
reset string
|
|
setter func(string) string
|
|
}{
|
|
{rendererColor: &s.setCc, programColor: &p.setCc, reset: ansi.ResetCursorColor, setter: ansi.SetCursorColor},
|
|
{rendererColor: &s.setFg, programColor: &p.setFg, reset: ansi.ResetForegroundColor, setter: ansi.SetForegroundColor},
|
|
{rendererColor: &s.setBg, programColor: &p.setBg, reset: ansi.ResetBackgroundColor, setter: ansi.SetBackgroundColor},
|
|
} {
|
|
if *c.rendererColor != *c.programColor {
|
|
if *c.rendererColor == nil {
|
|
// Reset the color if it was set to nil.
|
|
_, _ = s.scr.WriteString(c.reset)
|
|
} else {
|
|
// Set the color.
|
|
col, ok := colorful.MakeColor(*c.rendererColor)
|
|
if ok {
|
|
_, _ = s.scr.WriteString(c.setter(col.Hex()))
|
|
}
|
|
}
|
|
*c.programColor = *c.rendererColor
|
|
}
|
|
}
|
|
|
|
if s.lastCur != nil {
|
|
if s.lastCur.Shape != s.cursor.Shape || s.lastCur.Blink != s.cursor.Blink {
|
|
cursorStyle := encodeCursorStyle(s.lastCur.Shape, s.lastCur.Blink)
|
|
_, _ = s.scr.WriteString(ansi.SetCursorStyle(cursorStyle))
|
|
s.cursor.Shape = s.lastCur.Shape
|
|
s.cursor.Blink = s.lastCur.Blink
|
|
}
|
|
if s.lastCur.Color != s.cursor.Color {
|
|
seq := ansi.ResetCursorColor
|
|
if s.lastCur.Color != nil {
|
|
c, ok := colorful.MakeColor(s.lastCur.Color)
|
|
if ok {
|
|
seq = ansi.SetCursorColor(c.Hex())
|
|
}
|
|
}
|
|
_, _ = s.scr.WriteString(seq)
|
|
s.cursor.Color = s.lastCur.Color
|
|
}
|
|
}
|
|
|
|
// Render and queue changes to the screen buffer.
|
|
s.scr.Render(s.buf.Buffer)
|
|
if s.lastCur != nil {
|
|
// MoveTo must come after [uv.TerminalRenderer.Render] because the
|
|
// cursor position might get updated during rendering.
|
|
s.scr.MoveTo(s.lastCur.X, s.lastCur.Y)
|
|
s.cursor.Position = s.lastCur.Position
|
|
}
|
|
|
|
if err := s.scr.Flush(); err != nil {
|
|
return fmt.Errorf("bubbletea: error flushing screen writer: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// render implements renderer.
|
|
func (s *cursedRenderer) render(v View) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
frameArea := uv.Rect(0, 0, s.width, s.height)
|
|
if v.Layer == nil {
|
|
// If the component is nil, we should clear the screen buffer.
|
|
frameArea.Max.Y = 0
|
|
}
|
|
|
|
if !s.altScreen {
|
|
// Inline mode resizes the screen based on the frame height and
|
|
// terminal width. This is because the frame height can change based on
|
|
// the content of the frame. For example, if the frame contains a list
|
|
// of items, the height of the frame will be the number of items in the
|
|
// list. This is different from the alt screen buffer, which has a
|
|
// fixed height and width.
|
|
switch l := v.Layer.(type) {
|
|
case *uv.StyledString:
|
|
frameArea.Max.Y = l.Height()
|
|
case interface{ Bounds() uv.Rectangle }:
|
|
frameArea.Max.Y = l.Bounds().Dy()
|
|
}
|
|
|
|
// Resize the screen buffer to match the frame area. This is necessary
|
|
// to ensure that the screen buffer is the same size as the frame area
|
|
// and to avoid rendering issues when the frame area is smaller than
|
|
// the screen buffer.
|
|
s.buf.Resize(frameArea.Dx(), frameArea.Dy())
|
|
}
|
|
// Clear our screen buffer before copying the new frame into it to ensure
|
|
// we erase any old content.
|
|
s.buf.Clear()
|
|
if v.Layer != nil {
|
|
v.Layer.Draw(s.buf, frameArea)
|
|
}
|
|
|
|
frame := s.buf.Render()
|
|
|
|
// If an empty string was passed we should clear existing output and
|
|
// rendering nothing. Rather than introduce additional state to manage
|
|
// this, we render a single space as a simple (albeit less correct)
|
|
// solution.
|
|
if frame == "" {
|
|
frame = " "
|
|
}
|
|
|
|
cur := v.Cursor
|
|
|
|
s.windowTitle = v.WindowTitle
|
|
|
|
// Ensure we have any desired terminal colors set.
|
|
s.setBg = v.BackgroundColor
|
|
s.setFg = v.ForegroundColor
|
|
if cur != nil {
|
|
s.setCc = cur.Color
|
|
}
|
|
if s.lastFrame != nil && frame == *s.lastFrame &&
|
|
(s.lastCur == nil && cur == nil || s.lastCur != nil && cur != nil && *s.lastCur == *cur) {
|
|
return
|
|
}
|
|
|
|
s.layer = v.Layer
|
|
s.lastCur = cur
|
|
s.lastFrameHeight = frameArea.Dy()
|
|
|
|
// Cache the last rendered frame so we can avoid re-rendering it if
|
|
// the frame hasn't changed.
|
|
lastFrame := frame
|
|
s.lastFrame = &lastFrame
|
|
|
|
if cur == nil {
|
|
enableTextCursor(s, false)
|
|
} else {
|
|
enableTextCursor(s, true)
|
|
}
|
|
}
|
|
|
|
// hit implements renderer.
|
|
func (s *cursedRenderer) hit(mouse MouseMsg) []Msg {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
if s.layer != nil {
|
|
if h, ok := s.layer.(Hittable); ok {
|
|
m := mouse.Mouse()
|
|
if id := h.Hit(m.X, m.Y); id != "" {
|
|
return []Msg{LayerHitMsg{
|
|
ID: id,
|
|
Mouse: mouse,
|
|
}}
|
|
}
|
|
}
|
|
}
|
|
|
|
return []Msg{}
|
|
}
|
|
|
|
// setCursorColor implements renderer.
|
|
func (s *cursedRenderer) setCursorColor(c color.Color) {
|
|
s.mu.Lock()
|
|
s.setCc = c
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
// setForegroundColor implements renderer.
|
|
func (s *cursedRenderer) setForegroundColor(c color.Color) {
|
|
s.mu.Lock()
|
|
s.setFg = c
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
// setBackgroundColor implements renderer.
|
|
func (s *cursedRenderer) setBackgroundColor(c color.Color) {
|
|
s.mu.Lock()
|
|
s.setBg = c
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
// setWindowTitle implements renderer.
|
|
func (s *cursedRenderer) setWindowTitle(title string) {
|
|
s.mu.Lock()
|
|
s.windowTitle = title
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
// reset implements renderer.
|
|
func (s *cursedRenderer) reset() {
|
|
s.mu.Lock()
|
|
reset(s)
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
func reset(s *cursedRenderer) {
|
|
scr := uv.NewTerminalRenderer(s.w, s.env)
|
|
scr.SetColorProfile(s.profile)
|
|
scr.SetRelativeCursor(!s.altScreen)
|
|
scr.SetTabStops(s.width)
|
|
scr.SetBackspace(s.backspace)
|
|
scr.SetMapNewline(s.mapnl)
|
|
scr.SetLogger(s.logger)
|
|
if s.altScreen {
|
|
scr.EnterAltScreen()
|
|
} else {
|
|
scr.ExitAltScreen()
|
|
}
|
|
if !s.cursorHidden {
|
|
scr.ShowCursor()
|
|
} else {
|
|
scr.HideCursor()
|
|
}
|
|
s.scr = scr
|
|
}
|
|
|
|
// setColorProfile implements renderer.
|
|
func (s *cursedRenderer) setColorProfile(p colorprofile.Profile) {
|
|
s.mu.Lock()
|
|
s.profile = p
|
|
s.scr.SetColorProfile(p)
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
// resize implements renderer.
|
|
func (s *cursedRenderer) resize(w, h int) {
|
|
s.mu.Lock()
|
|
if s.altScreen || w != s.width {
|
|
// We need to mark the screen for clear to force a redraw. However, we
|
|
// only do so if we're using alt screen or the width has changed.
|
|
// That's because redrawing is expensive and we can avoid it if the
|
|
// width hasn't changed in inline mode. On the other hand, when using
|
|
// alt screen mode, we always want to redraw because some terminals
|
|
// would scroll the screen and our content would be lost.
|
|
s.scr.Erase()
|
|
}
|
|
if s.altScreen {
|
|
s.buf.Resize(w, h)
|
|
}
|
|
|
|
s.scr.Resize(s.width, s.height)
|
|
s.width, s.height = w, h
|
|
repaint(s)
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
// clearScreen implements renderer.
|
|
func (s *cursedRenderer) clearScreen() {
|
|
s.mu.Lock()
|
|
// Move the cursor to the top left corner of the screen and trigger a full
|
|
// screen redraw.
|
|
_, _ = s.scr.WriteString(ansi.CursorHomePosition)
|
|
s.scr.Redraw(s.buf.Buffer) // force redraw
|
|
repaint(s)
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
// enableAltScreen sets the alt screen mode.
|
|
func enableAltScreen(s *cursedRenderer, enable bool) {
|
|
s.altScreen = enable
|
|
if enable {
|
|
s.scr.EnterAltScreen()
|
|
} else {
|
|
s.scr.ExitAltScreen()
|
|
}
|
|
s.scr.SetRelativeCursor(!s.altScreen)
|
|
repaint(s)
|
|
}
|
|
|
|
// enterAltScreen implements renderer.
|
|
func (s *cursedRenderer) enterAltScreen() {
|
|
s.mu.Lock()
|
|
enableAltScreen(s, true)
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
// exitAltScreen implements renderer.
|
|
func (s *cursedRenderer) exitAltScreen() {
|
|
s.mu.Lock()
|
|
enableAltScreen(s, false)
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
// enableTextCursor sets the text cursor mode.
|
|
func enableTextCursor(s *cursedRenderer, enable bool) {
|
|
s.cursorHidden = !enable
|
|
if enable {
|
|
s.scr.ShowCursor()
|
|
} else {
|
|
s.scr.HideCursor()
|
|
}
|
|
}
|
|
|
|
// showCursor implements renderer.
|
|
func (s *cursedRenderer) showCursor() {
|
|
s.mu.Lock()
|
|
enableTextCursor(s, true)
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
// hideCursor implements renderer.
|
|
func (s *cursedRenderer) hideCursor() {
|
|
s.mu.Lock()
|
|
enableTextCursor(s, false)
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
// insertAbove implements renderer.
|
|
func (s *cursedRenderer) insertAbove(lines string) {
|
|
s.mu.Lock()
|
|
strLines := strings.Split(lines, "\n")
|
|
for i, line := range strLines {
|
|
if ansi.StringWidth(line) > s.width {
|
|
// If the line is wider than the screen, truncate it.
|
|
line = ansi.Truncate(line, s.width, "")
|
|
}
|
|
strLines[i] = line
|
|
}
|
|
s.scr.PrependString(strings.Join(strLines, "\n"))
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
func (s *cursedRenderer) repaint() {
|
|
s.mu.Lock()
|
|
repaint(s)
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
func repaint(s *cursedRenderer) {
|
|
s.lastFrame = nil
|
|
}
|