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
150
|
/* -*- 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_SVGANIMATEDORIENT_H_
#define DOM_SVG_SVGANIMATEDORIENT_H_
#include "DOMSVGAnimatedEnumeration.h"
#include "nsError.h"
#include "SVGAnimatedEnumeration.h"
#include "mozilla/AlreadyAddRefed.h"
#include "mozilla/Attributes.h"
#include "mozilla/SMILAttr.h"
#include "mozilla/dom/SVGAngleBinding.h"
#include "mozilla/dom/SVGMarkerElementBinding.h"
#include "mozilla/UniquePtr.h"
class nsISupports;
namespace mozilla {
class SMILValue;
namespace dom {
class DOMSVGAngle;
class DOMSVGAnimatedAngle;
class SVGAnimationElement;
class SVGElement;
} // namespace dom
class SVGAnimatedOrient {
friend class AutoChangeOrientNotifier;
friend class dom::DOMSVGAngle;
friend class dom::DOMSVGAnimatedAngle;
using SVGElement = dom::SVGElement;
public:
void Init() {
mAnimVal = mBaseVal = .0f;
mAnimType = mBaseType =
dom::SVGMarkerElement_Binding::SVG_MARKER_ORIENT_ANGLE;
mAnimValUnit = mBaseValUnit =
dom::SVGAngle_Binding::SVG_ANGLETYPE_UNSPECIFIED;
mIsAnimated = false;
}
nsresult SetBaseValueString(const nsAString& aValue, SVGElement* aSVGElement,
bool aDoSetAttr);
void GetBaseValueString(nsAString& aValue) const;
void GetBaseAngleValueString(nsAString& aValue) const;
void GetAnimAngleValueString(nsAString& aValue) const;
float GetBaseValue() const {
return mBaseVal * GetDegreesPerUnit(mBaseValUnit);
}
float GetAnimValue() const {
return mAnimVal * GetDegreesPerUnit(mAnimValUnit);
}
SVGEnumValue GetAnimType() const { return mAnimType; }
void SetBaseValue(float aValue, uint8_t aUnit, SVGElement* aSVGElement,
bool aDoSetAttr);
void SetBaseType(SVGEnumValue aValue, SVGElement* aSVGElement,
ErrorResult& aRv);
void SetAnimValue(float aValue, uint8_t aUnit, SVGElement* aSVGElement);
void SetAnimType(SVGEnumValue aValue, SVGElement* aSVGElement);
uint8_t GetBaseValueUnit() const { return mBaseValUnit; }
uint8_t GetAnimValueUnit() const { return mAnimValUnit; }
float GetBaseValInSpecifiedUnits() const { return mBaseVal; }
float GetAnimValInSpecifiedUnits() const { return mAnimVal; }
static nsresult ToDOMSVGAngle(nsISupports** aResult);
already_AddRefed<dom::DOMSVGAnimatedAngle> ToDOMAnimatedAngle(
SVGElement* aSVGElement);
already_AddRefed<dom::DOMSVGAnimatedEnumeration> ToDOMAnimatedEnum(
SVGElement* aSVGElement);
UniquePtr<SMILAttr> ToSMILAttr(SVGElement* aSVGElement);
static bool GetValueFromString(const nsAString& aString, float& aValue,
uint16_t* aUnitType);
static float GetDegreesPerUnit(uint8_t aUnit);
private:
float mAnimVal;
float mBaseVal;
uint8_t mAnimType;
uint8_t mBaseType;
uint8_t mAnimValUnit;
uint8_t mBaseValUnit;
bool mIsAnimated;
void SetBaseValueInSpecifiedUnits(float aValue, SVGElement* aSVGElement);
nsresult NewValueSpecifiedUnits(uint16_t aUnitType,
float aValueInSpecifiedUnits,
SVGElement* aSVGElement);
nsresult ConvertToSpecifiedUnits(uint16_t aUnitType, SVGElement* aSVGElement);
already_AddRefed<dom::DOMSVGAngle> ToDOMBaseVal(SVGElement* aSVGElement);
already_AddRefed<dom::DOMSVGAngle> ToDOMAnimVal(SVGElement* aSVGElement);
public:
// DOM wrapper class for the (DOM)SVGAnimatedEnumeration interface where the
// wrapped class is SVGAnimatedOrient.
struct DOMAnimatedEnum final : public dom::DOMSVGAnimatedEnumeration {
DOMAnimatedEnum(SVGAnimatedOrient* aVal, SVGElement* aSVGElement)
: DOMSVGAnimatedEnumeration(aSVGElement), mVal(aVal) {}
~DOMAnimatedEnum();
SVGAnimatedOrient* mVal; // kept alive because it belongs to content
using dom::DOMSVGAnimatedEnumeration::SetBaseVal;
uint16_t BaseVal() override { return mVal->mBaseType; }
void SetBaseVal(uint16_t aBaseVal, ErrorResult& aRv) override {
mVal->SetBaseType(aBaseVal, mSVGElement, aRv);
}
uint16_t AnimVal() override {
// Script may have modified animation parameters or timeline -- DOM
// getters need to flush any resample requests to reflect these
// modifications.
mSVGElement->FlushAnimations();
return mVal->mAnimType;
}
};
struct SMILOrient final : public SMILAttr {
public:
SMILOrient(SVGAnimatedOrient* aOrient, SVGElement* aSVGElement)
: mOrient(aOrient), mSVGElement(aSVGElement) {}
// These will stay alive because a SMILAttr only lives as long
// as the Compositing step, and DOM elements don't get a chance to
// die during that.
SVGAnimatedOrient* mOrient;
SVGElement* mSVGElement;
// SMILAttr methods
virtual nsresult ValueFromString(
const nsAString& aStr, const dom::SVGAnimationElement* aSrcElement,
SMILValue& aValue, bool& aPreventCachingOfSandwich) const override;
virtual SMILValue GetBaseValue() const override;
virtual void ClearAnimValue() override;
virtual nsresult SetAnimValue(const SMILValue& aValue) override;
};
};
} // namespace mozilla
#endif // DOM_SVG_SVGANIMATEDORIENT_H_
|
