2020-05-26 02:57:58 +03:00
|
|
|
package viewport
|
|
|
|
|
|
|
|
import (
|
2020-06-19 22:03:41 +03:00
|
|
|
"math"
|
2020-05-26 02:57:58 +03:00
|
|
|
"strings"
|
|
|
|
|
|
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
|
|
)
|
|
|
|
|
|
|
|
// MODEL
|
|
|
|
|
|
|
|
type Model struct {
|
|
|
|
Width int
|
|
|
|
Height int
|
2020-06-16 00:50:13 +03:00
|
|
|
|
|
|
|
// YOffset is the vertical scroll position.
|
|
|
|
YOffset int
|
|
|
|
|
2020-06-18 03:55:49 +03:00
|
|
|
// YPosition is the position of the viewport in relation to the terminal
|
|
|
|
// window. It's used in high performance rendering.
|
|
|
|
YPosition int
|
2020-06-16 00:50:13 +03:00
|
|
|
|
2020-06-18 03:55:49 +03:00
|
|
|
// HighPerformanceRendering bypasses the normal Bubble Tea renderer to
|
|
|
|
// provide higher performance rendering. Most of the time the normal Bubble
|
|
|
|
// Tea rendering methods will suffice, but if you're passing content with
|
|
|
|
// a lot of ANSI escape codes you may see improved rendering in certain
|
|
|
|
// terminals with this enabled.
|
|
|
|
//
|
2020-06-20 02:02:14 +03:00
|
|
|
// This should only be used in program occupying the entire terminal,
|
|
|
|
// which is usually via the alternate screen buffer.
|
2020-06-18 03:55:49 +03:00
|
|
|
HighPerformanceRendering bool
|
2020-05-26 02:57:58 +03:00
|
|
|
|
|
|
|
lines []string
|
2020-06-16 00:50:13 +03:00
|
|
|
}
|
|
|
|
|
2020-06-19 22:03:41 +03:00
|
|
|
// TODO: do we really need this?
|
2020-06-18 03:55:49 +03:00
|
|
|
func NewModel(width, height int) Model {
|
2020-06-16 00:50:13 +03:00
|
|
|
return Model{
|
2020-06-18 03:55:49 +03:00
|
|
|
Width: width,
|
|
|
|
Height: height,
|
2020-06-16 00:50:13 +03:00
|
|
|
}
|
2020-05-26 02:57:58 +03:00
|
|
|
}
|
|
|
|
|
2020-06-20 02:02:14 +03:00
|
|
|
// TODO: do we really need this?
|
|
|
|
func (m Model) SetSize(yPos, width, height int) {
|
2020-06-18 03:55:49 +03:00
|
|
|
m.YPosition = yPos
|
|
|
|
m.Width = width
|
|
|
|
m.Height = height
|
|
|
|
}
|
|
|
|
|
2020-06-16 04:19:15 +03:00
|
|
|
// AtTop returns whether or not the viewport is in the very top position.
|
|
|
|
func (m Model) AtTop() bool {
|
|
|
|
return m.YOffset <= 0
|
|
|
|
}
|
|
|
|
|
|
|
|
// AtBottom returns whether or not the viewport is at the very botom position.
|
|
|
|
func (m Model) AtBottom() bool {
|
|
|
|
return m.YOffset >= len(m.lines)-m.Height-1
|
|
|
|
}
|
|
|
|
|
2020-05-26 02:57:58 +03:00
|
|
|
// Scrollpercent returns the amount scrolled as a float between 0 and 1.
|
|
|
|
func (m Model) ScrollPercent() float64 {
|
|
|
|
if m.Height >= len(m.lines) {
|
|
|
|
return 1.0
|
|
|
|
}
|
2020-06-16 00:50:13 +03:00
|
|
|
y := float64(m.YOffset)
|
2020-05-26 02:57:58 +03:00
|
|
|
h := float64(m.Height)
|
|
|
|
t := float64(len(m.lines))
|
2020-06-19 22:03:41 +03:00
|
|
|
v := y / (t - h)
|
|
|
|
return math.Max(0.0, math.Min(1.0, v))
|
2020-05-26 02:57:58 +03:00
|
|
|
}
|
|
|
|
|
2020-06-18 20:41:23 +03:00
|
|
|
// SetContent set the pager's text content. For high performance rendering the
|
|
|
|
// Sync command should also be called.
|
2020-05-26 02:57:58 +03:00
|
|
|
func (m *Model) SetContent(s string) {
|
|
|
|
s = strings.Replace(s, "\r\n", "\n", -1) // normalize line endings
|
|
|
|
m.lines = strings.Split(s, "\n")
|
|
|
|
}
|
|
|
|
|
2020-06-19 19:20:35 +03:00
|
|
|
// Return the lines that should currently be visible in the viewport
|
|
|
|
func (m Model) visibleLines() (lines []string) {
|
|
|
|
if len(m.lines) > 0 {
|
|
|
|
top := max(0, m.YOffset)
|
|
|
|
bottom := min(len(m.lines), m.YOffset+m.Height)
|
|
|
|
lines = m.lines[top:bottom]
|
|
|
|
}
|
|
|
|
return lines
|
|
|
|
}
|
|
|
|
|
2020-05-26 02:57:58 +03:00
|
|
|
// ViewDown moves the view down by the number of lines in the viewport.
|
|
|
|
// Basically, "page down".
|
2020-06-19 19:20:35 +03:00
|
|
|
func (m *Model) ViewDown() []string {
|
2020-06-16 04:19:15 +03:00
|
|
|
if m.AtBottom() {
|
2020-06-19 19:20:35 +03:00
|
|
|
return nil
|
2020-06-16 04:19:15 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
m.YOffset = min(
|
|
|
|
m.YOffset+m.Height, // target
|
|
|
|
len(m.lines)-m.Height, // fallback
|
|
|
|
)
|
2020-06-19 19:20:35 +03:00
|
|
|
|
|
|
|
return m.visibleLines()
|
2020-05-26 02:57:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// ViewUp moves the view up by one height of the viewport. Basically, "page up".
|
2020-06-19 19:20:35 +03:00
|
|
|
func (m *Model) ViewUp() []string {
|
2020-06-16 04:19:15 +03:00
|
|
|
if m.AtTop() {
|
2020-06-19 19:20:35 +03:00
|
|
|
return nil
|
2020-06-16 04:19:15 +03:00
|
|
|
}
|
2020-05-26 02:57:58 +03:00
|
|
|
|
2020-06-16 04:19:15 +03:00
|
|
|
m.YOffset = max(
|
|
|
|
m.YOffset-m.Height, // target
|
|
|
|
0, // fallback
|
|
|
|
)
|
2020-06-19 19:20:35 +03:00
|
|
|
|
|
|
|
return m.visibleLines()
|
2020-05-26 02:57:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// HalfViewDown moves the view down by half the height of the viewport.
|
2020-06-19 20:23:14 +03:00
|
|
|
func (m *Model) HalfViewDown() (lines []string) {
|
2020-06-16 04:19:15 +03:00
|
|
|
if m.AtBottom() {
|
2020-06-19 20:23:14 +03:00
|
|
|
return nil
|
2020-06-16 04:19:15 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
m.YOffset = min(
|
|
|
|
m.YOffset+m.Height/2, // target
|
|
|
|
len(m.lines)-m.Height, // fallback
|
|
|
|
)
|
2020-06-19 20:23:14 +03:00
|
|
|
|
|
|
|
if len(m.lines) > 0 {
|
|
|
|
top := max(m.YOffset+m.Height/2, 0)
|
|
|
|
bottom := min(m.YOffset+m.Height, len(m.lines)-1)
|
|
|
|
lines = m.lines[top:bottom]
|
|
|
|
}
|
|
|
|
|
|
|
|
return lines
|
2020-06-16 04:19:15 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// HalfViewUp moves the view up by half the height of the viewport.
|
2020-06-19 20:23:14 +03:00
|
|
|
func (m *Model) HalfViewUp() (lines []string) {
|
2020-06-16 04:19:15 +03:00
|
|
|
if m.AtTop() {
|
2020-06-19 20:23:14 +03:00
|
|
|
return nil
|
2020-06-16 04:19:15 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
m.YOffset = max(
|
|
|
|
m.YOffset-m.Height/2, // target
|
|
|
|
0, // fallback
|
|
|
|
)
|
2020-06-19 20:23:14 +03:00
|
|
|
|
|
|
|
if len(m.lines) > 0 {
|
|
|
|
top := max(m.YOffset, 0)
|
|
|
|
bottom := min(m.YOffset+m.Height/2, len(m.lines)-1)
|
|
|
|
lines = m.lines[top:bottom]
|
|
|
|
}
|
|
|
|
|
|
|
|
return lines
|
2020-05-26 02:57:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// LineDown moves the view up by the given number of lines.
|
2020-06-19 18:50:54 +03:00
|
|
|
func (m *Model) LineDown(n int) (lines []string) {
|
2020-06-16 04:19:15 +03:00
|
|
|
if m.AtBottom() || n == 0 {
|
2020-06-19 20:23:14 +03:00
|
|
|
return nil
|
2020-06-16 00:50:13 +03:00
|
|
|
}
|
|
|
|
|
2020-06-16 04:19:15 +03:00
|
|
|
m.YOffset = min(
|
|
|
|
m.YOffset+n, // target
|
|
|
|
len(m.lines)-m.Height, // fallback
|
|
|
|
)
|
2020-06-19 18:50:54 +03:00
|
|
|
|
|
|
|
if len(m.lines) > 0 {
|
|
|
|
top := max(0, m.YOffset+m.Height-n)
|
|
|
|
bottom := min(len(m.lines)-1, m.YOffset+m.Height)
|
|
|
|
lines = m.lines[top:bottom]
|
|
|
|
}
|
|
|
|
|
|
|
|
return lines
|
2020-05-26 02:57:58 +03:00
|
|
|
}
|
|
|
|
|
2020-06-19 18:50:54 +03:00
|
|
|
// LineUp moves the view down by the given number of lines. Returns the new
|
|
|
|
// lines to show.
|
|
|
|
func (m *Model) LineUp(n int) (lines []string) {
|
2020-06-16 04:19:15 +03:00
|
|
|
if m.AtTop() || n == 0 {
|
2020-06-19 20:23:14 +03:00
|
|
|
return nil
|
2020-06-16 00:50:13 +03:00
|
|
|
}
|
|
|
|
|
2020-06-18 03:55:49 +03:00
|
|
|
m.YOffset = max(m.YOffset-n, 0)
|
2020-06-19 18:50:54 +03:00
|
|
|
|
|
|
|
if len(m.lines) > 0 {
|
|
|
|
top := max(0, m.YOffset)
|
|
|
|
bottom := min(len(m.lines)-1, m.YOffset+n)
|
|
|
|
lines = m.lines[top:bottom]
|
|
|
|
}
|
|
|
|
|
|
|
|
return lines
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// COMMANDS
|
|
|
|
|
2020-06-20 20:59:13 +03:00
|
|
|
// Sync tells the renderer where the viewport will be located and requests
|
|
|
|
// a render of the current state of the viewport. It should be called for the
|
|
|
|
// first render and after a window resize.
|
|
|
|
//
|
|
|
|
// For high performance rendering only.
|
2020-06-18 03:55:49 +03:00
|
|
|
func Sync(m Model) tea.Cmd {
|
2020-06-20 02:46:51 +03:00
|
|
|
if len(m.lines) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-06-18 23:29:05 +03:00
|
|
|
top := max(m.YOffset, 0)
|
|
|
|
bottom := min(m.YOffset+m.Height, len(m.lines)-1)
|
|
|
|
|
2020-06-18 20:41:23 +03:00
|
|
|
return tea.SyncScrollArea(
|
|
|
|
m.lines[top:bottom],
|
|
|
|
m.YPosition,
|
|
|
|
m.YPosition+m.Height,
|
|
|
|
)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
|
|
|
|
2020-06-20 20:59:13 +03:00
|
|
|
// ViewDown is a high performance command that moves the viewport up by one
|
|
|
|
// viewport height. Use Model.ViewDown to get the lines that should be
|
|
|
|
// rendered. For example:
|
|
|
|
//
|
|
|
|
// lines := model.ViewDown(1)
|
|
|
|
// cmd := ViewDown(m, lines)
|
|
|
|
//
|
2020-06-19 19:20:35 +03:00
|
|
|
func ViewDown(m Model, lines []string) tea.Cmd {
|
|
|
|
if len(lines) == 0 {
|
2020-06-18 03:55:49 +03:00
|
|
|
return nil
|
|
|
|
}
|
2020-06-19 20:23:14 +03:00
|
|
|
return tea.ScrollDown(lines, m.YPosition, m.YPosition+m.Height)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
|
|
|
|
2020-06-20 20:59:13 +03:00
|
|
|
// ViewUp is a high performance command the moves the viewport down by one
|
|
|
|
// viewport height. Use Model.ViewDown to get the lines that should be
|
|
|
|
// rendered.
|
2020-06-19 19:20:35 +03:00
|
|
|
func ViewUp(m Model, lines []string) tea.Cmd {
|
|
|
|
if len(lines) == 0 {
|
2020-06-18 03:55:49 +03:00
|
|
|
return nil
|
2020-06-16 00:50:13 +03:00
|
|
|
}
|
2020-06-19 20:23:14 +03:00
|
|
|
return tea.ScrollUp(lines, m.YPosition, m.YPosition+m.Height)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
|
|
|
|
2020-06-20 20:59:13 +03:00
|
|
|
// HalfViewDown is a high performance command the moves the viewport down by
|
|
|
|
// half of the height of the viewport. Use Model.HalfViewDown to get the lines
|
|
|
|
// that should be rendered.
|
2020-06-19 20:23:14 +03:00
|
|
|
func HalfViewDown(m Model, lines []string) tea.Cmd {
|
|
|
|
if len(lines) == 0 {
|
2020-06-18 03:55:49 +03:00
|
|
|
return nil
|
|
|
|
}
|
2020-06-19 20:23:14 +03:00
|
|
|
return tea.ScrollDown(lines, m.YPosition, m.YPosition+m.Height)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
|
|
|
|
2020-06-20 20:59:13 +03:00
|
|
|
// HalfViewUp is a high performance command the moves the viewport up by
|
|
|
|
// half of the height of the viewport. Use Model.HalfViewUp to get the lines
|
|
|
|
// that should be rendered.
|
2020-06-19 20:23:14 +03:00
|
|
|
func HalfViewUp(m Model, lines []string) tea.Cmd {
|
|
|
|
if len(lines) == 0 {
|
2020-06-18 03:55:49 +03:00
|
|
|
return nil
|
|
|
|
}
|
2020-06-19 20:23:14 +03:00
|
|
|
return tea.ScrollUp(lines, m.YPosition, m.YPosition+m.Height)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
|
|
|
|
2020-06-20 20:59:13 +03:00
|
|
|
// LineDown is a high performance command the moves the viewport down by
|
|
|
|
// a given number of lines. Use Model.LineDown to get the lines that should be
|
|
|
|
// rendered.
|
2020-06-19 18:50:54 +03:00
|
|
|
func LineDown(m Model, lines []string) tea.Cmd {
|
|
|
|
if len(lines) == 0 {
|
2020-06-18 03:55:49 +03:00
|
|
|
return nil
|
|
|
|
}
|
2020-06-19 20:23:14 +03:00
|
|
|
return tea.ScrollDown(lines, m.YPosition, m.YPosition+m.Height)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
|
|
|
|
2020-06-20 20:59:13 +03:00
|
|
|
// LineDown is a high performance command the moves the viewport up by a given
|
|
|
|
// number of lines. Use Model.LineDown to get the lines that should be
|
|
|
|
// rendered.
|
2020-06-19 18:50:54 +03:00
|
|
|
func LineUp(m Model, lines []string) tea.Cmd {
|
|
|
|
if len(lines) == 0 {
|
2020-06-18 03:55:49 +03:00
|
|
|
return nil
|
|
|
|
}
|
2020-06-19 20:23:14 +03:00
|
|
|
return tea.ScrollUp(lines, m.YPosition, m.YPosition+m.Height)
|
2020-05-26 02:57:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// UPDATE
|
|
|
|
|
2020-06-18 23:29:05 +03:00
|
|
|
// Update runs the update loop with default keybindings similar to popular
|
|
|
|
// pagers. To define your own keybindings use the methods on Model (i.e.
|
|
|
|
// Model.LineDown()) and define your own update function.
|
2020-05-26 02:57:58 +03:00
|
|
|
func Update(msg tea.Msg, m Model) (Model, tea.Cmd) {
|
2020-06-18 03:55:49 +03:00
|
|
|
var cmd tea.Cmd
|
|
|
|
|
2020-05-26 02:57:58 +03:00
|
|
|
switch msg := msg.(type) {
|
|
|
|
|
|
|
|
case tea.KeyMsg:
|
|
|
|
switch msg.String() {
|
|
|
|
// Down one page
|
|
|
|
case "pgdown":
|
|
|
|
fallthrough
|
|
|
|
case " ": // spacebar
|
|
|
|
fallthrough
|
|
|
|
case "f":
|
2020-06-19 19:20:35 +03:00
|
|
|
lines := m.ViewDown()
|
2020-06-18 03:55:49 +03:00
|
|
|
if m.HighPerformanceRendering {
|
2020-06-19 19:20:35 +03:00
|
|
|
cmd = ViewDown(m, lines)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
2020-05-26 02:57:58 +03:00
|
|
|
|
|
|
|
// Up one page
|
|
|
|
case "pgup":
|
|
|
|
fallthrough
|
|
|
|
case "b":
|
2020-06-19 19:20:35 +03:00
|
|
|
lines := m.ViewUp()
|
2020-06-18 03:55:49 +03:00
|
|
|
if m.HighPerformanceRendering {
|
2020-06-19 19:20:35 +03:00
|
|
|
cmd = ViewUp(m, lines)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
2020-05-26 02:57:58 +03:00
|
|
|
|
|
|
|
// Down half page
|
|
|
|
case "d":
|
2020-06-19 20:23:14 +03:00
|
|
|
lines := m.HalfViewDown()
|
2020-06-18 03:55:49 +03:00
|
|
|
if m.HighPerformanceRendering {
|
2020-06-19 20:23:14 +03:00
|
|
|
cmd = HalfViewDown(m, lines)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
2020-05-26 02:57:58 +03:00
|
|
|
|
|
|
|
// Up half page
|
|
|
|
case "u":
|
2020-06-19 20:23:14 +03:00
|
|
|
lines := m.HalfViewUp()
|
2020-06-18 03:55:49 +03:00
|
|
|
if m.HighPerformanceRendering {
|
2020-06-19 20:23:14 +03:00
|
|
|
cmd = HalfViewUp(m, lines)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
2020-05-26 02:57:58 +03:00
|
|
|
|
|
|
|
// Down one line
|
|
|
|
case "down":
|
|
|
|
fallthrough
|
|
|
|
case "j":
|
2020-06-19 18:50:54 +03:00
|
|
|
lines := m.LineDown(1)
|
2020-06-18 03:55:49 +03:00
|
|
|
if m.HighPerformanceRendering {
|
2020-06-19 18:50:54 +03:00
|
|
|
cmd = LineDown(m, lines)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
2020-05-26 02:57:58 +03:00
|
|
|
|
|
|
|
// Up one line
|
|
|
|
case "up":
|
|
|
|
fallthrough
|
|
|
|
case "k":
|
2020-06-19 18:50:54 +03:00
|
|
|
lines := m.LineUp(1)
|
2020-06-18 03:55:49 +03:00
|
|
|
if m.HighPerformanceRendering {
|
2020-06-19 18:50:54 +03:00
|
|
|
cmd = LineUp(m, lines)
|
2020-06-18 03:55:49 +03:00
|
|
|
}
|
2020-05-26 02:57:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-18 03:55:49 +03:00
|
|
|
return m, cmd
|
2020-05-26 02:57:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// VIEW
|
|
|
|
|
|
|
|
// View renders the viewport into a string.
|
|
|
|
func View(m Model) string {
|
2020-06-16 00:50:13 +03:00
|
|
|
|
2020-06-18 03:55:49 +03:00
|
|
|
if m.HighPerformanceRendering {
|
2020-06-19 19:20:35 +03:00
|
|
|
// Just send newlines since we're doing to be rendering the actual
|
2020-06-19 18:50:54 +03:00
|
|
|
// content seprately. We still need send something that equals the
|
|
|
|
// height of this view so that the Bubble Tea standard renderer can
|
|
|
|
// position anything below this view properly.
|
2020-06-19 01:31:30 +03:00
|
|
|
return strings.Repeat("\n", m.Height-1)
|
2020-06-16 00:50:13 +03:00
|
|
|
}
|
|
|
|
|
2020-06-19 20:23:14 +03:00
|
|
|
lines := m.visibleLines()
|
2020-05-26 02:57:58 +03:00
|
|
|
|
|
|
|
// Fill empty space with newlines
|
|
|
|
extraLines := ""
|
|
|
|
if len(lines) < m.Height {
|
|
|
|
extraLines = strings.Repeat("\n", m.Height-len(lines))
|
|
|
|
}
|
|
|
|
|
|
|
|
return strings.Join(lines, "\n") + extraLines
|
|
|
|
}
|
|
|
|
|
|
|
|
// ETC
|
|
|
|
|
|
|
|
func min(a, b int) int {
|
|
|
|
if a < b {
|
|
|
|
return a
|
|
|
|
}
|
|
|
|
return b
|
|
|
|
}
|
|
|
|
|
|
|
|
func max(a, b int) int {
|
|
|
|
if a > b {
|
|
|
|
return a
|
|
|
|
}
|
|
|
|
return b
|
|
|
|
}
|
2020-06-16 00:50:13 +03:00
|
|
|
|
|
|
|
func clamp(val, low, high int) int {
|
|
|
|
return max(low, min(high, val))
|
|
|
|
}
|