← Back to branch summary

~ubuntu-branches/ubuntu/maverick/webkit/maverick

« back to all changes in this revision

Viewing changes to WebCore/platform/graphics/cairo/AffineTransformCairo.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Mike Hommey
  • Date: 2007-08-19 15:54:12 UTC
  • Revision ID: james.westby@ubuntu.com-20070819155412-uxxg1h9plpghmtbi
Tags: upstream-0~svn25144
Import upstream version 0~svn25144

Show diffs side-by-side

added added

removed removed

Lines of Context:
WebCore/platform/graphics/cairo/AffineTransformCairo.cpp
 
1
/*
 
2
 *
 
3
 * Redistribution and use in source and binary forms, with or without
 
4
 * modification, are permitted provided that the following conditions
 
5
 * are met:
 
6
 * 1. Redistributions of source code must retain the above copyright
 
7
 *    notice, this list of conditions and the following disclaimer.
 
8
 * 2. Redistributions in binary form must reproduce the above copyright
 
9
 *    notice, this list of conditions and the following disclaimer in the
 
10
 *    documentation and/or other materials provided with the distribution.
 
11
 *
 
12
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 
13
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
14
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
15
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 
16
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 
17
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
18
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 
19
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 
20
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
21
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
22
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 
23
 */
 
24
 
 
25
#include "config.h"
 
26
#include "AffineTransform.h"
 
27
 
 
28
#include "IntRect.h"
 
29
#include "FloatRect.h"
 
30
 
 
31
#include "cairo.h"
 
