1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef DOM_SVG_SVGANIMATIONELEMENT_H_
#define DOM_SVG_SVGANIMATIONELEMENT_H_
#include "mozilla/Attributes.h"
#include "mozilla/SMILTimedElement.h"
#include "mozilla/dom/IDTracker.h"
#include "mozilla/dom/SVGElement.h"
#include "mozilla/dom/SVGTests.h"
namespace mozilla::dom {
using SVGAnimationElementBase = SVGElement;
class SVGAnimationElement : public SVGAnimationElementBase, public SVGTests {
protected:
explicit SVGAnimationElement(
already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);
nsresult Init();
virtual ~SVGAnimationElement() = default;
public:
// interfaces:
NS_DECL_ISUPPORTS_INHERITED
NS_IMPL_FROMNODE_HELPER(SVGAnimationElement, IsSVGAnimationElement())
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(SVGAnimationElement,
SVGAnimationElementBase)
bool IsSVGAnimationElement() const final { return true; }
bool PassesConditionalProcessingTests() const final {
return SVGTests::PassesConditionalProcessingTests();
}
nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override = 0;
// nsIContent specializations
nsresult BindToTree(BindContext&, nsINode& aParent) override;
void UnbindFromTree(UnbindContext&) override;
// Element specializations
bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
const nsAString& aValue,
nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
void AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
const nsAttrValue* aValue, const nsAttrValue* aOldValue,
nsIPrincipal* aSubjectPrincipal, bool aNotify) override;
Element* GetTargetElementContent();
virtual bool GetTargetAttributeName(int32_t* aNamespaceID,
nsAtom** aLocalName) const;
mozilla::SMILTimedElement& TimedElement();
mozilla::SMILTimeContainer* GetTimeContainer();
virtual SMILAnimationFunction& AnimationFunction() = 0;
bool IsEventAttributeNameInternal(nsAtom* aName) override;
// Utility methods for within SVG
void ActivateByHyperlink();
// WebIDL
SVGElement* GetTargetElement();
float GetStartTime(ErrorResult& rv);
float GetCurrentTimeAsFloat();
float GetSimpleDuration(ErrorResult& rv);
void BeginElement(ErrorResult& rv) { BeginElementAt(0.f, rv); }
void BeginElementAt(float offset, ErrorResult& rv);
void EndElement(ErrorResult& rv) { EndElementAt(0.f, rv); }
void EndElementAt(float offset, ErrorResult& rv);
// Manually implement onbegin/onrepeat/onend IDL property getters/setters.
// We don't autogenerate these methods because the property name differs
// from the event type atom - the event type atom has an extra 'Event' tacked
// on at the end. (i.e. 'onbegin' corresponds to an event whose name is
// literally 'beginEvent' rather than 'begin')
EventHandlerNonNull* GetOnbegin() {
return GetEventHandler(nsGkAtoms::onbeginEvent);
}
void SetOnbegin(EventHandlerNonNull* handler) {
EventTarget::SetEventHandler(nsGkAtoms::onbeginEvent, handler);
}
EventHandlerNonNull* GetOnrepeat() {
return GetEventHandler(nsGkAtoms::onrepeatEvent);
}
void SetOnrepeat(EventHandlerNonNull* handler) {
EventTarget::SetEventHandler(nsGkAtoms::onrepeatEvent, handler);
}
EventHandlerNonNull* GetOnend() {
return GetEventHandler(nsGkAtoms::onendEvent);
}
void SetOnend(EventHandlerNonNull* handler) {
EventTarget::SetEventHandler(nsGkAtoms::onendEvent, handler);
}
// SVGTests
SVGElement* AsSVGElement() final { return this; }
protected:
// SVGElement overrides
void UpdateHrefTarget(const nsAString& aHrefStr);
void AnimationTargetChanged();
/**
* 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.)
*/
class HrefTargetTracker final : public IDTracker {
public:
explicit HrefTargetTracker(SVGAnimationElement* aAnimationElement)
: mAnimationElement(aAnimationElement) {}
protected:
// We need to be notified when target changes, in order to request a
// sample (which will clear animation effects from old target and apply
// them to the new target) and update any event registrations.
void ElementChanged(Element* aFrom, Element* aTo) override {
IDTracker::ElementChanged(aFrom, aTo);
mAnimationElement->AnimationTargetChanged();
}
// We need to override IsPersistent to get persistent tracking (beyond the
// first time the target changes)
bool IsPersistent() override { return true; }
private:
SVGAnimationElement* const mAnimationElement;
};
HrefTargetTracker mHrefTarget;
mozilla::SMILTimedElement mTimedElement;
};
} // namespace mozilla::dom
#endif // DOM_SVG_SVGANIMATIONELEMENT_H_
|
