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 }