1 /*
2  * Copyright 2013 Google Inc.
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 #include "gm.h"
9 #include "SkCanvas.h"
10 #include "SkPath.h"
11 
12 namespace skiagm {
13 
14 // This GM tests a grab-bag of non-closed paths. All these paths look like
15 // closed rects, but they don't call path.close(). Depending on the stroke
16 // settings these slightly different paths give widely different results.
17 class NonClosedPathsGM: public GM {
18 public:
NonClosedPathsGM()19     NonClosedPathsGM() {}
20 
21     enum ClosureType {
22         TotallyNonClosed,  // The last point doesn't coincide with the first one in the contour.
23                            // The path looks not closed at all.
24 
25         FakeCloseCorner,   // The last point coincides with the first one at a corner.
26                            // The path looks closed, but final rendering has 2 ends with cap.
27 
28         FakeCloseMiddle,   // The last point coincides with the first one in the middle of a line.
29                            // The path looks closed, and the final rendering looks closed too.
30 
31         kClosureTypeCount
32     };
33 
34 protected:
35 
onShortName()36     SkString onShortName() override {
37         return SkString("nonclosedpaths");
38     }
39 
40     // 12 * 18 + 3 cases, every case is 100 * 100 pixels.
onISize()41     SkISize onISize() override {
42         return SkISize::Make(1220, 1920);
43     }
44 
45     // Use rect-like geometry for non-closed path, for right angles make it
46     // easier to show the visual difference of lineCap and lineJoin.
MakePath(SkPath * path,ClosureType type)47     static void MakePath(SkPath* path, ClosureType type) {
48         if (FakeCloseMiddle == type) {
49             path->moveTo(30, 50);
50             path->lineTo(30, 30);
51         } else {
52             path->moveTo(30, 30);
53         }
54         path->lineTo(70, 30);
55         path->lineTo(70, 70);
56         path->lineTo(30, 70);
57         path->lineTo(30, 50);
58         if (FakeCloseCorner == type) {
59             path->lineTo(30, 30);
60         }
61     }
62 
63     // Set the location for the current test on the canvas
SetLocation(SkCanvas * canvas,int counter,int lineNum)64     static void SetLocation(SkCanvas* canvas, int counter, int lineNum) {
65         SkScalar x = SK_Scalar1 * 100 * (counter % lineNum) + 10 + SK_Scalar1 / 4;
66         SkScalar y = SK_Scalar1 * 100 * (counter / lineNum) + 10 + 3 * SK_Scalar1 / 4;
67         canvas->translate(x, y);
68     }
69 
onDraw(SkCanvas * canvas)70     void onDraw(SkCanvas* canvas) override {
71         // Stroke widths are:
72         // 0(may use hairline rendering), 10(common case for stroke-style)
73         // 40 and 50(>= geometry width/height, make the contour filled in fact)
74         static const int kStrokeWidth[] = {0, 10, 40, 50};
75         int numWidths = SK_ARRAY_COUNT(kStrokeWidth);
76 
77         static const SkPaint::Style kStyle[] = {
78             SkPaint::kStroke_Style, SkPaint::kStrokeAndFill_Style
79         };
80 
81         static const SkPaint::Cap kCap[] = {
82             SkPaint::kButt_Cap, SkPaint::kRound_Cap, SkPaint::kSquare_Cap
83         };
84 
85         static const SkPaint::Join kJoin[] = {
86             SkPaint::kMiter_Join, SkPaint::kRound_Join, SkPaint::kBevel_Join
87         };
88 
89         static const ClosureType kType[] = {
90             TotallyNonClosed, FakeCloseCorner, FakeCloseMiddle
91         };
92 
93         int counter = 0;
94         SkPaint paint;
95         paint.setAntiAlias(true);
96 
97         // For stroke style painter and fill-and-stroke style painter
98         for (size_t type = 0; type < kClosureTypeCount; ++type) {
99             for (size_t style = 0; style < SK_ARRAY_COUNT(kStyle); ++style) {
100                 for (size_t cap = 0; cap < SK_ARRAY_COUNT(kCap); ++cap) {
101                     for (size_t join = 0; join < SK_ARRAY_COUNT(kJoin); ++join) {
102                         for (int width = 0; width < numWidths; ++width) {
103                             canvas->save();
104                             SetLocation(canvas, counter, SkPaint::kJoinCount * numWidths);
105 
106                             SkPath path;
107                             MakePath(&path, kType[type]);
108 
109                             paint.setStyle(kStyle[style]);
110                             paint.setStrokeCap(kCap[cap]);
111                             paint.setStrokeJoin(kJoin[join]);
112                             paint.setStrokeWidth(SkIntToScalar(kStrokeWidth[width]));
113 
114                             canvas->drawPath(path, paint);
115                             canvas->restore();
116                             ++counter;
117                         }
118                     }
119                 }
120             }
121         }
122 
123         // For fill style painter
124         paint.setStyle(SkPaint::kFill_Style);
125         for (size_t type = 0; type < kClosureTypeCount; ++type) {
126             canvas->save();
127             SetLocation(canvas, counter, SkPaint::kJoinCount * numWidths);
128 
129             SkPath path;
130             MakePath(&path, kType[type]);
131 
132             canvas->drawPath(path, paint);
133             canvas->restore();
134             ++counter;
135         }
136     }
137 
138 private:
139     typedef GM INHERITED;
140 };
141 
142 //////////////////////////////////////////////////////////////////////////////
143 
144 DEF_GM(return new NonClosedPathsGM;)
145 
146 }
147