io.worxbend.tui.widgets

Horizontal placement of a line inside the area it is drawn in — used by Paragraph for its text and by Block for its title. A line wider than the area is clipped from the right regardless of alignment.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Text with a time-based effect applied to it, drawn from how long the animation has been running.

Like every animation here, the frame is a pure function of elapsed, so a test renders any moment directly and the ambient AnimationClock drives it in an app with no counter to thread through.

style is the resting appearance and highlightStyle the emphasised one; an effect uses one, the other, or a blend, according to what it does.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: AnimatedText.type

A short inline label: a status tag, a count, a category.

One row, sized to its content — put it in a row beside the thing it labels. The badge clips rather than wrapping, because a badge that wrapped would stop reading as one.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: Badge.type

How a Badge is drawn. The three read at different volumes, which is the point of having three: a solid badge shouts, an outline badge sits inside prose, and a dot is almost silent.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Vertical bars with optional labels underneath: each (label, value) gets a barWidth-column bar scaled against max (defaulting to the data's maximum), topped with a partial block glyph for sub-cell precision.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: BarChart.type

Large banner text drawn with block glyphs from a built-in 3x5 pixel font (A–Z, 0–9, and common punctuation) — the splash-screen and header building block. Unknown characters render as blanks; lowercase maps to uppercase. Each glyph pixel is one terminal cell, glyphs are separated by one blank column.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: BigText.type

A bordered box with an optional title — the basic chrome widget almost everything else nests inside.

Borders are per-side (Borders.Top | Borders.Bottom for a horizontal band, Borders.All for the classic box); corner glyphs appear only where two adjacent sides meet. padding adds blank cells inside the borders on every side. Content belongs in inner(area); rendering the block never touches the interior, so it composes with any content widget drawn after it.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

The box-drawing set a Block frames itself with: ┌─┐, ╭─╮, ╔═╗, or ┏━┓.

All four are single-column glyphs, so the border never changes a block's Block.inner geometry — only its look.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Attributes

Supertypes: class Object

trait Matchable

class Any
Self type: Borders.type

A pressable control rendered as [ label ], centered in its area. Stateless — press handling lives with the caller (the DSL element activates on Enter/Space while focused).

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A month grid: title row, weekday header (weeks start Monday), and day numbers with an optional highlighted day.

Needs 20 columns (seven three-column day slots, the last one two wide) and 2 + weeks rows — the title, the weekday header, then one row per week the month touches, so up to 8. Overflow clips like everything else.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A free-form drawing surface: shapes describe themselves in a world coordinate system (xBounds right-ward, yBounds up-ward) and the canvas maps them onto its cell grid — at cell, half-block, or braille resolution.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

How many drawable sub-pixels one terminal cell contributes to a Canvas.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

An x/y chart with drawn axes; the plot region is a Canvas over the datasets' shapes.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A labeled checkbox. Stateless — the checked flag lives with the application (typically in a Signal).

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A color gradient sampled by a fraction in [0, 1] — what a progress bar uses to color its fill by how far along it is.

A named type rather than a (Color, Color) pair for two reasons: a tuple does not say which end is which, and two stops cannot express the most common progress ramp of all. Green through amber to red is three stops, and interpolating straight from green to red passes through a muddy brown rather than through amber.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: ColorRamp.type

Lays its items out top-to-bottom using the core constraint solver and renders each into its segment.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A sortable, filterable table with a selectable, scrollable body (the Tier 5 upgrade over Table).

The header shows a ▲/▼ indicator on the sorted column; the filter keeps rows where any cell contains the text (case-insensitive); sorting compares numerically when both cells parse as numbers, else as text.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait StatefulWidget[DataTableState]

class Object

trait Matchable

class Any
Show all

Caller-owned DataTable state: sort column/direction, a substring filter, selection, and scroll.

Selection indexes into the view (the filtered, sorted rows) — use DataTable.visibleRows to map it back to data.

Attributes

Companion: object
Supertypes: class Object

trait Matchable

class Any

Attributes

Companion: class
Supertypes: class Object

trait Matchable

class Any
Self type: DataTableState.type

One plotted series: points in world coordinates, drawn as a connected polyline or scattered markers.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

A modal-style dialog drawn over existing content: clears a centered box, borders it, renders the message and a row of buttons with one highlighted.

The widget owns no state and manages no stack of its own — it paints over whatever was drawn into the buffer before it, so rendering it last in the view is what makes it modal-looking. The DSL's Screen stack (TuiApp.pushScreen) builds on exactly that.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A filesystem browser (the Tier 5 filesystem-aware Tree): lazy-loaded directory listings with expand/collapse markers, /-suffixed directory names, selection highlight, and scroll-to-selection.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait StatefulWidget[DirectoryTreeState]

class Object

trait Matchable

class Any
Show all

Caller-owned DirectoryTree state rooted at a directory.

Directory listings are loaded lazily on first visibility and cached together with each entry's directory flag — the filesystem is only touched when a branch is first listed (or after invalidate), never while rendering or moving the selection. Unreadable directories degrade to empty.

Attributes

Supertypes: class Object

trait Matchable

class Any

Two sparklines sharing one area (top/bottom halves) for visually comparing a pair of series — e.g. ingress vs. egress. Each series scales independently unless a shared max is given.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A filled progress bar with a centered label; the fill spans the whole area height.

ratio is clamped to [0, 1] and NaN reads as no progress. The default label is the percentage.

fillRamp colors the fill by how far along it is. It replaces filledStyle's background — the fill is drawn as blank cells, so the bar's color is its background — and leaves everything else alone.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: Gauge.type

How a Dataset's points are drawn: Line joins consecutive points with segments, Scatter plots them alone.

Line follows the points in the order the dataset lists them — it does not sort by x, so an unsorted series draws as a zig-zag rather than a function plot.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

How a SpinnerGrid offsets each slot's animation from its neighbours'.

The offset is what turns a block of identical spinners into one moving thing, so this is the grid's whole character. The sign rule is uniform: a slot's offset is -distance * framesPerCell, so the feature travels away from distance zero, and a negative framesPerCell reverses it.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

A value grid rendered as shade intensity: each cell maps its value (against the grid's max) onto a shade ramp — rows are y (top first), columns are x.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: Heatmap.type

A raster image rendered with half-block cells: every terminal cell shows two vertical pixels (▀ with the upper pixel as foreground and the lower as background), the universally supported protocol from the reference ecosystems. Kitty/iTerm2/Sixel protocols remain out of scope.

pixels is row-major RGB; the image is scaled to the render area by nearest-neighbor sampling, preserving nothing but coverage — pre-scale for quality.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: Image.type

An indeterminate progress bar: a segment travelling along a track, advanced by phase.

The glyphs come from a ProgressStyle so a determinate and an indeterminate bar in the same view can be drawn from the same vocabulary, and the travel comes from an IndeterminateMotion.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

How an IndeterminateBar's segment travels. Indeterminate bars all say "working, no idea how long", but they say it at different volumes — pick by how much of the user's attention the task deserves.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

A language the highlighter understands. Highlighting is line-oriented (block comments and triple-quoted strings that span lines fall back to plain text), which is the right trade-off for the code snippets in help screens, READMEs and Markdown fences rather than a full editor.

Attributes

Companion: object
Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Attributes

Companion: enum
Supertypes: trait Sum

trait Mirror

class Object

trait Matchable

class Any
Self type: Language.type

One slot of a Row or Column: how much space the slot claims and what renders inside it.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

A one-row progress meter: a caption followed by a filled/unfilled line.

The glyphs come from a ProgressStyle, so a bar can step whole cells or move smoothly with sub-cell partials without this widget knowing which. ratio is clamped to [0, 1] and NaN reads as no progress.

fillRamp colors the fill by how far along it is. It overrides filledStyle's foreground and nothing else, so the modifiers set there still apply.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: LineGauge.type

Which way a linear spinner's track runs, and therefore which sub-cell axis carries its position.

The two are not symmetric, and the asymmetry is worth knowing before choosing one. A braille cell is 2 dots across and 4 down, so a horizontal track buys 2 positions per cell and can grade each over 4 brightness levels, while a vertical track buys 4 positions per cell and can grade each over 2. Horizontal moves in coarser steps and fades more smoothly; vertical is the other way round.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Which way a linear spinner travels. An enum rather than a signed rate or a reversed: Boolean, so a call site reads as a direction and a reversed spinner is greppable rather than a minus sign away from a typo.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

The walk a linear spinner's head takes along a one-dimensional track.

A path rather than two widgets: the animation is one head with a trail behind it, and only the walk differs. Each case owns its own cycle length and its own reading of LinearFlow, because the two are not reversed by the same operation — see positionAt.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

A head travelling a one-cell-thick track at sub-cell resolution, drawn from how long the animation has been running.

The row-or-column-shaped member of the animation family: where Spinner says "working" inside one glyph and OrbitSpinner says it in a block, this says it along a line — a status row under a log pane, or a column beside one. Like every animation here the frame is a pure function of elapsed, so a test renders any moment directly and an app with no tickRate still shows a legible first frame.

The three knobs are deliberately orthogonal, which is the difference from the obvious design: LinearPath is the walk, LinearTrail is the shading, trailSlots is the length. A bouncing head with a comet tail and a wrapping window of solid slots are the same widget with different arguments, rather than two modes in which half the options are silently ignored.

trailSlots counts sub-cell slots, not cells, because that is the resolution the motion happens at — at braille a horizontal track has two slots per cell, so the default four slots is two cells of tail.

rail is the resting brightness of the whole track on the same 0..1 scale as the trail. It is what turns an empty row into a visible track, and the rule at the meeting point is chosen rather than accidental: a slot is drawn in headStyle only where it is brighter than the rail, so a comet's tail dissolves into the track instead of ending on a hard edge. rail = 0.0 leaves the track empty and the head appears to float.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

How the slots behind a linear spinner's head are shaded.

Every case is a function of one number — how many steps ago the head was in that slot — because that is what makes a trail work on a bouncing path as well as a wrapping one. A trail defined by position behind the head has no answer at the turn, where "behind" flips; a trail defined by time simply folds back over itself, and the brighter sample wins.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

A clickable hyperlink (OSC 8): renders label underlined with the link attached — terminals without OSC 8 support just show the styled text.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Caller-owned list state: the selection and the scroll offset. Mutable on purpose — the widget adjusts the offset during render to keep the selection visible, and the app mutates the selection from key handlers (the StatefulWidget contract).

Attributes

Supertypes: class Object

trait Matchable

class Any

A scrollable list of single-row items with an optional highlighted selection.

Named ListView rather than the reference libraries' List to avoid colliding with scala.List at every call site.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait StatefulWidget[ListState]

class Object

trait Matchable

class Any
Show all

An append-only scrolling text panel (build/log output, chat transcripts).

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait StatefulWidget[LogState]

class Object

trait Matchable

class Any
Show all

Caller-owned Log state: a bounded ring of lines plus follow-tail scrolling.

While follow is on (the default), the view pins to the newest lines; scrolling up detaches it and scrolling back to the bottom re-attaches.

Attributes

Supertypes: class Object

trait Matchable

class Any

Renders a pragmatic Markdown subset: #/##/###+ headings, -/* bullets, 1. numbered items, > blockquotes, fenced code blocks, and inline **strong** / *emphasis* / `code`.

Inline [label](url) links render underlined with an OSC 8 target. Deliberately excluded: images, tables, and nested lists — this is a document viewer for help screens and READMEs, not a rendering-complete engine. Prose wraps at the area width (cluster-safe); code blocks render verbatim, except that a fence tagged with a Language the highlighter knows (```scala) is coloured through SyntaxHighlighter.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: Markdown.type

Styles for each Markdown construct; override individual entries to theme the view.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Text scrolling horizontally through the area (news-ticker style); the text wraps around with a gap between repetitions.

cellsPerSecond is a reading speed rather than a step count, so the same marquee scrolls at the same rate whatever the app's tick rate. Around 8 cells per second is comfortable to read.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A vertical menu / dropdown / context menu rendered as a bordered popup.

Labels sit on the left, shortcut hints right-aligned; the highlighted row draws with highlightStyle, disabled rows dim, separators become a full-width rule. Backend-agnostic and render-to-Buffer tested; the DSL wrapper adds focus, key, and mouse handling.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait StatefulWidget[MenuState]

class Object

trait Matchable

class Any
Show all

One entry in a Menu.

A separator renders as a horizontal rule and is never selectable; a disabled item renders dimmed and is skipped by keyboard navigation. shortcut is right-aligned hint text (e.g. ^S), never a live binding — the app wires the action.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: MenuItem.type

Caller-owned menu state: the highlighted index and the scroll offset for menus taller than their popup. Mutable on purpose (the StatefulWidget contract); navigation helpers skip separators and disabled entries.

Attributes

Supertypes: class Object

trait Matchable

class Any

One styled message line: an icon, an optional timestamp, and the message.

[12:04:31] ✔ deployed 8 services

The timestamp is passed in rather than read from the clock, because a widget that called LocalTime.now() would render differently on every frame — the frame would stop being a pure function of its inputs, golden-frame tests would be impossible, and a redraw triggered by something else entirely would silently change the displayed time. Stamp the message when the event happens, which is the moment the reader actually cares about.

A message longer than the area is clipped, not wrapped: see Notice.heightOf and pass wrap = true for a notice that should grow instead.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: Notice.type

The severity of a message to the user, shared by every surface that reports one — notices, toasts, and badges.

One enum rather than one per widget, because severity is the same idea everywhere and a second copy would drift: an app that maps its own error type onto a level should not have to map it again per widget.

The glyphs are deliberately from the geometric-shapes and dingbat blocks rather than emoji: emoji are two columns wide and inconsistently rendered, which makes a column of notices ragged.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

The closed loop an OrbitSpinner's arc travels.

A path rather than two widgets because the animation is identical — a bright window sliding along a loop — and only the loop differs. Both are rasterised by RingWalk into an ordered dot sequence, so sweep is a fraction of the lap on either of them and thickness falls out as the same lap at a smaller extent.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

A figure drawn at sub-cell resolution with a bright arc chasing round it, from how long the animation has been running.

The block-shaped counterpart to Spinner: where a one-cell spinner has to say "working" inside a single glyph, this has an area to say it in, so it is what a full-screen "connecting…" pane wants and what a status line does not. Like every animation here the frame is a pure function of elapsed — no state between renders, no clock read inside render, so a test renders any moment directly and an app with no tickRate shows a legible first frame.

radius is in DOTS, not cells, because that is the resolution the shape is drawn at — a radius in cells could not express the difference between the two smallest legible rings. Left unset the figure fills its area, staying round: an extreme aspect ratio yields a small centred ring rather than a squashed one, because a squashed circle reads as a wobble rather than as a rotation.

sweep is the fraction of the lap that is lit, not a dot count. A dot count makes the arc's apparent angle change with radius, which keeps radius and arc length from being independent knobs.

resolution and marker are the pair Canvas already ships, and reusing them is what gives this widget an ASCII floor: CanvasResolution.Cell with marker = "*" draws the same figure at a quarter of the vertical resolution on a terminal with no braille block. marker is read at that resolution only.

ONE STYLE PER CELL — the constraint this widget is shaped around. A braille cell packs eight dots and carries one Style, so dot resolution is 2x4 per cell while colour resolution is 1 per cell. Two rules follow, both chosen rather than fallen into. Masks are OR-ed, so a cell holding both arc and path dots keeps every dot and the resting path never erodes. Styles take the brightest dot in the cell, so such a cell reads as arc: the head is never overwritten by its own tail, and the quantisation error runs in one predictable direction — a cell can read brighter than it should, never dimmer, so the arc never appears to break. The budget, measured rather than estimated: the default radius-4 braille ring is 24 dots but only 11 cells, so a ramped comet shows 11 shades, not 24 (5 at the default sweep), and thickness buys geometry rather than colour. The alternative — one dot per cell, so colour and geometry agree — throws away the resolution braille was chosen for, and is rejected.

The consequence worth knowing before reaching for this on a monochrome terminal: because the mask never erodes, the glyphs are a pure function of the geometry and the whole animation lives in the per-cell style. A golden frame must therefore assert styles, not glyphs, and a terminal rendering neither colour nor dim shows a static ring.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: OrbitSpinner.type

How the travelling arc is shaded along its length.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

A compact page indicator: dots for small totals, page/total otherwise. Pages are 1-based for display.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Paints world-coordinate points into terminal cells for one Canvas render, accumulating sub-pixel hits and flushing them as glyphs.

Attributes

Supertypes: class Object

trait Matchable

class Any

Multi-line styled text with alignment and optional wrapping.

Wrapping breaks at grapheme-cluster boundaries (not word boundaries — good enough for v1 and never splits a wide character or emoji); without wrapping, long lines are clipped at the area edge.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: Paragraph.type

A filled pie: angular sectors proportional to each value, plus a legend when width allows.

Cells are roughly half as tall as they are wide, so the disc corrects the aspect ratio to look circular.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

What a progress meter writes beside its bar.

A named ADT rather than an Option[String], because that option had to carry three meanings — absent for the percentage, present for custom text, and present-but-empty for no caption at all. The third is the kind of sentinel a reader cannot guess and a type cannot check, and it forced the widget to treat Some("") specially anyway.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

The glyph vocabulary a progress bar draws with: what a filled cell looks like, what an empty one looks like, and optionally how to draw the cell the boundary falls inside.

partials is what separates a bar that steps a whole cell at a time from one that moves smoothly. Ordered narrowest to widest and excluding fill itself, it lets a bar show progress finer than its own cell grid: eight partial blocks turn a 20-column bar into 160 distinguishable positions. Leave it empty and the bar rounds to whole cells, which is the right choice for vocabularies with no partial glyphs (#, =) and for a bar one or two cells wide, where a partial glyph reads as noise.

That distinction is also why the two cases round differently, and it is deliberate: with partials the fill is floored and the remainder becomes the boundary glyph, so the bar never claims progress that has not happened; without them it rounds to nearest, because that is the closest a whole cell can get.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: ProgressStyle.type

A vertical set of mutually exclusive options, one marked (•). Stateless — selection lives with the app.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Lays its items out left-to-right using the core constraint solver and renders each into its segment.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A separator line with an optional inline label: ── label ─────. Vertical rules ignore the label.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A vertically scrollable window over content taller than the viewport.

The content renders at its full contentHeight into an offscreen buffer each frame; the visible window is blitted into place and a scrollbar drawn on the right edge when the content overflows. Content height is explicit (the caller knows its data) — an intrinsic-measure pass is future work.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait StatefulWidget[ScrollViewState]

class Object

trait Matchable

class Any
Show all

Caller-owned scroll offset for a ScrollView.

Attributes

Supertypes: class Object

trait Matchable

class Any

A scrollbar strip: a vertical bar on the area's right edge or a horizontal bar on its bottom edge.

The thumb's size is proportional to how much of the content the track (viewport) covers; when the content fits entirely, only the track is drawn.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait StatefulWidget[ScrollbarState]

class Object

trait Matchable

class Any
Show all

Caller-owned scrollbar state: total content length (in rows/columns) and the current scroll position.

Attributes

Supertypes: class Object

trait Matchable

class Any

A single-line option cycler (◀ value ▶). Stateless — the selected index lives with the application; left/right key handling belongs to the caller (or the DSL wrapper).

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Something drawable on a Canvas in world coordinates.

Attributes

Companion: object
Supertypes: class Object

trait Matchable

class Any
Known subtypes: class CircleShape

class Points

class Polyline

class RectangleShape

class SegmentShape

Attributes

Companion: trait
Supertypes: class Object

trait Matchable

class Any
Self type: Shape.type

A pulsing placeholder for content that has not loaded yet (skeleton screen): a base shade with a brighter band sweeping through, positioned from how long the animation has been running.

period is one full sweep, in wall-clock time, so the sweep takes the same time whatever the app's tick rate and whatever the widget's width. bandWidth defaults to a fifth of the area, which keeps the highlight proportional to whatever the skeleton is standing in for; give it an explicit width when several skeletons of different sizes need to pulse in step.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A one-row value slider: ├───●──────┤ proportional to value within [min, max].

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Renders nothing — claims layout space to push siblings apart.

Attributes

Supertypes: trait Singleton

trait Product

trait Mirror

trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all
Self type: Spacer.type

A compact bar-per-column chart using the eight block-element glyphs, scaled over the full area height.

Each data point maps to one column, oldest first; excess points are clipped on the right. max overrides the scale ceiling (defaults to the data's maximum).

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: Sparkline.type

Which way round an orbit travels. An enum rather than a signed rate or a reversed: Boolean, so a call site reads as a direction and a reversed orbit is greppable rather than a minus sign away from a typo.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

An animation frame indicator, drawn from how long the animation has been running.

Stateless by design: the frame is a pure function of elapsed, so nothing here retains state between renders and a test can render any moment directly. Elapsed time rather than a tick count is what makes a preset portable — the same spinner reads the same in an app ticking every 50ms and one ticking every 200ms.

The glyph and the label are styled separately, because they carry different weight: the glyph is the moving part and usually takes the accent color, while the label is ordinary text. labelStyle defaults to style.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A block of slots all running the same SpinnerPreset, each offset in time from its neighbours, so the block reads as one animation rather than as many.

It consumes the preset catalogue rather than extending it, and that is the point of it existing: a preset is a function of time alone and can never carry a spatial offset, while every preset already in the catalogue — braille, block, emoji, and the ASCII ones — becomes an area-filling animation the moment it is put here. SpinnerPreset.Line is this family's ASCII floor.

This is also the one place in the animated family where per-slot colour is free: every slot holds exactly one frame, so ramp shades the block by phase without any of the one-style-per-cell compromise OrbitSpinner has to make.

A slot is preset.width columns wide, so a two-column emoji preset gives half as many slots across rather than overwriting its neighbour. An area narrower than one slot draws nothing rather than a clipped half-glyph.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

One named spinner animation: the frames to cycle through and how long each frame holds.

Frames are reported padded to width, the widest frame's display width, so a spinner whose frames differ in width does not shove its label back and forth every tick. That is the whole reason this is a type rather than a bare Seq[String]: the padding needs the frame set to compute, and a caller passing raw frames cannot do it.

frameDuration is wall-clock, not a tick count, and that is deliberate. A preset cannot see the app's tick rate, so a speed expressed in ticks means the same preset reads as sluggish under tickRate = 200.millis and frantic under 50.millis. Holding each frame for a duration makes an animation look the same in every app that shows it, and lets a slow-ticking app still get a smooth spinner by ticking faster only while one is on screen.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

The built-in spinner animations.

Grouped by the glyph repertoire they need, because that is what decides whether a preset is safe on a given terminal: AsciiPresets need nothing, BraillePresets and BlockPresets need a font with the Unicode blocks, and EmojiPresets need color emoji and take two columns per frame.

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: SpinnerPreset.type

Bars stacked from multiple series: each (label, values) column stacks one segment per series, scaled against the tallest stack.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A pragmatic, dependency-free syntax highlighter: a per-language scanner turns a line of code into styled Spans. Recognises line comments, single-line strings, numbers, per-language keywords, name( call sites, and $variables (shell). Backend-agnostic and unit-tested against the produced spans.

Attributes

Supertypes: class Object

trait Matchable

class Any
Self type: SyntaxHighlighter.type

Styles for each token kind a SyntaxHighlighter emits; override entries to re-theme.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Rows of cells laid out in columns sized by the core constraint solver.

Each row is one terminal row (no cell wrapping); rows past the area's bottom edge are clipped, matching the library-wide silent-clipping philosophy.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A single-row tab bar: titles separated by a divider, the selected title highlighted.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A multi-line text editor view: vertical and horizontal scroll follow the cursor, which renders as a highlighted cell (showCursor = false for unfocused areas). No syntax highlighting.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait StatefulWidget[TextAreaState]

class Object

trait Matchable

class Any
Show all

Caller-owned multi-line editing state (the Tier 5 editor model).

Text is a vector of lines, each a vector of grapheme clusters — the cursor is (line, column) in cluster coordinates and can never split a combining sequence or emoji. Every editing operation snapshots onto a bounded undo stack.

Control characters other than the \n that separates lines are dropped on the way in — by the constructor as well as by insert — because a control is zero columns wide but still fills a whole Cell, so storing one desynchronises the backend's cursor model from the terminal's.

Attributes

Companion: object
Supertypes: class Object

trait Matchable

class Any

Attributes

Companion: class
Supertypes: class Object

trait Matchable

class Any
Self type: TextAreaState.type

What an AnimatedText does to its content over time.

Each case carries its own knobs rather than AnimatedText carrying the union of all of them, so a call site cannot set a typewriter's cursor on a shimmer and quietly have it ignored.

Attributes

Supertypes: trait Enum

trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

A single-line text input with horizontal scrolling and an optional visible cursor.

The cursor is drawn by styling the cluster under it (or a trailing space) with cursorStyle — pass showCursor = false for unfocused inputs so only the focused field shows a cursor.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait StatefulWidget[TextInputState]

class Object

trait Matchable

class Any
Show all

Caller-owned single-line editing state. The text is stored as grapheme clusters, so the cursor can never land inside a combining sequence or split an emoji; the cursor is a cluster index in [0, length] (the top value meaning "append here").

Control characters are dropped on the way in — by the constructor as well as by insert, because a field is just as often seeded from a file or an HTTP response as it is typed into. A control is zero columns wide but still fills a whole Cell, so storing one desynchronises the backend's cursor model from the terminal's.

Attributes

Supertypes: class Object

trait Matchable

class Any

A labeled on/off switch. Stateless — the flag lives with the application.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A small bordered popup of help text, meant to be layered near the thing it describes.

Stateless: it draws itself into whatever area it is given. Use width/height to size the overlay before placing it (the DSL tooltip helper anchors one next to a focused element).

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait Widget

class Object

trait Matchable

class Any
Show all

A collapsible tree with keyboard-driven selection: branch markers (▸ collapsed, ▾ expanded), two-column indentation per depth, and ListView-style scroll-to-selection.

Attributes

Companion: object
Supertypes: trait Serializable

trait Product

trait Equals

trait StatefulWidget[TreeState]

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: Tree.type

A node of a Tree: a label plus child nodes.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Caller-owned tree state: which branch paths are expanded, the selected path, and the scroll offset. Paths address nodes by child index at each level (Seq(1, 0) = second root's first child).

Attributes

Supertypes: class Object

trait Matchable

class Any

io.worxbend.tui.widgets

Members list

Type members

Classlikes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes