README
¶
gotermboard
A self-refreshing terminal board for Go command-line tools, on Bubble Tea v2.
A program built on it has a tab per view. Each view is one table of folding groups sharing one set of columns, with a side panel that follows the cursor. Each source of data refreshes at its own pace, and the board draws its last good read with that read's age, so a failing backend leaves the table drawn and says the read is old.
type board struct{ jobs *gotermboard.Source[[]job] }
func newBoard() *board {
return &board{jobs: gotermboard.NewSource("jobs", 5*time.Second, readJobs)}
}
func (b *board) Sources() []gotermboard.Refresher { return []gotermboard.Refresher{b.jobs} }
func (b *board) Groupings() []string { return nil }
func (b *board) Frame(now time.Time, _ string) gotermboard.Frame {
group := gotermboard.Group{Key: "jobs", Title: gotermboard.Line{gotermboard.C("JOBS", gotermboard.Bold)}}
for _, j := range b.jobs.Value() {
group.Rows = append(group.Rows, gotermboard.Row{Key: j.Name, Cells: []gotermboard.Cell{
gotermboard.C(j.Name, ""),
gotermboard.C(j.State, gotermboard.Cyan),
gotermboard.Ticking(gotermboard.Ago(now.Sub(j.Started)), ""),
}})
}
return gotermboard.Frame{
Strip: []gotermboard.Line{gotermboard.ReadStatus([]gotermboard.Status{b.jobs.Status()}, now)},
Columns: []gotermboard.Column{{Title: ""}, {Title: "STATE"}, {Title: "AGE"}},
Groups: []gotermboard.Group{group},
}
}
func main() {
pal := gotermstyle.PaletteFor(os.Stdout)
tabs, err := gotermboard.NewTabs([]gotermboard.Tab{{Name: "jobs", Board: newBoard()}}, pal, "")
if err != nil {
log.Fatal(err)
}
if _, err := tea.NewProgram(tabs).Run(); err != nil {
log.Fatal(err)
}
}
Tabs read only while they show
NewTabs takes the tabs in the order Tab cycles them, and the name of the one to open
on. Each tab keeps its own cursor, folds and filter. A hidden tab starts no read,
builds no frame and moves no strip. On its return it draws its last good read with that read's age, and
every source past its interval reads at once. A source inside its interval keeps its
pace, so cycling the tabs quickly starts nothing extra. A program with one tab draws no
tab line, and Tab does nothing in it.
Once draws one frame from what a board's sources already hold, and OnceSize picks
its size: COLUMNS by LINES, then the terminal, then a fallback you pass.
One line says how the reads stand
ReadStatus is a line for a view's strip. While every read is on schedule it says
read 3s ago. A failed read is named in red with its reason, one past twice its
interval in yellow, and a note on a read that covered less follows plain. The ?
overlay lists every source's age, interval, cost and fault.
A row that changed wears a cue
The board compares each row's and group's key and cells between frames, and marks a
changed one for CueFor: a dot in the pointer's column and its first cell in bold. No
column moves. A cell built with Ticking follows the clock, as an age or a gauge does,
so its text changing is no change to the row, though its color changing is. A first
read, a tab's return and a new grouping mark nothing.
Group rows share the columns
A Group with Cells draws them on the columns past the first, which holds its title,
and the column titles then take a line of their own at the top. Below holds lines
drawn under the header whether it is folded or not, which the cursor moves past as one
node. WrapLast on a Row or a Group is the last column as cells of their own colors,
continuing on further lines at that column, so a bar wider than the row keeps every cell.
Items makes a line of Below or Beside that the draw cuts to the items that fit,
ending in +N, because only the draw knows the width and it moves with the side panel.
Under is a group's summary, wrapping under Below while f has them on.
Span draws a long value whole past a group's title, wrapping under itself, so it never
sets the first column's width. The group's cells then take the next line, with Beside
ahead of them in the first column. Column.Min holds that column wide enough to be useful.
A row can open a document laid out at its width
Document on a Row or a Group is a function of width, because hanging bullets, tables
and boxes of code cannot be wrapped after they are drawn. A row's opens under it on space,
however tall it is. enter opens it the same way, or on the full-screen reader where it runs
past the screen, whether or not it already shows in place. StartsOpen on a row shows its text
from the first frame, so a view can draw its newest entry whole and still fold it to its first
line. A group's draws under Below whether the group is folded or not. The markdown package
makes one from markdown, in ANSI 0-15 so it follows the theme:
renderer := markdown.New(nil)
row.Document = func(width int) []gotermboard.Line { return renderer.Lines(description, min(width, 100)) }
A fence naming a language wraps a line wider than its box, marking each continued row with
↪, as bat and delta do. A text or bare fence cuts that line instead, so a diagram or a
table of output stays lined up. WrapEveryFence on the renderer wraps those too, for a text whose
every word has to reach the reader.
Its argument colors what a caller recognizes in prose, such as a number that names a record.
What holds the text stays at the top while it scrolls
Reading down an open row's text keeps the row and the groups above it on the band at the top of the table, as VS Code's sticky scroll and nvim-treesitter-context do. The band shows the first line of each node holding the first line it leaves showing, so the cursor's row carries its pointer there. A node joins once its own line has scrolled off, and a sibling arriving under the band takes its predecessor's place.
- The band covers lines rather than pushing them down, so nothing under it moves as it grows.
- It holds a few lines, never a large share of the table, and drops the outermost first.
- A band line is no cursor stop. A cursor moved under the band brings its row out below it.
- Only a row or group with lines under it and words to name them by joins, so a folded
group, a closed row and a group with no title never take a line of the band. A
Stillgroup at the top of the frame stays above the table already, so it never joins either.
Every board gets the band with no field to set, because gotermboard draws the table.
A Still group has no fold mark and the cursor passes over it. At the top of a frame it
stays on screen with the column titles while the table scrolls, which suits a row of totals.
A chevron marks only what opens
The board decides the mark from what a node holds. A row draws ▸ or ▾ where it holds Detail
or a Document, and a group where it holds a row or a group the table draws. Anywhere else enter
and space change nothing, so no mark promises otherwise and the footer and ? leave both keys out
on that line. A filter holds every group open, so a group draws no mark while one is typed.
A row's chevron sits in the last cell of its indent, one cell in from its parent's, with Symbol
beside it. MarkGlyph sits in the cell before the chevron. No column moves for either.
A filter can reach past what shows
FilterOnly keeps a group out of the table until a filter is typed, so a view that shows
the first few of something still finds the rest. Text is more the filter matches beyond
what a group draws, and Heading says a title only labels what sits under it, so a word in
it matches nothing.
The side panel follows the cursor
From PanelFrom columns the panel grows with the screen, up to ReadingWidth. It draws where any
row in the frame holds Panel, Document or Detail, or any group but a Still one holds Panel
or Detail, counting lines folded away or held back for a filter. A frame with none of them draws
no panel, and the table takes the width. The frame decides rather than the cursor's line, so the
table never jumps as the cursor moves.
Panel on a row or a group is what the side panel shows in Detail's place, a function of
the panel's width whose lines wrap at spaces with each cell's own color. A row with no Panel
shows its Document. A board implementing CursorBoard is
told each key the cursor lands on, so a read that only one row needs can follow it.
Frame.StartAt names the key the cursor starts on. Without one it starts on the first line
holding cells, or the last on a TailBoard, past any group with no panel text. With no such line
it starts on the first line with text to read.
A tall document reads on a full screen
Reader is a full screen over one Document. It lays the text out at up to 100 columns,
centers it on a wider screen, and keeps the same words at the top through a resize. j and
k, ctrl+d and ctrl+u, g and G move through it, [ and ] jump between sections,
and / searches with n and N. A query with no capital in it ignores case. y copies
CopyText, or the text as drawn, over OSC 52. e opens EditFile in $VISUAL or $EDITOR
and lays the text out again after.
Its top line names where the text sits: the groups the table's band would name over the row that opened it, its title, then each heading still open above the top row. A heading joins once its own row scrolls off, as the table's band does. Where the line runs long, the longest name is cut first, and the outermost leaves once every name is down to a few words.
Model.Read opens one over the board from a board's own key, and esc or space returns to the
board. Model.Tall says whether a document runs past the screen. NewReader runs as a program of its
own, which is all cmd/read-markdown does with a file or a pipe:
go install github.com/datapointchris/gotermboard/cmd/read-markdown@latest
read-markdown README.md
A Cell with Section set starts the words of a heading, and its value is the heading's depth, 1
outermost. A heading closes every open one at its depth or deeper. The markdown package sets it
on each heading's first word, past the bar that marks it.
A board's strip can move between its frames
A board implementing MovingBoard gets its strip from StripAt(now), redrawn every MoveEvery(),
for a diagram of work in motion between its reads. Only the strip redraws at that pace, so the table,
its change cue and the side panel wait for the next frame. Only the tab showing runs the clock, and a
reader over the board holds it until the key that closes the reader. A MoveEvery of zero holds the
strip still until the board's next tick asks again, so a board with nothing moving spends nothing.
func (b *board) MoveEvery() time.Duration { return 100 * time.Millisecond }
func (b *board) StripAt(now time.Time) []gotermboard.Line {
return []gotermboard.Line{b.lane(b.runs.Value(), now)}
}
StripAt replaces Frame.Strip on every draw, so it returns the lines that hold still as well. A
strip changing its height between beats redraws the table, because the table's height moves with it.
A beat builds no frame and draws no table, so a moving strip costs a fraction of rebuilding the whole frame at the same pace. What a beat does cost is mostly Bubble Tea's renderer, which compares the whole screen on every frame that changed.
A board can add keys
A board implementing Keyed adds Actions, which take precedence over the table's and
appear in the footer and the ? overlay. A board implementing TailBoard reads from its
newest row, as a log does.
enter and space are separate keys in the table, so a board that takes enter leaves space
folding in place. Model.Toggle is what the table's enter does, for a board's enter that acts
only on some rows. Bind it to enter alone. A row open in place that turns tall, as on a pane
shrink, reads on Toggle and closes only on the table's space.
Documentation
¶
Overview ¶
Package gotermboard draws a self-refreshing terminal board on Bubble Tea v2: a tab per view, folding groups on shared columns, a side panel that follows the cursor, and one action table the keys, the footer and the ? overlay all read.
A view is a read model, as in CQRS. Its reader joins sources into a snapshot, and its renderer turns the snapshot into a Frame this package draws. A failed read never gives up a good value: a Source keeps its last good read and says how old it is.
Index ¶
- Constants
- func Ago(d time.Duration) string
- func Once(board Board, pal gotermstyle.Palette, width, height int) string
- func OnceSize(fallbackWidth, fallbackHeight int) (width, height int)
- func RefreshAll(ctx context.Context, sources ...Refresher)
- type Action
- type Board
- type Cell
- type Column
- type CursorBoard
- type Document
- type Frame
- type Group
- type Keyed
- type Line
- type Model
- func (m *Model) Cursor() string
- func (m *Model) HalfScreen() int
- func (m *Model) Init() tea.Cmd
- func (m *Model) Read(title string, document Document)
- func (m *Model) Rebuild()
- func (m *Model) Restart() tea.Cmd
- func (m *Model) Reveal()
- func (m *Model) Say(text string)
- func (m *Model) ScrollBy(lines int)
- func (m *Model) Tall(document Document) bool
- func (m *Model) Toggle() tea.Cmd
- func (m *Model) ToggleEveryRow() tea.Cmd
- func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd)
- func (m *Model) View() tea.View
- type MovingBoard
- type Reader
- type Refresher
- type Row
- type RuleWeight
- type Source
- type Status
- type Tab
- type Tabs
- type TailBoard
Constants ¶
const ( CueGlyph = "•" CueCode = BoldCyan CueFor = 30 * time.Second )
The cue a row or group wears after it changed. It sits in the pointer's column, so no column moves for it.
const ( Red = gotermstyle.CodeRed Yellow = gotermstyle.CodeYellow Green = gotermstyle.CodeGreen Cyan = gotermstyle.CodeCyan Blue = gotermstyle.CodeBlue Magenta = gotermstyle.CodeMagenta White = gotermstyle.CodeWhite Bold = gotermstyle.CodeBold BoldRed = "\033[1;91m" BoldYellow = "\033[1;93m" BoldGreen = "\033[1;92m" BoldCyan = "\033[1;96m" BoldBlue = "\033[1;94m" BoldMagenta = "\033[1;95m" Reverse = "\033[7m" )
The codes a view colors a cell with, all in ANSI 0-15 so they follow the theme.
const ( MarkGlyph = "◆" MarkCode = BoldMagenta )
The mark a Marked row draws.
const PanelFrom = 160
PanelFrom is the narrowest screen that gets the side panel.
const ReadingWidth = 100
ReadingWidth is the widest a reader lays text out, because a longer line is hard to follow back to its start. A wider screen keeps the rest as margin. A view that lays the same text out in its table reads this, so the two wrap alike.
const RuleCode = "\033[0;90m"
RuleCode is the gray a rule draws in, which the terminal palette's theme sets.
Variables ¶
This section is empty.
Functions ¶
func Once ¶
func Once(board Board, pal gotermstyle.Palette, width, height int) string
Once is one frame at a size, drawn from what the board's sources already hold.
func OnceSize ¶
OnceSize is the size one printed frame draws at: COLUMNS by LINES, then the terminal's own size, then the fallback.
func RefreshAll ¶
RefreshAll reads every source once, all at once, and returns when each ended.
Types ¶
type Action ¶
type Action struct {
Keys []string
Label string
Run func(*Model) tea.Cmd
// Applies says whether this view can use the key now. Nil means always.
Applies func(*Model) bool
}
Action is one row of the key table the handler, the footer and the ? overlay all read.
type Board ¶
type Board interface {
Sources() []Refresher
Groupings() []string
Frame(now time.Time, grouping string) Frame
}
Board is one view, as this package draws it: sources to keep fresh, and the frame their last good reads make now.
type Cell ¶
type Cell struct {
Text string
Code string
Ticks bool
// Section says this cell starts the words of a heading, where a Reader's [ and ] land, and
// how deep the heading sits: 1 is outermost, and 0 is no heading. A heading closes every
// open one at its depth or deeper, which is the path a Reader's top line draws.
Section int
// contains filtered or unexported fields
}
Cell is text and its color. Ticks says the text follows the clock, as an age does, so its changing is no change to the row, though its color changing still is.
type Column ¶
type Column struct {
Title string
// Min holds the column at least this wide, for what a group's Beside fits into.
Min int
Max int
Right bool
}
Column is one column of the table. The last is unpadded, so the screen's edge cuts it first. Max caps its width, where one long value must not take the row.
type CursorBoard ¶ added in v0.3.0
type CursorBoard interface {
CursorOn(key string)
}
CursorBoard is a Board told which key the cursor is on, for a read that follows it.
type Document ¶ added in v0.4.0
Document is text that lays itself out at a width, for what only the draw can place: hanging bullets, tables and boxes of code. Its lines are drawn as they come.
type Frame ¶
type Frame struct {
Strip []Line
Columns []Column
Groups []Group
// StartAt is the key the cursor starts on, where that key is showing. Without one it
// starts on the first line holding cells, or the last on a TailBoard, past any group with
// no panel text. With no such line it starts on the first line with text to read.
StartAt string
}
Frame is one screen of a view, before it is laid out to a size.
type Group ¶
type Group struct {
Key string
Title Line
// Count is drawn after the title as " · n", where Counted says to.
Count int
Counted bool
// Cells draw on the columns past the first, which holds the title, so a group's
// totals line up with the rows under it.
Cells []Cell
// WrapLast is the last column as Row.WrapLast has it.
WrapLast Line
// Below are lines drawn under the header whether the group is folded or not. The
// cursor moves past them as one node.
Below []Line
// Span draws whole past the title on the header's line, wrapping under itself, so a
// long value never sets the first column's width. The cells then take a line of their
// own beneath it, and Beside sits ahead of them in the first column.
Span Line
// Beside is what the first column holds on a Span group's line of cells, under the
// Span's start. An Items line there is cut to fit.
Beside Line
// Under is the group's summary, wrapping on a └─ row under Below while those are on.
Under Cell
// Document draws under Below whether the group is folded or not, so a view can open
// a group's text in place. The cursor moves past it too.
Document Document
// Summary is drawn past the title while the group is folded.
Summary Line
Folded bool
// Gap draws a blank line after the group.
Gap bool
// Rule draws a thin line after the group, in place of Gap's blank one.
Rule bool
// Tone is the code the group's overline and underline draw in, where not the rule gray.
Tone string
// Overline draws a line across the table above the header.
Overline RuleWeight
// Underline draws a line across the table under the header, ahead of Below.
Underline RuleWeight
// Still keeps the header open with no fold mark, and the cursor passes over it. At
// the top of a frame it stays on screen with the column titles while the table scrolls.
Still bool
// Heading says the title only labels what sits under it, so the filter looks past it.
Heading bool
// FilterOnly keeps the group out of the table until a filter is typed, so a search
// reaches past what a view shows.
FilterOnly bool
Rows []Row
Groups []Group
Detail []Cell
// Panel is what the side panel shows in Detail's place, as Row.Panel has it.
Panel Document
// Text is more the filter matches beyond what the group draws.
Text string
// contains filtered or unexported fields
}
Group is a header carrying its count, with rows and groups under it.
type Keyed ¶
type Keyed interface {
Actions() []Action
}
Keyed is a Board with keys of its own. They are read ahead of the table's, so a view can add a key or take one over, and the footer and the ? overlay list them.
type Line ¶
type Line []Cell
Line is cells drawn one after another.
func Items ¶ added in v0.3.0
Items is a line of a Group's Below that the draw cuts to the items that fit, ending in +N for the rest, rather than letting the screen's edge cut one in half. The width it has moves with the side panel, so only the draw knows it. The filter and the change cue read every item, shown or not.
func ReadStatus ¶
ReadStatus is the one line a strip says about its reads. While every read is on schedule it says how old the newest is. A failed read is named in red with its reason, a late one in yellow, and a note follows plain, because a read that covered less still read. The screen's edge cuts them in that order.
type Model ¶
type Model struct {
// contains filtered or unexported fields
}
Model is the Bubble Tea program of one view. Tabs holds one per tab.
func NewModel ¶
func NewModel(board Board, pal gotermstyle.Palette) *Model
NewModel is a model reading board, sized until the terminal says otherwise.
func (*Model) Cursor ¶
Cursor is the key of the group or row the cursor is on, for a board's own keys.
func (*Model) HalfScreen ¶
HalfScreen is half the table's height in lines.
func (*Model) Read ¶ added in v0.6.0
Read opens document on a full-screen Reader over the board, until esc or space closes it. The reader's top line names the groups holding the cursor's line, then title.
func (*Model) Rebuild ¶
func (m *Model) Rebuild()
Rebuild is for a key that changed what the board shows from what it already holds.
func (*Model) Restart ¶
Restart puts the cursor back at the top and reads every source now, for a board's key that changes what the view shows.
func (*Model) Reveal ¶ added in v0.3.0
func (m *Model) Reveal()
Reveal scrolls the cursor's row and what opens under it into view, for a board's key that opens text under a row.
func (*Model) ScrollBy ¶
ScrollBy moves the screen over the table by lines and leaves the cursor, for reading through a row's detail taller than the screen. Moving the cursor ends it.
func (*Model) Tall ¶ added in v0.6.0
Tall says document runs past the screen, so enter reads it on a Reader.
func (*Model) Toggle ¶
Toggle is what enter does, for a board's key that takes enter and acts only on some rows: a row's Document that runs past the screen opens on a Reader, open in place or not, and anything else folds or opens in place. Bind it to enter alone and leave space to the table, which folds in place however tall the text. A row open in place that turns tall closes only on that space.
func (*Model) ToggleEveryRow ¶
ToggleEveryRow opens every showing row's detail, or closes them all where every one is open already, so a whole group reads as one document.
type MovingBoard ¶ added in v0.12.0
type MovingBoard interface {
// MoveEvery is how long the strip holds each drawing. Zero or less holds it still, and the
// next tick asks again, so a board with nothing moving spends nothing.
MoveEvery() time.Duration
// StripAt is the whole strip at now. It stands in for Frame.Strip on every draw, so a line
// holding still is returned as it is. A strip that changes its height redraws the table.
StripAt(now time.Time) []Line
}
MovingBoard is a Board whose strip moves between its frames, as a diagram of work in motion does. Only the strip redraws at this pace, so the table and its change cue wait for their frame. Only the tab showing runs it, and a reader over the board holds it.
type Reader ¶ added in v0.6.0
type Reader struct {
// CopyText is what y copies. Nil copies the text as drawn.
CopyText func() string
// EditFile is the file e opens in the editor, after which the text is laid out again.
// Empty leaves e unbound.
EditFile string
// contains filtered or unexported fields
}
Reader is a full screen over one Document. It lays out every row at the width and draws the window that fits, because Bubble Tea keeps only the last lines of a taller view. It runs as a program of its own, or a Model opens one with Read.
func NewReader ¶ added in v0.6.0
func NewReader(title string, document Document, pal gotermstyle.Palette) *Reader
NewReader is a Reader over document, sized until the terminal says otherwise.
func (*Reader) Once ¶ added in v0.6.0
Once is the whole document at width, for output nobody scrolls.
type Refresher ¶
type Refresher interface {
// Claim reports whether a read is due at now, and marks one under way.
Claim(now time.Time) bool
Refresh(ctx context.Context)
// Force makes the next Claim true.
Force()
Status() Status
}
Refresher is a Source with its value's type out of the way, for the loop that only starts reads.
type Row ¶
type Row struct {
Key string
Symbol Cell
Cells []Cell
Span Line
// WrapLast is the last column as cells of their own colors. It continues on
// further lines at that column, where a cell in Cells is cut at the screen's edge.
WrapLast Line
// Under is the row's summary, drawn on a └─ row while those are on.
Under Cell
// Detail is what the side panel shows while the cursor is on the row, and what opens
// under the row. Each cell is a paragraph that wraps. A row holding Detail or a
// Document draws a chevron in its indent.
Detail []Cell
// Document is what opens under the row and the side panel shows, in Detail's place.
Document Document
// StartsOpen shows the row's Detail or Document under it until a key closes it, so a
// view can draw its newest entry whole and still fold it to its first line.
StartsOpen bool
// Panel is what the side panel shows in place of both, each line wrapping at spaces
// with its cells' own colors.
Panel Document
// Text is more the filter matches beyond what the row draws.
Text string
// Marked draws MarkGlyph in the row's indent and its first cell in MarkCode. No
// column moves for it.
Marked bool
// contains filtered or unexported fields
}
Row is one line of the table: Cells on the columns, or Span across them.
type RuleWeight ¶ added in v0.8.0
type RuleWeight int
RuleWeight is how heavy a line across the table is drawn.
const ( RuleNone RuleWeight = iota RuleThin RuleDouble )
The weights a rule takes.
type Source ¶
type Source[T any] struct { // contains filtered or unexported fields }
Source is one read at its own interval, holding its last good value.
func NewSource ¶
func NewSource[T any](name string, every time.Duration, read func(context.Context) (T, string, error)) *Source[T]
NewSource declares a read. read answers the value, a note on what it could not cover, and a failure, which leaves the last good value in place.
func (*Source[T]) Claim ¶
Claim is Refresher's. A read still under way is never started twice, so a slow source falls behind rather than piling up.
type Status ¶
type Status struct {
Name string `json:"name"`
Every string `json:"every"`
ReadAt time.Time `json:"read_at,omitzero"`
Took string `json:"took,omitempty"`
TriedAt time.Time `json:"tried_at,omitzero"`
// Fault is why the newest try failed, and empty where it read.
Fault string `json:"fault,omitempty"`
// Note is what a read that succeeded could not cover, such as a host asleep.
Note string `json:"note,omitempty"`
// Reading says a read is under way.
Reading bool `json:"reading,omitempty"`
// contains filtered or unexported fields
}
Status is what a view says about one source, on its strip and in its --json.
type Tabs ¶
type Tabs struct {
// contains filtered or unexported fields
}
Tabs is the Bubble Tea program of one Model per tab, the Elm Architecture's composition. Each tab keeps its own cursor, folds and filter. A hidden tab starts no read, builds no frame and moves no strip. On its return it draws its last good read with that read's age, and whatever is due reads at once.
func NewTabs ¶
NewTabs is a program of these tabs, opening on the one named open, or the first where open is empty. A name no tab has is an error naming the ones there are.
Source Files
Directories
¶
| Path | Synopsis |
|---|---|
|
cmd
|
|
|
read-markdown
command
read-markdown draws a markdown file, or what is piped to it, on a full-screen reader.
|
read-markdown draws a markdown file, or what is piped to it, on a full-screen reader. |
|
Package markdown lays markdown out as a board's lines at a given width, in colors that follow the terminal's theme.
|
Package markdown lays markdown out as a board's lines at a given width, in colors that follow the terminal's theme. |