Host GraphicsContext's CTM inside GraphicsContextState
[WebKit-https.git] / Source / WebCore / platform / graphics / transforms / AffineTransform.h
1 /*
2  * Copyright (C) 2005, 2006 Apple Inc.  All rights reserved.
3  *               2010 Dirk Schulze <krit@webkit.org>
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #ifndef AffineTransform_h
28 #define AffineTransform_h
29
30 #include "PlatformExportMacros.h"
31 #include <array>
32 #include <wtf/FastMalloc.h>
33 #include <wtf/MathExtras.h>
34
35 #if USE(CG)
36 typedef struct CGAffineTransform CGAffineTransform;
37 #elif USE(CAIRO)
38 #include <cairo.h>
39 #endif
40
41 namespace WebCore {
42
43 class FloatPoint;
44 class FloatQuad;
45 class FloatRect;
46 class FloatSize;
47 class IntPoint;
48 class IntSize;
49 class IntRect;
50 class TextStream;
51 class TransformationMatrix;
52
53 class AffineTransform {
54     WTF_MAKE_FAST_ALLOCATED;
55 public:
56     WEBCORE_EXPORT AffineTransform();
57     WEBCORE_EXPORT AffineTransform(double a, double b, double c, double d, double e, double f);
58
59 #if USE(CG)
60     AffineTransform(const CGAffineTransform&);
61 #endif
62
63     void setMatrix(double a, double b, double c, double d, double e, double f);
64
65     void map(double x, double y, double& x2, double& y2) const;
66
67     // Rounds the mapped point to the nearest integer value.
68     WEBCORE_EXPORT IntPoint mapPoint(const IntPoint&) const;
69
70     WEBCORE_EXPORT FloatPoint mapPoint(const FloatPoint&) const;
71
72     IntSize mapSize(const IntSize&) const;
73
74     FloatSize mapSize(const FloatSize&) const;
75
76     // Rounds the resulting mapped rectangle out. This is helpful for bounding
77     // box computations but may not be what is wanted in other contexts.
78     IntRect mapRect(const IntRect&) const;
79
80     WEBCORE_EXPORT FloatRect mapRect(const FloatRect&) const;
81     FloatQuad mapQuad(const FloatQuad&) const;
82
83     WEBCORE_EXPORT bool isIdentity() const;
84
85     double a() const { return m_transform[0]; }
86     void setA(double a) { m_transform[0] = a; }
87     double b() const { return m_transform[1]; }
88     void setB(double b) { m_transform[1] = b; }
89     double c() const { return m_transform[2]; }
90     void setC(double c) { m_transform[2] = c; }
91     double d() const { return m_transform[3]; }
92     void setD(double d) { m_transform[3] = d; }
93     double e() const { return m_transform[4]; }
94     void setE(double e) { m_transform[4] = e; }
95     double f() const { return m_transform[5]; }
96     void setF(double f) { m_transform[5] = f; }
97
98     void makeIdentity();
99
100     WEBCORE_EXPORT AffineTransform& multiply(const AffineTransform& other);
101     WEBCORE_EXPORT AffineTransform& scale(double);
102     AffineTransform& scale(double sx, double sy); 
103     AffineTransform& scaleNonUniform(double sx, double sy);
104     AffineTransform& scale(const FloatSize&);
105     AffineTransform& rotate(double d);
106     AffineTransform& rotateFromVector(double x, double y);
107     WEBCORE_EXPORT AffineTransform& translate(double tx, double ty);
108     AffineTransform& translate(const FloatPoint&);
109     AffineTransform& shear(double sx, double sy);
110     AffineTransform& flipX();
111     WEBCORE_EXPORT AffineTransform& flipY();
112     AffineTransform& skew(double angleX, double angleY);
113     AffineTransform& skewX(double angle);
114     AffineTransform& skewY(double angle);
115
116     // These functions get the length of an axis-aligned unit vector
117     // once it has been mapped through the transform
118     WEBCORE_EXPORT double xScale() const;
119     WEBCORE_EXPORT double yScale() const;
120
121     double det() const;
122     WEBCORE_EXPORT bool isInvertible() const;
123     WEBCORE_EXPORT AffineTransform inverse() const;
124
125     void blend(const AffineTransform& from, double progress);
126
127     TransformationMatrix toTransformationMatrix() const;
128
129     bool isIdentityOrTranslation() const
130     {
131         return m_transform[0] == 1 && m_transform[1] == 0 && m_transform[2] == 0 && m_transform[3] == 1;
132     }
133     
134     bool isIdentityOrTranslationOrFlipped() const
135     {
136         return m_transform[0] == 1 && m_transform[1] == 0 && m_transform[2] == 0 && (m_transform[3] == 1 || m_transform[3] == -1);
137     }
138
139     bool preservesAxisAlignment() const
140     {
141         return (m_transform[1] == 0 && m_transform[2] == 0) || (m_transform[0] == 0 && m_transform[3] == 0);
142     }
143
144     // FIXME: If you compare floats for equality, you're gonna have a bad time. We should delete this.
145     bool operator== (const AffineTransform& m2) const
146     {
147         return (m_transform[0] == m2.m_transform[0]
148              && m_transform[1] == m2.m_transform[1]
149              && m_transform[2] == m2.m_transform[2]
150              && m_transform[3] == m2.m_transform[3]
151              && m_transform[4] == m2.m_transform[4]
152              && m_transform[5] == m2.m_transform[5]);
153     }
154
155     bool operator!=(const AffineTransform& other) const { return !(*this == other); }
156
157     bool isEssentiallyEqualTo(const AffineTransform& m2, double epsilon = 0.0001) const
158     {
159         // WTF::areEssentiallyEqual() doesn't work well in this case. That function is designed to allow for error
160         // which scales proportionately to the values. However, AffineTransforms are often rotated by pi/2, which
161         // are not exactly representable. This results in AffineTransform components which are close to, but not
162         // exactly equal to, zero. In this case, the error and the value are approximately equal, which leads to
163         // a false negative return.
164         return std::abs(m_transform[0] - m2.m_transform[0]) < epsilon
165             && std::abs(m_transform[1] - m2.m_transform[1]) < epsilon
166             && std::abs(m_transform[2] - m2.m_transform[2]) < epsilon
167             && std::abs(m_transform[3] - m2.m_transform[3]) < epsilon
168             && std::abs(m_transform[4] - m2.m_transform[4]) < epsilon
169             && std::abs(m_transform[5] - m2.m_transform[5]) < epsilon;
170     }
171
172     // *this = *this * t (i.e., a multRight)
173     AffineTransform& operator*=(const AffineTransform& t)
174     {
175         return multiply(t);
176     }
177     
178     // result = *this * t (i.e., a multRight)
179     AffineTransform operator*(const AffineTransform& t) const
180     {
181         AffineTransform result = *this;
182         result *= t;
183         return result;
184     }
185
186 #if USE(CG)
187     operator CGAffineTransform() const;
188 #elif USE(CAIRO)
189     operator cairo_matrix_t() const;
190 #endif
191
192     static AffineTransform translation(double x, double y)
193     {
194         return AffineTransform(1, 0, 0, 1, x, y);
195     }
196
197     // decompose the matrix into its component parts
198     typedef struct {
199         double scaleX, scaleY;
200         double angle;
201         double remainderA, remainderB, remainderC, remainderD;
202         double translateX, translateY;
203     } DecomposedType;
204     
205     bool decompose(DecomposedType&) const;
206     void recompose(const DecomposedType&);
207
208 private:
209     std::array<double, 6> m_transform;
210 };
211
212 AffineTransform makeMapBetweenRects(const FloatRect& source, const FloatRect& dest);
213
214 WEBCORE_EXPORT TextStream& operator<<(TextStream&, const AffineTransform&);
215
216 }
217
218 #endif