Home | History | Annotate | Download | only in gm 
      1 /*
      2  * Copyright 2012 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 "SkGradientShader.h"
     11 #include "SkSurface.h"
     12 
     13 #if SK_SUPPORT_GPU
     14     #include "SkGpuDevice.h"
     15 #endif
     16 
     17 #define W   SkIntToScalar(80)
     18 #define H   SkIntToScalar(60)
     19 
     20 typedef void (*PaintProc)(SkPaint*);
     21 
     22 static void identity_paintproc(SkPaint* paint) {
     23     paint->setShader(NULL);
     24 }
     25 
     26 static void gradient_paintproc(SkPaint* paint) {
     27     const SkColor colors[] = { SK_ColorGREEN, SK_ColorBLUE };
     28     const SkPoint pts[] = { { 0, 0 }, { W, H } };
     29     SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL,
     30                                                  SK_ARRAY_COUNT(colors),
     31                                                  SkShader::kClamp_TileMode);
     32     paint->setShader(s)->unref();
     33 }
     34 
     35 typedef void (*Proc)(SkCanvas*, const SkPaint&);
     36 
     37 static void draw_hair(SkCanvas* canvas, const SkPaint& paint) {
     38     SkPaint p(paint);
     39     p.setStrokeWidth(0);
     40     canvas->drawLine(0, 0, W, H, p);
     41 }
     42 
     43 static void draw_thick(SkCanvas* canvas, const SkPaint& paint) {
     44     SkPaint p(paint);
     45     p.setStrokeWidth(H/5);
     46     canvas->drawLine(0, 0, W, H, p);
     47 }
     48 
     49 static void draw_rect(SkCanvas* canvas, const SkPaint& paint) {
     50     canvas->drawRect(SkRect::MakeWH(W, H), paint);
     51 }
     52 
     53 static void draw_oval(SkCanvas* canvas, const SkPaint& paint) {
     54     canvas->drawOval(SkRect::MakeWH(W, H), paint);
     55 }
     56 
     57 static void draw_text(SkCanvas* canvas, const SkPaint& paint) {
     58     SkPaint p(paint);
     59     p.setTextSize(H/4);
     60     canvas->drawText("Hamburge", 8, 0, H*2/3, p);
     61 }
     62 
     63 class SrcModeGM : public skiagm::GM {
     64     SkPath fPath;
     65 public:
     66     SrcModeGM() {
     67         this->setBGColor(SK_ColorBLACK);
     68     }
     69 
     70 protected:
     71     virtual SkString onShortName() {
     72         return SkString("srcmode");
     73     }
     74 
     75     virtual SkISize onISize() {
     76         return SkISize::Make(640, 760);
     77     }
     78 
     79     void drawContent(SkCanvas* canvas) {
     80         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
     81 
     82         SkPaint paint;
     83         paint.setColor(0x80FF0000);
     84 
     85         const Proc procs[] = {
     86             draw_hair, draw_thick, draw_rect, draw_oval, draw_text
     87         };
     88 
     89         const SkXfermode::Mode modes[] = {
     90             SkXfermode::kSrcOver_Mode, SkXfermode::kSrc_Mode, SkXfermode::kClear_Mode
     91         };
     92 
     93         const PaintProc paintProcs[] = {
     94             identity_paintproc, gradient_paintproc
     95         };
     96 
     97         for (int aa = 0; aa <= 1; ++aa) {
     98             paint.setAntiAlias(SkToBool(aa));
     99             canvas->save();
    100             for (size_t i = 0; i < SK_ARRAY_COUNT(paintProcs); ++i) {
    101                 paintProcs[i](&paint);
    102                 for (size_t x = 0; x < SK_ARRAY_COUNT(modes); ++x) {
    103                     paint.setXfermodeMode(modes[x]);
    104                     canvas->save();
    105                     for (size_t y = 0; y < SK_ARRAY_COUNT(procs); ++y) {
    106                         procs[y](canvas, paint);
    107                         canvas->translate(0, H * 5 / 4);
    108                     }
    109                     canvas->restore();
    110                     canvas->translate(W * 5 / 4, 0);
    111                 }
    112             }
    113             canvas->restore();
    114             canvas->translate(0, (H * 5 / 4) * SK_ARRAY_COUNT(procs));
    115         }
    116     }
    117 
    118     static SkSurface* compat_surface(SkCanvas* canvas, const SkISize& size,
    119                                      bool skipGPU) {
    120         SkImage::Info info = {
    121             size.width(),
    122             size.height(),
    123             SkImage::kPMColor_ColorType,
    124             SkImage::kPremul_AlphaType
    125         };
    126 #if SK_SUPPORT_GPU
    127         SkDevice* dev = canvas->getDevice();
    128         if (!skipGPU && dev->accessRenderTarget()) {
    129             SkGpuDevice* gd = (SkGpuDevice*)dev;
    130             GrContext* ctx = gd->context();
    131             return SkSurface::NewRenderTarget(ctx, info, 0);
    132         }
    133 #endif
    134         return SkSurface::NewRaster(info);
    135     }
    136 
    137     virtual void onDraw(SkCanvas* canvas) {
    138         SkAutoTUnref<SkSurface> surf(compat_surface(canvas, this->getISize(),
    139                                                     this->isCanvasDeferred()));
    140         surf->getCanvas()->drawColor(SK_ColorWHITE);
    141         this->drawContent(surf->getCanvas());
    142         surf->draw(canvas, 0, 0, NULL);
    143     }
    144 
    145 private:
    146     typedef skiagm::GM INHERITED;
    147 };
    148 
    149 ///////////////////////////////////////////////////////////////////////////////
    150 
    151 DEF_GM(return new SrcModeGM;)
    152