2010-09-08 Dean Jackson <dino@apple.com>
[WebKit-https.git] / 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/RefCounted.h>
29
30 namespace WebCore {
31
32 class TimingFunction : public RefCounted<TimingFunction> {
33 public:
34
35     enum TimingFunctionType {
36         LinearFunction, CubicBezierFunction, StepsFunction
37     };
38     
39     virtual ~TimingFunction() { }
40     
41     bool isLinearTimingFunction() const { return m_type == LinearFunction; }
42     bool isCubicBezierTimingFunction() const { return m_type == CubicBezierFunction; }
43     bool isStepsTimingFunction() const { return m_type == StepsFunction; }
44     
45     virtual bool operator==(const TimingFunction& other) = 0;
46
47 protected:
48     TimingFunction(TimingFunctionType type)
49         : m_type(type)
50     {
51     }
52     
53     TimingFunctionType m_type;
54 };
55
56 class LinearTimingFunction : public TimingFunction {
57 public:
58     static PassRefPtr<LinearTimingFunction> create()
59     {
60         return adoptRef(new LinearTimingFunction);
61     }
62     
63     ~LinearTimingFunction() { }
64     
65     virtual bool operator==(const TimingFunction& other)
66     {
67         return other.isLinearTimingFunction();
68     }
69     
70 private:
71     LinearTimingFunction()
72         : TimingFunction(LinearFunction)
73     {
74     }
75 };
76     
77 class CubicBezierTimingFunction : public TimingFunction {
78 public:
79     static PassRefPtr<CubicBezierTimingFunction> create(double x1 = 0.25, double y1 = 0.1, double x2 = 0.25, double y2 = 1.0)
80     {
81         return adoptRef(new CubicBezierTimingFunction(x1, y1, x2, y2));
82     }
83
84     ~CubicBezierTimingFunction() { }
85     
86     virtual bool operator==(const TimingFunction& other)
87     {
88         if (other.isCubicBezierTimingFunction()) {
89             const CubicBezierTimingFunction* ctf = static_cast<const CubicBezierTimingFunction*>(&other);
90             return m_x1 == ctf->m_x1 && m_y1 == ctf->m_y1 && m_x2 == ctf->m_x2 && m_y2 == ctf->m_y2;
91         }
92         return false;
93     }
94
95     double x1() const { return m_x1; }
96     double y1() const { return m_y1; }
97     double x2() const { return m_x2; }
98     double y2() const { return m_y2; }
99     
100 private:
101     CubicBezierTimingFunction(double x1, double y1, double x2, double y2)
102         : TimingFunction(CubicBezierFunction)
103         , m_x1(x1)
104         , m_y1(y1)
105         , m_x2(x2)
106         , m_y2(y2)
107     {
108     }
109
110     double m_x1;
111     double m_y1;
112     double m_x2;
113     double m_y2;
114 };
115
116 class StepsTimingFunction : public TimingFunction {
117 public:
118     static PassRefPtr<StepsTimingFunction> create(int steps, bool stepAtStart)
119     {
120         return adoptRef(new StepsTimingFunction(steps, stepAtStart));
121     }
122     
123     ~StepsTimingFunction() { }
124     
125     virtual bool operator==(const TimingFunction& other)
126     {
127         if (other.isStepsTimingFunction()) {
128             const StepsTimingFunction* stf = static_cast<const StepsTimingFunction*>(&other);
129             return m_steps == stf->m_steps && m_stepAtStart == stf->m_stepAtStart;
130         }
131         return false;
132     }
133     
134     int numberOfSteps() const { return m_steps; }
135     bool stepAtStart() const { return m_stepAtStart; }
136     
137 private:
138     StepsTimingFunction(int steps, bool stepAtStart)
139         : TimingFunction(StepsFunction)
140         , m_steps(steps)
141         , m_stepAtStart(stepAtStart)
142     {
143     }
144     
145     int m_steps;
146     bool m_stepAtStart;
147 };
148     
149 } // namespace WebCore
150
151 #endif // TimingFunction_h