Home | History | Annotate | Download | only in gm 
      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 "gm.h"
      9 #include "SkCanvas.h"
     10 #include "SkPaint.h"
     11 #include "SkRandom.h"
     12 
     13 namespace skiagm {
     14 
     15 class EmptyPathGM : public GM {
     16 public:
     17     EmptyPathGM() {}
     18 
     19 protected:
     20     SkString onShortName() {
     21         return SkString("emptypath");
     22     }
     23 
     24     SkISize onISize() { return SkISize::Make(600, 280); }
     25 
     26     void drawEmpty(SkCanvas* canvas,
     27                     SkColor color,
     28                     const SkRect& clip,
     29                     SkPaint::Style style,
     30                     SkPath::FillType fill) {
     31         SkPath path;
     32         path.setFillType(fill);
     33         SkPaint paint;
     34         paint.setColor(color);
     35         paint.setStyle(style);
     36         canvas->save();
     37         canvas->clipRect(clip);
     38         canvas->drawPath(path, paint);
     39         canvas->restore();
     40     }
     41 
     42     virtual void onDraw(SkCanvas* canvas) {
     43         struct FillAndName {
     44             SkPath::FillType fFill;
     45             const char*      fName;
     46         };
     47         static const FillAndName gFills[] = {
     48             {SkPath::kWinding_FillType, "Winding"},
     49             {SkPath::kEvenOdd_FillType, "Even / Odd"},
     50             {SkPath::kInverseWinding_FillType, "Inverse Winding"},
     51             {SkPath::kInverseEvenOdd_FillType, "Inverse Even / Odd"},
     52         };
     53         struct StyleAndName {
     54             SkPaint::Style fStyle;
     55             const char*    fName;
     56         };
     57         static const StyleAndName gStyles[] = {
     58             {SkPaint::kFill_Style, "Fill"},
     59             {SkPaint::kStroke_Style, "Stroke"},
     60             {SkPaint::kStrokeAndFill_Style, "Stroke And Fill"},
     61         };
     62 
     63         SkPaint titlePaint;
     64         titlePaint.setColor(SK_ColorBLACK);
     65         titlePaint.setAntiAlias(true);
     66         sk_tool_utils::set_portable_typeface(&titlePaint);
     67         titlePaint.setLCDRenderText(true);
     68         titlePaint.setTextSize(15 * SK_Scalar1);
     69         const char title[] = "Empty Paths Drawn Into Rectangle Clips With "
     70                              "Indicated Style and Fill";
     71         canvas->drawText(title, strlen(title),
     72                             20 * SK_Scalar1,
     73                             20 * SK_Scalar1,
     74                             titlePaint);
     75 
     76         SkLCGRandom rand;
     77         SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
     78         int i = 0;
     79         canvas->save();
     80         canvas->translate(10 * SK_Scalar1, 0);
     81         canvas->save();
     82         for (size_t style = 0; style < SK_ARRAY_COUNT(gStyles); ++style) {
     83             for (size_t fill = 0; fill < SK_ARRAY_COUNT(gFills); ++fill) {
     84                 if (0 == i % 4) {
     85                     canvas->restore();
     86                     canvas->translate(0, rect.height() + 40 * SK_Scalar1);
     87                     canvas->save();
     88                 } else {
     89                     canvas->translate(rect.width() + 40 * SK_Scalar1, 0);
     90                 }
     91                 ++i;
     92 
     93 
     94                 SkColor color = rand.nextU();
     95                 color = 0xff000000| color; // force solid
     96                 this->drawEmpty(canvas, color, rect,
     97                                 gStyles[style].fStyle, gFills[fill].fFill);
     98 
     99                 SkPaint rectPaint;
    100                 rectPaint.setColor(SK_ColorBLACK);
    101                 rectPaint.setStyle(SkPaint::kStroke_Style);
    102                 rectPaint.setStrokeWidth(-1);
    103                 rectPaint.setAntiAlias(true);
    104                 canvas->drawRect(rect, rectPaint);
    105 
    106                 SkPaint labelPaint;
    107                 labelPaint.setColor(color);
    108                 labelPaint.setAntiAlias(true);
    109                 sk_tool_utils::set_portable_typeface(&labelPaint);
    110                 labelPaint.setLCDRenderText(true);
    111                 labelPaint.setTextSize(12 * SK_Scalar1);
    112                 canvas->drawText(gStyles[style].fName,
    113                                  strlen(gStyles[style].fName),
    114                                  0, rect.height() + 15 * SK_Scalar1,
    115                                  labelPaint);
    116                 canvas->drawText(gFills[fill].fName,
    117                                  strlen(gFills[fill].fName),
    118                                  0, rect.height() + 28 * SK_Scalar1,
    119                                  labelPaint);
    120             }
    121         }
    122         canvas->restore();
    123         canvas->restore();
    124     }
    125 
    126 private:
    127     typedef GM INHERITED;
    128 };
    129 
    130 //////////////////////////////////////////////////////////////////////////////
    131 
    132 static GM* MyFactory(void*) { return new EmptyPathGM; }
    133 static GMRegistry reg(MyFactory);
    134 
    135 }
    136