ArionUI.Presentation.Controls Core

Namespace in the ArionUI.Presentation package, 93 types.

Classes

ArionImage
A picture on a board or a control surface: an ArionBitmap read from a stream, a file or (with SkiaBitmaps.From) an SKImage, drawn into the control's box as ArionImage.Stretch says. The surface decodes the bitmap on its first draw and keeps it (on the GPU as a texture) for as long as the bitmap lives; a frame never decodes again. Swapping ArionImage.Source repaints only the control.
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.
Bound<TValue>
One property of a view model, mirrored for the controls of a board. The controls draw Bound.Value, a copy the board takes on the UI thread inside Board.Mutate whenever the view model raises INotifyPropertyChanged.PropertyChanged for the property, from any thread. What the user enters goes back through Bound.Set.
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.
Chip
One row that stands for a field or an item: an optional drag grip, a leading TypeBadge or icon, its caption, and at the end a status pill, a marker dot or a gradient swatch - and, while it is hovered or holds the focus, small icon buttons for its actions (ChipAction), which are in the accessibility tree whether shown or not. A click, Enter and Space run Chip.Click; the right button and Shift+F10 open its Control.ContextMenu. With a Chip.DragPayload the chip can be picked up and dragged (ControlHost.BeginDrag) once the pointer moved four units away from the press; in a DropList that is how it moves between lists.
ChoiceGroup
A set of ChoiceTiles of which one is picked - RadioGroup for tiles. The group owns the pick (ChoiceGroup.Selected, ChoiceGroup.Select); the arrows move the pick to the next tile that can be picked, skipping disabled ones and wrapping at the ends, and the focus goes with it; Home and End pick the first and the last tile that can be picked; Tab enters at the picked tile. For assistive technology it is a radio group holding its tiles.
ChoiceTile
One choice of several shown as a tile: a picture (or a glyph such as "123") and a caption. In a ChoiceGroup picking it unpicks the others, the arrows walk the group and Tab stops only at the picked tile - a radio button that looks like a card. Alone it picks through ChoiceTile.Check and reads ChoiceTile.IsChecked. A disabled tile cannot be picked by any means.
ComboBox
A value picked from a list. Closed it shows the value and a chevron; open, the grid's own combo list (the one the filter and the editors open) hangs below it in the pane stack, over the whole board and never cut at the tile.
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.
ControlValidation
Binds a control's Control.Error to what a model says about one of its properties, through INotifyDataErrorInfo or IDataErrorInfo (read by DataErrors, the same reading a grid's edit policy uses). The message follows the model: a view model that validates on every change marks the field red while it is wrong and clears it when it is right, with no code in the form.
DatePicker
A date field with a calendar, the free-standing form of a grid's date editor: typed through a mask made from the culture's short date (DatePatterns.NumericShortDate: "__.__.____" in German, "__/__/____" in US English), read back with the date column's rule (DateText: the format first), or picked in the grid's calendar (the button, Alt+Down or F4). Up and Down step the part of the date the caret stands in - day, month or year - as in a date cell. Like NumericUpDown it holds no value of its own: DatePicker.Value reads it and DatePicker.Changed hands a new one over.
DragData
What is being dragged inside a control tree: the payload the source hands over, the control it came from and the group it belongs to. A source starts the drag with ControlHost.BeginDrag; the targets under the pointer (IDropTarget) are asked whether they take it.
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.
DropList
A zone holding Chips one under the other that takes dragged chips: reordered within it, moved in from other lists of the same DropList.Group, refused where DropList.Accepts says no or where the list they come from must keep its last item (DropList.KeepsOne). While a drag is over it the zone is ringed in the accent and an accent line shows where the chip would land - at the end for a drop in the gap under the last chip; a drag of its group it refuses rings it in a dashed red, and the reason (DropList.RefusedHintFor) stands beside the pointer (DragData.Refusal). Empty, it shows a dashed placeholder ("Drop a field here"). Up and Down move the focus between the chips, Alt+Up and Alt+Down move the focused chip within the list; Ctrl+Shift+Left and Ctrl+Shift+Right move it to the previous or the next list of the same group in the host, and a chip's context menu offers "Move to" each other list of the group that has a caption (its DropList.Header). Every move is a request to the owner (DropList.Moved), who rebuilds the items.
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.
EmptyState
What a place shows while it has nothing to show: an icon in a tinted circle, a title, a line that says what to do, and the action that does it ("New order") - centred in its slot. The action is a Button of its own: focusable, styled, read as a button.
FieldNote
The line under an input field that says what the field needs: its error while the value does not validate - the field's own Control.ValidationMessage, with the same mark the field carries - else a hint; and, below it, a meter that sets the value against a limit (a stock level as a bar and "120 in stock"), red while the field is in error. One note for every kind of input, so a form shows its errors in one way, and the field then marks its error with its frame alone. The message is there while the note has a hint or the field an error, wrapped to the note's width, never cut; the board around it makes room when that changes.
FormGrid
A form laid out as one grid: a column of labels and a column of fields beside them, each field with its FieldNote right under it, and rows that span both columns (an action row, a heading). Every field starts at the same edge, a check box and a switch included, so nothing stands indented by chance; a label stands level with the first line of its field. Narrower than FormGrid.StackWidth the form stacks: each label over its field, every field as wide as the form. A row whose field is hidden is gone, its label and note with it.
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.
MenuBar
The menu bar of a window or a page: captions in a row, each opening its menu - the grid's own MenuOverlayContent, so a menu reads, looks and types like every other menu of the product. The keyboard reaches it with F10 (or Tab); Left and Right move between the captions and, while a menu is open, to the menu beside it; Enter, Space or Down open one; a letter opens the menu whose caption marks it, also as Alt plus the letter from anywhere in the tree (ControlHost.OnAccessKey). The access keys are underlined.
MenuRow
One command row of a menu-like surface (the filter dialog's chrome, menu entries, chooser rows, the command rows of a settings pane). 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 is either painted by a delegate (MenuRow.DrawContent) or, without one, the row's own: a leading MenuRow.Badge or MenuRow.Icon, the label with an optional MenuRow.Detail line under it, and at the end a check mark (MenuRow.Checked) or a submenu arrow (MenuRow.ShowsChevron).
NumericUpDown
A number field with up and down buttons, the free-standing form of a grid's number editor: typed and shown in a culture's format, read back with the number column's rules (TypedColumn.Number: "1234.5" in a German field is 1234.5, never 12345), kept between NumericUpDown.Minimum and NumericUpDown.Maximum. The arrows and the wheel (while it holds the keyboard; fractions of a touchpad add up to a step) move it by NumericUpDown.Step onto its multiples, Page Up/Down by NumericUpDown.LargeStep, Ctrl+Home and Ctrl+End to the ends (Home and End move the caret, as in any field); holding a button repeats while the pointer stays on it. Tabbing through the field changes nothing: its own text is read back as the value it shows, so a value is never rounded to the format or cut at a thousands separator. An optional NumericUpDown.Mask types through the cell editor's input mask. Like ArionSlider it holds no value of its own: NumericUpDown.Value reads it and NumericUpDown.Changed hands a new one over.
Panel
A control that holds others: the one place for what every container does alike. It keeps its children in one list (handed out without a copy), adds their layout print to its own, hit tests them in tree order before itself, and draws only those that reach into the surface's clip. A derived panel lays them out (Control.Measure, Control.Arrange) and draws its own face before them (Panel.RenderFace).
ProgressBar
A slim bar that fills to a fraction: how much of the stock an order takes, how far a task got. Takes no input and lets the pointer through; read by assistive technology as its ProgressBar.Spoken text, else as the percentage.
RadioButton
One choice of several, drawn as a ring with a dot and its caption beside it. In a RadioGroup it is one of the group's choices: picking it unpicks the others, the arrows walk the group and Tab stops only at the picked one. Alone it picks through RadioButton.Check and reads RadioButton.IsChecked, the way a check box toggles.
RadioGroup
A set of RadioButtons of which one is picked - an option group. The group owns the pick (RadioGroup.Selected, RadioGroup.Select); the arrows move the pick along the group and the focus with it, wrapping at the ends, and Tab enters the group at the picked button and leaves it with the next one - the group is one tab stop. For assistive technology it is a radio group holding its buttons, named by Control.AccessibleName.
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.
SearchBox
A search field: a TextBox with the magnifier at its start and a placeholder, reporting every change of its text. It composes the text box - typing, the caret, the edit menu, the clipboard and the reader all are the text box's own.
SectionHeader
The overline caption above a section of a panel - "ROWS", "VALUES": small, uppercase, in the dim text colour, with an optional icon before it. Read by assistive technology as text; it takes no input.
SegmentedControl
A choice of a few options shown as segments side by side, one of them picked - "Sum | Count | Average". It composes a ChoiceGroup of ChoiceTiles of equal width, so picking, the arrows (to the next option that can be picked, wrapping), Tab and the reader are the group's.
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:
TabControl
Pages behind a strip of tabs: one page is shown, the tabs pick which. A click or the arrows on the strip pick a tab and show its page at once; Home and End go to the first and the last tab; Ctrl+Tab and Ctrl+Shift+Tab (or Ctrl+Page Down/Up) step through the pages from anywhere inside the control. The strip is one tab stop - the selected tab - and Tab goes from it into the page. Tabs that can close show a close mark; a click on it, Delete or Ctrl+F4 on the focused tab close the page (TabControl.Closing may refuse).
TabItem
One tab of a TabControl's strip. Pressing it shows its page; the arrows walk the strip and show each page at once; a click on its close mark, Delete or Ctrl+F4 close it where it can close. Styled with Select.Type<TabItem>(), selected in TileStates.Checked.
TabPage
One page of a TabControl: the caption of its tab and what it shows.
TextArea
A text input of several lines: the text wraps at the field's width, Enter starts a new line, and the field scrolls inside itself when the text is taller than it (wheel, or the caret leaving the view). Caret, selection, word and line keys, undo, the clipboard and the input method's anchor work as in a TextBox; Up and Down keep the column the caret came from, Home and End go to the start and end of the line as shown, Ctrl+Home and Ctrl+End to the start and end of the text.
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.
ToolBar
A strip of commands: buttons, toggles, drop-downs and fields side by side, each at its own width, with ToolBar.Separator between groups. Tab enters at the first and leaves after the last as everywhere; inside, Left and Right move between the commands and Home and End jump to the ends, as in a Windows tool bar.
TypeBadge
A small rounded tag with a glyph ("Abc", "#", "Σ", "123") or an icon - what kind of field a row holds, or a status beside it. Takes no input and lets the pointer through to the control around it; read by assistive technology as text.
ViewModelBinding
Binds the controls of a board to a view model (INotifyPropertyChanged), typed and in both directions: board.Bind(viewModel, x => x.Name).
WrapPanel
Controls side by side at the width each asks for, wrapping onto the next line where the panel's width runs out: a row of chips, of tags, of small buttons. A line is as high as its highest control; the controls of a line stand at its top.

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.
ChipAction
A small action a Chip offers as an icon button while it is hovered or holds the focus (a filter funnel, "more"). Assistive technology finds the button at all times.
MenuBarItem
One menu of a MenuBar: its caption, with an ampersand before the access key ("&File" - Alt+F opens it, "&&" writes one ampersand), and its entries, asked each time the menu opens so they can follow the state.
SplitBranch
Divides its area along SplitBranch.Axis (BoardAxis.Columns: side by side, BoardAxis.Rows: one above the other) among its SplitBranch.Children, each taking its share of the SplitBranch.Ratios.
SplitNode
A node of a board's split tree (Board.Split): a branch that divides its area, or a group of tiles that fills one.
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.
TileGroup
An area of the split tree that holds the tiles of TileGroup.Tiles, by their controls. With more than one, a strip of tabs over the area shows the tile at TileGroup.Selected and lets the user pick another.

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.
ComboItemLook
How one value of a ComboBox reads, in the closed box and in its list: a round badge with initials before it and a dim secondary text after it - a customer's number beside the name, a country's code beside the country.
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).
DropMove
A move a DropList asks its owner to make: an item dropped on it (from itself, from another list or from elsewhere), or moved by the keyboard. The list changes nothing itself; the owner moves the item in its model and gives the lists their new chips (DropList.SetItems).
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.
Panel.ChildView
The children of a panel, read only: an index, a count and a foreach that takes no enumerator from the heap - the paths that read them run every frame.
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

