rename SkDrawable to SkADrawable

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 44 matching lines @@
 
 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),*/
     fLastTime(0), fAppended(false), fContainsScope(false), fDeleteScope(false), fEmbedded(false),
     fEnabled(false), fEnabling(false) {
 }
 
 SkApply::~SkApply() {
-    for (SkDrawable** curPtr = fScopes.begin(); curPtr < fScopes.end(); curPtr++)
+    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->fDrawIndex == 0 && fActive->fDrawMax == 0)
@@ skipping 70 matching lines @@
         if (type == SkType_String || type == SkType_DynamicString)
             info->setString(target, values->fString);
         else if (type == SkType_Drawable || type == SkType_Displayable)
             target->setReference(info, values->fDisplayable);
         else
             info->setValue(target, values, count);
     }
 }
 
 bool SkApply::contains(SkDisplayable* child) {
-    for (SkDrawable** curPtr = fScopes.begin(); curPtr < fScopes.end(); curPtr++) {
+    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) {
-    SkDrawable* saveScope = scope;
+    SkADrawable* saveScope = scope;
     scope = NULL;
     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;
@@ skipping 118 matching lines @@
         fActive->enable();
     if (mode == kMode_create && scope != NULL) {
         enableCreate(maker);
         return true;
     }
     if (mode == kMode_immediate) {
         return scope->isApply() || scope->isDrawable() == false;
     }
     refresh(maker);
     SkDisplayList& displayList = maker.fDisplayList;
-    SkDrawable* drawable;
+    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
@@ skipping 19 matching lines @@
     }
 #endif
 //  start here;
     // now that one apply might embed another, only the parent apply should replace the scope
     // or get appended to the display list
     // similarly, an apply added by an add immediate has already been located in the display list
     // and should not get moved or added again here
     if (fEmbedded) {
         return false;   // already added to display list by embedder
     }
-    drawable = (SkDrawable*) scope;
+    drawable = (SkADrawable*) scope;
     SkTDDrawableArray* parentList;
     SkTDDrawableArray* grandList;
     SkGroup* parentGroup;
     SkGroup* thisGroup;
     int old = displayList.findGroup(drawable, &parentList, &parentGroup, &thisGroup, &grandList);
     if (old < 0)
         goto append;
     else if (fContainsScope) {
         if ((*parentList)[old] != this || restore) {
 append:
@@ skipping 11 matching lines @@
         SkASSERT(old < parentList->count());
         if ((*parentList)[old]->isApply()) {
             SkApply* apply = (SkApply*) (*parentList)[old];
             if (apply != this && apply->fActive == NULL)
                 apply->activate(maker);
             apply->append(this);
             parentGroup = NULL;
         } else {
             if (parentGroup)
                 parentGroup->markCopySize(old);
-            SkDrawable** newApplyLocation = &(*parentList)[old];
+            SkADrawable** newApplyLocation = &(*parentList)[old];
             SkGroup* pGroup;
             int oldApply = displayList.findGroup(this, &parentList, &pGroup, &thisGroup, &grandList);
             if (oldApply >= 0) {
-                (*parentList)[oldApply] = (SkDrawable*) SkDisplayType::CreateInstance(&maker, SkType_Apply);
+                (*parentList)[oldApply] = (SkADrawable*) SkDisplayType::CreateInstance(&maker, SkType_Apply);
                 parentGroup = NULL;
                 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))
             continue;
         SkApply* copy = (SkApply*) deepCopy(&maker); // work on copy of animator state
         if (mode == kMode_create)
             copy->mode = (Mode) -1;
-        SkDrawable* copyScope = copy->scope = (SkDrawable*) scope->deepCopy(&maker);
+        SkADrawable* copyScope = copy->scope = (SkADrawable*) scope->deepCopy(&maker);
         *fScopes.append() = copyScope;
         if (copyScope->resolveIDs(maker, scope, this)) {
             step = steps; // quit
             goto next; // resolveIDs failed
         }
         if (newID.size() > 0)
             maker.setID(copyScope, newID);
         if (copy->resolveIDs(maker, this, this)) { // fix up all fields, including target
             step = steps; // quit
             goto next; // resolveIDs failed
@@ skipping 21 matching lines @@
                     SkDisplayable* oldChild = (*pList)[old];
                     if (oldChild->isApply() && found->copySet(old)) {
                         found->markCopyClear(old);
     //                  delete oldChild;
                     }
                 }
                 (*pList)[old] = scope;
             } else
                 pList->remove(old);
         }
-        scope = (SkDrawable*) newScope;
+        scope = (SkADrawable*) newScope;
         onEndElement(maker);
     }
     maker.removeActive(fActive);
     delete fActive;
     fActive = NULL;
 }
 
 void SkApply::endSave(int index) {
     SkAnimateBase* animate = fActive->fAnimators[index];
     const SkMemberInfo* info = animate->fFieldInfo;
@@ skipping 42 matching lines @@
     //      SkASSERT(0);
             return false;
     }
     return true;
 }
 
 void SkApply::getStep(SkScriptValue* value) {
     getProperty(SK_PROPERTY(step), value);
 }
 
-SkDrawable* SkApply::getTarget(SkAnimateBase* animate) {
+SkADrawable* SkApply::getTarget(SkAnimateBase* animate) {
     if (animate->fTargetIsScope == false || mode != kMode_create)
         return animate->fTarget;
     return scope;
 }
 
 bool SkApply::hasDelayedAnimator() const {
     SkAnimateBase* const* animEnd = fAnimators.end();
     for (SkAnimateBase* const* animPtr = fAnimators.begin(); animPtr < animEnd; animPtr++) {
         SkAnimateBase* const animator = *animPtr;
         if (animator->fDelayed)
@@ skipping 126 matching lines @@
 void SkApply::initialize() {
     if (scope == NULL)
         return;
     if (scope->isApply() || scope->isDrawable() == false)
         return;
     scope->initialize();
 }
 
 void SkApply::onEndElement(SkAnimateMaker& maker)
 {
-    SkDrawable* scopePtr = scope;
+    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;
@@ skipping 127 matching lines @@
 void SkApply::setSteps(int _steps) {
     steps = _steps;
 }
 
 #ifdef SK_DEBUG
 void SkApply::validate() {
     if (fActive)
         fActive->validate();
 }
 #endif