9b3181a6f52b34afe9fd1bddd6622815c5481ac3
[WebKit-https.git] / WebCore / platform / graphics / cg / TransformationMatrixCG.cpp
1 /*
2  * Copyright (C) 2005, 2006, 2007 Apple Inc.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "TransformationMatrix.h"
28
29 #if PLATFORM(CG)
30
31 #include "FloatConversion.h"
32 #include "FloatRect.h"
33 #include "IntRect.h"
34
35 #include <wtf/MathExtras.h>
36
37 namespace WebCore {
38
39 TransformationMatrix::TransformationMatrix()
40     : m_transform(CGAffineTransformIdentity)
41 {
42 }
43
44 TransformationMatrix::TransformationMatrix(double a, double b, double c, double d, double tx, double ty)
45 {
46     m_transform = CGAffineTransformMake(narrowPrecisionToCGFloat(a),
47                                         narrowPrecisionToCGFloat(b),
48                                         narrowPrecisionToCGFloat(c),
49                                         narrowPrecisionToCGFloat(d),
50                                         narrowPrecisionToCGFloat(tx),
51                                         narrowPrecisionToCGFloat(ty));
52 }
53
54 TransformationMatrix::TransformationMatrix(const PlatformTransformationMatrix& t)
55     : m_transform(t)
56 {
57 }
58
59 void TransformationMatrix::setMatrix(double a, double b, double c, double d, double tx, double ty)
60 {
61     m_transform = CGAffineTransformMake(narrowPrecisionToCGFloat(a),
62                                         narrowPrecisionToCGFloat(b),
63                                         narrowPrecisionToCGFloat(c),
64                                         narrowPrecisionToCGFloat(d),
65                                         narrowPrecisionToCGFloat(tx),
66                                         narrowPrecisionToCGFloat(ty));
67 }
68
69 void TransformationMatrix::map(double x, double y, double *x2, double *y2) const
70 {
71     CGPoint result = CGPointApplyAffineTransform(CGPointMake(narrowPrecisionToCGFloat(x), narrowPrecisionToCGFloat(y)), m_transform);
72     *x2 = result.x;
73     *y2 = result.y;
74 }
75
76 IntRect TransformationMatrix::mapRect(const IntRect &rect) const
77 {
78     return enclosingIntRect(CGRectApplyAffineTransform(CGRect(rect), m_transform));
79 }
80
81 FloatRect TransformationMatrix::mapRect(const FloatRect &rect) const
82 {
83     return FloatRect(CGRectApplyAffineTransform(CGRect(rect), m_transform));
84 }
85
86 bool TransformationMatrix::isIdentity() const
87 {
88     return CGAffineTransformIsIdentity(m_transform);
89 }
90
91 double TransformationMatrix::a() const
92 {
93     return m_transform.a;
94 }
95
96 void TransformationMatrix::setA(double a)
97 {
98     m_transform.a = narrowPrecisionToCGFloat(a);
99 }
100
101 double TransformationMatrix::b() const
102 {
103     return m_transform.b;
104 }
105
106 void TransformationMatrix::setB(double b)
107 {
108     m_transform.b = narrowPrecisionToCGFloat(b);
109 }
110
111 double TransformationMatrix::c() const
112 {
113     return m_transform.c;
114 }
115
116 void TransformationMatrix::setC(double c)
117 {
118     m_transform.c = narrowPrecisionToCGFloat(c);
119 }
120
121 double TransformationMatrix::d() const
122 {
123     return m_transform.d;
124 }
125
126 void TransformationMatrix::setD(double d)
127 {
128     m_transform.d = narrowPrecisionToCGFloat(d);
129 }
130
131 double TransformationMatrix::e() const
132 {
133     return m_transform.tx;
134 }
135
136 void TransformationMatrix::setE(double e)
137 {
138     m_transform.tx = narrowPrecisionToCGFloat(e);
139 }
140
141 double TransformationMatrix::f() const
142 {
143     return m_transform.ty;
144 }
145
146 void TransformationMatrix::setF(double f)
147 {
148     m_transform.ty = narrowPrecisionToCGFloat(f);
149 }
150
151 void TransformationMatrix::reset()
152 {
153     m_transform = CGAffineTransformIdentity;
154 }
155
156 TransformationMatrix &TransformationMatrix::scale(double sx, double sy)
157 {
158     m_transform = CGAffineTransformScale(m_transform, narrowPrecisionToCGFloat(sx), narrowPrecisionToCGFloat(sy));
159     return *this;
160 }
161
162 TransformationMatrix &TransformationMatrix::rotate(double d)
163 {
164     m_transform = CGAffineTransformRotate(m_transform, narrowPrecisionToCGFloat(deg2rad(d)));
165     return *this;
166 }
167
168 TransformationMatrix &TransformationMatrix::translate(double tx, double ty)
169 {
170     m_transform = CGAffineTransformTranslate(m_transform, narrowPrecisionToCGFloat(tx), narrowPrecisionToCGFloat(ty));
171     return *this;
172 }
173
174 TransformationMatrix &TransformationMatrix::shear(double sx, double sy)
175 {
176     CGAffineTransform shear = CGAffineTransformMake(1.0f, narrowPrecisionToCGFloat(sy), narrowPrecisionToCGFloat(sx), 1.0f, 0.0f, 0.0f);
177     m_transform = CGAffineTransformConcat(shear, m_transform);
178     return *this;
179 }
180
181 double TransformationMatrix::det() const
182 {
183     return m_transform.a * m_transform.d - m_transform.b * m_transform.c;
184 }
185
186 TransformationMatrix TransformationMatrix::inverse() const
187 {
188     if (isInvertible())
189         return TransformationMatrix(CGAffineTransformInvert(m_transform));
190     return TransformationMatrix();
191 }
192
193 TransformationMatrix::operator PlatformTransformationMatrix() const
194 {
195     return m_transform;
196 }
197
198 bool TransformationMatrix::operator== (const TransformationMatrix &m2) const
199 {
200     return CGAffineTransformEqualToTransform(m_transform, CGAffineTransform(m2));
201 }
202
203 TransformationMatrix &TransformationMatrix::operator*= (const TransformationMatrix &m2)
204 {
205     m_transform = CGAffineTransformConcat(m_transform, CGAffineTransform(m2));
206     return *this;
207 }
208
209 TransformationMatrix TransformationMatrix::operator* (const TransformationMatrix &m2)
210 {
211     return CGAffineTransformConcat(m_transform, CGAffineTransform(m2));
212 }
213
214 }
215
216 #endif // PLATFORM(CG)