+/* libs/graphics/animator/SkDisplayApply.cpp

+**

+** Copyright 2006, Google Inc.

+**

+** Licensed under the Apache License, Version 2.0 (the "License");

+** you may not use this file except in compliance with the License.

+** You may obtain a copy of the License at

+**

+** http://www.apache.org/licenses/LICENSE-2.0

+**

+** Unless required by applicable law or agreed to in writing, software

+** distributed under the License is distributed on an "AS IS" BASIS,

+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+** See the License for the specific language governing permissions and

+** limitations under the License.

+*/

+

+#include "SkDisplayApply.h"

+#include "SkAnimateActive.h"

+#include "SkAnimateMaker.h"

+#include "SkAnimateSet.h"

+#include "SkAnimatorScript.h"

+#include "SkDisplayType.h"

+#include "SkDrawGroup.h"

+#include "SkParse.h"

+#include "SkScript.h"

+#include "SkSystemEventTypes.h"

+#ifdef SK_DEBUG

+#include "SkTime.h"

+#endif

+#include <ctype.h>

+

+enum SkApply_Properties {

+ SK_PROPERTY(animator),

+ SK_PROPERTY(step),

+ SK_PROPERTY(steps),

+ SK_PROPERTY(time)

+};

+

+#if SK_USE_CONDENSED_INFO == 0

+

+// if no attibutes, enclosed displayable is both scope & target

+// only if both scope & target are specified, or if target and enclosed displayable, are scope and target different

+const SkMemberInfo SkApply::fInfo[] = {

+ SK_MEMBER_PROPERTY(animator, Animate),

+ SK_MEMBER(begin, MSec),

+ SK_MEMBER(dontDraw, Boolean),

+ SK_MEMBER(dynamicScope, String),

+ SK_MEMBER(interval, MSec), // recommended redraw interval

+ SK_MEMBER(mode, ApplyMode),

+#if 0

+ SK_MEMBER(pickup, Boolean),

+#endif

+ SK_MEMBER(restore, Boolean),

+ SK_MEMBER(scope, Drawable), // thing that scopes animation (unnamed enclosed displayable goes here)

+ SK_MEMBER_PROPERTY(step, Int),

+ 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),*/

+ 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++)

+ 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)

+ 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)

+ 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);

+ 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);

+ } 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) {

+ // !!! assert that it is SkType_Float ?

+ animator->packARGB(&values->fScalar, count, &converted);

+ values = converted.begin();

+ count = converted.count();

+ } else

+ SkASSERT(count == 1);

+ }

+// SkASSERT(type == SkType_ARGB || type == SkType_String ||info->isSettable());

+ 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++) {

+ if (*curPtr == child || (*curPtr)->contains(child))

+ return true;

+ }

+ return fDeleteScope && scope == child;

+}

+

+SkDisplayable* SkApply::deepCopy(SkAnimateMaker* maker) {

+ SkDrawable* 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;

+}

+

+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)

+ 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());

+ if (dontDraw == false) {

+// if (scope->isDrawable())

+ result |= scope->draw(maker);

+ }

+ if (restore) {

+ for (int index = 0; index < fActive->fAnimators.count(); index++)

+ endSave(index);

+ fActive->advance();

+ }

+ return result;

+}

+

+#ifdef SK_DUMP_ENABLED

