1/*
2 * Copyright 2011 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 "SkColorPriv.h"
11#include "SkShader.h"
12
13static void test4(SkCanvas* canvas) {
14    SkPaint paint;
15    paint.setAntiAlias(true);
16    SkPoint pts[] = {
17        {10, 160}, {610, 160},
18        {610, 160}, {10, 160},
19
20        {610, 160}, {610, 160},
21        {610, 199}, {610, 199},
22
23        {10, 198}, {610, 198},
24        {610, 199}, {10, 199},
25
26        {10, 160}, {10, 160},
27        {10, 199}, {10, 199}
28    };
29    char verbs[] = {
30        0, 1, 1, 1, 4,
31        0, 1, 1, 1, 4,
32        0, 1, 1, 1, 4,
33        0, 1, 1, 1, 4
34    };
35    SkPath path;
36    SkPoint* ptPtr = pts;
37    for (size_t i = 0; i < sizeof(verbs); ++i) {
38        switch ((SkPath::Verb) verbs[i]) {
39            case SkPath::kMove_Verb:
40                path.moveTo(ptPtr->fX, ptPtr->fY);
41                ++ptPtr;
42                break;
43            case SkPath::kLine_Verb:
44                path.lineTo(ptPtr->fX, ptPtr->fY);
45                ++ptPtr;
46                break;
47            case SkPath::kClose_Verb:
48                path.close();
49                break;
50            default:
51                SkASSERT(false);
52                break;
53        }
54    }
55    SkRect clip = {0, 130, 772, 531};
56    canvas->clipRect(clip);
57    canvas->drawPath(path, paint);
58}
59
60static const struct {
61    SkXfermode::Mode  fMode;
62    const char*         fLabel;
63} gModes[] = {
64    { SkXfermode::kClear_Mode,    "Clear"     },
65    { SkXfermode::kSrc_Mode,      "Src"       },
66    { SkXfermode::kDst_Mode,      "Dst"       },
67    { SkXfermode::kSrcOver_Mode,  "SrcOver"   },
68    { SkXfermode::kDstOver_Mode,  "DstOver"   },
69    { SkXfermode::kSrcIn_Mode,    "SrcIn"     },
70    { SkXfermode::kDstIn_Mode,    "DstIn"     },
71    { SkXfermode::kSrcOut_Mode,   "SrcOut"    },
72    { SkXfermode::kDstOut_Mode,   "DstOut"    },
73    { SkXfermode::kSrcATop_Mode,  "SrcATop"   },
74    { SkXfermode::kDstATop_Mode,  "DstATop"   },
75    { SkXfermode::kXor_Mode,      "Xor"       },
76};
77
78const int gWidth = 64;
79const int gHeight = 64;
80const SkScalar W = SkIntToScalar(gWidth);
81const SkScalar H = SkIntToScalar(gHeight);
82
83static SkScalar drawCell(SkCanvas* canvas, SkXfermode* mode,
84                         SkAlpha a0, SkAlpha a1) {
85
86    SkPaint paint;
87    paint.setAntiAlias(true);
88
89    SkRect r = SkRect::MakeWH(W, H);
90    r.inset(W/10, H/10);
91
92    paint.setColor(SK_ColorBLUE);
93    paint.setAlpha(a0);
94    canvas->drawOval(r, paint);
95
96    paint.setColor(SK_ColorRED);
97    paint.setAlpha(a1);
98    paint.setXfermode(mode);
99
100    SkScalar offset = SK_Scalar1 / 3;
101    SkRect rect = SkRect::MakeXYWH(W / 4 + offset,
102                                   H / 4 + offset,
103                                   W / 2, H / 2);
104    canvas->drawRect(rect, paint);
105
106    return H;
107}
108
109static SkShader* make_bg_shader() {
110    SkBitmap bm;
111    bm.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
112    bm.allocPixels();
113    *bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
114    *bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC,
115                                                             0xCC, 0xCC);
116
117    SkShader* s = SkShader::CreateBitmapShader(bm,
118                                               SkShader::kRepeat_TileMode,
119                                               SkShader::kRepeat_TileMode);
120
121    SkMatrix m;
122    m.setScale(SkIntToScalar(6), SkIntToScalar(6));
123    s->setLocalMatrix(m);
124    return s;
125}
126
127namespace skiagm {
128
129    class AARectModesGM : public GM {
130        SkPaint fBGPaint;
131    public:
132        AARectModesGM () {
133            fBGPaint.setShader(make_bg_shader())->unref();
134        }
135
136    protected:
137
138        virtual SkString onShortName() {
139            return SkString("aarectmodes");
140        }
141
142        virtual SkISize onISize() { return make_isize(640, 480); }
143
144        virtual void onDraw(SkCanvas* canvas) {
145            if (false) { // avoid bit rot, suppress warning
146                test4(canvas);
147            }
148            const SkRect bounds = SkRect::MakeWH(W, H);
149            static const SkAlpha gAlphaValue[] = { 0xFF, 0x88, 0x88 };
150
151            canvas->translate(SkIntToScalar(4), SkIntToScalar(4));
152
153            for (int alpha = 0; alpha < 4; ++alpha) {
154                canvas->save();
155                canvas->save();
156                for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); ++i) {
157                    if (6 == i) {
158                        canvas->restore();
159                        canvas->translate(W * 5, 0);
160                        canvas->save();
161                    }
162                    SkXfermode* mode = SkXfermode::Create(gModes[i].fMode);
163
164                    canvas->drawRect(bounds, fBGPaint);
165                    canvas->saveLayer(&bounds, NULL);
166                    SkScalar dy = drawCell(canvas, mode,
167                                           gAlphaValue[alpha & 1],
168                                           gAlphaValue[alpha & 2]);
169                    canvas->restore();
170
171                    canvas->translate(0, dy * 5 / 4);
172                    SkSafeUnref(mode);
173                }
174                canvas->restore();
175                canvas->restore();
176                canvas->translate(W * 5 / 4, 0);
177            }
178        }
179
180    private:
181        typedef GM INHERITED;
182    };
183
184//////////////////////////////////////////////////////////////////////////////
185
186    static GM* MyFactory(void*) { return new AARectModesGM; }
187    static GMRegistry reg(MyFactory);
188
189}
190