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