+void SkApply::dump(SkAnimateMaker* maker) {

+ dumpBase(maker);

+ if (dynamicScope.isEmpty() == false)

+ SkDebugf("dynamicScope=\"%s\" ", dynamicScope.c_str());

+ if (dontDraw)

+ SkDebugf("dontDraw=\"true\" ");

+ if (begin != 0) //perhaps we want this no matter what?

+ SkDebugf("begin=\"%g\" ", (float) begin/1000.0f); //is this correct?

+ if (interval != (SkMSec) -1)

+ SkDebugf("interval=\"%g\" ", (float) interval/1000.0f);

+ if (steps != -1)

+ SkDebugf("steps=\"%d\" ", steps);

+ if (restore)

+ SkDebugf("restore=\"true\" ");

+ if (transition == kTransition_reverse)

+ SkDebugf("transition=\"reverse\" ");

+ if (mode == kMode_immediate) {

+ SkDebugf("mode=\"immediate\" ");

+ }

+ else if (mode == kMode_create) {

+ SkDebugf("mode=\"create\" ");

+ }

+ bool closedYet = false;

+ SkDisplayList::fIndent += 4;

+ int save = SkDisplayList::fDumpIndex;

+ if (scope) {

+ if (closedYet == false) {

+ SkDebugf(">\n");

+ closedYet = true;

+ }

+ scope->dump(maker);

+ }

+ int index;

+// if (fActive) {

+ for (index = 0; index < fAnimators.count(); index++) {

+ if (closedYet == false) {

+ SkDebugf(">\n");

+ closedYet = true;

+ }

+ SkAnimateBase* animator = fAnimators[index];

+ animator->dump(maker);

+// }

+ }

+ SkDisplayList::fIndent -= 4;

+ SkDisplayList::fDumpIndex = save;

+ if (closedYet)

+ dumpEnd(maker);

+ else

+ SkDebugf("/>\n");

+}

+#endif

+

+bool SkApply::enable(SkAnimateMaker& maker) {

+ fEnabled = true;

+ bool initialized = fActive != NULL;

+ 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)

+ 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) {

+ enableCreate(maker);

+ return true;

+ }

+ if (mode == kMode_immediate) {

+ return scope->isApply() || scope->isDrawable() == false;

+ }

+ refresh(maker);

+ SkDisplayList& displayList = maker.fDisplayList;

+ SkDrawable* 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) {

+ 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)

+ 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;

+ }

+#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;

+ 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 == true) {

+append:

+ if (parentGroup)

+ parentGroup->markCopySize(old);

+ if (parentList->count() < 10000) {

+ fAppended = true;

+ *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)

+ apply->activate(maker);

+ apply->append(this);

+ parentGroup = NULL;

+ } else {

+ if (parentGroup)

+ parentGroup->markCopySize(old);

+ SkDrawable** 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);

+ 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);

+ *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

+ }

+ copy->activate(maker);

+ copy->interpolate(maker, step * SK_MSec1);

+ maker.removeActive(copy->fActive);

+ next:

+ delete copy;

+ }

+}

+

+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;

+ 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) {

+ 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;

+ onEndElement(maker);

+ }

+ maker.removeActive(fActive);

+ delete fActive;

+ fActive = NULL;

+}

+

+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);

+ int count = (int) (size / sizeof(SkScalar));

+ int activeIndex = fActive->fDrawIndex + index;

+ SkOperand* last = new SkOperand[count];

+ SkAutoTDelete<SkOperand> autoLast(last);

+ if (type != SkType_MemberProperty) {

+ info->getValue(target, last, count);

+ SkOperand* saveOperand = fActive->fSaveRestore[activeIndex];

+ if (saveOperand)

+ info->setValue(target, fActive->fSaveRestore[activeIndex], count);

+ } else {

+ SkScriptValue scriptValue;

+ bool success = target->getProperty(info->propertyIndex(), &scriptValue);

+ SkASSERT(success = true);

+ last[0] = scriptValue.fOperand;

+ scriptValue.fOperand = fActive->fSaveRestore[activeIndex][0];

+ target->setProperty(info->propertyIndex(), scriptValue);

+ }

+ SkOperand* save = fActive->fSaveRestore[activeIndex];

+ if (save)

+ memcpy(save, last, count * sizeof(SkOperand));

+}

+

+bool SkApply::getProperty(int index, SkScriptValue* value) const {

+ switch (index) {

+ case SK_PROPERTY(step):

+ value->fType = SkType_Int;

+ value->fOperand.fS32 = fLastTime / SK_MSec1;

+ break;

+ case SK_PROPERTY(steps):

+ value->fType = SkType_Int;

+ value->fOperand.fS32 = steps;

+ break;

+ case SK_PROPERTY(time):

+ value->fType = SkType_MSec;

+ value->fOperand.fS32 = fLastTime;

+ break;

+ default:

+ // SkASSERT(0);

+ return false;

+ }

+ return true;

+}

