[wx] Enable wxWebKit to run using the wxGC Cairo backend on platforms other than...
[WebKit-https.git] / Source / WebCore / platform / graphics / wx / PathWx.cpp
1 /*
2  * Copyright (C) 2007 Kevin Ollivier  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 "Path.h"
28
29 #include "AffineTransform.h"
30 #include "FloatPoint.h"
31 #include "FloatRect.h"
32 #include "NotImplemented.h"
33 #include "PlatformString.h"
34 #include "StrokeStyleApplier.h" 
35
36 #include <stdio.h>
37
38 #include <wx/defs.h>
39 #include <wx/graphics.h>
40
41 namespace WebCore {
42
43 int getWxWindRuleForWindRule(WindRule rule)
44 {
45      if (rule == RULE_EVENODD)
46         return wxODDEVEN_RULE;
47
48     return wxWINDING_RULE;
49 }
50
51 Path::Path() 
52
53     m_path = 0;
54     // NB: This only supports the 'default' renderer as determined by wx on
55     // each platform. If an app uses a non-default renderer (e.g. Cairo on Win),  
56     // there will be problems, but there's no way we can determine which 
57     // renderer an app is using right now with wx API, so we will just handle
58     // the common case.
59 #if USE(WXGC)
60     wxGraphicsRenderer* renderer = 0;
61 #if wxUSE_CAIRO
62     renderer = wxGraphicsRenderer::GetCairoRenderer();
63 #else
64     renderer = wxGraphicsRenderer::GetDefaultRenderer();
65 #endif
66     if (renderer) {
67         wxGraphicsPath path = renderer->CreatePath();
68         m_path = new wxGraphicsPath(path);
69     }
70 #endif
71 }
72
73 Path::~Path()
74 {
75     clear();
76 }
77
78 Path::Path(const Path& path)
79
80     m_path = new wxGraphicsPath(*path.m_path);
81 }
82
83 bool Path::contains(const FloatPoint& point, const WindRule rule) const
84 {
85 #if USE(WXGC)
86     if (m_path) {
87 #if wxCHECK_VERSION(2,9,0)
88         return m_path->Contains(point.x(), point.y(), static_cast<wxPolygonFillMode>(getWxWindRuleForWindRule(rule)));
89 #else
90         return m_path->Contains(point.x(), point.y(), getWxWindRuleForWindRule(rule));
91 #endif
92     }
93 #endif
94     return false; 
95 }
96
97 void Path::translate(const FloatSize&)
98
99     notImplemented();
100 }
101
102 FloatRect Path::boundingRect() const 
103
104 #if USE(WXGC)
105     if (m_path) {
106         return m_path->GetBox();     
107     }
108 #endif
109
110     return FloatRect();
111 }
112
113 FloatRect Path::strokeBoundingRect(StrokeStyleApplier* applier) const
114 {
115     notImplemented();
116     return FloatRect();
117 }
118
119 bool Path::strokeContains(StrokeStyleApplier*, const FloatPoint&) const
120 {
121     notImplemented();
122     return false;
123 }
124
125 Path& Path::operator=(const Path& path)
126
127     *m_path = *path.platformPath();
128     return *this; 
129 }
130
131 void Path::clear() 
132
133     if (m_path)
134         delete m_path;
135
136 #if USE(WXGC)
137 #if wxUSE_CAIRO
138     wxGraphicsRenderer* renderer = wxGraphicsRenderer::GetCairoRenderer();
139 #else
140     wxGraphicsRenderer* renderer = wxGraphicsRenderer::GetDefaultRenderer();
141 #endif
142     if (renderer) {
143         wxGraphicsPath path = renderer->CreatePath();
144         m_path = new wxGraphicsPath(path);
145     }
146 #endif
147 }
148
149 void Path::moveTo(const FloatPoint& point) 
150 {
151 #if USE(WXGC)
152     if (m_path)
153         m_path->MoveToPoint(point.x(), point.y());
154 #endif
155 }
156
157 void Path::addLineTo(const FloatPoint& point) 
158 {
159 #if USE(WXGC)
160     if (m_path)
161         m_path->AddLineToPoint(point.x(), point.y());
162 #endif
163 }
164
165 void Path::addQuadCurveTo(const FloatPoint& control, const FloatPoint& end) 
166 {
167 #if USE(WXGC)
168     if (m_path)
169         m_path->AddQuadCurveToPoint(control.x(), control.y(), end.x(), end.y());
170 #endif
171 }
172
173 void Path::addBezierCurveTo(const FloatPoint& control1, const FloatPoint& control2, const FloatPoint& end) 
174 {
175 #if USE(WXGC)
176     if (m_path)
177         m_path->AddCurveToPoint(control1.x(), control1.y(), control2.x(), control2.y(), end.x(), end.y());
178 #endif
179 }
180
181 void Path::addArcTo(const FloatPoint& point1, const FloatPoint& point2, float radius) 
182 {
183 #if USE(WXGC)
184     if (m_path)
185         m_path->AddArcToPoint(point1.x(), point1.y(), point2.x(), point2.y(), radius);
186 #endif
187 }
188
189 void Path::closeSubpath() 
190 {
191 #if USE(WXGC)
192     if (m_path)
193         m_path->CloseSubpath();
194 #endif
195 }
196
197 void Path::addArc(const FloatPoint& point, float radius, float startAngle, float endAngle, bool clockwise) 
198 {
199 #if USE(WXGC)
200     if (m_path)
201         m_path->AddArc(point.x(), point.y(), radius, startAngle, endAngle, clockwise);
202 #endif
203 }
204
205 void Path::addRect(const FloatRect& rect) 
206 {
207 #if USE(WXGC)
208     if (m_path)
209         m_path->AddRectangle(rect.x(), rect.y(), rect.width(), rect.height());
210 #endif
211 }
212
213 void Path::addEllipse(const FloatRect& rect) 
214 {
215 #if USE(WXGC)
216     if (m_path)
217         m_path->AddEllipse(rect.x(), rect.y(), rect.width(), rect.height());
218 #endif
219 }
220
221 void Path::transform(const AffineTransform& transform) 
222 {
223 #if USE(WXGC)
224     if (m_path)
225         m_path->Transform(transform);
226 #endif
227 }
228
229 void Path::apply(void* info, PathApplierFunction function) const 
230 {
231     notImplemented(); 
232 }
233
234 bool Path::isEmpty() const
235 {
236 #if USE(WXGC)
237     if (m_path) {
238         wxDouble x, y, width, height;
239         m_path->GetBox(&x, &y, &width, &height);
240         return (width == 0 && height == 0);
241     }
242 #endif
243     return true;
244 }
245
246 bool Path::hasCurrentPoint() const
247 {
248     return !isEmpty();
249 }
250
251 FloatPoint Path::currentPoint() const 
252 {
253     // FIXME: return current point of subpath.
254     float quietNaN = std::numeric_limits<float>::quiet_NaN();
255     return FloatPoint(quietNaN, quietNaN);
256 }
257
258 }