Style Change: NULL->nullptr

samplecode/SampleSlides.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SampleCode.h"
 #include "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
@@ skipping 75 matching lines @@
     paint->setPathEffect(SkPath1DPathEffect::Create(path, SkIntToScalar(21), 0,
                                                     SkPath1DPathEffect::kRotate_Style))->unref();
     compose_pe(paint);
 }
 
 typedef void (*PE_Proc)(SkPaint*);
 static const PE_Proc gPE[] = { hair_pe, hair2_pe, stroke_pe, dash_pe, one_d_pe };
 
 static void fill_pe(SkPaint* paint) {
     paint->setStyle(SkPaint::kFill_Style);
-    paint->setPathEffect(NULL);
+    paint->setPathEffect(nullptr);
 }
 
 static void discrete_pe(SkPaint* paint) {
     paint->setPathEffect(SkDiscretePathEffect::Create(10, 4))->unref();
 }
 
 static SkPathEffect* MakeTileEffect() {
     SkMatrix m;
     m.setScale(SkIntToScalar(12), SkIntToScalar(12));
 
@@ skipping 57 matching lines @@
 static const SkColor gColors[] = {
 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
 };
 static const SkScalar gPos0[] = { 0, SK_Scalar1 };
 static const SkScalar gPos1[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
 static const SkScalar gPos2[] = {
 0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
 };
 
 static const GradData gGradData[] = {
-{ 2, gColors, NULL },
+{ 2, gColors, nullptr },
 { 2, gColors, gPos0 },
 { 2, gColors, gPos1 },
-{ 5, gColors, NULL },
+{ 5, gColors, nullptr },
 { 5, gColors, gPos2 }
 };
 
 static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, data.fCount, tm);
 }
 
 static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
@@ skipping 95 matching lines @@
     len = strlen(text);
     SkScalar pathLen = getpathlen(path);
     SkMatrix matrix;
 
     paint.setColor(SK_ColorBLACK);
     paint.setStyle(SkPaint::kStroke_Style);
     canvas->drawPath(path, paint);
     paint.setStyle(SkPaint::kFill_Style);
 
     paint.setTextSize(50);
-    canvas->drawTextOnPath(text, len, path, NULL, paint);
+    canvas->drawTextOnPath(text, len, path, nullptr, paint);
 
     paint.setColor(SK_ColorRED);
     matrix.setScale(-SK_Scalar1, SK_Scalar1);
     matrix.postTranslate(pathLen, 0);
     canvas->drawTextOnPath(text, len, path, &matrix, paint);
 
     paint.setColor(SK_ColorBLUE);
     matrix.setScale(SK_Scalar1, -SK_Scalar1);
     canvas->drawTextOnPath(text, len, path, &matrix, paint);
 
@@ skipping 16 matching lines @@
     SkImageDecoder::DecodeFile("/skimages/logo.gif", &bm);
     size->set(bm.width(), bm.height());
     return SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode,
                                         SkShader::kClamp_TileMode);
 }
 
 static SkShader* make_shader1(const SkIPoint& size) {
     SkPoint pts[] = { { 0, 0 },
                       { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
     SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
-    return SkGradientShader::CreateLinear(pts, colors, NULL,
+    return SkGradientShader::CreateLinear(pts, colors, nullptr,
                                           SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode);
 }
 
 class Rec {
 public:
     SkCanvas::VertexMode    fMode;
     int                     fCount;
     SkPoint*                fVerts;
     SkPoint*                fTexs;
 
-    Rec() : fCount(0), fVerts(NULL), fTexs(NULL) {}
+    Rec() : fCount(0), fVerts(nullptr), fTexs(nullptr) {}
     ~Rec() { delete[] fVerts; delete[] fTexs; }
 };
 
 static void make_tris(Rec* rec) {
     int n = 10;
     SkRandom    rand;
 
     rec->fMode = SkCanvas::kTriangles_VertexMode;
     rec->fCount = n * 3;
     rec->fVerts = new SkPoint[rec->fCount];
@@ skipping 84 matching lines @@
     make_fan(&fRecs[1], size.fX, size.fY);
     make_tris(&fRecs[2]);
 
     SkPaint paint;
     paint.setDither(true);
     paint.setFilterQuality(kLow_SkFilterQuality);
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(fRecs); i++) {
         canvas->save();
 
-        paint.setShader(NULL);
+        paint.setShader(nullptr);
         canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
                              fRecs[i].fVerts, fRecs[i].fTexs,
-                             NULL, NULL, NULL, 0, paint);
+                             nullptr, nullptr, nullptr, 0, paint);
 
         canvas->translate(SkIntToScalar(210), 0);
 
         paint.setShader(fShader0);
         canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
                              fRecs[i].fVerts, fRecs[i].fTexs,
-                             NULL, NULL, NULL, 0, paint);
+                             nullptr, nullptr, nullptr, 0, paint);
 
         canvas->translate(SkIntToScalar(210), 0);
 
         paint.setShader(fShader1);
         canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
                              fRecs[i].fVerts, fRecs[i].fTexs,
