Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

Nstd
Chash< tachyon::ID >
Ntachyon
NDiagnostics
CLogArg	One argument
C[union].__unnamed0__
CLogCategory	A subsystem's log category
CLogRecord	One message as sinks and CopyRecentLogRecords see it
CProfileSample	One finalized node, depth-first. Durations are windowed averages (~4 updates/s)
CScopedTimer	Times its own lifetime as a scope; a disabled profiler costs one branch
CScopeLocation	Per-call-site descriptor, static at each TACHYON_PROFILE_SCOPE site
NRHI
CGpuPipeline
CUploadRequest
CRenderDevice	Device-lifetime operations
CRenderCommandList	One frame's recording surface for one window
NTableHelpers
CVirtualRowRange	Half-open [firstVisible, lastVisible) range of rows to emit
Nvulkan
CAllocatedBuffer
CAllocatedImage
CBuffer
CDeletionQueue	Library internal: destroy functions that run later, newest first
CDescriptorAllocator
CPoolSizeRatio
CDescriptorAllocatorGrowable
CPoolSizeRatio
CDescriptorLayoutBuilder
CDescriptorWriter
CFontTexture
CFrameData
CFrameWaits	Timeline semaphores the GUI's frame submissions wait on (VulkanGraphicsContext::AddFrameWait)
CGUIRenderContext	The Vulkan-side GUI pipeline set, built once at device init from kPrimitiveSpecs
CSwapchainState
CUploadWorker	Library internal: copies into mapped GPU memory on a thread of its own, so the main thread goes on recording commands
CVisualBoxStyleBuffers
CVisualColorStyleBuffers
CVulkanBuffer
CVulkanDeviceContext	The Vulkan device the GUI renders with: its own, or a host's (SetExternalDevice)
CInstanceDebugConfig	Diagnostic hook for the GPU test harness: the instance is built with this debug callback instead of the default printing messenger, and optionally with synchronization validation, so tests can fail on validation errors
CExternalDevice	A host's Vulkan handles for SetExternalDevice, so the GUI renders on the host's device (an engine hosting it as its editor, say) and can share resources with it
CDeviceRequirements	What a device must provide for the GUI to run on it
CVulkanGraphicsContext	The default graphics backend, on Vulkan 1.3
CVulkanImage
CRecipe	How it was made, to make it again on a new device after the old one is lost; with its pixels when it was made from them
CVulkanImageSet
CVulkanRenderCommandList
CVulkanRenderDevice
CVulkanTextAtlasManager
CVulkanWindowContext
CWindowVulkanState
CAddResult	What Add returns: the new element's ref and status; true on success
CAllocationHooks	Memory functions a host gives the library, for the allocations that can be routed: Vulkan objects, VMA, vk-bootstrap and SDL
CAtlasLocation	Where a handle's texels are in the atlas
CBannerAction	A banner's button or link, right-aligned after its message
CBottomUpDepthScanIterator
CBox
CBoxCorners	Per-corner values (border radius)
CBoxEdges	Per-side values of the box model (margin, padding, border widths)
CBoxShadow	One CSS box-shadow layer, outside the border box
CBuffer
CButtonGroupSubsystem	Button/toggle groups: every item takes the group's item style (its :first-child and :last-child rules shape the ends), and a single-item group reverts to "solo", a plain button, in EndGroup
CItemState	One open group: its styles and the items registered so far
Cbyte2
Cbyte3
Cbyte4
CCachedWireHandle	Last frame's draggable segment (node.pos space), for laying out its grab element
CChildStyles	A class's styles for where an element is among its parent's children, from its :first-child, :last-child and :only-child rules (box properties only)
CCircle	A circle outline: the ring lineWidth wide around center at radius, its color and dashes running clockwise from the right (+x towards +y), as LineStyle sets them
Ccolor4b
Ccolor4f
CColorPickerState	Persistent state of the color picker popup
CPaletteSwatch
CColorPickerSubsystem	The color picker popup's state plus swatch ColorStyles keyed by swatch ID
CColorStop	Color stops for gradients
CColorStyle	A fill: solid color, gradient or texture, as used for backgrounds, borders, text and icons
CColumnDragState	Column-reorder drag in progress; internal, owned by the application
CCommandID	Handle to a registered command, stable for the manager's lifetime
CCommandManager	Registry of commands: named actions with an optional icon and an optional shortcut key, each firing one callback when invoked (clicked from a menu / toolbar, or via its key)
CCommand	A registered command
CCommandSearchState	State of a CommandSearch box; user-owned, keep it alive across frames
CConstructionScopes	Construction-time Push/Pop nesting read by GUIStateManager::GetCurrentState
CContentRun	One run of rich text: a piece of text or an inline icon
CControlStyles	Default control styles
CCssPx	A size in CSS px
CCubicBezier	A CSS cubic-bezier(x1, y1, x2, y2) timing curve: maps the share of a transition's time that has passed (0..1) to how far its value has gone (0..1)
CCursorState	The mouse cursor requested this frame
CCustomDrawContext	Passed to custom-draw callbacks (ElementStorage::AddCustomDraw / AddCustomDrawAfter): geometry lookups and drawing calls in a current space the callback switches with SetSpace or SetSpaceRaw, also between calls
CCustomProperty	A resolved CSS custom property (:root { --name: value; }): a color, 1..4 numbers or a box-shadow
CDepthScanCursor
CDockDropResult	Result of FindDockDropTargetAtScreenPos: the drop target and its layout
CDockDropTarget	A drop location: the leaf under the cursor and the zone within its content area
CDockDropZoneAnim	The drop-zone overlay shown while a dock tab is dragged; it slides between zones
CDockingConstructionState	Construction state of the current docking container
CDockingLayout	A docking area: the split/tab tree and the panels its leaves refer to by ID
CDockLeafResult	Result of FindDockLeafAtScreenPos: the leaf and its layout, both null on a miss
CDockNode	Docking tree node: a leaf with panel tabs, or a split with two children where splitSize applies to the pinned child
CDockTabDragInfo	Set when a dock tab drag starts, so any target leaf can emit a phantom tab during construction
CDockTabDragSubsystem	Dock tab drag state: the dragged tab and the drop-zone overlay animation
CDocument	A document: a level, prefab, material graph, ... with its own panels
CInternal	Kept by the documents; not part of the API
CDocumentDrag	A document tab being dragged, for the document bars it passes over; internal
CDocumentMove	A document dropped on another bar or torn off, done at the start of the next frame; internal
CDocumentSet	The documents one main window shows, in tab order, and which one is active
CInternal	Kept by the documents; not part of the API
CDocumentWindowRef	A main window of documents, for PersistDocuments: its OS window and its documents
CDot
CDoubleClickTracker	Click-gesture tracker, owned per widget instance so instances (and tests) don't share it
CResult	Whether this click hit the same item as the previous one, and the time since it
CDragDropState	Drag-and-drop state, owned by GUIStateManager
CDragLabelState	Per-element state of a draggable label (element data store); internal
CDragVisualContext	What a DragVisualizer draws from: the pointer, the source and target, and the payload
CDrawnWire	A wire as drawn this frame, for hit-testing; points in node.pos space
CEdgeInset	Per-side offsets of a positioned element (CSS: top, right, bottom, left), in pixels
CElement
CElementCustomDraw	callback fires before the children render; the after-list fires after the whole subtree
CElementDataStore	Per-element typed state keyed by ID, kept across frames (drag start, double-click timing)
CElementEvent	An input event delivered to an element's EventHandler
CElementMove	What a MoveChild did: the slot rotations it applied at each depth, so code that stores ElementRefs (e.g
CRotation
CElementRect
CElementRef	An element's slot in ElementStorage: its depth and index within that depth
CElementStorage	The frame's element tree
CPostLayoutEntry	Fired in registration order between layout and rendering
CError	A failure: its category and a human-readable message
CFileDrag	A drag from another application, of files or text, over one of the app's windows
CFileDrop	Files or text dropped from another application
CFileEntry	A file or folder in a folder
CFileIcons	The OS's icon for a file or folder, registered with a text system as a picture icon (ITextSystem::RegisterIconFromPixels)
CFileThumbnails	A file's thumbnail, registered with a text system as a picture icon (ITextSystem::RegisterIconFromPixels)
CPicture	RGBA pixels, rows from the top, straight alpha
CFlexOverride	KDefault = use style value, >= 0 = override
CFlexProperties	Flexbox properties: the container's (direction, wrap, alignment, gap) and the item's own (grow, shrink, basis)
Cfloat2
Cfloat2x2
Cfloat3
Cfloat3x2	2D affine transform matrix (2 rows x 3 columns): x' = r0.x*x + r0.y*y + r0.z y' = r1.x*x + r1.y*y + r1.z
Cfloat4
Cfloat4x4
CFloatingDockWindow	A floating OS window holding torn-off panels in its own layout
CFloatingToolbarItem	A torn-off toolbar in its own OS window, owned by the caller
CFloatingToolbarOptions	Enables dragging a floating toolbar back onto a dock side; both fields are required, otherwise the drag handle only moves the OS window
CFontFace	One @font-face rule. Faces sharing a family name form one family
CFontFaceSource	One face of a font family: a font file, or font data in memory that stays valid while the family is registered (embedded in the executable, say)
CFrameClock	Animation time locked to the display refresh
CFrameContext	Per-frame values plus references to long-lived managers, passed to every stage callback
CFrameHover	Where the frame's input goes, from GUIStateManager::EndFrame
CFrameInput	What the window layer reports at the end of a frame's construction; GUIStateManager::EndFrame turns it into the hovered element and the active window
CFramePipeline	Stage callbacks run in registration order (no priorities): if A must run before B, construct A first (see GUIApplication::Initialize())
Cglsl_float4
CGlyph
CGPUDrawPushConstants
CGradient	Up to kMaxStops color stops plus an angle and interpolation color space
CGradientEditorState	Gradient editor popup state: edits a working copy, written back each frame it's open
CGradientEditorSubsystem	The gradient editor's state plus swatch styles keyed by swatch ID, with the same lifecycle as ColorPickerSubsystem's
CGradientHandle	Handle to a reference-counted GradientManager atlas slot
CGradientManager	The atlas that the colors of color styles are baked into: pages of 2D textures, one row per gradient, with solid and 2..4-color blocks packed into shared rows
CGraphicsContext	A graphics backend: the device, the window contexts that render the GUI's windows, and the images and text atlases they draw with
CGridAxisProperties	A grid item's placement and track request along one axis, plus the container's gap
CGridItemRenameInfo	Rename buffer and original name of a grid item; internal
CGridProperties	Grid container and item properties
CGridTrack	Size of one grid column or row (CSS: -tachyon-grid-column-track / -row-track)
CGridViewState	Construction state of the current GridView; internal
CGridViewVirtualState	User-owned, persistent state of a virtualized GridView; keep it alive across frames
CInternal	Written by the grid view each frame; not part of the API
CGUIApplication	The application: owns the windows, the systems and the frame loop
CFrameTimingSample	Rolling per-frame timing history in ms, recorded only while profiling is enabled
CScope	A container's scope: its End runs when the scope leaves (or at End())
CSettingsPanelState	What RenderSettingsPanel shows: its pages, the selected one and the tree width
CPage	A page: a stable ID, its name in the tree, and render, which builds its content
CInternal	Tree-view backing state, rebuilt per frame; not part of the API
CGUIApplicationInitializeOptions	What GUIApplication::Initialize sets up besides the core systems
CGUIContent	What a control shows: a text, an icon or both, and an optional tooltip
CGUIRenderer
CGUIStateManager	Owns the per-frame state objects and runs their BeginFrame / EndFrame in order
CGUITheme	The library's styles, icons and theme metrics, the defaults the controls draw with
CHierarchyInfo
CIClipboard	The clipboard text editors copy to and paste from; GUIApplication::SetClipboard sets one (default: SDL's, or LocalClipboard without SDL)
CIconMeasurement
CIconTextPlacement	Placement of a text + icon pair inside rect:
CID	A 64-bit element ID whose bit layout depends on its IDMode
CValue	The packed bits, viewed per mode; internal (use GetMode / Value / IDManager)
CStaticParts
CDynamicParts
CRangedParts
CSubRangeParts
CIDManager	Makes element IDs: per-frame dynamic / ranged IDs (hashed from the call site or a hint and the parent stack) and persistent static IDs
CIFileSystem	What a file view reads and changes
CImage	An image made by GraphicsContext::CreateImage; the backend defines its contents
CImageSet	The images the shaders can sample, each at an ImageIndex. Implemented by the backend
CImageWindowBackend	Adds windows that render to an image (WindowFlags::RenderToImage) to another window backend
CIndexRange	A half-open range [begin, end) of indices within one depth
CInputHandlerBroadcaster	Sends every platform input event to all handlers (e.g
CInputManager	Receives raw OS events, records them, and runs the frame's input pipeline (tab navigation, text editor focus, dispatch, post-dispatch)
CInputState	Snapshot of input state for a single recorded OS event
Cint2	Integer 2D vector
Cint3
Cint4
CInteractionState	The hovered, active, focused and captured elements, the active window, the one-shot click, hover suppression and the focus scroll axis
CIntRect
C[union].__unnamed0__
C[struct].__unnamed0__.__unnamed0__
C[struct].__unnamed0__.__unnamed1__
CIPlatformInputHandler	Platform-level input interface: receives raw OS events (keyboard, mouse) and forwards them into the GUI input pipeline
CItemDragDropConfig	Drag & drop setup for item-based views (tree, list, grid): items drag a payload and accept drops of the same payloadType
CITextSystem	Text and icon registration, measurement, rendering and editing
CTextEditUpdate
CITextValidator	What an editable field takes as text, asked while it is edited
CIWindowBackend	Makes and manages the OS windows and delivers their input; GUIApplication::SetWindowBackend sets one, SDLWindowBackend is the default
CIWindowContext	A window's rendering state: made by GraphicsContext::CreateWindowContext for each OS window, attached to it with IWindowBackend::AttachContextToWindow, and destroyed by GraphicsContext::DestroyWindowContext
CJsonValue	A JSON value (RFC 8259): null, bool, number, string, array or object
CLabelBinding	Links labels to the controls they describe during construction; owned by GUIStateManager
CLabelGroupSubsystem	Labels and DragLabels in a label group share a width; dragging any label's right edge resizes them all
CState	State of one label group, kept across frames by group ID
CLabelGroupVisualState	Shared by all labels in a group, so the edge highlight is synchronized
CLanguageTag	A BCP 47 language tag ("ja", "zh-Hant", "ko-KR") stored inline, so text styles stay plain values
CLayeredFades	Layered windows that stand in for a window while it fades in or out: each shows a fixed picture (the window's last frame) at a screen rect and an opacity
CLayoutData	Flex / grid properties and CSS sizes of a style. Sizes are in CSS px in a Style
CLayoutEngine	Computes element sizes and positions from styles, content and constraints, in four passes run after construction:
CLayoutFlexbox
CLayoutGrid
CLayoutHelpers
CJustifySpacing	Where justify-content puts the first of count items, measured from the main start, and the space between items, with freeSpace left over on the main axis
CLayoutOverride	Per-element overrides of style layout properties
C[struct].grid	Grid item overrides; Default tracks and start < 0 keep the style's values
CLayoutStyle	The layout part of a registered Style, in pixels; shared by every style with the same values
CLine
CLineStyle
CLinkStyle	Colors of a link run, normal and hovered
CLocalClipboard	A clipboard inside the process, not shared with other applications
CMemoryFileSystem	A file system kept in memory
CMenuManager	State of the open menus (menu bar dropdowns, context menus, submenus) and their mouse and keyboard behaviour; one per application
CLevel	One open menu: the root dropdown or a submenu
CMenuRectsSubsystem	Last frame's screen rects of menu triggers and popups, written by AddPostLayout callbacks
CMessageButton	A button of a MessageDialog
CMessageDialogDesc	What a MessageDialog shows
CMessageDialogItem	An affected item, listed in a well: a name, an optional color dot and note, and a checkbox when checked is set
CMonitorInfo	Window, monitor and mouse coordinates are physical pixels
CMultiSelectState	Selected item IDs of a multi-select view; user-owned, keep it alive across frames
CNodeModel	One node of a node view
CNodeProperty	One row of a node: an optional input socket, a body, and an optional output socket
CNodeView	All state of one node-view widget; no global state
CNodeViewEdit	One thing the user did in a node view, as values before and after, so a host can keep the undo history (NodeView::onEdit) and undo or redo it (ApplyNodeViewEdit)
CMove	A node (index) moved; positions in node.pos space
CRewire	An input's source changed; an invalid endpoint means unwired
CCollapse	A node (index) collapsed or expanded
CLanes	A wire's (by WireKey) lane overrides changed; default means no overrides
CNode	A node added at index (or, when !added, taken from there), with the wires from its outputs into other nodes' inputs and the lane overrides of every wire into or out of it
CNullGraphicsContext	A graphics backend that draws nothing: the UI is built, laid out and recorded as usual, but no GPU is used and windows stay empty
CNullWindowBackend	A window backend without an OS: windows are records with a rect, and no input arrives (inject it with GUIApplication::Inject*)
CNumericFieldConfig	Drag speed and range of a numeric Field, specialized per value type
CNumericFieldConfig< double >	NumericFieldConfig for double values
CNumericFieldConfig< float >	NumericFieldConfig for float values
CNumericFieldConfig< int16_t >	NumericFieldConfig for int16_t values
CNumericFieldConfig< int32_t >	NumericFieldConfig for int32_t values
CNumericFieldConfig< int64_t >	NumericFieldConfig for int64_t values
CNumericFieldConfig< int8_t >	NumericFieldConfig for int8_t values
CNumericFieldConfig< uint16_t >	NumericFieldConfig for uint16_t values
CNumericFieldConfig< uint32_t >	NumericFieldConfig for uint32_t values
CNumericFieldConfig< uint64_t >	NumericFieldConfig for uint64_t values
CNumericFieldConfig< uint8_t >	NumericFieldConfig for uint8_t values
CNumericValue
COccluder	Depth only: marks pos/size as covered by opaque content drawn after it, so what was drawn before under it is skipped (its fragments fail the depth test early)
COSWindowManager	Keeps the OS windows (through an IWindowBackend) and their window contexts for the GUI's window elements, keyed by ID
CPanel	A unit of docked UI content: a title, an optional icon, and the callback that builds it
CInternal	Kept by the docking; not part of the API
CParseError	A problem found while parsing a style sheet; the parser skips the bad part and goes on
CPendingConnection	A wire being dragged. Committed wires are the reciprocal endpoints on NodeProperty
CPendingRowClick	Deferred row-click state for the drag-drop path: MouseDown primes it, MouseUp applies the selection unless a drag promoted in between
CPixels	A size in device pixels, used as is (not scaled by the UI scale)
CPointerDrag	One press on an element that may become a drag
CPositionConstraintAxis	Where an element goes on one axis: in the parent's flow (Relative, Centered, Sticky) or out of it (Absolute, Fixed, Anchored)
CPostDrawEntry	Node in the flat post-draw linked list stored in ElementStorage
CPostLayoutContext	Context for post-layout callbacks (AddPostLayout)
CPrimitiveRenderer
CPrimitiveRenderPass	One contiguous same-kind run of primitives, drawn with one call; or, with replay set, a cached scope's draw (its own passes), and the other fields unused
CPrimitiveRenderTarget
CStream	Per-kind primitive stream: CPU bytes appended by the emit methods and packed together into the current frame slot's GPU upload arena
CScopeReplay	A cached scope drawn here, moved delta window pixels from where it was captured; its primitives' draw orders start at baseOrder
CPrimitiveSpec
CPropertyEndpoint	A property on a node. Default-constructed is invalid: in a socket it means "present, unwired"
CPropertyHelp	A property's help, shown in a larger tooltip (SetTooltip): its name, what it does, and where it lives in the API with its type, such as "MeshRenderer.castShadows (bool)"
CQuad
CRange
CRecordedInputEvent	A single OS input event recorded for dispatch this frame
CRenameSubsystem	In-place rename of a tree / list / grid row (F2, Ctrl+Shift+Click or a slow re-click); the target row emits a text field instead of its label
CReorderableConstructionState	Construction state of the current reorderable group
CReorderableDragState	Persistent drag state; one drag at a time application-wide
CReorderableFocusFollow	After a keyboard move: where the focus was in the moved item, to put it back there next frame, in the item's new slot, unless its ID moved with the item
CReorderableSubsystem	Drag and construction state of drag-to-reorder groups, used by the Begin/EndReorderableGroup and Begin/EndReorderableItem widgets
CResult	A value, or the Error saying why there is none
CResult< void >	Success, or the Error saying why not
CSavedDocument	A document as SaveUIState kept it: which one it was, and how its panels were laid out
CSavedDocumentWindow	A main window of documents as SaveUIState kept it (TakeSavedDocuments)
CScrollbarDragState	Per-element state of MakeScrollbarHandler (element data store); internal
CScrollManagement	Scroll containers' offsets (pixels), kept across frames by ID behind handles
CSDLClipboard	The system clipboard, through SDL
CSDLWindowBackend	The default window backend, on SDL3
CSDLWindowBackendOptions	Options for SDLWindowBackend (SDLWindowBackend::Options)
Cshort2
Cshort3
Cshort4
CSizeConstraintAxis	Per-axis size constraint: an explicit size, or a min / max clamp on the content-driven size
CSizerState	Per-element state of the sizer handlers (element data store); internal
CSkribidiTextSystem	Skribidi-based implementation of ITextSystem
CSliderFieldTrackSubsystem	Slider track widths written by the sliders' custom draws and read next frame (keyboard step sizes, drag mapping)
CSliderState	Per-element state of MakeSliderHandler and the integer slider (element data store); internal
CSplitSizeRange	An inclusive splitSize range, in CSS px
CStyle	A complete style, as parsed from CSS or built in code: layout properties plus the visual properties of each state, in CSS px
CStates	A style's states, indexed by ElementState (or by slot number)
CStyleManager	Bakes serializable Styles into deduplicated runtime layout/visual styles; a StyleRef holds indices into the (possibly shared) pools
CChildStyleRefs	A style's variants for where an element is among its parent's children
CStyleRef	A registered style, as StyleManager::Register returns it: indices into the shared style pools, cheap to copy
CStyleSheet	A parsed style sheet: named styles, custom properties and font faces
CStyleState	The visual properties of one element state (normal, :hover, :active, ...)
CTabBarMemory	What a tab bar keeps across frames (element data store, by bar ID): its keyboard navigation, and the sizes it measured, in pixels, that decide which tabs fit
CTabBarOptions	What a tab bar offers besides its tabs
CTabBarState	Construction state of the current tab bar; internal
CHiddenTab
CTabChainManager	Tracks the next/prev tab targets around the focused element, rebuilt each frame during construction and scoped to the active window
CTableColumn	A table column; callers pass an array of them each frame
CTableEmit	Transient state of one table emit; internal
CTableState	User-owned, persistent state of one table: column widths, selection, sort, options
CTreeRowInfo	Per-row metadata from TreeCell()
CCellLookupEntry	Cell-mode click dispatch: cell-element ID -> (rowID, columnIdx)
CLazyReorderFn	A ReorderColumnsFn that costs one pointer when unset; assign it like a std::function: state.onReorderColumns = [&](int from, int to) { ... };
CInternal	Written by the table each frame; not part of the API
CTabState	Construction state of the current tab, between BeginTab and EndTab; internal
CTextAtlasManager
CTextConverter	Turns a field's value into the text it shows and edits, and edited text back into a value
CTextConverter< T >
CTextDecoration	One text decoration line (underline, overline, ...)
CTextEditorFocusState	The focused text editor, plus the one as of the last Commit, to detect changes
CTextLayoutStyle	How a text block is laid out in its box; shared by all states of a Style
CTextMeasurement
CTextOverride	Per-element text overrides for StyleManager::WithTextOverride
CTextStyle	What text is measured and laid out from: font, metrics and decoration lines
CTextWrapContext
CToastAction	A text button on a toast; the first is drawn in the link color
CToastDesc	What a toast says (ShowToast). Change it later through FindToast
CToolbarDockCallbacks	Callbacks through which RenderToolbarDock changes the caller's data; the dock never touches that data itself
CToolbarDockState	Per-instance state for one toolbar dock
CToolbarItem	One toolbar item
CToolbarWindowDragSubsystem	A floating toolbar window dragged by its thumb; one drag at a time
CTooltipManager	Decides which element's tooltip shows: the hovered one after a delay, or at once for focus moved by the keyboard
CTopDownDepthScanIterator
CTrackingAllocator	Allocation hooks that count what is live, for finding leaks
CTransitionManager	Tracks in-progress visual state transitions per element ID
CBlend	A running transition: the states it blends between, and how far it is (eased)
CTransitionState	Pre-computed GPU style indices for a box that is mid-transition (or not)
CTransitionTiming	How long a change of state takes, and how it eases. A duration of 0 is instant
CTreeDropState	Tree reorder drop target under the cursor; internal, owned by the application
CTreeViewRow	One row of a flat-data tree view (VirtualTreeView); rows are in depth-first order
CTreeViewState	Construction state of the current TreeView / ListView; internal
CTriangle
CTypeDimensions
CTypeDimensions< byte2 >
CTypeDimensions< byte3 >
CTypeDimensions< byte4 >
CTypeDimensions< color4b >
CTypeDimensions< color4f >
CTypeDimensions< float2 >
CTypeDimensions< float3 >
CTypeDimensions< float4 >
CTypeDimensions< int2 >
CTypeDimensions< int3 >
CTypeDimensions< int4 >
CTypeDimensions< short2 >
CTypeDimensions< short3 >
CTypeDimensions< short4 >
CTypeDimensions< uint2 >
CTypeDimensions< uint3 >
CTypeDimensions< uint4 >
CTypeDimensions< ushort2 >
CTypeDimensions< ushort3 >
CTypeDimensions< ushort4 >
CUICacheManager	Retained-render cache for BeginCached/EndCached scopes
CScope	Only what's needed to decide whether a scope is still clean and to blit it; not the element tree
CHitInput	Per-frame input facts that decide whether a scope may be served from cache
Cuint2
Cuint3
Cuint4
CUndoHistory	The app's undo history: steps that each undo and redo one change
CStep
Cushort2
Cushort3
Cushort4
CVirtualTableColumn	A VirtualTable column: the TableColumn plus cell generator, sort order and section
CInternal	Written by the table each frame (end-of-frame handlers read it); not part of the API
CVisualBoxStyle	The box part of one state of a registered Style, in pixels; uploaded to the GPU as is (32 bytes)
CVisualColorStyle	GPU form of a ColorStyle, uploaded as is: the gradient is baked into an atlas slot that colorUV / gradientPage point at
CVisualShadow	A BoxShadow in pixels with its color registered. No color is no shadow
CVisualShadowStyle	What a state draws on the CPU only: its shadows and its opacity
CVisualTextStyle	The text part of one state of a registered Style, in pixels
CWindowRegistry	Per-window lists of ElementRefs in addition (render) order, driven during ElementStorage construction:
CRenderNode	One entry in a window's flat pre-order render list
CWindowEntry	A window of this frame and its render list
CWireLane	A wire's place among the wires between the same two nodes, so their default lanes nest instead of coinciding or crossing (ComputeWireLaneOffsets)
CWireRoute	Polyline plus its draggable interior segments (never the end stubs)
CWireRouteOverrides	User-pinned lanes of one wire (unset = default), in the route's space
CWireSegmentDrag	Segment drag via mouse capture rather than DnD, so the resize cursor sticks
CWireSegmentHandle	Draggable interior segment; vertical segments drag horizontally and vice versa
CPipelineBuilder