+

+void SkApply::getStep(SkScriptValue* value) {

+ getProperty(SK_PROPERTY(step), value);

+}

+

+SkDrawable* SkApply::getTarget(SkAnimateBase* animate) {

+ if (animate->fTargetIsScope == false || mode != kMode_create)

+ return animate->fTarget;

+ return scope;

+}

+

+bool SkApply::hasDelayedAnimator() const {

+ SkAnimateBase** animEnd = fAnimators.end();

+ for (SkAnimateBase** animPtr = fAnimators.begin(); animPtr < animEnd; animPtr++) {

+ SkAnimateBase* animator = *animPtr;

+ if (animator->fDelayed)

+ return true;

+ }

+ return false;

+}

+

+bool SkApply::hasEnable() const {

+ return true;

+}

+

+bool SkApply::inactivate(SkAnimateMaker& maker) {

+ if (fActive == NULL)

+ return false;

+ maker.removeActive(fActive);

+ delete fActive;

+ fActive = NULL;

+ return true;

+}

+

+#ifdef SK_DEBUG

+SkMSec lastTime = (SkMSec) -1;

+#endif

+

+bool SkApply::interpolate(SkAnimateMaker& maker, SkMSec rawTime) {

+ if (fActive == NULL)

+ 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 &&

+ 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);

+ debugOut.append(")");

+ SkDebugf("%s\n", debugOut.c_str());

+ }

+#endif

+ fActive->start();

+ if (restore)

+ fActive->initializeSave();

+ int animators = fActive->fAnimators.count();

+ for (int inner = 0; inner < animators; inner++) {

+ SkAnimateBase* animate = fActive->fAnimators[inner];

+ if (animate->fChanged) {

+ animate->fChanged = false;

+ animate->fStart = rawTime;

+ // SkTypedArray values;

+ // int count = animate->fValues.count();

+ // values.setCount(count);

+ // memcpy(values.begin(), animate->fValues.begin(), sizeof(SkOperand) * count);

+ animate->onEndElement(maker);

+ // if (memcmp(values.begin(), animate->fValues.begin(), sizeof(SkOperand) * count) != 0) {

+ fActive->append(this);

+ fActive->start();

+ // }

+ }

+ SkMSec time = fActive->getTime(rawTime, inner);

+ SkActive::SkState& state = fActive->fState[inner];

+ if (SkMSec_LT(rawTime, state.fStartTime)) {

+ if (fEnabling) {

+ animate->fDelayed = true;

+ maker.delayEnable(this, state.fStartTime);

+ }

+ continue;

+ } else

+ animate->fDelayed = false;

+ SkMSec innerTime = fLastTime = state.getRelativeTime(time);

+ if (restore)

+ fActive->restoreInterpolatorValues(inner);

+ if (animate->fReset) {

+ if (transition != SkApply::kTransition_reverse) {

+ if (SkMSec_LT(state.fBegin + state.fDuration, innerTime)) {

+ if (animate->fResetPending) {

+ innerTime = 0;

+ animate->fResetPending = false;

+ } else

+ continue;

+ }

+ } else if (innerTime == 0) {

+ if (animate->fResetPending) {

+ innerTime = state.fBegin + state.fDuration;

+ animate->fResetPending = false;

+ } else

+ continue;

+ }

+ }

+ int count = animate->components();

+ SkAutoSTMalloc<16, SkOperand> values(count);

+ SkInterpolatorBase::Result interpResult = fActive->fInterpolators[inner]->timeToValues(

+ innerTime, values.get());

+ result |= (interpResult != SkInterpolatorBase::kFreezeEnd_Result);

+ if ((transition != SkApply::kTransition_reverse && interpResult == SkInterpolatorBase::kFreezeEnd_Result ||

+ transition == SkApply::kTransition_reverse && fLastTime == 0) && state.fUnpostedEndEvent) {

+// 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);

+ bool success = animate->fFieldInfo->setValue(maker, &formulaValues, 0, 0, NULL,

+ 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)

+ return;

+ if (scope->isApply() || scope->isDrawable() == false)

+ return;

+ scope->initialize();

+}

+

+void SkApply::onEndElement(SkAnimateMaker& maker)

+{

+ SkDrawable* 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())

+ 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) {

+ 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())

