ArionUI.Presentation.Controls Core
Namespace in the ArionUI.Presentation package, 93 types.
Classes
- ArionImage
- A picture on a board or a control surface: an
ArionBitmapread from a stream, a file or (withSkiaBitmaps.From) anSKImage, drawn into the control's box asArionImage.Stretchsays. 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. SwappingArionImage.Sourcerepaints only the control. - ArionSlider
- A slider: a value between
ArionSlider.MinimumandArionSlider.Maximumin steps ofArionSlider.Step, picked by pressing and dragging along the track or by the keyboard - the arrows by a step, Page Up/Down byArionSlider.LargeStep, Home and End to the ends. LikeCheckBoxit holds no value of its own:ArionSlider.Valuereads it andArionSlider.Changedhands 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.Tilepicks tiles, and a selector with neither (Select.Class("card"),Select.Any) picks both kinds. Classes are those of the element - a tile's fromBoard.Add, a control's fromControl.Classes- and so are the states; all of them must hold (Button.primary:hoverisSelect.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.AutoorTrack.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 aControl, so boards nest (a form inside a dashboard); the top-level one is shown and virtualized by aBoardView. - BoardBreakpoint
- What a
Boardchanges 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 byBoard.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 insideBoard.Mutatewhenever the view model raisesINotifyPropertyChanged.PropertyChangedfor the property, from any thread. What the user enters goes back throughBound.Set. - Button
- A push button over the shared
ButtonWidgetpainter. 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.Insetkeeps room around the card for its shadow. - CheckBox
- A labelled checkbox over the shared
ArionIconsglyph. 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
TypeBadgeor 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 runChip.Click; the right button and Shift+F10 open itsControl.ContextMenu. With aChip.DragPayloadthe chip can be picked up and dragged (ControlHost.BeginDrag) once the pointer moved four units away from the press; in aDropListthat is how it moves between lists. - ChoiceGroup
- A set of
ChoiceTiles of which one is picked -RadioGroupfor 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
ChoiceGrouppicking 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 throughChoiceTile.Checkand readsChoiceTile.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
ArionControlSurfaceof 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
IOverlayContentimplemented 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 theControlHost. A pane that needs keys beyond its controls overridesControlPaneContent.OnKeyFallback.- ControlValidation
- Binds a control's
Control.Errorto what a model says about one of its properties, throughINotifyDataErrorInfoorIDataErrorInfo(read byDataErrors, 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. LikeNumericUpDownit holds no value of its own:DatePicker.Valuereads it andDatePicker.Changedhands 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 sameDropList.Group, refused whereDropList.Acceptssays 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 (itsDropList.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
Buttonof 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
FieldNoteright 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 thanFormGrid.StackWidththe 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.MaxLinesallows more. Rules for the label itself (Select.Type<Label>(), itsControl.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.EnabledWhenprobe. The row's CONTENT is either painted by a delegate (MenuRow.DrawContent) or, without one, the row's own: a leadingMenuRow.BadgeorMenuRow.Icon, the label with an optionalMenuRow.Detailline 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 betweenNumericUpDown.MinimumandNumericUpDown.Maximum. The arrows and the wheel (while it holds the keyboard; fractions of a touchpad add up to a step) move it byNumericUpDown.Steponto its multiples, Page Up/Down byNumericUpDown.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 optionalNumericUpDown.Masktypes through the cell editor's input mask. LikeArionSliderit holds no value of its own:NumericUpDown.Valuereads it andNumericUpDown.Changedhands 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.Spokentext, else as the percentage. - RadioButton
- One choice of several, drawn as a ring with a dot and its caption beside it. In a
RadioGroupit 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 throughRadioButton.Checkand readsRadioButton.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 byControl.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
TextBoxwith 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
ChoiceGroupofChoiceTiles 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.Closingmay 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 withSelect.Type<TabItem>(), selected inTileStates.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.Currentwhen drawn, so a style built from them looks right in every theme, light, dark or high contrast. Each has a name (accent,font-body), andTokens.TryGetfinds 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.Separatorbetween 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
Chipoffers 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 itsSplitBranch.Children, each taking its share of theSplitBranch.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 atTileGroup.Selectedand 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
ComboBoxreads, 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.ComputedStylereports (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
DropListasks 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
foreachthat 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 fixedRgbaconverts 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
TextBoxwith 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 (ValueandChangedorToggle) needs no adapter: it takesBound.GetandBound.Setdirectly. - IClipboardText
- The platform's clipboard, as far as text boxes need it. A host implements it once;
ControlHost.Clipboardhands 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
IBindingAdaptershows 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
Boardthe user may drag. - ChoiceTileLayout
- How a
ChoiceTileplaces 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
TypeBadgemarks; each kind is a class the style sheets colour.