/
pager.go
474 lines (388 loc) · 12.6 KB
/
pager.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
package m
import (
"fmt"
"regexp"
"strings"
"time"
"github.com/alecthomas/chroma/v2"
log "github.com/sirupsen/logrus"
"github.com/walles/moar/m/linenumbers"
"github.com/walles/moar/m/textstyles"
"github.com/walles/moar/twin"
)
type PagerMode interface {
onKey(key twin.KeyCode)
onRune(char rune)
drawFooter(statusText string, spinner string)
}
type StatusBarOption int
const (
//revive:disable-next-line:var-naming
STATUSBAR_STYLE_INVERSE StatusBarOption = iota
//revive:disable-next-line:var-naming
STATUSBAR_STYLE_PLAIN
//revive:disable-next-line:var-naming
STATUSBAR_STYLE_BOLD
)
type eventSpinnerUpdate struct {
spinner string
}
type eventMoreLinesAvailable struct{}
// Either reading, highlighting or both are done. Check reader.Done() and
// reader.HighlightingDone() for details.
type eventMaybeDone struct{}
// Pager is the main on-screen pager
type Pager struct {
reader *Reader
screen twin.Screen
quit bool
scrollPosition scrollPosition
leftColumnZeroBased int
// Maybe this should be renamed to "controller"? Because it controls the UI?
// But since we replace it in a lot of places based on the UI mode, maybe
// mode is better?
mode PagerMode
searchString string
searchPattern *regexp.Regexp
// We used to have a "Following" field here. If you want to follow, set
// TargetLineNumber to LineNumberMax() instead, see below.
isShowingHelp bool
preHelpState *_PreHelpState
// NewPager shows lines by default, this field can hide them
ShowLineNumbers bool
StatusBarStyle StatusBarOption
ShowStatusBar bool
UnprintableStyle textstyles.UnprintableStyleT
WrapLongLines bool
// Ref: https://github.com/walles/moar/issues/113
QuitIfOneScreen bool
// Ref: https://github.com/walles/moar/issues/94
ScrollLeftHint twin.Cell
ScrollRightHint twin.Cell
SideScrollAmount int // Should be positive
// If non-nil, scroll to this line number as soon as possible. Set this
// value to LineNumberMax() to follow the end of the input (tail).
TargetLineNumber *linenumbers.LineNumber
// If true, pager will clear the screen on return. If false, pager will
// clear the last line, and show the cursor.
DeInit bool
// Optional ANSI to prefix each text line with. Initialised using
// ChromaStyle and ChromaFormatter. Used for coloring unstyled text lines
// based on the Chroma style.
linePrefix string
// Length of the longest line displayed. This is used for limiting scrolling to the right.
longestLineLength int
// Bookmarks that you can come back to.
//
// Ref: https://github.com/walles/moar/issues/175
marks map[rune]scrollPosition
}
type _PreHelpState struct {
reader *Reader
scrollPosition scrollPosition
leftColumnZeroBased int
targetLineNumber *linenumbers.LineNumber
}
const _EofMarkerFormat = "\x1b[7m" // Reverse video
var _HelpReader = NewReaderFromText("Help", `
Welcome to Moar, the nice pager!
Miscellaneous
-------------
* Press 'q' or 'ESC' to quit
* Press 'w' to toggle wrapping of long lines
* Press '=' to toggle showing the status bar at the bottom
Moving around
-------------
* Arrow keys
* Alt key plus left / right arrow steps one column at a time
* Left / right can be used to hide / show line numbers
* Home and End for start / end of the document
* 'g' for going to a specific line number
* 'm' sets a mark, you will be asked for a letter to label it with
* ' (single quote) jumps to the mark
* CTRL-p moves to the previous line
* CTRL-n moves to the next line
* PageUp / 'b' and PageDown / 'f'
* SPACE moves down a page
* < / 'gg' to go to the start of the document
* > / 'G' to go to the end of the document
* 'h', 'l' for left and right (as in vim)
* Half page 'u'p / 'd'own, or CTRL-u / CTRL-d
* RETURN moves down one line
Searching
---------
* Type / to start searching, then type what you want to find
* Type RETURN to stop searching
* Find next by typing 'n' (for "next")
* Find previous by typing SHIFT-N or 'p' (for "previous")
* Search is case sensitive if it contains any UPPER CASE CHARACTERS
* Search is interpreted as a regexp if it is a valid one
Reporting bugs
--------------
File issues at https://github.com/walles/moar/issues, or post
questions to johan.walles@gmail.com.
Installing Moar as your default pager
-------------------------------------
Put the following line in your ~/.bashrc, ~/.bash_profile or ~/.zshrc:
export PAGER=moar
Source Code
-----------
Available at https://github.com/walles/moar/.
`)
// NewPager creates a new Pager with default settings
func NewPager(r *Reader) *Pager {
var name string
if r == nil || r.name == nil || len(*r.name) == 0 {
name = "Pager"
} else {
name = "Pager " + *r.name
}
pager := Pager{
reader: r,
quit: false,
ShowLineNumbers: true,
ShowStatusBar: true,
DeInit: true,
SideScrollAmount: 16,
ScrollLeftHint: twin.NewCell('<', twin.StyleDefault.WithAttr(twin.AttrReverse)),
ScrollRightHint: twin.NewCell('>', twin.StyleDefault.WithAttr(twin.AttrReverse)),
scrollPosition: newScrollPosition(name),
}
pager.mode = PagerModeViewing{pager: &pager}
return &pager
}
// How many lines are visible on screen? Depends on screen height and whether or
// not the status bar is visible.
func (p *Pager) visibleHeight() int {
_, height := p.screen.Size()
if p.ShowStatusBar {
return height - 1
}
return height
}
// Draw the footer string at the bottom using the status bar style
func (p *Pager) setFooter(footer string) {
width, height := p.screen.Size()
pos := 0
for _, token := range footer {
p.screen.SetCell(pos, height-1, twin.NewCell(token, statusbarStyle))
pos++
}
for ; pos < width; pos++ {
p.screen.SetCell(pos, height-1, twin.NewCell(' ', statusbarStyle))
}
}
// Quit leaves the help screen or quits the pager
func (p *Pager) Quit() {
if !p.isShowingHelp {
p.quit = true
return
}
// Reset help
p.isShowingHelp = false
p.reader = p.preHelpState.reader
p.scrollPosition = p.preHelpState.scrollPosition
p.leftColumnZeroBased = p.preHelpState.leftColumnZeroBased
p.TargetLineNumber = p.preHelpState.targetLineNumber
p.preHelpState = nil
}
// Negative deltas move left instead
func (p *Pager) moveRight(delta int) {
if p.ShowLineNumbers && delta > 0 {
p.ShowLineNumbers = false
return
}
if p.leftColumnZeroBased == 0 && delta < 0 {
p.ShowLineNumbers = true
return
}
result := p.leftColumnZeroBased + delta
if result < 0 {
p.leftColumnZeroBased = 0
} else {
p.leftColumnZeroBased = result
}
// If we try to move past the characters when moving right, stop scrolling to
// avoid moving infinitely into the void.
if p.leftColumnZeroBased > p.longestLineLength {
p.leftColumnZeroBased = p.longestLineLength
}
}
func (p *Pager) handleScrolledUp() {
p.TargetLineNumber = nil
}
func (p *Pager) handleScrolledDown() {
if p.isScrolledToEnd() {
reallyHigh := linenumbers.LineNumberMax()
p.TargetLineNumber = &reallyHigh
} else {
p.TargetLineNumber = &linenumbers.LineNumber{}
}
}
// Return an ANSI SGR sequence to use for plain text. Can be "".
func getLineColorPrefix(chromaStyle *chroma.Style, chromaFormatter *chroma.Formatter) string {
if chromaStyle == nil && chromaFormatter == nil {
return ""
}
if chromaStyle == nil || chromaFormatter == nil {
panic("Both ChromaStyle and ChromaFormatter should be set or neither")
}
stringBuilder := strings.Builder{}
err := (*chromaFormatter).Format(&stringBuilder, chromaStyle, chroma.Literator(chroma.Token{
Type: chroma.None,
Value: "XXX",
}))
if err != nil {
panic(err)
}
formatted := stringBuilder.String()
cutoff := strings.Index(formatted, "XXX")
if cutoff < 0 {
panic("XXX not found in " + formatted)
}
return formatted[:cutoff]
}
// StartPaging brings up the pager on screen
func (p *Pager) StartPaging(screen twin.Screen, chromaStyle *chroma.Style, chromaFormatter *chroma.Formatter) {
log.Trace("Pager starting")
defer log.Trace("Pager done")
defer func() {
if p.reader.err != nil {
log.Warnf("Reader reported an error: %s", p.reader.err.Error())
}
}()
textstyles.UnprintableStyle = p.UnprintableStyle
consumeLessTermcapEnvs(chromaStyle, chromaFormatter)
styleUI(chromaStyle, chromaFormatter, p.StatusBarStyle)
p.screen = screen
p.linePrefix = getLineColorPrefix(chromaStyle, chromaFormatter)
p.mode = PagerModeViewing{pager: p}
p.marks = make(map[rune]scrollPosition)
go func() {
for range p.reader.moreLinesAdded {
// Notify the main loop about the new lines so it can show them
screen.Events() <- eventMoreLinesAvailable{}
// Delay updates a bit so that we don't waste time refreshing
// the screen too often.
//
// Note that the delay is *after* reacting, this way single-line
// updates are reacted to immediately, and the first output line
// read will appear on screen without delay.
time.Sleep(200 * time.Millisecond)
}
}()
go func() {
// Spin the spinner as long as contents is still loading
spinnerFrames := [...]string{"/.\\", "-o-", "\\O/", "| |"}
spinnerIndex := 0
for {
if p.reader.done.Load() {
break
}
screen.Events() <- eventSpinnerUpdate{spinnerFrames[spinnerIndex]}
spinnerIndex++
if spinnerIndex >= len(spinnerFrames) {
spinnerIndex = 0
}
time.Sleep(200 * time.Millisecond)
}
// Empty our spinner, loading done!
screen.Events() <- eventSpinnerUpdate{""}
}()
go func() {
for range p.reader.maybeDone {
screen.Events() <- eventMaybeDone{}
}
}()
// Main loop
spinner := ""
for !p.quit {
if len(screen.Events()) == 0 {
// Nothing more to process for now, redraw the screen
overflow := p.redraw(spinner)
// Ref:
// https://github.com/gwsw/less/blob/ff8869aa0485f7188d942723c9fb50afb1892e62/command.c#L828-L831
if p.QuitIfOneScreen && overflow == didFit && !p.isShowingHelp {
// Do the slow (atomic) checks only if the fast ones (no locking
// required) passed
if p.reader.done.Load() && p.reader.highlightingDone.Load() {
// Ref:
// https://github.com/walles/moar/issues/113#issuecomment-1368294132
p.ShowLineNumbers = false // Requires a redraw to take effect, see below
p.DeInit = false
p.quit = true
// Without this the line numbers setting ^ won't take effect
p.redraw(spinner)
break
}
}
}
event := <-screen.Events()
switch event := event.(type) {
case twin.EventKeyCode:
log.Tracef("Handling key event %d...", event.KeyCode())
p.mode.onKey(event.KeyCode())
case twin.EventRune:
log.Tracef("Handling rune event '%c'/0x%04x...", event.Rune(), event.Rune())
p.mode.onRune(event.Rune())
case twin.EventMouse:
log.Tracef("Handling mouse event %d...", event.Buttons())
switch event.Buttons() {
case twin.MouseWheelUp:
// Clipping is done in _Redraw()
p.scrollPosition = p.scrollPosition.PreviousLine(1)
case twin.MouseWheelDown:
// Clipping is done in _Redraw()
p.scrollPosition = p.scrollPosition.NextLine(1)
case twin.MouseWheelLeft:
p.moveRight(-p.SideScrollAmount)
case twin.MouseWheelRight:
p.moveRight(p.SideScrollAmount)
}
case twin.EventResize:
// We'll be implicitly redrawn just by taking another lap in the loop
case twin.EventExit:
log.Debug("Got a Twin exit event, exiting")
return
case eventMoreLinesAvailable:
if p.TargetLineNumber != nil {
// The user wants to scroll down to a specific line number
if linenumbers.LineNumberFromLength(p.reader.GetLineCount()).IsBefore(*p.TargetLineNumber) {
// Not there yet, keep scrolling
p.scrollToEnd()
} else {
// We see the target, scroll to it
p.scrollPosition = NewScrollPositionFromLineNumber(*p.TargetLineNumber, "goToTargetLineNumber")
p.TargetLineNumber = nil
}
}
case eventMaybeDone:
// Do nothing. We got this just so that we'll do the QuitIfOneScreen
// check (above) as soon as highlighting is done.
case eventSpinnerUpdate:
spinner = event.spinner
case twin.EventTerminalBackgroundDetected:
// Do nothing, we don't care about background color updates
default:
log.Warnf("Unhandled event type: %v", event)
}
}
}
// After the pager has exited and the normal screen has been restored, you can
// call this method to print the pager contents to screen again, faking
// "leaving" pager contents on screen after exit.
func (p *Pager) ReprintAfterExit() error {
// Figure out how many screen lines are used by pager contents
renderedScreenLines, _, _ := p.renderScreenLines()
screenLinesCount := len(renderedScreenLines)
_, screenHeight := p.screen.Size()
screenHeightWithoutFooter := screenHeight - 1
if screenLinesCount > screenHeightWithoutFooter {
screenLinesCount = screenHeightWithoutFooter
}
if screenLinesCount > 0 {
p.screen.ShowNLines(screenLinesCount)
}
fmt.Println()
return nil
}