gm/aarectmodes.cpp

   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
  13 static 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
  60 static 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
  78 const int gWidth = 64;
  79 const int gHeight = 64;
  80 const SkScalar W = SkIntToScalar(gWidth);
  81 const SkScalar H = SkIntToScalar(gHeight);
  82
  83 static 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
 109 static SkShader* make_bg_shader() {
 110     SkBitmap bm;
 111     bm.allocN32Pixels(2, 2);
 112     *bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
 113     *bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC,
 114                                                              0xCC, 0xCC);
 115
 116     SkMatrix m;
 117     m.setScale(SkIntToScalar(6), SkIntToScalar(6));
 118     SkShader* s = SkShader::CreateBitmapShader(bm,
 119                                                SkShader::kRepeat_TileMode,
 120                                                SkShader::kRepeat_TileMode,
 121                                                &m);
 122
 123     return s;
 124 }
 125
 126 namespace skiagm {
 127
 128     class AARectModesGM : public GM {
 129         SkPaint fBGPaint;
 130     public:
 131         AARectModesGM () {
 132             fBGPaint.setShader(make_bg_shader())->unref();
 133         }
 134
 135     protected:
 136
 137         SkString onShortName() SK_OVERRIDE {
 138             return SkString("aarectmodes");
 139         }
 140
 141         SkISize onISize() SK_OVERRIDE { return SkISize::Make(640, 480); }
 142
 143         void onDraw(SkCanvas* canvas) SK_OVERRIDE {
 144             if (false) { // avoid bit rot, suppress warning
 145                 test4(canvas);
 146             }
 147             const SkRect bounds = SkRect::MakeWH(W, H);
 148             static const SkAlpha gAlphaValue[] = { 0xFF, 0x88, 0x88 };
 149
 150             canvas->translate(SkIntToScalar(4), SkIntToScalar(4));
 151
 152             for (int alpha = 0; alpha < 4; ++alpha) {
 153                 canvas->save();
 154                 canvas->save();
 155                 for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); ++i) {
 156                     if (6 == i) {
 157                         canvas->restore();
 158                         canvas->translate(W * 5, 0);
 159                         canvas->save();
 160                     }
 161                     SkXfermode* mode = SkXfermode::Create(gModes[i].fMode);
 162
 163                     canvas->drawRect(bounds, fBGPaint);
 164                     canvas->saveLayer(&bounds, NULL);
 165                     SkScalar dy = drawCell(canvas, mode,
 166                                            gAlphaValue[alpha & 1],
 167                                            gAlphaValue[alpha & 2]);
 168                     canvas->restore();
 169
 170                     canvas->translate(0, dy * 5 / 4);
 171                     SkSafeUnref(mode);
 172                 }
 173                 canvas->restore();
 174                 canvas->restore();
 175                 canvas->translate(W * 5 / 4, 0);
 176             }
 177         }
 178
 179     private:
 180         typedef GM INHERITED;
 181     };
 182
 183 //////////////////////////////////////////////////////////////////////////////
 184
 185     static GM* MyFactory(void*) { return new AARectModesGM; }
 186     static GMRegistry reg(MyFactory);
 187
 188 }