ui

type BranchFunc func(*text.Buffer) string

type Frame struct {
	// Tree arranges the windows. Required.
	Tree *view.Tree
	// Active is the window holding the cursor, unless the minibuffer does.
	Active *view.Window
	// Echo is the bottom row: an echo-area message, or the minibuffer's prompt
	// and contents when MiniOn.
	Echo string
	// MiniPt is the cursor's display column within the echo row, counted from
	// the left edge of the screen, so the caller decides how the prompt and the
	// text it has typed combine.
	MiniPt text.ColIdx
	// MiniOn reports whether a minibuffer prompt is active, which is what moves
	// the cursor to the echo row.
	MiniOn bool
	// Panels are drawn over the tiled frame, in slice order, so a later panel
	// overlaps an earlier one. They are not part of the split tree and so cannot
	// disturb its layout; view.PlacePanel decides where each one sits.
	Panels []Panel
	// CursorSet moves the cursor to CursorX, CursorY in absolute screen
	// coordinates, overriding both the active window and the echo row.
	//
	// It exists because a prompt can render inside a panel, and neither of the
	// other two can express that: MiniPt addresses a column of the echo row, and
	// the window path derives its position from point in a buffer. The caller
	// that drew the prompt into a panel already knows the exact cell, so it says
	// so rather than the renderer inferring it.
	CursorX, CursorY int
	CursorSet        bool
	// NameOf reports what each buffer is called, for the modeline. Optional: a
	// nil NameOf falls back to naming a buffer after its file, which is all the
	// renderer can work out on its own. See NameFunc.
	NameOf NameFunc
	// SpansOf reports how each line is classified, for syntax colour. Optional:
	// a nil SpansOf draws the text uncoloured. See SpansFunc.
	SpansOf SpansFunc
	// TypeOf reports each buffer's file type, and BranchOf the git branch its
	// file sits on, for the modeline's segments. Both optional: a nil source
	// simply contributes no segment. See TypeFunc and BranchFunc.
	TypeOf   TypeFunc
	BranchOf BranchFunc
	// ListingOf reports which buffers are listings rather than text. Optional:
	// a nil ListingOf treats every buffer as text. See ListingFunc.
	ListingOf ListingFunc

	// MiniRows lays a prompt's candidates out the emacs way, as Vertico does:
	// the prompt on its row and the candidates on the rows below it, down to
	// the bottom of the screen, full width. The windows give up the rows this
	// takes rather than being drawn over, so every window and its modeline stay
	// whole above the minibuffer. Empty means the minibuffer is the single echo
	// row. See also MiniNote.
	MiniRows []PanelLine
	// MiniNote is drawn quietly at the right-hand end of the prompt row, when
	// it fits beside what is typed: the candidate count.
	MiniNote string
}

type ListingFunc func(*text.Buffer) bool

type NameFunc func(*text.Buffer) string

type Panel struct {
	Rect view.Rect
	// Title is set into the top border when non-empty. It is styled as border
	// rather than as content, because it labels the panel; anything the user is
	// meant to read or edit belongs in a Line.
	Title string
	Lines []PanelLine
}

type PanelLine struct {
	Text string
	// Match holds rune indices within Text to emphasise, ascending, as
	// fuzzy.Match.Indices reports them. They are rune indices and not columns:
	// after a wide glyph the two diverge, and emphasising by column would light
	// the wrong cell. Indices outside Text are ignored rather than fatal, since
	// they arrive from another package.
	Match []int
	// Selected marks the row the user is currently on, which is filled across
	// the whole interior so it reads as a bar rather than stopping at the end of
	// its text.
	Selected bool
	// Icon, when not zero, is drawn before Text with a space after it, in the
	// colour IconClass has in the syntax palette. It is not part of Text, so
	// Match indices and the candidate a prompt returns are unaffected.
	Icon      rune
	IconClass syntax.Class
	// Spans colour parts of Text by syntax class, for a row that is more than
	// one thing - a key and the command it runs. Rune indices, as Match.
	Spans []syntax.Span
}

type Screen struct {
	tcell.Screen
}

type SpansFunc func(b *text.Buffer, line int) []syntax.Span

