Style Change: NULL->nullptr

src/animator/SkDisplayApply.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 "SkDisplayApply.h"
@@ skipping 38 matching lines @@
     SK_MEMBER_PROPERTY(steps, Int),
     SK_MEMBER_PROPERTY(time, MSec),
     SK_MEMBER(transition, ApplyTransition)
 };
 
 #endif
 
 DEFINE_GET_MEMBER(SkApply);
 
 SkApply::SkApply() : begin(0), dontDraw(false), interval((SkMSec) -1), mode((Mode) -1), /*pickup(false), */
-    restore(false), scope(NULL), steps(-1), transition((Transition) -1), fActive(NULL), /*fCurrentScope(NULL),*/
+    restore(false), scope(nullptr), steps(-1), transition((Transition) -1), fActive(nullptr), /*fCurrentScope(nullptr),*/
     fLastTime(0), fAppended(false), fContainsScope(false), fDeleteScope(false), fEmbedded(false),
     fEnabled(false), fEnabling(false) {
 }
 
 SkApply::~SkApply() {
     for (SkADrawable** curPtr = fScopes.begin(); curPtr < fScopes.end(); curPtr++)
         delete *curPtr;
     if (fDeleteScope)
         delete scope;
     // !!! caller must call maker.removeActive(fActive)
     delete fActive;
 }
 
 void SkApply::activate(SkAnimateMaker& maker) {
-    if (fActive != NULL) {
+    if (fActive != nullptr) {
         if (fActive->fDrawIndex == 0 && fActive->fDrawMax == 0)
             return; // if only one use, nothing more to do
         if (restore == false)
             return; // all share same state, regardless of instance number
         bool save = fActive->initializeSave();
         fActive->fixInterpolator(save);
     } else {
         fActive = new SkActive(*this, maker);
         fActive->init();
         maker.appendActive(fActive);
         if (restore) {
             fActive->initializeSave();
             int animators = fAnimators.count();
             for (int index = 0; index < animators; index++)
                 fActive->saveInterpolatorValues(index);
         }
     }
 }
 
 void SkApply::append(SkApply* apply) {
-    if (fActive == NULL)
+    if (fActive == nullptr)
         return;
     int oldCount = fActive->fAnimators.count();
     fActive->append(apply);
     if (restore) {
         fActive->appendSave(oldCount);
         int newCount = fActive->fAnimators.count();
         for (int index = oldCount; index < newCount; index++)
             fActive->saveInterpolatorValues(index);
     }
 }
 
 void SkApply::applyValues(int animatorIndex, SkOperand* values, int count,
      SkDisplayTypes valuesType, SkMSec time)
 {
     SkAnimateBase* animator = fActive->fAnimators[animatorIndex];
     const SkMemberInfo * info = animator->fFieldInfo;
     SkASSERT(animator);
-    SkASSERT(info != NULL);
+    SkASSERT(info != nullptr);
     SkDisplayTypes type = (SkDisplayTypes) info->fType;
     SkDisplayable* target = getTarget(animator);
     if (animator->hasExecute() || type == SkType_MemberFunction || type == SkType_MemberProperty) {
         SkDisplayable* executor = animator->hasExecute() ? animator : target;
         if (type != SkType_MemberProperty) {
             SkTDArray<SkScriptValue> typedValues;
             for (int index = 0; index < count; index++) {
                 SkScriptValue temp;
                 temp.fType = valuesType;
                 temp.fOperand = values[index];
                 *typedValues.append() = temp;
             }
-            executor->executeFunction(target, info->functionIndex(), typedValues, info->getType(), NULL);
+            executor->executeFunction(target, info->functionIndex(), typedValues, info->getType(), nullptr);
         } else {
             SkScriptValue scriptValue;
             scriptValue.fOperand = values[0];
             scriptValue.fType = info->getType();
             target->setProperty(info->propertyIndex(), scriptValue);
         }
     } else {
         SkTypedArray converted;
         if (type == SkType_ARGB) {
             if (count == 4) {
@@ skipping 18 matching lines @@
 bool SkApply::contains(SkDisplayable* child) {
     for (SkADrawable** curPtr = fScopes.begin(); curPtr < fScopes.end(); curPtr++) {
         if (*curPtr == child || (*curPtr)->contains(child))
             return true;
     }
     return fDeleteScope && scope == child;
 }
 
 SkDisplayable* SkApply::deepCopy(SkAnimateMaker* maker) {
     SkADrawable* saveScope = scope;
-    scope = NULL;
+    scope = nullptr;
     SkApply* result = (SkApply*) INHERITED::deepCopy(maker);
     result->scope = scope = saveScope;
     SkAnimateBase** end = fAnimators.end();
     for (SkAnimateBase** animPtr = fAnimators.begin(); animPtr < end; animPtr++) {
         SkAnimateBase* anim = (SkAnimateBase*) (*animPtr)->deepCopy(maker);
         *result->fAnimators.append() = anim;
         maker->helperAdd(anim);
     }
     return result;
 }
 
 void SkApply::disable() {
     //!!! this is the right thing to do, but has bad side effects because of other problems
     // currently, if an apply is in a g and scopes a statement in another g, it ends up as members
     // of both containers. The disabling here incorrectly disables both instances
     // maybe the fEnabled flag needs to be moved to the fActive data so that both
     // instances are not affected.
 //  fEnabled = false;
 }
 
 bool SkApply::draw(SkAnimateMaker& maker) {
-    if (scope ==NULL)
+    if (scope ==nullptr)
         return false;
     if (scope->isApply() || scope->isDrawable() == false)
         return false;
     if (fEnabled == false)
         enable(maker);
     SkASSERT(scope);
     activate(maker);
     if (mode == kMode_immediate)
         return fActive->draw();
     bool result = interpolate(maker, maker.getInTime());
@@ skipping 57 matching lines @@
     SkDisplayList::fDumpIndex = save;
     if (closedYet)
         dumpEnd(maker);
     else
         SkDebugf("/>\n");
 }
 #endif
 
 bool SkApply::enable(SkAnimateMaker& maker) {
     fEnabled = true;
-    bool initialized = fActive != NULL;
+    bool initialized = fActive != nullptr;
     if (dynamicScope.size() > 0)
         enableDynamic(maker);
     if (maker.fError.hasError())
         return false;
     int animators = fAnimators.count();
     int index;
     for (index = 0; index < animators; index++) {
         SkAnimateBase* animator = fAnimators[index];
         animator->fStart = maker.fEnableTime;
         animator->fResetPending = animator->fReset;
     }
     if (scope && scope->isApply())
         ((SkApply*) scope)->setEmbedded();
 /*  if (mode == kMode_once) {
         if (scope) {
             activate(maker);
             interpolate(maker, maker.fEnableTime);
             inactivate(maker);
         }
         return true;
     }*/
-    if ((mode == kMode_immediate || mode == kMode_create) && scope == NULL)
+    if ((mode == kMode_immediate || mode == kMode_create) && scope == nullptr)
         return false;   // !!! error?
     bool enableMe = scope && (scope->hasEnable() || scope->isApply() || scope->isDrawable() == false);
     if ((mode == kMode_immediate && enableMe) || mode == kMode_create)
         activate(maker);    // for non-drawables like post, prime them here
     if (mode == kMode_immediate && enableMe)
         fActive->enable();
-    if (mode == kMode_create && scope != NULL) {
+    if (mode == kMode_create && scope != nullptr) {
         enableCreate(maker);
         return true;
     }
     if (mode == kMode_immediate) {
         return scope->isApply() || scope->isDrawable() == false;
     }
     refresh(maker);
     SkDisplayList& displayList = maker.fDisplayList;
     SkADrawable* drawable;
 #if defined SK_DEBUG && defined SK_DEBUG_ANIMATION_TIMING
     SkString debugOut;
     SkMSec time = maker.getAppTime();
     debugOut.appendS32(time - maker.fDebugTimeBase);
     debugOut.append(" apply enable id=");
     debugOut.append(_id);
     debugOut.append("; start=");
     debugOut.appendS32(maker.fEnableTime - maker.fDebugTimeBase);
     SkDebugf("%s\n", debugOut.c_str());
 #endif
-    if (scope == NULL || scope->isApply() || scope->getType() == SkType_Movie || scope->isDrawable() == false) {
+    if (scope == nullptr || scope->isApply() || scope->getType() == SkType_Movie || scope->isDrawable() == false) {
         activate(maker);    // for non-drawables like post, prime them here
         if (initialized) {
             append(this);
         }
         fEnabling = true;
         interpolate(maker, maker.fEnableTime);
         fEnabling = false;
-        if (scope != NULL && dontDraw == false)
+        if (scope != nullptr && dontDraw == false)
             scope->enable(maker);
         return true;
     } else if (initialized && restore == false)
         append(this);
 #if 0
     bool wasActive = inactivate(maker); // start fresh
     if (wasActive) {
         activate(maker);
         interpolate(maker, maker.fEnableTime);
         return true;
@@ skipping 25 matching lines @@
                 *parentList->append() = this;
             } else
                 maker.setErrorCode(SkDisplayXMLParserError::kDisplayTreeTooDeep);
             old = -1;
         } else
             reset();
     } else {
         SkASSERT(old < parentList->count());
         if ((*parentList)[old]->isApply()) {
             SkApply* apply = (SkApply*) (*parentList)[old];
-            if (apply != this && apply->fActive == NULL)
+            if (apply != this && apply->fActive == nullptr)
                 apply->activate(maker);
             apply->append(this);
-            parentGroup = NULL;
+            parentGroup = nullptr;
         } else {
             if (parentGroup)
                 parentGroup->markCopySize(old);
             SkADrawable** newApplyLocation = &(*parentList)[old];
             SkGroup* pGroup;
             int oldApply = displayList.findGroup(this, &parentList, &pGroup, &thisGroup, &grandList);
             if (oldApply >= 0) {
                 (*parentList)[oldApply] = (SkADrawable*) SkDisplayType::CreateInstance(&maker, SkType_Apply);
-                parentGroup = NULL;
+                parentGroup = nullptr;
                 fDeleteScope = true;
             }
             *newApplyLocation = this;
         }
     }
     if (parentGroup) {
         parentGroup->markCopySet(old);
         fDeleteScope = dynamicScope.size() == 0;
     }
     return true;
 }
 
 void SkApply::enableCreate(SkAnimateMaker& maker) {
     SkString newID;
     for (int step = 0; step <= steps; step++) {
         fLastTime = step * SK_MSec1;
         bool success = maker.computeID(scope, this, &newID);
         if (success == false)
             return;
-        if (maker.find(newID.c_str(), NULL))
+        if (maker.find(newID.c_str(), nullptr))
             continue;
         SkApply* copy = (SkApply*) deepCopy(&maker); // work on copy of animator state
         if (mode == kMode_create)
             copy->mode = (Mode) -1;
         SkADrawable* copyScope = copy->scope = (SkADrawable*) scope->deepCopy(&maker);
         *fScopes.append() = copyScope;
         if (copyScope->resolveIDs(maker, scope, this)) {
             step = steps; // quit
             goto next; // resolveIDs failed
         }
@@ skipping 11 matching lines @@
     }
 }
 
 void SkApply::enableDynamic(SkAnimateMaker& maker) {
     SkASSERT(mode != kMode_create); // create + dynamic are not currently compatible
     SkDisplayable* newScope;
     bool success = SkAnimatorScript::EvaluateDisplayable(maker, this, dynamicScope.c_str(),
         &newScope);
     if (success && scope != newScope) {
         SkTDDrawableArray* pList, * gList;
-        SkGroup* pGroup = NULL, * found = NULL;
+        SkGroup* pGroup = nullptr, * found = nullptr;
         int old = maker.fDisplayList.findGroup(scope, &pList, &pGroup, &found, &gList);
         if (pList && old >= 0 && (*pList)[old]->isApply() && (*pList)[old] != this) {
             if (fAppended == false) {
-                if (found != NULL) {
+                if (found != nullptr) {
                     SkDisplayable* oldChild = (*pList)[old];
                     if (oldChild->isApply() && found->copySet(old)) {
                         found->markCopyClear(old);
     //                  delete oldChild;
                     }
                 }
                 (*pList)[old] = scope;
             } else
                 pList->remove(old);
         }
         scope = (SkADrawable*) newScope;
         onEndElement(maker);
     }
     maker.removeActive(fActive);
     delete fActive;
-    fActive = NULL;
+    fActive = nullptr;
 }
 
 void SkApply::endSave(int index) {
     SkAnimateBase* animate = fActive->fAnimators[index];
     const SkMemberInfo* info = animate->fFieldInfo;
     SkDisplayTypes type = (SkDisplayTypes) info->fType;
     if (type == SkType_MemberFunction)
         return;
     SkDisplayable* target = getTarget(animate);
     size_t size = info->getSize(target);
@@ skipping 58 matching lines @@
             return true;
     }
     return false;
 }
 
 bool SkApply::hasEnable() const {
     return true;
 }
 
 bool SkApply::inactivate(SkAnimateMaker& maker) {
-    if (fActive == NULL)
+    if (fActive == nullptr)
         return false;
     maker.removeActive(fActive);
     delete fActive;
-    fActive = NULL;
+    fActive = nullptr;
     return true;
 }
 
 #ifdef SK_DEBUG
 SkMSec lastTime = (SkMSec) -1;
 #endif
 
 bool SkApply::interpolate(SkAnimateMaker& maker, SkMSec rawTime) {
-    if (fActive == NULL)
+    if (fActive == nullptr)
         return false;
     bool result = false;
 #if defined SK_DEBUG && defined SK_DEBUG_ANIMATION_TIMING
     SkMSec time = maker.getAppTime();
     if (lastTime == (SkMSec) -1)
         lastTime = rawTime - 1;
-    if (fActive != NULL &&
+    if (fActive != nullptr &&
         strcmp(id, "a3") == 0 && rawTime > lastTime) {
         lastTime += 1000;
         SkString debugOut;
         debugOut.appendS32(time - maker.fDebugTimeBase);
         debugOut.append(" apply id=");
         debugOut.append(_id);
         debugOut.append("; ");
         debugOut.append(fActive->fAnimators[0]->_id);
         debugOut.append("=");
         debugOut.appendS32(rawTime - fActive->fState[0].fStartTime);
@@ skipping 60 matching lines @@
 //          SkDEBUGF(("interpolate: post on end\n"));
             state.fUnpostedEndEvent = false;
             maker.postOnEnd(animate, state.fBegin + state.fDuration);
             maker.fAdjustedStart = 0;    // !!! left over from synchronizing animation days, undoubtably out of date (and broken)
         }
         if (animate->formula.size() > 0) {
             if (fLastTime > animate->dur)
                 fLastTime = animate->dur;
             SkTypedArray formulaValues;
             formulaValues.setCount(count);
-            SkDEBUGCODE(bool success = ) animate->fFieldInfo->setValue(maker, &formulaValues, 0, 0, NULL,
+            SkDEBUGCODE(bool success = ) animate->fFieldInfo->setValue(maker, &formulaValues, 0, 0, nullptr,
                 animate->getValuesType(), animate->formula);
             SkASSERT(success);
             if (restore)
                 save(inner); // save existing value
             applyValues(inner, formulaValues.begin(), count, animate->getValuesType(), innerTime);
         } else {
             if (restore)
                 save(inner); // save existing value
             applyValues(inner, values.get(), count, animate->getValuesType(), innerTime);
         }
     }
     return result;
 }
 
 void SkApply::initialize() {
-    if (scope == NULL)
+    if (scope == nullptr)
         return;
     if (scope->isApply() || scope->isDrawable() == false)
         return;
     scope->initialize();
 }
 
 void SkApply::onEndElement(SkAnimateMaker& maker)
 {
     SkADrawable* scopePtr = scope;
     while (scopePtr && scopePtr->isApply()) {
         SkApply* scopedApply = (SkApply*) scopePtr;
         if (scopedApply->scope == this) {
             maker.setErrorCode(SkDisplayXMLParserError::kApplyScopesItself);
             return;
         }
         scopePtr = scopedApply->scope;
     }
     if (mode == kMode_create)
         return;
-    if (scope != NULL && steps >= 0 && scope->isApply() == false && scope->isDrawable())
+    if (scope != nullptr && steps >= 0 && scope->isApply() == false && scope->isDrawable())
         scope->setSteps(steps);
     for (SkAnimateBase** animPtr = fAnimators.begin(); animPtr < fAnimators.end(); animPtr++) {
         SkAnimateBase* anim = *animPtr;
         //for reusing apply statements with dynamic scope
-        if (anim->fTarget == NULL || anim->fTargetIsScope) {
+        if (anim->fTarget == nullptr || anim->fTargetIsScope) {
             anim->fTargetIsScope = true;
             if (scope)
                 anim->fTarget = scope;
             else
                 anim->setTarget(maker);
             anim->onEndElement(maker);  // allows animate->fFieldInfo to be set
         }
-        if (scope != NULL && steps >= 0 && anim->fTarget != scope && anim->fTarget->isDrawable())
+        if (scope != nullptr && steps >= 0 && anim->fTarget != scope && anim->fTarget->isDrawable())
             anim->fTarget->setSteps(steps);
     }
 }
 
 const SkMemberInfo* SkApply::preferredChild(SkDisplayTypes type) {
     SkASSERT(SkDisplayType::IsAnimate(type) == false);
     fContainsScope = true;
     return getMember("scope"); // !!! cwap! need to refer to member through enum like kScope instead
 }
 
@@ skipping 49 matching lines @@
 //      info = animate->getResolvedInfo();
     SkDisplayTypes type = (SkDisplayTypes) info->fType;
     if (type == SkType_MemberFunction)
         return; // nothing to save
     size_t size = info->getSize(target);
     int count = (int) (size / sizeof(SkScalar));
     bool useLast = true;
 // !!! this all may be unneeded, at least in the dynamic case ??
     int activeIndex = fActive->fDrawIndex + index;
     SkTDOperandArray last;
-    if (fActive->fSaveRestore[activeIndex] == NULL) {
+    if (fActive->fSaveRestore[activeIndex] == nullptr) {
         fActive->fSaveRestore[activeIndex] = new SkOperand[count];
         useLast = false;
     } else {
         last.setCount(count);
         memcpy(last.begin(), fActive->fSaveRestore[activeIndex], count * sizeof(SkOperand));
     }
     if (type != SkType_MemberProperty) {
         info->getValue(target, fActive->fSaveRestore[activeIndex], count);
         if (useLast)
             info->setValue(target, last.begin(), count);
@@ skipping 33 matching lines @@
 void SkApply::setSteps(int _steps) {
     steps = _steps;
 }
 
 #ifdef SK_DEBUG
 void SkApply::validate() {
     if (fActive)
         fActive->validate();
 }
 #endif