v0.1.0 initial commit
This commit is contained in:
@@ -0,0 +1,670 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/lixenwraith/color"
|
||||
"github.com/lixenwraith/terminal"
|
||||
"github.com/lixenwraith/terminal/tui"
|
||||
"github.com/lixenwraith/vif-log/internal/keys"
|
||||
"github.com/lixenwraith/vif-log/internal/logfile"
|
||||
"github.com/lixenwraith/vif-log/internal/ui"
|
||||
)
|
||||
|
||||
// paneOrder fixes render order. The list sizes itself first so the status bar
|
||||
// reads that height in the same frame.
|
||||
var paneOrder = []ui.Pane{
|
||||
ui.PaneList, ui.PaneDetail, ui.PaneHeader, ui.PaneStatus, ui.PaneFooter,
|
||||
}
|
||||
|
||||
// renderers binds panes to draw functions; layout decides where they land.
|
||||
var renderers = map[ui.Pane]func(*App, tui.Region){
|
||||
ui.PaneHeader: (*App).renderHeader,
|
||||
ui.PaneList: (*App).renderList,
|
||||
ui.PaneDetail: (*App).renderDetail,
|
||||
ui.PaneStatus: (*App).renderStatus,
|
||||
ui.PaneFooter: (*App).renderFooter,
|
||||
}
|
||||
|
||||
// Render draws one frame.
|
||||
func (a *App) Render() {
|
||||
w, h := a.w, a.h
|
||||
if w < 4 || h < 2 {
|
||||
return
|
||||
}
|
||||
if len(a.cells) != w*h {
|
||||
a.cells = make([]terminal.Cell, w*h)
|
||||
}
|
||||
blank := terminal.Cell{Rune: ' ', Fg: a.th.Fg, Bg: a.th.Bg}
|
||||
for i := range a.cells {
|
||||
a.cells[i] = blank
|
||||
}
|
||||
cells := a.cells
|
||||
root := tui.NewRegion(cells, w, 0, 0, w, h)
|
||||
|
||||
if w < minW || h < minH {
|
||||
a.renderTooSmall(root)
|
||||
a.term.Flush(cells, w, h)
|
||||
return
|
||||
}
|
||||
|
||||
regions := a.lay.Resolve(root)
|
||||
for _, pane := range paneOrder {
|
||||
if fn, region := renderers[pane], regions[pane]; fn != nil && region.W > 0 {
|
||||
fn(a, region)
|
||||
}
|
||||
}
|
||||
|
||||
switch a.overlay {
|
||||
case ovPrompt:
|
||||
a.renderPrompt(regions[ui.PaneFooter])
|
||||
case ovHelp:
|
||||
a.renderHelp(root)
|
||||
case ovOpen:
|
||||
a.renderBrowser(root)
|
||||
}
|
||||
if a.toast.Visible {
|
||||
root.Toast(a.toast.Opts)
|
||||
}
|
||||
a.term.Flush(cells, w, h)
|
||||
}
|
||||
|
||||
// renderTooSmall reports the shortfall rather than degrading the layout.
|
||||
func (a *App) renderTooSmall(r tui.Region) {
|
||||
r.Fill(a.th.Bg)
|
||||
y := r.H / 2
|
||||
r.TextCenter(y-1, "terminal too small", a.th.Warning, a.th.Bg, terminal.AttrBold)
|
||||
r.TextCenter(y+1, fmt.Sprintf("%dx%d - need %dx%d", a.w, a.h, minW, minH),
|
||||
a.th.HintFg, a.th.Bg, terminal.AttrNone)
|
||||
r.TextCenter(y+3, "q quits", a.th.HintFg, a.th.Bg, terminal.AttrDim)
|
||||
}
|
||||
|
||||
// --- bars ------------------------------------------------------------------
|
||||
|
||||
// pair is a label/value cell in the header and status bars.
|
||||
type pair struct {
|
||||
label, value string
|
||||
fg color.RGB
|
||||
}
|
||||
|
||||
const pairSep = " · "
|
||||
const pairSepW = 3 // runes; len(pairSep) is 4 bytes
|
||||
|
||||
// drawPairsRight renders pairs right-aligned, dropping leading pairs that do
|
||||
// not fit. Returns the x where drawing started, so the caller can clip its own
|
||||
// left-aligned content. Unlike tui.StatusBar this does not clear the row.
|
||||
func (a *App) drawPairsRight(r tui.Region, y int, ps []pair, bg color.RGB) int {
|
||||
width := func(p pair) int { return tui.RuneLen(p.label) + 1 + tui.RuneLen(p.value) }
|
||||
|
||||
total := 0
|
||||
for i, p := range ps {
|
||||
total += width(p)
|
||||
if i > 0 {
|
||||
total += pairSepW
|
||||
}
|
||||
}
|
||||
for len(ps) > 1 && total > r.W-2 {
|
||||
total -= width(ps[0]) + pairSepW
|
||||
ps = ps[1:]
|
||||
}
|
||||
|
||||
x := max(0, r.W-total-1)
|
||||
start := x
|
||||
for i, p := range ps {
|
||||
if i > 0 {
|
||||
r.Text(x, y, pairSep, a.th.HintFg, bg, terminal.AttrDim)
|
||||
x += pairSepW
|
||||
}
|
||||
r.Text(x, y, p.label, a.th.HintFg, bg, terminal.AttrNone)
|
||||
x += tui.RuneLen(p.label) + 1
|
||||
r.Text(x, y, p.value, p.fg, bg, terminal.AttrBold)
|
||||
x += tui.RuneLen(p.value)
|
||||
}
|
||||
return start
|
||||
}
|
||||
|
||||
func (a *App) renderHeader(r tui.Region) {
|
||||
r.Fill(a.th.HeaderBg)
|
||||
rx := a.drawPairsRight(r, 0, a.headerPairs(), a.th.HeaderBg)
|
||||
|
||||
x := 1
|
||||
r.Text(x, 0, " vif-log ", a.th.Bg, a.th.Accent, terminal.AttrBold)
|
||||
x += 10
|
||||
if rx > x+2*int(logfile.LevelCount) {
|
||||
x = a.drawLevelStrip(r, x)
|
||||
}
|
||||
if w := rx - x - 2; w > 8 {
|
||||
// title carries "name +N" once several files are merged
|
||||
name := a.title
|
||||
if name == "" {
|
||||
name = "no file - press o to open"
|
||||
}
|
||||
r.Text(x+1, 0, tui.TruncateLeft(name, w), a.th.HeaderFg, a.th.HeaderBg, terminal.AttrBold)
|
||||
}
|
||||
}
|
||||
|
||||
// drawLevelStrip shows every level's initial, filled for the levels currently
|
||||
// shown and outlined for the hidden ones. Returns the x past the strip.
|
||||
func (a *App) drawLevelStrip(r tui.Region, x int) int {
|
||||
for l := logfile.Level(0); l < logfile.LevelCount; l++ {
|
||||
fg, bg, attr := a.th.Level[l], a.th.HeaderBg, terminal.AttrNone
|
||||
if a.lvl.Has(l) {
|
||||
fg, bg, attr = a.th.HeaderBg, a.th.Level[l], terminal.AttrBold
|
||||
}
|
||||
r.Cell(x, 0, rune(l.Initial()), fg, bg, attr)
|
||||
x += 2
|
||||
}
|
||||
return x
|
||||
}
|
||||
|
||||
func (a *App) headerPairs() []pair {
|
||||
ps := make([]pair, 0, 4)
|
||||
if scanned, total, done := a.idx.Progress(); !done {
|
||||
p := 0
|
||||
if total > 0 {
|
||||
p = int(scanned * 100 / total)
|
||||
}
|
||||
ps = append(ps, pair{"indexing", fmt.Sprintf("%d%%", p), a.th.Accent2})
|
||||
}
|
||||
n := len(a.rows())
|
||||
row := "0"
|
||||
if n > 0 {
|
||||
row = fmt.Sprint(a.cursor + 1)
|
||||
}
|
||||
return append(ps,
|
||||
pair{"row", row, a.th.HeaderFg},
|
||||
pair{"shown", fmt.Sprint(n), a.th.Selected},
|
||||
pair{"total", fmt.Sprint(a.idx.Len()), a.th.StatusFg},
|
||||
)
|
||||
}
|
||||
|
||||
func (a *App) renderStatus(r tui.Region) {
|
||||
r.Fill(a.th.HeaderBg)
|
||||
rx := a.drawPairsRight(r, 0, a.statusPairs(), a.th.HeaderBg)
|
||||
if s := strings.Join(a.stack.Summary(), " "); s != "" && rx > 3 {
|
||||
r.Text(1, 0, tui.Truncate(s, rx-2), a.th.Accent, a.th.HeaderBg, terminal.AttrBold)
|
||||
}
|
||||
}
|
||||
|
||||
// statusPairs is ordered least to most important: overflow drops from the left.
|
||||
func (a *App) statusPairs() []pair {
|
||||
ps := make([]pair, 0, 5)
|
||||
if a.build.busy {
|
||||
ps = append(ps, pair{"filtering",
|
||||
fmt.Sprintf("%d%%", pct(a.build.next, a.idx.Len())), a.th.Accent2})
|
||||
}
|
||||
if n := a.idx.Malformed(); n > 0 {
|
||||
ps = append(ps, pair{"bad", fmt.Sprint(n), a.th.Error})
|
||||
}
|
||||
if n := a.pins.Len(); n > 0 {
|
||||
ps = append(ps, pair{"pins", fmt.Sprint(n), a.th.Warning})
|
||||
}
|
||||
if a.sortDir != sortNone {
|
||||
ps = append(ps, pair{"sort", a.sortCol.String() + " " + a.sortDir.String(), a.th.Partial})
|
||||
}
|
||||
return append(ps, pair{"col", a.col.String(), a.th.Accent})
|
||||
}
|
||||
|
||||
func pct(n, total int) int {
|
||||
if total <= 0 {
|
||||
return 100
|
||||
}
|
||||
return n * 100 / total
|
||||
}
|
||||
|
||||
// --- record list -----------------------------------------------------------
|
||||
|
||||
// colLayout is the physical geometry of the list pane: pin gutter, optional
|
||||
// source gutter, then the focusable columns with level wedged after time.
|
||||
type colLayout struct {
|
||||
w int
|
||||
pinX int
|
||||
srcX, srcW int
|
||||
tsX, tsW int
|
||||
lvlX int
|
||||
tickX, tickW int
|
||||
subX, subW int
|
||||
markX int
|
||||
msgX, msgW int
|
||||
fldX int
|
||||
}
|
||||
|
||||
func listCols(w, nsrc int) colLayout {
|
||||
c := colLayout{w: w, tsW: 12, subW: 8, msgW: 16}
|
||||
if nsrc > 1 {
|
||||
c.srcW = 1
|
||||
}
|
||||
if w >= 96 {
|
||||
c.tickW = 6
|
||||
}
|
||||
if w < 76 {
|
||||
c.msgW = 12
|
||||
}
|
||||
if w < 60 {
|
||||
c.subW, c.msgW = 6, 10
|
||||
}
|
||||
x := 0
|
||||
c.pinX, x = x, x+2
|
||||
c.srcX = x
|
||||
if c.srcW > 0 {
|
||||
x += c.srcW + 1
|
||||
}
|
||||
c.tsX, x = x, x+c.tsW+1
|
||||
c.lvlX, x = x, x+2
|
||||
c.tickX = x
|
||||
if c.tickW > 0 {
|
||||
x += c.tickW + 1
|
||||
}
|
||||
c.subX, x = x, x+c.subW+1
|
||||
c.markX, x = x, x+2
|
||||
c.msgX, x = x, x+c.msgW+1
|
||||
c.fldX = x
|
||||
return c
|
||||
}
|
||||
|
||||
// span returns the header extent of a focusable column.
|
||||
func (c colLayout) span(col logfile.Column) (int, int) {
|
||||
switch col {
|
||||
case logfile.ColTime:
|
||||
return c.tsX, c.tsW
|
||||
case logfile.ColTick:
|
||||
return c.tickX, c.tickW
|
||||
case logfile.ColSub:
|
||||
return c.subX, c.subW
|
||||
case logfile.ColMsg:
|
||||
return c.msgX, c.msgW
|
||||
case logfile.ColFields:
|
||||
return c.fldX, max(0, c.w-c.fldX)
|
||||
}
|
||||
return 0, c.w
|
||||
}
|
||||
|
||||
func (a *App) renderList(r tui.Region) {
|
||||
r.Fill(a.th.Bg)
|
||||
list := r.Sub(0, 0, r.W-1, r.H)
|
||||
c := listCols(list.W, a.idx.SrcCount())
|
||||
a.renderColHeader(list, c)
|
||||
|
||||
body := list.Sub(0, 1, list.W, list.H-1)
|
||||
a.listH = body.H
|
||||
a.clamp()
|
||||
|
||||
rows := a.rows()
|
||||
if len(rows) == 0 {
|
||||
msg := "no records match"
|
||||
if a.idx == nil {
|
||||
msg = "no file open — press o"
|
||||
}
|
||||
body.TextCenter(body.H/2, msg, a.th.HintFg, a.th.Bg, terminal.AttrDim)
|
||||
} else {
|
||||
metas := a.idx.Metas()
|
||||
for y := 0; y < body.H; y++ {
|
||||
i := a.scroll + y
|
||||
if i < 0 || i >= len(rows) {
|
||||
break
|
||||
}
|
||||
rec := rows[i]
|
||||
if int(rec) >= len(metas) {
|
||||
break
|
||||
}
|
||||
a.renderRow(body, y, rec, metas[rec], c, i == a.cursor)
|
||||
}
|
||||
}
|
||||
|
||||
sb := r.Sub(r.W-1, 1, 1, r.H-1)
|
||||
sb.ScrollBar(0, a.scroll, sb.H, len(rows), a.th.Border)
|
||||
}
|
||||
|
||||
// renderColHeader names the columns and marks the focused one, which is both
|
||||
// the search scope and the sort target.
|
||||
func (a *App) renderColHeader(r tui.Region, c colLayout) {
|
||||
for x := 0; x < r.W; x++ {
|
||||
r.Cell(x, 0, ' ', a.th.HintFg, a.th.HeaderBg, terminal.AttrNone)
|
||||
}
|
||||
fx, fw := c.span(a.col)
|
||||
for x := fx; x < fx+fw && x < r.W; x++ {
|
||||
r.Cell(x, 0, ' ', a.th.Bg, a.th.Accent, terminal.AttrNone)
|
||||
}
|
||||
|
||||
head := func(x, w int, s string, focused bool) {
|
||||
fg, bg := a.th.HintFg, a.th.HeaderBg
|
||||
if focused {
|
||||
fg, bg = a.th.Bg, a.th.Accent
|
||||
}
|
||||
r.Text(x, 0, tui.Truncate(s, max(1, w)), fg, bg, terminal.AttrBold)
|
||||
}
|
||||
all := a.col == logfile.ColAll
|
||||
head(c.tsX, c.tsW, "time", all || a.col == logfile.ColTime)
|
||||
head(c.lvlX, 1, "T", all)
|
||||
if c.tickW > 0 {
|
||||
head(c.tickX, c.tickW, "tick", all || a.col == logfile.ColTick)
|
||||
}
|
||||
head(c.subX, c.subW, "sub", all || a.col == logfile.ColSub)
|
||||
head(c.msgX, c.msgW, "msg", all || a.col == logfile.ColMsg)
|
||||
head(c.fldX, max(1, r.W-c.fldX), "fields", all || a.col == logfile.ColFields)
|
||||
|
||||
if a.sortDir != sortNone && sortable(a.sortCol) {
|
||||
sx, sw := c.span(a.sortCol)
|
||||
if x := sx + sw - 1; sw > 0 && x < r.W {
|
||||
fg, bg := a.th.Accent, a.th.HeaderBg
|
||||
if all || a.sortCol == a.col {
|
||||
fg, bg = a.th.Bg, a.th.Accent
|
||||
}
|
||||
r.Cell(x, 0, a.sortDir.arrow(), fg, bg, terminal.AttrBold)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (a *App) renderRow(r tui.Region, y int, rec int32, m logfile.Meta, c colLayout, cursor bool) {
|
||||
pinned := a.pins.Has(rec)
|
||||
bg := a.th.Bg
|
||||
switch {
|
||||
case cursor:
|
||||
bg = a.th.CursorBg
|
||||
case pinned:
|
||||
bg = a.th.FocusBg
|
||||
}
|
||||
for x := 0; x < r.W; x++ {
|
||||
r.Cell(x, y, ' ', a.th.Fg, bg, terminal.AttrNone)
|
||||
}
|
||||
if pinned {
|
||||
r.Cell(c.pinX, y, '◆', a.th.Warning, bg, terminal.AttrBold)
|
||||
}
|
||||
|
||||
collapsed := m.Flags&logfile.FlagSnapHead != 0 && !a.snap.Expanded(m.Snap)
|
||||
|
||||
// Source gutter: present only when more than one file is indexed
|
||||
if c.srcW > 0 {
|
||||
r.Cell(c.srcX, y, a.idx.SrcMark(m.Src), a.th.SrcColor(int(m.Src)), bg, terminal.AttrBold)
|
||||
}
|
||||
|
||||
r.Text(c.tsX, y, tui.Truncate(logfile.StampText(m), c.tsW), a.th.HintFg, bg, terminal.AttrDim)
|
||||
|
||||
lvlFg := a.th.Level[logfile.LevelBad]
|
||||
if m.Lvl < logfile.LevelCount {
|
||||
lvlFg = a.th.Level[m.Lvl]
|
||||
}
|
||||
r.Cell(c.lvlX, y, rune(m.Lvl.Initial()), lvlFg, bg, terminal.AttrBold)
|
||||
|
||||
// Tick column appears only on wide terminals; the index carries it always
|
||||
if c.tickW > 0 {
|
||||
r.Text(c.tickX, y, tui.PadLeft(strconv.FormatUint(uint64(m.Tick), 10), c.tickW),
|
||||
a.th.HintFg, bg, terminal.AttrDim)
|
||||
}
|
||||
|
||||
sub := logfile.Dash(a.idx.SubName(m.Sub))
|
||||
r.Text(c.subX, y, tui.PadRight(tui.Truncate(sub, c.subW), c.subW), a.th.SubColor(sub), bg, terminal.AttrNone)
|
||||
|
||||
if mark := snapMark(m, collapsed); mark != 0 {
|
||||
r.Cell(c.markX, y, mark, a.th.SnapFg, bg, terminal.AttrNone)
|
||||
}
|
||||
|
||||
msg, msgAttr := logfile.Dash(a.idx.MsgName(m.Msg)), terminal.AttrNone
|
||||
if collapsed {
|
||||
msg, msgAttr = "snapshot", terminal.AttrBold
|
||||
}
|
||||
r.Text(c.msgX, y, tui.PadRight(tui.Truncate(msg, c.msgW), c.msgW), a.th.Fg, bg, msgAttr)
|
||||
|
||||
if c.fldX >= r.W {
|
||||
return
|
||||
}
|
||||
switch {
|
||||
case m.Flags&logfile.FlagMalformed != 0:
|
||||
r.Text(c.fldX, y, tui.Truncate("<malformed line>", r.W-c.fldX),
|
||||
a.th.Level[logfile.LevelBad], bg, terminal.AttrItalic)
|
||||
case collapsed:
|
||||
r.Text(c.fldX, y, tui.Truncate(a.snapSummary(m), r.W-c.fldX), a.th.SnapFg, bg, terminal.AttrNone)
|
||||
default:
|
||||
r.Text(c.fldX, y, tui.Truncate(a.summary(m), r.W-c.fldX), a.th.StatusFg, bg, terminal.AttrNone)
|
||||
}
|
||||
}
|
||||
|
||||
// snapMark returns the group indicator: collapsed head, expanded head, member.
|
||||
func snapMark(m logfile.Meta, collapsed bool) rune {
|
||||
switch {
|
||||
case m.Flags&logfile.FlagSnapHead != 0 && collapsed:
|
||||
return '▶'
|
||||
case m.Flags&logfile.FlagSnapHead != 0:
|
||||
return '▼'
|
||||
case m.Snap != 0:
|
||||
return '·'
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// snapSummary describes a collapsed group from the index alone, no line read.
|
||||
func (a *App) snapSummary(m logfile.Meta) string {
|
||||
if s, ok := a.idx.SnapshotOf(m); ok {
|
||||
return fmt.Sprintf("stat snapshot ×%d run=%d tick=%d", s.Count, s.Run, s.Tick)
|
||||
}
|
||||
return fmt.Sprintf("stat snapshot run=%d tick=%d", m.Run, m.Tick)
|
||||
}
|
||||
|
||||
// summary renders the fields column; the search filter matches this same text.
|
||||
func (a *App) summary(m logfile.Meta) string {
|
||||
line, err := a.rd.Line(m)
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
a.rec.Parse(m, line)
|
||||
return a.rec.FieldsText()
|
||||
}
|
||||
|
||||
// --- detail ----------------------------------------------------------------
|
||||
|
||||
type detailRow struct {
|
||||
k, v string
|
||||
head bool
|
||||
}
|
||||
|
||||
func (a *App) renderDetail(r tui.Region) {
|
||||
r.Fill(a.th.Bg)
|
||||
r.VLine(0, tui.LineSingle, a.th.Border)
|
||||
c := r.Sub(2, 0, r.W-2, r.H)
|
||||
if c.W < 8 || c.H < 2 {
|
||||
return
|
||||
}
|
||||
|
||||
rec := a.cursorRec()
|
||||
m, ok := a.meta(rec)
|
||||
if !ok {
|
||||
c.TextCenter(0, "no record", a.th.HintFg, a.th.Bg, terminal.AttrDim)
|
||||
return
|
||||
}
|
||||
line, err := a.rd.Line(m)
|
||||
if err != nil {
|
||||
c.Text(0, 0, "read: "+err.Error(), a.th.Error, a.th.Bg, terminal.AttrNone)
|
||||
return
|
||||
}
|
||||
a.rec.Parse(m, line)
|
||||
|
||||
rows := make([]detailRow, 0, 10+len(a.rec.Fields))
|
||||
|
||||
appendWrapped := func(key, val string, head bool) string {
|
||||
if val == "" {
|
||||
rows = append(rows, detailRow{key, "", head})
|
||||
return " "
|
||||
}
|
||||
for _, vline := range strings.Split(val, "\n") {
|
||||
runes := []rune(vline)
|
||||
if len(runes) == 0 {
|
||||
rows = append(rows, detailRow{key, "", head})
|
||||
key = " "
|
||||
continue
|
||||
}
|
||||
for len(runes) > 0 {
|
||||
width := max(10, c.W-tui.RuneLen(key)-2)
|
||||
chunk := runes
|
||||
if len(chunk) > width {
|
||||
chunk = chunk[:width]
|
||||
}
|
||||
rows = append(rows, detailRow{key, string(chunk), head})
|
||||
runes = runes[len(chunk):]
|
||||
key = " "
|
||||
}
|
||||
}
|
||||
return key
|
||||
}
|
||||
|
||||
appendWrapped("time", a.rec.Time, true)
|
||||
appendWrapped("level", m.Lvl.String(), true)
|
||||
// Source line only earns its row in a merged view
|
||||
if a.idx.SrcCount() > 1 {
|
||||
appendWrapped("file", a.idx.SrcName(m.Src), true)
|
||||
}
|
||||
appendWrapped("sub", logfile.Dash(a.idx.SubName(m.Sub)), true)
|
||||
appendWrapped("run", fmt.Sprint(m.Run), true)
|
||||
appendWrapped("tick", fmt.Sprint(m.Tick), true)
|
||||
appendWrapped("frame", fmt.Sprint(m.Frame), true)
|
||||
|
||||
if a.rec.Trace != "" {
|
||||
key := "trace"
|
||||
steps := strings.Split(a.rec.Trace, " -> ")
|
||||
for i, step := range steps {
|
||||
if i > 0 {
|
||||
step = "-> " + step
|
||||
}
|
||||
key = appendWrapped(key, step, true)
|
||||
}
|
||||
}
|
||||
if s, ok := a.idx.SnapshotOf(m); ok {
|
||||
appendWrapped("snapshot", fmt.Sprintf("%d records, head %d", s.Count, s.Head), true)
|
||||
}
|
||||
if a.pins.Has(rec) {
|
||||
appendWrapped("pinned", "yes", true)
|
||||
}
|
||||
rows = append(rows, detailRow{})
|
||||
|
||||
if a.rec.Bad {
|
||||
raw := strings.TrimRight(string(line), "\r\n")
|
||||
appendWrapped("raw", raw, false)
|
||||
} else {
|
||||
for _, f := range a.rec.Fields {
|
||||
appendWrapped(f.Key, a.rec.Display(f), false)
|
||||
}
|
||||
}
|
||||
|
||||
ks := tui.Style{Fg: a.th.KeyFg}
|
||||
a.dscroll = tui.ClampScroll(a.dscroll, c.H, len(rows))
|
||||
for y := 0; y < c.H; y++ {
|
||||
i := a.dscroll + y
|
||||
if i >= len(rows) {
|
||||
break
|
||||
}
|
||||
if rows[i].k == "" {
|
||||
c.HLine(y, tui.LineSingle, a.th.Border)
|
||||
continue
|
||||
}
|
||||
vs := tui.Style{Fg: a.th.StrFg}
|
||||
if rows[i].head {
|
||||
vs = tui.Style{Fg: a.th.Fg}
|
||||
}
|
||||
c.KeyValue(y, rows[i].k, rows[i].v, ks, vs, ':')
|
||||
}
|
||||
}
|
||||
|
||||
// --- footer / prompt -------------------------------------------------------
|
||||
|
||||
// footerActions lists the bindings specific to this viewer; generic movement
|
||||
// and quit keys live in the help overlay. Chords come from the key table.
|
||||
var footerActions = []struct {
|
||||
act keys.Action
|
||||
label string
|
||||
}{
|
||||
{keys.ActHelp, "help"},
|
||||
{keys.ActOpen, "open"},
|
||||
{keys.ActSearch, "find"},
|
||||
{keys.ActFilter, "filter"},
|
||||
{keys.ActFollowNext, "same"},
|
||||
{keys.ActExpand, "snap"},
|
||||
{keys.ActPinToggle, "pin"},
|
||||
{keys.ActPinOnly, "only"},
|
||||
{keys.ActExport, "export"},
|
||||
{keys.ActColNext, "col"},
|
||||
{keys.ActSort, "sort"},
|
||||
}
|
||||
|
||||
func (a *App) renderFooter(r tui.Region) {
|
||||
r.Fill(a.th.HeaderBg)
|
||||
x := 1
|
||||
for _, h := range footerActions {
|
||||
k := " " + keys.KeysFor(keys.ModeNormal, h.act) + " "
|
||||
l := h.label + " "
|
||||
if x+tui.RuneLen(k)+tui.RuneLen(l) > r.W {
|
||||
break
|
||||
}
|
||||
r.Text(x, 0, k, a.th.Bg, a.th.Accent, terminal.AttrBold)
|
||||
x += tui.RuneLen(k)
|
||||
r.Text(x, 0, l, a.th.HintFg, a.th.HeaderBg, terminal.AttrNone)
|
||||
x += tui.RuneLen(l)
|
||||
}
|
||||
}
|
||||
|
||||
// renderPrompt replaces the footer row while text is being entered.
|
||||
func (a *App) renderPrompt(r tui.Region) {
|
||||
if r.W < 5 || r.H < 1 || a.prompt == nil {
|
||||
return
|
||||
}
|
||||
st := tui.DefaultTextFieldStyle()
|
||||
st.TextBg, st.PrefixFg, st.TextFg = a.th.InputBg, a.th.Accent, a.th.Fg
|
||||
st.CursorBg, st.CursorFg = a.th.Fg, a.th.Bg
|
||||
r.TextField(a.prompt, tui.TextFieldOpts{
|
||||
Prefix: a.promptKind.prefix(a.col), Border: tui.LineNone,
|
||||
Focused: true, Style: st,
|
||||
})
|
||||
}
|
||||
|
||||
// --- help ------------------------------------------------------------------
|
||||
|
||||
// helpLine is one rendered row of the help panel: a group heading or a binding.
|
||||
type helpLine struct {
|
||||
keys, text string
|
||||
head bool
|
||||
}
|
||||
|
||||
// buildHelpLines flattens the key table once at startup.
|
||||
func buildHelpLines() []helpLine {
|
||||
var out []helpLine
|
||||
group := ""
|
||||
for _, m := range []keys.Mode{keys.ModeNormal, keys.ModeOverlay} {
|
||||
for _, row := range keys.HelpRows(m) {
|
||||
if row.Group != group {
|
||||
group = row.Group
|
||||
if len(out) > 0 {
|
||||
out = append(out, helpLine{})
|
||||
}
|
||||
out = append(out, helpLine{text: strings.ToUpper(group), head: true})
|
||||
}
|
||||
out = append(out, helpLine{keys: row.Keys, text: row.Help})
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (a *App) renderHelp(root tui.Region) {
|
||||
a.help.Rows = len(a.helpLines)
|
||||
a.help.Title = "vif-log keys"
|
||||
a.help.Hint = "↑↓ scroll esc close"
|
||||
|
||||
body := a.help.Render(root, &a.th)
|
||||
if body.W < 10 || body.H < 1 {
|
||||
return
|
||||
}
|
||||
ks := tui.Style{Fg: a.th.Accent, Bg: a.th.FocusBg, Attr: terminal.AttrBold}
|
||||
vs := tui.Style{Fg: a.th.Fg, Bg: a.th.FocusBg}
|
||||
for y := 0; y < body.H; y++ {
|
||||
i := a.help.Scroll + y
|
||||
if i >= len(a.helpLines) {
|
||||
break
|
||||
}
|
||||
l := a.helpLines[i]
|
||||
switch {
|
||||
case l.head:
|
||||
body.Text(1, y, l.text, a.th.Accent2, a.th.FocusBg, terminal.AttrBold)
|
||||
case l.text != "":
|
||||
body.KeyValue(y, l.keys, l.text, ks, vs, ' ')
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user