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