Name Description Size
crashtests
DOMSVGAngle.cpp 3676
DOMSVGAngle.h Generic ctor for DOMSVGAngle objects that are created for an attribute. 2195
DOMSVGAnimatedAngle.cpp 1000
DOMSVGAnimatedAngle.h 1411
DOMSVGAnimatedBoolean.cpp 812
DOMSVGAnimatedBoolean.h 1541
DOMSVGAnimatedEnumeration.cpp 793
DOMSVGAnimatedEnumeration.h 1286
DOMSVGAnimatedInteger.cpp 812
DOMSVGAnimatedInteger.h 1233
DOMSVGAnimatedLength.cpp 1083
DOMSVGAnimatedLength.h 1394
DOMSVGAnimatedLengthList.cpp static 4597
DOMSVGAnimatedLengthList.h 9326
DOMSVGAnimatedNumber.cpp 806
DOMSVGAnimatedNumber.h 1219
DOMSVGAnimatedNumberList.cpp static 4643
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). 5083
DOMSVGAnimatedString.cpp 806
DOMSVGAnimatedString.h 1620
DOMSVGAnimatedTransformList.cpp static 4358
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). 5048
DOMSVGLength.cpp 16392
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 8070
DOMSVGLengthList.cpp 11883
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. 7747
DOMSVGNumber.cpp 4565
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. 5332
DOMSVGNumberList.cpp 11439
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. 7123
DOMSVGPathSeg.cpp May make HasOwner() == false 12862
DOMSVGPathSeg.h From DOMSVGPathSeg: 18930
DOMSVGPathSegList.cpp static 19916
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. 10745
DOMSVGPoint.cpp 6664
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. 6338
DOMSVGPointList.cpp static 13890
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. 9996
DOMSVGStringList.cpp static 6934
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. 4491
DOMSVGTransform.cpp 9668
DOMSVGTransform.h DOM wrapper for an SVG transform. See DOMSVGLength.h. 6000
DOMSVGTransformList.cpp 13041
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. 7298
moz.build 7629
SVGAElement.cpp 8739
SVGAElement.h 3781
SVGAnimatedBoolean.cpp Implementation 5248
SVGAnimatedBoolean.h 2501
SVGAnimatedClass.cpp aSrcElement 2942
SVGAnimatedClass.h 2297
SVGAnimatedClassOrString.cpp 1177
SVGAnimatedClassOrString.h 1229
SVGAnimatedEnumeration.cpp aSrcElement 6200
SVGAnimatedEnumeration.h 4046
SVGAnimatedInteger.cpp Implementation 5038
SVGAnimatedInteger.h 3776
SVGAnimatedIntegerPair.cpp Implementation 7930
SVGAnimatedIntegerPair.h 4338
SVGAnimatedLength.cpp Helper functions 20938
SVGAnimatedLength.h 11482
SVGAnimatedLengthList.cpp aSrcElement 7755
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. 4345
SVGAnimatedNumber.cpp Implementation 5461
SVGAnimatedNumber.h 3909
SVGAnimatedNumberList.cpp aSrcElement 6352
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. 4519
SVGAnimatedNumberPair.cpp 7575
SVGAnimatedNumberPair.h 4497
SVGAnimatedOrient.cpp Helper functions 15743
SVGAnimatedOrient.h 5543
SVGAnimatedPathSegList.cpp 7300
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. 4537
SVGAnimatedPointList.cpp 6704
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. 4339
SVGAnimatedPreserveAspectRatio.cpp Implementation 8019
SVGAnimatedPreserveAspectRatio.h 5036
SVGAnimatedRect.cpp 1318
SVGAnimatedRect.h 1502
SVGAnimatedString.cpp Implementation 2882
SVGAnimatedString.h 3342
SVGAnimatedTransformList.cpp 11306
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. 5904
SVGAnimatedViewBox.cpp Implementation of SVGViewBox methods 9151
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. 4134
SVGAnimateElement.cpp 1266
SVGAnimateElement.h 1359
SVGAnimateMotionElement.cpp 1782
SVGAnimateMotionElement.h 1977
SVGAnimateTransformElement.cpp 2170
SVGAnimateTransformElement.h 1726
SVGAnimationElement.cpp 11942
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.) 5462
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. 2803
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. 2071
SVGCircleElement.cpp virtual 5872
SVGCircleElement.h 2299
SVGClipPathElement.cpp 1852
SVGClipPathElement.h 1740
SVGComponentTransferFunctionElement.h 5903
SVGContentUtils.cpp 29745
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. 13191
SVGDataParser.cpp 975
SVGDataParser.h 1081
SVGDefsElement.cpp 1068
SVGDefsElement.h 1217
SVGDescElement.cpp 1068
SVGDescElement.h 1167
SVGDocument.cpp 1712
SVGDocument.h 1087
SVGElement.cpp 78867
SVGElement.h SVGElement is the base class for all SVG content elements. It implements all the common DOM interfaces and handles attributes. 25822
SVGElementFactory.cpp 3847
SVGElementFactory.h 1739
SVGEllipseElement.cpp virtual 6509
SVGEllipseElement.h 2354
SVGFEBlendElement.cpp 4501
SVGFEBlendElement.h 2362
SVGFEColorMatrixElement.cpp 5088
SVGFEColorMatrixElement.h 2691
SVGFEComponentTransferElement.cpp 3479
SVGFEComponentTransferElement.h 2206
SVGFECompositeElement.cpp 5548
SVGFECompositeElement.h 2889
SVGFEConvolveMatrixElement.cpp 10345
SVGFEConvolveMatrixElement.h 4267
SVGFEDiffuseLightingElement.cpp 3188
SVGFEDiffuseLightingElement.h 2079
SVGFEDisplacementMapElement.cpp 5288
SVGFEDisplacementMapElement.h 3209
SVGFEDistantLightElement.cpp 2442
SVGFEDistantLightElement.h 1890
SVGFEDropShadowElement.cpp 5756
SVGFEDropShadowElement.h 2903
SVGFEFloodElement.cpp 2875
SVGFEFloodElement.h 2058
SVGFEGaussianBlurElement.cpp 4461
SVGFEGaussianBlurElement.h 2561
SVGFEImageElement.cpp 12527
SVGFEImageElement.h 4231
SVGFEMergeElement.cpp 2183
SVGFEMergeElement.h 1875
SVGFEMergeNodeElement.cpp 1724
SVGFEMergeNodeElement.h 1822
SVGFEMorphologyElement.cpp 5409
SVGFEMorphologyElement.h 2892
SVGFEOffsetElement.cpp 3683
SVGFEOffsetElement.h 2379
SVGFEPointLightElement.cpp 2784
SVGFEPointLightElement.h 1884
SVGFESpecularLightingElement.cpp 3797
SVGFESpecularLightingElement.h 2211
SVGFESpotLightElement.cpp 4400
SVGFESpotLightElement.h 2331
SVGFETileElement.cpp 2723
SVGFETileElement.h 2102
SVGFETurbulenceElement.cpp 7690
SVGFETurbulenceElement.h 3253
SVGFilterElement.cpp virtual 4304
SVGFilterElement.h 2488
SVGFilters.cpp virtual 15533
SVGFilters.h Base class for filter primitive elements Children of those elements e.g. feMergeNode derive from SVGFilterPrimitiveChildElement instead 8467
SVGForeignObjectElement.cpp virtual 4859
SVGForeignObjectElement.h 2121
SVGFragmentIdentifier.cpp 5923
SVGFragmentIdentifier.h Implements support for parsing SVG fragment identifiers http://www.w3.org/TR/SVG/linking.html#SVGFragmentIdentifiers 1564
SVGGElement.cpp 1036
SVGGElement.h 1087
SVGGeometryElement.cpp 10304
SVGGeometryElement.h Causes this element to discard any Path object that GetOrBuildPath may have cached. 9652
SVGGeometryProperty.cpp 2185
SVGGeometryProperty.h 9641
SVGGradientElement.cpp 8079
SVGGradientElement.h 4846
SVGGraphicsElement.cpp 6072
SVGGraphicsElement.h 2006
SVGImageElement.cpp 10803
SVGImageElement.h 4424
SVGIntegerPairSMILType.cpp 3636
SVGIntegerPairSMILType.h 1651
SVGLength.cpp static 11727
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. 4401
SVGLengthList.cpp 2129
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. 12486
SVGLengthListSMILType.cpp static 11262
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!) 4500
SVGLengthSMILType.cpp 3846
SVGLengthSMILType.h 1611
SVGLineElement.cpp 7900
SVGLineElement.h 2254
SVGMarkerElement.cpp virtual 7399
SVGMarkerElement.h 3258
SVGMaskElement.cpp virtual 3683
SVGMaskElement.h 2119
SVGMatrix.cpp 5144
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. 5060
SVGMetadataElement.cpp 1163
SVGMetadataElement.h 1229
SVGMotionSMILAnimationFunction.cpp Returns the first <mpath> child of the given element 14566
SVGMotionSMILAnimationFunction.h 3758
SVGMotionSMILAttr.cpp representation of a dummy attribute targeted by <animateMotion> element 1502
SVGMotionSMILAttr.h representation of a dummy attribute targeted by <animateMotion> element 1805
SVGMotionSMILPathUtils.cpp 4245
SVGMotionSMILPathUtils.h Helper class to help with generating anonymous path elements for <animateMotion> elements to use. 3689
SVGMotionSMILType.cpp implementation of nsISMILType for use by <animateMotion> element 18638
SVGMotionSMILType.h implementation of SMILType for use by <animateMotion> element 2739
SVGMPathElement.cpp 4446
SVGMPathElement.h 2258
SVGNumberList.cpp 2016
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. 6462
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. 7589
SVGNumberListSMILType.h 1727
SVGNumberPairSMILType.cpp static 3717
SVGNumberPairSMILType.h 1568
SVGOrientSMILType.cpp static 5632
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. 2088
SVGPathData.cpp 50065
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. 11887
SVGPathDataParser.cpp 13177
SVGPathDataParser.h 2233
SVGPathElement.cpp 15235
SVGPathElement.h Note: This function maps d attribute to CSS d property, and we don't flush style in this function because some callers don't need it, so if the caller needs style to be flushed (e.g. DOM APIs), the caller should flush style before calling this. 5882
SVGPathSegListSMILType.cpp 18191
SVGPathSegListSMILType.h 1809
SVGPathSegUtils.cpp static 27398
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). 11226
SVGPatternElement.cpp virtual 5568
SVGPatternElement.h 3227
SVGPoint.h This class is currently used for point list attributes. The DOM wrapper class for this class is DOMSVGPoint. 2099
SVGPointList.cpp 3138
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. 7112
SVGPointListSMILType.cpp static 6410
SVGPointListSMILType.h 1719
SVGPolyElement.cpp virtual 3660
SVGPolyElement.h 1733
SVGPolygonElement.cpp 2484
SVGPolygonElement.h 1400
SVGPolylineElement.cpp 1608
SVGPolylineElement.h 1291
SVGPreserveAspectRatio.cpp static 4522
SVGPreserveAspectRatio.h 3981
SVGRect.cpp 4096
SVGRect.h Generic ctor for objects that are created for an attribute. 2616
SVGRectElement.cpp virtual 9744
SVGRectElement.h 2522
SVGScriptElement.cpp 7606
SVGScriptElement.h 3179
SVGSetElement.cpp 1226
SVGSetElement.h 1331
SVGStopElement.cpp 1558
SVGStopElement.h 1391
SVGStringList.cpp 1680
SVGStringList.h The DOM wrapper class for this class is DOMSVGStringList. 4011
SVGStyleElement.cpp 6899
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. 3467
SVGSVGElement.cpp 19629
SVGSVGElement.h Send appropriate events and updates if our root translate has changed. 9748
SVGSwitchElement.cpp 4465
SVGSwitchElement.h 2064
SVGSymbolElement.cpp 1306
SVGSymbolElement.h 1234
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 6819
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). 4193
SVGTextContentElement.cpp 6773
SVGTextContentElement.h 2647
SVGTextElement.cpp 1404
SVGTextElement.h 1536
SVGTextPathElement.cpp 4614
SVGTextPathElement.h TEXTLENGTH, 2859
SVGTextPositioningElement.cpp 2551
SVGTextPositioningElement.h 1719
SVGTitleElement.cpp 2729
SVGTitleElement.h 1807
SVGTransform.cpp 6251
SVGTransform.h The DOM wrapper class for this class is DOMSVGTransform. 5154
SVGTransformableElement.cpp static 5390
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. 2675
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. 4453
SVGTransformListParser.cpp 5064
SVGTransformListParser.h 1544
SVGTransformListSMILType.cpp 13204
SVGTransformListSMILType.h 4833
SVGTSpanElement.cpp 1416
SVGTSpanElement.h 1551
SVGUseElement.cpp 22983
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). 6179
SVGViewBoxSMILType.cpp static 4995
SVGViewBoxSMILType.h 1550
SVGViewElement.cpp 2643
SVGViewElement.h 2313
SVGViewportElement.cpp 12835
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! 6709
test