---
title: AFS_UI
product: Advanced Framework Pro
version: 1.0
engine: Unreal Engine 5.8
updated: 2026-10-05
canonical: https://docs.human-codeable.com/plugins/afs-ui.html
---

System

# AFS_UI

The design system: theme data assets, the widget lifecycle, primitives, composed controls, layout scaffolds, HUD, keyboard, overlays and replicated UI. The largest plugin in the framework.

#### What it gives you

- A themeable widget library covering primitives through to full page scaffolds
- Live theme switching without rebuilding widgets
- World-space and screen-space UI on the same widgets
- A VR keyboard and modal overlay system

#### Requires

None

#### Required by

None

166 assets1370 API members

## Description

`AFS_UI` is a design system, not a widget grab-bag. Its central idea is that styling and content are separate concerns with separate lifecycle hooks, which is what makes runtime theme switching cheap and consistent.

`BP_PDA_Theme` holds fonts, corner radii, outline widths and six colour ramps keyed by intensity. `BPC_GameState_ThemeManager` holds the available themes and broadcasts when the active one changes. Every widget implements `BPI_WidgetElement` and puts styling in `WidgetElement_UpdateTheme` — which runs at start and again on every theme change — while content goes in `WidgetElement_Initiate`, which runs once.

The library layers upward: `AF*` primitives, then composed controls, then layout scaffolds, then the feature plugins that build on all of it.

## Setup

1. Enable `AFS_UI`. Its `Engine.ini` sets the project's UI scaling curve for a 4K design size.
2. Add `BPC_GameState_ThemeManager` to your game state.
3. Populate **Available Themes** with theme data assets and set **Default Theme**.
4. Build your widgets deriving from `WBP_Base`.

[![The theme manager on the game state](../images/AFS_UI_setup-1600.webp?v=5d976696)](../images/AFS_UI_setup-1600.webp?v=5d976696)

The theme manager on the game state

## Usage

### Creating a theme

Duplicate a shipped `BP_PDA_Theme` into your project content and edit the colour ramps and fonts. Register it with the theme manager and switch with `SetThemeType`.

[![The same screen under two themes](../images/AFS_UI_theme_compare-1600.webp?v=6497caf1)](../images/AFS_UI_theme_compare-1600.webp?v=6497caf1)

The same screen under two themes

### Building a widget

Derive from `WBP_Base`. Put styling in `WidgetElement_UpdateTheme`, content in `WidgetElement_Initiate`, and design-time construction in `WidgetElement_InitialConstruct`.

Warning

Styling written in Construct will not re-run when the theme changes. This is the most common cause of a widget that looks wrong after a theme switch.

### Showing a widget in the world

Place a `BP_Widget` actor, or add `BPC_Widget` to your own actor. It supports automatic content fade by distance.

### Showing an overlay

Use `FL_UI_Overlays` for confirm, loading and notification overlays without building your own.

### Text entry in VR

Add a `BP_KeyboardLocation` and the framework shows `WBP_Keyboard_Default` when a text field is focused.

## Key properties

| Property | On | When to change |
|---|---|---|
| `Available Themes` / `Default Theme` | `BPC_GameState_ThemeManager` | To register your own themes |
| `Auto Blend Threshold` | `BP_PDA_Theme` | Contrast point at which text flips between light and dark |
| `Gradient` | `BP_PDA_Theme` | Strength of the gradient applied across surfaces |
| `Use Automatic Content Fade On Distance` | `BPC_Widget` | Turn on for world-space UI so distant widgets stop drawing |
| `Draw Size` | `BPC_Widget` | Widget render resolution — raise for crisp text, lower for performance |

## Extending

Derive from `WBP_Base` and implement `BPI_WidgetElement`. For a new primitive, follow the `AF*` naming and drive its appearance entirely from theme values so it participates in theme switching.

`FL_UI_Material` holds the material helpers the primitives use for rounded corners, gradients and outlines.

## Performance notes

Performance

`Draw Size` on world-space widgets is the biggest cost lever — 2000×2000 is the shipped default and is generous. Turn on distance fade for any world UI the player can walk away from.

## Example map

`Map_Examples_UI` is a full gallery: primitives, controls, layout, HUD anchors and live theme switching.

## Troubleshooting

**Widgets do not restyle on theme change.** Styling is not in `WidgetElement_UpdateTheme`.

**Text is blurry in VR.** Raise `Draw Size` on the widget component, or move the widget closer.

**UI scale is wrong.** The plugin's `Engine.ini` sets a scaling curve for a 3840×2160 design size; a project overriding UI scaling will fight it.

## API reference

Every blueprint asset in this plugin. Expand an asset to see its members.

### Blueprints

**BP_Widget**2 members

extends `Actor`

Ready-made actor for putting a world-space interface in a level: a scene root, an editor billboard and a widget component already set up with fade sounds, a six-metre content fade and a large draw size. Drop it in and choose the widget class on its component. Fade In Out fades the widget away, and the actor destroys itself once the fade finishes.

| Kind | Name | Signature | Description |
|---|---|---|---|
| event | `FadeInOut` | `(Fade: bool)` | Fades the hosted widget in or out by handing the visibility change to the widget component, which runs the fade curve, plays the matching fade sound and drops collision while hidden. The actor itself stays alive either way. |
| event | `OnFadeComplete_Event_0` | `(Visible: bool)` | Internal handler bound to the widget component's fade completion only while a close is running. Destroys the actor once the fade has finished hiding the widget; a fade that ends visible leaves the actor alone. |

### Components

**BPC_GameState_ThemeManager**6 members

extends `ActorComponent`

This component hold the current globally used theme.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Available Themes`Theme | `Map<name, BP_PDA_Theme>` | Themes this game state can switch between, keyed by the identifier passed to Set Theme Type. Fill it in the details panel or add to it at runtime through Add Theme; an identifier that is not in the map sends the current theme back to the default one. |
| var | `Current Theme`Theme | `name` | Identifier of the theme handed out to every bound widget. It is repaired back to the default identifier whenever it is read and found missing from Available Themes, so change it through Set Theme Type rather than writing to it, otherwise nothing is told to restyle. |
| var | `Default Theme`Theme | `name` | Identifier fallen back to whenever the current one cannot be found in Available Themes. Exposed on spawn so a game state can be brought up on a theme other than the light default. |
| fn | `SetThemeType`Theme | `(ID: name)` | Switches the current theme identifier and broadcasts On Theme Updated so every bound widget component and head-up display re-reads its colours. Ignored when the identifier is already the current one, and the identifier is not checked against Available Themes first. |
| fn | `AddTheme`Theme | `(ID: name, Theme: BP_PDA_Theme)` | Registers a theme asset under an identifier, replacing whatever was held under that identifier before. Registering does not switch to it; call Set Theme Type for that. |
| fn | `GetCurrent_Theme`Theme | `(out Theme: BP_PDA_Theme)` | Returns the theme asset registered under the current identifier, first resetting that identifier to the default one if it is missing from Available Themes. Comes back empty when neither identifier is in the map. |

**BPC_PawnAbility_HUD**16 members

extends `BPC_PawnAbility` · implements `BPI_WidgetComponent`

Pawn ability giving a pawn a head-up display. Add it and the pawn can add, remove and toggle widgets in numbered frames; on a VR pawn it spawns a helper actor carrying the display in front of the camera, on desktop and mobile it goes to the viewport. It also acts as those widgets' widget component, resolving actor references, playing sounds and following the theme manager.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Theme`Theme | `BP_PDA_Theme` | Override applied to this head-up display in place of the game-wide theme. While one is set the component ignores the game state's theme manager and unsubscribes from its updates; leave empty to follow the theme in use across the game. |
| var | `Initial Widgets`Initial | `ST_HUD_Widget[]` | Widgets meant to be present on the head-up display from the start, each paired with the frame it should occupy. Nothing in this component's graph reads the list in this build, so widgets have to be put up through Add Widget Class. |
| var | `Dynamic References`Initial | `Map<name, ST_DynamicReference>` | Allows the widgets to get world references of specified actors. |
| fn | `OnThemeUpdated`Theme | `()` | Hands the current theme to the head-up display widget so every element below it restyles, flagged as desktop styling for desktop and mobile pawns and as world styling for a VR pawn. Bound to the theme manager, so it runs again on every game-wide theme change. |
| fn | `BindToThemeManager`Theme | `()` | Subscribes the head-up display to the game state theme manager's update broadcast, or unsubscribes it when a theme override is set on the component. Does nothing when the game state carries no theme manager. |
| fn | `UpdateCustomTheme`Theme | `(Theme: BP_PDA_Theme)` | Swaps the theme override at runtime, rebinding to or unbinding from the theme manager and restyling the head-up display and everything on it. Does nothing when the asset passed is the one already in use. |
| fn | `SetHUDVisibility`State | `(Set: bool)` | Shows or hides the whole head-up display by driving its render opacity to one or zero, leaving the widgets in place rather than removing them. Skipped where cosmetic events cannot run, and ignored when the state asked for is the current one. |
| fn | `GetTheme`Theme | `(out Theme: BP_PDA_Theme)` | Returns the theme this head-up display draws with: the override on the component when one is set, otherwise the game state theme manager's current theme, falling back to the default light theme when the game state has no manager. |
| fn | `GetWidget`Widgets | `(WidgetClass: class<WBP_Base>, out Widget: WBP_Base)` | Returns the open head-up display widget whose class matches exactly, or nothing when no widget of that class is up. Only top-level widgets are searched, not their children. |
| fn | `ToggleWidget_Class`Widgets | `(WidgetClass: class<WBP_Base>, Frame: ST_HUD_FrameInfo, Struct_References: Struct_References, out Widget: WBP_Base)` | Closes the open widget of the given class, or creates one in the given frame when none is open and returns it. References are only resolved on the pass that creates the widget, and nothing is returned when the call closed one. |
| fn | `RemoveWidget_Class`Widgets | `(Widget: class<WBP_Base>)` | Removes the open widget of the given class from the head-up display and closes its frame. Does nothing when no widget of that class is open. |
| fn | `RemoveWidget_Object`Widgets | `(Widget: WBP_Base)` | Removes a widget from the head-up display, walking up from a nested widget to the top-level one owning its frame and closing that frame. The widget's screen control request is dropped at the same time, so the mouse mode falls back to what the remaining widgets ask for. |
| fn | `AddWidget_Class`Widgets | `(HUDWidget: class<WBP_Base>, Frame: ST_HUD_FrameInfo, References: Struct_References, CheckIfAlreadyExists: bool, out Widget: WBP_Base)` | Creates a widget of the given class inside a head-up display frame and returns it, resolving the dynamic references first. With Check If Already Exists set, an open widget of that class is returned untouched instead of a second one being built. |
| fn | `AddWidget_Object`Widgets | `(InWidget: WBP_Base, Frame: ST_HUD_FrameInfo, References: Struct_References)` | Resolves the dynamic references handed in, then places an already-created widget into a head-up display frame at the anchor and layer the frame describes. Use it when you need to build the widget yourself; Add Widget Class covers the ordinary case. |
| fn | `IsWidgetOpen`Widgets | `(Widget: WBP_Base, out Open: bool)` | Returns whether the given widget is one of the head-up display's top-level widgets. A nested child answers false, since only widgets added to a frame are tracked; the head-up display itself is created on the first call if it does not exist yet. |
| event | `OnDestroyed_Event_0` | `(DestroyedActor: Actor)` | Internal handler that tears the head-up display down when the actor it is bound to is destroyed, unregistering every element from replication and removing it. |

**BPC_Widget**51 members

extends `WidgetComponent` · implements `BPI_WidgetComponent`, `BPI_SourceInfo`, `BPI_WidgetInteraction`, `OutsidePawnRPCInterface`

Default widget component

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Sound Volume Multiplier`Sound | `float` | Volume multiplier applied to every sound this widget plays, fade sounds and widget sounds alike. An overlay copies it from the widget component that opened it, so both sound the same. |
| var | `Sound Attenuation Override`Sound | `SoundAttenuation` | Attenuation asset used for the widget's sounds in place of the one picked from its world scale. Leave empty to let the component choose the medium attenuation for a large widget and the near one for a small one. |
| var | `Fade Curve`Fade | `CurveFloat` | Curve meant to shape the widget's fade over time. The fades in this build run on the shared ease-in-out curve instead, so nothing in the graph reads it. |
| var | `Widget Visibility`Fade | `bool` | Whether the widget is currently shown. It also gates the automatic distance checks, the draw size check and the collision state, so set it through Set Widget Visibility rather than writing to it, or none of those follow-ups run. |
| var | `Fade Duration`Fade | `float` | Length in seconds of the fade the widget plays as it comes up at Begin Play. The component only counts as initialised, and only takes on collision, once that fade has finished. |
| var | `Use Automatic Content Fade on Distance`Automatic\|Content Fade | `bool` | Whether the widget watches its distance to the player camera so its content can fade out once the camera is far enough away. The watch only runs while the widget is visible. |
| var | `Automatic Refresh Time Range`Automatic | `FloatRange` | Bounds in seconds used to derive how often the automatic distance checks repeat. The interval is recomputed from the camera distance on each pass, so a distant widget is polled towards the upper bound and a near one towards the lower. |
| var | `Automatic Content Fade Distance`Automatic\|Content Fade | `float` | Distance in centimetres from the player camera at which the content fade switches over, with a ten per cent deadzone either side so the state does not flicker on the boundary. Only read while Use Automatic Content Fade On Distance is set. |
| var | `Fade in Sound`Sound | `SoundBase` | Sound played at the centre of the widget when it is switched to visible, placed in the world and attenuated like every other widget sound. Leave empty for a silent appearance. |
| var | `Fade Out Sound`Sound | `SoundBase` | Sound played at the centre of the widget when it is switched to hidden, placed in the world and attenuated like every other widget sound. Leave empty for a silent disappearance. |
| var | `Custom Theme`Theme | `BP_PDA_Theme` | Theme override for this widget. While one is set the component ignores the game state theme manager and unsubscribes from its updates; leave empty to follow the theme in use across the game. |
| var | `Reference Actors`Reference | `Map<name, Actor>` | Actors the widgets on this component can look up by name, seeded in the details panel and added to as dynamic references are resolved. A widget asking for a key that is not present gets nothing back rather than an error. |
| var | `Automatic Check Draw Size`Draw Size | `bool` | Whether the component polls its own draw size and broadcasts On Draw Size Updated when it changes. Switched on by itself when a panel is added, since the panel meshes have to be resized to match the widget. |
| var | `Draw Size Check Time`Draw Size | `float` | Interval in seconds between draw size checks while the size is holding steady. Straight after a change the check runs at 11 milliseconds instead, so a resize settles quickly and then backs off again. |
| var | `Use Automatic Disappear on Distance`Automatic\|Disappear | `bool` | Whether the widget watches its distance to the player camera so it can fade away outside a range. The watch only runs while the widget is visible. |
| var | `Automatic Disappear Range`Automatic\|Disappear | `FloatRange` | Near and far distance in centimetres between which the widget stays fully present. Outside that band, with a ten per cent deadzone either side, it is flagged as out of range and the redraw mode switches to manual. |
| var | `Automatic Disappear Opacity Value`Automatic\|Disappear | `float` | Opacity of 0 to 1 the widget is meant to settle at while it is outside the disappear range. Nothing in this component's graph reads it in this build. |
| var | `Use Panel`Frame | `bool` | Whether a panel component is spawned behind the widget to give it a solid backing. Read once at Begin Play; use Set Panel afterwards, which builds or tears the panel down and switches the draw size check on as it does. |
| var | `Use Automatic Redraw Update`Redraw | `bool` | Whether the redraw loop runs, tuning the widget's redraw rate from its distance to the camera and from whether it is hovered or animating. Read once at Begin Play; use Set Redraw Check to start or stop the loop later. |
| var | `Widget Collision`Collision | `bool` | Whether the widget may take on query collision so a laser or pointer can hit it. Collision is only switched on once the widget is also visible, initialised and not covered by a blocking overlay, so clearing this makes the widget purely decorative. |
| fn | `ReplicationUpdate`Replication | `()` | Replays every stored replicated value into the widget registered under its identifier, skipping the entries this client sent itself. Runs after the widget class is set and whenever a replicated update arrives; skipped where cosmetic events cannot run. |
| fn | `OnThemeUpdated_Event`Theme | `()` | Re-applies the current theme: refreshes the widget material's colour, hands the theme to the root widget so every element below restyles, and broadcasts On Widget Theme Updated. Bound to the theme manager, so it also runs on a game-wide theme change. |
| fn | `UpdateWidgetMaterialForTheme`Theme | `()` | Pushes the theme's high intensity background colour into the widget material's back colour parameter. Does nothing while the material instance does not yet exist, which is the case for the first moments of play. |
| fn | `BindToThemeManager`Theme | `()` | Subscribes the component to the game state theme manager's update broadcast, or unsubscribes it when a theme override is set. Runs at Begin Play and again on every override change; does nothing when the game state carries no theme manager. |
| fn | `UpdateCustomTheme`Theme | `(Theme: BP_PDA_Theme)` | Swaps the theme override at runtime, rebinding to or unbinding from the game state theme manager and then restyling the widget material and every element on the widget. Does nothing when the asset passed is the one already in use. |
| fn | `UpdateDrawSizeCheck`State\|Draw Size | `()` | Starts or stops the draw size polling loop according to whether automatic checking is on and the widget is visible. Called whenever visibility changes, so a hidden widget stops polling its size. |
| fn | `SetCustomOpacity`State\|Opacity | `(Opacity: float)` | Sets the custom opacity term, 0 to 1, and recomputes the widget's opacity from it together with the visibility, start-up and distance terms; the smallest of the four wins. The component hides itself outright once the result reaches zero. |
| fn | `DetermineSoundAttenuation`Sound | `(out SoundAttenuation: SoundAttenuation)` | Returns the attenuation used for this widget's sounds: the override when one is set, otherwise the medium attenuation for a component scaled above 0.025 and the near one for anything smaller. |
| fn | `GetTheme`Theme | `(out Theme: BP_PDA_Theme)` | Returns the theme this widget draws with: the override on the component when one is set, otherwise the game state theme manager's current theme, falling back to the default light theme when the game state has no manager. |
| fn | `CheckAndUpdateCollision`Collision | `()` | Re-evaluates the widget's collision. Query collision goes on only while the widget is visible, has collision allowed, has finished its start-up fade and is not covered by a blocking overlay; every other case leaves it with no collision. |
| fn | `isWidgetHovered`Widget | `(out IsHovered: bool)` | Returns whether a pointer is over the widget, as last reported by the interaction system. Reads a cached flag; nothing is traced when you call it. |
| fn | `UpdateManuallyRedraw`Redraw | `()` | Switches the component between manual and automatic redraw. Manual is used while the widget is hidden or flagged as beyond the disappear or content fade distance, since a widget nobody can read need not keep redrawing. |
| fn | `WidgetToWorldCoordinates`Coordinates | `(WidgetCoordinates: Vector2D) → Vector` | Returns the world position of a point given in widget coordinates, measured from the widget's pivot and pushed through the component's world transform. Used to put sounds and overlays where the user actually pressed. |
| fn | `getRelativeLocation_Unscaled`Coordinates | `(WidgetCoordinates: Vector2D, Anchor: Vector2D, out RelativeLocation: Vector)` | Returns a point given in widget coordinates as an offset in the component's local space, ignoring the component's relative scale. Use the scaled version when the result is going to position something attached to the component. |
| fn | `getRelativeLocation_Scaled`Coordinates | `(WidgetCoordinates: Vector2D, Anchor: Vector2D, out RelativeLocation: Vector)` | Returns a point given in widget coordinates as an offset in the component's local space, multiplied by the component's relative scale. Anchor runs 0 to 1 across the widget and says which corner or edge the coordinates are measured from. |
| fn | `SetReplicationValue`Replication | `(ReplicationValue: Struct_WidgetReplication)` | Stores a replicated value for one registered widget, overwriting the entry that shares its object and replication identifiers or appending a new one. Meant to run on the server; the other clients pick it up through the replication notification. |
| fn | `getWidgetObject`Widget | `(out AsWBP Base: WBP_Base)` | Returns the user widget this component is displaying, cast to the framework's widget base. Comes back empty when the widget class is a plain user widget, which is also why the theme and reference plumbing does nothing for such a widget. |
| event | `SetWidgetVisibility` | `(Set: bool)` | Shows or hides the widget, broadcasting On Widget Visibility Changed and playing the fade in or fade out sound at its centre. Also refreshes the redraw mode, the distance checks and the draw size check, and on hiding drops collision and closes any overlay. Ignored when the state asked for is the current one. |
| event | `SetAutomaticContentFade` | `(Set: bool)` | Starts or stops the loop watching the camera distance against Automatic Content Fade Distance, flagging whether the widget is beyond it and refreshing the redraw mode when that answer changes. Driven by the visibility and the content fade setting rather than called directly. |
| event | `Server_SetReplicationValue` | `(ReplicationValue: Struct_WidgetReplication)` | Server-side entry point for storing a replicated widget value. Widget elements reach it through Replicate Value rather than calling it themselves; the stored array then replicates down to the other clients, where it is replayed. |
| event | `SetInitialVisibility` | `()` | Called once from Begin Play to settle the widget's starting visibility. It branches on the visibility flag but carries no work of its own in this build. |
| event | `AddReferenceObject` | `(Key: name, Reference: Actor)` | Stores an actor under a name so the widgets on this component can look it up, replacing anything held under that name before. Use it for references only known at runtime, which cannot be set in the details panel. |
| event | `OpenOverlay` | `()` | Called once a blocking overlay has been spawned on this component and its collision has been dropped. Empty here; implement it in a child component to react to the widget being covered. |
| event | `OverlayClosed` | `(Overlay: BP_Overlay)` | Internal handler bound to the overlay this component spawned. Broadcasts On Overlay Updated, clears the blocking flag and restores collision, ignoring calls that come from an overlay which is no longer the current one. |
| event | `SetSoundSettings` | `(SoundVolumeMultiplier: float, SoundAttenuation: SoundAttenuation)` | Overwrites the volume multiplier and the attenuation override at runtime. Used when an overlay is spawned, so it plays its sounds exactly as the widget that opened it does. |
| event | `SetWidgetClass` | `(Widget: class<WBP_Base>, References: Struct_References)` | Creates a widget of the given class, sets it on the component, resolves the dynamic references, initialises the widget with the current theme, replays any replicated values and broadcasts On Widget Class Updated. Does nothing when no class is passed. |
| event | `CheckDrawSizeUpdated` | `(Condition: bool)` | Starts or stops the loop comparing the current draw size against the last one and broadcasting On Draw Size Updated when it has moved. Polls at 11 milliseconds while the size keeps changing and at Draw Size Check Time once it settles. |
| event | `SetAutomaticDisappear` | `(Set: bool)` | Starts or stops the loop watching the camera distance against the disappear range, flagging whether the widget has left it and refreshing the redraw mode when that answer changes. Driven by the visibility and the disappear setting rather than called directly. |
| event | `SetRedrawCheck` | `(Set: bool)` | Starts or stops the loop tuning the widget's redraw time. A hovered or animating widget redraws every frame, an ordinary visible one at a rate scaled by its distance to the camera, and one that has not been rendered recently drops to every three seconds. |
| event | `SetPanel` | `(Set: bool)` | Adds or removes the panel backing the widget. Adding spawns a panel component on the owner, attaches it and switches the draw size check on so the panel keeps matching the widget; removing cleans the panel up and destroys it. |
| event | `RemoveReferenceObject` | `(Key: name)` | Drops the actor held under a name, after which widgets asking for that key get nothing back. Removing a key that was never added is harmless. |

### DataAssets

**PDA_WidgetPage**2 members

extends `PrimaryDataAsset`

Data asset pairing a widget class with the button content that opens it, so a menu can carry its pages as data. Make one per page and list it on a menu subpage or on a pawn's page list rather than wiring the widget into the menu itself.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Button`Style | `ST_Button_Content` | Identifier, texts and images describing the button or tab that stands for this page, in the same content shape every framework button takes. The stock menus keep their tabs in the designer and only read the page list once one is selected, so this entry is for a menu that builds its buttons out of the list instead. |
| var | `Widget`Content | `class<WBP_Base>` | The page itself, shown in the menu's switcher when this entry is chosen. |

### Helper

**BPC_Panel_Widget**3 members

extends `BPC_Panel`

Panel component specialised for sitting behind a widget. It keeps its nine-slice meshes matched to the widget component's current draw size and pivot, and recolours them from the theme, choosing rounded or straight corners from the theme's corner sizes. The widget component adds and removes it as Use Panel changes, so there is rarely a reason to add it yourself.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Widget` | `BPC_Widget` | Owning widget component that this panel frames. Supplied when the widget component builds the panel through Set Panel; the theme, draw size and pivot are all read back from it, so a panel without one never updates its meshes or colour. |
| event | `OnThemeUpdated` | `()` | Called when the theme behind the framed widget changes. Swaps in the rounded corner mesh whenever the theme's large corner size is above zero and the straight one otherwise, then paints both the border and the base of the panel in the theme's text colour. |
| event | `OnDrawSizeUpdated_Event` | `()` | Called when the framed widget reports a new draw size. Rescales and repositions the panel meshes to that draw size and the widget's pivot, which is what keeps the frame wrapped around a widget that grows or shrinks. |

**BP_Helper_HUD**0 members

extends `Actor`

Carrier actor the head-up display ability spawns for VR pawns. Holds the display's widget component on a spring arm with rotation lag so the interface trails head movement instead of being welded to it, and tidies itself up through the auto-destroy component. Spawned for you; not something to place.

No editor-visible members; this asset configures defaults only.

### Interfaces

**BPI_WidgetComponent**17 members

extends `Interface`

Contract between a widget and whatever is presenting it: closing widgets, playing widget sounds, opening and closing overlays, registering widgets for replication and resolving named actor references. Widgets call it on their widget component, so implement it on any component of your own that should host framework widgets.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `WidgetComp_AddReference`Widget References | `(Key: name, Reference: Actor)` | Stores an already resolved actor under a key in the reference registry, replacing anything held there. Use it when the actor is known up front rather than found by class and tag. |
| fn | `WidgetComp_IsKeyboardSupported`Widget Keyboard | `(out SupportsKeyboard: bool)` | Reports whether a keyboard can be raised for widgets on this host. The interface default is no; the widget component answers yes, and text fields ask before offering to open a keyboard on focus. |
| fn | `WidgetComp_getEventListener`Widget Essentials | `(out EventListener: BP_WidgetEventListener_Mouse)` | Returns the object carrying the host's mouse delegates, creating it on the first call so it is never null. Bind to it when a widget needs to hear about presses that landed anywhere on the surface rather than on itself. |
| fn | `WidgetComp_MouseButtonPressed`Widget Essentials | `(PressLocation: Vector2D)` | Forwards a press at the given screen position to the host's event listener, which broadcasts it to everything bound. The widget component throttles this to one press per second, so rapid repeat presses are swallowed. |
| fn | `WidgetComp_WidgetAnimating`Widget Essentials | `(Time: float)` | Declares that an animation of the given length in seconds has started. The widget component holds its animating flag for that long, redrawing every frame meanwhile; the Widget Base Play Animation macro calls it for you. |
| fn | `WidgetComp_WidgetHovered`Widget Essentials | `(Set: bool)` | Reports that a pointer has entered or left the widget surface. The widget component records the state, broadcasts On Widget Hovered and keeps its redraw rate high while the surface stays hovered. |
| fn | `WidgetComp_CloseOverlay`Widget Overlay | `()` | Closes the overlay currently open in front of the host. Does nothing when none is open. |
| fn | `WidgetComp_PlayWidgetSound`Widget Sound | `(SoundLocation: Vector2D, SoundCue: SoundBase)` | Plays a sound at a point given in widget coordinates. The widget component converts those coordinates to world space and applies its own volume multiplier and attenuation, so the sound comes from the spot on the widget surface that caused it. |
| fn | `WidgetComp_AddAndResolveReference`Widget References | `(Key: name, DynamicReference: ST_DynamicReference, out Actor: Actor)` | Finds the actor a dynamic reference describes, stores it under the key and hands it back. Search is by class alone when the reference carries no actor tag; otherwise the first actor of that class carrying the tag wins and nothing is stored if none does. |
| fn | `WidgetComp_AddAndResolveReferences`Widget References | `(DynamicReferences: Struct_References)` | Resolves a whole set of dynamic references in one pass and stores each resulting actor under its key. Equivalent to calling Add And Resolve Reference for every entry of the struct. |
| fn | `WidgetComp_getAllReferenceKeys`Widget References | `(out Keys: name[])` | Returns every key currently present in the reference registry, in no particular order. |
| fn | `WidgetComp_RegisterWidget`Widget Replication | `(Key: name, Widget: BPI_WidgetElement)` | Registers a widget under a replication identifier so incoming replicated values can be routed to it. The widget component ignores the call entirely unless its owning actor replicates, and replaces whatever was already held under the same key. |
| fn | `WidgetComp_UnregisterWidget`Widget Replication | `(Widget: BPI_WidgetElement)` | Drops a widget from the replication registry so that replicated updates stop reaching it. Called on every element in turn as a widget tree is cleanly removed. |
| fn | `WidgetComp_getReferenceActor`Widget References | `(Key: name, out Reference: Actor)` | Looks up an actor previously registered under a key. Returns nothing when the key is unknown, and is how a widget reaches the actor it drives without holding a hard reference to it. |
| fn | `WidgetComp_OpenOverlay`Widget Overlay | `(WidgetCoordinates: Vector2D, Blocking: bool, SourceObject: Object, ContentClass: class<Object>, DesiredPivot: Vector2D, SizeMultiplier: float, out OverlayWidget: WBP_Base)` | Opens an overlay actor in front of the host at the given widget coordinates and returns its root widget. Blocking suppresses interaction with the surface underneath; asking again from the source that already owns the open overlay closes it instead of reopening. |
| fn | `WidgetComp_ReplicateValue`Widget Replication | `(Widget: BPI_WidgetElement, ReplicationIdentifier: name, ReplicationContent: string[])` | Sends a named value and its content strings from one registered widget out to the other clients. The widget component looks the widget up in its registry and pushes the entry through the server, so nothing is sent for a widget that was never registered. |
| fn | `WidgetComp_CloseWidget`Widget Essentials | `(Source: WBP_Base)` | Asks the host of a widget to close it, passing the widget that made the request. The widget component answers by broadcasting On Close Widget Requested rather than tearing anything down itself, so whoever spawned the widget decides what closing means. |

**BPI_WidgetElement**15 members

extends `Interface`

Contract every element inside a framework interface answers to, covering construct, initiate, theme update, replication and the slot and child queries the recursive widget walk uses to reach nested elements. The widget base already implements it; implement it yourself only on a widget built on something else that still has to be themed and initialised with the rest of the tree.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `WidgetElement_SwitcherVisibility`Style | `(Switcher: AFSwitcher, Set: bool)` | Tells the element that a switcher above it has shown or hidden the branch it lives in. Elements keep a list of the switchers currently hiding them and count themselves visible only once every one of those has released. |
| fn | `WidgetElement_RefreshStyling`Style | `()` | Called on an element's parent after one of its children has been shown or collapsed through the Set Show Collapse macro. Implement it for layout that has to close up around a hidden child, as the boxes do with their paddings. |
| fn | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `WidgetElement_getWidgetTag`Tag | `(out WidgetTag: name)` | Returns the tag this element answers to when a widget is searched for by tag. Defaults to None, which no search ever matches. |
| fn | `WidgetElement_getCustomChildWidgets`Slots | `(out Widgets: Widget[])` | Returns child widgets the tree walk would not otherwise reach, typically ones held in a variable rather than in the slot hierarchy. Listing them here is what gets them initiated, themed and cleaned up along with the rest of the tree. |
| fn | `WidgetElement_RemoveWidget`Construct | `()` | Takes this element out of the widget tree. Called on every element during a clean removal, immediately after its replication registration has been dropped. |
| fn | `WidgetElement_UnregisterReplication`Replication | `()` | Removes this element from the host's replication registry. Called on every element in reverse order as a widget tree is cleanly removed, just before Remove Widget. |
| fn | `WidgetElement_ExecuteReplication`Replication | `(ReplicationIdentifier: name, Content: string[])` | Called on the other clients when a replicated value arrives for this element, carrying the identifier and its content strings. Implement it to reflect a change another player made; it is skipped on the client that sent the value. |
| fn | `WidgetElement_getReplicationInfo`Replication | `(out Suffix: name)` | Returns the suffix identifying this element inside its parent's replication identifier. Defaults to None; siblings sharing a suffix are told apart by the index the tree walk counts out and passes to Initiate. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| fn | `WidgetElement_InitialConstruct`Construct | `()` | Called on every element while the owning widget pre-constructs in the editor, immediately before the design-time theme pass. Implement it for preview-only set-up; it never runs in a running game. |
| fn | `WidgetElement_getIsReplicating`Replication | `(out Replicating: bool)` | Reports whether this element mirrors its value to the other clients. Defaults to false, so an element that does not answer takes no part in replication. |
| fn | `WidgetElement_Initiate`Style | `(Parent: WBP_Base, ReplicationIndex: name)` | Called once per element while the owning widget walks its tree after begin play, handing over the parent widget and the index that makes this element's replication identifier unique among its siblings. Implement it for content set-up; the theme pass follows. |
| fn | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**BPI_Widget_Blend**2 members

extends `Interface`

One blend value for elements that cross-fade between two looks, such as a rounded border easing into its hover colour. Implemented by borders, icons and text so the button around them can drive the transition with a single call, without knowing what each element does with it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Widget_getBlendValue`Widget Blend | `(out Alpha: float)` | Returns the blend alpha last applied to the element, 0 to 1. Answers zero for elements that keep no blend state of their own. |
| fn | `Widget_setBlendValue`Widget Blend | `(Alpha: float)` | Drives the element's blend alpha, 0 to 1. Buttons, text fields, sliders and drop-downs push their hover and press animation curves in through this, and the receiving border, text or icon rebuilds its colour from the new value straight away. |

**BPI_Widget_TreeElement**1 members

extends `Interface`

Contract for an object that knows which tree element widget should display it, so a tree can build a row straight from its contents. Nothing in the shipped content implements it, which makes it an extension point for trees of your own rather than something already wired up.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `TreeElement_getWidgetClass` | `(out Class: class<WBP_TreeElement>)` | Returns the tree element widget class that should be built to represent this object in a tree. Returns nothing by default, which leaves the tree with no row to spawn. |

### Libraries

**FL_UI_Material**19 members

extends `BlueprintFunctionLibrary`

Function library building the dynamic material instances the framework's elements draw with, one call per border, image, outline and gradient variant, each fed from a theme and a colour definition. Also holds the contrast and auto-blend helpers that pick a readable foreground against a given background. Called statically by the elements, and by any element you write yourself.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `CreateMaterial_Border_Rounded_Custom`Materials\|Border | `(Theme: BP_PDA_Theme, NormalMaterial: MaterialInterface, DesktopMaterial: MaterialInterface, Desktop: bool, Corners: ST_Corner_Definition, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of a material you supply, choosing between the normal and the desktop version, and applies only the corner radii. Use it to bring a bespoke material into the theme's rounding; colour and everything else stay as the material authored them. |
| fn | `CreateMaterial_Image_Rounded_Transition`Materials\|Image | `(Theme: BP_PDA_Theme, Desktop: bool, Texture: Texture, CornerDefinition: ST_Corner_Definition, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the rounded transition image material with the given texture and corner radii. Only those two are set here; whatever the material exposes to drive the transition itself is left at its default. |
| fn | `CreateMaterial_Image_Rounded_Translated`Materials\|Image | `(Theme: BP_PDA_Theme, Desktop: bool, Texture: Texture, Corners: ST_Corner_Definition, Translation: ST_Image_Translation, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the rounded image material that can pan and zoom its texture, applying the texture, the corner radii and the zoom and offsets from the translation struct. |
| fn | `CreateMaterial_Image_Rounded_Background`Materials\|Image | `(Theme: BP_PDA_Theme, Desktop: bool, Texture: Texture, Corners: ST_Corner_Definition, Color: ST_Color_Definition, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the rounded image material that also fills behind the texture, applying the texture, the corner radii and the background colour. |
| fn | `InvertLinearColor`Color | `(LinearColor: LinearColor, __WorldContext: Object, out InvertedColor: LinearColor)` | Returns the colour with its brightness flipped and its hue, saturation and alpha untouched. Used by the automatic contrast pass rather than as a general-purpose inversion. |
| fn | `CreateMaterial_Hover`Materials\|Hover | `(Theme: BP_PDA_Theme, Desktop: bool, Color: ST_Color_Definition, Corners: ST_Corner_Definition, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the rounded hover material with the given colour and corner radii. This is the highlight layer that fades in under a hovered element, driven afterwards through Set Blend Value. |
| fn | `Get Color with Auto Blend`Color | `(Theme: BP_PDA_Theme, Color: ST_Color_Definition, AutoBlend: ST_AutoBlend, Alpha: float, __WorldContext: Object) → LinearColor` | Resolves a colour and, when the auto blend struct switches it on, blends between the versions adjusted for the resting and the blended background using Alpha from 0 to 1. With auto blend off the colour comes straight from the theme and Alpha is ignored. |
| fn | `ConvertForgroundColorAccordingToBackground`Color | `(Theme: BP_PDA_Theme, ForgroundColor: ST_Color_Definition, BackgroundColor: ST_Color_Definition, __WorldContext: Object, out AdjustedColor: LinearColor)` | Resolves a foreground colour against a background and flips its brightness when the two do not contrast enough, judged against the theme's auto blend threshold. Returns a bright orange when no theme is supplied, which makes the omission obvious on screen. |
| fn | `ContrastColors`Color | `(ForgroundColor: LinearColor, BackgroundColor: LinearColor, __WorldContext: Object, out ContrastValue: float)` | Returns the contrast ratio between two colours from their relative luminance, the lighter plus 0.05 over the darker plus 0.05. Runs from 1 for two identical colours up to 21, and is symmetrical, so swapping the inputs changes nothing. |
| fn | `CreateMaterial_Image_Rounded`Materials\|Image | `(Theme: BP_PDA_Theme, Desktop: bool, Texture: Texture, CornerDefinition: ST_Corner_Definition, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the rounded image material with the given texture and corner radii. |
| fn | `CreateMaterial_Outline`Materials\|Outline | `(Theme: BP_PDA_Theme, Desktop: bool, CornerDefinition: ST_Corner_Definition, OutlineCategory: E_UI_Outline, BorderColor: ST_Color_Definition, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the rounded outline material, applying the corner radii, the border colour and the width the theme registers for the given outline category. |
| fn | `CreateMaterial_Image_Icon`Materials\|Image | `(Theme: BP_PDA_Theme, Texture: Texture, Color: ST_Color_Definition, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the icon material, which tints the given texture with the resolved colour. Meant for single-tone icons; a full-colour texture is tinted along with everything else. |
| fn | `CreateMaterial_Image`Materials\|Image | `(Theme: BP_PDA_Theme, Texture: Texture, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the plain image material carrying the given texture. Nothing else is set, so the image draws unrounded and untinted. |
| fn | `CreateMaterial_Border_Rounded_Linear`Materials\|Border | `(Theme: BP_PDA_Theme, Desktop: bool, LinearColor: LinearColor, Corners: ST_Corner_Definition, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the rounded border material and writes a linear colour straight into it, bypassing the theme palette. Use it when the colour has already been resolved or comes from outside the theme; corner radii still come from the definition. |
| fn | `CreateMaterial_Border_Rounded_Gradient_2Colors`Materials\|Border | `(Theme: BP_PDA_Theme, Desktop: bool, Corners: ST_Corner_Definition, Color: ST_Color_Definition, SecondColor: ST_Color_Definition, GradientRotation: float, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the two-colour rounded gradient border material. Both colours are written along with their theme-shifted partners, so the gradient runs between two full tones at the given rotation. |
| fn | `CreateMaterial_Border_Rounded_Gradient`Materials\|Border | `(Theme: BP_PDA_Theme, Desktop: bool, CornerDefinition: ST_Corner_Definition, PrimaryColor: ST_Color_Definition, GradientRotation: float, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the rounded gradient border material. The one colour supplied fills one end of the gradient and its theme-shifted partner the other, turned by the given rotation in degrees. |
| fn | `CreateMaterial_Border_Rounded_Sides`Materials\|Border | `(Theme: BP_PDA_Theme, Desktop: bool, Corners: ST_Corner_Definition, Color: ST_Color_Definition, Sides: Vector4, SideColor: ST_Color_Definition, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the rounded border material that can colour individual edges. Applies the fill colour and corner radii, then the side mask and the colour those sides are drawn in. |
| fn | `CreateMaterial_Border_Rounded`Materials\|Border | `(Theme: BP_PDA_Theme, Desktop: bool, Corners: ST_Corner_Definition, Color: ST_Color_Definition, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the rounded border material and applies the fill colour and the corner radii. Set Desktop to take the desktop variant of the material, which is the one meant for widgets drawn on screen rather than in the world. |
| fn | `CreateMaterial_Border`Materials\|Border | `(Theme: BP_PDA_Theme, Color: ST_Color_Definition, __WorldContext: Object, out Material: MaterialInstanceDynamic)` | Creates a dynamic instance of the flat border material and paints it with the resolved colour definition. No corner rounding is applied, so it draws a square fill. |

**ML_UserWidget**0 members

extends `UserWidget`

Macro library for plain User Widgets, covering size box width and height overrides driven by the size override struct, animation playback, timed gates and float interpolation. Parented to User Widget, so its macros are offered in any widget, including ones not built on the framework's widget base.

No editor-visible members; this asset configures defaults only.

**ML_WBP_Base**0 members

extends `WBP_Base`

Macro library for widgets built on the framework's widget base: playing an animation while telling the widget component it is animating, looking up reference actors and components by key, show and collapse helpers, a temporary replication block and a Source Info lookup. Parented to that base, so the macros only appear inside widgets inheriting from it.

No editor-visible members; this asset configures defaults only.

### Objects

**BP_UI_Button_Object**13 members

extends `Object`

List item object standing in for a button that has not been built yet. It carries the content, padding, hierarchy preset, height and options a button should take on, plus its selected state and the pressed and selection-changed delegates. Feed these to a list view and each row's button configures itself from one, which is how button groups stay data-driven.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Parent`Widget | `WBP_Base` | Widget that owns the list this entry appears in. The button initialises itself as a sub-widget of it when the entry is assigned, which is how it inherits the theme and the widget component; leave it empty and the button stays uninitialised. |
| var | `Widget Component`Widget | `ActorComponent` | Widget component behind the list this entry appears in. Nothing in the entry or the standard button reads it, which take their component from Parent instead, so it is carried for list owners that need it earlier. |
| var | `Content`InfoItem | `ST_Button_Content` | Texts, images and identifier the button shows for this entry. Copied into the button when the list assigns the entry, and the identifier travels with the pressed broadcast so listeners know which entry fired. |
| var | `Button Padding`Style | `Margin` | Margin the entry asks for around its row. Neither the entry nor the standard button reads it, so it only has an effect where the list owner applies it while building the row. |
| var | `Button Variation`Style | `int` | Index selecting which visual variation of the button the list should build for this entry. Not read by the standard button, so it means only what the list owner chooses to make it mean. |
| var | `Use Button Height`Style | `bool` | Whether the row should take the fixed height given by Button Height Override instead of sizing to its content. Read by the list owner building the row rather than by the standard button. |
| var | `Button Height Override`Style | `float` | Height in slate units the row asks for when Use Button Height is set. Read by the list owner building the row rather than by the standard button. |
| var | `Content Widget`Style | `class<WBP_ButtonContent>` | Widget class drawn inside the button for this entry. Copied into the button as its content widget class when the entry is assigned; leave empty to keep whatever content class the button already has. |
| var | `Not Hoverable When Selected`Style | `bool` | Whether the button stops reacting to hover once this entry is selected. Copied into the button when the entry is assigned. |
| var | `Preset`Style | `E_UI_Hierarchy` | Emphasis level the button draws this entry with, primary through quaternary, which decides the theme colours it takes. Copied into the button when the entry is assigned. |
| var | `Options`Style | `string[]` | Free-form strings carried along with the entry for the list owner to interpret. Nothing in the entry or the standard button reads them. |
| event | `ButtonPressed` | `()` | Broadcasts On Button Pressed with this entry and the identifier from its content. Called by the button it was assigned to when that button is clicked in manual mode, so listeners hear about presses through the entry rather than the widget. |
| event | `SetSelected` | `(Selected: bool)` | Records the selected state of this entry and broadcasts On Selection Changed, but only when the value actually differs from the one held. The button it was assigned to listens for that broadcast and restyles itself, so call this rather than writing the state directly. |

**BP_WidgetEventListener_Mouse**0 members

extends `Object`

Small relay object carrying a single mouse-button-pressed delegate. A widget component creates one on demand and hands it out, so a widget that needs to know a click landed anywhere in the interface can bind to the listener instead of to the component.

No editor-visible members; this asset configures defaults only.

### Settings

**BP_Value_Settings_Name_Theme**4 members

extends `BP_Value_Settings_Name`

Settings entry exposing the interface theme as a named choice. Its value is read straight from the game state's theme manager, and it re-broadcasts On Value Updated when the theme changes elsewhere so the settings row stays in step. Register it with your settings component to offer theme switching; the desktop gameplay page already lists it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Value_Name_GetValue`Value_Name | `(out SourceInfo: ST_SourceInfo, out Name: name)` | Implemented by a name value to report the name it holds and the source info of whoever last set it. The drag state answers with the section its handle is currently sitting in. |
| event | `Value_Name_Set`Value_Name | `(SourceInfo: ST_SourceInfo, Name: name)` | Implemented by a name value to take a new name from the pawn described by the source info. The drag state reads the name as the section to move to. |
| event | `Init` | `()` | Empty override; no start-up work is needed because the current theme is read from the theme manager each time the entry is asked for its value. |
| event | `OnThemeUpdated_Event` | `()` | Internal handler that re-broadcasts On Value Updated when the theme manager reports a change, so any settings widget showing this entry refreshes to the new theme name. |

### Theme

**BP_PDA_Theme**38 members

extends `PrimaryDataAsset`

Theme data asset: colour families and their intensity steps, fonts per typography level, corner sizes, outline widths and gradient strength, which together decide how every widget in the framework looks. It also writes those values into the dynamic materials elements draw with. Duplicate a supplied theme and edit that to restyle the interface, rather than editing widgets.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Font`Fonts | `Map<E_UI_Typography, SlateFontInfo>` | The font for each typography level in this theme. Get Font reads it, and a level with no entry comes back as an empty font that draws no glyphs at all, so every level the widgets use needs filling in. |
| var | `Corner Categories Sizes`Corners | `Map<E_UI_Corner_Category, float>` | The corner radius for each named corner category. Get Corner Sizes looks a definition's category up here, while a definition marked Custom carries its own four radii and never reaches this map. |
| var | `Outline Width`Outline | `Map<E_UI_Outline, float>` | The width for each outline category. A category missing from the map gives zero, which draws no outline at all. |
| var | `Gradient`Gradient | `float` | How far a colour's brightness is shifted to make its gradient partner. Every gradient colour the theme resolves is offset by this one number, and it is negative by default, so partners come out darker. |
| var | `Display Name`Name | `text` | Name this theme is listed under wherever themes are offered for choosing. Nothing about how the theme draws depends on it. |
| var | `Color Primary`Colors | `Map<E_UI_Color_Intensity, LinearColor>` | The primary palette, one colour per intensity. An intensity with no entry resolves to fully transparent black, so a gap shows as nothing rather than as the wrong colour. |
| var | `Color Secondary`Colors | `Map<E_UI_Color_Intensity, LinearColor>` | The secondary palette, one colour per intensity, for elements that have to sit beside a primary one without competing with it. |
| var | `Color Action`Colors | `Map<E_UI_Color_Intensity, LinearColor>` | The action palette, one colour per intensity. This is the accent interactive and selected elements are drawn in, so it is the colour a reader learns to look for. |
| var | `Color Text`Colors | `Map<E_UI_Color_Intensity, LinearColor>` | The text palette, one colour per intensity. Labels resolve through it rather than holding a colour of their own, which is what lets one theme swap repaint every piece of text at once. |
| var | `Color Background`Colors | `Map<E_UI_Color_Intensity, LinearColor>` | The background palette, one colour per intensity. Get Theme Style also reads the high intensity entry here, judging from its luminance whether the theme counts as dark. |
| var | `Color Transparent`Colors | `Map<E_UI_Color_Intensity, LinearColor>` | The transparent palette, one colour per intensity, for scrims and washes laid over other content. |
| var | `Auto Blend Threshold`Colors | `float` | Contrast ratio a foreground colour has to reach against its background before the automatic correction leaves it alone. Convert Foreground Color According to Background measures the pair and flips the foreground's brightness when they fall short. 4.5 by default, the ratio WCAG asks of normal text; raise it to correct more often, lower it to correct less. |
| fn | `getThemeStyle`Style | `(out DarkTheme: bool)` | Reports whether the theme counts as dark, judged from the luminance of its high intensity background colour. The threshold is 128 while linear colour luminance runs 0 to 1, so as written every theme answers yes. |
| fn | `SetMaterialValue_Blend`Material\|Blend | `(Material: MaterialInstanceDynamic, Value: float)` | Writes a blend alpha into the material's blend parameter. Does nothing when the material is invalid. |
| fn | `Set Material Value Translation`Material\|Image | `(Material: MaterialInstanceDynamic, Translation: ST_Image_Translation)` | Writes an image translation into the material, setting its zoom and its two offset parameters together. Does nothing when the material is invalid. |
| fn | `getColorGradientFromDefinition`Colors | `(ColorDefinition: ST_Color_Definition, out LinearColor: LinearColor)` | Resolves a colour definition and returns its gradient partner: the same hue, saturation and alpha with the theme's gradient offset added to the brightness. Gives a flat colour a matching second tone for the gradient materials. |
| fn | `SetMaterialValue_Gradient_Color`Material\|Gradient | `(Material: MaterialInstanceDynamic, ColorDefinition: ST_Color_Definition)` | Resolves a colour definition against the theme and writes it, unshifted, into the material's gradient colour parameter. Does nothing when the material is invalid. |
| fn | `SetMaterialValue_Gradient_Rotation`Material\|Gradient | `(Material: MaterialInstanceDynamic, Rotation: float)` | Writes the gradient angle in degrees into the material's rotation parameter. Does nothing when the material is invalid. |
| fn | `Set Material Value Texture`Material\|Image | `(Material: MaterialInstanceDynamic, Texture: Texture)` | Writes a texture into the material's texture parameter. Does nothing when the material is invalid. |
| fn | `SetMaterialValue_Sides`Material\|Sides | `(Material: MaterialInstanceDynamic, Sides: Vector4)` | Writes the four side flags into the material's side orientation parameter, which decides which edges are drawn. Does nothing when the material is invalid. |
| fn | `Set Material Value Corner Definition`Material\|Corners | `(Material: MaterialInstanceDynamic, CornerDefinition: ST_Corner_Definition)` | Resolves a corner definition into four radii and writes them into the material's corner sizes parameter. Does nothing when the material is invalid. |
| fn | `SetMaterialValue_Border`Material\|Border | `(Material: MaterialInstanceDynamic, Set: bool)` | Switches the material's border parameter on or off, writing one or zero. Does nothing when the material is invalid. |
| fn | `SetMaterialValue_BorderWidth`Material\|Border | `(Material: MaterialInstanceDynamic, OutlineCategory: E_UI_Outline)` | Looks the width of an outline category up in the theme and writes it into the material's border width parameter. Does nothing when the material is invalid. |
| fn | `SetMaterialValue_SecondColor_Gradient`Material\|Color | `(Material: MaterialInstanceDynamic, ColorDefinition: ST_Color_Definition)` | Resolves a colour definition, shifts its brightness by the theme's gradient offset and writes the result into the material's second colour gradient parameter. Does nothing when the material is invalid. |
| fn | `SetMaterialValue_SecondColor`Material\|Color | `(Material: MaterialInstanceDynamic, ColorDefinition: ST_Color_Definition)` | Resolves a colour definition against the theme and writes it into the material's second colour parameter, the one used for side and two-tone materials. Does nothing when the material is invalid. |
| fn | `SetMaterialValue_Color_Gradient`Material\|Color | `(Material: MaterialInstanceDynamic, ColorDefinition: ST_Color_Definition)` | Resolves a colour definition, shifts its brightness by the theme's gradient offset and writes the result into the material's colour gradient parameter. Does nothing when the material is invalid. |
| fn | `SetMaterialValue_Color`Material\|Color | `(Material: MaterialInstanceDynamic, ColorDefinition: ST_Color_Definition)` | Resolves a colour definition against the theme and writes it into the material's colour parameter. Does nothing when the material is invalid, so it is safe to call before the instance exists. |
| fn | `getOutlineWidth`Outline | `(Key: E_UI_Outline, out Width: float)` | Returns the outline width registered for a category. A category missing from the theme gives zero, which draws no outline. |
| fn | `Get Corner Sizes`Corners | `(CornerDefinition: ST_Corner_Definition, out CornerSizes: LinearColor)` | Resolves a corner definition into four corner radii packed into a colour, in the layout the rounded materials expect. Named categories are looked up in the theme and Custom takes the definition's own size; either way the result is scaled by the definition's multiplier. |
| fn | `getGradient`Gradient | `(out Gradient: float)` | Returns the theme's gradient offset, the amount added to a colour's brightness to make its gradient partner. Negative values darken the partner, which is the default. |
| fn | `getColorFromDefinition`Colors | `(ColorDefinition: ST_Color_Definition, out LinearColor: LinearColor)` | Resolves a colour definition into a linear colour by switching on its category and looking the intensity up in the matching palette. A definition marked Custom bypasses the theme entirely and returns the colour from its own asset. |
| fn | `getTransparentColor`Colors | `(Intensity: E_UI_Color_Intensity, out Color: LinearColor)` | Returns the transparent palette colour registered for an intensity, used for scrims and washes over other content. Falls back to fully transparent black when the theme has no entry at that intensity. |
| fn | `getFont`Font | `(Typography: E_UI_Typography, out Value: SlateFontInfo)` | Returns the font registered for a typography level. Gives back an empty font when the level is missing from the theme, which draws no glyphs at all, so every level a widget uses needs an entry. |
| fn | `getBackgroundColor`Colors | `(Intensity: E_UI_Color_Intensity, out Color: LinearColor)` | Returns the background palette colour registered for an intensity. Falls back to fully transparent black when the theme has no entry at that intensity. |
| fn | `getTextColor`Colors | `(Intens: E_UI_Color_Intensity, out Color: LinearColor)` | Returns the text palette colour registered for an intensity. Falls back to fully transparent black when the theme has no entry at that intensity. |
| fn | `getActiveColor`Colors | `(Intensity: E_UI_Color_Intensity, out Color: LinearColor)` | Returns the action palette colour registered for an intensity, the accent used for interactive and selected elements. Falls back to fully transparent black when the theme has no entry at that intensity. |
| fn | `getSecondaryColor`Colors | `(Intensity: E_UI_Color_Intensity, out Color: LinearColor)` | Returns the secondary palette colour registered for an intensity. Falls back to fully transparent black when the theme has no entry at that intensity. |
| fn | `getPrimaryColor`Colors | `(Intensity: E_UI_Color_Intensity, out Color: LinearColor)` | Returns the primary palette colour registered for an intensity. Falls back to fully transparent black when the theme has no entry at that intensity, so a missing entry shows as nothing rather than as a wrong colour. |

### Utils/HUD/Widgets

**WBP_HUD**9 members

extends `WBP_Base`

Root widget of a pawn's head-up display, holding one frame per open widget. Provides add, remove and toggle by class or object, finds the outermost framework widget when something nested asks to close, and works out which screen control mode the desktop pawn should be in from the frames currently asking for the mouse. Driven by the head-up display ability rather than created directly.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `isWidgetOpen`Widgets | `(Widget: WBP_Base, out Open: bool)` | Returns whether that exact widget instance is currently registered with the HUD. Instances are compared, not classes, so pass the object you were handed when the widget was added. |
| fn | `RecursiveSearchForParentWidget`Search | `(Widget: WBP_Base, out MostOuterParentWidget: WBP_Base)` | Climbs the parent chain from the given widget and returns the first one registered as a HUD entry, which is how a deeply nested widget is traced back to the entry that owns it. Returns nothing for an invalid widget or one outside the HUD. |
| fn | `UpdateDesiredScreenControlMode`Screen Control | `()` | Works out which screen control mode the open HUD widgets need, taking the strongest of their requests and falling back to Original Screen Control Mode, then pushes it to the player pawn. Runs on desktop only, so in VR the mode is left untouched. |
| fn | `ToggleWidget`Widgets | `(WidgetClass: class<WBP_Base>, Frame: ST_HUD_FrameInfo, out Widget: WBP_Base)` | Removes the widget of the given class when it is already open, and otherwise creates it in the given frame. The returned widget is only filled on the branch that opens one, so an empty return means the widget was just closed. |
| fn | `RemoveWidgetByClass`Widgets | `(Widget: class<WBP_Base>)` | Looks up the open widget of exactly the given class and removes it with its frame, doing nothing when none is open. |
| fn | `RemoveWidgetObject`Widgets | `(Widget: WBP_Base)` | Removes the HUD entry the given widget belongs to, walking up the parent chain first so that a nested child removes the entry that owns it. Drops any screen control request the entry was holding, refreshes the desired mode and closes the frame through its hide animation. |
| fn | `AddWidgetObjectToFrame`Widgets | `(InWidget: WBP_Base, Frame: ST_HUD_FrameInfo)` | Wraps an already created widget in a HUD frame and adds that frame to the HUD canvas, stretched over the whole screen and sorted by the frame's Z layer. The frame is what carries the fade animation and the show and hide sounds. |
| fn | `addWidgetClassToFrame`Widgets | `(HUDWidget: class<WBP_Base>, Frame: ST_HUD_FrameInfo, out Widget: WBP_Base)` | Creates a widget of the given class for the owning player, adds it to the HUD in the given frame and returns the new instance. Nothing checks for one already being open, so use Toggle Widget or the HUD pawn ability where a single instance matters. |
| fn | `getWidgetWithClass`Widgets | `(WidgetClass: class<WBP_Base>, out Widget: WBP_Base)` | Returns the open HUD widget of exactly the given class, or nothing when none is open. Matching is on the exact class, so a subclass of what you pass is not found. |

**WBP_HUD_Frame**4 members

extends `UserWidget` · implements `BPI_WidgetElement`

Wrapper the head-up display puts around each widget it shows: a dimming background, a canvas placed at the frame's anchors and z-layer, and a show animation played forward on open and reversed on close before the widget is cleanly removed. Created for you when a widget is added to the display, with its look and sound taken from the frame info passed in.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Frame`Frame | `ST_HUD_FrameInfo` | Placement and sound settings the HUD was given for this entry, supplying the Z layer the frame is sorted at and the sound played as it hides. Filled in as the frame is created and not meant to change afterwards. |
| var | `Widget`Frame | `WBP_Base` | Content widget this frame wraps, handed over when the HUD creates the frame. It is reported as the frame's custom child so the widget system initialises and themes it, and it is cleanly removed when the frame closes. |
| event | `SequenceEvent` | `()` | Called from the fade animation's event track as it plays. Left empty on the stock frame; override it in your own frame to drive extra visuals from Show Animation Progress. |
| event | `Close` | `()` | Plays the hide sound and runs the show animation backwards, then cleanly removes the wrapped widget and takes the frame off the HUD. Guarded so that a second call while it is closing does nothing; the HUD calls it for you when a widget is removed. |

### Utils/Keyboard/Blueprints

**BP_KeyboardLocation**1 members

extends `PrimaryDataAsset`

Base data asset deciding where a virtual keyboard appears when a text field asks for one, and broadcasting when that keyboard closes. Point a text field at an instance of one of the supplied subclasses, or subclass it yourself and fill in Create Keyboard, which is empty here.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `CreateKeyboard` | `(Pawn: Pawn, KeyboardClass: class<WBP_Keyboard>, ExtensionClass: class<WBP_Keyboard_Extension>, KeyBoardSizeMultiplier: float, CloseOnEnter: bool, TextBoxWidget: Widget, InputWidget: WBP_TextField, WidgetInteractionComponent: WidgetInteractionComponent, out Keyboard: WBP_Keyboard)` | Creates the virtual keyboard for a text field and returns it. Empty on this base asset, which fixes only the contract and the Keyboard Closed delegate; pick one of the supplied locations, or override this, to decide where the keyboard appears. |

**BP_KeyboardLocation_Overlay**2 members

extends `BP_KeyboardLocation`

Keyboard location that opens the keyboard as an overlay hanging below the text field, initialises it with the field it is typing into and makes the overlay non-focusable so the field keeps focus. Broadcasts Keyboard Closed when the overlay is dismissed. Choose it for fields on a world-space interface with room beneath them.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `OnOverlayClosed` | `(Overlay: BP_Overlay)` | Internal handler bound to the spawned overlay that broadcasts Keyboard Closed once the overlay actor has finished closing, which is what returns the text field to its unselected state. |
| fn | `CreateKeyboard` | `(Pawn: Pawn, KeyboardClass: class<WBP_Keyboard>, ExtensionClass: class<WBP_Keyboard_Extension>, KeyBoardSizeMultiplier: float, CloseOnEnter: bool, TextBoxWidget: Widget, InputWidget: WBP_TextField, WidgetInteractionComponent: WidgetInteractionComponent, out Keyboard: WBP_Keyboard)` | Creates the virtual keyboard for a text field and returns it. Empty on this base asset, which fixes only the contract and the Keyboard Closed delegate; pick one of the supplied locations, or override this, to decide where the keyboard appears. |

### Utils/Keyboard/Interfaces

**BPI_KeyboardInput**3 members

extends `Interface`

Contract letting a virtual keyboard deliver what was pressed, whether that is a character, a key or a named command such as Upper or Close Keyboard, to whatever it is typing into. The keyboard calls it on the field it was opened for; implement it on an input widget of your own that is not built on the framework's text field.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `KeyboardInput_Command`Keyboard | `(Command: name)` | Implemented by the widget a virtual keyboard is typing into, and called with the command name of a button that changes case or layout, or closes the keyboard, instead of typing. The keyboard acts on those commands itself; implement this only to follow along. |
| fn | `KeyboardInput_Character`Keyboard | `(Character: string)` | Implemented by the widget a virtual keyboard is typing into, and called with the characters a pressed button produces before they are sent on to the widget interaction component. Implement it where the typed text has to go somewhere other than the focused text box. |
| fn | `KeyboardInput_Key`Keyboard | `(Key: Key)` | Implemented by the widget a virtual keyboard is typing into, and called with the key a pressed button stands for, such as Enter or Backspace. The keyboard also sends the press to the widget interaction component, so implement this only where you need to act on those keys yourself. |

### Utils/Keyboard/Widgets

**WBP_Keyboard_Default**3 members

extends `WBP_Keyboard`

Full alphabetic layout for the virtual keyboard, four rows of keys above an extension slot, with every key carrying its lower case, upper case, numeric and symbol faces. Name it as the keyboard class on a text field, or copy it as the starting point for a layout of your own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getExtensionSlot`Get Elements | `(out OverlaySlot: Overlay)` | Returns the overlay the extension widget is added to. Empty on this parent; each layout overrides it with the slot above its own key rows, and a layout that does not override it simply gets no extension. |
| fn | `getKeyboardButtons`Get Elements | `(out Buttons: WBP_Button_Normal_Keyboard[])` | Returns the keys that have to follow a change of case or layout. Empty on this parent, so a layout that does not override it will never update its keys; the default layout walks the children of its four letter rows and the numpad returns a fixed list. |
| event | `SetCapsLock`Case | `(CapsLock: bool)` | Records whether caps lock is latched, and nothing more. Undo Shift reads it to decide whether to fall back to lower case after a key, so this is the flag that keeps upper case on. |

**WBP_Keyboard_Numpad**1 members

extends `WBP_Keyboard`

Numeric layout for the virtual keyboard: digits, plus and enter in a narrower frame, fixed to the lower case character set so it never switches layers. Name it as the keyboard class on a text field that only takes numbers.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getKeyboardButtons`Get Elements | `(out Buttons: WBP_Button_Normal_Keyboard[])` | Returns the keys that have to follow a change of case or layout. Empty on this parent, so a layout that does not override it will never update its keys; the default layout walks the children of its four letter rows and the numpad returns a fixed list. |

### Utils/Keyboard/Widgets/Parents

**WBP_Button_Normal_Keyboard**12 members

extends `WBP_Button_Normal`

Single key of a virtual keyboard. Its text, icon, key binding and command are held in maps addressed by keyboard case, so one key serves every layer, and a press hands the entry for the current case to the keyboard as a command, a key or a string. Add it to a keyboard layout and fill in the maps; it also swaps the standard button sounds for the keyboard set.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Key Text`Content | `Map<E_Keyboard_Case, string>` | The characters this key sends, one entry per case. On Clicked checks it last, after the command and the key maps, and sends what it finds as a string rather than as a key press. |
| var | `Key Function`Key | `Map<E_Keyboard_Case, Key>` | The engine key this key presses, one entry per case. Checked after the command map and before the text map, so this is how backspace, tab or enter are sent rather than characters. |
| var | `Key Icon`Content | `Map<E_Keyboard_Case, Texture2D>` | The icon shown in place of a letter, one entry per case. Get Icon returns the entry for the current case or nothing at all, which is how shift and backspace show a glyph while the letter keys show text. |
| var | `Keyboard Command`Key | `Map<E_Keyboard_Case, name>` | The keyboard command this key runs, one entry per case, and the first of the three maps On Clicked checks. The names the keyboard answers to are Upper, Lower, Numeric, Special and Close Keyboard; anything else reaches the input widget and goes no further. |
| fn | `UpdateCase`Content | `(Case: E_Keyboard_Case)` | Stores the case this key should be showing and re-runs its button content, which is what swaps the letter, the icon and the key over. Called on every key by the keyboard's Set Keyboard Case rather than directly. |
| fn | `OnClicked_Event` | `(Button: WBP_Button)` | Runs the key. It looks the current case up in the command map first, then the key map, then the text map, and sends the first thing it finds to the parent keyboard as a command, a key press or a string. A case with no entry in any of the three does nothing, which is how a blank key stays blank. |
| fn | `getIcon`Content | `(out Value: Texture2D[])` | Returns the icon for the current case as a one-entry array, or an empty array when this case has no icon. The array is what lets the button treat a key showing a glyph and a key showing a letter the same way. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| event | `UpdateButtonContent`Content | `(ButtonContent: ST_Button_Content)` | Replaces the button's content and refreshes the label, the icon and the content widget from it. The chain runs through the text element first and the image element second, so a design missing either updates nothing beyond that point. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

**WBP_Keyboard**11 members

extends `WBP_Base`

Base class for the virtual keyboard. Tracks the current case and caps lock, forwards characters, keys and commands both to the text field it was opened for and to the widget interaction component driving the interface, and drops shift again after each keystroke. Subclass it to lay out a keyboard, overriding the button and extension slot getters; it has no keys of its own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Keyboard Case`State | `E_Keyboard_Case` | Which case or layer the keyboard is showing: lower, upper, numeric or special. Set Keyboard Case owns it, and writing here directly leaves every key still drawing the old layer, because it is the setter that pushes the change out to the keys. |
| fn | `SetKeyboardCase`Case | `(KeyboardCase: E_Keyboard_Case, Force: bool)` | Switches the keyboard to a case or layer. Unless Force is set, a case that is already current is ignored; otherwise it stores the new case, plays the upper or lower cue, and calls Update Case on every key Get Keyboard Buttons returns, which is what redraws the letters and icons. |
| fn | `SetCapsLock`Case | `(CapsLock: bool)` | Records whether caps lock is latched, and nothing more. Undo Shift reads it to decide whether to fall back to lower case after a key, so this is the flag that keeps upper case on. |
| fn | `ExecuteKeyboardCommand`Input | `(Command: name)` | Runs one of the keyboard's named commands. The command is reported to the input widget first, then acted on: Upper switches to upper case and clears caps lock, Lower latches caps lock when it is pressed while already upper and otherwise returns to lower case, Numeric and Special switch to those layers, and Close Keyboard closes the widget. A name the keyboard does not know reaches the input widget and goes no further. |
| fn | `ExecuteKeyboardKey`Input | `(Key: Key)` | Sends a key press: it reports the key to the input widget, presses it through the widget interaction component, closes the keyboard if the key was enter and that was asked for, and then undoes a shift so a single capital drops back to lower case. A remap for Android sits in the graph but is bypassed by a hard-wired false, so the key goes through unchanged. |
| fn | `ExecuteKeyboardString`Input | `(Characters: string)` | Sends one or more characters as text rather than as a key press, reporting them to the input widget, sending them through the widget interaction component and then undoing a shift. This is the path an ordinary letter takes. |
| fn | `UndoShift`Case | `()` | Drops upper case back to lower once a key has been sent, unless caps lock is latched. The numeric and special layers are left alone, so shift is the only case that behaves as a one-shot. |
| fn | `getExtensionSlot`Get Elements | `(out OverlaySlot: Overlay)` | Returns the overlay the extension widget is added to. Empty on this parent; each layout overrides it with the slot above its own key rows, and a layout that does not override it simply gets no extension. |
| fn | `getKeyboardButtons`Get Elements | `(out Buttons: WBP_Button_Normal_Keyboard[])` | Returns the keys that have to follow a change of case or layout. Empty on this parent, so a layout that does not override it will never update its keys; the default layout walks the children of its four letter rows and the numpad returns a fixed list. |
| event | `InitializeKeyboard` | `(CloseOnEnter: bool, TextBoxWidget: Widget, InputWidget: WBP_TextField, KeyboardExtension: class<WBP_Keyboard_Extension>, WidgetInteractionComponent: WidgetInteractionComponent)` | Sets a keyboard up for the field it serves. It stores whether enter should close the keyboard, the text box and input widget it types into and the widget interaction component it presses keys through, then creates the extension widget, when one was asked for and the layout offers an extension slot, and adds it above the key rows with thirty units of padding beneath. Called by whatever opens the keyboard; the keys do nothing useful until it has run. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

**WBP_Keyboard_Extension**2 members

extends `WBP_Base`

Base for a strip of extra content shown above the keyboard, such as suggestions or controls belonging to one field. It is created into the keyboard's extension slot with the text box and text field already set on it. Subclass it and name the subclass as the extension class when the keyboard is created.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Text Box Widget` | `Widget` | The text box the keyboard is serving, handed down as the keyboard creates this extension so the extension can read or act on the same field. |
| var | `Input Widget` | `WBP_TextField` | The framework text field the keyboard types into, handed down as the keyboard creates this extension. It is the same field the keys report to, so an extension can send input through the normal path rather than inventing one. |

### Utils/Overlay/Blueprints

**BP_Overlay**8 members

extends `Actor`

Actor the framework spawns to float a widget in world space in front of whatever opened it, used for pop-ups, dropdowns, confirmations and keyboards. Carries its own widget component, animates out from the source on open, plays the overlay sounds and destroys itself once the closing animation ends. Reached through Spawn Overlay on a widget rather than placed.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Content`Construction | `class<Object>` | Widget class displayed by the overlay, created on the overlay's own widget component in Begin Play. A class that is not a widget leaves the overlay empty and invisible; a pop-up frame is the usual outermost widget. |
| var | `Desired Pivot`Construction | `Vector2D` | Point of the widget, both values from 0 to 1, that is placed on the overlay's spawn location. Half and half centres the widget on it; half and zero hangs it below, which is how the keyboard sits under a text field. |
| var | `Source`Construction | `Object` | Object that asked for the overlay, normally the widget that called Spawn Overlay. The widget component compares it with the next request, so asking again from the same source closes the overlay rather than replacing it. |
| var | `Widget Component`Construction | `BPC_Widget` | Owning widget component the overlay was spawned from. Its sound settings, custom theme, geometry mode and cylinder arc angle are copied onto the overlay's own widget component in Begin Play, and its attenuation is used for the open and close sounds. |
| fn | `getWidgetObject`Default | `(out Widget: WBP_Base)` | Returns the widget instance the overlay is displaying, or nothing while it has yet to be created. |
| event | `OpenOverlay` | `()` | Runs the appearing animation, sliding the handle 50 centimetres out from the widget component and playing the spawn timeline that scales the overlay up from nothing. Called from Begin Play; the spawn sound follows after three tenths of a second. |
| event | `CloseOverlay` | `()` | Plays the despawn sound, slides the handle back onto the widget component and runs the spawn timeline in reverse, which broadcasts On Overlay Closed and destroys the actor once it reaches the end. Called by the widget component when the overlay is dismissed. |
| event | `MoveComponentToLocation` | `(Target Relative Location X: float)` | Slides the handle carrying the widget to the given distance in centimetres in front of the widget component, over half a second. Used to lift the overlay off the surface as it opens and to lay it back as it closes. |

### Utils/Overlay/Library

**FL_UI_Overlays**4 members

extends `BlueprintFunctionLibrary`

Function library of ready-made overlays: a general message with icon, title, body and a row of buttons, a confirmation, a notification with a single acknowledge button, and a loading overlay. Call one from any framework widget and it spawns centred over that widget and hands back the overlay widget for you to bind to.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Overlay_SpawnOverlay_Loading`Overlays | `(Widget: WBP_Base, Title: text, Content: text, __WorldContext: Object, out OverlayWidget: WBP_Overlay_Loading)` | Opens a loading overlay centred on the given widget, showing a spinner above the title and body text and carrying no buttons. Keep the returned overlay and call Close Widget on it when the work is done, as nothing dismisses it on its own. |
| fn | `Overlay_SpawnOverlay_Notification`Overlays | `(Widget: WBP_Base, Title: text, Icon: Texture2D, Content: text, ConfirmButtonContent: ST_Button_Content, __WorldContext: Object, out OverlayWidget: WBP_Overlay_Notification)` | Opens a single-button notification overlay centred on the given widget, with icon, title and body text. Pressing the button broadcasts On Button Clicked on the returned overlay and closes it. |
| fn | `Overlay_SpawnOverlay_Confirmation`Overlays | `(Widget: WBP_Base, Title: text, Icon: Texture2D, Content: text, DenyButtonContent: ST_Button_Content, DenyButtonType: E_UI_Hierarchy, ConfirmButtonContent: ST_Button_Content, ConfirmButtonType: E_UI_Hierarchy, __WorldContext: Object, out OverlayWidget: WBP_Overlay_Confirm)` | Opens a two-button confirmation overlay centred on the given widget, with the deny and confirm labels and hierarchies you supply. Bind to the returned overlay's On Button Clicked to hear the answer. |
| fn | `Overlay_SpawnOverlay_Default`Overlays | `(Widget: WBP_Base, Border_Color: PDA_Color, Icon_Color: PDA_Color, Icon: Texture2D, Title_Color: PDA_Color, Title_Text: text, BodyText: text, Button_Contents: ST_Button_Content[], Button_Presets: E_UI_Hierarchy[], __WorldContext: Object, out OverlayWidget: WBP_Overlay_Default)` | Opens the general-purpose overlay centred on the given widget and fills it with icon, title, body text and a row of buttons. Border, icon and title colours are taken from colour assets and may be left empty to keep the theme's own; the presets array is matched to the button contents by index. |

### Utils/Overlay/Widgets

**WBP_Overlay_Confirm**1 members

extends `WBP_Base`

Confirmation overlay with an icon, title, body and two buttons whose content and hierarchy are set when it is populated. Spawn it through the overlay library. The deny button broadcasts On Button Clicked and closes the overlay, while the confirm button carries no behaviour of its own, so bind the action you want to it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| event | `PopulateOverlay` | `(Title: text, Icon: Texture2D, Content: text, DenyButtonContent: ST_Button_Content, DenyButtonType: E_UI_Hierarchy, ConfirmButtonContent: ST_Button_Content, ConfirmButtonType: E_UI_Hierarchy)` | Fills the confirmation overlay with title, icon and body text, and applies the supplied content and hierarchy preset to the deny and the confirm button. Called by Spawn Overlay Confirmation as soon as the overlay has been created. |

**WBP_Overlay_Default**1 members

extends `WBP_Base`

General message overlay: coloured icon, title and body, with a horizontal button group built from an array of button contents and presets, and body text centred when short and left-aligned when long. Buttons report back through On Button Clicked, identified by their index in that array. Spawn it through the overlay library.

| Kind | Name | Signature | Description |
|---|---|---|---|
| event | `InitOverlay` | `(Border_Color: PDA_Color, Icon_Color: PDA_Color, Icon: Texture2D, Title_Color: PDA_Color, Title_Text: text, Body_Text: text, ButtonContents: ST_Button_Content[], ButtonPresets: E_UI_Hierarchy[])` | Fills the general overlay in one pass: colours and sets the icon, colours and sets the title, sets the body text and centres it while it is under fifty characters, builds the button row from the contents array and tints the scaffold outline. Button presets are applied half a second later, once the group has built its buttons. |

**WBP_Overlay_Loading**1 members

extends `WBP_Base`

Loading overlay: a circular throbber with a title and optional body text, and no buttons at all. Spawn it through the overlay library to hold the interface while something finishes, and close it yourself when the work is done, since nothing in it will.

| Kind | Name | Signature | Description |
|---|---|---|---|
| event | `InitOverlay` | `(Title: text, Content: text)` | Sets the loading overlay's title and body text, centring the body while it is shorter than fifty characters. Called by Spawn Overlay Loading right after the overlay is created; the spinner runs on its own. |

**WBP_Overlay_Notification**1 members

extends `WBP_Base`

Notification overlay with an icon, title, body and one acknowledge button that broadcasts On Button Clicked and closes the overlay. Spawn it through the overlay library when the player only has to read something and dismiss it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| event | `InitOverlay` | `(Title: text, Icon: Texture2D, Content: text, ConfirmButtonContent: ST_Button_Content)` | Fills the notification overlay with title, icon, body text and the confirm button's content, centring the body while it is shorter than fifty characters. Called by Spawn Overlay Notification right after the overlay is created. |

### Utils/ReplicatedUI/Components

**BPC_ReplicatedUI**5 members

extends `ActorComponent`

Pawn component that mirrors a player's world-space interfaces to the other clients as ghost copies. Add it to the pawn on both sides: where the pawn is locally controlled it gathers the transform, draw size, pivot and visibility of the widget components registered with it and replicates them, and elsewhere it spawns a ghost widget for each entry and fades out the ones that stop arriving.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `EliminateOldGhostWidgets` | `()` | Retires every spawned stand-in whose identity no longer appears in the replicated states. Each one is flagged to destroy itself at the end of its fade, told to fade to zero opacity, and dropped from the map of live stand-ins. |
| fn | `GatherGhostWidgetStates` | `(out ManagedWidgets: BPC_Widget[], out GhostWidgets: ST_ReplicatedUI[])` | Returns one replication entry per managed widget component, carrying its display name as identity together with draw size, world transform, cylinder arc angle, pivot and visibility. Components that have gone invalid, or whose owner has, are dropped from the managed list as the array is built. |
| event | `AddFakeUI` | `(WidgetComp: BPC_Widget)` | Adds a widget component to the list whose pose and size are replicated to the other clients, ignoring duplicates. Reached through Replicated UI Set Replication rather than called directly. |
| event | `RemoveFakeUI` | `(WidgetComp: BPC_Widget)` | Removes a widget component from the replicated list, so its stand-in fades out on the other clients with the next state update. Reached through Replicated UI Set Replication rather than called directly. |
| event | `Server_SetGhostWidgets` | `(GhostWidgetStates: ST_ReplicatedUI[])` | Hands the states gathered on the owning client to the server, which stores them for replication onwards. The replicated array skips the owner, since that player is already drawing the real widgets. |

**BPC_Widget_ReplicatedUI**4 members

extends `BPC_Widget`

Ghost stand-in for another player's interface: a widget component with collision switched off, its own material and a fixed placeholder widget, whose opacity is interpolated towards a target and which destroys itself once it reaches zero. Created and driven by the replicated UI component, so there is no reason to add it by hand.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Material`Material | `MaterialInterface` | Surface material applied to the stand-in when it begins play, exposed on spawn so the replicated UI component can pass through the material it was configured with. It is applied unconditionally, so an empty entry leaves the stand-in with no material of its own. |
| event | `UpdateGhostOpacity` | `(DesiredOpacity: float)` | Starts fading the stand-in towards the given opacity, 0 to 1, by storing the target and running the opacity tick on a repeating timer. Fading to zero while Destroy When Zero Opacity is set destroys the component once the fade lands. |
| event | `UpdateGhostWidgetOpacity_Tick` | `()` | Internal timer step that interpolates the custom opacity towards the stored target and writes it to the component. On reaching the target it pauses the timer and then either destroys the component or hides it in game, depending on Destroy When Zero Opacity. |
| event | `IsInRange` | `(Set: bool)` | Hook for reporting that the stand-in has come into or gone out of range of the local player. Carries no implementation and nothing in the framework calls it; stand-in opacity is driven through Update Ghost Opacity instead. |

### Utils/ReplicatedUI/Libaries

**BFL_ReplicatedUI**1 members

extends `BlueprintFunctionLibrary`

Function library holding the one call that registers or unregisters a widget component with a pawn's replicated UI component, which is what starts or stops that interface being mirrored to other players. It does nothing when the pawn has no such component, which is how the feature stays opt-in.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `ReplicatedUI_SetReplication` | `(Pawn: Pawn, WidgetComponent: BPC_Widget, Set: bool, __WorldContext: Object)` | Registers or unregisters a widget component with the pawn's replicated UI component, so that the other players see a blank stand-in panel where that widget sits. Silently does nothing when the pawn, the widget component or the replicated UI component is missing, so it is safe to call on pawns that do not carry one. |

### Utils/ReplicatedUI/Widgets

**WBP_ReplicatedUI**0 members

extends `WBP_Base`

Placeholder widget the ghost copies of other players' interfaces show, a single rounded border in a theme colour standing in for content that is never replicated. Change it on the ghost widget component if remote interfaces should read as something other than a blank panel.

No editor-visible members; this asset configures defaults only.

### Widgets

**WBP_Base**34 members

extends `AFSExtendedUserWidget` · implements `BPI_WidgetElement`

Root class for every widget in the framework. Carries the theme, the widget component the widget belongs to, the parent and replication chain and the tooltip settings, and provides the recursive walk that initiates, themes and cleanly removes nested elements, plus the overlay, sound and reference lookups widgets rely on. Inherit from this rather than User Widget; not something to place directly.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Parent`Requirement | `WBP_Base` | Widget that owns this one inside the tree. The theme, desktop flag, widget component and the front of the replication identifier are all inherited from it, and setting it on spawn is what makes the widget initiate itself as a sub-widget on construction. Leave it empty for a widget the widget component hosts directly. |
| var | `Widget Component`Requirement | `ActorComponent` | Host component this widget talks to for overlays, sounds, closing, reference lookups and replication. Copied from the parent during initiation, or handed over by the component itself for a root widget; while it is empty every one of those calls quietly does nothing. |
| var | `Theme`Theme | `BP_PDA_Theme` | Colour, font and metric set the widget and its tree are drawn with. Setting it here only affects the design-time preview, since a root widget is given the widget component's theme at start-up and a sub-widget copies its parent's. |
| var | `Should Replicate`Replication | `bool` | Whether the widget takes part in replication. With it on the widget registers under its replication identifier with the widget component and Replicate Value forwards its changes; with it off nothing is sent and the widget instead marks itself initiated, which is the flag that guards against a second initiation pass. |
| var | `Replication Index`Requirement | `name` | Number distinguishing this widget from siblings that share a replication suffix, appended to the identifier built from the parent's. The initiation pass counts matching elements and hands each one its index, so set it yourself only for a widget you create by hand; None appends nothing. |
| var | `Widget Tag`Tag | `name` | Tag the widget answers to when a tree is searched by tag. Left as None it matches nothing, and a search never steps inside a sub-widget's own tree unless that widget reports named slots, so the tag has to sit somewhere the searching widget can reach. |
| var | `Tool Tip Class`Tool Tip | `class<WBP_Tooltip>` | Tooltip widget class built the first time the tooltip anchor asks for content, then kept and reused for every later hover. Leave empty and no tooltip is ever created, so the anchor opens on nothing. |
| var | `Tool Tip Text`Tool Tip | `text` | Text handed to the tooltip widget as it is created. It is read once, at creation, so changing it after the tooltip has been built leaves the old text on screen until you update the tooltip itself. |
| var | `Tool Tip Placement`Tool Tip | `EMenuPlacement` | Placement passed to the tooltip widget when it is created, centred below by default. It is stored on the tooltip rather than applied to the anchor, so the menu anchor in the designer keeps whatever placement was set on it there. |
| fn | `setWidgetSwitcherVisibilityOfAllChildren`Switcher | `(Widget: Widget, Switcher: AFSwitcher, Set: bool)` | Tells every element beneath the given widget that a switcher has shown or hidden the branch they sit in. Switchers call it on their parent widget for each of their children as a transition begins, with the flag set only for the child being switched to. |
| fn | `CleanRemoveWidget`Close | `()` | Takes this widget and everything beneath it out of the tree, working through the collected elements in reverse so each one drops its replication registration before it is removed. Use it in place of Remove From Parent, which would leave stale registrations behind in the widget component. |
| fn | `CloseWidget`Close | `()` | Asks the widget component to close this widget. The component broadcasts On Close Widget Requested rather than tearing anything down itself, so whatever spawned the widget decides what closing means. |
| fn | `PlayWidgetSound`Sound | `(SoundCue: SoundBase)` | Plays a sound through the widget component at the centre point of this widget, so it comes from the right spot on the widget surface rather than from the actor origin. Nothing is heard while the widget component is unset. |
| fn | `InitializeRootWidget`Initialization | `(WidgetComponent: ActorComponent, Theme: BP_PDA_Theme, Desktop: bool)` | Starts a widget hosted directly by a widget component, storing the component, theme and desktop flag before initiating, theming and post-initiating the entire tree beneath it. Called by the widget component once the widget has been built, and skipped when the widget already counts as initiated. |
| fn | `InitializeSubWidget`Initialization | `(Parent: WBP_Base, ReplicationIndex: name)` | Adopts the given parent's theme, desktop flag and widget component, stores the parent and replication index, then initiates, themes and post-initiates the whole tree beneath this widget. Runs from Construct when a parent was passed in on spawn, and does nothing without a valid parent. |
| fn | `SetNewTheme`Theme | `(Theme: BP_PDA_Theme, Desktop: bool)` | Applies a new theme and desktop flag to the widget and pushes them to every element beneath it. Called by the widget component when the theme in use changes; only the theme pass runs, so nothing is initiated, measured or removed. |
| fn | `RecursiveWidgetAccumulation`Recursive WIdget Search | `(Widget: Widget)` | Internal walk that collects every element of a widget's subtree into the shared collected widgets list, stepping into sub-widget trees, custom child widgets, named slot children and panel children. Whoever starts the walk iterates that list and clears it afterwards, so two walks must not overlap. |
| fn | `OnMouseButtonDown`Mouse | `(MyGeometry: Geometry, MouseEvent: PointerEvent) → EventReply` | The system calls this method to notify the widget that a mouse button was pressed within it. This event is bubbled. @param MyGeometry The Geometry of the widget receiving the event @param MouseEvent Information about the input event @return Whether the event was handled along with possible requests for the system to take action. |
| fn | `CreateTooltipWidget`Tool Tip | `() → UserWidget` | Builds the tooltip widget from the tooltip class on the first call, keeps it for later, then shows it and returns it. Bound to the menu anchor's content event on the widgets that carry a tooltip, so it runs as the anchor opens rather than being called by hand. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `RecursiveSearchForOuterWidget`Recursive WIdget Search | `(SearchWidget: WBP_Base, Class: class<WBP_Base>, out OuterWidget: WBP_Base)` | Walks up the parent chain from the widget you pass in until it reaches one of the given class, and returns nothing when the chain runs out first. The comparison is against the exact class, so a widget derived from it is stepped over rather than returned. |
| fn | `getParentWidget`Get Elements | `(out Widget: WBP_Base)` | Returns the widget already stored as this one's parent, without searching for it. Answers nothing until initiation has run or a parent was passed in on spawn. |
| fn | `getWidgetCoordinates`Coordinates | `(Anchor: Vector2D) → Vector2D` | Converts a point on this widget, given as an anchor from 0 to 1 with the centre at 0.5, into absolute screen coordinates. Reads the cached geometry, so it answers zero until the widget has been drawn at least once. |
| fn | `getWidgetByTag`Get Elements | `(Widget: Widget, Tag: name, out FoundWidget: Widget)` | Searches the widget you pass in and everything under it for the first element reporting the given tag. Returns nothing for a tag of None, and unlike the search by class it does not step inside a sub-widget's own tree, only into its named slots and panel children. |
| fn | `getWidgetByClass`Get Elements | `(Widget: Widget, WidgetClass: class<Widget>, out FoundWidget: Widget)` | Searches the widget you pass in and everything under it for the first widget of that class or a subclass of it. The walk descends into sub-widgets' own trees, their custom child widgets, named slots and panel children, so pass the root of the branch you want covered; nothing comes back when there is no match. |
| fn | `DespawnOverlay`Overlay | `()` | Closes the overlay currently open in front of the host, whichever widget opened it. Does nothing when none is open. |
| fn | `SpawnOverlay`Overlay | `(WidgetPivot: Vector2D, Widget: class<WBP_Base>, PopupPivot: Vector2D, Blocking: bool, SizeMultiplier: float, out OverlayWidget: WBP_Base)` | Opens an overlay of the given class in front of the host, anchored at a point on this widget expressed as a pivot from 0 to 1, and returns its root widget. Blocking suppresses interaction with everything underneath, and the size multiplier scales the overlay; asking again from the widget that already owns the open overlay closes it instead. |
| fn | `getReferenceObject`Get Elements | `(Key: name, out Reference: Object)` | Looks an actor up in the host's reference registry under a key and hands it back. Returns nothing when the key was never registered, which is how a widget reaches the actor it drives without holding a hard reference to it. |
| fn | `getOwningActor`Get Elements | `(out OwningActor: Actor)` | Returns the actor hosting the widget, taken from the owner of the widget component. Gives nothing while the widget component is unset, which is the case until the widget has been initiated. |
| event | `ReplicateValue` | `(Replication Identifier: name, Replication Content: string[])` | Sends a named value and its content strings out to the other clients through the widget component. Does nothing while Should Replicate is off; the input widgets call it themselves after a change the other players need to see. |
| event | `OnMouseEnter`Mouse | `(MyGeometry: Geometry, MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has entered it. This event is NOT bubbled. @param MyGeometry The Geometry of the widget receiving the event @param MouseEvent Information about the input event |
| event | `OnMouseLeave`Mouse | `(MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has left it. This event is NOT bubbled. @param MouseEvent Information about the input event |
| event | `MouseButtonPressed` | `()` | Called by On Mouse Button Down when the left button goes down anywhere on the widget. Empty here and meant to be overridden, as the drop-down and the colour picker do to toggle their anchor menu open. |
| event | `WidgetSwitcherVisibilityChanged` | `(Visible: bool)` | Called with the widget's new visibility whenever the switchers above it change what they show, and directly by a switcher as it gives this widget focus. Stores the flag for anyone who asks; override it to start or stop work that only makes sense while the widget is on screen. |

### Widgets/Basic/Borders

**AFBorder**3 members

extends `AFSExtendedBorder` · implements `BPI_WidgetElement`

Themed surface at the root of the border family: a flat fill drawn with a material the theme builds, coloured from a colour definition rather than a literal value and rebuilt whenever the theme changes. Use it in a widget's hierarchy in place of a plain Border, or subclass it when a variant needs a material of its own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Color`Color | `ST_Color_Definition` | Theme colour definition the border is filled with, resolved against the palette when the material is built and again on every Update Colour. Set the category to Custom to take the colour from a colour asset instead of the theme. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the flat border material painted with the current colour definition. The desktop flag is ignored at this level and no corner rounding is applied; child borders override this to produce rounded, gradient, outline or hover materials. |
| event | `UpdateColor` | `(Color: ST_Color_Definition)` | Recolours the border at runtime, storing the definition and resolving it against the theme into the live material. The stored value changes either way, but nothing is repainted until a theme has been applied. |

**AFBorder_Custom**6 members

extends `AFSExtendedBorder` · implements `BPI_WidgetElement`

Themed surface that draws a material you supply instead of one of the framework's. Give it a normal and a desktop material and it keeps their corner and colour parameters fed from the theme, re-applying them on every theme change. Reach for it when a panel needs artwork of its own; the colour picker and the custom-material slider are the shipped examples.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Corners`Corner | `ST_Corner_Definition` | Corner rounding written into whichever material you supply, taken from a theme corner category or from a custom size and scaled by the definition's multiplier. A material without a corner sizes parameter ignores it. |
| var | `Material Normal`Material | `MaterialInterface` | Material instanced for the border while the theme pass reports world space rather than desktop. Leave empty and no dynamic instance can be made, so the border draws nothing. |
| var | `Material Desktop`Material | `MaterialInterface` | Material instanced instead when the theme pass reports desktop mode, that is when the widget is drawn on screen rather than in the world. Leave empty and the border draws nothing on desktop. |
| event | `UpdateCornerOverride` | `(Corners: ST_Corner_Definition)` | Replaces the corner definition and writes the resulting corner sizes straight into the live material rather than rebuilding it. Does nothing until a theme has been applied. |
| event | `UpdateMaterialSet` | `(Material_Normal: MaterialInterface, Material_Desktop: MaterialInterface)` | Swaps both materials at runtime and rebuilds the brush through Refresh Material. Pass the pair together, since the cached desktop flag decides which of the two is actually instanced. |
| event | `RefreshMaterial` | `()` | Instances the world or the desktop material according to the cached desktop flag, applies the corner sizes and sets the result as the brush. Skipped entirely while no theme has been applied, so the border stays as the designer left it. |

**AFBorder_Linear**4 members

extends `AFSExtendedBorder` · implements `BPI_WidgetElement`

Rounded surface coloured from a plain linear colour instead of a theme colour definition, with its own corner override. Use it in the few places where the colour comes from data or from the user rather than the palette, as the colour picker does for its preview; prefer the ordinary rounded border everywhere else.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Color`Color | `LinearColor` | Raw colour written straight into the border material, bypassing the theme palette entirely. Use this variant where the colour is chosen at runtime, as the colour picker does; the theme has no say in it. |
| var | `Corners`Corner | `ST_Corner_Definition` | Corner rounding of the border, resolved through the theme into the material's corner sizes when the material is built and refreshed by Update Corner Override. |
| event | `UpdateCornerOverride` | `(Corners: ST_Corner_Definition)` | Replaces the corner definition and pushes the new corner sizes into the live material rather than rebuilding it. Does nothing until a theme has been applied. |
| event | `UpdateColor` | `(Color: LinearColor)` | Recolours the border by writing the raw colour into the material's colour parameter, with no theme lookup on the way. The value is stored even before the theme pass has built a material, though nothing is repainted until it has. |

**AFBorder_Rounded**3 members

extends `AFBorder`

Rounded version of the themed surface and the default choice for panels, cards and button bodies. Same fill as the plain border, drawn with the theme's corner radii or a custom size from its corner definition. Parent of the hover, outline, gradient, separator and side-colour variants, so subclass it when you need a material the family does not cover.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Corners`Corner | `ST_Corner_Definition` | Corner rounding of the border, taken from a theme corner category or from a custom size and scaled by the definition's multiplier. Applied when the material is built and refreshed by Update Corners. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the flat border material painted with the current colour definition. The desktop flag is ignored at this level and no corner rounding is applied; child borders override this to produce rounded, gradient, outline or hover materials. |
| event | `UpdateCorners` | `(Corners: ST_Corner_Definition)` | Replaces the corner definition and writes the new corner sizes into the live material rather than rebuilding it. Does nothing until a theme has been applied. |

**AFBorder_Rounded_AutoBlend**5 members

extends `AFBorder_Rounded` · implements `BPI_Widget_Blend`

Rounded surface that blends between its own colour and one picked to stay legible against the background behind it, under a single value from 0 to 1. Implements the widget blend contract, so the colour, radio and toggle buttons drive it as their state changes. Place it where a fill has to shift colour without the widget knowing which colours are involved.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Blend`State | `float` | Mix factor, 0 to 1, between the two backgrounds named in Auto Blend. Normally driven through Widget Set Blend Value by whatever is animating the border, typically a button moving between states. |
| var | `Auto Blend`Auto Blend | `ST_AutoBlend` | Pair of background colour definitions the fill colour is adapted to, together with the switch that turns the adaptation on. With it on, the colour is corrected for legibility against each background and the two results mixed by Blend; with it off it comes straight from the theme. |
| event | `UpdateAutoBlend` | `(AutoBlend: ST_AutoBlend)` | Replaces the auto blend settings and repaints, letting a caller re-target the border at a different pair of background colours. The colour button uses it to keep the border following the colour it represents. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |
| event | `UpdateColor` | `(Color: ST_Color_Definition)` | Replaces the fill colour definition and repaints it through the auto blend instead of the base border's direct theme lookup, so the legibility correction survives a runtime recolour. Nothing is repainted until a theme and a material exist. |

**AFBorder_Rounded_Gradient**3 members

extends `AFBorder_Rounded`

Rounded surface filled with a gradient derived from one colour definition, with Gradient Rotation setting the sweep angle. Use it where a flat fill would read as dead space; take the two-colour variant instead when the far end of the gradient needs a colour of its own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Gradient Rotation`Gradient | `float` | Rotation of the gradient sweep, written into the material's rotation parameter as the material is built. Only read at build time, so change it before the theme is applied rather than after. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the flat border material painted with the current colour definition. The desktop flag is ignored at this level and no corner rounding is applied; child borders override this to produce rounded, gradient, outline or hover materials. |
| event | `UpdateColor` | `(Color: ST_Color_Definition)` | Colour hook overridden here with no work of its own, which drops the base border's runtime recolouring. Both ends of the gradient are fixed when the material is built, so re-apply the theme rather than expecting a colour change to show. |

**AFBorder_Rounded_Gradient_2Color**7 members

extends `AFBorder_Rounded_Gradient` · implements `BPI_Widget_Blend`

Rounded gradient surface with both ends under your control: a second colour definition, and an option to invert the sweep as the blend moves. The main button styles use it as their body and drive it through the widget blend contract, so a press or a selection slides between the two colours rather than cutting.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Second Color`Color | `ST_Color_Definition` | Theme colour definition for the far end of the gradient, written into the material together with its brightness-shifted partner. The near end stays with the inherited colour definition. |
| var | `Invert Gradient On Blend`Gradient | `bool` | Flag marking that this border's gradient is meant to run the other way as the blend rises, set in the designer on the standard button and drop-down borders. No graph reads it, so it marks the border for the widget that owns it rather than changing the material by itself. |
| var | `Blend`State | `float` | Mix factor, 0 to 1, written into the material's blend parameter to move the border between its two gradient colours. Driven through Widget Set Blend Value by the button or field animating it. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the flat border material painted with the current colour definition. The desktop flag is ignored at this level and no corner rounding is applied; child borders override this to produce rounded, gradient, outline or hover materials. |
| event | `UpdateColors` | `(Color: ST_Color_Definition, SecondColor: ST_Color_Definition)` | Sets both gradient colours in one call. Only the second reaches the material: the first is routed to the inherited colour update, which this branch of the family leaves empty, so re-apply the theme when the near colour has to change. |
| event | `UpdateSecondColor` | `(SecondColor: ST_Color_Definition)` | Replaces the far colour of the gradient and writes it, with its brightness-shifted partner, into the live material. Does nothing until a theme has been applied. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**AFBorder_Rounded_Hover**3 members

extends `AFBorder_Rounded` · implements `BPI_Widget_Blend`

Rounded surface that carries a button's hover highlight. Transparent by default and faded in through the widget blend contract as a pointer, laser or hand arrives, so buttons stack one over their body instead of recolouring it. Add it above the fill you want the highlight to sit on, and let the button own the blend value.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Blend` | `float` | Strength of the hover layer, 0 to 1, written into the material's blend parameter. Pushed in by the owning button, text field, slider or drop-down as its hover animation plays rather than set by hand. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the flat border material painted with the current colour definition. The desktop flag is ignored at this level and no corner rounding is applied; child borders override this to produce rounded, gradient, outline or hover materials. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**AFBorder_Rounded_Outline**4 members

extends `AFBorder_Rounded` · implements `BPI_Widget_Blend`

Rounded surface drawing only an edge, its weight taken from the theme's outline categories and its opacity driven through the widget blend contract. Nothing is painted in the middle, so it can sit above other content. Layer it over cards, text fields, overlays and anything that needs a focus or selection ring.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Outline Category`Outline | `E_UI_Outline` | Named outline weight, whose width is looked up in the theme's outline table and written into the material as its border width. Read only while the material is being built, and exposed on spawn so borders created at runtime can be given a weight up front. |
| var | `Blend`State | `float` | Strength of the outline's blend parameter, 0 to 1, driven through Widget Set Blend Value by the text field or colour picker whose focus and hover animations own this border. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the flat border material painted with the current colour definition. The desktop flag is ignored at this level and no corner rounding is applied; child borders override this to produce rounded, gradient, outline or hover materials. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**AFBorder_Rounded_Separator**0 members

extends `AFBorder_Rounded`

Preset of the rounded surface configured as a divider: background colour, a small fixed corner radius and even padding on all four sides. Drop it between rows or sections rather than styling a border by hand. Nothing in the shipped content uses it, so treat it as a convenience preset rather than something already wired in.

No editor-visible members; this asset configures defaults only.

**AFBorder_Rounded_SideColor**5 members

extends `AFBorder_Rounded`

Rounded surface that paints one or more of its four edges in a second colour, with the Sides vector choosing which. The default scaffold uses it for the accent rule down its edge. Place it where a panel needs a coloured edge without a separate widget stacked behind it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Sides`Side | `Vector4` | Mask deciding which edges of the border are drawn in the side colour, handed to the material as four channels, one per edge. The default scaffold forwards its own setting on to this border. |
| var | `Side Color`Side | `ST_Color_Definition` | Theme colour definition the masked edges are drawn in, written into the material as its second colour. The body of the border keeps the inherited fill colour. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the flat border material painted with the current colour definition. The desktop flag is ignored at this level and no corner rounding is applied; child borders override this to produce rounded, gradient, outline or hover materials. |
| event | `UpdateSideColor` | `(SideColor: ST_Color_Definition)` | Replaces the edge colour and writes it into the live material's second colour rather than rebuilding it. Does nothing until a theme has been applied. |
| event | `UpdateSides` | `(Sides: Vector4)` | Replaces the edge mask and pushes it into the live material. Called by the default scaffold when its own sides change, so a layout can move the accent from one edge to another at runtime. |

### Widgets/Basic/HorizontalBox

**AFHorizontalBox**4 members

extends `HorizontalBox` · implements `BPI_WidgetElement`

Horizontal container that owns the spacing between its children. On theme update and on restyle it re-applies Default Padding between them and trims it from the outer edge, skipping collapsed children so a hidden entry leaves no gap. Use it in place of a plain Horizontal Box inside a framework widget.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Default Padding`Style | `float` | Spacing in slate units placed between children whenever the paddings are refreshed. The outer edge of the first visible child and of the last are left at zero, so the box separates its children without padding its own ends. |
| fn | `FindFirstNotCollapsedIndex` | `(out Index: int)` | Returns the index of the first child that is not collapsed. Falls back to the index of the final child when every child is collapsed. |
| fn | `UpdatePaddings` | `()` | Rewrites the left and right padding of every child slot so that Default Padding sits between neighbours and zero sits on the outer edges of the first and last visible children. Each slot keeps its own top and bottom padding. |
| fn | `FindLastNotCollapsedIndex` | `(out Index: int)` | Returns the index of the last child that is not collapsed, walking the children in reverse. Falls back to 0 when every child is collapsed. |

### Widgets/Basic/Images

**AFGradient**4 members

extends `AFSExtendedImage` · implements `BPI_WidgetElement`

Image drawing a soft gradient tinted from a colour definition, with a rotation for its direction; both are re-applied whenever the theme changes. Used behind the expanding scaffold. Place it as a backdrop where a panel should fade out into the scene rather than end on a hard edge.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Color`Gradient | `ST_Color_Definition` | Theme colour definition the gradient is tinted with. It is applied as the brush tint rather than written into the material, so it multiplies the gradient the material draws; before a theme has been applied it resolves to nothing and the widget stays invisible. |
| var | `Rotation`Gradient | `float` | Angle the gradient sweeps through, written straight into the gradient material's rotation parameter and counted in turns rather than degrees, so 0.5 is a half turn. Reapplied on every theme pass. |
| event | `UpdateColor` | `(Color: ST_Color_Definition)` | Recolours the gradient at runtime, storing the definition and resolving it against the theme into the brush tint. Until a theme has been applied the tint resolves to fully transparent. |
| event | `UpdateRotation` | `(Rotation: float)` | Turns the gradient at runtime, storing the value and writing it into the material's rotation parameter. Only has an effect once the theme pass has built that material. |

**AFImage**9 members

extends `AFSExtendedImage` · implements `BPI_WidgetElement`

Themed image at the root of the image family: draws a texture through a material the theme builds, and can take its size from that texture or fit it inside Max Dimensions. Collapse If Empty hides it when no texture is set, so optional artwork leaves no hole in a layout. Use it in place of a plain Image, or subclass it for a variant with its own material.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Collapse if Empty`Behavior | `bool` | Whether the widget collapses itself when it has no texture, giving the space back to its parent box. The test only runs when the texture is changed through Update Image, so a texture set in the designer or written directly leaves the visibility as it was. |
| var | `Texture`Image | `Texture` | Picture drawn by this widget, written into the image material each time the material is built. Change it through Update Image rather than directly, so that the collapse check and the sizing rule run with it. |
| var | `Limit to Dimensions`Dimensions | `E_UI_Image_AutoSize` | Sizing rule: Custom leaves the brush size set in the designer alone, Take Size From Image overrides the desired size with the texture's own pixel size, and Fit To Dimensions scales that size evenly into Max Dimensions. Applied on every theme pass and on every image change. |
| var | `Max Dimensions`Dimensions | `Vector2D` | Box in slate units the image is scaled to fit inside while the sizing rule is Fit To Dimensions, keeping the aspect ratio of the texture. A negative component leaves that axis unconstrained; the value is ignored under the other two rules. |
| fn | `getTextureSize` | `(out Size X: int, out Size Y: int)` | Returns the pixel width and height of the current texture, read from a 2D texture or from a render target. Any other kind of texture, and an empty one, comes back as zero, which is then what the sizing rules work from. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the plain image material with the current texture written into it. Called by the theme pass to build the brush; the Desktop flag is ignored here, and the child classes override it to swap in the icon, rounded and transition materials. |
| event | `UpdateImage` | `(Texture: Texture)` | Swaps the displayed texture, re-runs the collapse check and, once a theme has been applied, writes the texture into the live material and reapplies the sizing rule. Before the theme pass only the stored texture and the visibility change. |
| event | `UpdateLimitToDimensions` | `(SizeRule: E_UI_Image_AutoSize, IdealDimensions: Vector2D)` | Applies a sizing rule together with its dimensions, overriding the widget's desired size either with the texture's pixel size or with an even scale into the given box. Under the Custom rule the desired size is left exactly as the designer set it. |
| event | `CheckCollapse` | `()` | Collapses the widget while it has no texture and shows it again once it has one, but only while Collapse If Empty is set; otherwise it does nothing at all. Run for you by Update Image. |

**AFImage_Icon**10 members

extends `AFImage` · implements `BPI_Widget_Blend`

Image preset for icons: a blank 64-pixel icon by default, tinted from a colour definition rather than from the texture's own pixels. Blends towards a legible contrast colour through the widget blend contract, so an icon inside a button follows the button's state, and Override With Custom Color swaps in a colour data asset. The framework's standard way to show an icon.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Color`Style | `ST_Color_Definition` | Theme colour definition the icon is tinted with, written into the icon material when it is built and again whenever the colour or the blend changes. With auto blend on it is first corrected for legibility against the backgrounds named there. |
| var | `Blend`Blend | `float` | Mix factor, 0 to 1, between the two backgrounds named in Auto Blend. Normally driven through Widget Set Blend Value by whatever is animating the icon, typically a button moving between states; ignored while auto blend is off. |
| var | `Auto Blend`Blend | `ST_AutoBlend` | Pair of background colour definitions the icon colour is adapted to, together with the switch that turns the adaptation on. With it on, the colour is corrected for legibility against each background and the two results mixed by Blend; with it off it comes straight from the theme. |
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `UpdateMaterialColorValues`Color | `()` | Writes the currently desired tint into the material, resolving the colour definition through the theme and through the auto blend settings. Does nothing while no material has been built yet. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the plain image material with the current texture written into it. Called by the theme pass to build the brush; the Desktop flag is ignored here, and the child classes override it to swap in the icon, rounded and transition materials. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |
| event | `UpdateColor` | `(Color: ST_Color_Definition)` | Recolours the icon at runtime, storing the definition and repainting the material through the auto blend. Nothing changes on screen until a material has been built. |
| event | `UpdateAutoBlendInfo` | `(AutoBlendDefinition: ST_AutoBlend)` | Replaces the auto blend settings and repaints, letting a caller re-target the icon at a different pair of background colours as its surroundings change. |
| event | `OverrideWithCustomColor` | `(Custom: PDA_Color)` | Forces the icon onto a specific colour asset, wrapping it in a custom definition at medium intensity and repainting. Ignored when no colour asset is passed. |

**AFImage_Rounded**4 members

extends `AFImage`

Image with rounded corners, their radii taken from the theme's corner definition or overridden per instance. Parent of the background, transition and translated variants. Use it for thumbnails and card artwork where a square edge would cut across the panel's shape.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Corners`Corners | `ST_Corner_Definition` | Corner rounding of the image, resolved by the theme into the four corner sizes written into the material. Applied when the material is built and again by Update Corner Override. |
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the plain image material with the current texture written into it. Called by the theme pass to build the brush; the Desktop flag is ignored here, and the child classes override it to swap in the icon, rounded and transition materials. |
| event | `UpdateCornerOverride` | `(Corners: ST_Corner_Definition)` | Rounds the corners differently at runtime, storing the definition and writing the resolved corner sizes into the live material. Does nothing until a theme has been applied. |

**AFImage_Rounded_Background**3 members

extends `AFImage_Rounded`

Rounded image with a themed colour drawn behind the texture, so artwork that is transparent or does not cover the whole brush still reads as a solid card. Used by the image button. Place it where the picture cannot be relied on to fill its frame.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Color`Color | `ST_Color_Definition` | Theme colour definition filling the rounded shape behind the image, written into the material when it is built and by Update Colour. Use it to give a transparent or partly transparent texture a themed backdrop. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the plain image material with the current texture written into it. Called by the theme pass to build the brush; the Desktop flag is ignored here, and the child classes override it to swap in the icon, rounded and transition materials. |
| event | `UpdateColor` | `(Color: ST_Color_Definition)` | Repaints the backdrop behind the image at runtime, storing the definition and resolving it into the material. Does nothing until a theme has been applied. |

**AFImage_Rounded_Transition**10 members

extends `AFImage_Rounded`

Rounded image that cross-fades between textures instead of swapping them. Give it an image list and call Switch To Index, or switch auto-scroll on to step through the list on a timer; Fade Duration is the length of one cross-fade, in seconds. Only the images example uses it, so it is here for slideshows and hero images of your own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Image List`Content | `Texture[]` | Textures this widget can cross-fade between, addressed by position through Switch To Index and stepped through by the auto scroll. Exposed on spawn; leave it empty and neither has anything to fade to. |
| var | `Current Index`State | `int` | Textures this widget can cross-fade between, addressed by position through Switch To Index and stepped through by the auto scroll. Exposed on spawn; leave it empty and neither has anything to fade to. |
| var | `Fade Duration`Settings | `float` | Length of a cross-fade in seconds, half a second by default. The blend is stepped every 11 milliseconds by that fraction of the duration, so at zero it never advances and the fade never finishes. |
| var | `Auto Scroll Time`AutoScroll | `float` | Seconds between automatic switches while auto scroll is running, three by default. It is read once as Set Auto Scroll arms the timer, so changing it afterwards takes effect only when auto scroll is switched off and on again. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the plain image material with the current texture written into it. Called by the theme pass to build the brush; the Desktop flag is ignored here, and the child classes override it to swap in the icon, rounded and transition materials. |
| event | `FadeToTexture` | `(Texture: Texture)` | Cross-fades to any texture, in or out of the image list, by writing it into the material's second slot and running a timer that raises the blend every 11 milliseconds until it arrives. The texture then becomes the widget's own and the blend resets, ready for the next fade. Does nothing while no material has been built. |
| event | `SwitchToIndex` | `(CurrentIndex: int)` | Cross-fades to the entry of the image list at the given position and records it as the current index. Nothing bounds-checks the position, so one outside the list fades to an empty texture. |
| event | `UpdateImageList` | `(ImageList: Texture[])` | Replaces the set of textures available to switching and to the auto scroll. Nothing on screen changes until the next switch, and the current index is left pointing where it was, which may no longer be the same picture. |
| event | `SetAutoScroll` | `(Set: bool)` | Starts or stops the automatic walk through the image list, arming a repeating timer at Auto Scroll Time seconds that cross-fades onwards each time it fires. Switching it off pauses that timer rather than clearing it. |
| event | `ExecAutoScroll` | `()` | Internal timer callback that moves the widget on to another entry of the image list through Switch To Index. Arm and disarm it through Set Auto Scroll rather than calling it yourself. |

**AFImage_Rounded_Translated**2 members

extends `AFImage_Rounded`

Rounded image whose texture is panned and zoomed inside the brush rather than stretched to fill it, driven by a translation struct holding an offset and a zoom. Use it to frame part of a larger picture at a fixed size; the images example is the only shipped user.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Translation`Transform | `ST_Image_Translation` | Zoom factor and two-axis offset applied to the texture inside the rounded frame, written into the material as its zoom and its two translate parameters. Use it to crop into a picture whose shape does not match the widget. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns a fresh dynamic instance of the plain image material with the current texture written into it. Called by the theme pass to build the brush; the Desktop flag is ignored here, and the child classes override it to swap in the icon, rounded and transition materials. |

**AFLogo**11 members

extends `AFImage`

Image showing the project's logo, taking the light or dark artwork from a logo struct to match the theme in use and refreshing when the theme changes. The auto-colour options let it pick against the background it is placed on. Set the logo on the idle screen, the VR menu and the navigation bar through this rather than swapping textures yourself.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Logo`Appearance | `ST_Logo` | Pair of artworks, one meant for light themes and one for dark. Update Content picks between them by asking the theme which it is, and as that reading always answers dark, the dark artwork is the one shown. |
| var | `Secondary Blend`State | `float` | Mix factor intended to move the logo towards a second state. Nothing in the graph reads it, so it stands as a marker for widgets built on top of the logo rather than changing anything here. |
| var | `Use Auto Color Blend`Auto Color | `bool` | Switch meant to adapt the logo colour to the background it sits on. Update Auto Colour Blend stores it, but nothing reads it back, so the logo is drawn the same either way. |
| var | `Background Color Normal`Auto Color | `ST_Color_Definition` | Background colour definition the logo would adapt to at rest. Stored by Update Auto Colour Blend and otherwise unread, as the automatic adaptation is not wired up on this widget. |
| var | `Background Color Secondary`Auto Color | `ST_Color_Definition` | Background colour definition the logo would adapt to in its second state, to be mixed against the resting one by Secondary Blend. Stored by Update Auto Colour Blend and otherwise unread. |
| var | `Color`Style | `ST_Color_Definition` | Theme colour definition offered for tinting the logo. The artwork is drawn through the plain image material, which carries no colour parameter, so nothing reads this; supply an already coloured texture instead. |
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| event | `UpdateLogo` | `(Logo: ST_Logo)` | Replaces the pair of light and dark artworks and immediately puts the one matching the theme on screen. This is the call that gives a logo its picture at runtime. |
| event | `UpdateAutoColorBlend` | `(UseAutoColorBlend: bool, BackgroundColor_Normal: ST_Color_Definition, BackgroundColor_Secondary: ST_Color_Definition)` | Stores the three automatic colour settings and refreshes the artwork. Since nothing reads those settings back, the refresh is the only visible effect. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |
| event | `UpdateContent` | `()` | Chooses the light or the dark artwork by what the theme reports about itself and hands it to Update Image, which brings the collapse check and the sizing rule with it. Run for you by Update Logo and by Update Auto Colour Blend. |

### Widgets/Basic/ScrollBox

**AFScrollbox**15 members

extends `AFSExtendedScrollbox` · implements `BPI_WidgetElement`

Scroll box for framework widgets: interpolated scrolling to an offset rather than jumping, a scroll sound played through the widget component, and a scrollbar built from four theme colours that fades away while there is nothing to scroll. Scroll position replicates to other players unless Should Replicate is off. Use the horizontal or vertical preset rather than placing this directly.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Scroll Speed`Scroll | `float` | Interpolation speed of the smooth scroll motion, stepped every 11 milliseconds until the target offset is reached. Higher values arrive sooner; scrolling the content by hand is unaffected. |
| var | `Sound Scroll`Sound | `SoundBase` | Sound played through the widget component while the user drags the content, throttled to one play per tenth of a second and only once the offset has moved more than 15 units since the last one. Leave empty for silent scrolling. |
| var | `Should Replicate`Replication | `bool` | Whether the scroll offset is mirrored to the other clients through the widget component, which registers this scroll box under a replication identifier. Turning it off instead binds the local scroll handler, which is what drives the scroll sound and the automatic scrollbar fade. |
| var | `Background Color`Color | `ST_Color_Definition` | Theme colour definition for the scrollbar track, resolved into a rounded border material each time the theme is applied. |
| var | `Bar Color Default`Color | `ST_Color_Definition` | Theme colour definition for the scrollbar thumb at rest, drawn as a rounded gradient material with a quarter-strength falloff. |
| var | `Bar Color Hovered`Color | `ST_Color_Definition` | Theme colour definition for the scrollbar thumb while the pointer is over it, drawn as a rounded gradient material with a quarter-strength falloff. |
| var | `Bar Color Dragged`Color | `ST_Color_Definition` | Theme colour definition for the scrollbar thumb while it is being dragged, drawn as a rounded gradient material with a quarter-strength falloff. |
| event | `StopScrollMovement` | `()` | Pauses the timer driving the smooth scroll interpolation, leaving the offset wherever it had reached. Called when the user scrolls by hand so that manual input takes over from an in-flight Scroll To Offset. |
| event | `AddScrollOffset` | `(Offset: float)` | Scrolls smoothly by the given amount relative to the current position, clamped between the top of the content and its end. Replicates the resulting absolute offset to the other clients when replication is on. |
| event | `IterateScrollMotion` | `()` | Internal timer callback that steps the offset towards its target and broadcasts On Scroll Offset Updated after each step. Skips its work while an incoming replicated update is blocked, and pauses its own timer once the target is reached. |
| event | `OnUserScrolled_Event` | `(CurrentOffset: float)` | Internal handler bound to the scroll box's own user scroll delegate. Broadcasts On Scroll Offset Updated, plays the scroll sound once the offset has moved more than 15 units, cancels any smooth scroll in progress, and pushes the new offset out while blocking incoming updates for a second. |
| event | `ScrollToOffset` | `(Target Scroll Offset: float)` | Animates the content towards an absolute scroll offset by storing it as the target and starting the repeating interpolation timer. Use it in place of setting the offset directly whenever the movement should be smoothed. |
| event | `UpdateOpacity` | `(NewOpacity: float)` | Applies an opacity of 0 to 1 to every brush of the scrollbar style, track and thumbs alike, and records it as the current opacity. Used by the fade that hides the scrollbar while there is nothing to scroll. |
| event | `ContinousScrollbarVisibilityCheck` | `()` | Hides the scrollbar, waits a second, then loops watching whether the content is long enough to scroll. Each time that answer changes it restarts the fade timer and waits two seconds before testing again. Started at initiation only when replication is off. |
| event | `ShowScrollBar_Tick` | `()` | Internal timer target for the scrollbar fade, registered on a 16 millisecond repeat whenever scrollbar visibility changes. It carries no work of its own in this build. |

**AFScrollbox_Horizontal**0 members

extends `AFScrollbox`

Horizontal preset of the framework scroll box, with the orientation set and the scrollbar padded off the bottom of the content. Nothing else is added; use it instead of reconfiguring the base scroll box by hand.

No editor-visible members; this asset configures defaults only.

**AFScrollbox_Vertical**3 members

extends `AFScrollbox`

Vertical preset of the framework scroll box, with the bar and its track always visible and padded off the left of the content, plus Boxed and Small for the two styling variants. The default scrolling container throughout the framework's widgets; reach for it whenever content can outgrow its panel.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Boxed`Design | `bool` | Design flag marking this scroll box as one sitting inside a boxed panel. Nothing in the graph reads it, so it serves as a marker for the widget that owns the scroll box rather than changing the styling itself. |
| var | `Small`Design | `bool` | Design flag marking the compact variant of the vertical scroll box. Nothing in the graph reads it, so it serves as a marker for the owning widget rather than changing the styling itself. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

### Widgets/Basic/Switcher

**AFSwitcher**25 members

extends `AFSExtendedOverlay` · implements `BPI_WidgetElement`

Overlay holding several widgets and cross-fading between them, optionally sliding them with Move Transform and playing a switch sound. Switch by index, by widget, or by an ID from its Widgets map, in which case it creates the page on demand and can drop it again once it has faded out. Registers with the widget component so the visible page replicates. The framework's page, tab and step container.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Initial Index`Content | `int` | Index of the child shown before anything switches. Applied when the switcher formats its children, which happens in the designer preview and again at initiation when replication is off. |
| var | `Transition Speed`Transition | `float` | Constant interpolation speed of the cross-fade between children, stepped every 11 milliseconds until each one has reached full or zero opacity. Raise it for a snappier switch. |
| var | `Should Replicate`Replication | `bool` | Whether switching is mirrored to the other clients through the widget component. With it on the switcher registers under a replication identifier instead of formatting its children at initiation, and every switch is sent out as an index or an identifier. |
| var | `Horizontal Alignment`Design | `EHorizontalAlignment` | Horizontal placement given to every child's overlay slot, both for children present in the designer and for those added later through Add Widget To Switcher. |
| var | `Vertical Alignment`Design | `EVerticalAlignment` | Vertical placement given to every child's overlay slot, both for children present in the designer and for those added later through Add Widget To Switcher. |
| var | `Widget Tag`Tag | `name` | Tag reported to the widget system when it asks this element to identify itself, letting other code find the switcher by name. Leave as None when nothing needs to look it up. |
| var | `Movetransform`Transition | `WidgetTransform` | Render transform a child is displaced by while it is out of view, interpolated away to nothing as the child fades in. The angle is mirrored according to whether you moved forwards or backwards through the children, unless Force Direction is set. |
| var | `Switch Sound`Sound | `SoundBase` | Sound played through the widget component at the centre of the switcher when a transition begins. Nothing is played for a switch made with the transition turned off; leave empty for a silent switch. |
| var | `Force Direction`Transition | `bool` | When set, transitions always lean the same way instead of mirroring the move transform's angle according to the direction of travel. Useful where the children have no meaningful order. |
| var | `Widgets`Content | `Map<name, WBP_Base>` | Named widget classes this switcher can produce on demand, keyed by the identifier passed to Switch To ID. The same map is read back to report the current identifier, so children placed by hand in the designer have none. |
| var | `Remove Widgets After Fade Out`Content | `bool` | Whether a child is removed from the switcher once it has faded out rather than kept collapsed for reuse. With it set, Create Widget builds a fresh instance every time; leave it clear to keep the state of a widget between switches. |
| fn | `ApplyWidgetPreTransitionState`Transition | `(Widget: Widget)` | Tells the owning widget that this child, and everything nested inside it, is about to be hidden or revealed by the switcher, so those elements can react before the fade starts. Does nothing until the switcher has been given a parent. |
| fn | `ApplyWidgetPostTransitionState`Transition | `(Widget: Widget)` | Settles a child once the fade has finished: visible and fully shown if it is the focussed one, collapsed and transparent otherwise, and removed from the switcher altogether when Remove Widgets After Fade Out is set. |
| fn | `TickTranstion`Transition | `()` | Internal timer callback that advances the cross-fade, moving each child's opacity towards one for the focussed widget and zero for the rest. Once every child has arrived it applies the final states and clears its own timer. |
| fn | `NextWidget`Switch | `()` | Steps the switcher on one child. Goes through Switch To Index, so the transition, the switch sound and any replication happen exactly as they would for a direct switch. |
| fn | `PreviousWidget`Switch | `()` | Steps the switcher back one child. Goes through Switch To Index, so the transition, the switch sound and any replication happen exactly as they would for a direct switch. |
| fn | `SwitchToWidget`Switch | `(NewFocussedWidget: Widget, Transition: bool)` | Makes the given child the focussed one, tells the owning widget which nested elements are now hidden behind the switcher and broadcasts New Widget Focussed. With the transition on it starts the cross-fade timer and plays the switch sound; otherwise every child snaps straight to its final state. |
| fn | `getCurrentIndex`State | `(out CurrentIndex: int)` | Returns the child index of the currently focussed widget, or -1 while nothing is focussed. |
| fn | `getCurrentID`State | `(out ID: name)` | Returns the identifier the focussed widget was created from by matching its class against the Widgets map. Comes back as None for children placed in the designer rather than created from the map. |
| fn | `getWidgetByClass`Widget | `(WidgetClass: class<WBP_Base>, out Widget: Widget)` | Returns the first child whose class matches exactly. Comes back empty when no widget of that class has been created yet, so check the result before using it. |
| fn | `SwitchToID`Switch | `(ID: name, Transition: bool, out NewWidget: WBP_Base)` | Looks the identifier up in the Widgets map and switches to a widget of that class, creating it if it does not exist yet. Returns without doing anything when the focussed widget is already of that class; sends the identifier out when replication is on. |
| fn | `SwitchToIndex`Switch | `(Index: int, Transition: bool) → Widget` | Switches to the child at the given index and returns it, doing nothing when that child already has focus. Records whether the move was forwards or backwards so the transition leans the right way, and sends the new index to the other clients when replication is on. |
| fn | `CreateWidget`Widget | `(WidgetClass: class<WBP_Base>, ReplicationIndex: name, Focus: bool, Transition: bool, out Widget: WBP_Base)` | Creates a widget of the given class, hands it the switcher's owning widget as parent along with a replication index derived from the switcher's own, and adds it as a child. Unless Remove Widgets After Fade Out is set an existing child of that class is reused instead. Does nothing when no class is supplied. |
| fn | `AddWidgetToSwitcher`Widget | `(Widget: Widget, Focus: bool, Transition: bool, out NewIndex: int)` | Adds an already-created widget as a child, aligns its slot, parks it collapsed at zero progress and reports back the index it landed on. Ask for focus to switch to it straight away, with or without the fade. |
| fn | `setWidgetTransitionProgress`Transition | `(Widget: Widget, Progress: float, Direction: bool)` | Places a widget at a point along the transition, setting its render opacity to the progress value and interpolating its render transform from the configured move transform towards none. Progress runs 0 to 1, from fully out to fully shown. |

### Widgets/Basic/Text

**AFText**12 members

extends `AFSExtendedText` · implements `BPI_WidgetElement`, `BPI_Widget_Blend`

Text styled from the theme: choose a Typography level and it takes the matching font, colour and desired padding, or set the colour rule to use a custom colour definition instead. Blends towards a contrast colour through the widget blend contract so text inside a button follows its state, and Collapse If Empty hides it when the text is blank. Use it in place of a plain Text Block.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Typography`Style | `E_UI_Typography` | Theme typography level, which selects the font and, unless the colour rule says otherwise, the emphasis of the text colour. It also fixes the padding this text asks its parent box for, from 30 units at the largest level down to 3 at the smallest. |
| var | `Color Rule`Style | `E_UI_Text_ColorRule` | Which colour the text takes: the one implied by its typography, or the custom colour definition below. Override With Custom Colour moves this onto the custom setting for you. |
| var | `Custom Color Definition`Style | `ST_Color_Definition` | Theme colour definition used while the colour rule is set to the custom definition. Ignored as long as the rule follows the typography. |
| var | `Blend`Auto Blend | `float` | Mix factor, 0 to 1, between the two backgrounds named in Auto Blend. Normally driven through Widget Set Blend Value by whatever is animating the text, typically a button moving between states. |
| var | `Collapse if Empty`Behavior | `bool` | Whether the text collapses itself when it has nothing to show, giving the space back to its parent box. Checked on every theme update and on every Update Text; leave clear to keep the empty line reserved. |
| var | `Auto Blend`Auto Blend | `ST_AutoBlend` | Pair of background colour definitions the text colour is adapted to, together with the switch that turns the adaptation on. With it on, the colour is corrected for legibility against each background and the two results mixed by Blend; with it off it comes straight from the theme. |
| event | `UpdateTypography` | `(Typography: E_UI_Typography)` | Moves the text onto another typography level at runtime, refreshing both the resolved colour and the font taken from the theme. Nothing visible changes until a theme has been applied. |
| event | `UpdateCustomColor` | `(ColorDefinition: ST_Color_Definition)` | Replaces the custom colour definition and repaints. Has no visible effect while the colour rule still follows the typography. |
| event | `UpdateAutoColorBlend` | `(UseAutoColorBlend: ST_AutoBlend)` | Replaces the auto blend settings and repaints, letting a caller re-target the text at a different pair of background colours as its surroundings change. |
| event | `UpdateText` | `(InText: text)` | Sets the displayed text and re-runs the empty check, collapsing or restoring the widget when Collapse If Empty is set. Prefer it to setting the text directly so that the collapse stays in step. |
| event | `UpdateColorRule` | `(ColorRule: E_UI_Text_ColorRule)` | Switches between taking the colour from the typography and taking it from the custom definition, then repaints. |
| event | `OverrideWithCustomColor` | `(Custom: PDA_Color)` | Forces the text onto a specific colour asset, moving the colour rule onto the custom definition and wrapping the asset in a medium-intensity definition. Ignored when no colour asset is passed. |

### Widgets/Basic/Throbber

**AFThrobber_Circular**2 members

extends `AFSExtendedImage` · implements `BPI_WidgetElement`

Circular busy indicator drawn with the round throbber material and tinted from a colour definition. The animation lives in the material, so it runs for as long as the widget is visible and needs no starting or stopping. Drop it in while something loads; the loading overlay and the loading switcher already use one.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Color`Color | `ST_Color_Definition` | Theme colour definition of the spinner, resolved against the theme and written into the round throbber material each time the theme is applied. |
| event | `UpdateColor` | `(Color: ST_Color_Definition)` | Recolours the spinner at runtime, storing the definition and resolving it against the theme into the material. Does nothing until a theme has been applied. |

**AFThrobber_Linear**4 members

extends `AFSExtendedImage` · implements `BPI_WidgetElement`

Indeterminate progress bar: a sweep running along a rounded track, with separate foreground and background colours from the theme and corners matched to it. Use it where a spinner would be too tall, as the top HUD example and the loading screen do, and a determinate progress widget where the amount of work is actually known.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Color Foreground`Color | `ST_Color_Definition` | Theme colour definition of the moving bar, written into the throbber material as its primary colour each time the theme is applied. |
| var | `Color Background`Color | `ST_Color_Definition` | Theme colour definition of the track behind the moving bar, written into the throbber material as its second colour each time the theme is applied. |
| event | `UpdateColor` | `(Color: ST_Color_Definition)` | Recolours the moving bar at runtime, storing the definition and resolving it against the theme into the material. Does nothing until a theme has been applied. |
| event | `UpdateBackgroundColor` | `(Color: ST_Color_Definition)` | Recolours the track behind the bar at runtime, writing the resolved colour into the material's second colour slot. Does nothing until a theme has been applied. |

### Widgets/Basic/VerticalBox

**AFVerticalBox**3 members

extends `VerticalBox` · implements `BPI_WidgetElement`

Vertical container that owns the spacing between its rows, re-applying it on theme update and on restyle and skipping collapsed children so a hidden row leaves no gap. Custom Padding For First Item and Last Element As Footer adjust the ends. The most-used container in the framework's widgets; use it in place of a plain Vertical Box.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Default Padding`Style | `float` | Fallback spacing in slate units for children that do not declare a preferred padding of their own. It is also what this box reports as its own desired padding when its last visible child is a plain widget. |
| var | `Custom Padding for First Item`Style | `bool` | Design flag asking for the first child to keep a padding of its own rather than sitting flush with the top of the box. The current padding pass never reads it, so widgets that set it rely on their own layout instead. |
| var | `Last Element as Footer`Style | `bool` | Design flag marking the last child as a footer that should be spaced away from the rest. As with the first-item flag, the current padding pass never reads it. |

### Widgets/Display/AnchorMenu

**WBP_AnchorMenu**12 members

extends `WBP_Base`

Base for a control that pops a menu out beside itself. Owns the drop-down currently open, opens, closes and toggles the anchor, and passes on the placement, the size overrides and the fit-in-window setting. It has no anchor or visuals of its own, so subclass it, return your menu anchor and build the menu in Create Drop Down Menu, as the drop-down button and the colour picker do.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Placement`Style | `EMenuPlacement` | Intended placement of the pop-out menu relative to the anchor. Nothing in the anchor menu reads it, so what actually decides the position is the placement set on the menu anchor widget in the designer. |
| var | `Height Overide`Style | `ST_SizeOverride` | Height override handed on to the drop-down menu this anchor creates. Leave the override flag off to let the menu size itself to its content. |
| var | `Width Override`Style | `ST_SizeOverride` | Width override handed on to the drop-down menu this anchor creates. Leave the override flag off to let the menu size itself to its content. |
| var | `Fit in Window`Style | `bool` | Flag deciding whether the open menu is pushed back inside the window when it would overflow an edge. It only reaches the menu anchor through Set Fit In Window, so editing it in the details panel alone has no effect. |
| fn | `OnMenuOpenChanged`State | `(bIsOpen: bool)` | Broadcasts On Menu Open or On Menu Closed according to the flag handed in. Bind it to the menu anchor's own open-changed event so listeners also hear about a menu the player closed by pressing outside it. |
| fn | `SetFitInWindow`Settings | `(Fit: bool)` | Records the fit-in-window flag and pushes it straight to the menu anchor. This is the only route by which the flag reaches the anchor. |
| fn | `OpenMenuAnchor`Anchor | `()` | Opens the menu anchor without giving the menu focus, which builds its content through Get User Menu Content when nothing is open yet. |
| fn | `createDropDownMenu`Anchor | `(out NewMenu: WBP_DropDownMenu)` | Creates the menu widget that pops out of this anchor. Empty on the base class; override it to spawn your own menu, passing the height and width overrides on and binding whatever delegates it offers. |
| fn | `MainMenuAnchor_GetUserMenuContent`Anchor | `() → UserWidget` | Builds the widget the anchor shows: creates a menu through Create Drop Down Menu, keeps it as the current menu and subscribes Close Menu Anchor to its On Selected Outside so a press elsewhere shuts it. Bind it to the anchor's Get User Menu Content event. |
| fn | `getMenuAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Returns the menu anchor the menu pops out of. Empty on the base class; every anchor menu overrides it, and opening, closing and Set Fit In Window all act on whatever it returns. |
| event | `CloseMenuAnchor` | `()` | Hides the open menu and closes the anchor 0.15 seconds later, which leaves the menu's appear animation time to run backwards before the widget is torn down. Does nothing when no menu has been created. |
| event | `ToggleMenuAnchor` | `()` | Closes the anchor when its menu is open and opens it otherwise. This is what a drop-down or a colour picker calls when its button is pressed. |

**WBP_DropDownMenu**9 members

extends `WBP_Base`

Base for the content that appears inside an anchor menu. Handles its own dismissal: it watches for a mouse press anywhere in the interface and broadcasts On Selected Outside when the press lands elsewhere, then plays the appear animation backwards with the close sound and removes itself. The anchor menu spawns it; subclass it and return your size box and appear animation.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Open Sound`Sound | `SoundBase` | Sound meant to accompany the menu appearing, handed in when the anchor menu spawns it. Nothing in the shipped menus plays it; only Close Sound is played, by Hide. |
| var | `Close Sound`Sound | `SoundBase` | Sound played as the menu is hidden, at the menu's own position on the widget surface. Leave empty for a silent close. |
| var | `Height Overide`Style | `ST_SizeOverride` | Height override passed in when the anchor menu spawns the menu. The menu never applies it itself, so a design that wants a fixed height has to push it onto the box returned by Get Size Box. |
| var | `Width Override`Style | `ST_SizeOverride` | Width override passed in when the anchor menu spawns the menu. As with the height, nothing applies it to the size box for you. |
| fn | `OnMouseButtonPressed`State | `(Location: Vector2D)` | Broadcasts On Selected Outside when a press lands anywhere but on the menu's own geometry, which is what makes the anchor close on a press elsewhere. Presses inside the menu are ignored; Hide unbinds it from the host's press listener again. |
| fn | `getAnimation_Appear`Get Animations | `(out AppearAnim: WidgetAnimation)` | Returns the animation that brings the menu in. Empty on the base class; each design overrides it with its own, and Hide plays whatever comes back in reverse. |
| fn | `getSizeBox`Get Elements | `(out SizeBox: SizeBox)` | Returns the size box wrapping the menu's content. Empty on the base class; each design overrides it with its own, and it is the box any height or width override belongs on. |
| event | `Hide` | `()` | Plays the appear animation backwards, unbinds the menu from the host's press listener and plays Close Sound, then removes the whole menu tree cleanly once the animation has finished. Called by the anchor menu as it closes. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

### Widgets/Display/BulletPoint

**WBP_BulletPoints**7 members

extends `WBP_Group`

Group building a vertical list of bulleted lines from an array of text. Populate Bulletpoints clears the group and creates one bullet widget per entry, all sharing the same icon. Drop it in and fill Texts in the details panel, or hand it a fresh array at runtime.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Texts`Content | `text[]` | Lines the list is built from, one bullet point per entry. Nothing is built while the widget is constructed; the entries only become widgets when Populate Bulletpoints runs, which also replaces the list with the one you hand it. |
| var | `Icon`Style | `Texture2D` | Marker texture handed to every bullet point Populate Bulletpoints creates. Leave empty and each bullet point keeps the default marker it ships with. |
| fn | `AddBulletpoint`Content | `(Icon: Texture2D, Text: text, out BulletPoint: WBP_BulletPoint)` | Creates one bullet point with the given marker texture and text and appends it to the group, padded by the spacing the bullet point asks for. Returns the new widget, which the group also keeps in its widget list. |
| fn | `PopulateBulletpoints`Content | `(out BulletPoints: text[], out Bullet Points: WBP_BulletPoint[])` | Rebuilds the list from the texts handed in, clearing every bullet point already in the group first and recording the texts as the widget's own. Hands back the bullet point widgets it created, in order. |
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |
| event | `WidgetElement_InitialConstruct`Construct | `()` | Called on every element while the owning widget pre-constructs in the editor, immediately before the design-time theme pass. Implement it for preview-only set-up; it never runs in a running game. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

### Widgets/Display/BulletPoint/Helper

**WBP_BulletPoint**4 members

extends `WBP_Base`

One line of a bulleted list: an icon and a piece of text side by side, either of which can be changed later through Set Icon and Set Text. The bullet points group creates one per entry, so reach for that group unless you need a single bullet on its own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Bullet Icon`Content | `Texture2D` | Marker texture drawn to the left of the line. Nothing applies it as the widget is built, so a point created by the bullet list keeps the default marker from the designer until Set Icon is called. |
| var | `Text`Content | `Text` | Line written beside the marker. Nothing applies it as the widget is built, so a point created with this set on spawn still shows the designer's placeholder until Set Text is called. |
| event | `SetText` | `(InText: text)` | Records the text and writes it into the label beside the marker. This is the only route by which the wording reaches the screen, since the value handed in on spawn is never applied by itself. |
| event | `SetIcon` | `(BulletIcon: Texture2D)` | Records the texture and swaps it into the marker image, which re-runs its own collapse check and writes it into its material. Handing in nothing leaves the marker blank rather than restoring the designer's bullet. |

### Widgets/Display/Enumerator

**WBP_Enumerator**7 members

extends `WBP_Group`

Group building a numbered or lettered list from an array of enumerator entries. Populate Texted Points clears the group and creates one item per entry, each with its own marker and line of text. Spacing sets how far the text sits from the marker, and is passed on to every item.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Content`Content | `Struct_UI_Enumerator[]` | Entries the list is built from, each carrying a marker such as a number and the line of text that follows it. Nothing is built while the widget is constructed; the entries only become widgets when Populate Texted Points runs. |
| var | `Spacing`Design | `float` | Gap in slate units between an item's marker and its text, handed to every item Add Enumerator creates. It reaches items built from then on, not ones already in the group. |
| fn | `AddEnumerator`Content | `(Enumerator: Struct_UI_Enumerator, out TextedPoint: WBP_EnumeratorItem)` | Creates one item from the entry, giving it the group's spacing, and appends it to the group padded by the spacing the item asks for. Returns the new widget, which the group also keeps in its widget list. |
| fn | `PopulateTextedPoints`Content | `(out BulletPoints: Struct_UI_Enumerator[], out Bullet Points: WBP_EnumeratorItem[])` | Rebuilds the list from the entries handed in, clearing everything already in the group first and recording the entries as the widget's own content. Hands back the item widgets it created, in order. |
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |
| event | `WidgetElement_InitialConstruct`Construct | `()` | Called on every element while the owning widget pre-constructs in the editor, immediately before the design-time theme pass. Implement it for preview-only set-up; it never runs in a running game. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

### Widgets/Display/Enumerator/Helper

**WBP_EnumeratorItem**4 members

extends `WBP_Base`

One row of an enumerated list: the marker and the line of text, laid out in an overlay so the text starts at the same offset however wide the marker is. The enumerator group creates one per entry; there is rarely a reason to place it yourself.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Enumerator`Content | `Struct_UI_Enumerator` | Entry the item shows, carrying the marker written on the left and the line of text that follows it. The enumerator list hands it in on spawn without applying it, so the item shows the designer's placeholder until Update Content runs. |
| var | `Spacing`Style | `float` | Gap in slate units between the marker and the text, applied as left padding on the text laid over it. It only reaches the layout through Update Spacing; until then the item keeps the eighty units set in the designer. |
| fn | `UpdateSpacing`Style | `(Spacing: float)` | Records the gap and applies it as left padding on the text, moving the line further from or closer to its marker. Call it yourself after creating an item; the value handed in on spawn is never applied by itself. |
| fn | `UpdateContent`Content | `(Enumerator: Struct_UI_Enumerator)` | Records the entry and writes its two halves out: the marker into the left-hand label and the line of text into the one laid over it. Nothing in the list calls it for you, so call it after creating an item. |

### Widgets/Display/Error

**WBP_Error**4 members

extends `WBP_Base`

Slot with an error line beneath it. Show Error fades the message in, fades it away again when the text is empty, and does nothing when the message has not changed; if the widget is replicating, the text goes out to the other clients too. Put your content in the Error slot and call Show Error when validation fails.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Error Text`Title | `text` | Message currently carried by the widget. Show Error compares against it and does nothing when the text is unchanged, so the default reads as an already shown message until it is replaced. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `ShowError` | `(Text: text)` | Shows a message under the slot content, or clears it when the text is empty: the appear animation runs forwards for a message and backwards for none, and the label is written 0.15 seconds later so the text changes out of sight. Repeating the text already shown does nothing. |
| event | `WidgetElement_ExecuteReplication`Replication | `(ReplicationIdentifier: name, Content: string[])` | Called on the other clients when a replicated value arrives for this element, carrying the identifier and its content strings. Implement it to reflect a change another player made; it is skipped on the client that sent the value. |

### Widgets/Display/Fallback

**WBP_Fallback**5 members

extends `WBP_Base`

Slot that swaps its content for a line of replacement text when there is nothing to show. Show Replacement Text switches the two over and Update Replacement Text sets the wording; the Show Replacement tick previews the swap while you are designing. Put the real content in the Fallback slot.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Show Replacement`Demo | `bool` | Preview flag for the designer, deciding which of the two states you want to look at. Nothing reads it at runtime, where the choice is made by Show Replacement Text. |
| var | `Replacement Text`Content | `text` | Message shown in place of the slot content once the widget has switched over. It reaches the label only through Update Replacement Text, so a value typed here alone never appears. |
| fn | `UpdateReplacementText`Content | `(Text: text)` | Records the replacement message and writes it straight into the label. The label is not re-measured for emptiness, so an empty text leaves an empty line rather than collapsing. |
| fn | `ShowReplacementText`Content | `(Show: bool)` | Switches between the slot content and the replacement message. The change is immediate, with no fade between the two. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |

### Widgets/Display/Indicator

**WBP_Indicator**10 members

extends `WBP_Base`

Badge overlaying a count on whatever sits in its slot, placed on its own canvas by Anchors, Position and Alignment. Update Number pops it with a scale animation and only when the value has actually changed, Show fades the badge in and out, and the number blends to stay legible against the badge behind it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Color`Content | `ST_Color_Definition` | Theme colour definition the badge and its number take. It is applied by Update Colour, so setting it alone repaints nothing and the badge keeps the colour set in the designer. |
| var | `Number`Content | `int` | Count shown in the badge. Update Number writes it and ignores a repeat of the value already held, so the pop animation only plays on a real change. |
| var | `Anchors`Canvas | `Anchors` | Anchor box the badge takes inside the indicator's canvas. Exposed on spawn together with Position and Alignment, though the indicator does not push any of the three onto the canvas slot itself. |
| var | `Position`Canvas | `Vector2D` | Offset in slate units of the badge from its anchor. Exposed on spawn together with Anchors and Alignment, and likewise not applied to the canvas slot by the indicator itself. |
| var | `Alignment`Canvas | `Vector2D` | Pivot of the badge within its own bounds, 0 to 1 on each axis, where one and one pins its bottom right corner to the anchor. Exposed on spawn alongside Anchors and Position and, like them, not applied by the indicator itself. |
| fn | `UpdateNumber`Content | `(Number: int)` | Writes a new number into the badge and plays the pop animation that scales it briefly up and back. A repeat of the number already shown is dropped, so nothing flashes. |
| fn | `UpdateColor`Content | `(BackgroundColor_Normal: ST_Color_Definition)` | Recolours the badge, painting the rounded border and driving the number's automatic blend from the same definition so the digits stay legible against it. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `Show` | `(Value: bool)` | Fades the badge in or out, running the show animation forwards or backwards. Repeating the state it is already in does nothing. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

### Widgets/Display/Loader

**WBP_LoadingSwitcher**8 members

extends `WBP_Base`

Slot that cross-fades between its content and a circular throbber while something loads. Set Loading plays the fade in either direction and ignores repeats, and a replacement line can be shown in place of the content when there is nothing to display. The Show Loading tick previews the loading state while you are designing.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Loading`State | `bool` | Whether the throbber rather than the slot content is currently showing. Set Loading compares against it and only cross-fades on a real change, so drive it through that rather than writing it directly. |
| var | `Show Loading`Demo | `bool` | Preview flag for the designer, deciding which of the two states you want to look at. Nothing reads it at runtime, where the choice is made by Set Loading. |
| var | `Replacement Text`Content | `text` | Message shown over the content, typically an empty-result line such as no items found. It reaches the label only through Update Replacement Text. |
| fn | `ShowReplacementText`State | `(Show: bool)` | Fades the replacement message in or out by its opacity alone. The label keeps its place in the layout either way, so the content below does not move. |
| fn | `ShowLoadingVisuals`State | `(Loading: bool)` | Snaps between throbber and content by setting the two overlays' opacities outright. Use it to arrive in a state without the cross-fade Set Loading plays. |
| fn | `UpdateReplacementText`Content | `(Text: text)` | Records the replacement message and writes it into the label, which collapses itself when the text is empty so nothing is left holding space. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `SetLoading` | `(Value: bool)` | Cross-fades between the slot content and the throbber, forwards into the loading state and backwards out of it. Repeating the state it is already in does nothing. |

### Widgets/Display/Progressbar

**AFProgressbar_Circular**1 members

extends `AFProgressbar`

Progress bar drawn as a ring, 400 by 400 pixels by default. Percent, interpolation and theme colours behave as they do across the family; only the material differs. Use it where a bar would not fit, for a radial gauge or a loading dial.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns the dynamic material instance the bar is drawn with, given the theme and the desktop flag to choose between variants. Empty here; each bar shape overrides it, and without an override the theme pass sets an empty brush. |

**AFProgressbar_Horizontal**3 members

extends `AFProgressbar`

Progress bar filling from left to right, 500 by 20 pixels by default and the shape the sliders are built on. Corners rounds the ends from the theme's corner definition, and it swaps to a desktop material when the interface is drawn on screen rather than in the world.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Corners`Style | `ST_Corner_Definition` | Corner rounding for the ends of the bar, either a category the theme sizes or a custom size. Nothing in the horizontal bar passes it to its material, so setting it on its own changes nothing on screen. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns the dynamic material instance the bar is drawn with, given the theme and the desktop flag to choose between variants. Empty here; each bar shape overrides it, and without an override the theme pass sets an empty brush. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**AFProgressbar_Vertical**3 members

extends `AFProgressbar`

Progress bar filling from bottom to top, 20 by 500 pixels by default. Same corner definition and desktop material swap as the horizontal one. Use it for meters running up the edge of a panel, as the left-hand head-up display example does.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Corners`Style | `ST_Corner_Definition` | Corner rounding for the ends of the bar, either a category the theme sizes or a custom size. Nothing in the vertical bar passes it to its material, so setting it on its own changes nothing on screen. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns the dynamic material instance the bar is drawn with, given the theme and the desktop flag to choose between variants. Empty here; each bar shape overrides it, and without an override the theme pass sets an empty brush. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

### Widgets/Display/Progressbar/Parents

**AFProgressbar**10 members

extends `AFSExtendedImage` · implements `BPI_WidgetElement`

Root of the progress bar family: an image drawn with a material whose fill it drives from Percent, between 0 and 1, with foreground and background colours taken from the theme and re-applied whenever the theme changes. Update Percent can interpolate towards the new value at Interp Speed rather than jumping. Take one of the three shapes, or subclass it and return a material of your own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Percent`State | `float` | Target fill of the bar, 0 for empty and 1 for full. Drive it through Update Percent; written on its own it moves nothing until the theme pass or Update Visuals pushes it into the material. |
| var | `Interp Speed`Style | `float` | Rate at which the drawn fill catches up with the target when Update Percent is asked to interpolate. The step runs every 11 milliseconds and stops once the two values are within a thousandth of each other. |
| var | `Color`Color | `ST_Color_Definition` | Colour definition of the filled part of the bar, resolved against the theme and written into the material's colour parameter. Reapplied on every theme change, and changing it takes effect only through Update Colour. |
| var | `Color Background`Color | `ST_Color_Definition` | Colour definition of the unfilled part behind the bar, resolved against the theme and written into the material's second colour parameter. It reaches the material only through Update Background Colour or the theme pass. |
| fn | `UpdateVisuals`Visuals | `(Percent: float)` | Writes the fill handed in straight into the material's percentage parameter and records it as the value currently drawn. This is the step that actually moves the bar, so calling it directly jumps rather than eases. |
| fn | `UpdateBackgroundColor`Color | `(Color: ST_Color_Definition)` | Records the colour definition and resolves it into the material's second colour parameter, repainting the part of the bar that is not filled. Nothing reaches the material before a theme has been handed in. |
| fn | `UpdateColor`Color | `(Color: ST_Color_Definition)` | Records the colour definition and resolves it into the material's colour parameter, repainting the filled part of the bar. The material is only touched once a theme has been handed in, so it is safe to call early. |
| fn | `CreateMaterial`Material | `(Theme: BP_PDA_Theme, Desktop: bool, out Material: MaterialInstanceDynamic)` | Returns the dynamic material instance the bar is drawn with, given the theme and the desktop flag to choose between variants. Empty here; each bar shape overrides it, and without an override the theme pass sets an empty brush. |
| event | `UpdatePercent` | `(NewValue: float, Interpolate: bool)` | Sets the target fill and either moves the bar there at once or starts the interpolation timer that eases it across at Interp Speed. The way in from outside; the bar stays where it is until this is called. |
| event | `InterpolationTick` | `()` | Internal timer step that eases the drawn fill towards the target at Interp Speed, running every 11 milliseconds while an interpolated Update Percent is in flight. Clears its own timer once the target is reached. |

### Widgets/Display/Tag

**WBP_Tag**6 members

extends `WBP_Base`

Small rounded label: a line of text on a coloured pill, taking its colour from a colour data asset rather than from the theme, with the text blended to stay readable against it. Carries its own tooltip anchor, so the widget base's tooltip settings work on it. Drop it in for statuses, categories and chips.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Text`Content | `text` | Label carried by the tag. Update Text writes it into the text block; setting it alone leaves the tag showing whatever the designer put there. |
| var | `Color`Content | `PDA_Color` | Colour asset the tag is filled with, applied as a custom colour at medium intensity rather than through the theme palette. Update Colour is what pushes it to the border and the label. |
| fn | `UpdateColor`Style | `(Manual Color: PDA_Color)` | Repaints the tag in a colour asset, filling the rounded border with it and blending the label to match so the text stays readable on the fill. |
| fn | `UpdateText`Content | `(Text: text)` | Records the label and writes it into the tag's text block. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

### Widgets/Display/Tooltip

**WBP_Tooltip_Default**4 members

extends `WBP_Tooltip`

The framework's standard tooltip: text in a rounded panel up to 400 pixels wide, fading in from above or below to match the placement it was given. The main button styles all name it as their tooltip class, so setting Tool Tip Text on one of them is enough; subclass it, or start from the tooltip base, to design your own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getShowAnimation`Animations | `(out Animation: WidgetAnimation)` | Returns the appear animation matching the placement the tooltip was spawned with, rising for the three below placements and falling for the three above ones. The combo box, centre and side placements return nothing, so a tooltip placed that way has no animation to play. |
| event | `ShowTooltip` | `()` | Called by the owning widget as its anchor pops the tooltip. Left empty in this design, so not even the base widget's shown flag is set; hook it up if your tooltip has to play its appear animation. |
| event | `HideTooltip` | `()` | Called by the owning widget when the tooltip is dismissed. Left empty in this design, so the shown flag the base widget keeps is never cleared either. |
| event | `UpdateText` | `(Text: text)` | Called to change the tooltip's wording while it is up. Left empty in this design, so the text handed in is dropped and the label keeps what it was given in the designer. |

### Widgets/Display/Tooltip/Parents

**WBP_Tooltip**5 members

extends `WBP_Base`

Base for tooltips. Holds the text, the placement and whether it is currently shown; the widget base creates one from a widget's Tool Tip Class when the tooltip anchor opens, then calls Show Tooltip, Hide Tooltip and Update Text on it. No visuals of its own, so subclass it for a tooltip of your own design and use the default variant otherwise.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Text`Content | `text` | Wording the tooltip is created with, taken from the owning widget's Tool Tip Text as the anchor builds it. Held here only; each tooltip design decides what to write it into, and Update Text is the way to change it later. |
| var | `Placement`Style | `EMenuPlacement` | Where the tooltip is meant to sit against the widget it belongs to, centred below by default. Nothing on this parent acts on it; the default tooltip reads it to pick between its rising and falling appear animations. |
| event | `HideTooltip` | `()` | Clears the shown flag again. Nothing in the framework calls it, so dismissing a tooltip is left to whatever opened it, and no design here plays a disappear animation. |
| event | `UpdateText` | `(Text: text)` | Replaces the stored wording while the tooltip is up. It records the text and no more; nothing writes it into a label, so a design has to override this for the change to show. |
| event | `ShowTooltip` | `()` | Called by the owning widget as its anchor pops the tooltip open. Raises the shown flag and does nothing else, so a design that has to play an appear animation overrides it. |

### Widgets/Display/Tree/Elements

**WBP_TreeElement**2 members

extends `WBP_Base`

Base for a widget standing in for one object in a tree. Carries the object it represents and the reference object the tree was built around, and nothing more. It is the class the tree element contract hands back, so subclass it to give the row a layout.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Tree Object` | `Object` | Object this element stands for, handed in as the tree creates it. The base element carries no logic at all, so what is read out of the object is entirely up to the design you build on top of it. |
| var | `Reference Object` | `Object` | Object the tree was drawn against, handed to every element so a row knows the context it appears in as well as the object it stands for. Empty unless the tree was drawn with one. |

### Widgets/Display/Tree/ExpandTree

**WBP_ExpandTree**2 members

extends `WBP_Base`

Container building a tree of collapsible rows. Draw Tree empties the vertical group and creates one widget of Tree Item Class per object it is given, passing each the object, the reference object and the tree itself so an item can go on to build its own children. Drop it in, set the item class and call Draw Tree.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Tree Item Class` | `class<WBP_Expandable_TreeItem>` | Row class Draw Tree builds one of for every object it is given, expected to be an expandable tree item so that the object, the tree and the reference object can be handed to it on spawn. Leave it empty and Draw Tree clears the tree and builds nothing. |
| event | `DrawTree` | `(ReferenceObject: Object, TreeObjects: Object[])` | Empties the vertical widget group and rebuilds it with one row per object handed in, each spawned with the object it stands for, a reference back to this tree and the shared reference object. Only this one level is built; a row fills its own group for the level below. |

### Widgets/Display/Tree/ExpandTree/Elements

**WBP_Expandable_TreeItem**6 members

extends `WBP_Expandable`

Base for one row of an expanding tree: an expandable header holding the object it stands for, the reference object and the tree it belongs to. Take the default variant, or subclass it and return the group its child rows are added to and the named slot its header content fills.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Tree Object`References | `Object` | Object this row stands for, handed in by the tree as the row is created. Nothing in the framework reads it; it is there for your row design to draw the object's own header and children from. |
| var | `Tree`References | `WBP_ExpandTree` | Reference back to the tree that created this row, set on spawn. Nothing in the framework reads it afterwards, so it is there for a row that has to ask its tree to redraw or to reach a sibling. |
| var | `Reference Object`References | `Object` | Object the tree was drawn against, passed unchanged to every row, so a row knows the context it is being shown in as well as the object it stands for. Empty unless the tree was drawn with one. |
| fn | `getHeaderSlot`Get Elements | `(out Header Slot: NamedSlot)` | Returns the slot the row's header content is placed in, beside the expand arrow. Empty on this parent; each row design overrides it with the slot from its own designer tree. |
| fn | `getGroupWidget`get Elements | `(out Widget Group: WBP_Group_Widget)` | Returns the group the rows of the level below are added to. Empty on this parent; the default row overrides it with the vertical widget group inside its content slot, and a row that answers nothing has nowhere to put children. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

**WBP_Expandable_TreeItem_Default**9 members

extends `WBP_Expandable_TreeItem`

Ready-made tree row: an arrow button expanding and collapsing the area beneath it, a header slot for the row's own content and a vertical group holding its children. Nothing references it, so it is a starting point rather than something already in use — name it as an expanding tree's item class, or subclass it to change the look.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getGroupWidget`get Elements | `(out Widget Group: WBP_Group_Widget)` | Returns the group the rows of the level below are added to. Empty on this parent; the default row overrides it with the vertical widget group inside its content slot, and a row that answers nothing has nowhere to put children. |
| fn | `getHeaderSlot`Get Elements | `(out Header Slot: NamedSlot)` | Returns the slot the row's header content is placed in, beside the expand arrow. Empty on this parent; each row design overrides it with the slot from its own designer tree. |
| fn | `getButton`Get Elements | `(out Button: WBP_Button)` | Returns the header button whose selected state is kept in step with the expansion. Empty here, and a variant with no header button can leave it that way, since Set Expanded checks it first. |
| fn | `getAnimation`Expandable | `(out Animation: WidgetAnimation)` | Returns the animation played alongside the area's roll-out, forwards when opening and backwards when closing. Empty here; each variant overrides it with its own. |
| fn | `getExpandableWidget`Expandable | `(out Expandable: ExpandableArea)` | Returns the expandable area the widget wraps, which Set Expanded opens and shuts with its animated roll-out. Empty here; each variant overrides it with the area from its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| fn | `WidgetElement_getCustomChildWidgets`Slots | `(out Widgets: Widget[])` | Returns child widgets the tree walk would not otherwise reach, typically ones held in a variable rather than in the slot hierarchy. Listing them here is what gets them initiated, themed and cleaned up along with the rest of the tree. |
| event | `Deactivate`State | `(Set: bool)` | Records that the expandable should stop responding. Nothing in the framework reads the flag afterwards, so it stands as a marker for your own widget to act on, and the default variant overrides the call with an empty body. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

### Widgets/Display/Tree/PageTree

**WBP_PageTree**2 members

extends `WBP_Base`

Container showing a tree one page at a time rather than expanding it in place, holding the pages in a switcher and building them from Page Class. Nothing in the shipped content uses it and it has no navigation of its own, so treat it as the skeleton for a drill-down browser you finish yourself.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Page Class` | `class<WBP_PageTree_Page>` | Page class a page tree is meant to build each level from. Nothing reads it as the widget stands, since Draw Tree is empty, so it is a hook for your own page tree rather than a setting that changes anything. |
| event | `DrawTree` | `()` | Entry point where a page tree would build its first page and push it into the switcher. Empty as it stands, so the switcher shows only what the designer placed in it until you fill this in. |

### Widgets/Display/Tree/PageTree/Elements

**WBP_PageTree_Page**3 members

extends `WBP_Base`

One page of a page tree: a group filled with widgets of Tree Item Class, plus a back delegate for stepping up to the page above. The page tree creates it from its page class, and the group is left for a subclass to supply, so expect to subclass it rather than place it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Tree Item Class` | `class<WBP_Expandable_TreeItem>` | Row class a page is meant to build its entries from, expected to be an expandable tree item. Nothing in the page reads it, so it stands as a hook for your own page design rather than a setting that builds anything. |
| fn | `getWidgetGroup`getElements | `(out OutputPin: WBP_Group)` | Returns the group a page's rows are added to. Answers nothing on this parent, so override it with the group from your own page's designer tree before anything can be placed in it. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

### Widgets/Input/Buttons

**WBP_Button**61 members

extends `WBP_Base` · implements `UserObjectListEntry`

Base class for every button in the framework. Owns the pressed, hovered, selected, custom and deactivated states, the repress gate, the sound and animation hooks and the content struct feeding its text and icon, and it can bind itself to a boolean or trigger value object. Subclass it by overriding the frame, sound, animation and blendable-element getters; it has no visuals of its own, and the shipped variants are all subclasses.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Selected`State | `bool` | Whether the button currently reads as selected. Drive it through Set Button Selected so the action animation, the blended label and any bound value object stay in step; writing to it directly changes nothing on screen. |
| var | `Deactivated`State | `bool` | Whether the button refuses input. While set, hover, press, release and click are all dropped and a press plays the blocked sound instead; switch it through Deactivate Button, which also runs the deactivate animation. |
| var | `Preset`Design | `E_UI_Hierarchy` | Emphasis level the design draws itself at, primary through quaternary. It selects the theme colours and, on most designs, the press sound; change it through Set Preset or Update Button Preset so the theme is re-applied. |
| var | `Custom State`State | `bool` | Second, design-defined state that is independent of selection and deactivation. It drives the custom animation and broadcasts On Custom State Changed; set it through Set Custom State. |
| var | `Manual Set`Manual Set | `bool` | Whether a click is handed to the owner instead of acted on locally. Left on, a click only tells the owning list item's button object that it was pressed and the owner decides what gets selected; switch it off to let the button toggle its own selection. |
| var | `Not Hoverable when Selected`Manual Set | `bool` | Whether a selected button stops responding to hover. It also gates the selection broadcast: On Selection Changed and the replicated button state are only sent when this is set and the button has just become selected. |
| var | `Sound Press Override`Sound | `SoundBase` | Sound played instead of the design's own press cue. Leave empty to use the cue the button design supplies for the current preset. |
| var | `Sound Hover Override`Sound | `SoundBase` | Sound played instead of the design's own hover cue when the cursor first enters. Leave empty to use the cue the button design supplies. |
| var | `Sound Blocked Override`Sound | `SoundBase` | Sound played instead of the design's own blocked cue when a deactivated button is pressed. Leave empty to use the cue the button design supplies. |
| var | `Button Repress Time`Settings | `float` | Lockout in seconds after a press or a click, during which further input of that kind is dropped. Press and click are gated separately, each with its own timer. |
| var | `Content Widget Class`Content | `class<WBP_ButtonContent>` | Content widget spawned into the button's slot for designs that carry more than a single label and icon. Leave empty to let the button draw its content into its own text and image elements. |
| var | `Content`Content | `ST_Button_Content` | Identifier, texts and images the button shows. Entry 0 is the resting label and entry 1 the label shown once selected; push changes in through Update Button Content, since writing here does not refresh the elements. |
| var | `Max Text Length`Content | `int` | Character limit for the blended label, past which the text is cut and an ellipsis appended. Leave at 0 for no limit; it only bites on designs that blend between two labels. |
| var | `Width Override`Dimension | `ST_SizeOverride` | Fixed width applied to the frame's size box by Style Button Frame. Leave the override switched off to take the width from the button design and the surrounding layout. |
| var | `Height Override`Dimension | `ST_SizeOverride` | Fixed height applied to the frame's size box by Style Button Frame. Leave the override switched off to take the height from the button design and the surrounding layout. |
| fn | `getButtonID`Content | `(out ID: name)` | Returns the identifier carried by the button's content. Button groups use it to track selection by name rather than by index, and it stays None unless the content was given one. |
| fn | `getBlendableElements_Custom`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the custom state animation. Empty on the base class, and most designs leave it that way. |
| fn | `getBlendableElements_Action`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the action animation, typically the background, icon and label that shift as the button is selected. Empty on the base class; each button design overrides it. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getTextWithIndex`Content | `(Index: int, out Text: text)` | Returns the text held at the given position in the button's content, or empty text when that position does not exist. |
| fn | `getImageWithIndex`Content | `(Index: int, out Texture: Texture)` | Returns the image held at the given position in the button's content, or nothing when that position does not exist. |
| fn | `UpdateAnimation_Custom`Animation | `()` | Pushes the current custom state blend value into every blendable element of the design and into the content widget. Called from the custom animation's event track rather than by hand. |
| fn | `UpdateAnimation_Hover`Animation | `()` | Pushes the current hover blend value into every blendable element of the design and into the content widget. Called from the hover animation's event track rather than by hand. |
| fn | `UpdateAnimation_Action`Animation | `()` | Pushes the current action blend value into every blendable element of the design and into the content widget, then re-checks the blended label. Called from the action animation's event track rather than by hand. |
| fn | `CheckBlendableText`Content | `()` | Swaps the label between content entry 0 and entry 1 as the action animation crosses its halfway point, trimming the result to Max Text Length. Does nothing unless the design has blendable text switched on and a second entry exists. |
| fn | `UpdateButtonContent`Content | `(ButtonContent: ST_Button_Content)` | Replaces the button's content and refreshes the label, the icon and the content widget from it. The chain runs through the text element first and the image element second, so a design missing either updates nothing beyond that point. |
| fn | `getButtonSlot`Get Elements | `(out Slot: NamedSlot)` | Returns the named slot the content widget is placed into. Empty on the base class; only designs built around a content widget override it. |
| fn | `getButtonImage`Get Elements | `(out Button Image: AFImage)` | Returns the image element the icon is written into. Empty on the base class; designs override it, and Update Button Content stops before forwarding content to the content widget when there is none. |
| fn | `getButtonText`Get Elements | `(out Button Text: AFText)` | Returns the text element the label is written into. Empty on the base class; designs override it, and Update Button Content stops before touching anything else when there is none. |
| fn | `WidgetElement_getCustomChildWidgets`Slots | `(out Widgets: Widget[])` | Returns child widgets the tree walk would not otherwise reach, typically ones held in a variable rather than in the slot hierarchy. Listing them here is what gets them initiated, themed and cleaned up along with the rest of the tree. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Custom`Get Animations | `(out CustomStateAnimation: WidgetAnimation)` | Returns the animation run forwards when the custom state is switched on and reversed when it is switched off. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `SetPreset`Design | `(Preset: E_UI_Hierarchy)` | Sets the emphasis level and immediately re-applies the theme, so the design repaints in the new preset's colours. Does the same work as Update Button Preset, which is the event form button groups use. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `On_Pressed` | `()` | Called when the underlying button reports a press. Reports the press position to the widget component, then either plays the blocked cue while deactivated or, once the repress lockout allows, marks the button down, plays the press cue, broadcasts On Pressed and runs the click animation. Nothing runs without a widget component. |
| event | `OnHovered_Event_0` | `()` | Called when the cursor enters the button. Runs the hover animation, records the hover, broadcasts On Hovered and plays the hover cue; skipped while the button is deactivated, already hovered, or selected with Not Hoverable When Selected set. |
| event | `OnUnhovered_Event_0` | `()` | Called when the cursor leaves the button. Reverses the hover animation, clears the hover and broadcasts On Unhovered; skipped while the button is deactivated or was never hovered. |
| event | `SetButtonSelected` | `(Set: bool)` | Sets the selected state and drives the action animation towards it. Nothing happens when the value is unchanged, and note that forcing the hover off, On Selection Changed and the replicated button state only follow when the button has just become selected and Not Hoverable When Selected is set. |
| event | `DeactivateButton` | `(Set: bool)` | Switches the button between deactivated and active and drives the deactivate animation towards the new state. Forces any hover off, then broadcasts On Deactivated or On Activated; ignored when the value is unchanged. |
| event | `ToggleButtonSelection` | `()` | Flips the selected state through Set Button Selected. A click reaches it when Manual Set is off, and it is safe to call from your own logic. |
| event | `ForceUnhover` | `()` | Drops the hover without waiting for the cursor to leave, reversing the hover animation and broadcasting On Unhovered. Used when a button is deactivated, or becomes selected and is not hoverable, while the cursor still rests on it. |
| event | `SetCustomState` | `(Set: bool)` | Sets the design-defined custom state, drives the custom animation towards it and broadcasts On Custom State Changed. Ignored when the value is unchanged. |
| event | `WidgetElement_ExecuteReplication`Replication | `(ReplicationIdentifier: name, Content: string[])` | Called on the other clients when a replicated value arrives for this element, carrying the identifier and its content strings. Implement it to reflect a change another player made; it is skipped on the client that sent the value. |
| event | `ToggleCustomState` | `()` | Flips the custom state through Set Custom State, so the design's custom animation runs in the opposite direction. |
| event | `On_Released` | `()` | Called when the underlying button reports a release. Clears the down state, broadcasts On Released and reverses the click animation; skipped while the button is deactivated or when no press ever registered. |
| event | `AssignBooleanObject` | `(Target: Object, UseContent: bool, ApplyValue: bool)` | Binds the button to a boolean value object so the two follow each other from then on. Set Apply Value to push the button's current selection into the object; leave it off to adopt the object's value instead. Use Content takes the object's false and true labels as content entries 0 and 1. |
| event | `OnValueUpdated_Event` | `()` | Internal handler that pulls the bound value object's boolean back into the button's selection whenever that object reports a change. |
| event | `OnPressed_Event` | `(Button: WBP_Button)` | Internal handler bound by Assign Boolean Object that toggles the bound object's boolean on every press, tagged with the widget's Source Info. |
| event | `OnPressed_Event_0` | `(Button: WBP_Button)` | Internal handler bound by Assign Trigger Object. It toggles the target's boolean rather than firing its trigger, so the assigned target has to answer the boolean value contract as well. |
| event | `AssignTriggerObject` | `(Target: Object, UseContent: bool)` | Binds the button to a trigger value object and forwards presses to it. Use Content takes the object's trigger text as the button's only content entry; be aware that the handler it binds toggles the target's boolean rather than calling its trigger. |
| event | `On_Clicked` | `()` | Called when the underlying button reports a full click. Once the repress lockout allows, broadcasts On Clicked and then either tells the owning list item's button object it was pressed, when Manual Set is on, or toggles the button's own selection. Skipped while the button is deactivated. |
| event | `StyleButtonFrame` | `()` | Applies the width and height overrides to the button frame. Runs when a list entry takes its settings from a button object; call it yourself after changing either override at runtime. |
| event | `OnSelectionChanged_Event` | `()` | Internal handler that mirrors the owning button object's selected state onto the button whenever that object reports a change. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |
| event | `UpdateButtonPreset` | `(Preset: E_UI_Hierarchy)` | Sets the emphasis level and re-applies the theme, so the design repaints in the new preset's colours. Does the same work as Set Preset; button groups use this form to restyle their buttons in bulk. |

**WBP_ButtonContent**18 members

extends `WBP_Base`

Swappable inner content for a button. It carries the same content struct as the button that owns it and is handed the hover, action and custom state as both animations and blend values, so a button's frame and its contents can react separately. Subclass it and name the subclass as a button's Content Widget Class when text and an icon are not enough.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Button Content`Content | `ST_Button_Content` | Identifier, texts and images this content widget draws from. The owning button fills it through Update Button Content, so there is rarely any need to edit it once the button has content. |
| var | `Owning Button`References | `WBP_Button` | Button this content widget belongs to. The state handlers read the selection, hover and custom state straight off it, so none of the animations move while it is empty. |
| fn | `getAnimation_Custom`Animations | `(out Custom: WidgetAnimation)` | Returns the animation played while the owning button's custom state is on. Empty on the base content widget; each content design overrides it with its own. |
| fn | `getAnimation_Hover`Animations | `(out Hover: WidgetAnimation)` | Returns the animation played while the owning button is hovered. Empty on the base content widget; each content design overrides it with its own. |
| fn | `OnCustomStateChanged`State | `(Button: WBP_Button)` | Called when the owning button's custom state changes. Drives the custom animation towards the button's new state. |
| fn | `OnHovered`State | `(Button: WBP_Button)` | Called when the owning button is hovered or unhovered. Drives the hover animation towards the button's current hover state, so the one handler serves both directions. |
| fn | `OnSelectionChanged`State | `(Button: WBP_Button)` | Called when the owning button's selection changes. Drives the action animation towards the button's new selected state. |
| fn | `getImageWithIndex`Content | `(Index: int, out Texture: Texture)` | Returns the image held at the given position in this widget's content, or nothing when that position does not exist. |
| fn | `getTextWithIndex`Content | `(Index: int, out Text: text)` | Returns the text held at the given position in this widget's content, or empty text when that position does not exist. |
| fn | `getAnimation_Action`Animations | `(out Action: WidgetAnimation)` | Returns the animation played while the owning button is selected. Empty on the base content widget; each content design overrides it with its own. |
| event | `UpdateButtonContent` | `(ButtonContent: ST_Button_Content)` | Called by the owning button when its content changes, to store that content here. Override it in a content design to also write the texts and images into your own elements. |
| event | `UpdateHoverBlend` | `(Percent: float)` | Called by the owning button whenever its hover blend value moves, in the range 0 to 1. Empty here; implement it in a content design to drive your own elements from that blend. |
| event | `UpdateActionBlend` | `(Percent: float)` | Called by the owning button whenever its selection blend value moves, in the range 0 to 1. Empty here; implement it in a content design to drive your own elements from that blend. |
| event | `UpdateHoverAnim` | `(Set: bool)` | Runs this widget's hover animation forwards or reverses it. Driven by the owning button's hover handler rather than called directly. |
| event | `UpdateActionAnim` | `(Set: bool)` | Runs this widget's action animation forwards or reverses it. Driven by the owning button's selection handler rather than called directly. |
| event | `UpdateCustomAnim` | `(Set: bool)` | Runs this widget's custom animation forwards or reverses it. Driven by the owning button's custom state handler rather than called directly. |
| event | `UpdateCustomBlend` | `(Percent: float)` | Called by the owning button whenever its custom state blend value moves, in the range 0 to 1. Empty here; implement it in a content design to drive your own elements from that blend. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

**WBP_ButtonFrame**2 members

extends `UserWidget` · implements `BPI_WidgetElement`

Clickable frame every button variant is built around: a size box wrapping an invisible Slate button whose named slot holds the button's visuals. It applies the width and height overrides and exposes that slot to the widget element walk. Put it at the root of a button subclass; it does nothing beyond sizing and taking the click.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `SetHeightOverride`Dimensions | `(HeightOverride: ST_SizeOverride)` | Applies a fixed height to the frame's size box, or releases the height again when the override is switched off. The button calls it from Style Button Frame with its own Height Override. |
| fn | `SetWidthOverride`Dimensions | `(WidthOverride: ST_SizeOverride)` | Applies a fixed width to the frame's size box, or releases the width again when the override is switched off. The button calls it from Style Button Frame with its own Width Override. |

### Widgets/Input/Buttons/Content

**WBP_ButtonContent_Card_Default**3 members

extends `WBP_ButtonContent`

Two-line card content for a button, a title above a body line, both drawn from the owning button's content struct and following its hover and action blends. Name it as a card button's Content Widget Class, as the navigation page does, or copy it as the pattern for content of your own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| event | `UpdateActionBlend` | `(Percent: float)` | Overridden here with an empty body, so nothing in the card's content follows the selection blend. The card's own border and background do the moving; override this in a design of your own to bring the title and body along. |
| event | `UpdateHoverBlend` | `(Percent: float)` | Overridden here with an empty body, so nothing in the card's content follows the hover blend. The hover look lives on the card button rather than on its content. |
| event | `UpdateButtonContent` | `(ButtonContent: ST_Button_Content)` | Stores the content through the parent and then writes it into this design's two labels: the first text becomes the title and the second the body. A card with only one text entry therefore shows an empty body rather than falling back to the title. |

### Widgets/Input/Buttons/Main

**WBP_Button_Arrow**11 members

extends `WBP_Button`

Chevron button for stepping and expanding: an icon in a button frame with an editable angle and size, so one asset serves up, down, left and right. Carries the arrow sound set. Drop it in wherever a bare directional control is wanted; the expandables and the vertical scrollable field already use it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Angle`Design | `float` | Angle the whole arrow is turned by, in degrees, applied as a render transform in Pre Construct. One widget rotated four ways rather than four arrow designs, and it reads correctly in the designer. |
| var | `Size`Design | `float` | Side length the arrow icon is drawn at, applied as a desired size override in Pre Construct. Both dimensions take this one number, so the icon stays square. Eighty by default. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**WBP_Button_Card_Left**19 members

extends `WBP_Button`

Card button with its image on the left and a named slot beside it for whatever the card should show. Fill that slot yourself, or feed image and text through the button content struct; an outline marks selection and a separate border follows the pointer. Use it for menu and list entries that need more than a label.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Custom`Get Animations | `(out CustomStateAnimation: WidgetAnimation)` | Returns the animation run forwards when the custom state is switched on and reversed when it is switched off. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getBlendableElements_Action`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the action animation, typically the background, icon and label that shift as the button is selected. Empty on the base class; each button design overrides it. |
| fn | `getButtonImage`Get Elements | `(out Button Image: AFImage)` | Returns the image element the icon is written into. Empty on the base class; designs override it, and Update Button Content stops before forwarding content to the content widget when there is none. |
| fn | `getButtonSlot`Get Elements | `(out Slot: NamedSlot)` | Returns the named slot the content widget is placed into. Empty on the base class; only designs built around a content widget override it. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays, and hands off to Update Animation Hover, which pushes the current hover blend into the elements Get Blendable Elements Hover returns. |
| event | `SequenceEvent_Custom` | `()` | Called from the custom animation's event track as it plays, and hands off to Update Animation Custom, which pushes the current custom blend into the elements that follow it. This is the card family's third state, the one a design is free to mean whatever it likes by. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays, and hands straight off to Update Animation Action, which pushes the current action blend into whatever Get Blendable Elements Action returns. The card designs go through that inherited helper rather than naming their elements one at a time. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**WBP_Button_Card_Top**16 members

extends `WBP_Button`

Card button with its image above the content rather than beside it, otherwise the left-hand card's twin: a named slot for the body, a selection outline and a hover border. Nothing in the shipped content uses it, so it stands as the vertical alternative to reach for when a card should read top to bottom.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getButtonImage`Get Elements | `(out Button Image: AFImage)` | Returns the image element the icon is written into. Empty on the base class; designs override it, and Update Button Content stops before forwarding content to the content widget when there is none. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonSlot`Get Elements | `(out Slot: NamedSlot)` | Returns the named slot the content widget is placed into. Empty on the base class; only designs built around a content widget override it. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getBlendableElements_Action`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the action animation, typically the background, icon and label that shift as the button is selected. Empty on the base class; each button design overrides it. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays, and hands off to Update Animation Action, which pushes the current action blend into the elements Get Blendable Elements Action returns. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays, and hands off to Update Animation Hover, which pushes the current hover blend into the elements Get Blendable Elements Hover returns. |

**WBP_Button_Checkbox**15 members

extends `WBP_Button`

Checkbox: a square tick box beside a label, the tick fading in as the button becomes selected, with different sounds for switching on and off. It is a button like any other, so bind it to a boolean value object or listen for the selection change. Use it for independent options rather than a set where only one may be chosen.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getBlendableElements_Action`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the action animation, typically the background, icon and label that shift as the button is selected. Empty on the base class; each button design overrides it. |
| fn | `getButtonText`Get Elements | `(out Button Text: AFText)` | Returns the text element the label is written into. Empty on the base class; designs override it, and Update Button Content stops before touching anything else when there is none. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value into the gradient border, the tick icon and the label so they recolour in step with the tick. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value into the rounded hover border. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**WBP_Button_Color**16 members

extends `WBP_Button`

Swatch button holding one colour definition, drawn as a filled rounded square whose hover and selection borders auto-blend against the fill so a pale swatch stays legible. The colour group that owns it sets what it shows as it builds the row, so it is normally created for you rather than placed by hand.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Color`Content | `ST_Color_Definition` | Swatch colour the button shows, given as a theme colour definition. Push changes in through Update Colour, since writing here on its own repaints neither the swatch nor its selection ring. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value into the rounded hover border. |
| event | `UpdateColor` | `(Color: ST_Color_Definition)` | Stores the given colour and repaints the swatch with it: the outer rounded border is recoloured directly, and the inner selection ring has both ends of its auto blend set to that same colour so it keeps it right through the selection blend. This is the only way to change what the swatch shows. |
| event | `UpdateButtonContent`Content | `(ButtonContent: ST_Button_Content)` | Replaces the button's content and refreshes the label, the icon and the content widget from it. The chain runs through the text element first and the image element second, so a design missing either updates nothing beyond that point. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value out to the design's action elements, of which this one registers none, so the selection ring is carried by its own opacity track rather than by the blend. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**WBP_Button_Image**19 members

extends `WBP_Button`

Image button: a rounded picture with a caption beneath it and a named slot over the image for a badge or overlay of your own. 300 by 400 by default, and it truncates its caption at forty characters. Use it for thumbnail grids and pickers where the picture, not the text, is the label.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonSlot`Get Elements | `(out Slot: NamedSlot)` | Returns the named slot the content widget is placed into. Empty on the base class; only designs built around a content widget override it. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getBlendableElements_Action`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the action animation, typically the background, icon and label that shift as the button is selected. Empty on the base class; each button design overrides it. |
| fn | `getButtonText`Get Elements | `(out Button Text: AFText)` | Returns the text element the label is written into. Empty on the base class; designs override it, and Update Button Content stops before touching anything else when there is none. |
| fn | `getButtonImage`Get Elements | `(out Button Image: AFImage)` | Returns the image element the icon is written into. Empty on the base class; designs override it, and Update Button Content stops before forwarding content to the content widget when there is none. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value into the outline border, which is what marks the card as selected. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value into the rounded hover border. |
| event | `SequenceEvent_Custom` | `()` | Called from the custom animation's event track as it plays. Pushes the current custom state blend value out to the design's custom elements, of which this one registers none; note also that the card's custom animation is never handed back to the button, so nothing plays it unless you do. |
| event | `SequenceEvent` | `()` | Called from an animation event track and doing exactly what Sequence Event Hover does, pushing the current hover blend value into the hover border. A leftover second entry point; wire new tracks to the named one. |
| event | `UpdateButtonContent`Content | `(ButtonContent: ST_Button_Content)` | Replaces the button's content and refreshes the label, the icon and the content widget from it. The chain runs through the text element first and the image element second, so a design missing either updates nothing beyond that point. |

**WBP_Button_Large**18 members

extends `WBP_Button`

Square button with its icon above the text, 250 by 250 by default, taking fill and text colours from the hierarchy preset and blending them towards the active colour while selected. Use it for tile grids and launcher menus; the contract is the same as any other button, only the layout differs.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getBlendableElements_Action`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the action animation, typically the background, icon and label that shift as the button is selected. Empty on the base class; each button design overrides it. |
| fn | `getButtonText`Get Elements | `(out Button Text: AFText)` | Returns the text element the label is written into. Empty on the base class; designs override it, and Update Button Content stops before touching anything else when there is none. |
| fn | `getTextColor`Colors | `(out Color: ST_Color_Definition)` | Returns the label colour for the current preset: the theme's text colour at high intensity for the first two presets and the active colour at low intensity for the third. Left uncalled by the stock design, in the same way as Get Normal And Action Colour. |
| fn | `getNormalAndActionColor`Colors | `(out Main: ST_Color_Definition, out Action: ST_Color_Definition)` | Returns the pair of theme colours the tile is meant to be drawn in: a main colour following the preset, primary, secondary or transparent, and the active colour at high intensity for the selected state. Nothing in the stock design calls it, as its elements carry their own colour settings, so it is there for your own overrides. |
| fn | `getButtonImage`Get Elements | `(out Button Image: AFImage)` | Returns the image element the icon is written into. Empty on the base class; designs override it, and Update Button Content stops before forwarding content to the content widget when there is none. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value into the gradient border, the icon and the label, and re-checks the blended label along the way. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value into the rounded hover border. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**WBP_Button_Normal**18 members

extends `WBP_Button`

Standard rectangular button, an icon and a label in a gradient rounded frame, and the one to reach for unless something else fits better. The hierarchy preset picks its fill, its text colour and its press sound, and given two texts in the content struct it swaps label as it becomes selected. Most of the framework's own interfaces are built from it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getButtonText`Get Elements | `(out Button Text: AFText)` | Returns the text element the label is written into. Empty on the base class; designs override it, and Update Button Content stops before touching anything else when there is none. |
| fn | `getTextColor`Colors | `(out Color: ST_Color_Definition)` | Returns the label colour for the current preset: the theme's text colour at high intensity for the first two presets and the active colour at low intensity for the third. Left uncalled by the stock design, in the same way as Get Normal And Action Colour. |
| fn | `getNormalAndActionColor`Colors | `(out Main: ST_Color_Definition, out Action: ST_Color_Definition)` | Returns the pair of theme colours the button is meant to be drawn in: a main colour following the preset, primary, secondary or transparent, and the active colour at high intensity for the selected state. Nothing in the stock design calls it, as its elements carry their own colour settings, so it is there for your own overrides. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonImage`Get Elements | `(out Button Image: AFImage)` | Returns the image element the icon is written into. Empty on the base class; designs override it, and Update Button Content stops before forwarding content to the content widget when there is none. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getBlendableElements_Action`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the action animation, typically the background, icon and label that shift as the button is selected. Empty on the base class; each button design overrides it. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value into the gradient border, the icon and the label, and re-checks the blended label along the way. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value into the rounded hover border. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**WBP_Button_Radio**14 members

extends `WBP_Button`

Radio button: a round indicator beside a label, filling in as it becomes selected, with separate on and off press sounds. It enforces no exclusivity itself, so put several inside a button group set to single select to get the one-of-many behaviour the shape implies.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getButtonText`Get Elements | `(out Button Text: AFText)` | Returns the text element the label is written into. Empty on the base class; designs override it, and Update Button Content stops before touching anything else when there is none. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getBlendableElements_Action`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the action animation, typically the background, icon and label that shift as the button is selected. Empty on the base class; each button design overrides it. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value into the gradient ring and the inner dot so both recolour as the option is chosen. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value into the rounded hover border. |

**WBP_Button_Small**18 members

extends `WBP_Button`

Small round icon button, 120 by 120 with no label, taking its colours and press sound from the hierarchy preset. Use it where an icon alone says enough; the framework's own furniture does, as the stepper's two side buttons and the reveal toggle on the password field.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getBlendableElements_Action`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the action animation, typically the background, icon and label that shift as the button is selected. Empty on the base class; each button design overrides it. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonImage`Get Elements | `(out Button Image: AFImage)` | Returns the image element the icon is written into. Empty on the base class; designs override it, and Update Button Content stops before forwarding content to the content widget when there is none. |
| fn | `getTextColor`Colors | `(out Color: ST_Color_Definition)` | Returns a label colour for the current preset, the theme's text colour at high intensity for the first two presets and the active colour at low intensity for the third. This design carries no label at all and nothing calls it, so it is only of use to a subclass that adds one. |
| fn | `getNormalAndActionColor`Colors | `(out Main: ST_Color_Definition, out Action: ST_Color_Definition)` | Returns the pair of theme colours the button is meant to be drawn in: a main colour following the preset, primary, secondary or transparent, and the active colour at high intensity for the selected state. Nothing in the stock design calls it, as its elements carry their own colour settings, so it is there for your own overrides. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value into the gradient border and the icon so both recolour as the button is selected. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value into the rounded hover border. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |
| event | `UpdateButtonContent`Content | `(ButtonContent: ST_Button_Content)` | Replaces the button's content and refreshes the label, the icon and the content widget from it. The chain runs through the text element first and the image element second, so a design missing either updates nothing beyond that point. |

**WBP_Button_Toggle**14 members

extends `WBP_Button`

Toggle switch: a track between an Off and an On label that fills towards the selected side, with separate sounds for the two directions. Selected means on. Bind it to a boolean value object, or use it wherever a setting reads better as a switch than as a checkbox.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getBlendableElements_Action`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the action animation, typically the background, icon and label that shift as the button is selected. Empty on the base class; each button design overrides it. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value into the gradient track and the knob so both recolour as the switch travels. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value into the rounded hover border. |
| event | `UpdateButtonContent`Content | `(ButtonContent: ST_Button_Content)` | Replaces the button's content and refreshes the label, the icon and the content widget from it. The chain runs through the text element first and the image element second, so a design missing either updates nothing beyond that point. |

### Widgets/Input/ChipSelector

**WBP_ChipSelector**10 members

extends `WBP_Group_Button`

Segmented chip selector: a row of chips in one rounded frame with selection and hover highlights that slide between them, driven by interpolating spacers rather than by moving a widget. Built on the button group, so the options come from its content array and selection is read the same way. Use it where a short set of mutually exclusive choices should read as a single control.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Scroll Speed`Group | `float` | Speed at which the hover and selection highlights slide from one chip to the next. The shrinking side of a highlight always travels six times faster than the growing side, so the pill appears to lead with its front edge. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |
| event | `OnButtonHovered` | `(Group: WBP_Group_Button, Index: int)` | Called when one of the chips is hovered. Slides the hover highlight onto that index and fades it in. |
| event | `OnButtonUnhovered` | `(Group: WBP_Group_Button, Index: int)` | Called when a chip stops being hovered. Fades the hover highlight out again, leaving it parked over the chip it last moved to. |
| event | `SetHoverIndex` | `(Index: int)` | Slides the hover highlight onto the chip at the given index by interpolating the spacers either side of it. Driven by the hover handler rather than called directly. |
| event | `OnButtonSelctionChanged` | `(Group: WBP_Group_Button)` | Called whenever the group's selection changes. Slides the selection highlight onto the newly selected chip, or fades the highlight away once nothing is selected. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |
| event | `PostAddDesign`Style | `()` | Trims the padding off the two ends of the group so it sits flush with its neighbours: the top of the first item and the bottom of the last in a column, the outer sides in a row, and a matching negative padding on the box itself for a wrap box. Run it after a batch of additions. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

### Widgets/Input/ChipSelector/Helpers

**WBP_Button_ChipSelector**13 members

extends `WBP_Button`

Single chip inside the chip selector: an icon and a label with no frame or fill of its own, auto-blending against the highlight sliding behind it. The chip selector creates these as its button class, so there is no reason to place one directly.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getBlendableElements_Action`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the action animation, typically the background, icon and label that shift as the button is selected. Empty on the base class; each button design overrides it. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonText`Get Elements | `(out Button Text: AFText)` | Returns the text element the label is written into. Empty on the base class; designs override it, and Update Button Content stops before touching anything else when there is none. |
| fn | `getButtonImage`Get Elements | `(out Button Image: AFImage)` | Returns the image element the icon is written into. Empty on the base class; designs override it, and Update Button Content stops before forwarding content to the content widget when there is none. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value into the icon and the label. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value out to the design's hover elements, of which this one registers none, so nothing on the chip itself follows it. |

### Widgets/Input/Color

**WBP_ColorPicker**16 members

extends `WBP_Base`

Colour field: a bar filled with the current colour that opens the picker menu when clicked and broadcasts every change. Bind it to a colour value object and the field and the value follow each other; the colour also replicates. Drop it into a settings page or configurator, the menu and its sliders come with it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Anim Value Hover`Animations | `float` | Blend value driven by the hover animation, running 0 to 1. Sequence Event Hover pushes it into the outline border while the animation plays. |
| var | `Color`Content | `LinearColor` | Colour the swatch currently shows. Change it through Set Color rather than writing to it directly, so the border, the pop-out wheel and any bound colour object stay in step. |
| var | `Deactivate`State | `bool` | Whether the swatch ignores input. While set, hover and click are dropped so the colour wheel cannot be opened, but the swatch is not dimmed or restyled. |
| var | `Width Override`Style | `ST_SizeOverride` | Optional fixed width for the swatch. Leave the override off to take the width from the surrounding layout. |
| fn | `SetColor`State | `(Color: LinearColor)` | Sets the shown colour, repaints the swatch and broadcasts On Color Updated. Nothing happens when the colour is unchanged; when the widget replicates, the four channels go out as strings under the Value identifier. |
| fn | `UpdateVisuals`State | `()` | Repaints the swatch fill with the current colour and pushes that colour into the pop-out wheel. Called from Set Color; you only need it after writing the colour directly. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track. Pushes the current hover blend value into the rounded outline border so the outline follows the animation. |
| event | `OnMouseEnter`Mouse | `(MyGeometry: Geometry, MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has entered it. This event is NOT bubbled. @param MyGeometry The Geometry of the widget receiving the event @param MouseEvent Information about the input event |
| event | `OnMouseLeave`Mouse | `(MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has left it. This event is NOT bubbled. @param MouseEvent Information about the input event |
| event | `SetHovered` | `(Value: bool)` | Fades the hover outline in or out and records the new hover state. Ignored while the swatch is deactivated, and ignored when the value has not actually changed. |
| event | `MouseButtonPressed` | `()` | Opens or closes the pop-out colour wheel when the swatch is clicked. Does nothing while the swatch is deactivated. |
| event | `WidgetElement_ExecuteReplication`Replication | `(ReplicationIdentifier: name, Content: string[])` | Called on the other clients when a replicated value arrives for this element, carrying the identifier and its content strings. Implement it to reflect a change another player made; it is skipped on the client that sent the value. |
| event | `AssignColorObject` | `(Target: Object, ApplyValue: bool)` | Binds the swatch to a colour value object so the two follow each other from then on. Set Apply Value to push the swatch's current colour into the object; leave it off to adopt the object's colour instead. |
| event | `OnValueUpdated_Event` | `()` | Internal handler that pulls the bound colour object's value back into the swatch whenever that object reports a change. |
| event | `OnColorUpdated_Event` | `(Color: LinearColor)` | Internal handler that writes a newly chosen colour into the bound colour object, tagged with the widget's Source Info so the object knows which pawn changed it. |

**WBP_Group_Button_WrapBox_Colors**9 members

extends `WBP_Group_Button_WrapBox`

Palette: a wrap box of swatch buttons built from a list of colour data assets, with automatic selection on. Bound to a colour value object, picking a swatch writes that colour through and an outside change selects the matching swatch. Nothing references it in the shipped content; fill in its colour list and place it where a fixed palette beats a free picker.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Colors`Content | `PDA_Color[]` | Palette the group offers, one swatch button per entry. Keep it in the same order as the group's button content, since selection is mapped between the two by index. |
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `getSelectedColor` | `(out Color: PDA_Color)` | Returns the palette asset behind the currently selected swatch. With nothing selected the lookup index is -1, so check that the group has a selection before trusting the result. |
| fn | `findColor` | `(ItemToFind: LinearColor) → int` | Returns the index of the first palette entry whose colour matches exactly, or -1 when the colour is not in the palette. |
| event | `AssignColorObject` | `(Target: Object, ApplyValue: bool)` | Binds the palette to a colour value object so the two follow each other. Set Apply Value to push the selected swatch's colour into the object; leave it off to select the swatch matching the object instead. |
| event | `OnValueUpdated_Color` | `()` | Internal handler that selects the swatch matching the bound object's colour whenever that object reports a change. A colour outside the palette leaves nothing selected. |
| event | `OnButtonSelectionChanged_Event` | `(Group: WBP_Group_Button)` | Internal handler that writes the newly selected palette colour into the bound colour object, tagged with the widget's Source Info. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |
| event | `WidgetElement_InitialConstruct`Construct | `()` | Called on every element while the owning widget pre-constructs in the editor, immediately before the design-time theme pass. Implement it for preview-only set-up; it never runs in a running game. |

### Widgets/Input/Color/Helper

**WBP_AnchorMenu_ColorPicker**7 members

extends `WBP_AnchorMenu`

Anchor menu that opens the colour picker's drop-down, creating it with the current colour and passing changes back out again. It sits between the colour field and the sliders and is already wired into that field, so there is nothing to configure here unless you are assembling a picker of your own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Close on Select`Behaviour | `bool` | Flag meant to shut the picker once a colour has been chosen. Nothing in the graph reads it, so the menu stays open until a press lands outside it or Close Menu Anchor is called. |
| var | `Automatic Selection`Behaviour | `bool` | Flag carried over from the button version of this anchor. Nothing in the colour picker reads it, and the shown colour is kept in step through Set Color however it is left. |
| fn | `WBP_AnchorMenu_ColorPicker_AutoGenFunc` | `(Color: LinearColor)` | Internal handler subscribed to the open picker's On Color Updated. Stores the colour the sliders produced and passes it on by broadcasting the anchor's own On Color Updated. |
| fn | `createDropDownMenu`Anchor | `(out NewMenu: WBP_DropDownMenu)` | Creates the menu widget that pops out of this anchor. Empty on the base class; override it to spawn your own menu, passing the height and width overrides on and binding whatever delegates it offers. |
| fn | `getMenuAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Returns the menu anchor the menu pops out of. Empty on the base class; every anchor menu overrides it, and opening, closing and Set Fit In Window all act on whatever it returns. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `SetColor` | `(Color: LinearColor)` | Stores the colour and moves an open picker's sliders to match it. Nothing is broadcast, so the widget owning the anchor is not told about a colour it has just set itself. |

**WBP_DropDownMenu_ColorPicker**6 members

extends `WBP_DropDownMenu`

Panel the colour picker opens: a hue slider above a brightness slider, both drawn with gradient materials, converting between the pair of them and the linear colour they describe and broadcasting each change back to the anchor menu. Created for you by the colour field; not a widget to place.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Color`Content | `LinearColor` | Colour the picker works on, handed over when the anchor menu spawns it. Nothing applies it to the sliders as the menu is built, so push it in through Set Color for the sliders to start where the current colour is. |
| fn | `SetColor`Content | `(Color: LinearColor)` | Moves both sliders to the positions matching the given colour and repaints their gradient materials so each shows the other's setting. Dispatchers are held off while it runs, so a colour pushed in this way is not echoed back through On Color Updated. |
| fn | `UpdateCurrentColor`Content | `()` | Rebuilds the colour from the two slider positions and broadcasts On Color Updated with it. The first slider gives the hue across a full 360 degrees; the second runs from black at 0, through the fully saturated hue at 0.5, to white at 1. |
| fn | `getAnimation_Appear`Get Animations | `(out AppearAnim: WidgetAnimation)` | Returns the animation that brings the menu in. Empty on the base class; each design overrides it with its own, and Hide plays whatever comes back in reverse. |
| fn | `getSizeBox`Get Elements | `(out SizeBox: SizeBox)` | Returns the size box wrapping the menu's content. Empty on the base class; each design overrides it with its own, and it is the box any height or width override belongs on. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

### Widgets/Input/DropDown

**WBP_DropDown_Default**9 members

extends `WBP_DropDown`

Ready-made drop-down: a labelled bar with an arrow that opens its options beneath it, showing the substitute text while nothing is chosen. This is the concrete drop-down to place, and the one the debug scene and the input examples use; the options, the selected index and the value binding all come from its parent class.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Anim Value Hover`Animations | `float` | Blend value driven by the hover animation, running 0 to 1. Sequence Event Hover pushes it into the hover border while the animation plays. |
| var | `Substitute Text`Content | `text` | Text shown while the selected index does not point at an option, which is the case before anything is picked and after the options are reset. Defaults to Select. |
| fn | `UpdateSubstituteText`Content | `(SubstituteText: text)` | Replaces the placeholder text and refreshes the display straight away, so the change shows even while nothing is selected. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getHoverAnimation`Get Elements | `(out Animation: WidgetAnimation)` | Returns the animation Set Hovered runs forwards as the cursor enters and reverses as it leaves. Empty on the base class; each design overrides it with its own. |
| fn | `getAnchorMenu`Get Elements | `(out AnchorMenu: WBP_AnchorMenu_Buttons)` | Returns the pop-out button menu holding the options. Empty on the base class; each design overrides it, and opening, updating the options and marking the selection all act on whatever comes back. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track. Pushes the current hover blend value into the rounded hover border so it fades with the animation. |
| event | `UpdateVisuals`Content | `()` | Redraws the collapsed drop-down from the current selection. Empty on the base class and called for you by Set Index; each design overrides it to write the selected option's text into its own elements. |
| event | `SetDeactivate`Deactivate | `(Deactivate: bool)` | Switches the drop-down off: drops any hover, records the flag and makes the anchor menu hit-test invisible so presses no longer reach it. The whole body is skipped when false is passed in, so it cannot switch a deactivated drop-down back on again. |

### Widgets/Input/DropDown/Helper

**WBP_AnchorMenu_Buttons**13 members

extends `WBP_AnchorMenu`

Anchor menu whose drop-down is a list of buttons. It holds the content array, the button class, the selection type and the selected indexes, and keeps them in step with the menu whether it happens to be open or not. The drop-down is built on it; use it directly when you want a button list hanging off a widget of your own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Button Content`Content | `ST_Button_Content[]` | Options the pop-out menu is built from, one button per entry. It is handed to the menu as that menu is created and pushed on to an already open one through Update Buttons, so change it through that event rather than writing here. |
| var | `Button Class`Style | `class<WBP_Button>` | Button class the pop-out menu is spawned with. The menu keeps it but never passes it on to the button group inside it, so the entries themselves are built from the class set on that group in the designer. |
| var | `Close on Select`Behaviour | `bool` | Whether the menu shuts as soon as one of its entries is pressed. Leave it off for a menu the user picks several options from and closes by pressing outside it. |
| var | `Selected Indexes`State | `int[]` | Live list of the options counting as selected. It is refreshed from the open menu's button group after every press while Automatic Selection is on, and reaches the menu again through Set Button Selected and Set Button Seleced Indexes rather than by being edited directly. |
| var | `Automatic Selection`Behaviour | `bool` | Whether the anchor keeps a selection of its own. With it on, a press first copies the button group's selected indexes back into this widget, and the press is dropped altogether when the open menu is not a button menu; with it off the press is only reported on. |
| var | `Selection Type`Behaviour | `E_UI_Group_Selection` | Selection rule handed to the menu as it is created, single select by default. As with the button class the menu does not forward it to its button group, so it is the group's own rule that decides how many entries can be held at once. |
| fn | `createDropDownMenu`Anchor | `(out NewMenu: WBP_DropDownMenu)` | Creates the menu widget that pops out of this anchor. Empty on the base class; override it to spawn your own menu, passing the height and width overrides on and binding whatever delegates it offers. |
| fn | `getMenuAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Returns the menu anchor the menu pops out of. Empty on the base class; every anchor menu overrides it, and opening, closing and Set Fit In Window all act on whatever it returns. |
| fn | `WBP_AnchorMenu_ButtonPressed` | `(Index: int)` | Internal handler subscribed to the created menu's On Button Pressed. Copies the group's selection back while Automatic Selection is on, closes the anchor when Close On Select is set, then broadcasts On Button Pressed with the index. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `UpdateButtons` | `(ButtonContent: ST_Button_Content[])` | Replaces the options and forwards them to the menu while one is open, where the button group grows or shrinks to match. With the menu closed only the stored content changes, which is what the next menu is created from. |
| event | `SetButtonSelected` | `(ButtonIndex: int, ButtonSet: bool)` | Adds or removes a single index in the selection and forwards the same change to an open menu. The index is added only once however often you call it. |
| event | `SetButtonSelecedIndexes` | `(ButtonIndexes: int[])` | Replaces the whole selection with the indexes given and pushes them to an open menu, where the group applies them to its entries. Pass an empty list to clear the selection. |

**WBP_DropDownButton**12 members

extends `WBP_Button`

Row button for a drop-down list: an icon and a label in a gradient frame, defaulting to the secondary hierarchy and swapping between its two content texts as it becomes selected. Named as the button class on the default drop-down's anchor menu. Point that at a class of your own rather than editing this one.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonText`Get Elements | `(out Button Text: AFText)` | Returns the text element the label is written into. Empty on the base class; designs override it, and Update Button Content stops before touching anything else when there is none. |
| fn | `getButtonImage`Get Elements | `(out Button Image: AFImage)` | Returns the image element the icon is written into. Empty on the base class; designs override it, and Update Button Content stops before forwarding content to the content widget when there is none. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value out to the design's action elements, of which this one registers none, so the gradient border, icon and label keep their colours and only the blended label changes. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value out to the design's hover elements, of which this one registers none, so the hover border sitting in the tree never fades in. |

**WBP_DropDownMenu_Buttons**11 members

extends `WBP_DropDownMenu`

Panel a drop-down opens: a vertical button group inside a scroll box, capped at 400 units tall, built from the content array it is spawned with and reporting the pressed index back to its anchor menu. Created for you; set the button class, selection type and initial selection on the anchor menu rather than here.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Initially Selected Indexes`Content | `int[]` | Selection the menu is spawned with, handed over by the anchor menu as it opens. Nothing in the menu applies it, so the entries come up carrying whatever the button group already had; push it in through Set Button Seleced Indexes once the menu exists. |
| var | `Button Content`Content | `ST_Button_Content[]` | Options the menu is spawned with. They reach the button group only when Update Buttons is called, so until then the group shows whatever content it was given in the designer. |
| var | `Automatic Selection`Buttons | `bool` | Whether the menu keeps a selection of its own, handed over as it is spawned. It is not forwarded to the button group inside the menu, so the group's own setting decides whether a press changes the selection. |
| var | `Button Class`Buttons | `class<WBP_Button>` | Button class the menu is spawned with. It is not forwarded to the button group either, so entries are built from the class set on that group in the designer, which ships as the checkbox button. |
| var | `Selection Type`Buttons | `E_UI_Group_Selection` | Selection rule the menu is spawned with, single select by default. As with the button class it never reaches the button group, so it is the group's own rule that decides how many entries can be held at once. |
| fn | `getAnimation_Appear`Get Animations | `(out AppearAnim: WidgetAnimation)` | Returns the animation that brings the menu in. Empty on the base class; each design overrides it with its own, and Hide plays whatever comes back in reverse. |
| fn | `getSizeBox`Get Elements | `(out SizeBox: SizeBox)` | Returns the size box wrapping the menu's content. Empty on the base class; each design overrides it with its own, and it is the box any height or width override belongs on. |
| event | `UpdateButtons` | `(ButtonContent: ST_Button_Content[])` | Replaces the options and rebuilds the column from them, adding or removing entries until the count matches and writing the content into each one. This is the only route by which content reaches the entries. |
| event | `SetButtonSelected` | `(ButtonIndex: int, ButtonSet: bool)` | Marks one entry as selected or clears it, leaving the others alone. The group applies its own selection rule, so under single select this replaces the selection rather than adding to it. |
| event | `SetButtonSelecedIndexes` | `(ButtonIndexes: int[])` | Replaces the whole selection with the entries given, in one go. Nothing happens when the list matches what is already selected; pass an empty list to clear it. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

### Widgets/Input/DropDown/Parents

**WBP_DropDown**27 members

extends `WBP_Base`

Base class for drop-downs. Holds the options, the selected index and the lookup between index and identifier, drives the anchor menu that displays them, and binds to an integer or name value object so selection and value follow each other. The selection replicates. Subclass it and supply the anchor menu, hover animation and visual update to give it a look, or place the default drop-down instead.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Selected Index`State | `int` | Position of the chosen option within Options. It sits at -1 while nothing is selected, which is also what Update Options leaves behind when asked to reset; move it through Set Index so the menu, the display and the listeners follow. |
| var | `Options`Content | `ST_Button_Content[]` | Full list of what the drop-down offers, each entry carrying an identifier and the texts its entry shows. Push a new list in through Update Options, which also hands it to the pop-out menu. |
| var | `Manual Set`Manual Set | `bool` | Flag intended to hand a press to the owner instead of acting on it locally. Nothing in the drop-down reads it, so a press is treated the same whichever way it is left. |
| var | `Deactivate`State | `bool` | Whether the drop-down refuses input. While set, hover is dropped and a press no longer opens the menu; switch it through Set Deactivate, which also takes the anchor out of hit testing. |
| var | `Fit In Window`Style | `bool` | Flag intended to push an overflowing menu back inside the window. Nothing in the drop-down reads it; the anchor menu carries a setting of its own, reached through Set Fit In Window, and that is the one that bites. |
| fn | `UpdateVisuals`Content | `()` | Redraws the collapsed drop-down from the current selection. Empty on the base class and called for you by Set Index; each design overrides it to write the selected option's text into its own elements. |
| fn | `SetIndexByID`State | `(ID: name)` | Selects the option carrying the given identifier, looking its position up first. An identifier no option carries resolves to -1 and so clears the selection. |
| fn | `SetIndex`State | `(SelectedIndex: int)` | Selects the option at the given position, marks it as the only selection in the pop-out menu, redraws the display and broadcasts On Selection Changed with the index and its identifier. Nothing happens when the index is unchanged; with replication on the index also goes out to the other clients. |
| fn | `UpdateOptions`Content | `(Options: ST_Button_Content[], ResetIndex: bool)` | Replaces the options and pushes them to the pop-out menu. Reset Index then clears the selection to -1, which redraws the display and broadcasts On Selection Changed; leave it off to keep the index you had, even where it now points at a different option. |
| fn | `getIDfromIndex`State | `(Index: int, out ID: name)` | Returns the identifier of the option at the given position, or None when that position lies outside the options. |
| fn | `getIndexByID`State | `(ID: name, out Index: int)` | Returns the position of the first option carrying the given identifier, or -1 when no option carries it. |
| fn | `ConvertTextsToContent`Conversion | `(out IDs: name[], out Texts: text[], Conent: ST_Button_Content[])` | Builds a list of option content from parallel lists of identifiers and texts, pairing each text with the identifier at the same position. Supply no identifiers and every entry comes back with an identifier of None, which is what happens on the integer value object path. |
| fn | `SetDeactivate`Deactivate | `(Deactivate: bool)` | Switches the drop-down off: drops any hover, records the flag and makes the anchor menu hit-test invisible so presses no longer reach it. The whole body is skipped when false is passed in, so it cannot switch a deactivated drop-down back on again. |
| fn | `getHoverAnimation`Get Elements | `(out Animation: WidgetAnimation)` | Returns the animation Set Hovered runs forwards as the cursor enters and reverses as it leaves. Empty on the base class; each design overrides it with its own. |
| fn | `getAnchorMenu`Get Elements | `(out AnchorMenu: WBP_AnchorMenu_Buttons)` | Returns the pop-out button menu holding the options. Empty on the base class; each design overrides it, and opening, updating the options and marking the selection all act on whatever comes back. |
| event | `OnMouseEnter`Mouse | `(MyGeometry: Geometry, MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has entered it. This event is NOT bubbled. @param MyGeometry The Geometry of the widget receiving the event @param MouseEvent Information about the input event |
| event | `OnMouseLeave`Mouse | `(MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has left it. This event is NOT bubbled. @param MouseEvent Information about the input event |
| event | `SetHovered` | `(Value: bool)` | Records the hover and runs the hover animation forwards or backwards to match. Ignored while the drop-down is deactivated, and ignored when the value has not actually changed. |
| event | `WidgetElement_ExecuteReplication`Replication | `(ReplicationIdentifier: name, Content: string[])` | Called on the other clients when a replicated value arrives for this element, carrying the identifier and its content strings. Implement it to reflect a change another player made; it is skipped on the client that sent the value. |
| event | `OnButtonPressed_Event` | `(Index: int)` | Selects the option the pop-out menu reports as pressed and broadcasts On Selection Pressed with it. Nothing binds it in the shipped design, so wire it to the anchor menu's On Button Pressed yourself. |
| event | `MouseButtonPressed` | `()` | Called when the left button goes down anywhere on the drop-down. Opens the pop-out menu, or closes it again when it is already open; skipped while the drop-down is deactivated or while it holds no options. |
| event | `AssignIntegerObject` | `(Target: Object, UseContent: bool, ApplyValue: bool)` | Binds the drop-down to an integer value object so the two follow each other from then on, the selected position being the value. Set Apply Value to push the current index into the object; leave it off to adopt the object's value instead. Use Content rebuilds the options from the object's texts, whose entries all carry an identifier of None. |
| event | `OnValueUpdated_Event` | `()` | Internal handler that pulls the bound integer object's value back in as the selected index whenever that object reports a change. |
| event | `AssignNameObject` | `(Target: Object, UseContent: bool, ApplyValue: bool)` | Binds the drop-down to a name value object, which matches options by identifier rather than by position. Set Apply Value to push the current option's identifier into the object; leave it off to adopt the object's value instead. Use Content rebuilds the options from the object's identifiers and texts and selects the one it names. |
| event | `OnValueUpdated_Name` | `()` | Internal handler that selects the option carrying the bound name object's value whenever that object reports a change. A name no option carries clears the selection. |
| event | `OnSelectionPressed_Event` | `(DropDown: WBP_DropDown, Index: int, ID: name)` | Internal handler bound by Assign Integer Object that writes the pressed position into the bound integer object, tagged with the widget's Source Info. |
| event | `OnSelectionPressed_Event_0` | `(DropDown: WBP_DropDown, Index: int, ID: name)` | Internal handler bound by Assign Name Object, with the same body as the one Assign Integer Object binds: it writes the pressed position into the integer object rather than the identifier into the name object. A drop-down bound only to a name object therefore never writes a choice back. |

### Widgets/Input/Slider

**WBP_Slider**34 members

extends `WBP_Base`

Base class for sliders. Owns the normalised value, the mapped range and unit used to write it out, the optional segment list it can snap to, the interpolated visual progress and the press, drag, release and hover sounds, and binds to a float value object that can also supply range, unit and segments. Subclass it and override the slider, animation and segment box getters; it draws nothing itself.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Deactivated`State | `bool` | Whether the slider refuses input. While set, the underlying slider widget is disabled, the deactivate animation is held at its end and any hover is forced off; switch it through Deactivate Slider rather than writing here. |
| var | `Value`State | `float` | Handle position as a fraction of the range, 0 to 1, not the figure shown to the player. Push changes in through Set Value or Set Value Mapped so the interpolation, the broadcasts and the replicated copy follow; writing here moves nothing on screen. |
| var | `Segments`Segments | `float[]` | Positions along the track, 0 to 1, at which marker widgets are placed. Leave empty for a plain track; run Update Segments after changing it, and note that only designs with a segment box show anything. |
| var | `Snap to Segment`Segments | `bool` | Whether the value settles on the nearest entry in Segments once the drag ends. The handle still moves freely during the drag; the rounding happens on release only. |
| var | `Fractional Digits`Config | `int` | Maximum number of decimal places used when the value is written out as text with its unit. Assign Float Object overwrites it with the figure the bound value object supplies. |
| var | `Unit`Slider | `text` | Suffix appended to the formatted value, such as a percentage sign or a distance unit. Leave empty to show the number on its own; Assign Float Object overwrites it from the bound value object when Use Content is set. |
| var | `Value Range`Slider | `InputRange` | Minimum and maximum the 0 to 1 position is mapped onto, which is what Get Value Mapped and the formatted text report. Change it at runtime through Update Range so the visuals refresh; the stored position stays put, so the displayed figure moves instead. |
| var | `Interpolation Speed`Behavior | `float` | Speed at which the drawn progress chases the value after a change, used by Interpolate To Value. Higher is snappier, and the interpolation stops once the two sit within 0.01 of each other. |
| fn | `SetValue`Value | `(InValue: float)` | Sets the position, 0 to 1, and starts everything that follows from it: the visual interpolation, the On Value Changed broadcast and its mapped counterpart, and the replicated copy when replication is switched on. Nothing runs when the value is unchanged. |
| fn | `SetValueMapped`Value | `(Value: float)` | Sets the slider from a figure given in the value range, normalising it against that range and clamping it to 0 to 1 before handing it on to Set Value. Use it whenever your source figure carries the displayed unit. |
| fn | `getValue_Mapped`Value | `(out MappedValue: float)` | Returns the current position expressed in the value range, that is the figure a player reads rather than the underlying 0 to 1 position. |
| fn | `Slider_MouseCapture_End`Slider Events | `()` | Called when the underlying slider gives up the mouse capture at the end of a drag. Plays the release cue, rounds the value to the closest entry in Segments when Snap To Segment is set, and broadcasts On Interaction Ended. |
| fn | `Slider_MouseCapture_Start`Slider Events | `()` | Called when the underlying slider takes the mouse capture at the start of a drag. Plays the press cue and broadcasts On Interaction Started. |
| fn | `Slider_ValueChanged`Slider Events | `(Value: float)` | Called by the underlying slider each time a drag moves the handle. Applies the new position through Set Value, then plays the drag cue once the value has travelled more than Sound Tick Intervall along the track since the last cue. |
| fn | `UpdateRange`Slider | `(ValueRange: InputRange)` | Replaces the range the position is mapped onto and redraws at the current progress. The stored position is untouched, so the handle stays where it is and the figure it reports changes. |
| fn | `translateFloatToText`Value | `(Value: float, out FormattedText: text)` | Returns the given position mapped into the value range and formatted with the unit appended. Feed it a 0 to 1 position, not a figure that is already in the displayed unit. |
| fn | `UpdateSegments`Segments | `()` | Rebuilds the segment markers. Clears the segment box, then for each entry in Segments adds a spacer sized to the gap since the previous one followed by a marker widget, and closes with a spacer filling the rest of the track. Run it after changing Segments; it does nothing on a design without a segment box. |
| fn | `getSegmentHorizontalBox`Get Animations | `(out HorizontalBox: HorizontalBox)` | Returns the horizontal box the segment markers and their spacers are built into. Empty on the base class, and a design that does not override it, such as the custom material slider, shows no segments at all. |
| fn | `getAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation carrying the deactivated look. Empty on the base class; each design overrides it, and Apply Deactivate runs it forwards on deactivation and in reverse on activation. |
| fn | `getAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation played while the cursor rests on the slider. Empty on the base class; each design overrides it with its own, and Set Hovered drives it forwards and in reverse. |
| fn | `getSlider`Get Elements | `(out MainSlider: Slider)` | Returns the underlying slider widget the drag input comes from. Empty on the base class; each slider design overrides it, and Apply Deactivate needs it to switch input on and off. |
| event | `DeactivateSlider` | `(Set: bool)` | Switches the slider between deactivated and active and applies the change through Apply Deactivate. Ignored when the state is unchanged. |
| event | `InterpolateToValue` | `()` | Steps the drawn progress towards the current value at Interpolation Speed, pushing each intermediate figure through Update Visuals until the two are within 0.01. Started by Set Value, so there is rarely a reason to call it yourself. |
| event | `UpdateVisuals` | `(VisualProgress: float)` | Called with the progress the slider should be drawn at, once per interpolation step. Records it and switches each segment marker on or off according to whether its position has been passed; designs override it to move their own bar or material as well. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |
| event | `SetHovered` | `(Set: bool)` | Sets the hover state and drives the hover animation towards it, playing the hover cue as it comes on. A deactivated slider is forced unhovered instead, and nothing happens when the state is unchanged. |
| event | `WidgetElement_ExecuteReplication`Replication | `(ReplicationIdentifier: name, Content: string[])` | Called on the other clients when a replicated value arrives for this element, carrying the identifier and its content strings. Implement it to reflect a change another player made; it is skipped on the client that sent the value. |
| event | `AssignFloatObject` | `(Target: Object, UseContent: bool, ApplyValue: bool)` | Binds the slider to a float value object so the two follow each other from then on. Set Apply Value to push the slider's current value into the object; leave it off to adopt the object's value instead. Use Content also takes the object's range, unit, decimal places and sorted segment list. |
| event | `ValueChanged_Event` | `(NewValue: float)` | Internal handler bound by Assign Float Object that writes each new slider value into the bound value object, tagged with the widget's Source Info. |
| event | `OnValueUpdated_Event` | `()` | Internal handler that pulls the bound value object's float back into the slider whenever that object reports a change. |
| event | `WidgetElement_Initiate`Style | `(Parent: WBP_Base, ReplicationIndex: name)` | Called once per element while the owning widget walks its tree after begin play, handing over the parent widget and the index that makes this element's replication identifier unique among its siblings. Implement it for content set-up; the theme pass follows. |
| event | `OnMouseEnter`Mouse | `(MyGeometry: Geometry, MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has entered it. This event is NOT bubbled. @param MyGeometry The Geometry of the widget receiving the event @param MouseEvent Information about the input event |
| event | `OnMouseLeave`Mouse | `(MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has left it. This event is NOT bubbled. @param MouseEvent Information about the input event |
| event | `ApplyDeactivate` | `()` | Enables or disables the underlying slider to match Deactivated and runs the deactivate animation towards that state, forcing the hover off once the slider is switched off. Reached through Deactivate Slider rather than called directly. |

**WBP_Slider_CustomMaterial**10 members

extends `WBP_Slider`

Slider whose track is a material rather than a coloured bar, with separate materials for VR and desktop and a thin outlined knob. The colour picker's hue and brightness sliders are both this class. Use it when the track has to show a gradient or some other shader-driven fill.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Background Material Normal`Style | `MaterialInterface` | Material the track is drawn with in the standard, non-desktop look, typically a gradient the handle picks a point out of. Leave empty to keep whatever the custom border was given in the designer; the colour picker uses this pair for its hue and brightness bars. |
| var | `Background Material Desktop`Style | `MaterialInterface` | Material the track is drawn with when the widget is built for desktop rather than in VR. Leave empty to keep whatever the custom border was given in the designer, so one slider can serve both looks. |
| fn | `getAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation played while the cursor rests on the slider. Empty on the base class; each design overrides it with its own, and Set Hovered drives it forwards and in reverse. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getSlider`Get Elements | `(out MainSlider: Slider)` | Returns the underlying slider widget the drag input comes from. Empty on the base class; each slider design overrides it, and Apply Deactivate needs it to switch input on and off. |
| fn | `getAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation carrying the deactivated look. Empty on the base class; each design overrides it, and Apply Deactivate runs it forwards on deactivation and in reverse on activation. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |
| event | `UpdateVisuals` | `(VisualProgress: float)` | Called with the progress the slider should be drawn at as the value interpolates. Left empty here, so the segment pass the base slider runs does not happen on this design, which has no segment box in any case. |
| event | `OnMouseEnter`Mouse | `(MyGeometry: Geometry, MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has entered it. This event is NOT bubbled. @param MyGeometry The Geometry of the widget receiving the event @param MouseEvent Information about the input event |
| event | `OnMouseLeave`Mouse | `(MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has left it. This event is NOT bubbled. @param MouseEvent Information about the input event |

**WBP_Slider_Default**10 members

extends `WBP_Slider`

Standard slider: a progress bar track with a round knob, segment marks where the parent's segment list puts them, and a tooltip above the knob showing the current value when Show Value is on. The one to place for an ordinary numeric control.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Show Value`Slider | `bool` | Whether the bubble above the handle carrying the current figure is used. Its content is built on demand by the value anchor and shows the progress formatted with the slider's unit. |
| fn | `On_ValueMenuAnchor_GetUserMenuContent`Value | `() → UserWidget` | Builds the bubble shown above the handle, creating a slider tooltip carrying the current progress formatted through Translate Float To Text and holding on to it afterwards. Bound to the value anchor; the text is only worked out when that widget is first created, so it does not follow later drags. |
| fn | `getSegmentHorizontalBox`Get Animations | `(out HorizontalBox: HorizontalBox)` | Returns the horizontal box the segment markers and their spacers are built into. Empty on the base class, and a design that does not override it, such as the custom material slider, shows no segments at all. |
| fn | `getAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation played while the cursor rests on the slider. Empty on the base class; each design overrides it with its own, and Set Hovered drives it forwards and in reverse. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getSlider`Get Elements | `(out MainSlider: Slider)` | Returns the underlying slider widget the drag input comes from. Empty on the base class; each slider design overrides it, and Apply Deactivate needs it to switch input on and off. |
| fn | `getAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation carrying the deactivated look. Empty on the base class; each design overrides it, and Apply Deactivate runs it forwards on deactivation and in reverse on activation. |
| event | `UpdateVisuals` | `(VisualProgress: float)` | Called with the progress the slider should be drawn at as the value interpolates. Left empty here, so the segment pass the base slider runs on each step does not happen on this design. |
| event | `OnMouseEnter`Mouse | `(MyGeometry: Geometry, MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has entered it. This event is NOT bubbled. @param MyGeometry The Geometry of the widget receiving the event @param MouseEvent Information about the input event |
| event | `OnMouseLeave`Mouse | `(MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has left it. This event is NOT bubbled. @param MouseEvent Information about the input event |

**WBP_Slider_Unit**8 members

extends `WBP_Slider`

Slider that writes its value and unit across the track itself instead of into a tooltip, in a taller frame with a hover border. Use it where the number matters as much as the position, such as a volume in decibels or a distance in metres.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Anim Value Hover`Animations | `float` | Blend value driven by the hover animation, running 0 to 1. Sequence Event Hover pushes it into the rounded hover border while the animation plays. |
| fn | `getSegmentHorizontalBox`Get Animations | `(out HorizontalBox: HorizontalBox)` | Returns the horizontal box the segment markers and their spacers are built into. Empty on the base class, and a design that does not override it, such as the custom material slider, shows no segments at all. |
| fn | `getAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation played while the cursor rests on the slider. Empty on the base class; each design overrides it with its own, and Set Hovered drives it forwards and in reverse. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation carrying the deactivated look. Empty on the base class; each design overrides it, and Apply Deactivate runs it forwards on deactivation and in reverse on activation. |
| fn | `getSlider`Get Elements | `(out MainSlider: Slider)` | Returns the underlying slider widget the drag input comes from. Empty on the base class; each slider design overrides it, and Apply Deactivate needs it to switch input on and off. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track. Pushes the current hover blend value into the rounded hover border so it fades in with the animation. |
| event | `UpdateVisuals` | `(VisualProgress: float)` | Called with the progress the slider should be drawn at as the value interpolates. Left empty here, so the segment pass the base slider runs on each step does not happen on this design. |

### Widgets/Input/Slider/Decoration

**WBP_SliderFrame_Default**4 members

extends `WBP_Base`

Decoration frame for a slider: an icon either side of a named slot the slider goes into, with one width override for the whole row. Nothing references it, so it is there to be used as it stands when a slider wants a quiet and a loud icon at its ends, or copied for a frame of your own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Icon Left`Content | `Texture` | Icon drawn at the low end of the slider, written into the left image in Pre Construct so it shows in the designer as well as at runtime. Leave it empty for a frame with no icon on that side. |
| var | `Icon Right`Content | `Texture` | Icon drawn at the high end of the slider, written into the right image in Pre Construct. Leave it empty for a frame with no icon on that side. |
| var | `Width Override`Style | `ST_SizeOverride` | Width the frame is held to, as a size override that can be switched off rather than a plain number. Applied to the frame's size box in Pre Construct, so the slider's width reads correctly in the designer. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |

### Widgets/Input/Slider/Helper/Segments

**WBP_SliderSegment**1 members

extends `WBP_Base`

Base class for the marks a slider draws at its snap points. The slider creates one per entry in its segment list and calls Update Active as the value passes each mark; that event is empty here and the class has no visuals. Subclass it, or name the supplied default, as a slider's segment class.

| Kind | Name | Signature | Description |
|---|---|---|---|
| event | `UpdateActive` | `(Set: bool)` | Called as the handle passes a segment mark, with true for the side the handle has reached. Empty here, so a segment design overrides it to show the change; nothing happens on the base widget. |

**WBP_SliderSegment_Default**1 members

extends `WBP_SliderSegment`

Default segment mark: two nested rounded borders that change colour as the slider's value passes them. Both the standard and the custom-material slider use it as their segment class; name it on a slider of your own, or copy it for a different mark.

| Kind | Name | Signature | Description |
|---|---|---|---|
| event | `UpdateActive` | `(Set: bool)` | Repaints the segment's outer rounded border as the handle passes it, switching the fill between two theme colour categories at the same intensity, so the marks behind the handle read differently from the ones ahead of it. |

### Widgets/Input/Slider/Helper/ToolTip

**WBP_Tooltip_Slider**4 members

extends `WBP_Tooltip`

Value tooltip the standard slider raises above its knob: a rounded box with an arrow beneath it and one line of text the slider keeps updated as the value moves. Created on demand by the slider; not something to place, nor to set as a widget's tooltip class.

| Kind | Name | Signature | Description |
|---|---|---|---|
| event | `ShowTooltip` | `()` | Raises the shown flag through the parent and then plays the hover variation animation forwards, so this tooltip rises into place instead of appearing instantly as the base class does. |
| event | `HideTooltip` | `()` | Clears the shown flag through the parent and plays the hover variation animation in reverse. One of the few tooltips that animates out at all: the base class only clears the flag. |
| event | `UpdateText` | `(Text: text)` | Stores the new wording through the parent and writes it into the label, so a text change while the tooltip is up is actually visible. It reads the stored text rather than the parameter, which comes to the same thing because the parent has just written it. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

### Widgets/Input/Stepper

**WBP_Stepper**22 members

extends `WBP_Base`

Base class for steppers: a list of text entries with a current index, a decrease and an increase button that deactivate at the ends, and a replacement text shown whenever the index falls outside the list. Binds to an integer value object, and the index replicates. Subclass it and override the button, text and animation getters, or place the ready-made default.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Entries`Selection | `text[]` | Ordered list of entries the stepper moves through, one per step. Leave empty and the display falls back to the replacement text with both side buttons deactivated. |
| var | `Current Index`State | `int` | Index of the entry on show. Change it through Set Index so the text, the side buttons and any bound value object follow; an index outside the entries shows the replacement text. |
| var | `Decrease Button`Style | `ST_Button_Content` | Label and icon content given to the side button that steps backwards through the entries. |
| var | `Increase Button`Style | `ST_Button_Content` | Label and icon content given to the side button that steps forwards through the entries. |
| var | `Replacement Text`Selection | `text` | Text shown whenever the current index falls outside the entries, typically before anything has been selected. Leave empty to show nothing at all in that case. |
| fn | `UpdateReplacementText`Content | `(ReplacementText: text)` | Replaces the text used when the index is out of range. It re-applies the current index afterwards, but the change gate drops that as a repeat, so the new text only appears at the next real index change. |
| fn | `UpdateEntries`Content | `(Entries: text[])` | Replaces the whole list of entries and redraws. The current index is left as it is, so it can end up outside the new list. |
| fn | `getDisplayText`Content | `(out Output: text)` | Returns the entry at the current index, or the replacement text when the index falls outside the entries. |
| fn | `SetIndex`Content | `(NewIndex: int)` | Moves to another entry, refreshing the display, broadcasting On Index Selected and replicating the index when the widget replicates. A repeat of the current index is dropped, and the value is not clamped, so an out-of-range index shows the replacement text. |
| fn | `getChangeDeactivateAnimation`Get Selection Elements | `(out ChangeAnim: WidgetAnimation)` | Returns the animation played when the stepper is deactivated or brought back. Returns nothing in this base class; each design overrides it. |
| fn | `getChangeAnimation`Get Selection Elements | `(out ChangeAnim: WidgetAnimation)` | Returns the animation played on each step, forwards when stepping down and in reverse when stepping up. Returns nothing in this base class; a design that leaves it unset plays no animation. |
| fn | `getSideButton_Increase`Get Selection Elements | `(out Button: WBP_Button)` | Returns the button that steps forwards. Returns nothing in this base class; Update Visuals deactivates whichever button a design returns here once the last entry is reached. |
| fn | `getSideButton_Descrease`Get Selection Elements | `(out Button: WBP_Button)` | Returns the button that steps backwards. Returns nothing in this base class; Update Visuals deactivates whichever button a design returns here once the first entry is reached. |
| fn | `getValueText`get Selection Elements | `(out Text: AFText)` | Returns the text widget that displays the current entry. Returns nothing in this base class; each stepper design overrides it to point at its own text block. |
| event | `OnPressed_DecreaseButton` | `(Button: WBP_Button)` | Called when the backwards side button is pressed. Plays the change animation forwards, then broadcasts On Decreased Pressed and steps the index down by one. |
| event | `OnPressed_IncreaseButton` | `(Button: WBP_Button)` | Called when the forwards side button is pressed. Plays the change animation in reverse, then broadcasts On Increased Pressed and steps the index up by one. |
| event | `WidgetElement_ExecuteReplication`Replication | `(ReplicationIdentifier: name, Content: string[])` | Called on the other clients when a replicated value arrives for this element, carrying the identifier and its content strings. Implement it to reflect a change another player made; it is skipped on the client that sent the value. |
| event | `Deactivate` | `(Set: bool)` | Plays the deactivate animation and makes the stepper hit-test invisible, so it stays on screen but no longer answers input. Pass false to bring it back. |
| event | `AssignIntegerObject` | `(Target: Object, UseContent: bool, ApplyValue: bool)` | Binds the stepper to an integer value object so the two follow each other. Set Apply Value to push the current index into the object, leave it off to adopt the object's value, and set Use Content to replace the entries with the texts the object supplies. |
| event | `OnValueUpdated_Event` | `()` | Internal handler that pulls the bound integer object's value back into the stepper whenever that object reports a change. |
| event | `IndexSelected_Event` | `(Index: int)` | Internal handler that writes the newly selected index into the bound integer object, tagged with the widget's Source Info. |
| event | `UpdateVisuals` | `()` | Redraws the value text from the current entry and deactivates the backwards button at the first entry and the forwards button at the last, so the stepper stops at the ends rather than wrapping. |

**WBP_Stepper_Default**6 members

extends `WBP_Stepper`

Ready-made stepper: two small chevron buttons either side of a centred value in a rounded frame, with an adjustable content width. This is the stepper to place; the entries, the index and the value binding come from its parent class.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Content Width`Style | `float` | Width in slate units of the area holding the current entry, between the two chevron buttons. Defaults to 120. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getChangeDeactivateAnimation`Get Selection Elements | `(out ChangeAnim: WidgetAnimation)` | Returns the animation played when the stepper is deactivated or brought back. Returns nothing in this base class; each design overrides it. |
| fn | `getValueText`get Selection Elements | `(out Text: AFText)` | Returns the text widget that displays the current entry. Returns nothing in this base class; each stepper design overrides it to point at its own text block. |
| fn | `getSideButton_Descrease`Get Selection Elements | `(out Button: WBP_Button)` | Returns the button that steps backwards. Returns nothing in this base class; Update Visuals deactivates whichever button a design returns here once the first entry is reached. |
| fn | `getSideButton_Increase`Get Selection Elements | `(out Button: WBP_Button)` | Returns the button that steps forwards. Returns nothing in this base class; Update Visuals deactivates whichever button a design returns here once the last entry is reached. |

### Widgets/Input/Textfield

**WBP_Textfield_Area**10 members

extends `WBP_TextField`

Multi-line text field for longer input. Same keyboard handling and character-limit counter as the single-line field, but Enter inserts a line break rather than committing, so the text commits when the keyboard closes. Use it for descriptions and notes.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Typography`Style | `E_UI_Typography` | Theme typography level used for the text inside the area. Defaults to Body 2. |
| fn | `getAnimation_Selected`Animations | `(out SeletedAnim: WidgetAnimation)` | Returns the animation played forwards while the field holds keyboard focus and reversed once the keyboard closes. Empty on the base class; each design overrides it with its own. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getCharacterLimitWidget`Get Elements | `(out Widget: Widget)` | Returns the badge showing how many characters are left, the one Set Charater Limit collapses while no limit is set. Empty on the base class, and designs without such a badge leave it that way. |
| fn | `getCharacterLimitTextWidget`Get Elements | `(out Text: TextBlock)` | Returns the text block inside the badge that the remaining-character count is written into. Empty on the base class. |
| fn | `getTextBox`Get Elements | `(out TextBoxWidget: Widget)` | Implemented by the owning design to hand back its editable text box, single-line or multi-line. Answers nothing on the base class, and without it neither Set Text, Get Text nor the keyboard has anywhere to write. |
| fn | `getAnimation_Hover`Animations | `(out HoverAnim: WidgetAnimation)` | Returns the animation Set Hovered runs forwards as the cursor enters and reverses as it leaves. Empty on the base class; each design overrides it with its own. |
| event | `SequenceEvent_Action` | `()` | Called from the selected animation's event track. Pushes the current action blend value into the outline border, which is what marks the field as focused. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track. Pushes the current hover blend value into the rounded hover border. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**WBP_Textfield_Default**10 members

extends `WBP_TextField`

Standard single-line text field: a rounded box with a hint, a selection outline and a character-limit counter that appears once a limit is set. The one to place for ordinary text input; the keyboard, the replication and the text events all come from its parent class.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Typography`Style | `E_UI_Typography` | Theme typography level used for the text inside the field. Defaults to Body 2. |
| fn | `getAnimation_Selected`Animations | `(out SeletedAnim: WidgetAnimation)` | Returns the animation played forwards while the field holds keyboard focus and reversed once the keyboard closes. Empty on the base class; each design overrides it with its own. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getCharacterLimitWidget`Get Elements | `(out Widget: Widget)` | Returns the badge showing how many characters are left, the one Set Charater Limit collapses while no limit is set. Empty on the base class, and designs without such a badge leave it that way. |
| fn | `getCharacterLimitTextWidget`Get Elements | `(out Text: TextBlock)` | Returns the text block inside the badge that the remaining-character count is written into. Empty on the base class. |
| fn | `getTextBox`Get Elements | `(out TextBoxWidget: Widget)` | Implemented by the owning design to hand back its editable text box, single-line or multi-line. Answers nothing on the base class, and without it neither Set Text, Get Text nor the keyboard has anywhere to write. |
| fn | `getAnimation_Hover`Animations | `(out HoverAnim: WidgetAnimation)` | Returns the animation Set Hovered runs forwards as the cursor enters and reverses as it leaves. Empty on the base class; each design overrides it with its own. |
| event | `SequenceEvent_Hover` | `()` | Called from an animation event track. Despite the name it pushes the focus blend value into the outline border, the one that marks the field as selected. |
| event | `SequenceEvent_Action` | `()` | Called from an animation event track. Despite the name it pushes the hover blend value into the rounded hover border; in this design the two sequence events are wired the opposite way round to the other text fields. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**WBP_Textfield_Password**8 members

extends `WBP_TextField`

Password field: a single-line text field with its characters masked, plus a small round button carrying an eye icon that reveals them while it is selected. Otherwise identical to the standard field. Use it wherever typed text should not be readable over the player's shoulder.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Typography`Style | `E_UI_Typography` | Theme typography level used for the text inside the field, masked characters included. Defaults to Body 2. |
| fn | `getAnimation_Selected`Animations | `(out SeletedAnim: WidgetAnimation)` | Returns the animation played forwards while the field holds keyboard focus and reversed once the keyboard closes. Empty on the base class; each design overrides it with its own. |
| fn | `getTooltipAnchor`Get Elements | `(out MenuAnchor: MenuAnchor)` | Implemented by the owning widget to hand back the menu anchor its tooltip hangs from; the buttons, sliders, text fields and drop-downs each return the anchor built into their designer tree. Answers nothing here, so a widget without such an anchor shows no tooltip. |
| fn | `getTextBox`Get Elements | `(out TextBoxWidget: Widget)` | Implemented by the owning design to hand back its editable text box, single-line or multi-line. Answers nothing on the base class, and without it neither Set Text, Get Text nor the keyboard has anywhere to write. |
| fn | `getAnimation_Hover`Animations | `(out HoverAnim: WidgetAnimation)` | Returns the animation Set Hovered runs forwards as the cursor enters and reverses as it leaves. Empty on the base class; each design overrides it with its own. |
| event | `SequenceEvent_Action` | `()` | Called from the selected animation's event track. Pushes the current action blend value into the outline border, which is what marks the field as focused. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track. Pushes the current hover blend value into the rounded hover border. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

### Widgets/Input/Textfield/Parents

**WBP_TextField**27 members

extends `WBP_Base`

Base class for text fields. Holds the text, the hint and the character limit, raises the framework's virtual keyboard through the widget component where one is supported and falls back to Slate keyboard focus where it is not, and reports changes and commits; the text replicates. Choose the keyboard class, extension and keyboard location on it, and subclass it when a field needs a new look.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Text`Content | `text` | Content the field holds. It is not written into the text box as the widget is built, so a value set here shows only once Set Text or Update Visuals has run; at runtime Update Text keeps it in step with what was typed. |
| var | `Keyboard Class`Keyboard | `class<WBP_Keyboard>` | Virtual keyboard spawned when the field is pressed on a host that has no real keyboard. Leave empty and the keyboard location has nothing to build, leaving the user with a field they cannot type into. |
| var | `Extension Class`Keyboard | `class<WBP_Keyboard_Extension>` | Extra panel the keyboard builds beside itself, for a number pad or similar. Leave empty for a keyboard with no extension. |
| var | `Keyboard Location`Keyboard | `class<BP_KeyboardLocation>` | Location object deciding where the keyboard appears: as an overlay hanging under the field, as a body-locked panel, or wherever your own class puts it. Leave empty and no keyboard is created at all. |
| var | `Close on Enter`Keyboard | `bool` | Whether pressing Enter commits the text and closes the keyboard, on by default. It is handed over as the keyboard is created, so changing it afterwards leaves an open keyboard as it was. |
| var | `Key Board Size Multiplier`Keyboard | `float` | Scale the keyboard is created at, 0.75 by default, relative to the size its location would otherwise give it. |
| var | `Hint`Content | `text` | Placeholder text shown while the field is empty. Nothing applies it as the widget is built, so push it in through Update Hint Text rather than setting it here. |
| var | `Character Limit`Content | `int` | Longest text the field accepts, in characters. At -1, the default, nothing is trimmed and the remaining-character badge stays hidden; the badge is shown and refreshed by Set Charater Limit and Update Visuals. |
| fn | `UpdateHintText`Content | `(Hint: text)` | Stores the placeholder and writes it into the editable text box as its hint, single-line or multi-line. This is the only route by which the hint reaches the screen. |
| fn | `SetCharaterLimit`Content | `(CharacterLimit: int)` | Records the character limit, then shows or collapses the remaining-character badge to match and writes the current count into it. A limit of -1 hides the badge again; text already in the field is not trimmed retrospectively. |
| fn | `getAnimation_Selected`Animations | `(out SeletedAnim: WidgetAnimation)` | Returns the animation played forwards while the field holds keyboard focus and reversed once the keyboard closes. Empty on the base class; each design overrides it with its own. |
| fn | `getCharacterLimitTextWidget`Get Elements | `(out Text: TextBlock)` | Returns the text block inside the badge that the remaining-character count is written into. Empty on the base class. |
| fn | `getCharacterLimitWidget`Get Elements | `(out Widget: Widget)` | Returns the badge showing how many characters are left, the one Set Charater Limit collapses while no limit is set. Empty on the base class, and designs without such a badge leave it that way. |
| fn | `getAnimation_Hover`Animations | `(out HoverAnim: WidgetAnimation)` | Returns the animation Set Hovered runs forwards as the cursor enters and reverses as it leaves. Empty on the base class; each design overrides it with its own. |
| fn | `OnPreviewMouseButtonDown`Mouse | `(MyGeometry: Geometry, MouseEvent: PointerEvent) → EventReply` | Just like OnMouseButtonDown, but tunnels instead of bubbling. If this event is handled, OnMouseButtonDown will not be sent. Use this event sparingly as preview events generally make UIs more difficult to reason about. @param MyGeometry The Geometry of the widget receiving the event @param MouseEvent Information about the input event @return Whether the event was handled along with possible requests for the system to take action. |
| fn | `getTextBox`Get Elements | `(out TextBoxWidget: Widget)` | Implemented by the owning design to hand back its editable text box, single-line or multi-line. Answers nothing on the base class, and without it neither Set Text, Get Text nor the keyboard has anywhere to write. |
| fn | `getText`Content | `() → text` | Returns the text as the editable text box currently holds it, which is the live value rather than the one last stored. Comes back empty on a design that provides no text box. |
| fn | `SetText`Content | `(InText: text)` | Writes the given text into this widget and into the editable text box behind it, single-line or multi-line as the design provides. No limit is applied and nothing is broadcast, so use Update Text for text the user has entered. |
| event | `SpawnKeyboard` | `()` | Plays the selected animation, broadcasts On Keyboard Focus Changed, then asks the host whether a virtual keyboard is supported. If it is, the keyboard location builds one for this field and its closing is subscribed to; if not, keyboard focus is handed straight to the text box. Reached by pressing the field rather than called by hand. |
| event | `UpdateText` | `(Text: text)` | Records text the user has entered, cut to the character limit where one is set, refreshes the display and broadcasts On Text Changed, sending the text on to the other clients when the widget replicates. Nothing happens when the text is unchanged, and no shipped design binds it, so wire it to your text box's own text-changed event. |
| event | `WidgetElement_ExecuteReplication`Replication | `(ReplicationIdentifier: name, Content: string[])` | Called on the other clients when a replicated value arrives for this element, carrying the identifier and its content strings. Implement it to reflect a change another player made; it is skipped on the client that sent the value. |
| event | `OnMouseEnter`Mouse | `(MyGeometry: Geometry, MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has entered it. This event is NOT bubbled. @param MyGeometry The Geometry of the widget receiving the event @param MouseEvent Information about the input event |
| event | `OnMouseLeave`Mouse | `(MouseEvent: PointerEvent)` | The system will use this event to notify a widget that the cursor has left it. This event is NOT bubbled. @param MouseEvent Information about the input event |
| event | `TextCommitedEvent` | `(Text: text, CommitMethod: ETextCommit)` | Broadcasts On Text Committed with the way the text was committed, and does nothing else; the text handed in is neither read nor stored. The virtual keyboard calls it with On Enter when the user presses Enter and Close On Enter is set. |
| event | `UpdateVisuals` | `()` | Pushes the stored text back into the editable text box and, while a character limit is set, refreshes the count of characters left. Called by Update Text after every accepted change. |
| event | `KeyboardClosed_Event` | `()` | Internal handler subscribed to the keyboard location as a keyboard is created. Reverses the selected animation and broadcasts On Keyboard Focus Changed once more, which is what returns the field to its unselected look. |
| event | `SetHovered` | `(Set: bool)` | Records the hover and runs the hover animation forwards or backwards to match. Ignored when the value has not actually changed; the field's own mouse-enter and mouse-leave overrides are empty, so something else has to call it as the cursor arrives. |

### Widgets/Layout/Box

**WBP_Box**6 members

extends `WBP_Base`

Root of the box family: a container wrapping its content in a size box and exposing Width Override and Height Override so a panel can be pinned to a fixed size in the details panel or changed at runtime. It draws no layout of its own, so use one of the box variants or subclass it and return your own size box.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Width Override`Dimensions | `ST_SizeOverride` | Optional fixed width for the box's own size box, in slate units. It reaches the layout only through Set Width Override Main Box, so editing it in the details panel on its own resizes nothing; with the override flag off the box takes its width from its content. |
| var | `Height Override`Dimensions | `ST_SizeOverride` | Optional fixed height for the box's own size box, in slate units. It reaches the layout only through Set Height Override Main Box; with the override flag off the box takes its height from its content. |
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `getSizeBox`getElements | `(out SizeBox: SizeBox)` | Returns the size box that the width and height overrides are applied to. It comes back empty here, so every box variant overrides it with the size box from its own designer tree. |
| event | `SetWidthOverride_MainBox` | `(Width_Override: ST_SizeOverride)` | Stores the given width override and applies it to the box's size box, fixing the width while the override flag is on and clearing it back to auto-sizing otherwise. Use it in place of writing to Width Override, since nothing else pushes that value into the layout. |
| event | `SetHeightOverride_MainBox` | `(Height_Override: ST_SizeOverride)` | Stores the given height override and applies it to the box's size box, fixing the height while the override flag is on and clearing it back to auto-sizing otherwise. |

**WBP_Box_Card**4 members

extends `WBP_Box`

Box pairing a picture with its content. Adds a Texture and an Update Image call on top of the plain box while leaving where the image sits to its subclasses. Take the left or top card for the shipped arrangements, or subclass it when a card of your own needs the picture somewhere else.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Texture`Image | `Texture` | Picture the card shows. It reaches the image element only through Update Image, so dropping a texture in here records the value while the card carries on showing whatever the designer set. |
| fn | `getImage`Get Elements | `(out Image: AFImage)` | Returns the image element that Update Image writes to. It comes back empty in this base card, so the card variants override it with the rounded image from their own designer tree. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |
| event | `UpdateImage` | `(Texture: Texture)` | Stores the given texture and hands it to the card's image, which swaps it into its material and re-applies its size rule. Nothing happens on the base card, whose Get Image returns nothing. |

**WBP_Box_Card_Left**4 members

extends `WBP_Box_Card`

Card with its picture down the left-hand side and the content slot filling the space beside it, sized 800 by 250 by default. Use it for a wide, row-shaped card in a list or a scrolling field, and set Texture on the instance; a fallback image shows until you do.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getImage`Get Elements | `(out Image: AFImage)` | Returns the image element that Update Image writes to. It comes back empty in this base card, so the card variants override it with the rounded image from their own designer tree. |
| fn | `getSizeBox`getElements | `(out SizeBox: SizeBox)` | Returns the size box that the width and height overrides are applied to. It comes back empty here, so every box variant overrides it with the size box from its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**WBP_Box_Card_Top**4 members

extends `WBP_Box_Card`

Card with its picture across the top and the content slot beneath it, sized 300 by 400 by default. The upright counterpart to the left-hand card, meant for grids and galleries of tiles. Set Texture on the instance and put the caption or controls in the slot.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getImage`Get Elements | `(out Image: AFImage)` | Returns the image element that Update Image writes to. It comes back empty in this base card, so the card variants override it with the rounded image from their own designer tree. |
| fn | `getSizeBox`getElements | `(out SizeBox: SizeBox)` | Returns the size box that the width and height overrides are applied to. It comes back empty here, so every box variant overrides it with the size box from its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `WidgetElement_UpdateTheme`Style | `(Theme: BP_PDA_Theme, Desktop: bool)` | Called on every element of a widget tree at start-up and again each time a new theme is applied, carrying the theme and the desktop flag. Implement it for anything that reads colours, fonts or metrics; it runs after Initiate, so content already exists by then. |

**WBP_Box_Default**3 members

extends `WBP_Box`

Plain rounded panel with a single content slot, its fill and corner radius taken from the theme. The everyday container for grouping a few elements inside a larger interface: drop it in and fill the slot. Use a scaffold instead when the panel is the outermost frame of a whole widget.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `getSizeBox`getElements | `(out SizeBox: SizeBox)` | Returns the size box that the width and height overrides are applied to. It comes back empty here, so every box variant overrides it with the size box from its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |

### Widgets/Layout/Collapse

**WBP_Collapse**9 members

extends `WBP_Base`

Wrapper that slides its content out of view and back. Direction chooses which edge it collapses towards; Set Collapse and Toggle Collapse drive it, animating the content's maximum desired size, playing the collapse and expand sounds and replicating the state to other players. Put the content in the slot rather than hiding widgets yourself.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Is Collapsed`State | `bool` | Whether the content is currently hidden away. It starts collapsed and is meant to be changed through Set Collapse or Toggle Collapse, which animate, sound and replicate the change; writing to it directly leaves the layout as it was. |
| var | `Direction`State | `E_UI_Direction_2D` | Edge the content stays pinned to while the widget shrinks. Left and Right collapse the width, Up and Down the height. Refresh is what turns this into anchors and a size clamp. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `SequenceEvent_Collapse` | `()` | Called from the expand animation as it plays. Drives the size box's maximum width or height from Collapse Progress, which is what squeezes the content along the collapse direction frame by frame. |
| event | `SetCollapse` | `(Set: bool)` | Collapses or expands the content, doing nothing when the state already matches. Plays the matching sound, broadcasts On Collapse Changed and runs the expand animation forwards or backwards, sending the new state to the other clients as it goes; the size box's overrides are cleared once an expansion has finished. |
| event | `ToggleCollapse` | `()` | Flips the collapsed state by calling Set Collapse with the opposite value, so the sound, the animation and the replication happen exactly as they would for a direct call. |
| event | `WidgetElement_ExecuteReplication`Replication | `(ReplicationIdentifier: name, Content: string[])` | Called on the other clients when a replicated value arrives for this element, carrying the identifier and its content strings. Implement it to reflect a change another player made; it is skipped on the client that sent the value. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |
| event | `Refresh` | `()` | Re-applies the layout for the current direction: anchors the content slot to that edge and clamps the size box's maximum width or height to zero while collapsed. Nothing calls it for you, so call it yourself after changing Direction or Is Collapsed by hand. |

### Widgets/Layout/ContentScroller

**WBP_ScrollableField**7 members

extends `WBP_Base`

Base for a scrolling area driven by its own back and forward buttons instead of a visible scroll bar. Each press moves the scroll box by Scroll Step Distance, and the buttons deactivate as the content reaches either end. Take the horizontal or vertical variant, or subclass it and return your own scroll box and arrow pair.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Scroll Step Distance`Config | `float` | How far one press of an arrow button moves the content, in slate units. The horizontal variant raises it to 800. |
| fn | `OnScrollOffsetUpdated`Actions | `()` | Greys out whichever arrow has nowhere left to go: the back one within 5 units of the top of the content, the forward one within 5 units of its end. Run it whenever the offset changes, or the arrows stop telling the truth. |
| fn | `OnPressed_ForwardButton`Actions | `(Button: WBP_Button)` | Steps the content forward by Scroll Step Distance through the scroll box's smooth Add Scroll Offset, so the move is animated and stops at the end of the content. |
| fn | `OnPressed_BackButton`Actions | `(Button: WBP_Button)` | Steps the content back by Scroll Step Distance through the scroll box's smooth Add Scroll Offset, so the move is animated and stops at the top of the content. |
| fn | `getArrowButtons`Get Elements | `(out ButtonBack: WBP_Button, out ButtonForward: WBP_Button)` | Returns the back and forward arrow buttons as a pair. It comes back empty here, so each variant overrides it with the two buttons for its own orientation. |
| fn | `getScrollbox`Get Elements | `(out Scrollbox: AFScrollbox)` | Returns the scroll box holding the content. It comes back empty here, so each variant overrides it with the scroll box from its own designer tree. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

**WBP_ScrollableField_Horizontal**4 members

extends `WBP_ScrollableField`

Scrolling field laid out sideways, with round scroll-arrow buttons pinned over the left and right edges of the content and a default step of 800. Use it for a row of cards or buttons wider than the space available; fill the slot and it drives and deactivates the arrows itself.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getScrollbox`Get Elements | `(out Scrollbox: AFScrollbox)` | Returns the scroll box holding the content. It comes back empty here, so each variant overrides it with the scroll box from its own designer tree. |
| fn | `getArrowButtons`Get Elements | `(out ButtonBack: WBP_Button, out ButtonForward: WBP_Button)` | Returns the back and forward arrow buttons as a pair. It comes back empty here, so each variant overrides it with the two buttons for its own orientation. |
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |

**WBP_ScrollableField_Vertical**4 members

extends `WBP_ScrollableField`

Scrolling field laid out downwards, with the framework's arrow buttons floating above and below the content. Use it for a tall list inside a panel of fixed height; fill the slot and the arrows enable and disable themselves as each end of the content comes into view.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getScrollbox`Get Elements | `(out Scrollbox: AFScrollbox)` | Returns the scroll box holding the content. It comes back empty here, so each variant overrides it with the scroll box from its own designer tree. |
| fn | `getArrowButtons`Get Elements | `(out ButtonBack: WBP_Button, out ButtonForward: WBP_Button)` | Returns the back and forward arrow buttons as a pair. It comes back empty here, so each variant overrides it with the two buttons for its own orientation. |
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |

### Widgets/Layout/ContentScroller/Helper

**WBP_Button_Scrollarrow**11 members

extends `WBP_Button`

Round arrow button the horizontal scrolling field pins over its content, with Angle rotating the icon to point whichever way a press should scroll. Carries its own press, hover and blocked sounds and a hover animation that swells the icon. Built for that widget; use the standard arrow button for arrows elsewhere.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Angle`Style | `float` | Rotation in degrees the arrow icon is meant to be drawn at. Nothing in the graph reads it; the scrollable fields set it to 90 and minus 90 on their two arrows, so it stands as a marker on the instance rather than turning the icon itself. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getBlendableElements_Hover`Get Elements | `(out Blendable: BPI_Widget_Blend[])` | Returns the elements whose blend value follows the hover animation, typically the hover outline. Empty on the base class; each button design overrides it. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's own event track as it plays. Pushes the current hover blend value into the rounded hover border through Update Animation Hover. |

### Widgets/Layout/Expandable

**WBP_Expandable_Default**6 members

extends `WBP_Expandable`

Expandable with a header row and an arrow button at its right-hand end that toggles the content open and shut. Fill the header slot with a title or a whole row of widgets and the content slot with what should be revealed; the button is wired up for you.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getButton`Get Elements | `(out Button: WBP_Button)` | Returns the header button whose selected state is kept in step with the expansion. Empty here, and a variant with no header button can leave it that way, since Set Expanded checks it first. |
| fn | `getAnimation`Expandable | `(out Animation: WidgetAnimation)` | Returns the animation played alongside the area's roll-out, forwards when opening and backwards when closing. Empty here; each variant overrides it with its own. |
| fn | `getExpandableWidget`Expandable | `(out Expandable: ExpandableArea)` | Returns the expandable area the widget wraps, which Set Expanded opens and shuts with its animated roll-out. Empty here; each variant overrides it with the area from its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| fn | `WidgetElement_getCustomChildWidgets`Slots | `(out Widgets: Widget[])` | Returns child widgets the tree walk would not otherwise reach, typically ones held in a variable rather than in the slot hierarchy. Listing them here is what gets them initiated, themed and cleaned up along with the rest of the tree. |
| event | `Deactivate`State | `(Set: bool)` | Records that the expandable should stop responding. Nothing in the framework reads the flag afterwards, so it stands as a marker for your own widget to act on, and the default variant overrides the call with an empty body. |

**WBP_Expandable_Empty**4 members

extends `WBP_Expandable`

Expandable with no button of its own: the header slot spans the full width and you decide what opens it, calling Set Expanded or Toggle Expanded from your own widget. Nothing in the shipped content uses it, so treat it as the starting point for a header that is not a plain arrow row.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Content Padding`Style | `Margin` | Margin intended for the space around the content slot. No node in the graph applies it, so the slot keeps the padding set in the designer and this stays a value for the owning widget to read. |
| fn | `getAnimation`Expandable | `(out Animation: WidgetAnimation)` | Returns the animation played alongside the area's roll-out, forwards when opening and backwards when closing. Empty here; each variant overrides it with its own. |
| fn | `getExpandableWidget`Expandable | `(out Expandable: ExpandableArea)` | Returns the expandable area the widget wraps, which Set Expanded opens and shuts with its animated roll-out. Empty here; each variant overrides it with the area from its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |

### Widgets/Layout/Expandable/Parents

**WBP_Expandable**10 members

extends `WBP_Base`

Base for a header that reveals a block of content beneath it. Owns the expanded state, the reveal animation, the expand and collapse sounds, replication of the state and keeping its header button's selected look in step. Use the default variant, or subclass it and return your own expandable area, animation and button.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Is Expanded`State | `bool` | Whether the area is currently open. Drive it through Set Expanded so the roll-out, the animation, the cue and the header button follow; writing here moves nothing. |
| fn | `OnExpansionChanged`State | `(Area: ExpandableArea, bIsExpanded: bool)` | Internal handler for the expandable area's own expansion delegate. Feeds the area's new state back through Set Expanded, so the cue, the animation, the replication and the header button keep up when the area is opened by its native header. |
| fn | `ToggleExpanded`State | `()` | Flips the expansion through Set Expanded, so the roll-out, the cue, the animation, the replication and the header button all follow. |
| fn | `Deactivate`State | `(Set: bool)` | Records that the expandable should stop responding. Nothing in the framework reads the flag afterwards, so it stands as a marker for your own widget to act on, and the default variant overrides the call with an empty body. |
| fn | `getButton`Get Elements | `(out Button: WBP_Button)` | Returns the header button whose selected state is kept in step with the expansion. Empty here, and a variant with no header button can leave it that way, since Set Expanded checks it first. |
| fn | `getAnimation`Expandable | `(out Animation: WidgetAnimation)` | Returns the animation played alongside the area's roll-out, forwards when opening and backwards when closing. Empty here; each variant overrides it with its own. |
| fn | `getExpandableWidget`Expandable | `(out Expandable: ExpandableArea)` | Returns the expandable area the widget wraps, which Set Expanded opens and shuts with its animated roll-out. Empty here; each variant overrides it with the area from its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `SetExpanded` | `(Set: bool)` | Opens or shuts the area with its animated roll-out and plays the expand animation alongside it, then plays the expand or collapse cue, broadcasts On Expand Changed, replicates the new state and mirrors it onto the header button. Ignored when the value is unchanged. |
| event | `WidgetElement_ExecuteReplication`Replication | `(ReplicationIdentifier: name, Content: string[])` | Called on the other clients when a replicated value arrives for this element, carrying the identifier and its content strings. Implement it to reflect a change another player made; it is skipped on the client that sent the value. |

### Widgets/Layout/Groups

**WBP_Group_Button_Horizontal**2 members

extends `WBP_Group_Button`

Button group arranging its buttons in a row, spaced by the preferred padding of whichever button class is chosen. Use it for a bar of actions across the bottom of a panel; the default popup and overlay build their confirm and cancel row with it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |

**WBP_Group_Button_Vertical**2 members

extends `WBP_Group_Button`

Button group arranging its buttons in a column, which is the framework's default menu shape and by far the most used group. Fill Content with button entries and it creates, spaces and manages the selection of the buttons; the desktop menu, the drop-down list and most of the examples are built on it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |

**WBP_Group_Button_WrapBox**6 members

extends `WBP_Group_Button`

Button group whose buttons flow onto a new line when they run out of width. Num Of Elements In Column fixes how many sit on a line by overriding the group's width from the button width and padding; leave it at zero to let the wrap box decide. Use it for a keypad or a grid of choices rather than a single row.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Num Of Elements in Column`Style\|Wrap Box | `int` | How many buttons a row should hold before the wrap box wraps. Post Add Design turns it into a width override on the box; leave it at zero to let the box take whatever width it is given. |
| var | `Max Width Limit to Elements`Style\|Wrap Box | `bool` | Whether the calculated width is capped at the number of buttons actually present. Leave it off to keep the group wide enough for a full row even when it holds fewer buttons than that. |
| var | `Width Correction Value`Style\|Wrap Box | `float` | Intended as a manual nudge to the calculated wrap width. Nothing in the graph reads it, so changing it has no effect on the layout. |
| fn | `PostAddDesign`Style | `()` | Trims the padding off the two ends of the group so it sits flush with its neighbours: the top of the first item and the bottom of the last in a column, the outer sides in a row, and a matching negative padding on the box itself for a wrap box. Run it after a batch of additions. |
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |

**WBP_Group_Widget_Horizontal**1 members

extends `WBP_Group_Widget`

Widget group arranging its items in a row. Nothing in the shipped content uses it, unlike the vertical and wrap box variants, but it is the one to reach for when a run of identical widgets should sit side by side: set Widget Class and populate it in the usual way.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |

**WBP_Group_Widget_Vertical**1 members

extends `WBP_Group_Widget`

Widget group arranging its items in a column, the usual choice for a stack of identical rows. Set Widget Class, then populate or resize the group and each item is created, added and padded for you. The example configurator and the expand tree build their contents this way.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |

**WBP_Group_Widget_WrapBox**1 members

extends `WBP_Group_Widget`

Widget group arranging its items in a wrap box, so they flow onto a new line when they run out of width. Use it for a gallery of tiles or colour swatches whose count is not known in advance, as the example configurator does.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |

### Widgets/Layout/Groups/Parents

**WBP_Group**17 members

extends `WBP_Base`

Root of the group family: a widget owning a list of child widgets and keeping a panel in step with it. Add, remove, populate, clear and resize the list through its functions and it applies the size rule, the alignment and each child's preferred padding, then trims the padding off the outer edges. Use a button or widget group, whose variants supply the panel.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Override Padding`Style\|Box | `bool` | Whether the group spaces its items with Item Padding instead of asking each one for the padding it wants. Leave it off and every item is spaced by its own desired padding, which is what the framework's widgets are built around. |
| var | `Item Padding`Style\|Box | `Margin` | Spacing put around each item while Override Padding is on, in slate units. It is ignored entirely with that switched off, and the wrap box variants also read it when working out their width. |
| var | `Size Rule`Style\|Box | `ESlateSizeRule` | How each item's slot divides the space in a row or column, automatic by default so that items take their desired size. Fill shares the space out instead; a wrap box group ignores it. |
| var | `Vertical Alignment`Style\|Box | `EVerticalAlignment` | How each item sits within its slot in a column, filling it by default. A row or wrap box group ignores it. |
| var | `Horizontal Alignment`Style\|Box | `EHorizontalAlignment` | How each item sits within its slot in a row, filling it by default. A column or wrap box group ignores it. |
| fn | `ResizeWidgetGroup`Group | `(Length: int)` | Grows or shrinks the group to the number of items you ask for, adding through Add Default Widget and removing from the end. A group whose Add Default Widget does nothing can never reach a larger count, and only a safety counter stops the loop. |
| fn | `PostAddDesign`Style | `()` | Trims the padding off the two ends of the group so it sits flush with its neighbours: the top of the first item and the bottom of the last in a column, the outer sides in a row, and a matching negative padding on the box itself for a wrap box. Run it after a batch of additions. |
| fn | `getGroupLength`Group | `() → int` | Returns how many items the group currently holds. |
| fn | `AddDefaultWidget`Group | `()` | Adds one more item of whatever kind the group is built from. Empty here, so a plain group cannot grow itself; the button and widget groups override it, which is also what makes Resize Widget Group work for them. |
| fn | `ClearGroup`Group | `()` | Removes every item from the tree and empties the group's list, leaving it ready to be filled again. |
| fn | `RemoveWidgetFromGroupByIndex`Group | `(Index: int)` | Removes the item at that position from the tree and drops it from the group's list. An out-of-range position does nothing. |
| fn | `RemoveWidgetFromGroup`Group | `(ItemToFind: WBP_Base)` | Takes a widget you already hold out of the group, looking its position up first. A widget that is not in the group resolves to an invalid position and nothing is removed. |
| fn | `PopulateWidgets`Group | `(Widgets: WBP_Base[])` | Replaces the contents of the group with the widgets you pass in, clearing what was there, placing each one and trimming the padding at the two ends afterwards. |
| fn | `DesignWidget`Style | `(Widget: WBP_Base, Index: int)` | Places one widget into the group's panel and styles its slot: size rule and alignment for a column or a row, then either Item Padding while Override Padding is on or the widget's own desired padding. A panel that is none of the three leaves the widget unplaced. |
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |
| fn | `AddWidgetToGroup`Group | `(Widget: WBP_Base, out Index: int)` | Appends a widget you have already created to the group, places it in the panel through Design Widget and hands back the position it was given. The padding at the two ends is not re-trimmed, so call Post Add Design once you have finished adding. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

**WBP_Group_Button**54 members

extends `WBP_Group`

Button Collections allow the listing and Management of Buttons.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Automatic Selection`Selection | `bool` | Whether a click changes the group's selection by itself. With it on the click is applied under the Selection Type rule and On Button Selection Changed follows; with it off only On Button Clicked is broadcast and the selection is left to you. |
| var | `Selection Type`Selection | `E_UI_Group_Selection` | Rule deciding how many buttons can be held at once: single select, single select that can be clicked off again, or multiple select. It is also read as each button is created, since single select makes a button unhoverable while it is selected. |
| var | `Content`Content | `ST_Button_Content[]` | Identifier, texts and images for each button, one entry per button. Push changes in through Populate Buttons or Update Buttons; the list is also rewritten by the group itself as buttons are added and removed. |
| var | `Button Class`Style\|Button | `class<WBP_Button>` | Button design every entry of the group is built from. Leave it empty and no button is ever created, so the group stays empty however much content it is given. |
| var | `Content Widget Class`Style\|Button | `class<WBP_ButtonContent>` | Content widget class handed to each button as it is created, for designs carrying more than a single label and icon. Leave it empty to let the buttons draw their content into their own text and image elements. |
| var | `Width Override`Style\|Button | `ST_SizeOverride` | Fixed width applied to every button as it is created. With the override switched off each button falls back to the width set on its own class defaults. |
| var | `Height Override`Style\|Button | `ST_SizeOverride` | Fixed height applied to every button as it is created. With the override switched off each button falls back to the height set on its own class defaults. |
| var | `Button Padding`Style\|Button | `Margin` | Margin intended for the space around each button. Nothing in the graph reads it, so the spacing comes from Item Padding or from the buttons' own desired padding instead. |
| var | `Button Preset`Style\|Button | `E_UI_Hierarchy` | Emphasis level every button is created at, primary through quaternary. It is read only at creation, so use Update Button Presets to restyle buttons that already exist. |
| var | `Select by ID`Selection | `bool` | Whether selection is tracked by the buttons' identifiers rather than by their positions. With it on the group paints itself from Selected IDs and ignores Selected Indexes, which is what you want for content that is reordered or rebuilt. |
| var | `Selected Indexes`Selection | `int[]` | Positions of the buttons counting as selected while the group is selecting by position. Change it through Set Button Selected or Set Button Selected Indexes; editing it directly leaves the buttons showing the old selection. |
| var | `Selected IDs`Selection | `name[]` | Identifiers of the buttons counting as selected while Select By ID is on. Change it through Set Button Selected ID or Set Button Selected IDs; editing it directly leaves the buttons showing the old selection. |
| fn | `SetButtonSelected_IDs`Selected | `(IDs: name[])` | Replaces the whole selection with the identifiers you pass in, repaints every button and broadcasts On Button Selection Changed. Nothing happens when the list matches what is already selected. |
| fn | `ConvertTextsToConent`Conversion | `(out IDs: name[], out Texts: text[], Conent: ST_Button_Content[])` | Builds button content out of a list of texts, pairing each one with the identifier at the same position and giving each button a single label. Pass an empty identifier list when the buttons do not need one, as the integer binding does. |
| fn | `UpdateButtonPresets`Style | `(Presets: E_UI_Hierarchy[])` | Restyles the buttons in order from the emphasis levels you pass in, one per button, re-applying the theme to each. Levels beyond the number of buttons present are ignored. |
| fn | `ClearGroup`Group | `()` | Removes every item from the tree and empties the group's list, leaving it ready to be filled again. |
| fn | `DeactivateAllButtons`Deactivate | `(Set: bool)` | Deactivates or reactivates every button in the group at once, each one running its own deactivate animation. |
| fn | `SetButtonDeactivated_ID`Deactivate | `(ID: name, Set: bool)` | Deactivates or reactivates the button carrying that identifier. An identifier that is not in the content resolves to an invalid position and nothing happens. |
| fn | `SetButtonDeactivated`Deactivate | `(Index: int, Set: bool)` | Deactivates or reactivates the button at that position, running its deactivate animation and stopping it responding to input. An out-of-range position is ignored. |
| fn | `SetButtonCustomState_ID`Custom | `(ID: name, Set: bool)` | Switches the design-defined custom state of the button carrying that identifier. An identifier that is not in the content resolves to an invalid position and nothing happens. |
| fn | `SetButtonCustomState`Custom | `(Index: int, Set: bool)` | Switches the design-defined custom state of the button at that position, running its custom animation. An out-of-range position is ignored. |
| fn | `SetButtonSelected_Indexes`Selected | `(ButtonIndex: int[])` | Replaces the whole selection with the positions you pass in, repaints every button and broadcasts On Button Selection Changed. Nothing happens when the list matches what is already selected. |
| fn | `SetButtonSelected_ID`Selected | `(ID: name, ButtonSet: bool)` | Selects or deselects the button carrying that identifier, repaints every button and broadcasts On Button Selection Changed, replicating the new selection. Both single select rules replace the whole selection, and a group that is not selecting by identifier repaints from its position list, so the call changes nothing on screen there. |
| fn | `SetButtonSelected`Selected | `(ButtonIndex: int, ButtonSet: bool)` | Selects or deselects the button at that position, repaints every button and broadcasts On Button Selection Changed, replicating the new selection. Both single select rules replace the whole selection; a group with Select By ID on repaints from its identifier list, so the call changes nothing on screen there. |
| fn | `getButtonSelected_ID`Selected | `(ID: name, out Selected: bool)` | Returns whether the button with that identifier counts as selected, reading the identifier list. |
| fn | `getButtonByIndex`Conversion | `(Index: int, out Button: WBP_Button)` | Returns the button at that position, or nothing when the position is out of range or the item sitting there is not a button. |
| fn | `getIndexWithID`Conversion | `(ID: name, out Index: int)` | Returns the position of the button carrying that identifier, or -1 when the identifier is None or is not in the content. Answers are cached as they are found, and the cache is emptied whenever the group is cleared. |
| fn | `getButtonSelected`Selected | `(Index: int, out Selected: bool)` | Returns whether the button at that position counts as selected. It reads the position list, so a group selecting by identifier answers from a list it is not using. |
| fn | `getSelected_Indexes`Selected | `(out SelectedIndexes: int[])` | Returns the positions of every selected button, straight from the group's own list. |
| fn | `AddDefaultWidget`Group | `()` | Adds one more item of whatever kind the group is built from. Empty here, so a plain group cannot grow itself; the button and widget groups override it, which is also what makes Resize Widget Group work for them. |
| fn | `UpdateButtons`Content | `(ButtonContent: ST_Button_Content[])` | Resizes the group to match the content you pass in, stores it, and pushes each entry into the button at the same position. Cheaper than Populate Buttons, since the existing buttons are kept and only their content is refreshed. |
| fn | `PopulateButtons`Content | `(ButtonContent: ST_Button_Content[], out Buttons: WBP_Button[])` | Rebuilds the group from the content you pass in, clearing what was there, creating one button per entry, trimming the end padding and handing the new buttons back. Use it when the whole set of options changes; Update Buttons is the cheaper call when only the content does. |
| fn | `AddButtonToGroup`Content | `(ButtonContent: ST_Button_Content, out Button: WBP_Button)` | Creates one button from the group's button class, appends its content, places it in the panel and subscribes the group to its click and hover events. The button is created in manual mode so it never selects itself, and a single select group also makes it unhoverable while selected. |
| fn | `getSelected_IDs`Selected | `(out SelectedButtons: name[])` | Returns the identifiers of every selected button, straight from the group's own list. |
| fn | `getSelectionArray`Selected | `(out SelectedButtons: bool[])` | Returns one flag per button saying whether it counts as selected. The flags are worked out from the position list even when the group is selecting by identifier. |
| fn | `findSelectedID`Selected | `(out ID: name)` | Returns the identifier of the first selected button, or None when nothing is selected. It reads the identifier list only, so it answers None throughout for a group selecting by position. |
| fn | `findSelected`Selected | `(out Index: int)` | Returns the position of the first selected button, or -1 when nothing is selected. It reads the position list only, so it answers -1 throughout for a group selecting by identifier. |
| fn | `isAnyButtonSelected`Selected | `(out Index: bool)` | Returns whether anything is selected at all, reading the identifier list while Select By ID is on and the position list otherwise. |
| event | `OnClicked` | `(Button: WBP_Button)` | Internal handler subscribed to every button's click. With Automatic Selection on it updates the selection under the group's rule, single select ignoring a click on the button already selected while the toggle and multiple rules clear it, then broadcasts On Button Selection Changed and On Button Clicked. With it off only On Button Clicked is broadcast, and a selection made this way is not replicated. |
| event | `OnHovered` | `(Button: WBP_Button)` | Internal handler subscribed to every button's hover. Broadcasts On Button Hover with that button's position and restarts the dynamic hover resize when it is switched on. |
| event | `OnUnhovered` | `(Button: WBP_Button)` | Internal handler subscribed to every button's unhover. Broadcasts On Button Unhover with that button's position and restarts the dynamic hover resize when it is switched on. |
| event | `WidgetElement_InitialConstruct`Construct | `()` | Called on every element while the owning widget pre-constructs in the editor, immediately before the design-time theme pass. Implement it for preview-only set-up; it never runs in a running game. |
| event | `WidgetElement_ExecuteReplication`Replication | `(ReplicationIdentifier: name, Content: string[])` | Called on the other clients when a replicated value arrives for this element, carrying the identifier and its content strings. Implement it to reflect a change another player made; it is skipped on the client that sent the value. |
| event | `TickTransition` | `()` | Internal timer handler that eases each queued button's slot size towards the dynamic hover size while it is hovered and back to normal once it is not, dropping buttons as they arrive and pausing the timer when none are left. It only bites in a row or a column, since a wrap box slot has no size to drive. |
| event | `AssignIntegerObject` | `(Target: Object, UseContent: bool, ApplyValue: bool)` | Binds the group to an integer value object so the two follow each other, the selected position being the value. Set Apply Value to push the current selection into the object; leave it off to adopt the object's value instead. Use Content rebuilds the buttons from the object's texts, which leaves them without identifiers. |
| event | `OnValueUpdated_Event` | `()` | Internal handler that mirrors the bound integer object back onto the group, selecting the position it reports and clearing the selection when it reports -1. |
| event | `OnButtonClicked_Integer` | `(Group: WBP_Group_Button, Index: int, ID: name)` | Internal handler bound by Assign Integer Object that writes the clicked position into that object, tagged with the widget's Source Info. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |
| event | `RemoveWidgetFromGroupByIndex`Group | `(Index: int)` | Removes the item at that position from the tree and drops it from the group's list. An out-of-range position does nothing. |
| event | `InitiateDynamicHover` | `()` | Queues every button for resizing and starts the tick that eases them towards or away from the dynamic hover size. Called from the group's own hover handlers, and it does nothing in a wrap box group, where slots have no size to drive. |
| event | `UpdateDynamicHover` | `(DynamicHover: ST_Group_Button_DynamicHover)` | Stores new dynamic hover settings, being the switch, the size a hovered button grows to and the speed it moves at. They reach the buttons on the next hover rather than at once. |
| event | `AssignNameObject` | `(Target: Object, UseContent: bool, ApplyValue: bool)` | Binds the group to a name value object so the two follow each other, the selected button's identifier being the value. Set Apply Value to push the current selection into the object; leave it off and the refresh runs through the integer handler instead, so nothing is selected unless an integer object is bound as well. Use Content rebuilds the buttons from the object's identifiers and texts. |
| event | `OnValueUpdated_Name` | `()` | Internal handler that selects the button whose identifier matches the bound name object whenever that object reports a change. |
| event | `OnButtonClicked_Name` | `(Group: WBP_Group_Button, Index: int, ID: name)` | Internal handler bound by Assign Name Object that writes the clicked button's identifier into that object, tagged with the widget's Source Info. |

**WBP_Group_Widget**4 members

extends `WBP_Group`

Group that fills itself with instances of one widget class rather than with buttons. Set Widget Class and it can add default items, resize itself to a given length, or spawn a number of demo items so the layout reads properly while you are designing. Take the horizontal, vertical or wrap box variant.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Widget Class`Demo | `class<WBP_Base>` | Widget class the group builds its items from, read both by Spawn Demo Items and whenever the group is asked to grow itself. Leave it empty and neither creates anything. |
| var | `Number Of Demo Items`Demo | `int` | How many items Spawn Demo Items creates. Nothing else reads it, so changing it does not resize a group that has already been filled. |
| fn | `AddDefaultWidget`Group | `()` | Adds one more item of whatever kind the group is built from. Empty here, so a plain group cannot grow itself; the button and widget groups override it, which is also what makes Resize Widget Group work for them. |
| fn | `SpawnDemoItems`Demo | `()` | Fills the group with that many freshly created widgets of the group's widget class, replacing anything already in it. Meant for laying a design out against placeholder content. |

### Widgets/Layout/Header

**WBP_Header**2 members

extends `WBP_Base`

Title row in three slots: a fixed-width slot at each side and a filling title slot between them, so headings line up across pages whatever sits in the corners. Nothing in the shipped content uses it. Drop it at the top of a widget of your own, or copy it when the sides need different widths.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Side Width`Style | `float` | Returns the wrap box the group adds its widgets to, which is what lets this variant flow its items onto several rows. Items land with even padding on all four sides rather than the single axis the row and column use. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |

### Widgets/Layout/InfoRow

**WBP_InfoRow**9 members

extends `WBP_Base`

Labelled row pairing a title and optional caption on the left with a slot on the right for whatever the row controls. The framework's standard way of laying out a settings or information list, and the most used layout widget in the pack. Set Title and Caption on the instance or update them at runtime; the caption hides itself when empty.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Title`Content | `text` | Text meant for the emphasised first line of the row. It reaches the text element only through Update Title, so editing it here alone leaves the row showing whatever the designer set. |
| var | `Caption`Content | `text` | Quieter second line under the title. It reaches the text element only through Update Caption, which also collapses the caption away when the text is empty. |
| var | `Title Size`Design | `ST_SizeOverride` | Optional fixed width for the title column, in slate units. Applied by Update Title Size; with the override flag off that call clears the width instead, leaving the column to size itself from its text. |
| var | `Vertical Alignment`Design | `EVerticalAlignment` | Vertical placement the row's content is meant to take, exposed on spawn so whatever creates the row can set it. No node in the graph applies it, so the slots keep the centred alignment from the designer. |
| var | `Slot Horizontal Alignment`Design | `EHorizontalAlignment` | Horizontal placement the content slot is meant to take, exposed on spawn. As with the vertical setting, no node in the graph applies it, so the slot keeps the fill alignment from the designer. |
| fn | `UpdateCaption`Content | `(Text: text)` | Records the new caption and hands it to the caption text, which collapses itself away when the text it is given is empty. |
| fn | `UpdateTitle`Content | `(Text: text)` | Records the new title and writes it straight into the title text. The write is a plain set, so the empty check that collapses an empty caption is not run for the title. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `UpdateTitleSize` | `(SizeOverride: ST_SizeOverride)` | Stores a new title width and applies it to the title column, fixing the width while the override flag is on and clearing it back to auto-sizing otherwise. |

### Widgets/Layout/Scaffolds

**WBP_Scaffold_Bar**2 members

extends `WBP_Scaffold`

Small rounded scaffold, 600 by 200 by default, for a strip of controls rather than a page of them. The desktop menu uses it as its bar. Put the controls in the slot and override the dimensions when the bar needs to be a different length.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getSizeBox`Elements | `(out SizeBox: SizeBox)` | Returns the size box the width and height overrides are applied to. Empty here; each variant overrides it with the box wrapping its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |

**WBP_Scaffold_Default**4 members

extends `WBP_Scaffold`

Standard page frame: a rounded panel with generous padding around a single content slot, and a side-coloured border whose highlighted edges and tint are set at runtime through Update Sides and Update Side Colour. The usual outermost widget for a menu page, an information panel or an example screen.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getSizeBox`Elements | `(out SizeBox: SizeBox)` | Returns the size box the width and height overrides are applied to. Empty here; each variant overrides it with the box wrapping its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `UpdateSides` | `(Sides: Vector4)` | Records which edges of the border carry the accent colour and pushes the four values into its material, one per side. It needs the border to have had a theme applied first, otherwise there is no material to write to. |
| event | `UpdateSideColor` | `(Side Color: ST_Color_Definition)` | Records the accent colour for those edges and pushes it into the border's material as its second colour. It needs the border to have had a theme applied first, otherwise there is no material to write to. |

**WBP_Scaffold_Expand**8 members

extends `WBP_Scaffold`

Page frame in two parts: a content area of fixed size and a panel beside it that collapses away sideways behind a gradient. Toggle Collapse and Set Collapsed drive the side panel, On Collapsed State Changed reports it and the state replicates. The navigation bar and the VR menu are built on it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Is Collapsed`State | `bool` | Whether the expanding side panel is currently hidden. Kept in step with the inner collapse by Set Collapsed and Toggle Collapse; setting it directly moves nothing. |
| var | `Width Override Expand`Dimensions | `ST_SizeOverride` | Optional fixed width for the expanding side panel, in slate units. Applied by Set Size Override Expand Box; with the override flag off the panel sizes itself from its content. |
| fn | `SetCollapsed`State | `(Set: bool)` | Shows or hides the expanding side panel, recording the state on the scaffold and passing it to the inner collapse, which animates the move, plays the sound and replicates it to the other clients. |
| fn | `ToggleCollapse`State | `()` | Flips the side panel between shown and hidden by calling Set Collapsed with the opposite value. |
| fn | `getSizeBox`Elements | `(out SizeBox: SizeBox)` | Returns the size box the width and height overrides are applied to. Empty here; each variant overrides it with the box wrapping its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `SetSizeOverride_ExpandBox` | `(SizeOverride: ST_SizeOverride)` | Stores a new width for the expanding side panel and applies it to that panel's size box, fixing the width while the override flag is on and clearing it back to auto-sizing otherwise. |
| event | `SetHeightOverride_MainBox` | `(Height_Override: ST_SizeOverride)` | Deliberately empty override that swallows the scaffold's height override, so this variant keeps the height it was given in the designer whatever is passed in. Width overrides still work as they do on any scaffold. |

**WBP_Scaffold_Overlay**4 members

extends `WBP_Scaffold`

Frame for a panel floating over the world: a rounded fill with an outline above it and tighter padding than the page scaffold. Outline Colour takes a colour asset, applied at runtime by Update Outline Colour. Every head-up display corner uses it, so reach for it when the widget sits in the view rather than in a menu.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Outline Color`Sides | `PDA_Color` | Colour asset drawn as the outline over the scaffold. Applied by Update Outline Color; leave it empty and the outline keeps the theme colour it was built with. |
| fn | `getSizeBox`Elements | `(out SizeBox: SizeBox)` | Returns the size box the width and height overrides are applied to. Empty here; each variant overrides it with the box wrapping its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `UpdateOutlineColor` | `(OutlineColor: PDA_Color)` | Records a new outline colour and pushes it into the outline border as a custom colour definition at medium intensity. An empty asset is ignored, leaving the outline exactly as it was. |

### Widgets/Layout/Scaffolds/Parents

**WBP_Scaffold**6 members

extends `WBP_Base`

Root of the scaffold family: the outer frame of a widget, wrapping everything in a size box with Width Override and Height Override that can be set in the details panel or changed at runtime. It draws nothing itself, so use one of the scaffold variants or subclass it and return your own size box.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Width Override`Dimensions | `ST_SizeOverride` | Fixed width for the scaffold's size box, in slate units. With the override switched off the scaffold takes its width from its content; change it at runtime through Set Width Override Main Box rather than writing here. |
| var | `Height Override`Dimensions | `ST_SizeOverride` | Fixed height for the scaffold's size box, in slate units. With the override switched off the scaffold takes its height from its content; change it at runtime through Set Height Override Main Box rather than writing here. |
| fn | `getSizeBox`Elements | `(out SizeBox: SizeBox)` | Returns the size box the width and height overrides are applied to. Empty here; each variant overrides it with the box wrapping its own designer tree. |
| fn | `WidgetElement_getNamedSlots`Slots | `(out Slots: NamedSlot[])` | Returns the named slots this element exposes so that the tree walk can descend into their children. Return an empty list and the element is treated as a leaf, which means anything parented into a slot you do not list is never initiated or themed. |
| event | `SetWidthOverride_MainBox` | `(Width_Override: ST_SizeOverride)` | Stores a new width and applies it to the scaffold's size box, fixing the width while the override flag is on and clearing it back to auto-sizing otherwise. |
| event | `SetHeightOverride_MainBox` | `(Height_Override: ST_SizeOverride)` | Stores a new height and applies it to the scaffold's size box, fixing the height while the override flag is on and clearing it back to auto-sizing otherwise. |

### Widgets/Navigation/Pagination

**WBP_Pagination_Menu_Horizontal**1 members

extends `WBP_Pagination`

Ready-made tab bar: pagination drawing horizontal tab buttons across a row, over a rule that runs the full width behind them. The framework's standard page switcher, used by the examples, the desktop settings and both menu subpages. Drop it in, point Switcher Tag at your switcher and fill in the button content.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |

**WBP_Pagination_Menu_Vertical**1 members

extends `WBP_Pagination`

Ready-made side navigation: pagination drawing vertical tab buttons down a column, stretched past its own bounds so the entries run edge to edge. Used by the VR menu and the navigation bar. Drop it in, point Switcher Tag at your switcher and fill in the button content.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |

### Widgets/Navigation/Pagination/Helpers

**WBP_Button_Tab_Horizontal**12 members

extends `WBP_Button`

Tab button for the horizontal tab bar: icon and text in a row, with an underline that grows in along the bottom edge as the tab becomes the selected one, and hover, press and blocked sounds of its own. The tab bar builds these from its button content, so subclass it rather than placing it when tabs need a different look.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getButtonText`Get Elements | `(out Button Text: AFText)` | Returns the text element the label is written into. Empty on the base class; designs override it, and Update Button Content stops before touching anything else when there is none. |
| fn | `getButtonImage`Get Elements | `(out Button Image: AFImage)` | Returns the image element the icon is written into. Empty on the base class; designs override it, and Update Button Content stops before forwarding content to the content widget when there is none. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value out to the design's blendable elements, of which this one registers none, so the underline is carried by its own tracks rather than by the blend. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value out to the design's blendable elements, of which this one registers none, so only a content widget beneath the tab sees the value. |

**WBP_Button_Tab_Vertical**13 members

extends `WBP_Button`

Tab button for the vertical tab bar: icon and text in a row, with a full background fading in behind the selected entry and an accent strip widening on hover. Carries the same tab sounds as its horizontal counterpart and asks for no outer padding, so entries stack flush. Built by the tab bar; subclass it to restyle a side menu.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `WidgetElement_getDesiredPadding`Slots | `(out Padding: float)` | Returns the spacing in slate units this element wants around itself inside one of the framework's boxes. The boxes ask every child that implements the interface and fall back to their own default padding only for children that do not; the default answer here is zero. |
| fn | `getButtonText`Get Elements | `(out Button Text: AFText)` | Returns the text element the label is written into. Empty on the base class; designs override it, and Update Button Content stops before touching anything else when there is none. |
| fn | `getButtonAnimation_Action`Get Animations | `(out ActionAnimation: WidgetAnimation)` | Returns the animation carrying the selected look, run forwards when the button becomes selected and reversed when the selection is cleared. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Hover`Get Animations | `(out HoverAnimation: WidgetAnimation)` | Returns the animation run forwards as the cursor enters and reversed as it leaves. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Deactivate`Get Animations | `(out DeactivateAnimation: WidgetAnimation)` | Returns the animation run forwards when the button is deactivated and reversed when it is activated again. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonAnimation_Click`Get Animations | `(out ClickAnimation: WidgetAnimation)` | Returns the animation run forwards while the button is held down and reversed on release. Empty on the base class; each button design overrides it with its own. |
| fn | `getButtonImage`Get Elements | `(out Button Image: AFImage)` | Returns the image element the icon is written into. Empty on the base class; designs override it, and Update Button Content stops before forwarding content to the content widget when there is none. |
| fn | `getSound_Pressed`Sound | `(out Sound: SoundBase)` | Returns the cue played when the button is pressed. Empty on the base class; designs override it, usually with a different cue per preset, and the Sound Press Override wins over it when set. |
| fn | `getSound_Hover`Sound | `(out Sound: SoundBase)` | Returns the cue played when the cursor first enters the button. Empty on the base class; designs override it, and the Sound Hover Override wins over it when set. |
| fn | `getSound_Deactivated`Sound | `(out Sound: SoundBase)` | Returns the cue played when a deactivated button is pressed. Empty on the base class; designs override it, and the Sound Blocked Override wins over it when set. |
| fn | `getButtonFrame`Get Elements | `(out ButtonFrame: WBP_ButtonFrame)` | Returns the frame widget wrapping this button's content and holding its size box. Empty on the base class; each button design overrides it, and Style Button Frame needs it to apply the width and height overrides. |
| event | `SequenceEvent_Hover` | `()` | Called from the hover animation's event track as it plays. Pushes the current hover blend value out to the design's blendable elements, of which this one registers none, so the side bar is carried by its own tracks rather than by the blend. |
| event | `SequenceEvent_Action` | `()` | Called from the action animation's event track as it plays. Pushes the current action blend value out to the design's blendable elements, of which this one registers none, so only a content widget beneath the tab sees the value. |

### Widgets/Navigation/Pagination/Parents

**WBP_Pagination**5 members

extends `WBP_Group_Button`

Button group wired to a widget switcher: pressing a button switches the switcher to the matching page, and a page change from anywhere else selects the matching button, by index or by ID. Switcher Tag names the switcher to drive, which is looked up by tag anywhere inside the parent widget. Take one of the variants; this class has no panel of its own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Switcher Tag`Switcher | `name` | Tag of the switcher these buttons page through, searched for in the owning widget's tree rather than in this one. Left as None nothing is found, so pressing a button changes no page. |
| fn | `NewWidgetFocussed_Event`State | `()` | Closes any open overlay and marks the button matching the switcher's current page as selected, by identifier or by position according to Select By ID. Meant to be bound to the switcher's New Widget Focussed delegate so the buttons follow a page change made elsewhere. |
| fn | `OnButtonClicked_Event`State | `(Group: WBP_Group_Button, Index: int, ID: name)` | Switches the paired switcher to the page the pressed button stands for, by identifier when Select By ID is set and by position otherwise. Meant to be bound to the group's On Button Clicked delegate, which nothing here does for you. |
| fn | `getWidgetSwitcher`Get Elements | `(out Switcher: AFSwitcher)` | Searches the owning widget's tree from its root for the switcher carrying Switcher Tag and returns it. The search runs afresh on every call and does not step inside a sub-widget's own tree, so the switcher has to sit where the owner can reach it. |
| event | `WidgetElement_PostInitiate`Style | `()` | Called on every element once the entire tree has been initiated and themed. Implement it for set-up that needs the finished tree, such as measuring or reading the state of a sibling. |

**WBP_Pagination_Horizontal**1 members

extends `WBP_Pagination`

Pagination in a plain horizontal box, with no framing and no button class chosen. Nothing uses it, and the horizontal menu variant is the one to reach for when you want tabs; take this only when you intend to supply the button class and styling yourself.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |

**WBP_Pagination_Vertical**1 members

extends `WBP_Pagination`

Pagination in a plain vertical box, with no framing and no button class chosen. Nothing uses it, and the vertical menu variant is the one to reach for when you want side navigation; take this only when you intend to supply the button class and styling yourself.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getPanelWidget`Style | `(out PanelWidget: PanelWidget)` | Returns the panel the items are placed in, which is what decides whether the group lays out as a column, a row or a wrapped grid. Empty here; each variant overrides it with the box from its own designer tree. |