Style Change: NULL->nullptr

samplecode/SampleAll.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 "SkCanvas.h"
@@ skipping 66 matching lines @@
 };
 
 ///////////////////////////////////////////////////////////
 
 static void r0(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
     p.setMaskFilter(SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
                                              SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(3)),
                                              SkBlurMaskFilter::kNone_BlurFlag))->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 30 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);
 }
 
 static void r5(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
     rastBuilder->addLayer(p);
 
     p.setPathEffect(SkDiscretePathEffect::Create(SK_Scalar1*4, SK_Scalar1*3))->unref();
     p.setXfermodeMode(SkXfermode::kSrcOut_Mode);
     rastBuilder->addLayer(p);
 }
@@ skipping 43 matching lines @@
 static void r8(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
     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(new Dot2DPathEffect(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 65 matching lines @@
     }
 
     virtual void onDrawContent(SkCanvas* canvas) {
         canvas->save();
         this->drawPicture(canvas, 0);
         canvas->restore();
 
         {
             SkPictureRecorder recorder;
             {
-                SkCanvas* record = recorder.beginRecording(320, 480, NULL, 0);
+                SkCanvas* record = recorder.beginRecording(320, 480, nullptr, 0);
                 this->drawPicture(record, 120);
             }
             SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
             canvas->translate(0, SkIntToScalar(120));
 
             SkRect clip;
             clip.set(0, 0, SkIntToScalar(160), SkIntToScalar(160));
             do {
                 canvas->save();
@@ skipping 35 matching lines @@
                                        SkIntToScalar((unsigned int)index * 2));
         SkTDArray<SkPoint>(pos2);
         pos2.setCount(asciiLength);
         for (index = 0;  index < asciiLength; index++)
             pos2[index].set(SkIntToScalar((unsigned int)index * 10),
                                         SkIntToScalar(20));
 
         // shaders
         SkPoint linearPoints[] = { { 0, 0, }, { SkIntToScalar(40), SkIntToScalar(40) } };
         SkColor linearColors[] = { SK_ColorRED, SK_ColorBLUE };
-        SkScalar* linearPos = NULL;
+        SkScalar* linearPos = nullptr;
         int linearCount = 2;
         SkShader::TileMode linearMode = SkShader::kMirror_TileMode;
         SkShader* linear = SkGradientShader::CreateLinear(linearPoints,
             linearColors, linearPos, linearCount, linearMode);
 
         SkPoint radialCenter = { SkIntToScalar(25), SkIntToScalar(25) };
         SkScalar radialRadius = SkIntToScalar(25);
         SkColor radialColors[] = { SK_ColorGREEN, SK_ColorGRAY, SK_ColorRED };
         SkScalar radialPos[] = { 0, SkIntToScalar(3) / 5, SkIntToScalar(1)};
         int radialCount = 3;
@@ skipping 29 matching lines @@
         canvas->drawPaint(paint);
         canvas->save();
 
         // line (exercises xfermode, colorShader, colorFilter, filterShader)
         paint.setColor(SK_ColorGREEN);
         paint.setStrokeWidth(SkIntToScalar(10));
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setXfermode(xfermode)->unref();
         paint.setColorFilter(lightingFilter)->unref();
         canvas->drawLine(start.fX, start.fY, stop.fX, stop.fY, paint); // should not be green
-        paint.setXfermode(NULL);
-        paint.setColorFilter(NULL);
+        paint.setXfermode(nullptr);
+        paint.setColorFilter(nullptr);
 
         // rectangle
         paint.setStyle(SkPaint::kFill_Style);
         canvas->translate(SkIntToScalar(50), 0);
         paint.setColor(SK_ColorYELLOW);
         paint.setShader(linear)->unref();
         paint.setPathEffect(pathEffectTest())->unref();
         canvas->drawRect(rect, paint);
-        paint.setPathEffect(NULL);
+        paint.setPathEffect(nullptr);
 
         // circle w/ emboss & transparent (exercises 3dshader)
         canvas->translate(SkIntToScalar(50), 0);
         paint.setMaskFilter(embossFilter)->unref();
         canvas->drawOval(rect, paint);
         canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
 //        paint.setShader(transparentShader)->unref();
         canvas->drawOval(rect, paint);
         canvas->translate(0, SkIntToScalar(-10));
 
         // path
         canvas->translate(SkIntToScalar(50), 0);
         paint.setColor(SK_ColorRED);
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(SkIntToScalar(5));
         paint.setShader(radial)->unref();
-        paint.setMaskFilter(NULL);
+        paint.setMaskFilter(nullptr);
         canvas->drawPath(path, paint);
 
-        paint.setShader(NULL);
+        paint.setShader(nullptr);
         // bitmap, sprite
         canvas->translate(SkIntToScalar(50), 0);
         paint.setStyle(SkPaint::kFill_Style);
         canvas->drawBitmap(fBug, left, top, &paint);
         canvas->translate(SkIntToScalar(30), 0);
         canvas->drawSprite(fTb,
             SkScalarRoundToInt(canvas->getTotalMatrix().getTranslateX()),
             spriteOffset + 10, &paint);
 
         canvas->translate(-SkIntToScalar(30), SkIntToScalar(30));
         paint.setShader(shaderTest())->unref(); // test compose shader
         canvas->drawRect(rect2, paint);
-        paint.setShader(NULL);
+        paint.setShader(nullptr);
 
         canvas->restore();
         // text
         canvas->translate(0, SkIntToScalar(60));
         canvas->save();
         paint.setColor(SK_ColorGRAY);
         canvas->drawPosText(ascii, asciiLength, pos.begin(), paint);
         canvas->drawPosText(ascii, asciiLength, pos2.begin(), paint);
 
         canvas->translate(SkIntToScalar(50), 0);
         paint.setColor(SK_ColorCYAN);
         canvas->drawText(utf8, sizeof(utf8) - 1, x, y, paint);
 
         canvas->translate(SkIntToScalar(30), 0);
         paint.setColor(SK_ColorMAGENTA);
         paint.setTextEncoding(SkPaint::kUTF16_TextEncoding);
         matrix.setTranslate(SkIntToScalar(10), SkIntToScalar(10));
         canvas->drawTextOnPath((void*) utf16, sizeof(utf16), path, &matrix, paint);
         canvas->translate(0, SkIntToScalar(20));
         canvas->drawTextOnPath((void*) utf16simple, sizeof(utf16simple), path, &matrix, paint);
         canvas->restore();
 
         canvas->translate(0, SkIntToScalar(60));
         paint.setTextEncoding(SkPaint::kUTF8_TextEncoding);
         canvas->restore();
     }
 
     virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) {
         fClickPt.set(x, y);
-        this->inval(NULL);
+        this->inval(nullptr);
         return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
     SkPathEffect* pathEffectTest() {
         static const int gXY[] = { 1, 0, 0, -1, 2, -1, 3, 0, 2, 1, 0, 1 };
         SkScalar gPhase = 0;
         SkPath path;
         path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1]));
         for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2)
             path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1]));
         path.close();
         path.offset(SkIntToScalar(-6), 0);
         SkPathEffect* outer = SkPath1DPathEffect::Create(path, SkIntToScalar(12),
             gPhase, SkPath1DPathEffect::kRotate_Style);
         SkPathEffect* inner = SkDiscretePathEffect::Create(SkIntToScalar(2),
             SkIntToScalar(1)/10); // SkCornerPathEffect(SkIntToScalar(2));
         SkPathEffect* result = SkComposePathEffect::Create(outer, inner);
         outer->unref();
         inner->unref();
         return result;
     }
 
     SkShader* shaderTest() {
         SkPoint pts[] = { { 0, 0, }, { SkIntToScalar(100), 0 } };
         SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
-        SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, NULL,
+        SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, nullptr,
             2, SkShader::kClamp_TileMode);
         pts[1].set(0, SkIntToScalar(100));
         SkColor colors2[] = {SK_ColorBLACK,  SkColorSetARGB(0x80, 0, 0, 0)};
