|
guillaume 2026.6.1
A C++ UI framework designed for modern desktop and extended reality (XR) applications.
|
| Nguillaume | A C++20 UI framework for desktop and XR, built as an entity-component-system |
| Ncomponents | State. Every class here is plain data attached to an entity |
| CAccessibilityValue | Position of a control within a range, such as a slider or a progress bar. Accessibility::setValue requires min <= now <= max |
| CAccessibility | What an entity means to a user who does not see it: its name, its role, its state and its place in the keyboard traversal |
| CAnimation | A timer that runs from 0 to a duration and reports its eased progress, from 0 to 1, to a callback on every frame |
| CAppBar | State of an app bar: the strip that carries a screen's title, its navigation icon and its action icons |
| CAction | One pressable icon of the bar: the leading navigation icon or a trailing action |
| CArc | A portion of a ring: the moving part of a circular progress or loading indicator |
| CBackdrop | State of a modal backdrop, the dimming layer behind a dialog or a drawer: whether it is shown and how far its fade-in has progressed |
| CBadge | State of a badge: a small dot or pill, usually holding a count, drawn over another widget |
| CBorders | Corner radii and outline stroke of a rectangular entity |
| CBound | Size of an entity: the width and height, in dp, of the rectangle that starts at the position of its components::Transform |
| CButton | State shared by every pressable button, whatever its look |
| CButtonInteraction | Which buttons of an input device are held on an entity, and what to call when one is pressed or released on it |
| CCard | State of a card: a surface grouping an optional cover image, title, text and row of action buttons |
| CAction | One button of the actions row: its label and what it does |
| CCheckbox | State of a checkbox: checked state, variant, label, color overrides and the identifiers of its check glyph and label children |
| CChip | Configuration of a chip: a compact pill with a label and optional leading, check and close icons |
| CClip | Asks that drawing be cut to the entity's rectangle, and holds the rectangle that results |
| CRect | The clip rectangle, in the same coordinates as the position of a components::Transform |
| CColor | Main color of an entity: the fill of a shape, or the ink of a text or an icon |
| CCommonButton | Look of a Material 3 common button: color style, corner shape, size and padding options |
| CCorners | Radius of each corner, for a button joined to its neighbours (a segment of a segmented button) |
| CDialog | State of a dialog: a modal panel with an optional icon, a title, a message and a row of text buttons |
| CAction | One action of the dialog, drawn as a text button in the action row |
| CDivider | State of a divider: a thin horizontal line separating content |
| CDragInteraction | State of a drag gesture on an entity: whether it is in progress, how far the pointer moved since the previous motion event, and the callbacks for its start, its moves and its end |
| CElevation | Soft shadow drawn around an elevated surface |
| CEllipse | Marks an entity as a filled ellipse: a dot, a switch thumb, a disc |
| CExtendedFloatingActionButton | Look of a Material 3 extended floating action button: a FAB that shows a label next to its icon and can collapse to the icon alone |
| CFloatingActionButton | Look of a Material 3 floating action button (FAB): color variant, size and shadow |
| CFloatingActionButtonMenu | State of a floating action button menu (speed dial): a trigger button that expands into a column of action buttons above it |
| CAction | One entry of the menu: what its button shows and does |
| CFocus | Makes an entity able to own the input focus, and holds whether it owns it and what to call when it gains or loses it |
| CGlyph | An icon: one glyph of the Material Symbols font, chosen by name, at a given size |
| CHandHoverInteraction | Whether an XR hand (controller) aims at an entity, what to call when the aim enters or leaves, and how far the hit area extends past the bound |
| CHandPinchInteraction | Whether an XR hand pinches while pointing at an entity, and what to call when it does |
| CHandPokeInteraction | Whether an XR hand pokes an entity (touches it with a finger), and what to call when it does |
| CHandSqueezeInteraction | Marks an entity as a target of XR hand squeeze (grip) input and stores the callback for it |
| CHandThumbRestInteraction | Marks an entity as a target of XR controller thumb rest input and stores the callback for it |
| CHandThumbStickInteraction | Marks an entity as a target of XR controller thumb stick input and stores the callback for it |
| CHandTriggerInteraction | Marks an entity as a target of XR controller trigger input and stores the callback for it |
| CHierarchy | Place of an entity in the entity tree: its parent, its direct children and its depth |
| CIconButton | Look of a Material 3 icon button: color variant and size |
| CImage | A picture drawn in the entity's rectangle: the texture to show, a fallback texture, and whether loading succeeded |
| CInteractionBase | The part shared by every Interaction: one callback to run when the input the component stands for reaches the entity |
| CInteraction | Component that makes an entity react to one kind of input event (a hand pinch, a hand poke, a trigger pull, ...) |
| CInteraction< EventType, false > | Interaction for an event type without nested Factory type |
| CInteraction< EventType, true > | Interaction for an event type that declares a nested Factory type |
| CLayout | How a container arranges its children: in a row or a column, with which alignment, spacing and padding, and at which size |
| CLayoutExtent | Space a widget takes in its parent's layout beyond its Bound |
| CLine | A straight stroke across the width of the entity: a divider, an indicator, the underline of a text field |
| CList | State of a list: a column of rows, each with a headline and optional supporting text, icons or image, plus subheaders, dividers and accordions |
| CItem | Description of one list entry, as given by the user |
| CRow | Identifiers of the entities built for one entry |
| CLoadingIndicator | State of a loading indicator: an arc that turns, or a bar that slides, in a loop while something is in progress |
| CMenu | State of a menu: a floating list of choices that opens next to an anchor |
| CItem | Description of one menu item, as given by the user |
| CRow | Identifiers of the entities built for one item |
| CMesh | A 3D model shown at the entity's pose: the model file and an optional texture |
| CMouseHoverInteraction | Whether the mouse pointer is over an entity, what to call when it enters or leaves, and how far the hit area extends past the bound |
| CNavigationBar | State of a navigation bar: the bottom strip of three to five destinations that switches between the top-level views of an app |
| CDestination | Description of one destination, as given by the user |
| CNavigationBarDestination | State of one destination of a navigation bar: an icon in a pill, a label under it and an optional badge |
| CNavigationDrawer | State of a navigation drawer: the side sheet that lists the destinations of an app, grouped by section headers and dividers |
| CEntry | Description of one drawer entry, as given by the user |
| CNavigationDrawerDestination | State of one destination of a navigation drawer: an icon, a label and an optional text at the trailing edge |
| COverlay | Marks an entity as something shown temporarily above the rest of the interface (a dialog, a menu, a drawer, a snackbar, a tooltip) and holds how it is dismissed |
| CProgressIndicator | State of a progress indicator: a bar or a ring that fills up with a value from 0 to 1, or loops when the value is unknown |
| CRadioButton | Configuration of a radio button: its variant, its label and the identifiers of its dot and label children |
| CRadioGroup | State of a radio group: a column of radio buttons of which at most one is selected |
| CRange | An interval [low, high] kept inside a range, with a callback run when it changes |
| CRing | A full ring: the outline of a radio button, the track of a circular progress indicator |
| CScrim | A translucent veil drawn over the whole bound of its entity, to dim what is behind a modal surface |
| CScrollable | How far the content of an entity is scrolled, how large that content is, and how fast the mouse wheel scrolls it |
| CSearch | State of a search field: a leading icon, the query the user types (or a placeholder), then a clear button or a loading glyph and an optional trailing icon |
| CSegmentedButton | State of a segmented button: a row of joined toggle buttons of which one (or several) can be selected |
| CSegment | What one segment shows and whether it can be pressed |
| CSelectable | Selected/unselected flag of an entity, with a callback run when it changes |
| CSelectionGroup | Marks an entity whose Selectable children are mutually exclusive, and remembers which one is selected |
| CSnackbar | State of a snackbar: a short message at the bottom of the screen, with an optional action, that goes away by itself |
| CStyleState | The interaction state of an entity in one place: enabled or disabled, and whether it is hovered, pressed, focused or dragged |
| CSurfaceTone | State of a tonal surface: how high it sits above the background, and whether it casts a shadow |
| CSwitch | Configuration of a switch: its variant, its thumb icon, its label and the identifiers of its thumb, icon and label children |
| CText | A run of text: its content, its font metrics and the position of the editing cursor |
| CTextField | The texts around the input of a text field, and its error state: placeholder, label, supporting text, prefix, suffix and error text |
| CTextFieldConfiguration | State of a text field widget that is not text around the input: its variant, icons, flags, width, callbacks and the identifiers of its children |
| CTooltip | State of a tooltip: a small label that appears under an entity (its anchor) after the pointer has rested on it |
| CTransform | Where an entity is in space: its pose (position and orientation) and its scale |
| CTypography | Which typescale role a text uses (BodyMedium, TitleLarge, ...) and an optional explicit size |
| CValue | A number kept inside a range, with a callback run when it changes |
| Necs | The entity-component-system core, independent of any widget |
| CComponent | Base class of every component: a piece of state attached to an entity, plus a "changed" flag |
| CEntityComponentNotFoundException | Thrown by ComponentRegistry::getComponent when the entity has no component of the requested type |
| CComponentRegistry | Stores every component of a scene, per component type and per entity identifier, and knows which ones changed this frame |
| CComponentRegistryFiller | A ComponentRegistry whose storages for a fixed list of component types exist from construction |
| CIComponentStorage | What ComponentRegistry can do with a component storage without knowing which component type it holds |
| CComponentStorage | Holds every component of one type, indexed by entity identifier |
| CComponentTypeLimitExceededException | Thrown by ComponentTypeId::get when a program uses more than MaxComponentTypes component types |
| CComponentTypeId | Gives each component type a small number: its bit position in an Entity::Signature |
| CEntity | One thing in the UI: an identifier, a signature and a place in the tree. It holds no state of its own |
| CEntityBuilder | Base class of the widget builders: remembers in which registries the entities it creates go |
| CEntityBuilderManager | Holds one builder per builder type and hands them out by type |
| CEntityBuilderManagerFiller | An EntityBuilderManager that creates one builder of each listed type when it is constructed |
| CEntityFiller | The base class of a widget without children: an Entity that creates its components when it is constructed |
| CEntityRegistry | Owns entities and gives the systems the list of entities to visit |
| CEntityRegistryContainer | An EntityRegistry that is not itself an entity: the top of an ownership tree |
| CEntityTreeTraveler | Decides in which order the entities of a scene are visited |
| CLevelOrderTraveler | Visits owners before what they own: the entities owned by the scene first, then the entities those own, and so on |
| CParentEntity | An entity that owns child entities: both an Entity and an EntityRegistry |
| CParentEntityFiller | The base class of a widget with children: an EntityFiller that is also a ParentEntity |
| CReverseLevelOrderTraveler | Visits owned entities before their owners: the deepest entities first, the entities owned by the scene last |
| CSystem | Base class of every system: a rule applied each frame to every entity that has a given set of components |
| CSystemFiller | The base class to derive a system from: a System whose signature is the list of component types given as template arguments |
| CSystemPhase | Ties a Phase to the order in which its systems visit the entities |
| CSystemRegistry | Owns the systems of an application, grouped by phase and kept in registration order |
| Nentities | Widgets: the classes used to create entities with the right components and children |
| Ndetail | |
| CBarDestination | One destination of a NavigationBar: a pressable column with an active-indicator pill around the icon, a label under it and an optional badge on the icon |
| CDrawerDestination | One destination of a NavigationDrawer: a pressable row with an icon, a label and an optional trailing text, or, collapsed, an icon in a pill with the label under it (Paper Drawer.Item and Drawer.CollapsedItem) |
| CAppBar | A horizontal bar with a leading navigation icon button, a title and trailing action icon buttons |
| CBuilder | Configures an AppBar, creates it and registers it in an entity registry |
| CBackdrop | The translucent veil painted behind a dialog or a modal drawer to dim the rest of the scene |
| CBadge | A small colored pill showing a count or a short label, or a plain status dot (react-native-paper Badge) |
| CBuilder | Configures Badge widgets and registers them in the scene's entity registry |
| CEntityBuilderBase | Base of every widget Builder: turns a configuration into a widget that is attached to a parent and owned by an entity registry |
| CButton | A Material 3 common button: a clickable container with a text label and an optional icon (elevated, filled, tonal, outlined or text) |
| CBuilder | Configures, creates and registers Button widgets |
| CButtonBase | What Button, IconButton, FloatingActionButton and ExtendedFloatingActionButton have in common: an icon, a label, a click, a toggle state |
| CCard | A rounded panel grouping a cover image, a title, a text and action buttons about one subject (react-native-paper Card) |
| CBuilder | Configures Card widgets and registers them in the scene's entity registry |
| CCheckbox | A box the user checks, unchecks or leaves indeterminate, with an optional label next to it |
| CBuilder | Configures, creates and registers Checkbox widgets |
| CChip | A compact, 32 dp high pill with a label and optional icons, used as an action, a filter, an entered value or a suggestion |
| CBuilder | Configures, creates and registers Chip widgets |
| CDialog | A modal panel shown above the rest of the interface, with an optional icon, a title, a message and a row of text buttons |
| CBuilder | Configures a Dialog, then builds it and registers it in the entity registry given at construction |
| CDivider | A thin horizontal line separating two pieces of content |
| CBuilder | Configures Divider widgets and registers them in the scene's entity registry |
| CExtendedFloatingActionButton | A Material 3 extended floating action button: a wide, raised button with a text label and an optional icon, which can collapse to a square icon-only FAB |
| CBuilder | Configures, creates and registers ExtendedFloatingActionButton widgets |
| CFloatingActionButton | A Material 3 floating action button (FAB): a raised, square button with an icon, for the main action of a screen |
| CBuilder | Configures, creates and registers FloatingActionButton widgets |
| CFloatingActionButtonMenu | A floating action button menu (speed dial): a trigger FAB that shows a column of smaller action buttons above it when opened |
| CBuilder | Configures, creates and registers FloatingActionButtonMenu widgets |
| CIcon | A Material Symbols icon, chosen by name and drawn as one glyph of the icon font |
| CBuilder | Configures Icon widgets and registers them in the scene's entity registry |
| CIconButton | A Material 3 icon button: a small clickable container that shows a single icon and no label |
| CBuilder | Configures, creates and registers IconButton widgets |
| CImage | A picture loaded from a texture file and stretched over a rectangle |
| CBuilder | Configures Image widgets and registers them in the scene's entity registry |
| CList | A vertical list of pressable rows, with optional subheaders, dividers and accordions that fold nested rows (Paper List.Section, List.Subheader, List.Item, List.Accordion, List.Icon and List.Image) |
| CBuilder | Configures a List, creates it and registers it in an entity registry |
| CLoadingIndicator | An animation that loops for as long as work is in progress: a rotating arc or a sliding bar, with no value |
| CBuilder | Configures a LoadingIndicator, then builds it and registers it in the entity registry given at construction |
| CMenu | A pop-up column of pressable items, shown on demand next to an anchor entity (Paper Menu and Menu.Item) |
| CBuilder | Configures a Menu, creates it and registers it in an entity registry |
| CMesh | A 3D model loaded from a file, with an optional texture |
| CBuilder | Configures Mesh widgets and registers them in the scene's entity registry |
| CNavigationBar | A bottom bar of destinations (icon, label, optional badge) of which exactly one is selected |
| CBuilder | Configures a NavigationBar, creates it and registers it in an entity registry |
| CNavigationDrawer | A side sheet listing destinations, of which exactly one is selected, with optional section titles and dividers (Paper Drawer.Section, Drawer.Item and Drawer.CollapsedItem) |
| CBuilder | Configures a NavigationDrawer, creates it and registers it in an entity registry |
| CProgressIndicator | A bar or a ring that fills up to show how far a task has progressed, or that loops when the progress is unknown |
| CBuilder | Configures a ProgressIndicator, then builds it and registers it in the entity registry given at construction |
| CRadioButton | A circle the user selects to pick one option, with an optional label next to it |
| CBuilder | Configures, creates and registers RadioButton widgets |
| CRadioGroup | A column of labelled radio buttons of which at most one is selected (Paper RadioButton.Group) |
| CBuilder | Configures RadioGroup widgets and registers them in the scene's entity registry |
| CSearch | A search field: a leading icon, an editable query with a placeholder, a clear button and an optional trailing icon (Paper Searchbar) |
| CBuilder | Configures a Search, creates it and registers it in an entity registry |
| CSegmentedButton | A row of joined toggle buttons (segments) from which the user picks one option, or several |
| CBuilder | Configures, creates and registers SegmentedButton widgets |
| CSnackbar | A short message bar that disappears by itself after a few seconds, with an optional action label the user can press |
| CBuilder | Configures a Snackbar, then builds it and registers it in the entity registry given at construction |
| CSurfaceConfig | Everything needed to set up a surface in one value: where it is, how it looks and how it arranges its children |
| CSurfaceBase | Base of the widgets that are a rectangle containing other widgets (Card, Dialog, Checkbox, ...) |
| CSurface | A plain container whose background gets lighter or darker with its elevation, and which can cast a shadow |
| CBuilder | Configures and registers Surface widgets |
| CSwitch | An on/off toggle: a rounded track with a thumb that slides to the right when on, an optional icon on the thumb and an optional label next to the track |
| CBuilder | Configures Switch widgets and registers them in the scene's entity registry |
| CText | A single run of text drawn with a typescale role, a color and an optional explicit font size |
| CBuilder | Configures Text widgets and registers them in the scene's entity registry |
| CTextField | A box the user types text into, with a label, optional icons, prefix and suffix, and a helper or error text under it (Paper TextInput and HelperText) |
| CBuilder | Configures a TextField, then builds it and registers it in the entity registry given at construction |
| CTooltip | A small label that appears next to another entity while the pointer or a hand hovers that entity |
| CBuilder | Configures a Tooltip, then builds it and registers it in the entity registry given at construction |
| CView | A rectangle, colored or transparent, that lays its children out in a row or a column |
| CBuilder | Configures View widgets and registers them in the scene's entity registry |
| CBarDestination | One destination of a NavigationBar: a pressable column with an active-indicator pill around the icon, a label under it and an optional badge on the icon |
| CDrawerDestination | One destination of a NavigationDrawer: a pressable row with an icon, a label and an optional trailing text, or, collapsed, an icon in a pill with the label under it (Paper Drawer.Item and Drawer.CollapsedItem) |
| Nevent | Delivery of engine events to the systems that subscribed to them |
| CEventBus | Hands each engine event to the listeners subscribed to its type |
| CEventManager | Base class that gives a system the input events of one type, one event per frame |
| CEventSubscriber | A queue of the events of one type published on an EventBus, waiting to be read |
| Nsystems | Rules. Every class here runs each frame on the entities that have the components it declares |
| CAnimation | Moves every running animation forward by the time of one frame |
| CAppBar | Styles an app bar and lays out its navigation button, title and action buttons in a row |
| CArcRender | Draws a part of a ring (an arc with a thickness and flat ends) for every entity that has a components::Arc |
| CBackdrop | Fades the backdrop of a modal widget in and keeps it behind its owner |
| CBadge | Sizes and colors a badge (the small dot or counter drawn over another widget) and fades it in and out |
| CButton | Input and content rules shared by every button variant: press, release, toggle, click and long press |
| CChild | Short-lived handle on the icon or label child of a button, used by the variant systems to style it |
| CCard | Styles a card, animates its elevation while pressed and arranges its cover, title, content and actions sections |
| CCheckbox | The rules of a checkbox: toggling it, coloring its box and placing its label |
| CChip | The rules of a chip: pressing it, selecting it, closing it, coloring it and arranging its icons and label |
| CClip | Turns the bound of an entity into the rectangle the engine clips drawing to |
| CCommonButton | Colors, sizes and lays out a common button: the elevated, filled, tonal, outlined and text buttons, and the segments of a segmented button |
| CDialog | Styles a dialog panel, stacks its icon, title, message and action row, and shows or hides the backdrop behind it |
| CDivider | Turns the configuration of a divider (a thin horizontal separator line) into the geometry that is drawn |
| CDrag | Turns "button held while the pointer moves" into a drag gesture |
| CElevationRender | Draws the soft shadow of every entity that has a components::Elevation |
| CEllipseRender | Draws a filled ellipse (a disc when the bound is square) for every entity that has a components::Ellipse |
| CExtendedFloatingActionButton | Colors, sizes and lays out an extended floating action button: a FAB that shows a label beside its icon and can collapse to the icon alone |
| CFloatingActionButton | Colors, sizes and lays out a floating action button (FAB): the raised square button carrying the main action of a screen |
| CFloatingActionButtonMenu | Opens and closes a floating action button menu (speed dial): a trigger button that reveals a column of action buttons above it |
| CFocus | Decides which single entity has the keyboard focus |
| CFocusRingRender | Draws the focus indicator: an outline around the entity that has the keyboard focus |
| CGlyphRender | Draws the icon of every entity that has a components::Glyph |
| CHandButton | Tracks which XR controller buttons are held on which entities |
| CHandEventSystem | Base of the XR hand input systems: the wiring they share |
| CHandRaySystem | Base of the hand input systems that point at an entity: a gesture counts for the entity the hand ray hits |
| CHandMotion | Tracks which entities an XR hand is pointing at |
| CHandPinch | Marks the entities an XR hand pinches (thumb and index brought together while pointing at them) |
| CHandPoke | Marks the entities an XR hand pokes (a fingertip pushed toward them) |
| CHandSqueeze | Receives XR hand squeeze events (the grip of a controller) |
| CHandThumbRest | Receives XR thumb-rest events (the thumb touching the rest pad of a controller) |
| CHandThumbStick | Receives XR thumb-stick events (the joystick of a controller) |
| CHandTrigger | Receives XR trigger events (the index trigger of a controller) |
| CIconButton | Colors, sizes and lays out an icon button: a round button that shows a single icon and no label |
| CImageRender | Draws the picture of every entity that has a components::Image, stretched over its bound |
| CKeyboardControl | Applies editing keys (arrows, Home, End, Delete, Backspace) to editable text |
| CLayout | Arranges the children of a container in a row or a column and sizes the container around them |
| CLineRender | Draws a horizontal stroke, solid or dashed, for every entity that has a components::Line |
| CList | Styles a list, stacks its rows and folds its accordions |
| CLoadingIndicator | Draws an indeterminate loading indicator: a rotating arc (circular variant) or a bar sliding along a track (linear variant) |
| CMeasureGlyphCacheKey | Key of the size cache of MeasureGlyph: everything a measured icon size is looked up by |
| CMeasureGlyph | Computes the size of every icon and writes it into its Bound, so the layout knows how much room the icon takes |
| CMeasureMeshCacheKey | Key of the size cache of MeasureMesh: the path of the model file |
| CMeasureMesh | Computes the size of every 3D model and writes it into its Bound, so the layout knows how much room the model takes |
| CMeasureTextCacheKey | Key of the size cache of MeasureText: everything a measured size is looked up by |
| CMeasureText | Computes the size of every text and writes it into its Bound, so the layout knows how much room a label takes |
| CMenu | Styles a menu, sizes its rows to the widest one and places the menu below or above its anchor |
| CMeshRender | Draws the 3D model of every entity that has a components::Mesh |
| CMouseButton | Tracks which mouse buttons are held on which entities |
| CMouseMotion | Tracks which entities the mouse pointer is over |
| CNavigationBar | Styles a navigation bar, shares its width between its destinations and keeps exactly one of them selected |
| CNavigationBarDestination | Styles one destination of a navigation bar (an icon in a pill with a label under it and an optional badge) and places those children |
| CNavigationDrawer | Styles a navigation drawer, stacks its entries in a column and keeps exactly one of its destinations selected |
| CNavigationDrawerDestination | Styles one destination of a navigation drawer and places its icon, label and trailing text |
| COverlay | Keeps the stack of open overlays (dialogs, menus, snackbars) and closes the top one on Escape or when its delay runs out |
| CProgressIndicator | Draws a progress indicator: a track and a fill that shows a value from 0 to 1, as a bar or as a ring |
| CRadioButton | The rules of a radio button: selecting it, coloring its ring and placing its dot and label |
| CRadioGroup | The rules of a radio group: a list of radio buttons of which at most one is selected |
| CRectangleRender | Draws the background of an entity: a filled rectangle with rounded corners and an optional border |
| CRenderHandle | What a render system remembers about the engine object it created for one entity |
| CRenderHandleMap | The engine objects one render system owns, keyed by entity identifier |
| CRingRender | Draws a full ring (a circle outline with a thickness) for every entity that has a components::Ring |
| CScrimRender | Draws a scrim: a flat, usually translucent rectangle covering the whole bound of an entity. A modal backdrop is drawn this way |
| CScroll | Scrolls content with the mouse wheel |
| CSearch | Styles a search field and lays out the children that its query, loading state and trailing icon call for |
| CSegmentedButton | Arranges a segmented button: a row of joined toggle buttons of which one (Single mode) or several (Multi mode) are selected |
| CSelection | Keeps at most one child selected in each selection group |
| CSnackbar | Styles a snackbar (a short message with an optional action that disappears on its own) and handles its dismissal |
| CStyleState | Summarizes the input state of an entity into its components::StyleState, the one component widget systems read to choose a look |
| CSurfaceTone | Gives a surface the color and the shadow that match its elevation level in the active theme |
| CSwitch | The rules of a switch: turning it on and off, coloring its track and placing its thumb, thumb icon and label |
| CTextField | Styles a text field, arranges its label, input, affixes, icons and supporting text, and reports what the user typed |
| CTextInput | Adds typed text to editable text |
| CTextRender | Draws the string of every entity that has a components::Text |
| CTooltip | Styles a tooltip, shows it after its anchor has been hovered for a while and places it next to that anchor |
| CTypography | Turns the type-scale role of a text (Body Large, Label Medium, ...) into the font metrics of the active theme |
| Ntheme | Design tokens: colors, type scale, shapes, elevation, motion and spacing. Read them through guillaume::getActiveTheme and the helpers of guillaume/theme.hpp |
| CShapeScale | Turns a ShapeRole into a corner radius in dp, scaled by one "roundness" value |
| CElevationToken | What one elevation level looks like: how much the surface is tinted and how large and dark its shadow is |
| CElevationScale | The six elevation levels of a theme: one ElevationToken per ElevationLevel |
| CStateLayerScale | The opacity of each StateLayer, 0 to 1 |
| CMotionScale | The animation timings of a theme: one length per MotionDuration, plus which easing curve to use for which kind of movement |
| CSpacingScale | Spacing constants: the 4 dp grid every margin and gap is a multiple of, and the minimum size of something a user can hit |
| CFocusRing | Dimensions of the ring drawn around the entity that has the keyboard focus |
| CTypeToken | One text style: everything needed to measure and draw a piece of text |
| CTypescale | The text styles of a theme: one TypeToken per TypeRole |
| CApplication | The entry point of a program: owns the engine, the scenes and the systems, and runs the frame loop |
| CComponentRegistry | An ecs::ComponentRegistry whose storages for the general-purpose components (geometry, appearance, interaction) exist from construction |
| CEventHandler | Interface of an event source: something that reads platform input and reports it as utility::event::Event objects through a callback |
| CLocalStorage | Key-value storage kept in a file: the place for data that must be found again at the next start (preferences, a saved session) |
| CMeshRenderable | What a render system hands to the engine to draw geometry: a list of meshes and the name of the material to draw them with |
| CMetadata | The identity card of an application: its name, version, author and similar descriptive strings |
| CScene | One screen of the application: it owns the entities shown and the components that hold their state |
| CSceneManager | Owns the scenes of an application, knows which one is active, and performs the switches between them |
| CSessionStorage | Key-value storage that lasts as long as the process: the place for data shared between scenes that need not survive a restart |
| CStorage | A key-value store of strings, modelled on the web Storage API (setItem, getItem, removeItem, clear) |
| CTextRenderable | What a render system hands to the engine to draw a piece of text: glyph quads already placed in world coordinates |
| CExtendedColor | A color with a name and a description, as stored in a Scheme or a Palette |
| CScheme | One complete set of colors: a color for every SchemeColorRole |
| CPalette | The shades of one color family, from black (tone 0) to white (tone 100) |
| CTheme | Every design token of the UI in one object: colors, type scale, corner shapes, elevation, state layers and motion |