-                             NULL, NULL, NULL, 0, paint);
+                             nullptr, nullptr, nullptr, 0, paint);
         canvas->restore();
 
         canvas->translate(0, SkIntToScalar(250));
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void r0(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
 {
     p.setMaskFilter(SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
                                              SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(3))))->unref();
     rastBuilder->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
 
-    p.setMaskFilter(NULL);
+    p.setMaskFilter(nullptr);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(SK_Scalar1);
     rastBuilder->addLayer(p);
 
     p.setAlpha(0x11);
     p.setStyle(SkPaint::kFill_Style);
     p.setXfermodeMode(SkXfermode::kSrc_Mode);
     rastBuilder->addLayer(p);
 }
 
@@ skipping 34 matching lines @@
 
 static void r4(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
 {
     p.setAlpha(0x60);
     rastBuilder->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
 
     p.setAlpha(0xFF);
     p.setXfermodeMode(SkXfermode::kClear_Mode);
     rastBuilder->addLayer(p, SK_Scalar1*3/2, SK_Scalar1*3/2);
 
-    p.setXfermode(NULL);
+    p.setXfermode(nullptr);
     rastBuilder->addLayer(p);
 }
 
 #include "SkDiscretePathEffect.h"
 
 static void r5(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
 {
     rastBuilder->addLayer(p);
 
     p.setPathEffect(SkDiscretePathEffect::Create(SK_Scalar1*4, SK_Scalar1*3))->unref();
@@ skipping 34 matching lines @@
 {
     rastBuilder->addLayer(p);
 
     SkMatrix    lattice;
     lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
     lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
     p.setPathEffect(MakeDotEffect(SK_Scalar1*2, lattice))->unref();
     p.setXfermodeMode(SkXfermode::kClear_Mode);
     rastBuilder->addLayer(p);
 
-    p.setPathEffect(NULL);
-    p.setXfermode(NULL);
+    p.setPathEffect(nullptr);
+    p.setXfermode(nullptr);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(SK_Scalar1);
     rastBuilder->addLayer(p);
 }
 
 static void r9(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
 {
     rastBuilder->addLayer(p);
 
     SkMatrix    lattice;
     lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0);
     lattice.postRotate(SkIntToScalar(30), 0, 0);
     p.setPathEffect(SkLine2DPathEffect::Create(SK_Scalar1*2, lattice))->unref();
     p.setXfermodeMode(SkXfermode::kClear_Mode);
     rastBuilder->addLayer(p);
 
-    p.setPathEffect(NULL);
-    p.setXfermode(NULL);
+    p.setPathEffect(nullptr);
+    p.setXfermode(nullptr);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(SK_Scalar1);
     rastBuilder->addLayer(p);
 }
 
 typedef void (*raster_proc)(SkLayerRasterizer::Builder*, SkPaint&);
 
 static const raster_proc gRastProcs[] = {
     r0, r1, r2, r3, r4, r5, r6, r7, r8, r9
 };
@@ skipping 88 matching lines @@
     }
 
     void onDrawContent(SkCanvas* canvas) override {
         this->init();
         gProc[fIndex](canvas);
     }
 
     SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override {
         this->init();
         fIndex = (fIndex + 1) % SK_ARRAY_COUNT(gProc);
-        this->inval(NULL);
-        return NULL;
+        this->inval(nullptr);
+        return nullptr;
     }
 
 private:
     typedef SampleView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* MyFactory() { return new SlideView; }
 static SkViewRegister reg(MyFactory);