ArionUI.Presentation.Controls Core

Namespace in the ArionUI.Presentation package, 45 types.

Classes

ArionSlider: A slider: a value between ArionSlider.Minimum and ArionSlider.Maximum in steps of ArionSlider.Step, picked by pressing and dragging along the track or by the keyboard - the arrows by a step, Page Up/Down by ArionSlider.LargeStep, Home and End to the ends. Like CheckBox it holds no value of its own: ArionSlider.Value reads it and ArionSlider.Changed hands a new one over, so the application keeps one source.
ArionStyleSelector: What a rule styles - a CSS selector, typed. It picks elements of two kinds: the tiles of a board (the box a board draws around a control) and the controls themselves (a button's own face). A control type (Select.Type<Button>()) picks controls of that type, Select.Tile picks tiles, and a selector with neither (Select.Class("card"), Select.Any) picks both kinds. Classes are those of the element - a tile's from Board.Add, a control's from Control.Classes - and so are the states; all of them must hold (Button.primary:hover is Select.Type<Button>().Class("primary").Hover). Two selectors are equal when they pick the same elements.
Board: A grid of tracks that places controls in cells - the positioning grid of the drawn UI, like XAML's Grid or CSS grid. Columns and rows are sized Track.Px, Track.Auto or Track.Star; columns may also repeat as many times as fit (Track.AutoFit). A tile sits in given cells (Board.Add) or is placed by the board in reading order (Board.Flow); it may span several rows and columns; gaps and padding keep the rhythm. A board is a Control, so boards nest (a form inside a dashboard); the top-level one is shown and virtualized by a BoardView.
BoardBreakpoint: What a Board changes while its width lies in a range - a CSS media query (@media (min-width: 900px) { … }) as a typed block: other tracks, gaps or padding, tiles placed elsewhere or hidden, and style rules that hold only there. Everything is optional; what a breakpoint leaves unset stays as the board (or an earlier breakpoint) has it. Made and filled by Board.When, fixed afterwards.
BoardTile: One control placed on a Board: its cells, alignment, margin, classes and style.
Button: A push button over the shared ButtonWidget painter. The behaviours every hand-rolled copy had to reimplement are inherent here, once: the press ARMS (pressed look), the release over the same button FIRES (slide off = cancel), Space/Enter call the SAME endpoint, hover comes from the router, and the focus ring is drawn over whatever the painter produced.
Card: A card around one child: rounded fill, hairline border and a soft shadow, all drawn - so a card looks the same on every host, including those whose native containers cannot round a corner. The child sits inside Card.Padding; Card.Inset keeps room around the card for its shadow.
CheckBox: A labelled checkbox over the shared ArionIcons glyph. Inherent: it toggles on release-over (sliding off cancels) and on Space/Enter — the SAME endpoint — announces its new state to a focused screen-reader user, and its focus ring wraps the whole row.
Control: One interactive part of the drawn UI — the atom of the control-tree concept (docs/control-baum-konzept.md). A control owns its capabilities INHERENTLY: bounds (set by layout — the one geometry source), state (hover/pressed/focus — written only by the ControlHost), behaviour (pointer/keys/text), rendering (reads its own state), spoken label and cursor shape. A pane COMPOSES controls; it no longer implements input, hover, focus or hit-testing itself — which is exactly why a new control cannot get those wrong.
ControlDispatch: The one way a host drives a control tree from outside its pointer path: what assistive technology reads and does, the keyboard coming in and going out (Tab from outside, Tab past the last control), the keys and the typing, the clipboard and the caret the input method anchors to. The board shown in a grid and the ArionControlSurface of every host take the same path, so a text box or a button behaves the same wherever it is drawn.
ControlHost: The one input router of a control tree (docs/control-baum-konzept.md): hit-testing over the same bounds the layout set, FOCUS FOLLOWS THE CLICK, exclusive hover with a pointer-left signal, capture from press to release, Tab traversal in tree order with announcement, keys to the focused control, typing to the focused text sink or — the Excel rule — to the first one, and the default focus ring for controls that do not draw their own.
ControlPaneContent: IOverlayContent implemented ONCE over a control tree. A pane derives, builds its tree in the constructor (ControlPaneContent.SetRoot), sets the start focus — and is done: pointer routing, focus-follows-click, hover, Tab traversal, key/typing routing, announcements, cursor shapes, ticking and the focus ring all come from the ControlHost. A pane that needs keys beyond its controls overrides ControlPaneContent.OnKeyFallback.
Drawing: A leaf the application paints itself (a mark, a chip, a tile), the control-tree counterpart of a composition's draw element. Never focusable, hit-transparent.
DropDownButton: A dropdown trigger (operator picker, combo openers): a bordered row showing an optional icon, the current value and the shared ⏷ chevron. Inherent behaviour: click, Space, Enter AND Down all open through the SAME endpoint (Down is the native combo-trigger key), the hover fill doubles as the focus visual, plus the shared ring. The opened list itself is a pane (MenuOverlayContent) — this control only triggers it, anchored at its own bounds.
ElementTile: A cell composition as a control - a sparkline, a bullet, a donut or any other SlotEl - drawn from one data item: new ElementTile(Cell.Sparkline<Kpi>(k => k.History), kpi) { Height = 48 }. The same drawing a grid cell shows, so a dashboard tile and a table column look alike. Never focusable.
Label: Static text (a counter, a caption, a paragraph) — drawn, never focusable, hit-transparent, read by a screen reader as text. One line unless Label.MaxLines allows more. Rules for the label itself (Select.Type<Label>(), its Control.Classes) set its colour and font over the text it inherits from its tile.
MenuRow: One command row of a menu-like surface (the filter dialog's chrome, menu entries, chooser rows). Inherent: the hover row and the keyboard focus are the SAME visual (the shared row highlight — the keyboard cursor never invents its own), click and Space/Enter call the SAME endpoint, and a disabled row drops out of the tab order through its Control.EnabledWhen probe. The row's CONTENT (icon, label, submenu arrow) is painted by a delegate — composition stays with the pane, behaviour stays here.
ScrollPanel: Scrolls one child vertically inside its bounds, with the grid's own self-drawn scrollbar (thumb drag, track paging, auto-hide). The child is measured at the panel's width and may be as tall as it likes; the wheel over any part of it scrolls, and a control that takes the keyboard focus is brought into view.
Select: Starts an ArionStyleSelector: Select.Class("card").Hover, Select.Type<Button>(), Select.Tile.Disabled.
Separator: A horizontal separator line, vertically centred in its slot. Purely visual: never focusable, never hit (the pointer falls through to nothing).
Spacer: Empty space in a stack — sized by its slot, draws nothing, hit-transparent.
StackPanel: The one geometry source of a control tree: a stack (vertical or horizontal) whose children are Fixed, Auto (their measured size) or Fill (share of the leftover). Measure and Arrange derive from the SAME child specification, so a pane's desired size and its layout can never drift apart — the successor of the per-pane y-accumulation walks that existed five times per pane.
StyleSheet: Style rules for the tiles of a board and the controls on it - a CSS style sheet, typed. Written as a list:
TextBox: A text input over the shared TextFieldWidget (buffer, caret, selection, caret-follow scroll). Inherent behaviours: a click places the caret (the router has already moved the focus here — that is ITS rule), dragging selects, double/triple click select word/all, typing inserts, and the field's accent border is the focus visual. The pane only wires the endpoints: TextBox.Changed, TextBox.Committed, TextBox.Cancelled.
ToggleSwitch: An on/off switch: a pill track with a sliding knob and its label beside it, for a setting that takes effect at once (a check box is for a choice confirmed later). Behaves like CheckBox: release-over and Space/Enter flip it through the same endpoint, a focused screen-reader user hears the new state.
Tokens: The theme's design tokens for styles - colours and lengths that are read from ArionTheme.Current when drawn, so a style built from them looks right in every theme, light, dark or high contrast. Each has a name (accent, font-body), and Tokens.TryGet finds it by that name - the lookup a text form of style sheets would use.

Records

ArionStyle: A set of style declarations - what a CSS rule block holds, typed. Every property is optional: a style sets only what it names, and the cascade (StyleSheet) lays the matching styles over each other, the more specific or later one winning per property.
StyleDeclaration: One declaration the cascade weighed for an element - what the Styles pane of a browser's developer tools lists: the property, its value, where it comes from and whether it won.
StyleSheetRule: One rule of a StyleSheet: the elements it styles and the style.

Structs

AccessiblePart: One part of a control tree as assistive technology sees it, interactive or only read — the host-neutral answer the automation peers are FED from (step 5 of the control-tree concept): the tree already knows identity, kind, spoken label, bounds and focus, so a peer translates instead of re-deriving.
AccessibleRange: The range of a part that picks a value along one (a slider) - what a screen reader reads as the range and steps by with "increase" and "decrease".
ArionTransition: How a tile blends into a new look when its state or classes change: a duration and a curve. Durations go through the grid's animation speed, so "reduce motion" (ArionMotion.Reduce) makes every change appear at once.
ComputedStyle: A style with every value resolved against one theme - what a tile draws with, and what BoardTile.ComputedStyle reports (mid-transition too). The font properties are null where the tile leaves the text to what it inherits.
ControlFrame: What the host tells the tree about the frame being drawn — the pane-level OverlayFrameState, carried through so a control can decide whether its focus visual and caret may show (only the TOPMOST pane owns the keyboard).
FeedStats: What a feed board knows about the heights of its items (Board.ItemsFrom): how many it measured at the current width and how many it estimates, and the cards that exist to show them.
Insets: Space on the four sides of a box (a tile's margin, a board's padding). A single number converts to the same space on every side.
StyleColor: A colour in an ArionStyle: a fixed colour, or a theme token (Tokens) read from the active theme each time it is drawn - so a style written with tokens follows every theme switch without being written again. A fixed Rgba converts implicitly.
StyleLength: A length in an ArionStyle (a radius, a font size, a blur): a fixed number of logical units, or a theme token (Tokens.FontBody) read at draw time. A number converts implicitly.

Interfaces

IClipboardText: The platform's clipboard, as far as text boxes need it. A host implements it once; ControlHost.Clipboard hands it to every text box of a tree.

Enums

ArionEasing: How a transition moves from the old look to the new one over its duration.
BoardMode: How a top-level board uses the height of its window.
ControlRole: What KIND of part a control is, for assistive technology — the neutral vocabulary both hosts translate into their automation control types.
StyleOrigin: The layer of the cascade a declaration comes from - CSS's origins, lowest first.
TileAlign: Where a tile sits inside its cell area on one axis.
TileStates: The interaction states a style rule can ask for - the pseudo-classes of CSS. A tile and a control each have their own.