1
2 /*
3 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8 #include "gm.h"
9 #include "SkCanvas.h"
10 #include "SkPaint.h"
11 #include "SkPath.h"
12 #include "SkRandom.h"
13
14 namespace skiagm {
15
16 class EmptyPathGM : public GM {
17 public:
EmptyPathGM()18 EmptyPathGM() {}
19
20 protected:
onShortName()21 SkString onShortName() {
22 return SkString("emptypath");
23 }
24
onISize()25 SkISize onISize() { return SkISize::Make(600, 280); }
26
drawEmpty(SkCanvas * canvas,SkColor color,const SkRect & clip,SkPaint::Style style,SkPath::FillType fill)27 void drawEmpty(SkCanvas* canvas,
28 SkColor color,
29 const SkRect& clip,
30 SkPaint::Style style,
31 SkPath::FillType fill) {
32 SkPath path;
33 path.setFillType(fill);
34 SkPaint paint;
35 paint.setColor(color);
36 paint.setStyle(style);
37 canvas->save();
38 canvas->clipRect(clip);
39 canvas->drawPath(path, paint);
40 canvas->restore();
41 }
42
onDraw(SkCanvas * canvas)43 virtual void onDraw(SkCanvas* canvas) {
44 struct FillAndName {
45 SkPath::FillType fFill;
46 const char* fName;
47 };
48 static const FillAndName gFills[] = {
49 {SkPath::kWinding_FillType, "Winding"},
50 {SkPath::kEvenOdd_FillType, "Even / Odd"},
51 {SkPath::kInverseWinding_FillType, "Inverse Winding"},
52 {SkPath::kInverseEvenOdd_FillType, "Inverse Even / Odd"},
53 };
54 struct StyleAndName {
55 SkPaint::Style fStyle;
56 const char* fName;
57 };
58 static const StyleAndName gStyles[] = {
59 {SkPaint::kFill_Style, "Fill"},
60 {SkPaint::kStroke_Style, "Stroke"},
61 {SkPaint::kStrokeAndFill_Style, "Stroke And Fill"},
62 };
63
64 SkPaint titlePaint;
65 titlePaint.setColor(SK_ColorBLACK);
66 titlePaint.setAntiAlias(true);
67 sk_tool_utils::set_portable_typeface(&titlePaint);
68 titlePaint.setTextSize(15 * SK_Scalar1);
69 const char title[] = "Empty Paths Drawn Into Rectangle Clips With "
70 "Indicated Style and Fill";
71 canvas->drawText(title, strlen(title),
72 20 * SK_Scalar1,
73 20 * SK_Scalar1,
74 titlePaint);
75
76 SkRandom rand;
77 SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
78 int i = 0;
79 canvas->save();
80 canvas->translate(10 * SK_Scalar1, 0);
81 canvas->save();
82 for (size_t style = 0; style < SK_ARRAY_COUNT(gStyles); ++style) {
83 for (size_t fill = 0; fill < SK_ARRAY_COUNT(gFills); ++fill) {
84 if (0 == i % 4) {
85 canvas->restore();
86 canvas->translate(0, rect.height() + 40 * SK_Scalar1);
87 canvas->save();
88 } else {
89 canvas->translate(rect.width() + 40 * SK_Scalar1, 0);
90 }
91 ++i;
92
93
94 SkColor color = rand.nextU();
95 color = 0xff000000 | color; // force solid
96 color = sk_tool_utils::color_to_565(color);
97 this->drawEmpty(canvas, color, rect,
98 gStyles[style].fStyle, gFills[fill].fFill);
99
100 SkPaint rectPaint;
101 rectPaint.setColor(SK_ColorBLACK);
102 rectPaint.setStyle(SkPaint::kStroke_Style);
103 rectPaint.setStrokeWidth(-1);
104 rectPaint.setAntiAlias(true);
105 canvas->drawRect(rect, rectPaint);
106
107 SkPaint labelPaint;
108 labelPaint.setColor(color);
109 labelPaint.setAntiAlias(true);
110 sk_tool_utils::set_portable_typeface(&labelPaint);
111 labelPaint.setTextSize(12 * SK_Scalar1);
112 canvas->drawText(gStyles[style].fName,
113 strlen(gStyles[style].fName),
114 0, rect.height() + 15 * SK_Scalar1,
115 labelPaint);
116 canvas->drawText(gFills[fill].fName,
117 strlen(gFills[fill].fName),
118 0, rect.height() + 28 * SK_Scalar1,
119 labelPaint);
120 }
121 }
122 canvas->restore();
123 canvas->restore();
124 }
125
126 private:
127 typedef GM INHERITED;
128 };
DEF_GM(return new EmptyPathGM;)129 DEF_GM( return new EmptyPathGM; )
130
131 //////////////////////////////////////////////////////////////////////////////
132
133 static void make_path_move(SkPath* path, const SkPoint pts[3]) {
134 for (int i = 0; i < 3; ++i) {
135 path->moveTo(pts[i]);
136 }
137 }
138
make_path_move_close(SkPath * path,const SkPoint pts[3])139 static void make_path_move_close(SkPath* path, const SkPoint pts[3]) {
140 for (int i = 0; i < 3; ++i) {
141 path->moveTo(pts[i]);
142 path->close();
143 }
144 }
145
make_path_move_line(SkPath * path,const SkPoint pts[3])146 static void make_path_move_line(SkPath* path, const SkPoint pts[3]) {
147 for (int i = 0; i < 3; ++i) {
148 path->moveTo(pts[i]);
149 path->lineTo(pts[i]);
150 }
151 }
152
153 typedef void (*MakePathProc)(SkPath*, const SkPoint pts[3]);
154
make_path_move_mix(SkPath * path,const SkPoint pts[3])155 static void make_path_move_mix(SkPath* path, const SkPoint pts[3]) {
156 path->moveTo(pts[0]);
157 path->moveTo(pts[1]); path->close();
158 path->moveTo(pts[2]); path->lineTo(pts[2]);
159 }
160
161 class EmptyStrokeGM : public GM {
162 SkPoint fPts[3];
163
164 public:
EmptyStrokeGM()165 EmptyStrokeGM() {
166 fPts[0].set(40, 40);
167 fPts[1].set(80, 40);
168 fPts[2].set(120, 40);
169 }
170
171 protected:
onShortName()172 SkString onShortName() override {
173 return SkString("emptystroke");
174 }
175
onISize()176 SkISize onISize() override { return SkISize::Make(200, 240); }
177
onDraw(SkCanvas * canvas)178 void onDraw(SkCanvas* canvas) override {
179 const MakePathProc procs[] = {
180 make_path_move, // expect red red red
181 make_path_move_close, // expect black black black
182 make_path_move_line, // expect black black black
183 make_path_move_mix, // expect red black black,
184 };
185
186 SkPaint strokePaint;
187 strokePaint.setStyle(SkPaint::kStroke_Style);
188 strokePaint.setStrokeWidth(21);
189 strokePaint.setStrokeCap(SkPaint::kSquare_Cap);
190
191 SkPaint dotPaint;
192 dotPaint.setColor(SK_ColorRED);
193 strokePaint.setStyle(SkPaint::kStroke_Style);
194 dotPaint.setStrokeWidth(7);
195
196 for (size_t i = 0; i < SK_ARRAY_COUNT(procs); ++i) {
197 SkPath path;
198 procs[i](&path, fPts);
199 canvas->drawPoints(SkCanvas::kPoints_PointMode, 3, fPts, dotPaint);
200 canvas->drawPath(path, strokePaint);
201 canvas->translate(0, 40);
202 }
203 }
204
205 private:
206 typedef GM INHERITED;
207 };
208 DEF_GM( return new EmptyStrokeGM; )
209
210 }
211