/* * 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 "SkAnimatorScript.h" #include "SkAnimateBase.h" #include "SkAnimateMaker.h" #include "SkDisplayTypes.h" #include "SkExtras.h" #include "SkMemberInfo.h" #include "SkParse.h" static const SkDisplayEnumMap gEnumMaps[] = { { SkType_AddMode, "indirect|immediate" }, { SkType_Align, "left|center|right" }, { SkType_ApplyMode, "create|immediate|once" }, { SkType_ApplyTransition, "normal|reverse" }, { SkType_BitmapEncoding, "jpeg|png" }, { SkType_BitmapFormat, "none|A1|A8|Index8|RGB16|RGB32" }, { SkType_Boolean, "false|true" }, { SkType_Cap, "butt|round|square" }, { SkType_EventCode, "none|leftSoftKey|rightSoftKey|home|back|send|end|key0|key1|key2|key3|key4|key5|key6|key7|key8|key9|star|hash|up|down|left|right|OK|volUp|volDown|camera" }, { SkType_EventKind, "none|keyChar|keyPress|keyPressUp|mouseDown|mouseDrag|mouseMove|mouseUp|onEnd|onLoad|user" }, { SkType_EventMode, "deferred|immediate" }, { SkType_FillType, "winding|evenOdd" }, { SkType_FilterType, "none|bilinear" }, { SkType_FontStyle, "normal|bold|italic|boldItalic" }, { SkType_FromPathMode, "normal|angle|position" }, { SkType_Join, "miter|round|blunt" }, { SkType_MaskFilterBlurStyle, "normal|solid|outer|inner" }, { SkType_PathDirection, "cw|ccw" }, { SkType_Style, "fill|stroke|strokeAndFill" }, { SkType_TextBoxAlign, "start|center|end" }, { SkType_TextBoxMode, "oneLine|lineBreak" }, { SkType_TileMode, "clamp|repeat|mirror" }, { SkType_Xfermode, "clear|src|dst|srcOver|dstOver|srcIn|dstIn|srcOut|dstOut|" "srcATop|dstATop|xor|darken|lighten" }, }; static int gEnumMapCount = SK_ARRAY_COUNT(gEnumMaps); SkAnimatorScript::SkAnimatorScript(SkAnimateMaker& maker, SkDisplayable* working, SkDisplayTypes type) : SkScriptEngine(SkScriptEngine::ToOpType(type)), fMaker(maker), fParent(nullptr), fWorking(working) { memberCallBack(EvalMember, (void*) this); memberFunctionCallBack(EvalMemberFunction, (void*) this); boxCallBack(Box, (void*) this); unboxCallBack(Unbox, (void*) &maker); propertyCallBack(EvalID, (void*) this); // must be first (entries are prepended, will be last), since it never fails propertyCallBack(Infinity, (void*) this); propertyCallBack(NaN, (void*) this); functionCallBack(Eval, (void*) this); functionCallBack(IsFinite, (void*) this); functionCallBack(IsNaN, (void*) this); if (type == SkType_ARGB) { functionCallBack(EvalRGB, (void*) this); propertyCallBack(EvalNamedColor, (void*) &maker.fIDs); } if (SkDisplayType::IsEnum(&maker, type)) { // !!! for SpiderMonkey, iterate through the enum values, and map them to globals const SkDisplayEnumMap& map = GetEnumValues(type); propertyCallBack(EvalEnum, (void*) map.fValues); } for (SkExtras** extraPtr = maker.fExtras.begin(); extraPtr < maker.fExtras.end(); extraPtr++) { SkExtras* extra = *extraPtr; if (extra->fExtraCallBack) propertyCallBack(extra->fExtraCallBack, extra->fExtraStorage); } } SkAnimatorScript::~SkAnimatorScript() { for (SkDisplayable** dispPtr = fTrackDisplayable.begin(); dispPtr < fTrackDisplayable.end(); dispPtr++) delete *dispPtr; } bool SkAnimatorScript::evaluate(const char* original, SkScriptValue* result, SkDisplayTypes type) { const char* script = original; bool success = evaluateScript(&script, result); if (success == false || result->fType != type) { fMaker.setScriptError(*this); return false; } return true; } bool SkAnimatorScript::Box(void* user, SkScriptValue* scriptValue) { SkAnimatorScript* engine = (SkAnimatorScript*) user; SkDisplayTypes type = scriptValue->fType; SkDisplayable* displayable; switch (type) { case SkType_Array: { SkDisplayArray* boxedValue = new SkDisplayArray(*scriptValue->fOperand.fArray); displayable = boxedValue; } break; case SkType_Boolean: { SkDisplayBoolean* boxedValue = new SkDisplayBoolean; displayable = boxedValue; boxedValue->value = !! scriptValue->fOperand.fS32; } break; case SkType_Int: { SkDisplayInt* boxedValue = new SkDisplayInt; displayable = boxedValue; boxedValue->value = scriptValue->fOperand.fS32; } break; case SkType_Float: { SkDisplayFloat* boxedValue = new SkDisplayFloat; displayable = boxedValue; boxedValue->value = scriptValue->fOperand.fScalar; } break; case SkType_String: { SkDisplayString* boxedValue = new SkDisplayString(*scriptValue->fOperand.fString); displayable = boxedValue; } break; case SkType_Displayable: scriptValue->fOperand.fObject = scriptValue->fOperand.fDisplayable; scriptValue->fType = SkType_Displayable; return true; default: SkASSERT(0); return false; } engine->track(displayable); scriptValue->fOperand.fObject = displayable; scriptValue->fType = SkType_Displayable; return true; } bool SkAnimatorScript::Eval(const char* function, size_t len, SkTDArray& params, void* eng, SkScriptValue* value) { if (SK_LITERAL_STR_EQUAL("eval", function, len) == false) return false; if (params.count() != 1) return false; SkAnimatorScript* host = (SkAnimatorScript*) eng; SkAnimatorScript engine(host->fMaker, host->fWorking, SkScriptEngine::ToDisplayType(host->fReturnType)); SkScriptValue* scriptValue = params.begin(); bool success = true; if (scriptValue->fType == SkType_String) { const char* script = scriptValue->fOperand.fString->c_str(); success = engine.evaluateScript(&script, value); } else *value = *scriptValue; return success; } bool SkAnimatorScript::EvalEnum(const char* token, size_t len, void* callBack, SkScriptValue* value) { const char* tokens = (const char*) callBack; value->fType = SkType_Int; if (MapEnums(tokens, token, len, (int*)&value->fOperand.fS32)) return true; return false; } bool SkAnimatorScript::EvalID(const char* token, size_t len, void* user, SkScriptValue* value) { SkAnimatorScript* engine = (SkAnimatorScript*) user; SkTDict* ids = &engine->fMaker.fIDs; SkDisplayable* displayable; bool success = ids->find(token, len, &displayable); if (success == false) { displayable = engine->fWorking; if (SK_LITERAL_STR_EQUAL("parent", token, len)) { SkDisplayable* parent = displayable->getParent(); if (parent == nullptr) parent = engine->fParent; if (parent) { value->fOperand.fDisplayable = parent; value->fType = SkType_Displayable; return true; } } if (displayable && EvalMember(token, len, displayable, engine, value)) return true; value->fOperand.fString = nullptr; value->fType = SkType_String; } else { SkDisplayable* working = engine->fWorking; value->fOperand.fDisplayable = displayable; value->fType = SkType_Displayable; if (displayable->canContainDependents() && working && working->isAnimate()) { SkAnimateBase* animator = (SkAnimateBase*) working; if (animator->isDynamic()) { SkDisplayDepend* depend = (SkDisplayDepend* ) displayable; depend->addDependent(working); } } } return true; } bool SkAnimatorScript::EvalNamedColor(const char* token, size_t len, void* callback, SkScriptValue* value) { value->fType = SkType_Int; if (SkParse::FindNamedColor(token, len, (SkColor*) &value->fOperand.fS32) != nullptr) return true; return false; } bool SkAnimatorScript::EvalRGB(const char* function, size_t len, SkTDArray& params, void* eng, SkScriptValue* value) { if (SK_LITERAL_STR_EQUAL("rgb", function, len) == false) return false; if (params.count() != 3) return false; SkScriptEngine* engine = (SkScriptEngine*) eng; unsigned result = 0xFF000000; int shift = 16; for (SkScriptValue* valuePtr = params.begin(); valuePtr < params.end(); valuePtr++) { engine->convertTo(SkType_Int, valuePtr); result |= SkClampMax(valuePtr->fOperand.fS32, 255) << shift; shift -= 8; } value->fOperand.fS32 = result; value->fType = SkType_Int; return true; } bool SkAnimatorScript::EvalMemberCommon(SkScriptEngine* engine, const SkMemberInfo* info, SkDisplayable* displayable, SkScriptValue* value) { SkDisplayTypes original; SkDisplayTypes type = original = (SkDisplayTypes) info->getType(); if (info->fType == SkType_Array) type = SkType_Array; switch (type) { case SkType_ARGB: type = SkType_Int; case SkType_Boolean: case SkType_Int: case SkType_MSec: case SkType_Float: SkASSERT(info->getCount() == 1); if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction) value->fOperand.fS32 = *(int32_t*) info->memberData(displayable); // OK for SkScalar too if (type == SkType_MSec) { value->fOperand.fScalar = value->fOperand.fS32 * 0.001f; type = SkType_Float; } break; case SkType_String: { SkString* displayableString; if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction) { info->getString(displayable, &displayableString); value->fOperand.fString = new SkString(*displayableString); } } break; case SkType_Array: { SkASSERT(info->fType != SkType_MemberProperty); // !!! incomplete SkTDOperandArray* displayableArray = (SkTDOperandArray*) info->memberData(displayable); if (displayable->getType() == SkType_Array) { SkDisplayArray* typedArray = (SkDisplayArray*) displayable; original = typedArray->values.getType(); } SkASSERT(original != SkType_Unknown); SkTypedArray* array = value->fOperand.fArray = new SkTypedArray(original); engine->track(array); int count = displayableArray->count(); if (count > 0) { array->setCount(count); memcpy(array->begin(), displayableArray->begin(), count * sizeof(SkOperand)); } } break; default: SkASSERT(0); // unimplemented } value->fType = type; return true; } bool SkAnimatorScript::EvalMember(const char* member, size_t len, void* object, void* eng, SkScriptValue* value) { SkScriptEngine* engine = (SkScriptEngine*) eng; SkDisplayable* displayable = (SkDisplayable*) object; SkString name(member, len); SkDisplayable* named = displayable->contains(name); if (named) { value->fOperand.fDisplayable = named; value->fType = SkType_Displayable; return true; } const SkMemberInfo* info = displayable->getMember(name.c_str()); if (info == nullptr) return false; if (info->fType == SkType_MemberProperty) { if (displayable->getProperty(info->propertyIndex(), value) == false) { SkASSERT(0); return false; } } return EvalMemberCommon(engine, info, displayable, value); } bool SkAnimatorScript::EvalMemberFunction(const char* member, size_t len, void* object, SkTDArray& params, void* eng, SkScriptValue* value) { SkScriptEngine* engine = (SkScriptEngine*) eng; SkDisplayable* displayable = (SkDisplayable*) object; SkString name(member, len); const SkMemberInfo* info = displayable->getMember(name.c_str()); SkASSERT(info != nullptr); /* !!! error handling unimplemented */ if (info->fType != SkType_MemberFunction) { SkASSERT(0); return false; } displayable->executeFunction(displayable, info->functionIndex(), params, info->getType(), value); return EvalMemberCommon(engine, info, displayable, value); } bool SkAnimatorScript::EvaluateDisplayable(SkAnimateMaker& maker, SkDisplayable* displayable, const char* script, SkDisplayable** result) { SkAnimatorScript engine(maker, displayable, SkType_Displayable); SkScriptValue value; bool success = engine.evaluate(script, &value, SkType_Displayable); if (success) *result = value.fOperand.fDisplayable; return success; } bool SkAnimatorScript::EvaluateInt(SkAnimateMaker& maker, SkDisplayable* displayable, const char* script, int32_t* result) { SkAnimatorScript engine(maker, displayable, SkType_Int); SkScriptValue value; bool success = engine.evaluate(script, &value, SkType_Int); if (success) *result = value.fOperand.fS32; return success; } bool SkAnimatorScript::EvaluateFloat(SkAnimateMaker& maker, SkDisplayable* displayable, const char* script, SkScalar* result) { SkAnimatorScript engine(maker, displayable, SkType_Float); SkScriptValue value; bool success = engine.evaluate(script, &value, SkType_Float); if (success) *result = value.fOperand.fScalar; return success; } bool SkAnimatorScript::EvaluateString(SkAnimateMaker& maker, SkDisplayable* displayable, const char* script, SkString* result) { SkAnimatorScript engine(maker, displayable, SkType_String); SkScriptValue value; bool success = engine.evaluate(script, &value, SkType_String); if (success) result->set(*(value.fOperand.fString)); return success; } bool SkAnimatorScript::EvaluateString(SkAnimateMaker& maker, SkDisplayable* displayable, SkDisplayable* parent, const char* script, SkString* result) { SkAnimatorScript engine(maker, displayable, SkType_String); engine.fParent = parent; SkScriptValue value; bool success = engine.evaluate(script, &value, SkType_String); if (success) result->set(*(value.fOperand.fString)); return success; } const SkDisplayEnumMap& SkAnimatorScript::GetEnumValues(SkDisplayTypes type) { int index = SkTSearch(&gEnumMaps[0].fType, gEnumMapCount, type, sizeof(SkDisplayEnumMap)); SkASSERT(index >= 0); return gEnumMaps[index]; } bool SkAnimatorScript::Infinity(const char* token, size_t len, void* user, SkScriptValue* value) { if (SK_LITERAL_STR_EQUAL("Infinity", token, len) == false) return false; value->fType = SkType_Float; value->fOperand.fScalar = SK_ScalarInfinity; return true; } bool SkAnimatorScript::IsFinite(const char* function, size_t len, SkTDArray& params, void* eng, SkScriptValue* value) { if (SK_LITERAL_STR_EQUAL(function, "isFinite", len) == false) return false; if (params.count() != 1) return false; SkScriptValue* scriptValue = params.begin(); SkDisplayTypes type = scriptValue->fType; SkScalar scalar = scriptValue->fOperand.fScalar; value->fType = SkType_Int; value->fOperand.fS32 = type == SkType_Float ? SkScalarIsNaN(scalar) == false && SkScalarAbs(scalar) != SK_ScalarInfinity : type == SkType_Int; return true; } bool SkAnimatorScript::IsNaN(const char* function, size_t len, SkTDArray& params, void* eng, SkScriptValue* value) { if (SK_LITERAL_STR_EQUAL("isNaN", function, len) == false) return false; if (params.count() != 1) return false; SkScriptValue* scriptValue = params.begin(); value->fType = SkType_Int; value->fOperand.fS32 = scriptValue->fType == SkType_Float ? SkScalarIsNaN(scriptValue->fOperand.fScalar) : 0; return true; } bool SkAnimatorScript::MapEnums(const char* ptr, const char* match, size_t len, int* value) { int index = 0; bool more = true; do { const char* last = strchr(ptr, '|'); if (last == nullptr) { last = &ptr[strlen(ptr)]; more = false; } size_t length = last - ptr; if (len == length && strncmp(ptr, match, length) == 0) { *value = index; return true; } index++; ptr = last + 1; } while (more); return false; } bool SkAnimatorScript::NaN(const char* token, size_t len, void* user, SkScriptValue* value) { if (SK_LITERAL_STR_EQUAL("NaN", token, len) == false) return false; value->fType = SkType_Float; value->fOperand.fScalar = SK_ScalarNaN; return true; } #if 0 bool SkAnimatorScript::ObjectToString(void* object, void* user, SkScriptValue* value) { SkTDict* ids = (SkTDict*) user; SkDisplayable* displayable = (SkDisplayable*) object; const char* key; bool success = ids->findKey(displayable, &key); if (success == false) return false; value->fOperand.fString = new SkString(key); value->fType = SkType_String; return true; } #endif bool SkAnimatorScript::Unbox(void* m, SkScriptValue* scriptValue) { SkAnimateMaker* maker = (SkAnimateMaker*) m; SkASSERT((unsigned) scriptValue->fType == (unsigned) SkType_Displayable); SkDisplayable* displayable = (SkDisplayable*) scriptValue->fOperand.fObject; SkDisplayTypes type = displayable->getType(); switch (displayable->getType()) { case SkType_Array: { SkDisplayArray* boxedValue = (SkDisplayArray*) displayable; scriptValue->fOperand.fArray = &boxedValue->values; } break; case SkType_Boolean: { SkDisplayBoolean* boxedValue = (SkDisplayBoolean*) displayable; scriptValue->fOperand.fS32 = boxedValue->value; } break; case SkType_Int: { SkDisplayInt* boxedValue = (SkDisplayInt*) displayable; scriptValue->fOperand.fS32 = boxedValue->value; } break; case SkType_Float: { SkDisplayFloat* boxedValue = (SkDisplayFloat*) displayable; scriptValue->fOperand.fScalar = boxedValue->value; } break; case SkType_String: { SkDisplayString* boxedValue = (SkDisplayString*) displayable; scriptValue->fOperand.fString = new SkString(boxedValue->value); } break; default: { const char* id = nullptr; SkDEBUGCODE(bool success = ) maker->findKey(displayable, &id); SkASSERT(success); scriptValue->fOperand.fString = new SkString(id); type = SkType_String; } } scriptValue->fType = type; return true; } #if defined SK_SUPPORT_UNITTEST #include "SkAnimator.h" static const char scriptTestSetup[] = "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" ""; #define DEFAULT_ANSWER , 0 static const SkScriptNAnswer scriptTests[] = { { "label.text.length == 4", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, // { "labelPaint.measureText(label.text) > 0 ? labelPaint.measureText(label.text)+10 : 40", SkType_Float, 0, SkIntToScalar(0x23) }, { "Number.POSITIVE_INFINITY >= Number.MAX_VALUE ? 1 : 0", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "Infinity >= Number.MAX_VALUE ? 1 : 0", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "Number.NEGATIVE_INFINITY <= -Number.MAX_VALUE ? 1 : 0", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "Number.MIN_VALUE > 0 ? 1 : 0", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "isNaN(Number.NaN)", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "isNaN(NaN)", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "Math.sin(0)", SkType_Float, 0, SkIntToScalar(0) DEFAULT_ANSWER }, { "alpha+alpha", SkType_String, 0, 0, "abcabc" }, { "intArray[4]", SkType_Unknown DEFAULT_ANSWER DEFAULT_ANSWER DEFAULT_ANSWER }, { "emptyArray[4]", SkType_Unknown DEFAULT_ANSWER DEFAULT_ANSWER DEFAULT_ANSWER }, { "idx", SkType_Int, 2 DEFAULT_ANSWER DEFAULT_ANSWER }, { "intArray.length", SkType_Int, 3 DEFAULT_ANSWER DEFAULT_ANSWER }, { "intArray.values[0]", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "intArray[0]", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "idx.value", SkType_Int, 2 DEFAULT_ANSWER DEFAULT_ANSWER }, { "alpha.value", SkType_String, 0, 0, "abc" }, { "alpha", SkType_String, 0, 0, "abc" }, { "alpha.value+alpha.value", SkType_String, 0, 0, "abcabc" }, { "alpha+idx", SkType_String, 0, 0, "abc2" }, { "idx+alpha", SkType_String, 0, 0, "2abc" }, { "intArray[idx]", SkType_Int, 6 DEFAULT_ANSWER DEFAULT_ANSWER }, { "alpha.slice(1,2)", SkType_String, 0, 0, "b" }, { "alpha.value.slice(1,2)", SkType_String, 0, 0, "b" }, { "testRect.left+2", SkType_Float, 0, SkIntToScalar(3) DEFAULT_ANSWER }, { "0 ? Math.sin(0) : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "0 ? intArray[0] : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "0 ? intArray.values[0] : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "0 ? idx : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "0 ? idx.value : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "0 ? alpha.slice(1,2) : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "0 ? alpha.value.slice(1,2) : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER }, { "idy", SkType_Int, 3 DEFAULT_ANSWER DEFAULT_ANSWER } }; #define SkScriptNAnswer_testCount SK_ARRAY_COUNT(scriptTests) void SkAnimatorScript::UnitTest() { #if defined(SK_SUPPORT_UNITTEST) SkAnimator animator; SkASSERT(animator.decodeMemory(scriptTestSetup, sizeof(scriptTestSetup)-1)); SkEvent evt; evt.setString("id", "evt"); evt.setS32("x", 3); animator.doUserEvent(evt); // set up animator with memory script above, then run value tests for (unsigned index = 0; index < SkScriptNAnswer_testCount; index++) { SkAnimatorScript engine(*animator.fMaker, nullptr, scriptTests[index].fType); SkScriptValue value; const char* script = scriptTests[index].fScript; bool success = engine.evaluateScript(&script, &value); if (success == false) { SkDebugf("script failed: %s\n", scriptTests[index].fScript); SkASSERT(scriptTests[index].fType == SkType_Unknown); continue; } SkASSERT(value.fType == scriptTests[index].fType); SkScalar error; switch (value.fType) { case SkType_Int: SkASSERT(value.fOperand.fS32 == scriptTests[index].fIntAnswer); break; case SkType_Float: error = SkScalarAbs(value.fOperand.fScalar - scriptTests[index].fScalarAnswer); SkASSERT(error < SK_Scalar1 / 10000); break; case SkType_String: SkASSERT(strcmp(value.fOperand.fString->c_str(), scriptTests[index].fStringAnswer) == 0); break; default: SkASSERT(0); } } #endif } #endif