32
 
 
33
namespace WebCore {
 
34
 
 
35
static const double deg2rad = 0.017453292519943295769; // pi/180
 
36
 
 
37
AffineTransform::AffineTransform()
 
38
{
 
39
    cairo_matrix_init_identity(&m_transform);
 
40
}
 
41
 
 
42
AffineTransform::AffineTransform(double a, double b, double c, double d, double tx, double ty)
 
43
{
 
44
    cairo_matrix_init(&m_transform, a, c, b, d, tx, ty);
 
45
}
 
46
 
 
47
AffineTransform::AffineTransform(const cairo_matrix_t &matrix)
 
48
{
 
49
    m_transform = matrix;
 
50
}
 
51
 
 
52
void AffineTransform::setMatrix(double a, double b, double c, double d, double tx, double ty)
 
53
{
 
54
    cairo_matrix_init(&m_transform, a, c, b, d, tx, ty);
 
55
}
 
56
 
 
57
void AffineTransform::map(double x, double y, double* x2, double* y2) const
 
58
{
 
59
    *x2 = x;
 
60
    *y2 = y;
 
61
    cairo_matrix_transform_point(&m_transform, x2, y2);
 
62
}
 
63
 
 
64
IntRect AffineTransform::mapRect(const IntRect &rect) const
 
65
{
 
66
    FloatRect floatRect(rect);
 
67
    FloatRect enclosingFloatRect = this->mapRect(floatRect);
 
68
 
 
69
    return enclosingIntRect(enclosingFloatRect);
 
70
}
 
71
 
 
72
FloatRect AffineTransform::mapRect(const FloatRect &rect) const
 
73
{
 
74
    double rectMinX = rect.x();
 
75
    double rectMaxX = rect.x() + rect.width();
 
76
    double rectMinY = rect.y();
 
77
    double rectMaxY = rect.y() + rect.height();
 
78
 
 
79
    double px = rectMinX;
 
80
    double py = rectMinY;
 
81
    cairo_matrix_transform_point(&m_transform, &px, &py);
 
82
    
 
83
    double enclosingRectMinX = px;
 
84
    double enclosingRectMinY = py;
 
85
    double enclosingRectMaxX = px;
 
86
    double enclosingRectMaxY = py;
 
87
    
 
88
    px = rectMaxX;
 
89
    py = rectMinY;
 
90
    cairo_matrix_transform_point(&m_transform, &px, &py);
 
91
    if (px < enclosingRectMinX) 
 
92
        enclosingRectMinX = px;
 
93
    else if (px > enclosingRectMaxX) 
 
94
        enclosingRectMaxX = px;
 
95
    if (py < enclosingRectMinY) 
 
96
        enclosingRectMinY = py;
 
97
    else if (py > enclosingRectMaxY) 
 
98
        enclosingRectMaxY = py;
 
99
 
 
100
    px = rectMaxX;
 
101
    py = rectMaxY;
 
102
    cairo_matrix_transform_point(&m_transform, &px, &py);
 
103
    if (px < enclosingRectMinX) 
 
104
        enclosingRectMinX = px;
 
105
    else if (px > enclosingRectMaxX)
 
106
        enclosingRectMaxX = px;
 
107
    if (py < enclosingRectMinY) 
 
108
        enclosingRectMinY = py;
 
109
    else if (py > enclosingRectMaxY) 
 
110
        enclosingRectMaxY = py;
 
111
 
 
112
    px = rectMinX;
 
113
    py = rectMaxY;
 
114
    cairo_matrix_transform_point(&m_transform, &px, &py);
 
115
    if (px < enclosingRectMinX) 
 
116
        enclosingRectMinX = px;
 
117
    else if (px > enclosingRectMaxX) 
 
118
        enclosingRectMaxX = px;
 
119
    if (py < enclosingRectMinY) 
 
120
        enclosingRectMinY = py;
 
121
    else if (py > enclosingRectMaxY) 
 
122
        enclosingRectMaxY = py;
 
123
 
 
124
 
 
125
    double enclosingRectWidth = enclosingRectMaxX - enclosingRectMinX;
 
126
    double enclosingRectHeight = enclosingRectMaxY - enclosingRectMinY;
 
127
 
 
128
    return FloatRect(enclosingRectMinX, enclosingRectMinY, enclosingRectWidth, enclosingRectHeight);
 
129
}
 
130
 
 
131
bool AffineTransform::isIdentity() const
 
132
{
 
133
    return ((m_transform.xx == 1) && (m_transform.yy == 1) 
 
134
         && (m_transform.xy == 0) && (m_transform.yx == 0) 
 
135
         && (m_transform.x0 == 0) && (m_transform.y0 == 0));
 
136
}
 
137
 
 
138
double AffineTransform::a() const
 
139
{
 
140
    return m_transform.xx;
 
141
}
 
142
 
 
143
void AffineTransform::setA(double a)
 
144
{
 
145
    m_transform.xx = a;
 
146
}
 
147
 
 
148
double AffineTransform::b() const
 
149
{
 
150
    return m_transform.xy;
 
151
}
 
152
 
 
153
void AffineTransform::setB(double b)
 
154
{
 
155
    m_transform.xy = b;
 
156
}
 
157
 
 
158
double AffineTransform::c() const
 
159
{
 
160
    return m_transform.yx;
 
161
}
 
162
 
 
163
void AffineTransform::setC(double c)
 
164
{
 
165
    m_transform.yx = c;
 
166
}
 
167
 
 
168
double AffineTransform::d() const
 
169
{
 
170
    return m_transform.yy;
 
171
}
 
172
 
 
173
void AffineTransform::setD(double d)
 
174
{
 
175
    m_transform.yy = d;
 
176
}
 
177
 
 
178
double AffineTransform::e() const
 
179
{
 
180
    return m_transform.x0;
 
181
}
 
182
 
 
183
void AffineTransform::setE(double e)
 
184
{
 
185
    m_transform.x0 = e;
 
186
}
 
187
 
 
188
double AffineTransform::f() const
 
189
{
 
190
    return m_transform.y0;
 
191
}
 
192
 
 
193
void AffineTransform::setF(double f)
 
194
{
 
195
    m_transform.y0 = f;
 
196
}
 
197
 
 
198
void AffineTransform::reset()
 
199
{
 
200
    cairo_matrix_init_identity(&m_transform);
 
201
}
 
202
 
 
203
AffineTransform &AffineTransform::scale(double sx, double sy)
 
204
{
 
205
    cairo_matrix_scale(&m_transform, sx, sy);
 
206
    return *this;
 
207
}
 
208
 
 
209
AffineTransform &AffineTransform::rotate(double d)
 
210
{
 
211
    cairo_matrix_rotate(&m_transform, d * deg2rad);
 
212
    return *this;
 
213
}
 
214
 
 
215
AffineTransform &AffineTransform::translate(double tx, double ty)
 
216
{
 
217
    cairo_matrix_translate(&m_transform, tx, ty);
 
218
    return *this;
 
219
}
 
220
 
 
221
AffineTransform &AffineTransform::shear(double sx, double sy)
 
222
{
 
223
    cairo_matrix_t shear;
 
224
    cairo_matrix_init(&shear, 1, sx, sy, 1, 0, 0);
 
225
 
 
226
    cairo_matrix_t result;
 
227
    cairo_matrix_multiply(&result, &shear, &m_transform);
 
228
    m_transform = result;
 
229
 
 
230
    return *this;
 
231
}
 
232
 
 
233
double AffineTransform::det() const
 
234
{
 
235
    return m_transform.xx * m_transform.yy - m_transform.xy * m_transform.yx;
 
236
}
 
237
 
 
238
AffineTransform AffineTransform::inverse() const
 
239
{
 
240
    if (!isInvertible()) return AffineTransform();
 
241
 
 
242
    cairo_matrix_t result = m_transform;
 
243
    cairo_matrix_invert(&result);
 
244
    return AffineTransform(result);
 
245
}
 
246
 
 
247
AffineTransform::operator cairo_matrix_t() const
 
248
{
 
249
    return m_transform;
 
250
}
 
251
 
 
252
bool AffineTransform::operator== (const AffineTransform &m2) const
 
253
{
 
254
    return ((m_transform.xx == m2.m_transform.xx) 
 
255
         && (m_transform.yy == m2.m_transform.yy) 
 
256
         && (m_transform.xy == m2.m_transform.xy)
 
257
         && (m_transform.yx == m2.m_transform.yx) 
 
258
         && (m_transform.x0 == m2.m_transform.x0)
 
259
         && (m_transform.y0 == m2.m_transform.y0));
 
260
 
 
261
}
 
262
 
 
263
AffineTransform &AffineTransform::operator*= (const AffineTransform &m2)
 
264
{
 
265
    cairo_matrix_t result;
 
266
    cairo_matrix_multiply(&result, &m_transform, &m2.m_transform);
 
267
    m_transform = result;
 
268
 
 
269
    return *this;
 
270
}
 
271
 
 
272
AffineTransform AffineTransform::operator* (const AffineTransform &m2)
 
273
{
 
274
    cairo_matrix_t result;
 
275
    cairo_matrix_multiply(&result, &m_transform, &m2.m_transform);
 
276
    return result;
 
277
}
 
278
 
 
279
}
 
280
 
 
281
// vim: ts=4 sw=4 et