Use "= default" to denote default constructor or destructor
[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 #pragma once
26
27 #include <wtf/Ref.h>
28 #include <wtf/RefCounted.h>
29
30 namespace WTF {
31 class TextStream;
32 }
33
34 namespace WebCore {
35
36 class TimingFunction : public RefCounted<TimingFunction> {
37 public:
38     virtual Ref<TimingFunction> clone() const = 0;
39
40     virtual ~TimingFunction() = default;
41
42     enum TimingFunctionType { LinearFunction, CubicBezierFunction, StepsFunction, SpringFunction };
43     TimingFunctionType type() const { return m_type; }
44
45     bool isLinearTimingFunction() const { return m_type == LinearFunction; }
46     bool isCubicBezierTimingFunction() const { return m_type == CubicBezierFunction; }
47     bool isStepsTimingFunction() const { return m_type == StepsFunction; }
48     bool isSpringTimingFunction() const { return m_type == SpringFunction; }
49
50     virtual bool operator==(const TimingFunction&) const = 0;
51     bool operator!=(const TimingFunction& other) const { return !(*this == other); }
52
53 protected:
54     explicit TimingFunction(TimingFunctionType type)
55         : m_type(type)
56     {
57     }
58
59 private:
60     TimingFunctionType m_type;
61 };
62
63 class LinearTimingFunction final : public TimingFunction {
64 public:
65     static Ref<LinearTimingFunction> create()
66     {
67         return adoptRef(*new LinearTimingFunction);
68     }
69     
70     bool operator==(const TimingFunction& other) const final
71     {
72         return other.isLinearTimingFunction();
73     }
74
75 private:
76     LinearTimingFunction()
77         : TimingFunction(LinearFunction)
78     {
79     }
80
81     Ref<TimingFunction> clone() const final
82     {
83         return adoptRef(*new LinearTimingFunction);
84     }
85 };
86
87 class CubicBezierTimingFunction final : public TimingFunction {
88 public:
89     enum TimingFunctionPreset { Ease, EaseIn, EaseOut, EaseInOut, Custom };
90     
91     static Ref<CubicBezierTimingFunction> create(double x1, double y1, double x2, double y2)
92     {
93         return adoptRef(*new CubicBezierTimingFunction(Custom, x1, y1, x2, y2));
94     }
95
96     static Ref<CubicBezierTimingFunction> create()
97     {
98         return adoptRef(*new CubicBezierTimingFunction());
99     }
100     
101     static Ref<CubicBezierTimingFunction> create(TimingFunctionPreset preset)
102     {
103         switch (preset) {
104         case Ease:
105             return adoptRef(*new CubicBezierTimingFunction);
106         case EaseIn:
107             return adoptRef(*new CubicBezierTimingFunction(EaseIn, 0.42, 0.0, 1.0, 1.0));
108         case EaseOut:
109             return adoptRef(*new CubicBezierTimingFunction(EaseOut, 0.0, 0.0, 0.58, 1.0));
110         case EaseInOut:
111             return adoptRef(*new CubicBezierTimingFunction(EaseInOut, 0.42, 0.0, 0.58, 1.0));
112         case Custom:
113             break;
114         }
115         ASSERT_NOT_REACHED();
116         return adoptRef(*new CubicBezierTimingFunction);
117     }
118
119     bool operator==(const TimingFunction& other) const final
120     {
121         if (!other.isCubicBezierTimingFunction())
122             return false;
123         auto& otherCubic = static_cast<const CubicBezierTimingFunction&>(other);
124         if (m_timingFunctionPreset != otherCubic.m_timingFunctionPreset)
125             return false;
126         if (m_timingFunctionPreset != Custom)
127             return true;
128         return m_x1 == otherCubic.m_x1 && m_y1 == otherCubic.m_y1 && m_x2 == otherCubic.m_x2 && m_y2 == otherCubic.m_y2;
129     }
130
131     double x1() const { return m_x1; }
132     double y1() const { return m_y1; }
133     double x2() const { return m_x2; }
134     double y2() const { return m_y2; }
135     
136     void setValues(double x1, double y1, double x2, double y2)
137     {
138         m_x1 = x1;
139         m_y1 = y1;
140         m_x2 = x2;
141         m_y2 = y2;
142     }
143
144     TimingFunctionPreset timingFunctionPreset() const { return m_timingFunctionPreset; }
145     void setTimingFunctionPreset(TimingFunctionPreset preset) { m_timingFunctionPreset = preset; }
146
147     static const CubicBezierTimingFunction& defaultTimingFunction()
148     {
149         static const CubicBezierTimingFunction& function = create().leakRef();
150         return function;
151     }
152
153     Ref<CubicBezierTimingFunction> createReversed() const
154     {
155         return create(1.0 - m_x2, 1.0 - m_y2, 1.0 - m_x1, 1.0 - m_y1);
156     }
157
158 private:
159     explicit CubicBezierTimingFunction(TimingFunctionPreset preset = Ease, double x1 = 0.25, double y1 = 0.1, double x2 = 0.25, double y2 = 1.0)
160         : TimingFunction(CubicBezierFunction)
161         , m_x1(x1)
162         , m_y1(y1)
163         , m_x2(x2)
164         , m_y2(y2)
165         , m_timingFunctionPreset(preset)
166     {
167     }
168
169     Ref<TimingFunction> clone() const final
170     {
171         return adoptRef(*new CubicBezierTimingFunction(m_timingFunctionPreset, m_x1, m_y1, m_x2, m_y2));
172     }
173
174     double m_x1;
175     double m_y1;
176     double m_x2;
177     double m_y2;
178     TimingFunctionPreset m_timingFunctionPreset;
179 };
180
181 class StepsTimingFunction final : public TimingFunction {
182 public:
183     static Ref<StepsTimingFunction> create(int steps, bool stepAtStart)
184     {
185         return adoptRef(*new StepsTimingFunction(steps, stepAtStart));
186     }
187     static Ref<StepsTimingFunction> create()
188     {
189         return adoptRef(*new StepsTimingFunction(1, true));
190     }
191     
192     bool operator==(const TimingFunction& other) const final
193     {
194         if (!other.isStepsTimingFunction())
195             return false;
196         auto& otherSteps = static_cast<const StepsTimingFunction&>(other);
197         return m_steps == otherSteps.m_steps && m_stepAtStart == otherSteps.m_stepAtStart;
198     }
199     
200     int numberOfSteps() const { return m_steps; }
201     void setNumberOfSteps(int steps) { m_steps = steps; }
202
203     bool stepAtStart() const { return m_stepAtStart; }
204     void setStepAtStart(bool stepAtStart) { m_stepAtStart = stepAtStart; }
205
206 private:
207     StepsTimingFunction(int steps, bool stepAtStart)
208         : TimingFunction(StepsFunction)
209         , m_steps(steps)
210         , m_stepAtStart(stepAtStart)
211     {
212     }
213
214     Ref<TimingFunction> clone() const final
215     {
216         return adoptRef(*new StepsTimingFunction(m_steps, m_stepAtStart));
217     }
218     
219     int m_steps;
220     bool m_stepAtStart;
221 };
222
223 class SpringTimingFunction final : public TimingFunction {
224 public:
225     static Ref<SpringTimingFunction> create(double mass, double stiffness, double damping, double initialVelocity)
226     {
227         return adoptRef(*new SpringTimingFunction(mass, stiffness, damping, initialVelocity));
228     }
229
230     static Ref<SpringTimingFunction> create()
231     {
232         // This create() function should only be used by the argument decoders, and it is expected that
233         // real values will be filled in using setValues().
234         return create(0, 0, 0, 0);
235     }
236     
237     bool operator==(const TimingFunction& other) const final
238     {
239         if (!other.isSpringTimingFunction())
240             return false;
241         auto& otherSpring = static_cast<const SpringTimingFunction&>(other);
242         return m_mass == otherSpring.m_mass && m_stiffness == otherSpring.m_stiffness && m_damping == otherSpring.m_damping && m_initialVelocity == otherSpring.m_initialVelocity;
243     }
244
245     double mass() const { return m_mass; }
246     double stiffness() const { return m_stiffness; }
247     double damping() const { return m_damping; }
248     double initialVelocity() const { return m_initialVelocity; }
249     
250     void setValues(double mass, double stiffness, double damping, double initialVelocity)
251     {
252         m_mass = mass;
253         m_stiffness = stiffness;
254         m_damping = damping;
255         m_initialVelocity = initialVelocity;
256     }
257
258 private:
259     explicit SpringTimingFunction(double mass, double stiffness, double damping, double initialVelocity)
260         : TimingFunction(SpringFunction)
261         , m_mass(mass)
262         , m_stiffness(stiffness)
263         , m_damping(damping)
264         , m_initialVelocity(initialVelocity)
265     {
266     }
267
268     Ref<TimingFunction> clone() const final
269     {
270         return adoptRef(*new SpringTimingFunction(m_mass, m_stiffness, m_damping, m_initialVelocity));
271     }
272
273     double m_mass;
274     double m_stiffness;
275     double m_damping;
276     double m_initialVelocity;
277 };
278
279 WEBCORE_EXPORT WTF::TextStream& operator<<(WTF::TextStream&, const TimingFunction&);
280
281 } // namespace WebCore