go r.listen()

// Stop the renderer before acquiring the mutex to avoid a deadlock.

r.once.Do(func() {

r.done <- struct{}{}

})

// flush locks the mutex

r.flush()

r.mtx.Lock()

defer r.mtx.Unlock()

r.out.ClearLine()

if r.useANSICompressor {

if w, ok := r.out.TTY().(io.WriteCloser); ok {

_ = w.Close()

}

}

// Stop the renderer before acquiring the mutex to avoid a deadlock.

r.once.Do(func() {

r.done <- struct{}{}

})

r.mtx.Lock()

defer r.mtx.Unlock()

r.out.ClearLine()

for {

select {

case <-r.done:

r.ticker.Stop()

return

case <-r.ticker.C:

r.flush()

}

}

r.mtx.Lock()

defer r.mtx.Unlock()

if r.buf.Len() == 0 || r.buf.String() == r.lastRender {

// Nothing to do

return

}

// Output buffer

buf := &bytes.Buffer{}

out := termenv.NewOutput(buf)

newLines := strings.Split(r.buf.String(), "\n")

// If we know the output's height, we can use it to determine how many

// lines we can render. We drop lines from the top of the render buffer if

// necessary, as we can't navigate the cursor into the terminal's scrollback

// buffer.

if r.height > 0 && len(newLines) > r.height {

newLines = newLines[len(newLines)-r.height:]

}

numLinesThisFlush := len(newLines)

oldLines := strings.Split(r.lastRender, "\n")

skipLines := make(map[int]struct{})

flushQueuedMessages := len(r.queuedMessageLines) > 0 && !r.altScreenActive

// Clear any lines we painted in the last render.

if r.linesRendered > 0 {

for i := r.linesRendered - 1; i > 0; i-- {

// if we are clearing queued messages, we want to clear all lines, since

// printing messages allows for native terminal word-wrap, we

// don't have control over the queued lines

if flushQueuedMessages {

out.ClearLine()

} else if (len(newLines) <= len(oldLines)) && (len(newLines) > i && len(oldLines) > i) && (newLines[i] == oldLines[i]) {

// If the number of lines we want to render hasn't increased and

// new line is the same as the old line we can skip rendering for

// this line as a performance optimization.

skipLines[i] = struct{}{}

} else if _, exists := r.ignoreLines[i]; !exists {

out.ClearLine()

}

out.CursorUp(1)

}

if _, exists := r.ignoreLines[0]; !exists {

// We need to return to the start of the line here to properly

// erase it. Going back the entire width of the terminal will

// usually be farther than we need to go, but terminal emulators

// will stop the cursor at the start of the line as a rule.

//

// We use this sequence in particular because it's part of the ANSI

// standard (whereas others are proprietary to, say, VT100/VT52).

// If cursor previous line (ESC[ + <n> + F) were better supported

// we could use that above to eliminate this step.

out.CursorBack(r.width)

out.ClearLine()

}

}

// Merge the set of lines we're skipping as a rendering optimization with

// the set of lines we've explicitly asked the renderer to ignore.

for k, v := range r.ignoreLines {

skipLines[k] = v

}

if flushQueuedMessages {

// Dump the lines we've queued up for printing

for _, line := range r.queuedMessageLines {

_, _ = out.WriteString(line)

_, _ = out.WriteString("\r\n")

}

// clear the queued message lines

r.queuedMessageLines = []string{}

}

// Paint new lines

for i := 0; i < len(newLines); i++ {

if _, skip := skipLines[i]; skip {

// Unless this is the last line, move the cursor down.

if i < len(newLines)-1 {

out.CursorDown(1)

}

} else {

line := newLines[i]

// Truncate lines wider than the width of the window to avoid

// wrapping, which will mess up rendering. If we don't have the

// width of the window this will be ignored.

//

// Note that on Windows we only get the width of the window on

// program initialization, so after a resize this won't perform

// correctly (signal SIGWINCH is not supported on Windows).

if r.width > 0 {

line = truncate.String(line, uint(r.width))

}

_, _ = out.WriteString(line)

if i < len(newLines)-1 {

_, _ = out.WriteString("\r\n")

}

}

}

