|
Donner 0.8.0-pre
Embeddable browser-grade SVG2 engine
|
|
|
Donner 0.8.0-pre
Embeddable browser-grade SVG2 engine
|
| 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 |
| 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 |
| CRuleParser | Rule-related parsing routines, including parsing individual rules, lists of rules, and stylesheets |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 | Phase 2.5 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 | Design doc 0033 §M4 — 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, not mid-rasterize, per design doc 0033 §R3 / §D4) 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 |
| 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 (design doc 0033 M1). 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 unified "everything composited together" view that the layer-inspector panel renders in paint order — design doc 0033 §M1++. Mirrors what composeLayers actually draws so the operator sees the same sequence of blits the renderer performs |
| 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 | |
| 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 |
| 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 |
| 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 |
| 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() |
| 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 |
| 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 |
| 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 |
| 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 |
| CPathLengthComponent | Stores a user-overridden path length on an element |
| CPreserveAspectRatioComponent | Stores the preserveAspectRatio attribute of "<svg>" and "<pattern>" |
| 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 |
| 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 |
| CResolvedMarker | Resolved "<marker>" reference applied to a rendering instance |
| CRenderingInstanceComponent | An instance of the entity in the rendering tree |
| CFontResource | In-memory representation of a font resource, containing the parsed WOFF data |
| CImageComponent | Parameters for the "<image>" element |
| 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 |
| CSubDocumentCache | Cache for parsed SVG sub-documents referenced by <image> or <use> elements |
| 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 |
| 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 |
| 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>" |
| 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 |
| CStyleComponent | Contains properties the style="" attribute for an element, local to the element |
| 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 |
| 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 |
| CRenderingContext | Rendering controller, which instantiates and and manages the rendering tree |
| 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 |
| 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) |
| 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 |
| 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 |
| CRenderer | Backend-agnostic renderer that resolves to the active build backend (Skia or tiny-skia) |
| CRendererDriver | Backend-agnostic renderer driver that prepares documents for rendering and emits drawing commands through a RendererInterface implementation |
| CRendererGeodeTextureSnapshot | WebGPU texture snapshot exported by RendererGeode |
| CFrameTimings | Per-frame performance instrumentation for RendererGeode |
| CRendererGeode | Geode rendering backend — GPU-native via WebGPU + 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 |
| CRendererTextureSnapshot | Backend-owned GPU texture snapshot produced by a renderer |
| CPathShape | Represents a resolved path along with its fill rule, transform, and layer index for boolean ops |
| 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 |
| 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 |
| CResolvedGradientData | Fully resolved gradient payload that can cross non-SVG package boundaries |
| 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 |
| CFontLoader | Helper to load a font from a URI, using a ResourceLoaderInterface to fetch the raw data and then parsing it as a WOFF file |
| CFontHandle | Opaque handle to a loaded font, used to reference fonts in the FontManager |
| CFontManager | Manages font loading, caching, and lookup for text rendering |
| 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 |
| CUrlLoader | Utility class for loading a URI or decoding a data URL |
| CResult | Result of loading a URI or decoding a data URL |
| CSVGCircleElement | DOM object for a "<circle>" element |
| CSVGClipPathElement | DOM object for a "<clipPath>" element |
| CSVGDefsElement | DOM object for a "<defs>" element |
| CSVGDocument | Represents a parsed SVG document containing a tree of SVGElement nodes |
| 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 |
| 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 |
| 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 | Source-backed declaration within a stylesheet rule |
| CSVGStylesheetRule | Source-backed author stylesheet rule in a document |
| CSVGStyleRuleAtSourceOffset | Stylesheet rule found at a document source offset |
| CSVGSVGElement | DOM object for a "<svg>" element |
| CSVGSymbolElement | DOM object for a "<symbol>" element, which defines a graphical template that can be instantiated using a "<use>" element |
| 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 |
| 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) |
| 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 |
| CTextEngine | Shared SVG text engine |
| CTextLayoutParams | Layout-only parameters consumed by TextEngine |
| 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, top-level objects are donner::xml::XMLParser and donner::xml::XMLDocument |
| Ncomponents | |
| CEntityDeclarationsContext | Manages XML entity declarations for a document |
| CXMLDocumentContext | Holds global state of an XML document, such as the root element |
| 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 |
| CXMLIncrementalParser | Parser entry points for source-edit fragments |
| CXMLAttributeSourceLocation | Resolved source metadata for one serialized XML attribute |
| CXMLNode | Represents an XML element belonging to an donner::xml::XMLDocument |
| CXMLParser | Parses an XML document from a string |
| 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 |
| CXMLToken | A single token emitted by the XML tokenizer |
| Ndetail | |
| CCompileTimeMapResult | Contains the constructed map and associated build status |
| Nfonts | |
| CWoff2Parser | Decompress a WOFF2 font file into a raw TTF/OTF byte stream |
| CWoffTable | Single sfnt table extracted from a WOFF container |
| CWoffFont | In‑memory representation of a complete WOFF font |
| CWoffParser | Parse a WOFF font file |
| 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 | |
| CRenderSessionOptions | |
| CRenderSessionSnapshot | Snapshot of the most recent navigation result. All fields are read-only after EditorApp::navigate returns — subsequent navigations produce a new snapshot |
| CRenderSession | |
| CRenderSessionReplOptions | Runtime options for the REPL. Defaults match the interactive binary |
| CRenderSessionRepl | |
| Ngui | |
| CUiScaleConfig | HiDPI settings derived from the native window/display scale |
| CEditorWindowOptions | |
| 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 |
| 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 |
| CGlRnrReplayResult | Result of a GL replay run |
| CReproViewport | Snapshot of the editor viewport used to map window coordinates into SVG-document coordinates |
| CReproHit | Hit-test checkpoint captured at mouse-down time |
| 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 |
| 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) |
| Nsandbox | |
| CDecodedCommand | One message in the decoded stream. The summary is meant for UI display (ImGui command-list rows, text dumps, structural diffs) — it is intentionally terse and not round-trippable |
| CInspectionResult | Outcome of FrameInspector::Decode. streamValid is true iff the entire wire stream parsed without error — a false value means commands contains whatever the inspector was able to decode before the first failure, and error describes why it stopped |
| CFrameInspector | All static helpers — inspector instances are stateless beyond the inputs each call is given |
| CPipelinedFrame | One frame's worth of rendered pixels and metadata handed back to the main thread after PipelinedRenderer completes a submission |
| CPipelinedRenderer | A pipelined renderer that moves rasterization off the caller's thread |
| CReplayReport | Statistics and diagnostic info from a replay. Always valid regardless of status |
| CReplayingRenderer | |
| CRnrHeader | Per-file metadata. All fields are POD or trivially serializable. uri may be empty when the recording originated from an in-memory string |
| CDiffResult | Result of comparing two .rnr recordings |
| CHardeningOptions | Knobs for which hardening measures to apply. Defaults match the "strict production sandbox child" profile the design doc calls out. Tests and developer tools can relax individual measures — e.g., setting requireSandboxEnv = false makes the child runnable by hand under a debugger |
| CHardeningResult | |
| CRenderResult | Result payload for a render call. Fields are populated according to status — see each field comment for when it's valid |
| CSandboxHost | Spawns and communicates with the sandbox child binary. Not thread-safe: construct one instance per thread that needs to render |
| CSerializingRenderer | |
| CSvgFetchResult | Result payload. bytes is only populated on kOk; all other statuses leave it empty and set diagnostics to a human-readable reason |
| CSvgSourceOptions | Configuration knobs for a SvgSource. Defaults match the design doc's address-bar section: 100 MB cap on local files |
| CSvgSource | Stateless-from-the-outside URI resolver. SvgSource holds the config knobs, but every fetch() call is independent and thread-safe |
| CWireWriter | Append-only byte buffer writer. Cheap by design — a std::vector<uint8_t> owner with a few typed helpers. No growth policy beyond the vector's |
| CMessageToken | Reserves a payload-length slot before the payload is encoded, returning a token the caller hands back to finishMessage() once the payload is complete. This avoids having to buffer the payload twice |
| CWireReader | Read cursor into an immutable byte span. Every read that could overflow the buffer returns false and leaves failed_ set, so callers can do their work without interleaved error checking and verify success at the end |
| 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 | |
| CPresentationSnapshotPlan | Final full-canvas snapshot work needed after compositor rendering |
| CRenderResult | Presentation payload plus the document version it was rendered from |
| CWorkerTimingBreakdown | Internal timing split for one async worker iteration |
| CCompositedTile | One composite tile from the worker's CompositorController:: snapshotCompositorTiles() snapshot (design doc 0033 §M2C). The editor uploads one GL texture per tile (keyed on id) and blits each tile at its canvas offset. Immediate tiles intentionally use transient ids and always carry a fresh payload. Geometry fields are doc-unit quantities so the editor can scale them by the current pixelsPerDocUnit during canvas-resize debouncing |
| CCompositedPreview | |
| CAsyncRenderer | |
| CAsyncSVGDocument | Wraps an svg::SVGDocument and the editor's per-frame command queue |
| CFlushResult | |
| 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 |
| CClassifyResult | Result of classifying a text change |
| CClipboardInterface | Three-method interface for clipboard access |
| CCommandQueue | |
| CFlushResult | |
| CCompositedPresentation | Tracks composited presentation state across selection, drag, and release |
| CDiagnosticsSnapshot | Immutable-by-copy presentation diagnostics for tests and MCP reporting |
| CDialogPresenter | Owns the editor's popup/modal state and renders the corresponding ImGui dialogs |
| 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 |
| 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 | |
| CEditorCommand | Discriminated union of every editor-initiated DOM mutation in the M2 scope. Coalescing rules in CommandQueue are keyed off kind plus the command's payload |
| 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 |
| CEditorShellOptions | |
| CLayerInspectorStatusReadback | Layer-inspector freshness status exposed to replay/readback harnesses |
| CTile | One paint-order composited tile exposed to replay diagnostics |
| CEditorShell | Stateful advanced editor frontend shell. Owns all long-lived GUI/editor orchestration state |
| 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 |
| 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 |
| CFrameCostBreakdown | Per-frame cost counters for editor rendering diagnostics |
| 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 |
| 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 | Owns the GL textures the advanced editor uses for overlay and composited presentation |
| CTileView | One composite-tile entry as the presenter sees it: the GL texture handle (resolved from the upload cache) plus the geometry fields the presenter needs to blit in paint order |
| CImGuiClipboard | ClipboardInterface implementation that routes through ImGui's built-in clipboard |
| CInMemoryClipboard | In-memory ClipboardInterface backed by a single std::string member |
| CCompositorHeuristicTelemetryContext | Context fields written with a compositor heuristic telemetry snapshot |
| CLayerInspectorPanel | 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 |
| CMenuBarState | |
| CMenuBarActions | |
| CMenuBarPresenter | Renders the app's top menu bar and reports semantic actions back to the shell |
| CSelectionChromeBoundsPreview | Active transform bounds chrome. Used while rotating to draw the gesture-start selection box transformed into the current document space |
| 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 |
| COverlayRenderer | |
| CPenTool | Click-to-place path authoring tool |
| CPreviewSegment | Preview segment for immediate pen-tool chrome |
| CPreviewHandleLine | Preview line connecting an anchor to one of its control handles |
| 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 |
| 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 | |
| CRenderPanePresenterCost | CPU cost counters produced while presenting the render pane |
| CRenderPanePresenter | |
| 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 |
| CRotateCursorSet | RAII owner for the editor's custom cursors |
| 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 | |
| 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 |
| CTreeViewState | |
| CSidebarPresenter | Renders the editor's tree view and inspector panes |
| CSoftWrapSegment | One visual row produced from a logical source line |
| 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 |
| CDispatchSourceTextChangeResult | Outcome from dispatching a source-pane text change |
| CStyleSourceContribution | One source-backed style contribution and its source-editor annotation metadata |
| CStyleSourceAnnotations | Source annotations derived from CSS cascade analysis |
| 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 |
| 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 |
| CTextPatch | A byte-level splice in the source text buffer |
| CApplyPatchesResult | Result of an applyPatches call |
| 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 |
| 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 |
| CDrawingViewportLayout | Computed layout for the Drawing window image, plus helpers for converting between screen coordinates and document coordinates |
| 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 | |
| CPendingClick | |
| 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 |
| CXmlAutocompleteContext | Source replacement range and prefix for XML autocomplete |
| CXmlAutocompleteSuggestion | A single XML autocomplete suggestion |
| Ngeode | |
| CGeodeCounters | Steady-state resource-creation and submission counts for a single frame |
| CGeodeEmbedConfig | Configuration for embedding Geode into a host application that already owns a WebGPU device |
| CGeodeDevice | Owns (or wraps) a WebGPU device/queue pair for GPU rendering |
| CGeodeFilterEngine | GPU filter-graph executor |
| CGeodeImagePipeline | Caches a compiled wgpu::RenderPipeline 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. Invalidated whenever the fill slot is (geometry change, via the entt signal), or 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) |
| 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 | Metadata for one horizontal band |
| CVertex | Vertex for the band bounding quad (input to the Slug vertex shader) |
| CGeodePathEncoder | Encodes a Path into Slug band decomposition format for GPU rendering |
| CGeodePipeline | Caches a compiled wgpu::RenderPipeline for the Slug fill shader, plus its bind group layout |
| CGeodeGradientPipeline | Caches a compiled wgpu::RenderPipeline for the Slug gradient-fill shader plus its bind-group layout |
| CGeodeMaskPipeline | Caches a compiled wgpu::RenderPipeline for the path-clip mask shader (shaders/slug_mask.wgsl) plus its bind-group layout |
| CGeodeTextureEncoder | Reusable helpers for uploading pixel data to a wgpu::Texture and drawing it as a textured quad through GeodeImagePipeline |
| CQuadParams | Parameters for a single textured-quad draw call |
| CScopedWgpuHandle | Move-only RAII owner for a single WebGPU handle |
| CScopedWgpuResourceArena | Scoped owner for short-lived WebGPU resources used while recording a command encoder |
| 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 encoder premultiplies before upload. Offsets must be in [0, 1] |
| CRadialGradientParams | Parameters for a radial gradient fill at the Geode drawing layer |
| CGeoEncoder | Drawing API for the Geode GPU renderer |
| CPatternPaint | Describes a pattern tile used as a paint source for fillPathPattern |
| 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 |
| CDecompress | A utility class for decompressing data |
| CFileOffset | Error context for a failed parse, such as the error reason, line, and character offset |
| 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) |
| CLength | Parses a CSS <length-percentage> type 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 |
| 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 |
| 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 RcString |
| 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 |
1.15.0