| 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 |
19990 |
| 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.
|
10750 |
| DOMSVGPoint.cpp |
|
6623 |
| 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 |
13954 |
| 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.
|
10001 |
| 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 |
|
9133 |
| SVGAElement.h |
|
3718 |
| 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 |
|
11880 |
| 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.)
|
5460 |
| 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 |
|
30898 |
| 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 |
|
78875 |
| SVGElement.h |
SVGElement is the base class for all SVG content elements.
It implements all the common DOM interfaces and handles attributes.
|
25830 |
| 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 |
|
13364 |
| SVGFEImageElement.h |
|
4308 |
| 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 |
|
10256 |
| 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 |
|
6036 |
| SVGGraphicsElement.h |
|
2006 |
| SVGImageElement.cpp |
|
11400 |
| SVGImageElement.h |
|
4502 |
| 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 |
|
4797 |
| 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 |
|
4450 |
| SVGMPathElement.h |
|
2256 |
| 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 |
static |
50030 |
| 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.
|
12317 |
| SVGPathDataParser.cpp |
|
13177 |
| SVGPathDataParser.h |
|
2233 |
| SVGPathElement.cpp |
|
14080 |
| 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 |
26604 |
| 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).
|
11300 |
| 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 |
3493 |
| 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 |
|
6903 |
| 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.
|
3458 |
| SVGSVGElement.cpp |
|
19770 |
| SVGSVGElement.h |
Send appropriate events and updates if our root translate
has changed.
|
9746 |
| SVGSwitchElement.cpp |
|
4465 |
| SVGSwitchElement.h |
|
2064 |
| SVGSymbolElement.cpp |
|
1773 |
| SVGSymbolElement.h |
|
1404 |
| 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 |
|
2733 |
| SVGTitleElement.h |
|
1798 |
| 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 |
|
23270 |
| 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).
|
6249 |
| SVGViewBoxSMILType.cpp |
static |
4995 |
| SVGViewBoxSMILType.h |
|
1550 |
| SVGViewElement.cpp |
|
2643 |
| SVGViewElement.h |
|
2313 |
| SVGViewportElement.cpp |
|
12824 |
| 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!
|
6352 |
| test |
|
|