Name Description Size
crashtests 100
DOMSVGAngle.cpp 3494
DOMSVGAngle.h Generic ctor for DOMSVGAngle objects that are created for an attribute. 2204
DOMSVGAnimatedAngle.cpp 1162
DOMSVGAnimatedAngle.h 1436
DOMSVGAnimatedBoolean.cpp 978
DOMSVGAnimatedBoolean.h 1592
DOMSVGAnimatedEnumeration.cpp 1104
DOMSVGAnimatedEnumeration.h 1291
DOMSVGAnimatedInteger.cpp 1111
DOMSVGAnimatedInteger.h 1242
DOMSVGAnimatedLength.cpp 1247
DOMSVGAnimatedLength.h 1419
DOMSVGAnimatedLengthList.cpp static 4769
DOMSVGAnimatedLengthList.h 9345
DOMSVGAnimatedNumber.cpp 1102
DOMSVGAnimatedNumber.h 1254
DOMSVGAnimatedNumberList.cpp static 4951
DOMSVGAnimatedNumberList.h Class DOMSVGAnimatedNumberList This class is used to create the DOM tearoff objects that wrap internal SVGAnimatedNumberList objects. See the architecture comment in DOMSVGAnimatedLengthList.h (that's LENGTH list). The comment for that class largly applies to this one too and will go a long way to helping you understand the architecture here. This class is strongly intertwined with DOMSVGNumberList and DOMSVGNumber. Our DOMSVGNumberList base and anim vals are friends and take care of nulling out our pointers to them when they die (making our pointers to them true weak refs). 5112
DOMSVGAnimatedString.cpp 702
DOMSVGAnimatedString.h 1139
DOMSVGAnimatedTransformList.cpp static 4536
DOMSVGAnimatedTransformList.h Class DOMSVGAnimatedTransformList This class is used to create the DOM tearoff objects that wrap internal SVGAnimatedTransformList objects. See the architecture comment in DOMSVGAnimatedLengthList.h (that's LENGTH list). The comment for that class largly applies to this one too and will go a long way to helping you understand the architecture here. This class is strongly intertwined with DOMSVGTransformList and DOMSVGTransform. Our DOMSVGTransformList base and anim vals are friends and take care of nulling out our pointers to them when they die (making our pointers to them true weak refs). 5064
DOMSVGLength.cpp 14046
DOMSVGLength.h Class DOMSVGLength This class creates the DOM objects that wrap internal SVGLength objects that are in an SVGLengthList. It is also used to create the objects returned by SVGSVGElement.createSVGLength(). For the DOM wrapper classes for non-list SVGLength, see SVGAnimatedLength.h. See the architecture comment in DOMSVGAnimatedLengthList.h. This class is strongly intertwined with DOMSVGAnimatedLengthList and DOMSVGLengthList. We are a friend of DOMSVGLengthList, and are responsible for nulling out our DOMSVGLengthList's pointer to us when we die, making it a real weak pointer. When objects of this type are in a DOMSVGLengthList they belong to an attribute. While they belong to an attribute, the objects' values come from their corresponding internal SVGLength objects in the internal SVGLengthList objects for the attribute. Getting and setting values of a DOMSVGLength requires reading and writing to its internal SVGLength. However, if the DOMSVGLength is detached from its DOMSVGLengthList then it first makes a copy of its internal SVGLength's value and unit so that it doesn't appear to "lose" its value from script's perspective on being removed from the list. This means that these DOM tearoffs have space to store these values, even though they're not used in the common case. Objects of this type are also used to reflect the baseVal and animVal of a single, non-list SVGLength attribute. Getting and settings values of the DOMSVGLength in this case requires reading and writing to the corresponding SVGAnimatedLength object. This class also stores its current list index, attribute enum, and whether it belongs to a baseVal or animVal list. This is so that objects of this type can find their corresponding internal SVGLength. To use these classes for <length> attributes as well as <list-of-length> attributes, we would need to take a bit from mListIndex and use that to indicate whether the object belongs to a list or non-list attribute, then if-else as appropriate. The bug for doing that work is: https://bugzilla.mozilla.org/show_bug.cgi?id=571734 9158
DOMSVGLengthList.cpp 12724
DOMSVGLengthList.h Class DOMSVGLengthList This class is used to create the DOM tearoff objects that wrap internal SVGLengthList objects. See the architecture comment in DOMSVGAnimatedLengthList.h. This class is strongly intertwined with DOMSVGAnimatedLengthList and DOMSVGLength. We are a friend of DOMSVGAnimatedLengthList, and are responsible for nulling out our DOMSVGAnimatedLengthList's pointer to us when we die, essentially making its pointer to us a weak pointer. Similarly, our DOMSVGLength items are friends of us and responsible for nulling out our pointers to them. Our DOM items are created lazily on demand as and when script requests them. 6149
DOMSVGNumber.cpp 6032
DOMSVGNumber.h Class DOMSVGNumber This class creates the DOM objects that wrap internal SVGNumber objects that are in an SVGNumberList. It is also used to create the objects returned by SVGSVGElement.createSVGNumber(). For the DOM wrapper classes for non-list SVGNumber, see SVGAnimatedNumber.h. See the architecture comment in DOMSVGAnimatedNumberList.h. See the comment in DOMSVGLength.h (yes, LENGTH), which applies here too. 5192
DOMSVGNumberList.cpp 12390
DOMSVGNumberList.h Class DOMSVGNumberList This class is used to create the DOM tearoff objects that wrap internal SVGNumberList objects. See the architecture comment in DOMSVGAnimatedNumberList.h. This class is strongly intertwined with DOMSVGAnimatedNumberList and DOMSVGNumber. We are a friend of DOMSVGAnimatedNumberList, and are responsible for nulling out our DOMSVGAnimatedNumberList's pointer to us when we die, essentially making its pointer to us a weak pointer. Similarly, our DOMSVGNumber items are friends of us and responsible for nulling out our pointers to them. Our DOM items are created lazily on demand as and when script requests them. 6120
DOMSVGPathSeg.cpp 14120
DOMSVGPathSeg.h From DOMSVGPathSeg: 19138
DOMSVGPathSegList.cpp static 20770
DOMSVGPathSegList.h Class DOMSVGPathSegList This class is used to create the DOM tearoff objects that wrap internal SVGPathData objects. See the architecture comment in DOMSVGAnimatedLengthList.h first (that's LENGTH list), then continue reading the remainder of this comment. The architecture of this class is very similar to that of DOMSVGLengthList except that, since there is no nsIDOMSVGAnimatedPathSegList interface in SVG, we have no parent DOMSVGAnimatedPathSegList (unlike DOMSVGLengthList which has a parent DOMSVGAnimatedLengthList class). (There is an SVGAnimatedPathData interface, but that is quite different to DOMSVGAnimatedLengthList, since it is inherited by elements rather than elements having members of that type.) As a consequence, much of the logic that would otherwise be in DOMSVGAnimatedPathSegList (and is in DOMSVGAnimatedLengthList) is contained in this class. This class is strongly intertwined with DOMSVGPathSeg. Our DOMSVGPathSeg items are friends of us and responsible for nulling out our pointers to them when they die. Our DOM items are created lazily on demand as and when script requests them. 9773
DOMSVGPoint.cpp 3216
DOMSVGPoint.h Class DOMSVGPoint This class creates the DOM objects that wrap internal SVGPoint objects that are in an SVGPointList. It is also used to create the objects returned by SVGSVGElement.createSVGPoint() and other functions that return DOM SVGPoint objects. See the architecture comment in DOMSVGPointList.h for an overview of the important points regarding these DOM wrapper structures. See the architecture comment in DOMSVGLength.h (yes, LENGTH) for an overview of the important points regarding how this specific class works. 2824
DOMSVGPointList.cpp static 14820
DOMSVGPointList.h Class DOMSVGPointList This class is used to create the DOM tearoff objects that wrap internal SVGPointList objects. See the architecture comment in DOMSVGAnimatedLengthList.h first (that's LENGTH list), then continue reading the remainder of this comment. The architecture of this class is very similar to that of DOMSVGLengthList except that, since there is no nsIDOMSVGAnimatedPointList interface in SVG, we have no parent DOMSVGAnimatedPointList (unlike DOMSVGLengthList which has a parent DOMSVGAnimatedLengthList class). (There is an SVGAnimatedPoints interface, but that is quite different to DOMSVGAnimatedLengthList, since it is inherited by elements rather than elements having members of that type.) As a consequence, much of the logic that would otherwise be in DOMSVGAnimatedPointList (and is in DOMSVGAnimatedLengthList) is contained in this class. This class is strongly intertwined with DOMSVGPoint. Our DOMSVGPoint items are friends of us and responsible for nulling out our pointers to them when they die. Our DOM items are created lazily on demand as and when script requests them. 8289
DOMSVGStringList.cpp static 6263
DOMSVGStringList.h Class DOMSVGStringList This class is used to create the DOM tearoff objects that wrap internal SVGPathData objects. See the architecture comment in DOMSVGAnimatedLengthList.h first (that's LENGTH list), then continue reading the remainder of this comment. The architecture of this class is similar to that of DOMSVGLengthList except for two important aspects: First, since there is no nsIDOMSVGAnimatedStringList interface in SVG, we have no parent DOMSVGAnimatedStringList (unlike DOMSVGLengthList which has a parent DOMSVGAnimatedLengthList class). As a consequence, much of the logic that would otherwise be in DOMSVGAnimatedStringList (and is in DOMSVGAnimatedLengthList) is contained in this class. Second, since there is no nsIDOMSVGString interface in SVG, we have no DOMSVGString items to maintain. As far as script is concerned, objects of this class contain a list of strings, not a list of mutable objects like the other SVG list types. As a result, unlike the other SVG list types, this class does not create its items lazily on demand and store them so it can return the same objects each time. It simply returns a new string each time any given item is requested. 4476
DOMSVGTransform.cpp 10222
DOMSVGTransform.h DOM wrapper for an SVG transform. See DOMSVGLength.h. 5703
DOMSVGTransformList.cpp 13889
DOMSVGTransformList.h Class DOMSVGTransformList This class is used to create the DOM tearoff objects that wrap internal SVGTransformList objects. See the architecture comment in DOMSVGAnimatedTransformList.h. 5844
moz.build 7349
nsISVGPoint.cpp 2572
nsISVGPoint.h Class nsISVGPoint This class creates the DOM objects that wrap internal SVGPoint objects. An nsISVGPoint can be either a DOMSVGPoint or a DOMSVGTranslatePoint 5605
SVGAElement.cpp 11532
SVGAElement.h 3991
SVGAnimatedBoolean.cpp Implementation 4434
SVGAnimatedBoolean.h 2408
SVGAnimatedClass.cpp Implementation 4571
SVGAnimatedClass.h 2285
SVGAnimatedEnumeration.cpp aSrcElement 5364
SVGAnimatedEnumeration.h 3894
SVGAnimatedInteger.cpp Implementation 4227
SVGAnimatedInteger.h 3751
SVGAnimatedIntegerPair.cpp Implementation 6819
SVGAnimatedIntegerPair.h 4329
SVGAnimatedLength.cpp SVG_LENGTHTYPE_UNKNOWN 15021
SVGAnimatedLength.h 7975
SVGAnimatedLengthList.cpp 8162
SVGAnimatedLengthList.h Class SVGAnimatedLengthList This class is very different to the SVG DOM interface of the same name found in the SVG specification. This is a lightweight internal class - see DOMSVGAnimatedLengthList for the heavier DOM class that wraps instances of this class and implements the SVG specification's SVGAnimatedLengthList DOM interface. Except where noted otherwise, this class' methods take care of keeping the appropriate DOM wrappers in sync (see the comment in DOMSVGAnimatedLengthList::InternalBaseValListWillChangeTo) so that their consumers don't need to concern themselves with that. 4109
SVGAnimatedNumber.cpp Implementation 4799
SVGAnimatedNumber.h 4046
SVGAnimatedNumberList.cpp 6613
SVGAnimatedNumberList.h Class SVGAnimatedNumberList This class is very different to the SVG DOM interface of the same name found in the SVG specification. This is a lightweight internal class - see DOMSVGAnimatedNumberList for the heavier DOM class that wraps instances of this class and implements the SVG specification's SVGAnimatedNumberList DOM interface. Except where noted otherwise, this class' methods take care of keeping the appropriate DOM wrappers in sync (see the comment in DOMSVGAnimatedNumberList::InternalBaseValListWillChangeTo) so that their consumers don't need to concern themselves with that. 4251
SVGAnimatedNumberPair.cpp 6629
SVGAnimatedNumberPair.h 4493
SVGAnimatedOrient.cpp SVG_ANGLETYPE_UNKNOWN 15526
SVGAnimatedOrient.h 5499
SVGAnimatedPathSegList.cpp 7369
SVGAnimatedPathSegList.h Class SVGAnimatedPathSegList Despite the fact that no SVGAnimatedPathSegList interface or objects exist in the SVG specification (unlike e.g. SVGAnimated*Length*List), we nevertheless have this internal class. (Note that there is an SVGAnimatedPathData interface, but that's quite different to SVGAnimatedLengthList since it is inherited by elements, as opposed to elements having members of that type.) The reason that we have this class is to provide a single locked down point of entry to the SVGPathData objects, which helps ensure that the DOM wrappers for SVGPathData objects' are always kept in sync. This is vitally important (see the comment in DOMSVGPathSegList::InternalListWillChangeTo) and frees consumers from having to know or worry about wrappers (or forget about them!) for the most part. 4301
SVGAnimatedPointList.cpp 7120
SVGAnimatedPointList.h Class SVGAnimatedPointList Despite the fact that no SVGAnimatedPointList interface or objects exist in the SVG specification (unlike e.g. SVGAnimated*Length*List), we nevertheless have this internal class. (Note that there is an SVGAnimatedPoints interface, but that's quite different to SVGAnimatedLengthList since it is inherited by elements, as opposed to elements having members of that type.) The reason that we have this class is to provide a single locked down point of entry to the SVGPointList objects, which helps ensure that the DOM wrappers for SVGPointList objects' are always kept in sync. This is vitally important (see the comment in DOMSVGPointList::InternalListWillChangeTo) and frees consumers from having to know or worry about wrappers (or forget about them!) for the most part. 4106
SVGAnimatedPreserveAspectRatio.cpp Implementation 7221
SVGAnimatedPreserveAspectRatio.h 4950
SVGAnimatedRect.cpp 1472
SVGAnimatedRect.h 1560
SVGAnimatedString.cpp Implementation 4241
SVGAnimatedString.h 3721
SVGAnimatedTransformList.cpp 11140
SVGAnimatedTransformList.h Class SVGAnimatedTransformList This class is very different to the SVG DOM interface of the same name found in the SVG specification. This is a lightweight internal class - see DOMSVGAnimatedTransformList for the heavier DOM class that wraps instances of this class and implements the SVG specification's SVGAnimatedTransformList DOM interface. Except where noted otherwise, this class' methods take care of keeping the appropriate DOM wrappers in sync (see the comment in DOMSVGAnimatedTransformList::InternalBaseValListWillChangeTo) so that their consumers don't need to concern themselves with that. 5605
SVGAnimatedViewBox.cpp Implementation of SVGViewBox methods 8155
SVGAnimatedViewBox.h Returns true if the corresponding "viewBox" attribute defined a rectangle with finite values and nonnegative width/height. Returns false if the viewBox was set to an invalid string, or if any of the four rect values were too big to store in a float, or the width/height are negative. 3847
SVGAnimateElement.cpp 1292
SVGAnimateElement.h 1426
SVGAnimateMotionElement.cpp 1807
SVGAnimateMotionElement.h 1959
SVGAnimateTransformElement.cpp 2196
SVGAnimateTransformElement.h 1793
SVGAnimationElement.cpp 12496
SVGAnimationElement.h Helper that provides a reference to the element with the ID that is referenced by the animation element's 'href' attribute, if any, and that will notify the animation element if the element that that ID identifies changes to a different element (or none). (If the 'href' attribute is not specified, then the animation target is the parent element and this helper is not used.) 4483
SVGAttrTearoffTable.h Global hashmap to associate internal SVG data types (e.g. SVGAnimatedLength) with DOM tear-off objects (e.g. DOMSVGLength). This allows us to always return the same object for subsequent requests for DOM objects. We don't keep an owning reference to the tear-off objects so they are responsible for removing themselves from this table when they die. 2731
SVGAttrValueWrapper.cpp static 2985
SVGAttrValueWrapper.h Utility wrapper for handling SVG types used inside nsAttrValue so that these types don't need to be exported outside the SVG module. 2074
SVGCircleElement.cpp virtual 5347
SVGCircleElement.h 2333
SVGClipPathElement.cpp 1878
SVGClipPathElement.h 1799
SVGComponentTransferFunctionElement.h 6591
SVGContentUtils.cpp 29570
SVGContentUtils.h SVGTransformTypes controls the transforms that PrependLocalTransformsTo applies. If aWhich is eAllTransforms, then all the transforms from the coordinate space established by this element for its children to the coordinate space established by this element's parent element for this element, are included. If aWhich is eUserSpaceToParent, then only the transforms from this element's userspace to the coordinate space established by its parent is included. This includes any transforms introduced by the 'transform' attribute, transform animations and animateMotion, but not any offsets due to e.g. 'x'/'y' attributes, or any transform due to a 'viewBox' attribute. (SVG userspace is defined to be the coordinate space in which coordinates on an element apply.) If aWhich is eChildToUserSpace, then only the transforms from the coordinate space established by this element for its childre to this elements userspace are included. This includes any offsets due to e.g. 'x'/'y' attributes, and any transform due to a 'viewBox' attribute, but does not include any transforms due to the 'transform' attribute. 13030
SVGDataParser.cpp 975
SVGDataParser.h 1243
SVGDefsElement.cpp 1936
SVGDefsElement.h 1443
SVGDescElement.cpp 1094
SVGDescElement.h 1202
SVGDocument.cpp 1759
SVGDocument.h 1325
SVGElement.cpp 79990
SVGElement.h SVGElement is the base class for all SVG content elements. It implements all the common DOM interfaces and handles attributes. 26109
SVGElementFactory.cpp 3699
SVGElementFactory.h mozilla_dom_SVGElementFactory_h 1775
SVGEllipseElement.cpp virtual 5941
SVGEllipseElement.h 2380
SVGFEBlendElement.cpp 4244
SVGFEBlendElement.h 2397
SVGFEColorMatrixElement.cpp 4768
SVGFEColorMatrixElement.h 2708
SVGFEComponentTransferElement.cpp 3227
SVGFEComponentTransferElement.h 2208
SVGFECompositeElement.cpp 5180
SVGFECompositeElement.h 2906
SVGFEConvolveMatrixElement.cpp 9991
SVGFEConvolveMatrixElement.h 4363
SVGFEDiffuseLightingElement.cpp 2846
SVGFEDiffuseLightingElement.h 2072
SVGFEDisplacementMapElement.cpp 4953
SVGFEDisplacementMapElement.h 3222
SVGFEDistantLightElement.cpp 2467
SVGFEDistantLightElement.h 1971
SVGFEDropShadowElement.cpp 5748
SVGFEDropShadowElement.h 2937
SVGFEFloodElement.cpp 2403
SVGFEFloodElement.h 2020
SVGFEGaussianBlurElement.cpp 4131
SVGFEGaussianBlurElement.h 2570
SVGFEImageElement.cpp 11666
SVGFEImageElement.h 3786
SVGFEMergeElement.cpp 1974
SVGFEMergeElement.h 1881
SVGFEMergeNodeElement.cpp 1739
SVGFEMergeNodeElement.h 1766
SVGFEMorphologyElement.cpp 5065
SVGFEMorphologyElement.h 2877
SVGFEOffsetElement.cpp 3407
SVGFEOffsetElement.h 2393
SVGFEPointLightElement.cpp 2824
SVGFEPointLightElement.h 1986
SVGFESpecularLightingElement.cpp 3451
SVGFESpecularLightingElement.h 2209
SVGFESpotLightElement.cpp 4467
SVGFESpotLightElement.h 2412
SVGFETileElement.cpp 2439
SVGFETileElement.h 2132
SVGFETurbulenceElement.cpp 7371
SVGFETurbulenceElement.h 3291
SVGFilterElement.cpp virtual 4924
SVGFilterElement.h 2571
SVGFilters.cpp virtual 16762
SVGFilters.h Base class for filter primitive elements Children of those elements e.g. feMergeNode derive from SVGFEUnstyledElement instead 8683
SVGForeignObjectElement.cpp virtual 5450
SVGForeignObjectElement.h 2188
SVGFragmentIdentifier.cpp 6166
SVGFragmentIdentifier.h Implements support for parsing SVG fragment identifiers http://www.w3.org/TR/SVG/linking.html#SVGFragmentIdentifiers 1567
SVGGElement.cpp 1901
SVGGElement.h 1203
SVGGeometryElement.cpp 9065
SVGGeometryElement.h Causes this element to discard any Path object that GetOrBuildPath may have cached. 8422
SVGGeometryProperty.cpp 3198
SVGGeometryProperty.h 10168
SVGGradientElement.cpp 8517
SVGGradientElement.h 4940
SVGGraphicsElement.cpp 1945
SVGGraphicsElement.h 1481
SVGImageElement.cpp 10676
SVGImageElement.h 4498
SVGIntegerPairSMILType.cpp 3636
SVGIntegerPairSMILType.h 1811
SVGLength.cpp Helper to convert between different CSS absolute units without the need for an element, which provides more flexibility at the DOM level (and without the need for an intermediary conversion to user units, which avoids unnecessary overhead and rounding error). Example usage: to find out how many centimeters there are per inch: GetAbsUnitsPerAbsUnit(SVGLength_Binding::SVG_LENGTHTYPE_CM, SVGLength_Binding::SVG_LENGTHTYPE_IN) 7669
SVGLength.h This SVGLength class is currently used for SVGLength *list* attributes only. The class that is currently used for <length> attributes is SVGAnimatedLength. The member mUnit should always be valid, but the member mValue may be numeric_limits<float>::quiet_NaN() under one circumstances (see the comment in SetValueAndUnit below). Even if mValue is valid, some methods may return numeric_limits<float>::quiet_NaN() if they involve a unit conversion that fails - see comments below. The DOM wrapper class for this class is DOMSVGLength. 5201
SVGLengthList.cpp 2046
SVGLengthList.h ATTENTION! WARNING! WATCH OUT!! Consumers that modify objects of this type absolutely MUST keep the DOM wrappers for those lists (if any) in sync!! That's why this class is so locked down. The DOM wrapper class for this class is DOMSVGLengthList. 12123
SVGLengthListSMILType.cpp static 11139
SVGLengthListSMILType.h When this method initializes the SVGLengthListAndInfo for its SMILValue argument, it has to blindly set its mCanZeroPadList to true despite the fact that some attributes can't be zero-padded. (See the explaination that follows.) SVGAnimatedLengthList::SMILAnimatedLengthList's GetBaseValue() and ValueFromString() methods then override this for the SMILValue objects that they create to set this flag to the appropriate value for the attribute in question. The reason that we default to setting the mCanZeroPadList to true is because the SMIL engine creates "zero" valued SMILValue objects for intermediary calculations, and may pass such a SMILValue (along with a SMILValue from an animation element - that is a SMILValue created by SVGAnimatedLengthList::SMILAnimatedLengthList's GetBaseValue() or ValueFromString() methods) into the Add(), ComputeDistance() or Interpolate() methods below. Even in the case of animation of list attributes that may *not* be padded with zeros (such as 'x' and 'y' on the <text> element), we need to allow zero-padding of these "zero" valued SMILValue's lists. One reason for this is illustrated by the following example: <text x="2 4">foo <animate by="2 2" .../> </text> In this example there are two SMIL animation layers to be sandwiched: the base layer, and the layer created for the <animate> element. The SMIL engine calculates the result of each layer *independently*, before compositing the results together. Thus for the <animate> sandwich layer the SMIL engine interpolates between a "zero" SMILValue that it creates (since there is no explicit "from") and the "2 2", before the result of that interpolation is added to the "2 4" from the base layer. Clearly for the interpolation between the "zero" SMILValue and "2 2" to work, the "zero" SMILValue's SVGLengthListAndInfo must be zero paddable - hence why this method always sets mCanZeroPadList to true. (Since the Add(), ComputeDistance() and Interpolate() methods may be passed two input SMILValue objects for which CanZeroPadList() returns opposite values, these methods must be careful what they set the flag to on the SMILValue that they output. If *either* of the input SMILValues has an SVGLengthListAndInfo for which CanZeroPadList() returns false, then they must set the flag to false on the output SMILValue too. If the methods failed to do that, then when the result SMILValue objects from each sandwich layer are composited together, we could end up allowing animation between lists of different length when we should not!) 4660
SVGLineElement.cpp 8276
SVGLineElement.h 2483
SVGMarkerElement.cpp 8524
SVGMarkerElement.h 3585
SVGMaskElement.cpp virtual 4737
SVGMaskElement.h 2276
SVGMatrix.cpp 5312
SVGMatrix.h Notes on transforms in Mozilla and the SVG code. It's important to note that the matrix convention used in the SVG standard is the opposite convention to the one used in the Mozilla code or, more specifically, the convention used in Thebes code (code using gfxMatrix). Whereas the SVG standard uses the column vector convention, Thebes code uses the row vector convention. Thus, whereas in the SVG standard you have [M1][M2][M3]|p|, in Thebes you have |p|'[M3]'[M2]'[M1]'. In other words, the following are equivalent: / a1 c1 tx1 \ / a2 c2 tx2 \ / a3 c3 tx3 \ / x \ SVG: | b1 d1 ty1 | | b2 d2 ty2 | | b3 d3 ty3 | | y | \ 0 0 1 / \ 0 0 1 / \ 0 0 1 / \ 1 / / a3 b3 0 \ / a2 b2 0 \ / a1 b1 0 \ Thebes: [ x y 1 ] | c3 d3 0 | | c2 d2 0 | | c1 d1 0 | \ tx3 ty3 1 / \ tx2 ty2 1 / \ tx1 ty1 1 / Because the Thebes representation of a transform is the transpose of the SVG representation, our transform order must be reversed when representing SVG transforms using gfxMatrix in the SVG code. Since the SVG implementation stores and obtains matrices in SVG order, to do this we must pre-multiply gfxMatrix objects that represent SVG transforms instead of post-multiplying them as we would for matrices using SVG's column vector convention. Pre-multiplying may look wrong if you're only familiar with the SVG convention, but in that case hopefully the above explanation clears things up. 5112
SVGMetadataElement.cpp 1189
SVGMetadataElement.h 1288
SVGMotionSMILAnimationFunction.cpp Returns the first <mpath> child of the given element 14649
SVGMotionSMILAnimationFunction.h 3829
SVGMotionSMILAttr.cpp representation of a dummy attribute targeted by <animateMotion> element 1502
SVGMotionSMILAttr.h representation of a dummy attribute targeted by <animateMotion> element 1777
SVGMotionSMILPathUtils.cpp 4226
SVGMotionSMILPathUtils.h Helper class to help with generating anonymous path elements for <animateMotion> elements to use. 3697
SVGMotionSMILType.cpp implementation of nsISMILType for use by <animateMotion> element 18638
SVGMotionSMILType.h implementation of SMILType for use by <animateMotion> element 2915
SVGMPathElement.cpp 9051
SVGMPathElement.h Helper that provides a reference to the 'path' element with the ID that is referenced by the 'mpath' element's 'href' attribute, and that will invalidate the parent of the 'mpath' and update mutation observers to the new path element if the element that that ID identifies changes to a different element (or none). 4383
SVGNumberList.cpp 1933
SVGNumberList.h ATTENTION! WARNING! WATCH OUT!! Consumers that modify objects of this type absolutely MUST keep the DOM wrappers for those lists (if any) in sync!! That's why this class is so locked down. The DOM wrapper class for this class is DOMSVGNumberList. 6107
SVGNumberListSMILType.cpp The "identity" number list for a given number list attribute (the effective number list that is used if an attribute value is not specified) varies widely for different number list attributes, and can depend on the value of other attributes on the same element: http://www.w3.org/TR/SVG11/filters.html#feColorMatrixValuesAttribute http://www.w3.org/TR/SVG11/filters.html#feComponentTransferTableValuesAttribute http://www.w3.org/TR/SVG11/filters.html#feConvolveMatrixElementKernelMatrixAttribute http://www.w3.org/TR/SVG11/text.html#TextElementRotateAttribute Note that we don't need to worry about that variation here, however. The way that the SMIL engine creates and composites sandwich layers together allows us to treat "identity" SMILValue objects as a number list of zeros. Such identity SMILValues are identified by the fact that their # SVGNumberListAndInfo has not been given an element yet. 7634
SVGNumberListSMILType.h 1887
SVGNumberPairSMILType.cpp static 3717
SVGNumberPairSMILType.h 1728
SVGOrientSMILType.cpp static 5557
SVGOrientSMILType.h This SMILType class is a special case for the 'orient' attribute on SVG's 'marker' element. orient = "auto | auto-start-reverse | <angle>" Unusually, this attribute doesn't have just a single corresponding DOM property, but rather is split into two properties: 'orientType' (of type DOMSVGAnimatedEnumeration) and 'orientAngle' (of type DOMSVGAnimatedAngle). If 'orientType.animVal' is SVG_MARKER_ORIENT_ANGLE, then 'orientAngle.animVal' contains the angle that is being used. The lacuna value is 0. The SVG 2 specification does not define a SVG_MARKER_ORIENT_AUTO_START_REVERSE constant value for orientType to use; instead, if the attribute is set to "auto-start-reverse", SVG_MARKER_ORIENT_UNKNOWN is used. Internally, however, we do use a constant with this name. 2535
SVGPathData.cpp 39211
SVGPathData.h ATTENTION! WARNING! WATCH OUT!! Consumers that modify objects of this type absolutely MUST keep the DOM wrappers for those lists (if any) in sync!! That's why this class is so locked down. The DOM wrapper class for this class is DOMSVGPathSegList. This class is not called |class SVGPathSegList| for one very good reason; this class does not provide a list of "SVGPathSeg" items, it provides an array of floats into which path segments are encoded. See the paragraphs that follow for why. Note that the Length() method returns the number of floats in our array, not the number of encoded segments, and the index operator indexes floats in the array, not segments. If this class were called SVGPathSegList the names of these methods would be very misleading. The reason this class is designed in this way is because there are many different types of path segment, each taking a different numbers of arguments. We want to store the segments in an nsTArray to avoid individual allocations for each item, but the different size of segments means we can't have one single segment type for the nsTArray (not without using a space wasteful union or something similar). Since the internal code does not need to index into the list (the DOM wrapper does, but it handles that itself) the obvious solution is to have the items in this class take up variable width and have the internal code iterate over these lists rather than index into them. Implementing indexing to segments with O(1) performance would require us to allocate and maintain a separate segment index table (keeping that table in sync when items are inserted or removed from the list). So long as the internal code doesn't require indexing to segments, we can avoid that overhead and additional complexity. Segment encoding: the first float in the encoding of a segment contains the segment's type. The segment's type is encoded to/decoded from this float using the static methods SVGPathSegUtils::EncodeType(uint32_t)/ SVGPathSegUtils::DecodeType(float). If the path segment type in question takes any arguments then these follow the first float, and are in the same order as they are given in a <path> element's 'd' attribute (NOT in the order of the createSVGPathSegXxx() methods' arguments from the SVG DOM interface SVGPathElement, which are different...grr). Consumers can use SVGPathSegUtils::ArgCountForType(type) to determine how many arguments there are (if any), and thus where the current encoded segment ends, and where the next segment (if any) begins. 11060
SVGPathDataParser.cpp 13132
SVGPathDataParser.h 2227
SVGPathElement.cpp 10438
SVGPathElement.h This returns a path without the extra little line segments that ApproximateZeroLengthSubpathSquareCaps can insert if we have square-caps. See the comment for that function for more info on that. 5144
SVGPathSegListSMILType.cpp 18191
SVGPathSegListSMILType.h 1969
SVGPathSegUtils.cpp static 14676
SVGPathSegUtils.h Code that works with path segments can use an instance of this class to store/provide information about the start of the current subpath and the last path segment (if any). 10118
SVGPatternElement.cpp 6625
SVGPatternElement.h 3524
SVGPoint.h This class is currently used for point list attributes. The DOM wrapper class for this class is DOMSVGPoint. 2092
SVGPointList.cpp 3085
SVGPointList.h ATTENTION! WARNING! WATCH OUT!! Consumers that modify objects of this type absolutely MUST keep the DOM wrappers for those lists (if any) in sync!! That's why this class is so locked down. The DOM wrapper class for this class is DOMSVGPointList. 6824
SVGPointListSMILType.cpp static 6452
SVGPointListSMILType.h 1879
SVGPolyElement.cpp virtual 4054
SVGPolyElement.h 1907
SVGPolygonElement.cpp 2510
SVGPolygonElement.h 1442
SVGPolylineElement.cpp 1634
SVGPolylineElement.h 1379
SVGPreserveAspectRatio.cpp static 4807
SVGPreserveAspectRatio.h 4045
SVGRect.cpp 4064
SVGRect.h Generic ctor for objects that are created for an attribute. 2589
SVGRectElement.cpp virtual 8614
SVGRectElement.h 2571
SVGScriptElement.cpp 8039
SVGScriptElement.h 3278
SVGSetElement.cpp 1252
SVGSetElement.h 1398
SVGStopElement.cpp 1999
SVGStopElement.h 1539
SVGStringList.cpp 1849
SVGStringList.h The DOM wrapper class for this class is DOMSVGStringList. 4014
SVGStyleElement.cpp 6864
SVGStyleElement.h Common method to call from the various mutation observer methods. aContent is a content node that's either the one that changed or its parent; we should only respond to the change if aContent is non-anonymous. 3511
SVGSVGElement.cpp 22167
SVGSVGElement.h For use by zoom controls to allow currentScale, currentTranslate.x and currentTranslate.y to be set by a single operation that dispatches a single SVGZoom event (instead of one SVGZoom and two SVGScroll events). XXX SVGZoomEvent is no more, is this needed? 11177
SVGSwitchElement.cpp 5827
SVGSwitchElement.h 2142
SVGSymbolElement.cpp 1332
SVGSymbolElement.h 1314
SVGTagList.h This file contains the list of all SVG tags. It is designed to be used as inline input to SVGElementFactory.cpp through the magic of C preprocessing. Additionally, it is consumed by the self-regeneration code in ElementName.java from which nsHtml5ElementName.cpp/h is translated. See parser/html/java/README.txt. If you edit this list, you need to re-run ElementName.java self-regeneration and the HTML parser Java to C++ translation. All entries must be enclosed in the macro SVG_TAG or SVG_FROM_PARSER_TAG which will have cruel and unusual things done to them. SVG_FROM_PARSER_TAG is used where the element creation method takes a FromParser argument, and SVG_TAG where it does not. It is recommended (but not strictly necessary) to keep all entries in alphabetical order. The first argument to SVG_TAG is both the enum identifier of the property and the atom name. The second argument is the "creator" method of the form NS_New$TAGNAMEElement, that will be used by SVGElementFactory.cpp to create a content object for a tag of that type. **** 3250
SVGTests.cpp 7220
SVGTests.h Compare the language name(s) in a systemLanguage attribute to the user's language preferences, as defined in http://www.w3.org/TR/SVG11/struct.html#SystemLanguageAttribute We have a match if a language name in the users language preferences exactly equals one of the language names or exactly equals a prefix of one of the language names in the systemLanguage attribute. @returns 2 * the lowest index in the aAcceptLangs that matches + 1 if only the prefix matches, -2 if there's no systemLanguage attribute, or -1 if no indices match. XXX This algorithm is O(M*N). 3965
SVGTextContentElement.cpp 6189
SVGTextContentElement.h 2655
SVGTextElement.cpp 1867
SVGTextElement.h 1741
SVGTextPathElement.cpp 5087
SVGTextPathElement.h TEXTLENGTH, 3065
SVGTextPositioningElement.cpp 2577
SVGTextPositioningElement.h 1744
SVGTitleElement.cpp 2596
SVGTitleElement.h 1890
SVGTransform.cpp 6251
SVGTransform.h The DOM wrapper class for this class is DOMSVGTransform. 5213
SVGTransformableElement.cpp 10451
SVGTransformableElement.h Helper for overrides of PrependLocalTransformsTo. If both arguments are provided they are multiplied in the order in which the arguments appear, and the result is returned. If neither argument is provided, the identity matrix is returned. If only one argument is provided its transform is returned. 3229
SVGTransformList.cpp 2000
SVGTransformList.h ATTENTION! WARNING! WATCH OUT!! Consumers that modify objects of this type absolutely MUST keep the DOM wrappers for those lists (if any) in sync!! That's why this class is so locked down. The DOM wrapper class for this class is DOMSVGTransformList. 4159
SVGTransformListParser.cpp 5059
SVGTransformListParser.h 1547
SVGTransformListSMILType.cpp 13251
SVGTransformListSMILType.h 4985
SVGTSpanElement.cpp 1883
SVGTSpanElement.h 1756
SVGUseElement.cpp 19313
SVGUseElement.h Helper that provides a reference to the element with the ID that is referenced by the 'use' element's 'href' attribute, and that will update the 'use' element if the element that that ID identifies changes to a different element (or none). 5942
SVGViewBoxSMILType.cpp static 4786
SVGViewBoxSMILType.h 1710
SVGViewElement.cpp 2535
SVGViewElement.h 2320
SVGViewportElement.cpp 13483
SVGViewportElement.h Returns true if this element has a base/anim value for its "viewBox" attribute that defines a viewBox rectangle with finite values, or if there is a view element overriding this element's viewBox and it has a valid viewBox. Note that this does not check whether we need to synthesize a viewBox, so you must call ShouldSynthesizeViewBox() if you need to chck that too. Note also that this method does not pay attention to whether the width or height values of the viewBox rect are positive! 6889
test 105