Name Description Size
DOMSVGAngle.cpp 3646
DOMSVGAngle.h Generic ctor for DOMSVGAngle objects that are created for an attribute. 2211
DOMSVGAnimatedAngle.cpp 1162
DOMSVGAnimatedAngle.h 1427
DOMSVGAnimatedBoolean.cpp 978
DOMSVGAnimatedBoolean.h 1583
DOMSVGAnimatedEnumeration.cpp 967
DOMSVGAnimatedEnumeration.h 1312
DOMSVGAnimatedInteger.cpp 978
DOMSVGAnimatedInteger.h 1259
DOMSVGAnimatedLength.cpp 1247
DOMSVGAnimatedLength.h 1410
DOMSVGAnimatedLengthList.cpp static 4769
DOMSVGAnimatedLengthList.h 9342
DOMSVGAnimatedNumber.cpp 970
DOMSVGAnimatedNumber.h 1245
DOMSVGAnimatedNumberList.cpp static 4815
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). 5099
DOMSVGAnimatedString.cpp 970
DOMSVGAnimatedString.h 1646
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 14957
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 7894
DOMSVGLengthList.cpp 11909
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. 7763
DOMSVGNumber.cpp 4713
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. 5348
DOMSVGNumberList.cpp 11369
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. 7139
DOMSVGPathSeg.cpp May make HasOwner() == false 13012
DOMSVGPathSeg.h From DOMSVGPathSeg: 19370
DOMSVGPathSegList.cpp static 19942
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. 10761
DOMSVGPoint.cpp 6810
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. 6365
DOMSVGPointList.cpp static 13916
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. 10012
DOMSVGStringList.cpp static 6965
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. 4507
DOMSVGTransform.cpp 9812
DOMSVGTransform.h DOM wrapper for an SVG transform. See DOMSVGLength.h. 6042
DOMSVGTransformList.cpp 12978
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. 7314
SVGAElement.cpp 11500
SVGAElement.h 3982
SVGAnimateElement.cpp 1292
SVGAnimateElement.h 1417
SVGAnimateMotionElement.cpp 1807
SVGAnimateMotionElement.h 1950
SVGAnimateTransformElement.cpp 2196
SVGAnimateTransformElement.h 1784
SVGAnimatedBoolean.cpp Implementation 5285
SVGAnimatedBoolean.h 2463
SVGAnimatedClass.cpp aSrcElement 3036
SVGAnimatedClass.h 2259
SVGAnimatedClassOrString.cpp 1177
SVGAnimatedClassOrString.h 1229
SVGAnimatedEnumeration.cpp aSrcElement 6220
SVGAnimatedEnumeration.h 4032
SVGAnimatedInteger.cpp Implementation 5075
SVGAnimatedInteger.h 3762
SVGAnimatedIntegerPair.cpp Implementation 7942
SVGAnimatedIntegerPair.h 4324
SVGAnimatedLength.cpp SVG_LENGTHTYPE_UNKNOWN 15721
SVGAnimatedLength.h 7882
SVGAnimatedLengthList.cpp 8164
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. 4083
SVGAnimatedNumber.cpp Implementation 5498
SVGAnimatedNumber.h 3940
SVGAnimatedNumberList.cpp 6620
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. 4225
SVGAnimatedNumberPair.cpp 7587
SVGAnimatedNumberPair.h 4478
SVGAnimatedOrient.cpp SVG_ANGLETYPE_UNKNOWN 15772
SVGAnimatedOrient.h 5526
SVGAnimatedPathSegList.cpp 7371
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. 4275
SVGAnimatedPointList.cpp 7127
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. 4080
SVGAnimatedPreserveAspectRatio.cpp Implementation 8259
SVGAnimatedPreserveAspectRatio.h 4990
SVGAnimatedRect.cpp 1472
SVGAnimatedRect.h 1518
SVGAnimatedString.cpp Implementation 2919
SVGAnimatedString.h 2830
SVGAnimatedTransformList.cpp 11316
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. 5511
SVGAnimatedViewBox.cpp Implementation of SVGViewBox methods 9163
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. 3843
SVGAnimationElement.cpp 12450
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.) 4915
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. 2746
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 5957
SVGCircleElement.h 2322
SVGClipPathElement.cpp 1878
SVGClipPathElement.h 1793
SVGComponentTransferFunctionElement.h 6594
SVGContentUtils.cpp 29523
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. 13103
SVGDataParser.cpp 975
SVGDataParser.h 1249
SVGDefsElement.cpp 1936
SVGDefsElement.h 1434
SVGDescElement.cpp 1094
SVGDescElement.h 1193
SVGDocument.cpp 1588
SVGDocument.h 1316
SVGElement.cpp 83486
SVGElement.h SVGElement is the base class for all SVG content elements. It implements all the common DOM interfaces and handles attributes. 29117
SVGElementFactory.cpp 3699
SVGElementFactory.h 1765
SVGEllipseElement.cpp virtual 6595
SVGEllipseElement.h 2369
SVGFEBlendElement.cpp 4218
SVGFEBlendElement.h 2398
SVGFEColorMatrixElement.cpp 4742
SVGFEColorMatrixElement.h 2709
SVGFEComponentTransferElement.cpp 3201
SVGFEComponentTransferElement.h 2209
SVGFECompositeElement.cpp 5178
SVGFECompositeElement.h 2907
SVGFEConvolveMatrixElement.cpp 10001
SVGFEConvolveMatrixElement.h 4326
SVGFEDiffuseLightingElement.cpp 2826
SVGFEDiffuseLightingElement.h 2073
SVGFEDisplacementMapElement.cpp 4933
SVGFEDisplacementMapElement.h 3223
SVGFEDistantLightElement.cpp 2471
SVGFEDistantLightElement.h 1966
SVGFEDropShadowElement.cpp 5737
SVGFEDropShadowElement.h 2938
SVGFEFloodElement.cpp 2422
SVGFEFloodElement.h 2021
SVGFEGaussianBlurElement.cpp 4111
SVGFEGaussianBlurElement.h 2571
SVGFEImageElement.cpp 11964
SVGFEImageElement.h 3827
SVGFEMergeElement.cpp 1972
SVGFEMergeElement.h 1882
SVGFEMergeNodeElement.cpp 1739
SVGFEMergeNodeElement.h 1769
SVGFEMorphologyElement.cpp 5067
SVGFEMorphologyElement.h 2876
SVGFEOffsetElement.cpp 3411
SVGFEOffsetElement.h 2394
SVGFEPointLightElement.cpp 2828
SVGFEPointLightElement.h 1981
SVGFESpecularLightingElement.cpp 3431
SVGFESpecularLightingElement.h 2210
SVGFESpotLightElement.cpp 4471
SVGFESpotLightElement.h 2407
SVGFETileElement.cpp 2443
SVGFETileElement.h 2133
SVGFETurbulenceElement.cpp 7355
SVGFETurbulenceElement.h 3292
SVGFilterElement.cpp virtual 4870
SVGFilterElement.h 2566
SVGFilters.cpp virtual 16722
SVGFilters.h Base class for filter primitive elements Children of those elements e.g. feMergeNode derive from SVGFEUnstyledElement instead 8534
SVGForeignObjectElement.cpp virtual 5475
SVGForeignObjectElement.h 2182
SVGFragmentIdentifier.cpp 6353
SVGFragmentIdentifier.h Implements support for parsing SVG fragment identifiers http://www.w3.org/TR/SVG/linking.html#SVGFragmentIdentifiers 1564
SVGGElement.cpp 1995
SVGGElement.h 1247
SVGGeometryElement.cpp 9444
SVGGeometryElement.h Causes this element to discard any Path object that GetOrBuildPath may have cached. 8807
SVGGeometryProperty.cpp 3325
SVGGeometryProperty.h 10112
SVGGradientElement.cpp 8531
SVGGradientElement.h 4995
SVGGraphicsElement.cpp 2525
SVGGraphicsElement.h 1714
SVGImageElement.cpp 10985
SVGImageElement.h 4495
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. 5198
SVGLengthList.cpp 2074
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. 12120
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 2474
SVGMPathElement.cpp 9101
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). 4381
SVGMarkerElement.cpp 8548
SVGMarkerElement.h 3573
SVGMaskElement.cpp virtual 4737
SVGMaskElement.h 2268
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. 5103
SVGMetadataElement.cpp 1189
SVGMetadataElement.h 1279
SVGMotionSMILAnimationFunction.cpp Returns the first <mpath> child of the given element 14572
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
SVGNumberList.cpp 1961
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. 6104
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 38619
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. 11009
SVGPathDataParser.cpp 13132
SVGPathDataParser.h 2233
SVGPathElement.cpp 10427
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. 5316
SVGPathSegListSMILType.cpp 18191
SVGPathSegListSMILType.h 1969
SVGPathSegUtils.cpp static 14702
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). 10115
SVGPatternElement.cpp 6639
SVGPatternElement.h 3435
SVGPoint.h This class is currently used for point list attributes. The DOM wrapper class for this class is DOMSVGPoint. 2089
SVGPointList.cpp 3113
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. 6769
SVGPointListSMILType.cpp static 6452
SVGPointListSMILType.h 1879
SVGPolyElement.cpp virtual 4054
SVGPolyElement.h 1922
SVGPolygonElement.cpp 2510
SVGPolygonElement.h 1433
SVGPolylineElement.cpp 1634
SVGPolylineElement.h 1370
SVGPreserveAspectRatio.cpp static 4670
SVGPreserveAspectRatio.h 3997
SVGRect.cpp 4234
SVGRect.h Generic ctor for objects that are created for an attribute. 2642
SVGRectElement.cpp virtual 9734
SVGRectElement.h 2560
SVGSVGElement.cpp 19826
SVGSVGElement.h Send appropriate events and updates if our root translate has changed. 10020
SVGScriptElement.cpp 7818
SVGScriptElement.h 3269
SVGSetElement.cpp 1252
SVGSetElement.h 1389
SVGStopElement.cpp 2062
SVGStopElement.h 1530
SVGStringList.cpp 1849
SVGStringList.h The DOM wrapper class for this class is DOMSVGStringList. 4011
SVGStyleElement.cpp 6967
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. 3599
SVGSwitchElement.cpp 5352
SVGSwitchElement.h 2072
SVGSymbolElement.cpp 1332
SVGSymbolElement.h 1305
SVGTSpanElement.cpp 1883
SVGTSpanElement.h 1747
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 6980
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 6108
SVGTextContentElement.h 2647
SVGTextElement.cpp 1964
SVGTextElement.h 1785
SVGTextPathElement.cpp 5087
SVGTextPathElement.h TEXTLENGTH, 3063
SVGTextPositioningElement.cpp 2577
SVGTextPositioningElement.h 1735
SVGTitleElement.cpp 2631
SVGTitleElement.h 1881
SVGTransform.cpp 6251
SVGTransform.h The DOM wrapper class for this class is DOMSVGTransform. 5210
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. 4156
SVGTransformListParser.cpp 5059
SVGTransformListParser.h 1544
SVGTransformListSMILType.cpp 13293
SVGTransformListSMILType.h 5009
SVGTransformableElement.cpp 10576
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. 3202
SVGUseElement.cpp 19710
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). 6121
SVGViewBoxSMILType.cpp static 4786
SVGViewBoxSMILType.h 1710
SVGViewElement.cpp 2669
SVGViewElement.h 2313
SVGViewportElement.cpp 13618
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! 6803
crashtests 101
moz.build 7447
test 107