code.vuplus.com Git - vuplus_webkit/blob - Source/WebCore/platform/graphics/skia/PathSkia.cpp

   1 // Copyright (c) 2008, Google Inc.
   2 // 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 are
   6 // met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright
   9 // notice, this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above
  11 // copyright notice, this list of conditions and the following disclaimer
  12 // in the documentation and/or other materials provided with the
  13 // distribution.
  14 //     * Neither the name of Google Inc. nor the names of its
  15 // contributors may be used to endorse or promote products derived from
  16 // this software without specific prior written permission.
  17 //
  18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29
  30 #include "config.h"
  31 #include "Path.h"
  32
  33 #include "AffineTransform.h"
  34 #include "FloatRect.h"
  35 #include "ImageBuffer.h"
  36 #include "StrokeStyleApplier.h"
  37
  38 #include "SkPath.h"
  39 #include "SkRegion.h"
  40 #include "SkiaUtils.h"
  41
  42 #include <wtf/MathExtras.h>
  43
  44 namespace WebCore {
  45
  46 Path::Path()
  47 {
  48     m_path = new SkPath;
  49 }
  50
  51 Path::Path(const Path& other)
  52 {
  53     m_path = new SkPath(*other.m_path);
  54 }
  55
  56 Path::~Path()
  57 {
  58     delete m_path;
  59 }
  60
  61 Path& Path::operator=(const Path& other)
  62 {
  63     *m_path = *other.m_path;
  64     return *this;
  65 }
  66
  67 bool Path::isEmpty() const
  68 {
  69     return m_path->isEmpty();
  70 }
  71
  72 bool Path::hasCurrentPoint() const
  73 {
  74     return m_path->getPoints(NULL, 0) != 0;
  75 }
  76
  77 FloatPoint Path::currentPoint() const
  78 {
  79     // FIXME: return current point of subpath.
  80     float quietNaN = std::numeric_limits<float>::quiet_NaN();
  81     return FloatPoint(quietNaN, quietNaN);
  82 }
  83
  84 bool Path::contains(const FloatPoint& point, WindRule rule) const
  85 {
  86     return SkPathContainsPoint(m_path, point,
  87       rule == RULE_NONZERO ? SkPath::kWinding_FillType : SkPath::kEvenOdd_FillType);
  88 }
  89
  90 void Path::translate(const FloatSize& size)
  91 {
  92     m_path->offset(WebCoreFloatToSkScalar(size.width()), WebCoreFloatToSkScalar(size.height()));
  93 }
  94
  95 FloatRect Path::boundingRect() const
  96 {
  97     return m_path->getBounds();
  98 }
  99
 100 void Path::moveTo(const FloatPoint& point)
 101 {
 102     m_path->moveTo(point);
 103 }
 104
 105 void Path::addLineTo(const FloatPoint& point)
 106 {
 107     m_path->lineTo(point);
 108 }
 109
 110 void Path::addQuadCurveTo(const FloatPoint& cp, const FloatPoint& ep)
 111 {
 112     m_path->quadTo(cp, ep);
 113 }
 114
 115 void Path::addBezierCurveTo(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& ep)
 116 {
 117     m_path->cubicTo(p1, p2, ep);
 118 }
 119
 120 void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)
 121 {
 122     m_path->arcTo(p1, p2, WebCoreFloatToSkScalar(radius));
 123 }
 124
 125 void Path::closeSubpath()
 126 {
 127     m_path->close();
 128 }
 129
 130 void Path::addArc(const FloatPoint& p, float r, float sa, float ea, bool anticlockwise) {
 131     SkScalar cx = WebCoreFloatToSkScalar(p.x());
 132     SkScalar cy = WebCoreFloatToSkScalar(p.y());
 133     SkScalar radius = WebCoreFloatToSkScalar(r);
 134     SkScalar s360 = SkIntToScalar(360);
 135
 136     SkRect oval;
 137     oval.set(cx - radius, cy - radius, cx + radius, cy + radius);
 138
 139     float sweep = ea - sa;
 140     SkScalar startDegrees = WebCoreFloatToSkScalar(sa * 180 / piFloat);
 141     SkScalar sweepDegrees = WebCoreFloatToSkScalar(sweep * 180 / piFloat);
 142     // Check for a circle.
 143     if (sweepDegrees >= s360 || sweepDegrees <= -s360) {
 144         // Move to the start position (0 sweep means we add a single point).
 145         m_path->arcTo(oval, startDegrees, 0, false);
 146         // Draw the circle.
 147         m_path->addOval(oval, anticlockwise ?
 148             SkPath::kCCW_Direction : SkPath::kCW_Direction);
 149         // Force a moveTo the end position.
 150         m_path->arcTo(oval, startDegrees + sweepDegrees, 0, true);
 151     } else {
 152         // Counterclockwise arcs should be drawn with negative sweeps, while
 153         // clockwise arcs should be drawn with positive sweeps. Check to see
 154         // if the situation is reversed and correct it by adding or subtracting
 155         // a full circle
 156         if (anticlockwise && sweepDegrees > 0) {
 157             sweepDegrees -= s360;
 158         } else if (!anticlockwise && sweepDegrees < 0) {
 159             sweepDegrees += s360;
 160         }
 161
 162         m_path->arcTo(oval, startDegrees, sweepDegrees, false);
 163     }
 164 }
 165
 166 void Path::addRect(const FloatRect& rect)
 167 {
 168     m_path->addRect(rect);
 169 }
 170
 171 void Path::addEllipse(const FloatRect& rect)
 172 {
 173     m_path->addOval(rect);
 174 }
 175
 176 void Path::clear()
 177 {
 178     m_path->reset();
 179 }
 180
 181 static FloatPoint* convertPathPoints(FloatPoint dst[], const SkPoint src[], int count)
 182 {
 183     for (int i = 0; i < count; i++) {
 184         dst[i].setX(SkScalarToFloat(src[i].fX));
 185         dst[i].setY(SkScalarToFloat(src[i].fY));
 186     }
 187     return dst;
 188 }
 189
 190 void Path::apply(void* info, PathApplierFunction function) const
 191 {
 192     SkPath::Iter iter(*m_path, false);
 193     SkPoint pts[4];
 194     PathElement pathElement;
 195     FloatPoint pathPoints[3];
 196
 197     for (;;) {
 198         switch (iter.next(pts)) {
 199         case SkPath::kMove_Verb:
 200             pathElement.type = PathElementMoveToPoint;
 201             pathElement.points = convertPathPoints(pathPoints, &pts[0], 1);
 202             break;
 203         case SkPath::kLine_Verb:
 204             pathElement.type = PathElementAddLineToPoint;
 205             pathElement.points = convertPathPoints(pathPoints, &pts[1], 1);
 206             break;
 207         case SkPath::kQuad_Verb:
 208             pathElement.type = PathElementAddQuadCurveToPoint;
 209             pathElement.points = convertPathPoints(pathPoints, &pts[1], 2);
 210             break;
 211         case SkPath::kCubic_Verb:
 212             pathElement.type = PathElementAddCurveToPoint;
 213             pathElement.points = convertPathPoints(pathPoints, &pts[1], 3);
 214             break;
 215         case SkPath::kClose_Verb:
 216             pathElement.type = PathElementCloseSubpath;
 217             pathElement.points = convertPathPoints(pathPoints, 0, 0);
 218             break;
 219         case SkPath::kDone_Verb:
 220             return;
 221         }
 222         function(info, &pathElement);
 223     }
 224 }
 225
 226 void Path::transform(const AffineTransform& xform)
 227 {
 228     m_path->transform(xform);
 229 }
 230
 231 FloatRect Path::strokeBoundingRect(StrokeStyleApplier* applier) const
 232 {
 233     GraphicsContext* scratch = scratchContext();
 234     scratch->save();
 235
 236     if (applier)
 237         applier->strokeStyle(scratch);
 238
 239     SkPaint paint;
 240     scratch->platformContext()->setupPaintForStroking(&paint, 0, 0);
 241     SkPath boundingPath;
 242     paint.getFillPath(*platformPath(), &boundingPath);
 243
 244     FloatRect r = boundingPath.getBounds();
 245     scratch->restore();
 246     return r;
 247 }
 248
 249 bool Path::strokeContains(StrokeStyleApplier* applier, const FloatPoint& point) const
 250 {
 251     ASSERT(applier);
 252     GraphicsContext* scratch = scratchContext();
 253     scratch->save();
 254
 255     applier->strokeStyle(scratch);
 256
 257     SkPaint paint;
 258     scratch->platformContext()->setupPaintForStroking(&paint, 0, 0);
 259     SkPath strokePath;
 260     paint.getFillPath(*platformPath(), &strokePath);
 261     bool contains = SkPathContainsPoint(&strokePath, point,
 262                                         SkPath::kWinding_FillType);
 263
 264     scratch->restore();
 265     return contains;
 266 }
 267 } // namespace WebCore