add guard to switch to SkPathTypes
Change-Id: I44d8b5ae8a5172d11a6d4cd9d994373dd3816d6f
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/241278
Reviewed-by: Kevin Lubick <kjlubick@google.com>
Reviewed-by: Florin Malita <fmalita@chromium.org>
Commit-Queue: Mike Reed <reed@google.com>
diff --git a/bench/AAClipBench.cpp b/bench/AAClipBench.cpp
index abd7ec5..5570ad0 100644
--- a/bench/AAClipBench.cpp
+++ b/bench/AAClipBench.cpp
@@ -34,7 +34,7 @@
doAA ? "AA" : "BW");
fClipRect.setLTRB(10.5f, 10.5f, 50.5f, 50.5f);
- fClipPath.addRoundRect(fClipRect, SkIntToScalar(10), SkIntToScalar(10));
+ fClipPath.addRRect(SkRRect::MakeRectXY(fClipRect, SkIntToScalar(10), SkIntToScalar(10)));
fDrawRect.setWH(100, 100);
SkASSERT(fClipPath.isConvex());
@@ -51,8 +51,7 @@
// jostle the clip regions each time to prevent caching
fClipRect.offset((i % 2) == 0 ? SkIntToScalar(10) : SkIntToScalar(-10), 0);
fClipPath.reset();
- fClipPath.addRoundRect(fClipRect,
- SkIntToScalar(5), SkIntToScalar(5));
+ fClipPath.addRRect(SkRRect::MakeRectXY(fClipRect, 5, 5));
SkASSERT(fClipPath.isConvex());
canvas->save();
diff --git a/bench/BlurRectsBench.cpp b/bench/BlurRectsBench.cpp
index ed2b254..df1775c 100644
--- a/bench/BlurRectsBench.cpp
+++ b/bench/BlurRectsBench.cpp
@@ -34,8 +34,8 @@
paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, fRadius));
SkPath path;
- path.addRect(fOuter, SkPath::kCW_Direction);
- path.addRect(fInner, SkPath::kCW_Direction);
+ path.addRect(fOuter, SkPathDirection::kCW);
+ path.addRect(fInner, SkPathDirection::kCW);
for (int i = 0; i < loops; i++) {
canvas->drawPath(path, paint);
diff --git a/bench/GeometryBench.cpp b/bench/GeometryBench.cpp
index 457151d..634ff09 100644
--- a/bench/GeometryBench.cpp
+++ b/bench/GeometryBench.cpp
@@ -271,7 +271,7 @@
void onDraw(int loops, SkCanvas* canvas) override {
for (int i = 0; i < loops; ++i) {
- fPath.setConvexity(SkPath::kUnknown_Convexity);
+ fPath.setConvexity(SkPathConvexityType::kUnknown);
(void)fPath.isConvex();
}
}
diff --git a/bench/PathBench.cpp b/bench/PathBench.cpp
index eb4d4a3..58dfb14 100644
--- a/bench/PathBench.cpp
+++ b/bench/PathBench.cpp
@@ -691,7 +691,7 @@
// mimic how Chrome does circles
temp.arcTo(r, 0, 0, false);
- temp.addOval(r, SkPath::kCCW_Direction);
+ temp.addOval(r, SkPathDirection::kCCW);
temp.arcTo(r, 360, 0, true);
temp.close();
@@ -825,7 +825,7 @@
break;
case kRoundRect_Type:
fName.append("round_rect");
- fPath.addRoundRect(kBaseRect, kRRRadii[0], kRRRadii[1]);
+ fPath.addRRect(SkRRect::MakeRectXY(kBaseRect, kRRRadii[0], kRRRadii[1]));
break;
case kOval_Type:
fName.append("oval");
diff --git a/example/SkiaSDLExample.cpp b/example/SkiaSDLExample.cpp
index 7aebbbc..6dcee90 100644
--- a/example/SkiaSDLExample.cpp
+++ b/example/SkiaSDLExample.cpp
@@ -97,7 +97,7 @@
for (int i = 0; i < kNumPoints; ++i) {
concavePath.lineTo(points[(2 * i) % kNumPoints]);
}
- concavePath.setFillType(SkPath::kEvenOdd_FillType);
+ concavePath.setFillType(SkPathFillType::kEvenOdd);
SkASSERT(!concavePath.isConvex());
concavePath.close();
return concavePath;
diff --git a/experimental/svg/model/SkSVGCircle.cpp b/experimental/svg/model/SkSVGCircle.cpp
index 66e7d28..47da074 100644
--- a/experimental/svg/model/SkSVGCircle.cpp
+++ b/experimental/svg/model/SkSVGCircle.cpp
@@ -54,7 +54,7 @@
return std::make_tuple(SkPoint::Make(cx, cy), r);
}
void SkSVGCircle::onDraw(SkCanvas* canvas, const SkSVGLengthContext& lctx,
- const SkPaint& paint, SkPath::FillType) const {
+ const SkPaint& paint, SkPathFillType) const {
SkPoint pos;
SkScalar r;
std::tie(pos, r) = this->resolve(lctx);
diff --git a/experimental/svg/model/SkSVGCircle.h b/experimental/svg/model/SkSVGCircle.h
index c53cf4a..fc774a1 100644
--- a/experimental/svg/model/SkSVGCircle.h
+++ b/experimental/svg/model/SkSVGCircle.h
@@ -26,7 +26,7 @@
void onSetAttribute(SkSVGAttribute, const SkSVGValue&) override;
void onDraw(SkCanvas*, const SkSVGLengthContext&, const SkPaint&,
- SkPath::FillType) const override;
+ SkPathFillType) const override;
SkPath onAsPath(const SkSVGRenderContext&) const override;
diff --git a/experimental/svg/model/SkSVGEllipse.cpp b/experimental/svg/model/SkSVGEllipse.cpp
index b7d4fad..60d3048 100644
--- a/experimental/svg/model/SkSVGEllipse.cpp
+++ b/experimental/svg/model/SkSVGEllipse.cpp
@@ -67,7 +67,7 @@
}
void SkSVGEllipse::onDraw(SkCanvas* canvas, const SkSVGLengthContext& lctx,
- const SkPaint& paint, SkPath::FillType) const {
+ const SkPaint& paint, SkPathFillType) const {
canvas->drawOval(this->resolve(lctx), paint);
}
diff --git a/experimental/svg/model/SkSVGEllipse.h b/experimental/svg/model/SkSVGEllipse.h
index c6bd2b3..ec0a753 100644
--- a/experimental/svg/model/SkSVGEllipse.h
+++ b/experimental/svg/model/SkSVGEllipse.h
@@ -27,7 +27,7 @@
void onSetAttribute(SkSVGAttribute, const SkSVGValue&) override;
void onDraw(SkCanvas*, const SkSVGLengthContext&, const SkPaint&,
- SkPath::FillType) const override;
+ SkPathFillType) const override;
SkPath onAsPath(const SkSVGRenderContext&) const override;
diff --git a/experimental/svg/model/SkSVGLine.cpp b/experimental/svg/model/SkSVGLine.cpp
index 3d0efa1..05fc1f9 100644
--- a/experimental/svg/model/SkSVGLine.cpp
+++ b/experimental/svg/model/SkSVGLine.cpp
@@ -64,7 +64,7 @@
}
void SkSVGLine::onDraw(SkCanvas* canvas, const SkSVGLengthContext& lctx,
- const SkPaint& paint, SkPath::FillType) const {
+ const SkPaint& paint, SkPathFillType) const {
SkPoint p0, p1;
std::tie(p0, p1) = this->resolve(lctx);
diff --git a/experimental/svg/model/SkSVGLine.h b/experimental/svg/model/SkSVGLine.h
index 08e0fe6..c4de847 100644
--- a/experimental/svg/model/SkSVGLine.h
+++ b/experimental/svg/model/SkSVGLine.h
@@ -27,7 +27,7 @@
void onSetAttribute(SkSVGAttribute, const SkSVGValue&) override;
void onDraw(SkCanvas*, const SkSVGLengthContext&, const SkPaint&,
- SkPath::FillType) const override;
+ SkPathFillType) const override;
SkPath onAsPath(const SkSVGRenderContext&) const override;
diff --git a/experimental/svg/model/SkSVGPath.cpp b/experimental/svg/model/SkSVGPath.cpp
index f3f4524..07fc348 100644
--- a/experimental/svg/model/SkSVGPath.cpp
+++ b/experimental/svg/model/SkSVGPath.cpp
@@ -26,7 +26,7 @@
}
void SkSVGPath::onDraw(SkCanvas* canvas, const SkSVGLengthContext&, const SkPaint& paint,
- SkPath::FillType fillType) const {
+ SkPathFillType fillType) const {
// the passed fillType follows inheritance rules and needs to be applied at draw time.
fPath.setFillType(fillType);
canvas->drawPath(fPath, paint);
diff --git a/experimental/svg/model/SkSVGPath.h b/experimental/svg/model/SkSVGPath.h
index 5b41637..1b7b17d 100644
--- a/experimental/svg/model/SkSVGPath.h
+++ b/experimental/svg/model/SkSVGPath.h
@@ -22,7 +22,7 @@
void onSetAttribute(SkSVGAttribute, const SkSVGValue&) override;
void onDraw(SkCanvas*, const SkSVGLengthContext&, const SkPaint&,
- SkPath::FillType) const override;
+ SkPathFillType) const override;
SkPath onAsPath(const SkSVGRenderContext&) const override;
diff --git a/experimental/svg/model/SkSVGPoly.cpp b/experimental/svg/model/SkSVGPoly.cpp
index 6bacb1a..29af890 100644
--- a/experimental/svg/model/SkSVGPoly.cpp
+++ b/experimental/svg/model/SkSVGPoly.cpp
@@ -33,7 +33,7 @@
}
void SkSVGPoly::onDraw(SkCanvas* canvas, const SkSVGLengthContext&, const SkPaint& paint,
- SkPath::FillType fillType) const {
+ SkPathFillType fillType) const {
// the passed fillType follows inheritance rules and needs to be applied at draw time.
fPath.setFillType(fillType);
canvas->drawPath(fPath, paint);
diff --git a/experimental/svg/model/SkSVGPoly.h b/experimental/svg/model/SkSVGPoly.h
index f47b764..ef9c3a5 100644
--- a/experimental/svg/model/SkSVGPoly.h
+++ b/experimental/svg/model/SkSVGPoly.h
@@ -30,7 +30,7 @@
void onSetAttribute(SkSVGAttribute, const SkSVGValue&) override;
void onDraw(SkCanvas*, const SkSVGLengthContext&, const SkPaint&,
- SkPath::FillType) const override;
+ SkPathFillType) const override;
SkPath onAsPath(const SkSVGRenderContext&) const override;
diff --git a/experimental/svg/model/SkSVGRect.cpp b/experimental/svg/model/SkSVGRect.cpp
index 24267d0..5c518bd 100644
--- a/experimental/svg/model/SkSVGRect.cpp
+++ b/experimental/svg/model/SkSVGRect.cpp
@@ -83,7 +83,7 @@
}
void SkSVGRect::onDraw(SkCanvas* canvas, const SkSVGLengthContext& lctx,
- const SkPaint& paint, SkPath::FillType) const {
+ const SkPaint& paint, SkPathFillType) const {
canvas->drawRRect(this->resolve(lctx), paint);
}
diff --git a/experimental/svg/model/SkSVGRect.h b/experimental/svg/model/SkSVGRect.h
index 7d749b0..fca15e0 100644
--- a/experimental/svg/model/SkSVGRect.h
+++ b/experimental/svg/model/SkSVGRect.h
@@ -29,7 +29,7 @@
void onSetAttribute(SkSVGAttribute, const SkSVGValue&) override;
void onDraw(SkCanvas*, const SkSVGLengthContext&, const SkPaint&,
- SkPath::FillType) const override;
+ SkPathFillType) const override;
SkPath onAsPath(const SkSVGRenderContext&) const override;
diff --git a/experimental/svg/model/SkSVGShape.h b/experimental/svg/model/SkSVGShape.h
index bfbad0e..ff57d5b 100644
--- a/experimental/svg/model/SkSVGShape.h
+++ b/experimental/svg/model/SkSVGShape.h
@@ -26,7 +26,7 @@
void onRender(const SkSVGRenderContext&) const final;
virtual void onDraw(SkCanvas*, const SkSVGLengthContext&, const SkPaint&,
- SkPath::FillType) const = 0;
+ SkPathFillType) const = 0;
private:
typedef SkSVGTransformableNode INHERITED;
diff --git a/experimental/svg/model/SkSVGTypes.h b/experimental/svg/model/SkSVGTypes.h
index 9ac7654..00a09bf 100644
--- a/experimental/svg/model/SkSVGTypes.h
+++ b/experimental/svg/model/SkSVGTypes.h
@@ -239,9 +239,9 @@
Type type() const { return fType; }
- SkPath::FillType asFillType() const {
+ SkPathFillType asFillType() const {
SkASSERT(fType != Type::kInherit); // should never be called for unresolved values.
- return fType == Type::kEvenOdd ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType;
+ return fType == Type::kEvenOdd ? SkPathFillType::kEvenOdd : SkPathFillType::kWinding;
}
private:
diff --git a/fuzz/FuzzCommon.cpp b/fuzz/FuzzCommon.cpp
index 3a2108e..1b953da 100644
--- a/fuzz/FuzzCommon.cpp
+++ b/fuzz/FuzzCommon.cpp
@@ -33,8 +33,8 @@
return;
}
uint8_t fillType;
- fuzz->nextRange(&fillType, 0, (uint8_t)SkPath::kInverseEvenOdd_FillType);
- path->setFillType((SkPath::FillType)fillType);
+ fuzz->nextRange(&fillType, 0, (uint8_t)SkPathFillType::kInverseEvenOdd);
+ path->setFillType((SkPathFillType)fillType);
uint8_t numOps;
fuzz->nextRange(&numOps, 0, maxOps);
for (uint8_t i = 0; i < numOps; ++i) {
@@ -52,7 +52,7 @@
SkMatrix m;
SkRRect rr;
SkRect r;
- SkPath::Direction dir;
+ SkPathDirection dir;
unsigned int ui;
SkScalar a, b, c, d, e, f;
switch (op) {
@@ -112,32 +112,32 @@
case 13:
fuzz_nice_rect(fuzz, &r);
fuzz->nextRange(&ui, 0, 1);
- dir = static_cast<SkPath::Direction>(ui);
+ dir = static_cast<SkPathDirection>(ui);
path->addRect(r, dir);
break;
case 14:
fuzz->nextRange(&ui, 0, 1);
- dir = static_cast<SkPath::Direction>(ui);
+ dir = static_cast<SkPathDirection>(ui);
fuzz_nice_rect(fuzz, &r);
fuzz->next(&ui);
path->addRect(r, dir, ui);
break;
case 15:
fuzz->nextRange(&ui, 0, 1);
- dir = static_cast<SkPath::Direction>(ui);
+ dir = static_cast<SkPathDirection>(ui);
fuzz_nice_rect(fuzz, &r);
path->addOval(r, dir);
break;
case 16:
fuzz->nextRange(&ui, 0, 1);
- dir = static_cast<SkPath::Direction>(ui);
+ dir = static_cast<SkPathDirection>(ui);
fuzz_nice_rect(fuzz, &r);
fuzz->next(&ui);
path->addOval(r, dir, ui);
break;
case 17:
fuzz->nextRange(&ui, 0, 1);
- dir = static_cast<SkPath::Direction>(ui);
+ dir = static_cast<SkPathDirection>(ui);
fuzz_nice_float(fuzz, &a, &b, &c);
path->addCircle(a, b, c, dir);
break;
@@ -150,18 +150,18 @@
fuzz_nice_float(fuzz, &a, &b);
fuzz_nice_rect(fuzz, &r);
fuzz->nextRange(&ui, 0, 1);
- dir = static_cast<SkPath::Direction>(ui);
- path->addRoundRect(r, a, b, dir);
+ dir = static_cast<SkPathDirection>(ui);
+ path->addRRect(SkRRect::MakeRectXY(r, a, b), dir);
break;
case 20:
FuzzNiceRRect(fuzz, &rr);
fuzz->nextRange(&ui, 0, 1);
- dir = static_cast<SkPath::Direction>(ui);
+ dir = static_cast<SkPathDirection>(ui);
path->addRRect(rr, dir);
break;
case 21:
fuzz->nextRange(&ui, 0, 1);
- dir = static_cast<SkPath::Direction>(ui);
+ dir = static_cast<SkPathDirection>(ui);
FuzzNiceRRect(fuzz, &rr);
path->addRRect(rr, dir, ui);
break;
diff --git a/fuzz/FuzzPathop.cpp b/fuzz/FuzzPathop.cpp
index 63862a9..79a3616 100644
--- a/fuzz/FuzzPathop.cpp
+++ b/fuzz/FuzzPathop.cpp
@@ -25,8 +25,8 @@
for (uint8_t i = 0; i < ops && !fuzz->exhausted(); i++) {
SkPath path;
FuzzEvilPath(fuzz, &path, SkPath::Verb::kDone_Verb);
- SkPath::FillType ft;
- fuzz->nextRange(&ft, 0, SkPath::kInverseEvenOdd_FillType);
+ SkPathFillType ft;
+ fuzz->nextRange(&ft, 0, SkPathFillType::kInverseEvenOdd);
path.setFillType(ft);
SkPathOp op;
@@ -41,8 +41,8 @@
case 1: {
SkPath path;
FuzzEvilPath(fuzz, &path, SkPath::Verb::kDone_Verb);
- SkPath::FillType ft;
- fuzz->nextRange(&ft, 0, SkPath::kInverseEvenOdd_FillType);
+ SkPathFillType ft;
+ fuzz->nextRange(&ft, 0, SkPathFillType::kInverseEvenOdd);
path.setFillType(ft);
SkPath result;
@@ -57,13 +57,13 @@
case 2: {
SkPath path;
FuzzEvilPath(fuzz, &path, SkPath::Verb::kDone_Verb);
- SkPath::FillType ft;
- fuzz->nextRange(&ft, 0, SkPath::kInverseEvenOdd_FillType);
+ SkPathFillType ft;
+ fuzz->nextRange(&ft, 0, SkPathFillType::kInverseEvenOdd);
path.setFillType(ft);
SkPath path2;
FuzzEvilPath(fuzz, &path2, SkPath::Verb::kDone_Verb);
- fuzz->nextRange(&ft, 0, SkPath::kInverseEvenOdd_FillType);
+ fuzz->nextRange(&ft, 0, SkPathFillType::kInverseEvenOdd);
path.setFillType(ft);
SkPathOp op;
@@ -83,8 +83,8 @@
case 3: {
SkPath path;
FuzzEvilPath(fuzz, &path, SkPath::Verb::kDone_Verb);
- SkPath::FillType ft;
- fuzz->nextRange(&ft, 0, SkPath::kInverseEvenOdd_FillType);
+ SkPathFillType ft;
+ fuzz->nextRange(&ft, 0, SkPathFillType::kInverseEvenOdd);
path.setFillType(ft);
SkPath result;
@@ -99,8 +99,8 @@
case 4: {
SkPath path;
FuzzEvilPath(fuzz, &path, SkPath::Verb::kDone_Verb);
- SkPath::FillType ft;
- fuzz->nextRange(&ft, 0, SkPath::kInverseEvenOdd_FillType);
+ SkPathFillType ft;
+ fuzz->nextRange(&ft, 0, SkPathFillType::kInverseEvenOdd);
path.setFillType(ft);
SkRect result;
diff --git a/gm/arcto.cpp b/gm/arcto.cpp
index f28d86c..ba0207c 100644
--- a/gm/arcto.cpp
+++ b/gm/arcto.cpp
@@ -79,13 +79,13 @@
SkScalar ovalHeight = oval.height() / oHeight;
svgArc.moveTo(oval.fLeft, oval.fTop);
svgArc.arcTo(oval.width() / 2, ovalHeight, SkIntToScalar(angle), SkPath::kSmall_ArcSize,
- SkPath::kCW_Direction, oval.right(), oval.bottom());
+ SkPathDirection::kCW, oval.right(), oval.bottom());
canvas->drawPath(svgArc, paint);
svgArc.reset();
svgArc.moveTo(oval.fLeft + 100, oval.fTop + 100);
svgArc.arcTo(oval.width() / 2, ovalHeight, SkIntToScalar(angle), SkPath::kLarge_ArcSize,
- SkPath::kCCW_Direction, oval.right(), oval.bottom() + 100);
+ SkPathDirection::kCCW, oval.right(), oval.bottom() + 100);
canvas->drawPath(svgArc, paint);
oval.offset(50, 0);
svgArc.reset();
diff --git a/gm/circularclips.cpp b/gm/circularclips.cpp
index 025b693..b213838 100644
--- a/gm/circularclips.cpp
+++ b/gm/circularclips.cpp
@@ -28,8 +28,8 @@
fY = 50;
fR = 40;
- fCircle1.addCircle(fX1, fY, fR, SkPath::kCW_Direction);
- fCircle2.addCircle(fX2, fY, fR, SkPath::kCW_Direction);
+ fCircle1.addCircle(fX1, fY, fR, SkPathDirection::kCW);
+ fCircle2.addCircle(fX2, fY, fR, SkPathDirection::kCW);
}
diff --git a/gm/collapsepaths.cpp b/gm/collapsepaths.cpp
index 7335171..82233c9 100644
--- a/gm/collapsepaths.cpp
+++ b/gm/collapsepaths.cpp
@@ -21,7 +21,7 @@
path.moveTo( 370.50653076171875, 73.684051513671875);
path.lineTo( 525.02093505859375, 208.6413726806640625);
path.lineTo( 478.403564453125, 213.5998992919921875);
- path.setFillType(SkPath::FillType::kEvenOdd_FillType);
+ path.setFillType(SkPathFillType::kEvenOdd);
canvas->drawPath(path, paint);
}
@@ -70,7 +70,7 @@
path.moveTo(154.6182708740234375, 188.230926513671875);
path.lineTo( 430.242095947265625, 546.76605224609375);
path.lineTo( 373.1005859375, 559.0906982421875);
- path.setFillType(SkPath::FillType::kEvenOdd_FillType);
+ path.setFillType(SkPathFillType::kEvenOdd);
canvas->drawPath(path, paint);
}
@@ -83,7 +83,7 @@
path.moveTo(39.09362030029296875, 47.59223175048828125);
path.lineTo(108.7822418212890625, 138.244110107421875);
path.lineTo(94.33460235595703125, 141.360260009765625);
- path.setFillType(SkPath::FillType::kEvenOdd_FillType);
+ path.setFillType(SkPathFillType::kEvenOdd);
canvas->drawPath(path, paint);
}
@@ -96,7 +96,7 @@
path.moveTo(40.33458709716796875, 49.10297393798828125);
path.lineTo(112.2353668212890625, 142.6324462890625);
path.lineTo(97.32910919189453125, 145.8475189208984375);
- path.setFillType(SkPath::FillType::kEvenOdd_FillType);
+ path.setFillType(SkPathFillType::kEvenOdd);
canvas->drawPath(path, paint);
}
@@ -109,7 +109,7 @@
path.moveTo( 34.50, 42.00);
path.lineTo( 96.00, 122.00);
path.lineTo( 83.25, 124.75);
- path.setFillType(SkPath::FillType::kEvenOdd_FillType);
+ path.setFillType(SkPathFillType::kEvenOdd);
canvas->drawPath(path, paint);
}
@@ -125,7 +125,7 @@
path.lineTo(SkDoubleToScalar(100.167), SkDoubleToScalar(140.096));
path.lineTo(SkDoubleToScalar( 99.0364), SkDoubleToScalar(140.364));
path.lineTo(SkDoubleToScalar( 94.25), SkDoubleToScalar(141.50));
- path.setFillType(SkPath::FillType::kEvenOdd_FillType);
+ path.setFillType(SkPathFillType::kEvenOdd);
canvas->drawPath(path, paint);
}
diff --git a/gm/complexclip2.cpp b/gm/complexclip2.cpp
index 46e2aad..340d62b 100644
--- a/gm/complexclip2.cpp
+++ b/gm/complexclip2.cpp
@@ -67,27 +67,27 @@
fRects[0].setLTRB(xB, yB, xE, yE);
fRRects[0].setRectXY(fRects[0], 7, 7);
- fPaths[0].addRoundRect(fRects[0], 5, 5);
+ fPaths[0].addRRect(SkRRect::MakeRectXY(fRects[0], 5, 5));
fRectColors[0] = SK_ColorRED;
fRects[1].setLTRB(xA, yA, xD, yD);
fRRects[1].setRectXY(fRects[1], 7, 7);
- fPaths[1].addRoundRect(fRects[1], 5, 5);
+ fPaths[1].addRRect(SkRRect::MakeRectXY(fRects[1], 5, 5));
fRectColors[1] = SK_ColorGREEN;
fRects[2].setLTRB(xC, yA, xF, yD);
fRRects[2].setRectXY(fRects[2], 7, 7);
- fPaths[2].addRoundRect(fRects[2], 5, 5);
+ fPaths[2].addRRect(SkRRect::MakeRectXY(fRects[2], 5, 5));
fRectColors[2] = SK_ColorBLUE;
fRects[3].setLTRB(xA, yC, xD, yF);
fRRects[3].setRectXY(fRects[3], 7, 7);
- fPaths[3].addRoundRect(fRects[3], 5, 5);
+ fPaths[3].addRRect(SkRRect::MakeRectXY(fRects[3], 5, 5));
fRectColors[3] = SK_ColorYELLOW;
fRects[4].setLTRB(xC, yC, xF, yF);
fRRects[4].setRectXY(fRects[4], 7, 7);
- fPaths[4].addRoundRect(fRects[4], 5, 5);
+ fPaths[4].addRRect(SkRRect::MakeRectXY(fRects[4], 5, 5));
fRectColors[4] = SK_ColorCYAN;
const SkClipOp ops[] = {
diff --git a/gm/convex_all_line_paths.cpp b/gm/convex_all_line_paths.cpp
index 2fa2adf..1936dfc 100644
--- a/gm/convex_all_line_paths.cpp
+++ b/gm/convex_all_line_paths.cpp
@@ -183,7 +183,7 @@
SkISize onISize() override { return SkISize::Make(kGMWidth, kGMHeight); }
bool runAsBench() const override { return true; }
- static SkPath GetPath(int index, SkPath::Direction dir) {
+ static SkPath GetPath(int index, SkPathDirection dir) {
std::unique_ptr<SkPoint[]> data(nullptr);
const SkPoint* points;
int numPts;
@@ -238,7 +238,7 @@
SkPath path;
- if (SkPath::kCW_Direction == dir) {
+ if (SkPathDirection::kCW == dir) {
path.moveTo(points[0]);
for (int i = 1; i < numPts; ++i) {
path.lineTo(points[i]);
@@ -273,7 +273,7 @@
SkPoint center;
{
- SkPath path = GetPath(index, SkPath::kCW_Direction);
+ SkPath path = GetPath(index, SkPathDirection::kCW);
if (offset->fX+path.getBounds().width() > kGMWidth) {
offset->fX = 0;
offset->fY += kMaxPathHeight;
@@ -290,7 +290,7 @@
}
const SkColor colors[2] = { SK_ColorBLACK, SK_ColorWHITE };
- const SkPath::Direction dirs[2] = { SkPath::kCW_Direction, SkPath::kCCW_Direction };
+ const SkPathDirection dirs[2] = { SkPathDirection::kCW, SkPathDirection::kCCW };
const float scales[] = { 1.0f, 0.75f, 0.5f, 0.25f, 0.1f, 0.01f, 0.001f };
const SkPaint::Join joins[3] = { SkPaint::kRound_Join,
SkPaint::kBevel_Join,
diff --git a/gm/crbug_908646.cpp b/gm/crbug_908646.cpp
index 843799e..3d11276 100644
--- a/gm/crbug_908646.cpp
+++ b/gm/crbug_908646.cpp
@@ -14,7 +14,7 @@
SkPaint paint;
paint.setAntiAlias(true);
SkPath path;
- path.setFillType(SkPath::kEvenOdd_FillType);
+ path.setFillType(SkPathFillType::kEvenOdd);
path.moveTo(50, 50);
path.lineTo(50, 300);
path.lineTo(250, 300);
diff --git a/gm/distantclip.cpp b/gm/distantclip.cpp
index b0da264..a213a2a 100644
--- a/gm/distantclip.cpp
+++ b/gm/distantclip.cpp
@@ -38,7 +38,7 @@
rec->save();
SkRect r = SkRect::MakeXYWH(-kExtents, kOffset - kExtents, 2 * kExtents, 2 * kExtents);
SkPath p;
- p.addRoundRect(r, 5, 5);
+ p.addRRect(SkRRect::MakeRectXY(r, 5, 5));
rec->clipPath(p, true);
rec->drawColor(SK_ColorGREEN);
rec->restore();
diff --git a/gm/inversepaths.cpp b/gm/inversepaths.cpp
index 0726983..7ddf088 100644
--- a/gm/inversepaths.cpp
+++ b/gm/inversepaths.cpp
@@ -34,7 +34,7 @@
static SkPath generate_circle(SkScalar cx, SkScalar cy, SkScalar d) {
SkPath path;
- path.addCircle(cx, cy, d/2, SkPath::kCW_Direction);
+ path.addCircle(cx, cy, d/2, SkPathDirection::kCW);
return path;
}
diff --git a/gm/nested.cpp b/gm/nested.cpp
index 859077f..9c1370c 100644
--- a/gm/nested.cpp
+++ b/gm/nested.cpp
@@ -53,7 +53,7 @@
kShapeCount
};
- static void AddShape(SkPath* path, const SkRect& rect, Shapes shape, SkPath::Direction dir) {
+ static void AddShape(SkPath* path, const SkRect& rect, Shapes shape, SkPathDirection dir) {
switch (shape) {
case kRect_Shape:
path->addRect(rect, dir);
@@ -105,9 +105,9 @@
for (size_t innerRect = 0; innerRect < SK_ARRAY_COUNT(innerRects); ++innerRect) {
SkPath path;
- AddShape(&path, outerRect, (Shapes) outerShape, SkPath::kCW_Direction);
+ AddShape(&path, outerRect, (Shapes) outerShape, SkPathDirection::kCW);
AddShape(&path, innerRects[innerRect], (Shapes) innerShape,
- SkPath::kCCW_Direction);
+ SkPathDirection::kCCW);
canvas->save();
if (fFlipped) {
diff --git a/gm/patheffects.cpp b/gm/patheffects.cpp
index 33a6841..37715f1 100644
--- a/gm/patheffects.cpp
+++ b/gm/patheffects.cpp
@@ -148,9 +148,9 @@
path.reset();
SkRect r = { 0, 0, 250, 120 };
- path.addOval(r, SkPath::kCW_Direction);
+ path.addOval(r, SkPathDirection::kCW);
r.inset(50, 50);
- path.addRect(r, SkPath::kCCW_Direction);
+ path.addRect(r, SkPathDirection::kCCW);
canvas->translate(320, 20);
for (size_t i = 0; i < SK_ARRAY_COUNT(gPE2); i++) {
diff --git a/gm/pathfill.cpp b/gm/pathfill.cpp
index 6a00f39..529bf72 100644
--- a/gm/pathfill.cpp
+++ b/gm/pathfill.cpp
@@ -21,7 +21,7 @@
static SkScalar make_frame(SkPath* path) {
SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
SkIntToScalar(630), SkIntToScalar(470) };
- path->addRoundRect(r, SkIntToScalar(15), SkIntToScalar(15));
+ path->addRRect(SkRRect::MakeRectXY(r, 15, 15));
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
diff --git a/gm/pathopsskpclip.cpp b/gm/pathopsskpclip.cpp
index 75e7bd8..a2d7cee 100644
--- a/gm/pathopsskpclip.cpp
+++ b/gm/pathopsskpclip.cpp
@@ -42,7 +42,7 @@
SkIntToScalar(400),
SkIntToScalar(700)
};
- p.addRoundRect(r, SkIntToScalar(50), SkIntToScalar(50));
+ p.addRRect(SkRRect::MakeRectXY(r, 50, 50));
rec->clipPath(p, true);
rec->translate(SkIntToScalar(250), SkIntToScalar(250));
rec->clipPath(p, true);
diff --git a/include/core/SkPath.h b/include/core/SkPath.h
index 6a87648..151758d 100644
--- a/include/core/SkPath.h
+++ b/include/core/SkPath.h
@@ -15,6 +15,8 @@
#include <initializer_list>
+#define SK_SUPPORT_LEGACY_PATH_ENUMS
+
class SkAutoPathBoundsUpdate;
class SkData;
class SkRRect;
@@ -41,6 +43,7 @@
class SK_API SkPath {
public:
+#ifdef SK_SUPPORT_LEGACY_PATH_ENUMS
/** \enum SkPath::Direction
Direction describes whether contour is clockwise or counterclockwise.
When SkPath contains multiple overlapping contours, Direction together with
@@ -58,6 +61,7 @@
kCW_Direction = static_cast<int>(SkPathDirection::kCW),
kCCW_Direction = static_cast<int>(SkPathDirection::kCCW)
};
+#endif
/** Constructs an empty SkPath. By default, SkPath has no verbs, no SkPoint, and no weights.
SkPath::FillType is set to kWinding_FillType.
@@ -151,6 +155,7 @@
*/
bool interpolate(const SkPath& ending, SkScalar weight, SkPath* out) const;
+#ifdef SK_SUPPORT_LEGACY_PATH_ENUMS
/** \enum SkPath::FillType
FillType selects the rule used to fill SkPath. SkPath set to kWinding_FillType
fills if the sum of contour edges is not zero, where clockwise edges add one, and
@@ -166,7 +171,6 @@
kInverseWinding_FillType = static_cast<int>(SkPathFillType::kInverseWinding),
kInverseEvenOdd_FillType = static_cast<int>(SkPathFillType::kInverseEvenOdd)
};
-
/** Returns FillType, the rule used to fill SkPath. FillType of a new SkPath is
kWinding_FillType.
@@ -175,13 +179,26 @@
*/
FillType getFillType() const { return (FillType)fFillType; }
+ void setFillType(FillType ft) {
+ this->setFillType(static_cast<SkPathFillType>(ft));
+ }
+#else
+ /** Returns FillType, the rule used to fill SkPath. FillType of a new SkPath is
+ kWinding_FillType.
+
+ @return one of: kWinding_FillType, kEvenOdd_FillType, kInverseWinding_FillType,
+ kInverseEvenOdd_FillType
+ */
+ SkPathFillType getFillType() const { return (SkPathFillType)fFillType; }
+#endif
+
/** Sets FillType, the rule used to fill SkPath. While there is no check
that ft is legal, values outside of FillType are not supported.
@param ft one of: kWinding_FillType, kEvenOdd_FillType, kInverseWinding_FillType,
kInverseEvenOdd_FillType
*/
- void setFillType(FillType ft) {
+ void setFillType(SkPathFillType ft) {
fFillType = SkToU8(ft);
}
@@ -190,7 +207,7 @@
@return true if FillType is kInverseWinding_FillType or kInverseEvenOdd_FillType
*/
- bool isInverseFillType() const { return IsInverseFillType((FillType)fFillType); }
+ bool isInverseFillType() const;
/** Replaces FillType with its inverse. The inverse of FillType describes the area
unmodified by the original FillType.
@@ -199,6 +216,7 @@
fFillType ^= 2;
}
+#ifdef SK_SUPPORT_LEGACY_PATH_ENUMS
/** \enum SkPath::Convexity
SkPath is convex if it contains one contour and contour loops no more than
360 degrees, and contour angles all have same Direction. Convex SkPath
@@ -228,7 +246,7 @@
if (convexity != kUnknown_Convexity) {
return convexity;
}
- return this->internalGetConvexity();
+ return (Convexity)this->internalGetConvexity();
}
/** Returns last computed SkPath::Convexity, or kUnknown_Convexity if
@@ -236,7 +254,9 @@
@return stored SkPath::Convexity
*/
- Convexity getConvexityOrUnknown() const { return fConvexity.load(std::memory_order_relaxed); }
+ Convexity getConvexityOrUnknown() const {
+ return (Convexity)fConvexity.load(std::memory_order_relaxed);
+ }
/** Stores convexity so that it is later returned by getConvexity() or getConvexityOrUnknown().
convexity may differ from getConvexity(), although setting an incorrect value may
@@ -251,7 +271,47 @@
@param convexity one of: kUnknown_Convexity, kConvex_Convexity, or kConcave_Convexity
*/
- void setConvexity(Convexity convexity);
+ void setConvexity(Convexity convexity) {
+ this->setConvexity(static_cast<SkPathConvexityType>(convexity));
+ }
+#else
+ /** Computes SkPath::Convexity if required, and returns stored value.
+ SkPath::Convexity is computed if stored value is kUnknown_Convexity,
+ or if SkPath has been altered since SkPath::Convexity was computed or set.
+
+ @return computed or stored SkPath::Convexity
+ */
+ SkPathConvexityType getConvexity() const {
+ SkPathConvexityType convexity = this->getConvexityOrUnknown();
+ if (convexity != SkPathConvexityType::kUnknown) {
+ return convexity;
+ }
+ return this->internalGetConvexity();
+ }
+
+ /** Returns last computed SkPath::Convexity, or kUnknown_Convexity if
+ SkPath has been altered since SkPath::Convexity was computed or set.
+
+ @return stored SkPath::Convexity
+ */
+ SkPathConvexityType getConvexityOrUnknown() const {
+ return static_cast<SkPathConvexityType>(fConvexity.load(std::memory_order_relaxed));
+ }
+#endif
+ /** Stores convexity so that it is later returned by getConvexity() or getConvexityOrUnknown().
+ convexity may differ from getConvexity(), although setting an incorrect value may
+ cause incorrect or inefficient drawing.
+
+ If convexity is kUnknown_Convexity: getConvexity() will
+ compute SkPath::Convexity, and getConvexityOrUnknown() will return kUnknown_Convexity.
+
+ If convexity is kConvex_Convexity or kConcave_Convexity, getConvexity()
+ and getConvexityOrUnknown() will return convexity until the path is
+ altered.
+
+ @param convexity one of: kUnknown_Convexity, kConvex_Convexity, or kConcave_Convexity
+ */
+ void setConvexity(SkPathConvexityType convexity);
/** Computes SkPath::Convexity if required, and returns true if value is kConvex_Convexity.
If setConvexity() was called with kConvex_Convexity or kConcave_Convexity, and
@@ -260,7 +320,7 @@
@return true if SkPath::Convexity stored or computed is kConvex_Convexity
*/
bool isConvex() const {
- return kConvex_Convexity == this->getConvexity();
+ return SkPathConvexityType::kConvex == (SkPathConvexityType)this->getConvexity();
}
/** Returns true if this path is recognized as an oval or circle.
@@ -899,35 +959,7 @@
@return reference to SkPath
*/
SkPath& arcTo(SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc,
- Direction sweep, SkScalar x, SkScalar y);
-
- /** Appends arc to SkPath. Arc is implemented by one or more conic weighted to describe
- part of oval with radii (r.fX, r.fY) rotated by xAxisRotate degrees. Arc curves
- from last SkPath SkPoint to (xy.fX, xy.fY), choosing one of four possible routes:
- clockwise or counterclockwise,
- and smaller or larger.
-
- Arc sweep is always less than 360 degrees. arcTo() appends line to xy if either
- radii are zero, or if last SkPath SkPoint equals (xy.fX, xy.fY). arcTo() scales radii r to
- fit last SkPath SkPoint and xy if both are greater than zero but too small to describe
- an arc.
-
- arcTo() appends up to four conic curves.
- arcTo() implements the functionality of SVG arc, although SVG sweep-flag value is
- opposite the integer value of sweep; SVG sweep-flag uses 1 for clockwise, while
- kCW_Direction cast to int is zero.
-
- @param r radii on axes before x-axis rotation
- @param xAxisRotate x-axis rotation in degrees; positive values are clockwise
- @param largeArc chooses smaller or larger arc
- @param sweep chooses clockwise or counterclockwise arc
- @param xy end of arc
- @return reference to SkPath
- */
- SkPath& arcTo(const SkPoint r, SkScalar xAxisRotate, ArcSize largeArc, Direction sweep,
- const SkPoint xy) {
- return this->arcTo(r.fX, r.fY, xAxisRotate, largeArc, sweep, xy.fX, xy.fY);
- }
+ SkPathDirection sweep, SkScalar x, SkScalar y);
/** Appends arc to SkPath, relative to last SkPath SkPoint. Arc is implemented by one or
more conic, weighted to describe part of oval with radii (rx, ry) rotated by
@@ -956,7 +988,7 @@
@return reference to SkPath
*/
SkPath& rArcTo(SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc,
- Direction sweep, SkScalar dx, SkScalar dy);
+ SkPathDirection sweep, SkScalar dx, SkScalar dy);
/** Appends kClose_Verb to SkPath. A closed contour connects the first and last SkPoint
with line, forming a continuous loop. Open and closed contour draw the same
@@ -970,6 +1002,7 @@
*/
SkPath& close();
+#ifdef SK_SUPPORT_LEGACY_PATH_ENUMS
/** Returns true if fill is inverted and SkPath with fill represents area outside
of its geometric bounds.
@@ -999,6 +1032,7 @@
static_assert(3 == kInverseEvenOdd_FillType, "fill_type_mismatch");
return (FillType)(fill & 1);
}
+#endif
/** Approximates conic with quad array. Conic is constructed from start SkPoint p0,
control SkPoint p1, end SkPoint p2, and weight w.
@@ -1041,7 +1075,7 @@
@param direction storage set to SkRect direction; may be nullptr
@return true if SkPath contains SkRect
*/
- bool isRect(SkRect* rect, bool* isClosed = nullptr, Direction* direction = nullptr) const;
+ bool isRect(SkRect* rect, bool* isClosed = nullptr, SkPathDirection* dir = nullptr) const;
/** Adds SkRect to SkPath, appending kMove_Verb, three kLine_Verb, and kClose_Verb,
starting with top-left corner of SkRect; followed by top-right, bottom-right,
@@ -1052,7 +1086,7 @@
@param dir SkPath::Direction to wind added contour
@return reference to SkPath
*/
- SkPath& addRect(const SkRect& rect, Direction dir = kCW_Direction);
+ SkPath& addRect(const SkRect& rect, SkPathDirection dir = SkPathDirection::kCW);
/** Adds SkRect to SkPath, appending kMove_Verb, three kLine_Verb, and kClose_Verb.
If dir is kCW_Direction, SkRect corners are added clockwise; if dir is
@@ -1064,23 +1098,7 @@
@param start initial corner of SkRect to add
@return reference to SkPath
*/
- SkPath& addRect(const SkRect& rect, Direction dir, unsigned start);
-
- /** Adds SkRect (left, top, right, bottom) to SkPath,
- appending kMove_Verb, three kLine_Verb, and kClose_Verb,
- starting with top-left corner of SkRect; followed by top-right, bottom-right,
- and bottom-left if dir is kCW_Direction; or followed by bottom-left,
- bottom-right, and top-right if dir is kCCW_Direction.
-
- @param left smaller x-axis value of SkRect
- @param top smaller y-axis value of SkRect
- @param right larger x-axis value of SkRect
- @param bottom larger y-axis value of SkRect
- @param dir SkPath::Direction to wind added contour
- @return reference to SkPath
- */
- SkPath& addRect(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom,
- Direction dir = kCW_Direction);
+ SkPath& addRect(const SkRect& rect, SkPathDirection dir, unsigned start);
/** Adds oval to path, appending kMove_Verb, four kConic_Verb, and kClose_Verb.
Oval is upright ellipse bounded by SkRect oval with radii equal to half oval width
@@ -1091,7 +1109,7 @@
@param dir SkPath::Direction to wind ellipse
@return reference to SkPath
*/
- SkPath& addOval(const SkRect& oval, Direction dir = kCW_Direction);
+ SkPath& addOval(const SkRect& oval, SkPathDirection dir = SkPathDirection::kCW);
/** Adds oval to SkPath, appending kMove_Verb, four kConic_Verb, and kClose_Verb.
Oval is upright ellipse bounded by SkRect oval with radii equal to half oval width
@@ -1103,7 +1121,7 @@
@param start index of initial point of ellipse
@return reference to SkPath
*/
- SkPath& addOval(const SkRect& oval, Direction dir, unsigned start);
+ SkPath& addOval(const SkRect& oval, SkPathDirection dir, unsigned start);
/** Adds circle centered at (x, y) of size radius to SkPath, appending kMove_Verb,
four kConic_Verb, and kClose_Verb. Circle begins at: (x + radius, y), continuing
@@ -1118,7 +1136,7 @@
@return reference to SkPath
*/
SkPath& addCircle(SkScalar x, SkScalar y, SkScalar radius,
- Direction dir = kCW_Direction);
+ SkPathDirection dir = SkPathDirection::kCW);
/** Appends arc to SkPath, as the start of new contour. Arc added is part of ellipse
bounded by oval, from startAngle through sweepAngle. Both startAngle and
@@ -1136,39 +1154,6 @@
*/
SkPath& addArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle);
- /** Appends SkRRect to SkPath, creating a new closed contour. SkRRect has bounds
- equal to rect; each corner is 90 degrees of an ellipse with radii (rx, ry). If
- dir is kCW_Direction, SkRRect starts at top-left of the lower-left corner and
- winds clockwise. If dir is kCCW_Direction, SkRRect starts at the bottom-left
- of the upper-left corner and winds counterclockwise.
-
- If either rx or ry is too large, rx and ry are scaled uniformly until the
- corners fit. If rx or ry is less than or equal to zero, addRoundRect() appends
- SkRect rect to SkPath.
-
- After appending, SkPath may be empty, or may contain: SkRect, oval, or SkRRect.
-
- @param rect bounds of SkRRect
- @param rx x-axis radius of rounded corners on the SkRRect
- @param ry y-axis radius of rounded corners on the SkRRect
- @param dir SkPath::Direction to wind SkRRect
- @return reference to SkPath
- */
- SkPath& addRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry,
- Direction dir = kCW_Direction);
-
- /** Appends SkRRect to SkPath, creating a new closed contour. SkRRect has bounds
- equal to rect; each corner is 90 degrees of an ellipse with radii from the
- array.
-
- @param rect bounds of SkRRect
- @param radii array of 8 SkScalar values, a radius pair for each corner
- @param dir SkPath::Direction to wind SkRRect
- @return reference to SkPath
- */
- SkPath& addRoundRect(const SkRect& rect, const SkScalar radii[],
- Direction dir = kCW_Direction);
-
/** Adds rrect to SkPath, creating a new closed contour. If
dir is kCW_Direction, rrect starts at top-left of the lower-left corner and
winds clockwise. If dir is kCCW_Direction, rrect starts at the bottom-left
@@ -1180,7 +1165,7 @@
@param dir SkPath::Direction to wind SkRRect
@return reference to SkPath
*/
- SkPath& addRRect(const SkRRect& rrect, Direction dir = kCW_Direction);
+ SkPath& addRRect(const SkRRect& rrect, SkPathDirection dir = SkPathDirection::kCW);
/** Adds rrect to SkPath, creating a new closed contour. If dir is kCW_Direction, rrect
winds clockwise; if dir is kCCW_Direction, rrect winds counterclockwise.
@@ -1191,7 +1176,7 @@
@param start index of initial point of SkRRect
@return reference to SkPath
*/
- SkPath& addRRect(const SkRRect& rrect, Direction dir, unsigned start);
+ SkPath& addRRect(const SkRRect& rrect, SkPathDirection dir, unsigned start);
/** Adds contour created from line array, adding (count - 1) line segments.
Contour added starts at pts[0], then adds a line for every additional SkPoint
@@ -1651,10 +1636,66 @@
*/
bool isValid() const { return this->isValidImpl() && fPathRef->isValid(); }
+#ifdef SK_SUPPORT_LEGACY_PATH_ENUMS
+ SkPath& arcTo(SkScalar rx, SkScalar ry, SkScalar xRotate, ArcSize largeArc,
+ Direction sweep, SkScalar x, SkScalar y) {
+ return this->arcTo(rx, ry, xRotate, largeArc, static_cast<SkPathDirection>(sweep), x, y);
+ }
+ SkPath& arcTo(const SkPoint r, SkScalar xAxisRotate, ArcSize largeArc, Direction sweep,
+ const SkPoint xy) {
+ return this->arcTo(r.fX, r.fY, xAxisRotate, largeArc, sweep, xy.fX, xy.fY);
+ }
+ SkPath& rArcTo(SkScalar rx, SkScalar ry, SkScalar xRotate, ArcSize largeArc,
+ Direction sweep, SkScalar dx, SkScalar dy) {
+ return this->rArcTo(rx, ry, xRotate, largeArc, static_cast<SkPathDirection>(sweep), dx, dy);
+ }
+ bool isRect(SkRect* rect, bool* isClosed, Direction* direction) const {
+ return this->isRect(rect, isClosed, reinterpret_cast<SkPathDirection*>(direction));
+ }
+ bool isRect(SkRect* rect, bool* isClosed, std::nullptr_t) const {
+ return this->isRect(rect, isClosed, (SkPathDirection*)nullptr);
+ }
+ SkPath& addRect(const SkRect& rect, Direction dir) {
+ return this->addRect(rect, static_cast<SkPathDirection>(dir));
+ }
+ SkPath& addRect(const SkRect& rect, Direction dir, unsigned start) {
+ return this->addRect(rect, static_cast<SkPathDirection>(dir), start);
+ }
+ SkPath& addRect(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom,
+ Direction dir = kCW_Direction) {
+ return this->addRect({left, top, right, bottom}, static_cast<SkPathDirection>(dir));
+ }
+ SkPath& addOval(const SkRect& oval, Direction dir) {
+ return this->addOval(oval, static_cast<SkPathDirection>(dir));
+ }
+ SkPath& addOval(const SkRect& oval, Direction dir, unsigned start) {
+ return this->addOval(oval, static_cast<SkPathDirection>(dir), start);
+ }
+ SkPath& addCircle(SkScalar x, SkScalar y, SkScalar radius, Direction dir) {
+ return this->addCircle(x, y, radius, static_cast<SkPathDirection>(dir));
+ }
+ SkPath& addRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry,
+ Direction dir = kCW_Direction) {
+ return this->addRRect(SkRRect::MakeRectXY(rect, rx, ry), static_cast<SkPathDirection>(dir));
+ }
+ SkPath& addRoundRect(const SkRect& rect, const SkScalar radii[],
+ Direction dir = kCW_Direction) {
+ SkRRect rr;
+ rr.setRectRadii(rect, reinterpret_cast<const SkPoint*>(radii));
+ return this->addRRect(rr, static_cast<SkPathDirection>(dir));
+ }
+ SkPath& addRRect(const SkRRect& rrect, Direction dir) {
+ return this->addRRect(rrect, static_cast<SkPathDirection>(dir));
+ }
+ SkPath& addRRect(const SkRRect& rrect, Direction dir, unsigned start) {
+ return this->addRRect(rrect, static_cast<SkPathDirection>(dir), start);
+ }
+#endif
+
private:
sk_sp<SkPathRef> fPathRef;
int fLastMoveToIndex;
- mutable std::atomic<Convexity> fConvexity;
+ mutable std::atomic<uint8_t> fConvexity;
mutable std::atomic<uint8_t> fFirstDirection; // really an SkPathPriv::FirstDirection
uint8_t fFillType : 2;
uint8_t fIsVolatile : 1;
@@ -1695,7 +1736,7 @@
inline bool hasOnlyMoveTos() const;
- Convexity internalGetConvexity() const;
+ SkPathConvexityType internalGetConvexity() const;
/** Asserts if SkPath data is inconsistent.
Debugging check intended for internal use only.
@@ -1727,7 +1768,7 @@
// Bottlenecks for working with fConvexity and fFirstDirection.
// Notice the setters are const... these are mutable atomic fields.
- void setConvexity(Convexity) const;
+ void setConvexity(SkPathConvexityType) const;
void setFirstDirection(uint8_t) const;
uint8_t getFirstDirection() const;
diff --git a/include/private/GrTypesPriv.h b/include/private/GrTypesPriv.h
index cc36958..5802721 100644
--- a/include/private/GrTypesPriv.h
+++ b/include/private/GrTypesPriv.h
@@ -251,12 +251,12 @@
};
inline GrFillRule GrFillRuleForSkPath(const SkPath& path) {
- switch (path.getFillType()) {
- case SkPath::kWinding_FillType:
- case SkPath::kInverseWinding_FillType:
+ switch ((SkPathFillType)path.getFillType()) {
+ case SkPathFillType::kWinding:
+ case SkPathFillType::kInverseWinding:
return GrFillRule::kNonzero;
- case SkPath::kEvenOdd_FillType:
- case SkPath::kInverseEvenOdd_FillType:
+ case SkPathFillType::kEvenOdd:
+ case SkPathFillType::kInverseEvenOdd:
return GrFillRule::kEvenOdd;
}
SkUNREACHABLE;
diff --git a/modules/pathkit/pathkit_wasm_bindings.cpp b/modules/pathkit/pathkit_wasm_bindings.cpp
index c47af69..7e2f285 100644
--- a/modules/pathkit/pathkit_wasm_bindings.cpp
+++ b/modules/pathkit/pathkit_wasm_bindings.cpp
@@ -318,7 +318,7 @@
// Path2D API things
// ======================================================================================
void ApplyAddRect(SkPath& path, SkScalar x, SkScalar y, SkScalar width, SkScalar height) {
- path.addRect(x, y, x+width, y+height);
+ path.addRect({x, y, x+width, y+height});
}
void ApplyAddArc(SkPath& path, SkScalar x, SkScalar y, SkScalar radius,
@@ -356,9 +356,9 @@
}
JSString GetFillTypeString(const SkPath& path) {
- if (path.getFillType() == SkPath::FillType::kWinding_FillType) {
+ if ((SkPathFillType)path.getFillType() == SkPathFillType::kWinding) {
return emscripten::val("nonzero");
- } else if (path.getFillType() == SkPath::FillType::kEvenOdd_FillType) {
+ } else if ((SkPathFillType)path.getFillType() == SkPathFillType::kEvenOdd) {
return emscripten::val("evenodd");
} else {
SkDebugf("warning: can't translate inverted filltype to HTML Canvas\n");
@@ -503,7 +503,7 @@
.function("_rect", &ApplyAddRect)
// Extra features
- .function("setFillType", &SkPath::setFillType)
+ .function("setFillType", select_overload<void(SkPathFillType)>(&SkPath::setFillType))
.function("getFillType", &SkPath::getFillType)
.function("getFillTypeString", &GetFillTypeString)
.function("getBounds", &SkPath::getBounds)
@@ -564,11 +564,11 @@
.value("XOR", SkPathOp::kXOR_SkPathOp)
.value("REVERSE_DIFFERENCE", SkPathOp::kReverseDifference_SkPathOp);
- enum_<SkPath::FillType>("FillType")
- .value("WINDING", SkPath::FillType::kWinding_FillType)
- .value("EVENODD", SkPath::FillType::kEvenOdd_FillType)
- .value("INVERSE_WINDING", SkPath::FillType::kInverseWinding_FillType)
- .value("INVERSE_EVENODD", SkPath::FillType::kInverseEvenOdd_FillType);
+ enum_<SkPathFillType>("FillType")
+ .value("WINDING", SkPathFillType::kWinding)
+ .value("EVENODD", SkPathFillType::kEvenOdd)
+ .value("INVERSE_WINDING", SkPathFillType::kInverseWinding)
+ .value("INVERSE_EVENODD", SkPathFillType::kInverseEvenOdd);
constant("MOVE_VERB", MOVE);
constant("LINE_VERB", LINE);
diff --git a/modules/skottie/src/layers/ShapeLayer.cpp b/modules/skottie/src/layers/ShapeLayer.cpp
index 3b7f98c..d2baab2 100644
--- a/modules/skottie/src/layers/ShapeLayer.cpp
+++ b/modules/skottie/src/layers/ShapeLayer.cpp
@@ -41,8 +41,8 @@
sk_sp<sksg::GeometryNode> AttachRRectGeometry(const skjson::ObjectValue& jrect,
const AnimationBuilder* abuilder) {
auto rect_node = sksg::RRect::Make();
- rect_node->setDirection(ParseDefault(jrect["d"], -1) == 3 ? SkPath::kCCW_Direction
- : SkPath::kCW_Direction);
+ rect_node->setDirection(ParseDefault(jrect["d"], -1) == 3 ? SkPathDirection::kCCW
+ : SkPathDirection::kCW);
rect_node->setInitialPointIndex(2); // starting point: (Right, Top - radius.y)
auto adapter = sk_make_sp<RRectAdapter>(rect_node);
@@ -70,8 +70,8 @@
sk_sp<sksg::GeometryNode> AttachEllipseGeometry(const skjson::ObjectValue& jellipse,
const AnimationBuilder* abuilder) {
auto rect_node = sksg::RRect::Make();
- rect_node->setDirection(ParseDefault(jellipse["d"], -1) == 3 ? SkPath::kCCW_Direction
- : SkPath::kCW_Direction);
+ rect_node->setDirection(ParseDefault(jellipse["d"], -1) == 3 ? SkPathDirection::kCCW
+ : SkPathDirection::kCW);
rect_node->setInitialPointIndex(1); // starting point: (Center, Top)
auto adapter = sk_make_sp<RRectAdapter>(rect_node);
diff --git a/modules/sksg/include/SkSGRect.h b/modules/sksg/include/SkSGRect.h
index 29456a0..c7966f4 100644
--- a/modules/sksg/include/SkSGRect.h
+++ b/modules/sksg/include/SkSGRect.h
@@ -32,8 +32,8 @@
SG_ATTRIBUTE(R, SkScalar, fRect.fRight )
SG_ATTRIBUTE(B, SkScalar, fRect.fBottom)
- SG_MAPPED_ATTRIBUTE(Direction , SkPath::Direction, fAttrContaier)
- SG_MAPPED_ATTRIBUTE(InitialPointIndex, uint8_t , fAttrContaier)
+ SG_MAPPED_ATTRIBUTE(Direction , SkPathDirection, fAttrContaier)
+ SG_MAPPED_ATTRIBUTE(InitialPointIndex, uint8_t , fAttrContaier)
protected:
void onClip(SkCanvas*, bool antiAlias) const override;
@@ -52,15 +52,15 @@
uint8_t fDirection : 1;
uint8_t fInitialPointIndex : 2;
- SkPath::Direction getDirection() const {
- return static_cast<SkPath::Direction>(fDirection);
+ SkPathDirection getDirection() const {
+ return static_cast<SkPathDirection>(fDirection);
}
- void setDirection(SkPath::Direction dir) { fDirection = SkTo<uint8_t>(dir); }
+ void setDirection(SkPathDirection dir) { fDirection = SkTo<uint8_t>(dir); }
uint8_t getInitialPointIndex() const { return fInitialPointIndex; }
void setInitialPointIndex(uint8_t idx) { fInitialPointIndex = idx; }
};
- AttrContainer fAttrContaier = { SkPath::kCW_Direction, 0 };
+ AttrContainer fAttrContaier = { (uint8_t)SkPathDirection::kCW, 0 };
using INHERITED = GeometryNode;
};
@@ -75,8 +75,8 @@
SG_ATTRIBUTE(RRect, SkRRect, fRRect)
- SG_MAPPED_ATTRIBUTE(Direction , SkPath::Direction, fAttrContaier)
- SG_MAPPED_ATTRIBUTE(InitialPointIndex, uint8_t , fAttrContaier)
+ SG_MAPPED_ATTRIBUTE(Direction , SkPathDirection, fAttrContaier)
+ SG_MAPPED_ATTRIBUTE(InitialPointIndex, uint8_t , fAttrContaier)
protected:
void onClip(SkCanvas*, bool antiAlias) const override;
@@ -95,15 +95,15 @@
uint8_t fDirection : 1;
uint8_t fInitialPointIndex : 2;
- SkPath::Direction getDirection() const {
- return static_cast<SkPath::Direction>(fDirection);
+ SkPathDirection getDirection() const {
+ return static_cast<SkPathDirection>(fDirection);
}
- void setDirection(SkPath::Direction dir) { fDirection = SkTo<uint8_t>(dir); }
+ void setDirection(SkPathDirection dir) { fDirection = SkTo<uint8_t>(dir); }
uint8_t getInitialPointIndex() const { return fInitialPointIndex; }
void setInitialPointIndex(uint8_t idx) { fInitialPointIndex = idx; }
};
- AttrContainer fAttrContaier = { SkPath::kCW_Direction, 0 };
+ AttrContainer fAttrContaier = { (uint8_t)SkPathDirection::kCW, 0 };
using INHERITED = GeometryNode;
};
diff --git a/samplecode/SampleAAClip.cpp b/samplecode/SampleAAClip.cpp
index 46e4fe2..b762066 100644
--- a/samplecode/SampleAAClip.cpp
+++ b/samplecode/SampleAAClip.cpp
@@ -70,7 +70,7 @@
// path.addRect(bounds);
// path.addOval(bounds);
- path.addRoundRect(bounds, 4, 4);
+ path.addRRect(SkRRect::MakeRectXY(bounds, 4, 4));
aaclip.setPath(path);
canvas->translate(30, 30);
drawClip(canvas, aaclip);
diff --git a/samplecode/SampleAndroidShadows.cpp b/samplecode/SampleAndroidShadows.cpp
index 71eb22a..7ee80b0 100644
--- a/samplecode/SampleAndroidShadows.cpp
+++ b/samplecode/SampleAndroidShadows.cpp
@@ -51,9 +51,8 @@
fCirclePath.addCircle(0, 0, 50);
fRectPath.addRect(SkRect::MakeXYWH(-100, -50, 200, 100));
fRRPath.addRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(-100, -50, 200, 100), 4, 4));
- fFunkyRRPath.addRoundRect(SkRect::MakeXYWH(-50, -50, SK_Scalar1 * 100, SK_Scalar1 * 100),
- 40 * SK_Scalar1, 20 * SK_Scalar1,
- SkPath::kCW_Direction);
+ fFunkyRRPath.addRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(-50, -50, 100, 100), 40, 20),
+ SkPathDirection::kCW);
fCubicPath.cubicTo(100 * SK_Scalar1, 50 * SK_Scalar1,
20 * SK_Scalar1, 100 * SK_Scalar1,
0 * SK_Scalar1, 0 * SK_Scalar1);
diff --git a/samplecode/SampleClip.cpp b/samplecode/SampleClip.cpp
index e931881..cbc76e9 100644
--- a/samplecode/SampleClip.cpp
+++ b/samplecode/SampleClip.cpp
@@ -114,7 +114,7 @@
SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) };
SkPath clipPath;
r.inset(SK_Scalar1 / 4, SK_Scalar1 / 4);
- clipPath.addRoundRect(r, SkIntToScalar(20), SkIntToScalar(20));
+ clipPath.addRRect(SkRRect::MakeRectXY(r, 20, 20));
// clipPath.toggleInverseFillType();
diff --git a/samplecode/SampleClock.cpp b/samplecode/SampleClock.cpp
index a90ecf1..f7332ce 100644
--- a/samplecode/SampleClock.cpp
+++ b/samplecode/SampleClock.cpp
@@ -160,7 +160,7 @@
#ifdef USE_PATH
path.reset();
path.arcTo(rect, 0, 0, false);
- path.addOval(rect, SkPath::kCCW_Direction);
+ path.addOval(rect, SkPathDirection::kCCW);
path.arcTo(rect, 360, 0, true);
canvas->drawPath(path, paintFill);
#else
@@ -170,7 +170,7 @@
#ifdef USE_PATH
path.reset();
path.arcTo(rect, 0, 0, false);
- path.addOval(rect, SkPath::kCCW_Direction);
+ path.addOval(rect, SkPathDirection::kCCW);
path.arcTo(rect, 360, 0, true);
canvas->drawPath(path, paintStroke);
#else
@@ -180,7 +180,7 @@
#ifdef USE_PATH
rect = SkRect::MakeLTRB(-6, -6, 6, 6);
path.arcTo(rect, 0, 0, false);
- path.addOval(rect, SkPath::kCCW_Direction);
+ path.addOval(rect, SkPathDirection::kCCW);
path.arcTo(rect, 360, 0, true);
canvas->drawPath(path, paintFill);
#else
@@ -196,7 +196,7 @@
#ifdef USE_PATH
path.reset();
path.arcTo(rect, 0, 0, false);
- path.addOval(rect, SkPath::kCCW_Direction);
+ path.addOval(rect, SkPathDirection::kCCW);
path.arcTo(rect, 360, 0, true);
canvas->drawPath(path, paintStroke);
#else
diff --git a/samplecode/SampleComplexClip.cpp b/samplecode/SampleComplexClip.cpp
index 4e811a0..d903148 100644
--- a/samplecode/SampleComplexClip.cpp
+++ b/samplecode/SampleComplexClip.cpp
@@ -34,7 +34,7 @@
path.quadTo(SkIntToScalar(150), SkIntToScalar(150), SkIntToScalar(125), SkIntToScalar(150));
path.lineTo(SkIntToScalar(50), SkIntToScalar(150));
path.close();
- path.setFillType(SkPath::kEvenOdd_FillType);
+ path.setFillType(SkPathFillType::kEvenOdd);
SkColor pathColor = SK_ColorBLACK;
SkPaint pathPaint;
pathPaint.setAntiAlias(true);
@@ -99,8 +99,8 @@
}
canvas->save();
// set clip
- clipA.setFillType(invA ? SkPath::kInverseEvenOdd_FillType :
- SkPath::kEvenOdd_FillType);
+ clipA.setFillType(invA ? SkPathFillType::kInverseEvenOdd :
+ SkPathFillType::kEvenOdd);
canvas->clipPath(clipA);
canvas->clipPath(clipB, gOps[op].fOp);
diff --git a/samplecode/SampleFillType.cpp b/samplecode/SampleFillType.cpp
index 58e954a..2678491 100644
--- a/samplecode/SampleFillType.cpp
+++ b/samplecode/SampleFillType.cpp
@@ -27,7 +27,7 @@
protected:
virtual SkString name() { return SkString("FillType"); }
- void showPath(SkCanvas* canvas, int x, int y, SkPath::FillType ft,
+ void showPath(SkCanvas* canvas, int x, int y, SkPathFillType ft,
SkScalar scale, const SkPaint& paint) {
const SkRect r = { 0, 0, SkIntToScalar(150), SkIntToScalar(150) };
@@ -45,14 +45,10 @@
}
void showFour(SkCanvas* canvas, SkScalar scale, const SkPaint& paint) {
- showPath(canvas, 0, 0, SkPath::kWinding_FillType,
- scale, paint);
- showPath(canvas, 200, 0, SkPath::kEvenOdd_FillType,
- scale, paint);
- showPath(canvas, 00, 200, SkPath::kInverseWinding_FillType,
- scale, paint);
- showPath(canvas, 200, 200, SkPath::kInverseEvenOdd_FillType,
- scale, paint);
+ showPath(canvas, 0, 0, SkPathFillType::kWinding, scale, paint);
+ showPath(canvas, 200, 0, SkPathFillType::kEvenOdd, scale, paint);
+ showPath(canvas, 00, 200, SkPathFillType::kInverseWinding, scale, paint);
+ showPath(canvas, 200, 200, SkPathFillType::kInverseEvenOdd, scale, paint);
}
virtual void onDrawContent(SkCanvas* canvas) {
diff --git a/samplecode/SampleFilterQuality.cpp b/samplecode/SampleFilterQuality.cpp
index 54fe4af..f18a1a6 100644
--- a/samplecode/SampleFilterQuality.cpp
+++ b/samplecode/SampleFilterQuality.cpp
@@ -42,7 +42,7 @@
canvas->drawColor(SK_ColorWHITE);
SkPath path;
- path.setFillType(SkPath::kEvenOdd_FillType);
+ path.setFillType(SkPathFillType::kEvenOdd);
path.addRect(SkRect::MakeWH(N/2, N));
path.addRect(SkRect::MakeWH(N, N/2));
diff --git a/samplecode/SampleIdentityScale.cpp b/samplecode/SampleIdentityScale.cpp
index 4e7b1dd..dcfdc0a 100644
--- a/samplecode/SampleIdentityScale.cpp
+++ b/samplecode/SampleIdentityScale.cpp
@@ -56,7 +56,7 @@
SkRect r = { 100, 100, 356, 356 };
SkPath clipPath;
- clipPath.addRoundRect(r, SkIntToScalar(5), SkIntToScalar(5));
+ clipPath.addRRect(SkRRect::MakeRectXY(r, 5, 5));
canvas->clipPath(clipPath, kIntersect_SkClipOp, true);
text = "Scaled = 0";
}
diff --git a/samplecode/SampleLayerMask.cpp b/samplecode/SampleLayerMask.cpp
index 9785e88..546c6c4 100644
--- a/samplecode/SampleLayerMask.cpp
+++ b/samplecode/SampleLayerMask.cpp
@@ -42,7 +42,7 @@
} else {
SkPath p;
p.addOval(r);
- p.setFillType(SkPath::kInverseWinding_FillType);
+ p.setFillType(SkPathFillType::kInverseWinding);
paint.setBlendMode(SkBlendMode::kDstOut);
canvas->drawPath(p, paint);
}
diff --git a/samplecode/SamplePathEffects.cpp b/samplecode/SamplePathEffects.cpp
index ccdc541..8666940 100644
--- a/samplecode/SamplePathEffects.cpp
+++ b/samplecode/SamplePathEffects.cpp
@@ -99,7 +99,7 @@
SkRect oval;
oval.setLTRB(20, 30, 100, 60);
oval.offset(x, 0);
- fPath.addRoundRect(oval, SkIntToScalar(8), SkIntToScalar(8));
+ fPath.addRRect(SkRRect::MakeRectXY(oval, 8, 8));
}
fClickPt.set(SkIntToScalar(200), SkIntToScalar(200));
diff --git a/samplecode/SampleQuadStroker.cpp b/samplecode/SampleQuadStroker.cpp
index 72dfabc..6b679e2 100644
--- a/samplecode/SampleQuadStroker.cpp
+++ b/samplecode/SampleQuadStroker.cpp
@@ -488,7 +488,7 @@
paint.setColor(0x3f0f1f3f);
canvas->drawPath(path, paint);
path.reset();
- path.setFillType(SkPath::kEvenOdd_FillType);
+ path.setFillType(SkPathFillType::kEvenOdd);
path.addCircle(center.fX, center.fY, maxSide + width / 2);
SkRect outside = SkRect::MakeXYWH(center.fX - maxSide - width, center.fY - maxSide - width,
(maxSide + width) * 2, (maxSide + width) * 2);
@@ -646,9 +646,9 @@
path.reset();
SkRRect rr2;
rr.inset(width/2, width/2, &rr2);
- path.addRRect(rr2, SkPath::kCCW_Direction);
+ path.addRRect(rr2, SkPathDirection::kCCW);
rr.inset(-width/2, -width/2, &rr2);
- path.addRRect(rr2, SkPath::kCW_Direction);
+ path.addRRect(rr2, SkPathDirection::kCW);
SkPaint paint;
paint.setAntiAlias(true);
paint.setColor(0x40FF8844);
diff --git a/samplecode/SampleRegion.cpp b/samplecode/SampleRegion.cpp
index 58ad5e0..7adb9ef 100644
--- a/samplecode/SampleRegion.cpp
+++ b/samplecode/SampleRegion.cpp
@@ -30,9 +30,7 @@
SkScalar dy = 20;
SkPath path;
- path.addRect(0.0f, 0.0f,
- SkIntToScalar(width), SkIntToScalar(height),
- SkPath::kCW_Direction);
+ path.addRect({0.0f, 0.0f, SkIntToScalar(width), SkIntToScalar(height)}, SkPathDirection::kCW);
SkRect r = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
SkCanvas c(bitmap);
diff --git a/samplecode/SampleShadowUtils.cpp b/samplecode/SampleShadowUtils.cpp
index 86151c1..b3023fa 100644
--- a/samplecode/SampleShadowUtils.cpp
+++ b/samplecode/SampleShadowUtils.cpp
@@ -42,7 +42,7 @@
protected:
void onOnceBeforeDraw() override {
- fConvexPaths.push_back().addRoundRect(SkRect::MakeWH(50, 50), 10, 10);
+ fConvexPaths.push_back().addRRect(SkRRect::MakeRectXY(SkRect::MakeWH(50, 50), 10, 10));
SkRRect oddRRect;
oddRRect.setNinePatch(SkRect::MakeWH(50, 50), 9, 13, 6, 16);
fConvexPaths.push_back().addRRect(oddRRect);
diff --git a/samplecode/SampleSlides.cpp b/samplecode/SampleSlides.cpp
index 09cb87c..d58f4f1 100644
--- a/samplecode/SampleSlides.cpp
+++ b/samplecode/SampleSlides.cpp
@@ -136,9 +136,9 @@
path.reset();
SkRect r = { 0, 0, 250, 120 };
- path.addOval(r, SkPath::kCW_Direction);
+ path.addOval(r, SkPathDirection::kCW);
r.inset(50, 50);
- path.addRect(r, SkPath::kCCW_Direction);
+ path.addRect(r, SkPathDirection::kCCW);
canvas->translate(320, 20);
for (i = 0; i < SK_ARRAY_COUNT(gPE2); i++) {
diff --git a/samplecode/SampleStrokePath.cpp b/samplecode/SampleStrokePath.cpp
index 4963f97..b22ba8d 100644
--- a/samplecode/SampleStrokePath.cpp
+++ b/samplecode/SampleStrokePath.cpp
@@ -112,8 +112,8 @@
"Z";
SkParsePath::FromSVGString(str, &fPath);
#else
- fPath.addCircle(0, 0, SkIntToScalar(50), SkPath::kCW_Direction);
- fPath.addCircle(0, SkIntToScalar(-50), SkIntToScalar(30), SkPath::kCW_Direction);
+ fPath.addCircle(0, 0, SkIntToScalar(50), SkPathDirection::kCW);
+ fPath.addCircle(0, SkIntToScalar(-50), SkIntToScalar(30), SkPathDirection::kCW);
#endif
scale_to_width(&fPath, fWidth);
@@ -192,11 +192,11 @@
fPath.offset(100, 0);
#endif
- fPath.setFillType(SkPath::kWinding_FillType);
+ fPath.setFillType(SkPathFillType::kWinding);
drawSet(canvas, &paint);
canvas->translate(0, fPath.getBounds().height() * 5 / 4);
- fPath.setFillType(SkPath::kEvenOdd_FillType);
+ fPath.setFillType(SkPathFillType::kEvenOdd);
drawSet(canvas, &paint);
}
diff --git a/samplecode/SampleTextEffects.cpp b/samplecode/SampleTextEffects.cpp
index 2303288..8e57750 100644
--- a/samplecode/SampleTextEffects.cpp
+++ b/samplecode/SampleTextEffects.cpp
@@ -82,7 +82,7 @@
virtual bool onFilterPath(SkPath* dst, const SkPath& src,
SkStrokeRec*, const SkRect*) const override {
*dst = src;
- dst->setFillType(SkPath::kInverseWinding_FillType);
+ dst->setFillType(SkPathFillType::kInverseWinding);
return true;
}
diff --git a/src/c/sk_surface.cpp b/src/c/sk_surface.cpp
index b3f203f..65fe209 100644
--- a/src/c/sk_surface.cpp
+++ b/src/c/sk_surface.cpp
@@ -56,13 +56,13 @@
const struct {
sk_path_direction_t fC;
- SkPath::Direction fSk;
+ SkPathDirection fSk;
} gPathDirMap[] = {
- { CW_SK_PATH_DIRECTION, SkPath::kCW_Direction },
- { CCW_SK_PATH_DIRECTION, SkPath::kCCW_Direction },
+ { CW_SK_PATH_DIRECTION, SkPathDirection::kCW },
+ { CCW_SK_PATH_DIRECTION, SkPathDirection::kCCW },
};
-static bool from_c_path_direction(sk_path_direction_t cdir, SkPath::Direction* dir) {
+static bool from_c_path_direction(sk_path_direction_t cdir, SkPathDirection* dir) {
for (size_t i = 0; i < SK_ARRAY_COUNT(gPathDirMap); ++i) {
if (gPathDirMap[i].fC == cdir) {
if (dir) {
@@ -202,7 +202,7 @@
}
void sk_path_add_rect(sk_path_t* cpath, const sk_rect_t* crect, sk_path_direction_t cdir) {
- SkPath::Direction dir;
+ SkPathDirection dir;
if (!from_c_path_direction(cdir, &dir)) {
return;
}
@@ -210,7 +210,7 @@
}
void sk_path_add_oval(sk_path_t* cpath, const sk_rect_t* crect, sk_path_direction_t cdir) {
- SkPath::Direction dir;
+ SkPathDirection dir;
if (!from_c_path_direction(cdir, &dir)) {
return;
}
diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index 9219f67..f8dad04 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -129,13 +129,13 @@
case DeviceSpaceType::kRect:
fDeviceSpacePath.init();
fDeviceSpacePath.get()->addRect(this->getDeviceSpaceRect());
- fDeviceSpacePath.get()->setFillType(SkPath::kInverseEvenOdd_FillType);
+ fDeviceSpacePath.get()->setFillType(SkPathFillType::kInverseEvenOdd);
fDeviceSpaceType = DeviceSpaceType::kPath;
break;
case DeviceSpaceType::kRRect:
fDeviceSpacePath.init();
fDeviceSpacePath.get()->addRRect(fDeviceSpaceRRect);
- fDeviceSpacePath.get()->setFillType(SkPath::kInverseEvenOdd_FillType);
+ fDeviceSpacePath.get()->setFillType(SkPathFillType::kInverseEvenOdd);
fDeviceSpaceType = DeviceSpaceType::kPath;
break;
case DeviceSpaceType::kPath:
@@ -752,7 +752,7 @@
bool isAA = false;
path->reset();
- path->setFillType(SkPath::kInverseEvenOdd_FillType);
+ path->setFillType(SkPathFillType::kInverseEvenOdd);
SkClipStack::Iter iter(*this, SkClipStack::Iter::kBottom_IterStart);
while (const SkClipStack::Element* element = iter.next()) {
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index 0847ea5..d5dd2e2 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -107,8 +107,8 @@
}
~SkAutoPathBoundsUpdate() {
- fPath->setConvexity(fDegenerate ? SkPath::kConvex_Convexity
- : SkPath::kUnknown_Convexity);
+ fPath->setConvexity(fDegenerate ? SkPathConvexityType::kConvex
+ : SkPathConvexityType::kUnknown);
if ((fEmpty || fHasValidBounds) && fRect.isFinite()) {
fPath->setBounds(fRect);
}
@@ -151,8 +151,8 @@
void SkPath::resetFields() {
//fPathRef is assumed to have been emptied by the caller.
fLastMoveToIndex = INITIAL_LASTMOVETOINDEX_VALUE;
- fFillType = kWinding_FillType;
- this->setConvexity(kUnknown_Convexity);
+ fFillType = static_cast<uint8_t>(SkPathFillType::kWinding);
+ this->setConvexity(SkPathConvexityType::kUnknown);
this->setFirstDirection(SkPathPriv::kUnknown_FirstDirection);
// We don't touch Android's fSourcePath. It's used to track texture garbage collection, so we
@@ -212,7 +212,7 @@
that.fIsVolatile = iv;
// Non-atomic swaps of atomic values.
- Convexity c = this->getConvexityOrUnknown();
+ SkPathConvexityType c = (SkPathConvexityType)this->getConvexityOrUnknown();
this->setConvexity(that.getConvexityOrUnknown());
that.setConvexity(c);
@@ -271,7 +271,7 @@
bool SkPath::conservativelyContainsRect(const SkRect& rect) const {
// This only handles non-degenerate convex paths currently.
- if (kConvex_Convexity != this->getConvexity()) {
+ if (SkPathConvexityType::kConvex != (SkPathConvexityType)this->getConvexity()) {
return false;
}
@@ -363,6 +363,10 @@
return genID;
}
+bool SkPath::isInverseFillType() const {
+ return SkPathPriv::IsInverseFillType((SkPathFillType)this->getFillType());
+}
+
SkPath& SkPath::reset() {
SkDEBUGCODE(this->validate();)
@@ -455,7 +459,7 @@
return ((0 != dx) << 0) | ((dx > 0 || dy > 0) << 1);
}
-bool SkPath::isRect(SkRect* rect, bool* isClosed, Direction* direction) const {
+bool SkPath::isRect(SkRect* rect, bool* isClosed, SkPathDirection* direction) const {
SkDEBUGCODE(this->validate();)
int currVerb = 0;
const SkPoint* pts = fPathRef->points();
@@ -559,13 +563,13 @@
}
// This is the public-facing non-const setConvexity().
-void SkPath::setConvexity(Convexity c) {
- fConvexity.store(c, std::memory_order_relaxed);
+void SkPath::setConvexity(SkPathConvexityType c) {
+ fConvexity.store(static_cast<uint8_t>(c), std::memory_order_relaxed);
}
// Const hooks for working with fConvexity and fFirstDirection from const methods.
-void SkPath::setConvexity(Convexity c) const {
- fConvexity.store(c, std::memory_order_relaxed);
+void SkPath::setConvexity(SkPathConvexityType c) const {
+ fConvexity.store(static_cast<uint8_t>(c), std::memory_order_relaxed);
}
void SkPath::setFirstDirection(uint8_t d) const {
fFirstDirection.store(d, std::memory_order_relaxed);
@@ -579,7 +583,7 @@
#define DIRTY_AFTER_EDIT \
do { \
- this->setConvexity(kUnknown_Convexity); \
+ this->setConvexity(SkPathConvexityType::kUnknown); \
this->setFirstDirection(SkPathPriv::kUnknown_FirstDirection); \
} while (0)
@@ -760,21 +764,11 @@
///////////////////////////////////////////////////////////////////////////////
-static void assert_known_direction(int dir) {
- SkASSERT(SkPath::kCW_Direction == dir || SkPath::kCCW_Direction == dir);
-}
-
-SkPath& SkPath::addRect(const SkRect& rect, Direction dir) {
+SkPath& SkPath::addRect(const SkRect& rect, SkPathDirection dir) {
return this->addRect(rect, dir, 0);
}
-SkPath& SkPath::addRect(SkScalar left, SkScalar top, SkScalar right,
- SkScalar bottom, Direction dir) {
- return this->addRect(SkRect::MakeLTRB(left, top, right, bottom), dir, 0);
-}
-
-SkPath& SkPath::addRect(const SkRect &rect, Direction dir, unsigned startIndex) {
- assert_known_direction(dir);
+SkPath& SkPath::addRect(const SkRect &rect, SkPathDirection dir, unsigned startIndex) {
this->setFirstDirection(this->hasOnlyMoveTos() ? (SkPathPriv::FirstDirection)dir
: SkPathPriv::kUnknown_FirstDirection);
SkAutoDisableDirectionCheck addc(this);
@@ -902,21 +896,12 @@
return count;
}
-SkPath& SkPath::addRoundRect(const SkRect& rect, const SkScalar radii[],
- Direction dir) {
- SkRRect rrect;
- rrect.setRectRadii(rect, (const SkVector*) radii);
- return this->addRRect(rrect, dir);
-}
-
-SkPath& SkPath::addRRect(const SkRRect& rrect, Direction dir) {
+SkPath& SkPath::addRRect(const SkRRect& rrect, SkPathDirection dir) {
// legacy start indices: 6 (CW) and 7(CCW)
- return this->addRRect(rrect, dir, dir == kCW_Direction ? 6 : 7);
+ return this->addRRect(rrect, dir, dir == SkPathDirection::kCW ? 6 : 7);
}
-SkPath& SkPath::addRRect(const SkRRect &rrect, Direction dir, unsigned startIndex) {
- assert_known_direction(dir);
-
+SkPath& SkPath::addRRect(const SkRRect &rrect, SkPathDirection dir, unsigned startIndex) {
bool isRRect = hasOnlyMoveTos();
const SkRect& bounds = rrect.getBounds();
@@ -934,7 +919,7 @@
SkAutoDisableDirectionCheck addc(this);
// we start with a conic on odd indices when moving CW vs. even indices when moving CCW
- const bool startsWithConic = ((startIndex & 1) == (dir == kCW_Direction));
+ const bool startsWithConic = ((startIndex & 1) == (dir == SkPathDirection::kCW));
const SkScalar weight = SK_ScalarRoot2Over2;
SkDEBUGCODE(int initialVerbCount = this->countVerbs());
@@ -946,7 +931,7 @@
SkPath_RRectPointIterator rrectIter(rrect, dir, startIndex);
// Corner iterator indices follow the collapsed radii model,
// adjusted such that the start pt is "behind" the radii start pt.
- const unsigned rectStartIndex = startIndex / 2 + (dir == kCW_Direction ? 0 : 1);
+ const unsigned rectStartIndex = startIndex / 2 + (dir == SkPathDirection::kCW ? 0 : 1);
SkPath_RectPointIterator rectIter(bounds, dir, rectStartIndex);
this->moveTo(rrectIter.current());
@@ -966,7 +951,7 @@
this->close();
SkPathRef::Editor ed(&fPathRef);
- ed.setIsRRect(isRRect, dir, startIndex % 8);
+ ed.setIsRRect(isRRect, dir == SkPathDirection::kCCW, startIndex % 8);
SkASSERT(this->countVerbs() == initialVerbCount + kVerbs);
}
@@ -1005,27 +990,12 @@
return true;
}
-SkPath& SkPath::addRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry,
- Direction dir) {
- assert_known_direction(dir);
-
- if (rx < 0 || ry < 0) {
- return *this;
- }
-
- SkRRect rrect;
- rrect.setRectXY(rect, rx, ry);
- return this->addRRect(rrect, dir);
-}
-
-SkPath& SkPath::addOval(const SkRect& oval, Direction dir) {
+SkPath& SkPath::addOval(const SkRect& oval, SkPathDirection dir) {
// legacy start index: 1
return this->addOval(oval, dir, 1);
}
-SkPath& SkPath::addOval(const SkRect &oval, Direction dir, unsigned startPointIndex) {
- assert_known_direction(dir);
-
+SkPath& SkPath::addOval(const SkRect &oval, SkPathDirection dir, unsigned startPointIndex) {
/* If addOval() is called after previous moveTo(),
this path is still marked as an oval. This is used to
fit into WebKit's calling sequences.
@@ -1048,7 +1018,7 @@
SkPath_OvalPointIterator ovalIter(oval, dir, startPointIndex);
// The corner iterator pts are tracking "behind" the oval/radii pts.
- SkPath_RectPointIterator rectIter(oval, dir, startPointIndex + (dir == kCW_Direction ? 0 : 1));
+ SkPath_RectPointIterator rectIter(oval, dir, startPointIndex + (dir == SkPathDirection::kCW ? 0 : 1));
const SkScalar weight = SK_ScalarRoot2Over2;
this->moveTo(ovalIter.current());
@@ -1061,11 +1031,11 @@
SkPathRef::Editor ed(&fPathRef);
- ed.setIsOval(isOval, kCCW_Direction == dir, startPointIndex % 4);
+ ed.setIsOval(isOval, SkPathDirection::kCCW == dir, startPointIndex % 4);
return *this;
}
-SkPath& SkPath::addCircle(SkScalar x, SkScalar y, SkScalar r, Direction dir) {
+SkPath& SkPath::addCircle(SkScalar x, SkScalar y, SkScalar r, SkPathDirection dir) {
if (r > 0) {
this->addOval(SkRect::MakeLTRB(x - r, y - r, x + r, y + r), dir);
}
@@ -1145,7 +1115,7 @@
// http://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter
// Note that arcSweep bool value is flipped from the original implementation.
SkPath& SkPath::arcTo(SkScalar rx, SkScalar ry, SkScalar angle, SkPath::ArcSize arcLarge,
- SkPath::Direction arcSweep, SkScalar x, SkScalar y) {
+ SkPathDirection arcSweep, SkScalar x, SkScalar y) {
this->injectMoveToIfNeeded();
SkPoint srcPts[2];
this->getLastPt(&srcPts[0]);
@@ -1196,7 +1166,8 @@
SkScalar scaleFactorSquared = SkTMax(1 / d - 0.25f, 0.f);
SkScalar scaleFactor = SkScalarSqrt(scaleFactorSquared);
- if (SkToBool(arcSweep) != SkToBool(arcLarge)) { // flipped from the original implementation
+ if ((arcSweep == SkPathDirection::kCCW) != SkToBool(arcLarge)) {
+ // flipped from the original implementation
scaleFactor = -scaleFactor;
}
delta.scale(scaleFactor);
@@ -1208,9 +1179,11 @@
SkScalar theta1 = SkScalarATan2(unitPts[0].fY, unitPts[0].fX);
SkScalar theta2 = SkScalarATan2(unitPts[1].fY, unitPts[1].fX);
SkScalar thetaArc = theta2 - theta1;
- if (thetaArc < 0 && !arcSweep) { // arcSweep flipped from the original implementation
+ if (thetaArc < 0 && arcSweep == SkPathDirection::kCW) {
+ // arcSweep flipped from the original implementation
thetaArc += SK_ScalarPI * 2;
- } else if (thetaArc > 0 && arcSweep) { // arcSweep flipped from the original implementation
+ } else if (thetaArc > 0 && arcSweep == SkPathDirection::kCCW) {
+ // arcSweep flipped from the original implementation
thetaArc -= SK_ScalarPI * 2;
}
@@ -1270,7 +1243,7 @@
}
SkPath& SkPath::rArcTo(SkScalar rx, SkScalar ry, SkScalar xAxisRotate, SkPath::ArcSize largeArc,
- SkPath::Direction sweep, SkScalar dx, SkScalar dy) {
+ SkPathDirection sweep, SkScalar dx, SkScalar dy) {
SkPoint currentPoint;
this->getLastPt(¤tPoint);
return this->arcTo(rx, ry, xAxisRotate, largeArc, sweep,
@@ -1294,7 +1267,8 @@
// Index 1 is at startAngle == 0.
SkScalar startIndex = std::fmod(startOver90I + 1.f, 4.f);
startIndex = startIndex < 0 ? startIndex + 4.f : startIndex;
- return this->addOval(oval, sweepAngle > 0 ? kCW_Direction : kCCW_Direction,
+ return this->addOval(oval,
+ sweepAngle > 0 ? SkPathDirection::kCW : SkPathDirection::kCCW,
(unsigned) startIndex);
}
}
@@ -1597,7 +1571,7 @@
matrix.mapPoints(ed.writablePoints(), ed.pathRef()->countPoints());
dst->setFirstDirection(SkPathPriv::kUnknown_FirstDirection);
} else {
- Convexity convexity = this->getConvexityOrUnknown();
+ auto convexity = this->getConvexityOrUnknown();
SkPathRef::CreateTransformedCopy(&dst->fPathRef, *fPathRef.get(), matrix);
@@ -1619,7 +1593,7 @@
if (matrix.isScaleTranslate() && SkPathPriv::IsAxisAligned(*this)) {
dst->setConvexity(convexity);
} else {
- dst->setConvexity(kUnknown_Convexity);
+ dst->setConvexity(SkPathConvexityType::kUnknown);
}
if (this->getFirstDirection() == SkPathPriv::kUnknown_FirstDirection) {
@@ -1992,7 +1966,7 @@
struct Convexicator {
Convexicator()
: fPtCount(0)
- , fConvexity(SkPath::kConvex_Convexity)
+ , fConvexity(SkPathConvexityType::kConvex)
, fFirstDirection(SkPathPriv::kUnknown_FirstDirection)
, fIsFinite(true)
, fIsCurve(false)
@@ -2009,7 +1983,7 @@
fSx = fSy = kValueNeverReturnedBySign;
}
- SkPath::Convexity getConvexity() const { return fConvexity; }
+ SkPathConvexityType getConvexity() const { return fConvexity; }
/** The direction returned is only valid if the path is determined convex */
SkPathPriv::FirstDirection getFirstDirection() const { return fFirstDirection; }
@@ -2151,7 +2125,7 @@
SkVector fLastVec, fFirstVec;
int fPtCount; // non-degenerate points
DirChange fExpectedDir;
- SkPath::Convexity fConvexity;
+ SkPathConvexityType fConvexity;
SkPathPriv::FirstDirection fFirstDirection;
int fDx, fDy, fSx, fSy;
bool fIsFinite;
@@ -2294,7 +2268,7 @@
return true;
}
- static SkPath::Convexity BySign(const SkPoint points[], int count) {
+ static SkPathConvexityType BySign(const SkPoint points[], int count) {
const SkPoint* last = points + count;
SkPoint currPt = *points++;
SkPoint firstPt = currPt;
@@ -2308,14 +2282,14 @@
if (!vec.isZero()) {
// give up if vector construction failed
if (!vec.isFinite()) {
- return SkPath::kUnknown_Convexity;
+ return SkPathConvexityType::kUnknown;
}
int sx = sign(vec.fX);
int sy = sign(vec.fY);
dxes += (sx != lastSx);
dyes += (sy != lastSy);
if (dxes > 3 || dyes > 3) {
- return SkPath::kConcave_Convexity;
+ return SkPathConvexityType::kConcave;
}
lastSx = sx;
lastSy = sy;
@@ -2327,7 +2301,7 @@
}
points = &firstPt;
}
- return SkPath::kConvex_Convexity; // that is, it may be convex, don't know yet
+ return SkPathConvexityType::kConvex; // that is, it may be convex, don't know yet
}
bool close() {
@@ -2407,12 +2381,12 @@
bool fIsFinite { true };
};
-SkPath::Convexity SkPath::internalGetConvexity() const {
+SkPathConvexityType SkPath::internalGetConvexity() const {
SkPoint pts[4];
SkPath::Verb verb;
SkPath::Iter iter(*this, true);
- auto setComputedConvexity = [=](Convexity convexity){
- SkASSERT(kUnknown_Convexity != convexity);
+ auto setComputedConvexity = [=](SkPathConvexityType convexity){
+ SkASSERT(SkPathConvexityType::kUnknown != convexity);
this->setConvexity(convexity);
return convexity;
};
@@ -2431,15 +2405,15 @@
++points;
}
--points;
- SkPath::Convexity convexity = Convexicator::BySign(points, (int) (last - points));
- if (SkPath::kConcave_Convexity == convexity) {
- return setComputedConvexity(SkPath::kConcave_Convexity);
- } else if (SkPath::kUnknown_Convexity == convexity) {
- return SkPath::kUnknown_Convexity;
+ SkPathConvexityType convexity = Convexicator::BySign(points, (int) (last - points));
+ if (SkPathConvexityType::kConcave == convexity) {
+ return setComputedConvexity(SkPathConvexityType::kConcave);
+ } else if (SkPathConvexityType::kUnknown == convexity) {
+ return SkPathConvexityType::kUnknown;
}
iter.setPath(*this, true);
} else if (!this->isFinite()) {
- return kUnknown_Convexity;
+ return SkPathConvexityType::kUnknown;
}
int contourCount = 0;
@@ -2447,16 +2421,16 @@
Convexicator state;
auto setFail = [=](){
if (!state.isFinite()) {
- return SkPath::kUnknown_Convexity;
+ return SkPathConvexityType::kUnknown;
}
- return setComputedConvexity(SkPath::kConcave_Convexity);
+ return setComputedConvexity(SkPathConvexityType::kConcave);
};
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
switch (verb) {
case kMove_Verb:
if (++contourCount > 1) {
- return setComputedConvexity(kConcave_Convexity);
+ return setComputedConvexity(SkPathConvexityType::kConcave);
}
state.setMovePt(pts[0]);
count = 0;
@@ -2480,7 +2454,7 @@
break;
default:
SkDEBUGFAIL("bad verb");
- return setComputedConvexity(kConcave_Convexity);
+ return setComputedConvexity(SkPathConvexityType::kConcave);
}
for (int i = 1; i <= count; i++) {
if (!state.addPt(pts[i])) {
@@ -2493,16 +2467,16 @@
if (state.getFirstDirection() == SkPathPriv::kUnknown_FirstDirection
&& !this->getBounds().isEmpty()) {
return setComputedConvexity(state.reversals() < 3 ?
- kConvex_Convexity : kConcave_Convexity);
+ SkPathConvexityType::kConvex : SkPathConvexityType::kConcave);
}
this->setFirstDirection(state.getFirstDirection());
}
- return setComputedConvexity(kConvex_Convexity);
+ return setComputedConvexity(SkPathConvexityType::kConvex);
}
bool SkPathPriv::IsConvex(const SkPoint points[], int count) {
- SkPath::Convexity convexity = Convexicator::BySign(points, count);
- if (SkPath::kConvex_Convexity != convexity) {
+ SkPathConvexityType convexity = Convexicator::BySign(points, count);
+ if (SkPathConvexityType::kConvex != convexity) {
return false;
}
Convexicator state;
@@ -2701,7 +2675,7 @@
// We don't want to pay the cost for computing convexity if it is unknown,
// so we call getConvexityOrUnknown() instead of isConvex().
- if (path.getConvexityOrUnknown() == SkPath::kConvex_Convexity) {
+ if ((SkPathConvexityType)path.getConvexityOrUnknown() == SkPathConvexityType::kConvex) {
SkASSERT(path.getFirstDirection() == kUnknown_FirstDirection);
*dir = static_cast<FirstDirection>(path.getFirstDirection());
return false;
@@ -3224,8 +3198,8 @@
break;
}
} while (!done);
- bool evenOddFill = SkPath::kEvenOdd_FillType == this->getFillType()
- || SkPath::kInverseEvenOdd_FillType == this->getFillType();
+ bool evenOddFill = SkPathFillType::kEvenOdd == (SkPathFillType)this->getFillType()
+ || SkPathFillType::kInverseEvenOdd == (SkPathFillType)this->getFillType();
if (evenOddFill) {
w &= 1;
}
@@ -3294,7 +3268,7 @@
return conic.chopIntoQuadsPOW2(pts, pow2);
}
-bool SkPathPriv::IsSimpleClosedRect(const SkPath& path, SkRect* rect, SkPath::Direction* direction,
+bool SkPathPriv::IsSimpleClosedRect(const SkPath& path, SkRect* rect, SkPathDirection* direction,
unsigned* start) {
if (path.getSegmentMasks() != SkPath::kLine_SegmentMask) {
return false;
@@ -3364,22 +3338,22 @@
switch (sortFlags) {
case 0b00:
rect->setLTRB(rectPts[0].fX, rectPts[0].fY, rectPts[2].fX, rectPts[2].fY);
- *direction = vec03IsVertical ? SkPath::kCW_Direction : SkPath::kCCW_Direction;
+ *direction = vec03IsVertical ? SkPathDirection::kCW : SkPathDirection::kCCW;
*start = 0;
break;
case 0b01:
rect->setLTRB(rectPts[2].fX, rectPts[0].fY, rectPts[0].fX, rectPts[2].fY);
- *direction = vec03IsVertical ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
+ *direction = vec03IsVertical ? SkPathDirection::kCCW : SkPathDirection::kCW;
*start = 1;
break;
case 0b10:
rect->setLTRB(rectPts[0].fX, rectPts[2].fY, rectPts[2].fX, rectPts[0].fY);
- *direction = vec03IsVertical ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
+ *direction = vec03IsVertical ? SkPathDirection::kCCW : SkPathDirection::kCW;
*start = 3;
break;
case 0b11:
rect->setLTRB(rectPts[2].fX, rectPts[2].fY, rectPts[0].fX, rectPts[0].fY);
- *direction = vec03IsVertical ? SkPath::kCW_Direction : SkPath::kCCW_Direction;
+ *direction = vec03IsVertical ? SkPathDirection::kCW : SkPathDirection::kCCW;
*start = 2;
break;
}
@@ -3407,7 +3381,7 @@
path->reset();
path->setIsVolatile(true);
- path->setFillType(SkPath::kWinding_FillType);
+ path->setFillType(SkPathFillType::kWinding);
if (isFillNoPathEffect && SkScalarAbs(sweepAngle) >= 360.f) {
path->addOval(oval);
SkASSERT(path->isConvex() && DrawArcIsConvex(sweepAngle, false, isFillNoPathEffect));
@@ -3441,7 +3415,7 @@
if (useCenter) {
path->close();
}
- path->setConvexity(convex ? SkPath::kConvex_Convexity : SkPath::kConcave_Convexity);
+ path->setConvexity(convex ? SkPathConvexityType::kConvex : SkPathConvexityType::kConcave);
path->setFirstDirection(firstDir);
}
@@ -3560,7 +3534,7 @@
//////////////////////////////////////////////////////////////////////////////////////////////////
bool SkPathPriv::IsRectContour(const SkPath& path, bool allowPartial, int* currVerb,
- const SkPoint** ptsPtr, bool* isClosed, SkPath::Direction* direction,
+ const SkPoint** ptsPtr, bool* isClosed, SkPathDirection* direction,
SkRect* rect) {
int corners = 0;
SkPoint closeXY; // used to determine if final line falls on a diagonal
@@ -3693,17 +3667,17 @@
}
if (direction) {
*direction = directions[0] == ((directions[1] + 1) & 3) ?
- SkPath::kCW_Direction : SkPath::kCCW_Direction;
+ SkPathDirection::kCW : SkPathDirection::kCCW;
}
return true;
}
-bool SkPathPriv::IsNestedFillRects(const SkPath& path, SkRect rects[2], SkPath::Direction dirs[2]) {
+bool SkPathPriv::IsNestedFillRects(const SkPath& path, SkRect rects[2], SkPathDirection dirs[2]) {
SkDEBUGCODE(path.validate();)
int currVerb = 0;
const SkPoint* pts = path.fPathRef->points();
- SkPath::Direction testDirs[2];
+ SkPathDirection testDirs[2];
SkRect testRects[2];
if (!IsRectContour(path, true, &currVerb, &pts, nullptr, &testDirs[0], &testRects[0])) {
return false;
diff --git a/src/core/SkPathMakers.h b/src/core/SkPathMakers.h
index a4ef7e1..8e668e5 100644
--- a/src/core/SkPathMakers.h
+++ b/src/core/SkPathMakers.h
@@ -8,15 +8,15 @@
#ifndef SkPathMakers_DEFINED
#define SkPathMakers_DEFINED
-#include "include/core/SkPath.h" // just for direction
+#include "include/core/SkPathTypes.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRRect.h"
template <unsigned N> class SkPath_PointIterator {
public:
- SkPath_PointIterator(SkPath::Direction dir, unsigned startIndex)
+ SkPath_PointIterator(SkPathDirection dir, unsigned startIndex)
: fCurrent(startIndex % N)
- , fAdvance(dir == SkPath::kCW_Direction ? 1 : N - 1) { }
+ , fAdvance(dir == SkPathDirection::kCW ? 1 : N - 1) { }
const SkPoint& current() const {
SkASSERT(fCurrent < N);
@@ -38,7 +38,7 @@
class SkPath_RectPointIterator : public SkPath_PointIterator<4> {
public:
- SkPath_RectPointIterator(const SkRect& rect, SkPath::Direction dir, unsigned startIndex)
+ SkPath_RectPointIterator(const SkRect& rect, SkPathDirection dir, unsigned startIndex)
: SkPath_PointIterator(dir, startIndex) {
fPts[0] = SkPoint::Make(rect.fLeft, rect.fTop);
@@ -50,7 +50,7 @@
class SkPath_OvalPointIterator : public SkPath_PointIterator<4> {
public:
- SkPath_OvalPointIterator(const SkRect& oval, SkPath::Direction dir, unsigned startIndex)
+ SkPath_OvalPointIterator(const SkRect& oval, SkPathDirection dir, unsigned startIndex)
: SkPath_PointIterator(dir, startIndex) {
const SkScalar cx = oval.centerX();
@@ -65,7 +65,7 @@
class SkPath_RRectPointIterator : public SkPath_PointIterator<8> {
public:
- SkPath_RRectPointIterator(const SkRRect& rrect, SkPath::Direction dir, unsigned startIndex)
+ SkPath_RRectPointIterator(const SkRRect& rrect, SkPathDirection dir, unsigned startIndex)
: SkPath_PointIterator(dir, startIndex) {
const SkRect& bounds = rrect.getBounds();
diff --git a/src/core/SkPathPriv.h b/src/core/SkPathPriv.h
index 7fc5966..c3f571e 100644
--- a/src/core/SkPathPriv.h
+++ b/src/core/SkPathPriv.h
@@ -10,6 +10,11 @@
#include "include/core/SkPath.h"
+static_assert(0 == static_cast<int>(SkPathFillType::kWinding), "fill_type_mismatch");
+static_assert(1 == static_cast<int>(SkPathFillType::kEvenOdd), "fill_type_mismatch");
+static_assert(2 == static_cast<int>(SkPathFillType::kInverseWinding), "fill_type_mismatch");
+static_assert(3 == static_cast<int>(SkPathFillType::kInverseEvenOdd), "fill_type_mismatch");
+
class SkPathPriv {
public:
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
@@ -24,7 +29,7 @@
kUnknown_FirstDirection,
};
- static FirstDirection AsFirstDirection(SkPath::Direction dir) {
+ static FirstDirection AsFirstDirection(SkPathDirection dir) {
// since we agree numerically for the values in Direction, we can just cast.
return (FirstDirection)dir;
}
@@ -96,7 +101,7 @@
* followed by four lines or a move followed by 3 lines and a close. None of the parameters are
* optional. This does not permit degenerate line or point rectangles.
*/
- static bool IsSimpleClosedRect(const SkPath& path, SkRect* rect, SkPath::Direction* direction,
+ static bool IsSimpleClosedRect(const SkPath& path, SkRect* rect, SkPathDirection* direction,
unsigned* start);
/**
@@ -192,11 +197,11 @@
@param start storage for start of oval; may be nullptr
@return true if SkPath was constructed by method that reduces to oval
*/
- static bool IsOval(const SkPath& path, SkRect* rect, SkPath::Direction* dir, unsigned* start) {
+ static bool IsOval(const SkPath& path, SkRect* rect, SkPathDirection* dir, unsigned* start) {
bool isCCW = false;
bool result = path.fPathRef->isOval(rect, &isCCW, start);
if (dir && result) {
- *dir = isCCW ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
+ *dir = isCCW ? SkPathDirection::kCCW : SkPathDirection::kCW;
}
return result;
}
@@ -219,12 +224,12 @@
@param start storage for start of SkRRect; may be nullptr
@return true if SkPath contains only SkRRect
*/
- static bool IsRRect(const SkPath& path, SkRRect* rrect, SkPath::Direction* dir,
+ static bool IsRRect(const SkPath& path, SkRRect* rrect, SkPathDirection* dir,
unsigned* start) {
bool isCCW = false;
bool result = path.fPathRef->isRRect(rrect, &isCCW, start);
if (dir && result) {
- *dir = isCCW ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
+ *dir = isCCW ? SkPathDirection::kCCW : SkPathDirection::kCW;
}
return result;
}
@@ -282,7 +287,7 @@
}
static bool IsRectContour(const SkPath&, bool allowPartial, int* currVerb,
- const SkPoint** ptsPtr, bool* isClosed, SkPath::Direction* direction,
+ const SkPoint** ptsPtr, bool* isClosed, SkPathDirection* direction,
SkRect* rect);
/** Returns true if SkPath is equivalent to nested SkRect pair when filled.
@@ -297,7 +302,22 @@
@return true if SkPath contains nested SkRect pair
*/
static bool IsNestedFillRects(const SkPath&, SkRect rect[2],
- SkPath::Direction dirs[2] = nullptr);
+ SkPathDirection dirs[2] = nullptr);
+
+ static bool IsInverseFillType(SkPathFillType fill) {
+ return (static_cast<int>(fill) & 2) != 0;
+ }
+
+ /** Returns equivalent SkPath::FillType representing SkPath fill inside its bounds.
+ .
+
+ @param fill one of: kWinding_FillType, kEvenOdd_FillType,
+ kInverseWinding_FillType, kInverseEvenOdd_FillType
+ @return fill, or kWinding_FillType or kEvenOdd_FillType if fill is inverted
+ */
+ static SkPathFillType ConvertToNonInverseFillType(SkPathFillType fill) {
+ return (SkPathFillType)(static_cast<int>(fill) & 1);
+ }
};
// Lightweight variant of SkPath::Iter that only returns segments (e.g. lines/conics).
diff --git a/src/core/SkStroke.cpp b/src/core/SkStroke.cpp
index ecfefdf..098251e 100644
--- a/src/core/SkStroke.cpp
+++ b/src/core/SkStroke.cpp
@@ -1391,7 +1391,7 @@
{
SkRect rect;
bool isClosed;
- SkPath::Direction dir;
+ SkPathDirection dir;
if (src.isRect(&rect, &isClosed, &dir) && isClosed) {
this->strokeRect(rect, dst, dir);
// our answer should preserve the inverseness of the src
@@ -1498,15 +1498,15 @@
}
}
-static SkPath::Direction reverse_direction(SkPath::Direction dir) {
- static const SkPath::Direction gOpposite[] = { SkPath::kCCW_Direction, SkPath::kCW_Direction };
- return gOpposite[dir];
+static SkPathDirection reverse_direction(SkPathDirection dir) {
+ static const SkPathDirection gOpposite[] = { SkPathDirection::kCCW, SkPathDirection::kCW };
+ return gOpposite[(unsigned)dir];
}
-static void addBevel(SkPath* path, const SkRect& r, const SkRect& outer, SkPath::Direction dir) {
+static void addBevel(SkPath* path, const SkRect& r, const SkRect& outer, SkPathDirection dir) {
SkPoint pts[8];
- if (SkPath::kCW_Direction == dir) {
+ if (SkPathDirection::kCW == dir) {
pts[0].set(r.fLeft, outer.fTop);
pts[1].set(r.fRight, outer.fTop);
pts[2].set(outer.fRight, r.fTop);
@@ -1529,7 +1529,7 @@
}
void SkStroke::strokeRect(const SkRect& origRect, SkPath* dst,
- SkPath::Direction dir) const {
+ SkPathDirection dir) const {
SkASSERT(dst != nullptr);
dst->reset();
@@ -1565,7 +1565,7 @@
addBevel(dst, rect, r, dir);
break;
case SkPaint::kRound_Join:
- dst->addRoundRect(r, radius, radius, dir);
+ dst->addRRect(SkRRect::MakeRectXY(r, radius, radius), dir);
break;
default:
break;
diff --git a/src/core/SkStroke.h b/src/core/SkStroke.h
index 66edf3d..b0458d3 100644
--- a/src/core/SkStroke.h
+++ b/src/core/SkStroke.h
@@ -62,7 +62,7 @@
* Stroke the specified rect, winding it in the specified direction..
*/
void strokeRect(const SkRect& rect, SkPath* result,
- SkPath::Direction = SkPath::kCW_Direction) const;
+ SkPathDirection = SkPathDirection::kCW) const;
void strokePath(const SkPath& path, SkPath*) const;
////////////////////////////////////////////////////////////////
diff --git a/src/effects/SkDashPathEffect.cpp b/src/effects/SkDashPathEffect.cpp
index 913d851..a13fa07 100644
--- a/src/effects/SkDashPathEffect.cpp
+++ b/src/effects/SkDashPathEffect.cpp
@@ -297,8 +297,8 @@
}
if (clampedInitialDashLength < fIntervals[0]) {
// This one will not be like the others
- results->fFirst.addRect(x - halfWidth, y - halfHeight,
- x + halfWidth, y + halfHeight);
+ results->fFirst.addRect({x - halfWidth, y - halfHeight,
+ x + halfWidth, y + halfHeight});
} else {
SkASSERT(curPt < results->fNumPoints);
results->fPoints[curPt].set(x, y);
@@ -346,8 +346,7 @@
halfWidth = SkScalarHalf(rec.getWidth());
halfHeight = SkScalarHalf(temp);
}
- results->fLast.addRect(x - halfWidth, y - halfHeight,
- x + halfWidth, y + halfHeight);
+ results->fLast.addRect({x - halfWidth, y - halfHeight, x + halfWidth, y + halfHeight});
}
SkASSERT(curPt == results->fNumPoints);
diff --git a/src/gpu/GrDistanceFieldGenFromVector.cpp b/src/gpu/GrDistanceFieldGenFromVector.cpp
index 29aa16d..fc505e5 100644
--- a/src/gpu/GrDistanceFieldGenFromVector.cpp
+++ b/src/gpu/GrDistanceFieldGenFromVector.cpp
@@ -763,7 +763,7 @@
workingPath = path;
}
- if (!IsDistanceFieldSupportedFillType(workingPath.getFillType())) {
+ if (!IsDistanceFieldSupportedFillType((SkPathFillType)workingPath.getFillType())) {
return false;
}
@@ -829,15 +829,19 @@
kOutside = 1
} dfSign;
- if (workingPath.getFillType() == SkPath::kWinding_FillType) {
- dfSign = windingNumber ? kInside : kOutside;
- } else if (workingPath.getFillType() == SkPath::kInverseWinding_FillType) {
- dfSign = windingNumber ? kOutside : kInside;
- } else if (workingPath.getFillType() == SkPath::kEvenOdd_FillType) {
- dfSign = (windingNumber % 2) ? kInside : kOutside;
- } else {
- SkASSERT(workingPath.getFillType() == SkPath::kInverseEvenOdd_FillType);
- dfSign = (windingNumber % 2) ? kOutside : kInside;
+ switch ((SkPathFillType)workingPath.getFillType()) {
+ case SkPathFillType::kWinding:
+ dfSign = windingNumber ? kInside : kOutside;
+ break;
+ case SkPathFillType::kInverseWinding:
+ dfSign = windingNumber ? kOutside : kInside;
+ break;
+ case SkPathFillType::kEvenOdd:
+ dfSign = (windingNumber % 2) ? kInside : kOutside;
+ break;
+ case SkPathFillType::kInverseEvenOdd:
+ dfSign = (windingNumber % 2) ? kOutside : kInside;
+ break;
}
// The winding number at the end of a scanline should be zero.
diff --git a/src/gpu/GrDistanceFieldGenFromVector.h b/src/gpu/GrDistanceFieldGenFromVector.h
index 8e8d1b3..0362166 100644
--- a/src/gpu/GrDistanceFieldGenFromVector.h
+++ b/src/gpu/GrDistanceFieldGenFromVector.h
@@ -30,10 +30,10 @@
const SkPath& path, const SkMatrix& viewMatrix,
int width, int height, size_t rowBytes);
-inline bool IsDistanceFieldSupportedFillType(SkPath::FillType fFillType)
+inline bool IsDistanceFieldSupportedFillType(SkPathFillType fFillType)
{
- return (SkPath::kEvenOdd_FillType == fFillType ||
- SkPath::kInverseEvenOdd_FillType == fFillType);
+ return (SkPathFillType::kEvenOdd == fFillType ||
+ SkPathFillType::kInverseEvenOdd == fFillType);
}
#endif
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index dd3472c..edb7611 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -1493,7 +1493,7 @@
assert_alive(paint);
this->drawShapeUsingPathRenderer(
clip, std::move(paint), aa, viewMatrix,
- GrShape(SkRRect::MakeOval(oval), SkPath::kCW_Direction, 2, false, style));
+ GrShape(SkRRect::MakeOval(oval), SkPathDirection::kCW, 2, false, style));
}
void GrRenderTargetContext::drawArc(const GrClip& clip,
diff --git a/src/gpu/GrTestUtils.cpp b/src/gpu/GrTestUtils.cpp
index c6e95a3..cabac43 100644
--- a/src/gpu/GrTestUtils.cpp
+++ b/src/gpu/GrTestUtils.cpp
@@ -232,7 +232,7 @@
gPath[2].lineTo(-50.0f, 31.0f);
for (size_t i = 0; i < SK_ARRAY_COUNT(gPath); i++) {
- SkASSERT(SkPath::kConvex_Convexity == gPath[i].getConvexity());
+ SkASSERT(SkPathConvexityType::kConvex == (SkPathConvexityType)gPath[i].getConvexity());
}
}
diff --git a/src/gpu/ccpr/GrCCFiller.cpp b/src/gpu/ccpr/GrCCFiller.cpp
index 9c09b4a..9a6c9dd 100644
--- a/src/gpu/ccpr/GrCCFiller.cpp
+++ b/src/gpu/ccpr/GrCCFiller.cpp
@@ -135,7 +135,7 @@
// We use "winding" fill type right now because we are producing a coverage count, and must
// fill in every region that has non-zero wind. The path processor will convert coverage
// count to the appropriate fill type later.
- fan.setFillType(SkPath::kWinding_FillType);
+ fan.setFillType(SkPathFillType::kWinding);
} else {
// When counting winding numbers in the stencil buffer, it works to just tessellate the
// Redbook fan with the same fill type as the path.
diff --git a/src/gpu/geometry/GrShape.cpp b/src/gpu/geometry/GrShape.cpp
index 4fc3472..a510a19 100644
--- a/src/gpu/geometry/GrShape.cpp
+++ b/src/gpu/geometry/GrShape.cpp
@@ -201,7 +201,7 @@
const int conicWeightCnt = SkPathPriv::ConicWeightCnt(path);
SkASSERT(verbCnt <= GrShape::kMaxKeyFromDataVerbCnt);
SkASSERT(pointCnt && verbCnt);
- *key++ = path.getFillType();
+ *key++ = (uint32_t)path.getFillType();
*key++ = verbCnt;
memcpy(key, SkPathPriv::VerbData(path), verbCnt * sizeof(uint8_t));
int verbKeySize = SkAlign4(verbCnt);
@@ -273,7 +273,7 @@
case Type::kRRect:
fRRectData.fRRect.writeToMemory(key);
key += SkRRect::kSizeInMemory / sizeof(uint32_t);
- *key = (fRRectData.fDir == SkPath::kCCW_Direction) ? (1 << 31) : 0;
+ *key = (fRRectData.fDir == SkPathDirection::kCCW) ? (1 << 31) : 0;
*key |= fRRectData.fInverted ? (1 << 30) : 0;
*key++ |= fRRectData.fStart;
SkASSERT(fRRectData.fStart < 8);
@@ -297,7 +297,7 @@
*key++ = fPathData.fGenID;
// We could canonicalize the fill rule for paths that don't differentiate between
// even/odd or winding fill (e.g. convex).
- *key++ = this->path().getFillType();
+ *key++ = (uint32_t)this->path().getFillType();
break;
}
}
@@ -507,7 +507,7 @@
void GrShape::attemptToSimplifyPath() {
SkRect rect;
SkRRect rrect;
- SkPath::Direction rrectDir;
+ SkPathDirection rrectDir;
unsigned rrectStart;
bool inverted = this->path().isInverseFillType();
SkPoint pts[2];
diff --git a/src/gpu/geometry/GrShape.h b/src/gpu/geometry/GrShape.h
index 37f38f8..8771c94 100644
--- a/src/gpu/geometry/GrShape.h
+++ b/src/gpu/geometry/GrShape.h
@@ -61,7 +61,7 @@
this->attemptToSimplifyRRect();
}
- GrShape(const SkRRect& rrect, SkPath::Direction dir, unsigned start, bool inverted,
+ GrShape(const SkRRect& rrect, SkPathDirection dir, unsigned start, bool inverted,
const GrStyle& style)
: fStyle(style) {
this->initType(Type::kRRect);
@@ -160,7 +160,7 @@
}
/** Returns the unstyled geometry as a rrect if possible. */
- bool asRRect(SkRRect* rrect, SkPath::Direction* dir, unsigned* start, bool* inverted) const {
+ bool asRRect(SkRRect* rrect, SkPathDirection* dir, unsigned* start, bool* inverted) const {
if (Type::kRRect != fType) {
return false;
}
@@ -255,12 +255,12 @@
return false;
}
- SkPath::Direction dirs[2];
+ SkPathDirection dirs[2];
if (!SkPathPriv::IsNestedFillRects(this->path(), rects, dirs)) {
return false;
}
- if (SkPath::kWinding_FillType == this->path().getFillType() && dirs[0] == dirs[1]) {
+ if (SkPathFillType::kWinding == (SkPathFillType)this->path().getFillType() && dirs[0] == dirs[1]) {
// The two rects need to be wound opposite to each other
return false;
}
@@ -550,15 +550,15 @@
const SkPath* originalPathForListeners() const;
// Defaults to use when there is no distinction between even/odd and winding fills.
- static constexpr SkPath::FillType kDefaultPathFillType = SkPath::kEvenOdd_FillType;
- static constexpr SkPath::FillType kDefaultPathInverseFillType =
- SkPath::kInverseEvenOdd_FillType;
+ static constexpr SkPathFillType kDefaultPathFillType = SkPathFillType::kEvenOdd;
+ static constexpr SkPathFillType kDefaultPathInverseFillType =
+ SkPathFillType::kInverseEvenOdd;
- static constexpr SkPath::Direction kDefaultRRectDir = SkPath::kCW_Direction;
+ static constexpr SkPathDirection kDefaultRRectDir = SkPathDirection::kCW;
static constexpr unsigned kDefaultRRectStart = 0;
static unsigned DefaultRectDirAndStartIndex(const SkRect& rect, bool hasPathEffect,
- SkPath::Direction* dir) {
+ SkPathDirection* dir) {
*dir = kDefaultRRectDir;
// This comes from SkPath's interface. The default for adding a SkRect is counter clockwise
// beginning at index 0 (which happens to correspond to rrect index 0 or 7).
@@ -575,11 +575,11 @@
// 0 becomes start index 2 and times 2 to convert from rect the rrect indices.
return 2 * 2;
} else if (swapX) {
- *dir = SkPath::kCCW_Direction;
+ *dir = SkPathDirection::kCCW;
// 0 becomes start index 1 and times 2 to convert from rect the rrect indices.
return 2 * 1;
} else if (swapY) {
- *dir = SkPath::kCCW_Direction;
+ *dir = SkPathDirection::kCCW;
// 0 becomes start index 3 and times 2 to convert from rect the rrect indices.
return 2 * 3;
}
@@ -587,7 +587,7 @@
}
static unsigned DefaultRRectDirAndStartIndex(const SkRRect& rrect, bool hasPathEffect,
- SkPath::Direction* dir) {
+ SkPathDirection* dir) {
// This comes from SkPath's interface. The default for adding a SkRRect to a path is
// clockwise beginning at starting index 6.
static constexpr unsigned kPathRRectStartIdx = 6;
@@ -602,7 +602,7 @@
union {
struct {
SkRRect fRRect;
- SkPath::Direction fDir;
+ SkPathDirection fDir;
unsigned fStart;
bool fInverted;
} fRRectData;
diff --git a/src/gpu/ops/GrAAConvexTessellator.cpp b/src/gpu/ops/GrAAConvexTessellator.cpp
index 9952491..9468692 100644
--- a/src/gpu/ops/GrAAConvexTessellator.cpp
+++ b/src/gpu/ops/GrAAConvexTessellator.cpp
@@ -369,7 +369,7 @@
}
bool GrAAConvexTessellator::extractFromPath(const SkMatrix& m, const SkPath& path) {
- SkASSERT(SkPath::kConvex_Convexity == path.getConvexity());
+ SkASSERT(SkPathConvexityType::kConvex == (SkPathConvexityType)path.getConvexity());
SkRect bounds = path.getBounds();
m.mapRect(&bounds);
diff --git a/src/pathops/SkOpBuilder.cpp b/src/pathops/SkOpBuilder.cpp
index 9dac160..bada1c4 100644
--- a/src/pathops/SkOpBuilder.cpp
+++ b/src/pathops/SkOpBuilder.cpp
@@ -36,11 +36,11 @@
}
bool SkOpBuilder::FixWinding(SkPath* path) {
- SkPath::FillType fillType = path->getFillType();
- if (fillType == SkPath::kInverseEvenOdd_FillType) {
- fillType = SkPath::kInverseWinding_FillType;
- } else if (fillType == SkPath::kEvenOdd_FillType) {
- fillType = SkPath::kWinding_FillType;
+ SkPathFillType fillType = (SkPathFillType)path->getFillType();
+ if (fillType == SkPathFillType::kInverseEvenOdd) {
+ fillType = SkPathFillType::kInverseWinding;
+ } else if (fillType == SkPathFillType::kEvenOdd) {
+ fillType = SkPathFillType::kWinding;
}
SkPathPriv::FirstDirection dir;
if (one_contour(*path) && SkPathPriv::CheapComputeFirstDirection(*path, &dir)) {
diff --git a/src/pathops/SkOpEdgeBuilder.cpp b/src/pathops/SkOpEdgeBuilder.cpp
index 3efb0e0..7e97c03 100644
--- a/src/pathops/SkOpEdgeBuilder.cpp
+++ b/src/pathops/SkOpEdgeBuilder.cpp
@@ -10,7 +10,7 @@
void SkOpEdgeBuilder::init() {
fOperand = false;
- fXorMask[0] = fXorMask[1] = (fPath->getFillType() & 1) ? kEvenOdd_PathOpsMask
+ fXorMask[0] = fXorMask[1] = ((int)fPath->getFillType() & 1) ? kEvenOdd_PathOpsMask
: kWinding_PathOpsMask;
fUnparseable = false;
fSecondHalf = preFetch();
@@ -40,7 +40,7 @@
SkASSERT(fPathVerbs.count() > 0 && fPathVerbs.end()[-1] == SkPath::kDone_Verb);
fPathVerbs.pop();
fPath = &path;
- fXorMask[1] = (fPath->getFillType() & 1) ? kEvenOdd_PathOpsMask
+ fXorMask[1] = ((int)fPath->getFillType() & 1) ? kEvenOdd_PathOpsMask
: kWinding_PathOpsMask;
preFetch();
}
diff --git a/src/pathops/SkPathOpsAsWinding.cpp b/src/pathops/SkPathOpsAsWinding.cpp
index 80e52be..c415087 100644
--- a/src/pathops/SkPathOpsAsWinding.cpp
+++ b/src/pathops/SkPathOpsAsWinding.cpp
@@ -367,7 +367,7 @@
const SkPath& fPath;
};
-static bool set_result_path(SkPath* result, const SkPath& path, SkPath::FillType fillType) {
+static bool set_result_path(SkPath* result, const SkPath& path, SkPathFillType fillType) {
*result = path;
result->setFillType(fillType);
return true;
@@ -377,13 +377,13 @@
if (!path.isFinite()) {
return false;
}
- SkPath::FillType fillType = path.getFillType();
- if (fillType == SkPath::kWinding_FillType
- || fillType == SkPath::kInverseWinding_FillType ) {
+ SkPathFillType fillType = (SkPathFillType)path.getFillType();
+ if (fillType == SkPathFillType::kWinding
+ || fillType == SkPathFillType::kInverseWinding ) {
return set_result_path(result, path, fillType);
}
- fillType = path.isInverseFillType() ? SkPath::kInverseWinding_FillType :
- SkPath::kWinding_FillType;
+ fillType = path.isInverseFillType() ? SkPathFillType::kInverseWinding :
+ SkPathFillType::kWinding;
if (path.isEmpty() || path.isConvex()) {
return set_result_path(result, path, fillType);
}
diff --git a/src/pathops/SkPathOpsDebug.cpp b/src/pathops/SkPathOpsDebug.cpp
index 7ee44de..367de68 100644
--- a/src/pathops/SkPathOpsDebug.cpp
+++ b/src/pathops/SkPathOpsDebug.cpp
@@ -2927,12 +2927,12 @@
return;
}
#endif
- SkPath::FillType fillType = path.getFillType();
- SkASSERT(fillType >= SkPath::kWinding_FillType && fillType <= SkPath::kInverseEvenOdd_FillType);
+ SkPathFillType fillType = (SkPathFillType)path.getFillType();
+ SkASSERT(fillType >= SkPathFillType::kWinding && fillType <= SkPathFillType::kInverseEvenOdd);
if (includeDeclaration) {
SkDebugf(" SkPath %s;\n", name);
}
- SkDebugf(" %s.setFillType(SkPath::%s);\n", name, gFillTypeStr[fillType]);
+ SkDebugf(" %s.setFillType(SkPath::%s);\n", name, gFillTypeStr[(unsigned)fillType]);
iter.setPath(path);
showPathContours(iter, name);
}
diff --git a/src/pathops/SkPathOpsOp.cpp b/src/pathops/SkPathOpsOp.cpp
index 825ae7b1..2c89f35 100644
--- a/src/pathops/SkPathOpsOp.cpp
+++ b/src/pathops/SkPathOpsOp.cpp
@@ -248,8 +248,8 @@
#endif
op = gOpInverse[op][one.isInverseFillType()][two.isInverseFillType()];
bool inverseFill = gOutInverse[op][one.isInverseFillType()][two.isInverseFillType()];
- SkPath::FillType fillType = inverseFill ? SkPath::kInverseEvenOdd_FillType :
- SkPath::kEvenOdd_FillType;
+ SkPathFillType fillType = inverseFill ? SkPathFillType::kInverseEvenOdd :
+ SkPathFillType::kEvenOdd;
SkRect rect1, rect2;
if (kIntersect_SkPathOp == op && one.isRect(&rect1) && two.isRect(&rect2)) {
result->reset();
diff --git a/src/pathops/SkPathOpsSimplify.cpp b/src/pathops/SkPathOpsSimplify.cpp
index f079b50..6c522f4 100644
--- a/src/pathops/SkPathOpsSimplify.cpp
+++ b/src/pathops/SkPathOpsSimplify.cpp
@@ -140,8 +140,8 @@
bool SimplifyDebug(const SkPath& path, SkPath* result
SkDEBUGPARAMS(bool skipAssert) SkDEBUGPARAMS(const char* testName)) {
// returns 1 for evenodd, -1 for winding, regardless of inverse-ness
- SkPath::FillType fillType = path.isInverseFillType() ? SkPath::kInverseEvenOdd_FillType
- : SkPath::kEvenOdd_FillType;
+ SkPathFillType fillType = path.isInverseFillType() ? SkPathFillType::kInverseEvenOdd
+ : SkPathFillType::kEvenOdd;
if (path.isConvex()) {
if (result != &path) {
*result = path;
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 3ed6f797..1b98c14 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -511,7 +511,8 @@
maskDevice->makeFormXObjectFromDevice(dstMaskBounds, true), false,
SkPDFGraphicState::kLuminosity_SMaskMode, fDocument), content.stream());
SkPDFUtils::AppendRectangle(SkRect::Make(dstMaskBounds), content.stream());
- SkPDFUtils::PaintPath(SkPaint::kFill_Style, path.getFillType(), content.stream());
+ SkPDFUtils::PaintPath(SkPaint::kFill_Style, (SkPathFillType)path.getFillType(),
+ content.stream());
this->clearMaskOnGraphicState(content.stream());
}
@@ -598,7 +599,8 @@
paint->getStrokeCap() != SkPaint::kSquare_Cap);
SkPDFUtils::EmitPath(*pathPtr, paint->getStyle(), consumeDegeratePathSegments, content.stream(),
tolerance);
- SkPDFUtils::PaintPath(paint->getStyle(), pathPtr->getFillType(), content.stream());
+ SkPDFUtils::PaintPath(paint->getStyle(), (SkPathFillType)pathPtr->getFillType(),
+ content.stream());
}
////////////////////////////////////////////////////////////////////////////////
@@ -1568,7 +1570,7 @@
maskDevice->makeFormXObjectFromDevice(maskDeviceBounds, true), false,
SkPDFGraphicState::kLuminosity_SMaskMode, fDocument), content.stream());
SkPDFUtils::AppendRectangle(SkRect::Make(this->size()), content.stream());
- SkPDFUtils::PaintPath(SkPaint::kFill_Style, SkPath::kWinding_FillType, content.stream());
+ SkPDFUtils::PaintPath(SkPaint::kFill_Style, SkPathFillType::kWinding, content.stream());
this->clearMaskOnGraphicState(content.stream());
return;
}
diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp
index ba79a15..ff8a61e 100644
--- a/src/pdf/SkPDFFont.cpp
+++ b/src/pdf/SkPDFFont.cpp
@@ -573,7 +573,8 @@
if (path && !path->isEmpty()) {
setGlyphWidthAndBoundingBox(glyph->advanceX(), glyphBBox, &content);
SkPDFUtils::EmitPath(*path, SkPaint::kFill_Style, &content);
- SkPDFUtils::PaintPath(SkPaint::kFill_Style, path->getFillType(), &content);
+ SkPDFUtils::PaintPath(SkPaint::kFill_Style, (SkPathFillType)path->getFillType(),
+ &content);
} else {
auto pimg = to_image(gID, cache.get());
if (!pimg.fImage) {
diff --git a/src/pdf/SkPDFGradientShader.cpp b/src/pdf/SkPDFGradientShader.cpp
index 919c07a5..ad2a65d 100644
--- a/src/pdf/SkPDFGradientShader.cpp
+++ b/src/pdf/SkPDFGradientShader.cpp
@@ -780,7 +780,7 @@
}
SkPDFUtils::ApplyPattern(patternIndex, &content);
SkPDFUtils::AppendRectangle(bounds, &content);
- SkPDFUtils::PaintPath(SkPaint::kFill_Style, SkPath::kEvenOdd_FillType, &content);
+ SkPDFUtils::PaintPath(SkPaint::kFill_Style, SkPathFillType::kEvenOdd, &content);
return content.detachAsStream();
}
diff --git a/src/pdf/SkPDFGraphicStackState.cpp b/src/pdf/SkPDFGraphicStackState.cpp
index a27170b..89aa6cf 100644
--- a/src/pdf/SkPDFGraphicStackState.cpp
+++ b/src/pdf/SkPDFGraphicStackState.cpp
@@ -104,10 +104,10 @@
static void append_clip_path(const SkPath& clipPath, SkWStream* wStream) {
SkPDFUtils::EmitPath(clipPath, SkPaint::kFill_Style, wStream);
- SkPath::FillType clipFill = clipPath.getFillType();
- NOT_IMPLEMENTED(clipFill == SkPath::kInverseEvenOdd_FillType, false);
- NOT_IMPLEMENTED(clipFill == SkPath::kInverseWinding_FillType, false);
- if (clipFill == SkPath::kEvenOdd_FillType) {
+ SkPathFillType clipFill = (SkPathFillType)clipPath.getFillType();
+ NOT_IMPLEMENTED(clipFill == SkPathFillType::kInverseEvenOdd, false);
+ NOT_IMPLEMENTED(clipFill == SkPathFillType::kInverseWinding, false);
+ if (clipFill == SkPathFillType::kEvenOdd) {
wStream->writeText("W* n\n");
} else {
wStream->writeText("W n\n");
diff --git a/src/pdf/SkPDFUtils.cpp b/src/pdf/SkPDFUtils.cpp
index 9beedfb..a29cee7 100644
--- a/src/pdf/SkPDFUtils.cpp
+++ b/src/pdf/SkPDFUtils.cpp
@@ -213,7 +213,7 @@
content->writeText("h\n");
}
-void SkPDFUtils::PaintPath(SkPaint::Style style, SkPath::FillType fill,
+void SkPDFUtils::PaintPath(SkPaint::Style style, SkPathFillType fill,
SkWStream* content) {
if (style == SkPaint::kFill_Style) {
content->writeText("f");
@@ -224,9 +224,9 @@
}
if (style != SkPaint::kStroke_Style) {
- NOT_IMPLEMENTED(fill == SkPath::kInverseEvenOdd_FillType, false);
- NOT_IMPLEMENTED(fill == SkPath::kInverseWinding_FillType, false);
- if (fill == SkPath::kEvenOdd_FillType) {
+ NOT_IMPLEMENTED(fill == SkPathFillType::kInverseEvenOdd, false);
+ NOT_IMPLEMENTED(fill == SkPathFillType::kInverseWinding, false);
+ if (fill == SkPathFillType::kEvenOdd) {
content->writeText("*");
}
}
@@ -235,7 +235,7 @@
void SkPDFUtils::StrokePath(SkWStream* content) {
SkPDFUtils::PaintPath(
- SkPaint::kStroke_Style, SkPath::kWinding_FillType, content);
+ SkPaint::kStroke_Style, SkPathFillType::kWinding, content);
}
void SkPDFUtils::ApplyGraphicState(int objectIndex, SkWStream* content) {
diff --git a/src/pdf/SkPDFUtils.h b/src/pdf/SkPDFUtils.h
index 90b1c57..45218e6 100644
--- a/src/pdf/SkPDFUtils.h
+++ b/src/pdf/SkPDFUtils.h
@@ -58,7 +58,7 @@
SkPDFUtils::EmitPath(path, paintStyle, true, content, tolerance);
}
void ClosePath(SkWStream* content);
-void PaintPath(SkPaint::Style style, SkPath::FillType fill,
+void PaintPath(SkPaint::Style style, SkPathFillType fill,
SkWStream* content);
void StrokePath(SkWStream* content);
void ApplyGraphicState(int objectIndex, SkWStream* content);
diff --git a/src/utils/SkDashPath.cpp b/src/utils/SkDashPath.cpp
index 92e4bdb..e166cc0 100644
--- a/src/utils/SkDashPath.cpp
+++ b/src/utils/SkDashPath.cpp
@@ -425,7 +425,7 @@
} while (meas.nextContour());
if (segCount > 1) {
- dst->setConvexity(SkPath::kConcave_Convexity);
+ dst->setConvexity(SkPathConvexityType::kConcave);
}
return true;
diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp
index 03318bb..a437fb2 100644
--- a/src/utils/SkLua.cpp
+++ b/src/utils/SkLua.cpp
@@ -1248,22 +1248,22 @@
return 1;
}
-static const char* fill_type_to_str(SkPath::FillType fill) {
+static const char* fill_type_to_str(SkPathFillType fill) {
switch (fill) {
- case SkPath::kEvenOdd_FillType:
+ case SkPathFillType::kEvenOdd:
return "even-odd";
- case SkPath::kWinding_FillType:
+ case SkPathFillType::kWinding:
return "winding";
- case SkPath::kInverseEvenOdd_FillType:
+ case SkPathFillType::kInverseEvenOdd:
return "inverse-even-odd";
- case SkPath::kInverseWinding_FillType:
+ case SkPathFillType::kInverseWinding:
return "inverse-winding";
}
return "unknown";
}
static int lpath_getFillType(lua_State* L) {
- SkPath::FillType fill = get_obj<SkPath>(L, 1)->getFillType();
+ SkPathFillType fill = (SkPathFillType)get_obj<SkPath>(L, 1)->getFillType();
SkLua(L).pushString(fill_type_to_str(fill));
return 1;
}
@@ -1310,7 +1310,8 @@
}
static int lpath_isConvex(lua_State* L) {
- bool isConvex = SkPath::kConvex_Convexity == get_obj<SkPath>(L, 1)->getConvexity();
+ bool isConvex = SkPathConvexityType::kConvex ==
+ (SkPathConvexityType)get_obj<SkPath>(L, 1)->getConvexity();
SkLua(L).pushBool(isConvex);
return 1;
}
diff --git a/src/utils/SkParsePath.cpp b/src/utils/SkParsePath.cpp
index 8c9469b..beddaa1 100644
--- a/src/utils/SkParsePath.cpp
+++ b/src/utils/SkParsePath.cpp
@@ -174,8 +174,8 @@
&& (data = find_scalar(data, &sweep, false, 0))
&& (data = skip_sep(data))
&& (data = find_points(data, &points[0], 1, relative, &c))) {
- path.arcTo(radii, angle, (SkPath::ArcSize) SkToBool(largeArc),
- (SkPath::Direction) !SkToBool(sweep), points[0]);
+ path.arcTo(radii.fX, radii.fY, angle, (SkPath::ArcSize) SkToBool(largeArc),
+ (SkPathDirection) !SkToBool(sweep), points[0].fX, points[0].fY);
path.getLastPt(&c);
}
} break;
diff --git a/tests/GrShapeTest.cpp b/tests/GrShapeTest.cpp
index 548bd04..44d43be 100644
--- a/tests/GrShapeTest.cpp
+++ b/tests/GrShapeTest.cpp
@@ -119,7 +119,7 @@
// The asRRect() output params are all initialized just to silence compiler warnings about
// uninitialized variables.
SkRRect rrectA = SkRRect::MakeEmpty(), rrectB = SkRRect::MakeEmpty();
- SkPath::Direction dirA = SkPath::kCW_Direction, dirB = SkPath::kCW_Direction;
+ SkPathDirection dirA = SkPathDirection::kCW, dirB = SkPathDirection::kCW;
unsigned startA = ~0U, startB = ~0U;
bool invertedA = true, invertedB = true;
@@ -457,7 +457,7 @@
}
SkRect rect;
unsigned start;
- SkPath::Direction dir;
+ SkPathDirection dir;
if (SkPathPriv::IsSimpleClosedRect(fPath, &rect, &dir, &start)) {
return RectGeo(rect).strokeAndFillIsConvertedToFill(paint);
}
@@ -1577,7 +1577,7 @@
dashAndStrokeEmptyRRectCase.compare(reporter, fillEmptyCase,
TestCase::kAllSame_ComparisonExpecation);
- static constexpr SkPath::Direction kDir = SkPath::kCCW_Direction;
+ static constexpr SkPathDirection kDir = SkPathDirection::kCCW;
static constexpr int kStart = 0;
TestCase fillInvertedEmptyRRectCase(reporter, emptyRRect, kDir, kStart, true, GrStyle(fill));
@@ -1646,21 +1646,21 @@
static constexpr Style kStyleCnt = static_cast<Style>(SK_ARRAY_COUNT(strokeRecs));
auto index = [](bool inverted,
- SkPath::Direction dir,
+ SkPathDirection dir,
unsigned start,
Style style,
bool dash) -> int {
return inverted * (2 * 8 * kStyleCnt * 2) +
- dir * ( 8 * kStyleCnt * 2) +
+ (int)dir * ( 8 * kStyleCnt * 2) +
start * ( kStyleCnt * 2) +
style * ( 2) +
dash;
};
- static const SkPath::Direction kSecondDirection = static_cast<SkPath::Direction>(1);
+ static const SkPathDirection kSecondDirection = static_cast<SkPathDirection>(1);
const int cnt = index(true, kSecondDirection, 7, static_cast<Style>(kStyleCnt - 1), true) + 1;
SkAutoTArray<GrShape> shapes(cnt);
for (bool inverted : {false, true}) {
- for (SkPath::Direction dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (SkPathDirection dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (unsigned start = 0; start < 8; ++start) {
for (Style style : {kFill, kStroke, kHairline, kStrokeAndFill}) {
for (bool dash : {false, true}) {
@@ -1676,7 +1676,7 @@
// Get the keys for some example shape instances that we'll use for comparision against the
// rest.
- static constexpr SkPath::Direction kExamplesDir = SkPath::kCW_Direction;
+ static constexpr SkPathDirection kExamplesDir = SkPathDirection::kCW;
static constexpr unsigned kExamplesStart = 0;
const GrShape& exampleFillCase = shapes[index(false, kExamplesDir, kExamplesStart, kFill,
false)];
@@ -1720,61 +1720,61 @@
// These are dummy initializations to suppress warnings.
SkRRect queryRR = SkRRect::MakeEmpty();
- SkPath::Direction queryDir = SkPath::kCW_Direction;
+ SkPathDirection queryDir = SkPathDirection::kCW;
unsigned queryStart = ~0U;
bool queryInverted = true;
REPORTER_ASSERT(r, exampleFillCase.asRRect(&queryRR, &queryDir, &queryStart, &queryInverted));
REPORTER_ASSERT(r, queryRR == rrect);
- REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+ REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir);
REPORTER_ASSERT(r, 0 == queryStart);
REPORTER_ASSERT(r, !queryInverted);
REPORTER_ASSERT(r, exampleInvFillCase.asRRect(&queryRR, &queryDir, &queryStart,
&queryInverted));
REPORTER_ASSERT(r, queryRR == rrect);
- REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+ REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir);
REPORTER_ASSERT(r, 0 == queryStart);
REPORTER_ASSERT(r, queryInverted);
REPORTER_ASSERT(r, exampleStrokeAndFillCase.asRRect(&queryRR, &queryDir, &queryStart,
&queryInverted));
REPORTER_ASSERT(r, queryRR == rrect);
- REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+ REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir);
REPORTER_ASSERT(r, 0 == queryStart);
REPORTER_ASSERT(r, !queryInverted);
REPORTER_ASSERT(r, exampleInvStrokeAndFillCase.asRRect(&queryRR, &queryDir, &queryStart,
&queryInverted));
REPORTER_ASSERT(r, queryRR == rrect);
- REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+ REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir);
REPORTER_ASSERT(r, 0 == queryStart);
REPORTER_ASSERT(r, queryInverted);
REPORTER_ASSERT(r, exampleHairlineCase.asRRect(&queryRR, &queryDir, &queryStart,
&queryInverted));
REPORTER_ASSERT(r, queryRR == rrect);
- REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+ REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir);
REPORTER_ASSERT(r, 0 == queryStart);
REPORTER_ASSERT(r, !queryInverted);
REPORTER_ASSERT(r, exampleInvHairlineCase.asRRect(&queryRR, &queryDir, &queryStart,
&queryInverted));
REPORTER_ASSERT(r, queryRR == rrect);
- REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+ REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir);
REPORTER_ASSERT(r, 0 == queryStart);
REPORTER_ASSERT(r, queryInverted);
REPORTER_ASSERT(r, exampleStrokeCase.asRRect(&queryRR, &queryDir, &queryStart, &queryInverted));
REPORTER_ASSERT(r, queryRR == rrect);
- REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+ REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir);
REPORTER_ASSERT(r, 0 == queryStart);
REPORTER_ASSERT(r, !queryInverted);
REPORTER_ASSERT(r, exampleInvStrokeCase.asRRect(&queryRR, &queryDir, &queryStart,
&queryInverted));
REPORTER_ASSERT(r, queryRR == rrect);
- REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+ REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir);
REPORTER_ASSERT(r, 0 == queryStart);
REPORTER_ASSERT(r, queryInverted);
@@ -1791,7 +1791,7 @@
REPORTER_ASSERT(r, exampleInvStrokeAndFillCaseKey == exampleInvHairlineCaseKey);
for (bool inverted : {false, true}) {
- for (SkPath::Direction dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (SkPathDirection dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (unsigned start = 0; start < 8; ++start) {
for (bool dash : {false, true}) {
const GrShape& fillCase = shapes[index(inverted, dir, start, kFill, dash)];
@@ -1846,7 +1846,7 @@
// The pre-style case for the dash will match the non-dash example iff the
// dir and start match (dir=cw, start=0).
- if (0 == expectedStart && SkPath::kCW_Direction == dir) {
+ if (0 == expectedStart && SkPathDirection::kCW == dir) {
e.compare(r, f, TestCase::kSameUpToPE_ComparisonExpecation);
g.compare(r, h, TestCase::kSameUpToPE_ComparisonExpecation);
} else {
diff --git a/tests/ParsePathTest.cpp b/tests/ParsePathTest.cpp
index 00f5c86..5fcd002 100644
--- a/tests/ParsePathTest.cpp
+++ b/tests/ParsePathTest.cpp
@@ -60,7 +60,7 @@
test_to_from(reporter, p);
p.addOval(r);
test_to_from(reporter, p);
- p.addRoundRect(r, 4, 4.5f);
+ p.addRRect(SkRRect::MakeRectXY(r, 4, 4.5f));
test_to_from(reporter, p);
}
diff --git a/tests/PathOpsBuilderConicTest.cpp b/tests/PathOpsBuilderConicTest.cpp
index f776b43..062578c 100644
--- a/tests/PathOpsBuilderConicTest.cpp
+++ b/tests/PathOpsBuilderConicTest.cpp
@@ -54,7 +54,7 @@
static void testOne(skiatest::Reporter* reporter, const OvalSet& set) {
SkPath oval, regionResult, builderResult, opResult;
- oval.setFillType(SkPath::kWinding_FillType);
+ oval.setFillType(SkPathFillType::kWinding);
oval.addOval(set.fBounds);
SkOpBuilder builder;
SkRegion region;
@@ -412,7 +412,7 @@
DEF_TEST(SixtyOvalsA, reporter) {
SkPath path;
-path.setFillType(SkPath::kEvenOdd_FillType);
+path.setFillType(SkPathFillType::kEvenOdd);
path.moveTo(11.1722f, -8.10398f);
path.conicTo(22.9143f, -10.3787f, 23.7764f, -7.72542f, 1.00863f);
path.conicTo(24.6671f, -4.98406f, 13.8147f, 0.0166066f, 0.973016f);
@@ -439,7 +439,7 @@
path.close();
SkPath one(path);
path.reset();
-path.setFillType(SkPath::kWinding_FillType);
+path.setFillType(SkPathFillType::kWinding);
path.moveTo(-1.54509f, -4.75528f);
path.conicTo(22.2313f, -12.4807f, 23.7764f, -7.72543f, 0.707107f);
path.conicTo(25.3215f, -2.97014f, 1.54509f, 4.75528f, 0.707107f);
@@ -453,7 +453,7 @@
DEF_TEST(SixtyOvalsAX, reporter) {
SkPath path;
-path.setFillType(SkPath::kEvenOdd_FillType);
+path.setFillType(SkPathFillType::kEvenOdd);
path.moveTo(SkBits2Float(0x4132c174), SkBits2Float(0xc101a9e5)); // 11.1722f, -8.10398f
path.conicTo(SkBits2Float(0x41b7508a), SkBits2Float(0xc1260efe), SkBits2Float(0x41be3618), SkBits2Float(0xc0f736ad), SkBits2Float(0x3f811abd)); // 22.9143f, -10.3787f, 23.7764f, -7.72542f, 1.00863f
path.conicTo(SkBits2Float(0x41c5564b), SkBits2Float(0xc09f7d6d), SkBits2Float(0x415d0934), SkBits2Float(0x3c880a93), SkBits2Float(0x3f79179a)); // 24.6671f, -4.98406f, 13.8147f, 0.0166066f, 0.973016f
@@ -481,7 +481,7 @@
path.close();
SkPath one(path);
path.reset();
-path.setFillType(SkPath::kWinding_FillType);
+path.setFillType(SkPathFillType::kWinding);
path.moveTo(SkBits2Float(0xbfc5c55c), SkBits2Float(0xc0982b46)); // -1.54509f, -4.75528f
path.conicTo(SkBits2Float(0x41b1d9c2), SkBits2Float(0xc147b0fc), SkBits2Float(0x41be3618), SkBits2Float(0xc0f736b3), SkBits2Float(0x3f3504f3)); // 22.2313f, -12.4807f, 23.7764f, -7.72543f, 0.707107f
path.conicTo(SkBits2Float(0x41ca926e), SkBits2Float(0xc03e16da), SkBits2Float(0x3fc5c55c), SkBits2Float(0x40982b46), SkBits2Float(0x3f3504f3)); // 25.3215f, -2.97014f, 1.54509f, 4.75528f, 0.707107f
diff --git a/tests/PathOpsChalkboardTest.cpp b/tests/PathOpsChalkboardTest.cpp
index 6c03f2c..70148f5 100644
--- a/tests/PathOpsChalkboardTest.cpp
+++ b/tests/PathOpsChalkboardTest.cpp
@@ -15,7 +15,7 @@
static void chalkboard(skiatest::Reporter* reporter, uint64_t testlines) {
SkPath path;
- path.setFillType((SkPath::FillType) 0);
+ path.setFillType((SkPathFillType) 0);
uint64_t i = 0;
path.moveTo(SkBits2Float(0x4470eed9), SkBits2Float(0x439c1ac1)); // 963.732f, 312.209f
if (testlines & (1LL << i++)) path.lineTo(SkBits2Float(0x4470dde3), SkBits2Float(0x439c63d8)); // 963.467f, 312.78f
diff --git a/tests/PathOpsExtendedTest.cpp b/tests/PathOpsExtendedTest.cpp
index 45699d7..6ce9972 100644
--- a/tests/PathOpsExtendedTest.cpp
+++ b/tests/PathOpsExtendedTest.cpp
@@ -772,12 +772,12 @@
}
}
-void PathOpsThreadState::outputProgress(const char* pathStr, SkPath::FillType pathFillType) {
+void PathOpsThreadState::outputProgress(const char* pathStr, SkPathFillType pathFillType) {
const char testFunction[] = "testSimplify(path);";
const char* pathPrefix = nullptr;
const char* nameSuffix = nullptr;
- if (pathFillType == SkPath::kEvenOdd_FillType) {
- pathPrefix = " path.setFillType(SkPath::kEvenOdd_FillType);\n";
+ if (pathFillType == SkPathFillType::kEvenOdd) {
+ pathPrefix = " path.setFillType(SkPathFillType::kEvenOdd);\n";
nameSuffix = "x";
}
appendTest(pathStr, pathPrefix, nameSuffix, testFunction, false, fPathStr);
diff --git a/tests/PathOpsInverseTest.cpp b/tests/PathOpsInverseTest.cpp
index 6f0034b..196c580 100644
--- a/tests/PathOpsInverseTest.cpp
+++ b/tests/PathOpsInverseTest.cpp
@@ -10,19 +10,19 @@
SkPath one, two;
int testCount = 0;
for (int op = kDifference_SkPathOp; op <= kReverseDifference_SkPathOp; ++op) {
- for (int oneFill = SkPath::kWinding_FillType; oneFill <= SkPath::kInverseEvenOdd_FillType;
+ for (int oneFill = (int)SkPathFillType::kWinding; oneFill <= (int)SkPathFillType::kInverseEvenOdd;
++oneFill) {
- for (int oneDir = SkPath::kCW_Direction; oneDir != SkPath::kCCW_Direction; ++oneDir) {
+ for (int oneDir = (int)SkPathDirection::kCW; oneDir != (int)SkPathDirection::kCCW; ++oneDir) {
one.reset();
one.setFillType((SkPath::FillType) oneFill);
one.addRect(0, 0, 6, 6, (SkPath::Direction) oneDir);
- for (int twoFill = SkPath::kWinding_FillType;
- twoFill <= SkPath::kInverseEvenOdd_FillType; ++twoFill) {
+ for (int twoFill = (int)SkPathFillType::kWinding;
+ twoFill <= (int)SkPathFillType::kInverseEvenOdd; ++twoFill) {
for (int twoDir = SkPath::kCW_Direction; twoDir != SkPath::kCCW_Direction;
++twoDir) {
two.reset();
- two.setFillType((SkPath::FillType) twoFill);
- two.addRect(3, 3, 9, 9, (SkPath::Direction) twoDir);
+ two.setFillType((SkPathFillType) twoFill);
+ two.addRect({3, 3, 9, 9}, (SkPathDirection) twoDir);
SkString testName;
testName.printf("inverseTest%d", ++testCount);
testPathOp(reporter, one, two, (SkPathOp) op, testName.c_str());
diff --git a/tests/PathOpsSimplifyDegenerateThreadedTest.cpp b/tests/PathOpsSimplifyDegenerateThreadedTest.cpp
index cf36924..cb0554a 100644
--- a/tests/PathOpsSimplifyDegenerateThreadedTest.cpp
+++ b/tests/PathOpsSimplifyDegenerateThreadedTest.cpp
@@ -32,7 +32,7 @@
}
SkString pathStr;
SkPath path, out;
- path.setFillType(SkPath::kWinding_FillType);
+ path.setFillType(SkPathFillType::kWinding);
path.moveTo(SkIntToScalar(ax), SkIntToScalar(ay));
path.lineTo(SkIntToScalar(bx), SkIntToScalar(by));
path.lineTo(SkIntToScalar(cx), SkIntToScalar(cy));
@@ -50,12 +50,12 @@
pathStr.appendf(" path.lineTo(%d, %d);\n", ex, ey);
pathStr.appendf(" path.lineTo(%d, %d);\n", fx, fy);
pathStr.appendf(" path.close();\n");
- state.outputProgress(pathStr.c_str(), SkPath::kWinding_FillType);
+ state.outputProgress(pathStr.c_str(), SkPathFillType::kWinding);
}
testSimplify(path, false, out, state, pathStr.c_str());
path.setFillType(SkPath::kEvenOdd_FillType);
if (state.fReporter->verbose()) {
- state.outputProgress(pathStr.c_str(), SkPath::kEvenOdd_FillType);
+ state.outputProgress(pathStr.c_str(), SkPathFillType::kEvenOdd);
}
testSimplify(path, true, out, state, pathStr.c_str());
}
diff --git a/tests/PathOpsSimplifyFailTest.cpp b/tests/PathOpsSimplifyFailTest.cpp
index 6e7c650..e1e037a 100644
--- a/tests/PathOpsSimplifyFailTest.cpp
+++ b/tests/PathOpsSimplifyFailTest.cpp
@@ -59,11 +59,11 @@
case 12: path.moveTo(nonFinitePts[i]); break;
}
SkPath result;
- result.setFillType(SkPath::kWinding_FillType);
+ result.setFillType(SkPathFillType::kWinding);
bool success = Simplify(path, &result);
REPORTER_ASSERT(reporter, !success);
REPORTER_ASSERT(reporter, result.isEmpty());
- REPORTER_ASSERT(reporter, result.getFillType() == SkPath::kWinding_FillType);
+ REPORTER_ASSERT(reporter, (SkPathFillType)result.getFillType() == SkPathFillType::kWinding);
reporter->bumpTestCount();
}
@@ -85,10 +85,10 @@
case 10: path.moveTo(finitePts[f]); break;
}
SkPath result;
- result.setFillType(SkPath::kWinding_FillType);
+ result.setFillType(SkPathFillType::kWinding);
bool success = Simplify(path, &result);
REPORTER_ASSERT(reporter, success);
- REPORTER_ASSERT(reporter, result.getFillType() != SkPath::kWinding_FillType);
+ REPORTER_ASSERT(reporter, (SkPathFillType)result.getFillType() != SkPathFillType::kWinding);
reporter->bumpTestCount();
}
@@ -126,7 +126,7 @@
static void fuzz763_1(skiatest::Reporter* reporter, const char* filename) {
SkPath path;
- path.setFillType((SkPath::FillType) 0);
+ path.setFillType((SkPathFillType) 0);
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
path.cubicTo(SkBits2Float(0xbcb63000), SkBits2Float(0xb6b6b6b7), SkBits2Float(0x38b6b6b6), SkBits2Float(0xafb63a5a), SkBits2Float(0xca000087), SkBits2Float(0xe93ae9e9)); // -0.0222397f, -5.44529e-06f, 8.71247e-05f, -3.31471e-10f, -2.09719e+06f, -1.41228e+25f
path.quadTo(SkBits2Float(0xb6007fb6), SkBits2Float(0xb69fb6b6), SkBits2Float(0xe9e964b6), SkBits2Float(0xe9e9e9e9)); // -1.91478e-06f, -4.75984e-06f, -3.52694e+25f, -3.5348e+25f
@@ -157,7 +157,7 @@
static void fuzz763_2s(skiatest::Reporter* reporter, const char* filename) {
SkPath path;
- path.setFillType((SkPath::FillType) 0);
+ path.setFillType((SkPathFillType) 0);
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
path.cubicTo(SkBits2Float(0x76773011), SkBits2Float(0x5d66fe78), SkBits2Float(0xbbeeff66), SkBits2Float(0x637677a2), SkBits2Float(0x205266fe), SkBits2Float(0xec296fdf)); // 1.25339e+33f, 1.0403e+18f, -0.00729363f, 4.54652e+21f, 1.78218e-19f, -8.19347e+26f
path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
@@ -217,7 +217,7 @@
static void fuzz_x3(skiatest::Reporter* reporter, const char* filename) {
SkPath path;
-path.setFillType(SkPath::kWinding_FillType);
+path.setFillType(SkPathFillType::kWinding);
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
path.cubicTo(SkBits2Float(0x92743420), SkBits2Float(0x74747474), SkBits2Float(0x0f747c74), SkBits2Float(0xff538565), SkBits2Float(0x74744374), SkBits2Float(0x20437474)); // -7.70571e-28f, 7.74708e+31f, 1.20541e-29f, -2.8116e+38f, 7.74102e+31f, 1.65557e-19f
path.conicTo(SkBits2Float(0x7474926d), SkBits2Float(0x7c747474), SkBits2Float(0x00170f74), SkBits2Float(0x3a7410d7), SkBits2Float(0x3a3a3a3a)); // 7.7508e+31f, 5.07713e+36f, 2.11776e-39f, 0.000931037f, 0.000710401f
@@ -229,7 +229,7 @@
static void fuzz_k1(skiatest::Reporter* reporter, const char* filename) {
SkPath path;
-path.setFillType(SkPath::kWinding_FillType);
+path.setFillType(SkPathFillType::kWinding);
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
path.conicTo(SkBits2Float(0x2073732f), SkBits2Float(0x73f17f00), SkBits2Float(0x737b7b73), SkBits2Float(0x73916773), SkBits2Float(0x00738773)); // 2.0621e-19f, 3.82666e+31f, 1.99245e+31f, 2.30402e+31f, 1.06097e-38f
path.lineTo(SkBits2Float(0x5803736d), SkBits2Float(0x807b5ba1)); // 5.78127e+14f, -1.13286e-38f
diff --git a/tests/PathOpsSimplifyQuadThreadedTest.cpp b/tests/PathOpsSimplifyQuadThreadedTest.cpp
index fc5f646..b722976 100644
--- a/tests/PathOpsSimplifyQuadThreadedTest.cpp
+++ b/tests/PathOpsSimplifyQuadThreadedTest.cpp
@@ -61,12 +61,12 @@
pathStr.appendf(" path.close();\n");
pathStr.appendf(" testSimplify(reporter, path, filename);\n");
pathStr.appendf("}\n");
- state.outputProgress(pathStr.c_str(), SkPath::kWinding_FillType);
+ state.outputProgress(pathStr.c_str(), SkPathFillType::kWinding);
}
testSimplify(path, false, out, state, pathStr.c_str());
path.setFillType(SkPath::kEvenOdd_FillType);
if (state.fReporter->verbose()) {
- state.outputProgress(pathStr.c_str(), SkPath::kEvenOdd_FillType);
+ state.outputProgress(pathStr.c_str(), SkPathFillType::kEvenOdd);
}
testSimplify(path, true, out, state, pathStr.c_str());
}
diff --git a/tests/PathOpsSimplifyQuadralateralsThreadedTest.cpp b/tests/PathOpsSimplifyQuadralateralsThreadedTest.cpp
index 2cfca49..678988c 100644
--- a/tests/PathOpsSimplifyQuadralateralsThreadedTest.cpp
+++ b/tests/PathOpsSimplifyQuadralateralsThreadedTest.cpp
@@ -63,12 +63,12 @@
pathStr.appendf(" path.close();\n");
pathStr.appendf(" testPathSimplify(reporter, path, filename);\n");
pathStr.appendf("}\n");
- state.outputProgress(pathStr.c_str(), SkPath::kWinding_FillType);
+ state.outputProgress(pathStr.c_str(), SkPathFillType::kWinding);
}
testSimplify(path, false, out, state, pathStr.c_str());
path.setFillType(SkPath::kEvenOdd_FillType);
if (state.fReporter->verbose()) {
- state.outputProgress(pathStr.c_str(), SkPath::kEvenOdd_FillType);
+ state.outputProgress(pathStr.c_str(), SkPathFillType::kEvenOdd);
}
testSimplify(path, true, out, state, pathStr.c_str());
}
diff --git a/tests/PathOpsSimplifyRectThreadedTest.cpp b/tests/PathOpsSimplifyRectThreadedTest.cpp
index e3b58a3..9f8b27b 100644
--- a/tests/PathOpsSimplifyRectThreadedTest.cpp
+++ b/tests/PathOpsSimplifyRectThreadedTest.cpp
@@ -168,11 +168,11 @@
}
path.close();
if (state.fReporter->verbose()) {
- state.outputProgress(pathStr.c_str(), SkPath::kWinding_FillType);
+ state.outputProgress(pathStr.c_str(), SkPathFillType::kWinding);
}
testSimplify(path, false, out, state, pathStr.c_str());
if (state.fReporter->verbose()) {
- state.outputProgress(pathStr.c_str(), SkPath::kEvenOdd_FillType);
+ state.outputProgress(pathStr.c_str(), SkPathFillType::kEvenOdd);
}
testSimplify(path, true, out, state, pathStr.c_str());
}
diff --git a/tests/PathOpsSimplifyTrianglesThreadedTest.cpp b/tests/PathOpsSimplifyTrianglesThreadedTest.cpp
index 52f0a84..d421ce0 100644
--- a/tests/PathOpsSimplifyTrianglesThreadedTest.cpp
+++ b/tests/PathOpsSimplifyTrianglesThreadedTest.cpp
@@ -53,13 +53,13 @@
pathStr.appendf(" path.lineTo(%d, %d);\n", ex, ey);
pathStr.appendf(" path.lineTo(%d, %d);\n", fx, fy);
pathStr.appendf(" path.close();\n");
- state.outputProgress(pathStr.c_str(), SkPath::kWinding_FillType);
+ state.outputProgress(pathStr.c_str(), SkPathFillType::kWinding);
}
ShowTestName(&state, d, e, f, 0);
testSimplify(path, false, out, state, pathStr.c_str());
path.setFillType(SkPath::kEvenOdd_FillType);
if (state.fReporter->verbose()) {
- state.outputProgress(pathStr.c_str(), SkPath::kEvenOdd_FillType);
+ state.outputProgress(pathStr.c_str(), SkPathFillType::kEvenOdd);
}
ShowTestName(&state, d, e, f, 1);
testSimplify(path, true, out, state, pathStr.c_str());
diff --git a/tests/PathOpsThreadedCommon.h b/tests/PathOpsThreadedCommon.h
index 4b4c9b8..1248fde 100644
--- a/tests/PathOpsThreadedCommon.h
+++ b/tests/PathOpsThreadedCommon.h
@@ -34,7 +34,7 @@
skiatest::Reporter* fReporter;
SkBitmap* fBitmap;
- void outputProgress(const char* pathStr, SkPath::FillType);
+ void outputProgress(const char* pathStr, SkPathFillType);
void outputProgress(const char* pathStr, SkPathOp);
};
diff --git a/tests/PathTest.cpp b/tests/PathTest.cpp
index 54ef767..be62a79 100644
--- a/tests/PathTest.cpp
+++ b/tests/PathTest.cpp
@@ -1129,13 +1129,13 @@
// Test two donuts, each wound a different direction. Only the outer contour
// determines the cheap direction
path.reset();
- path.addCircle(0, 0, SkIntToScalar(2), SkPath::kCW_Direction);
- path.addCircle(0, 0, SkIntToScalar(1), SkPath::kCCW_Direction);
+ path.addCircle(0, 0, SkIntToScalar(2), SkPathDirection::kCW);
+ path.addCircle(0, 0, SkIntToScalar(1), SkPathDirection::kCCW);
check_direction(reporter, path, SkPathPriv::kCW_FirstDirection);
path.reset();
- path.addCircle(0, 0, SkIntToScalar(1), SkPath::kCW_Direction);
- path.addCircle(0, 0, SkIntToScalar(2), SkPath::kCCW_Direction);
+ path.addCircle(0, 0, SkIntToScalar(1), SkPathDirection::kCW);
+ path.addCircle(0, 0, SkIntToScalar(2), SkPathDirection::kCCW);
check_direction(reporter, path, SkPathPriv::kCCW_FirstDirection);
// triangle with one point really far from the origin.
@@ -1155,7 +1155,7 @@
path.lineTo(1, 1e7f);
path.lineTo(1e7f, 2e7f);
path.close();
- REPORTER_ASSERT(reporter, SkPath::kConvex_Convexity == path.getConvexity());
+ REPORTER_ASSERT(reporter, SkPathConvexityType::kConvex == (SkPathConvexityType)path.getConvexity());
check_direction(reporter, path, SkPathPriv::kCCW_FirstDirection);
}
@@ -1913,7 +1913,7 @@
swap(qRect.fTop, qRect.fBottom);
}
for (int d = 0; d < 2; ++d) {
- SkPath::Direction dir = d ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
+ SkPathDirection dir = d ? SkPathDirection::kCCW : SkPathDirection::kCW;
path.reset();
path.addRect(kBaseRect, dir);
REPORTER_ASSERT(reporter, kQueries[q].fInRect ==
@@ -1925,7 +1925,7 @@
path.conservativelyContainsRect(qRect));
path.reset();
- path.addRoundRect(kBaseRect, kRRRadii[0], kRRRadii[1], dir);
+ path.addRRect(SkRRect::MakeRectXY(kBaseRect, kRRRadii[0], kRRRadii[1]), dir);
REPORTER_ASSERT(reporter, kQueries[q].fInRR ==
path.conservativelyContainsRect(qRect));
@@ -2157,7 +2157,7 @@
if (tests[testIndex].fIsRect) {
SkRect computed, expected;
bool isClosed;
- SkPath::Direction direction;
+ SkPathDirection direction;
SkPathPriv::FirstDirection cheapDirection;
int pointCount = tests[testIndex].fPointCount - (d2 == tests[testIndex].fPoints);
expected.setBounds(tests[testIndex].fPoints, pointCount);
@@ -2170,9 +2170,9 @@
SkRect computed;
computed.setLTRB(123, 456, 789, 1011);
for (auto c : {true, false})
- for (auto d : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto d : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
bool isClosed = c;
- SkPath::Direction direction = d;
+ SkPathDirection direction = d;
REPORTER_ASSERT(reporter, !path.isRect(&computed, &isClosed, &direction));
REPORTER_ASSERT(reporter, computed.fLeft == 123 && computed.fTop == 456);
REPORTER_ASSERT(reporter, computed.fRight == 789 && computed.fBottom == 1011);
@@ -2239,9 +2239,9 @@
}
static void check_simple_closed_rect(skiatest::Reporter* reporter, const SkPath& path,
- const SkRect& rect, SkPath::Direction dir, unsigned start) {
+ const SkRect& rect, SkPathDirection dir, unsigned start) {
SkRect r = SkRect::MakeEmpty();
- SkPath::Direction d = SkPath::kCCW_Direction;
+ SkPathDirection d = SkPathDirection::kCCW;
unsigned s = ~0U;
REPORTER_ASSERT(reporter, SkPathPriv::IsSimpleClosedRect(path, &r, &d, &s));
@@ -2253,14 +2253,14 @@
static void test_is_simple_closed_rect(skiatest::Reporter* reporter) {
using std::swap;
SkRect r = SkRect::MakeEmpty();
- SkPath::Direction d = SkPath::kCCW_Direction;
+ SkPathDirection d = SkPathDirection::kCCW;
unsigned s = ~0U;
const SkRect testRect = SkRect::MakeXYWH(10, 10, 50, 70);
const SkRect emptyRect = SkRect::MakeEmpty();
SkPath path;
for (int start = 0; start < 4; ++start) {
- for (auto dir : {SkPath::kCCW_Direction, SkPath::kCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCCW, SkPathDirection::kCW}) {
SkPath path;
path.addRect(testRect, dir, start);
check_simple_closed_rect(reporter, path, testRect, dir, start);
@@ -2317,9 +2317,9 @@
path2.addRect(degenRect, dir, start);
REPORTER_ASSERT(reporter, !SkPathPriv::IsSimpleClosedRect(path2, &r, &d, &s));
// An inverted rect makes a rect path, but changes the winding dir and start point.
- SkPath::Direction swapDir = (dir == SkPath::kCW_Direction)
- ? SkPath::kCCW_Direction
- : SkPath::kCW_Direction;
+ SkPathDirection swapDir = (dir == SkPathDirection::kCW)
+ ? SkPathDirection::kCCW
+ : SkPathDirection::kCW;
static constexpr unsigned kXSwapStarts[] = { 1, 0, 3, 2 };
static constexpr unsigned kYSwapStarts[] = { 3, 2, 1, 0 };
SkRect swapRect = testRect;
@@ -2341,7 +2341,7 @@
path.lineTo(1, 1);
path.lineTo(0, 1);
SkRect rect;
- SkPath::Direction dir;
+ SkPathDirection dir;
unsigned start;
path.close();
REPORTER_ASSERT(reporter, !SkPathPriv::IsSimpleClosedRect(path, &rect, &dir, &start));
@@ -2444,7 +2444,7 @@
for (size_t testIndex = 0; testIndex < testCount; ++testIndex) {
SkPath path;
if (rectFirst) {
- path.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
+ path.addRect({-1, -1, 2, 2}, SkPathDirection::kCW);
}
path.moveTo(tests[testIndex].fPoints[0].fX, tests[testIndex].fPoints[0].fY);
for (index = 1; index < tests[testIndex].fPointCount; ++index) {
@@ -2454,14 +2454,14 @@
path.close();
}
if (!rectFirst) {
- path.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
+ path.addRect({-1, -1, 2, 2}, SkPathDirection::kCCW);
}
REPORTER_ASSERT(reporter,
tests[testIndex].fIsNestedRect == SkPathPriv::IsNestedFillRects(path, nullptr));
if (tests[testIndex].fIsNestedRect) {
SkRect expected[2], computed[2];
SkPathPriv::FirstDirection expectedDirs[2];
- SkPath::Direction computedDirs[2];
+ SkPathDirection computedDirs[2];
SkRect testBounds;
testBounds.setBounds(tests[testIndex].fPoints, tests[testIndex].fPointCount);
expected[0] = SkRect::MakeLTRB(-1, -1, 2, 2);
@@ -2483,7 +2483,7 @@
// fail, close then line
SkPath path1;
if (rectFirst) {
- path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
+ path1.addRect({-1, -1, 2, 2}, SkPathDirection::kCW);
}
path1.moveTo(r1[0].fX, r1[0].fY);
for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
@@ -2492,14 +2492,14 @@
path1.close();
path1.lineTo(1, 0);
if (!rectFirst) {
- path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
+ path1.addRect({-1, -1, 2, 2}, SkPathDirection::kCCW);
}
REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
// fail, move in the middle
path1.reset();
if (rectFirst) {
- path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
+ path1.addRect({-1, -1, 2, 2}, SkPathDirection::kCW);
}
path1.moveTo(r1[0].fX, r1[0].fY);
for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
@@ -2510,14 +2510,14 @@
}
path1.close();
if (!rectFirst) {
- path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
+ path1.addRect({-1, -1, 2, 2}, SkPathDirection::kCCW);
}
REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
// fail, move on the edge
path1.reset();
if (rectFirst) {
- path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
+ path1.addRect({-1, -1, 2, 2}, SkPathDirection::kCW);
}
for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
path1.moveTo(r1[index - 1].fX, r1[index - 1].fY);
@@ -2525,14 +2525,14 @@
}
path1.close();
if (!rectFirst) {
- path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
+ path1.addRect({-1, -1, 2, 2}, SkPathDirection::kCCW);
}
REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
// fail, quad
path1.reset();
if (rectFirst) {
- path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
+ path1.addRect({-1, -1, 2, 2}, SkPathDirection::kCW);
}
path1.moveTo(r1[0].fX, r1[0].fY);
for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
@@ -2543,14 +2543,14 @@
}
path1.close();
if (!rectFirst) {
- path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
+ path1.addRect({-1, -1, 2, 2}, SkPathDirection::kCCW);
}
REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
// fail, cubic
path1.reset();
if (rectFirst) {
- path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
+ path1.addRect({-1, -1, 2, 2}, SkPathDirection::kCW);
}
path1.moveTo(r1[0].fX, r1[0].fY);
for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
@@ -2561,14 +2561,14 @@
}
path1.close();
if (!rectFirst) {
- path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
+ path1.addRect({-1, -1, 2, 2}, SkPathDirection::kCCW);
}
REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
// fail, not nested
path1.reset();
- path1.addRect(1, 1, 3, 3, SkPath::kCW_Direction);
- path1.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
+ path1.addRect({1, 1, 3, 3}, SkPathDirection::kCW);
+ path1.addRect({2, 2, 4, 4}, SkPathDirection::kCW);
REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
}
@@ -2588,7 +2588,7 @@
// pass, stroke rect
SkPath src, dst;
- src.addRect(1, 1, 7, 7, SkPath::kCW_Direction);
+ src.addRect({1, 1, 7, 7}, SkPathDirection::kCW);
SkPaint strokePaint;
strokePaint.setStyle(SkPaint::kStroke_Style);
strokePaint.setStrokeWidth(2);
@@ -2614,7 +2614,7 @@
p.getConvexityOrUnknown());
SkRect oval0, oval1;
- SkPath::Direction dir0, dir1;
+ SkPathDirection dir0, dir1;
unsigned start0, start1;
REPORTER_ASSERT(reporter, readBack.isOval(nullptr) == p.isOval(nullptr));
if (SkPathPriv::IsOval(p, &oval0, &dir0, &start0) &&
@@ -2756,7 +2756,7 @@
}
p.reset();
- p.addCircle(0, 0, 1, SkPath::kCW_Direction);
+ p.addCircle(0, 0, 1, SkPathDirection::kCW);
{
SkMatrix matrix;
@@ -3286,7 +3286,7 @@
SkPathPriv::FirstDirection expectedDir) {
SkRect rect = SkRect::MakeEmpty();
REPORTER_ASSERT(reporter, path.isOval(&rect) == expectedCircle);
- SkPath::Direction isOvalDir;
+ SkPathDirection isOvalDir;
unsigned isOvalStart;
if (SkPathPriv::IsOval(path, &rect, &isOvalDir, &isOvalStart)) {
REPORTER_ASSERT(reporter, rect.height() == rect.width());
@@ -3406,7 +3406,7 @@
}
static void test_circle_with_direction(skiatest::Reporter* reporter,
- SkPath::Direction inDir) {
+ SkPathDirection inDir) {
const SkPathPriv::FirstDirection dir = SkPathPriv::AsFirstDirection(inDir);
SkPath path;
@@ -3453,8 +3453,8 @@
SkPath rect;
SkPath empty;
- const SkPath::Direction kCircleDir = SkPath::kCW_Direction;
- const SkPath::Direction kCircleDirOpposite = SkPath::kCCW_Direction;
+ const SkPathDirection kCircleDir = SkPathDirection::kCW;
+ const SkPathDirection kCircleDirOpposite = SkPathDirection::kCCW;
circle.addCircle(0, 0, SkIntToScalar(10), kCircleDir);
rect.addRect(SkIntToScalar(5), SkIntToScalar(5),
@@ -3484,24 +3484,24 @@
}
static void test_circle(skiatest::Reporter* reporter) {
- test_circle_with_direction(reporter, SkPath::kCW_Direction);
- test_circle_with_direction(reporter, SkPath::kCCW_Direction);
+ test_circle_with_direction(reporter, SkPathDirection::kCW);
+ test_circle_with_direction(reporter, SkPathDirection::kCCW);
// multiple addCircle()
SkPath path;
- path.addCircle(0, 0, SkIntToScalar(10), SkPath::kCW_Direction);
- path.addCircle(0, 0, SkIntToScalar(20), SkPath::kCW_Direction);
+ path.addCircle(0, 0, SkIntToScalar(10), SkPathDirection::kCW);
+ path.addCircle(0, 0, SkIntToScalar(20), SkPathDirection::kCW);
check_for_circle(reporter, path, false, SkPathPriv::kCW_FirstDirection);
// some extra lineTo() would make isOval() fail
path.reset();
- path.addCircle(0, 0, SkIntToScalar(10), SkPath::kCW_Direction);
+ path.addCircle(0, 0, SkIntToScalar(10), SkPathDirection::kCW);
path.lineTo(0, 0);
check_for_circle(reporter, path, false, SkPathPriv::kCW_FirstDirection);
// not back to the original point
path.reset();
- path.addCircle(0, 0, SkIntToScalar(10), SkPath::kCW_Direction);
+ path.addCircle(0, 0, SkIntToScalar(10), SkPathDirection::kCW);
path.setLastPt(SkIntToScalar(5), SkIntToScalar(5));
check_for_circle(reporter, path, false, SkPathPriv::kCW_FirstDirection);
@@ -3509,7 +3509,7 @@
// test negative radius
path.reset();
- path.addCircle(0, 0, -1, SkPath::kCW_Direction);
+ path.addCircle(0, 0, -1, SkPathDirection::kCW);
REPORTER_ASSERT(reporter, path.isEmpty());
}
@@ -3518,7 +3518,7 @@
SkMatrix m;
SkPath path;
unsigned start = 0;
- SkPath::Direction dir = SkPath::kCCW_Direction;
+ SkPathDirection dir = SkPathDirection::kCCW;
rect = SkRect::MakeWH(SkIntToScalar(30), SkIntToScalar(50));
path.addOval(rect);
@@ -3533,7 +3533,7 @@
// is unchanged.
REPORTER_ASSERT(reporter, SkPathPriv::IsOval(tmp, nullptr, &dir, &start));
REPORTER_ASSERT(reporter, 2 == start);
- REPORTER_ASSERT(reporter, SkPath::kCW_Direction == dir);
+ REPORTER_ASSERT(reporter, SkPathDirection::kCW == dir);
m.reset();
m.setRotate(SkIntToScalar(30));
@@ -3572,7 +3572,7 @@
tmp.addOval(rect);
path = tmp;
REPORTER_ASSERT(reporter, SkPathPriv::IsOval(path, nullptr, &dir, &start));
- REPORTER_ASSERT(reporter, SkPath::kCW_Direction == dir);
+ REPORTER_ASSERT(reporter, SkPathDirection::kCW == dir);
REPORTER_ASSERT(reporter, 1 == start);
}
@@ -3591,7 +3591,7 @@
}
static void test_rrect_is_convex(skiatest::Reporter* reporter, SkPath* path,
- SkPath::Direction dir) {
+ SkPathDirection dir) {
REPORTER_ASSERT(reporter, path->isConvex());
REPORTER_ASSERT(reporter, SkPathPriv::CheapIsFirstDirection(*path, SkPathPriv::AsFirstDirection(dir)));
path->setConvexity(SkPath::kUnknown_Convexity);
@@ -3600,7 +3600,7 @@
}
static void test_rrect_convexity_is_unknown(skiatest::Reporter* reporter, SkPath* path,
- SkPath::Direction dir) {
+ SkPathDirection dir) {
REPORTER_ASSERT(reporter, path->isConvex());
REPORTER_ASSERT(reporter, SkPathPriv::CheapIsFirstDirection(*path, SkPathPriv::AsFirstDirection(dir)));
path->setConvexity(SkPath::kUnknown_Convexity);
@@ -3615,39 +3615,39 @@
SkRect r = {10, 20, 30, 40};
rr.setRectRadii(r, radii);
p.addRRect(rr);
- test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
- p.addRRect(rr, SkPath::kCCW_Direction);
- test_rrect_is_convex(reporter, &p, SkPath::kCCW_Direction);
+ test_rrect_is_convex(reporter, &p, SkPathDirection::kCW);
+ p.addRRect(rr, SkPathDirection::kCCW);
+ test_rrect_is_convex(reporter, &p, SkPathDirection::kCCW);
p.addRoundRect(r, &radii[0].fX);
- test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
+ test_rrect_is_convex(reporter, &p, SkPathDirection::kCW);
p.addRoundRect(r, &radii[0].fX, SkPath::kCCW_Direction);
- test_rrect_is_convex(reporter, &p, SkPath::kCCW_Direction);
+ test_rrect_is_convex(reporter, &p, SkPathDirection::kCCW);
p.addRoundRect(r, radii[1].fX, radii[1].fY);
- test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
+ test_rrect_is_convex(reporter, &p, SkPathDirection::kCW);
p.addRoundRect(r, radii[1].fX, radii[1].fY, SkPath::kCCW_Direction);
- test_rrect_is_convex(reporter, &p, SkPath::kCCW_Direction);
+ test_rrect_is_convex(reporter, &p, SkPathDirection::kCCW);
for (size_t i = 0; i < SK_ARRAY_COUNT(radii); ++i) {
SkVector save = radii[i];
radii[i].set(0, 0);
rr.setRectRadii(r, radii);
p.addRRect(rr);
- test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
+ test_rrect_is_convex(reporter, &p, SkPathDirection::kCW);
radii[i] = save;
}
p.addRoundRect(r, 0, 0);
SkRect returnedRect;
REPORTER_ASSERT(reporter, p.isRect(&returnedRect));
REPORTER_ASSERT(reporter, returnedRect == r);
- test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
+ test_rrect_is_convex(reporter, &p, SkPathDirection::kCW);
SkVector zeroRadii[] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};
rr.setRectRadii(r, zeroRadii);
p.addRRect(rr);
bool closed;
- SkPath::Direction dir;
+ SkPathDirection dir;
REPORTER_ASSERT(reporter, p.isRect(nullptr, &closed, &dir));
REPORTER_ASSERT(reporter, closed);
- REPORTER_ASSERT(reporter, SkPath::kCW_Direction == dir);
- test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
+ REPORTER_ASSERT(reporter, SkPathDirection::kCW == dir);
+ test_rrect_is_convex(reporter, &p, SkPathDirection::kCW);
p.addRRect(rr, SkPath::kCW_Direction);
p.addRRect(rr, SkPath::kCW_Direction);
REPORTER_ASSERT(reporter, !p.isConvex());
@@ -3666,7 +3666,7 @@
SkRect largeR = {0, 0, SK_ScalarMax, SK_ScalarMax};
rr.setRectRadii(largeR, radii);
p.addRRect(rr);
- test_rrect_convexity_is_unknown(reporter, &p, SkPath::kCW_Direction);
+ test_rrect_convexity_is_unknown(reporter, &p, SkPathDirection::kCW);
// we check for non-finites
SkRect infR = {0, 0, SK_ScalarMax, SK_ScalarInfinity};
@@ -3676,7 +3676,7 @@
// We consider any path with very small (numerically unstable) edges to be concave.
SkRect tinyR = {0, 0, 1e-9f, 1e-9f};
p.addRoundRect(tinyR, 5e-11f, 5e-11f);
- test_rrect_convexity_is_unknown(reporter, &p, SkPath::kCW_Direction);
+ test_rrect_convexity_is_unknown(reporter, &p, SkPathDirection::kCW);
}
static void test_arc(skiatest::Reporter* reporter) {
@@ -3738,7 +3738,7 @@
static void check_oval_arc(skiatest::Reporter* reporter, SkScalar start, SkScalar sweep,
const SkPath& path) {
SkRect r = SkRect::MakeEmpty();
- SkPath::Direction d = SkPath::kCCW_Direction;
+ SkPathDirection d = SkPathDirection::kCCW;
unsigned s = ~0U;
bool isOval = SkPathPriv::IsOval(path, &r, &d, &s);
REPORTER_ASSERT(reporter, isOval);
@@ -3746,7 +3746,7 @@
recreatedPath.addOval(r, d, s);
REPORTER_ASSERT(reporter, path == recreatedPath);
REPORTER_ASSERT(reporter, oval_start_index_to_angle(s) == canonical_start_angle(start));
- REPORTER_ASSERT(reporter, (SkPath::kCW_Direction == d) == (sweep > 0.f));
+ REPORTER_ASSERT(reporter, (SkPathDirection::kCW == d) == (sweep > 0.f));
}
static void test_arc_ovals(skiatest::Reporter* reporter) {
diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp
index d4fdd2d..be90e49 100644
--- a/tests/PictureTest.cpp
+++ b/tests/PictureTest.cpp
@@ -379,7 +379,7 @@
SkPath invPath;
invPath.addOval(rect1);
- invPath.setFillType(SkPath::kInverseEvenOdd_FillType);
+ invPath.setFillType(SkPathFillType::kInverseEvenOdd);
SkPath path;
path.addOval(rect2);
SkPath path2;
diff --git a/tests/RRectInPathTest.cpp b/tests/RRectInPathTest.cpp
index a25ad45..c36a5ba 100644
--- a/tests/RRectInPathTest.cpp
+++ b/tests/RRectInPathTest.cpp
@@ -12,7 +12,7 @@
#include "tests/Test.h"
static SkRRect path_contains_rrect(skiatest::Reporter* reporter, const SkPath& path,
- SkPath::Direction* dir, unsigned* start) {
+ SkPathDirection* dir, unsigned* start) {
SkRRect out;
REPORTER_ASSERT(reporter, SkPathPriv::IsRRect(path, &out, dir, start));
SkPath recreatedPath;
@@ -30,7 +30,7 @@
SkPath xformed;
path.transform(m, &xformed);
SkRRect xrr = SkRRect::MakeRect(SkRect::MakeEmpty());
- SkPath::Direction xd = SkPath::kCCW_Direction;
+ SkPathDirection xd = SkPathDirection::kCCW;
unsigned xs = ~0U;
REPORTER_ASSERT(reporter, SkPathPriv::IsRRect(xformed, &xrr, &xd, &xs));
recreatedPath.reset();
@@ -41,7 +41,7 @@
}
static SkRRect inner_path_contains_rrect(skiatest::Reporter* reporter, const SkRRect& in,
- SkPath::Direction dir, unsigned start) {
+ SkPathDirection dir, unsigned start) {
switch (in.getType()) {
case SkRRect::kEmpty_Type:
case SkRRect::kRect_Type:
@@ -52,7 +52,7 @@
}
SkPath path;
path.addRRect(in, dir, start);
- SkPath::Direction outDir;
+ SkPathDirection outDir;
unsigned outStart;
SkRRect rrect = path_contains_rrect(reporter, path, &outDir, &outStart);
REPORTER_ASSERT(reporter, outDir == dir && outStart == start);
@@ -60,7 +60,7 @@
}
static void path_contains_rrect_check(skiatest::Reporter* reporter, const SkRRect& in,
- SkPath::Direction dir, unsigned start) {
+ SkPathDirection dir, unsigned start) {
SkRRect out = inner_path_contains_rrect(reporter, in, dir, start);
if (in != out) {
SkDebugf("");
@@ -69,7 +69,7 @@
}
static void path_contains_rrect_nocheck(skiatest::Reporter* reporter, const SkRRect& in,
- SkPath::Direction dir, unsigned start) {
+ SkPathDirection dir, unsigned start) {
SkRRect out = inner_path_contains_rrect(reporter, in, dir, start);
if (in == out) {
SkDebugf("");
@@ -77,7 +77,7 @@
}
static void path_contains_rrect_check(skiatest::Reporter* reporter, const SkRect& r,
- SkVector v[4], SkPath::Direction dir, unsigned start) {
+ SkVector v[4], SkPathDirection dir, unsigned start) {
SkRRect rrect;
rrect.setRectRadii(r, v);
path_contains_rrect_check(reporter, rrect, dir, start);
@@ -85,15 +85,15 @@
class ForceIsRRect_Private {
public:
- ForceIsRRect_Private(SkPath* path, SkPath::Direction dir, unsigned start) {
- path->fPathRef->setIsRRect(true, dir == SkPath::kCCW_Direction, start);
+ ForceIsRRect_Private(SkPath* path, SkPathDirection dir, unsigned start) {
+ path->fPathRef->setIsRRect(true, dir == SkPathDirection::kCCW, start);
}
};
static void force_path_contains_rrect(skiatest::Reporter* reporter, SkPath& path,
- SkPath::Direction dir, unsigned start) {
+ SkPathDirection dir, unsigned start) {
ForceIsRRect_Private force_rrect(&path, dir, start);
- SkPath::Direction outDir;
+ SkPathDirection outDir;
unsigned outStart;
path_contains_rrect(reporter, path, &outDir, &outStart);
REPORTER_ASSERT(reporter, outDir == dir && outStart == start);
@@ -124,7 +124,7 @@
path.lineTo(3.5f, 66);
path.conicTo(0, 66, 0, 62.5, weight);
path.close();
- force_path_contains_rrect(reporter, path, SkPath::kCW_Direction, 6);
+ force_path_contains_rrect(reporter, path, SkPathDirection::kCW, 6);
path.reset();
path.moveTo(0, 81.5f);
@@ -137,7 +137,7 @@
path.lineTo(3.5f, 85);
path.conicTo(0, 85, 0, 81.5f, weight);
path.close();
- force_path_contains_rrect(reporter, path, SkPath::kCW_Direction, 6);
+ force_path_contains_rrect(reporter, path, SkPathDirection::kCW, 6);
path.reset();
path.moveTo(14, 1189);
@@ -150,7 +150,7 @@
path.lineTo(21, 1196);
path.conicTo(14, 1196, 14, 1189, weight);
path.close();
- force_path_contains_rrect(reporter, path, SkPath::kCW_Direction, 6);
+ force_path_contains_rrect(reporter, path, SkPathDirection::kCW, 6);
path.reset();
path.moveTo(14, 1743);
@@ -163,14 +163,14 @@
path.lineTo(21, 1750);
path.conicTo(14, 1750, 14, 1743, weight);
path.close();
- force_path_contains_rrect(reporter, path, SkPath::kCW_Direction, 6);
+ force_path_contains_rrect(reporter, path, SkPathDirection::kCW, 6);
}
static const SkScalar kWidth = 100.0f;
static const SkScalar kHeight = 100.0f;
static void test_tricky_radii(skiatest::Reporter* reporter) {
- for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (int start = 0; start < 8; ++start) {
{
// crbug.com/458522
@@ -197,7 +197,7 @@
}
static void test_empty_crbug_458524(skiatest::Reporter* reporter) {
- for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (int start = 0; start < 8; ++start) {
SkRRect rr;
const SkRect bounds = { 3709, 3709, 3709 + 7402, 3709 + 29825 };
@@ -215,7 +215,7 @@
}
static void test_inset(skiatest::Reporter* reporter) {
- for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (int start = 0; start < 8; ++start) {
SkRRect rr, rr2;
SkRect r = { 0, 0, 100, 100 };
@@ -244,7 +244,7 @@
const SkRect& rect,
SkScalar l, SkScalar t, SkScalar r, SkScalar b,
bool checkRadii) {
- for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (int start = 0; start < 8; ++start) {
SkRRect rr;
rr.setNinePatch(rect, l, t, r, b);
@@ -268,7 +268,7 @@
// Test out the basic API entry points
static void test_round_rect_basic(skiatest::Reporter* reporter) {
- for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (int start = 0; start < 8; ++start) {
//----
SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight);
@@ -342,7 +342,7 @@
// Test out the cases when the RR degenerates to a rect
static void test_round_rect_rects(skiatest::Reporter* reporter) {
- for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (int start = 0; start < 8; ++start) {
//----
SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight);
@@ -371,7 +371,7 @@
// Test out the cases when the RR degenerates to an oval
static void test_round_rect_ovals(skiatest::Reporter* reporter) {
- for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (int start = 0; start < 8; ++start) {
//----
SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight);
@@ -385,7 +385,7 @@
// Test out the non-degenerate RR cases
static void test_round_rect_general(skiatest::Reporter* reporter) {
- for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (int start = 0; start < 8; ++start) {
//----
SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight);
@@ -406,7 +406,7 @@
}
static void test_round_rect_iffy_parameters(skiatest::Reporter* reporter) {
- for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (int start = 0; start < 8; ++start) {
SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight);
SkPoint radii[4] = { { 50, 100 }, { 100, 50 }, { 50, 100 }, { 100, 50 } };
@@ -432,7 +432,7 @@
const SkRect rectx = SkRect::MakeLTRB(min, min, max, big);
const SkRect recty = SkRect::MakeLTRB(min, min, big, max);
- for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (int start = 0; start < 8; ++start) {
SkVector radii[4];
for (int i = 0; i < 4; ++i) {
@@ -445,7 +445,7 @@
}
static void test_mix(skiatest::Reporter* reporter) {
- for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+ for (auto dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) {
for (int start = 0; start < 8; ++start) {
// Test out mixed degenerate and non-degenerate geometry with Conics
const SkVector radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 100, 100 } };
diff --git a/tests/RegionTest.cpp b/tests/RegionTest.cpp
index 239ffaa..a7d585d 100644
--- a/tests/RegionTest.cpp
+++ b/tests/RegionTest.cpp
@@ -421,7 +421,7 @@
DEF_TEST(region_inverse_union_skbug_7491, reporter) {
SkPath path;
- path.setFillType(SkPath::kInverseWinding_FillType);
+ path.setFillType(SkPathFillType::kInverseWinding);
path.moveTo(10, 20); path.lineTo(10, 30); path.lineTo(10.1f, 10); path.close();
SkRegion clip;
diff --git a/tests/StrokeTest.cpp b/tests/StrokeTest.cpp
index e13a775..2f3a01d 100644
--- a/tests/StrokeTest.cpp
+++ b/tests/StrokeTest.cpp
@@ -168,7 +168,7 @@
paint.setStrokeWidth(1.49679073e+10f);
SkPath path;
- path.setFillType(SkPath::kWinding_FillType);
+ path.setFillType(SkPathFillType::kWinding);
path.moveTo(SkBits2Float(0x46380000), SkBits2Float(0xc6380000)); // 11776, -11776
path.lineTo(SkBits2Float(0x46a00000), SkBits2Float(0xc6a00000)); // 20480, -20480
path.lineTo(SkBits2Float(0x468c0000), SkBits2Float(0xc68c0000)); // 17920, -17920
diff --git a/tools/debugger/DrawCommand.cpp b/tools/debugger/DrawCommand.cpp
index 31f7e63..569ea2b 100644
--- a/tools/debugger/DrawCommand.cpp
+++ b/tools/debugger/DrawCommand.cpp
@@ -518,18 +518,18 @@
void DrawCommand::MakeJsonPath(SkJSONWriter& writer, const SkPath& path) {
writer.beginObject();
- switch (path.getFillType()) {
- case SkPath::kWinding_FillType:
+ switch ((SkPathFillType)path.getFillType()) {
+ case SkPathFillType::kWinding:
writer.appendString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE, DEBUGCANVAS_FILLTYPE_WINDING);
break;
- case SkPath::kEvenOdd_FillType:
+ case SkPathFillType::kEvenOdd:
writer.appendString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE, DEBUGCANVAS_FILLTYPE_EVENODD);
break;
- case SkPath::kInverseWinding_FillType:
+ case SkPathFillType::kInverseWinding:
writer.appendString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE,
DEBUGCANVAS_FILLTYPE_INVERSEWINDING);
break;
- case SkPath::kInverseEvenOdd_FillType:
+ case SkPathFillType::kInverseEvenOdd:
writer.appendString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE,
DEBUGCANVAS_FILLTYPE_INVERSEEVENODD);
break;
