| Ndonner | Top-level Donner namespace, which is split into different sub-namespaces such as donner::svg and donner::css |
| Nparser | Parsers for shared data types such as NumberParser and LengthParser |
| CDataUrlParser | Parse a URL, which can be an external resource or a data URL |
| COptions | Encoded input and external URL length limits for one parse |
| CResult | Result of parsing a data URL or external URL |
| CParserBase | Base class for parsers, containing common functionality such as maintaining the current parse location, skipping whitespace, and parsing numbers |
| CIntegerParser | Parser for positive integers, either decimal or hexadecimal |
| CResult | Container for parse result, containing the parsed result and the number of characters that were consumed to parse it |
| CLengthParser | Parser for CSS <length-percentage> strings, such as "10px", "30%", "10em", etc |
| CResult | Container for parse result, containing the parsed result and the number of characters that were consumed to parse it |
| COptions | Options to modify the parsing behavior |
| CLineOffsets | Helper class for finding newlines in a string, so that error messages can convert string-relative offsets into line numbers |
| CNumberParser | Parser for floating point numbers in SVG or CSS, corresponding to the CSS3 <number-token> definition from https://www.w3.org/TR/css-syntax-3/#number-token-diagram |
| CResult | Container for parse result, containing the parsed result and the number of characters that were consumed to parse it |
| COptions | Options to modify the parsing behavior |
| Ncss | Donner CSS library, a standalone composable CSS parser |
| Nparser | Parsers for various CSS data types, such as the top-level StylesheetParser and SelectorParser, as well as internal details such as ColorParser |
| CAnbMicrosyntaxParser | Parse a CSS value, per https://www.w3.org/TR/css-syntax-3/#parse-list-of-component-values |
| CResult | Result of parsing the An+B microsyntax |
| CColorParser | Parse a CSS color, either from a string or the CSS intermediate representation, a list of ComponentValues |
| CDeclarationListParser | Parse a CSS declaration list, which can be either from an HTML/SVG style attribute, or from the list of component values from within a rule |
| CSecurityStats | Parsing work observed before a declaration list finishes or reaches a limit |
| CRuleParser | Rule-related parsing routines, including parsing individual rules, lists of rules, and stylesheets |
| CSecurityStats | Parsing work observed before a rule list finishes or reaches a limit |
| CSelectorParser | Parse a CSS selector, or list of selectors, and returns a Selector that can be matched against in the stylesheet |
| CStylesheetParser | Parse a CSS stylesheet into a list of selectors and their associated declarations |
| CValueParser | Parse a CSS value, per https://www.w3.org/TR/css-syntax-3/#parse-list-of-component-values |
| CRGBA | Represents as 32-bit RGBA color, with each component in the range [0, 255] |
| CHSLA | Represents an HSLA color |
| CColor | Represents a CSS color value, like a RGBA color from a #rrggbb or #rgb hex value, or the currentcolor keyword |
| CCurrentColor | Represents the currentColor keyword |
| CFunction | A CSS function, such as rgb(255, 0, 0), parsed into a function name and a list of parameter values |
| CSimpleBlock | A CSS simple block, such as a rule block or a parenthesized expression |
| CComponentValue | A CSS component value, which is either a token, or a parsed function or block |
| CCSS | Public API for parsing CSS |
| CDeclaration | A declaration is a CSS name/value pair, such as color: red; |
| CDeclarationOrAtRule | Return value of parsers that may return either a declaration or an AtRule, specifically donner::css::parser::DeclarationListParser::Parse |
| CAnbValue | An+B microsyntax value, which is parsed by parser::AnbMicrosyntaxParser |
| CFontFaceSource | A single entry listed in src:-either a local face, a URL, or inline data |
| CFontFace | In-memory representation of a single @font-face rule |
| CAtRule | Rules starting with an @ are called At-Rules, and are used to define CSS features such as @media, @font-face, @keyframes, etc |
| CQualifiedRule | A QualifiedRule has a list of component values and a block, this is the intermediate representation of a stylesheet rule |
| CInvalidRule | InvalidRule is used to represent a rule which could not be parsed, such as an invalid at-rule |
| CRule | Holds a CSS rule which can either be a standard QualifiedRule, an AtRule, or an InvalidRule if there was a parse error |
| CSelector | A top-level Selector, which is a list of ComplexSelector |
| CAttributeSelector | Selectors which match against element attributes, such as a[href^="https://"] or h1[title] |
| CMatcher | Matcher condition for an attribute selector |
| CClassSelector | Selector which match the element's class attribute, for example .foo matches an element with class foo |
| CSelectorMatchResult | Returned by Selector::matches to indicate whether the selector matched, and if so, the specificity of the match |
| CComplexSelector | A complex selector is a sequence of one or more compound selectors, separated by combinators |
| CEntry | A single entry in a complex selector, which is a compound selector and a combinator |
| CCompoundSelector | A compound selector is a sequence of simple selectors, which represents a set of conditions that are combined to match a single element |
| CIdSelector | Selector which match the element's id attribute, for example #foo matches an element with an id="foo" attribute |
| CPseudoClassSelector | Selectors which start with one colon, e.g |
| CPseudoMatchResult | Result of matches, returns if the selector matched and if it can be treated as a "primary" matcher |
| CPseudoElementSelector | Selectors which start with two colons are called pseudo-elements, e.g |
| CSelectorTraversalBudget | Aggregate bound on selector work: element visits and bounded chunks of text inspection |
| CSelectorTraversalNavigation | Navigation that charges both visible elements and adapter-specific skipped nodes |
| CSelectorMatchOptions | Options for matching a selector against an element |
| CTypeSelector | Selector which matches the element type, e.g |
| CSpecificity | A CSS specificity value (id, class, type), as defined in https://www.w3.org/TR/selectors-4/#specificity-rules, which is used during cascading to determine which style takes precedence |
| CABC | A 3-tuple of integers representing the specificity before modifiers such as the "!important" flag have been applied |
| CSelectorRule | A rule in a stylesheet, which consists of a selector and a list of declarations |
| CStylesheet | A CSS stylesheet, which is a list of rules |
| CSecurityStats | Resource-limit accounting produced while parsing an untrusted stylesheet |
| CToken | A CSS token, which are created as a first step when parsing a CSS string |
| CIdent | <ident-token>, which represents a CSS identifier, which is an unquoted string |
| CFunction | <function-token>, which indicates the start of a function call |
| CAtKeyword | <at-keyword-token>, representing @ followed by an identifier |
| CHash | <hash-token>, representing a CSS identifier that starts with a # |
| CString | <string-token>, which represents a quoted string, either with double or single quotes ("foo" or 'foo') |
| CBadString | <bad-string-token>, which is generated when a string contains an unescaped newline |
| CUrl | <url-token>, which represents a url() function |
| CBadUrl | <bad-url-token>, which represents an invalid url() function |
| CDelim | <delim-token>, which contains a single character |
| CNumber | <number-token>, which represents a number, either integer or floating point |
| CPercentage | <percentage-token>, which represents a percentage such as '50' |
| CDimension | <dimension-token>, which represents a dimension such as '50px' |
| CWhitespace | <whitespace-token>, which contains one or more whitespace characters in the source |
| CCDO | <CDO-token>, which represents the HTML comment opening <!– in the source |
| CCDC | <CDC-token>, which represents --> in the source |
| CColon | <colon-token>, which represents ':' in the source |
| CSemicolon | <semicolon-token>, which represents ';' in the source |
| CComma | <comma-token>, which represents ',' in the source |
| CSquareBracket | <[-token>, which represents [ in the source |
| CParenthesis | <(-token>, which represents ( in the source |
| CCurlyBracket | <{-token>, which represents { in the source |
| CCloseSquareBracket | <]-token>, which represents ] in the source |
| CCloseParenthesis | <)-token>, which represents ) in the source |
| CCloseCurlyBracket | <}-token>, which represents } in the source |
| CErrorToken | Special error token, used to mark named parsing errors |
| CEofToken | <EOF-token>, which marks the end of the input stream and is always output at the end of a token list |
| CWqName | A CSS qualified name, which is a name optionally associated with a namespace |
| Nsvg | Donner SVG library, which can load, manipulate and render SVG files |
| Nparser | Parsers for the SVG XML format, SVGParser, as well as individual parsers for SVG components, such as PathParser and TransformParser |
| CAttributeParser | Parses XML attributes and sets applies them to SVGElements |
| CClockValueParser | Parses SMIL clock values from string representation |
| CCssTransformParser | Parse a CSS "transform" property |
| CParserOrigin | Contains the start location within a string where a subparser was invoked, used for remapping errors back to their original text |
| CSVGParserContext | Stores the current state of SVGParser during parsing |
| CListParser | Parses a list of values conforming to the SVG comma-or-space list syntax |
| CNumber2dParser | Parser for floating point numbers in SVG or CSS, corresponding to the CSS3 <number-token> definition from https://www.w3.org/TR/css-syntax-3/#number-token-diagram |
| CResult | Container for parse result, containing the parsed result and the number of characters that were consumed to parse it |
| CPathParser | Parse an SVG path "d"-string, see Path Data Syntax |
| CCommand | One authored command, before coordinate or curve normalization |
| CCommandList | Owning command syntax; implicit repetitions are expanded, including moveto's later lineto |
| CPointsListParser | Parse a SVG "points" attribute, used to specify line paths for <polyline> and <polygon> elements |
| CPreserveAspectRatioParser | Parser for SVG preserveAspectRatio attribute |
| CSVGParser | Parse an SVG XML document |
| COptions | Options to modify the parsing behavior |
| CTransformParser | Parse an SVG transform attribute, such as translate(100 100), using the SVG syntax which does not support units on numbers |
| CViewBoxParser | Parse an SVG viewBox attribute, such as "0 0 100 100" |
| CUnparsedProperty | Represents an unparsed property, which is a CSS property that is element-specific and needs to be matched with the actual element before it can be parsed and applied |
| CPropertyParseFnParams | Parameters for a property parse function |
| Ncompositor | |
| CComplexityBucketerConfig | Runtime configuration for ComplexityBucketer |
| CComplexityBucketerStats | Stats produced by ComplexityBucketer::reconcile() |
| CComplexityBucketer | Producer that pre-chunks a document into a small number of layers based on per-subtree rasterization cost |
| CCompositorTile | A single bitmap cache unit the compositor exposes for GPU upload - either a static segment (non-promoted content between promoted layers) or a promoted layer's own rasterization |
| CCancellationToken | Cancellation handle for CompositorController::renderFrame. The token wraps a single std::atomic<bool>; the compositor's per-layer / per-segment rasterize loops poll isCancelled() at coarse safe points (between rasterizeLayer / rasterizeStaticSegment calls, never mid-rasterize) and bail early when set |
| CCompositorConfig | Runtime feature gates for CompositorController |
| CCompositorController | Controls compositor layer promotion/demotion and orchestrates composited rendering |
| CPromoteResult | Result of requesting an editor-facing compositor presentation plan |
| CBitmapMemoryBreakdown | Split of totalBitmapMemory by what holds the pixels. The four kinds are evicted by different rules, so a single total cannot say which rule is the one letting memory grow |
| CFastPathCounters | Diagnostic counters for the translation-only fast path. Tests read these to assert that a drag is taking the fast path every frame, not falling through to prepareDocumentForRendering |
| CLayerInspectorRow | One row of diagnostic state per active compositor layer, intended for the editor's read-only layer-inspector panel. Cheap to build, cheap to copy: a few ints and one short string per layer |
| CSegmentInspectorRow | One row of diagnostic state per static segment (the non-promoted content between promoted layers, plus the pre-first and post-last slots). Sized N+1 where N is layerCount() |
| CStaticSpanPlan | Conservative draw-cost plan for one static segment slot |
| CCompositeTileSnapshot | One row of the layer inspector's paint-order tile structure. Promoted layers remain visible in this view even when they have no bitmap or texture payload. When pixels are available, a CPU thumbnail or backend texture snapshot lets the panel show a preview inline |
| CRenderFrameStats | Worker render costs from the most recent renderFrame call, split by whether the work was caused by immediate-mode transient spans or retained cached tiles |
| CStateSnapshot | Compact observable compositor state for diagnostics and tests |
| CHintEntry | A single {source, weight} entry stored by CompositorHintComponent |
| CCompositorHintComponent | Author-layer ECS component carrying the set of weighted hints published against an entity |
| CImmediateLayerPlan | Immediate-mode eligibility and timing diagnostics for a promoted layer |
| CCompositorLayer | Represents a single compositor layer with its cached bitmap and dirty state |
| CPayloadRaster | Raster a payload was drawn under |
| CComputedLayerAssignmentComponent | Resolved-layer ECS component written by LayerResolver each frame; must not be hand-edited |
| CDragSession | RAII session for a drag interaction with composited rendering |
| CDualPathVerifier | Dual-path assertion harness for composited rendering |
| CVerifyResult | Result of a dual-path verification pass |
| CResolveOptions | Per-call policy for LayerResolver::resolve() |
| CLayerResolverStats | Stats produced by LayerResolver::resolve(). Tests inspect these |
| CLayerResolver | Stateless resolver that collapses CompositorHintComponent entries into ComputedLayerAssignmentComponent assignments, subject to a layer budget |
| CMandatoryHintDetectorStats | Stats produced by MandatoryHintDetector::reconcile() |
| CMandatoryHintDetector | Subsystem that publishes Mandatory CompositorHint entries for SVG features that force isolated compositing |
| CScopedCompositorHint | RAII handle that adds a HintEntry to an entity's CompositorHintComponent on construction and removes exactly that entry on destruction |
| Ncomponents | Contains the implementation of the Donner ECS, |
| Nfilter_primitive | Variant holding the parameters for each type of filter primitive |
| CGaussianBlur | Parameters for feGaussianBlur |
| CFlood | Parameters for feFlood |
| COffset | Parameters for feOffset |
| CBlend | Parameters for feBlend |
| CComposite | Parameters for feComposite |
| CColorMatrix | Parameters for feColorMatrix |
| CMerge | Parameters for feMerge. Children are represented as additional inputs on the FilterNode |
| CDropShadow | Parameters for feDropShadow |
| CComponentTransfer | Parameters for feComponentTransfer |
| CFunc | A single channel's transfer function |
| CConvolveMatrix | Parameters for feConvolveMatrix |
| CMorphology | Parameters for feMorphology |
| CTile | Parameters for feTile |
| CTurbulence | Parameters for feTurbulence |
| CImage | Parameters for feImage |
| CDisplacementMap | Parameters for feDisplacementMap |
| CLightSource | Light source parameters for lighting filter primitives |
| CDiffuseLighting | Parameters for feDiffuseLighting |
| CSpecularLighting | Parameters for feSpecularLighting |
| CAnimationStyleContext | Enables animated presentation values during the final style cascade pass |
| CAnimatedValuesComponent | Component on target entities that holds animated attribute overrides |
| CAnimateMotionComponent | Declarative motion-path values and timing |
| CMPathComponent | Reference from an mpath child to a local path element |
| CAnimateTransformComponent | Component storing <animateTransform>-specific data |
| CAnimateValueComponent | Component storing <animate>-specific value data |
| CAnimationInterpolation | Shared keyframe timing and composition attributes |
| CAnimationSegment | Selected keyframe interval and its eased progress |
| CSampledAnimationMotion | A sampled motion transform with its effective composition mode |
| CAnimationContextualWorkBudget | Shared contextual preparation allowance; used only by serialized document preparation |
| CAnimationContextualWorkContext | Scoped preparation context; never carried by filter graphs, snapshots, or raster replay |
| CAnimationResourceBudget | Per-document animation admission with optional owner-frame contextual preparation admission |
| CAnimationInterval | One resolved active interval, with the unconstrained repeating duration |
| CAnimationStateComponent | Runtime state of an animation element, computed each frame by the AnimationSystem |
| CAnimationSystem | Evaluates declarative SVG animation elements at a document time and applies their values |
| CAnimationTimeSpecifier | One declarative timing source and its offset |
| CAnimationTimingComponent | Stores timing attributes for an animation element |
| CAnimationValueContext | Context required to resolve relative units and currentColor for an animated value |
| CClockValue | Represents a SMIL clock value, which can be a concrete time in seconds or indefinite |
| CContextualLengthSample | An admitted value declaration with its resolved time, independent of document storage |
| CContextualLengthRecipe | Ordered animation stack retained until the referencing instance's length context is known |
| CSetAnimationComponent | Component storing <set>-specific animation data |
| CClassComponent | Holds the value of the class attribute of an element |
| CComputedClipPathsComponent | Stores a computed clip path, which is used to clip the rendering of an entity |
| CClipPath | Information about a specific shape within a clip path |
| CConditionalProcessingComponent | Stores the SVG conditional-processing attributes (requiredFeatures, requiredExtensions, systemLanguage) for an element |
| CDescriptiveTextComponent | Stores the concatenated text content of a descriptive element, such as <title>, <desc>, or <metadata> |
| CDirtyFlagsComponent | Tracks which computed properties are stale and need recomputation after a DOM mutation |
| CRenderTreeState | Global invalidation state, stored in the registry context via Registry::ctx() |
| CDocumentResourceFamilyBudget | Shared live-memory envelope for a root SVG document and all cached subdocuments |
| CLimits | Per-kind and aggregate retained-byte ceilings |
| CSecurityStats | Current charges and sticky refusal state for diagnostics |
| CDocumentResourceFamilyContext | Shared budget handle carried by a root document and its cached subdocuments |
| CElementTypeComponent | Stores the parsed element type of the current entity |
| CEvaluatedReferenceComponent | Represents a reference to another entity which has been evaluated from a Reference string |
| CComputedFilterResourceBudget | Owns computed-filter structural reservations and shared raster payload admission |
| CLimits | Per-document computed-filter memory ceiling |
| CFilterComponent | Parameters for a <filter> element |
| CComputedFilterComponent | Computed filter parameters parsed by FilterSystem, represents the resolved DOM hierarchy of a <filter> element |
| CFilterInput | Identifies the input to a filter primitive node |
| CPrevious | The input is the output of the immediately preceding primitive (or SourceGraphic for the first primitive) |
| CNamed | The input is a named result from a prior primitive's result attribute |
| CFilterNode | A single node in the filter graph, representing one filter primitive |
| CFilterGraph | The complete filter graph for a <filter> element |
| CGpuFilterWorkingSet | Conservative resource layout for the live float filter execution strategy |
| CFilterWorkMultiplier | Computes one primitive's full-surface work multiplier without changing its validation rules |
| CFilterStandardInputUsage | Standard filter inputs that a graph reads, other than SourceGraphic |
| CCpuTransientBufferCount | Computes one CPU primitive's transient float-buffer demand |
| CFilterExecutionBudget | Shared per-frame filter budget |
| CReservation | Successful preflight reservation made before allocating a filter capture surface |
| CFilterPrimitiveComponent | Parameters for SVGFilterPrimitiveStandardAttributes |
| CFEGaussianBlurComponent | Parameters for SVGFEGaussianBlurElement |
| CFEFloodComponent | Parameters for SVGFEFloodElement |
| CFEOffsetComponent | Parameters for SVGFEOffsetElement |
| CFECompositeComponent | Parameters for SVGFECompositeElement |
| CFEColorMatrixComponent | Parameters for SVGFEColorMatrixElement |
| CFEBlendComponent | Parameters for SVGFEBlendElement |
| CFEDropShadowComponent | Parameters for SVGFEDropShadowElement |
| CFEComponentTransferComponent | Marker component for SVGFEComponentTransferElement |
| CFEFuncComponent | Parameters for a feFuncR/G/B/A child element within feComponentTransfer |
| CFEConvolveMatrixComponent | Parameters for SVGFEConvolveMatrixElement |
| CFEMorphologyComponent | Parameters for SVGFEMorphologyElement |
| CFETileComponent | Marker component for SVGFETileElement |
| CFEImageComponent | Parameters for SVGFEImageElement |
| CFEDisplacementMapComponent | Parameters for SVGFEDisplacementMapElement |
| CFETurbulenceComponent | Parameters for SVGFETurbulenceElement |
| CFEMergeComponent | Marker component for SVGFEMergeElement |
| CFEMergeNodeComponent | Parameters for a feMergeNode child element within feMerge |
| CLightSourceComponent | Light source parameters, stored on feDistantLight, fePointLight, or feSpotLight child elements |
| CFEDiffuseLightingComponent | Parameters for SVGFEDiffuseLightingElement |
| CFESpecularLightingComponent | Parameters for SVGFESpecularLightingElement |
| CFilterSystem | Handles parsing and instantiating SVG filter effects from the SVG DOM |
| CFontMetricDependenciesComponent | Faces used to resolve font-relative shape lengths, independently of any text subtree |
| CChildFontPaintDependencies | Owned evidence for pixels drawn from a separate registry. The weak handle does not keep an obsolete source document alive. Its budget and revision cannot be replaced by a parent's face |
| CFontPaintDependenciesComponent | Faces used by lazy paint work on one consuming rendering instance. These snapshots survive temporary offscreen traversals and include external SVG images as separate consumers |
| CFontResourcePreparationState | Changes to prepared geometry or captured child evidence invalidate operation-local graph caches |
| CRenderedFontResourceScope | Exclusions belong only to the last completed render. Target preflight never consults this proof |
| CScopedFontResourceRender | A render scope accepts exclusions only after its caller completes the corresponding traversal |
| CFontResourceGraph | A frame-local snapshot of the font dependencies and resolved reference ranges of the render tree |
| CCollection | Owned result of following the prepared references reachable from a target |
| CFontResourceGraphCache | Bounded reuse within one render preparation or font-refresh traversal. No entry survives the operation, and preparation changes invalidate both the graph and its target collections |
| CStats | Work and reuse counters for one cache lifetime |
| CGeometryPreparationResourceBudget | Owns the current computed-path reservation for one document registry |
| CLimits | Local ceiling for geometry reservations |
| CHyperlinkComponent | Stores the hyperlink target for an <a> element |
| CIdComponent | Holds the value of the id attribute of an element |
| CLayoutSystem | Handles layout and bounds calculations for SVG elements |
| CSizedElementProperties | Stores an offset/size for elements that are positioned with x/y/width/height attributes with respect to their parent |
| CSizedElementComponent | Stores the properties of a sized element, x, y, width, height |
| CComputedSizedElementComponent | Stores the computed bounds of a sized element, resolving units and percentages |
| CComputedShadowSizedElementComponent | Stores a shadow tree's computed SizedElementComponent, where a <use> element overrides the width or height on <symbol> or <svg> which use SizedElementComponent |
| CSymbolComponent | Stores unique parameters for the <symbol> element |
| CTransformComponent | Stores the raw transform value set on an entity, for the transform presentation attribute |
| CComputedLocalTransformComponent | Stores the computed local transform for an entity (after CSS cascade + percentage/viewport resolution) |
| CComputedAbsoluteTransformComponent | Stores the computed absolute transform for an entity - the full cascade of ancestor transforms composed together |
| CViewBoxComponent | A component attached to entities that have a viewBox attribute, such as <svg> and <pattern> |
| CComputedViewBoxComponent | Computed value of a viewBox for the current element |
| CNodeLifetimeCollector | Collects detached SVG DOM subtrees when no public handles retain them |
| CNodeExternalRefState | Shared control block retained by public SVG DOM element wrappers |
| CNodeLifetimeComponent | Tracks whether an SVG DOM node is attached to the document tree or currently detached |
| CClipPathComponent | Parameters for the <clipPath> element |
| CGradientComponent | Common parameters for gradient elements, <linearGradient> and <radialGradient> |
| CComputedGradientComponent | Created by PaintSystem during render tree instantiation |
| CLinearGradientComponent | Parameters for a <linearGradient> element |
| CComputedLinearGradientComponent | Computed properties for a <linearGradient> element |
| CMarkerComponent | Stores the marker data for an SVG element |
| CMaskComponent | Parameters for the <mask> element |
| CPaintSystem | Manages Paint Servers for gradients and patterns, handling style and structural inheritance and creating "computed" state and shadow trees for these elements |
| CPatternComponent | Parameters for <pattern> elements which are not captured by ViewBoxComponent and SizedElementComponent |
| CComputedPatternComponent | Computed properties for <pattern> elements, after resolving and inheriting values from referenced patterns |
| CRadialGradientComponent | Parameters for a <radialGradient> element |
| CComputedRadialGradientComponent | Computed properties for a <radialGradient> element |
| CStopProperties | Parameters for a <stop> element |
| CComputedStopComponent | Stores the computed properties of a <stop> element |
| CStopComponent | Stores the properties of a <stop> element |
| CParsedPayloadResourceBudget | Bounds dynamic payload retained while parsing one untrusted SVG document |
| CLimits | Local ceiling for all retained parsed payloads |
| CSecurityStats | Current category bytes and cumulative admission failures |
| CPathLengthComponent | Stores a user-overridden path length on an element |
| CPreserveAspectRatioComponent | Stores the preserveAspectRatio attribute of <svg> and <pattern> |
| CReferenceResolutionBudget | Bounds document-wide href inheritance traversal for filters, gradients, and patterns |
| CLimits | Caller-selected depth and per-kind hop limits |
| CStats | Accumulated reservation state for one reference kind |
| CRenderingBehaviorComponent | Component that controls how the attached element is rendered, determines how different element types are rendered |
| CSubtreeInfo | Created on the start of a subtree, to inform the renderer about which element ends the current subtree, plus how many isolated layers need to be popped when the subtree is complete |
| CPaintContextRemap | Remap information for a paint inherited through the SVG2 context-fill / context-stroke keywords (https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint) |
| CPaintResolvedReference | Contains rendering information for a paint server, such as the subtree needed if it establishes an isolated layer, and where the paint server is located |
| CResolvedClipPath | Contains resolved information about the clip-path property, such as which element it is pointing to |
| CResolvedMask | Contains resolved information about the mask property, such as which element it is pointing to |
| CResolvedMarkerLengths | Animated marker lengths resolved once against the referencing rendering instance |
| CResolvedMarker | Resolved <marker> reference applied to a rendering instance |
| CRenderingInstanceComponent | An instance of the entity in the rendering tree |
| CDecodedImageCacheReclaimer | Optional decoded-animation cache hook invoked before a family-budget reservation |
| CDeferredDecodedImageComponent | A decoded image waiting for enough recoverable document-family capacity |
| CImageComponent | Parameters for the <image> element |
| CDecodedImageReservation | Owns a decoded-raster reservation from a shared document-family budget |
| CLoadedImageComponent | Loaded raster image resource, created from a ImageComponent when the href references a raster image (PNG, JPEG, GIF) |
| CLoadedSVGImageComponent | Loaded SVG sub-document, created from a ImageComponent when the href references an SVG file (image/svg+xml) |
| CExternalUseComponent | Loaded external SVG sub-document referenced by a <use> element |
| CResourceManagerContext | Resource manager, which handles loading resources from URLs and caching results |
| CFetchSecurityStats | External resource fetch attempts, cache use, and limit state |
| CSubDocumentAdmission | Internal count admission for retained SVG resource graphs. Resource graphs must be idle/serialized during traversal; the mutex protects metadata only |
| CStats | Family-wide admission observations; entity/payload charges are high-water snapshots |
| CReservation | Provisional document slots. Destruction refunds slots but not parse attempts |
| CSubDocumentCache | Cache for parsed SVG sub-documents referenced by <image> or <use> elements |
| CLimits | Local admission ceilings, also tightening the family when bound to a resource registry. Entity and parsed-payload admission snapshots include the original root |
| CSecurityStats | Observed cache size, parse work, and admission failures |
| CScopedRenderInvalidationRestore | Auxiliary preparation may compute geometry, but cannot consume the canvas renderer's dirty obligations. Hold under the document write guard; restore only identities still alive |
| CComputedShadowTreeComponent | An instantiated ShadowTreeComponent, which points to the roots of parallel entity trees |
| CBranchStorage | Storage for a single shadow tree |
| COffscreenShadowTreeComponent | Defines an offscreen shadow tree attached to the current entity (the shadow host) |
| CShadowEntityComponent | A component attached to entities in the shadow tree, indicating which light entity they are mirroring |
| CShadowTreeRootComponent | Indicates root of an instantiated shadow tree, where the light entity is is the target of the href, e.g |
| CShadowTreeComponent | Indicates the entry point to a shadow tree, which instantiates a virtual tree of entities mirroring another entity's tree |
| CShadowTreeResourceBudget | Aggregate generated-entity and recursion budget shared by every shadow-tree source |
| CShadowTreeSystem | Instantiates shadow trees for elements that are not part of the main render graph, such as <use> and <pattern> elements |
| CCircleProperties | Properties for a <circle> element |
| CComputedCircleComponent | Computed properties for a <circle> element, which applies values from the CSS cascade |
| CCircleComponent | Parameters for a <circle> element |
| CComputedInstanceGeometryComponent | Selects instance-owned geometry, including an intentionally empty or refused path |
| CComputedPathComponent | Stores a Path used for rendering a shape, which may be generated from the parameters of shapes such as circle, rect, line, poly, and path |
| CEllipseProperties | Parameters for a <ellipse> element |
| CComputedEllipseComponent | Computed properties for a <ellipse> element, which applies values from the CSS cascade |
| CEllipseComponent | Parameters for a <ellipse> element |
| CLineComponent | Parameters for a <line> element |
| CPathComponent | Parameters for a <path> element |
| CPolyComponent | Parameters for a <polygon> or <polyline> element |
| CRectProperties | Parameters for a <rect> element |
| CComputedRectComponent | Computed properties for a <rect> element, which applies values from the CSS cascade |
| CRectComponent | Parameters for a <rect> element |
| CShapeSystem | Creates computed path for shapes such as <circle>, <line>, and <path> |
| CComputedResourceOpacities | Final resource opacities for this style instance, including explicit parent inheritance |
| CComputedStyleComponent | Contains the computed style properties for an element, which is a combination of the style="" attribute, the CSS stylesheet, and the CSS cascade where properties are inherited from the parent |
| CDoNotInheritFillOrStrokeTag | This component is added to entities to indicate that 'fill' and 'stroke' attributes should not be inherited, which is used for <pattern> because it establishes a shadow tree, and we do not want to recursively inherit 'fill' or 'stroke' values into the children |
| CExternalUseStyleContext | Installed only while the child document's write access is held |
| CProjectedNonWhitespaceTextTag | Non-whitespace authored text not represented by the active raw-text child view. Covers conversion pruning and typed appends after incremental source projection |
| CSelectorRawTextAuthorityTag | Incremental content projection retained a complete raw-text child view for selectors |
| CSelectorRejectedTextTag | A rejected source projection leaves retained typed text authoritative |
| CStyleComponent | Contains properties the style="" attribute for an element, local to the element |
| CStyleResourceBudget | Aggregate stylesheet cascade and selector traversal budget for one style-computation pass |
| CLimits | Independent cascade, traversal, and retained-property limits |
| COwnerScope | Shared owner scope; nested recording and fallback work preserves the current allowance |
| CActiveRegistryScope | Keep mutable document storage active throughout preparation, drawing and restoration |
| CMatchedStyleRule | Diagnostic record for one stylesheet rule that matched an element |
| CStyleRuleAtSourceOffset | Stylesheet rule found at a document source offset |
| CStyleSystem | Computes stylesheet information for elements, applying the CSS cascade and inheritance rules |
| CStylesheetSourceMapSegment | Maps a contiguous span of parsed CSS text back to the SVG document source |
| CStylesheetSourceMap | Source map for stylesheet text produced by concatenating <style> text/CDATA children |
| CStylesheetComponent | Data for a <style> element |
| CSVGDocumentContext | Holds global state of an SVG document, such as the root element, id-to-element mapping, and the document size |
| CComputedTextComponent | Pre-computed layout information for a text subtree |
| COwnerSpanRange | Half-open range of indices into spans |
| CTextSpan | A contiguous slice of text with fully resolved layout attributes |
| CAncestorShift | Unresolved baseline-shift values from ancestor tspan elements. Each entry is the ancestor's (baseline-shift keyword, baseline-shift Lengthd, font-size in pixels). Layout engines resolve each entry using font OS/2 metrics for sub/super or toPixels() for explicit lengths, then sum to get the total ancestor shift |
| CComputedTextGeometryComponent | Cached geometry for text layout and text-derived public API queries |
| CGlyphGeometry | Outline geometry for a single rendered glyph |
| CCharacterGeometry | Cached geometry for one addressable character |
| CTextComponent | Defines the start of a text element, which may have other text elements as children |
| CTextPathComponent | Stores attributes specific to <textPath> elements |
| CTextPositioningComponent | Defines the positioning of a text element, which may have other text elements as children |
| CTextRootComponent | Defines the start of a text element, which may have other text elements as children |
| CTextSystem | System to compute text layout spans from raw text and positioning attributes |
| CTreeMutation | Central mutation service for SVG DOM tree edits |
| CTinySkiaPathCacheComponent | Per-entity cache of a shape's donner::Path converted to tiny_skia::Path |
| CTinySkiaImageCacheComponent | Per-entity cache of a LoadedImageComponent's pixels converted from the straight-alpha ImageResource contract to the premultiplied form tiny-skia samples |
| CRenderingContext | Rendering controller, which instantiates and and manages the rendering tree |
| CHitGeometry | Evaluated pointer-event geometry shared by live queries and immutable frame captures |
| CHitRecord | Owned geometry and internal target identity in front-to-back paint order |
| CFeImageSubtreeResult | Result from createFeImageShadowTree |
| Ntext_engine_detail | |
| CChunkRange | Byte range within a span representing a shaping chunk |
| CByteIndexMappings | Index mapping result for a span's text |
| CChunkBoundary | Text chunk boundary for per-chunk text-anchor adjustment |
| CRunPenExtent | Per-run pen start/end position for textLength calculation |
| CTextLengthTraversalStats | Optional operation counts for deterministic textLength traversal complexity tests |
| CFilterEffect | Filter effect container, which can contain a reference to another filter effect, or a CSS filter function (such as blur(), grayscale(), etc) |
| CNone | No effect |
| CBlur | Blur effect, which applies a gaussian blur with the given standard deviation |
| CElementReference | Reference to another filter effect, from a url() |
| CHueRotate | CSS hue-rotate(<angle>) filter function |
| CBrightness | CSS brightness(<number-percentage>) filter function |
| CContrast | CSS contrast(<number-percentage>) filter function |
| CGrayscale | CSS grayscale(<number-percentage>) filter function |
| CInvert | CSS invert(<number-percentage>) filter function |
| CFilterOpacity | CSS opacity(<number-percentage>) filter function |
| CSaturate | CSS saturate(<number-percentage>) filter function |
| CSepia | CSS sepia(<number-percentage>) filter function |
| CDropShadow | CSS drop-shadow() filter function |
| CCssTransform | Compared to an SVG transform, CSS transforms have additional features, such as the ability to add units to the translate() function, such as translate(1em 30px) |
| CSimple | Stores a precomputed transform |
| CTranslate | Stores a deferred translate() operation, which can have two <length-percentage> arguments, such as translate(1em 30px) |
| CCursorImage | One authored cursor image candidate and its optional hotspot |
| CCursor | Cascaded CSS cursor value with authored URL candidates and a required keyword fallback |
| CEvent | A DOM event object, carrying information about a user interaction |
| CListenerHandle | Handle for removing an event listener. Returned by addEventListener |
| CGradientStop | Values for a gradient stop, https://www.w3.org/TR/SVG2/pservers.html#StopElement |
| CMarkerOrient | Represents the orientation of a marker |
| CPaintOrder | CSS paint-order property value: the order in which the fill, stroke, and markers of a shape/text are painted |
| CPreserveAspectRatio | Handles SVG's preserveAspectRatio attribute |
| CStrokeDasharray | The parsed result of the 'stroke-dasharray' property, see: https://www.w3.org/TR/SVG2/painting.html#StrokeDasharrayProperty |
| CTransformOrigin | Represents the transform-origin property value |
| CDocumentAccessLock | Lightweight reader/writer gate for document access |
| CDetachedNodeDiagnostics | Summary of detached-node collection state |
| CDocumentAccessDiagnostics | Summary of document access and lock state |
| CDocumentMutationRecord | One committed document mutation revision |
| CDocumentMutationLogSnapshot | Snapshot of mutation-log records after a caller-owned sequence number |
| CDetachedNodeState | Document-local detached-node collection state |
| CDocumentState | Shared mutable state behind SVGDocument and SVGElement facades |
| CDocumentReadAccess | Scoped read access to a DocumentState |
| CDocumentWriteAccess | Scoped write access to a DocumentState |
| CDetachedNodeCollectionDeferral | Scoped deferral for detached-node collection during snapshot or observer epochs |
| CDocumentMutationBatch | Scoped write access that coalesces nested DOM mutation revision bumps |
| CDonnerController | Provides hit-testing and spatial queries for an SVG document |
| CHitTestSnapshot | Immutable hit geometry for one rendered document state. No live layout access during queries |
| CLinkHit | Result of a successful hitTestLink query: the enclosing <a> element that was hit, its retained link target, and the concrete element under the point |
| CRecursionGuard | Helper to guard against recursion when evaluating references |
| CResolvedReference | Represents a resolved reference to an SVG entity |
| CReference | Represents a reference to an SVG entity by its href, typically created from a url(#id) string |
| CPaintServer | Represents a paint server, which can be a solid color, a reference to another element, or a special value like "none" or "context-fill" |
| CNone | Represents the "none" value for a paint server |
| CContextFill | Represents the "context-fill" value for a paint server |
| CContextStroke | Represents the "context-stroke" value for a paint server |
| CSolid | Represents a solid color paint server |
| CElementReference | Represents a reference to another element, which originates from a url() reference. Should point to another paint server |
| CProperty | Holds a CSS property, which has a name and value, and integrates with inheritance to allow cascading values using the CSS model with specificity |
| CPropertyRegistry | Holds CSS properties for a single element |
| CRenderingInstanceView | A view containing a list of components::RenderingInstanceComponent which can be iterated over |
| CSavedState | Opaque iterator state returned by save and consumed by restore |
| CFilterRegionSample | Resolved clipping bounds and optional un-clipped animated geometry, in user coordinates |
| CFilterRegionContext | Per-invocation filter coordinates and subregion history, independent of GPU resources |
| CGifEncoder | Incremental in-memory encoder for looping animated GIF89a images |
| CRgb | An opaque 8-bit sRGB color |
| COptions | Encoder configuration |
| CPatternTileRasterMetrics | Validated dimensions and scale for a rasterized pattern tile |
| CPreparedTextDraw | Immutable layout slice and full-element bounds prepared once for a text effect owner |
| CTextDrawGeometry | Mutable per-call run copy after effect ownership and visibility filtering |
| CGlyphOutlineAndPlacement | A glyph's outline split into the part that depends only on the glyph and the part that depends only on where the glyph sits in the run |
| CAtlasDocumentPlacement | Placement of one document inside a shared atlas render target |
| CRenderer | Backend-agnostic renderer that resolves to the active build backend (tiny-skia by default, or Geode) |
| CRendererDriver | Backend-agnostic renderer driver that prepares documents for rendering and emits drawing commands through a RendererInterface implementation |
| CSecurityStats | Optional diagnostics for structured fuzzers and embedders auditing rejected preparation |
| CTextPreparationStats | CPU preparation work performed by this driver, for text-effect regression tests |
| CEntityRangeBoundsOptions | Controls visibility and transform handling when computing an entity range's bounds |
| CRendererGeodeTextureSnapshot | GPU runtime texture snapshot exported by RendererGeode |
| CFrameTimings | Per-frame performance instrumentation for RendererGeode |
| CRendererGeodeTexturePoolStats | Retained-memory instrumentation for RendererGeode's transient texture pool |
| CRendererGeode | Geode rendering backend - GPU-native via the Slug algorithm |
| CRendererImageIO | Utility class for saving images to disk |
| CRenderViewport | Describes the viewport for a render pass |
| CRendererBitmap | CPU-readable bitmap produced by a renderer snapshot |
| CRendererReadbackStats | Aggregate diagnostics for CPU readbacks run by a renderer and any offscreen instances that share its backend device, plus the device-health outcome those readbacks observed |
| CRendererSurfaceBudget | Aggregate budget for render targets, layers, masks, clips, and pattern tiles |
| CLimits | Per-frame limits, including any tighter limits installed by a test |
| CRendererFilterPreparationBudget | Aggregate filter-graph preparation and source-image materialization budget for one frame |
| CLimits | Per-frame capacity for filter preparation |
| CRendererDrawBudget | Aggregate conversion, rasterization, and upload work shared by a render frame |
| CCost | Work charged to the shared budget by one draw operation or batch |
| CPathMeasurementReservation | Exclusive reservation for one bounded path-measurement query |
| CRendererTextMaterializationBudget | Aggregate text outline, bitmap, path-copy, and cache-storage budget for one renderer frame |
| CCost | Aggregate limits or conservative charges for text work and storage |
| CRendererResourceStats | Bounded-resource diagnostics for the most recently started render frame |
| CRendererTextureSnapshot | Backend-owned GPU texture snapshot produced by a renderer |
| CRendererImage | A rendered image that lives either in a backend GPU texture or in CPU pixels |
| CPathShape | A path to draw, along with its fill rule and the entity it came from |
| CClipPathShape | One resolved clip-path shape, owned by the ResolvedClip that holds it |
| CPaintParams | Paint state derived from resolved style for the current node |
| CResolvedClip | Clip stack entry combining rectangles, paths, and optional masks |
| CImageParams | Parameters describing how an image should be drawn |
| CTextParams | Parameters describing how text is drawn and outlined |
| CRendererInterface | Backend-agnostic rendering interface consumed by RendererDriver during document traversal |
| CRendererTinySkiaFrameCounters | Per-frame counts of the conversions RendererTinySkia caches |
| CRendererTinySkia | Rendering backend using tiny-skia-cpp |
| CRendererUtils | Utility functions for the renderer |
| CRenderSnapshot | Immutable command stream captured from a prepared SVG document |
| CRenderSnapshotRecorder | RendererInterface implementation that records commands into a RenderSnapshot |
| CRetainedSpanKey | Everything a captured blit sequence depends on, besides the shape's geometry |
| CRetainedSpanSlot | One retained fill or stroke pass of one shape |
| CRetainedSpansComponent | Retained rasterization output for one shape, attached to the entity its geometry came from |
| CRetainedSpanDocumentState | Document-wide state for retained coverage, stored in the registry context |
| CRetainedSpanStats | Counters describing what a renderer's retained coverage did, for tests and benchmarks |
| CStrokeParams | Stroke configuration used for path and primitive drawing |
| CTerminalCapabilities | Terminal detection results derived from environment probing |
| CTerminalSize | Terminal size in columns and rows |
| CTerminalCellSize | Terminal cell size in pixels |
| CTerminalImageViewerConfig | Rendering configuration for terminal output |
| CTerminalImageView | Image view describing an RGBA buffer |
| CQuarterBlock | Per-cell subpixel sampling for quarter-pixel mode |
| CHalfBlock | Per-cell subpixel sampling for half-pixel mode |
| CTerminalCell | Aggregated subpixel data for a terminal cell |
| CTerminalImage | Sampled representation of an image prepared for terminal rendering |
| CTerminalImageViewer | Terminal image sampler for quarter- and half-pixel block glyphs |
| CCatalogFontAsset | Build-pinned catalog metadata. Runtime responses never add entries or choose package paths |
| CCatalogEncodedFontStore | Session-owned verified encoded bytes and shared catalog decode admission |
| CEmbeddedFontProvider | Curated bundled fonts, sharing one generated WOFF2 catalog on native and Wasm |
| CFontCatalog | Aggregate font catalog: the single surface the editor's font picker and FontManager resolution consume |
| CFontFamilyInfo | One entry in the font catalog: a family name plus how it was discovered and classified |
| CFontFaceRequest | Which face inside a family a font-family lookup wants, taken from the element's computed CSS font properties |
| CFontFaceAvailability | Nonblocking metadata for a face. Empty contentId preserves legacy synchronous providers |
| CFontFaceDependency | Copyable dependency record suitable for handing off before a temporary document is destroyed |
| CFontFaceLoadReservation | A reservation stays alive through the provider copy, decoder, and transfer into retained data |
| CFontFaceAdmission | Nonblocking admission result. Synchronous custom providers need no reservation by default |
| CFontFamilyProvider | Interface implemented by each font source (embedded, system) and by the aggregate FontCatalog |
| CScopedFontLoadInterruption | Lets the calling thread abandon provider font loads that are no longer wanted |
| CFontHandle | Opaque handle to a loaded font, used to reference fonts in the FontManager |
| CFontManager | Manages font loading, caching, and lookup for text rendering |
| CGlyphOutlineComplexity | Validation-time allocation/work bound for one font outline |
| CDependencyCapture | Record every catalog face consulted in a layout, including memoized and pending faces. The output survives this manager and can be attached to a stable preview/document task |
| CFontMetadata | Metadata extracted from a raw OpenType/TrueType font file |
| CSvgImageContent | Contains raw SVG document bytes, returned by ImageLoader when the referenced resource is an SVG image (image/svg+xml) |
| CImageLoader | Utility class for loading images from a URI |
| CImageResource | Contains a decoded image resource in RGBA format |
| CNullResourceLoader | A resource loader that does not load any resources and always returns an error |
| CResourceLoaderInterface | Interface for loading external resources, such as images |
| CSandboxedFileResourceLoader | A resource loader that loads files from a sandboxed directory |
| CSystemFontProvider | FontFamilyProvider backed by the host operating system's installed fonts |
| CUrlLoader | Utility class for loading a URI or decoding a data URL |
| CResult | Result of loading a URI or decoding a data URL |
| CSVGAElement | DOM object for a <a> element |
| CSVGAnimateElement | DOM object for a <animate> element |
| CSVGAnimateMotionElement | DOM wrapper for the <animateMotion> element |
| CSVGAnimateTransformElement | DOM object for a <animateTransform> element |
| CSVGCircleElement | DOM object for a <circle> element |
| CSVGClipPathElement | DOM object for a <clipPath> element |
| CSVGDefsElement | DOM object for a <defs> element |
| CSVGDescElement | DOM object for a <desc> element |
| CSVGAnimationEvent | A declarative animation boundary observed over a time interval |
| CSVGAnimationEventBatch | Bounded lifecycle query result. An incomplete query returns no partial events |
| CFontResourcePreflight | Readiness of catalog-dependent geometry or pixels for an explicit element target |
| CSVGDocument | Represents a parsed SVG document containing a tree of SVGElement nodes |
| CResourcePolicySnapshot | Opaque, equality-comparable identity of the current resource-loading and parsing policy |
| CSettings | Document settings which configure the document behavior |
| CSVGDocumentMutation | Typed DOM mutation helper used by SVGDocument::withWriteAccess |
| CElementAnchor | Lifetime-aware reference to an SVG element entity |
| CSVGElement | Represents a single SVG element (e.g., <rect>, <circle>, <g>, <text>, etc.) within an SVGDocument |
| CScopedMutation | Scoped mutation helper that runs cleanup before committing the mutation revision |
| CSVGEllipseElement | DOM object for a <ellipse> element |
| CSVGFEBlendElement | DOM object for a <feBlend> element |
| CSVGFEColorMatrixElement | DOM object for a <feColorMatrix> element |
| CSVGFEComponentTransferElement | DOM object for a <feComponentTransfer> element |
| CSVGFECompositeElement | DOM object for a <feComposite> element |
| CSVGFEConvolveMatrixElement | DOM object for a <feConvolveMatrix> element |
| CSVGFEDiffuseLightingElement | DOM object for a <feDiffuseLighting> element |
| CSVGFEDisplacementMapElement | DOM object for a <feDisplacementMap> element |
| CSVGFEDistantLightElement | DOM object for a <feDistantLight> element |
| CSVGFEDropShadowElement | DOM object for a <feDropShadow> element |
| CSVGFEFloodElement | DOM object for a <feFlood> element |
| CSVGFEFuncAElement | DOM object for a <feFuncA> element |
| CSVGFEFuncBElement | DOM object for a <feFuncB> element |
| CSVGFEFuncGElement | DOM object for a <feFuncG> element |
| CSVGFEFuncRElement | DOM object for a <feFuncR> element |
| CSVGFEGaussianBlurElement | DOM object for a <feGaussianBlur> element |
| CSVGFEImageElement | DOM object for a <feImage> element |
| CSVGFEMergeElement | DOM object for a <feMerge> element |
| CSVGFEMergeNodeElement | DOM object for a <feMergeNode> element |
| CSVGFEMorphologyElement | DOM object for a <feMorphology> element |
| CSVGFEOffsetElement | DOM object for a <feOffset> element |
| CSVGFEPointLightElement | DOM object for a <fePointLight> element |
| CSVGFESpecularLightingElement | DOM object for a <feSpecularLighting> element |
| CSVGFESpotLightElement | DOM object for a <feSpotLight> element |
| CSVGFETileElement | DOM object for a <feTile> element |
| CSVGFETurbulenceElement | DOM object for a <feTurbulence> element |
| CSVGFilterElement | DOM object for a <filter> element |
| CSVGFilterPrimitiveStandardAttributes | Handles standard attributes for filter primitives, which are children of the <filter> element |
| CSVGGElement | DOM object for a <g> element |
| CSVGGeometryElement | Base class for all Elements: Basic Shapes |
| CSVGGradientElement | Base class for SVG gradient elements, such as SVGLinearGradientElement and SVGRadialGradientElement |
| CSVGGraphicsElement | Base class for elements which render or impact the rendering tree, such as <path> and <g> |
| CSVGImageElement | DOM object for a <image> element |
| CSVGLinearGradientElement | DOM object for a <linearGradient> element |
| CSVGLineElement | DOM object for a <line> element |
| CSVGMarkerElement | DOM object for a <marker> element, which is used to define graphical objects that can be used repeatedly along a path, such as arrowheads or other markers on paths |
| CSVGMaskElement | Represents the <mask> element in SVG, which is used to define a mask for graphical elements |
| CSVGMetadataElement | DOM object for a <metadata> element |
| CSVGMPathElement | DOM wrapper for the <mpath> element |
| CSVGPathElement | DOM object for a <path> element |
| CSVGPatternElement | DOM object for a <pattern> element |
| CSVGPolygonElement | DOM object for a <polygon> element |
| CSVGPolylineElement | DOM object for a <polyline> element |
| CSVGRadialGradientElement | DOM object for a <radialGradient> element |
| CSVGRectElement | DOM object for the <rect> element |
| CSVGSetElement | DOM object for a <set> element |
| CSVGStopElement | DOM object for a <stop> element |
| CSVGStyleElement | DOM object for a <style> element, which contains a CSS stylesheet |
| CSVGMatchedStyleRule | Diagnostic record for one stylesheet rule that matched an element |
| CSVGStylesheetDeclaration | Parsed declaration within a stylesheet rule, with an optional document source range |
| CSVGStylesheetRule | Stylesheet rule in a document; built-in rules have no document source ranges |
| CSVGStyleRuleAtSourceOffset | Stylesheet rule found at a document source offset |
| CSVGSVGElement | DOM object for a <svg> element |
| CSVGSwitchElement | DOM object for a <switch> element |
| CSVGSymbolElement | DOM object for a <symbol> element, which defines a graphical template that can be instantiated using a <use> element |
| CTextGlyphOutline | A single placed glyph outline paired with the element that painted it |
| CSVGTextContentElement | Base class for elements that support rendering child text content |
| CSVGTextElement | DOM object for a <text> element |
| CSVGTextPathElement | DOM object for a <textPath> element |
| CSVGTextPositioningElement | Base class for elements that support per-glyph positioning attributes (x, y, dx, dy, rotate) on top of the basic text content interface |
| CSVGTitleElement | DOM object for a <title> element |
| CSVGTSpanElement | DOM object for a <tspan> element |
| CSVGUnknownElement | DOM object for an unknown SVG element |
| CSVGUseElement | DOM object for a <use> element |
| CFontVMetrics | Font vertical metrics in font design units (unscaled) |
| CUnderlineMetrics | Line decoration positioning metrics in font design units |
| CSubSuperMetrics | Sub/superscript Y offsets from the OS/2 table, in font design units |
| CTextBackend | Abstract font backend for text rendering operations |
| CBitmapGlyph | Bitmap glyph data from color fonts (CBDT/CBLC) |
| CBitmapGlyphMetrics | Validated bitmap cost and placement metadata; not an authentication or cache identity token |
| CShapedGlyph | A single shaped glyph with advance and cluster info |
| CShapedRun | Result of shaping a text range |
| CTextBackendFull | HarfBuzz + FreeType font backend |
| CTextBackendSimple | Stb_truetype-based font backend |
| CTextStyleContext | Internal, frame-owned mapping from authored text entities to one rendered instance's styles. Callers pass it synchronously; layout and draw results retain no reference to this map |
| CTextEngine | Shared SVG text engine |
| CGlyphOutline | A placed glyph outline paired with the source element that produced it |
| CTextLayoutParams | Layout-only parameters consumed by TextEngine |
| CResolvedTextFont | Resolved face and used font size for layout or declaring-element decoration metrics |
| CTextGlyph | A single positioned glyph in a laid-out text run |
| CTextRun | A run of positioned glyphs sharing the same font |
| CSampledImageInfo | Sampled image dimensions and scaling for coordinate mapping |
| Nxml | XML parsing and document model support |
| Ncomponents | |
| CEntityDeclarationsContext | Manages XML entity declarations for a document |
| CXMLSourceStoreHolder | Holds the source store of a document for as long as the document exists |
| CXMLDocumentContext | Holds global state of an XML document, such as the root element |
| CUnreparsedSpan | One source span the live tree does not reflect, with the failure that reported it |
| CXMLNamespaceContext | Manages XML namespace state for a document |
| CXMLValueComponent | Stores XMLNode values (such as text contents) |
| Ndetail | |
| CXMLTokenizerImpl | Internal tokenizer state, factored out of the template so the header doesn't carry lambdas across translation units (which would cause the goto_into_protected_scope issue with goto + lambdas in the same scope) |
| CXMLAttributeAtSourceOffset | Result of locating an attribute at a source offset |
| CXMLEditIntent | Source edit request from an editor/source view |
| CXMLMutation | XML DOM mutation emitted by an incremental source edit |
| CApplySourceEditResult | Result from XMLDocument::applySourceEdit |
| CXMLDocument | Represents an XML document, which holds a collection of XMLNode as the document tree |
| CNodeInsertion | One completed source-less node insertion and the source delta insertNode returned |
| CXMLIncrementalParser | Parser entry points for source-edit fragments |
| CXMLAttributeSourceLocation | Resolved source metadata for one serialized XML attribute |
| CXMLNode | Represents an XML node, such as an element, text, or comment, belonging to an donner::xml::XMLDocument |
| CProjectedTextChild | Owning value and current source span for one deliberately projected-out text child |
| CXMLParser | Parses an XML document from UTF-8 bytes |
| COptions | Options to modify the parsing behavior |
| CXMLQualifiedName | Represents an XML attribute name with an optional namespace |
| CXMLQualifiedNameRef | Reference type for XMLQualifiedName, to pass the value to APIs without needing to allocate an RcString |
| CSourceAnchorId | Stable identifier for a source anchor stored in XMLSourceStore |
| CResolvedSourceSpan | Current resolved byte span between two source anchors |
| CSourceAnchorSpan | Pair of anchors representing a source span |
| CXMLSourceDelta | Describes one applied source edit |
| CXMLSourceStore | Owns XML source bytes and mutable source anchors |
| CResourceLimits | Resource limits for retained anchors and anchor-update work |
| CResourceStats | Exact resource accounting for source anchors and edit work |
| CXMLToken | A single token emitted by the XML tokenizer |
| Ndetail | |
| CCompileTimeMapResult | Contains the constructed map and associated build status |
| Nfonts | |
| CCffGlyphOutlineComplexity | Bounded outline cost proved for one CFF or CFF2 glyph |
| CCffOutlineValidationResult | Per-glyph complexities returned by the bounded CFF interpreter |
| CSfntValidationOptions | Caller-selected limits for one sfnt validation |
| CSfntValidationMetrics | Work and limiting outcome observed while validating one sfnt |
| CSfntFont | Validated, allocation-bounded index for one sfnt font |
| CTableRecord | A table location validated against the original font byte span |
| CGlyphOutlineComplexity | Allocation and CPU-work ceiling proved for one glyph outline |
| CWoff2Parser | Decompress a WOFF2 font file into a raw TTF/OTF byte stream |
| COptions | Resource ceilings and pinned-font constraints for one WOFF2 decode |
| CWoffTable | Single sfnt table extracted from a WOFF container |
| CWoffFont | In-memory representation of a complete WOFF font |
| CWoffParser | Parse a WOFF font file |
| COptions | Resource ceilings for one WOFF parse and sfnt reconstruction |
| Ncomponents | |
| CAttributesComponent | Stores XML attribute values |
| CAttributeSourceAnchors | Source anchors for one serialized attribute |
| CTreeComponent | Stores the tree structure for an XML element, such as the parent, children, and siblings |
| CTreeMutationContext | Document-local hooks for tree mutations |
| Neditor | |
| Napp | |
| CSourceLoadOptions | Configuration knobs for loading SVG source bytes |
| CRenderSessionOptions | Default viewport and source-loading policy for a render session |
| CRenderSessionSnapshot | Snapshot of the most recent navigation result. All fields are read-only after EditorApp::navigate returns - subsequent navigations produce a new snapshot |
| CRenderSession | Document loading and rendering state for a host-driven session |
| CRenderSessionReplOptions | Runtime options for the REPL. Defaults match the interactive binary |
| CRenderSessionRepl | Line-oriented command interface for inspecting and controlling a render session |
| Ngui | |
| Ninternal | |
| CWgpuSurfaceRetryDecision | Frame scheduling and reconfiguration actions after surface acquisition fails |
| CWgpuDiagnosticReadbackDecision | Retry and completion actions for one diagnostic readback result |
| CPresentationSubmissionQueue | Bounds pending UI submissions while retaining only the most recent input request |
| CFence | One submitted UI frame: the GPU serial that retires it and the input it presented |
| CCompletionObservation | Serial and clock read after a bounded GPU completion confirmation |
| CPresentationDeviceLossRecord | Immutable first observation of settled presentation-device loss diagnostics |
| CObservation | Expensive owner-thread details acquired only for the first settled loss |
| CUiScaleConfig | HiDPI settings derived from the native window/display scale |
| CEditorWindowOptions | Window creation settings and host UI configuration |
| CEditorWindowFrameTiming | Host-frame timing captured by EditorWindow |
| CEditorWindowFonts | Fonts loaded into this window's ImGui context for the editor shell |
| CEditorWindowInputOverride | ImGui input state to inject for deterministic editor replay |
| CEditorWindow | Initializes GLFW + GL + ImGui when constructed, tears everything down in the destructor. One instance per process - ImGui's global state means we can't easily have two at once |
| CPresentedDocumentFrameIdentity | Stable document identity committed only after a complete framebuffer presentation |
| Nrepro | |
| CGlRnrReplayOptions | Options for replaying an .rnr file through the real OpenGL editor shell |
| CGlRnrReplayCapture | One PNG written by RunGlRnrReplay |
| CGlRnrReplayTileDiagnostics | Per-frame texture tile diagnostics captured during GL replay |
| CGlRnrReplayFrameDiagnostics | Per-frame diagnostics captured during GL replay |
| CRowThumbnail | One Layers-panel row thumbnail exposed to replay diagnostics |
| CThumbnailRefreshStats | Layers-panel thumbnail refresh diagnostics |
| CGlRnrReplayResult | Result of a GL replay run |
| CReplaySemanticActionCost | Estimated work performed by one semantic replay action |
| CReplayInputFrameCost | Estimated source-mutation work from raw replay input dispatched for one frame |
| CReplayHeldMutationKeyState | Tracks repeat-capable mutation keys whose down state persists across replay frames |
| CReplayExecutionResourceBudget | Aggregate runtime budget for replay frames and semantic actions |
| CReplayDiagnosticsResourceBudget | Aggregate retained-memory budget for replay diagnostics |
| CReproViewport | Snapshot of the editor viewport used to map window coordinates into SVG-document coordinates |
| CReproHit | Hit-test checkpoint captured at mouse-down time |
| CReproAction | One semantic editor action that fired within a frame. MCP-generated repros use actions for deterministic operations that are not raw pointer input, such as selecting the Pen tool or changing active paint |
| CReproEvent | One discrete event that fired within a frame. Frame-state (mouse position, button mask) lives on the owning frame record; this captures only events that can't be reconstructed from continuous state (key presses, character input, wheel deltas, resizes) |
| CReproFrame | One frame's snapshot: continuous input state + any discrete events that fired during the frame |
| CReproExpectedCrop | Optional pixel crop attached to a replay expectation |
| CReproExpectation | Human-reviewed expectation metadata for important replay fixtures |
| CReproMetadata | Session-level metadata captured at recording start |
| CReproFile | In-memory form of a loaded or in-progress recording |
| CReproReplaySecurityPolicy | Ambient capabilities granted while replaying an untrusted recording |
| CReproSvgFile | SVG source loaded from a replay-relative path |
| CFrameContext | Additional per-frame state that is only available from the live editor, not from ImGui alone |
| CReproRecorderOptions | Options passed at construction. All fields populated from editor startup state; the recorder copies what it needs |
| CReproRecorder | Records editor UI inputs frame-by-frame. Not thread-safe; must be invoked from the UI thread (where ImGui context is active) |
| Ninternal | |
| CToolbarPaintReferenceState | Source range for a referenced paint server shown by the toolbar |
| CToolbarPaintSlotState | Paint slot presentation state for the fill/stroke toolbar |
| CToolbarPaintState | Fill and stroke toolbar paint state |
| CDocumentLoadFailureNotice | Copy for the canvas notice shown when an opened document could not be loaded |
| CFillStrokeWidgetLayout | Screen-space rectangles for every drawable/interactive part of the widget |
| CFillStrokeWidgetInteractionState | Stable interaction policy for one fill/stroke toolbar frame |
| CRenderLease | Non-null renderer/document handoff for a render request |
| CRenderRequest | Per-request handoff data captured at render-request time so the worker has everything it needs without touching live UI state |
| CDragPreview | Drag state snapshotted with one worker render request |
| CPresentationSnapshotPlan | Final full-canvas snapshot work needed after compositor rendering |
| CHandoffTimings | Attribution of one worker-to-UI handoff, in milliseconds |
| CRenderResult | Presentation payload plus the document version it was rendered from |
| CWorkerTimingBreakdown | Internal timing split for one async worker iteration |
| CCompositedTile | One paint-order tile from the worker's compositor snapshot. Ids and generations let presentation reuse unchanged GL textures or Geode UI registrations, including regular immediate static segments. A matching published tile may carry metadata without a fresh payload. Geometry is in document units so the presenter follows live zoom while a new canvas raster is deferred |
| CCompositedPreview | Paint-ordered composited tiles and promoted interaction state |
| CSampleThumbnailRenderRequest | One SVG source queued for bounded, low-priority rendering on the existing render worker |
| CSampleThumbnailRenderResult | CPU bitmap returned by one asynchronous sample-thumbnail attempt |
| CSampleThumbnailRenderStats | Observable state and monotonic counters for the bounded sample-thumbnail lane |
| CAsyncRenderer | Background render worker with foreground document and low-priority thumbnail lanes |
| CGpuWaitFailure | Device-health outcome the render worker observed, independent of any frame it produced |
| CAsyncSVGDocument | Wraps an svg::SVGDocument and the editor's per-frame command queue |
| CFlushResult | Outcome of applying queued document mutations |
| CAttachedNumericStepperResult | One pair of compact step buttons joined to the right edge of a numeric field |
| CNumericPresetPopupPlacement | Where a numeric preset popup opens relative to the control it belongs to |
| CAttributeWritebackPathSegment | Stable element locator for canvas→text writeback and selection remap |
| CAttributeWritebackTarget | Path to an element through element children only, from the SVG root down |
| CCanvasScrollbarAxis | One scrollbar axis of the render pane's emulated canvas scrollbars |
| CCanvasScrollbars | Both axes of the render pane's emulated canvas scrollbars |
| CCapturedPresentation | Immutable geometry/provenance paired with one render result |
| CTextEditing | Text layout annotations captured under the same mutation revision as their glyphs |
| CObject | Selection geometry attributed to one object, rather than a gesture-wide coordinate guess |
| CAdornment | Additional annotation geometry anchored to a captured object or its independent ancestor |
| CClipboardInterface | Three-method interface for clipboard access |
| CCommandQueue | Ordered queue of editor commands awaiting document access |
| CFlushResult | Outcome of flushing pending editor commands |
| CCompositedPresentation | Accepted composited presentation resources, plus the released drag intent retained until a render that represents it is accepted |
| CDiagnosticsSnapshot | Detached metadata for scheduler, replay and inspector diagnostics |
| CCompositorDebugPanel | Stateful - owns one preview resource per active composite tile (keyed on CompositeTileSnapshot::id). OpenGL builds upload CPU thumbnail pixels into small GL textures. WebGPU builds keep backend texture snapshots alive and pass their texture views directly to ImGui, avoiding thumbnail readback. Construct and destroy on the presentation thread |
| CDialogPresenter | Owns the editor's popup/modal state and renders the corresponding ImGui dialogs |
| CDocumentCompositeTextureView | One axis-aligned document composite suitable for a single ImGui image draw |
| CDocumentPresentationCompositor | Composes cached non-WGPU document tiles into one transparent GL texture |
| CDocumentPresenter | Owns the installed frame; raster and chrome callbacks receive the same immutable object |
| CDocumentSaveResult | Detailed outcome from a document save attempt |
| CDocumentSyncController | Owns source-pane debounce, parse-error markers, and XML-owned source view mirroring |
| CPathOperationAvailability | Whether a path operation can currently be applied to the editor selection |
| CGroupOperationAvailability | Whether a lossless group or ungroup operation can currently be applied |
| CActivePaintStyle | Active paint settings used by authoring tools when creating new geometry |
| CEditorApp | Top-level editor shell |
| CCompletedTransformWriteback | Payload describing a completed DOM-side transform mutation that needs to be spliced into the source text. target is a stable path-based reference captured while the source was still in sync with the DOM; transform is the local (parent-space) transform that should appear in the element's transform= attribute |
| CCompletedElementRemoveWriteback | Source writeback information retained after an element removal completes |
| CEditorCommand | Discriminated union of queued editor DOM mutations. Coalescing rules in CommandQueue are keyed off kind plus the command's payload. Immediate structured source edits are not represented by this type |
| CElementReplacement | One source element and its fully detached replacement subtree |
| CSourceRecoveryState | Source-pane recovery admission, rechecked before queue coalescing |
| CEditorDockNodes | Node ids produced by BuildDefaultDockLayout. Ids of zero mean the node was not created (e.g. EditorDockNodes::rightBottom when the compositor debug info panel is not enabled) |
| CEditorDockLayoutParams | Inputs controlling the default editor dock layout proportions |
| CEditorInputBridge | Wraps the editor's raw GLFW scroll callback + native pinch monitor plumbing so the advanced editor shell can consume queued gesture events without owning callback lifecycle directly |
| CEditorMenuNode | One item in the shared native/ImGui menu declaration |
| CEditorMenu | One top-level menu in display order |
| CEditorMenuItemPresentation | Enabled and checked state computed once for both menu backends |
| CEditorSample | One built-in SVG document that can be loaded by editor UI surfaces |
| CEditorShellOptions | Initial document and host-capability settings for the editor shell |
| CEditorShellDocumentReplayInput | Document-space replay input consumed by the editor shell test harness |
| CLayerInspectorStatusReadback | Layer-inspector freshness status exposed to replay/readback harnesses |
| CTile | One paint-order composited tile exposed to replay diagnostics |
| CRowThumbnail | One Layers-panel row thumbnail exposed to replay diagnostics |
| CThumbnailRefreshStats | Layers-panel thumbnail refresh diagnostics |
| CEditorShell | Stateful advanced editor frontend shell. Owns all long-lived GUI/editor orchestration state |
| CEditorAdaptiveUiInput | Inputs used to select and size the adaptive editor chrome |
| CEditorAdaptiveUiLayout | Adaptive editor chrome geometry and feature subset for one frame |
| CEditorMainPaneLayoutInput | Inputs used to compute the editor's horizontal source/render/sidebar layout |
| CEditorMainPaneLayout | Computed geometry for the editor's horizontal source/render/sidebar layout |
| CRightSidebarLayoutInput | Inputs used to compute the editor's right sidebar pane layout |
| CRightSidebarLayout | Computed geometry for the editor's right sidebar panes |
| CLayoutRect | A screen-space rectangle in logical pixels |
| CRenderPaneLatchInput | Geometry the render pane's first-fit latch inspects to decide whether this frame's pane rectangle is the settled one. See RenderPaneViewportLatchReady |
| CEditorTheme | Named design tokens for the editor chrome (Graphite ramp) |
| CEmbeddedSvgIconRequest | One embedded-SVG rasterization, for the batched atlas path |
| CFileDialogFilter | A single file-type filter offered by a native open/save dialog |
| CFileDialogState | Tracks the directory the user last browsed to and the most-recently opened/saved files, so the next dialog can seed a sensible starting directory and (on platforms without an OS recents list) an in-editor recent-files menu |
| CSourceByteRange | Half-open byte range in the current source buffer |
| CActiveFlash | Visible flash decoration for the current frame |
| CFlashDecorations | Per-view transient source-change highlights |
| CLineRange | Half-open line range in zero-based editor line coordinates |
| CSourcePoint | Zero-based source coordinate in logical editor lines and columns |
| CFocusReferenceLink | View-only connector from a source reference to the referenced source target |
| CFocusPartition | View-only source-pane partition for selected-element focus mode |
| CStyleFocus | Focus information for a stylesheet rule under the source cursor |
| CReferenceHighlightSummary | Distinct same-document references related to the active selection |
| CFontPreviewCache | Bounded on-disk outlined SVG previews with validated RGBA reloads |
| CFrameAttemptStats | Owner-thread counters; index zero is scheduled work and index one is an event frame |
| CFrameCallbackAdmission | Start/stop and callback execution belong to the app thread; admission may run on another thread |
| CEventFrameWake | Coalesces event-frame requests into at most one queued frame without losing a request |
| CFrameCostBreakdown | Per-frame cost counters for editor rendering diagnostics |
| CMainFrame | Editor-shell work that runs on the UI thread during one runFrame |
| CHostFrame | Host-window work bracketing the editor frame |
| CDirectPresentation | Direct WGPU document presentation work completed in the previous host frame |
| COverlay | Cost counters for capturing and presenting selection/source-hover chrome |
| CCompositedUpload | Cost counters for uploading compositor tiles into presentation textures |
| CCompositedRender | Worker-side compositor raster costs for the render result that landed this UI frame |
| CSourceRopes | Cost counters for source-focus reference rope layout, simulation, and drawing |
| CFrameMissResourceTelemetry | Presentation memory counters included in frame-miss telemetry |
| CFrameMissTelemetryInput | Input used to build one frame-budget miss telemetry record |
| CPresentationDecorations | Transient UI adornments, distinct from selection geometry captured with the document pixels |
| CFramePresentationBuildResult | A sealed frame, when available, and the exact work needed to complete its presentation |
| CFramePresentationInput | Input intent consumed once while sealing a frame; draw callbacks cannot consult it later |
| CFramePresentation | Immutable, validated pixel/geometry binding used by every draw pass for a presented frame |
| CCompositedTileTextureIdentity | Stable identity for deciding whether a metadata-only composited tile can reuse an existing presentation texture |
| CPresentationResourceStats | Approximate resource footprint retained by the editor presentation texture cache |
| CPresentationCoverageDiagnostics | Presentation coverage state for composited tile fallback diagnostics |
| CGlTextureCache | Retains editor presentation textures for composited tiles and Layers thumbnails |
| CThumbnailTextureView | ImGui texture handle and UV range for valid thumbnail content |
| CTileView | One cached tile's ImGui texture handle and paint-order geometry |
| CRasterCoverageGroup | Owner-indexed coverage and paint bounds in one immutable raster coordinate system |
| CPresentationResources | Immutable resource manifest published only after complete preparation succeeds |
| CImGuiRuntimeRenderer | Draws one frame of UI draw data through donner::gpu |
| CUiTextureBacking | Runtime handles keeping one UI texture registration's backing reachable |
| CUiTextureId | Opaque identifier for a UI texture registration, in the form ImGui carries through draw data |
| CUiTextureDescriptor | What a UI texture registration carries beyond the view it names |
| CUiTextureBinding | The validated result of a registration lookup |
| CUiTextureRegistry | Registrations of runtime textures that UI draw data may sample, keyed by an opaque identifier |
| CImGuiClipboard | ClipboardInterface implementation that routes through ImGui's built-in clipboard |
| CInMemoryClipboard | In-memory ClipboardInterface backed by a single std::string member |
| CInspectorTextParser | Converts the typed text of a numeric field to its value, or returns std::nullopt to reject it |
| CInspectorNumericEdit | Outcome of one frame of an Inspector numeric field |
| CInspectorLengthEdit | Outcome of one frame of an Inspector length field |
| CCompositorHeuristicTelemetryContext | Context fields written with a compositor heuristic telemetry snapshot |
| CCompositorTelemetryFileAccess | Host authority for diagnostic telemetry exports. Replay input must not populate these fields |
| CLayersLockedRejectionFlash | Current "this element is locked, you can't select it" flash fed into the Layers panel so the rejected element's row flashes red in sync with the canvas outline flash. Mirrors OverlayRenderer.h's LockedRejectionFlashInput but is kept local so LayersPanel stays decoupled from SelectTool / OverlayRenderer; EditorShell maps the tool's flash into this struct |
| CLayersPanel | ImGui Layers panel backed by a LayerTreeModel snapshot |
| CThumbnailTexture | Maps a per-row rendered thumbnail bitmap to an ImGui texture handle for display. The editor shell supplies an implementation backed by GlTextureCache (the same Donner-bitmap -> GL/WGPU texture path the render pane uses); when null (e.g. in headless unit tests) the panel falls back to the deterministic swatch. Donner renders the thumbnail pixels; ImGui only blits the resulting texture - see CLAUDE.md "No Rendering Vector Graphics
With ImGui" |
| CIconTexture | Maps a static layer-affordance icon bitmap to an ImGui texture handle for display. The icon bitmaps are rendered from embedded Bootstrap SVG resources through Donner; ImGui only receives the final raster texture for the image button |
| CThumbnailRefreshStats | Diagnostics for the most recent thumbnail refresh |
| CClickModifiers | Modifier state for a row click. Mirrors the ImGui click path so tests can drive selection without a live ImGui frame |
| CLayerTreeRow | One flattened row of the Layers tree. The list is flat (not nested); nesting is conveyed by depth. Rows for descendants of a collapsed group are omitted, but hasChildren is still set on collapsed groups so the disclosure chevron renders |
| CLayerTreeModel | Builds and owns the flat Layers row list. Selection is mirrored in from EditorApp on every refresh; selection requests flow back out through LayersPanel (this model is read-only with respect to the document) |
| CMenuBarState | Availability, focus, and toggle state sampled before drawing the application menus |
| CMenuBarActions | Edge-triggered commands selected during one menu presentation pass |
| CMenuBarPresenter | Renders the app's top menu bar and reports semantic actions back to the shell |
| CNativeDialogCoordinator | Presents native open/save dialogs and tracks directory/recents state |
| CNativeOpenDialogRequest | Parameters for a native open dialog |
| CNativeSaveDialogRequest | Parameters for a native save dialog |
| CNativeMenuMac | MacOS menu bar built from EditorMenuModel |
| CDrainResult | Actions collected while draining the native menu command queue |
| CWindowChromeState | Inputs to the window title / chrome derivation |
| CSelectionChromeBoundsPreview | Active transform bounds chrome. Used while rotating to draw the gesture-start selection box transformed into the current document space |
| CLockedRejectionFlashInput | Locked-rejection flash input for OverlayRenderer::captureChromeSnapshot. Carries the rejected (locked) element whose outline should flash red plus the current fade intensity. Kept as a dedicated struct (rather than a dependency on SelectTool::LockedRejectionFlash) so the overlay renderer stays decoupled from the tool layer |
| CSelectionChromeSnapshot | Frozen view of everything OverlayRenderer::drawChromeWithTransform would normally read off the live registry: per-element path splines transformed into document space, per-element AABBs in document space, and the optional marquee rect |
| COrientedBox | Four document-space corners of an oriented selection box |
| CPathItem | One entry per renderable geometry leaf in the selection (groups are expanded into their geometry descendants, same as the live path). Empty when nothing's selected |
| CClipGuide | One supported effective clip boundary, kept separately from selection/export chrome. basePathDoc is captured at the last safe idle state. A direct selected-owner clip follows its gesture from that base; an inherited ancestor clip stays fixed while the child moves |
| CPathControlLine | Document-space Bezier handle guide line for selected SVG paths |
| CLockedFlash | Transient "this element is locked, you can't select it" feedback. When present, the rejected (locked) element's outline is stroked in red with alpha scaled by intensity (1 → 0 as the flash fades). Captured from SelectTool::lockedRejectionFlash() |
| CLivePathPreview | Live document-geometry preview of the path the Pen tool is actively authoring or point-editing. Drawn beneath the selection chrome with the path's own resolved solid paint, so the presented pixels for the edited path come from the same post-flush DOM capture as the chrome - they never wait for the async raster of the new geometry. While this is present the presenter suppresses the path's stale composited layer tile (ShouldPresentCompositedTile), otherwise the old geometry would show through underneath the preview |
| CTextCaret | Text-editing caret for the in-canvas text session: document-space endpoints of the caret bar (top, bottom) |
| CTextBoxDragPreview | Drag-to-create text-box preview: the live rectangle the text tool is dragging out, plus the first baseline it would create and an I-beam marker at the future caret position. Drawn as dedicated text-box chrome (crisp frame + guidance baseline + I-beam), visually distinct from the selection marquee's translucent fill + white outline |
| CTextBaseline | One baseline segment of a selected text run, in document space |
| COverlayRenderer | Draws selection and tool chrome from captured document geometry |
| CPenTool | Click-to-place path authoring tool with direct point editing |
| CPresentationIdentity | Identity of the document content consumed by one renderer capture |
| CPresentationPose | An object's absolute pose in the document, independent of mouse gestures |
| CPresentationRenderScheduleInput | Inputs for one editor-style render scheduling decision |
| CPresentationRenderScheduleDecision | Result of one editor-style render scheduling decision |
| CPresentationRenderScheduler | Shared editor/MCP scheduler for deciding when to post presentation renders |
| CPresentedFrameTileGeometry | Backend-neutral geometry for one presented composited tile |
| CPresentedDragBaseline | Active drag baseline needed to resolve a presented tile offset |
| CPresentedTileQuad | Output-space quad for one presented tile |
| CPresentedTileRect | Output-space rectangle for one presented tile |
| CPresentedPixelRect | Integer output-space rectangle used by headless bitmap presentation |
| CDocumentPixelCaptureIdentity | Identity shared by a worker pixel request and its accepted presentation |
| CDocumentPixelCapture | One immutable document-only pixel capture retained while the picker is armed |
| CPresentationRepairIdentity | Stable repair inputs, excluding allocation counters that cannot make a retry productive |
| CRenderAttemptIdentity | What a posted render request asked the worker for, as far as deciding whether a later request would repeat it |
| CNothingToPresentRetry | Paces re-posting a render request whose worker result had nothing to present |
| CRenderCoordinator | Owns the advanced editor's renderer-side orchestration: async rendering, overlay rasterization, composited drag presentation, and selection-bounds cache promotion |
| CRenderPaneScrollEvent | Raw scroll event captured from the windowing layer |
| CRenderPaneGestureContext | Per-frame state needed to route a raw scroll event |
| CRenderPaneGestureAction | Output of ClassifyRenderPaneScrollGesture |
| CRenderPanePresenterState | Borrowed presentation inputs for one render-pane UI pass |
| CRenderPanePresenter | Draws the document presentation and diagnostic overlays into the render pane |
| CRopeSimulationOptions | Tunable parameters for text-view reference rope simulation |
| CRopeSimulation | Small fixed-endpoint Verlet rope simulation used by source reference connectors |
| CRotateCursorImage | RGBA pixels for one custom editor cursor image |
| CCursorHotspot | Pointer hotspot for a cursor, in 32x32 cursor-image pixels |
| CRotateCursorSet | RAII owner for the editor's custom cursors |
| CSamplePickerController | Applies sample-picker actions that cross the editor's platform boundary |
| CSamplePickerLayout | Pure geometry for the sample grid. Values are logical pixels in the pane |
| CSamplePickerState | Application state consumed when presenting the sample picker |
| CSamplePickerActions | Edge-triggered requests emitted by one rendered picker frame |
| CSamplePickerThumbnail | Donner-rendered sample artwork uploaded to a texture the picker can blit |
| CSamplePickerPresenter | Draw the welcome/sample surface inside the current ImGui pane |
| CSelectionBoundsCache | Pending/displayed selection AABBs tracked across document-version changes |
| CSelectionTransformHandleIntent | Hit-test result for selection transform handles |
| CSelectionTransformHandleBoxes | Visual handle boxes for one selection envelope, in document coordinates |
| CSelectTool | Canvas tool for selection, marquee gestures, and selection transforms |
| CActiveDragPreview | Preview state for an in-progress drag, consumed by the async renderer |
| CActiveTransformBoundsPreview | Active transform chrome state for selection bounds presentation |
| CActiveGesturePreview | Active selection gesture state for editor UI chrome |
| CCompletedDragWriteback | Payload needed to write a completed drag back into the source pane. For multi-element drags this is the primary; additional writeback entries are latched in extras |
| CLockedRejectionFlash | A transient "this element is locked, you can't select it" flash on the rejected element's outline. intensity fades from 1 → 0 over the flash duration |
| CPreparePasteResult | Result of preparing a paste |
| CShapeClipboardPayload | Structured shape-clipboard payload. See file comment for the wire format |
| CTreeViewState | Selection and scrolling requests shared with the tree presenter |
| CDecomposedTransform | Scale-rotate-translate view of a transform, used by the inspector's editable transform fields. The equivalent matrix is Scale(scale) * Rotate(rotationRadians) * Translate(translation) with Donner's apply-left-to-right composition (scale first, translation last) |
| CInspectorStyleDisplayValue | User-facing form of a computed CSS value and its provenance |
| CSidebarPresenter | Renders the editor's tree view and inspector panes |
| CIconTexture | Maps a static path-operation icon bitmap to an ImGui texture handle for display. The icon bitmaps are rendered from embedded Bootstrap SVG resources through Donner; ImGui only receives the final raster texture for the image button |
| CSoftWrapSegment | One visual row produced from a logical source line |
| CSourceDiagnostic | Source diagnostic prepared for editor presentation |
| CSourceDiagnosticSnapshot | Immutable diagnostics published by one parse revision |
| CSourceDiagnosticCounts | Severity totals shown in the source diagnostics header |
| CSourceDiagnosticsPanelAction | User interaction emitted by one diagnostics panel frame |
| CSourceDiagnosticsPanel | Compact bottom panel presenting source warnings and errors |
| CSourceEditPoint | Line/column coordinate attached to a source edit boundary |
| CSourceEditIntent | One source-buffer edit expressed in byte offsets against the buffer version visible when the edit occurred |
| CSourceStructuralMovePlan | Revision-bound, DOM-shaped move prepared from a source drag target |
| CSourceStructuralMoveEvaluation | Result of validating and building a structural move plan |
| CDispatchSourceTextChangeResult | Outcome from dispatching a source-pane text change |
| CStrokeMarkerPrefabOption | Human-readable picker entry for one reusable marker shape |
| CStyleSourceContribution | One source-backed style contribution and its source-editor annotation metadata |
| CStyleSourceAnnotations | Source annotations derived from CSS cascade analysis |
| CDetachedStyleSourceContribution | One annotation contribution detached from a document registry |
| CDetachedStyleSourceAnnotations | Registry-independent result of a source-only annotation computation |
| CCoordinates | Coordinates representing a position in the text buffer, using a grid-based system where tabs are expanded to spaces according to the tab size setting |
| CGlyph | A single character in the text buffer with associated syntax highlighting information |
| CLine | A single line of text, stored as a vector of glyphs |
| CTextBuffer | Manages a collection of lines (the raw text) plus related text operations like insert, delete, and substring extraction |
| CShortcut | Represents a keyboard shortcut for editor actions |
| CTextEditor | A text editor widget for Dear ImGui that supports syntax highlighting, undo & redo, and more |
| CSourceStyleDecoration | Source decoration for style/cascade annotations in the editor |
| CSourceStructuralMoveDecoration | Source structural-drag decoration supplied by the editor shell |
| CAutocompleteRequest | Request payload for structured autocomplete providers |
| CAutocompleteSuggestion | A single autocomplete suggestion |
| CAutocompleteResponse | Response from a structured autocomplete provider |
| CEditorState | Editor cursor and selection state, captured by value for undo/redo |
| CUndoRecord | Record of a single text mutation for undo/redo |
| CUndoState | Scratch state threaded through the helpers that handle a single character insertion (handleNewLine, handleRegularCharacter, etc.) |
| CIdentifier | An editor-recognized identifier (function, variable, attribute name) |
| CLanguageDefinition | Definition of a programming language's syntax for highlighting |
| CTextEditorCore | Headless editing substrate - the text buffer, cursor, undo history and syntax colorizer with no ImGui dependency |
| CFormatBarFontPreview | Donner-rendered family-name preview uploaded for one dropdown row |
| CFormatBarFontFamily | One selectable font family in the format bar's family picker |
| CFormatBarState | Snapshot of the current text formatting context, driving the bar's controls |
| CFormatBarActions | Edge-triggered requests emitted by the format bar in one frame. Each set* / toggle* flag is true only on the frame the user committed the control |
| CTextFormatBarPresenter | Contextual text-formatting bar shown as a floating canvas toolbar |
| CTextInspectorPanel | Inspector section for a single selected <text> element |
| CTextPatch | A byte-level splice in the source text buffer |
| CApplyPatchesResult | Result of an applyPatches call |
| CTextTool | In-canvas text authoring with a live caret |
| CEditingChrome | Caret + frame chrome for the active editing session, in document space |
| CSelectionRange | Normalized logical text range, with start inclusive and end exclusive. Newline code points participate in the logical range even though they do not produce highlight geometry |
| CActiveStyle | Effective B/I/U formatting for the active typing position |
| CDragPreviewChrome | Drag-to-create preview chrome (document space): the live box being dragged out, the first text baseline it would create (one default font size below the box top, clamped into the box), and an I-beam marker at the future caret position. Distinct from the selection marquee so the gesture reads as "creating a text box" |
| CConvertTextToOutlinesResult | Result of preparing a text-to-outline conversion |
| CConvertTextsToOutlinesResult | All-or-error result for a set of text-to-outline conversions |
| CMouseModifiers | Modifier-key state captured at the moment a mouse event was dispatched. Tools use this for shift-add-to-selection, alt-clone, etc. Default-constructed = no modifiers, which keeps existing callsites that don't care about modifiers source-compatible |
| CTool | Abstract editor pointer tool. Implementations are stateless across document load (the editor recreates them on document change is fine since Tool instances are cheap), but may carry per-drag state |
| CToolbarIconTexture | An uploaded icon texture plus the valid payload UV range (icon bitmaps may be padded to a texture-friendly size) |
| CToolKeybinding | Display label and single-key shortcut for a tool. key is the binding design-tool users expect (Selection = V, Pen = P, Type = T); label is the tool's human name. The toolbar renders the tooltip as "<label> (<key>)" |
| CUndoSnapshot | Captured state of an element at a point in time |
| CUndoEntry | A single entry in the non-destructive undo timeline |
| CUndoTimeline | Non-destructive chronological undo timeline |
| CFrameProfilerSample | Render-pane profiler costs aligned with one UI frame-history sample |
| CFrameMemorySample | Presentation memory retained by the editor texture cache for one UI frame |
| CFrameHistory | Bounded ring of aligned UI, worker, profiler, and presentation-memory samples |
| CPendingClick | Document-space click buffered until the document is available for interaction |
| CScrollConsumptionResult | Result of consuming render-pane scroll events for one UI frame |
| CViewportInteractionController | Owns viewport/input state for the render pane: zoom/pan, pending click dispatch, and frame timing history |
| CEditorRasterViewport | Raster target derived from an editor viewport |
| CViewportState | All viewport state for a single frame of the render pane. Plain data, side-effect-free, copyable, ~80 bytes |
| CResult | A success-or-error value used by the viewport SVG exporter |
| CViewportExportOptions | Options controlling viewport SVG export behavior |
| CXmlAutocompleteContext | Source replacement range and prefix for XML autocomplete |
| CXmlAutocompleteSuggestion | A single XML autocomplete suggestion |
| Ngeode | |
| Nbenchmarks | |
| CDrawCpuSample | CPU time for one accepted submission. Pipeline/resource creation and GPU completion are outside both timed intervals |
| CDrawCountObserver | A fixed observer avoids allocating in the measured Device::submit path |
| CDrawCpuWorkload | Uses the shipped SlugFill pipeline and all eleven reflected bind slots. One target and bind group serve every sample so the timer isolates command recording and submission |
| CGeodeGpuRootCapabilities | Capabilities shared by runtime devices opened over one browser GPU device |
| CGeodeGpuRoot | Owns the browser GPU device and loss condition shared by logical Geode contexts |
| CGpuRootSelection | Inputs to browser-root selection. A named unsupported backend is refused |
| CGeodeRuntimeDevice | One logical runtime device over the selected browser root |
| CGeodeBufferPool | Size-and-usage-keyed free list of GPU buffers |
| CCheckerboardScissorPx | Device-pixel sub-rectangle of the target a checkerboard pass is confined to |
| CCheckerboardUnderlayParams | Placement and appearance of a transparency-checkerboard pass over a render target |
| CGeodeCheckerboardPipeline | Caches the compiled render pipeline that draws the transparency checkerboard behind see-through document regions, plus its bind group layout |
| CGeodeCheckerboardPass | Draws the transparency checkerboard over a Geode-owned render target |
| CGeodeCounters | Steady-state resource-creation and submission counts for a single frame |
| CGeodePhysicalDeviceOwner | Shared lifetime owner for one selected GPU runtime device and the backend root it drives |
| CSnapshotReadbackResources | Move-only resource set for one GPU snapshot unpremultiply readback: a straight-alpha staging texture, its view, and a map-readable readback buffer |
| CGeodeDevice | Owns a logical Geode context over a selected GPU runtime device |
| CReadbackStats | Readback timing, completion, loss, cancellation, and resource counters |
| CSceneBatchBindGroupKey | Key identifying a scene-batch bind group by its exact buffer bindings: the shared batch uniform allocation, the geometry slab chunk, and the record span |
| CRuntimeComputeProgram | A compute pipeline built from a precompiled shader artifact, with the objects it is layered on |
| CFilterTextureAllocator | Renderer-owned allocation boundary for filter textures |
| CRetainedFilterResources | Runtime handles a filter execution's recorded commands reference, moved to whatever outlives those commands |
| CFrameCommandBufferSink | Renderer-owned collection point for the command buffers one frame records |
| CFilterTexture | A texture flowing between filter primitives: the runtime handle holding it and the descriptor it was allocated with |
| CFilterExecutionResult | Outcome of running a filter graph, and the ownership that comes with it |
| CFilterTilePlan | Exact-resolution tile layout with overlapping sampling halos |
| CFilterExecutionMemory | GPU allocation bytes retained by an execution, excluding the caller's source/capture |
| CGeodeFilterEngine | GPU filter-graph executor |
| CGlyphGeometryKey | Identity of one unique glyph outline: every input that can change the encoded geometry, and nothing that cannot |
| CGlyphGeometryKeyHash | Hash for GlyphGeometryKey. Mixes with the 64-bit splitmix finalizer so the low-entropy fields (small glyph indices, a handful of scales) still spread across buckets |
| CGeodeGlyphResidentEntry | One unique glyph outline: the CPU outline, its analytic encode, and its GPU residence |
| CGeodeGlyphCache | Document-scoped cache of unique glyph outlines and their GPU residence |
| CGeodeTextInstanceRecordComponent | Persistent per-occurrence instance records for one text element |
| COccurrence | One occurrence's record slot plus the bytes last written to it |
| CGeodeTextInstanceResidencyComponent | One text element's persistent occurrence records, one GeodeTextInstanceRecordComponent per device that draws it: records hold slots in that device's record slab, and a device's frame generation means nothing to another device |
| CGeodeGpuContext | Everything Geode's encoders need to record a frame through the donner::gpu runtime |
| CGeodeTransientResources | RAII holder for transient GPU handles created while recording draws - per-draw uniform buffers, texture views, samplers, and bind groups |
| CGpuWaitTestHooks | Test seams for BoundedGpuWait. Production callers pass none; tests inject a fake clock and a sleep recorder so timeout behavior is verified deterministically and without real sleeping |
| CGeodeHandleRetirement | Buffers and bind groups of one runtime device that were let go of where that device may not be used, kept until the context rendering through the device releases them on its own thread |
| CHeldCounts | Handles waiting to be released, by kind. Test accessor |
| CGeodeImagePipeline | Caches a compiled render pipeline for the image-blit shader plus its bind group layout and two reusable samplers (linear and nearest) |
| CGeodePathCacheComponent | Per-entity cache of Geode's encoded-path output (and strokeToFill result). Installed lazily by RendererGeode at the encode call sites via get_or_emplace; removed automatically when the source ComputedPathComponent updates or is destroyed |
| CStrokeSlot | Stroke-slot cache. Holds both the Path::strokeToFill output path and its encoded form, keyed by the source StrokeStyle plus the device-derived curve-flattening tolerance. Invalidated whenever the fill slot is (geometry change, via the entt signal), on stroke-key mismatch (stroke width/dash/cap/ join change via CSS - the old key no longer matches the new one, so the next access regenerates), or on tolerance mismatch (the view scale crossed a flattening bucket) |
| CEncodedPath | GPU-ready encoded path data produced by the Slug band decomposition algorithm |
| CCurve | A quadratic Bézier curve segment (3 control points) stored as floats for GPU consumption |
| CBand | Compact metadata for one band. Layout matches the WGSL Band struct exactly |
| CAxisStats | Per-axis encode statistics retained with the path for diagnostics and perf tests |
| CEncodingStats | Output-neutral instrumentation for the CPU encoding result |
| CBoundingPoint | One path-space vertex in the convex bounding polygon |
| CGeodePathEncoder | Encodes a Path into Slug band decomposition format for GPU rendering |
| CLimits | Resource admission limits for path encoding |
| CGeodeDeviceKey | Identifies a device to state kept per device: its context's process-unique id, and the retirement that context releases handles through, which says whether the context still exists |
| CGeodePerDevice | One T per device that draws a document, kept on the document |
| CGeodePipeline | Caches a compiled render pipeline for the Slug fill shader, plus its bind group layout |
| CGeodeGradientPipeline | Caches a compiled render pipeline for the Slug gradient-fill shader plus its bind-group layout |
| CGeodeMaskPipeline | Caches a compiled render pipeline for the path-clip mask shader (donner/gpu/shader/programs/SlugMaskSource.h) plus its bind-group layout |
| CGeodeSnapshotReadbackPipeline | Compute pipeline for GPU-side snapshot unpremultiplication |
| CGeodeRecordSlab | Document-scoped, painter-ordered record slab for ordered draw batching (ordered batching) |
| CSlot | One record slot: its index in the contiguous array and its absolute byte offset in the owning buffer |
| CBatchUniformHandle | A batch-uniform buffer plus its stable identity; buffer is null when the slab declined (uniform cache full, or buffer creation failed) |
| CGeodeResidentSlab | Document-scoped suballocation slab for GPU residence |
| CAllocation | One sub-range of a slab chunk |
| CGeodeResidentSlot | GPU-resident geometry for one cached EncodedPath (a fill slot or a stroke slot). Owns a single combined-usage GPU buffer that holds the path's eight analytic dual-ray SSBO regions and per-draw uniform block, plus the cached fill bind group. Bounding vertices live in that uniform and are expanded from vertex_index, so the resident geometry needs no vertex buffer. The buffer and bind group are built once by GeoEncoder on first residence and reused every subsequent unchanged frame |
| CRegion | A byte sub-range of buffer. size == 0 is never bound directly - empty SSBO regions reserve a zero-filled dummy slot wide enough for one element of the WGSL array they feed, so the shader's band-count gate keeps them un-dereferenced and the binding still passes WebGPU's minimum-size validation (matching the per-frame arena allocStorageOrDummy dummy) |
| CGeodeResidentGradientSlot | GPU-resident geometry for one gradient-painted fill. Mirrors GeodeResidentSlot. A combined-usage buffer holds the same eight analytic dual-ray SSBO regions, but the uniform region holds the 704-byte gradient uniform block (stops inline, donner/gpu/shader/programs/SlugGradientSource.h) and the cached bind group uses the reflected ten-resource gradient pipeline layout with the device-owned dummy clip-mask texture. Residence is only taken when no clip mask, clip polygon, or mask pass is active (the gradient shader's clip flags must stay zero for the cached bind group to remain stable), exactly like the solid-fill residence gate |
| CRegion | A byte sub-range of buffer (same semantics as GeodeResidentSlot::Region) |
| CGeodeResidentPathSlots | Sibling of GeodePathCacheComponent: holds the GPU residence for an entity's fill and stroke encodes. Installed lazily by RendererGeode at the solid-fill draw sites; removed by the same entt listener that clears GeodePathCacheComponent when geometry changes |
| CGeodeResidentPathComponent | One entity's GPU residence, one set of slots per device that draws it: a second device neither reuses the first one's slots nor resets them |
| CGeodeFrameGeometryBudget | Aggregate encoded-geometry work retained by one renderer frame |
| CLimits | Caller-selected frame limits for draws, items, and retained bytes |
| CGeodeDocumentGeometryBudget | Live document geometry retained outside the frame-local arena |
| CLimits | Caller-selected cache and GPU residency ceilings |
| CGeodeGeometryCacheReservation | Movable ownership of one cached geometry reservation |
| CGeodeRuntimeDeviceSource | Opens runtime devices over a GPU backend that its owner selected and keeps alive |
| CGeodeTextureEncoder | Reusable helpers for uploading pixel data to a GPU texture and drawing it as a textured quad through GeodeImagePipeline |
| CUniformAllocation | Borrowed uniform-buffer range for one blit uniform upload. The buffer field is a raw non-owning handle: the provider keeps it alive (see UniformScratch's contract below); holders must not retain the allocation beyond the current frame |
| CUniformScratch | Interface for callers that pool blit uniform uploads into a per-frame scratch arena instead of creating one uniform buffer per blit |
| CQuadParams | Parameters for a single textured-quad draw call |
| CGeodeWgpuRoots | The wgpu objects one reference device is reached through, released together |
| CWgpuReferenceRoot | The wgpu objects every reference runtime device records against, and the sticky loss condition they share |
| CWgpuReferenceSelection | A selected wgpu reference: the Geode root production contexts are created over, and the wgpu objects behind it |
| CGeodeWgpuAdapterDevice | Implements donner::gpu::Device over one selected wgpu device, so the resvg comparison drives the production Geode contexts and renderer through an independent WebGPU implementation |
| CScopedWgpuHandle | Move-only RAII owner for a single WebGPU handle |
| CScopedWgpuResourceArena | Scoped owner for short-lived WebGPU resources used while recording a command encoder |
| CGeometryDebugSink | Optional debug observer for Slug draws that actually reach a GPU draw call |
| CGeometryAdmission | Frame-wide admission gate invoked before every Slug geometry upload or draw |
| CLinearGradientParams | Parameters for a linear gradient fill at the Geode drawing layer |
| CStop | Gradient stops. Colors are in straight alpha, 0..1 per channel - the shader interpolates in straight alpha and premultiplies at output. Offsets are in [0, 1] |
| CRadialGradientParams | Parameters for a radial gradient fill at the Geode drawing layer |
| CGeoEncoder | Drawing API for the Geode GPU renderer |
| CScenePaint | Paint carried by one cross-entity batch instance: a solid colour, or a resolved gradient whose parameters and stop ramp the encoder copies into the slot's persistent paint block |
| CSceneRecordState | The record fields a batched instance takes from encoder-side state rather than from its own arguments: the paint scalars published into its slot and the clip rectangle live at the time it was appended |
| CSceneBatchBinding | One cross-entity ordered batch: consecutive resident slots of one slab chunk plus a run of consecutive record-slab slots |
| CPatternPaint | Describes a pattern tile used as a paint source for fillPathPattern |
| Ngpu | |
| Nshader | |
| Nprograms | |
| CCheckerboardParams | Uniform block consumed by both checkerboard entry points |
| CColorSpaceConvertParams | Uniform direction selector |
| CColorTransferTable | Read-only storage layout of the shared transfer table |
| CCompositeParams | Uniform operator selection and arithmetic coefficients |
| CConvolveMatrixParams | Host storage layout consumed by the matrix-convolution program |
| CDisplacementMapParams | Uniform displacement scale and channel selectors |
| CDropShadowParams | Uniform straight flood color and integer-rounded pixel offset |
| CErrorLatch | Latches the first builder error so a program can be transliterated linearly |
| CFilterBlendParams | Parameters for the sixteen SVG blend modes |
| CFilterColorMatrixParams | Uniform 4x5 matrix stored as five columns; the last column is the constant offset |
| CFilterImageParams | Uniform row-major 2x3 image-from-output transform and sampling selection |
| CFilterResolveParams | Shared 48-byte transform, half-open clipping region and conversion flags |
| CFloodParams | Uniform flood color. The bytes are stored exactly as supplied; the host premultiplies |
| CGaussianBlurParams | Host layout for the params uniform resource of the Gaussian blur program |
| CImageBlitParams | Host layout for quad geometry, sampling, masking and compositing |
| CLightingParams | Host-shareable layout of the lighting parameter storage buffer |
| CMorphologyParams | Uniform radii and operator for one erode or dilate pass |
| COffsetParams | Uniform layout for finite pixel shifts in the admitted [-4096, 4096] range |
| CSlugFillParams | Per-draw transform, paint, geometry and clip parameters |
| CSlugFillInstance | One painter-ordered instance, including its nested transform and bounding polygon |
| CSlugFillBand | A band indexes the corresponding curve-reference range |
| CSlugPixelMapping | Pixel-to-path mapping a Slug fragment applies to its own pixel center p: pathFromPixel * (p - pixelOrigin) + pathOffset, with pathFromPixel holding the inverse linear transform's two columns |
| CSlugGradientParams | Host uniform layout for dedicated Slug gradients |
| CSlugGradientBand | Host element of either gradient band array |
| CSlugMaskParams | Host uniform layout consumed by the Slug mask program |
| CSlugMaskBand | Host element layout of either band array |
| CTileParams | Uniform source rectangle in pixels; non-positive extents produce transparent output |
| CTurbulenceParams | Noise admission and device-to-filter coordinate parameters |
| CTurbulenceTables | Deterministic permutation and per-channel gradient tables |
| CUiDrawParams | Uniform block consumed by the UI draw entry points |
| Nwgsl | |
| Ndetail | |
| CToken | Lexical token retaining its source spelling and location |
| CPunctuationEntry | Mapping from one punctuation character to its token category |
| CParser | Private parser state. All storage is fixed-size and constexpr-compatible |
| CSourceSpan | A half-open byte range in the WGSL input |
| CNameRef | A module-owned identifier spelling |
| CType | A resolved scalar, vector, structure, or resource type |
| CInterfaceDecoration | A scalar/vector leaf in an entry-point interface |
| CStructMember | Storage layout of one structure member |
| CStruct | One declared structure and its computed uniform layout |
| CBinding | One module-scope resource binding |
| CSymbol | One resolved identifier declaration |
| CExpression | One typed expression node. Operands are in source order |
| CStatement | One typed statement node. The next link preserves lexical statement order |
| CInterfaceVariable | A flattened scalar/vector input or output of one entry point |
| CFunction | One declared function |
| CFoldedConstant | An outermost constant f32 or abstract-float expression the parser folded. The WGSL projection spells its value exactly in place of the authored source, so a browser receives the value the native projections carry rather than evaluating the expression with WGSL's looser accuracy |
| CModuleLimits | Fixed capacities for one frontend module |
| CModule | A complete, immutable-on-success frontend module backed by fixed arenas |
| CDiagnostic | A fail-closed parser diagnostic |
| CParseResult | Result of parsing a bounded WGSL source string |
| CShaderName | A small owning identifier in a frozen shader interface |
| CShaderBufferMember | A reflected buffer member, including the layout required by the shader |
| CShaderResource | One resource and the layout of its parameter block, when applicable |
| CShaderInterfaceVariable | A flattened scalar/vector entry-point input or output |
| CShaderEntryPoint | One entry point and its source-derived interface ranges |
| CCompiledShaderView | Borrowed views into a shader artifact with static storage in the owning program |
| CIrExpr | A typed, immutable IR expression handle |
| CRefInfo | One name reference found inside an expression tree (see collectRefs) |
| CNode | Internal storage for IrExpr nodes; public for the factory, serialization, and emitter implementations only |
| CTypeLayout | Alignment and size of a host-shareable type |
| CStructMemberLayout | Layout of one struct member |
| CStructLayout | Layout of a struct type: overall alignment/size plus per-member offsets in declaration order |
| CArrayStrideInfo | Element stride of an array in an address space, plus whether uniform rules padded it |
| CWorkgroupSize | Declared workgroup size of a compute entry point. Every dimension is at least 1, and the product bounds how many invocations one dispatched workgroup runs |
| CIrConstant | One module-scope constant |
| CIrBinding | One module-scope resource binding |
| CIrParam | One entry point parameter or plain function parameter |
| CIrOutputMember | One entry point output member |
| CIrFunction | One function: a plain function or an entry point |
| CIrModule | An immutable, validated shader IR module |
| CFunctionBuilder | Builds one function or entry point |
| CModuleBuilder | Builds an IrModule: module-scope constants, resource bindings with (group, binding) uniqueness validation, and functions |
| CIrStmt | One IR statement |
| CData | Internal storage; public for the builder and serialization implementation |
| CIrType | An immutable shader IR type with deep value equality |
| CMember | One named member of a struct type |
| CShaderError | An error from IR construction, validation, or layout computation |
| CShaderResult | Result of a fallible shader IR operation: exactly one of a value of type T or a ShaderError |
| Nbrowser | |
| CBrowserBindGroupLayoutEntry | One entry of a bind group layout, with its enumerated values already encoded |
| CBrowserBindGroupEntry | One entry of a bind group, naming the bound object by identifier |
| CBrowserVertexAttribute | One vertex attribute of a render pipeline, with its format already encoded |
| CBrowserVertexBufferLayout | One vertex buffer slot of a render pipeline |
| CBrowserBlendComponent | One blend term of a color target, with its factors and operation already encoded |
| CBrowserColorTarget | One color target of a render pipeline |
| CBrowserRenderPipelineRequest | A render pipeline, with every referenced object named by identifier |
| CBrowserComputePipelineRequest | A compute pipeline, with every referenced object named by identifier |
| CBrowserColorAttachment | One color attachment of a render pass, naming its view by identifier |
| CBrowserCopyRegion | A rectangular region of texels, for the copy operations |
| CBrowserTexelLayout | The byte layout of texel rows in a copy, already flattened to scalars |
| CBrowserSurfaceCapabilities | What a browser surface reports it supports |
| CBrowserSharedTexture | A texture one logical device has shared with the others over the same browser device |
| CBrowserBridge | The browser's GPU service, as the runtime uses it |
| CBrowserDeviceRequest | A request for a browser GPU device, in progress |
| CBrowserDevice | Browser backend of the Donner GPU runtime |
| CBrowserGpuTask | Intrusive task. Its caller keeps it alive until the callback completes |
| CBrowserGpuTaskQueue | Accessed exclusively by the GPU owner. New work cannot extend an executing batch |
| CBrowserObjectInsertion | What BrowserObjectTable::insert did: the identifier it minted, and any identifier the slot was still holding |
| CBrowserObjectTable | Maps the runtime's per-kind resource slots to the identifiers the browser side knows them by |
| CBrowserShareReleaseQueue | Texture share releases waiting for the worker that made the shares |
| CRelease | A release to run on the owner |
| CEmscriptenBrowserBridge | The BrowserBridge implementation that actually calls the browser's GPU service |
| Nmetal | |
| CMetalDevice | Metal backend of the Donner GPU runtime |
| CSystemCapabilities | What the system default Metal device supports, which every device Create opens shares |
| CGpuFamilies | The GPU families a Metal device belongs to, as far as its 2D texture limit depends on them |
| CWriteStats | Snapshot of upload bookkeeping for tests and performance measurements |
| CNativeTextureUsage | Native texture access reported by Metal, exposed for allocation-contract tests |
| CMetalSurface | Presentation state of one surface: the Core Animation layer it presents to, the configuration it presents under, and the drawable the current frame is holding |
| Nvulkan | |
| CBufferAllocation | Where one buffer's bytes live |
| CBufferSuballocator | Supplies the memory a buffer is bound into |
| CDedicatedBufferAllocator | The passthrough implementation: one dedicated VkDeviceMemory per buffer, mapped for its lifetime. Every allocation it returns owns its memory and starts at offset zero |
| CVulkanSurfaceRetirement | Shared, atomically readable retirement disposition for an external Vulkan surface |
| CVulkanSharedRoot | One native Vulkan instance, device and graphics queue shared by runtime devices |
| CVulkanPresentationProbe | Presentation instance held while an embedder creates its platform surface |
| CVulkanDevice | Vulkan backend of the Donner GPU runtime |
| CSystemCapabilities | What the physical device Create selects supports, which every device it opens shares |
| CRecordedImageBarrierForTest | One image barrier the backend recorded, reported as plain numbers so this header stays free of Vulkan types. Test accessor: which barriers are emitted is the whole contract of the resource-state model, and it is not observable in the pixels a test reads back |
| CNativeContextForTest | Borrowed native objects for tests that submit their own synchronization gate. Valid only until this device is destroyed; callers must use the owning thread, release every gate, and finish their native work before destroying any of these objects or the device |
| CBufferWriteStats | Snapshot of queued buffer-write ownership, without polling the queue |
| CSurfaceAcquisitionForTest | What a surface's acquisition bookkeeping looks like from outside, for the contracts whose only other symptom is timing dependent |
| CVulkanQueueProgress | When the one queue every runtime device over a Vulkan root submits to last made progress |
| CFenceProgressWait | How a fence wait bounded by queue progress ended, with the native result of its last step |
| CTextureSyncState | The synchronization state a texture is left in, as the backend's bookkeeping records it |
| CImageBarrierParams | The six values an image barrier is built from, plus whether precision was available |
| CTextureSyncStateTable | Tracked state for a set of textures, under the discipline the backend records against |
| CVulkanSurfaceLifetime | Preallocated owner/child teardown state shared by every surface of one device |
| CVulkanSurfaceContext | What a swapchain borrows from the device that owns it. None of these are owned here, and all of them outlive the swapchain |
| CSurfaceWaitSync | Semaphores a submission must wait on, with the stages that wait applies to |
| CVulkanSwapchain | One surface and the swapchain it presents through |
| CBufferMappingHost | The facts a backend supplies about its own buffers so BufferMappingTable can decide when a mapping is readable and which bytes it names |
| CBufferMappingTable | Tracks the host mappings a backend has open and answers the mapping hooks Device dispatches to it |
| CRenderPassEncoder | Encodes commands inside an active render pass |
| CComputePassEncoder | Encodes commands inside an active compute pass |
| CCommandEncoder | Records and validates GPU commands for one command buffer |
| CBeginRenderPassCommand | Recorded beginRenderPass. Attachment references inside the descriptor are validated before recording and re-validated at submission |
| CBeginComputePassCommand | Recorded beginComputePass |
| CSetPipelineCommand | Recorded render pass setPipeline |
| CSetComputePipelineCommand | Recorded compute pass setPipeline |
| CSetBindGroupCommand | Recorded setBindGroup |
| CSetVertexBufferCommand | Recorded setVertexBuffer |
| CSetIndexBufferCommand | Recorded setIndexBuffer. The bound range runs from offsetBytes to the end of the buffer |
| CSetScissorRectCommand | Recorded setScissorRect |
| CSetViewportCommand | Recorded setViewport |
| CDrawCommand | Recorded draw |
| CDrawIndexedCommand | Recorded drawIndexed. Vertex-stepped attributes fetch element baseVertex + index value; instance-stepped attributes fetch element firstInstance + instance |
| CDispatchWorkgroupsCommand | Recorded dispatchWorkgroups |
| CEndRenderPassCommand | Recorded render pass end |
| CEndComputePassCommand | Recorded compute pass end |
| CCopyTextureToBufferCommand | Recorded copyTextureToBuffer (readback staging copy) |
| CCopyTextureToTextureCommand | Recorded copyTextureToTexture (sub-rectangle texture copy; both origins default to texel (0, 0), which is the whole-rect copy every recorded stream used before origins existed) |
| CIsBitmaskEnum | Marks an enum as a bitmask, enabling operator|, operator&, operator|=, and HasAllFlags |
| CNativeSurfaceHandle | The platform object a surface presents to |
| CSurfaceDescriptor | Descriptor for Device::createSurface |
| CMapSliceReport | What one backend wait slice found, and how it spent the slice |
| CMapWaitReport | How a bounded wait for a mapping ended, and how its slices were spent |
| CMapWaitParams | Bounds of a wait for a pending buffer mapping |
| CSerialWaitResult | How a wait for a submission serial ended, and how long it ran |
| CExtent2d | A 2D extent in texels |
| COrigin2d | A 2D texel coordinate, used as the corner a copy region starts at. The default (0, 0) is the whole-rect-from-the-origin convention every copy used before sub-rectangle copies existed |
| CBufferDescriptor | Descriptor for Device::createBuffer |
| CTextureDescriptor | Descriptor for Device::createTexture. All Donner textures are 2D, single-mip |
| CTextureViewDescriptor | Descriptor for Device::createTextureView. Views cover the whole texture |
| CSurfaceConfiguration | Configuration a surface presents under |
| CSurfaceCapabilities | What a surface supports, for choosing a SurfaceConfiguration |
| CSamplerDescriptor | Descriptor for Device::createSampler |
| CBindGroupLayoutEntry | One entry of a BindGroupLayoutDescriptor |
| CBindGroupLayoutDescriptor | Descriptor for Device::createBindGroupLayout |
| CPipelineLayoutDescriptor | Descriptor for Device::createPipelineLayout |
| CWorkgroupSize | Workgroup size a compute entry point declares |
| CComputeEntryPointInfo | One compute entry point a shader module contains, with the workgroup size compiled into it |
| CShaderBufferBindingInfo | One buffer statically used by an entry point, including uses through helper functions. Generated from the same IR as shader source; the runtime never parses shader source |
| CShaderModuleDescriptor | Descriptor for Device::createShaderModule. Source is trusted generated build output, never runtime input from documents. Exactly one source representation must be populated: text kinds (ShaderSourceKind::Wgsl, ShaderSourceKind::Msl) require nonempty sourceText and empty spirvWords; ShaderSourceKind::Spirv requires nonempty spirvWords and empty sourceText. Device::createShaderModule fails closed on any other combination |
| CVertexAttribute | One vertex attribute within a VertexBufferLayout |
| CVertexBufferLayout | Layout of one vertex buffer slot of a render pipeline |
| CBlendComponent | One blend term (color or alpha) of a BlendState |
| CBlendState | Blend state for one color target |
| CColorTargetState | One color target of a render pipeline's fragment stage |
| CVertexState | Vertex stage of a RenderPipelineDescriptor |
| CFragmentState | Fragment stage of a RenderPipelineDescriptor |
| CComputeState | Compute stage of a ComputePipelineDescriptor |
| CComputePipelineDescriptor | Descriptor for Device::createComputePipeline |
| CComputePassDescriptor | Descriptor for CommandEncoder::beginComputePass |
| CRenderPipelineDescriptor | Descriptor for Device::createRenderPipeline |
| CRenderPassColorAttachment | One color attachment of a RenderPassDescriptor |
| CRenderPassDescriptor | Descriptor for CommandEncoder::beginRenderPass |
| CTexelCopyTextureInfo | Source texture of a texture-to-buffer copy. Copies start at texel (0, 0) |
| CTexelCopyBufferLayout | Byte layout of texel rows in buffer or host memory for copy operations |
| CBufferBinding | A buffer range bound through a bind group |
| CTextureViewBinding | A texture view bound through a bind group |
| CSamplerBinding | A sampler bound through a bind group |
| CBindGroupEntry | One entry of a BindGroupDescriptor. The resource alternative must match the BindingType of the layout entry with the same binding index |
| CBindGroupDescriptor | Descriptor for Device::createBindGroup |
| CSubmittedCommandBuffer | One command buffer of a submission, as a backend receives it: the slot the buffer occupied before it was consumed, plus its validated commands in recording order |
| CSurfaceTexture | A texture acquired from a surface for one frame, with the state the surface reported while handing it over |
| CDevice | Abstract GPU device: resource creation, queue writes, and submission with shared fail-closed validation |
| CMapWaitTestHooks | Test seam for donner::gpu::Device::waitForMapping. Production callers pass none; a test injects a clock and a rest so a budget is verified deterministically and without spending it |
| CDeviceLossSnapshot | Stable diagnostic view of the first declaration that won a device-loss condition |
| CDeviceLossRelease | Work a declared loss has to release: something blocked on the device behind a wait that only progress on the lost root would ever satisfy |
| CDeviceLostState | Sticky device-loss condition of one backend root |
| CDeviceObserver | Receives one notification for each operation a Device accepted, one for each queue submission its backend made on its own, and one when the device's ownership of a texture allocation ends, which can happen inside Device::poll as well as inside a destroy |
| CGpuError | An explicit error result from a donner::gpu operation, carrying the error category and a human-readable message that names the offending field or state so a failing test localizes the bug without a rerun |
| CResult | Result of a fallible GPU operation: exactly one of a value of type T or a GpuError |
| CResourceIdentity | Identity of a resource at a point in time: slot plus generation, so slot reuse cannot alias two different resources |
| CHandle | Move-only RAII handle to a device resource |
| CHandleRef | Copyable non-owning reference to a Handle, used inside descriptor structs |
| CBufferTag | Tag for Buffer handles |
| CTextureTag | Tag for Texture handles |
| CTextureViewTag | Tag for TextureView handles |
| CSamplerTag | Tag for Sampler handles |
| CBindGroupLayoutTag | Tag for BindGroupLayout handles |
| CBindGroupTag | Tag for BindGroup handles |
| CPipelineLayoutTag | Tag for PipelineLayout handles |
| CShaderModuleTag | Tag for ShaderModule handles |
| CRenderPipelineTag | Tag for RenderPipeline handles |
| CComputePipelineTag | Tag for ComputePipeline handles |
| CSurfaceTag | Tag for Surface handles |
| CBufferMappingTag | Tag for BufferMapping handles |
| CCommandBufferTag | Tag for CommandBuffer handles |
| CRecordingDevice | Deterministic recording backend |
| CBackendDeviceIdentity | Which backend a device belongs to and which native device it records against. Two devices can name each other's textures only when both fields match. The pointers are compared, never dereferenced |
| CExportedTextureBacking | Backend half of an exported texture: a reference to the native allocation, plus whatever a sibling device of the same backend needs to name it |
| CSubmissionCompletion | Thread-safe view of a producer's submission completion, read by consumers on their own threads |
| CBackendTextureExport | What a backend reports when it exports one of its textures |
| CSourceWait | Producer work one consumer submission is ordered after on the device, for a registration whose ordering is SourceOrdering::WaitOnDevice and whose producer work has not completed yet |
| CTextureExport | An immutable, thread-safe token naming one texture of a producer device, for registration on another runtime device over the same backend device |
| Nexample | |
| CNativeEmbedSurface | Platform object and selected root for the example's runtime surface. The GLFW window must outlive this object and its runtime surface |
| CFrameSuspendTotals | Suspend totals accumulated between BeginSuspendFrame and EndSuspendFrame on the calling thread |
| CScopedSuspendPoint | Brackets one call that may suspend the wasm stack under ASYNCIFY |
| CBox2 | A 2D axis-aligned bounding box |
| CChunkedString | ChunkedString is a small helper to accumulate multiple RcStringOrRef pieces, either as small appended fragments or single codepoints |
| CCompileTimeMapTables | Perfect-hash metadata used to resolve keys into storage slots |
| CCompileTimeMapDiagnostics | Diagnostics describing how a CompileTimeMap was constructed |
| CCompileTimeMap | Compile-time associative container backed by a perfect hash layout |
| CDiagnosticRenderer | Renders diagnostic messages with source context and caret/tilde indicators, similar to clang/rustc output |
| COptions | Options for rendering diagnostics |
| CElementTraversalGenerator | Selectors may need to traverse the tree in different ways to match, and this is abstracted away using C++20 coroutines |
| CPromise | Defines and controls the behavior of the coroutine itself, by implementing methods that are called by the C++ runtime during execution of the coroutine |
| CElementTraversalNavigation | Default navigation for element-only traversal generators |
| CDecompress | A utility class for decompressing data |
| CFileOffset | A location in parser input, as a character offset and optional line information |
| CLineInfo | Represents line information within a file, including the line number and the character offset on that line |
| CSourceRange | Holds a selection range for a region in the source text, as a half-open interval [start, end) |
| CAllocTagTotals | Live large-block bytes attributed to each AllocTag |
| CScopedAllocTag | Sets the calling thread's AllocTag for the lifetime of the scope, restoring the previous one on exit so guards nest |
| CHeapSizeHistogram | Live allocation totals split by block size |
| CLength | A parsed CSS <length-percentage> value, as defined by https://www.w3.org/TR/css-values-3/#typedef-length-percentage |
| CMathConstants | Contains a set of math constants for the specified type (float or double) |
| CMathConstants< float > | Math constants for float |
| CMathConstants< double > | Math constants for double |
| CQuadraticSolution | Holds the solution of a quadratic equation, as returned by SolveQuadratic |
| CMemoryAttributionSample | One frame's view of where the process's bytes are |
| CMemoryStageSample | Net allocator movement attributed to each stage |
| CScopedHeapDelta | Brackets one stage of the frame and attributes the allocator movement across it |
| COptionalRef | A class that simulates an optional reference to a constant object of type T |
| CParseDiagnostic | A diagnostic message from a parser, with severity, source range, and human-readable reason |
| CParseResult | A parser result, which may contain a result of type T, or an error, or both |
| CParseWarningSink | Collects parse warnings during parsing |
| CStrokeStyle | Parameters for converting a stroked path to a filled outline |
| CPath | Immutable 2D vector path |
| CCommand | A command in the path, pairing a verb with the index of its first point |
| CPointOnPath | Result of sampling the path at a given arc length distance |
| CMeasuredPath | Precomputed arc-length index for repeated path sampling |
| CVertex | Vertex in a path's edge list, used for marker placement |
| CPathBuilder | Mutable builder for constructing immutable Path objects |
| CPathBooleanInput | One filled path participating in a boolean operation |
| CPathBooleanOptions | Limits and tolerances for bounded boolean operations |
| CPathBooleanResult | Result of ApplyPathBoolean |
| CRcString | A reference counted string, that is copy-on-write and implements the small-string optimization |
| CRcStringOrRef | An in-transit type that can hold either an RcString or std::string_view, to enable transferring the RcString reference or also accepting a non-owning std::string_view from API surfaces |
| CFontMetrics | A container for font information relevant for computing font-relative lengths, per https://www.w3.org/TR/css-values/#font-relative-lengths |
| CAbsoluteLengthMetrics | A container with ratios for converting absolute lengths, such as "cm" or "in", see https://www.w3.org/TR/css-values/#absolute-lengths |
| CSmallVector | A vector with small-size optimization |
| CCaseInsensitiveCharTraits | Type traits for case-insensitive string comparison, usable with algorithms that accept an STL std::char_traits |
| CStringUtils | A collection of string utils, such as case-insensitive comparison and StartsWith/EndsWith |
| CTransform2 | A 2D matrix representing an affine transformation |
| CUninitializedTag | Tag type for constructing an uninitialized transform |
| CUtf8 | Utility class for working with UTF-8 encoded strings |
| CVector2 | A 2D vector, (x, y) |
| Nstd | STL namespace |
| Chash< donner::RcString > | Hash function for RcString |
| Chash< donner::RcStringOrRef > | Hash function for RcStringOrRef |
| Chash< donner::xml::XMLQualifiedNameRef > | Hash function for donner::xml::XMLQualifiedNameRef |
| Chash< donner::xml::XMLQualifiedName > | Hash function for donner::xml::XMLQualifiedName |
| Chash< donner::svg::FontHandle > | Std::hash specialization so donner::svg::FontHandle can be used as a key in unordered associative containers |
| CParseDiagnostic | A diagnostic message from a parser, with severity, source range, and human-readable reason |
| CParseResult | A parser result, which may contain a result of type T, or an error, or both |
| CSVGDocument | Represents a parsed SVG document containing a tree of SVGElement nodes |
| CResourcePolicySnapshot | Opaque, equality-comparable identity of the current resource-loading and parsing policy |
| CSettings | Document settings which configure the document behavior |
| CSVGElement | Represents a single SVG element (e.g., <rect>, <circle>, <g>, <text>, etc.) within an SVGDocument |
| CScopedMutation | Scoped mutation helper that runs cleanup before committing the mutation revision |
| CSVGFEGaussianBlurElement | DOM object for a <feGaussianBlur> element |
| CSVGTextElement | DOM object for a <text> element |
| CSVGTSpanElement | DOM object for a <tspan> element |
1.15.0 