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);
}
}
void SkAnimate::onEndElement(SkAnimateMaker& maker) {
bool resolved = resolveCommon(maker);
if (resolved && fFieldInfo == NULL) {
maker.setErrorNoun(field);
maker.setErrorCode(SkDisplayXMLParserError::kFieldNotInTarget);
}
if (resolved == false || fFieldInfo == NULL)
return;
SkDisplayTypes outType = fFieldInfo->getType();
if (fHasValues) {
SkASSERT(to.size() > 0);
fFieldInfo->setValue(maker, &fValues, 0, 0, NULL, outType, to);
SkASSERT(0);
// !!! this needs to set fComponents
return;
}
fComponents = fFieldInfo->getCount();
if (fFieldInfo->fType == SkType_Array) {
SkTypedArray* array = (SkTypedArray*) fFieldInfo->memberData(fTarget);
int count = array->count();
if (count > 0)
fComponents = count;
}
if (outType == SkType_ARGB) {
fComponents <<= 2; // four color components
outType = SkType_Float;
}
fValues.setType(outType);
if (formula.size() > 0){
fComponents = 1;
from.set("0");
to.set("dur");
outType = SkType_MSec;
}
int max = fComponents * 2;
fValues.setCount(max);
memset(fValues.begin(), 0, max * sizeof(fValues.begin()[0]));
fFieldInfo->setValue(maker, &fValues, fFieldOffset, max, this, outType, from);
fFieldInfo->setValue(maker, &fValues, fComponents + fFieldOffset, max, this, outType, to);
}
bool SkMemberInfo::writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage,
int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType,
SkScriptValue& scriptValue) const
{
SkOperand* storage = untypedStorage ? (SkOperand*) untypedStorage : arrayStorage ?
arrayStorage->begin() : NULL;
if (storage)
storage += storageOffset;
SkDisplayTypes type = getType();
if (fType == SkType_MemberProperty) {
if(displayable)
displayable->setProperty(propertyIndex(), scriptValue);
else {
SkASSERT(storageOffset < arrayStorage->count());
switch (scriptValue.fType) {
case SkType_Boolean:
case SkType_Float:
case SkType_Int:
memcpy(&storage->fScalar, &scriptValue.fOperand.fScalar, sizeof(SkScalar));
break;
case SkType_Array:
memcpy(&storage->fScalar, scriptValue.fOperand.fArray->begin(), scriptValue.fOperand.fArray->count() * sizeof(SkScalar));
break;
case SkType_String:
storage->fString->set(*scriptValue.fOperand.fString);
break;
default:
SkASSERT(0); // type isn't handled yet
}
}
} else if (fType == SkType_MemberFunction) {
SkASSERT(scriptValue.fType == SkType_Array);
if (displayable)
displayable->executeFunction(displayable, this, scriptValue.fOperand.fArray, NULL);
else {
int count = scriptValue.fOperand.fArray->count();
// SkASSERT(maxStorage == 0 || count == maxStorage);
if (arrayStorage->count() == 2)
arrayStorage->setCount(2 * count);
else {
storageOffset *= count;
SkASSERT(count + storageOffset <= arrayStorage->count());
}
memcpy(&(*arrayStorage)[storageOffset], scriptValue.fOperand.fArray->begin(), count * sizeof(SkOperand));
}
} else if (fType == SkType_Array) {
SkTypedArray* destArray = (SkTypedArray*) (untypedStorage ? untypedStorage : arrayStorage);
SkASSERT(destArray);
// destArray->setCount(0);
if (scriptValue.fType != SkType_Array) {
SkASSERT(type == scriptValue.fType);
// SkASSERT(storageOffset + 1 <= maxStorage);
destArray->setCount(storageOffset + 1);
(*destArray)[storageOffset] = scriptValue.fOperand;
} else {
if (type == SkType_Unknown) {
type = scriptValue.fOperand.fArray->getType();
destArray->setType(type);
}
SkASSERT(type == scriptValue.fOperand.fArray->getType());
int count = scriptValue.fOperand.fArray->count();
// SkASSERT(storageOffset + count <= maxStorage);
destArray->setCount(storageOffset + count);
memcpy(destArray->begin() + storageOffset, scriptValue.fOperand.fArray->begin(), sizeof(SkOperand) * count);
}
} else if (type == SkType_String) {
SkString* string = untypedStorage ? (SkString*) untypedStorage : (*arrayStorage)[storageOffset].fString;
string->set(*scriptValue.fOperand.fString);
} else if (type == SkType_ARGB && outType == SkType_Float) {
SkTypedArray* array = scriptValue.fOperand.fArray;
SkASSERT(scriptValue.fType == SkType_Int || scriptValue.fType == SkType_ARGB ||
scriptValue.fType == SkType_Array);
SkASSERT(scriptValue.fType != SkType_Array || (array != NULL &&
array->getType() == SkType_Int));
int numberOfColors = scriptValue.fType == SkType_Array ? array->count() : 1;
int numberOfComponents = numberOfColors * 4;
// SkASSERT(maxStorage == 0 || maxStorage == numberOfComponents);
if (maxStorage == 0)
arrayStorage->setCount(numberOfComponents);
for (int index = 0; index < numberOfColors; index++) {
SkColor color = scriptValue.fType == SkType_Array ?
(SkColor) array->begin()[index].fS32 : (SkColor) scriptValue.fOperand.fS32;
storage[0].fScalar = SkIntToScalar(SkColorGetA(color));
storage[1].fScalar = SkIntToScalar(SkColorGetR(color));
storage[2].fScalar = SkIntToScalar(SkColorGetG(color));
storage[3].fScalar = SkIntToScalar(SkColorGetB(color));
storage += 4;
}
} else if (SkDisplayType::IsStruct(NULL /* !!! maker*/, type)) {
if (scriptValue.fType != SkType_Array)
return true; // error
SkASSERT(sizeof(SkScalar) == sizeof(SkOperand)); // !!! no 64 bit pointer support yet
int count = scriptValue.fOperand.fArray->count();
if (count > 0) {
SkASSERT(fCount == count);
memcpy(storage, scriptValue.fOperand.fArray->begin(), count * sizeof(SkOperand));
}
} else if (scriptValue.fType == SkType_Array) {
SkASSERT(scriptValue.fOperand.fArray->getType() == type);
SkASSERT(scriptValue.fOperand.fArray->count() == getCount());
memcpy(storage, scriptValue.fOperand.fArray->begin(), getCount() * sizeof(SkOperand));
} else {
memcpy(storage, &scriptValue.fOperand, sizeof(SkOperand));
}
return false;
}
