|
Donner 0.5.1
Embeddable browser-grade SVG2 engine
|
|
|
Donner 0.5.1
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 |
| CCompositorConfig | Runtime feature gates for CompositorController |
| CCompositorController | Controls compositor layer promotion/demotion and orchestrates composited rendering |
| 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 |
| CHintEntry | A single {source, weight} entry stored by CompositorHintComponent |
| CCompositorHintComponent | Author-layer ECS component carrying the set of weighted hints published against an entity |
| 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 |
| 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 |
| CStyleSystem | Computes stylesheet information for elements, applying the CSS cascade and inheritance rules |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| CSVGElement | Represents a single SVG element (e.g., <rect>, <circle>, <g>, <text>, etc.) within an SVGDocument |
| 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 |
| 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) |
| CXMLDocument | Represents an XML document, which holds a collection of XMLNode as the document tree |
| 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 |
| 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 |
| CTreeComponent | Stores the tree structure for an XML element, such as the parent, children, and siblings |
| 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 | |
| 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 | |
| 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 |
| CReproMetadata | Session-level metadata captured at recording start |
| CReproFile | In-memory form of a loaded or in-progress recording |
| 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 |
| CRenderRequest | Per-request handoff data captured at render-request time so the worker has everything it needs without touching live UI state |
| CDragPreview | |
| CRenderResult | Bitmap plus the document version it was rendered from |
| 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 | |
| CDialogPresenter | Owns the editor's popup/modal state and renders the corresponding ImGui dialogs |
| CDocumentSyncController | Owns source-pane debounce, parse-error markers, and pending canvas→text writebacks |
| 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 | |
| CEditorShell | Stateful advanced editor frontend shell. Owns all long-lived GUI/editor orchestration state |
| CExperimentalDragPresentation | Tracks experimental drag-compositing presentation state across selection, drag, and release |
| CGlTextureCache | Owns the GL textures the advanced editor uses for flat, overlay, and composited presentation |
| CImGuiClipboard | ClipboardInterface implementation that routes through ImGui's built-in clipboard |
| CInMemoryClipboard | In-memory ClipboardInterface backed by a single std::string member |
| CMenuBarState | |
| CMenuBarActions | |
| CMenuBarPresenter | Renders the app's top menu bar and reports semantic actions back to the shell |
| COverlayRenderer | |
| 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 | |
| CRenderPanePresenter | Draws the advanced editor render pane's image, overlay chrome, and frame graph |
| CSelectionBoundsCache | Pending/displayed selection AABBs tracked across document-version changes |
| CSelectTool | |
| CActiveDragPreview | Preview state for an in-progress drag, consumed by the async renderer |
| 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 |
| CDispatchSourceTextChangeResult | Outcome from dispatching a source-pane text change |
| 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 |
| 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 |
| CFrameHistory | |
| CPendingClick | |
| CViewportInteractionController | Owns viewport/input state for the render pane: zoom/pan, pending click dispatch, and frame timing history |
| CViewportState | All viewport state for a single frame of the render pane. Plain data, side-effect-free, copyable, ~80 bytes |
| 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 |
| 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 |
| 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