type Theme struct {
	// Text area, applied via tcell directly.
	Text  tcell.Style
	Trunc tcell.Style
	// ParenMatch styles both halves of a matched bracket pair, ParenMismatch a
	// bracket whose partner is missing or of the wrong kind. Match is marked by
	// weight and an underline rather than by a hue, so it needs no colour and
	// cannot clash with a terminal palette; a mismatch borrows the accent,
	// since an unclosed bracket is the other thing worth interrupting you for.
	ParenMatch    tcell.Style
	ParenMismatch tcell.Style
	// LineNumbers turns the gutter on. It is on by default: a line number is
	// the one piece of chrome you want in view constantly rather than on
	// request, and every editor people arrive from shows them.
	//
	// The numbers live only here, in the renderer. They are never in the buffer,
	// so a region cannot reach them and C-w cannot copy them - the gutter is
	// drawn outside the span handed to drawLine, which is what makes that
	// structural rather than a rule someone has to remember.
	//
	// LineNumber is quiet for the same reason inactive buffer names are: it is
	// secondary information you read only when you are looking for it.
	// LineNumberCurrent marks the line point is on, using the terminal's own
	// foreground plus weight rather than a colour, so it reads correctly on a
	// light or a dark background without nem knowing which it is on.
	LineNumbers       bool
	LineNumber        tcell.Style
	LineNumberCurrent tcell.Style

	// Region styles the cells between point and the mark.
	//
	// A selection is the one thing in the editor that legitimately needs a
	// background: a span cannot be indicated with a foreground alone. That sits
	// against the palette's rule that nothing paints a background, which exists
	// so nem works on a light or a dark terminal without knowing which it is on.
	//
	// Reverse resolves it. Swapping foreground and background guarantees correct
	// contrast on any palette because it adapts to the palette rather than
	// guessing at it, and an inverted span is the universal terminal convention
	// for a selection.
	//
	// This is deliberately not a contradiction of dropping reverse video from
	// bracket matching. Reverse as decoration - marking something that is merely
	// interesting - is the dated tell. Reverse as selection is what it means
	// everywhere, and is the only palette-independent way to mark a span.
	Region tcell.Style

	// Panels - the completion list and prefix-key discovery - are drawn cell by
	// cell rather than through Lip Gloss, because they need to emphasise
	// individual runes inside a row and to clip a wide glyph at the border.
	//
	// PanelBorder is the same hairline as the modeline rule and the pane divider,
	// so all of nem's chrome reads as one system rather than three.
	//
	// PanelSelected marks the row the user is on, and is reverse for exactly the
	// reason Region is: it is a selection, and swapping foreground and background
	// adapts to the terminal's palette instead of guessing at it.
	//
	// PanelMatch emphasises the runes a fuzzy query matched. Weight alone,
	// deliberately: it composes with PanelSelected's inversion instead of
	// fighting it, it needs no colour so it cannot clash with a palette, and it
	// leaves the single accent spent where it belongs - on unsaved changes.
	PanelBorder   tcell.Style
	PanelSelected tcell.Style
	PanelMatch    tcell.Style
	// ListCursor is the bar across the row point is on in a listing buffer. It
	// is the panel's selected row in another place - the same act of picking
	// one item from a list - so it is reverse for the same reason.
	ListCursor tcell.Style
	// MiniNote styles the candidate count beside a prompt at the bottom of the
	// screen: quiet, since it is secondary to what is being typed.
	MiniNote tcell.Style

	// Chrome, rendered through Lip Gloss and blitted in. The modeline is built
	// from four separately styled segments rather than one flat bar, which is
	// what lets focus read as weight instead of as a block of colour.
	//
	// ModelineName carries no colour on purpose: the focused buffer name uses
	// the terminal's own foreground, so it is the most legible thing on screen
	// whatever palette you run.
	ModelineName    lipgloss.Style
	ModelineNameOff lipgloss.Style
	ModelineRule    lipgloss.Style
	ModelinePos     lipgloss.Style
	ModelineMark    lipgloss.Style

	Divider lipgloss.Style
	// Echo styles a transient message, which is quiet to read as ephemeral.
	Echo lipgloss.Style
	// Mini styles an active minibuffer prompt. It is deliberately not quieted:
	// text being typed is ordinary content, not a passing notice.
	Mini lipgloss.Style

	// Syntax enables colouring the text area from a SpansFunc. Off restores
	// exactly the uncoloured rendering.
	Syntax bool
	// SyntaxStyle maps a syntax.Class to its style. Foregrounds only: see
	// defaultSyntaxStyles and the note above about never painting a background.
	SyntaxStyle [numSyntaxClasses]tcell.Style

	// ScrollMargin is the rows of context kept around point.
	ScrollMargin int
}

type TypeFunc func(*text.Buffer) string