IBindingAdapter<TControl, TValue>
How a binding reaches a control that holds its value itself, such as TextBox with its text: read what the control holds now, and show a value that came from the view model. A control whose value is a pair of delegates (Value and Changed or Toggle) needs no adapter: it takes Bound.Get and Bound.Set directly.
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.
IDropTarget
A control that takes drags (ControlHost.BeginDrag). While a drag is under way, the host asks the nearest target among the control under the pointer and its parents - the next one up when it refuses. All calls come on the UI thread with absolute coordinates.
IScrollAxisMember
A tile whose scroll can join a ScrollAxis: a tile that shows a view with its own scrolling content.

Enums

ArionBorderStyle
How the border of a styled box is stroked (ArionStyle.BorderStyle).
ArionEasing
How a transition moves from the old look to the new one over its duration.
BindingUpdate
When a control bound through an IBindingAdapter shows what the view model made of its own edit (a price typed as "25" that the view model formats as "25.00"). Edits reach the view model with every keystroke either way.
BoardAxis
The two track axes of a Board.
BoardMode
How a top-level board uses the height of its window.
BoardSplitters
Which track boundaries of a Board the user may drag.
ChoiceTileLayout
How a ChoiceTile places its picture and its caption; each layout is a class the style sheets can select.
ControlRole
What KIND of part a control is, for assistive technology — the neutral vocabulary both hosts translate into their automation control types.
DockSide
Where a tile docks: beside a target (or the board), or in its place.
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.
TypeBadgeKind
What kind of value a TypeBadge marks; each kind is a class the style sheets colour.