Style Change: NULL->nullptr

src/animator/SkAnimator.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkAnimator.h"
@@ skipping 24 matching lines @@
 #endif
 
 _static const char gMathPrimerText[] =
 "<screenplay>"
     "<Math id=\"Math\"/>"
     "<Number id=\"Number\"/>"
 "</screenplay>";
 
 #define gMathPrimer gMathPrimerText
 
-SkAnimator::SkAnimator() : fMaker(NULL) {
+SkAnimator::SkAnimator() : fMaker(nullptr) {
     initialize();
 }
 
 SkAnimator::~SkAnimator() { delete fMaker; }
 
 void SkAnimator::addExtras(SkExtras* extras) {
     *fMaker->fExtras.append() = extras;
 }
 
 bool SkAnimator::appendStream(SkStream* stream) {
@@ skipping 81 matching lines @@
     fMaker->notifyInval();
     return result;
 }
 
 bool SkAnimator::doUserEvent(const SkEvent& evt) {
     fMaker->fEnableTime = fMaker->getAppTime();
     return onEvent(evt);
 }
 
 SkAnimator::DifferenceType SkAnimator::draw(SkCanvas* canvas, SkPaint* paint, SkMSec time) {
-    if (paint == NULL)
+    if (paint == nullptr)
         return draw(canvas, time);
     fMaker->fScreenplay.time = time;
     fMaker->fCanvas = canvas;
     fMaker->fPaint = paint;
     fMaker->fDisplayList.fHasUnion = false;
     int result = fMaker->fDisplayList.draw(*fMaker, time);
     if (result)
         result += fMaker->fDisplayList.fHasUnion;
     return (DifferenceType) result;
 }
@@ skipping 14 matching lines @@
     state.fX = x;
     state.fY = y;
     fMaker->fEnableTime = fMaker->getAppTime();
     bool result = fMaker->fEvents.doEvent(*fMaker, SkDisplayEvent::kMouseDown, &state);
     fMaker->notifyInval();
     return result;
 }
 
 const SkAnimator* SkAnimator::getAnimator(const SkDisplayable* displayable) const {
     if (displayable->getType() != SkType_Movie)
-        return NULL;
+        return nullptr;
     const SkDisplayMovie* movie = (const SkDisplayMovie*) displayable;
     return movie->getAnimator();
 }
 
 const SkDisplayable* SkAnimator::getElement(const char* id) {
     SkDisplayable* element;
     if (fMaker->find(id, &element) == false)
-        return NULL;
+        return nullptr;
     return (const SkDisplayable*) element;
 }
 
 SkElementType SkAnimator::getElementType(const SkDisplayable* ae) {
     SkDisplayable* element = (SkDisplayable*) ae;
-    const SkMemberInfo* info = SkDisplayType::GetMembers(fMaker, element->getType(), NULL);
+    const SkMemberInfo* info = SkDisplayType::GetMembers(fMaker, element->getType(), nullptr);
     return (SkElementType) SkDisplayType::Find(fMaker, info);
 }
 
 SkElementType SkAnimator::getElementType(const char* id) {
     const SkDisplayable* element = getElement(id);
     return getElementType(element);
 }
 
 const SkMemberInfo* SkAnimator::getField(const SkDisplayable* ae, const char* field) {
     SkDisplayable* element = (SkDisplayable*) ae;
@@ skipping 26 matching lines @@
 
 int32_t SkAnimator::getArrayInt(const SkDisplayable* ae,
         const SkMemberInfo* ai, int index) {
     SkOperand operand;
     bool result = getArrayCommon(ae, ai, index, &operand);
     return result ? operand.fS32 : SK_NaN32;
 }
 
 int32_t SkAnimator::getArrayInt(const char* id, const char* fieldID, int index) {
     const SkDisplayable* element = getElement(id);
-    if (element == NULL)
+    if (element == nullptr)
         return SK_NaN32;
     const SkMemberInfo* field = getField(element, fieldID);
-    if (field == NULL)
+    if (field == nullptr)
         return SK_NaN32;
     return getArrayInt(element, field, index);
 }
 
 SkScalar SkAnimator::getArrayScalar(const SkDisplayable* ae,
         const SkMemberInfo* ai, int index) {
     SkOperand operand;
     bool result = getArrayCommon(ae, ai, index, &operand);
     return result ? operand.fScalar : SK_ScalarNaN;
 }
 
 SkScalar SkAnimator::getArrayScalar(const char* id, const char* fieldID, int index) {
     const SkDisplayable* element = getElement(id);
-    if (element == NULL)
+    if (element == nullptr)
         return SK_ScalarNaN;
     const SkMemberInfo* field = getField(element, fieldID);
-    if (field == NULL)
+    if (field == nullptr)
         return SK_ScalarNaN;
     return getArrayScalar(element, field, index);
 }
 
 const char* SkAnimator::getArrayString(const SkDisplayable* ae,
         const SkMemberInfo* ai, int index) {
     SkOperand operand;
     bool result = getArrayCommon(ae, ai, index, &operand);
-    return result ? operand.fString->c_str() : NULL;
+    return result ? operand.fString->c_str() : nullptr;
 }
 
 const char* SkAnimator::getArrayString(const char* id, const char* fieldID, int index) {
     const SkDisplayable* element = getElement(id);
-    if (element == NULL)
-        return NULL;
+    if (element == nullptr)
+        return nullptr;
     const SkMemberInfo* field = getField(element, fieldID);
-    if (field == NULL)
-        return NULL;
+    if (field == nullptr)
+        return nullptr;
     return getArrayString(element, field, index);
 }
 
 SkMSec SkAnimator::getInterval() {
     return fMaker->fMinimumInterval == (SkMSec) -1 ? 0 : fMaker->fMinimumInterval;
 }
 
 void SkAnimator::getInvalBounds(SkRect* inval) {
     if (fMaker->fDisplayList.fHasUnion) {
         inval->fLeft = SkIntToScalar(fMaker->fDisplayList.fInvalBounds.fLeft);
@@ skipping 27 matching lines @@
     }
     SkScriptValue scriptValue;
     bool success = element->getProperty(info->propertyIndex(), &scriptValue);
     if (success && scriptValue.fType == SkType_Int)
         return scriptValue.fOperand.fS32;
     return SK_NaN32;
 }
 
 int32_t SkAnimator::getInt(const char* id, const char* fieldID) {
     const SkDisplayable* element = getElement(id);
-    if (element == NULL)
+    if (element == nullptr)
         return SK_NaN32;
     const SkMemberInfo* field = getField(element, fieldID);
-    if (field == NULL)
+    if (field == nullptr)
         return SK_NaN32;
     return getInt(element, field);
 }
 
 SkScalar SkAnimator::getScalar(const SkDisplayable* element, const SkMemberInfo* info) {
     if (info->fType != SkType_MemberProperty) {
         SkOperand operand;
         if (info->getType() == SkType_Float) {
             info->getValue(element, &operand, 1);
             return operand.fScalar;
         }
         return SK_ScalarNaN;
     }
     SkScriptValue scriptValue;
     bool success = element->getProperty(info->propertyIndex(), &scriptValue);
     if (success && scriptValue.fType == SkType_Float)
         return scriptValue.fOperand.fScalar;
     return SK_ScalarNaN;
 }
 
 SkScalar SkAnimator::getScalar(const char* id, const char* fieldID) {
     const SkDisplayable* element = getElement(id);
-    if (element == NULL)
+    if (element == nullptr)
         return SK_ScalarNaN;
     const SkMemberInfo* field = getField(element, fieldID);
-    if (field == NULL)
+    if (field == nullptr)
         return SK_ScalarNaN;
     return getScalar(element, field);
 }
 
 const char* SkAnimator::getString(const SkDisplayable* ae,
         const SkMemberInfo* ai) {
     const SkDisplayable* element = (const SkDisplayable*) ae;
     const SkMemberInfo* info = (const SkMemberInfo*) ai;
     SkString* temp;
     info->getString(element, &temp);
     return temp->c_str();
 }
 
 const char* SkAnimator::getString(const char* id, const char* fieldID) {
     const SkDisplayable* element = getElement(id);
-    if (element == NULL)
-        return NULL;
+    if (element == nullptr)
+        return nullptr;
     const SkMemberInfo* field = getField(element, fieldID);
-    if (field == NULL)
-        return NULL;
+    if (field == nullptr)
+        return nullptr;
     return getString(element, field);
 }
 
 const char* SkAnimator::getURIBase() {
     return fMaker->fPrefix.c_str();
 }
 
 void SkAnimator::initialize() {
     delete fMaker;
-    fMaker = new SkAnimateMaker(this, NULL, NULL);
+    fMaker = new SkAnimateMaker(this, nullptr, nullptr);
     decodeMemory(gMathPrimer, sizeof(gMathPrimer)-1);
 #ifdef SK_BUILD_FOR_ANDROID
     InitializeSkExtraPathEffects(this);
 #endif
 }
 
 
 #ifdef SK_DEBUG
 bool SkAnimator::isTrackingEvents() {
     return false;
 }
 #endif
 
 bool SkAnimator::onEvent(const SkEvent& evt) {
 #ifdef SK_DEBUG
     SkAnimator* root = fMaker->getRoot();
-    if (root == NULL)
+    if (root == nullptr)
         root = this;
     if (root->isTrackingEvents())
         root->eventDone(evt);
 #endif
     if (evt.isType(SK_EventType_OnEnd)) {
         SkEventState eventState;
         SkDEBUGCODE(bool success =) evt.findPtr("anim", (void**) &eventState.fDisplayable);
         SkASSERT(success);
         SkDEBUGCODE(success =) evt.findS32("time", (int32_t*) &fMaker->fEnableTime);
         SkASSERT(success);
         fMaker->fAdjustedStart = fMaker->getAppTime() - fMaker->fEnableTime;
         fMaker->fEvents.doEvent(*fMaker, SkDisplayEvent::kOnEnd, &eventState);
         fMaker->fAdjustedStart = 0;
         goto inval;
     }
     if (evt.isType(SK_EventType_Delay)) {
         fMaker->doDelayedEvent();
         goto inval;
     }
     {
         const char* id = evt.findString("id");
-        if (id == NULL)
+        if (id == nullptr)
             return false;
         SkDisplayable** firstMovie = fMaker->fMovies.begin();
         SkDisplayable** endMovie = fMaker->fMovies.end();
         for (SkDisplayable** ptr = firstMovie; ptr < endMovie; ptr++) {
             SkDisplayMovie* movie = (SkDisplayMovie*) *ptr;
             movie->doEvent(evt);
         }
         {
             SkDisplayable* event;
             if (fMaker->find(id, &event) == false)
@@ skipping 110 matching lines @@
         SkDisplayArray* dispArray = (SkDisplayArray*) element;
         dispArray->values = array;
         return true;
     }
     else
         return false;   //currently i don't care about this case
 }
 
 bool SkAnimator::setArray(const char* id, const char* fieldID, SkTypedArray array) {
     SkDisplayable* element = (SkDisplayable*) getElement(id);
-    //should I go ahead and change all 'NULL's to 'NULL'?
-    if (element == NULL)
+    //should I go ahead and change all 'nullptr's to 'nullptr'?
+    if (element == nullptr)
         return false;
     const SkMemberInfo* field = getField(element, fieldID);
-    if (field == NULL)
+    if (field == nullptr)
         return false;
     return setArray(element, field, array);
 }
 
 bool SkAnimator::setInt(SkDisplayable* element, const SkMemberInfo* info, int32_t s32) {
     if (info->fType != SkType_MemberProperty) {
         SkOperand operand;
         operand.fS32 = s32;
         SkASSERT(info->getType() == SkType_Int);
         info->setValue(element, &operand, 1);
     } else {
         SkScriptValue scriptValue;
         scriptValue.fType = SkType_Int;
         scriptValue.fOperand.fS32 = s32;
         element->setProperty(info->propertyIndex(), scriptValue);
     }
     return true;
 }
 
 bool SkAnimator::setInt(const char* id, const char* fieldID, int32_t s32) {
     SkDisplayable* element = (SkDisplayable*) getElement(id);
-    if (element == NULL)
+    if (element == nullptr)
         return false;
     const SkMemberInfo* field = getField(element, fieldID);
-    if (field == NULL)
+    if (field == nullptr)
         return false;
     return setInt(element, field, s32);
 }
 
 bool SkAnimator::setScalar(SkDisplayable* element, const SkMemberInfo* info, SkScalar scalar) {
     if (info->fType != SkType_MemberProperty) {
         SkOperand operand;
         operand.fScalar = scalar;
         SkASSERT(info->getType() == SkType_Float);
         info->setValue(element, &operand, 1);
     } else {
         SkScriptValue scriptValue;
         scriptValue.fType = SkType_Float;
         scriptValue.fOperand.fScalar = scalar;
         element->setProperty(info->propertyIndex(), scriptValue);
     }
     return true;
 }
 
 bool SkAnimator::setScalar(const char* id, const char* fieldID, SkScalar scalar) {
     SkDisplayable* element = (SkDisplayable*) getElement(id);
-    if (element == NULL)
+    if (element == nullptr)
         return false;
     const SkMemberInfo* field = getField(element, fieldID);
-    if (field == NULL)
+    if (field == nullptr)
         return false;
     return setScalar(element, field, scalar);
 }
 
 bool SkAnimator::setString(SkDisplayable* element,
         const SkMemberInfo* info, const char* str) {
     // !!! until this is fixed, can't call script with global references from here
-    info->setValue(*fMaker, NULL, 0, info->fCount, element, info->getType(), str, strlen(str));
+    info->setValue(*fMaker, nullptr, 0, info->fCount, element, info->getType(), str, strlen(str));
     return true;
 }
 
 bool SkAnimator::setString(const char* id, const char* fieldID, const char* str) {
     SkDisplayable* element = (SkDisplayable*) getElement(id);
-    if (element == NULL)
+    if (element == nullptr)
         return false;
     const SkMemberInfo* field = getField(element, fieldID);
-    if (field == NULL)
+    if (field == nullptr)
         return false;
     return setString(element, field, str);
 }
 
 void SkAnimator::setTimeline(const Timeline& timeline) {
     fMaker->fTimeline = &timeline;
 }
 
 void SkAnimator::setURIBase(const char* uri) {
     if (uri)
@@ skipping 55 matching lines @@
         gUnitTests[i].fUnitTest();
         SkDebugf("SkAnimator: End UnitTest for %s\n", gUnitTests[i].fTypeName);
     }
 }
 #else
 void SkAnimator::Init(bool) {}
 #endif
 
 void SkAnimator::Term() {
 }