[WTF] Import std::optional reference implementation as WTF::Optional
[WebKit-https.git] / Source / WebCore / platform / graphics / transforms / AffineTransform.h
1 /*
2  * Copyright (C) 2005-2016 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/Optional.h>
34
35 #if USE(CG)
36 typedef struct CGAffineTransform CGAffineTransform;
37 #elif USE(CAIRO)
38 #include <cairo.h>
39 #endif
40
41 #if PLATFORM(WIN)
42 struct D2D_MATRIX_3X2_F;
43 typedef D2D_MATRIX_3X2_F D2D1_MATRIX_3X2_F;
44 #endif
45
46 namespace WebCore {
47
48 class FloatPoint;
49 class FloatQuad;
50 class FloatRect;
51 class FloatSize;
52 class IntPoint;
53 class IntSize;
54 class IntRect;
55 class TextStream;
56 class TransformationMatrix;
57
58 class AffineTransform {
59     WTF_MAKE_FAST_ALLOCATED;
60 public:
61     WEBCORE_EXPORT AffineTransform();
62     WEBCORE_EXPORT AffineTransform(double a, double b, double c, double d, double e, double f);
63
64 #if USE(CG)
65     WEBCORE_EXPORT AffineTransform(const CGAffineTransform&);
66 #endif
67
68 #if PLATFORM(WIN)
69     AffineTransform(const D2D1_MATRIX_3X2_F&);
70 #endif
71
72     void setMatrix(double a, double b, double c, double d, double e, double f);
73
74     void map(double x, double y, double& x2, double& y2) const;
75
76     // Rounds the mapped point to the nearest integer value.
77     WEBCORE_EXPORT IntPoint mapPoint(const IntPoint&) const;
78
79     WEBCORE_EXPORT FloatPoint mapPoint(const FloatPoint&) const;
80
81     WEBCORE_EXPORT IntSize mapSize(const IntSize&) const;
82
83     WEBCORE_EXPORT FloatSize mapSize(const FloatSize&) const;
84
85     // Rounds the resulting mapped rectangle out. This is helpful for bounding
86     // box computations but may not be what is wanted in other contexts.
87     WEBCORE_EXPORT IntRect mapRect(const IntRect&) const;
88
89     WEBCORE_EXPORT FloatRect mapRect(const FloatRect&) const;
90     WEBCORE_EXPORT FloatQuad mapQuad(const FloatQuad&) const;
91
92     WEBCORE_EXPORT bool isIdentity() const;
93
94     double a() const { return m_transform[0]; }
95     void setA(double a) { m_transform[0] = a; }
96     double b() const { return m_transform[1]; }
97     void setB(double b) { m_transform[1] = b; }
98     double c() const { return m_transform[2]; }
99     void setC(double c) { m_transform[2] = c; }
100     double d() const { return m_transform[3]; }
101     void setD(double d) { m_transform[3] = d; }
102     double e() const { return m_transform[4]; }
103     void setE(double e) { m_transform[4] = e; }
104     double f() const { return m_transform[5]; }
105     void setF(double f) { m_transform[5] = f; }
106
107     WEBCORE_EXPORT void makeIdentity();
108
109     WEBCORE_EXPORT AffineTransform& multiply(const AffineTransform& other);
110     WEBCORE_EXPORT AffineTransform& scale(double);
111     AffineTransform& scale(double sx, double sy); 
112     WEBCORE_EXPORT AffineTransform& scaleNonUniform(double sx, double sy);
113     WEBCORE_EXPORT AffineTransform& scale(const FloatSize&);
114     WEBCORE_EXPORT AffineTransform& rotate(double);
115     AffineTransform& rotateFromVector(double x, double y);
116     WEBCORE_EXPORT AffineTransform& translate(double tx, double ty);
117     WEBCORE_EXPORT AffineTransform& translate(const FloatPoint&);
118     WEBCORE_EXPORT AffineTransform& shear(double sx, double sy);
119     WEBCORE_EXPORT AffineTransform& flipX();
120     WEBCORE_EXPORT AffineTransform& flipY();
121     WEBCORE_EXPORT AffineTransform& skew(double angleX, double angleY);
122     AffineTransform& skewX(double angle);
123     AffineTransform& skewY(double angle);
124
125     // These functions get the length of an axis-aligned unit vector
126     // once it has been mapped through the transform
127     WEBCORE_EXPORT double xScale() const;
128     WEBCORE_EXPORT double yScale() const;
129
130     bool isInvertible() const; // If you call this this, you're probably doing it wrong.
131     WEBCORE_EXPORT std::optional<AffineTransform> inverse() const;
132
133     WEBCORE_EXPORT void blend(const AffineTransform& from, double progress);
134
135     WEBCORE_EXPORT TransformationMatrix toTransformationMatrix() const;
136
137     bool isIdentityOrTranslation() const
138     {
139         return m_transform[0] == 1 && m_transform[1] == 0 && m_transform[2] == 0 && m_transform[3] == 1;
140     }
141     
142     bool isIdentityOrTranslationOrFlipped() const
143     {
144         return m_transform[0] == 1 && m_transform[1] == 0 && m_transform[2] == 0 && (m_transform[3] == 1 || m_transform[3] == -1);
145     }
146
147     bool preservesAxisAlignment() const
148     {
149         return (m_transform[1] == 0 && m_transform[2] == 0) || (m_transform[0] == 0 && m_transform[3] == 0);
150     }
151
152     bool operator== (const AffineTransform& m2) const
153     {
154         return (m_transform[0] == m2.m_transform[0]
155              && m_transform[1] == m2.m_transform[1]
156              && m_transform[2] == m2.m_transform[2]
157              && m_transform[3] == m2.m_transform[3]
158              && m_transform[4] == m2.m_transform[4]
159              && m_transform[5] == m2.m_transform[5]);
160     }
161
162     bool operator!=(const AffineTransform& other) const { return !(*this == other); }
163
164     // *this = *this * t (i.e., a multRight)
165     AffineTransform& operator*=(const AffineTransform& t)
166     {
167         return multiply(t);
168     }
169     
170     // result = *this * t (i.e., a multRight)
171     AffineTransform operator*(const AffineTransform& t) const
172     {
173         AffineTransform result = *this;
174         result *= t;
175         return result;
176     }
177
178 #if USE(CG)
179     WEBCORE_EXPORT operator CGAffineTransform() const;
180 #elif USE(CAIRO)
181     operator cairo_matrix_t() const;
182 #endif
183
184 #if PLATFORM(WIN)
185     operator D2D1_MATRIX_3X2_F() const;
186 #endif
187
188     static AffineTransform translation(double x, double y)
189     {
190         return AffineTransform(1, 0, 0, 1, x, y);
191     }
192
193     // decompose the matrix into its component parts
194     typedef struct {
195         double scaleX, scaleY;
196         double angle;
197         double remainderA, remainderB, remainderC, remainderD;
198         double translateX, translateY;
199     } DecomposedType;
200     
201     bool decompose(DecomposedType&) const;
202     void recompose(const DecomposedType&);
203
204 private:
205     std::array<double, 6> m_transform;
206 };
207
208 WEBCORE_EXPORT AffineTransform makeMapBetweenRects(const FloatRect& source, const FloatRect& dest);
209
210 WEBCORE_EXPORT TextStream& operator<<(TextStream&, const AffineTransform&);
211
212 }
213
214 #endif