Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 123]

Ctachyon::IntRect::[struct].__unnamed0__.__unnamed0__
Ctachyon::IntRect::[struct].__unnamed0__.__unnamed1__
Ctachyon::LayoutOverride::[struct].grid	Grid item overrides; Default tracks and start < 0 keep the style's values
Ctachyon::Diagnostics::LogArg::[union].__unnamed0__
Ctachyon::IntRect::[union].__unnamed0__
Ctachyon::AddResult	What Add returns: the new element's ref and status; true on success
Ctachyon::vulkan::AllocatedBuffer
Ctachyon::vulkan::AllocatedImage
Ctachyon::AllocationHooks	Memory functions a host gives the library, for the allocations that can be routed: Vulkan objects, VMA, vk-bootstrap and SDL
Ctachyon::AtlasLocation	Where a handle's texels are in the atlas
Ctachyon::BannerAction	A banner's button or link, right-aligned after its message
Ctachyon::TransitionManager::Blend	A running transition: the states it blends between, and how far it is (eased)
Ctachyon::BottomUpDepthScanIterator
Ctachyon::Box
Ctachyon::BoxCorners	Per-corner values (border radius)
Ctachyon::BoxEdges	Per-side values of the box model (margin, padding, border widths)
Ctachyon::BoxShadow	One CSS box-shadow layer, outside the border box
Ctachyon::Buffer
Ctachyon::vulkan::VulkanBuffer
Ctachyon::vulkan::Buffer
Ctachyon::ButtonGroupSubsystem	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
Ctachyon::byte2
Ctachyon::byte3
Ctachyon::byte4
Ctachyon::CachedWireHandle	Last frame's draggable segment (node.pos space), for laying out its grab element
Ctachyon::TableState::CellLookupEntry	Cell-mode click dispatch: cell-element ID -> (rowID, columnIdx)
Ctachyon::StyleManager::ChildStyleRefs	A style's variants for where an element is among its parent's children
Ctachyon::ChildStyles	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)
Ctachyon::Circle	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
Ctachyon::NodeViewEdit::Collapse	A node (index) collapsed or expanded
Ctachyon::color4b
Ctachyon::color4f
Ctachyon::ColorPickerState	Persistent state of the color picker popup
Ctachyon::ColorPickerSubsystem	The color picker popup's state plus swatch ColorStyles keyed by swatch ID
Ctachyon::ColorStop	Color stops for gradients
Ctachyon::ColorStyle	A fill: solid color, gradient or texture, as used for backgrounds, borders, text and icons
Ctachyon::ColumnDragState	Column-reorder drag in progress; internal, owned by the application
Ctachyon::CommandManager::Command	A registered command
Ctachyon::CommandID	Handle to a registered command, stable for the manager's lifetime
Ctachyon::CommandManager	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)
Ctachyon::CommandSearchState	State of a CommandSearch box; user-owned, keep it alive across frames
Ctachyon::ConstructionScopes	Construction-time Push/Pop nesting read by GUIStateManager::GetCurrentState
Ctachyon::ContentRun	One run of rich text: a piece of text or an inline icon
Ctachyon::ControlStyles	Default control styles
Ctachyon::CssPx	A size in CSS px
Ctachyon::CubicBezier	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)
Ctachyon::CursorState	The mouse cursor requested this frame
Ctachyon::CustomDrawContext	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
Ctachyon::CustomProperty	A resolved CSS custom property (:root { --name: value; }): a color, 1..4 numbers or a box-shadow
Ctachyon::vulkan::DeletionQueue	Library internal: destroy functions that run later, newest first
Ctachyon::DepthScanCursor
Ctachyon::vulkan::DescriptorAllocator
Ctachyon::vulkan::DescriptorAllocatorGrowable
Ctachyon::vulkan::DescriptorLayoutBuilder
Ctachyon::vulkan::DescriptorWriter
Ctachyon::vulkan::VulkanDeviceContext::DeviceRequirements	What a device must provide for the GUI to run on it
Ctachyon::DockDropResult	Result of FindDockDropTargetAtScreenPos: the drop target and its layout
Ctachyon::DockDropTarget	A drop location: the leaf under the cursor and the zone within its content area
Ctachyon::DockDropZoneAnim	The drop-zone overlay shown while a dock tab is dragged; it slides between zones
Ctachyon::DockingConstructionState	Construction state of the current docking container
Ctachyon::DockingLayout	A docking area: the split/tab tree and the panels its leaves refer to by ID
Ctachyon::DockLeafResult	Result of FindDockLeafAtScreenPos: the leaf and its layout, both null on a miss
Ctachyon::DockNode	Docking tree node: a leaf with panel tabs, or a split with two children where splitSize applies to the pinned child
Ctachyon::DockTabDragInfo	Set when a dock tab drag starts, so any target leaf can emit a phantom tab during construction
Ctachyon::DockTabDragSubsystem	Dock tab drag state: the dragged tab and the drop-zone overlay animation
Ctachyon::Document	A document: a level, prefab, material graph, ... with its own panels
Ctachyon::DocumentDrag	A document tab being dragged, for the document bars it passes over; internal
Ctachyon::DocumentMove	A document dropped on another bar or torn off, done at the start of the next frame; internal
Ctachyon::DocumentSet	The documents one main window shows, in tab order, and which one is active
Ctachyon::DocumentWindowRef	A main window of documents, for PersistDocuments: its OS window and its documents
Ctachyon::Dot
Ctachyon::DoubleClickTracker	Click-gesture tracker, owned per widget instance so instances (and tests) don't share it
Ctachyon::DragDropState	Drag-and-drop state, owned by GUIStateManager
Ctachyon::DragLabelState	Per-element state of a draggable label (element data store); internal
Ctachyon::DragVisualContext	What a DragVisualizer draws from: the pointer, the source and target, and the payload
Ctachyon::DrawnWire	A wire as drawn this frame, for hit-testing; points in node.pos space
Ctachyon::ID::Value::DynamicParts
Ctachyon::EdgeInset	Per-side offsets of a positioned element (CSS: top, right, bottom, left), in pixels
Ctachyon::Element
Ctachyon::ElementCustomDraw	callback fires before the children render; the after-list fires after the whole subtree
Ctachyon::ElementDataStore	Per-element typed state keyed by ID, kept across frames (drag start, double-click timing)
Ctachyon::ElementEvent	An input event delivered to an element's EventHandler
Ctachyon::ElementMove	What a MoveChild did: the slot rotations it applied at each depth, so code that stores ElementRefs (e.g
Ctachyon::ElementRect
Ctachyon::ElementRef	An element's slot in ElementStorage: its depth and index within that depth
Ctachyon::ElementStorage	The frame's element tree
Ctachyon::Error	A failure: its category and a human-readable message
Ctachyon::vulkan::VulkanDeviceContext::ExternalDevice	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
Ctachyon::FileDrag	A drag from another application, of files or text, over one of the app's windows
Ctachyon::FileDrop	Files or text dropped from another application
Ctachyon::FileEntry	A file or folder in a folder
Ctachyon::FileIcons	The OS's icon for a file or folder, registered with a text system as a picture icon (ITextSystem::RegisterIconFromPixels)
Ctachyon::FileThumbnails	A file's thumbnail, registered with a text system as a picture icon (ITextSystem::RegisterIconFromPixels)
Ctachyon::FlexOverride	KDefault = use style value, >= 0 = override
Ctachyon::FlexProperties	Flexbox properties: the container's (direction, wrap, alignment, gap) and the item's own (grow, shrink, basis)
Ctachyon::float2
Ctachyon::float2x2
Ctachyon::float3
Ctachyon::float3x2	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
Ctachyon::float4
Ctachyon::float4x4
Ctachyon::FloatingDockWindow	A floating OS window holding torn-off panels in its own layout
Ctachyon::FloatingToolbarItem	A torn-off toolbar in its own OS window, owned by the caller
Ctachyon::FloatingToolbarOptions	Enables dragging a floating toolbar back onto a dock side; both fields are required, otherwise the drag handle only moves the OS window
Ctachyon::FontFace	One @font-face rule. Faces sharing a family name form one family
Ctachyon::FontFaceSource	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)
Ctachyon::vulkan::FontTexture
Ctachyon::FrameClock	Animation time locked to the display refresh
Ctachyon::FrameContext	Per-frame values plus references to long-lived managers, passed to every stage callback
Ctachyon::vulkan::FrameData
Ctachyon::FrameHover	Where the frame's input goes, from GUIStateManager::EndFrame
Ctachyon::FrameInput	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
Ctachyon::FramePipeline	Stage callbacks run in registration order (no priorities): if A must run before B, construct A first (see GUIApplication::Initialize())
Ctachyon::GUIApplication::FrameTimingSample	Rolling per-frame timing history in ms, recorded only while profiling is enabled
Ctachyon::vulkan::FrameWaits	Timeline semaphores the GUI's frame submissions wait on (VulkanGraphicsContext::AddFrameWait)
Ctachyon::glsl_float4
Ctachyon::Glyph
Ctachyon::GPUDrawPushConstants
Ctachyon::RHI::GpuPipeline
Ctachyon::Gradient	Up to kMaxStops color stops plus an angle and interpolation color space
Ctachyon::GradientEditorState	Gradient editor popup state: edits a working copy, written back each frame it's open
Ctachyon::GradientEditorSubsystem	The gradient editor's state plus swatch styles keyed by swatch ID, with the same lifecycle as ColorPickerSubsystem's
Ctachyon::GradientHandle	Handle to a reference-counted GradientManager atlas slot
Ctachyon::GradientManager	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
Ctachyon::GraphicsContext	A graphics backend: the device, the window contexts that render the GUI's windows, and the images and text atlases they draw with
Ctachyon::NullGraphicsContext	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
Ctachyon::vulkan::VulkanGraphicsContext	The default graphics backend, on Vulkan 1.3
Ctachyon::GridAxisProperties	A grid item's placement and track request along one axis, plus the container's gap
Ctachyon::GridItemRenameInfo	Rename buffer and original name of a grid item; internal
Ctachyon::GridProperties	Grid container and item properties
Ctachyon::GridTrack	Size of one grid column or row (CSS: -tachyon-grid-column-track / -row-track)
Ctachyon::GridViewState	Construction state of the current GridView; internal
Ctachyon::GridViewVirtualState	User-owned, persistent state of a virtualized GridView; keep it alive across frames
Ctachyon::GUIApplication	The application: owns the windows, the systems and the frame loop
Ctachyon::GUIApplicationInitializeOptions	What GUIApplication::Initialize sets up besides the core systems
Ctachyon::GUIContent	What a control shows: a text, an icon or both, and an optional tooltip
Ctachyon::vulkan::GUIRenderContext	The Vulkan-side GUI pipeline set, built once at device init from kPrimitiveSpecs
Ctachyon::GUIRenderer
Ctachyon::PrimitiveRenderer
Ctachyon::GUIStateManager	Owns the per-frame state objects and runs their BeginFrame / EndFrame in order
Ctachyon::GUITheme	The library's styles, icons and theme metrics, the defaults the controls draw with
Cstd::hash< tachyon::ID >
Ctachyon::TabBarState::HiddenTab
Ctachyon::HierarchyInfo
Ctachyon::UICacheManager::HitInput	Per-frame input facts that decide whether a scope may be served from cache
Ctachyon::IClipboard	The clipboard text editors copy to and paste from; GUIApplication::SetClipboard sets one (default: SDL's, or LocalClipboard without SDL)
Ctachyon::LocalClipboard	A clipboard inside the process, not shared with other applications
Ctachyon::SDLClipboard	The system clipboard, through SDL
Ctachyon::IconMeasurement
Ctachyon::IconTextPlacement	Placement of a text + icon pair inside rect:
Ctachyon::ID	A 64-bit element ID whose bit layout depends on its IDMode
Ctachyon::IDManager	Makes element IDs: per-frame dynamic / ranged IDs (hashed from the call site or a hint and the parent stack) and persistent static IDs
Ctachyon::IFileSystem	What a file view reads and changes
Ctachyon::MemoryFileSystem	A file system kept in memory
Ctachyon::Image	An image made by GraphicsContext::CreateImage; the backend defines its contents
Ctachyon::vulkan::VulkanImage
Ctachyon::ImageSet	The images the shaders can sample, each at an ImageIndex. Implemented by the backend
Ctachyon::vulkan::VulkanImageSet
Ctachyon::IndexRange	A half-open range [begin, end) of indices within one depth
Ctachyon::InputState	Snapshot of input state for a single recorded OS event
Ctachyon::vulkan::VulkanDeviceContext::InstanceDebugConfig	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
Ctachyon::int2	Integer 2D vector
Ctachyon::int3
Ctachyon::int4
Ctachyon::InteractionState	The hovered, active, focused and captured elements, the active window, the one-shot click, hover suppression and the focus scroll axis
Ctachyon::Document::Internal	Kept by the documents; not part of the API
Ctachyon::DocumentSet::Internal	Kept by the documents; not part of the API
Ctachyon::GridViewVirtualState::Internal	Written by the grid view each frame; not part of the API
Ctachyon::GUIApplication::SettingsPanelState::Internal	Tree-view backing state, rebuilt per frame; not part of the API
Ctachyon::Panel::Internal	Kept by the docking; not part of the API
Ctachyon::TableState::Internal	Written by the table each frame; not part of the API
Ctachyon::VirtualTableColumn::Internal	Written by the table each frame (end-of-frame handlers read it); not part of the API
Ctachyon::IntRect
Ctachyon::IPlatformInputHandler	Platform-level input interface: receives raw OS events (keyboard, mouse) and forwards them into the GUI input pipeline
Ctachyon::ITextSystem	Text and icon registration, measurement, rendering and editing
Ctachyon::SkribidiTextSystem	Skribidi-based implementation of ITextSystem
Ctachyon::InputHandlerBroadcaster	Sends every platform input event to all handlers (e.g
Ctachyon::InputManager	Receives raw OS events, records them, and runs the frame's input pipeline (tab navigation, text editor focus, dispatch, post-dispatch)
Ctachyon::ItemDragDropConfig	Drag & drop setup for item-based views (tree, list, grid): items drag a payload and accept drops of the same payloadType
Ctachyon::ButtonGroupSubsystem::ItemState	One open group: its styles and the items registered so far
Ctachyon::ITextValidator	What an editable field takes as text, asked while it is edited
Ctachyon::TextConverter< T >
Ctachyon::IWindowBackend	Makes and manages the OS windows and delivers their input; GUIApplication::SetWindowBackend sets one, SDLWindowBackend is the default
Ctachyon::ImageWindowBackend	Adds windows that render to an image (WindowFlags::RenderToImage) to another window backend
Ctachyon::NullWindowBackend	A window backend without an OS: windows are records with a rect, and no input arrives (inject it with GUIApplication::Inject*)
Ctachyon::SDLWindowBackend	The default window backend, on SDL3
Ctachyon::IWindowContext	A window's rendering state: made by GraphicsContext::CreateWindowContext for each OS window, attached to it with IWindowBackend::AttachContextToWindow, and destroyed by GraphicsContext::DestroyWindowContext
Ctachyon::vulkan::VulkanWindowContext
Ctachyon::JsonValue	A JSON value (RFC 8259): null, bool, number, string, array or object
Ctachyon::LayoutHelpers::JustifySpacing	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
Ctachyon::LabelBinding	Links labels to the controls they describe during construction; owned by GUIStateManager
Ctachyon::LabelGroupSubsystem	Labels and DragLabels in a label group share a width; dragging any label's right edge resizes them all
Ctachyon::LabelGroupVisualState	Shared by all labels in a group, so the edge highlight is synchronized
Ctachyon::NodeViewEdit::Lanes	A wire's (by WireKey) lane overrides changed; default means no overrides
Ctachyon::LanguageTag	A BCP 47 language tag ("ja", "zh-Hant", "ko-KR") stored inline, so text styles stay plain values
Ctachyon::LayeredFades	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
Ctachyon::LayoutData	Flex / grid properties and CSS sizes of a style. Sizes are in CSS px in a Style
Ctachyon::LayoutEngine	Computes element sizes and positions from styles, content and constraints, in four passes run after construction:
Ctachyon::LayoutFlexbox
Ctachyon::LayoutGrid
Ctachyon::LayoutHelpers
Ctachyon::LayoutOverride	Per-element overrides of style layout properties
Ctachyon::LayoutStyle	The layout part of a registered Style, in pixels; shared by every style with the same values
Ctachyon::TableState::LazyReorderFn	A ReorderColumnsFn that costs one pointer when unset; assign it like a std::function: state.onReorderColumns = [&](int from, int to) { ... };
Ctachyon::MenuManager::Level	One open menu: the root dropdown or a submenu
Ctachyon::Line
Ctachyon::LineStyle
Ctachyon::LinkStyle	Colors of a link run, normal and hovered
Ctachyon::Diagnostics::LogArg	One argument
Ctachyon::Diagnostics::LogCategory	A subsystem's log category
Ctachyon::Diagnostics::LogRecord	One message as sinks and CopyRecentLogRecords see it
Ctachyon::MenuManager	State of the open menus (menu bar dropdowns, context menus, submenus) and their mouse and keyboard behaviour; one per application
Ctachyon::MenuRectsSubsystem	Last frame's screen rects of menu triggers and popups, written by AddPostLayout callbacks
Ctachyon::MessageButton	A button of a MessageDialog
Ctachyon::MessageDialogDesc	What a MessageDialog shows
Ctachyon::MessageDialogItem	An affected item, listed in a well: a name, an optional color dot and note, and a checkbox when checked is set
Ctachyon::MonitorInfo	Window, monitor and mouse coordinates are physical pixels
Ctachyon::NodeViewEdit::Move	A node (index) moved; positions in node.pos space
Ctachyon::MultiSelectState	Selected item IDs of a multi-select view; user-owned, keep it alive across frames
Ctachyon::NodeViewEdit::Node	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
Ctachyon::NodeModel	One node of a node view
Ctachyon::NodeProperty	One row of a node: an optional input socket, a body, and an optional output socket
Ctachyon::NodeView	All state of one node-view widget; no global state
Ctachyon::NodeViewEdit	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)
Ctachyon::NumericFieldConfig< T >	Drag speed and range of a numeric Field, specialized per value type
Ctachyon::NumericFieldConfig< double >	NumericFieldConfig for double values
Ctachyon::NumericFieldConfig< float >	NumericFieldConfig for float values
Ctachyon::NumericFieldConfig< int16_t >	NumericFieldConfig for int16_t values
Ctachyon::NumericFieldConfig< int32_t >	NumericFieldConfig for int32_t values
Ctachyon::NumericFieldConfig< int64_t >	NumericFieldConfig for int64_t values
Ctachyon::NumericFieldConfig< int8_t >	NumericFieldConfig for int8_t values
Ctachyon::NumericFieldConfig< uint16_t >	NumericFieldConfig for uint16_t values
Ctachyon::NumericFieldConfig< uint32_t >	NumericFieldConfig for uint32_t values
Ctachyon::NumericFieldConfig< uint64_t >	NumericFieldConfig for uint64_t values
Ctachyon::NumericFieldConfig< uint8_t >	NumericFieldConfig for uint8_t values
Ctachyon::NumericValue
Ctachyon::Occluder	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)
Ctachyon::OSWindowManager	Keeps the OS windows (through an IWindowBackend) and their window contexts for the GUI's window elements, keyed by ID
Ctachyon::GUIApplication::SettingsPanelState::Page	A page: a stable ID, its name in the tree, and render, which builds its content
Ctachyon::ColorPickerState::PaletteSwatch
Ctachyon::Panel	A unit of docked UI content: a title, an optional icon, and the callback that builds it
Ctachyon::ParseError	A problem found while parsing a style sheet; the parser skips the bad part and goes on
Ctachyon::PendingConnection	A wire being dragged. Committed wires are the reciprocal endpoints on NodeProperty
Ctachyon::PendingRowClick	Deferred row-click state for the drag-drop path: MouseDown primes it, MouseUp applies the selection unless a drag promoted in between
Ctachyon::FileThumbnails::Picture	RGBA pixels, rows from the top, straight alpha
CPipelineBuilder
Ctachyon::Pixels	A size in device pixels, used as is (not scaled by the UI scale)
Ctachyon::PointerDrag	One press on an element that may become a drag
Ctachyon::vulkan::DescriptorAllocator::PoolSizeRatio
Ctachyon::vulkan::DescriptorAllocatorGrowable::PoolSizeRatio
Ctachyon::PositionConstraintAxis	Where an element goes on one axis: in the parent's flow (Relative, Centered, Sticky) or out of it (Absolute, Fixed, Anchored)
Ctachyon::PostDrawEntry	Node in the flat post-draw linked list stored in ElementStorage
Ctachyon::PostLayoutContext	Context for post-layout callbacks (AddPostLayout)
Ctachyon::ElementStorage::PostLayoutEntry	Fired in registration order between layout and rendering
Ctachyon::PrimitiveRenderPass	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
Ctachyon::PrimitiveRenderTarget
Ctachyon::PrimitiveSpec
Ctachyon::Diagnostics::ProfileSample	One finalized node, depth-first. Durations are windowed averages (~4 updates/s)
Ctachyon::PropertyEndpoint	A property on a node. Default-constructed is invalid: in a socket it means "present, unwired"
Ctachyon::PropertyHelp	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)"
Ctachyon::Quad
Ctachyon::Range< Iterator >
Ctachyon::ID::Value::RangedParts
Ctachyon::vulkan::VulkanImage::Recipe	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
Ctachyon::RecordedInputEvent	A single OS input event recorded for dispatch this frame
Ctachyon::RenameSubsystem	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
Ctachyon::RHI::RenderCommandList	One frame's recording surface for one window
Ctachyon::vulkan::VulkanRenderCommandList
Ctachyon::RHI::RenderDevice	Device-lifetime operations
Ctachyon::vulkan::VulkanRenderDevice
Ctachyon::WindowRegistry::RenderNode	One entry in a window's flat pre-order render list
Ctachyon::ReorderableConstructionState	Construction state of the current reorderable group
Ctachyon::ReorderableDragState	Persistent drag state; one drag at a time application-wide
Ctachyon::ReorderableFocusFollow	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
Ctachyon::ReorderableSubsystem	Drag and construction state of drag-to-reorder groups, used by the Begin/EndReorderableGroup and Begin/EndReorderableItem widgets
Ctachyon::DoubleClickTracker::Result	Whether this click hit the same item as the previous one, and the time since it
Ctachyon::Result< T >	A value, or the Error saying why there is none
Ctachyon::Result< void >	Success, or the Error saying why not
Ctachyon::NodeViewEdit::Rewire	An input's source changed; an invalid endpoint means unwired
Ctachyon::ElementMove::Rotation
Ctachyon::SavedDocument	A document as SaveUIState kept it: which one it was, and how its panels were laid out
Ctachyon::SavedDocumentWindow	A main window of documents as SaveUIState kept it (TakeSavedDocuments)
Ctachyon::GUIApplication::Scope< EndFn >	A container's scope: its End runs when the scope leaves (or at End())
Ctachyon::UICacheManager::Scope	Only what's needed to decide whether a scope is still clean and to blit it; not the element tree
Ctachyon::Diagnostics::ScopedTimer	Times its own lifetime as a scope; a disabled profiler costs one branch
Ctachyon::Diagnostics::ScopeLocation	Per-call-site descriptor, static at each TACHYON_PROFILE_SCOPE site
Ctachyon::PrimitiveRenderTarget::ScopeReplay	A cached scope drawn here, moved delta window pixels from where it was captured; its primitives' draw orders start at baseOrder
Ctachyon::ScrollbarDragState	Per-element state of MakeScrollbarHandler (element data store); internal
Ctachyon::ScrollManagement	Scroll containers' offsets (pixels), kept across frames by ID behind handles
Ctachyon::SDLWindowBackendOptions	Options for SDLWindowBackend (SDLWindowBackend::Options)
Ctachyon::GUIApplication::SettingsPanelState	What RenderSettingsPanel shows: its pages, the selected one and the tree width
Ctachyon::short2
Ctachyon::short3
Ctachyon::short4
Ctachyon::SizeConstraintAxis	Per-axis size constraint: an explicit size, or a min / max clamp on the content-driven size
Ctachyon::SizerState	Per-element state of the sizer handlers (element data store); internal
Ctachyon::SliderFieldTrackSubsystem	Slider track widths written by the sliders' custom draws and read next frame (keyboard step sizes, drag mapping)
Ctachyon::SliderState	Per-element state of MakeSliderHandler and the integer slider (element data store); internal
Ctachyon::SplitSizeRange	An inclusive splitSize range, in CSS px
Ctachyon::LabelGroupSubsystem::State	State of one label group, kept across frames by group ID
Ctachyon::Style::States	A style's states, indexed by ElementState (or by slot number)
Ctachyon::ID::Value::StaticParts
Ctachyon::UndoHistory::Step
Ctachyon::PrimitiveRenderTarget::Stream	Per-kind primitive stream: CPU bytes appended by the emit methods and packed together into the current frame slot's GPU upload arena
Ctachyon::Style	A complete style, as parsed from CSS or built in code: layout properties plus the visual properties of each state, in CSS px
Ctachyon::StyleManager	Bakes serializable Styles into deduplicated runtime layout/visual styles; a StyleRef holds indices into the (possibly shared) pools
Ctachyon::StyleRef	A registered style, as StyleManager::Register returns it: indices into the shared style pools, cheap to copy
Ctachyon::StyleSheet	A parsed style sheet: named styles, custom properties and font faces
Ctachyon::StyleState	The visual properties of one element state (normal, :hover, :active, ...)
Ctachyon::ID::Value::SubRangeParts
Ctachyon::vulkan::SwapchainState
Ctachyon::TabBarMemory	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
Ctachyon::TabBarOptions	What a tab bar offers besides its tabs
Ctachyon::TabBarState	Construction state of the current tab bar; internal
Ctachyon::TabChainManager	Tracks the next/prev tab targets around the focused element, rebuilt each frame during construction and scoped to the active window
Ctachyon::TableColumn	A table column; callers pass an array of them each frame
Ctachyon::TableEmit	Transient state of one table emit; internal
Ctachyon::TableState	User-owned, persistent state of one table: column widths, selection, sort, options
Ctachyon::TabState	Construction state of the current tab, between BeginTab and EndTab; internal
Ctachyon::GUIApplication::PersistedTable::Target
Ctachyon::TextAtlasManager
Ctachyon::vulkan::VulkanTextAtlasManager
Ctachyon::TextConverter< T >	Turns a field's value into the text it shows and edits, and edited text back into a value
Ctachyon::TextDecoration	One text decoration line (underline, overline, ...)
Ctachyon::TextEditorFocusState	The focused text editor, plus the one as of the last Commit, to detect changes
Ctachyon::ITextSystem::TextEditUpdate
Ctachyon::TextLayoutStyle	How a text block is laid out in its box; shared by all states of a Style
Ctachyon::TextMeasurement
Ctachyon::TextOverride	Per-element text overrides for StyleManager::WithTextOverride
Ctachyon::TextStyle	What text is measured and laid out from: font, metrics and decoration lines
Ctachyon::TextWrapContext
Ctachyon::ToastAction	A text button on a toast; the first is drawn in the link color
Ctachyon::ToastDesc	What a toast says (ShowToast). Change it later through FindToast
Ctachyon::ToolbarDockCallbacks	Callbacks through which RenderToolbarDock changes the caller's data; the dock never touches that data itself
Ctachyon::ToolbarDockState	Per-instance state for one toolbar dock
Ctachyon::ToolbarItem	One toolbar item
Ctachyon::ToolbarWindowDragSubsystem	A floating toolbar window dragged by its thumb; one drag at a time
Ctachyon::TooltipManager	Decides which element's tooltip shows: the hovered one after a delay, or at once for focus moved by the keyboard
Ctachyon::TopDownDepthScanIterator
Ctachyon::TrackingAllocator	Allocation hooks that count what is live, for finding leaks
Ctachyon::TransitionManager	Tracks in-progress visual state transitions per element ID
Ctachyon::TransitionState	Pre-computed GPU style indices for a box that is mid-transition (or not)
Ctachyon::TransitionTiming	How long a change of state takes, and how it eases. A duration of 0 is instant
Ctachyon::TreeDropState	Tree reorder drop target under the cursor; internal, owned by the application
Ctachyon::TableState::TreeRowInfo	Per-row metadata from TreeCell()
Ctachyon::TreeViewRow	One row of a flat-data tree view (VirtualTreeView); rows are in depth-first order
Ctachyon::TreeViewState	Construction state of the current TreeView / ListView; internal
Ctachyon::Triangle
Ctachyon::TypeDimensions< T >
Ctachyon::TypeDimensions< byte2 >
Ctachyon::TypeDimensions< byte3 >
Ctachyon::TypeDimensions< byte4 >
Ctachyon::TypeDimensions< color4b >
Ctachyon::TypeDimensions< color4f >
Ctachyon::TypeDimensions< float2 >
Ctachyon::TypeDimensions< float3 >
Ctachyon::TypeDimensions< float4 >
Ctachyon::TypeDimensions< int2 >
Ctachyon::TypeDimensions< int3 >
Ctachyon::TypeDimensions< int4 >
Ctachyon::TypeDimensions< short2 >
Ctachyon::TypeDimensions< short3 >
Ctachyon::TypeDimensions< short4 >
Ctachyon::TypeDimensions< uint2 >
Ctachyon::TypeDimensions< uint3 >
Ctachyon::TypeDimensions< uint4 >
Ctachyon::TypeDimensions< ushort2 >
Ctachyon::TypeDimensions< ushort3 >
Ctachyon::TypeDimensions< ushort4 >
Ctachyon::UICacheManager	Retained-render cache for BeginCached/EndCached scopes
Ctachyon::uint2
Ctachyon::uint3
Ctachyon::uint4
Ctachyon::UndoHistory	The app's undo history: steps that each undo and redo one change
Ctachyon::RHI::UploadRequest
Ctachyon::vulkan::UploadWorker	Library internal: copies into mapped GPU memory on a thread of its own, so the main thread goes on recording commands
Ctachyon::ushort2
Ctachyon::ushort3
Ctachyon::ushort4
Ctachyon::ID::Value	The packed bits, viewed per mode; internal (use GetMode / Value / IDManager)
Ctachyon::TableHelpers::VirtualRowRange	Half-open [firstVisible, lastVisible) range of rows to emit
Ctachyon::VirtualTableColumn	A VirtualTable column: the TableColumn plus cell generator, sort order and section
Ctachyon::VisualBoxStyle	The box part of one state of a registered Style, in pixels; uploaded to the GPU as is (32 bytes)
Ctachyon::vulkan::VisualBoxStyleBuffers
Ctachyon::VisualColorStyle	GPU form of a ColorStyle, uploaded as is: the gradient is baked into an atlas slot that colorUV / gradientPage point at
Ctachyon::vulkan::VisualColorStyleBuffers
Ctachyon::VisualShadow	A BoxShadow in pixels with its color registered. No color is no shadow
Ctachyon::VisualShadowStyle	What a state draws on the CPU only: its shadows and its opacity
Ctachyon::VisualTextStyle	The text part of one state of a registered Style, in pixels
Ctachyon::vulkan::VulkanDeviceContext	The Vulkan device the GUI renders with: its own, or a host's (SetExternalDevice)
Ctachyon::WindowRegistry::WindowEntry	A window of this frame and its render list
Ctachyon::WindowRegistry	Per-window lists of ElementRefs in addition (render) order, driven during ElementStorage construction:
Ctachyon::vulkan::WindowVulkanState
Ctachyon::WireLane	A wire's place among the wires between the same two nodes, so their default lanes nest instead of coinciding or crossing (ComputeWireLaneOffsets)
Ctachyon::WireRoute	Polyline plus its draggable interior segments (never the end stubs)
Ctachyon::WireRouteOverrides	User-pinned lanes of one wire (unset = default), in the route's space
Ctachyon::WireSegmentDrag	Segment drag via mouse capture rather than DnD, so the resize cursor sticks
Ctachyon::WireSegmentHandle	Draggable interior segment; vertical segments drag horizontally and vice versa