r.linesRendered = numLinesThisFlush

// Make sure the cursor is at the start of the last line to keep rendering

// behavior consistent.

if r.altScreenActive {

// This case fixes a bug in macOS terminal. In other terminals the

// other case seems to do the job regardless of whether or not we're

// using the full terminal window.

out.MoveCursor(r.linesRendered, 0)

} else {

out.CursorBack(r.width)

}

_, _ = r.out.Write(buf.Bytes())

r.lastRender = r.buf.String()

r.buf.Reset()

r.mtx.Lock()

defer r.mtx.Unlock()

r.buf.Reset()

// 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 s == "" {

s = " "

}

_, _ = r.buf.WriteString(s)

r.mtx.Lock()

defer r.mtx.Unlock()

r.out.ClearScreen()

r.out.MoveCursor(1, 1)

r.repaint()

r.mtx.Lock()

defer r.mtx.Unlock()

return r.altScreenActive

r.mtx.Lock()

defer r.mtx.Unlock()

if r.altScreenActive {

return

}

r.altScreenActive = true

r.out.AltScreen()

// Ensure that the terminal is cleared, even when it doesn't support

// alt screen (or alt screen support is disabled, like GNU screen by

// default).

//

// Note: we can't use r.clearScreen() here because the mutex is already

// locked.

r.out.ClearScreen()

r.out.MoveCursor(1, 1)

// cmd.exe and other terminals keep separate cursor states for the AltScreen

// and the main buffer. We have to explicitly reset the cursor visibility

// whenever we enter AltScreen.

if r.cursorHidden {

r.out.HideCursor()

} else {

r.out.ShowCursor()

}

r.repaint()

r.mtx.Lock()

defer r.mtx.Unlock()

if !r.altScreenActive {

return

}

r.altScreenActive = false

r.out.ExitAltScreen()

// cmd.exe and other terminals keep separate cursor states for the AltScreen

// and the main buffer. We have to explicitly reset the cursor visibility

// whenever we exit AltScreen.

if r.cursorHidden {

r.out.HideCursor()

} else {

r.out.ShowCursor()

}

r.repaint()

r.mtx.Lock()

defer r.mtx.Unlock()

r.cursorHidden = false

r.out.ShowCursor()

r.mtx.Lock()

defer r.mtx.Unlock()

r.cursorHidden = true

r.out.HideCursor()

r.mtx.Lock()

defer r.mtx.Unlock()

r.out.EnableMouseCellMotion()

r.mtx.Lock()

defer r.mtx.Unlock()

r.out.DisableMouseCellMotion()

r.mtx.Lock()

defer r.mtx.Unlock()

r.out.EnableMouseAllMotion()

r.mtx.Lock()

defer r.mtx.Unlock()

r.out.DisableMouseAllMotion()

r.mtx.Lock()

defer r.mtx.Unlock()

r.out.EnableMouseExtendedMode()

r.mtx.Lock()

defer r.mtx.Unlock()

r.out.DisableMouseExtendedMode()

r.mtx.Lock()

defer r.mtx.Unlock()

r.out.EnableBracketedPaste()

r.bpActive = true

r.mtx.Lock()

defer r.mtx.Unlock()

r.out.DisableBracketedPaste()

r.bpActive = false

r.mtx.Lock()

defer r.mtx.Unlock()

return r.bpActive

// Lock if we're going to be clearing some lines since we don't want

// anything jacking our cursor.

if r.linesRendered > 0 {

r.mtx.Lock()

defer r.mtx.Unlock()

}

if r.ignoreLines == nil {

r.ignoreLines = make(map[int]struct{})

}

for i := from; i < to; i++ {

r.ignoreLines[i] = struct{}{}

}

