panels

type ActivePanel ¶

type ActivePanel struct {
	// contains filtered or unexported fields
}

ActivePanel renders calls currently being followed.

func NewActive() *ActivePanel

func (p *ActivePanel) HandleMouse(msg tea.MouseMsg, localY int) tea.Cmd

func (ActivePanel) Keys() []key.Binding

func (ActivePanel) Title() string

func (p *ActivePanel) Update(msg tea.Msg, s *state.SharedState) (Panel, tea.Cmd)

func (p *ActivePanel) View(width, height int, focused bool, s *state.SharedState) string

type DashboardPanel ¶

type DashboardPanel struct{}

DashboardPanel is the at-a-glance landing screen. It is a pure renderer over SharedState; it owns no local state.

func NewDashboard() *DashboardPanel

func (DashboardPanel) Keys() []key.Binding

func (DashboardPanel) Title() string

func (p *DashboardPanel) Update(_ tea.Msg, _ *state.SharedState) (Panel, tea.Cmd)

func (p *DashboardPanel) View(width, height int, _ bool, s *state.SharedState) string

type DevicesPanel ¶

type DevicesPanel struct {
	// contains filtered or unexported fields
}

DevicesPanel renders the SDR pool snapshot — every dongle the daemon has opened, with role / tuner / configured gain / PPM / bias-tee state.

func NewDevices() *DevicesPanel

func (p *DevicesPanel) HandleMouse(msg tea.MouseMsg, localY int) tea.Cmd

func (DevicesPanel) Keys() []key.Binding

func (p *DevicesPanel) Reveal(key string)

func (DevicesPanel) Title() string

func (p *DevicesPanel) Update(msg tea.Msg, s *state.SharedState) (Panel, tea.Cmd)

func (p *DevicesPanel) View(width, height int, focused bool, s *state.SharedState) string

type EventsPanel ¶

type EventsPanel struct {
	// contains filtered or unexported fields
}

EventsPanel renders the rolling SSE event log.

func NewEvents() *EventsPanel

func (EventsPanel) Keys() []key.Binding

func (EventsPanel) Title() string

func (p *EventsPanel) Update(msg tea.Msg, s *state.SharedState) (Panel, tea.Cmd)

func (p *EventsPanel) View(width, height int, focused bool, s *state.SharedState) string

type HistoryPanel ¶

type HistoryPanel struct {
	// contains filtered or unexported fields
}

HistoryPanel renders ended calls from /api/v1/calls/history.

Loading is on-demand: the root model issues the initial fetch when this panel becomes active and again when the user presses `r`. The panel does not poll continuously — history is a stable list and the daemon already paginates it.

Refresh is asynchronous: when the SharedState hash for History changes, Update returns a tea.Cmd that builds the new []table.Row slice off the Update goroutine. The result arrives back as a HistoryRefreshedMsg and is committed only when its hash still matches the latest snapshot — newer results win.

func NewHistory() *HistoryPanel

func (p *HistoryPanel) HandleMouse(msg tea.MouseMsg, localY int) tea.Cmd

func (HistoryPanel) Keys() []key.Binding

func (p *HistoryPanel) ReloadRequested() bool

func (HistoryPanel) Title() string

func (p *HistoryPanel) Update(msg tea.Msg, s *state.SharedState) (Panel, tea.Cmd)

func (p *HistoryPanel) View(width, height int, focused bool, s *state.SharedState) string

type HistoryRefreshedMsg ¶

type HistoryRefreshedMsg struct {
	Hash uint64
	Rows []table.Row
}

HistoryRefreshedMsg carries the result of an async refresh job. Exported so the root model can route it to the history panel.

type HuntPanel ¶ added in v0.3.5

type HuntPanel struct {
	// contains filtered or unexported fields
}

HuntPanel renders the live system-discovery ("hunt") run — its state, sweep/ identify progress, and the discovered system summary — and lets the operator start a run (bands to sweep + an optional name) or stop the active one.

func NewHunt() *HuntPanel

func (HuntPanel) Keys() []key.Binding

func (HuntPanel) Title() string

func (p *HuntPanel) Update(msg tea.Msg, s *state.SharedState) (Panel, tea.Cmd)

func (p *HuntPanel) View(width, height int, focused bool, s *state.SharedState) string

type ImportCommitMsg ¶ added in v0.1.5

type ImportCommitMsg struct {
	ID    string
	Force bool
}

ImportCommitMsg is emitted when the operator presses 'c' on the Preview view.

type ImportDiscardMsg ¶ added in v0.1.5