-        SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors2, NULL,
+        SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors2, nullptr,
             2, SkShader::kClamp_TileMode);
         SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstIn_Mode);
         SkShader* result = new SkComposeShader(shaderA, shaderB, mode);
         shaderA->unref();
         shaderB->unref();
         mode->unref();
         return result;
     }
 
     virtual void startTest() {
@@ skipping 17 matching lines @@
         paint.setAntiAlias(true);
         paint.setTextSize(SkIntToScalar(48));
         paint.setTypeface(SkTypeface::CreateFromName("sans-serif",
                                                      SkTypeface::kBold));
 
         SkString str("GOOGLE");
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(gRastProcs); i++) {
             apply_shader(&paint, (int)i);
 
-          //  paint.setMaskFilter(NULL);
+          //  paint.setMaskFilter(nullptr);
           //  paint.setColor(SK_ColorBLACK);
 
 #if 01
             int index = i % SK_ARRAY_COUNT(gLightingColors);
             paint.setColorFilter(SkColorFilter::CreateLightingFilter(
                                     gLightingColors[index].fMul,
                                     gLightingColors[index].fAdd))->unref();
 #endif
 
             canvas->drawText(str.c_str(), str.size(), x, y, paint);
@@ skipping 11 matching lines @@
 private:
     SkPoint fClickPt;
     SkBitmap fBug, fTb, fTx;
     typedef SampleView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* MyFactory() { return new DemoView; }
 static SkViewRegister reg(MyFactory);