// Erase ignored lines

if r.linesRendered > 0 {

buf := &bytes.Buffer{}

out := termenv.NewOutput(buf)

for i := r.linesRendered - 1; i >= 0; i-- {

if _, exists := r.ignoreLines[i]; exists {

out.ClearLine()

}

out.CursorUp(1)

}

out.MoveCursor(r.linesRendered, 0) // put cursor back

_, _ = r.out.Write(buf.Bytes())

}

r.mtx.Lock()

defer r.mtx.Unlock()

buf := &bytes.Buffer{}

out := termenv.NewOutput(buf)

out.ChangeScrollingRegion(topBoundary, bottomBoundary)

out.MoveCursor(topBoundary, 0)

out.InsertLines(len(lines))

_, _ = out.WriteString(strings.Join(lines, "\r\n"))

out.ChangeScrollingRegion(0, r.height)

// Move cursor back to where the main rendering routine expects it to be

out.MoveCursor(r.linesRendered, 0)

_, _ = r.out.Write(buf.Bytes())

r.mtx.Lock()

defer r.mtx.Unlock()

buf := &bytes.Buffer{}

out := termenv.NewOutput(buf)

out.ChangeScrollingRegion(topBoundary, bottomBoundary)

out.MoveCursor(bottomBoundary, 0)

_, _ = out.WriteString("\r\n" + strings.Join(lines, "\r\n"))

out.ChangeScrollingRegion(0, r.height)

// Move cursor back to where the main rendering routine expects it to be

out.MoveCursor(r.linesRendered, 0)

_, _ = r.out.Write(buf.Bytes())

switch msg := msg.(type) {

case repaintMsg:

// Force a repaint by clearing the render cache as we slide into a

// render.

r.mtx.Lock()

r.repaint()

r.mtx.Unlock()

case WindowSizeMsg:

r.mtx.Lock()

r.width = msg.Width

r.height = msg.Height

r.repaint()

r.mtx.Unlock()

case clearScrollAreaMsg:

r.clearIgnoredLines()

// Force a repaint on the area where the scrollable stuff was in this

// update cycle

r.mtx.Lock()

r.repaint()

r.mtx.Unlock()

case syncScrollAreaMsg:

// Re-render scrolling area

r.clearIgnoredLines()

r.setIgnoredLines(msg.topBoundary, msg.bottomBoundary)

r.insertTop(msg.lines, msg.topBoundary, msg.bottomBoundary)

// Force non-scrolling stuff to repaint in this update cycle

r.mtx.Lock()

r.repaint()

r.mtx.Unlock()

case scrollUpMsg:

r.insertTop(msg.lines, msg.topBoundary, msg.bottomBoundary)

case scrollDownMsg:

r.insertBottom(msg.lines, msg.topBoundary, msg.bottomBoundary)

case printLineMessage:

if !r.altScreenActive {

lines := strings.Split(msg.messageBody, "\n")

r.mtx.Lock()

r.queuedMessageLines = append(r.queuedMessageLines, lines...)

r.repaint()

r.mtx.Unlock()

}

}

lines []string

topBoundary int

bottomBoundary int

return func() Msg {

return syncScrollAreaMsg{

lines: lines,

topBoundary: topBoundary,

bottomBoundary: bottomBoundary,

}

}

lines []string

topBoundary int

bottomBoundary int

return func() Msg {

return scrollUpMsg{

lines: newLines,

topBoundary: topBoundary,

bottomBoundary: bottomBoundary,

}

}

lines []string

topBoundary int

bottomBoundary int

return func() Msg {

return scrollDownMsg{

lines: newLines,

topBoundary: topBoundary,

bottomBoundary: bottomBoundary,

}

}

return func() Msg {

return printLineMessage{

messageBody: fmt.Sprint(args...),

}

}

return func() Msg {

return printLineMessage{

messageBody: fmt.Sprintf(template, args...),

}

}