type ImportDiscardMsg struct {
	ID string
}

ImportDiscardMsg is emitted when the operator presses 'd' on the Preview view.

type ImportPanel ¶ added in v0.1.5

type ImportPanel struct {
	// contains filtered or unexported fields
}

ImportPanel is the live-import cockpit. Three views:

1. Stage — operator adds local file paths via a textinput; pressing 'u' uploads them to the daemon and we transition to Preview.
2. Preview — table of parsed systems returned by the daemon; 'c' commits, 'd' discards, esc returns to Stage.
3. Result — list of systems_added / systems_replaced; esc returns to Stage.

func NewImport() *ImportPanel

func (*ImportPanel) Keys() []key.Binding

func (*ImportPanel) Title() string

func (p *ImportPanel) Update(msg tea.Msg, shared *state.SharedState) (Panel, tea.Cmd)

func (p *ImportPanel) View(width, height int, focused bool, shared *state.SharedState) string

type ImportPreviewArrivedMsg ¶ added in v0.1.5

type ImportPreviewArrivedMsg struct {
	Preview client.ImportPreview
	Err     error
}

ImportPreviewArrivedMsg is consumed by the panel when the root model has received the staging response.

type ImportResultArrivedMsg ¶ added in v0.1.5

type ImportResultArrivedMsg struct {
	Result client.ImportResult
	Err    error
}

ImportResultArrivedMsg is consumed by the panel when a commit finishes.

type ImportUploadMsg ¶ added in v0.1.5

type ImportUploadMsg struct {
	Paths []string
}

ImportUploadMsg is emitted when the operator has confirmed an upload via 'u'. The root model resolves it into an HTTP call.

type MetricsPanel ¶

type MetricsPanel struct {
	// contains filtered or unexported fields
}

MetricsPanel surfaces a curated subset of /metrics. Showing every Prometheus series produced by the daemon would be noisy; this whitelist captures the headline counters operators usually care about.

func NewMetrics() *MetricsPanel

func (p *MetricsPanel) HandleMouse(msg tea.MouseMsg, localY int) tea.Cmd

func (MetricsPanel) Keys() []key.Binding

func (MetricsPanel) Title() string

func (p *MetricsPanel) Update(msg tea.Msg, s *state.SharedState) (Panel, tea.Cmd)

func (p *MetricsPanel) View(width, height int, focused bool, s *state.SharedState) string

type MouseAware ¶

type MouseAware interface {
	HandleMouse(msg tea.MouseMsg, localY int) tea.Cmd
}

MouseAware is an optional interface for panels that want to react to mouse events inside their body. localY is the row offset relative to the panel's top-left (0 = panel border row); msg carries the full bubbletea mouse payload so the panel can distinguish a left-click on a data row (move cursor) from a scroll-wheel tick (advance one row) from a button release (no-op). Returning a tea.Cmd is permitted but most implementations will return nil.

type Panel ¶

type Panel interface {
	Title() string
	Keys() []key.Binding
	Update(msg tea.Msg, shared *state.SharedState) (Panel, tea.Cmd)
	View(width, height int, focused bool, shared *state.SharedState) string
}

Panel is the contract every visible panel implements. Update may return a replacement Panel — bubbletea's Elm-style "return next state" pattern. Panels never call the network; they read from shared state populated by the root model's polling Cmds.

type Revealer ¶

type Revealer interface {
	Reveal(key string)
}

Revealer is an optional interface for panels that can pre-position their internal cursor on a specific row when the operator jumps in from the command palette. key is panel-defined: SystemsPanel takes a system name, TalkgroupsPanel a decimal ID, DevicesPanel a serial, ScannerPanel "sys:<name>" or "conv:<idx>".

type ScannerPanel ¶

type ScannerPanel struct {
	// contains filtered or unexported fields
}

ScannerPanel is the police-scanner cockpit. Renders three sections:

1. Systems (trunked) — per-system CC hunt state + last grant.
2. Conventional — fixed-frequency analog channels + current dwell.
3. TG scan summary — global scan_mode + scan-list size.

Operator mutations (hold / resume / retune / dwell / cycle scan mode) ride the existing WriteRequest machinery so the daemon's allow_mutations gate + the TUI's --write flag govern them.

func NewScanner() *ScannerPanel

func (ScannerPanel) Keys() []key.Binding

func (p *ScannerPanel) Reveal(key string)

"sys:<name>"   — trunked system by name
"conv:<index>" — conventional channel by zero-based index

func (ScannerPanel) Title() string

func (p *ScannerPanel) Update(msg tea.Msg, s *state.SharedState) (Panel, tea.Cmd)

