4a571d47a61b25915c4777407128b56efbb5b339
[WebKit-https.git] / Source / WebCore / platform / animation / TimingFunction.h
1 /*
2  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
3  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2000 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2003, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
6  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #ifndef TimingFunction_h
26 #define TimingFunction_h
27
28 #include <wtf/PassRefPtr.h>
29 #include <wtf/RefCounted.h>
30
31 namespace WebCore {
32
33 class TimingFunction : public RefCounted<TimingFunction> {
34 public:
35
36     virtual PassRefPtr<TimingFunction> clone() const = 0;
37
38     enum TimingFunctionType {
39         LinearFunction, CubicBezierFunction, StepsFunction, SpringFunction
40     };
41     
42     virtual ~TimingFunction() { }
43
44     TimingFunctionType type() const { return m_type; }
45     
46     bool isLinearTimingFunction() const { return m_type == LinearFunction; }
47     bool isCubicBezierTimingFunction() const { return m_type == CubicBezierFunction; }
48     bool isStepsTimingFunction() const { return m_type == StepsFunction; }
49     bool isSpringTimingFunction() const { return m_type == SpringFunction; }
50     
51     virtual bool operator==(const TimingFunction& other) = 0;
52
53 protected:
54     TimingFunction(TimingFunctionType type)
55         : m_type(type)
56     {
57     }
58     
59     TimingFunctionType m_type;
60 };
61
62 class LinearTimingFunction final : public TimingFunction {
63 public:
64     static PassRefPtr<LinearTimingFunction> create()
65     {
66         return adoptRef(new LinearTimingFunction);
67     }
68     
69     virtual ~LinearTimingFunction() { }
70     
71     bool operator==(const TimingFunction& other) override
72     {
73         return other.isLinearTimingFunction();
74     }
75
76 private:
77     LinearTimingFunction()
78         : TimingFunction(LinearFunction)
79     {
80     }
81
82     PassRefPtr<TimingFunction> clone() const override
83     {
84         return adoptRef(new LinearTimingFunction);
85     }
86 };
87
88 class CubicBezierTimingFunction final : public TimingFunction {
89 public:
90     enum TimingFunctionPreset {
91         Ease,
92         EaseIn,
93         EaseOut,
94         EaseInOut,
95         Custom
96     };
97     
98     static PassRefPtr<CubicBezierTimingFunction> create(double x1, double y1, double x2, double y2)
99     {
100         return adoptRef(new CubicBezierTimingFunction(Custom, x1, y1, x2, y2));
101     }
102
103     static PassRefPtr<CubicBezierTimingFunction> create()
104     {
105         return adoptRef(new CubicBezierTimingFunction());
106     }
107     
108     static PassRefPtr<CubicBezierTimingFunction> create(TimingFunctionPreset preset)
109     {
110         switch (preset) {
111         case Ease:
112             return adoptRef(new CubicBezierTimingFunction());
113         case EaseIn:
114             return adoptRef(new CubicBezierTimingFunction(EaseIn, 0.42, 0.0, 1.0, 1.0));
115         case EaseOut:
116             return adoptRef(new CubicBezierTimingFunction(EaseOut, 0.0, 0.0, 0.58, 1.0));
117         case EaseInOut:
118             return adoptRef(new CubicBezierTimingFunction(EaseInOut, 0.42, 0.0, 0.58, 1.0));
119         default:
120             ASSERT_NOT_REACHED();
121             return 0;
122         }
123     }
124
125     virtual ~CubicBezierTimingFunction() { }
126     
127     bool operator==(const TimingFunction& other) override
128     {
129         if (other.isCubicBezierTimingFunction()) {
130             const CubicBezierTimingFunction* ctf = static_cast<const CubicBezierTimingFunction*>(&other);
131             if (m_timingFunctionPreset != Custom)
132                 return m_timingFunctionPreset == ctf->m_timingFunctionPreset;
133             
134             return m_x1 == ctf->m_x1 && m_y1 == ctf->m_y1 && m_x2 == ctf->m_x2 && m_y2 == ctf->m_y2;
135         }
136         return false;
137     }
138
139     double x1() const { return m_x1; }
140     double y1() const { return m_y1; }
141     double x2() const { return m_x2; }
142     double y2() const { return m_y2; }
143     
144     void setValues(double x1, double y1, double x2, double y2)
145     {
146         m_x1 = x1;
147         m_y1 = y1;
148         m_x2 = x2;
149         m_y2 = y2;
150     }
151     
152     TimingFunctionPreset timingFunctionPreset() const { return m_timingFunctionPreset; }
153     void setTimingFunctionPreset(TimingFunctionPreset preset) { m_timingFunctionPreset = preset; }
154     
155     static const CubicBezierTimingFunction* defaultTimingFunction()
156     {
157         static const CubicBezierTimingFunction* dtf = create().leakRef();
158         return dtf;
159     }
160
161     PassRefPtr<CubicBezierTimingFunction> createReversed() const
162     {
163         return create(1.0 - m_x2, 1.0 - m_y2, 1.0 - m_x1, 1.0 - m_y1);
164     }
165     
166 private:
167     explicit CubicBezierTimingFunction(TimingFunctionPreset preset = Ease, double x1 = 0.25, double y1 = 0.1, double x2 = 0.25, double y2 = 1.0)
168         : TimingFunction(CubicBezierFunction)
169         , m_x1(x1)
170         , m_y1(y1)
171         , m_x2(x2)
172         , m_y2(y2)
173         , m_timingFunctionPreset(preset)
174     {
175     }
176
177     PassRefPtr<TimingFunction> clone() const override
178     {
179         return adoptRef(new CubicBezierTimingFunction(m_timingFunctionPreset, m_x1, m_y1, m_x2, m_y2));
180     }
181
182     double m_x1;
183     double m_y1;
184     double m_x2;
185     double m_y2;
186     TimingFunctionPreset m_timingFunctionPreset;
187 };
188
189 class StepsTimingFunction final : public TimingFunction {
190 public:
191     
192     static PassRefPtr<StepsTimingFunction> create(int steps, bool stepAtStart)
193     {
194         return adoptRef(new StepsTimingFunction(steps, stepAtStart));
195     }
196     static PassRefPtr<StepsTimingFunction> create()
197     {
198         return adoptRef(new StepsTimingFunction(1, true));
199     }
200     
201     virtual ~StepsTimingFunction() { }
202     
203     bool operator==(const TimingFunction& other) override
204     {
205         if (other.isStepsTimingFunction()) {
206             const StepsTimingFunction* stf = static_cast<const StepsTimingFunction*>(&other);
207             return m_steps == stf->m_steps && m_stepAtStart == stf->m_stepAtStart;
208         }
209         return false;
210     }
211     
212     int numberOfSteps() const { return m_steps; }
213     void setNumberOfSteps(int steps) { m_steps = steps; }
214
215     bool stepAtStart() const { return m_stepAtStart; }
216     void setStepAtStart(bool stepAtStart) { m_stepAtStart = stepAtStart; }
217     
218 private:
219     StepsTimingFunction(int steps, bool stepAtStart)
220         : TimingFunction(StepsFunction)
221         , m_steps(steps)
222         , m_stepAtStart(stepAtStart)
223     {
224     }
225
226     PassRefPtr<TimingFunction> clone() const override
227     {
228         return adoptRef(new StepsTimingFunction(m_steps, m_stepAtStart));
229     }
230     
231     int m_steps;
232     bool m_stepAtStart;
233 };
234
235 class SpringTimingFunction final : public TimingFunction {
236 public:
237     static Ref<SpringTimingFunction> create(double mass, double stiffness, double damping, double initialVelocity)
238     {
239         return adoptRef(*new SpringTimingFunction(mass, stiffness, damping, initialVelocity));
240     }
241
242     static Ref<SpringTimingFunction> create()
243     {
244         // This create() function should only be used by the argument decoders, and it is expected that
245         // real values will be filled in using setValues().
246         return create(0, 0, 0, 0);
247     }
248     
249     bool operator==(const TimingFunction& other) override
250     {
251         if (other.isSpringTimingFunction()) {
252             const SpringTimingFunction& otherString = *static_cast<const SpringTimingFunction*>(&other);
253             return m_mass == otherString.m_mass && m_stiffness == otherString.m_stiffness && m_damping == otherString.m_damping && m_initialVelocity == otherString.m_initialVelocity;
254         }
255         return false;
256     }
257
258     double mass() const { return m_mass; }
259     double stiffness() const { return m_stiffness; }
260     double damping() const { return m_damping; }
261     double initialVelocity() const { return m_initialVelocity; }
262     
263     void setValues(double mass, double stiffness, double damping, double initialVelocity)
264     {
265         m_mass = mass;
266         m_stiffness = stiffness;
267         m_damping = damping;
268         m_initialVelocity = initialVelocity;
269     }
270
271 private:
272     explicit SpringTimingFunction(double mass, double stiffness, double damping, double initialVelocity)
273         : TimingFunction(SpringFunction)
274         , m_mass(mass)
275         , m_stiffness(stiffness)
276         , m_damping(damping)
277         , m_initialVelocity(initialVelocity)
278     {
279     }
280
281     PassRefPtr<TimingFunction> clone() const override
282     {
283         return adoptRef(new SpringTimingFunction(m_mass, m_stiffness, m_damping, m_initialVelocity));
284     }
285
286     double m_mass;
287     double m_stiffness;
288     double m_damping;
289     double m_initialVelocity;
290 };
291
292 class TextStream;
293 WEBCORE_EXPORT TextStream& operator<<(TextStream&, const TimingFunction&);
294
295 } // namespace WebCore
296
297 #endif // TimingFunction_h