+ 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

+}

+

+void SkApply::refresh(SkAnimateMaker& maker) {

+ for (SkAnimateBase** animPtr = fAnimators.begin(); animPtr < fAnimators.end(); animPtr++) {

+ SkAnimateBase* animate = *animPtr;

+ animate->onEndElement(maker);

+ }

+ if (fActive)

+ fActive->resetInterpolators();

+}

+

+void SkApply::reset() {

+ if (fActive)

+ fActive->resetState();

+}

+

+bool SkApply::resolveIDs(SkAnimateMaker& maker, SkDisplayable* original, SkApply* apply) { // replace to/formula strings in animators of the form xxx.step with the step value, if xxx.step is in scope

+ if (resolveField(maker, apply, &dynamicScope) == false)

+ return true; // failed

+ SkAnimateBase** endPtr = fAnimators.end();

+ SkAnimateBase** origPtr = ((SkApply*) original)->fAnimators.begin();

+ for (SkAnimateBase** animPtr = fAnimators.begin(); animPtr < endPtr; ) {

+ SkAnimateBase* animator = *animPtr++;

+ maker.resolveID(animator, *origPtr++);

+ if (resolveField(maker, this, &animator->target) == false)

+ return true;

+ if (resolveField(maker, this, &animator->from) == false)

+ return true;

+ if (resolveField(maker, this, &animator->to) == false)

+ return true;

+ if (resolveField(maker, this, &animator->formula) == false)

+ return true;

+ }

+// setEmbedded();

+ onEndElement(maker);

+ return false; // succeeded

+}

+

+bool SkApply::resolveField(SkAnimateMaker& maker, SkDisplayable* parent, SkString* str) {

+ const char* script = str->c_str();

+ if (str->startsWith("#string:") == false)

+ return true;

+ script += sizeof("#string:") - 1;

+ return SkAnimatorScript::EvaluateString(maker, this, parent, script, str);

+}

+

+void SkApply::save(int index) {

+ SkAnimateBase* animate = fActive->fAnimators[index];

+ const SkMemberInfo * info = animate->fFieldInfo;

+ SkDisplayable* target = getTarget(animate);

+// if (animate->hasExecute())

+// 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) {

+ 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);

+ } else {

+ SkScriptValue scriptValue;

+ bool success = target->getProperty(info->propertyIndex(), &scriptValue);

+ SkASSERT(success == true);

+ SkASSERT(scriptValue.fType == SkType_Float);

+ fActive->fSaveRestore[activeIndex][0] = scriptValue.fOperand;

+ if (useLast) {

+ SkScriptValue scriptValue;

+ scriptValue.fType = type;

+ scriptValue.fOperand = last[0];

+ target->setProperty(info->propertyIndex(), scriptValue);

+ }

+ }

+// !!! end of unneeded

+}

+

+bool SkApply::setProperty(int index, SkScriptValue& scriptValue) {

+ switch (index) {

+ case SK_PROPERTY(animator): {

+ SkAnimateBase* animate = (SkAnimateBase*) scriptValue.fOperand.fDisplayable;

+ SkASSERT(animate->isAnimate());

+ *fAnimators.append() = animate;

+ return true;

+ }

+ case SK_PROPERTY(steps):

+ steps = scriptValue.fOperand.fS32;

+ if (fActive)

+ fActive->setSteps(steps);

+ return true;

+ }

+ return false;

+}

+

+void SkApply::setSteps(int _steps) {

+ steps = _steps;

+}

+

+#ifdef SK_DEBUG

+void SkApply::validate() {

+ if (fActive)

+ fActive->validate();

+}

+#endif

+

+

+