Teksilo Widget Catalog

A categorized index of every widget that ships in the workspace. One line per widget; the source link is the authoritative reference. For full public API surfaces (struct, builder methods, enums, module doc) of one or more widgets, run python3 tools/extract_widget_api.py <Widget…> or --all for everything.

For per-subsystem docs (data binding, accessibility overrides, animation, drag-and-drop, multi-window, settings, i18n, theming, shortcuts/intents/actions), see SUMMARY.md.

Styling status

All 33 themable widgets are on the four-tier styling system (docs/styling-system.md): each ships a *Style trait in teksilo-core::styles::* plus a default Recipe*Style impl in teksilo-widgets/src/styles/*. The widget builds its parts, hands a *StyleConfig to the active style, and uses the returned WidgetId as its root child — no themable widget self-paints. Style resolution is per-call .style(impl FooStyle) → theme-wide theme.style_slots.<slot> → recipe default.

The 17 legacy per-widget dimension structs in teksilo-tokens::components were deleted; their IntUI constants now live in the matching teksilo-widgets/src/styles/recipe_*_style.rs modules. The dimension data for non-themable widgets (toolbar, status bar, dialog, accordion, badge, progress bar, table, …) lives directly in those same recipe_*_style.rs modules as pub const blocks. Three sibling preset crates ship — Material 3 (theme-material3), Fluent / Windows 11 (theme-fluent) and macOS Aqua (theme-macos). Image-backed styles, the ImageTheme TOML loader, and a GTK4-Adwaita preset are still pending.

End-to-end demo of the slot bag + per-call override: see examples/theme_styles/.

Layout primitives — crates/teksilo-widgets/src/primitives/

The composable building blocks of every widget tree. See layout-primitives.md for the layout protocol, slack distribution math, and worked examples.

• HStack — horizontal stack with cross-axis alignment, spacing, and slack distribution.
• VStack — vertical stack; same model.
• ZStack — overlay stack at a shared origin with two-axis alignment.
• Grid — fixed/fr/auto track grid (TrackSize); explicit cell placement.
• Wrap — flow layout that wraps to new rows when out of width.
• MasonryLayout — variable-height grid packing into the shortest column (Pinterest-style).
• ColumnFlow — newspaper columns whose count follows the available width: drops a column and re-partitions every child as the width shrinks. Contiguous source-order runs, so reading and focus order stay correct at every count; min/max_column_width, max_columns, column_rule, opt-in semantic_list, reactive column_count_signal(). Pair with a ScrollArea for vertical overflow.
• FormLayout — labelled rows with column alignment for settings panels.
• Center — centers a single child within the space it is given (fills a bounded axis, shrink-wraps an open one; flex = 0, so it does not claim stack slack — wrap in Expand for that).
• Expand — flex-basis-zero workhorse for ratio splits and full-bleed children.
• Shrinkable — shrink counterpart to Expand: opts a child into compression (down to a min floor) when a stack is over-constrained. Native shrink covers single-line / ellipsis text; controls (Button etc.) stay rigid and overflow via Toolbar.
• Padding — uniform or per-edge inset around a single child (propagates flex/shrink/min).
• Spacer — flexible empty space that consumes slack via flex = 1.0.
• Divider — 1 dp themed line, horizontal or vertical.
• FixedSize — pins width/height regardless of parent proposal.
• MinSize — clamps response to a floor (touch-target enforcement, etc.).
• MaxSize — clamps response to a ceiling.
• AspectRatio — constrains a child to a fixed width-to-height ratio.
• Switcher — shows one of N children, driven by Signal<usize>.
• DeadZone — layout-transparent gesture dead zone: a press inside it never arms a drag/swipe on an ancestor. Wrap interactive controls (buttons, a ⋮ menu) inside a draggable/swipeable container (a dock-panel header, a card, a list row) so clicking them — even with click jitter — can't start the ancestor's drag. The framework counterpart of Electron's -webkit-app-region: no-drag; backed by the node-level gesture_dead_zone flag (robust by construction, not a recognizer-timing race).
• FocusScope — layout-transparent Tab traversal boundary (lives at crate root). Scopes its descendants' tab_index so sibling regions don't interleave, and traps or passes Tab via TraversalScopePolicy::{Cycle, Continue}. See events-and-gestures.md §6.1.

Visual primitives

Direct draw surfaces with no internal composition.

• RectWidget — themed rectangle (background, border, corner radius); reactive bindings.
• TextWidget — single-line text via the TextBackend; reactive content + color.
• IconWidget — vector icon rendered through the path atlas; IconMode for tinted vs. raw.
• ImageWidget — bitmap with ImageFit (fill / contain / cover / none / scale-down).
• ImageMask — CPU-side anti-aliased alpha mask (ImageMaskShape); used by Avatar and other shaped-image patterns.
• ValidationStrip — inline error/warning/success strip under a field.
• TextInputField — primitive single-line editable text used inside the higher-level field widgets.
• TwistArrow — small chevron that indicates and toggles a tree node's expansion (used by TreeView / TreeTableView).

Containers and chrome

Themed framing, sectioning, and window-level structure.

• Panel — themed background + border + corner radius + padding.
• Card — elevated panel with shadow and optional header/footer slots.
• GroupBox — labelled bordered group for related controls.
• GroupHeader — section header (label + trailing rule line) for settings forms.
• Toolbar — command bar (ToolbarAction/ToolbarItem) with automatic overflow: excess actions collapse into a ⌄ MenuList popover (Qt extension / NSToolbar overflow / WinUI CommandBar). Per-action overflow priority, always_overflow, toggle, pinned custom widgets, collapsible custom widgets (overflow_as menu row / overflow_widget live embedded control / the ToolbarOverflow trait), separators, flexible space, display mode, orientation, is_overflowing(). Full ARIA toolbar a11y (Role::Toolbar + orientation, roving tab-index + arrow nav, chevron HasPopup::Menu, no AT duplication of overflowed items). Built on LayoutContext::measure_intrinsic. Reference: docs/toolbar.md.
• StatusBar — bottom-of-window status text strip with Role::Status.
• Banner — persistent inline info / success / warning / error strip (BannerSeverity); Role::Status + Live::Polite.
• DropZone — standalone "drop files here" target for external (OS) drag-and-drop; accept_extensions filter, allow_multiple, on_files_dropped / on_text_dropped / on_urls_dropped, keyboard Browse fallback; Tier-3 DropZoneStyle, Role::Group + Live::Polite. See drag-and-drop.md §11.4.
• DropTarget — wrapping drop container: turns any child into a drop target without hiding it (the child stays fully visible; the highlight is a border, not a fill). Reacts to internal (typed DragPayload) and external drops; optional centered hint popup; accept_external_* / accept_typed::<T> / accept_when filters, on_drop / on_drop_typed::<T>, targeted_signal (SwiftUI isTargeted pattern); Tier-3 DropTargetStyle, Role::Group. See drag-and-drop.md §11.6.
• Accordion — vertically stacked collapsible sections, multiple-open allowed.
• ToolBox — vertically stacked collapsible pages, exactly one expanded (Qt QToolBox analog).
• ScrollArea — viewport with overlay or permanent scrollbars (ScrollBarMode, ScrollBarPolicy).
• ScrollBar — standalone scrollbar, drag/track-click/keyboard.
• Splitter — N-pane resizable splitter with draggable, collapsible dividers, per-pane stretch, and a serializable SplitterModel. See docs/splitter.md.
• DockingLayout — VS Code-style dockable layout: a centre slot + 4 collapsible/splittable/draggable side regions (leading/trailing/top/bottom), per-corner ownership, activity rail, drag-to-dock five-zone overlay, and a serializable DockingModel. See docs/docking.md.
• TabWidget — tab bar + content switcher; data-source-driven TabBar<T> underneath. See tab-widget.md.
• Stepper — embeddable step-flow widget (Material / Ant / Flutter "stepper"): horizontal or vertical, linear or non-linear, per-step completion state.
• Wizard — thin modal launcher built on Stepper: a multi-step flow with header, footer, and step switching.
• Breadcrumb — clickable path segments with chevron separators (BreadcrumbItem). Automatic overflow: when too narrow the middle crumbs collapse into a trailing-of-root … MenuList dropdown (Windows Explorer / web breadcrumb pattern) while the root + current crumb stay; is_overflowing() signal. RTL-aware separators (chevron mirrors). Built on measure_intrinsic + MenuList::item_when.
• TitleBar — custom window title bar with drag region, resize strip, and window controls. See title-bar.md.

Buttons

• Button — seven ButtonVariants (Filled / Tinted / Outlined / Plain / Ghost / Link / Destructive) × five interaction states; IconLocation for leading/trailing icon; chrome via the ButtonStyle trait (see Styling status above). Reference exemplar — read the source.
• IconButton — square icon-only button at five IconButtonSize steps (Compact / Default / Toolbar / Large / Hero). .embedded() mode for trailing-slot use inside fields. Includes BuiltInIcons factory.
• CommandLinkButton — large two-line CTA: leading icon + bold title + secondary description; flat surface.
• PopoverButton — Button preset that opens a Popover when activated.
• PopoverIconButton — IconButton variant of the same.
• SplitButton — main action region + chevron region that opens a related-actions menu.

Inputs and indicators

• Checkbox — two-state and tristate (CheckState).
• RadioButton — single radio, bound to a shared value via RadioGroup for mutual exclusion.
• RadioTile / RadioTileGroup — "selectable card" radios: icon + title + inline radio + wrapping description. N-ary group with TileLayout::{Row, Grid, Column, Vertical} (equal-size cards, adaptive wrapping grid, or a compact settings list with trailing meta), a WAI-ARIA roving radiogroup keyboard, and Role::RadioGroup + per-tile Role::RadioButton.
• Toggle — on/off control; four ToggleVariants (Switch / Pill / Square / Inset) via the ToggleStyle trait.
• Slider — horizontal or vertical, optional stepping.
• SegmentedControl — segmented chooser keyed by SegmentId (so a contributed segment can't re-point the selection); segments that don't fit overflow into a chevron menu, with the selected one always visible; RadioGroup AT role. See segmented-control.md.
• ComboBox — selection-only dropdown; virtualized via ListView past max_visible_items.
• FontPicker — lists/searches/filters all installed fonts with per-row in-font samples; spacing + writing-system filters (off-thread coverage index). See font-picker.md.
• ProgressBar — determinate or indeterminate; linear.
• Spinner — circular-arc loading indicator on the shader-driven AnimatedQuadKind::SpinnerArc pipeline; honours prefers-reduced-motion.
• Link — typographic hyperlink with hover and visited states.
• Badge — passive count/label pill.
• Avatar — user identity (image / initials fallback / hash-derived tint); circular / rounded-square / square shapes; presence indicator with corner positioning.

Text input family

• TextInput — styled single-line input on top of TextInputField; ValidationState.
• RichTextEditor — full editing surface with IME, formatting commands, undo/redo, intrinsic-mode sizing (min_lines / max_lines); also runs read-only as the rich-text viewer (ScrollPolicy).
• CodeEditor / PlainTextEditor — multi-line source / plain-text editors over one core: gutter, current-line band, injected language-agnostic indentation / comment / bracket handling, multiple carets, caret-anchored completion, paragraph/run accessibility. See docs/code-editor.md.
• LogView — read-only, append-only, tail-following streaming view scaling to 100k+ lines via windowed layout; derived follow-tail, scrollback cap, injected per-line severity colour, windowed accessibility. See docs/log-view.md.
• SpinBox — numeric input with WrapMode, StepType, ButtonLayout, WheelMode, WidthPolicy.
• SearchField — TextInput preset with leading magnifier glyph and clear-X; Role::SearchInput.
• PasswordField — secure entry with an embedded reveal toggle, character masking, Caps Lock warning, and clipboard protection. EchoMode (Masked / NoEcho / RevealWhileTyping), RevealMode (Toggle / Hold / None), AtRevealPolicy (SwapRole / AlwaysProtected). Masks at the text-engine layer (Role::PasswordInput; plaintext never reaches the shaper, glyph atlas, or AT value while masked). Demo: cargo run -p password-field.
• FilePickerField — TextInput + Browse button wired to the native file dialog; FilePickerKind::OpenFile / PickFolder / SaveFile.
• InputDialog — single-field input modal: title + prompt + TextInput + Cancel/OK; on_result delivers Some(value) / None.

Date and time

• Calendar — month grid with WAI-ARIA grid keyboard pattern; CalendarMode::Single / Range (DateRange); WeekNumberDisplay toggle. Locale-derived first day of week and format pattern.
• DateEdit — date input with trailing calendar-icon trigger; WidthPolicy, ValidationBehavior.
• TimeEdit — time input; TimeFormat, SecondsMode.
• DateTimeEdit — combined date + time input.
• DateRangeEdit — two-date range input.

Color

• HexColorInput — hex code text input with live swatch.
• ColorEdit — compact color editor with swatch trigger.
• ColorPicker — full HSV picker; ColorPickerLayout controls panel arrangement.

Menus

• MenuBar — top-of-window menu strip; widget-based on Windows/Linux. On macOS it mirrors a declarative MenuModel into the system NSMenu — MenuBar::from_model(..).native_on_macos(..) + install_native_menu(), see native-menu.md (on-device validation pending). MenuBar::build installs an Rc<dyn MenubarDispatcher> into WindowState on every platform so the framework can intercept F10, Alt+<letter>, and bare-Alt-tap before focus-based key dispatch — matching Win32's WM_SYSKEYDOWN semantics. Returns MenubarAction::{OpenMenu, FocusTrigger, Intercept}. Alt-tap is detected on the WindowState::alt_down falling edge with other_key_pressed_during_alt == false. Mnemonic-derived chords NEVER enter ShortcutRegistry — by construction ShortcutSettings cannot list them, which is the correct behaviour (mnemonics are derived from labels, change with locale, and are not user-rebindable per Win32 / GNOME HIG).

  macOS-specific behaviour: the dispatcher's Alt+<letter> branch is compiled out on macOS because the OS rewrites Option+letter into accented characters (Option+E → ´, Option+F → ƒ) before winit hands the keystroke to the app — the chord can never match the mnemonic table, and intercepting would silently break accented text input. F10, bare-Alt-tap → focus menubar, and bare-letter activation inside an open menu all continue to work on macOS (none involves a transformed letter key). Mnemonic underlines are also hidden on macOS via cfg!(target_os = "macos") in MenuLabel::paint so the UI doesn't promise a chord that won't fire. Use F10 + arrows + Enter for keyboard menu navigation, and the existing Shortcut system for Cmd+? accelerators.

• MenuList — overlay menu panel; accepts arbitrary impl Widget children. MenuSeparator for inline rules. Full keyboard suite: ArrowUp/Down + wrap, Home/End, Enter/Space activates the focused item, ArrowRight opens submenus, ArrowLeft/Esc bubble. Type-ahead with 500 ms default reset (.type_ahead_timeout(d) override), ASCII case-fold, separators skipped. In-menu mnemonic activation: bare letter (no modifiers) inside an open menu activates the item whose &-marker matches; mnemonic wins over type-ahead when both could fire.

• MenuItem — keyboard-highlightable menu row with for_shortcut(id) for live-rebinding labels. Three modes via builder methods:

  • .checked(Signal<bool>) → Role::MenuItemCheckBox, checkmark glyph in the leading slot, click flips the bound signal.
  • .check_state(Signal<CheckState>) → tri-state checkbox; click cycles Unchecked↔Checked (Indeterminate is external-source-only per Windows convention); rendered glyph: check / dash / spacer.
  • .radio(value, Signal<usize>) → Role::MenuItemRadio, filled-dot glyph when selected == value. Radio items in the same MenuList auto-group via Signal::same and announce "2 of N" via push_to_radio_group.

  All four (icon / check / tristate / radio) are mutually exclusive — a debug_assert! fires if both .icon(...) and a check/radio mode are set. AT state mirrors Checkbox exactly: set_toggled(bool) for binary, inner_mut().set_toggled(Toggled::Mixed) for Indeterminate.

• Mnemonics use the in-string Windows / Qt & convention: &Save underlines 'S' when Alt is held; && produces a literal &. MenuLabel (private leaf widget) renders the underline via canvas.draw_underline gated on WindowState::alt_down; the AT name strips the &, and the mnemonic letter is written to inner_mut().set_access_key("S") for Windows Narrator. Parser at mnemonic.rs.

• Safe-triangle submenu hover gate: when a submenu opens, the trigger MenuItem stamps a shared anchor (cursor position at open) into the enclosing MenuList's SafeTriangleState; sibling items, before firing their hover-switch, call point_in_safe_triangle(cursor, anchor, submenu_bounds). The triangle's near edge is inferred from anchor.x vs submenu.x — the algorithm is RTL-symmetric automatically. EventContext exposes tree_pointer_position() + overlay_bounds_for_content(content_id) (snapshotted per dispatch). The existing 150 ms PointerLeave close stays as a graceful fallback.

Overlays and dialogs

See tooltips.md for the tooltip system.

• TooltipWidget — plain, rich, or composite tooltips (three tiers, per-anchor mutual exclusion); sticky-on-dwell promotion to non-modal Role::Dialog; TooltipRegistry for app-wide reuse. Rich tier carries inline markup + shortcut chip + "more" disclosure; composite tier (CompositeTooltipWidget) hosts an arbitrary widget tree (CK3-style: tabbed sections, charts, progress bars).
• Popover — anchored overlay accepting arbitrary impl Widget content; configurable placement, dismissal, optional caret.
• Dialog — modal dialog frame; DialogContent / ModalContainer for content + presentation.
• MessageBox — predefined info/warning/error/question modals (MessageBoxSeverity); semantic-role buttons (ButtonRole, StandardButton, MessageBoxButton, MessageBoxButtons) with platform-aware ordering; result via MessageBoxResult.
• Snackbar — queued auto-dismissing toast with animated slide-in.
• Toast — stackable, action-rich, severity-aware floating notification (info / success / warning / error / loading); link + button actions; Toast::id update-in-place; persistent archive backing; corner-anchored hover-pause stack. The "upgrade path" from Snackbar. Full reference: toast.md.
• ToastHost — per-window invisible widget owning the toast queue + per-frame timer + hover-pause; mounted by install_toast.
• NotificationLog — archive UI: mark-all-read / clear toolbar + day-bucket section headers (Today / Yesterday / This week / Earlier) + replayable action buttons.
• NotificationCenterButton — bell icon + live unread-count badge + popover containing a NotificationLog. Marks-all-read on popover open.
• NotificationLogDialog — one-liner ::show(archive, ctx) modal preset.
• Shadow — drop-shadow primitive used by elevated surfaces (AttachedSide for one-sided shadows).

Data-driven widgets

Backed by the teksilo-data reactive collections. See data-models.md for the underlying ListModel<T> / TreeModel<T> / SelectionModel / sort-filter projections.

• Repeater — non-virtualized siblings driven by ListModel<T> change notifications; for small bounded collections.
• ListView — virtualized vertical list for large/unbounded collections.
• GridView — virtualized 2D tile grid (photo-gallery / icon-view / collection-view) bound to ListModel<T> / ListDataSource. Pluggable GridLayoutStrategy: UniformGrid (fixed size / fixed column count / adaptive min-width), VariableRowGrid (rows sized to tallest tile, auto-measure + scroll-anchoring or exact .item_height), VirtualizedMasonry (Pinterest waterfall). Flat SelectionModel (Single/Multi) with click/Ctrl/Shift + rubber-band marquee, full 2D keyboard nav (arrows / Home-End / PageUp-Down / type-ahead / Alt+Arrow reorder), drag-to-reorder routed through the source's drag/can_accept/accept_drop (+ on_item_drop escape hatch for foreign payloads), per-tile activation + context menu, sections (grouping_sections) with sticky pinned headers, empty/loading states, source-driven lazy loading (request_window + can_fetch_more/fetch_more + placeholder rows), and Role::Grid > Role::GridCell accessibility. See grid-view.md; demo cargo run -p grid-view.
• TreeView — hierarchical list with twist-arrow expand/collapse. The 4-arg new_with_context variant passes a TreeRowContext carrying a one-line toggle_callback() for chevron wiring.
• StandardListItem — canonical row layout for ListView delegates: [checkbox?] [leading_slot?] [center_slot?] [label] [Spacer] [trailing_slot?], plus an optional subtitle line with its own [subtitle_leading_slot?] [subtitle] [Spacer] [subtitle_trailing_slot?]. Selection / hover / pressed background routes through SurfaceRole::Selected / AccentSubtle / Pressed (theme-driven, rounded item_corner_radius: 8.0, mirrors MenuItem / ComboBox). Optional two-state (Signal<bool>) or tri-state (Signal<CheckState>) checkbox at the start of the row, independent of row selection. See the worked example in examples/data_collections/src/main.rs.
• StandardTreeItem — StandardListItem plus depth-driven indent and a chevron column (always reserved, even for leaves, so labels at the same depth align). .from_entry(&FlatEntry) sets depth + has_children + is_expanded in one call; .on_toggle(...) / .on_toggle_rc(...) wires the chevron tap to a TreeSliceHandle::toggle_expand callback (cleanest with TreeView::new_with_context).
• TableView — multi-column, virtualized; sort/filter via SortFilterListModel, drag-resize and drag-reorder columns, pinned Leading/Trailing, cell + row selection, edit hooks, row drag-drop reorder, full Role::Table AT tree. See table-view.md.
• TreeTableView — hierarchical multi-column variant of TableView; Role::TreeGrid.

Worked TreeView delegate using both new pieces:

#![allow(unused)]
fn main() {
let tree_checks: TreeCheckedModel<Item> = state.app_state();
TreeView::new_with_context(model, move |item, entry, selected, ctx| {
    let mut row = StandardTreeItem::new(lit!(&item.title))
        .from_entry(entry)
        .selected(selected)
        .on_toggle_rc(ctx.toggle_callback());
    if entry.has_children {
        row = row.tristate_checkbox(tree_checks.signal_for(entry.node_id));
    }
    Box::new(row)
})
}

Charts — crates/teksilo-charts/src/

Sits at the same tier as teksilo-widgets (no dep on widgets). Series data is a ChartModel<T> (teksilo-data, see data-models.md), not a Prop/ Signal-bound Vec. See charts.md.

• BarChart — vertical or horizontal bars; single or grouped series; optional value labels, axis labels, grid lines, hover tooltips.
• LineChart — points connected by polylines; single or multiple series; optional area fill; hover tooltips on data points.
• PieChart — pie + donut variants; donut variant has a center slot.

All three sit on the Tier-3 styling ladder via ChartStyle (.style(...) / theme.style_slots.chart) — an all-recipe trait distinct from the widget world's make_*(cfg, ctx) -> WidgetId traits; its default RecipeChartStyle lives in teksilo-charts itself, not teksilo-widgets/src/styles/* (see styling-system.md). Gridlines support dashed/dotted patterns (theme-wide via a custom ChartStyle, or per-axis via AxisConfig::gridline_dash); area and donut fills support gradients. Full reference: charts.md §11.

Shared infrastructure (axis.rs, legend.rs, palette.rs, layout.rs, hit.rs) is reused across all three; ChartSeries<T> / ChartDatum<T> construction DTOs live in teksilo-data and are re-exported from teksilo_charts.

Animation wrappers — crates/teksilo-widgets/src/animations/

Wrappers that animate a child subtree without the caller managing scheduler state. See animation.md for Signal<f32>::animate_to and the underlying scheduler.

• Fade — opacity tween 0↔1; layout-transparent.
• Pulse — sine-driven looping opacity oscillation (recording-indicator pattern).
• Cycle — cycles through children on a fixed period.
• Crossfade — keyed builder; old fades to new on key change.
• Collapse — height-collapse tween used by Accordion and disclosure patterns.
• Unroll — the horizontal sibling of Collapse: a width-unroll tween for side panels and inline reveals.
• SmoothSize — auto-sizes to the child's intrinsic size and animates every change (SmoothSizeAxes).
• Slide — slides a child in/out from a chosen edge (SlideEdge); layout-stable.
• Shake — damped horizontal oscillation triggered by a Signal<u32> bump (invalid-input feedback).
• Scale — uniform 2D scale 0↔1 (ScaleOrigin); visual-only by default, optional layout-driving mode.
• Rotate — rotates a child subtree by a Prop<f32> angle in radians.
• Blur — Gaussian-equivalent blur on the child subtree via dual-Kawase chain; sub-perceptual radii are zero-cost.

Settings widgets

Pre-built UI for common app-level concerns.

• ShortcutSettings — full keyboard-shortcut rebind UI (Rebind / Reset / conflict auto-unbind / key capture). See shortcut-intent-action.md.
• PrivacySettings (telemetry feature) — consent toggles for telemetry adapters; ties into the telemetry.md consent gate.
• TextScaleControl — a specialized SpinBox (80 %–200 %) for the global "grow all text" accessibility setting; binds the persisted TEXT_SCALE_KEY, applies app-wide on edit. See text-scale.md.
• ThemeSwitcher — drop-in app-theme picker for settings screens & toolbars (native / OS-follow themes, persistence); applies app-wide on select.
• LanguageSwitcher — drop-in UI-language picker for settings screens; switches the active locale app-wide. See i18n.md.

Cross-references

• Layout protocol and slack distribution: layout-primitives.md
• Events, gestures, focus, attached handlers: events-and-gestures.md
• Accessibility overrides on every widget: accessibility-overrides.md
• Animation scheduler and MotionTokens: animation.md
• Theming and role-based color resolution: reactive-theme.md
• Drag and drop integration: drag-and-drop.md
• Settings persistence (SettingsStore, SettingsFile<T>, MruList<T>): settings.md
• Global text-scale accessibility setting (TextScaleControl, ctx.text_scale, follow_text_scale): text-scale.md
• i18n (tr!, tr_signal!, locale-aware formatting): i18n.md
• Shortcuts / intents / actions: shortcut-intent-action.md
• Multi-window orchestration: multi-window.md
• Inspector for runtime introspection: inspector.md
• Framework internals (Canvas, rendering pipeline, threading, testability): architecture.md
• Full per-widget API extraction: python3 tools/extract_widget_api.py <Widget…> or --all