Result of running tools/sanitize_source_files.py (which was added in https://codereview.appspot.com/6465078/)
This CL is part II of IV (I broke down the 1280 files into 4 CLs).
Review URL: https://codereview.appspot.com/6474054
git-svn-id: http://skia.googlecode.com/svn/trunk@5263 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/animator/SkAnimateActive.cpp b/src/animator/SkAnimateActive.cpp
index 4177aa0..00ee9df 100644
--- a/src/animator/SkAnimateActive.cpp
+++ b/src/animator/SkAnimateActive.cpp
@@ -22,7 +22,7 @@
fMaxTime(0), fMaker(maker), fDrawIndex(0), fDrawMax(0) {
}
-void SkActive::init()
+void SkActive::init()
{
fAnimators = fApply.fAnimators;
int animators = fAnimators.count();
@@ -98,7 +98,7 @@
saveIndex -= oldCount;
delete[] fSaveRestore[saveIndex];
fSaveRestore.remove(saveIndex);
- delete[] fSaveInterpolators[saveIndex];
+ delete[] fSaveInterpolators[saveIndex];
fSaveInterpolators.remove(saveIndex);
} while (saveIndex > 0);
}
@@ -127,17 +127,17 @@
SkASSERT(saveIndex >= 0);
SkASSERT(newTotal >= 0);
memmove(&fSaveRestore[newTotal], &fSaveRestore[saveIndex], oldCount);
- memset(&fSaveRestore[newTotal + oldCount], 0,
+ memset(&fSaveRestore[newTotal + oldCount], 0,
sizeof(fSaveRestore[0]) * (newCount - oldCount));
- memmove(&fSaveInterpolators[newTotal],
+ memmove(&fSaveInterpolators[newTotal],
&fSaveInterpolators[saveIndex], oldCount);
- memset(&fSaveInterpolators[newTotal + oldCount], 0,
+ memset(&fSaveInterpolators[newTotal + oldCount], 0,
sizeof(fSaveRestore[0]) * (newCount - oldCount));
} while (saveIndex > 0);
SkASSERT(newTotal == 0);
}
-void SkActive::calcDurations(int index)
+void SkActive::calcDurations(int index)
{
SkAnimateBase* animate = fAnimators[index];
SkMSec duration = animate->dur;
@@ -174,7 +174,7 @@
if (animate->formula.size() > 0) {
SkTDOperandArray values;
values.setCount(count);
- bool success = animate->fFieldInfo->setValue(fMaker, &values, 0, 0, NULL,
+ bool success = animate->fFieldInfo->setValue(fMaker, &values, 0, 0, NULL,
animate->getValuesType(), animate->formula);
SkASSERT(success);
fApply.applyValues(index, values.begin(), count, animate->getValuesType(), time);
@@ -212,7 +212,7 @@
if (animate->formula.size() > 0) {
SkTDOperandArray values;
values.setCount(count);
- bool success = animate->fFieldInfo->setValue(fMaker, &values, 0, 0, NULL,
+ bool success = animate->fFieldInfo->setValue(fMaker, &values, 0, 0, NULL,
animate->getValuesType(), animate->formula);
SkASSERT(success);
fApply.applyValues(index, values.begin(), count, animate->getValuesType(), time);
@@ -259,7 +259,7 @@
memset(&fSaveRestore[oldCount], 0, sizeof(fSaveRestore[0]) * (activeTotal - oldCount));
SkASSERT(fSaveInterpolators.count() == oldCount);
fSaveInterpolators.setCount(activeTotal);
- memset(&fSaveInterpolators[oldCount], 0,
+ memset(&fSaveInterpolators[oldCount], 0,
sizeof(fSaveInterpolators[0]) * (activeTotal - oldCount));
return true;
}
@@ -287,7 +287,7 @@
state.fStarted = false;
state.fSteps = apply->steps;
state.fTicks = 0;
- state.fUnpostedEndEvent = (SkBool8) animate->fHasEndEvent;
+ state.fUnpostedEndEvent = (SkBool8) animate->fHasEndEvent;
calcDurations(index);
setInterpolator(index, from);
}
@@ -317,7 +317,7 @@
if (workingSum < originalSum) {
SkScalar originalDistance = SkScalarSqrt(originalSum);
SkScalar workingDistance = SkScalarSqrt(workingSum);
- existing->fState[index].fDuration = (SkMSec) SkScalarMulDiv(fState[index].fDuration,
+ existing->fState[index].fDuration = (SkMSec) SkScalarMulDiv(fState[index].fDuration,
workingDistance, originalDistance);
}
fInterpolators[index]->reset(components, 2, SkType_Float);
@@ -376,7 +376,7 @@
SkMSec duration = fState[index].fDuration;
int components = animate->components();
SkOperandInterpolator& interpolator = *fInterpolators[index];
- interpolator.reset(components, entries == 1 ? 2 : entries, animate->getValuesType());
+ interpolator.reset(components, entries == 1 ? 2 : entries, animate->getValuesType());
interpolator.setMirror(SkToBool(animate->fMirror));
interpolator.setReset(SkToBool(animate->fReset));
interpolator.setRepeatCount(animate->repeat);
@@ -387,7 +387,7 @@
}
for (int entry = 0; entry < entries; entry++) {
int blendIndex = SkMin32(animate->blend.count() - 1, entry);
- interpolator.setKeyFrame(entry, entry * duration / (entries - 1), from,
+ interpolator.setKeyFrame(entry, entry * duration / (entries - 1), from,
animate->blend[blendIndex]);
from += components;
}
@@ -475,12 +475,12 @@
// the code below should only be bumping fSave, and there shouldn't be anything
// it needs to be synchronized with
-// however, if there are two animates both operating on the same field, then
-// when one replaces the other, it may make sense to pick up the old value as a starting
+// however, if there are two animates both operating on the same field, then
+// when one replaces the other, it may make sense to pick up the old value as a starting
// value for the new one somehow.
//void SkActive::SkState::bumpSave() {
-// if (fMode != SkApply::kMode_hold)
+// if (fMode != SkApply::kMode_hold)
// return;
// if (fTransition == SkApply::kTransition_reverse) {
// if (fSave > 0)
diff --git a/src/animator/SkAnimateBase.cpp b/src/animator/SkAnimateBase.cpp
index fe3815d..0e56faa 100644
--- a/src/animator/SkAnimateBase.cpp
+++ b/src/animator/SkAnimateBase.cpp
@@ -39,8 +39,8 @@
DEFINE_GET_MEMBER(SkAnimateBase);
SkAnimateBase::SkAnimateBase() : begin(0), dur(1), repeat(SK_Scalar1),
- fApply(NULL), fFieldInfo(NULL), fFieldOffset(0), fStart((SkMSec) -1), fTarget(NULL),
- fChanged(0), fDelayed(0), fDynamic(0), fHasEndEvent(0), fHasValues(0),
+ fApply(NULL), fFieldInfo(NULL), fFieldOffset(0), fStart((SkMSec) -1), fTarget(NULL),
+ fChanged(0), fDelayed(0), fDynamic(0), fHasEndEvent(0), fHasValues(0),
fMirror(0), fReset(0), fResetPending(0), fTargetIsScope(0) {
blend.setCount(1);
blend[0] = SK_Scalar1;
@@ -54,8 +54,8 @@
}
}
-int SkAnimateBase::components() {
- return 1;
+int SkAnimateBase::components() {
+ return 1;
}
SkDisplayable* SkAnimateBase::deepCopy(SkAnimateMaker* maker) {
@@ -131,9 +131,9 @@
return true;
}
-bool SkAnimateBase::hasExecute() const
+bool SkAnimateBase::hasExecute() const
{
- return false;
+ return false;
}
void SkAnimateBase::onEndElement(SkAnimateMaker& maker) {
@@ -159,11 +159,11 @@
}
}
-void SkAnimateBase::packARGB(SkScalar array[], int count, SkTDOperandArray* converted)
-{
+void SkAnimateBase::packARGB(SkScalar array[], int count, SkTDOperandArray* converted)
+{
SkASSERT(count == 4);
converted->setCount(1);
- SkColor color = SkColorSetARGB(SkScalarRound(array[0]), SkScalarRound(array[1]),
+ SkColor color = SkColorSetARGB(SkScalarRound(array[0]), SkScalarRound(array[1]),
SkScalarRound(array[2]), SkScalarRound(array[3]));
(*converted)[0].fS32 = color;
}
@@ -228,8 +228,8 @@
}
}
-bool SkAnimateBase::targetNeedsInitialization() const {
- return false;
+bool SkAnimateBase::targetNeedsInitialization() const {
+ return false;
}
diff --git a/src/animator/SkAnimateField.cpp b/src/animator/SkAnimateField.cpp
index 65e084a..43f510e 100644
--- a/src/animator/SkAnimateField.cpp
+++ b/src/animator/SkAnimateField.cpp
@@ -28,8 +28,8 @@
SkAnimate::~SkAnimate() {
}
-int SkAnimate::components() {
- return fComponents;
+int SkAnimate::components() {
+ return fComponents;
}
#ifdef SK_DUMP_ENABLED
@@ -50,7 +50,7 @@
SkDebugf("blend=\"[");
bool firstElem = true;
for (int i = 0; i < blend.count(); i++) {
- if (!firstElem)
+ if (!firstElem)
SkDebugf(",");
firstElem = false;
SkDebugf("%g", SkScalarToFloat(blend[i]));
@@ -82,7 +82,7 @@
SkASSERT(to.size() > 0);
fFieldInfo->setValue(maker, &fValues, 0, 0, NULL, outType, to);
SkASSERT(0);
- // !!! this needs to set fComponents
+ // !!! this needs to set fComponents
return;
}
fComponents = fFieldInfo->getCount();
diff --git a/src/animator/SkAnimateMaker.cpp b/src/animator/SkAnimateMaker.cpp
index 414e728..ddde2eb 100644
--- a/src/animator/SkAnimateMaker.cpp
+++ b/src/animator/SkAnimateMaker.cpp
@@ -28,7 +28,7 @@
} gDefaultTimeline;
SkAnimateMaker::SkAnimateMaker(SkAnimator* animator, SkCanvas* canvas, SkPaint* paint)
- : fActiveEvent(NULL), fAdjustedStart(0), fCanvas(canvas), fEnableTime(0),
+ : fActiveEvent(NULL), fAdjustedStart(0), fCanvas(canvas), fEnableTime(0),
fHostEventSinkID(0), fMinimumInterval((SkMSec) -1), fPaint(paint), fParentMaker(NULL),
fTimeline(&gDefaultTimeline), fInInclude(false), fInMovie(false),
fFirstScriptError(false), fLoaded(false), fIDs(256), fAnimator(animator)
@@ -82,7 +82,7 @@
SkDisplayable* SkAnimateMaker::createInstance(const char name[], size_t len) {
SkDisplayTypes type = SkDisplayType::GetType(this, name, len );
- if ((int)type >= 0)
+ if ((int)type >= 0)
return SkDisplayType::CreateInstance(this, type);
return NULL;
}
@@ -124,7 +124,7 @@
if (index < 0) {
*fDelayed.append() = apply;
}
-
+
(new SkEvent(SK_EventType_Delay, fAnimator->getSinkID()))->postTime(time);
}
@@ -302,7 +302,7 @@
#if defined SK_DEBUG
SkDebugf("%s\n", fErrorString.c_str());
#endif
- }
+ }
}
void SkAnimateMaker::setEnableTime(SkMSec appTime, SkMSec expectedTime) {
@@ -330,7 +330,7 @@
}
}
-void SkAnimateMaker::setExtraPropertyCallBack(SkDisplayTypes type,
+void SkAnimateMaker::setExtraPropertyCallBack(SkDisplayTypes type,
SkScriptEngine::_propertyCallBack callBack, void* userStorage) {
SkExtras** end = fExtras.end();
for (SkExtras** extraPtr = fExtras.begin(); extraPtr < end; extraPtr++) {
diff --git a/src/animator/SkAnimateMaker.h b/src/animator/SkAnimateMaker.h
index f20a7d4..53a5521 100644
--- a/src/animator/SkAnimateMaker.h
+++ b/src/animator/SkAnimateMaker.h
@@ -57,16 +57,16 @@
void dump(const char* match);
#endif
int dynamicProperty(SkString& nameStr, SkDisplayable** );
- bool find(const char* str, SkDisplayable** displayablePtr) const {
+ bool find(const char* str, SkDisplayable** displayablePtr) const {
return fIDs.find(str, displayablePtr);
}
- bool find(const char* str, size_t len, SkDisplayable** displayablePtr) const {
+ bool find(const char* str, size_t len, SkDisplayable** displayablePtr) const {
return fIDs.find(str, len, displayablePtr);
}
bool findKey(SkDisplayable* displayable, const char** string) const {
return fIDs.findKey(displayable, string);
}
-// bool find(SkString& string, SkDisplayable** displayablePtr) {
+// bool find(SkString& string, SkDisplayable** displayablePtr) {
// return fIDs.find(string.c_str(), displayablePtr);
// }
SkAnimator* getAnimator() { return fAnimator; }
@@ -80,7 +80,7 @@
bool hasError() { return fError.hasError(); }
void helperAdd(SkDisplayable* trackMe);
void helperRemove(SkDisplayable* alreadyTracked);
- void idsSet(const char* attrValue, size_t len, SkDisplayable* displayable) {
+ void idsSet(const char* attrValue, size_t len, SkDisplayable* displayable) {
fIDs.set(attrValue, len, displayable); }
// void loadMovies();
void notifyInval();
diff --git a/src/animator/SkAnimateSet.cpp b/src/animator/SkAnimateSet.cpp
index 3dd9648..f153b16 100644
--- a/src/animator/SkAnimateSet.cpp
+++ b/src/animator/SkAnimateSet.cpp
@@ -32,7 +32,7 @@
DEFINE_GET_MEMBER(SkSet);
SkSet::SkSet() {
- dur = 1;
+ dur = 1;
}
#ifdef SK_DUMP_ENABLED
@@ -48,7 +48,7 @@
#endif
void SkSet::refresh(SkAnimateMaker& maker) {
- fFieldInfo->setValue(maker, &fValues, 0, fFieldInfo->fCount, NULL,
+ fFieldInfo->setValue(maker, &fValues, 0, fFieldInfo->fCount, NULL,
fFieldInfo->getType(), to);
}
diff --git a/src/animator/SkAnimator.cpp b/src/animator/SkAnimator.cpp
index c1fba65..5d1f220 100644
--- a/src/animator/SkAnimator.cpp
+++ b/src/animator/SkAnimator.cpp
@@ -34,7 +34,7 @@
#define _static static
#endif
-_static const char gMathPrimerText[] =
+_static const char gMathPrimerText[] =
"<screenplay>"
"<Math id=\"Math\"/>"
"<Number id=\"Number\"/>"
@@ -108,9 +108,9 @@
state.fX = x;
state.fY = y;
fMaker->fEnableTime = fMaker->getAppTime();
- bool result = fMaker->fEvents.doEvent(*fMaker,
- clickState == 0 ? SkDisplayEvent::kMouseDown :
- clickState == 1 ? SkDisplayEvent::kMouseDrag :
+ bool result = fMaker->fEvents.doEvent(*fMaker,
+ clickState == 0 ? SkDisplayEvent::kMouseDown :
+ clickState == 1 ? SkDisplayEvent::kMouseDrag :
SkDisplayEvent::kMouseUp, &state);
fMaker->notifyInval();
return result;
@@ -160,7 +160,7 @@
SkPaint paint;
return draw(canvas, &paint, time);
}
-
+
#ifdef SK_DEBUG
void SkAnimator::eventDone(const SkEvent& ) {
}
@@ -231,7 +231,7 @@
return info->getArrayValue(element, index, operand);
}
-int32_t SkAnimator::getArrayInt(const SkDisplayable* ae,
+int32_t SkAnimator::getArrayInt(const SkDisplayable* ae,
const SkMemberInfo* ai, int index) {
SkOperand operand;
bool result = getArrayCommon(ae, ai, index, &operand, SkType_Int);
@@ -248,7 +248,7 @@
return getArrayInt(element, field, index);
}
-SkScalar SkAnimator::getArrayScalar(const SkDisplayable* ae,
+SkScalar SkAnimator::getArrayScalar(const SkDisplayable* ae,
const SkMemberInfo* ai, int index) {
SkOperand operand;
bool result = getArrayCommon(ae, ai, index, &operand, SkType_Float);
@@ -265,7 +265,7 @@
return getArrayScalar(element, field, index);
}
-const char* SkAnimator::getArrayString(const SkDisplayable* ae,
+const char* SkAnimator::getArrayString(const SkDisplayable* ae,
const SkMemberInfo* ai, int index) {
SkOperand operand;
bool result = getArrayCommon(ae, ai, index, &operand, SkType_String);
@@ -360,7 +360,7 @@
return getScalar(element, field);
}
-const char* SkAnimator::getString(const SkDisplayable* ae,
+const char* SkAnimator::getString(const SkDisplayable* ae,
const SkMemberInfo* ai) {
const SkDisplayable* element = (const SkDisplayable*) ae;
const SkMemberInfo* info = (const SkMemberInfo*) ai;
@@ -501,11 +501,11 @@
}
SkEventSinkID SkAnimator::getHostEventSinkID() const {
- return fMaker->fHostEventSinkID;
+ return fMaker->fHostEventSinkID;
}
void SkAnimator::setHostEventSinkID(SkEventSinkID target) {
- fMaker->fHostEventSinkID = target;
+ fMaker->fHostEventSinkID = target;
}
void SkAnimator::onSetHostHandler(Handler ) {
@@ -530,7 +530,7 @@
SkTypedArray tArray(SkType_Int);
tArray.setCount(num);
for (int i = 0; i < num; i++) {
- SkOperand op;
+ SkOperand op;
op.fS32 = array[i];
tArray[i] = op;
}
@@ -546,7 +546,7 @@
SkDisplayTypes type = element->getType();
if (type == SkType_Array) {
SkDisplayArray* dispArray = (SkDisplayArray*) element;
- dispArray->values = array;
+ dispArray->values = array;
return true;
}
else
@@ -614,9 +614,9 @@
return setScalar(element, field, scalar);
}
-bool SkAnimator::setString(SkDisplayable* element,
+bool SkAnimator::setString(SkDisplayable* element,
const SkMemberInfo* info, const char* str) {
- // !!! until this is fixed, can't call script with global references from here
+ // !!! until this is fixed, can't call script with global references from here
info->setValue(*fMaker, NULL, 0, info->fCount, element, info->getType(), str, strlen(str));
return true;
}
diff --git a/src/animator/SkAnimatorScript.cpp b/src/animator/SkAnimatorScript.cpp
index 6aae006..0e639f2 100644
--- a/src/animator/SkAnimatorScript.cpp
+++ b/src/animator/SkAnimatorScript.cpp
@@ -64,8 +64,8 @@
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);
- }
+ propertyCallBack(EvalEnum, (void*) map.fValues);
+ }
for (SkExtras** extraPtr = maker.fExtras.begin(); extraPtr < maker.fExtras.end(); extraPtr++) {
SkExtras* extra = *extraPtr;
if (extra->fExtraCallBack)
@@ -116,7 +116,7 @@
SkDisplayString* boxedValue = new SkDisplayString(*scriptValue->fOperand.fString);
displayable = boxedValue;
} break;
- case SkType_Displayable:
+ case SkType_Displayable:
scriptValue->fOperand.fObject = scriptValue->fOperand.fDisplayable;
scriptValue->fType = SkType_Displayable;
return true;
@@ -130,7 +130,7 @@
return true;
}
-bool SkAnimatorScript::Eval(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
+bool SkAnimatorScript::Eval(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
void* eng, SkScriptValue* value) {
if (SK_LITERAL_STR_EQUAL("eval", function, len) == false)
return false;
@@ -152,7 +152,7 @@
const char* tokens = (const char*) callBack;
value->fType = SkType_Int;
if (MapEnums(tokens, token, len, (int*)&value->fOperand.fS32))
- return true;
+ return true;
return false;
}
@@ -160,7 +160,7 @@
SkAnimatorScript* engine = (SkAnimatorScript*) user;
SkTDict<SkDisplayable*>* ids = &engine->fMaker.fIDs;
SkDisplayable* displayable;
- bool success = ids->find(token, len, &displayable);
+ bool success = ids->find(token, len, &displayable);
if (success == false) {
displayable = engine->fWorking;
if (SK_LITERAL_STR_EQUAL("parent", token, len)) {
@@ -176,7 +176,7 @@
if (displayable && EvalMember(token, len, displayable, engine, value))
return true;
value->fOperand.fString = NULL;
- value->fType = SkType_String;
+ value->fType = SkType_String;
} else {
SkDisplayable* working = engine->fWorking;
value->fOperand.fDisplayable = displayable;
@@ -199,7 +199,7 @@
return false;
}
-bool SkAnimatorScript::EvalRGB(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
+bool SkAnimatorScript::EvalRGB(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
void* eng, SkScriptValue* value) {
if (SK_LITERAL_STR_EQUAL("rgb", function, len) == false)
return false;
@@ -218,7 +218,7 @@
return true;
}
-bool SkAnimatorScript::EvalMemberCommon(SkScriptEngine* engine, const SkMemberInfo* info,
+bool SkAnimatorScript::EvalMemberCommon(SkScriptEngine* engine, const SkMemberInfo* info,
SkDisplayable* displayable, SkScriptValue* value) {
SkDisplayTypes original;
SkDisplayTypes type = original = (SkDisplayTypes) info->getType();
@@ -232,10 +232,10 @@
case SkType_MSec:
case SkType_Float:
SkASSERT(info->getCount() == 1);
- if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction)
+ 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 = SkScalarDiv((SkScalar) value->fOperand.fS32, 1000); // dividing two ints is the same as dividing two scalars
+ value->fOperand.fScalar = SkScalarDiv((SkScalar) value->fOperand.fS32, 1000); // dividing two ints is the same as dividing two scalars
type = SkType_Float;
}
break;
@@ -269,7 +269,7 @@
return true;
}
-bool SkAnimatorScript::EvalMember(const char* member, size_t len, void* object, void* eng,
+bool SkAnimatorScript::EvalMember(const char* member, size_t len, void* object, void* eng,
SkScriptValue* value) {
SkScriptEngine* engine = (SkScriptEngine*) eng;
SkDisplayable* displayable = (SkDisplayable*) object;
@@ -292,7 +292,7 @@
return EvalMemberCommon(engine, info, displayable, value);
}
-bool SkAnimatorScript::EvalMemberFunction(const char* member, size_t len, void* object,
+bool SkAnimatorScript::EvalMemberFunction(const char* member, size_t len, void* object,
SkTDArray<SkScriptValue>& params, void* eng, SkScriptValue* value) {
SkScriptEngine* engine = (SkScriptEngine*) eng;
SkDisplayable* displayable = (SkDisplayable*) object;
@@ -303,7 +303,7 @@
SkASSERT(0);
return false;
}
- displayable->executeFunction(displayable, info->functionIndex(), params, info->getType(),
+ displayable->executeFunction(displayable, info->functionIndex(), params, info->getType(),
value);
return EvalMemberCommon(engine, info, displayable, value);
}
@@ -355,7 +355,7 @@
}
const SkDisplayEnumMap& SkAnimatorScript::GetEnumValues(SkDisplayTypes type) {
- int index = SkTSearch<SkDisplayTypes>(&gEnumMaps[0].fType, gEnumMapCount, type,
+ int index = SkTSearch<SkDisplayTypes>(&gEnumMaps[0].fType, gEnumMapCount, type,
sizeof(SkDisplayEnumMap));
SkASSERT(index >= 0);
return gEnumMaps[index];
@@ -369,7 +369,7 @@
return true;
}
-bool SkAnimatorScript::IsFinite(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
+bool SkAnimatorScript::IsFinite(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
void* eng, SkScriptValue* value) {
if (SK_LITERAL_STR_EQUAL(function, "isFinite", len) == false)
return false;
@@ -379,12 +379,12 @@
SkDisplayTypes type = scriptValue->fType;
SkScalar scalar = scriptValue->fOperand.fScalar;
value->fType = SkType_Int;
- value->fOperand.fS32 = type == SkType_Float ? SkScalarIsNaN(scalar) == false &&
+ 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<SkScriptValue>& params,
+bool SkAnimatorScript::IsNaN(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
void* eng, SkScriptValue* value) {
if (SK_LITERAL_STR_EQUAL("isNaN", function, len) == false)
return false;
@@ -429,7 +429,7 @@
SkTDict<SkDisplayable*>* ids = (SkTDict<SkDisplayable*>*) user;
SkDisplayable* displayable = (SkDisplayable*) object;
const char* key;
- bool success = ids->findKey(displayable, &key);
+ bool success = ids->findKey(displayable, &key);
if (success == false)
return false;
value->fOperand.fString = new SkString(key);
@@ -480,7 +480,7 @@
#include "SkAnimator.h"
-static const char scriptTestSetup[] =
+static const char scriptTestSetup[] =
"<screenplay>\n"
"<text id='label' text='defg'/>\n"
"<add id='addLabel' use='label'/>\n"
diff --git a/src/animator/SkAnimatorScript.h b/src/animator/SkAnimatorScript.h
index a23f90d..c8802a3 100644
--- a/src/animator/SkAnimatorScript.h
+++ b/src/animator/SkAnimatorScript.h
@@ -27,8 +27,8 @@
SkAnimatorScript(SkAnimateMaker& , SkDisplayable* , SkDisplayTypes type);
~SkAnimatorScript();
bool evaluate(const char* script, SkScriptValue* , SkDisplayTypes type);
- void track(SkDisplayable* displayable) {
- SkASSERT(fTrackDisplayable.find(displayable) < 0);
+ void track(SkDisplayable* displayable) {
+ SkASSERT(fTrackDisplayable.find(displayable) < 0);
*fTrackDisplayable.append() = displayable; }
static bool EvaluateDisplayable(SkAnimateMaker& , SkDisplayable* , const char* script, SkDisplayable** );
static bool EvaluateFloat(SkAnimateMaker& , SkDisplayable* , const char* script, SkScalar* );
@@ -38,24 +38,24 @@
static bool MapEnums(const char* ptr, const char* match, size_t len, int* value);
protected:
static bool Box(void* user, SkScriptValue* );
- static bool Eval(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
+ static bool Eval(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
void* callBack, SkScriptValue* );
static bool EvalEnum(const char* token, size_t len, void* callBack, SkScriptValue* );
static bool EvalID(const char* token, size_t len, void* callBack, SkScriptValue* );
- static bool EvalMember(const char* member, size_t len, void* object, void* eng,
+ static bool EvalMember(const char* member, size_t len, void* object, void* eng,
SkScriptValue* value);
- static bool EvalMemberCommon(SkScriptEngine* , const SkMemberInfo* info,
+ static bool EvalMemberCommon(SkScriptEngine* , const SkMemberInfo* info,
SkDisplayable* displayable, SkScriptValue* value);
- static bool EvalMemberFunction(const char* member, size_t len, void* object,
+ static bool EvalMemberFunction(const char* member, size_t len, void* object,
SkTDArray<SkScriptValue>& params, void* user, SkScriptValue* value);
static bool EvalNamedColor(const char* token, size_t len, void* callBack, SkScriptValue* );
- static bool EvalRGB(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
+ static bool EvalRGB(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
void* callBack, SkScriptValue* );
- static const SkDisplayEnumMap& GetEnumValues(SkDisplayTypes type);
+ static const SkDisplayEnumMap& GetEnumValues(SkDisplayTypes type);
static bool Infinity(const char* token, size_t len, void* callBack, SkScriptValue* );
- static bool IsFinite(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
+ static bool IsFinite(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
void* callBack, SkScriptValue* );
- static bool IsNaN(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
+ static bool IsNaN(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
void* callBack, SkScriptValue* );
static bool NaN(const char* token, size_t len, void* callBack, SkScriptValue* );
static bool Unbox(void* , SkScriptValue* scriptValue);
diff --git a/src/animator/SkAnimatorScript2.cpp b/src/animator/SkAnimatorScript2.cpp
index ae51fdc..45ce3ce 100644
--- a/src/animator/SkAnimatorScript2.cpp
+++ b/src/animator/SkAnimatorScript2.cpp
@@ -17,29 +17,29 @@
#include "SkScriptCallBack.h"
static const SkDisplayEnumMap gEnumMaps[] = {
- { SkType_AddMode, "indirect|immediate" },
- { SkType_Align, "left|center|right" },
- { SkType_ApplyMode, "immediate|once" },
- { SkType_ApplyTransition, "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|up|down|left|right|back|end|OK|send|leftSoftKey|rightSoftKey|key0|key1|key2|key3|key4|key5|key6|key7|key8|key9|star|hash" },
- { SkType_EventKind, "none|keyChar|keyPress|mouseDown|mouseDrag|mouseMove|mouseUp|onEnd|onLoad|user" },
- { SkType_EventMode, "deferred|immediate" },
- { SkType_FillType, "winding|evenOdd" },
- { SkType_FilterType, "none|bilinear" },
- { 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" },
+ { SkType_AddMode, "indirect|immediate" },
+ { SkType_Align, "left|center|right" },
+ { SkType_ApplyMode, "immediate|once" },
+ { SkType_ApplyTransition, "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|up|down|left|right|back|end|OK|send|leftSoftKey|rightSoftKey|key0|key1|key2|key3|key4|key5|key6|key7|key8|key9|star|hash" },
+ { SkType_EventKind, "none|keyChar|keyPress|mouseDown|mouseDrag|mouseMove|mouseUp|onEnd|onLoad|user" },
+ { SkType_EventMode, "deferred|immediate" },
+ { SkType_FillType, "winding|evenOdd" },
+ { SkType_FilterType, "none|bilinear" },
+ { 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);
@@ -47,575 +47,575 @@
class SkAnimatorScript_Box : public SkScriptCallBackConvert {
public:
- SkAnimatorScript_Box() {}
+ SkAnimatorScript_Box() {}
- ~SkAnimatorScript_Box() {
- for (SkDisplayable** dispPtr = fTrackDisplayable.begin(); dispPtr < fTrackDisplayable.end(); dispPtr++)
- delete *dispPtr;
- }
+ ~SkAnimatorScript_Box() {
+ for (SkDisplayable** dispPtr = fTrackDisplayable.begin(); dispPtr < fTrackDisplayable.end(); dispPtr++)
+ delete *dispPtr;
+ }
- virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) {
- SkDisplayable* displayable;
- switch (type) {
- case SkOperand2::kArray: {
- SkDisplayArray* boxedValue = new SkDisplayArray(*operand->fArray);
- displayable = boxedValue;
- } break;
- case SkOperand2::kS32: {
- SkDisplayInt* boxedValue = new SkDisplayInt;
- displayable = boxedValue;
- boxedValue->value = operand->fS32;
- } break;
- case SkOperand2::kScalar: {
- SkDisplayFloat* boxedValue = new SkDisplayFloat;
- displayable = boxedValue;
- boxedValue->value = operand->fScalar;
- } break;
- case SkOperand2::kString: {
- SkDisplayString* boxedValue = new SkDisplayString(*operand->fString);
- displayable = boxedValue;
- } break;
- case SkOperand2::kObject:
- return true;
- default:
- SkASSERT(0);
- return false;
- }
- track(displayable);
- operand->fObject = (void*) displayable;
- return true;
- }
+ virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) {
+ SkDisplayable* displayable;
+ switch (type) {
+ case SkOperand2::kArray: {
+ SkDisplayArray* boxedValue = new SkDisplayArray(*operand->fArray);
+ displayable = boxedValue;
+ } break;
+ case SkOperand2::kS32: {
+ SkDisplayInt* boxedValue = new SkDisplayInt;
+ displayable = boxedValue;
+ boxedValue->value = operand->fS32;
+ } break;
+ case SkOperand2::kScalar: {
+ SkDisplayFloat* boxedValue = new SkDisplayFloat;
+ displayable = boxedValue;
+ boxedValue->value = operand->fScalar;
+ } break;
+ case SkOperand2::kString: {
+ SkDisplayString* boxedValue = new SkDisplayString(*operand->fString);
+ displayable = boxedValue;
+ } break;
+ case SkOperand2::kObject:
+ return true;
+ default:
+ SkASSERT(0);
+ return false;
+ }
+ track(displayable);
+ operand->fObject = (void*) displayable;
+ return true;
+ }
- virtual SkOperand2::OpType getReturnType(int index) {
- return SkOperand2::kObject;
- }
+ virtual SkOperand2::OpType getReturnType(int index) {
+ return SkOperand2::kObject;
+ }
- virtual Type getType() const {
- return kBox;
- }
+ virtual Type getType() const {
+ return kBox;
+ }
- void track(SkDisplayable* displayable) {
- SkASSERT(fTrackDisplayable.find(displayable) < 0);
- *fTrackDisplayable.append() = displayable;
- }
+ void track(SkDisplayable* displayable) {
+ SkASSERT(fTrackDisplayable.find(displayable) < 0);
+ *fTrackDisplayable.append() = displayable;
+ }
- SkTDDisplayableArray fTrackDisplayable;
+ SkTDDisplayableArray fTrackDisplayable;
};
class SkAnimatorScript_Enum : public SkScriptCallBackProperty {
public:
- SkAnimatorScript_Enum(const char* tokens) : fTokens(tokens) {}
+ SkAnimatorScript_Enum(const char* tokens) : fTokens(tokens) {}
- virtual bool getConstValue(const char* name, int len, SkOperand2* value) {
- return SkAnimatorScript2::MapEnums(fTokens, name, len, &value->fS32);
- }
+ virtual bool getConstValue(const char* name, int len, SkOperand2* value) {
+ return SkAnimatorScript2::MapEnums(fTokens, name, len, &value->fS32);
+ }
private:
- const char* fTokens;
+ const char* fTokens;
};
- // !!! if type is string, call invoke
- // if any other type, return original value
- // distinction is undone: could do this by returning index == 0 only if param is string
- // still, caller of getParamTypes will attempt to convert param to string (I guess)
+ // !!! if type is string, call invoke
+ // if any other type, return original value
+ // distinction is undone: could do this by returning index == 0 only if param is string
+ // still, caller of getParamTypes will attempt to convert param to string (I guess)
class SkAnimatorScript_Eval : public SkScriptCallBackFunction {
public:
- SkAnimatorScript_Eval(SkAnimatorScript2* engine) : fEngine(engine) {}
+ SkAnimatorScript_Eval(SkAnimatorScript2* engine) : fEngine(engine) {}
- virtual bool getIndex(const char* name, int len, size_t* result) {
- if (SK_LITERAL_STR_EQUAL("eval", name, len) != 0)
- return false;
- *result = 0;
- return true;
- }
-
- virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
- types->setCount(1);
- SkOperand2::OpType* type = types->begin();
- type[0] = SkOperand2::kString;
- }
+ virtual bool getIndex(const char* name, int len, size_t* result) {
+ if (SK_LITERAL_STR_EQUAL("eval", name, len) != 0)
+ return false;
+ *result = 0;
+ return true;
+ }
- virtual bool invoke(size_t index, SkOpArray* params, SkOperand2* answer) {
- SkAnimatorScript2 engine(fEngine->getMaker(), fEngine->getWorking(),
- SkAnimatorScript2::ToDisplayType(fEngine->getReturnType()));
- SkOperand2* op = params->begin();
- const char* script = op->fString->c_str();
- SkScriptValue2 value;
- return engine.evaluateScript(&script, &value);
- SkASSERT(value.fType == fEngine->getReturnType());
- *answer = value.fOperand;
- // !!! incomplete ?
- return true;
- }
+ virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
+ types->setCount(1);
+ SkOperand2::OpType* type = types->begin();
+ type[0] = SkOperand2::kString;
+ }
+
+ virtual bool invoke(size_t index, SkOpArray* params, SkOperand2* answer) {
+ SkAnimatorScript2 engine(fEngine->getMaker(), fEngine->getWorking(),
+ SkAnimatorScript2::ToDisplayType(fEngine->getReturnType()));
+ SkOperand2* op = params->begin();
+ const char* script = op->fString->c_str();
+ SkScriptValue2 value;
+ return engine.evaluateScript(&script, &value);
+ SkASSERT(value.fType == fEngine->getReturnType());
+ *answer = value.fOperand;
+ // !!! incomplete ?
+ return true;
+ }
private:
- SkAnimatorScript2* fEngine;
+ SkAnimatorScript2* fEngine;
};
class SkAnimatorScript_ID : public SkScriptCallBackProperty {
public:
- SkAnimatorScript_ID(SkAnimatorScript2* engine) : fEngine(engine) {}
+ SkAnimatorScript_ID(SkAnimatorScript2* engine) : fEngine(engine) {}
- virtual bool getIndex(const char* token, int len, size_t* result) {
- SkDisplayable* displayable;
- bool success = fEngine->getMaker().find(token, len, &displayable);
- if (success == false) {
- *result = 0;
- } else {
- *result = (size_t) displayable;
- SkDisplayable* working = fEngine->getWorking();
- if (displayable->canContainDependents() && working && working->isAnimate()) {
- SkAnimateBase* animator = (SkAnimateBase*) working;
- if (animator->isDynamic()) {
- SkDisplayDepend* depend = (SkDisplayDepend* ) displayable;
- depend->addDependent(working);
- }
- }
- }
- return true;
- }
+ virtual bool getIndex(const char* token, int len, size_t* result) {
+ SkDisplayable* displayable;
+ bool success = fEngine->getMaker().find(token, len, &displayable);
+ if (success == false) {
+ *result = 0;
+ } else {
+ *result = (size_t) displayable;
+ SkDisplayable* working = fEngine->getWorking();
+ if (displayable->canContainDependents() && working && working->isAnimate()) {
+ SkAnimateBase* animator = (SkAnimateBase*) working;
+ if (animator->isDynamic()) {
+ SkDisplayDepend* depend = (SkDisplayDepend* ) displayable;
+ depend->addDependent(working);
+ }
+ }
+ }
+ return true;
+ }
- virtual bool getResult(size_t ref, SkOperand2* answer) {
- answer->fObject = (void*) ref;
- return true;
- }
+ virtual bool getResult(size_t ref, SkOperand2* answer) {
+ answer->fObject = (void*) ref;
+ return true;
+ }
- virtual SkOperand2::OpType getReturnType(size_t index) {
- return index == 0 ? SkOperand2::kString : SkOperand2::kObject;
- }
+ virtual SkOperand2::OpType getReturnType(size_t index) {
+ return index == 0 ? SkOperand2::kString : SkOperand2::kObject;
+ }
private:
- SkAnimatorScript2* fEngine;
+ SkAnimatorScript2* fEngine;
};
class SkAnimatorScript_Member : public SkScriptCallBackMember {
public:
- SkAnimatorScript_Member(SkAnimatorScript2* engine) : fEngine(engine) {}
+ SkAnimatorScript_Member(SkAnimatorScript2* engine) : fEngine(engine) {}
- bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) {
- SkDisplayable* displayable = (SkDisplayable*) object;
- SkString name(member, len);
- SkDisplayable* named = displayable->contains(name);
- if (named) {
- ref->fType = SkOperand2::kObject;
- ref->fOperand.fObject = named;
- return true;
- }
- const SkMemberInfo* info = displayable->getMember(name.c_str());
- if (info == NULL)
- return false; // !!! add additional error info?
- ref->fType = SkAnimatorScript2::ToOpType(info->getType());
- ref->fOperand.fObject = (void*) info;
- return true;
- }
+ bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) {
+ SkDisplayable* displayable = (SkDisplayable*) object;
+ SkString name(member, len);
+ SkDisplayable* named = displayable->contains(name);
+ if (named) {
+ ref->fType = SkOperand2::kObject;
+ ref->fOperand.fObject = named;
+ return true;
+ }
+ const SkMemberInfo* info = displayable->getMember(name.c_str());
+ if (info == NULL)
+ return false; // !!! add additional error info?
+ ref->fType = SkAnimatorScript2::ToOpType(info->getType());
+ ref->fOperand.fObject = (void*) info;
+ return true;
+ }
- bool invoke(size_t ref, void* object, SkOperand2* value) {
- const SkMemberInfo* info = (const SkMemberInfo* ) ref;
- SkDisplayable* displayable = (SkDisplayable*) object;
- if (info->fType == SkType_MemberProperty) {
- if (displayable->getProperty2(info->propertyIndex(), value) == false) {
- return false;
- }
- }
- return fEngine->evalMemberCommon(info, displayable, value);
- }
+ bool invoke(size_t ref, void* object, SkOperand2* value) {
+ const SkMemberInfo* info = (const SkMemberInfo* ) ref;
+ SkDisplayable* displayable = (SkDisplayable*) object;
+ if (info->fType == SkType_MemberProperty) {
+ if (displayable->getProperty2(info->propertyIndex(), value) == false) {
+ return false;
+ }
+ }
+ return fEngine->evalMemberCommon(info, displayable, value);
+ }
- SkAnimatorScript2* fEngine;
+ SkAnimatorScript2* fEngine;
};
class SkAnimatorScript_MemberFunction : public SkScriptCallBackMemberFunction {
public:
- SkAnimatorScript_MemberFunction(SkAnimatorScript2* engine) : fEngine(engine) {}
+ SkAnimatorScript_MemberFunction(SkAnimatorScript2* engine) : fEngine(engine) {}
- bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) {
- SkDisplayable* displayable = (SkDisplayable*) object;
- SkString name(member, len);
- const SkMemberInfo* info = displayable->getMember(name.c_str());
- if (info == NULL || info->fType != SkType_MemberFunction)
- return false; // !!! add additional error info?
- ref->fType = SkAnimatorScript2::ToOpType(info->getType());
- ref->fOperand.fObject = (void*) info;
- return true;
- }
+ bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) {
+ SkDisplayable* displayable = (SkDisplayable*) object;
+ SkString name(member, len);
+ const SkMemberInfo* info = displayable->getMember(name.c_str());
+ if (info == NULL || info->fType != SkType_MemberFunction)
+ return false; // !!! add additional error info?
+ ref->fType = SkAnimatorScript2::ToOpType(info->getType());
+ ref->fOperand.fObject = (void*) info;
+ return true;
+ }
- virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
- types->setCount(3);
- SkOperand2::OpType* type = types->begin();
- type[0] = type[1] = type[2] = SkOperand2::kS32;
- }
+ virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
+ types->setCount(3);
+ SkOperand2::OpType* type = types->begin();
+ type[0] = type[1] = type[2] = SkOperand2::kS32;
+ }
- bool invoke(size_t ref, void* object, SkOpArray* params, SkOperand2* value)
- {
- const SkMemberInfo* info = (const SkMemberInfo* ) ref;
- SkDisplayable* displayable = (SkDisplayable*) object;
- displayable->executeFunction2(displayable, info->functionIndex(), params, info->getType(),
- value);
- return fEngine->evalMemberCommon(info, displayable, value);
- }
+ bool invoke(size_t ref, void* object, SkOpArray* params, SkOperand2* value)
+ {
+ const SkMemberInfo* info = (const SkMemberInfo* ) ref;
+ SkDisplayable* displayable = (SkDisplayable*) object;
+ displayable->executeFunction2(displayable, info->functionIndex(), params, info->getType(),
+ value);
+ return fEngine->evalMemberCommon(info, displayable, value);
+ }
- SkAnimatorScript2* fEngine;
+ SkAnimatorScript2* fEngine;
};
class SkAnimatorScript_NamedColor : public SkScriptCallBackProperty {
public:
- virtual bool getConstValue(const char* name, int len, SkOperand2* value) {
- return SkParse::FindNamedColor(name, len, (SkColor*) &value->fS32) != NULL;
- }
+ virtual bool getConstValue(const char* name, int len, SkOperand2* value) {
+ return SkParse::FindNamedColor(name, len, (SkColor*) &value->fS32) != NULL;
+ }
};
class SkAnimatorScript_RGB : public SkScriptCallBackFunction {
public:
- virtual bool getIndex(const char* name, int len, size_t* result) {
- if (SK_LITERAL_STR_EQUAL("rgb", name, len) != 0)
- return false;
- *result = 0;
- return true;
- }
+ virtual bool getIndex(const char* name, int len, size_t* result) {
+ if (SK_LITERAL_STR_EQUAL("rgb", name, len) != 0)
+ return false;
+ *result = 0;
+ return true;
+ }
- virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
- types->setCount(3);
- SkOperand2::OpType* type = types->begin();
- type[0] = type[1] = type[2] = SkOperand2::kS32;
- }
+ virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
+ types->setCount(3);
+ SkOperand2::OpType* type = types->begin();
+ type[0] = type[1] = type[2] = SkOperand2::kS32;
+ }
- virtual bool invoke(size_t index, SkOpArray* params, SkOperand2* answer) {
- SkASSERT(index == 0);
- unsigned result = 0xFF000000;
- int shift = 16;
- for (int index = 0; index < 3; index++) {
- result |= SkClampMax(params->begin()[index].fS32, 255) << shift;
- shift -= 8;
- }
- answer->fS32 = result;
- return true;
- }
+ virtual bool invoke(size_t index, SkOpArray* params, SkOperand2* answer) {
+ SkASSERT(index == 0);
+ unsigned result = 0xFF000000;
+ int shift = 16;
+ for (int index = 0; index < 3; index++) {
+ result |= SkClampMax(params->begin()[index].fS32, 255) << shift;
+ shift -= 8;
+ }
+ answer->fS32 = result;
+ return true;
+ }
};
class SkAnimatorScript_Unbox : public SkScriptCallBackConvert {
public:
- SkAnimatorScript_Unbox(SkAnimatorScript2* engine) : fEngine(engine) {}
+ SkAnimatorScript_Unbox(SkAnimatorScript2* engine) : fEngine(engine) {}
- virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) {
- SkASSERT(type == SkOperand2::kObject);
- SkDisplayable* displayable = (SkDisplayable*) operand->fObject;
- switch (displayable->getType()) {
- case SkType_Array: {
- SkDisplayArray* boxedValue = (SkDisplayArray*) displayable;
- operand->fArray = new SkOpArray(SkAnimatorScript2::ToOpType(boxedValue->values.getType()));
- int count = boxedValue->values.count();
- operand->fArray->setCount(count);
- memcpy(operand->fArray->begin(), boxedValue->values.begin(), count * sizeof(SkOperand2));
- fEngine->track(operand->fArray);
- } break;
- case SkType_Boolean: {
- SkDisplayBoolean* boxedValue = (SkDisplayBoolean*) displayable;
- operand->fS32 = boxedValue->value;
- } break;
- case SkType_Int: {
- SkDisplayInt* boxedValue = (SkDisplayInt*) displayable;
- operand->fS32 = boxedValue->value;
- } break;
- case SkType_Float: {
- SkDisplayFloat* boxedValue = (SkDisplayFloat*) displayable;
- operand->fScalar = boxedValue->value;
- } break;
- case SkType_String: {
- SkDisplayString* boxedValue = (SkDisplayString*) displayable;
- operand->fString = SkNEW_ARGS(SkString, (boxedValue->value));
- } break;
- default: {
- const char* id;
- bool success = fEngine->getMaker().findKey(displayable, &id);
- SkASSERT(success);
- operand->fString = SkNEW_ARGS(SkString, (id));
- }
- }
- return true;
- }
+ virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) {
+ SkASSERT(type == SkOperand2::kObject);
+ SkDisplayable* displayable = (SkDisplayable*) operand->fObject;
+ switch (displayable->getType()) {
+ case SkType_Array: {
+ SkDisplayArray* boxedValue = (SkDisplayArray*) displayable;
+ operand->fArray = new SkOpArray(SkAnimatorScript2::ToOpType(boxedValue->values.getType()));
+ int count = boxedValue->values.count();
+ operand->fArray->setCount(count);
+ memcpy(operand->fArray->begin(), boxedValue->values.begin(), count * sizeof(SkOperand2));
+ fEngine->track(operand->fArray);
+ } break;
+ case SkType_Boolean: {
+ SkDisplayBoolean* boxedValue = (SkDisplayBoolean*) displayable;
+ operand->fS32 = boxedValue->value;
+ } break;
+ case SkType_Int: {
+ SkDisplayInt* boxedValue = (SkDisplayInt*) displayable;
+ operand->fS32 = boxedValue->value;
+ } break;
+ case SkType_Float: {
+ SkDisplayFloat* boxedValue = (SkDisplayFloat*) displayable;
+ operand->fScalar = boxedValue->value;
+ } break;
+ case SkType_String: {
+ SkDisplayString* boxedValue = (SkDisplayString*) displayable;
+ operand->fString = SkNEW_ARGS(SkString, (boxedValue->value));
+ } break;
+ default: {
+ const char* id;
+ bool success = fEngine->getMaker().findKey(displayable, &id);
+ SkASSERT(success);
+ operand->fString = SkNEW_ARGS(SkString, (id));
+ }
+ }
+ return true;
+ }
- virtual SkOperand2::OpType getReturnType(int /*index*/, SkOperand2* operand) {
- SkDisplayable* displayable = (SkDisplayable*) operand->fObject;
- switch (displayable->getType()) {
- case SkType_Array:
- return SkOperand2::kArray;
- case SkType_Int:
- return SkOperand2::kS32;
- case SkType_Float:
- return SkOperand2::kScalar;
- case SkType_String:
- default:
- return SkOperand2::kString;
- }
- }
+ virtual SkOperand2::OpType getReturnType(int /*index*/, SkOperand2* operand) {
+ SkDisplayable* displayable = (SkDisplayable*) operand->fObject;
+ switch (displayable->getType()) {
+ case SkType_Array:
+ return SkOperand2::kArray;
+ case SkType_Int:
+ return SkOperand2::kS32;
+ case SkType_Float:
+ return SkOperand2::kScalar;
+ case SkType_String:
+ default:
+ return SkOperand2::kString;
+ }
+ }
- virtual Type getType() const {
- return kUnbox;
- }
+ virtual Type getType() const {
+ return kUnbox;
+ }
- SkAnimatorScript2* fEngine;
+ SkAnimatorScript2* fEngine;
};
-SkAnimatorScript2::SkAnimatorScript2(SkAnimateMaker& maker, SkDisplayable* working, SkDisplayTypes type) :
- SkScriptEngine2(ToOpType(type)), fMaker(maker), fWorking(working) {
- *fCallBackArray.append() = new SkAnimatorScript_Member(this);
- *fCallBackArray.append() = new SkAnimatorScript_MemberFunction(this);
- *fCallBackArray.append() = new SkAnimatorScript_Box();
- *fCallBackArray.append() = new SkAnimatorScript_Unbox(this);
- *fCallBackArray.append() = new SkAnimatorScript_ID(this);
- if (type == SkType_ARGB) {
- *fCallBackArray.append() = new SkAnimatorScript_RGB();
- *fCallBackArray.append() = new SkAnimatorScript_NamedColor();
- }
- if (SkDisplayType::IsEnum(&maker, type)) {
- // !!! for SpiderMonkey, iterate through the enum values, and map them to globals
- const SkDisplayEnumMap& map = GetEnumValues(type);
- *fCallBackArray.append() = new SkAnimatorScript_Enum(map.fValues);
- }
- *fCallBackArray.append() = new SkAnimatorScript_Eval(this);
-#if 0 // !!! no extra support for now
- for (SkExtras** extraPtr = maker.fExtras.begin(); extraPtr < maker.fExtras.end(); extraPtr++) {
- SkExtras* extra = *extraPtr;
- if (extra->fExtraCallBack)
- *fCallBackArray.append() = new propertyCallBack(extra->fExtraCallBack, extra->fExtraStorage);
- }
+SkAnimatorScript2::SkAnimatorScript2(SkAnimateMaker& maker, SkDisplayable* working, SkDisplayTypes type) :
+ SkScriptEngine2(ToOpType(type)), fMaker(maker), fWorking(working) {
+ *fCallBackArray.append() = new SkAnimatorScript_Member(this);
+ *fCallBackArray.append() = new SkAnimatorScript_MemberFunction(this);
+ *fCallBackArray.append() = new SkAnimatorScript_Box();
+ *fCallBackArray.append() = new SkAnimatorScript_Unbox(this);
+ *fCallBackArray.append() = new SkAnimatorScript_ID(this);
+ if (type == SkType_ARGB) {
+ *fCallBackArray.append() = new SkAnimatorScript_RGB();
+ *fCallBackArray.append() = new SkAnimatorScript_NamedColor();
+ }
+ if (SkDisplayType::IsEnum(&maker, type)) {
+ // !!! for SpiderMonkey, iterate through the enum values, and map them to globals
+ const SkDisplayEnumMap& map = GetEnumValues(type);
+ *fCallBackArray.append() = new SkAnimatorScript_Enum(map.fValues);
+ }
+ *fCallBackArray.append() = new SkAnimatorScript_Eval(this);
+#if 0 // !!! no extra support for now
+ for (SkExtras** extraPtr = maker.fExtras.begin(); extraPtr < maker.fExtras.end(); extraPtr++) {
+ SkExtras* extra = *extraPtr;
+ if (extra->fExtraCallBack)
+ *fCallBackArray.append() = new propertyCallBack(extra->fExtraCallBack, extra->fExtraStorage);
+ }
#endif
}
SkAnimatorScript2::~SkAnimatorScript2() {
- SkScriptCallBack** end = fCallBackArray.end();
- for (SkScriptCallBack** ptr = fCallBackArray.begin(); ptr < end; ptr++)
- delete *ptr;
+ SkScriptCallBack** end = fCallBackArray.end();
+ for (SkScriptCallBack** ptr = fCallBackArray.begin(); ptr < end; ptr++)
+ delete *ptr;
}
-bool SkAnimatorScript2::evalMemberCommon(const SkMemberInfo* info,
- SkDisplayable* displayable, SkOperand2* 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->fS32 = *(int32_t*) info->memberData(displayable); // OK for SkScalar too
- if (type == SkType_MSec) {
- value->fScalar = SkScalarDiv((SkScalar) value->fS32, 1000); // dividing two ints is the same as dividing two scalars
- type = SkType_Float;
- }
- break;
- case SkType_String: {
- SkString* displayableString;
- if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction) {
- info->getString(displayable, &displayableString);
- value->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);
- SkOpArray* array = value->fArray = new SkOpArray(ToOpType(original));
- track(array);
- int count = displayableArray->count();
- if (count > 0) {
- array->setCount(count);
- memcpy(array->begin(), displayableArray->begin(), count * sizeof(SkOperand2));
- }
- } break;
- default:
- SkASSERT(0); // unimplemented
- }
- return true;
+bool SkAnimatorScript2::evalMemberCommon(const SkMemberInfo* info,
+ SkDisplayable* displayable, SkOperand2* 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->fS32 = *(int32_t*) info->memberData(displayable); // OK for SkScalar too
+ if (type == SkType_MSec) {
+ value->fScalar = SkScalarDiv((SkScalar) value->fS32, 1000); // dividing two ints is the same as dividing two scalars
+ type = SkType_Float;
+ }
+ break;
+ case SkType_String: {
+ SkString* displayableString;
+ if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction) {
+ info->getString(displayable, &displayableString);
+ value->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);
+ SkOpArray* array = value->fArray = new SkOpArray(ToOpType(original));
+ track(array);
+ int count = displayableArray->count();
+ if (count > 0) {
+ array->setCount(count);
+ memcpy(array->begin(), displayableArray->begin(), count * sizeof(SkOperand2));
+ }
+ } break;
+ default:
+ SkASSERT(0); // unimplemented
+ }
+ return true;
}
const SkDisplayEnumMap& SkAnimatorScript2::GetEnumValues(SkDisplayTypes type) {
- int index = SkTSearch<SkDisplayTypes>(&gEnumMaps[0].fType, gEnumMapCount, type,
- sizeof(SkDisplayEnumMap));
- SkASSERT(index >= 0);
- return gEnumMaps[index];
+ int index = SkTSearch<SkDisplayTypes>(&gEnumMaps[0].fType, gEnumMapCount, type,
+ sizeof(SkDisplayEnumMap));
+ SkASSERT(index >= 0);
+ return gEnumMaps[index];
}
SkDisplayTypes SkAnimatorScript2::ToDisplayType(SkOperand2::OpType type) {
- int val = type;
- switch (val) {
- case SkOperand2::kNoType:
- return SkType_Unknown;
- case SkOperand2::kS32:
- return SkType_Int;
- case SkOperand2::kScalar:
- return SkType_Float;
- case SkOperand2::kString:
- return SkType_String;
- case SkOperand2::kArray:
- return SkType_Array;
- case SkOperand2::kObject:
- return SkType_Displayable;
- default:
- SkASSERT(0);
- return SkType_Unknown;
- }
+ int val = type;
+ switch (val) {
+ case SkOperand2::kNoType:
+ return SkType_Unknown;
+ case SkOperand2::kS32:
+ return SkType_Int;
+ case SkOperand2::kScalar:
+ return SkType_Float;
+ case SkOperand2::kString:
+ return SkType_String;
+ case SkOperand2::kArray:
+ return SkType_Array;
+ case SkOperand2::kObject:
+ return SkType_Displayable;
+ default:
+ SkASSERT(0);
+ return SkType_Unknown;
+ }
}
SkOperand2::OpType SkAnimatorScript2::ToOpType(SkDisplayTypes type) {
- if (SkDisplayType::IsDisplayable(NULL /* fMaker */, type))
- return SkOperand2::kObject;
- if (SkDisplayType::IsEnum(NULL /* fMaker */, type))
- return SkOperand2::kS32;
- switch (type) {
- case SkType_ARGB:
- case SkType_MSec:
- case SkType_Int:
- return SkOperand2::kS32;
- case SkType_Float:
- case SkType_Point:
- case SkType_3D_Point:
- return SkOperand2::kScalar;
- case SkType_Base64:
- case SkType_DynamicString:
- case SkType_String:
- return SkOperand2::kString;
- case SkType_Array:
- return SkOperand2::kArray;
- case SkType_Unknown:
- return SkOperand2::kNoType;
- default:
- SkASSERT(0);
- return SkOperand2::kNoType;
- }
+ if (SkDisplayType::IsDisplayable(NULL /* fMaker */, type))
+ return SkOperand2::kObject;
+ if (SkDisplayType::IsEnum(NULL /* fMaker */, type))
+ return SkOperand2::kS32;
+ switch (type) {
+ case SkType_ARGB:
+ case SkType_MSec:
+ case SkType_Int:
+ return SkOperand2::kS32;
+ case SkType_Float:
+ case SkType_Point:
+ case SkType_3D_Point:
+ return SkOperand2::kScalar;
+ case SkType_Base64:
+ case SkType_DynamicString:
+ case SkType_String:
+ return SkOperand2::kString;
+ case SkType_Array:
+ return SkOperand2::kArray;
+ case SkType_Unknown:
+ return SkOperand2::kNoType;
+ default:
+ SkASSERT(0);
+ return SkOperand2::kNoType;
+ }
}
bool SkAnimatorScript2::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 == NULL) {
- 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;
+ int index = 0;
+ bool more = true;
+ do {
+ const char* last = strchr(ptr, '|');
+ if (last == NULL) {
+ 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;
}
#if defined SK_DEBUG
#include "SkAnimator.h"
-static const char scriptTestSetup[] =
+static const char scriptTestSetup[] =
"<screenplay>"
- "<apply>"
- "<paint>"
- "<emboss id='emboss' direction='[1,1,1]' />"
- "</paint>"
- "<animateField id='animation' field='direction' target='emboss' from='[1,1,1]' to='[-1,1,1]' dur='1'/>"
- "<set lval='direction[0]' target='emboss' to='-1' />"
- "</apply>"
- "<color id='testColor' color='0 ? rgb(0,0,0) : rgb(255,255,255)' />"
- "<color id='xColor' color='rgb(12,34,56)' />"
- "<typedArray id='emptyArray' />"
- "<typedArray id='intArray' values='[1, 4, 6]' />"
- "<s32 id='idx' value='2' />"
- "<s32 id='idy' value='2' />"
- "<string id='alpha' value='abc' />"
- "<rectangle id='testRect' left='Math.cos(0)' top='2' right='12' bottom='5' />"
- "<event id='evt'>"
- "<input name='x' />"
- "<apply scope='idy'>"
- "<set field='value' to='evt.x.s32' />"
- "</apply>"
- "</event>"
+ "<apply>"
+ "<paint>"
+ "<emboss id='emboss' direction='[1,1,1]' />"
+ "</paint>"
+ "<animateField id='animation' field='direction' target='emboss' from='[1,1,1]' to='[-1,1,1]' dur='1'/>"
+ "<set lval='direction[0]' target='emboss' to='-1' />"
+ "</apply>"
+ "<color id='testColor' color='0 ? rgb(0,0,0) : rgb(255,255,255)' />"
+ "<color id='xColor' color='rgb(12,34,56)' />"
+ "<typedArray id='emptyArray' />"
+ "<typedArray id='intArray' values='[1, 4, 6]' />"
+ "<s32 id='idx' value='2' />"
+ "<s32 id='idy' value='2' />"
+ "<string id='alpha' value='abc' />"
+ "<rectangle id='testRect' left='Math.cos(0)' top='2' right='12' bottom='5' />"
+ "<event id='evt'>"
+ "<input name='x' />"
+ "<apply scope='idy'>"
+ "<set field='value' to='evt.x.s32' />"
+ "</apply>"
+ "</event>"
"</screenplay>";
static const SkScriptNAnswer scriptTests[] = {
- { "alpha+alpha", SkType_String, 0, 0, "abcabc" },
- { "0 ? Math.sin(0) : 1", SkType_Int, 1 },
- { "intArray[4]", SkType_Unknown },
- { "emptyArray[4]", SkType_Unknown },
- { "idx", SkType_Int, 2 },
- { "intArray.length", SkType_Int, 3 },
- { "intArray.values[0]", SkType_Int, 1 },
- { "intArray[0]", SkType_Int, 1 },
- { "idx.value", SkType_Int, 2 },
- { "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 },
- { "alpha.slice(1,2)", SkType_String, 0, 0, "b" },
- { "alpha.value.slice(1,2)", SkType_String, 0, 0, "b" },
- { "Math.sin(0)", SkType_Float, 0, SkIntToScalar(0) },
- { "testRect.left+2", SkType_Float, 0, SkIntToScalar(3) },
- { "0 ? intArray[0] : 1", SkType_Int, 1 },
- { "0 ? intArray.values[0] : 1", SkType_Int, 1 },
- { "0 ? idx : 1", SkType_Int, 1 },
- { "0 ? idx.value : 1", SkType_Int, 1 },
- { "0 ? alpha.slice(1,2) : 1", SkType_Int, 1 },
- { "0 ? alpha.value.slice(1,2) : 1", SkType_Int, 1 },
- { "idy", SkType_Int, 3 }
+ { "alpha+alpha", SkType_String, 0, 0, "abcabc" },
+ { "0 ? Math.sin(0) : 1", SkType_Int, 1 },
+ { "intArray[4]", SkType_Unknown },
+ { "emptyArray[4]", SkType_Unknown },
+ { "idx", SkType_Int, 2 },
+ { "intArray.length", SkType_Int, 3 },
+ { "intArray.values[0]", SkType_Int, 1 },
+ { "intArray[0]", SkType_Int, 1 },
+ { "idx.value", SkType_Int, 2 },
+ { "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 },
+ { "alpha.slice(1,2)", SkType_String, 0, 0, "b" },
+ { "alpha.value.slice(1,2)", SkType_String, 0, 0, "b" },
+ { "Math.sin(0)", SkType_Float, 0, SkIntToScalar(0) },
+ { "testRect.left+2", SkType_Float, 0, SkIntToScalar(3) },
+ { "0 ? intArray[0] : 1", SkType_Int, 1 },
+ { "0 ? intArray.values[0] : 1", SkType_Int, 1 },
+ { "0 ? idx : 1", SkType_Int, 1 },
+ { "0 ? idx.value : 1", SkType_Int, 1 },
+ { "0 ? alpha.slice(1,2) : 1", SkType_Int, 1 },
+ { "0 ? alpha.value.slice(1,2) : 1", SkType_Int, 1 },
+ { "idy", SkType_Int, 3 }
};
-#define SkScriptNAnswer_testCount SK_ARRAY_COUNT(scriptTests)
+#define SkScriptNAnswer_testCount SK_ARRAY_COUNT(scriptTests)
void SkAnimatorScript2::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 (int index = 0; index < SkScriptNAnswer_testCount; index++) {
- SkAnimatorScript2 engine(*animator.fMaker, NULL, scriptTests[index].fType);
- SkScriptValue2 value;
- const char* script = scriptTests[index].fScript;
- bool success = engine.evaluateScript(&script, &value);
- if (success == false) {
- SkASSERT(scriptTests[index].fType == SkType_Unknown);
- continue;
- }
- SkASSERT(value.fType == ToOpType(scriptTests[index].fType));
- SkScalar error;
- switch (value.fType) {
- case SkOperand2::kS32:
- SkASSERT(value.fOperand.fS32 == scriptTests[index].fIntAnswer);
- break;
- case SkOperand2::kScalar:
- error = SkScalarAbs(value.fOperand.fScalar - scriptTests[index].fScalarAnswer);
- SkASSERT(error < SK_Scalar1 / 10000);
- break;
- case SkOperand2::kString:
- SkASSERT(value.fOperand.fString->equals(scriptTests[index].fStringAnswer));
- break;
- default:
- SkASSERT(0);
- }
- }
+ 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 (int index = 0; index < SkScriptNAnswer_testCount; index++) {
+ SkAnimatorScript2 engine(*animator.fMaker, NULL, scriptTests[index].fType);
+ SkScriptValue2 value;
+ const char* script = scriptTests[index].fScript;
+ bool success = engine.evaluateScript(&script, &value);
+ if (success == false) {
+ SkASSERT(scriptTests[index].fType == SkType_Unknown);
+ continue;
+ }
+ SkASSERT(value.fType == ToOpType(scriptTests[index].fType));
+ SkScalar error;
+ switch (value.fType) {
+ case SkOperand2::kS32:
+ SkASSERT(value.fOperand.fS32 == scriptTests[index].fIntAnswer);
+ break;
+ case SkOperand2::kScalar:
+ error = SkScalarAbs(value.fOperand.fScalar - scriptTests[index].fScalarAnswer);
+ SkASSERT(error < SK_Scalar1 / 10000);
+ break;
+ case SkOperand2::kString:
+ SkASSERT(value.fOperand.fString->equals(scriptTests[index].fStringAnswer));
+ break;
+ default:
+ SkASSERT(0);
+ }
+ }
#endif
}
diff --git a/src/animator/SkAnimatorScript2.h b/src/animator/SkAnimatorScript2.h
index e6bf58e..c3995f6 100644
--- a/src/animator/SkAnimatorScript2.h
+++ b/src/animator/SkAnimatorScript2.h
@@ -17,33 +17,33 @@
#ifndef SkAnimatorScript_DEFINED
struct SkDisplayEnumMap {
- SkDisplayTypes fType;
- const char* fValues;
+ SkDisplayTypes fType;
+ const char* fValues;
};
#endif
class SkAnimatorScript2 : public SkScriptEngine2 {
public:
- SkAnimatorScript2(SkAnimateMaker& , SkDisplayable* working, SkDisplayTypes type);
- ~SkAnimatorScript2();
- bool evalMemberCommon(const SkMemberInfo* info,
- SkDisplayable* displayable, SkOperand2* value);
- SkAnimateMaker& getMaker() { return fMaker; }
- SkDisplayable* getWorking() { return fWorking; }
- static bool MapEnums(const char* ptr, const char* match, size_t len, int* value);
- static const SkDisplayEnumMap& GetEnumValues(SkDisplayTypes type);
- static SkDisplayTypes ToDisplayType(SkOperand2::OpType type);
- static SkOperand2::OpType ToOpType(SkDisplayTypes type);
+ SkAnimatorScript2(SkAnimateMaker& , SkDisplayable* working, SkDisplayTypes type);
+ ~SkAnimatorScript2();
+ bool evalMemberCommon(const SkMemberInfo* info,
+ SkDisplayable* displayable, SkOperand2* value);
+ SkAnimateMaker& getMaker() { return fMaker; }
+ SkDisplayable* getWorking() { return fWorking; }
+ static bool MapEnums(const char* ptr, const char* match, size_t len, int* value);
+ static const SkDisplayEnumMap& GetEnumValues(SkDisplayTypes type);
+ static SkDisplayTypes ToDisplayType(SkOperand2::OpType type);
+ static SkOperand2::OpType ToOpType(SkDisplayTypes type);
private:
- SkAnimateMaker& fMaker;
- SkDisplayable* fWorking;
- friend class SkDump;
- friend struct SkScriptNAnswer;
- // illegal
- SkAnimatorScript2& operator=(const SkAnimatorScript2&);
+ SkAnimateMaker& fMaker;
+ SkDisplayable* fWorking;
+ friend class SkDump;
+ friend struct SkScriptNAnswer;
+ // illegal
+ SkAnimatorScript2& operator=(const SkAnimatorScript2&);
#ifdef SK_DEBUG
public:
- static void UnitTest();
+ static void UnitTest();
#endif
};
diff --git a/src/animator/SkBoundable.cpp b/src/animator/SkBoundable.cpp
index 017b6b8..7f36218 100644
--- a/src/animator/SkBoundable.cpp
+++ b/src/animator/SkBoundable.cpp
@@ -39,7 +39,7 @@
}
-SkBoundableAuto::SkBoundableAuto(SkBoundable* boundable,
+SkBoundableAuto::SkBoundableAuto(SkBoundable* boundable,
SkAnimateMaker& maker) : fBoundable(boundable), fMaker(maker) {
if (fBoundable->hasBounds()) {
fMaker.fCanvas->setBounder(&maker.fDisplayList);
diff --git a/src/animator/SkBuildCondensedInfo.cpp b/src/animator/SkBuildCondensedInfo.cpp
index 30da67e..8fb82c7 100644
--- a/src/animator/SkBuildCondensedInfo.cpp
+++ b/src/animator/SkBuildCondensedInfo.cpp
@@ -10,7 +10,7 @@
#include "SkTypes.h"
#if defined SK_BUILD_CONDENSED
#include "SkMemberInfo.h"
-#if SK_USE_CONDENSED_INFO == 1
+#if SK_USE_CONDENSED_INFO == 1
#error "SK_USE_CONDENSED_INFO must be zero to build condensed info"
#endif
#if !defined SK_BUILD_FOR_WIN32
@@ -115,7 +115,7 @@
continue;
AddInfo(gTypeNames[index].fType, info, infoCount);
}
- const SkMemberInfo* extraInfo =
+ const SkMemberInfo* extraInfo =
SkDisplayType::GetMembers(maker, SkType_3D_Point, &infoCount);
AddInfo(SkType_Point, extraInfo, infoCount);
AddInfo(SkType_3D_Point, extraInfo, infoCount);
@@ -239,7 +239,7 @@
Get3DName(scratch, gTypeNames[typeNameIndex].fName);
} else
sprintf(scratch, "Unknown%d", unknown++);
- fprintf(condensed, "%d%c // %s\n\t", index,
+ fprintf(condensed, "%d%c // %s\n\t", index,
index < gInfosCounts.count() ? ',' : ' ', scratch);
}
fprintf(condensed, "\n};\n\n");
diff --git a/src/animator/SkCondensedDebug.cpp b/src/animator/SkCondensedDebug.cpp
index c1c7007..08764b6 100644
--- a/src/animator/SkCondensedDebug.cpp
+++ b/src/animator/SkCondensedDebug.cpp
@@ -14,7 +14,7 @@
// To change it, edit the file with the matching debug info.
// Then execute SkDisplayType::BuildCondensedInfo() to regenerate this file.
-static const char gMathStrings[] =
+static const char gMathStrings[] =
"E\0"
"LN10\0"
"LN2\0"
@@ -72,7 +72,7 @@
{123, -18, 66, 98}
};
-static const char gAddStrings[] =
+static const char gAddStrings[] =
"inPlace\0"
"offset\0"
"use\0"
@@ -86,7 +86,7 @@
{19, 28, 37, 1}
};
-static const char gAddCircleStrings[] =
+static const char gAddCircleStrings[] =
"\0"
"radius\0"
"x\0"
@@ -100,7 +100,7 @@
{10, 32, 98, 1}
};
-static const char gUnknown1Strings[] =
+static const char gUnknown1Strings[] =
"direction"
;
@@ -108,7 +108,7 @@
{0, 20, 75, 1}
};
-static const char gAddOvalStrings[] =
+static const char gAddOvalStrings[] =
""
;
@@ -116,7 +116,7 @@
{0, 6, 18, 5}
};
-static const char gAddPathStrings[] =
+static const char gAddPathStrings[] =
"matrix\0"
"path"
;
@@ -126,7 +126,7 @@
{7, 24, 74, 1}
};
-static const char gAddRectangleStrings[] =
+static const char gAddRectangleStrings[] =
"\0"
"bottom\0"
"left\0"
@@ -142,7 +142,7 @@
{19, 28, 98, 1}
};
-static const char gAddRoundRectStrings[] =
+static const char gAddRoundRectStrings[] =
"\0"
"rx\0"
"ry"
@@ -154,7 +154,7 @@
{4, 44, 98, 1}
};
-static const char gUnknown2Strings[] =
+static const char gUnknown2Strings[] =
"begin\0"
"blend\0"
"dur\0"
@@ -186,7 +186,7 @@
{73, -4, 67, 40}
};
-static const char gAnimateFieldStrings[] =
+static const char gAnimateFieldStrings[] =
""
;
@@ -194,7 +194,7 @@
{0, 8, 18, 13}
};
-static const char gApplyStrings[] =
+static const char gApplyStrings[] =
"animator\0"
"begin\0"
"dontDraw\0"
@@ -226,7 +226,7 @@
{88, 56, 14, 1}
};
-static const char gUnknown3Strings[] =
+static const char gUnknown3Strings[] =
"x\0"
"y"
;
@@ -236,7 +236,7 @@
{2, 52, 98, 1}
};
-static const char gBitmapStrings[] =
+static const char gBitmapStrings[] =
"\0"
"erase\0"
"format\0"
@@ -254,7 +254,7 @@
{30, 68, 96, 1}
};
-static const char gBitmapShaderStrings[] =
+static const char gBitmapShaderStrings[] =
"\0"
"filterType\0"
"image"
@@ -266,7 +266,7 @@
{12, 32, 17, 1}
};
-static const char gBlurStrings[] =
+static const char gBlurStrings[] =
"blurStyle\0"
"radius"
;
@@ -276,7 +276,7 @@
{10, 20, 98, 1}
};
-static const char gBoundsStrings[] =
+static const char gBoundsStrings[] =
"\0"
"inval"
;
@@ -286,7 +286,7 @@
{1, 44, 26, 1}
};
-static const char gClipStrings[] =
+static const char gClipStrings[] =
"path\0"
"rectangle"
;
@@ -296,7 +296,7 @@
{5, 16, 91, 1}
};
-static const char gColorStrings[] =
+static const char gColorStrings[] =
"alpha\0"
"blue\0"
"color\0"
@@ -318,7 +318,7 @@
{42, -7, 67, 98}
};
-static const char gCubicToStrings[] =
+static const char gCubicToStrings[] =
"x1\0"
"x2\0"
"x3\0"
@@ -336,7 +336,7 @@
{15, 40, 98, 1}
};
-static const char gDashStrings[] =
+static const char gDashStrings[] =
"intervals\0"
"phase"
;
@@ -346,7 +346,7 @@
{10, 36, 98, 1}
};
-static const char gDataStrings[] =
+static const char gDataStrings[] =
"\0"
"name"
;
@@ -356,7 +356,7 @@
{1, 32, 108, 2}
};
-static const char gDiscreteStrings[] =
+static const char gDiscreteStrings[] =
"deviation\0"
"segLength"
;
@@ -366,7 +366,7 @@
{10, 24, 98, 1}
};
-static const char gDrawToStrings[] =
+static const char gDrawToStrings[] =
"drawOnce\0"
"use"
;
@@ -376,7 +376,7 @@
{9, 76, 19, 1}
};
-static const char gDumpStrings[] =
+static const char gDumpStrings[] =
"displayList\0"
"eventList\0"
"events\0"
@@ -394,7 +394,7 @@
{41, 40, 26, 1}
};
-static const char gEmbossStrings[] =
+static const char gEmbossStrings[] =
"ambient\0"
"direction\0"
"radius\0"
@@ -408,7 +408,7 @@
{25, -2, 67, 98}
};
-static const char gEventStrings[] =
+static const char gEventStrings[] =
"code\0"
"disable\0"
"key\0"
@@ -430,7 +430,7 @@
{36, 40, 98, 1}
};
-static const char gFromPathStrings[] =
+static const char gFromPathStrings[] =
"mode\0"
"offset\0"
"path"
@@ -442,7 +442,7 @@
{12, 28, 74, 1}
};
-static const char gUnknown4Strings[] =
+static const char gUnknown4Strings[] =
"\0"
"offsets\0"
"unitMapper"
@@ -454,7 +454,7 @@
{9, 44, 108, 2}
};
-static const char gGStrings[] =
+static const char gGStrings[] =
"condition\0"
"enableCondition"
;
@@ -464,7 +464,7 @@
{10, 24, 40, 2}
};
-static const char gHitClearStrings[] =
+static const char gHitClearStrings[] =
"targets"
;
@@ -472,7 +472,7 @@
{0, 16, 119, 36}
};
-static const char gHitTestStrings[] =
+static const char gHitTestStrings[] =
"bullets\0"
"hits\0"
"targets\0"
@@ -486,7 +486,7 @@
{21, 64, 26, 1}
};
-static const char gImageStrings[] =
+static const char gImageStrings[] =
"\0"
"base64\0"
"src"
@@ -498,7 +498,7 @@
{8, 64, 108, 2}
};
-static const char gIncludeStrings[] =
+static const char gIncludeStrings[] =
"src"
;
@@ -506,7 +506,7 @@
{0, 16, 108, 2}
};
-static const char gInputStrings[] =
+static const char gInputStrings[] =
"s32\0"
"scalar\0"
"string"
@@ -518,7 +518,7 @@
{11, 24, 108, 2}
};
-static const char gLineStrings[] =
+static const char gLineStrings[] =
"x1\0"
"x2\0"
"y1\0"
@@ -532,7 +532,7 @@
{9, 36, 98, 1}
};
-static const char gLineToStrings[] =
+static const char gLineToStrings[] =
"x\0"
"y"
;
@@ -542,7 +542,7 @@
{2, 24, 98, 1}
};
-static const char gLinearGradientStrings[] =
+static const char gLinearGradientStrings[] =
"\0"
"points"
;
@@ -552,7 +552,7 @@
{1, 88, 77, 4}
};
-static const char gMatrixStrings[] =
+static const char gMatrixStrings[] =
"matrix\0"
"perspectX\0"
"perspectY\0"
@@ -582,7 +582,7 @@
{87, -11, 67, 98}
};
-static const char gMoveStrings[] =
+static const char gMoveStrings[] =
""
;
@@ -590,7 +590,7 @@
{0, 1, 18, 4}
};
-static const char gMoveToStrings[] =
+static const char gMoveToStrings[] =
"x\0"
"y"
;
@@ -600,7 +600,7 @@
{2, 24, 98, 1}
};
-static const char gMovieStrings[] =
+static const char gMovieStrings[] =
"src"
;
@@ -608,7 +608,7 @@
{0, 16, 108, 2}
};
-static const char gOvalStrings[] =
+static const char gOvalStrings[] =
""
;
@@ -616,7 +616,7 @@
{0, 58, 18, 7}
};
-static const char gPaintStrings[] =
+static const char gPaintStrings[] =
"antiAlias\0"
"ascent\0"
"color\0"
@@ -672,7 +672,7 @@
{235, 100, 121, 1}
};
-static const char gPathStrings[] =
+static const char gPathStrings[] =
"d\0"
"fillType\0"
"length"
@@ -684,7 +684,7 @@
{11, -2, 67, 98}
};
-static const char gUnknown5Strings[] =
+static const char gUnknown5Strings[] =
"x\0"
"y\0"
"z"
@@ -696,7 +696,7 @@
{4, 8, 98, 1}
};
-static const char gPointStrings[] =
+static const char gPointStrings[] =
"x\0"
"y"
;
@@ -706,7 +706,7 @@
{2, 20, 98, 1}
};
-static const char gPolyToPolyStrings[] =
+static const char gPolyToPolyStrings[] =
"destination\0"
"source"
;
@@ -716,7 +716,7 @@
{12, 20, 80, 1}
};
-static const char gPolygonStrings[] =
+static const char gPolygonStrings[] =
""
;
@@ -724,7 +724,7 @@
{0, 48, 18, 1}
};
-static const char gPolylineStrings[] =
+static const char gPolylineStrings[] =
"points"
;
@@ -732,7 +732,7 @@
{0, 88, 119, 98}
};
-static const char gPostStrings[] =
+static const char gPostStrings[] =
"delay\0"
"initialized\0"
"mode\0"
@@ -750,7 +750,7 @@
{35, -3, 67, 108}
};
-static const char gQuadToStrings[] =
+static const char gQuadToStrings[] =
"x1\0"
"x2\0"
"y1\0"
@@ -764,7 +764,7 @@
{9, 32, 98, 1}
};
-static const char gRCubicToStrings[] =
+static const char gRCubicToStrings[] =
""
;
@@ -772,7 +772,7 @@
{0, 18, 18, 6}
};
-static const char gRLineToStrings[] =
+static const char gRLineToStrings[] =
""
;
@@ -780,7 +780,7 @@
{0, 35, 18, 2}
};
-static const char gRMoveToStrings[] =
+static const char gRMoveToStrings[] =
""
;
@@ -788,7 +788,7 @@
{0, 39, 18, 2}
};
-static const char gRQuadToStrings[] =
+static const char gRQuadToStrings[] =
""
;
@@ -796,7 +796,7 @@
{0, 50, 18, 4}
};
-static const char gRadialGradientStrings[] =
+static const char gRadialGradientStrings[] =
"\0"
"center\0"
"radius"
@@ -808,7 +808,7 @@
{8, 96, 98, 1}
};
-static const char gRandomStrings[] =
+static const char gRandomStrings[] =
"blend\0"
"max\0"
"min\0"
@@ -824,7 +824,7 @@
{21, -2, 67, 96}
};
-static const char gRectToRectStrings[] =
+static const char gRectToRectStrings[] =
"destination\0"
"source"
;
@@ -834,7 +834,7 @@
{12, 20, 91, 1}
};
-static const char gRectangleStrings[] =
+static const char gRectangleStrings[] =
"bottom\0"
"height\0"
"left\0"
@@ -854,7 +854,7 @@
{41, -3, 67, 98}
};
-static const char gRemoveStrings[] =
+static const char gRemoveStrings[] =
"offset\0"
"where"
;
@@ -864,7 +864,7 @@
{7, 28, 37, 1}
};
-static const char gReplaceStrings[] =
+static const char gReplaceStrings[] =
""
;
@@ -872,7 +872,7 @@
{0, 1, 18, 4}
};
-static const char gRotateStrings[] =
+static const char gRotateStrings[] =
"center\0"
"degrees"
;
@@ -882,7 +882,7 @@
{7, 20, 98, 1}
};
-static const char gRoundRectStrings[] =
+static const char gRoundRectStrings[] =
"\0"
"rx\0"
"ry"
@@ -894,7 +894,7 @@
{4, 48, 98, 1}
};
-static const char gS32Strings[] =
+static const char gS32Strings[] =
"value"
;
@@ -902,7 +902,7 @@
{0, 16, 96, 1}
};
-static const char gScalarStrings[] =
+static const char gScalarStrings[] =
"value"
;
@@ -910,7 +910,7 @@
{0, 16, 98, 1}
};
-static const char gScaleStrings[] =
+static const char gScaleStrings[] =
"center\0"
"x\0"
"y"
@@ -922,7 +922,7 @@
{9, 24, 98, 1}
};
-static const char gSetStrings[] =
+static const char gSetStrings[] =
"begin\0"
"dur\0"
"dynamic\0"
@@ -944,7 +944,7 @@
{45, 76, 40, 2}
};
-static const char gShaderStrings[] =
+static const char gShaderStrings[] =
"matrix\0"
"tileMode"
;
@@ -954,7 +954,7 @@
{7, 24, 116, 1}
};
-static const char gSkewStrings[] =
+static const char gSkewStrings[] =
"center\0"
"x\0"
"y"
@@ -966,7 +966,7 @@
{9, 24, 98, 1}
};
-static const char g3D_CameraStrings[] =
+static const char g3D_CameraStrings[] =
"axis\0"
"hackHeight\0"
"hackWidth\0"
@@ -986,7 +986,7 @@
{50, 48, 106, 3}
};
-static const char g3D_PatchStrings[] =
+static const char g3D_PatchStrings[] =
"origin\0"
"rotateDegrees\0"
"u\0"
@@ -1000,7 +1000,7 @@
{23, 28, 106, 3}
};
-static const char gUnknown6Strings[] =
+static const char gUnknown6Strings[] =
"x\0"
"y\0"
"z"
@@ -1012,7 +1012,7 @@
{4, 8, 98, 1}
};
-static const char gSnapshotStrings[] =
+static const char gSnapshotStrings[] =
"filename\0"
"quality\0"
"sequence\0"
@@ -1026,7 +1026,7 @@
{26, 32, 20, 1}
};
-static const char gStringStrings[] =
+static const char gStringStrings[] =
"length\0"
"slice\0"
"value"
@@ -1038,7 +1038,7 @@
{13, 16, 108, 2}
};
-static const char gTextStrings[] =
+static const char gTextStrings[] =
"length\0"
"text\0"
"x\0"
@@ -1052,7 +1052,7 @@
{14, 36, 98, 1}
};
-static const char gTextBoxStrings[] =
+static const char gTextBoxStrings[] =
"\0"
"mode\0"
"spacingAdd\0"
@@ -1070,7 +1070,7 @@
{41, 44, 108, 2}
};
-static const char gTextOnPathStrings[] =
+static const char gTextOnPathStrings[] =
"offset\0"
"path\0"
"text"
@@ -1082,7 +1082,7 @@
{12, 32, 110, 1}
};
-static const char gTextToPathStrings[] =
+static const char gTextToPathStrings[] =
"path\0"
"text"
;
@@ -1092,7 +1092,7 @@
{5, 20, 110, 1}
};
-static const char gTranslateStrings[] =
+static const char gTranslateStrings[] =
"x\0"
"y"
;
@@ -1102,7 +1102,7 @@
{2, 24, 98, 1}
};
-static const char gTypedArrayStrings[] =
+static const char gTypedArrayStrings[] =
"length\0"
"values"
;
@@ -1112,7 +1112,7 @@
{7, 16, 119, 0}
};
-static const char gTypefaceStrings[] =
+static const char gTypefaceStrings[] =
"fontName"
;
@@ -1294,7 +1294,7 @@
117, // Translate
119, // TypedArray
120, // Typeface
-
+
};
static const int kTypeIDs = 81;
diff --git a/src/animator/SkCondensedRelease.cpp b/src/animator/SkCondensedRelease.cpp
index 234e67e..60fa991 100644
--- a/src/animator/SkCondensedRelease.cpp
+++ b/src/animator/SkCondensedRelease.cpp
@@ -14,7 +14,7 @@
// To change it, edit the file with the matching debug info.
// Then execute SkDisplayType::BuildCondensedInfo() to regenerate this file.
-static const char gMathStrings[] =
+static const char gMathStrings[] =
"E\0"
"LN10\0"
"LN2\0"
@@ -72,7 +72,7 @@
{123, -18, 66, 98}
};
-static const char gAddStrings[] =
+static const char gAddStrings[] =
"inPlace\0"
"offset\0"
"use\0"
@@ -86,7 +86,7 @@
{19, 16, 37, 1}
};
-static const char gAddCircleStrings[] =
+static const char gAddCircleStrings[] =
"\0"
"radius\0"
"x\0"
@@ -100,7 +100,7 @@
{10, 20, 98, 1}
};
-static const char gUnknown1Strings[] =
+static const char gUnknown1Strings[] =
"direction"
;
@@ -108,7 +108,7 @@
{0, 8, 75, 1}
};
-static const char gAddOvalStrings[] =
+static const char gAddOvalStrings[] =
""
;
@@ -116,7 +116,7 @@
{0, 6, 18, 5}
};
-static const char gAddPathStrings[] =
+static const char gAddPathStrings[] =
"matrix\0"
"path"
;
@@ -126,7 +126,7 @@
{7, 12, 74, 1}
};
-static const char gAddRectangleStrings[] =
+static const char gAddRectangleStrings[] =
"\0"
"bottom\0"
"left\0"
@@ -142,7 +142,7 @@
{19, 16, 98, 1}
};
-static const char gAddRoundRectStrings[] =
+static const char gAddRoundRectStrings[] =
"\0"
"rx\0"
"ry"
@@ -154,7 +154,7 @@
{4, 32, 98, 1}
};
-static const char gUnknown2Strings[] =
+static const char gUnknown2Strings[] =
"begin\0"
"blend\0"
"dur\0"
@@ -186,7 +186,7 @@
{73, -4, 67, 40}
};
-static const char gAnimateFieldStrings[] =
+static const char gAnimateFieldStrings[] =
""
;
@@ -194,7 +194,7 @@
{0, 8, 18, 13}
};
-static const char gApplyStrings[] =
+static const char gApplyStrings[] =
"animator\0"
"begin\0"
"dontDraw\0"
@@ -226,7 +226,7 @@
{88, 40, 14, 1}
};
-static const char gUnknown3Strings[] =
+static const char gUnknown3Strings[] =
"x\0"
"y"
;
@@ -236,7 +236,7 @@
{2, 40, 98, 1}
};
-static const char gBitmapStrings[] =
+static const char gBitmapStrings[] =
"\0"
"erase\0"
"format\0"
@@ -254,7 +254,7 @@
{30, 56, 96, 1}
};
-static const char gBitmapShaderStrings[] =
+static const char gBitmapShaderStrings[] =
"\0"
"filterType\0"
"image"
@@ -266,7 +266,7 @@
{12, 20, 17, 1}
};
-static const char gBlurStrings[] =
+static const char gBlurStrings[] =
"blurStyle\0"
"radius"
;
@@ -276,7 +276,7 @@
{10, 8, 98, 1}
};
-static const char gBoundsStrings[] =
+static const char gBoundsStrings[] =
"\0"
"inval"
;
@@ -286,7 +286,7 @@
{1, 32, 26, 1}
};
-static const char gClipStrings[] =
+static const char gClipStrings[] =
"path\0"
"rectangle"
;
@@ -296,7 +296,7 @@
{5, 4, 91, 1}
};
-static const char gColorStrings[] =
+static const char gColorStrings[] =
"alpha\0"
"blue\0"
"color\0"
@@ -318,7 +318,7 @@
{42, -7, 67, 98}
};
-static const char gCubicToStrings[] =
+static const char gCubicToStrings[] =
"x1\0"
"x2\0"
"x3\0"
@@ -336,7 +336,7 @@
{15, 28, 98, 1}
};
-static const char gDashStrings[] =
+static const char gDashStrings[] =
"intervals\0"
"phase"
;
@@ -346,7 +346,7 @@
{10, 16, 98, 1}
};
-static const char gDataStrings[] =
+static const char gDataStrings[] =
"\0"
"name"
;
@@ -356,7 +356,7 @@
{1, 16, 108, 1}
};
-static const char gDiscreteStrings[] =
+static const char gDiscreteStrings[] =
"deviation\0"
"segLength"
;
@@ -366,7 +366,7 @@
{10, 12, 98, 1}
};
-static const char gDrawToStrings[] =
+static const char gDrawToStrings[] =
"drawOnce\0"
"use"
;
@@ -376,7 +376,7 @@
{9, 40, 19, 1}
};
-static const char gEmbossStrings[] =
+static const char gEmbossStrings[] =
"ambient\0"
"direction\0"
"radius\0"
@@ -390,7 +390,7 @@
{25, -2, 67, 98}
};
-static const char gEventStrings[] =
+static const char gEventStrings[] =
"code\0"
"disable\0"
"key\0"
@@ -412,7 +412,7 @@
{36, 24, 98, 1}
};
-static const char gFromPathStrings[] =
+static const char gFromPathStrings[] =
"mode\0"
"offset\0"
"path"
@@ -424,7 +424,7 @@
{12, 16, 74, 1}
};
-static const char gUnknown4Strings[] =
+static const char gUnknown4Strings[] =
"\0"
"offsets\0"
"unitMapper"
@@ -436,7 +436,7 @@
{9, 24, 108, 1}
};
-static const char gGStrings[] =
+static const char gGStrings[] =
"condition\0"
"enableCondition"
;
@@ -446,7 +446,7 @@
{10, 8, 40, 1}
};
-static const char gHitClearStrings[] =
+static const char gHitClearStrings[] =
"targets"
;
@@ -454,7 +454,7 @@
{0, 4, 119, 36}
};
-static const char gHitTestStrings[] =
+static const char gHitTestStrings[] =
"bullets\0"
"hits\0"
"targets\0"
@@ -468,7 +468,7 @@
{21, 28, 26, 1}
};
-static const char gImageStrings[] =
+static const char gImageStrings[] =
"\0"
"base64\0"
"src"
@@ -480,7 +480,7 @@
{8, 52, 108, 1}
};
-static const char gIncludeStrings[] =
+static const char gIncludeStrings[] =
"src"
;
@@ -488,7 +488,7 @@
{0, 4, 108, 1}
};
-static const char gInputStrings[] =
+static const char gInputStrings[] =
"s32\0"
"scalar\0"
"string"
@@ -500,7 +500,7 @@
{11, 12, 108, 1}
};
-static const char gLineStrings[] =
+static const char gLineStrings[] =
"x1\0"
"x2\0"
"y1\0"
@@ -514,7 +514,7 @@
{9, 24, 98, 1}
};
-static const char gLineToStrings[] =
+static const char gLineToStrings[] =
"x\0"
"y"
;
@@ -524,7 +524,7 @@
{2, 12, 98, 1}
};
-static const char gLinearGradientStrings[] =
+static const char gLinearGradientStrings[] =
"\0"
"points"
;
@@ -534,7 +534,7 @@
{1, 48, 77, 4}
};
-static const char gMatrixStrings[] =
+static const char gMatrixStrings[] =
"matrix\0"
"perspectX\0"
"perspectY\0"
@@ -564,7 +564,7 @@
{87, -11, 67, 98}
};
-static const char gMoveStrings[] =
+static const char gMoveStrings[] =
""
;
@@ -572,7 +572,7 @@
{0, 1, 18, 4}
};
-static const char gMoveToStrings[] =
+static const char gMoveToStrings[] =
"x\0"
"y"
;
@@ -582,7 +582,7 @@
{2, 12, 98, 1}
};
-static const char gMovieStrings[] =
+static const char gMovieStrings[] =
"src"
;
@@ -590,7 +590,7 @@
{0, 4, 108, 1}
};
-static const char gOvalStrings[] =
+static const char gOvalStrings[] =
""
;
@@ -598,7 +598,7 @@
{0, 57, 18, 7}
};
-static const char gPaintStrings[] =
+static const char gPaintStrings[] =
"antiAlias\0"
"ascent\0"
"color\0"
@@ -654,7 +654,7 @@
{235, 88, 121, 1}
};
-static const char gPathStrings[] =
+static const char gPathStrings[] =
"d\0"
"fillType\0"
"length"
@@ -666,7 +666,7 @@
{11, -2, 67, 98}
};
-static const char gUnknown5Strings[] =
+static const char gUnknown5Strings[] =
"x\0"
"y\0"
"z"
@@ -678,7 +678,7 @@
{4, 8, 98, 1}
};
-static const char gPointStrings[] =
+static const char gPointStrings[] =
"x\0"
"y"
;
@@ -688,7 +688,7 @@
{2, 8, 98, 1}
};
-static const char gPolyToPolyStrings[] =
+static const char gPolyToPolyStrings[] =
"destination\0"
"source"
;
@@ -698,7 +698,7 @@
{12, 8, 80, 1}
};
-static const char gPolygonStrings[] =
+static const char gPolygonStrings[] =
""
;
@@ -706,7 +706,7 @@
{0, 47, 18, 1}
};
-static const char gPolylineStrings[] =
+static const char gPolylineStrings[] =
"points"
;
@@ -714,7 +714,7 @@
{0, 56, 119, 98}
};
-static const char gPostStrings[] =
+static const char gPostStrings[] =
"delay\0"
"initialized\0"
"mode\0"
@@ -732,7 +732,7 @@
{35, -3, 67, 108}
};
-static const char gQuadToStrings[] =
+static const char gQuadToStrings[] =
"x1\0"
"x2\0"
"y1\0"
@@ -746,7 +746,7 @@
{9, 20, 98, 1}
};
-static const char gRCubicToStrings[] =
+static const char gRCubicToStrings[] =
""
;
@@ -754,7 +754,7 @@
{0, 18, 18, 6}
};
-static const char gRLineToStrings[] =
+static const char gRLineToStrings[] =
""
;
@@ -762,7 +762,7 @@
{0, 34, 18, 2}
};
-static const char gRMoveToStrings[] =
+static const char gRMoveToStrings[] =
""
;
@@ -770,7 +770,7 @@
{0, 38, 18, 2}
};
-static const char gRQuadToStrings[] =
+static const char gRQuadToStrings[] =
""
;
@@ -778,7 +778,7 @@
{0, 49, 18, 4}
};
-static const char gRadialGradientStrings[] =
+static const char gRadialGradientStrings[] =
"\0"
"center\0"
"radius"
@@ -790,7 +790,7 @@
{8, 56, 98, 1}
};
-static const char gRandomStrings[] =
+static const char gRandomStrings[] =
"blend\0"
"max\0"
"min\0"
@@ -806,7 +806,7 @@
{21, -2, 67, 96}
};
-static const char gRectToRectStrings[] =
+static const char gRectToRectStrings[] =
"destination\0"
"source"
;
@@ -816,7 +816,7 @@
{12, 8, 91, 1}
};
-static const char gRectangleStrings[] =
+static const char gRectangleStrings[] =
"bottom\0"
"height\0"
"left\0"
@@ -836,7 +836,7 @@
{41, -3, 67, 98}
};
-static const char gRemoveStrings[] =
+static const char gRemoveStrings[] =
"offset\0"
"where"
;
@@ -846,7 +846,7 @@
{7, 16, 37, 1}
};
-static const char gReplaceStrings[] =
+static const char gReplaceStrings[] =
""
;
@@ -854,7 +854,7 @@
{0, 1, 18, 4}
};
-static const char gRotateStrings[] =
+static const char gRotateStrings[] =
"center\0"
"degrees"
;
@@ -864,7 +864,7 @@
{7, 8, 98, 1}
};
-static const char gRoundRectStrings[] =
+static const char gRoundRectStrings[] =
"\0"
"rx\0"
"ry"
@@ -876,7 +876,7 @@
{4, 36, 98, 1}
};
-static const char gS32Strings[] =
+static const char gS32Strings[] =
"value"
;
@@ -884,7 +884,7 @@
{0, 4, 96, 1}
};
-static const char gScalarStrings[] =
+static const char gScalarStrings[] =
"value"
;
@@ -892,7 +892,7 @@
{0, 4, 98, 1}
};
-static const char gScaleStrings[] =
+static const char gScaleStrings[] =
"center\0"
"x\0"
"y"
@@ -904,7 +904,7 @@
{9, 12, 98, 1}
};
-static const char gSetStrings[] =
+static const char gSetStrings[] =
"begin\0"
"dur\0"
"dynamic\0"
@@ -926,7 +926,7 @@
{45, 40, 40, 1}
};
-static const char gShaderStrings[] =
+static const char gShaderStrings[] =
"matrix\0"
"tileMode"
;
@@ -936,7 +936,7 @@
{7, 12, 116, 1}
};
-static const char gSkewStrings[] =
+static const char gSkewStrings[] =
"center\0"
"x\0"
"y"
@@ -948,7 +948,7 @@
{9, 12, 98, 1}
};
-static const char g3D_CameraStrings[] =
+static const char g3D_CameraStrings[] =
"axis\0"
"hackHeight\0"
"hackWidth\0"
@@ -968,7 +968,7 @@
{50, 36, 106, 3}
};
-static const char g3D_PatchStrings[] =
+static const char g3D_PatchStrings[] =
"origin\0"
"rotateDegrees\0"
"u\0"
@@ -982,7 +982,7 @@
{23, 16, 106, 3}
};
-static const char gUnknown6Strings[] =
+static const char gUnknown6Strings[] =
"x\0"
"y\0"
"z"
@@ -994,7 +994,7 @@
{4, 8, 98, 1}
};
-static const char gSnapshotStrings[] =
+static const char gSnapshotStrings[] =
"filename\0"
"quality\0"
"sequence\0"
@@ -1008,7 +1008,7 @@
{26, 16, 20, 1}
};
-static const char gStringStrings[] =
+static const char gStringStrings[] =
"length\0"
"slice\0"
"value"
@@ -1020,7 +1020,7 @@
{13, 4, 108, 1}
};
-static const char gTextStrings[] =
+static const char gTextStrings[] =
"length\0"
"text\0"
"x\0"
@@ -1034,7 +1034,7 @@
{14, 20, 98, 1}
};
-static const char gTextBoxStrings[] =
+static const char gTextBoxStrings[] =
"\0"
"mode\0"
"spacingAdd\0"
@@ -1052,7 +1052,7 @@
{41, 32, 108, 1}
};
-static const char gTextOnPathStrings[] =
+static const char gTextOnPathStrings[] =
"offset\0"
"path\0"
"text"
@@ -1064,7 +1064,7 @@
{12, 20, 110, 1}
};
-static const char gTextToPathStrings[] =
+static const char gTextToPathStrings[] =
"path\0"
"text"
;
@@ -1074,7 +1074,7 @@
{5, 8, 110, 1}
};
-static const char gTranslateStrings[] =
+static const char gTranslateStrings[] =
"x\0"
"y"
;
@@ -1084,7 +1084,7 @@
{2, 12, 98, 1}
};
-static const char gTypedArrayStrings[] =
+static const char gTypedArrayStrings[] =
"length\0"
"values"
;
@@ -1094,7 +1094,7 @@
{7, 4, 119, 0}
};
-static const char gTypefaceStrings[] =
+static const char gTypefaceStrings[] =
"fontName"
;
@@ -1274,7 +1274,7 @@
117, // Translate
119, // TypedArray
120, // Typeface
-
+
};
static const int kTypeIDs = 80;
diff --git a/src/animator/SkDisplayAdd.cpp b/src/animator/SkDisplayAdd.cpp
index 1cf89a1..7fd5026 100644
--- a/src/animator/SkDisplayAdd.cpp
+++ b/src/animator/SkDisplayAdd.cpp
@@ -33,7 +33,7 @@
DEFINE_GET_MEMBER(SkAdd);
-SkAdd::SkAdd() : mode(kMode_indirect),
+SkAdd::SkAdd() : mode(kMode_indirect),
offset(SK_MaxS32), use(NULL), where(NULL) {
}
@@ -119,7 +119,7 @@
parentGroup->markCopySet(index);
useParentList->begin()[index] = use;
break;
- }
+ }
}
*parentList->append() = use;
}
diff --git a/src/animator/SkDisplayAdd.h b/src/animator/SkDisplayAdd.h
index 47948fb..5883963 100644
--- a/src/animator/SkDisplayAdd.h
+++ b/src/animator/SkDisplayAdd.h
@@ -16,12 +16,12 @@
class SkAdd : public SkDrawable {
DECLARE_MEMBER_INFO(Add);
SkAdd();
-
+
enum Mode {
kMode_indirect,
kMode_immediate
};
-
+
virtual SkDisplayable* deepCopy(SkAnimateMaker* );
virtual bool draw(SkAnimateMaker& );
#ifdef SK_DUMP_ENABLED
diff --git a/src/animator/SkDisplayApply.cpp b/src/animator/SkDisplayApply.cpp
index d54ee26..baa10e7 100644
--- a/src/animator/SkDisplayApply.cpp
+++ b/src/animator/SkDisplayApply.cpp
@@ -51,13 +51,13 @@
SK_MEMBER(transition, ApplyTransition)
};
-#endif
+#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),
+ fLastTime(0), fAppended(false), fContainsScope(false), fDeleteScope(false), fEmbedded(false),
fEnabled(false), fEnabling(false) {
}
@@ -105,7 +105,7 @@
}
void SkApply::applyValues(int animatorIndex, SkOperand* values, int count,
- SkDisplayTypes valuesType, SkMSec time)
+ SkDisplayTypes valuesType, SkMSec time)
{
SkAnimateBase* animator = fActive->fAnimators[animatorIndex];
const SkMemberInfo * info = animator->fFieldInfo;
@@ -149,7 +149,7 @@
target->setReference(info, values->fDisplayable);
else
info->setValue(target, values, count);
- }
+ }
}
bool SkApply::contains(SkDisplayable* child) {
@@ -178,7 +178,7 @@
//!!! 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
+ // maybe the fEnabled flag needs to be moved to the fActive data so that both
// instances are not affected.
// fEnabled = false;
}
@@ -265,7 +265,7 @@
bool initialized = fActive != NULL;
if (dynamicScope.size() > 0)
enableDynamic(maker);
- if (maker.fError.hasError())
+ if (maker.fError.hasError())
return false;
int animators = fAnimators.count();
int index;
@@ -333,7 +333,7 @@
}
#endif
// start here;
- // now that one apply might embed another, only the parent apply should replace the scope
+ // 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
@@ -408,7 +408,7 @@
step = steps; // quit
goto next; // resolveIDs failed
}
- if (newID.size() > 0)
+ if (newID.size() > 0)
maker.setID(copyScope, newID);
if (copy->resolveIDs(maker, this, this)) { // fix up all fields, including target
step = steps; // quit
@@ -517,7 +517,7 @@
SkAnimateBase** animEnd = fAnimators.end();
for (SkAnimateBase** animPtr = fAnimators.begin(); animPtr < animEnd; animPtr++) {
SkAnimateBase* animator = *animPtr;
- if (animator->fDelayed)
+ if (animator->fDelayed)
return true;
}
return false;
@@ -548,7 +548,7 @@
SkMSec time = maker.getAppTime();
if (lastTime == (SkMSec) -1)
lastTime = rawTime - 1;
- if (fActive != NULL &&
+ if (fActive != NULL &&
strcmp(id, "a3") == 0 && rawTime > lastTime) {
lastTime += 1000;
SkString debugOut;
@@ -593,7 +593,7 @@
} else
animate->fDelayed = false;
SkMSec innerTime = fLastTime = state.getRelativeTime(time);
- if (restore)
+ if (restore)
fActive->restoreInterpolatorValues(inner);
if (animate->fReset) {
if (transition != SkApply::kTransition_reverse) {
@@ -629,7 +629,7 @@
fLastTime = animate->dur;
SkTypedArray formulaValues;
formulaValues.setCount(count);
- bool success = animate->fFieldInfo->setValue(maker, &formulaValues, 0, 0, NULL,
+ bool success = animate->fFieldInfo->setValue(maker, &formulaValues, 0, 0, NULL,
animate->getValuesType(), animate->formula);
SkASSERT(success);
if (restore)
@@ -652,7 +652,7 @@
scope->initialize();
}
-void SkApply::onEndElement(SkAnimateMaker& maker)
+void SkApply::onEndElement(SkAnimateMaker& maker)
{
SkDrawable* scopePtr = scope;
while (scopePtr && scopePtr->isApply()) {
@@ -781,7 +781,7 @@
SkAnimateBase* animate = (SkAnimateBase*) scriptValue.fOperand.fDisplayable;
SkASSERT(animate->isAnimate());
*fAnimators.append() = animate;
- return true;
+ return true;
}
case SK_PROPERTY(steps):
steps = scriptValue.fOperand.fS32;
@@ -792,8 +792,8 @@
return false;
}
-void SkApply::setSteps(int _steps) {
- steps = _steps;
+void SkApply::setSteps(int _steps) {
+ steps = _steps;
}
#ifdef SK_DEBUG
diff --git a/src/animator/SkDisplayApply.h b/src/animator/SkDisplayApply.h
index 018b894..3a066a4 100644
--- a/src/animator/SkDisplayApply.h
+++ b/src/animator/SkDisplayApply.h
@@ -27,7 +27,7 @@
kTransition_normal,
kTransition_reverse
};
-
+
enum Mode {
kMode_create,
kMode_immediate,
@@ -58,7 +58,7 @@
bool hasDelayedAnimator() const;
virtual bool hasEnable() const;
bool inactivate(SkAnimateMaker& maker);
- virtual void initialize();
+ virtual void initialize();
bool interpolate(SkAnimateMaker& , SkMSec time);
virtual void onEndElement(SkAnimateMaker& );
virtual const SkMemberInfo* preferredChild(SkDisplayTypes type);
diff --git a/src/animator/SkDisplayBounds.cpp b/src/animator/SkDisplayBounds.cpp
index 69ec47e..4c89481b9 100644
--- a/src/animator/SkDisplayBounds.cpp
+++ b/src/animator/SkDisplayBounds.cpp
@@ -36,7 +36,7 @@
maker.fDisplayList.fHasUnion = true;
if (rect.isEmpty())
rect = fBounds;
- else
+ else
rect.join(fBounds);
}
return result;
diff --git a/src/animator/SkDisplayEvent.cpp b/src/animator/SkDisplayEvent.cpp
index 0eb956a..303e42c 100644
--- a/src/animator/SkDisplayEvent.cpp
+++ b/src/animator/SkDisplayEvent.cpp
@@ -52,9 +52,9 @@
deleteMembers();
}
-bool SkDisplayEvent::add(SkAnimateMaker& , SkDisplayable* child) {
- *fChildren.append() = child;
- return true;
+bool SkDisplayEvent::add(SkAnimateMaker& , SkDisplayable* child) {
+ *fChildren.append() = child;
+ return true;
}
bool SkDisplayEvent::contains(SkDisplayable* match) {
@@ -112,7 +112,7 @@
}
#endif
-bool SkDisplayEvent::enableEvent(SkAnimateMaker& maker)
+bool SkDisplayEvent::enableEvent(SkAnimateMaker& maker)
{
maker.fActiveEvent = this;
if (fChildren.count() == 0)
@@ -134,7 +134,7 @@
}
if (displayable->enable(maker))
continue;
- if (maker.hasError())
+ if (maker.hasError())
return true;
if (displayable->isDrawable() == false)
return true; // error
diff --git a/src/animator/SkDisplayEvents.cpp b/src/animator/SkDisplayEvents.cpp
index 38f82a0..c42fbdf 100644
--- a/src/animator/SkDisplayEvents.cpp
+++ b/src/animator/SkDisplayEvents.cpp
@@ -83,7 +83,7 @@
int count = drawArray.count();
for (index = 0; index < count; index++) {
SkDrawable* drawable = drawArray[index];
- drawable->dumpEvents();
+ drawable->dumpEvents();
}
count = fEvents.count();
for (index = 0; index < count; index++) {
diff --git a/src/animator/SkDisplayInput.cpp b/src/animator/SkDisplayInput.cpp
index 77bc5de..7061aa8 100644
--- a/src/animator/SkDisplayInput.cpp
+++ b/src/animator/SkDisplayInput.cpp
@@ -49,7 +49,7 @@
}
return true;
}
-
+
bool SkInput::hasEnable() const {
return true;
}
diff --git a/src/animator/SkDisplayList.cpp b/src/animator/SkDisplayList.cpp
index 8424b12..39465f1 100644
--- a/src/animator/SkDisplayList.cpp
+++ b/src/animator/SkDisplayList.cpp
@@ -51,7 +51,7 @@
}
int SkDisplayList::findGroup(SkDrawable* match, SkTDDrawableArray** list,
- SkGroup** parent, SkGroup** found, SkTDDrawableArray**grandList) {
+ SkGroup** parent, SkGroup** found, SkTDDrawableArray**grandList) {
*parent = NULL;
*list = &fDrawList;
*grandList = &fDrawList;
@@ -69,7 +69,7 @@
}
int SkDisplayList::SearchForMatch(SkDrawable* match, SkTDDrawableArray** list,
- SkGroup** parent, SkGroup** found, SkTDDrawableArray**grandList) {
+ SkGroup** parent, SkGroup** found, SkTDDrawableArray**grandList) {
*found = NULL;
for (int index = 0; index < (*list)->count(); index++) {
SkDrawable* draw = (**list)[index];
@@ -88,11 +88,11 @@
return index;
//perhaps should call SearchGroupForMatch here as well (on scope)
}
- }
+ }
}
- if (draw->isGroup() && SearchGroupForMatch(draw, match, list, parent, found, grandList, index))
+ if (draw->isGroup() && SearchGroupForMatch(draw, match, list, parent, found, grandList, index))
return index;
-
+
}
return -1;
}
@@ -120,7 +120,7 @@
continue;
SkApply* apply = (SkApply*) draw;
apply->reset();
- }
+ }
}
void SkDisplayList::remove(SkActive* active) {
diff --git a/src/animator/SkDisplayList.h b/src/animator/SkDisplayList.h
index f520b55..af98aef 100644
--- a/src/animator/SkDisplayList.h
+++ b/src/animator/SkDisplayList.h
@@ -35,8 +35,8 @@
static int fIndent;
static int fDumpIndex;
#endif
- int findGroup(SkDrawable* match, SkTDDrawableArray** list,
- SkGroup** parent, SkGroup** found, SkTDDrawableArray** grandList);
+ int findGroup(SkDrawable* match, SkTDDrawableArray** list,
+ SkGroup** parent, SkGroup** found, SkTDDrawableArray** grandList);
SkDrawable* get(int index) { return fDrawList[index]; }
SkMSec getTime() { return fInTime; }
SkTDDrawableArray* getDrawList() { return &fDrawList; }
@@ -51,8 +51,8 @@
#endif
static int SearchForMatch(SkDrawable* match, SkTDDrawableArray** list,
SkGroup** parent, SkGroup** found, SkTDDrawableArray**grandList);
- static bool SearchGroupForMatch(SkDrawable* draw, SkDrawable* match,
- SkTDDrawableArray** list, SkGroup** parent, SkGroup** found, SkTDDrawableArray** grandList,
+ static bool SearchGroupForMatch(SkDrawable* draw, SkDrawable* match,
+ SkTDDrawableArray** list, SkGroup** parent, SkGroup** found, SkTDDrawableArray** grandList,
int &index);
public:
SkIRect fBounds;
diff --git a/src/animator/SkDisplayMath.cpp b/src/animator/SkDisplayMath.cpp
index c4d496d..bdf377b 100644
--- a/src/animator/SkDisplayMath.cpp
+++ b/src/animator/SkDisplayMath.cpp
@@ -29,7 +29,7 @@
1.442695041f, // LOG2E
3.141592654f, // PI
0.707106781f, // SQRT1_2
- 1.414213562f // SQRT2
+ 1.414213562f // SQRT2
#else
0x2B7E1, // E
0x24D76, // LN10
@@ -139,7 +139,7 @@
DEFINE_GET_MEMBER(SkDisplayMath);
-void SkDisplayMath::executeFunction(SkDisplayable* target, int index,
+void SkDisplayMath::executeFunction(SkDisplayable* target, int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
SkScriptValue* scriptValue) {
if (scriptValue == NULL)
@@ -151,7 +151,7 @@
SkScalar scalarResult;
switch (index) {
case SK_FUNCTION(abs):
- scalarResult = SkScalarAbs(input);
+ scalarResult = SkScalarAbs(input);
break;
case SK_FUNCTION(acos):
scalarResult = SkScalarACos(input);
@@ -166,7 +166,7 @@
scalarResult = SkScalarATan2(input, parameters[1].fOperand.fScalar);
break;
case SK_FUNCTION(ceil):
- scalarResult = SkIntToScalar(SkScalarCeil(input));
+ scalarResult = SkIntToScalar(SkScalarCeil(input));
break;
case SK_FUNCTION(cos):
scalarResult = SkScalarCos(input);
@@ -175,7 +175,7 @@
scalarResult = SkScalarExp(input);
break;
case SK_FUNCTION(floor):
- scalarResult = SkIntToScalar(SkScalarFloor(input));
+ scalarResult = SkIntToScalar(SkScalarFloor(input));
break;
case SK_FUNCTION(log):
scalarResult = SkScalarLog(input);
@@ -204,7 +204,7 @@
scalarResult = fRandom.nextUScalar1();
break;
case SK_FUNCTION(round):
- scalarResult = SkIntToScalar(SkScalarRound(input));
+ scalarResult = SkIntToScalar(SkScalarRound(input));
break;
case SK_FUNCTION(sin):
scalarResult = SkScalarSin(input);
@@ -212,7 +212,7 @@
case SK_FUNCTION(sqrt): {
SkASSERT(parameters.count() == 1);
SkASSERT(type == SkType_Float);
- scalarResult = SkScalarSqrt(input);
+ scalarResult = SkScalarSqrt(input);
} break;
case SK_FUNCTION(tan):
scalarResult = SkScalarTan(input);
diff --git a/src/animator/SkDisplayMath.h b/src/animator/SkDisplayMath.h
index e21d03f..faa929e 100644
--- a/src/animator/SkDisplayMath.h
+++ b/src/animator/SkDisplayMath.h
@@ -16,7 +16,7 @@
class SkDisplayMath : public SkDisplayable {
DECLARE_DISPLAY_MEMBER_INFO(Math);
- virtual void executeFunction(SkDisplayable* , int index,
+ virtual void executeFunction(SkDisplayable* , int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
SkScriptValue* );
virtual const SkFunctionParamType* getFunctionsParameters();
@@ -27,6 +27,6 @@
static const SkFunctionParamType fFunctionParameters[];
};
-
+
#endif // SkDisplayMath_DEFINED
diff --git a/src/animator/SkDisplayMovie.cpp b/src/animator/SkDisplayMovie.cpp
index 4fbf3f3..33123cb 100644
--- a/src/animator/SkDisplayMovie.cpp
+++ b/src/animator/SkDisplayMovie.cpp
@@ -78,7 +78,7 @@
enable(maker);
maker.fCanvas->save();
SkPaint local = SkPaint(*maker.fPaint);
- bool result = fMovie.draw(maker.fCanvas, &local,
+ bool result = fMovie.draw(maker.fCanvas, &local,
maker.fDisplayList.getTime()) != SkAnimator::kNotDifferent;
maker.fDisplayList.fInvalBounds.join(fMovie.fMaker->fDisplayList.fInvalBounds);
maker.fCanvas->restore();
diff --git a/src/animator/SkDisplayNumber.h b/src/animator/SkDisplayNumber.h
index 7092e21..16c6f4f 100644
--- a/src/animator/SkDisplayNumber.h
+++ b/src/animator/SkDisplayNumber.h
@@ -18,5 +18,5 @@
virtual bool getProperty(int index, SkScriptValue* value) const;
private:
};
-
+
#endif // SkDisplayNumber_DEFINED
diff --git a/src/animator/SkDisplayPost.cpp b/src/animator/SkDisplayPost.cpp
index bf89055..3c9fa19 100644
--- a/src/animator/SkDisplayPost.cpp
+++ b/src/animator/SkDisplayPost.cpp
@@ -54,12 +54,12 @@
return true;
}
-bool SkPost::childrenNeedDisposing() const {
- return false;
+bool SkPost::childrenNeedDisposing() const {
+ return false;
}
-void SkPost::dirty() {
- fDirty = true;
+void SkPost::dirty() {
+ fDirty = true;
}
#ifdef SK_DUMP_ENABLED
@@ -74,7 +74,7 @@
else
SkDebugf("type=\"%s\" ", eventType->c_str());
delete eventType;
-
+
if (delay > 0) {
SkDebugf("delay=\"%g\" ", SkScalarToFloat(SkScalarDiv(delay, 1000)));
}
@@ -99,7 +99,7 @@
SkDisplayList::fIndent += 4;
//this seems to work, but kinda hacky
//for some reason the last part is id, which i don't want
- //and the parts seem to be in the reverse order from the one in which we find the
+ //and the parts seem to be in the reverse order from the one in which we find the
//data itself
//SkDataInput** ptr = fParts.end();
//SkDataInput* data;
@@ -211,7 +211,7 @@
SkAnimator* anim = maker.getAnimator();
if (targetID == 0) {
isAnimatorEvent = fEvent.findString("id") != NULL;
- if (isAnimatorEvent)
+ if (isAnimatorEvent)
targetID = anim->getSinkID();
else if (maker.fHostEventSinkID)
targetID = maker.fHostEventSinkID;
@@ -260,7 +260,7 @@
SkAnimator* anim = fTargetMaker->getAnimator();
fSinkID = anim->getSinkID();
}
-
+
bool SkPost::hasEnable() const {
return true;
}
@@ -274,8 +274,8 @@
}
}
-void SkPost::setChildHasID() {
- fChildHasID = true;
+void SkPost::setChildHasID() {
+ fChildHasID = true;
}
bool SkPost::setProperty(int index, SkScriptValue& value) {
diff --git a/src/animator/SkDisplayRandom.cpp b/src/animator/SkDisplayRandom.cpp
index 3f77fcb..31a20b5 100644
--- a/src/animator/SkDisplayRandom.cpp
+++ b/src/animator/SkDisplayRandom.cpp
@@ -37,7 +37,7 @@
dumpBase(maker);
SkDebugf("min=\"%g\" ", SkScalarToFloat(min));
SkDebugf("max=\"%g\" ", SkScalarToFloat(max));
- SkDebugf("blend=\"%g\" ", SkScalarToFloat(blend));
+ SkDebugf("blend=\"%g\" ", SkScalarToFloat(blend));
SkDebugf("/>\n");
}
#endif
diff --git a/src/animator/SkDisplayType.cpp b/src/animator/SkDisplayType.cpp
index 3527517..dc52f0c 100644
--- a/src/animator/SkDisplayType.cpp
+++ b/src/animator/SkDisplayType.cpp
@@ -67,7 +67,7 @@
#else
#define CASE_DEBUG_RETURN_NIL(_class)
#endif
-
+
SkDisplayTypes SkDisplayType::gNewTypes = kNumberOfTypes;
@@ -224,7 +224,7 @@
info = SkDisplay##_class::fInfo; infoCount = SkDisplay##_class::fInfoCount; \
break
-const SkMemberInfo* SkDisplayType::GetMembers(SkAnimateMaker* maker,
+const SkMemberInfo* SkDisplayType::GetMembers(SkAnimateMaker* maker,
SkDisplayTypes type, int* infoCountPtr) {
const SkMemberInfo* info = NULL;
int infoCount = 0;
@@ -355,7 +355,7 @@
CASE_GET_DRAW_INFO(Typeface);
// xfermode
// knumberoftypes
- default:
+ default:
if (maker) {
SkExtras** end = maker->fExtras.end();
for (SkExtras** extraPtr = maker->fExtras.begin(); extraPtr < end; extraPtr++) {
@@ -370,7 +370,7 @@
return info;
}
-const SkMemberInfo* SkDisplayType::GetMember(SkAnimateMaker* maker,
+const SkMemberInfo* SkDisplayType::GetMember(SkAnimateMaker* maker,
SkDisplayTypes type, const char** matchPtr ) {
int infoCount;
const SkMemberInfo* info = GetMembers(maker, type, &infoCount);
@@ -546,7 +546,7 @@
SkASSERT(info);
if (info->fType != SkType_BaseClassInfo)
return SkType_Unknown; // if no base, done
- // !!! could change SK_MEMBER_INHERITED macro to take type, stuff in offset, so that
+ // !!! could change SK_MEMBER_INHERITED macro to take type, stuff in offset, so that
// this (and table builder) could know type without the following steps:
const SkMemberInfo* inherited = info->getInherited();
SkDisplayTypes result = (SkDisplayTypes) (SkType_Unknown + 1);
@@ -560,7 +560,7 @@
}
SkDisplayTypes SkDisplayType::GetType(SkAnimateMaker* maker, const char match[], size_t len ) {
- int index = SkStrSearch(&gTypeNames[0].fName, kTypeNamesSize, match,
+ int index = SkStrSearch(&gTypeNames[0].fName, kTypeNamesSize, match,
len, sizeof(gTypeNames[0]));
if (index >= 0 && index < kTypeNamesSize)
return gTypeNames[index].fType;
diff --git a/src/animator/SkDisplayType.h b/src/animator/SkDisplayType.h
index 7abde23..474a65e 100644
--- a/src/animator/SkDisplayType.h
+++ b/src/animator/SkDisplayType.h
@@ -187,7 +187,7 @@
static SkDisplayTypes RegisterNewType();
static SkDisplayTypes Resolve(const char[] , const SkMemberInfo** );
#ifdef SK_DEBUG
- static bool IsAnimate(SkDisplayTypes type ) { return type == SkType_Animate ||
+ static bool IsAnimate(SkDisplayTypes type ) { return type == SkType_Animate ||
type == SkType_Set; }
static const char* GetName(SkAnimateMaker* , SkDisplayTypes );
#endif
diff --git a/src/animator/SkDisplayTypes.cpp b/src/animator/SkDisplayTypes.cpp
index d3bfa10..d320fc0 100644
--- a/src/animator/SkDisplayTypes.cpp
+++ b/src/animator/SkDisplayTypes.cpp
@@ -11,7 +11,7 @@
#include "SkAnimateBase.h"
bool SkDisplayDepend::canContainDependents() const {
- return true;
+ return true;
}
void SkDisplayDepend::dirty() {
@@ -118,7 +118,7 @@
SkDisplayString::SkDisplayString(SkString& copyFrom) : value(copyFrom) {
}
-void SkDisplayString::executeFunction(SkDisplayable* target, int index,
+void SkDisplayString::executeFunction(SkDisplayable* target, int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
SkScriptValue* scriptValue) {
if (scriptValue == NULL)
@@ -150,7 +150,7 @@
}
bool SkDisplayString::getProperty(int index, SkScriptValue* scriptValue) const {
- switch (index) {
+ switch (index) {
case SK_PROPERTY(length):
scriptValue->fType = SkType_Int;
scriptValue->fOperand.fS32 = (int32_t) value.size();
@@ -201,7 +201,7 @@
}
bool SkDisplayArray::getProperty(int index, SkScriptValue* value) const {
- switch (index) {
+ switch (index) {
case SK_PROPERTY(length):
value->fType = SkType_Int;
value->fOperand.fS32 = values.count();
diff --git a/src/animator/SkDisplayTypes.h b/src/animator/SkDisplayTypes.h
index 75cace6..614018f 100644
--- a/src/animator/SkDisplayTypes.h
+++ b/src/animator/SkDisplayTypes.h
@@ -75,7 +75,7 @@
DECLARE_DISPLAY_MEMBER_INFO(String);
SkDisplayString();
SkDisplayString(SkString& );
- virtual void executeFunction(SkDisplayable* , int index,
+ virtual void executeFunction(SkDisplayable* , int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
SkScriptValue* );
virtual const SkFunctionParamType* getFunctionsParameters();
diff --git a/src/animator/SkDisplayXMLParser.cpp b/src/animator/SkDisplayXMLParser.cpp
index 68dc259..31be3da 100644
--- a/src/animator/SkDisplayXMLParser.cpp
+++ b/src/animator/SkDisplayXMLParser.cpp
@@ -34,7 +34,7 @@
"last offset in gradient must be one",
"offsets in gradient must be increasing",
"first offset in gradient must be zero",
- "gradient attribute \"points\" must have length of four",
+ "gradient attribute \"points\" must have length of four",
"in include ",
"in movie ",
"include name unknown or missing ",
@@ -70,7 +70,7 @@
SkDisplayXMLParser::SkDisplayXMLParser(SkAnimateMaker& maker)
- : INHERITED(&maker.fError), fMaker(maker), fInInclude(maker.fInInclude),
+ : INHERITED(&maker.fError), fMaker(maker), fInInclude(maker.fInInclude),
fInSkia(maker.fInInclude), fCurrDisplayable(NULL)
{
}
@@ -94,7 +94,7 @@
return onAddAttributeLen(name, value, strlen(value));
}
-bool SkDisplayXMLParser::onAddAttributeLen(const char attrName[], const char attrValue[],
+bool SkDisplayXMLParser::onAddAttributeLen(const char attrName[], const char attrValue[],
size_t attrValueLen)
{
if (fCurrDisplayable == NULL) // this signals we should ignore attributes for this element
@@ -172,16 +172,16 @@
SkDisplayable* displayable = container.fDisplayable;
fMaker.fEndDepth = parentIndex;
displayable->onEndElement(fMaker);
- if (fMaker.fError.hasError())
+ if (fMaker.fError.hasError())
return true;
if (parentIndex > 0) {
SkDisplayable* parent = fParents[parentIndex - 1].fDisplayable;
bool result = parent->add(fMaker, displayable);
- if (fMaker.hasError())
+ if (fMaker.hasError())
return true;
if (result == false) {
int infoCount;
- const SkMemberInfo* info =
+ const SkMemberInfo* info =
SkDisplayType::GetMembers(&fMaker, fParents[parentIndex - 1].fType, &infoCount);
const SkMemberInfo* foundInfo;
if ((foundInfo = searchContainer(info, infoCount)) != NULL) {
@@ -213,7 +213,7 @@
SkDebugf("%s\n", debugOut.c_str());
#endif
fMaker.fEvents.doEvent(fMaker, SkDisplayEvent::kOnload, NULL);
- if (fMaker.fError.hasError())
+ if (fMaker.fError.hasError())
return true;
fMaker.fEvents.removeEvent(SkDisplayEvent::kOnload, NULL);
@@ -281,7 +281,7 @@
}
Parent* container = fParents.end() - 1;
SkDisplayTypes type = (SkDisplayTypes) info->fType;
- if (type == SkType_MemberProperty)
+ if (type == SkType_MemberProperty)
type = info->propertyType();
SkDisplayTypes containerType = container->fType;
if (type == containerType && (type == SkType_Rect || type == SkType_Polygon ||
@@ -296,7 +296,7 @@
}
return info;
next:
- if (type == SkType_Drawable || (type == SkType_Displayable &&
+ if (type == SkType_Drawable || (type == SkType_Displayable &&
container->fDisplayable->isDrawable())) {
rectNext:
if (fParents.count() > 1) {
diff --git a/src/animator/SkDisplayable.cpp b/src/animator/SkDisplayable.cpp
index 396ce6b..753764b 100644
--- a/src/animator/SkDisplayable.cpp
+++ b/src/animator/SkDisplayable.cpp
@@ -21,7 +21,7 @@
#endif
#ifdef SK_DEBUG
-SkDisplayable::SkDisplayable() {
+SkDisplayable::SkDisplayable() {
id = _id.c_str();
#ifdef SK_FIND_LEAKS
// fAllocationCount++;
@@ -40,20 +40,20 @@
}
bool SkDisplayable::add(SkAnimateMaker& , SkDisplayable* child) {
- return false;
+ return false;
}
-//void SkDisplayable::apply(SkAnimateMaker& , const SkMemberInfo* ,
-// SkDisplayable* , SkScalar [], int count) {
-// SkASSERT(0);
+//void SkDisplayable::apply(SkAnimateMaker& , const SkMemberInfo* ,
+// SkDisplayable* , SkScalar [], int count) {
+// SkASSERT(0);
//}
bool SkDisplayable::canContainDependents() const {
- return false;
+ return false;
}
-
-bool SkDisplayable::childrenNeedDisposing() const {
- return false;
+
+bool SkDisplayable::childrenNeedDisposing() const {
+ return false;
}
void SkDisplayable::clearBounder() {
@@ -170,18 +170,18 @@
//last two are dummies
dumpValues(info, value.fType, value.fOperand, blankValue.fOperand, value.fOperand, blankValue.fOperand);
}
-
+
propIndex++;
continue;
}
if (SkDisplayType::IsDisplayable(maker, info->fType)) {
continue;
}
-
+
if (info->fType == SkType_MemberFunction)
continue;
-
-
+
+
if (info->fType == SkType_Array) {
SkTDOperandArray* array = (SkTDOperandArray*) info->memberData(this);
int arrayCount;
@@ -201,14 +201,14 @@
case SkType_Displayable:
SkDebugf("%s", op->fDisplayable->id);
break;
- case SkType_Int:
+ case SkType_Int:
SkDebugf("%d", op->fS32);
break;
case SkType_Float:
SkDebugf("%g", SkScalarToFloat(op->fScalar));
break;
case SkType_String:
- case SkType_DynamicString:
+ case SkType_DynamicString:
SkDebugf("%s", op->fString->c_str());
break;
default:
@@ -219,16 +219,16 @@
SkDebugf("]\" ");
continue;
}
-
+
if (info->fType == SkType_String || info->fType == SkType_DynamicString) {
SkString* string;
info->getString(this, &string);
if (string->isEmpty() == false)
- SkDebugf("%s=\"%s\"\t", info->fName, string->c_str());
+ SkDebugf("%s=\"%s\"\t", info->fName, string->c_str());
continue;
}
-
-
+
+
blankInfo = blankCopy->getMember(index);
int i = info->fCount;
info->getValue(this, values, i);
@@ -252,7 +252,7 @@
}
void SkDisplayable::dumpChildren(SkAnimateMaker* maker, bool closedAngle) {
-
+
int index = -1;
const SkMemberInfo* info;
index = -1;
@@ -354,7 +354,7 @@
break;
case SkType_TileMode:
//correct to look at the S32?
- if (op.fS32 != blankOp.fS32)
+ if (op.fS32 != blankOp.fS32)
SkDebugf("%s=\"%s\" ", info->fName, op.fS32 == 0 ? "clamp" : op.fS32 == 1 ? "repeat" : "mirror");
break;
case SkType_Boolean:
@@ -372,7 +372,7 @@
break;
case SkType_String:
case SkType_DynamicString:
- if (op.fString->size() > 0)
+ if (op.fString->size() > 0)
SkDebugf("%s=\"%s\" ", info->fName, op.fString->c_str());
break;
case SkType_MSec:
@@ -381,24 +381,24 @@
}
default:
SkDebugf("");
- }
+ }
}
#endif
-bool SkDisplayable::enable( SkAnimateMaker& ) {
+bool SkDisplayable::enable( SkAnimateMaker& ) {
return false;
}
void SkDisplayable::enableBounder() {
}
-void SkDisplayable::executeFunction(SkDisplayable* , int index,
+void SkDisplayable::executeFunction(SkDisplayable* , int index,
SkTDArray<SkScriptValue>& , SkDisplayTypes, SkScriptValue* ) {
- SkASSERT(0);
+ SkASSERT(0);
}
-void SkDisplayable::executeFunction(SkDisplayable* target,
+void SkDisplayable::executeFunction(SkDisplayable* target,
const SkMemberInfo* info, SkTypedArray* values, SkScriptValue* value) {
SkTDArray<SkScriptValue> typedValues;
for (SkOperand* op = values->begin(); op < values->end(); op++) {
@@ -410,9 +410,9 @@
executeFunction(target, info->functionIndex(), typedValues, info->getType(), value);
}
-void SkDisplayable::executeFunction2(SkDisplayable* , int index,
+void SkDisplayable::executeFunction2(SkDisplayable* , int index,
SkOpArray* params, SkDisplayTypes, SkOperand2* ) {
- SkASSERT(0);
+ SkASSERT(0);
}
void SkDisplayable::getBounds(SkRect* rect) {
@@ -425,15 +425,15 @@
return NULL;
}
-const SkMemberInfo* SkDisplayable::getMember(int index) {
- return NULL;
+const SkMemberInfo* SkDisplayable::getMember(int index) {
+ return NULL;
}
-const SkMemberInfo* SkDisplayable::getMember(const char name[]) {
- return NULL;
+const SkMemberInfo* SkDisplayable::getMember(const char name[]) {
+ return NULL;
}
-const SkFunctionParamType* SkDisplayable::getParameters(const SkMemberInfo* info,
+const SkFunctionParamType* SkDisplayable::getParameters(const SkMemberInfo* info,
int* paramCount) {
const SkFunctionParamType* params = getFunctionsParameters();
SkASSERT(params != NULL);
@@ -460,17 +460,17 @@
}
bool SkDisplayable::getProperty(int index, SkScriptValue* ) const {
-// SkASSERT(0);
- return false;
+// SkASSERT(0);
+ return false;
}
bool SkDisplayable::getProperty2(int index, SkOperand2* value) const {
- SkASSERT(0);
- return false;
+ SkASSERT(0);
+ return false;
}
-SkDisplayTypes SkDisplayable::getType() const {
- return SkType_Unknown;
+SkDisplayTypes SkDisplayable::getType() const {
+ return SkType_Unknown;
}
bool SkDisplayable::hasEnable() const {
@@ -478,7 +478,7 @@
}
bool SkDisplayable::isDrawable() const {
- return false;
+ return false;
}
void SkDisplayable::onEndElement(SkAnimateMaker& ) {}
@@ -491,8 +491,8 @@
return false;
}
-//SkDisplayable* SkDisplayable::resolveTarget(SkAnimateMaker& ) {
-// return this;
+//SkDisplayable* SkDisplayable::resolveTarget(SkAnimateMaker& ) {
+// return this;
//}
void SkDisplayable::setChildHasID() {
@@ -503,8 +503,8 @@
}
bool SkDisplayable::setProperty(int index, SkScriptValue& ) {
- //SkASSERT(0);
- return false;
+ //SkASSERT(0);
+ return false;
}
void SkDisplayable::setReference(const SkMemberInfo* info, SkDisplayable* displayable) {
diff --git a/src/animator/SkDisplayable.h b/src/animator/SkDisplayable.h
index a3db002..5fc2d3e 100644
--- a/src/animator/SkDisplayable.h
+++ b/src/animator/SkDisplayable.h
@@ -50,30 +50,30 @@
#endif
virtual bool enable( SkAnimateMaker& );
virtual void enableBounder();
- virtual void executeFunction(SkDisplayable* , int functionIndex,
- SkTDArray<SkScriptValue>& , SkDisplayTypes , SkScriptValue* );
- void executeFunction(SkDisplayable* , const SkMemberInfo* ,
- SkTypedArray* , SkScriptValue* );
- virtual void executeFunction2(SkDisplayable* , int functionIndex,
+ virtual void executeFunction(SkDisplayable* , int functionIndex,
+ SkTDArray<SkScriptValue>& , SkDisplayTypes , SkScriptValue* );
+ void executeFunction(SkDisplayable* , const SkMemberInfo* ,
+ SkTypedArray* , SkScriptValue* );
+ virtual void executeFunction2(SkDisplayable* , int functionIndex,
SkOpArray* params , SkDisplayTypes , SkOperand2* ); // compiled scripting experiment
virtual void getBounds(SkRect* );
virtual const SkFunctionParamType* getFunctionsParameters();
virtual const SkMemberInfo* getMember(int index);
virtual const SkMemberInfo* getMember(const char name[]);
- const SkFunctionParamType* getParameters(const SkMemberInfo* info,
+ const SkFunctionParamType* getParameters(const SkMemberInfo* info,
int* paramCount);
virtual SkDisplayable* getParent() const;
virtual bool getProperty(int index, SkScriptValue* value) const;
virtual bool getProperty2(int index, SkOperand2* value) const; // compiled scripting experiment
virtual SkDisplayTypes getType() const;
virtual bool hasEnable() const;
- bool isAnimate() const {
- SkDisplayTypes type = getType();
+ bool isAnimate() const {
+ SkDisplayTypes type = getType();
return type == SkType_Animate || type == SkType_Set; }
bool isApply() const { return getType() == SkType_Apply; }
bool isColor() const { return getType() == SkType_Color; }
virtual bool isDrawable() const;
- bool isGroup() const { return getType() == SkType_Group ||
+ bool isGroup() const { return getType() == SkType_Group ||
getType() == SkType_Save || getType() == SkType_DrawTo ||
getType() == SkType_SaveLayer; }
bool isMatrix() const { return getType() == SkType_Matrix; }
diff --git a/src/animator/SkDraw3D.cpp b/src/animator/SkDraw3D.cpp
index ce2bec4..6ec178f 100644
--- a/src/animator/SkDraw3D.cpp
+++ b/src/animator/SkDraw3D.cpp
@@ -25,7 +25,7 @@
DEFINE_NO_VIRTUALS_GET_MEMBER(Sk3D_Point);
Sk3D_Point::Sk3D_Point() {
- fPoint.set(0, 0, 0);
+ fPoint.set(0, 0, 0);
}
#if SK_USE_CONDENSED_INFO == 0
@@ -85,7 +85,7 @@
DEFINE_GET_MEMBER(Sk3D_Patch);
-void Sk3D_Patch::executeFunction(SkDisplayable* target, int index,
+void Sk3D_Patch::executeFunction(SkDisplayable* target, int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
SkScriptValue* ) {
SkASSERT(target == this);
@@ -93,7 +93,7 @@
case SK_FUNCTION(rotateDegrees):
SkASSERT(parameters.count() == 3);
SkASSERT(type == SkType_Float);
- fPatch.rotateDegrees(parameters[0].fOperand.fScalar,
+ fPatch.rotateDegrees(parameters[0].fOperand.fScalar,
parameters[1].fOperand.fScalar, parameters[2].fOperand.fScalar);
break;
default:
diff --git a/src/animator/SkDraw3D.h b/src/animator/SkDraw3D.h
index e6549ea..f4bd82b 100644
--- a/src/animator/SkDraw3D.h
+++ b/src/animator/SkDraw3D.h
@@ -38,7 +38,7 @@
class Sk3D_Patch : public SkDisplayable {
DECLARE_MEMBER_INFO(3D_Patch);
private:
- virtual void executeFunction(SkDisplayable* , int index,
+ virtual void executeFunction(SkDisplayable* , int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
SkScriptValue* );
virtual const SkFunctionParamType* getFunctionsParameters();
diff --git a/src/animator/SkDrawBitmap.cpp b/src/animator/SkDrawBitmap.cpp
index 420045a..4604a71 100644
--- a/src/animator/SkDrawBitmap.cpp
+++ b/src/animator/SkDrawBitmap.cpp
@@ -56,7 +56,7 @@
DEFINE_GET_MEMBER(SkDrawBitmap);
-SkDrawBitmap::SkDrawBitmap() : format((SkBitmap::Config) -1), height(-1),
+SkDrawBitmap::SkDrawBitmap() : format((SkBitmap::Config) -1), height(-1),
rowBytes(0), width(-1), fColor(0), fColorSet(false) {
}
@@ -137,7 +137,7 @@
}
SkImageBaseBitmap::~SkImageBaseBitmap() {
- delete[] base64.fData;
+ delete[] base64.fData;
}
SkDisplayable* SkImageBaseBitmap::deepCopy(SkAnimateMaker* maker) {
@@ -151,13 +151,13 @@
}
bool SkImageBaseBitmap::draw(SkAnimateMaker& maker) {
- if (fDirty)
+ if (fDirty)
resolve();
return INHERITED::draw(maker);
}
bool SkImageBaseBitmap::getProperty(int index, SkScriptValue* value) const {
- if (fDirty)
+ if (fDirty)
resolve();
switch (index) {
case SK_PROPERTY(height):
@@ -188,11 +188,11 @@
return;
fLast.set(src);
fBitmap.reset();
-
+
//SkStream* stream = SkStream::GetURIStream(fUriBase, src.c_str());
SkStream* stream = new SkFILEStream(src.c_str());
SkAutoTDelete<SkStream> autoDel(stream);
SkImageDecoder::DecodeStream(stream, &fBitmap);
- }
+ }
}
diff --git a/src/animator/SkDrawBitmap.h b/src/animator/SkDrawBitmap.h
index 927c33b..f9a9212 100644
--- a/src/animator/SkDrawBitmap.h
+++ b/src/animator/SkDrawBitmap.h
@@ -65,7 +65,7 @@
protected:
SkBase64 base64;
SkString src;
- SkString fLast; // cache of src so that stream isn't unnecessarily decoded
+ SkString fLast; // cache of src so that stream isn't unnecessarily decoded
SkBool fDirty;
const char* fUriBase;
typedef SkBaseBitmap INHERITED;
diff --git a/src/animator/SkDrawBlur.cpp b/src/animator/SkDrawBlur.cpp
index 57e8e20..68996bc 100644
--- a/src/animator/SkDrawBlur.cpp
+++ b/src/animator/SkDrawBlur.cpp
@@ -20,7 +20,7 @@
DEFINE_GET_MEMBER(SkDrawBlur);
-SkDrawBlur::SkDrawBlur() : radius(-1),
+SkDrawBlur::SkDrawBlur() : radius(-1),
blurStyle(SkBlurMaskFilter::kNormal_BlurStyle) {
}
diff --git a/src/animator/SkDrawColor.cpp b/src/animator/SkDrawColor.cpp
index 9abc8d0..dfe0622 100644
--- a/src/animator/SkDrawColor.cpp
+++ b/src/animator/SkDrawColor.cpp
@@ -73,7 +73,7 @@
SkScalar fraction = hue / 60 - SkIntToScalar(sextant);
SkScalar p = SkScalarMul(value , SK_Scalar1 - saturation);
SkScalar q = SkScalarMul(value, SK_Scalar1 - SkScalarMul(saturation, fraction));
- SkScalar t = SkScalarMul(value, SK_Scalar1 -
+ SkScalar t = SkScalarMul(value, SK_Scalar1 -
SkScalarMul(saturation, SK_Scalar1 - fraction));
switch (sextant % 6) {
case 0: red = value; green = t; blue = p; break;
@@ -85,11 +85,11 @@
}
}
//used to say SkToU8((U8CPU) red) etc
- return SkColorSetARGB(SkColorGetA(color), SkScalarRound(red),
+ return SkColorSetARGB(SkColorGetA(color), SkScalarRound(red),
SkScalarRound(green), SkScalarRound(blue));
}
-#if defined _WIN32 && _MSC_VER >= 1300
+#if defined _WIN32 && _MSC_VER >= 1300
#pragma warning ( pop )
#endif
@@ -120,8 +120,8 @@
DEFINE_GET_MEMBER(SkDrawColor);
-SkDrawColor::SkDrawColor() : fDirty(false) {
- color = SK_ColorBLACK;
+SkDrawColor::SkDrawColor() : fDirty(false) {
+ color = SK_ColorBLACK;
fHue = fSaturation = fValue = SK_ScalarNaN;
}
@@ -150,13 +150,13 @@
#ifdef SK_DUMP_ENABLED
void SkDrawColor::dump(SkAnimateMaker* maker) {
dumpBase(maker);
- SkDebugf("alpha=\"%d\" red=\"%d\" green=\"%d\" blue=\"%d\" />\n",
+ SkDebugf("alpha=\"%d\" red=\"%d\" green=\"%d\" blue=\"%d\" />\n",
SkColorGetA(color)/255, SkColorGetR(color),
SkColorGetG(color), SkColorGetB(color));
}
#endif
-SkColor SkDrawColor::getColor() {
+SkColor SkDrawColor::getColor() {
if (fDirty) {
if (SkScalarIsNaN(fValue) == false)
color = HSV_to_RGB(color, kGetValue, fValue);
@@ -166,7 +166,7 @@
color = HSV_to_RGB(color, kGetHue, fHue);
fDirty = false;
}
- return color;
+ return color;
}
SkDisplayable* SkDrawColor::getParent() const {
@@ -231,17 +231,17 @@
#else
alpha = SkToU8((scalar - (scalar >= SK_ScalarHalf)) >> 8);
#endif
- color = SkColorSetARGB(alpha, SkColorGetR(color),
+ color = SkColorSetARGB(alpha, SkColorGetR(color),
SkColorGetG(color), SkColorGetB(color));
break;
case SK_PROPERTY(blue):
scalar = SkScalarClampMax(scalar, 255 * SK_Scalar1);
- color = SkColorSetARGB(SkColorGetA(color), SkColorGetR(color),
+ color = SkColorSetARGB(SkColorGetA(color), SkColorGetR(color),
SkColorGetG(color), SkToU8((U8CPU) scalar));
break;
case SK_PROPERTY(green):
scalar = SkScalarClampMax(scalar, 255 * SK_Scalar1);
- color = SkColorSetARGB(SkColorGetA(color), SkColorGetR(color),
+ color = SkColorSetARGB(SkColorGetA(color), SkColorGetR(color),
SkToU8((U8CPU) scalar), SkColorGetB(color));
break;
case SK_PROPERTY(hue):
@@ -250,7 +250,7 @@
break;
case SK_PROPERTY(red):
scalar = SkScalarClampMax(scalar, 255 * SK_Scalar1);
- color = SkColorSetARGB(SkColorGetA(color), SkToU8((U8CPU) scalar),
+ color = SkColorSetARGB(SkColorGetA(color), SkToU8((U8CPU) scalar),
SkColorGetG(color), SkColorGetB(color));
break;
case SK_PROPERTY(saturation):
diff --git a/src/animator/SkDrawEmboss.cpp b/src/animator/SkDrawEmboss.cpp
index 2284504..7e47ec2 100644
--- a/src/animator/SkDrawEmboss.cpp
+++ b/src/animator/SkDrawEmboss.cpp
@@ -22,7 +22,7 @@
DEFINE_GET_MEMBER(SkDrawEmboss);
-SkDrawEmboss::SkDrawEmboss() : radius(-1) {
+SkDrawEmboss::SkDrawEmboss() : radius(-1) {
direction.setCount(3);
}
diff --git a/src/animator/SkDrawGradient.cpp b/src/animator/SkDrawGradient.cpp
index 9e29074..2e751ca 100644
--- a/src/animator/SkDrawGradient.cpp
+++ b/src/animator/SkDrawGradient.cpp
@@ -34,16 +34,16 @@
public:
SkDrawGradientUnitMapper(SkAnimateMaker* maker, const char* script) : fMaker(maker), fScript(script) {
}
-
+
SK_DECLARE_UNFLATTENABLE_OBJECT()
-
+
protected:
virtual uint16_t mapUnit16(uint16_t x) {
fUnit = SkUnitToScalar(x);
SkScriptValue value;
SkAnimatorScript engine(*fMaker, NULL, SkType_Float);
engine.propertyCallBack(GetUnitValue, &fUnit);
- if (engine.evaluate(fScript, &value, SkType_Float))
+ if (engine.evaluate(fScript, &value, SkType_Float))
x = SkScalarToUnit(value.fOperand.fScalar);
return x;
}
@@ -79,7 +79,7 @@
}
SkDrawGradient::~SkDrawGradient() {
- for (int index = 0; index < fDrawColors.count(); index++)
+ for (int index = 0; index < fDrawColors.count(); index++)
delete fDrawColors[index];
delete fUnitMapper;
}
@@ -97,7 +97,7 @@
int SkDrawGradient::addPrelude() {
int count = fDrawColors.count();
fColors.setCount(count);
- for (int index = 0; index < count; index++)
+ for (int index = 0; index < count; index++)
fColors[index] = fDrawColors[index]->color;
return count;
}
@@ -116,7 +116,7 @@
SkDrawColor* color = *ptr;
color->dump(maker);
}
- SkDisplayList::fIndent -= 4;
+ SkDisplayList::fIndent -= 4;
dumpChildren(maker, closedYet); //dumps the matrix if it has one
}
#endif
@@ -146,7 +146,7 @@
}
}
}
- if (unitMapper.size() > 0)
+ if (unitMapper.size() > 0)
fUnitMapper = new SkDrawGradientUnitMapper(&maker, unitMapper.c_str());
INHERITED::onEndElement(maker);
}
@@ -162,7 +162,7 @@
DEFINE_GET_MEMBER(SkDrawLinearGradient);
-SkDrawLinearGradient::SkDrawLinearGradient() {
+SkDrawLinearGradient::SkDrawLinearGradient() {
}
void SkDrawLinearGradient::onEndElement(SkAnimateMaker& maker)
@@ -203,8 +203,8 @@
DEFINE_GET_MEMBER(SkDrawRadialGradient);
-SkDrawRadialGradient::SkDrawRadialGradient() : radius(0) {
- center.set(0, 0);
+SkDrawRadialGradient::SkDrawRadialGradient() : radius(0) {
+ center.set(0, 0);
}
#ifdef SK_DUMP_ENABLED
diff --git a/src/animator/SkDrawGradient.h b/src/animator/SkDrawGradient.h
index 09eb405..d01ee70 100644
--- a/src/animator/SkDrawGradient.h
+++ b/src/animator/SkDrawGradient.h
@@ -23,7 +23,7 @@
virtual bool add(SkAnimateMaker& , SkDisplayable* child);
#ifdef SK_DUMP_ENABLED
virtual void dumpRest(SkAnimateMaker*);
-#endif
+#endif
virtual void onEndElement(SkAnimateMaker& );
protected:
SkTDScalarArray offsets;
@@ -55,7 +55,7 @@
SkDrawRadialGradient();
#ifdef SK_DUMP_ENABLED
virtual void dump(SkAnimateMaker*);
-#endif
+#endif
virtual SkShader* getShader();
protected:
SkPoint center;
diff --git a/src/animator/SkDrawGroup.cpp b/src/animator/SkDrawGroup.cpp
index 939bd9f..806da5e 100644
--- a/src/animator/SkDrawGroup.cpp
+++ b/src/animator/SkDrawGroup.cpp
@@ -50,7 +50,7 @@
}
bool SkGroup::add(SkAnimateMaker& , SkDisplayable* child) {
- SkASSERT(child);
+ SkASSERT(child);
// SkASSERT(child->isDrawable());
*fChildren.append() = (SkDrawable*) child;
if (child->isGroup()) {
diff --git a/src/animator/SkDrawLine.cpp b/src/animator/SkDrawLine.cpp
index fe93c4e..d0ae7d9 100644
--- a/src/animator/SkDrawLine.cpp
+++ b/src/animator/SkDrawLine.cpp
@@ -25,7 +25,7 @@
DEFINE_GET_MEMBER(SkLine);
-SkLine::SkLine() : x1(0), x2(0), y1(0), y2(0) {
+SkLine::SkLine() : x1(0), x2(0), y1(0), y2(0) {
}
bool SkLine::draw(SkAnimateMaker& maker) {
diff --git a/src/animator/SkDrawMatrix.cpp b/src/animator/SkDrawMatrix.cpp
index 96e8292..1d7b3e0 100644
--- a/src/animator/SkDrawMatrix.cpp
+++ b/src/animator/SkDrawMatrix.cpp
@@ -51,9 +51,9 @@
DEFINE_GET_MEMBER(SkDrawMatrix);
-SkDrawMatrix::SkDrawMatrix() : fChildHasID(false), fDirty(false) {
+SkDrawMatrix::SkDrawMatrix() : fChildHasID(false), fDirty(false) {
fConcat.reset();
- fMatrix.reset();
+ fMatrix.reset();
}
SkDrawMatrix::~SkDrawMatrix() {
@@ -66,11 +66,11 @@
SkMatrixPart* part = (SkMatrixPart*) child;
*fParts.append() = part;
if (part->add())
- maker.setErrorCode(SkDisplayXMLParserError::kErrorAddingToMatrix);
+ maker.setErrorCode(SkDisplayXMLParserError::kErrorAddingToMatrix);
return true;
}
-bool SkDrawMatrix::childrenNeedDisposing() const {
+bool SkDrawMatrix::childrenNeedDisposing() const {
return false;
}
@@ -83,8 +83,8 @@
return copy;
}
-void SkDrawMatrix::dirty() {
- fDirty = true;
+void SkDrawMatrix::dirty() {
+ fDirty = true;
}
bool SkDrawMatrix::draw(SkAnimateMaker& maker) {
@@ -207,8 +207,8 @@
}
}
-void SkDrawMatrix::setChildHasID() {
- fChildHasID = true;
+void SkDrawMatrix::setChildHasID() {
+ fChildHasID = true;
}
bool SkDrawMatrix::setProperty(int index, SkScriptValue& scriptValue) {
diff --git a/src/animator/SkDrawPaint.h b/src/animator/SkDrawPaint.h
index a2a893e..db95d34 100644
--- a/src/animator/SkDrawPaint.h
+++ b/src/animator/SkDrawPaint.h
@@ -32,7 +32,7 @@
#ifdef SK_DUMP_ENABLED
virtual void dump(SkAnimateMaker* );
#endif
- virtual void executeFunction(SkDisplayable* target, int index,
+ virtual void executeFunction(SkDisplayable* target, int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
SkScriptValue* );
virtual const SkFunctionParamType* getFunctionsParameters();
diff --git a/src/animator/SkDrawPath.cpp b/src/animator/SkDrawPath.cpp
index 10e9203..81cbdb1 100644
--- a/src/animator/SkDrawPath.cpp
+++ b/src/animator/SkDrawPath.cpp
@@ -50,17 +50,17 @@
SkPathPart* part = (SkPathPart*) child;
*fParts.append() = part;
if (part->add())
- maker.setErrorCode(SkDisplayXMLParserError::kErrorAddingToPath);
+ maker.setErrorCode(SkDisplayXMLParserError::kErrorAddingToPath);
fDirty = false;
return true;
}
-bool SkDrawPath::childrenNeedDisposing() const {
- return false;
+bool SkDrawPath::childrenNeedDisposing() const {
+ return false;
}
-void SkDrawPath::dirty() {
- fDirty = true;
+void SkDrawPath::dirty() {
+ fDirty = true;
fLength = SK_ScalarNaN;
if (fParent)
fParent->dirty();
@@ -115,7 +115,7 @@
fDirty = false;
return fPath;
}
-
+
void SkDrawPath::onEndElement(SkAnimateMaker& ) {
if (d.size() > 0) {
parseSVG();
@@ -153,8 +153,8 @@
return true;
}
-void SkDrawPath::setChildHasID() {
- fChildHasID = true;
+void SkDrawPath::setChildHasID() {
+ fChildHasID = true;
}
bool SkDrawPath::setParent(SkDisplayable* parent) {
@@ -189,7 +189,7 @@
DEFINE_GET_MEMBER(SkPolyline);
bool SkPolyline::add(SkAnimateMaker& , SkDisplayable*) const {
- return false;
+ return false;
}
void SkPolyline::onEndElement(SkAnimateMaker& maker) {
diff --git a/src/animator/SkDrawPoint.cpp b/src/animator/SkDrawPoint.cpp
index 94fe4d2..66d2b4e 100644
--- a/src/animator/SkDrawPoint.cpp
+++ b/src/animator/SkDrawPoint.cpp
@@ -34,8 +34,8 @@
DEFINE_GET_MEMBER(SkDrawPoint);
-SkDrawPoint::SkDrawPoint() {
- fPoint.set(0, 0);
+SkDrawPoint::SkDrawPoint() {
+ fPoint.set(0, 0);
}
void SkDrawPoint::getBounds(SkRect* rect ) {
diff --git a/src/animator/SkDrawRectangle.cpp b/src/animator/SkDrawRectangle.cpp
index 19edf50..7587e4b 100644
--- a/src/animator/SkDrawRectangle.cpp
+++ b/src/animator/SkDrawRectangle.cpp
@@ -36,8 +36,8 @@
DEFINE_GET_MEMBER(SkDrawRect);
-SkDrawRect::SkDrawRect() : fParent(NULL) {
- fRect.setEmpty();
+SkDrawRect::SkDrawRect() : fParent(NULL) {
+ fRect.setEmpty();
}
void SkDrawRect::dirty() {
diff --git a/src/animator/SkDrawRectangle.h b/src/animator/SkDrawRectangle.h
index 49c9cf4..321c4ee 100644
--- a/src/animator/SkDrawRectangle.h
+++ b/src/animator/SkDrawRectangle.h
@@ -44,7 +44,7 @@
virtual bool draw(SkAnimateMaker& );
#ifdef SK_DUMP_ENABLED
virtual void dump(SkAnimateMaker* );
-#endif
+#endif
protected:
SkScalar rx;
SkScalar ry;
diff --git a/src/animator/SkDrawSaveLayer.cpp b/src/animator/SkDrawSaveLayer.cpp
index a7592db..43ec5c1 100644
--- a/src/animator/SkDrawSaveLayer.cpp
+++ b/src/animator/SkDrawSaveLayer.cpp
@@ -35,7 +35,7 @@
if (!bounds) {
return false;
}
- SkPaint* save = maker.fPaint;
+ SkPaint* save = maker.fPaint;
//paint is an SkDrawPaint
if (paint)
{
diff --git a/src/animator/SkDrawShader.cpp b/src/animator/SkDrawShader.cpp
index 5019622..e3aa4da 100644
--- a/src/animator/SkDrawShader.cpp
+++ b/src/animator/SkDrawShader.cpp
@@ -24,7 +24,7 @@
DEFINE_GET_MEMBER(SkDrawShader);
-SkDrawShader::SkDrawShader() : matrix(NULL),
+SkDrawShader::SkDrawShader() : matrix(NULL),
tileMode(SkShader::kClamp_TileMode) {
}
@@ -66,14 +66,14 @@
SkShader* SkDrawBitmapShader::getShader() {
if (image == NULL)
return NULL;
-
+
// note: bitmap shader now supports independent tile modes for X and Y
// we pass the same to both, but later we should extend this flexibility
// to the xml (e.g. tileModeX="repeat" tileModeY="clmap")
- //
+ //
// oops, bitmapshader no longer takes filterBitmap, but deduces it at
- // draw-time from the paint
- SkShader* shader = SkShader::CreateBitmapShader(image->fBitmap,
+ // draw-time from the paint
+ SkShader* shader = SkShader::CreateBitmapShader(image->fBitmap,
(SkShader::TileMode) tileMode,
(SkShader::TileMode) tileMode);
SkAutoTDelete<SkShader> autoDel(shader);
diff --git a/src/animator/SkDrawText.h b/src/animator/SkDrawText.h
index 7dd2e26..3ac2479 100644
--- a/src/animator/SkDrawText.h
+++ b/src/animator/SkDrawText.h
@@ -21,7 +21,7 @@
#ifdef SK_DUMP_ENABLED
virtual void dump(SkAnimateMaker* );
#endif
- virtual bool getProperty(int index, SkScriptValue* value) const ;
+ virtual bool getProperty(int index, SkScriptValue* value) const ;
const char* getText() { return text.c_str(); }
size_t getSize() { return text.size(); }
protected:
diff --git a/src/animator/SkDrawTextBox.cpp b/src/animator/SkDrawTextBox.cpp
index d97dc5c..f920e8e 100644
--- a/src/animator/SkDrawTextBox.cpp
+++ b/src/animator/SkDrawTextBox.cpp
@@ -47,7 +47,7 @@
{
dumpBase(maker);
dumpAttrs(maker);
- if (mode == 0)
+ if (mode == 0)
SkDebugf("mode=\"oneLine\" ");
if (spacingAlign == 1)
SkDebugf("spacingAlign=\"center\" ");
diff --git a/src/animator/SkDrawable.cpp b/src/animator/SkDrawable.cpp
index 8db0333..9e80c9d 100644
--- a/src/animator/SkDrawable.cpp
+++ b/src/animator/SkDrawable.cpp
@@ -13,8 +13,8 @@
return false;
}
-bool SkDrawable::isDrawable() const {
- return true;
+bool SkDrawable::isDrawable() const {
+ return true;
}
void SkDrawable::initialize() {
diff --git a/src/animator/SkDrawable.h b/src/animator/SkDrawable.h
index 139ce85..6bb9608 100644
--- a/src/animator/SkDrawable.h
+++ b/src/animator/SkDrawable.h
@@ -19,7 +19,7 @@
class SkDrawable : public SkDisplayable {
public:
virtual bool doEvent(SkDisplayEvent::Kind , SkEventState* state );
- virtual bool draw(SkAnimateMaker& ) = 0;
+ virtual bool draw(SkAnimateMaker& ) = 0;
virtual void initialize();
virtual bool isDrawable() const;
virtual void setSteps(int steps);
diff --git a/src/animator/SkDump.cpp b/src/animator/SkDump.cpp
index bd91277..563b0e1 100644
--- a/src/animator/SkDump.cpp
+++ b/src/animator/SkDump.cpp
@@ -144,7 +144,7 @@
}
bool SkDump::setProperty(int index, SkScriptValue& ) {
- return index <= SK_PROPERTY(posts);
+ return index <= SK_PROPERTY(posts);
}
#endif
diff --git a/src/animator/SkGetCondensedInfo.cpp b/src/animator/SkGetCondensedInfo.cpp
index a583cef..6d83b1d 100644
--- a/src/animator/SkGetCondensedInfo.cpp
+++ b/src/animator/SkGetCondensedInfo.cpp
@@ -26,7 +26,7 @@
int mid = (hi + lo) >> 1;
if (strcmp(&strings[lengths[mid << 2]], target) < 0)
lo = mid + 1;
- else
+ else
hi = mid;
}
if (strcmp(&strings[lengths[hi << 2]], target) != 0)
diff --git a/src/animator/SkIntArray.h b/src/animator/SkIntArray.h
index 6769a9e..4dac75a 100644
--- a/src/animator/SkIntArray.h
+++ b/src/animator/SkIntArray.h
@@ -36,21 +36,21 @@
typedef SkIntArray(SkMSec) SkTDMSecArray;
typedef SkIntArray(SkScalar) SkTDScalarArray;
-typedef SkLongArray(SkActive*) SkTDActiveArray;
-typedef SkLongArray(SkAnimateBase*) SkTDAnimateArray;
-typedef SkLongArray(SkDataInput*) SkTDDataArray;
-typedef SkLongArray(SkDisplayable*) SkTDDisplayableArray;
-typedef SkLongArray(SkDisplayEvent*) SkTDDisplayEventArray;
-typedef SkLongArray(SkDrawable*) SkTDDrawableArray;
-typedef SkLongArray(SkDrawColor*) SkTDDrawColorArray;
-typedef SkLongArray(SkMatrixPart*) SkTDMatrixPartArray;
+typedef SkLongArray(SkActive*) SkTDActiveArray;
+typedef SkLongArray(SkAnimateBase*) SkTDAnimateArray;
+typedef SkLongArray(SkDataInput*) SkTDDataArray;
+typedef SkLongArray(SkDisplayable*) SkTDDisplayableArray;
+typedef SkLongArray(SkDisplayEvent*) SkTDDisplayEventArray;
+typedef SkLongArray(SkDrawable*) SkTDDrawableArray;
+typedef SkLongArray(SkDrawColor*) SkTDDrawColorArray;
+typedef SkLongArray(SkMatrixPart*) SkTDMatrixPartArray;
typedef SkLongArray(const SkMemberInfo*) SkTDMemberInfoArray;
-typedef SkLongArray(SkPaintPart*) SkTDPaintPartArray;
-typedef SkLongArray(SkPathPart*) SkTDPathPartArray;
-typedef SkLongArray(SkTypedArray*) SkTDTypedArrayArray;
-typedef SkLongArray(SkString*) SkTDStringArray;
-typedef SkLongArray(SkOperand) SkTDOperandArray;
-typedef SkLongArray(SkOperand*) SkTDOperandPtrArray;
+typedef SkLongArray(SkPaintPart*) SkTDPaintPartArray;
+typedef SkLongArray(SkPathPart*) SkTDPathPartArray;
+typedef SkLongArray(SkTypedArray*) SkTDTypedArrayArray;
+typedef SkLongArray(SkString*) SkTDStringArray;
+typedef SkLongArray(SkOperand) SkTDOperandArray;
+typedef SkLongArray(SkOperand*) SkTDOperandPtrArray;
#endif // SkIntArray_DEFINED
diff --git a/src/animator/SkMatrixParts.cpp b/src/animator/SkMatrixParts.cpp
index f00bb8e..221ac0a 100644
--- a/src/animator/SkMatrixParts.cpp
+++ b/src/animator/SkMatrixParts.cpp
@@ -16,8 +16,8 @@
SkMatrixPart::SkMatrixPart() : fMatrix(NULL) {
}
-void SkMatrixPart::dirty() {
- fMatrix->dirty();
+void SkMatrixPart::dirty() {
+ fMatrix->dirty();
}
SkDisplayable* SkMatrixPart::getParent() const {
@@ -44,8 +44,8 @@
DEFINE_GET_MEMBER(SkRotate);
-SkRotate::SkRotate() : degrees(0) {
- center.fX = center.fY = 0;
+SkRotate::SkRotate() : degrees(0) {
+ center.fX = center.fY = 0;
}
bool SkRotate::add() {
@@ -66,12 +66,12 @@
DEFINE_GET_MEMBER(SkScale);
-SkScale::SkScale() : x(SK_Scalar1), y(SK_Scalar1) {
- center.fX = center.fY = 0;
+SkScale::SkScale() : x(SK_Scalar1), y(SK_Scalar1) {
+ center.fX = center.fY = 0;
}
bool SkScale::add() {
- fMatrix->scale(x, y, center);
+ fMatrix->scale(x, y, center);
return false;
}
@@ -88,12 +88,12 @@
DEFINE_GET_MEMBER(SkSkew);
-SkSkew::SkSkew() : x(0), y(0) {
- center.fX = center.fY = 0;
+SkSkew::SkSkew() : x(0), y(0) {
+ center.fX = center.fY = 0;
}
bool SkSkew::add() {
- fMatrix->skew(x, y, center);
+ fMatrix->skew(x, y, center);
return false;
}
@@ -113,7 +113,7 @@
}
bool SkTranslate::add() {
- fMatrix->translate(x, y);
+ fMatrix->translate(x, y);
return false;
}
@@ -130,7 +130,7 @@
DEFINE_GET_MEMBER(SkFromPath);
-SkFromPath::SkFromPath() :
+SkFromPath::SkFromPath() :
mode(0), offset(0), path(NULL) {
}
@@ -166,7 +166,7 @@
DEFINE_GET_MEMBER(SkRectToRect);
-SkRectToRect::SkRectToRect() :
+SkRectToRect::SkRectToRect() :
source(NULL), destination(NULL) {
}
@@ -200,7 +200,7 @@
SkDisplayList::fIndent += 4;
destination->dump(maker);
SkDisplayList::fIndent -= 4;
- SkDebugf("%*s</destination>\n", SkDisplayList::fIndent, "");
+ SkDebugf("%*s</destination>\n", SkDisplayList::fIndent, "");
}
SkDisplayList::fIndent -= 4;
dumpEnd(maker);
@@ -268,7 +268,7 @@
SkDisplayList::fIndent += 4;
destination->dump(maker);
SkDisplayList::fIndent -= 4;
- SkDebugf("%*s</destination>\n", SkDisplayList::fIndent, "");
+ SkDebugf("%*s</destination>\n", SkDisplayList::fIndent, "");
}
SkDisplayList::fIndent -= 4;
dumpEnd(maker);
diff --git a/src/animator/SkMatrixParts.h b/src/animator/SkMatrixParts.h
index 5f6cd54..51c9559 100644
--- a/src/animator/SkMatrixParts.h
+++ b/src/animator/SkMatrixParts.h
@@ -114,6 +114,6 @@
SkPolygon* destination;
};
-// !!! add concat matrix ?
+// !!! add concat matrix ?
#endif // SkMatrixParts_DEFINED
diff --git a/src/animator/SkMemberInfo.cpp b/src/animator/SkMemberInfo.cpp
index 7fae503..582b29a 100644
--- a/src/animator/SkMemberInfo.cpp
+++ b/src/animator/SkMemberInfo.cpp
@@ -52,7 +52,7 @@
case SkType_Displayable:
case SkType_Drawable:
case SkType_Matrix:
- byteSize = sizeof(void*);
+ byteSize = sizeof(void*);
break;
case SkType_MSec:
byteSize = sizeof(SkMSec);
@@ -137,7 +137,7 @@
void SkMemberInfo::getValue(const SkDisplayable* displayable, SkOperand value[], int count) const {
SkASSERT(fType != SkType_String && fType != SkType_MemberProperty);
- SkASSERT(count == fCount);
+ SkASSERT(count == fCount);
void* valuePtr = memberData(displayable);
size_t byteSize = getSize(displayable);
SkASSERT(sizeof(value[0].fScalar) == sizeof(value[0])); // no support for 64 bit pointers, yet
@@ -150,7 +150,7 @@
displayable->dirty();
}
-void SkMemberInfo::setValue(SkDisplayable* displayable, const SkOperand values[],
+void SkMemberInfo::setValue(SkDisplayable* displayable, const SkOperand values[],
int count) const {
SkASSERT(sizeof(values[0].fScalar) == sizeof(values[0])); // no support for 64 bit pointers, yet
char* dst = (char*) memberData(displayable);
@@ -163,7 +163,7 @@
displayable->dirty();
}
-
+
static inline bool is_between(int c, int min, int max)
{
return (unsigned)(c - min) <= (unsigned)(max - min);
@@ -180,9 +180,9 @@
}
-bool SkMemberInfo::setValue(SkAnimateMaker& maker, SkTDOperandArray* arrayStorage,
+bool SkMemberInfo::setValue(SkAnimateMaker& maker, SkTDOperandArray* arrayStorage,
int storageOffset, int maxStorage, SkDisplayable* displayable, SkDisplayTypes outType,
- const char rawValue[], size_t rawValueLen) const
+ const char rawValue[], size_t rawValueLen) const
{
SkString valueStr(rawValue, rawValueLen);
SkScriptValue scriptValue;
@@ -218,7 +218,7 @@
}
*(char*) poundPos = '0'; // overwrite '#'
valueStr.insert(offset + 1, "xFF");
- }
+ }
}
if (SkDisplayType::IsDisplayable(&maker, type) || SkDisplayType::IsEnum(&maker, type) || type == SkType_ARGB)
goto scriptCommon;
@@ -226,22 +226,22 @@
case SkType_String:
#if 0
if (displayable && displayable->isAnimate()) {
-
+
goto noScriptString;
- }
+ }
if (strncmp(rawValue, "#string:", sizeof("#string:") - 1) == 0) {
SkASSERT(sizeof("string") == sizeof("script"));
char* stringHeader = valueStr.writable_str();
memcpy(&stringHeader[1], "script", sizeof("script") - 1);
rawValue = valueStr.c_str();
goto noScriptString;
- } else
+ } else
#endif
if (strncmp(rawValue, "#script:", sizeof("#script:") - 1) != 0)
goto noScriptString;
valueStr.remove(0, 8);
case SkType_Unknown:
- case SkType_Int:
+ case SkType_Int:
case SkType_MSec: // for the purposes of script, MSec is treated as a Scalar
case SkType_Point:
case SkType_3D_Point:
@@ -331,10 +331,10 @@
SkASSERT(0);
break;
}
-// if (SkDisplayType::IsStruct(type) == false)
+// if (SkDisplayType::IsStruct(type) == false)
{
writeStruct:
- if (writeValue(displayable, arrayStorage, storageOffset, maxStorage,
+ if (writeValue(displayable, arrayStorage, storageOffset, maxStorage,
untypedStorage, outType, scriptValue)) {
maker.setErrorCode(SkDisplayXMLParserError::kUnexpectedType);
return false;
@@ -346,18 +346,18 @@
return true;
}
-bool SkMemberInfo::setValue(SkAnimateMaker& maker, SkTDOperandArray* arrayStorage,
+bool SkMemberInfo::setValue(SkAnimateMaker& maker, SkTDOperandArray* arrayStorage,
int storageOffset, int maxStorage, SkDisplayable* displayable, SkDisplayTypes outType,
SkString& raw) const {
return setValue(maker, arrayStorage, storageOffset, maxStorage, displayable, outType, raw.c_str(),
raw.size());
}
-bool SkMemberInfo::writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage,
- int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType,
+bool SkMemberInfo::writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage,
+ int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType,
SkScriptValue& scriptValue) const
{
- SkOperand* storage = untypedStorage ? (SkOperand*) untypedStorage : arrayStorage ?
+ SkOperand* storage = untypedStorage ? (SkOperand*) untypedStorage : arrayStorage ?
arrayStorage->begin() : NULL;
if (storage)
storage += storageOffset;
@@ -424,7 +424,7 @@
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 ||
+ SkASSERT(scriptValue.fType == SkType_Int || scriptValue.fType == SkType_ARGB ||
scriptValue.fType == SkType_Array);
SkASSERT(scriptValue.fType != SkType_Array || (array != NULL &&
array->getType() == SkType_Int));
@@ -434,7 +434,7 @@
if (maxStorage == 0)
arrayStorage->setCount(numberOfComponents);
for (int index = 0; index < numberOfColors; index++) {
- SkColor color = scriptValue.fType == SkType_Array ?
+ 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));
@@ -528,11 +528,11 @@
#endif // SK_USE_CONDENSED_INFO == 0
#if 0
-bool SkMemberInfo::SetValue(void* valuePtr, const char value[], SkDisplayTypes type,
+bool SkMemberInfo::SetValue(void* valuePtr, const char value[], SkDisplayTypes type,
int count) {
switch (type) {
case SkType_Animate:
- case SkType_BaseBitmap:
+ case SkType_BaseBitmap:
case SkType_Bitmap:
case SkType_Dash:
case SkType_Displayable:
@@ -548,7 +548,7 @@
case SkType_3D_Point:
case SkType_Point:
// case SkType_PointArray:
- case SkType_ScalarArray:
+ case SkType_ScalarArray:
SkParse::FindScalars(value, (SkScalar*) valuePtr, count);
break;
default:
diff --git a/src/animator/SkMemberInfo.h b/src/animator/SkMemberInfo.h
index f2e690c..007df60 100644
--- a/src/animator/SkMemberInfo.h
+++ b/src/animator/SkMemberInfo.h
@@ -83,15 +83,15 @@
}
void setString(SkDisplayable* , SkString* ) const;
void setValue(SkDisplayable* , const SkOperand values[], int count) const;
- bool setValue(SkAnimateMaker& , SkTDOperandArray* storage,
- int storageOffset, int maxStorage, SkDisplayable* ,
+ bool setValue(SkAnimateMaker& , SkTDOperandArray* storage,
+ int storageOffset, int maxStorage, SkDisplayable* ,
SkDisplayTypes outType, const char value[], size_t len) const;
- bool setValue(SkAnimateMaker& , SkTDOperandArray* storage,
- int storageOffset, int maxStorage, SkDisplayable* ,
+ bool setValue(SkAnimateMaker& , SkTDOperandArray* storage,
+ int storageOffset, int maxStorage, SkDisplayable* ,
SkDisplayTypes outType, SkString& str) const;
// void setValue(SkDisplayable* , const char value[], const char name[]) const;
- bool writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage,
- int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType,
+ bool writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage,
+ int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType,
SkScriptValue& scriptValue) const;
#if SK_USE_CONDENSED_INFO == 0
static const SkMemberInfo* Find(const SkMemberInfo [], int count, int* index);
@@ -119,7 +119,7 @@
#define SK_MEMBER_INHERITED \
{ (const char*) INHERITED::fInfo, 0, SkType_BaseClassInfo, INHERITED::fInfoCount }
-// #define SK_MEMBER_KEY_TYPE(_member, _type)
+// #define SK_MEMBER_KEY_TYPE(_member, _type)
// {#_member, (size_t) -1, SkType_##_type, 0}
#define SK_FUNCTION(_member) \
@@ -184,7 +184,7 @@
#define DECLARE_EMPTY_MEMBER_INFO(_type) \
public: \
virtual SkDisplayTypes getType() const { return SkType_##_type; }
-
+
#define DECLARE_EXTRAS_MEMBER_INFO(_type) \
public: \
static const SkMemberInfo fInfo[]; \
diff --git a/src/animator/SkOpArray.cpp b/src/animator/SkOpArray.cpp
index 1f14476..94298cc 100644
--- a/src/animator/SkOpArray.cpp
+++ b/src/animator/SkOpArray.cpp
@@ -14,10 +14,10 @@
}
bool SkOpArray::getIndex(int index, SkOperand2* operand) {
- if (index >= count()) {
- SkASSERT(0);
- return false;
- }
- *operand = begin()[index];
- return true;
+ if (index >= count()) {
+ SkASSERT(0);
+ return false;
+ }
+ *operand = begin()[index];
+ return true;
}
diff --git a/src/animator/SkOpArray.h b/src/animator/SkOpArray.h
index d5b9fe7..260bf78 100644
--- a/src/animator/SkOpArray.h
+++ b/src/animator/SkOpArray.h
@@ -11,19 +11,19 @@
#include "SkOperand2.h"
#include "SkTDArray_Experimental.h"
-typedef SkLongArray(SkOperand2) SkTDOperand2Array;
+typedef SkLongArray(SkOperand2) SkTDOperand2Array;
class SkOpArray : public SkTDOperand2Array {
public:
- SkOpArray();
- SkOpArray(SkOperand2::OpType type);
- bool getIndex(int index, SkOperand2* operand);
- SkOperand2::OpType getType() { return fType; }
- void setType(SkOperand2::OpType type) {
- fType = type;
- }
+ SkOpArray();
+ SkOpArray(SkOperand2::OpType type);
+ bool getIndex(int index, SkOperand2* operand);
+ SkOperand2::OpType getType() { return fType; }
+ void setType(SkOperand2::OpType type) {
+ fType = type;
+ }
protected:
- SkOperand2::OpType fType;
+ SkOperand2::OpType fType;
};
#endif // SkOpArray_DEFINED
diff --git a/src/animator/SkOperand2.h b/src/animator/SkOperand2.h
index 4f09a01..f844b6b 100644
--- a/src/animator/SkOperand2.h
+++ b/src/animator/SkOperand2.h
@@ -14,40 +14,40 @@
class SkString;
union SkOperand2 {
- enum OpType {
- kNoType,
- kS32 = 1,
- kScalar = 2,
- kString = 4,
- kArray = 8,
- kObject = 16
- };
- SkOpArray* fArray;
- void* fObject;
- size_t fReference;
- int32_t fS32;
- SkScalar fScalar;
- SkString* fString;
+ enum OpType {
+ kNoType,
+ kS32 = 1,
+ kScalar = 2,
+ kString = 4,
+ kArray = 8,
+ kObject = 16
+ };
+ SkOpArray* fArray;
+ void* fObject;
+ size_t fReference;
+ int32_t fS32;
+ SkScalar fScalar;
+ SkString* fString;
};
struct SkScriptValue2 {
- enum IsConstant {
- kConstant,
- kVariable
- };
- enum IsWritten {
- kUnwritten,
- kWritten
- };
- SkOperand2 fOperand;
- SkOperand2::OpType fType : 8;
- IsConstant fIsConstant : 8;
- IsWritten fIsWritten : 8;
- SkOpArray* getArray() { SkASSERT(fType == SkOperand2::kArray); return fOperand.fArray; }
- void* getObject() { SkASSERT(fType == SkOperand2::kObject); return fOperand.fObject; }
- int32_t getS32() { SkASSERT(fType == SkOperand2::kS32); return fOperand.fS32; }
- SkScalar getScalar() { SkASSERT(fType == SkOperand2::kScalar); return fOperand.fScalar; }
- SkString* getString() { SkASSERT(fType == SkOperand2::kString); return fOperand.fString; }
+ enum IsConstant {
+ kConstant,
+ kVariable
+ };
+ enum IsWritten {
+ kUnwritten,
+ kWritten
+ };
+ SkOperand2 fOperand;
+ SkOperand2::OpType fType : 8;
+ IsConstant fIsConstant : 8;
+ IsWritten fIsWritten : 8;
+ SkOpArray* getArray() { SkASSERT(fType == SkOperand2::kArray); return fOperand.fArray; }
+ void* getObject() { SkASSERT(fType == SkOperand2::kObject); return fOperand.fObject; }
+ int32_t getS32() { SkASSERT(fType == SkOperand2::kS32); return fOperand.fS32; }
+ SkScalar getScalar() { SkASSERT(fType == SkOperand2::kScalar); return fOperand.fScalar; }
+ SkString* getString() { SkASSERT(fType == SkOperand2::kString); return fOperand.fString; }
bool isConstant() const { return fIsConstant == kConstant; }
};
diff --git a/src/animator/SkOperandIterpolator.cpp b/src/animator/SkOperandIterpolator.cpp
index dcc454d..bc7d46b 100644
--- a/src/animator/SkOperandIterpolator.cpp
+++ b/src/animator/SkOperandIterpolator.cpp
@@ -15,7 +15,7 @@
fType = SkType_Unknown;
}
-SkOperandInterpolator::SkOperandInterpolator(int elemCount, int frameCount,
+SkOperandInterpolator::SkOperandInterpolator(int elemCount, int frameCount,
SkDisplayTypes type)
{
this->reset(elemCount, frameCount, type);
diff --git a/src/animator/SkParseSVGPath.cpp b/src/animator/SkParseSVGPath.cpp
index 1b375aa..f020e2e 100644
--- a/src/animator/SkParseSVGPath.cpp
+++ b/src/animator/SkParseSVGPath.cpp
@@ -101,7 +101,7 @@
return str;
}
-static const char* find_scalar(const char str[], SkScalar* value,
+static const char* find_scalar(const char str[], SkScalar* value,
bool isRelative, SkScalar relative)
{
str = SkParse::FindScalar(str, value);
@@ -146,7 +146,7 @@
op = 'L';
c = points[0];
break;
- case 'L':
+ case 'L':
data = find_points(data, points, 1, relative, &c);
fPath.lineTo(points[0]);
c = points[0];
@@ -165,10 +165,10 @@
c.fY = y;
}
break;
- case 'C':
+ case 'C':
data = find_points(data, points, 3, relative, &c);
goto cubicCommon;
- case 'S':
+ case 'S':
data = find_points(data, &points[1], 2, relative, &c);
points[0] = c;
if (previousOp == 'C' || previousOp == 'S') {
diff --git a/src/animator/SkPathParts.cpp b/src/animator/SkPathParts.cpp
index 5af8150..3060bd4 100644
--- a/src/animator/SkPathParts.cpp
+++ b/src/animator/SkPathParts.cpp
@@ -16,8 +16,8 @@
SkPathPart::SkPathPart() : fPath(NULL) {
}
-void SkPathPart::dirty() {
- fPath->dirty();
+void SkPathPart::dirty() {
+ fPath->dirty();
}
SkDisplayable* SkPathPart::getParent() const {
@@ -86,7 +86,7 @@
}
bool SkLineTo::add() {
- fPath->fPath.lineTo(x, y);
+ fPath->fPath.lineTo(x, y);
return false;
}
@@ -103,7 +103,7 @@
DEFINE_GET_MEMBER(SkRLineTo);
bool SkRLineTo::add() {
- fPath->fPath.rLineTo(x, y);
+ fPath->fPath.rLineTo(x, y);
return false;
}
@@ -225,8 +225,8 @@
DEFINE_GET_MEMBER(SkAddRect);
-SkAddRect::SkAddRect() {
- fRect.setEmpty();
+SkAddRect::SkAddRect() {
+ fRect.setEmpty();
}
bool SkAddRect::add() {
@@ -309,7 +309,7 @@
}
bool SkAddPath::add() {
- SkASSERT (path != NULL);
+ SkASSERT (path != NULL);
if (matrix)
fPath->fPath.addPath(path->fPath, matrix->getMatrix());
else
diff --git a/src/animator/SkPostParts.cpp b/src/animator/SkPostParts.cpp
index 4b776a8..b6549a2 100644
--- a/src/animator/SkPostParts.cpp
+++ b/src/animator/SkPostParts.cpp
@@ -29,7 +29,7 @@
fParent->fEvent.setS32(dataName, fInt);
else if (SkScalarIsNaN(fFloat) == false)
fParent->fEvent.setScalar(dataName, fFloat);
- else if (string.size() > 0)
+ else if (string.size() > 0)
fParent->fEvent.setString(dataName, string);
// else
// SkASSERT(0);
diff --git a/src/animator/SkScript.cpp b/src/animator/SkScript.cpp
index 3b498fa..92e8f3c 100644
--- a/src/animator/SkScript.cpp
+++ b/src/animator/SkScript.cpp
@@ -16,7 +16,7 @@
/* things to do
? re-enable support for struct literals (e.g., for initializing points or rects)
{x:1, y:2}
- ? use standard XML / script notation like document.getElementById("canvas");
+ ? use standard XML / script notation like document.getElementById("canvas");
finish support for typed arrays
? allow indexing arrays by string
this could map to the 'name' attribute of a given child of an array
@@ -224,7 +224,7 @@
if (nextChar == '>') {
op = kShiftRight;
goto twoChar;
- }
+ }
op = kGreaterEqual;
if (nextChar == '=')
goto twoChar;
@@ -253,7 +253,7 @@
twoChar:
advance++;
break;
- }
+ }
op = kLogicalNot;
break;
case '?':
@@ -298,7 +298,7 @@
} while (true);
signed char topPrecedence = gPrecedence[compare];
SkASSERT(topPrecedence != -1);
- if (topPrecedence > precedence || (topPrecedence == precedence &&
+ if (topPrecedence > precedence || (topPrecedence == precedence &&
gOpAttributes[op].fLeftType == kNoType)) {
break;
}
@@ -327,7 +327,7 @@
*fUserCallBacks.prepend() = callBack;
}
-bool SkScriptEngine::convertParams(SkTDArray<SkScriptValue>& params,
+bool SkScriptEngine::convertParams(SkTDArray<SkScriptValue>& params,
const SkFunctionParamType* paramTypes, int paramCount) {
if (params.count() > paramCount) {
fError = kTooManyParameters;
@@ -366,7 +366,7 @@
return ConvertTo(this, toType, value);
}
-bool SkScriptEngine::evaluateDot(const char*& script, bool suppressed) {
+bool SkScriptEngine::evaluateDot(const char*& script, bool suppressed) {
size_t fieldLength = token_length(++script); // skip dot
if (fieldLength == 0) {
fError = kExpectedFieldName;
@@ -382,8 +382,8 @@
return evaluateDotParam(script, suppressed, field, fieldLength);
}
-bool SkScriptEngine::evaluateDotParam(const char*& script, bool suppressed,
- const char* field, size_t fieldLength) {
+bool SkScriptEngine::evaluateDotParam(const char*& script, bool suppressed,
+ const char* field, size_t fieldLength) {
void* object;
if (suppressed)
object = NULL;
@@ -397,7 +397,7 @@
fOperandStack.pop();
}
char ch; // see if it is a simple member or a function
- while (is_ws(ch = script[0]))
+ while (is_ws(ch = script[0]))
script++;
bool success = true;
if (ch != '(') {
@@ -410,10 +410,10 @@
*fBraceStack.push() = kFunctionBrace;
success = functionParams(&script, params);
if (success && suppressed == false &&
- (success = handleMemberFunction(field, fieldLength, object, params)) == false)
- fError = kHandleMemberFunctionFailed;
+ (success = handleMemberFunction(field, fieldLength, object, params)) == false)
+ fError = kHandleMemberFunctionFailed;
}
- return success;
+ return success;
}
bool SkScriptEngine::evaluateScript(const char** scriptPtr, SkScriptValue* value) {
@@ -559,15 +559,15 @@
if (convertTo(tokenInfo->getType(), &tokenValue) == false)
return false;
}
- tokenInfo->writeValue(fDisplayable, NULL, 0, 0,
+ tokenInfo->writeValue(fDisplayable, NULL, 0, 0,
(void*) ((char*) fInfo->memberData(fDisplayable) + tokenInfo->fOffset + fArrayOffset),
tokenInfo->getType(), tokenValue);
}
}
lastPush = false;
continue;
- } else
-#endif
+ } else
+#endif
if (fBraceStack.top() == kArrayBrace) {
SkScriptValue tokenValue;
success = innerScript(&script, &tokenValue); // terminate and return on comma, close brace
@@ -579,12 +579,12 @@
#if 0 // no support for structures for now
if (tokenValue.fType == SkType_Structure) {
fArrayOffset += (int) fInfo->getSize(fDisplayable);
- } else
+ } else
#endif
{
SkDisplayTypes type = ToDisplayType(fReturnType);
if (fReturnType == kNoType) {
- // !!! short sighted; in the future, allow each returned array component to carry
+ // !!! short sighted; in the future, allow each returned array component to carry
// its own type, and let caller do any needed conversions
if (value->fOperand.fArray->count() == 0)
value->fOperand.fArray->setType(type = tokenValue.fType);
@@ -730,11 +730,11 @@
if (success == false)
return false;
lastPush = true;
- continue;
+ continue;
}
// get next token, and evaluate immediately
success = evaluateDot(script, SkToBool(suppressed));
- if (success == false)
+ if (success == false)
return false;
lastPush = true;
continue;
@@ -772,7 +772,7 @@
}
#endif
if (ch == ')' && fBraceStack.count() > 0) {
- SkBraceStyle braceStyle = fBraceStack.top();
+ SkBraceStyle braceStyle = fBraceStack.top();
if (braceStyle == kFunctionBrace) {
fBraceStack.pop();
break;
@@ -795,7 +795,7 @@
int advance = logicalOp(ch, nextChar);
if (advance < 0) // error
return false;
- if (advance == 0)
+ if (advance == 0)
advance = arithmeticOp(ch, nextChar, lastPush);
if (advance == 0) // unknown token
return false;
@@ -814,7 +814,7 @@
return false;
if (processOp() == false)
return false;
- }
+ }
SkOpType topType = fTypeStack.count() > 0 ? fTypeStack.top() : kNoType;
if (suppressed == false && topType != fReturnType &&
topType == kString && fReturnType != kNoType) { // if result is a string, give handle property a chance to convert it to the property value
@@ -945,7 +945,7 @@
for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
if (callBack->fCallBackType != kFunction)
continue;
- success = (*callBack->fFunctionCallBack)(functionName.c_str(), functionName.size(), params,
+ success = (*callBack->fFunctionCallBack)(functionName.c_str(), functionName.size(), params,
callBack->fUserStorage, &callbackResult);
if (success) {
fOperandStack.push(callbackResult.fOperand);
@@ -986,7 +986,7 @@
for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
if (callBack->fCallBackType != kMemberFunction)
continue;
- success = (*callBack->fMemberFunctionCallBack)(field, len, object, params,
+ success = (*callBack->fMemberFunctionCallBack)(field, len, object, params,
callBack->fUserStorage, &callbackResult);
if (success) {
if (callbackResult.fType == SkType_String)
@@ -1008,7 +1008,7 @@
for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
if (callBack->fCallBackType != kObjectToString)
continue;
- success = (*callBack->fObjectToStringCallBack)(object,
+ success = (*callBack->fObjectToStringCallBack)(object,
callBack->fUserStorage, &callbackResult);
if (success) {
if (callbackResult.fType == SkType_String)
@@ -1027,14 +1027,14 @@
bool SkScriptEngine::handleProperty(bool suppressed) {
SkScriptValue callbackResult;
bool success = true;
- if (suppressed)
+ if (suppressed)
goto done;
success = false; // note that with standard animator-script plugins, callback never returns false
{
for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
if (callBack->fCallBackType != kProperty)
continue;
- success = (*callBack->fPropertyCallBack)(fToken, fTokenLength,
+ success = (*callBack->fPropertyCallBack)(fToken, fTokenLength,
callBack->fUserStorage, &callbackResult);
if (success) {
if (callbackResult.fType == SkType_String && callbackResult.fOperand.fString == NULL) {
@@ -1146,7 +1146,7 @@
fError = kMismatchedBrackets;
return -1;
}
- if (match == kParen)
+ if (match == kParen)
fOpStack.pop();
else {
SkOpType indexType;
@@ -1157,7 +1157,7 @@
}
SkOperand indexOperand;
fOperandStack.pop(&indexOperand);
- int index = indexType == kScalar ? SkScalarFloor(indexOperand.fScalar) :
+ int index = indexType == kScalar ? SkScalarFloor(indexOperand.fScalar) :
indexOperand.fS32;
SkOpType arrayType;
fTypeStack.pop(&arrayType);
@@ -1192,7 +1192,7 @@
}
suppress.fSuppress = ifValue.fOperand.fS32 == 0;
suppress.fOperator = kIf;
- suppress.fOpStackDepth = fOpStack.count();
+ suppress.fOpStackDepth = fOpStack.count();
suppress.fElse = false;
fSuppressStack.push(suppress);
// if left is true, do only up to colon
@@ -1218,7 +1218,7 @@
if (match == kLogicalOr ? topInt != 0 : topInt == 0) {
suppress.fSuppress = true;
suppress.fOperator = match;
- suppress.fOpStackDepth = fOpStack.count();
+ suppress.fOpStackDepth = fOpStack.count();
suppress.fElse = false;
fSuppressStack.push(suppress);
} else {
@@ -1467,16 +1467,16 @@
commonCallBack(kProperty, callBack, userStorage);
}
-void SkScriptEngine::track(SkTypedArray* array) {
- SkASSERT(fTrackArray.find(array) < 0);
- *(fTrackArray.end() - 1) = array;
- fTrackArray.appendClear();
+void SkScriptEngine::track(SkTypedArray* array) {
+ SkASSERT(fTrackArray.find(array) < 0);
+ *(fTrackArray.end() - 1) = array;
+ fTrackArray.appendClear();
}
-void SkScriptEngine::track(SkString* string) {
- SkASSERT(fTrackString.find(string) < 0);
- *(fTrackString.end() - 1) = string;
- fTrackString.appendClear();
+void SkScriptEngine::track(SkString* string) {
+ SkASSERT(fTrackString.find(string) < 0);
+ *(fTrackString.end() - 1) = string;
+ fTrackString.appendClear();
}
void SkScriptEngine::unboxCallBack(_unboxCallBack func, void* userStorage) {
@@ -1494,7 +1494,7 @@
if (toType == SkType_Drawable)
toType = SkType_Displayable;
SkDisplayTypes type = value->fType;
- if (type == toType)
+ if (type == toType)
return true;
SkOperand& operand = value->fOperand;
bool success = true;
@@ -1534,7 +1534,7 @@
engine->track(strPtr);
if (type == SkType_Int)
strPtr->appendS32(operand.fS32);
- else if (type == SkType_Displayable)
+ else if (type == SkType_Displayable)
SkASSERT(0); // must call through instance version instead of static version
else {
if (type != SkType_Float) {
@@ -1665,17 +1665,17 @@
testInt((6+7)*8),
testInt(0&&1?2:3),
testInt(3*(4+5)),
- testScalar(1.0+2.0),
- testScalar(1.0+5),
- testScalar(3.0-1.0),
- testScalar(6-1.0),
- testScalar(- -5.5- -1.5),
- testScalar(2.5*6.),
- testScalar(0.5*4),
- testScalar(4.5/.5),
- testScalar(9.5/19),
- testRemainder(9.5, 0.5),
- testRemainder(9.,2),
+ testScalar(1.0+2.0),
+ testScalar(1.0+5),
+ testScalar(3.0-1.0),
+ testScalar(6-1.0),
+ testScalar(- -5.5- -1.5),
+ testScalar(2.5*6.),
+ testScalar(0.5*4),
+ testScalar(4.5/.5),
+ testScalar(9.5/19),
+ testRemainder(9.5, 0.5),
+ testRemainder(9.,2),
testRemainder(9,2.5),
testRemainder(-9,2.5),
testTrue(-9==-9.0),
@@ -1854,7 +1854,7 @@
testInt(0?2?3:4:5),
testInt(1?0?3:4:5),
testInt(0?0?3:4:5),
-
+
testInt(1?2:(3?4:5)),
testInt(0?2:(3?4:5)),
testInt(1?0:(3?4:5)),
diff --git a/src/animator/SkScript.h b/src/animator/SkScript.h
index 95930e8..aa8d9a3 100644
--- a/src/animator/SkScript.h
+++ b/src/animator/SkScript.h
@@ -63,9 +63,9 @@
typedef bool (*_boxCallBack)(void* userStorage, SkScriptValue* result);
typedef bool (*_functionCallBack)(const char* func, size_t len, SkTDArray<SkScriptValue>& params,
void* userStorage, SkScriptValue* result);
- typedef bool (*_memberCallBack)(const char* member, size_t len, void* object,
+ typedef bool (*_memberCallBack)(const char* member, size_t len, void* object,
void* userStorage, SkScriptValue* result);
- typedef bool (*_memberFunctionCallBack)(const char* member, size_t len, void* object,
+ typedef bool (*_memberFunctionCallBack)(const char* member, size_t len, void* object,
SkTDArray<SkScriptValue>& params, void* userStorage, SkScriptValue* result);
// typedef bool (*_objectToStringCallBack)(void* object, void* userStorage, SkScriptValue* result);
typedef bool (*_propertyCallBack)(const char* prop, size_t len, void* userStorage, SkScriptValue* result);
@@ -169,7 +169,7 @@
kTowardsNumber = 0,
kTowardsString
};
-
+
protected:
struct SkOperatorAttributes {
diff --git a/src/animator/SkScript2.h b/src/animator/SkScript2.h
index 05073e4..03eb92c 100644
--- a/src/animator/SkScript2.h
+++ b/src/animator/SkScript2.h
@@ -15,274 +15,274 @@
#include "SkTDict.h"
#include "SkTDStack.h"
-typedef SkLongArray(SkString*) SkTDStringArray;
+typedef SkLongArray(SkString*) SkTDStringArray;
class SkAnimateMaker;
class SkScriptCallBack;
class SkScriptEngine2 {
public:
- enum Error {
- kNoError,
- kArrayIndexOutOfBounds,
- kCouldNotFindReferencedID,
- kFunctionCallFailed,
- kMemberOpFailed,
- kPropertyOpFailed
- };
+ enum Error {
+ kNoError,
+ kArrayIndexOutOfBounds,
+ kCouldNotFindReferencedID,
+ kFunctionCallFailed,
+ kMemberOpFailed,
+ kPropertyOpFailed
+ };
- enum Attrs {
- kConstant,
- kVariable
- };
+ enum Attrs {
+ kConstant,
+ kVariable
+ };
- SkScriptEngine2(SkOperand2::OpType returnType);
- ~SkScriptEngine2();
- bool convertTo(SkOperand2::OpType , SkScriptValue2* );
- bool evaluateScript(const char** script, SkScriptValue2* value);
- void forget(SkOpArray* array);
- Error getError() { return fError; }
- SkOperand2::OpType getReturnType() { return fReturnType; }
- void track(SkOpArray* array) {
- SkASSERT(fTrackArray.find(array) < 0);
- *fTrackArray.append() = array; }
- void track(SkString* string) {
- SkASSERT(fTrackString.find(string) < 0);
- *fTrackString.append() = string;
- }
- static bool ConvertTo(SkScriptEngine2* , SkOperand2::OpType toType, SkScriptValue2* value);
- static SkScalar IntToScalar(int32_t );
- static bool ValueToString(const SkScriptValue2& value, SkString* string);
+ SkScriptEngine2(SkOperand2::OpType returnType);
+ ~SkScriptEngine2();
+ bool convertTo(SkOperand2::OpType , SkScriptValue2* );
+ bool evaluateScript(const char** script, SkScriptValue2* value);
+ void forget(SkOpArray* array);
+ Error getError() { return fError; }
+ SkOperand2::OpType getReturnType() { return fReturnType; }
+ void track(SkOpArray* array) {
+ SkASSERT(fTrackArray.find(array) < 0);
+ *fTrackArray.append() = array; }
+ void track(SkString* string) {
+ SkASSERT(fTrackString.find(string) < 0);
+ *fTrackString.append() = string;
+ }
+ static bool ConvertTo(SkScriptEngine2* , SkOperand2::OpType toType, SkScriptValue2* value);
+ static SkScalar IntToScalar(int32_t );
+ static bool ValueToString(const SkScriptValue2& value, SkString* string);
- enum Op { // used by tokenizer attribute table
- kUnassigned,
- kAdd,
- kBitAnd,
- kBitNot,
- kBitOr,
- kDivide,
- kEqual,
- kFlipOps,
- kGreaterEqual,
- kLogicalAnd,
- kLogicalNot,
- kLogicalOr,
- kMinus,
- kModulo,
- kMultiply,
- kShiftLeft,
- kShiftRight, // signed
- kSubtract,
- kXor,
+ enum Op { // used by tokenizer attribute table
+ kUnassigned,
+ kAdd,
+ kBitAnd,
+ kBitNot,
+ kBitOr,
+ kDivide,
+ kEqual,
+ kFlipOps,
+ kGreaterEqual,
+ kLogicalAnd,
+ kLogicalNot,
+ kLogicalOr,
+ kMinus,
+ kModulo,
+ kMultiply,
+ kShiftLeft,
+ kShiftRight, // signed
+ kSubtract,
+ kXor,
// following not in attribute table
- kArrayOp,
- kElse,
- kIf,
- kParen,
- kLastLogicalOp,
- kArtificialOp = 0x20
- };
+ kArrayOp,
+ kElse,
+ kIf,
+ kParen,
+ kLastLogicalOp,
+ kArtificialOp = 0x20
+ };
- enum TypeOp { // generated by tokenizer
- kNop, // should never get generated
- kAccumulatorPop,
- kAccumulatorPush,
- kAddInt,
- kAddScalar,
- kAddString, // string concat
- kArrayIndex,
- kArrayParam,
- kArrayToken,
- kBitAndInt,
- kBitNotInt,
- kBitOrInt,
- kBoxToken,
- kCallback,
- kDivideInt,
- kDivideScalar,
- kDotOperator,
- kElseOp,
- kEnd,
- kEqualInt,
- kEqualScalar,
- kEqualString,
- kFunctionCall,
- kFlipOpsOp,
- kFunctionToken,
- kGreaterEqualInt,
- kGreaterEqualScalar,
- kGreaterEqualString,
- kIfOp,
- kIntToScalar,
- kIntToScalar2,
- kIntToString,
- kIntToString2,
- kIntegerAccumulator,
- kIntegerOperand,
- kLogicalAndInt,
- kLogicalNotInt,
- kLogicalOrInt,
- kMemberOp,
- kMinusInt,
- kMinusScalar,
- kModuloInt,
- kModuloScalar,
- kMultiplyInt,
- kMultiplyScalar,
- kPropertyOp,
- kScalarAccumulator,
- kScalarOperand,
- kScalarToInt,
- kScalarToInt2,
- kScalarToString,
- kScalarToString2,
- kShiftLeftInt,
- kShiftRightInt, // signed
- kStringAccumulator,
- kStringOperand,
- kStringToInt,
- kStringToScalar,
- kStringToScalar2,
- kStringTrack,
- kSubtractInt,
- kSubtractScalar,
- kToBool,
- kUnboxToken,
- kUnboxToken2,
- kXorInt,
- kLastTypeOp
- };
+ enum TypeOp { // generated by tokenizer
+ kNop, // should never get generated
+ kAccumulatorPop,
+ kAccumulatorPush,
+ kAddInt,
+ kAddScalar,
+ kAddString, // string concat
+ kArrayIndex,
+ kArrayParam,
+ kArrayToken,
+ kBitAndInt,
+ kBitNotInt,
+ kBitOrInt,
+ kBoxToken,
+ kCallback,
+ kDivideInt,
+ kDivideScalar,
+ kDotOperator,
+ kElseOp,
+ kEnd,
+ kEqualInt,
+ kEqualScalar,
+ kEqualString,
+ kFunctionCall,
+ kFlipOpsOp,
+ kFunctionToken,
+ kGreaterEqualInt,
+ kGreaterEqualScalar,
+ kGreaterEqualString,
+ kIfOp,
+ kIntToScalar,
+ kIntToScalar2,
+ kIntToString,
+ kIntToString2,
+ kIntegerAccumulator,
+ kIntegerOperand,
+ kLogicalAndInt,
+ kLogicalNotInt,
+ kLogicalOrInt,
+ kMemberOp,
+ kMinusInt,
+ kMinusScalar,
+ kModuloInt,
+ kModuloScalar,
+ kMultiplyInt,
+ kMultiplyScalar,
+ kPropertyOp,
+ kScalarAccumulator,
+ kScalarOperand,
+ kScalarToInt,
+ kScalarToInt2,
+ kScalarToString,
+ kScalarToString2,
+ kShiftLeftInt,
+ kShiftRightInt, // signed
+ kStringAccumulator,
+ kStringOperand,
+ kStringToInt,
+ kStringToScalar,
+ kStringToScalar2,
+ kStringTrack,
+ kSubtractInt,
+ kSubtractScalar,
+ kToBool,
+ kUnboxToken,
+ kUnboxToken2,
+ kXorInt,
+ kLastTypeOp
+ };
- enum OpBias {
- kNoBias,
- kTowardsNumber = 0,
- kTowardsString
- };
+ enum OpBias {
+ kNoBias,
+ kTowardsNumber = 0,
+ kTowardsString
+ };
protected:
- enum BraceStyle {
- // kStructBrace,
- kArrayBrace,
- kFunctionBrace
- };
+ enum BraceStyle {
+ // kStructBrace,
+ kArrayBrace,
+ kFunctionBrace
+ };
- enum AddTokenRegister {
- kAccumulator,
- kOperand
- };
-
- enum ResultIsBoolean {
- kResultIsNotBoolean,
- kResultIsBoolean
- };
+ enum AddTokenRegister {
+ kAccumulator,
+ kOperand
+ };
- struct OperatorAttributes {
- unsigned int fLeftType : 3; // SkOpType union, but only lower values
- unsigned int fRightType : 3; // SkOpType union, but only lower values
- OpBias fBias : 1;
- ResultIsBoolean fResultIsBoolean : 1;
- };
-
- struct Branch {
- Branch() {
- }
-
- Branch(Op op, int depth, unsigned offset) : fOffset(offset), fOpStackDepth(depth), fOperator(op),
- fPrimed(kIsNotPrimed), fDone(kIsNotDone) {
- }
+ enum ResultIsBoolean {
+ kResultIsNotBoolean,
+ kResultIsBoolean
+ };
- enum Primed {
- kIsNotPrimed,
- kIsPrimed
- };
+ struct OperatorAttributes {
+ unsigned int fLeftType : 3; // SkOpType union, but only lower values
+ unsigned int fRightType : 3; // SkOpType union, but only lower values
+ OpBias fBias : 1;
+ ResultIsBoolean fResultIsBoolean : 1;
+ };
- enum Done {
- kIsNotDone,
- kIsDone,
- };
+ struct Branch {
+ Branch() {
+ }
- unsigned fOffset : 16; // offset in generated stream where branch needs to go
- int fOpStackDepth : 7; // depth when operator was found
- Op fOperator : 6; // operand which generated branch
- mutable Primed fPrimed : 1; // mark when next instruction generates branch
- Done fDone : 1; // mark when branch is complete
- void prime() { fPrimed = kIsPrimed; }
- void resolve(SkDynamicMemoryWStream* , size_t offset);
- };
+ Branch(Op op, int depth, unsigned offset) : fOffset(offset), fOpStackDepth(depth), fOperator(op),
+ fPrimed(kIsNotPrimed), fDone(kIsNotDone) {
+ }
- static const OperatorAttributes gOpAttributes[];
- static const signed char gPrecedence[];
- static const TypeOp gTokens[];
- void addToken(TypeOp );
- void addTokenConst(SkScriptValue2* , AddTokenRegister , SkOperand2::OpType , TypeOp );
- void addTokenInt(int );
- void addTokenScalar(SkScalar );
- void addTokenString(const SkString& );
- void addTokenValue(const SkScriptValue2& , AddTokenRegister );
- int arithmeticOp(char ch, char nextChar, bool lastPush);
- bool convertParams(SkTDArray<SkScriptValue2>* ,
- const SkOperand2::OpType* paramTypes, int paramTypeCount);
- void convertToString(SkOperand2* operand, SkOperand2::OpType type) {
- SkScriptValue2 scriptValue;
- scriptValue.fOperand = *operand;
- scriptValue.fType = type;
- convertTo(SkOperand2::kString, &scriptValue);
- *operand = scriptValue.fOperand;
- }
- bool evaluateDot(const char*& script);
- bool evaluateDotParam(const char*& script, const char* field, size_t fieldLength);
- bool functionParams(const char** scriptPtr, SkTDArray<SkScriptValue2>* params);
- size_t getTokenOffset();
- SkOperand2::OpType getUnboxType(SkOperand2 scriptValue);
- bool handleArrayIndexer(const char** scriptPtr);
- bool handleFunction(const char** scriptPtr);
- bool handleMember(const char* field, size_t len, void* object);
- bool handleMemberFunction(const char* field, size_t len, void* object,
- SkTDArray<SkScriptValue2>* params);
- bool handleProperty();
- bool handleUnbox(SkScriptValue2* scriptValue);
- bool innerScript(const char** scriptPtr, SkScriptValue2* value);
- int logicalOp(char ch, char nextChar);
- void processLogicalOp(Op op);
- bool processOp();
- void resolveBranch(Branch& );
-// void setAnimateMaker(SkAnimateMaker* maker) { fMaker = maker; }
- SkDynamicMemoryWStream fStream;
- SkDynamicMemoryWStream* fActiveStream;
- SkTDStack<BraceStyle> fBraceStack; // curly, square, function paren
- SkTDStack<Branch> fBranchStack; // logical operators, slot to store forward branch
- SkLongArray(SkScriptCallBack*) fCallBackArray;
- SkTDStack<Op> fOpStack;
- SkTDStack<SkScriptValue2> fValueStack;
-// SkAnimateMaker* fMaker;
- SkLongArray(SkOpArray*) fTrackArray;
- SkTDStringArray fTrackString;
- const char* fToken; // one-deep stack
- size_t fTokenLength;
- SkOperand2::OpType fReturnType;
- Error fError;
- SkOperand2::OpType fAccumulatorType; // tracking for code generation
- SkBool fBranchPopAllowed;
- SkBool fConstExpression;
- SkBool fOperandInUse;
+ enum Primed {
+ kIsNotPrimed,
+ kIsPrimed
+ };
+
+ enum Done {
+ kIsNotDone,
+ kIsDone,
+ };
+
+ unsigned fOffset : 16; // offset in generated stream where branch needs to go
+ int fOpStackDepth : 7; // depth when operator was found
+ Op fOperator : 6; // operand which generated branch
+ mutable Primed fPrimed : 1; // mark when next instruction generates branch
+ Done fDone : 1; // mark when branch is complete
+ void prime() { fPrimed = kIsPrimed; }
+ void resolve(SkDynamicMemoryWStream* , size_t offset);
+ };
+
+ static const OperatorAttributes gOpAttributes[];
+ static const signed char gPrecedence[];
+ static const TypeOp gTokens[];
+ void addToken(TypeOp );
+ void addTokenConst(SkScriptValue2* , AddTokenRegister , SkOperand2::OpType , TypeOp );
+ void addTokenInt(int );
+ void addTokenScalar(SkScalar );
+ void addTokenString(const SkString& );
+ void addTokenValue(const SkScriptValue2& , AddTokenRegister );
+ int arithmeticOp(char ch, char nextChar, bool lastPush);
+ bool convertParams(SkTDArray<SkScriptValue2>* ,
+ const SkOperand2::OpType* paramTypes, int paramTypeCount);
+ void convertToString(SkOperand2* operand, SkOperand2::OpType type) {
+ SkScriptValue2 scriptValue;
+ scriptValue.fOperand = *operand;
+ scriptValue.fType = type;
+ convertTo(SkOperand2::kString, &scriptValue);
+ *operand = scriptValue.fOperand;
+ }
+ bool evaluateDot(const char*& script);
+ bool evaluateDotParam(const char*& script, const char* field, size_t fieldLength);
+ bool functionParams(const char** scriptPtr, SkTDArray<SkScriptValue2>* params);
+ size_t getTokenOffset();
+ SkOperand2::OpType getUnboxType(SkOperand2 scriptValue);
+ bool handleArrayIndexer(const char** scriptPtr);
+ bool handleFunction(const char** scriptPtr);
+ bool handleMember(const char* field, size_t len, void* object);
+ bool handleMemberFunction(const char* field, size_t len, void* object,
+ SkTDArray<SkScriptValue2>* params);
+ bool handleProperty();
+ bool handleUnbox(SkScriptValue2* scriptValue);
+ bool innerScript(const char** scriptPtr, SkScriptValue2* value);
+ int logicalOp(char ch, char nextChar);
+ void processLogicalOp(Op op);
+ bool processOp();
+ void resolveBranch(Branch& );
+// void setAnimateMaker(SkAnimateMaker* maker) { fMaker = maker; }
+ SkDynamicMemoryWStream fStream;
+ SkDynamicMemoryWStream* fActiveStream;
+ SkTDStack<BraceStyle> fBraceStack; // curly, square, function paren
+ SkTDStack<Branch> fBranchStack; // logical operators, slot to store forward branch
+ SkLongArray(SkScriptCallBack*) fCallBackArray;
+ SkTDStack<Op> fOpStack;
+ SkTDStack<SkScriptValue2> fValueStack;
+// SkAnimateMaker* fMaker;
+ SkLongArray(SkOpArray*) fTrackArray;
+ SkTDStringArray fTrackString;
+ const char* fToken; // one-deep stack
+ size_t fTokenLength;
+ SkOperand2::OpType fReturnType;
+ Error fError;
+ SkOperand2::OpType fAccumulatorType; // tracking for code generation
+ SkBool fBranchPopAllowed;
+ SkBool fConstExpression;
+ SkBool fOperandInUse;
private:
#ifdef SK_DEBUG
public:
- void decompile(const unsigned char* , size_t );
- static void UnitTest();
- static void ValidateDecompileTable();
+ void decompile(const unsigned char* , size_t );
+ static void UnitTest();
+ static void ValidateDecompileTable();
#endif
};
#ifdef SK_DEBUG
struct SkScriptNAnswer2 {
- const char* fScript;
- SkOperand2::OpType fType;
- int32_t fIntAnswer;
- SkScalar fScalarAnswer;
- const char* fStringAnswer;
+ const char* fScript;
+ SkOperand2::OpType fType;
+ int32_t fIntAnswer;
+ SkScalar fScalarAnswer;
+ const char* fStringAnswer;
};
#endif
diff --git a/src/animator/SkScriptCallBack.h b/src/animator/SkScriptCallBack.h
index b2a1958..dcbaf11 100644
--- a/src/animator/SkScriptCallBack.h
+++ b/src/animator/SkScriptCallBack.h
@@ -13,53 +13,53 @@
class SkScriptCallBack {
public:
- enum Type {
- kBox,
- kFunction,
- kMember,
- kMemberFunction,
- kProperty,
- kUnbox
- };
+ enum Type {
+ kBox,
+ kFunction,
+ kMember,
+ kMemberFunction,
+ kProperty,
+ kUnbox
+ };
- virtual bool getReference(const char* , size_t len, SkScriptValue2* result) { return false; }
- virtual SkOperand2::OpType getReturnType(size_t ref, SkOperand2*) {
- return SkOperand2::kS32; }
- virtual Type getType() const = 0;
+ virtual bool getReference(const char* , size_t len, SkScriptValue2* result) { return false; }
+ virtual SkOperand2::OpType getReturnType(size_t ref, SkOperand2*) {
+ return SkOperand2::kS32; }
+ virtual Type getType() const = 0;
};
class SkScriptCallBackConvert : public SkScriptCallBack {
public:
- virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) = 0;
+ virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) = 0;
};
class SkScriptCallBackFunction : public SkScriptCallBack {
public:
- virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) = 0;
- virtual Type getType() const { return kFunction; }
- virtual bool invoke(size_t ref, SkOpArray* params, SkOperand2* value) = 0;
+ virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) = 0;
+ virtual Type getType() const { return kFunction; }
+ virtual bool invoke(size_t ref, SkOpArray* params, SkOperand2* value) = 0;
};
class SkScriptCallBackMember: public SkScriptCallBack {
public:
- bool getMemberReference(const char* , size_t len, void* object, SkScriptValue2* ref);
- virtual Type getType() const { return kMember; }
- virtual bool invoke(size_t ref, void* object, SkOperand2* value) = 0;
+ bool getMemberReference(const char* , size_t len, void* object, SkScriptValue2* ref);
+ virtual Type getType() const { return kMember; }
+ virtual bool invoke(size_t ref, void* object, SkOperand2* value) = 0;
};
class SkScriptCallBackMemberFunction : public SkScriptCallBack {
public:
- bool getMemberReference(const char* , size_t len, void* object, SkScriptValue2* ref);
- virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) = 0;
- virtual Type getType() const { return kMemberFunction; }
- virtual bool invoke(size_t ref, void* object, SkOpArray* params, SkOperand2* value) = 0;
+ bool getMemberReference(const char* , size_t len, void* object, SkScriptValue2* ref);
+ virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) = 0;
+ virtual Type getType() const { return kMemberFunction; }
+ virtual bool invoke(size_t ref, void* object, SkOpArray* params, SkOperand2* value) = 0;
};
class SkScriptCallBackProperty : public SkScriptCallBack {
public:
- virtual bool getConstValue(const char* name, size_t len, SkOperand2* value) { return false; }
- virtual bool getResult(size_t ref, SkOperand2* answer) { return false; }
- virtual Type getType() const { return kProperty; }
+ virtual bool getConstValue(const char* name, size_t len, SkOperand2* value) { return false; }
+ virtual bool getResult(size_t ref, SkOperand2* answer) { return false; }
+ virtual Type getType() const { return kProperty; }
};
#endif // SkScriptCallBack_DEFINED
diff --git a/src/animator/SkScriptDecompile.cpp b/src/animator/SkScriptDecompile.cpp
index 26b678c..995da87 100644
--- a/src/animator/SkScriptDecompile.cpp
+++ b/src/animator/SkScriptDecompile.cpp
@@ -99,7 +99,7 @@
OperandName(kString),
OperandName(kArray),
OperandName(kObject)
-};
+};
static size_t gOperandNamesSize = sizeof(gOperandNames) / sizeof(gOperandNames[0]);
@@ -135,7 +135,7 @@
opCode += sizeof(index);
SkDebugf(" index: %d", index);
} break;
- case SkScriptEngine2::kFunctionCall:
+ case SkScriptEngine2::kFunctionCall:
case SkScriptEngine2::kMemberOp:
case SkScriptEngine2::kPropertyOp: {
size_t ref;
diff --git a/src/animator/SkScriptRuntime.cpp b/src/animator/SkScriptRuntime.cpp
index 6a96633..b211a71 100644
--- a/src/animator/SkScriptRuntime.cpp
+++ b/src/animator/SkScriptRuntime.cpp
@@ -27,326 +27,326 @@
// replace script string with script tokens preceeded by special value
// need second version of script plugins that return private index of found value?
- // then would need in script index of plugin, private index
+ // then would need in script index of plugin, private index
// encode brace stack push/pop as opcodes
// should token script enocde type where possible?
// current flow:
- // strip whitespace
- // if in array brace [ recurse, continue
- // if token, handle function, or array, or property (continue)
- // parse number, continue
- // parse token, continue
- // parse string literal, continue
- // if dot operator, handle dot, continue
- // if [ , handle array literal or accessor, continue
- // if ), pop (if function, break)
- // if ], pop ; if ',' break
- // handle logical ops
- // or, handle arithmetic ops
- // loop
+ // strip whitespace
+ // if in array brace [ recurse, continue
+ // if token, handle function, or array, or property (continue)
+ // parse number, continue
+ // parse token, continue
+ // parse string literal, continue
+ // if dot operator, handle dot, continue
+ // if [ , handle array literal or accessor, continue
+ // if ), pop (if function, break)
+ // if ], pop ; if ',' break
+ // handle logical ops
+ // or, handle arithmetic ops
+ // loop
// !!! things to do
- // add separate processing loop to advance while suppressed
- // or, include jump offset to skip suppressed code?
+ // add separate processing loop to advance while suppressed
+ // or, include jump offset to skip suppressed code?
SkScriptRuntime::~SkScriptRuntime() {
- for (SkString** stringPtr = fTrackString.begin(); stringPtr < fTrackString.end(); stringPtr++)
- delete *stringPtr;
- for (SkOpArray** arrayPtr = fTrackArray.begin(); arrayPtr < fTrackArray.end(); arrayPtr++)
- delete *arrayPtr;
+ for (SkString** stringPtr = fTrackString.begin(); stringPtr < fTrackString.end(); stringPtr++)
+ delete *stringPtr;
+ for (SkOpArray** arrayPtr = fTrackArray.begin(); arrayPtr < fTrackArray.end(); arrayPtr++)
+ delete *arrayPtr;
}
bool SkScriptRuntime::executeTokens(unsigned char* opCode) {
- SkOperand2 operand[2]; // 1=accumulator and 2=operand
- SkScriptEngine2::TypeOp op;
- size_t ref;
- int index, size;
- int registerLoad;
- SkScriptCallBack* callBack SK_INIT_TO_AVOID_WARNING;
- do {
- switch ((op = (SkScriptEngine2::TypeOp) *opCode++)) {
- case SkScriptEngine2::kArrayToken: // create an array
- operand[0].fArray = new SkOpArray(SkOperand2::kNoType /*fReturnType*/);
- break;
- case SkScriptEngine2::kArrayIndex: // array accessor
- index = operand[1].fS32;
- if (index >= operand[0].fArray->count()) {
- fError = kArrayIndexOutOfBounds;
- return false;
- }
- operand[0] = operand[0].fArray->begin()[index];
- break;
- case SkScriptEngine2::kArrayParam: // array initializer, or function param
- *operand[0].fArray->append() = operand[1];
- break;
- case SkScriptEngine2::kCallback:
- memcpy(&index, opCode, sizeof(index));
- opCode += sizeof(index);
- callBack = fCallBackArray[index];
- break;
- case SkScriptEngine2::kFunctionCall: {
- memcpy(&ref, opCode, sizeof(ref));
- opCode += sizeof(ref);
- SkScriptCallBackFunction* callBackFunction = (SkScriptCallBackFunction*) callBack;
- if (callBackFunction->invoke(ref, operand[0].fArray, /* params */
- &operand[0] /* result */) == false) {
- fError = kFunctionCallFailed;
- return false;
- }
- } break;
- case SkScriptEngine2::kMemberOp: {
- memcpy(&ref, opCode, sizeof(ref));
- opCode += sizeof(ref);
- SkScriptCallBackMember* callBackMember = (SkScriptCallBackMember*) callBack;
- if (callBackMember->invoke(ref, operand[0].fObject, &operand[0]) == false) {
- fError = kMemberOpFailed;
- return false;
- }
- } break;
- case SkScriptEngine2::kPropertyOp: {
- memcpy(&ref, opCode, sizeof(ref));
- opCode += sizeof(ref);
- SkScriptCallBackProperty* callBackProperty = (SkScriptCallBackProperty*) callBack;
- if (callBackProperty->getResult(ref, &operand[0])== false) {
- fError = kPropertyOpFailed;
- return false;
- }
- } break;
- case SkScriptEngine2::kAccumulatorPop:
- fRunStack.pop(&operand[0]);
- break;
- case SkScriptEngine2::kAccumulatorPush:
- *fRunStack.push() = operand[0];
- break;
- case SkScriptEngine2::kIntegerAccumulator:
- case SkScriptEngine2::kIntegerOperand:
- registerLoad = op - SkScriptEngine2::kIntegerAccumulator;
- memcpy(&operand[registerLoad].fS32, opCode, sizeof(int32_t));
- opCode += sizeof(int32_t);
- break;
- case SkScriptEngine2::kScalarAccumulator:
- case SkScriptEngine2::kScalarOperand:
- registerLoad = op - SkScriptEngine2::kScalarAccumulator;
- memcpy(&operand[registerLoad].fScalar, opCode, sizeof(SkScalar));
- opCode += sizeof(SkScalar);
- break;
- case SkScriptEngine2::kStringAccumulator:
- case SkScriptEngine2::kStringOperand: {
- SkString* strPtr = new SkString();
- track(strPtr);
- registerLoad = op - SkScriptEngine2::kStringAccumulator;
- memcpy(&size, opCode, sizeof(size));
- opCode += sizeof(size);
- strPtr->set((char*) opCode, size);
- opCode += size;
- operand[registerLoad].fString = strPtr;
- } break;
- case SkScriptEngine2::kStringTrack: // call after kObjectToValue
- track(operand[0].fString);
- break;
- case SkScriptEngine2::kBoxToken: {
- SkOperand2::OpType type;
- memcpy(&type, opCode, sizeof(type));
- opCode += sizeof(type);
- SkScriptCallBackConvert* callBackBox = (SkScriptCallBackConvert*) callBack;
- if (callBackBox->convert(type, &operand[0]) == false)
- return false;
- } break;
- case SkScriptEngine2::kUnboxToken:
- case SkScriptEngine2::kUnboxToken2: {
- SkScriptCallBackConvert* callBackUnbox = (SkScriptCallBackConvert*) callBack;
- if (callBackUnbox->convert(SkOperand2::kObject, &operand[0]) == false)
- return false;
- } break;
- case SkScriptEngine2::kIfOp:
- case SkScriptEngine2::kLogicalAndInt:
- memcpy(&size, opCode, sizeof(size));
- opCode += sizeof(size);
- if (operand[0].fS32 == 0)
- opCode += size; // skip to else (or end of if predicate)
- break;
- case SkScriptEngine2::kElseOp:
- memcpy(&size, opCode, sizeof(size));
- opCode += sizeof(size);
- opCode += size; // if true: after predicate, always skip to end of else
- break;
- case SkScriptEngine2::kLogicalOrInt:
- memcpy(&size, opCode, sizeof(size));
- opCode += sizeof(size);
- if (operand[0].fS32 != 0)
- opCode += size; // skip to kToBool opcode after || predicate
- break;
- // arithmetic conversion ops
- case SkScriptEngine2::kFlipOpsOp:
- SkTSwap(operand[0], operand[1]);
- break;
- case SkScriptEngine2::kIntToString:
- case SkScriptEngine2::kIntToString2:
- case SkScriptEngine2::kScalarToString:
- case SkScriptEngine2::kScalarToString2:{
- SkString* strPtr = new SkString();
- track(strPtr);
- if (op == SkScriptEngine2::kIntToString || op == SkScriptEngine2::kIntToString2)
- strPtr->appendS32(operand[op - SkScriptEngine2::kIntToString].fS32);
- else
- strPtr->appendScalar(operand[op - SkScriptEngine2::kScalarToString].fScalar);
- operand[0].fString = strPtr;
- } break;
- case SkScriptEngine2::kIntToScalar:
- case SkScriptEngine2::kIntToScalar2:
- operand[0].fScalar = SkScriptEngine2::IntToScalar(operand[op - SkScriptEngine2::kIntToScalar].fS32);
- break;
- case SkScriptEngine2::kStringToInt:
- if (SkParse::FindS32(operand[0].fString->c_str(), &operand[0].fS32) == false)
- return false;
- break;
- case SkScriptEngine2::kStringToScalar:
- case SkScriptEngine2::kStringToScalar2:
- if (SkParse::FindScalar(operand[0].fString->c_str(),
- &operand[op - SkScriptEngine2::kStringToScalar].fScalar) == false)
- return false;
- break;
- case SkScriptEngine2::kScalarToInt:
- operand[0].fS32 = SkScalarFloor(operand[0].fScalar);
- break;
- // arithmetic ops
- case SkScriptEngine2::kAddInt:
- operand[0].fS32 += operand[1].fS32;
- break;
- case SkScriptEngine2::kAddScalar:
- operand[0].fScalar += operand[1].fScalar;
- break;
- case SkScriptEngine2::kAddString:
-// if (fTrackString.find(operand[1].fString) < 0) {
-// operand[1].fString = SkNEW_ARGS(SkString, (*operand[1].fString));
-// track(operand[1].fString);
-// }
- operand[0].fString->append(*operand[1].fString);
- break;
- case SkScriptEngine2::kBitAndInt:
- operand[0].fS32 &= operand[1].fS32;
- break;
- case SkScriptEngine2::kBitNotInt:
- operand[0].fS32 = ~operand[0].fS32;
- break;
- case SkScriptEngine2::kBitOrInt:
- operand[0].fS32 |= operand[1].fS32;
- break;
- case SkScriptEngine2::kDivideInt:
- SkASSERT(operand[1].fS32 != 0);
- if (operand[1].fS32 == 0)
- operand[0].fS32 = operand[0].fS32 == 0 ? SK_NaN32 :
- operand[0].fS32 > 0 ? SK_MaxS32 : -SK_MaxS32;
- else
- if (operand[1].fS32 != 0) // throw error on divide by zero?
- operand[0].fS32 /= operand[1].fS32;
- break;
- case SkScriptEngine2::kDivideScalar:
- if (operand[1].fScalar == 0)
- operand[0].fScalar = operand[0].fScalar == 0 ? SK_ScalarNaN :
- operand[0].fScalar > 0 ? SK_ScalarMax : -SK_ScalarMax;
- else
- operand[0].fScalar = SkScalarDiv(operand[0].fScalar, operand[1].fScalar);
- break;
- case SkScriptEngine2::kEqualInt:
- operand[0].fS32 = operand[0].fS32 == operand[1].fS32;
- break;
- case SkScriptEngine2::kEqualScalar:
- operand[0].fS32 = operand[0].fScalar == operand[1].fScalar;
- break;
- case SkScriptEngine2::kEqualString:
- operand[0].fS32 = *operand[0].fString == *operand[1].fString;
- break;
- case SkScriptEngine2::kGreaterEqualInt:
- operand[0].fS32 = operand[0].fS32 >= operand[1].fS32;
- break;
- case SkScriptEngine2::kGreaterEqualScalar:
- operand[0].fS32 = operand[0].fScalar >= operand[1].fScalar;
- break;
- case SkScriptEngine2::kGreaterEqualString:
- operand[0].fS32 = strcmp(operand[0].fString->c_str(), operand[1].fString->c_str()) >= 0;
- break;
- case SkScriptEngine2::kToBool:
- operand[0].fS32 = !! operand[0].fS32;
- break;
- case SkScriptEngine2::kLogicalNotInt:
- operand[0].fS32 = ! operand[0].fS32;
- break;
- case SkScriptEngine2::kMinusInt:
- operand[0].fS32 = -operand[0].fS32;
- break;
- case SkScriptEngine2::kMinusScalar:
- operand[0].fScalar = -operand[0].fScalar;
- break;
- case SkScriptEngine2::kModuloInt:
- operand[0].fS32 %= operand[1].fS32;
- break;
- case SkScriptEngine2::kModuloScalar:
- operand[0].fScalar = SkScalarMod(operand[0].fScalar, operand[1].fScalar);
- break;
- case SkScriptEngine2::kMultiplyInt:
- operand[0].fS32 *= operand[1].fS32;
- break;
- case SkScriptEngine2::kMultiplyScalar:
- operand[0].fScalar = SkScalarMul(operand[0].fScalar, operand[1].fScalar);
- break;
- case SkScriptEngine2::kShiftLeftInt:
- operand[0].fS32 <<= operand[1].fS32;
- break;
- case SkScriptEngine2::kShiftRightInt:
- operand[0].fS32 >>= operand[1].fS32;
- break;
- case SkScriptEngine2::kSubtractInt:
- operand[0].fS32 -= operand[1].fS32;
- break;
- case SkScriptEngine2::kSubtractScalar:
- operand[0].fScalar -= operand[1].fScalar;
- break;
- case SkScriptEngine2::kXorInt:
- operand[0].fS32 ^= operand[1].fS32;
- break;
- case SkScriptEngine2::kEnd:
- goto done;
- case SkScriptEngine2::kNop:
- SkASSERT(0);
+ SkOperand2 operand[2]; // 1=accumulator and 2=operand
+ SkScriptEngine2::TypeOp op;
+ size_t ref;
+ int index, size;
+ int registerLoad;
+ SkScriptCallBack* callBack SK_INIT_TO_AVOID_WARNING;
+ do {
+ switch ((op = (SkScriptEngine2::TypeOp) *opCode++)) {
+ case SkScriptEngine2::kArrayToken: // create an array
+ operand[0].fArray = new SkOpArray(SkOperand2::kNoType /*fReturnType*/);
+ break;
+ case SkScriptEngine2::kArrayIndex: // array accessor
+ index = operand[1].fS32;
+ if (index >= operand[0].fArray->count()) {
+ fError = kArrayIndexOutOfBounds;
+ return false;
+ }
+ operand[0] = operand[0].fArray->begin()[index];
+ break;
+ case SkScriptEngine2::kArrayParam: // array initializer, or function param
+ *operand[0].fArray->append() = operand[1];
+ break;
+ case SkScriptEngine2::kCallback:
+ memcpy(&index, opCode, sizeof(index));
+ opCode += sizeof(index);
+ callBack = fCallBackArray[index];
+ break;
+ case SkScriptEngine2::kFunctionCall: {
+ memcpy(&ref, opCode, sizeof(ref));
+ opCode += sizeof(ref);
+ SkScriptCallBackFunction* callBackFunction = (SkScriptCallBackFunction*) callBack;
+ if (callBackFunction->invoke(ref, operand[0].fArray, /* params */
+ &operand[0] /* result */) == false) {
+ fError = kFunctionCallFailed;
+ return false;
+ }
+ } break;
+ case SkScriptEngine2::kMemberOp: {
+ memcpy(&ref, opCode, sizeof(ref));
+ opCode += sizeof(ref);
+ SkScriptCallBackMember* callBackMember = (SkScriptCallBackMember*) callBack;
+ if (callBackMember->invoke(ref, operand[0].fObject, &operand[0]) == false) {
+ fError = kMemberOpFailed;
+ return false;
+ }
+ } break;
+ case SkScriptEngine2::kPropertyOp: {
+ memcpy(&ref, opCode, sizeof(ref));
+ opCode += sizeof(ref);
+ SkScriptCallBackProperty* callBackProperty = (SkScriptCallBackProperty*) callBack;
+ if (callBackProperty->getResult(ref, &operand[0])== false) {
+ fError = kPropertyOpFailed;
+ return false;
+ }
+ } break;
+ case SkScriptEngine2::kAccumulatorPop:
+ fRunStack.pop(&operand[0]);
+ break;
+ case SkScriptEngine2::kAccumulatorPush:
+ *fRunStack.push() = operand[0];
+ break;
+ case SkScriptEngine2::kIntegerAccumulator:
+ case SkScriptEngine2::kIntegerOperand:
+ registerLoad = op - SkScriptEngine2::kIntegerAccumulator;
+ memcpy(&operand[registerLoad].fS32, opCode, sizeof(int32_t));
+ opCode += sizeof(int32_t);
+ break;
+ case SkScriptEngine2::kScalarAccumulator:
+ case SkScriptEngine2::kScalarOperand:
+ registerLoad = op - SkScriptEngine2::kScalarAccumulator;
+ memcpy(&operand[registerLoad].fScalar, opCode, sizeof(SkScalar));
+ opCode += sizeof(SkScalar);
+ break;
+ case SkScriptEngine2::kStringAccumulator:
+ case SkScriptEngine2::kStringOperand: {
+ SkString* strPtr = new SkString();
+ track(strPtr);
+ registerLoad = op - SkScriptEngine2::kStringAccumulator;
+ memcpy(&size, opCode, sizeof(size));
+ opCode += sizeof(size);
+ strPtr->set((char*) opCode, size);
+ opCode += size;
+ operand[registerLoad].fString = strPtr;
+ } break;
+ case SkScriptEngine2::kStringTrack: // call after kObjectToValue
+ track(operand[0].fString);
+ break;
+ case SkScriptEngine2::kBoxToken: {
+ SkOperand2::OpType type;
+ memcpy(&type, opCode, sizeof(type));
+ opCode += sizeof(type);
+ SkScriptCallBackConvert* callBackBox = (SkScriptCallBackConvert*) callBack;
+ if (callBackBox->convert(type, &operand[0]) == false)
+ return false;
+ } break;
+ case SkScriptEngine2::kUnboxToken:
+ case SkScriptEngine2::kUnboxToken2: {
+ SkScriptCallBackConvert* callBackUnbox = (SkScriptCallBackConvert*) callBack;
+ if (callBackUnbox->convert(SkOperand2::kObject, &operand[0]) == false)
+ return false;
+ } break;
+ case SkScriptEngine2::kIfOp:
+ case SkScriptEngine2::kLogicalAndInt:
+ memcpy(&size, opCode, sizeof(size));
+ opCode += sizeof(size);
+ if (operand[0].fS32 == 0)
+ opCode += size; // skip to else (or end of if predicate)
+ break;
+ case SkScriptEngine2::kElseOp:
+ memcpy(&size, opCode, sizeof(size));
+ opCode += sizeof(size);
+ opCode += size; // if true: after predicate, always skip to end of else
+ break;
+ case SkScriptEngine2::kLogicalOrInt:
+ memcpy(&size, opCode, sizeof(size));
+ opCode += sizeof(size);
+ if (operand[0].fS32 != 0)
+ opCode += size; // skip to kToBool opcode after || predicate
+ break;
+ // arithmetic conversion ops
+ case SkScriptEngine2::kFlipOpsOp:
+ SkTSwap(operand[0], operand[1]);
+ break;
+ case SkScriptEngine2::kIntToString:
+ case SkScriptEngine2::kIntToString2:
+ case SkScriptEngine2::kScalarToString:
+ case SkScriptEngine2::kScalarToString2:{
+ SkString* strPtr = new SkString();
+ track(strPtr);
+ if (op == SkScriptEngine2::kIntToString || op == SkScriptEngine2::kIntToString2)
+ strPtr->appendS32(operand[op - SkScriptEngine2::kIntToString].fS32);
+ else
+ strPtr->appendScalar(operand[op - SkScriptEngine2::kScalarToString].fScalar);
+ operand[0].fString = strPtr;
+ } break;
+ case SkScriptEngine2::kIntToScalar:
+ case SkScriptEngine2::kIntToScalar2:
+ operand[0].fScalar = SkScriptEngine2::IntToScalar(operand[op - SkScriptEngine2::kIntToScalar].fS32);
+ break;
+ case SkScriptEngine2::kStringToInt:
+ if (SkParse::FindS32(operand[0].fString->c_str(), &operand[0].fS32) == false)
+ return false;
+ break;
+ case SkScriptEngine2::kStringToScalar:
+ case SkScriptEngine2::kStringToScalar2:
+ if (SkParse::FindScalar(operand[0].fString->c_str(),
+ &operand[op - SkScriptEngine2::kStringToScalar].fScalar) == false)
+ return false;
+ break;
+ case SkScriptEngine2::kScalarToInt:
+ operand[0].fS32 = SkScalarFloor(operand[0].fScalar);
+ break;
+ // arithmetic ops
+ case SkScriptEngine2::kAddInt:
+ operand[0].fS32 += operand[1].fS32;
+ break;
+ case SkScriptEngine2::kAddScalar:
+ operand[0].fScalar += operand[1].fScalar;
+ break;
+ case SkScriptEngine2::kAddString:
+// if (fTrackString.find(operand[1].fString) < 0) {
+// operand[1].fString = SkNEW_ARGS(SkString, (*operand[1].fString));
+// track(operand[1].fString);
+// }
+ operand[0].fString->append(*operand[1].fString);
+ break;
+ case SkScriptEngine2::kBitAndInt:
+ operand[0].fS32 &= operand[1].fS32;
+ break;
+ case SkScriptEngine2::kBitNotInt:
+ operand[0].fS32 = ~operand[0].fS32;
+ break;
+ case SkScriptEngine2::kBitOrInt:
+ operand[0].fS32 |= operand[1].fS32;
+ break;
+ case SkScriptEngine2::kDivideInt:
+ SkASSERT(operand[1].fS32 != 0);
+ if (operand[1].fS32 == 0)
+ operand[0].fS32 = operand[0].fS32 == 0 ? SK_NaN32 :
+ operand[0].fS32 > 0 ? SK_MaxS32 : -SK_MaxS32;
+ else
+ if (operand[1].fS32 != 0) // throw error on divide by zero?
+ operand[0].fS32 /= operand[1].fS32;
+ break;
+ case SkScriptEngine2::kDivideScalar:
+ if (operand[1].fScalar == 0)
+ operand[0].fScalar = operand[0].fScalar == 0 ? SK_ScalarNaN :
+ operand[0].fScalar > 0 ? SK_ScalarMax : -SK_ScalarMax;
+ else
+ operand[0].fScalar = SkScalarDiv(operand[0].fScalar, operand[1].fScalar);
+ break;
+ case SkScriptEngine2::kEqualInt:
+ operand[0].fS32 = operand[0].fS32 == operand[1].fS32;
+ break;
+ case SkScriptEngine2::kEqualScalar:
+ operand[0].fS32 = operand[0].fScalar == operand[1].fScalar;
+ break;
+ case SkScriptEngine2::kEqualString:
+ operand[0].fS32 = *operand[0].fString == *operand[1].fString;
+ break;
+ case SkScriptEngine2::kGreaterEqualInt:
+ operand[0].fS32 = operand[0].fS32 >= operand[1].fS32;
+ break;
+ case SkScriptEngine2::kGreaterEqualScalar:
+ operand[0].fS32 = operand[0].fScalar >= operand[1].fScalar;
+ break;
+ case SkScriptEngine2::kGreaterEqualString:
+ operand[0].fS32 = strcmp(operand[0].fString->c_str(), operand[1].fString->c_str()) >= 0;
+ break;
+ case SkScriptEngine2::kToBool:
+ operand[0].fS32 = !! operand[0].fS32;
+ break;
+ case SkScriptEngine2::kLogicalNotInt:
+ operand[0].fS32 = ! operand[0].fS32;
+ break;
+ case SkScriptEngine2::kMinusInt:
+ operand[0].fS32 = -operand[0].fS32;
+ break;
+ case SkScriptEngine2::kMinusScalar:
+ operand[0].fScalar = -operand[0].fScalar;
+ break;
+ case SkScriptEngine2::kModuloInt:
+ operand[0].fS32 %= operand[1].fS32;
+ break;
+ case SkScriptEngine2::kModuloScalar:
+ operand[0].fScalar = SkScalarMod(operand[0].fScalar, operand[1].fScalar);
+ break;
+ case SkScriptEngine2::kMultiplyInt:
+ operand[0].fS32 *= operand[1].fS32;
+ break;
+ case SkScriptEngine2::kMultiplyScalar:
+ operand[0].fScalar = SkScalarMul(operand[0].fScalar, operand[1].fScalar);
+ break;
+ case SkScriptEngine2::kShiftLeftInt:
+ operand[0].fS32 <<= operand[1].fS32;
+ break;
+ case SkScriptEngine2::kShiftRightInt:
+ operand[0].fS32 >>= operand[1].fS32;
+ break;
+ case SkScriptEngine2::kSubtractInt:
+ operand[0].fS32 -= operand[1].fS32;
+ break;
+ case SkScriptEngine2::kSubtractScalar:
+ operand[0].fScalar -= operand[1].fScalar;
+ break;
+ case SkScriptEngine2::kXorInt:
+ operand[0].fS32 ^= operand[1].fS32;
+ break;
+ case SkScriptEngine2::kEnd:
+ goto done;
+ case SkScriptEngine2::kNop:
+ SkASSERT(0);
default:
break;
- }
- } while (true);
+ }
+ } while (true);
done:
- fRunStack.push(operand[0]);
- return true;
+ fRunStack.push(operand[0]);
+ return true;
}
bool SkScriptRuntime::getResult(SkOperand2* result) {
- if (fRunStack.count() == 0)
- return false;
- fRunStack.pop(result);
- return true;
+ if (fRunStack.count() == 0)
+ return false;
+ fRunStack.pop(result);
+ return true;
}
-void SkScriptRuntime::track(SkOpArray* array) {
- SkASSERT(fTrackArray.find(array) < 0);
- *fTrackArray.append() = array;
+void SkScriptRuntime::track(SkOpArray* array) {
+ SkASSERT(fTrackArray.find(array) < 0);
+ *fTrackArray.append() = array;
}
-void SkScriptRuntime::track(SkString* string) {
- SkASSERT(fTrackString.find(string) < 0);
- *fTrackString.append() = string;
+void SkScriptRuntime::track(SkString* string) {
+ SkASSERT(fTrackString.find(string) < 0);
+ *fTrackString.append() = string;
}
void SkScriptRuntime::untrack(SkOpArray* array) {
- int index = fTrackArray.find(array);
- SkASSERT(index >= 0);
- fTrackArray.begin()[index] = NULL;
+ int index = fTrackArray.find(array);
+ SkASSERT(index >= 0);
+ fTrackArray.begin()[index] = NULL;
}
void SkScriptRuntime::untrack(SkString* string) {
- int index = fTrackString.find(string);
- SkASSERT(index >= 0);
- fTrackString.begin()[index] = NULL;
+ int index = fTrackString.find(string);
+ SkASSERT(index >= 0);
+ fTrackString.begin()[index] = NULL;
}
diff --git a/src/animator/SkScriptRuntime.h b/src/animator/SkScriptRuntime.h
index 7721bd2..3e73801 100644
--- a/src/animator/SkScriptRuntime.h
+++ b/src/animator/SkScriptRuntime.h
@@ -14,37 +14,37 @@
class SkScriptCallBack;
-typedef SkLongArray(SkString*) SkTDStringArray;
-typedef SkLongArray(SkScriptCallBack*) SkTDScriptCallBackArray;
+typedef SkLongArray(SkString*) SkTDStringArray;
+typedef SkLongArray(SkScriptCallBack*) SkTDScriptCallBackArray;
class SkScriptRuntime {
public:
- enum SkError {
- kNoError,
- kArrayIndexOutOfBounds,
- kCouldNotFindReferencedID,
- kFunctionCallFailed,
- kMemberOpFailed,
- kPropertyOpFailed
- };
+ enum SkError {
+ kNoError,
+ kArrayIndexOutOfBounds,
+ kCouldNotFindReferencedID,
+ kFunctionCallFailed,
+ kMemberOpFailed,
+ kPropertyOpFailed
+ };
- SkScriptRuntime(SkTDScriptCallBackArray& callBackArray) : fCallBackArray(callBackArray)
- { }
- ~SkScriptRuntime();
- bool executeTokens(unsigned char* opCode);
- bool getResult(SkOperand2* result);
- void untrack(SkOpArray* array);
- void untrack(SkString* string);
+ SkScriptRuntime(SkTDScriptCallBackArray& callBackArray) : fCallBackArray(callBackArray)
+ { }
+ ~SkScriptRuntime();
+ bool executeTokens(unsigned char* opCode);
+ bool getResult(SkOperand2* result);
+ void untrack(SkOpArray* array);
+ void untrack(SkString* string);
private:
- void track(SkOpArray* array);
- void track(SkString* string);
- SkTDScriptCallBackArray& fCallBackArray;
- SkError fError;
- SkTDStack<SkOperand2> fRunStack;
- SkLongArray(SkOpArray*) fTrackArray;
- SkTDStringArray fTrackString;
- // illegal
- SkScriptRuntime& operator=(const SkScriptRuntime&);
+ void track(SkOpArray* array);
+ void track(SkString* string);
+ SkTDScriptCallBackArray& fCallBackArray;
+ SkError fError;
+ SkTDStack<SkOperand2> fRunStack;
+ SkLongArray(SkOpArray*) fTrackArray;
+ SkTDStringArray fTrackString;
+ // illegal
+ SkScriptRuntime& operator=(const SkScriptRuntime&);
};
#endif // SkScriptRuntime_DEFINED
diff --git a/src/animator/SkScriptTokenizer.cpp b/src/animator/SkScriptTokenizer.cpp
index 90a50b6..9547a98 100644
--- a/src/animator/SkScriptTokenizer.cpp
+++ b/src/animator/SkScriptTokenizer.cpp
@@ -17,31 +17,31 @@
const SkScriptEngine2::OperatorAttributes SkScriptEngine2::gOpAttributes[] = {
{ SkOperand2::kNoType, SkOperand2::kNoType, kNoBias, kResultIsNotBoolean },
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString), kTowardsString, kResultIsNotBoolean }, // kAdd
{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kBitAnd
{ SkOperand2::kNoType, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kBitNot
{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kBitOr
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kDivide
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
- SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar |SkOperand2:: kString), kTowardsNumber,
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
+ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar |SkOperand2:: kString), kTowardsNumber,
kResultIsBoolean }, // kEqual
{ SkOperand2::kS32, SkOperand2::kNoType, kNoBias, kResultIsNotBoolean }, // kFlipOps
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString), kTowardsNumber,
kResultIsBoolean }, // kGreaterEqual
{ SkOperand2::kNoType, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kLogicalAnd (really, ToBool)
{ SkOperand2::kNoType, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kLogicalNot
{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kLogicalOr
{ SkOperand2::kNoType, SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kMinus
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
SkOperand2::OpType(SkOperand2::kS32 |SkOperand2:: kScalar), kNoBias, kResultIsNotBoolean }, // kModulo
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kMultiply
{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kShiftLeft
{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kShiftRight
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kSubtract
{ SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean } // kXor
};
@@ -120,7 +120,7 @@
}
SkScriptEngine2::SkScriptEngine2(SkOperand2::OpType returnType) : fActiveStream(&fStream),
-fTokenLength(0), fReturnType(returnType), fError(kNoError),
+fTokenLength(0), fReturnType(returnType), fError(kNoError),
fAccumulatorType(SkOperand2::kNoType),
fBranchPopAllowed(true), fConstExpression(true), fOperandInUse(false)
{
@@ -151,7 +151,7 @@
fActiveStream->write(&charOp, sizeof(charOp));
}
-void SkScriptEngine2::addTokenConst(SkScriptValue2* value, AddTokenRegister reg,
+void SkScriptEngine2::addTokenConst(SkScriptValue2* value, AddTokenRegister reg,
SkOperand2::OpType toType, SkScriptEngine2::TypeOp op) {
if (value->fIsConstant == SkScriptValue2::kConstant && convertTo(toType, value))
return;
@@ -243,7 +243,7 @@
if (nextChar == '>') {
op = kShiftRight;
goto twoChar;
- }
+ }
op = kGreaterEqual;
if (nextChar == '=')
goto twoChar;
@@ -272,7 +272,7 @@
twoChar:
advance++;
break;
- }
+ }
op = kLogicalNot;
break;
case '?':
@@ -316,7 +316,7 @@
} while (true);
signed char topPrecedence = gPrecedence[compare];
SkASSERT(topPrecedence != -1);
- if (topPrecedence > precedence || (topPrecedence == precedence &&
+ if (topPrecedence > precedence || (topPrecedence == precedence &&
gOpAttributes[op].fLeftType == SkOperand2::kNoType)) {
break;
}
@@ -331,14 +331,14 @@
return advance;
}
-bool SkScriptEngine2::convertParams(SkTDArray<SkScriptValue2>* params,
+bool SkScriptEngine2::convertParams(SkTDArray<SkScriptValue2>* params,
const SkOperand2::OpType* paramTypes, int paramCount) {
int count = params->count();
if (count > paramCount) {
SkASSERT(0);
return false; // too many parameters passed
}
- for (int index = 0; index < count; index++)
+ for (int index = 0; index < count; index++)
convertTo(paramTypes[index], &(*params)[index]);
return true;
}
@@ -355,7 +355,7 @@
return ConvertTo(this, toType, value);
}
-bool SkScriptEngine2::evaluateDot(const char*& script) {
+bool SkScriptEngine2::evaluateDot(const char*& script) {
size_t fieldLength = token_length(++script); // skip dot
SkASSERT(fieldLength > 0); // !!! add error handling
const char* field = script;
@@ -370,14 +370,14 @@
return false;
}
-bool SkScriptEngine2::evaluateDotParam(const char*& script, const char* field, size_t fieldLength) {
+bool SkScriptEngine2::evaluateDotParam(const char*& script, const char* field, size_t fieldLength) {
SkScriptValue2& top = fValueStack.top();
if (top.fType != SkOperand2::kObject)
return false;
void* object = top.fOperand.fObject;
fValueStack.pop();
char ch; // see if it is a simple member or a function
- while (is_ws(ch = script[0]))
+ while (is_ws(ch = script[0]))
script++;
bool success = true;
if (ch != '(')
@@ -389,7 +389,7 @@
if (success)
success = handleMemberFunction(field, fieldLength, object, ¶ms);
}
- return success;
+ return success;
}
bool SkScriptEngine2::evaluateScript(const char** scriptPtr, SkScriptValue2* value) {
@@ -492,7 +492,7 @@
{
SkOperand2::OpType type = fReturnType;
if (fReturnType == SkOperand2::kNoType) {
- // !!! short sighted; in the future, allow each returned array component to carry
+ // !!! short sighted; in the future, allow each returned array component to carry
// its own type, and let caller do any needed conversions
if (value->fOperand.fArray->count() == 0)
value->fOperand.fArray->setType(type = tokenValue.fType);
@@ -513,7 +513,7 @@
if (ch == '(') {
*fBraceStack.push() = kFunctionBrace;
SkString functionName(fToken, fTokenLength);
-
+
if (handleFunction(&script) == false)
return false;
lastPush = true;
@@ -611,7 +611,7 @@
SkASSERT(fValueStack.count() > 0); // !!! add error handling
SkScriptValue2 top;
fValueStack.pop(&top);
-
+
addTokenInt(top.fType);
addToken(kBoxToken);
top.fType = SkOperand2::kObject;
@@ -621,7 +621,7 @@
success = evaluateDotParam(script, token, tokenLength);
SkASSERT(success);
lastPush = true;
- continue;
+ continue;
}
// get next token, and evaluate immediately
success = evaluateDot(script);
@@ -638,7 +638,7 @@
*fBraceStack.push() = kArrayBrace;
operand.fOperand.fArray = value->fOperand.fArray = new SkOpArray(fReturnType);
track(value->fOperand.fArray);
-
+
operand.fType = SkOperand2::kArray;
operand.fIsConstant = SkScriptValue2::kVariable;
fValueStack.push(operand);
@@ -663,7 +663,7 @@
}
#endif
if (ch == ')' && fBraceStack.count() > 0) {
- BraceStyle braceStyle = fBraceStack.top();
+ BraceStyle braceStyle = fBraceStack.top();
if (braceStyle == kFunctionBrace) {
fBraceStack.pop();
break;
@@ -681,7 +681,7 @@
}
char nextChar = script[1];
int advance = logicalOp(ch, nextChar);
- if (advance == 0)
+ if (advance == 0)
advance = arithmeticOp(ch, nextChar, lastPush);
if (advance == 0) // unknown token
return false;
@@ -760,7 +760,7 @@
if (fValueStack.count() == 0)
return false;
fValueStack.pop(value);
- if (value->fType != fReturnType && value->fType == SkOperand2::kObject &&
+ if (value->fType != fReturnType && value->fType == SkOperand2::kObject &&
fReturnType != SkOperand2::kNoType)
convertTo(fReturnType, value);
}
@@ -850,7 +850,7 @@
return success;
}
-bool SkScriptEngine2::handleMemberFunction(const char* field, size_t len, void* object,
+bool SkScriptEngine2::handleMemberFunction(const char* field, size_t len, void* object,
SkTDArray<SkScriptValue2>* params) {
bool success = true;
for (SkScriptCallBack** callBack = fCallBackArray.begin(); callBack < fCallBackArray.end(); callBack++) {
@@ -980,13 +980,13 @@
case kParen:
case kArrayOp:
SkASSERT(fOpStack.count() > 1 && fOpStack.top() == op); // !!! add error handling
- if (op == kParen)
+ if (op == kParen)
fOpStack.pop();
else {
SkScriptValue2 value;
fValueStack.pop(&value);
SkASSERT(value.fType == SkOperand2::kS32 || value.fType == SkOperand2::kScalar); // !!! add error handling (although, could permit strings eventually)
- int index = value.fType == SkOperand2::kScalar ? SkScalarFloor(value.fOperand.fScalar) :
+ int index = value.fType == SkOperand2::kScalar ? SkScalarFloor(value.fOperand.fScalar) :
value.fOperand.fS32;
SkScriptValue2 arrayValue;
fValueStack.pop(&arrayValue);
@@ -1046,7 +1046,7 @@
// if 'or', write bne goto to bool
addToken(op == kLogicalAnd ? kLogicalAndInt : kLogicalOrInt);
Branch branch(op, fOpStack.count(), getTokenOffset());
- addTokenInt(0); // placeholder for future branch
+ addTokenInt(0); // placeholder for future branch
oldTop.fPrimed = wasPrime;
oldTop.fDone = wasDone;
*fBranchStack.push() = branch;
@@ -1073,7 +1073,7 @@
bool constantOperands = value2.fIsConstant == SkScriptValue2::kConstant;
if (attributes->fLeftType != SkOperand2::kNoType) {
fValueStack.pop(&value1);
- constantOperands &= value1.fIsConstant == SkScriptValue2::kConstant;
+ constantOperands &= value1.fIsConstant == SkScriptValue2::kConstant;
value1.fIsWritten = SkScriptValue2::kUnwritten;
if (op == kFlipOps) {
SkTSwap(value1, value2);
@@ -1094,17 +1094,17 @@
}
if (attributes->fLeftType != SkOperand2::kNoType) {
if (value1.fType != value2.fType) {
- if ((attributes->fLeftType & SkOperand2::kString) && attributes->fBias & kTowardsString &&
+ if ((attributes->fLeftType & SkOperand2::kString) && attributes->fBias & kTowardsString &&
((value1.fType | value2.fType) & SkOperand2::kString)) {
if (value1.fType == SkOperand2::kS32 || value1.fType == SkOperand2::kScalar) {
- addTokenConst(&value1, kAccumulator, SkOperand2::kString,
+ addTokenConst(&value1, kAccumulator, SkOperand2::kString,
value1.fType == SkOperand2::kS32 ? kIntToString : kScalarToString);
}
if (value2.fType == SkOperand2::kS32 || value2.fType == SkOperand2::kScalar) {
- addTokenConst(&value2, kOperand, SkOperand2::kString,
+ addTokenConst(&value2, kOperand, SkOperand2::kString,
value2.fType == SkOperand2::kS32 ? kIntToString2 : kScalarToString2);
}
- } else if (attributes->fLeftType & SkOperand2::kScalar && ((value1.fType | value2.fType) &
+ } else if (attributes->fLeftType & SkOperand2::kScalar && ((value1.fType | value2.fType) &
SkOperand2::kScalar)) {
if (value1.fType == SkOperand2::kS32)
addTokenConst(&value1, kAccumulator, SkOperand2::kScalar, kIntToScalar);
@@ -1115,7 +1115,7 @@
if ((value1.fType & attributes->fLeftType) == 0 || value1.fType != value2.fType) {
if (value1.fType == SkOperand2::kString)
addTokenConst(&value1, kAccumulator, SkOperand2::kScalar, kStringToScalar);
- if (value1.fType == SkOperand2::kScalar && (attributes->fLeftType == SkOperand2::kS32 ||
+ if (value1.fType == SkOperand2::kScalar && (attributes->fLeftType == SkOperand2::kS32 ||
value2.fType == SkOperand2::kS32))
addTokenConst(&value1, kAccumulator, SkOperand2::kS32, kScalarToInt);
}
@@ -1125,7 +1125,7 @@
if ((value2.fType & attributes->fRightType) == 0 || value1.fType != value2.fType) {
if (value2.fType == SkOperand2::kString)
addTokenConst(&value2, rhRegister, SkOperand2::kScalar, kStringToScalar2);
- if (value2.fType == SkOperand2::kScalar && (attributes->fRightType == SkOperand2::kS32 ||
+ if (value2.fType == SkOperand2::kScalar && (attributes->fRightType == SkOperand2::kS32 ||
value1.fType == SkOperand2::kS32))
addTokenConst(&value2, rhRegister, SkOperand2::kS32, kScalarToInt2);
}
@@ -1154,7 +1154,7 @@
if (constantOperands) {
addToken(kEnd);
SkAutoDataUnref data(fStream.copyToData());
-#ifdef SK_DEBUG
+#ifdef SK_DEBUG
decompile(data->bytes(), data->size());
#endif
SkScriptRuntime runtime(fCallBackArray);
@@ -1195,7 +1195,7 @@
bool SkScriptEngine2::ConvertTo(SkScriptEngine2* engine, SkOperand2::OpType toType, SkScriptValue2* value ) {
SkASSERT(value);
SkOperand2::OpType type = value->fType;
- if (type == toType)
+ if (type == toType)
return true;
SkOperand2& operand = value->fOperand;
bool success = true;
@@ -1288,18 +1288,18 @@
static const SkScriptNAnswer2 scriptTests[] = {
testInt(1||(0&&3)),
testScalar(- -5.5- -1.5),
- testScalar(1.0+5),
+ testScalar(1.0+5),
testInt((6+7)*8),
testInt(3*(4+5)),
testScalar(1.0+2.0),
- testScalar(3.0-1.0),
- testScalar(6-1.0),
- testScalar(2.5*6.),
- testScalar(0.5*4),
- testScalar(4.5/.5),
- testScalar(9.5/19),
- testRemainder(9.5, 0.5),
- testRemainder(9.,2),
+ testScalar(3.0-1.0),
+ testScalar(6-1.0),
+ testScalar(2.5*6.),
+ testScalar(0.5*4),
+ testScalar(4.5/.5),
+ testScalar(9.5/19),
+ testRemainder(9.5, 0.5),
+ testRemainder(9.,2),
testRemainder(9,2.5),
testRemainder(-9,2.5),
testTrue(-9==-9.0),
diff --git a/src/animator/SkTDArray_Experimental.h b/src/animator/SkTDArray_Experimental.h
index e598a6d..094d106 100644
--- a/src/animator/SkTDArray_Experimental.h
+++ b/src/animator/SkTDArray_Experimental.h
@@ -38,9 +38,9 @@
int32_t* append() { return this->append(1, NULL); }
int32_t* append(U16CPU count, const int32_t* src = NULL);
- int32_t* appendClear()
- {
- int32_t* result = this->append();
+ int32_t* appendClear()
+ {
+ int32_t* result = this->append();
*result = 0;
return result;
}
@@ -108,9 +108,9 @@
SkTDS32Array(const SkTDS32Array<T>& src) : SkDS32Array(src) {}
~SkTDS32Array() { sk_free(fArray); }
T& operator[](int index) const { SYNC(); SkASSERT((unsigned)index < fCount); return ((T*) fArray)[index]; }
- SkTDS32Array<T>& operator=(const SkTDS32Array<T>& src) {
+ SkTDS32Array<T>& operator=(const SkTDS32Array<T>& src) {
return (SkTDS32Array<T>&) SkDS32Array::operator=(src); }
- friend int operator==(const SkTDS32Array<T>& a, const SkTDS32Array<T>& b) {
+ friend int operator==(const SkTDS32Array<T>& a, const SkTDS32Array<T>& b) {
return operator==((const SkDS32Array&) a, (const SkDS32Array&) b); }
T* append() { return (T*) SkDS32Array::append(); }
T* appendClear() { return (T*) SkDS32Array::appendClear(); }
diff --git a/src/animator/SkTextOnPath.cpp b/src/animator/SkTextOnPath.cpp
index e7f7651..7bdb7fd 100644
--- a/src/animator/SkTextOnPath.cpp
+++ b/src/animator/SkTextOnPath.cpp
@@ -33,7 +33,7 @@
SkASSERT(text);
SkASSERT(path);
SkBoundableAuto boundable(this, maker);
- maker.fCanvas->drawTextOnPathHV(text->getText(), text->getSize(),
+ maker.fCanvas->drawTextOnPathHV(text->getText(), text->getSize(),
path->getPath(), offset, 0, *maker.fPaint);
return false;
}
diff --git a/src/animator/SkTextToPath.cpp b/src/animator/SkTextToPath.cpp
index cf78ff5..b38daff 100644
--- a/src/animator/SkTextToPath.cpp
+++ b/src/animator/SkTextToPath.cpp
@@ -42,7 +42,7 @@
}
SkPaint realPaint;
paint->setupPaint(&realPaint);
- realPaint.getTextPath(text->getText(), text->getSize(), text->x,
+ realPaint.getTextPath(text->getText(), text->getSize(), text->x,
text->y, &path->getPath());
}
diff --git a/src/animator/SkTime.cpp b/src/animator/SkTime.cpp
index 35c7eb8..06ad9bd 100644
--- a/src/animator/SkTime.cpp
+++ b/src/animator/SkTime.cpp
@@ -51,7 +51,7 @@
{
tm syst;
time_t tm;
-
+
time(&tm);
localtime_r(&tm, &syst);
t->fYear = SkToU16(syst.tm_year);
diff --git a/src/animator/SkTypedArray.h b/src/animator/SkTypedArray.h
index 222c8df..e93b106 100644
--- a/src/animator/SkTypedArray.h
+++ b/src/animator/SkTypedArray.h
@@ -20,7 +20,7 @@
bool getIndex(int index, SkOperand* operand);
SkDisplayTypes getType() { return fType; }
SkScriptEngine::SkOpType getOpType() { return SkScriptEngine::ToOpType(fType); }
- void setType(SkDisplayTypes type) {
+ void setType(SkDisplayTypes type) {
// SkASSERT(count() == 0);
fType = type;
}