1 #include "SampleCode.h"
2 #include "SkView.h"
3 #include "SkCanvas.h"
4 #include "SkDevice.h"
5 #include "SkPaint.h"
6
7 #define BG_COLOR 0xFFDDDDDD
8
9 typedef void (*SlideProc)(SkCanvas*);
10
11 ///////////////////////////////////////////////////////////////////////////////
12
13 #include "Sk1DPathEffect.h"
14 #include "Sk2DPathEffect.h"
15 #include "SkCornerPathEffect.h"
16 #include "SkDashPathEffect.h"
17 #include "SkDiscretePathEffect.h"
18
compose_pe(SkPaint * paint)19 static void compose_pe(SkPaint* paint) {
20 SkPathEffect* pe = paint->getPathEffect();
21 SkPathEffect* corner = new SkCornerPathEffect(25);
22 SkPathEffect* compose;
23 if (pe) {
24 compose = new SkComposePathEffect(pe, corner);
25 corner->unref();
26 } else {
27 compose = corner;
28 }
29 paint->setPathEffect(compose)->unref();
30 }
31
hair_pe(SkPaint * paint)32 static void hair_pe(SkPaint* paint) {
33 paint->setStrokeWidth(0);
34 }
35
hair2_pe(SkPaint * paint)36 static void hair2_pe(SkPaint* paint) {
37 paint->setStrokeWidth(0);
38 compose_pe(paint);
39 }
40
stroke_pe(SkPaint * paint)41 static void stroke_pe(SkPaint* paint) {
42 paint->setStrokeWidth(12);
43 compose_pe(paint);
44 }
45
dash_pe(SkPaint * paint)46 static void dash_pe(SkPaint* paint) {
47 SkScalar inter[] = { 20, 10, 10, 10 };
48 paint->setStrokeWidth(12);
49 paint->setPathEffect(new SkDashPathEffect(inter, SK_ARRAY_COUNT(inter),
50 0))->unref();
51 compose_pe(paint);
52 }
53
54 static const int gXY[] = {
55 4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4
56 };
57
scale(SkPath * path,SkScalar scale)58 static void scale(SkPath* path, SkScalar scale) {
59 SkMatrix m;
60 m.setScale(scale, scale);
61 path->transform(m);
62 }
63
one_d_pe(SkPaint * paint)64 static void one_d_pe(SkPaint* paint) {
65 SkPath path;
66 path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1]));
67 for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2)
68 path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1]));
69 path.close();
70 path.offset(SkIntToScalar(-6), 0);
71 scale(&path, 1.5);
72
73 paint->setPathEffect(new SkPath1DPathEffect(path, SkIntToScalar(21), 0,
74 SkPath1DPathEffect::kRotate_Style))->unref();
75 compose_pe(paint);
76 }
77
78 typedef void (*PE_Proc)(SkPaint*);
79 static const PE_Proc gPE[] = { hair_pe, hair2_pe, stroke_pe, dash_pe, one_d_pe };
80
fill_pe(SkPaint * paint)81 static void fill_pe(SkPaint* paint) {
82 paint->setStyle(SkPaint::kFill_Style);
83 paint->setPathEffect(NULL);
84 }
85
discrete_pe(SkPaint * paint)86 static void discrete_pe(SkPaint* paint) {
87 paint->setPathEffect(new SkDiscretePathEffect(10, 4))->unref();
88 }
89
90 class TilePathEffect : public Sk2DPathEffect {
make_mat()91 static SkMatrix make_mat() {
92 SkMatrix m;
93 m.setScale(12, 12);
94 return m;
95 }
96 public:
TilePathEffect()97 TilePathEffect() : Sk2DPathEffect(make_mat()) {}
98
99 protected:
next(const SkPoint & loc,int u,int v,SkPath * dst)100 virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) {
101 dst->addCircle(loc.fX, loc.fY, 5);
102 }
103 };
104
tile_pe(SkPaint * paint)105 static void tile_pe(SkPaint* paint) {
106 paint->setPathEffect(new TilePathEffect)->unref();
107 }
108
109 static const PE_Proc gPE2[] = { fill_pe, discrete_pe, tile_pe };
110
patheffect_slide(SkCanvas * canvas)111 static void patheffect_slide(SkCanvas* canvas) {
112 SkPaint paint;
113 paint.setAntiAlias(true);
114 paint.setStyle(SkPaint::kStroke_Style);
115
116 SkPath path;
117 path.moveTo(20, 20);
118 path.lineTo(70, 120);
119 path.lineTo(120, 30);
120 path.lineTo(170, 80);
121 path.lineTo(240, 50);
122
123 size_t i;
124 canvas->save();
125 for (i = 0; i < SK_ARRAY_COUNT(gPE); i++) {
126 gPE[i](&paint);
127 canvas->drawPath(path, paint);
128 canvas->translate(0, 75);
129 }
130 canvas->restore();
131
132 path.reset();
133 SkRect r = { 0, 0, 250, 120 };
134 path.addOval(r, SkPath::kCW_Direction);
135 r.inset(50, 50);
136 path.addRect(r, SkPath::kCCW_Direction);
137
138 canvas->translate(320, 20);
139 for (i = 0; i < SK_ARRAY_COUNT(gPE2); i++) {
140 gPE2[i](&paint);
141 canvas->drawPath(path, paint);
142 canvas->translate(0, 160);
143 }
144 }
145
146 ///////////////////////////////////////////////////////////////////////////////
147
148 #include "SkGradientShader.h"
149
150 struct GradData {
151 int fCount;
152 const SkColor* fColors;
153 const SkScalar* fPos;
154 };
155
156 static const SkColor gColors[] = {
157 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
158 };
159 static const SkScalar gPos0[] = { 0, SK_Scalar1 };
160 static const SkScalar gPos1[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
161 static const SkScalar gPos2[] = {
162 0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
163 };
164
165 static const GradData gGradData[] = {
166 { 2, gColors, NULL },
167 { 2, gColors, gPos0 },
168 { 2, gColors, gPos1 },
169 { 5, gColors, NULL },
170 { 5, gColors, gPos2 }
171 };
172
MakeLinear(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm,SkUnitMapper * mapper)173 static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
174 SkShader::TileMode tm, SkUnitMapper* mapper) {
175 return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
176 data.fCount, tm, mapper);
177 }
178
MakeRadial(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm,SkUnitMapper * mapper)179 static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
180 SkShader::TileMode tm, SkUnitMapper* mapper) {
181 SkPoint center;
182 center.set(SkScalarAve(pts[0].fX, pts[1].fX),
183 SkScalarAve(pts[0].fY, pts[1].fY));
184 return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
185 data.fPos, data.fCount, tm, mapper);
186 }
187
MakeSweep(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm,SkUnitMapper * mapper)188 static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
189 SkShader::TileMode tm, SkUnitMapper* mapper) {
190 SkPoint center;
191 center.set(SkScalarAve(pts[0].fX, pts[1].fX),
192 SkScalarAve(pts[0].fY, pts[1].fY));
193 return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors,
194 data.fPos, data.fCount, mapper);
195 }
196
Make2Radial(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm,SkUnitMapper * mapper)197 static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
198 SkShader::TileMode tm, SkUnitMapper* mapper) {
199 SkPoint center0, center1;
200 center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
201 SkScalarAve(pts[0].fY, pts[1].fY));
202 center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
203 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
204 return SkGradientShader::CreateTwoPointRadial(
205 center1, (pts[1].fX - pts[0].fX) / 7,
206 center0, (pts[1].fX - pts[0].fX) / 2,
207 data.fColors, data.fPos, data.fCount, tm, mapper);
208 }
209
210 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
211 SkShader::TileMode tm, SkUnitMapper* mapper);
212 static const GradMaker gGradMakers[] = {
213 MakeLinear, MakeRadial, MakeSweep, Make2Radial
214 };
215
gradient_slide(SkCanvas * canvas)216 static void gradient_slide(SkCanvas* canvas) {
217 SkPoint pts[2] = {
218 { 0, 0 },
219 { SkIntToScalar(100), SkIntToScalar(100) }
220 };
221 SkShader::TileMode tm = SkShader::kClamp_TileMode;
222 SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
223 SkPaint paint;
224 paint.setAntiAlias(true);
225 paint.setDither(true);
226
227 canvas->translate(SkIntToScalar(20), SkIntToScalar(10));
228 for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
229 canvas->save();
230 for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
231 SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL);
232 paint.setShader(shader);
233 canvas->drawRect(r, paint);
234 shader->unref();
235 canvas->translate(0, SkIntToScalar(120));
236 }
237 canvas->restore();
238 canvas->translate(SkIntToScalar(120), 0);
239 }
240 }
241
242 ///////////////////////////////////////////////////////////////////////////////
243
244 #include "SkPathMeasure.h"
245
getpathlen(const SkPath & path)246 static SkScalar getpathlen(const SkPath& path) {
247 SkPathMeasure meas(path, false);
248 return meas.getLength();
249 }
250
textonpath_slide(SkCanvas * canvas)251 static void textonpath_slide(SkCanvas* canvas) {
252 const char* text = "Displacement";
253 size_t len =strlen(text);
254 SkPath path;
255 path.moveTo(100, 300);
256 path.quadTo(300, 100, 500, 300);
257 path.offset(0, -100);
258
259 SkPaint paint;
260 paint.setAntiAlias(true);
261 paint.setTextSize(40);
262
263 paint.setStyle(SkPaint::kStroke_Style);
264 canvas->drawPath(path, paint);
265 paint.setStyle(SkPaint::kFill_Style);
266
267 SkScalar x = 50;
268 paint.setColor(0xFF008800);
269 canvas->drawTextOnPathHV(text, len, path,
270 x, paint.getTextSize()*2/3, paint);
271 paint.setColor(SK_ColorRED);
272 canvas->drawTextOnPathHV(text, len, path,
273 x + 60, 0, paint);
274 paint.setColor(SK_ColorBLUE);
275 canvas->drawTextOnPathHV(text, len, path,
276 x + 120, -paint.getTextSize()*2/3, paint);
277
278 path.offset(0, 200);
279 paint.setTextAlign(SkPaint::kRight_Align);
280
281 text = "Matrices";
282 len = strlen(text);
283 SkScalar pathLen = getpathlen(path);
284 SkMatrix matrix;
285
286 paint.setColor(SK_ColorBLACK);
287 paint.setStyle(SkPaint::kStroke_Style);
288 canvas->drawPath(path, paint);
289 paint.setStyle(SkPaint::kFill_Style);
290
291 paint.setTextSize(50);
292 canvas->drawTextOnPath(text, len, path, NULL, paint);
293
294 paint.setColor(SK_ColorRED);
295 matrix.setScale(-SK_Scalar1, SK_Scalar1);
296 matrix.postTranslate(pathLen, 0);
297 canvas->drawTextOnPath(text, len, path, &matrix, paint);
298
299 paint.setColor(SK_ColorBLUE);
300 matrix.setScale(SK_Scalar1, -SK_Scalar1);
301 canvas->drawTextOnPath(text, len, path, &matrix, paint);
302
303 paint.setColor(0xFF008800);
304 matrix.setScale(-SK_Scalar1, -SK_Scalar1);
305 matrix.postTranslate(pathLen, 0);
306 canvas->drawTextOnPath(text, len, path, &matrix, paint);
307 }
308
309 ///////////////////////////////////////////////////////////////////////////////
310
311 #include "SkImageDecoder.h"
312 #include "SkOSFile.h"
313 #include "SkRandom.h"
314 #include "SkStream.h"
315 #include "SkNinePatch.h"
316
make_shader0(SkIPoint * size)317 static SkShader* make_shader0(SkIPoint* size) {
318 SkBitmap bm;
319
320 SkImageDecoder::DecodeFile("/skimages/logo.gif", &bm);
321 size->set(bm.width(), bm.height());
322 return SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode,
323 SkShader::kClamp_TileMode);
324 }
325
make_shader1(const SkIPoint & size)326 static SkShader* make_shader1(const SkIPoint& size) {
327 SkPoint pts[] = { { 0, 0 },
328 { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
329 SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
330 return SkGradientShader::CreateLinear(pts, colors, NULL,
331 SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode, NULL);
332 }
333
334 class Rec {
335 public:
336 SkCanvas::VertexMode fMode;
337 int fCount;
338 SkPoint* fVerts;
339 SkPoint* fTexs;
340
Rec()341 Rec() : fCount(0), fVerts(NULL), fTexs(NULL) {}
~Rec()342 ~Rec() { delete[] fVerts; delete[] fTexs; }
343 };
344
make_tris(Rec * rec)345 void make_tris(Rec* rec) {
346 int n = 10;
347 SkRandom rand;
348
349 rec->fMode = SkCanvas::kTriangles_VertexMode;
350 rec->fCount = n * 3;
351 rec->fVerts = new SkPoint[rec->fCount];
352
353 for (int i = 0; i < n; i++) {
354 SkPoint* v = &rec->fVerts[i*3];
355 for (int j = 0; j < 3; j++) {
356 v[j].set(rand.nextUScalar1() * 250, rand.nextUScalar1() * 250);
357 }
358 }
359 }
360
make_fan(Rec * rec,int texWidth,int texHeight)361 void make_fan(Rec* rec, int texWidth, int texHeight) {
362 const SkScalar tx = SkIntToScalar(texWidth);
363 const SkScalar ty = SkIntToScalar(texHeight);
364 const int n = 24;
365
366 rec->fMode = SkCanvas::kTriangleFan_VertexMode;
367 rec->fCount = n + 2;
368 rec->fVerts = new SkPoint[rec->fCount];
369 rec->fTexs = new SkPoint[rec->fCount];
370
371 SkPoint* v = rec->fVerts;
372 SkPoint* t = rec->fTexs;
373
374 v[0].set(0, 0);
375 t[0].set(0, 0);
376 for (int i = 0; i < n; i++) {
377 SkScalar cos;
378 SkScalar sin = SkScalarSinCos(SK_ScalarPI * 2 * i / n, &cos);
379 v[i+1].set(cos, sin);
380 t[i+1].set(i*tx/n, ty);
381 }
382 v[n+1] = v[1];
383 t[n+1].set(tx, ty);
384
385 SkMatrix m;
386 m.setScale(SkIntToScalar(100), SkIntToScalar(100));
387 m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
388 m.mapPoints(v, rec->fCount);
389 }
390
make_strip(Rec * rec,int texWidth,int texHeight)391 void make_strip(Rec* rec, int texWidth, int texHeight) {
392 const SkScalar tx = SkIntToScalar(texWidth);
393 const SkScalar ty = SkIntToScalar(texHeight);
394 const int n = 24;
395
396 rec->fMode = SkCanvas::kTriangleStrip_VertexMode;
397 rec->fCount = 2 * (n + 1);
398 rec->fVerts = new SkPoint[rec->fCount];
399 rec->fTexs = new SkPoint[rec->fCount];
400
401 SkPoint* v = rec->fVerts;
402 SkPoint* t = rec->fTexs;
403
404 for (int i = 0; i < n; i++) {
405 SkScalar cos;
406 SkScalar sin = SkScalarSinCos(SK_ScalarPI * 2 * i / n, &cos);
407 v[i*2 + 0].set(cos/2, sin/2);
408 v[i*2 + 1].set(cos, sin);
409
410 t[i*2 + 0].set(tx * i / n, ty);
411 t[i*2 + 1].set(tx * i / n, 0);
412 }
413 v[2*n + 0] = v[0];
414 v[2*n + 1] = v[1];
415
416 t[2*n + 0].set(tx, ty);
417 t[2*n + 1].set(tx, 0);
418
419 SkMatrix m;
420 m.setScale(SkIntToScalar(100), SkIntToScalar(100));
421 m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
422 m.mapPoints(v, rec->fCount);
423 }
424
mesh_slide(SkCanvas * canvas)425 static void mesh_slide(SkCanvas* canvas) {
426 Rec fRecs[3];
427 SkIPoint size;
428
429 SkShader* fShader0 = make_shader0(&size);
430 SkShader* fShader1 = make_shader1(size);
431
432 SkAutoUnref aur0(fShader0);
433 SkAutoUnref aur1(fShader1);
434
435 make_strip(&fRecs[0], size.fX, size.fY);
436 make_fan(&fRecs[1], size.fX, size.fY);
437 make_tris(&fRecs[2]);
438
439 SkPaint paint;
440 paint.setDither(true);
441 paint.setFilterBitmap(true);
442
443 for (size_t i = 0; i < SK_ARRAY_COUNT(fRecs); i++) {
444 canvas->save();
445
446 paint.setShader(NULL);
447 canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
448 fRecs[i].fVerts, fRecs[i].fTexs,
449 NULL, NULL, NULL, 0, paint);
450
451 canvas->translate(SkIntToScalar(210), 0);
452
453 paint.setShader(fShader0);
454 canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
455 fRecs[i].fVerts, fRecs[i].fTexs,
456 NULL, NULL, NULL, 0, paint);
457
458 canvas->translate(SkIntToScalar(210), 0);
459
460 paint.setShader(fShader1);
461 canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
462 fRecs[i].fVerts, fRecs[i].fTexs,
463 NULL, NULL, NULL, 0, paint);
464 canvas->restore();
465
466 canvas->translate(0, SkIntToScalar(250));
467 }
468 }
469
470 ///////////////////////////////////////////////////////////////////////////////
471
472 #include "SkGradientShader.h"
473 #include "SkLayerRasterizer.h"
474 #include "SkBlurMaskFilter.h"
475
r0(SkLayerRasterizer * rast,SkPaint & p)476 static void r0(SkLayerRasterizer* rast, SkPaint& p)
477 {
478 p.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(3),
479 SkBlurMaskFilter::kNormal_BlurStyle))->unref();
480 rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
481
482 p.setMaskFilter(NULL);
483 p.setStyle(SkPaint::kStroke_Style);
484 p.setStrokeWidth(SK_Scalar1);
485 rast->addLayer(p);
486
487 p.setAlpha(0x11);
488 p.setStyle(SkPaint::kFill_Style);
489 p.setXfermodeMode(SkXfermode::kSrc_Mode);
490 rast->addLayer(p);
491 }
492
r1(SkLayerRasterizer * rast,SkPaint & p)493 static void r1(SkLayerRasterizer* rast, SkPaint& p)
494 {
495 rast->addLayer(p);
496
497 p.setAlpha(0x40);
498 p.setXfermodeMode(SkXfermode::kSrc_Mode);
499 p.setStyle(SkPaint::kStroke_Style);
500 p.setStrokeWidth(SK_Scalar1*2);
501 rast->addLayer(p);
502 }
503
r2(SkLayerRasterizer * rast,SkPaint & p)504 static void r2(SkLayerRasterizer* rast, SkPaint& p)
505 {
506 p.setStyle(SkPaint::kStrokeAndFill_Style);
507 p.setStrokeWidth(SK_Scalar1*4);
508 rast->addLayer(p);
509
510 p.setStyle(SkPaint::kStroke_Style);
511 p.setStrokeWidth(SK_Scalar1*3/2);
512 p.setXfermodeMode(SkXfermode::kClear_Mode);
513 rast->addLayer(p);
514 }
515
r3(SkLayerRasterizer * rast,SkPaint & p)516 static void r3(SkLayerRasterizer* rast, SkPaint& p)
517 {
518 p.setStyle(SkPaint::kStroke_Style);
519 p.setStrokeWidth(SK_Scalar1*3);
520 rast->addLayer(p);
521
522 p.setAlpha(0x20);
523 p.setStyle(SkPaint::kFill_Style);
524 p.setXfermodeMode(SkXfermode::kSrc_Mode);
525 rast->addLayer(p);
526 }
527
r4(SkLayerRasterizer * rast,SkPaint & p)528 static void r4(SkLayerRasterizer* rast, SkPaint& p)
529 {
530 p.setAlpha(0x60);
531 rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
532
533 p.setAlpha(0xFF);
534 p.setXfermodeMode(SkXfermode::kClear_Mode);
535 rast->addLayer(p, SK_Scalar1*3/2, SK_Scalar1*3/2);
536
537 p.setXfermode(NULL);
538 rast->addLayer(p);
539 }
540
541 #include "SkDiscretePathEffect.h"
542
r5(SkLayerRasterizer * rast,SkPaint & p)543 static void r5(SkLayerRasterizer* rast, SkPaint& p)
544 {
545 rast->addLayer(p);
546
547 p.setPathEffect(new SkDiscretePathEffect(SK_Scalar1*4, SK_Scalar1*3))->unref();
548 p.setXfermodeMode(SkXfermode::kSrcOut_Mode);
549 rast->addLayer(p);
550 }
551
r6(SkLayerRasterizer * rast,SkPaint & p)552 static void r6(SkLayerRasterizer* rast, SkPaint& p)
553 {
554 rast->addLayer(p);
555
556 p.setAntiAlias(false);
557 SkLayerRasterizer* rast2 = new SkLayerRasterizer;
558 r5(rast2, p);
559 p.setRasterizer(rast2)->unref();
560 p.setXfermodeMode(SkXfermode::kClear_Mode);
561 rast->addLayer(p);
562 }
563
564 #include "Sk2DPathEffect.h"
565
566 class Dot2DPathEffect : public Sk2DPathEffect {
567 public:
Dot2DPathEffect(SkScalar radius,const SkMatrix & matrix)568 Dot2DPathEffect(SkScalar radius, const SkMatrix& matrix)
569 : Sk2DPathEffect(matrix), fRadius(radius) {}
570
flatten(SkFlattenableWriteBuffer & buffer)571 virtual void flatten(SkFlattenableWriteBuffer& buffer)
572 {
573 this->INHERITED::flatten(buffer);
574
575 buffer.writeScalar(fRadius);
576 }
getFactory()577 virtual Factory getFactory() { return CreateProc; }
578
579 protected:
next(const SkPoint & loc,int u,int v,SkPath * dst)580 virtual void next(const SkPoint& loc, int u, int v, SkPath* dst)
581 {
582 dst->addCircle(loc.fX, loc.fY, fRadius);
583 }
584
Dot2DPathEffect(SkFlattenableReadBuffer & buffer)585 Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer)
586 {
587 fRadius = buffer.readScalar();
588 }
589 private:
590 SkScalar fRadius;
591
CreateProc(SkFlattenableReadBuffer & buffer)592 static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer)
593 {
594 return new Dot2DPathEffect(buffer);
595 }
596
597 typedef Sk2DPathEffect INHERITED;
598 };
599
r7(SkLayerRasterizer * rast,SkPaint & p)600 static void r7(SkLayerRasterizer* rast, SkPaint& p)
601 {
602 SkMatrix lattice;
603 lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
604 lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
605 p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*4, lattice))->unref();
606 rast->addLayer(p);
607 }
608
r8(SkLayerRasterizer * rast,SkPaint & p)609 static void r8(SkLayerRasterizer* rast, SkPaint& p)
610 {
611 rast->addLayer(p);
612
613 SkMatrix lattice;
614 lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
615 lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
616 p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*2, lattice))->unref();
617 p.setXfermodeMode(SkXfermode::kClear_Mode);
618 rast->addLayer(p);
619
620 p.setPathEffect(NULL);
621 p.setXfermode(NULL);
622 p.setStyle(SkPaint::kStroke_Style);
623 p.setStrokeWidth(SK_Scalar1);
624 rast->addLayer(p);
625 }
626
627 class Line2DPathEffect : public Sk2DPathEffect {
628 public:
Line2DPathEffect(SkScalar width,const SkMatrix & matrix)629 Line2DPathEffect(SkScalar width, const SkMatrix& matrix)
630 : Sk2DPathEffect(matrix), fWidth(width) {}
631
filterPath(SkPath * dst,const SkPath & src,SkScalar * width)632 virtual bool filterPath(SkPath* dst, const SkPath& src, SkScalar* width)
633 {
634 if (this->INHERITED::filterPath(dst, src, width))
635 {
636 *width = fWidth;
637 return true;
638 }
639 return false;
640 }
641
getFactory()642 virtual Factory getFactory() { return CreateProc; }
flatten(SkFlattenableWriteBuffer & buffer)643 virtual void flatten(SkFlattenableWriteBuffer& buffer)
644 {
645 this->INHERITED::flatten(buffer);
646 buffer.writeScalar(fWidth);
647 }
648 protected:
nextSpan(int u,int v,int ucount,SkPath * dst)649 virtual void nextSpan(int u, int v, int ucount, SkPath* dst)
650 {
651 if (ucount > 1)
652 {
653 SkPoint src[2], dstP[2];
654
655 src[0].set(SkIntToScalar(u) + SK_ScalarHalf,
656 SkIntToScalar(v) + SK_ScalarHalf);
657 src[1].set(SkIntToScalar(u+ucount) + SK_ScalarHalf,
658 SkIntToScalar(v) + SK_ScalarHalf);
659 this->getMatrix().mapPoints(dstP, src, 2);
660
661 dst->moveTo(dstP[0]);
662 dst->lineTo(dstP[1]);
663 }
664 }
665
Line2DPathEffect(SkFlattenableReadBuffer & buffer)666 Line2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer)
667 {
668 fWidth = buffer.readScalar();
669 }
670
671 private:
672 SkScalar fWidth;
673
CreateProc(SkFlattenableReadBuffer & buffer)674 static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer)
675 {
676 return new Line2DPathEffect(buffer);
677 }
678
679 typedef Sk2DPathEffect INHERITED;
680 };
681
r9(SkLayerRasterizer * rast,SkPaint & p)682 static void r9(SkLayerRasterizer* rast, SkPaint& p)
683 {
684 rast->addLayer(p);
685
686 SkMatrix lattice;
687 lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0);
688 lattice.postRotate(SkIntToScalar(30), 0, 0);
689 p.setPathEffect(new Line2DPathEffect(SK_Scalar1*2, lattice))->unref();
690 p.setXfermodeMode(SkXfermode::kClear_Mode);
691 rast->addLayer(p);
692
693 p.setPathEffect(NULL);
694 p.setXfermode(NULL);
695 p.setStyle(SkPaint::kStroke_Style);
696 p.setStrokeWidth(SK_Scalar1);
697 rast->addLayer(p);
698 }
699
700 typedef void (*raster_proc)(SkLayerRasterizer*, SkPaint&);
701
702 static const raster_proc gRastProcs[] = {
703 r0, r1, r2, r3, r4, r5, r6, r7, r8, r9
704 };
705
apply_shader(SkPaint * paint,int index)706 static void apply_shader(SkPaint* paint, int index) {
707 raster_proc proc = gRastProcs[index];
708 SkPaint p;
709 SkLayerRasterizer* rast = new SkLayerRasterizer;
710
711 p.setAntiAlias(true);
712 proc(rast, p);
713 paint->setRasterizer(rast)->unref();
714 paint->setColor(SK_ColorBLUE);
715 }
716
717 #include "SkTypeface.h"
718
texteffect_slide(SkCanvas * canvas)719 static void texteffect_slide(SkCanvas* canvas) {
720 const char* str = "Google";
721 size_t len = strlen(str);
722 SkScalar x = 20;
723 SkScalar y = 80;
724 SkPaint paint;
725 paint.setTypeface(SkTypeface::CreateFromName("Georgia", SkTypeface::kItalic));
726 paint.setTextSize(75);
727 paint.setAntiAlias(true);
728 paint.setColor(SK_ColorBLUE);
729 for (size_t i = 0; i < SK_ARRAY_COUNT(gRastProcs); i++) {
730 apply_shader(&paint, i);
731 canvas->drawText(str, len, x, y, paint);
732 y += 80;
733 if (i == 4) {
734 x += 320;
735 y = 80;
736 }
737 }
738 }
739
740 ///////////////////////////////////////////////////////////////////////////////
741
742 #include "SkImageEncoder.h"
743
744 static const SlideProc gProc[] = {
745 patheffect_slide,
746 gradient_slide,
747 textonpath_slide,
748 mesh_slide,
749 texteffect_slide
750 };
751
752 class SlideView : public SampleView {
753 int fIndex;
754 public:
SlideView()755 SlideView() {
756 fIndex = 0;
757
758 SkBitmap bm;
759 bm.setConfig(SkBitmap::kARGB_8888_Config, 1024, 768);
760 bm.allocPixels();
761 SkCanvas canvas(bm);
762 SkScalar s = SkIntToScalar(1024) / 640;
763 canvas.scale(s, s);
764 for (size_t i = 0; i < SK_ARRAY_COUNT(gProc); i++) {
765 canvas.save();
766 canvas.drawColor(BG_COLOR);
767 gProc[i](&canvas);
768 canvas.restore();
769 SkString str;
770 str.printf("/skimages/slide_%d.png", i);
771 SkImageEncoder::EncodeFile(str.c_str(), bm, SkImageEncoder::kPNG_Type, 100);
772 }
773 this->setBGColor(BG_COLOR);
774 }
775
776 protected:
777 // overrides from SkEventSink
onQuery(SkEvent * evt)778 virtual bool onQuery(SkEvent* evt) {
779 if (SampleCode::TitleQ(*evt)) {
780 SampleCode::TitleR(evt, "Slides");
781 return true;
782 }
783 return this->INHERITED::onQuery(evt);
784 }
785
onDrawContent(SkCanvas * canvas)786 virtual void onDrawContent(SkCanvas* canvas) {
787 gProc[fIndex](canvas);
788 }
789
onFindClickHandler(SkScalar x,SkScalar y)790 virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
791 fIndex = (fIndex + 1) % SK_ARRAY_COUNT(gProc);
792 this->inval(NULL);
793 return NULL;
794 }
795
796 private:
797 typedef SampleView INHERITED;
798 };
799
800 //////////////////////////////////////////////////////////////////////////////
801
MyFactory()802 static SkView* MyFactory() { return new SlideView; }
803 static SkViewRegister reg(MyFactory);
804
805
