From 68ec6c7ffca1c7011fa6bb22bc63ab3fad921e8a Mon Sep 17 00:00:00 2001 From: Christian Rocha Date: Mon, 15 Jun 2020 21:19:15 -0400 Subject: [PATCH] Integrate viewport navigation controls with new renderer --- viewport/renderer.go | 20 ++++---- viewport/viewport.go | 108 +++++++++++++++++++++++++++++++++++-------- 2 files changed, 99 insertions(+), 29 deletions(-) diff --git a/viewport/renderer.go b/viewport/renderer.go index 2299f5e..610d846 100644 --- a/viewport/renderer.go +++ b/viewport/renderer.go @@ -30,37 +30,37 @@ func (r *renderer) clear() { func (r *renderer) sync(lines []string) { r.clear() moveTo(r.Out, r.Y, 0) - r.write(lines) + r.writeLines(lines) } // write writes to the set writer. -func (r *renderer) write(lines []string) { +func (r *renderer) writeLines(lines []string) { if len(lines) == 0 { return } io.WriteString(r.Out, strings.Join(lines, "\r\n")) } -// Effectively scroll up. That is, insert a line at the top, scrolling +// Effectively scroll up. That is, insert a line at the top, pushing // everything else down. This is roughly how ncurses does it. -func (r *renderer) insertTop(line string) { +func (r *renderer) insertTop(lines []string) { changeScrollingRegion(r.Out, r.Y, r.Y+r.Height) moveTo(r.Out, r.Y, 0) - insertLine(r.Out, 1) - io.WriteString(r.Out, line) + insertLine(r.Out, len(lines)) + r.writeLines(lines) changeScrollingRegion(r.Out, r.TerminalWidth, r.TerminalHeight) } -// Effectively scroll down. That is, insert a line at the bottom, scrolling +// Effectively scroll down. That is, insert a line at the bottom, pushing // everything else up. This is roughly how ncurses does it. -func (r *renderer) insertBottom(line string) { +func (r *renderer) insertBottom(lines []string) { changeScrollingRegion(r.Out, r.Y, r.Y+r.Height) moveTo(r.Out, r.Y+r.Height, 0) - io.WriteString(r.Out, "\n"+line) + io.WriteString(r.Out, "\r\n"+strings.Join(lines, "\r\n")) changeScrollingRegion(r.Out, r.TerminalWidth, r.TerminalHeight) } -// Screen command +// Terminal Control const csi = "\x1b[" diff --git a/viewport/viewport.go b/viewport/viewport.go index 9f80510..d69a296 100644 --- a/viewport/viewport.go +++ b/viewport/viewport.go @@ -45,6 +45,16 @@ func NewModel(yPos, width, height, terminalWidth, terminalHeight int) Model { } } +// 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 +} + // Scrollpercent returns the amount scrolled as a float between 0 and 1. func (m Model) ScrollPercent() float64 { if m.Height >= len(m.lines) { @@ -61,53 +71,117 @@ func (m *Model) SetContent(s string) { s = strings.Replace(s, "\r\n", "\n", -1) // normalize line endings m.lines = strings.Split(s, "\n") - lines := bounded(m.lines, m.YOffset, m.Height) - m.r.sync(lines) + if m.UseInternalRenderer { + top := max(m.YOffset, 0) + bottom := min(m.YOffset+m.Height, len(m.lines)) + m.r.sync(m.lines[top:bottom]) + } } // ViewDown moves the view down by the number of lines in the viewport. // Basically, "page down". func (m *Model) ViewDown() { - m.YOffset = min(len(m.lines)-m.Height, m.YOffset+m.Height) + if m.AtBottom() { + return + } + + if m.UseInternalRenderer { + top := max(m.YOffset+m.Height, 0) + bottom := min(top+m.Height, len(m.lines)-1) + m.r.insertBottom(m.lines[top:bottom]) + } + + m.YOffset = min( + m.YOffset+m.Height, // target + len(m.lines)-m.Height, // fallback + ) } // ViewUp moves the view up by one height of the viewport. Basically, "page up". func (m *Model) ViewUp() { - m.YOffset = max(0, m.YOffset-m.Height) -} + if m.AtTop() { + return + } -// HalfViewUp moves the view up by half the height of the viewport. -func (m *Model) HalfViewUp() { - m.YOffset = max(0, m.YOffset-m.Height/2) + if m.UseInternalRenderer { + top := max(m.YOffset-m.Height, 0) + bottom := min(m.YOffset, len(m.lines)) + m.r.insertTop(m.lines[top:bottom]) + } + + m.YOffset = max( + m.YOffset-m.Height, // target + 0, // fallback + ) } // HalfViewDown moves the view down by half the height of the viewport. func (m *Model) HalfViewDown() { - m.YOffset = min(len(m.lines)-m.Height, m.YOffset+m.Height/2) + if m.AtBottom() { + return + } + + if m.UseInternalRenderer { + top := max(m.YOffset+m.Height/2, 0) + bottom := min(top+m.Height, len(m.lines)-1) + m.r.insertBottom(m.lines[top:bottom]) + } + + m.YOffset = min( + m.YOffset+m.Height/2, // target + len(m.lines)-m.Height, // fallback + ) +} + +// HalfViewUp moves the view up by half the height of the viewport. +func (m *Model) HalfViewUp() { + if m.AtTop() { + return + } + + if m.UseInternalRenderer { + top := max(m.YOffset-m.Height/2, 0) + bottom := clamp(m.YOffset, top, len(m.lines)) + m.r.insertTop(m.lines[top:bottom]) + } + + m.YOffset = max( + m.YOffset-m.Height/2, // target + 0, // fallback + ) } // LineDown moves the view up by the given number of lines. func (m *Model) LineDown(n int) { - if m.YOffset >= len(m.lines)-m.Height-1 { + if m.AtBottom() || n == 0 { return } - m.YOffset = min(len(m.lines)-m.Height, m.YOffset+n) if m.UseInternalRenderer { - m.r.insertBottom(m.lines[m.YOffset+m.Height-1]) + bottom := min(m.YOffset+m.Height+n, len(m.lines)) + top := max(bottom-n, 0) + m.r.insertBottom(m.lines[top:bottom]) } + + m.YOffset = min( + m.YOffset+n, // target + len(m.lines)-m.Height, // fallback + ) } // LineUp moves the view down by the given number of lines. func (m *Model) LineUp(n int) { - if m.YOffset == 0 { + if m.AtTop() || n == 0 { return } - m.YOffset = max(0, m.YOffset-n) if m.UseInternalRenderer { - m.r.insertTop(m.lines[m.YOffset]) + top := max(m.YOffset-n, 0) + bottom := min(top+n, len(m.lines)) + m.r.insertTop(m.lines[top:bottom]) } + + m.YOffset = max(m.YOffset-n, 0) } // UPDATE @@ -214,7 +288,3 @@ func max(a, b int) int { func clamp(val, low, high int) int { return max(low, min(high, val)) } - -func bounded(s []string, start, end int) []string { - return s[clamp(start, 0, len(s)):clamp(end, 0, len(s))] -}