Home | History | Annotate | Download | only in samplecode 
      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 "SampleCode.h"
      9 #include "SkBlurMaskFilter.h"
     10 #include "SkColorPriv.h"
     11 #include "SkGradientShader.h"
     12 #include "SkView.h"
     13 #include "SkCanvas.h"
     14 #include "SkUtils.h"
     15 
     16 static SkBitmap make_bitmap() {
     17     SkBitmap bm;
     18     SkColorTable* ctable = new SkColorTable(256);
     19 
     20     SkPMColor* c = ctable->lockColors();
     21     for (int i = 0; i < 256; i++) {
     22         c[i] = SkPackARGB32(255 - i, 0, 0, 0);
     23     }
     24     ctable->unlockColors(true);
     25     bm.setConfig(SkBitmap::kIndex8_Config, 256, 256);
     26     bm.allocPixels(ctable);
     27     ctable->unref();
     28 
     29     bm.lockPixels();
     30     const float cx = bm.width() * 0.5f;
     31     const float cy = bm.height() * 0.5f;
     32     for (int y = 0; y < bm.height(); y++) {
     33         float dy = y - cy;
     34         dy *= dy;
     35         uint8_t* p = bm.getAddr8(0, y);
     36         for (int x = 0; x < 256; x++) {
     37             float dx = x - cx;
     38             dx *= dx;
     39             float d = (dx + dy) / (cx/2);
     40             int id = (int)d;
     41             if (id > 255) {
     42                 id = 255;
     43             }
     44             p[x] = id;
     45         }
     46     }
     47     bm.unlockPixels();
     48     return bm;
     49 }
     50 
     51 class BlurView : public SampleView {
     52     SkBitmap    fBM;
     53 public:
     54 	BlurView() {
     55     }
     56 
     57 protected:
     58     // overrides from SkEventSink
     59     virtual bool onQuery(SkEvent* evt) {
     60         if (SampleCode::TitleQ(*evt)) {
     61             SampleCode::TitleR(evt, "Blur");
     62             return true;
     63         }
     64         return this->INHERITED::onQuery(evt);
     65     }
     66 
     67     void drawBG(SkCanvas* canvas) {
     68         canvas->drawColor(0xFFDDDDDD);
     69     }
     70 
     71     virtual void onDrawContent(SkCanvas* canvas) {
     72         drawBG(canvas);
     73 
     74         SkBlurMaskFilter::BlurStyle NONE = SkBlurMaskFilter::BlurStyle(-999);
     75         static const struct {
     76             SkBlurMaskFilter::BlurStyle fStyle;
     77             int                         fCx, fCy;
     78         } gRecs[] = {
     79             { NONE,                                 0,  0 },
     80             { SkBlurMaskFilter::kInner_BlurStyle,  -1,  0 },
     81             { SkBlurMaskFilter::kNormal_BlurStyle,  0,  1 },
     82             { SkBlurMaskFilter::kSolid_BlurStyle,   0, -1 },
     83             { SkBlurMaskFilter::kOuter_BlurStyle,   1,  0 },
     84         };
     85 
     86         SkPaint paint;
     87         paint.setAntiAlias(true);
     88         paint.setTextSize(25);
     89         canvas->translate(-40, 0);
     90 
     91         SkBlurMaskFilter::BlurFlags flags = SkBlurMaskFilter::kNone_BlurFlag;
     92         for (int j = 0; j < 2; j++) {
     93             canvas->save();
     94             paint.setColor(SK_ColorBLUE);
     95             for (size_t i = 0; i < SK_ARRAY_COUNT(gRecs); i++) {
     96                 if (gRecs[i].fStyle != NONE) {
     97                     SkMaskFilter* mf = SkBlurMaskFilter::Create(20,
     98                                                                 gRecs[i].fStyle,
     99                                                                 flags);
    100                     paint.setMaskFilter(mf)->unref();
    101                 } else {
    102                     paint.setMaskFilter(NULL);
    103                 }
    104                 canvas->drawCircle(200 + gRecs[i].fCx*100.f,
    105                                    200 + gRecs[i].fCy*100.f, 50, paint);
    106             }
    107             // draw text
    108             {
    109                 SkMaskFilter* mf = SkBlurMaskFilter::Create(4,
    110                                                             SkBlurMaskFilter::kNormal_BlurStyle,
    111                                                             flags);
    112                 paint.setMaskFilter(mf)->unref();
    113                 SkScalar x = SkIntToScalar(70);
    114                 SkScalar y = SkIntToScalar(400);
    115                 paint.setColor(SK_ColorBLACK);
    116                 canvas->drawText("Hamburgefons Style", 18, x, y, paint);
    117                 canvas->drawText("Hamburgefons Style", 18, x, y + SkIntToScalar(50), paint);
    118                 paint.setMaskFilter(NULL);
    119                 paint.setColor(SK_ColorWHITE);
    120                 x -= SkIntToScalar(2);
    121                 y -= SkIntToScalar(2);
    122                 canvas->drawText("Hamburgefons Style", 18, x, y, paint);
    123             }
    124             canvas->restore();
    125             flags = SkBlurMaskFilter::kHighQuality_BlurFlag;
    126             canvas->translate(350, 0);
    127         }
    128     }
    129 
    130 private:
    131     typedef SkView INHERITED;
    132 };
    133 
    134 //////////////////////////////////////////////////////////////////////////////
    135 
    136 static SkView* MyFactory() { return new BlurView; }
    137 static SkViewRegister reg(MyFactory);
    138 
    139