func (p *ScannerPanel) View(width, height int, focused bool, s *state.SharedState) string

type SettingsErrorMsg ¶ added in v0.1.5

type SettingsErrorMsg struct {
	Field   string
	Message string
}

SettingsErrorMsg is dispatched by the root model when a Settings PATCH comes back with an error (validation failure, 503, etc.). The panel re-opens the editor on the failing row and surfaces the message inline so the operator can correct without re-navigating.

type SettingsPanel ¶

type SettingsPanel struct {
	// contains filtered or unexported fields
}

SettingsPanel is the tabbed inspector that surfaces every config knob, output, protocol surface, and runtime fact. Driven by SharedState.Runtime; one /api/v1/runtime poll feeds every tab so the operator sees a coherent snapshot.

func NewSettings() *SettingsPanel

func (SettingsPanel) Keys() []key.Binding

func (SettingsPanel) Title() string

func (p *SettingsPanel) Update(msg tea.Msg, s *state.SharedState) (Panel, tea.Cmd)

func (p *SettingsPanel) View(width, height int, focused bool, s *state.SharedState) string

type SystemDetailMsg ¶

type SystemDetailMsg struct{ Name string }

SystemDetailMsg is emitted by the Systems panel when the operator presses Enter on a row. The root model fetches the detail record via GET /api/v1/systems/{name} and renders a read-only modal.

type SystemsPanel ¶

type SystemsPanel struct {
	// contains filtered or unexported fields
}

SystemsPanel renders the configured trunking systems.

func NewSystems() *SystemsPanel

func (p *SystemsPanel) Cursor() int

func (p *SystemsPanel) HandleMouse(msg tea.MouseMsg, localY int) tea.Cmd

func (SystemsPanel) Keys() []key.Binding

func (p *SystemsPanel) Reveal(key string)

func (SystemsPanel) Title() string

func (p *SystemsPanel) Update(msg tea.Msg, s *state.SharedState) (Panel, tea.Cmd)

func (p *SystemsPanel) View(width, height int, focused bool, s *state.SharedState) string

type TalkgroupDetailMsg ¶

type TalkgroupDetailMsg struct{ ID uint32 }

TalkgroupDetailMsg is emitted by the Talkgroups panel when the operator presses Enter on a row.

type TalkgroupsPanel ¶

type TalkgroupsPanel struct {
	// contains filtered or unexported fields
}

TalkgroupsPanel renders all configured talkgroups with a substring filter and sort cycle.

func NewTalkgroups() *TalkgroupsPanel

func (p *TalkgroupsPanel) FilterValue() string

func (p *TalkgroupsPanel) HandleMouse(msg tea.MouseMsg, localY int) tea.Cmd

func (TalkgroupsPanel) Keys() []key.Binding

func (p *TalkgroupsPanel) Reveal(key string)

func (p *TalkgroupsPanel) RowCount() int

func (p *TalkgroupsPanel) SetFilterValue(v string)

func (TalkgroupsPanel) Title() string

func (p *TalkgroupsPanel) Update(msg tea.Msg, s *state.SharedState) (Panel, tea.Cmd)

func (p *TalkgroupsPanel) View(width, height int, focused bool, s *state.SharedState) string

type ThemeChangedMsg ¶

type ThemeChangedMsg struct{}

ThemeChangedMsg is broadcast by the root model after a palette swap. Panels that cache lipgloss styles (chiefly the bubbles/table-backed ones, which call SetStyles in their constructor) handle it by re-applying tableStyles() so the new palette takes effect on the next render. Read-only panels that fetch theme.Theme() on every View() can ignore it.

type TonesPanel ¶

type TonesPanel struct {
	// contains filtered or unexported fields
}

TonesPanel renders the tone-alert ring buffer.

func NewTones() *TonesPanel

func (p *TonesPanel) HandleMouse(msg tea.MouseMsg, localY int) tea.Cmd

func (TonesPanel) Keys() []key.Binding

func (TonesPanel) Title() string

func (p *TonesPanel) Update(msg tea.Msg, s *state.SharedState) (Panel, tea.Cmd)

func (p *TonesPanel) View(width, height int, focused bool, s *state.SharedState) string

type WriteActionMsg ¶

type WriteActionMsg struct{ Request state.WriteRequest }

WriteActionMsg is what panels emit to ask the root model to run a mutation. The root catches this exact type, so panels stay decoupled from the root's modal mechanics and HTTP client.

Exported so tests in other packages can assert on it; intended to be opaque to consumers.