bool SkBaseBitmap::draw(SkAnimateMaker& maker) {
SkBoundableAuto boundable(this, maker);
maker.fCanvas->drawBitmap(fBitmap, x, y, maker.fPaint);
return false;
}
enum SkDrawBitmap_Properties {
SK_PROPERTY(erase)
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDrawBitmap::fInfo[] = {
SK_MEMBER_INHERITED,
SK_MEMBER_PROPERTY(erase, ARGB),
SK_MEMBER(format, BitmapFormat),
SK_MEMBER(height, Int),
SK_MEMBER(rowBytes, Int),
SK_MEMBER(width, Int),
};
#endif
DEFINE_GET_MEMBER(SkDrawBitmap);
SkDrawBitmap::SkDrawBitmap() : format((SkBitmap::Config) -1), height(-1),
rowBytes(0), width(-1), fColor(0), fColorSet(false) {
}
SkDrawBitmap::~SkDrawBitmap() {
SK_PROPERTY(descent)
};
// !!! in the future, this could be compiled by build-condensed-info into an array of parameters
// with a lookup table to find the first parameter -- for now, it is iteratively searched through
const SkFunctionParamType SkDrawPaint::fFunctionParameters[] = {
(SkFunctionParamType) SkType_String,
(SkFunctionParamType) 0 // terminator for parameter list (there may be multiple parameter lists)
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDrawPaint::fInfo[] = {
SK_MEMBER(antiAlias, Boolean),
SK_MEMBER_PROPERTY(ascent, Float),
SK_MEMBER(color, Color),
SK_MEMBER_PROPERTY(descent, Float),
SK_MEMBER(fakeBold, Boolean),
SK_MEMBER(filterBitmap, Boolean),
SK_MEMBER(linearText, Boolean),
SK_MEMBER(maskFilter, MaskFilter),
SK_MEMBER_FUNCTION(measureText, Float),
SK_MEMBER(pathEffect, PathEffect),
SK_MEMBER(shader, Shader),
SK_MEMBER(strikeThru, Boolean),
SK_MEMBER(stroke, Boolean),
SK_MEMBER(strokeCap, Cap),
SK_MEMBER(strokeJoin, Join),
SK_MEMBER(strokeMiter, Float),
SK_MEMBER(strokeWidth, Float),
#include "SkDisplayRandom.h"
#include "SkInterpolator.h"
enum SkDisplayRandom_Properties {
SK_PROPERTY(random),
SK_PROPERTY(seed)
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDisplayRandom::fInfo[] = {
SK_MEMBER(blend, Float),
SK_MEMBER(max, Float),
SK_MEMBER(min, Float),
SK_MEMBER_DYNAMIC_PROPERTY(random, Float),
SK_MEMBER_PROPERTY(seed, Int)
};
#endif
DEFINE_GET_MEMBER(SkDisplayRandom);
SkDisplayRandom::SkDisplayRandom() : blend(0), min(0), max(SK_Scalar1) {
}
#ifdef SK_DUMP_ENABLED
void SkDisplayRandom::dump(SkAnimateMaker* maker) {
dumpBase(maker);
SkDebugf("min=\"%g\" ", SkScalarToFloat(min));
SkDebugf("max=\"%g\" ", SkScalarToFloat(max));
SkDebugf("blend=\"%g\" ", SkScalarToFloat(blend));
SK_PROPERTY(rotate),
SK_PROPERTY(scale),
SK_PROPERTY(scaleX),
SK_PROPERTY(scaleY),
SK_PROPERTY(skewX),
SK_PROPERTY(skewY),
SK_PROPERTY(translate),
SK_PROPERTY(translateX),
SK_PROPERTY(translateY)
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDrawMatrix::fInfo[] = {
SK_MEMBER_ARRAY(matrix, Float),
SK_MEMBER_PROPERTY(perspectX, Float),
SK_MEMBER_PROPERTY(perspectY, Float),
SK_MEMBER_PROPERTY(rotate, Float),
SK_MEMBER_PROPERTY(scale, Float),
SK_MEMBER_PROPERTY(scaleX, Float),
SK_MEMBER_PROPERTY(scaleY, Float),
SK_MEMBER_PROPERTY(skewX, Float),
SK_MEMBER_PROPERTY(skewY, Float),
SK_MEMBER_PROPERTY(translate, Point),
SK_MEMBER_PROPERTY(translateX, Float),
SK_MEMBER_PROPERTY(translateY, Float)
};
#endif
DEFINE_GET_MEMBER(SkDrawMatrix);
#endif
enum SkDrawColor_Properties {
SK_PROPERTY(alpha),
SK_PROPERTY(blue),
SK_PROPERTY(green),
SK_PROPERTY(hue),
SK_PROPERTY(red),
SK_PROPERTY(saturation),
SK_PROPERTY(value)
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDrawColor::fInfo[] = {
SK_MEMBER_PROPERTY(alpha, Float),
SK_MEMBER_PROPERTY(blue, Float),
SK_MEMBER(color, ARGB),
SK_MEMBER_PROPERTY(green, Float),
SK_MEMBER_PROPERTY(hue, Float),
SK_MEMBER_PROPERTY(red, Float),
SK_MEMBER_PROPERTY(saturation, Float),
SK_MEMBER_PROPERTY(value, Float),
};
#endif
DEFINE_GET_MEMBER(SkDrawColor);
SkDrawColor::SkDrawColor() : fDirty(false) {
color = SK_ColorBLACK;
#include "SkCanvas.h"
#include "SkMath.h"
#include "SkMatrixParts.h"
#include "SkPaint.h"
#include "SkPathParts.h"
enum SkPath_Properties {
SK_PROPERTY(fillType),
SK_PROPERTY(length)
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDrawPath::fInfo[] = {
SK_MEMBER(d, String),
SK_MEMBER_PROPERTY(fillType, FillType),
SK_MEMBER_PROPERTY(length, Float)
};
#endif
DEFINE_GET_MEMBER(SkDrawPath);
SkDrawPath::SkDrawPath()
{
fParent = NULL;
fLength = SK_ScalarNaN;
fChildHasID = false;
fDirty = false;
}
#include "SkKey.h"
#include "SkMetaData.h"
#include "SkScript.h"
#include "SkUtils.h"
enum SkDisplayEvent_Properties {
SK_PROPERTY(key),
SK_PROPERTY(keys)
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDisplayEvent::fInfo[] = {
SK_MEMBER(code, EventCode),
SK_MEMBER(disable, Boolean),
SK_MEMBER_PROPERTY(key, String), // a single key (also last key pressed)
SK_MEMBER_PROPERTY(keys, String), // a single key or dash-delimited range of keys
SK_MEMBER(kind, EventKind),
SK_MEMBER(target, String),
SK_MEMBER(x, Float),
SK_MEMBER(y, Float)
};
#endif
DEFINE_GET_MEMBER(SkDisplayEvent);
SkDisplayEvent::SkDisplayEvent() : code((SkKey) -1), disable(false),
kind(kUser), x(0), y(0), fLastCode((SkKey) -1), fMax((SkKey) -1), fTarget(NULL) {
}
(SkFunctionParamType) SkType_Float, // random
(SkFunctionParamType) 0,
(SkFunctionParamType) SkType_Float, // round
(SkFunctionParamType) 0,
(SkFunctionParamType) SkType_Float, // sin
(SkFunctionParamType) 0,
(SkFunctionParamType) SkType_Float, // sqrt
(SkFunctionParamType) 0,
(SkFunctionParamType) SkType_Float, // tan
(SkFunctionParamType) 0
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDisplayMath::fInfo[] = {
SK_MEMBER_PROPERTY(E, Float),
SK_MEMBER_PROPERTY(LN10, Float),
SK_MEMBER_PROPERTY(LN2, Float),
SK_MEMBER_PROPERTY(LOG10E, Float),
SK_MEMBER_PROPERTY(LOG2E, Float),
SK_MEMBER_PROPERTY(PI, Float),
SK_MEMBER_PROPERTY(SQRT1_2, Float),
SK_MEMBER_PROPERTY(SQRT2, Float),
SK_MEMBER_FUNCTION(abs, Float),
SK_MEMBER_FUNCTION(acos, Float),
SK_MEMBER_FUNCTION(asin, Float),
SK_MEMBER_FUNCTION(atan, Float),
SK_MEMBER_FUNCTION(atan2, Float),
SK_MEMBER_FUNCTION(ceil, Float),
SK_MEMBER_FUNCTION(cos, Float),
SK_MEMBER_FUNCTION(exp, Float),
#endif
#include <ctype.h>
enum SkApply_Properties {
SK_PROPERTY(animator),
SK_PROPERTY(step),
SK_PROPERTY(steps),
SK_PROPERTY(time)
};
#if SK_USE_CONDENSED_INFO == 0
// if no attibutes, enclosed displayable is both scope & target
// only if both scope & target are specified, or if target and enclosed displayable, are scope and target different
const SkMemberInfo SkApply::fInfo[] = {
SK_MEMBER_PROPERTY(animator, Animate),
SK_MEMBER(begin, MSec),
SK_MEMBER(dontDraw, Boolean),
SK_MEMBER(dynamicScope, String),
SK_MEMBER(interval, MSec), // recommended redraw interval
SK_MEMBER(mode, ApplyMode),
#if 0
SK_MEMBER(pickup, Boolean),
#endif
SK_MEMBER(restore, Boolean),
SK_MEMBER(scope, Drawable), // thing that scopes animation (unnamed enclosed displayable goes here)
SK_MEMBER_PROPERTY(step, Int),
SK_MEMBER_PROPERTY(steps, Int),
SK_MEMBER_PROPERTY(time, MSec),
SK_MEMBER(transition, ApplyTransition)
};
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
#include "SkAnimateSet.h"
#include "SkAnimateMaker.h"
#include "SkAnimateProperties.h"
#include "SkParse.h"
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkSet::fInfo[] = {
SK_MEMBER(begin, MSec),
SK_MEMBER(dur, MSec),
SK_MEMBER_PROPERTY(dynamic, Boolean),
SK_MEMBER(field, String),
// SK_MEMBER(formula, DynamicString),
SK_MEMBER(lval, DynamicString),
// SK_MEMBER_PROPERTY(reset, Boolean),
SK_MEMBER_PROPERTY(step, Int),
SK_MEMBER(target, DynamicString),
SK_MEMBER(to, DynamicString)
};
#endif
DEFINE_GET_MEMBER(SkSet);
SkSet::SkSet() {
dur = 1;
// are not stored and have no effect
#if SK_USE_CONDENSED_INFO == 0
enum SkDump_Properties {
SK_PROPERTY(displayList),
SK_PROPERTY(eventList),
SK_PROPERTY(events),
SK_PROPERTY(groups),
SK_PROPERTY(name),
SK_PROPERTY(posts),
SK_PROPERTY(script)
};
const SkMemberInfo SkDump::fInfo[] = {
SK_MEMBER_PROPERTY(displayList, Boolean),
SK_MEMBER_PROPERTY(eventList, Boolean),
SK_MEMBER_PROPERTY(events, Boolean),
SK_MEMBER_PROPERTY(groups, Boolean),
SK_MEMBER_PROPERTY(name, String),
SK_MEMBER_PROPERTY(posts, Boolean),
SK_MEMBER_PROPERTY(script, String)
};
#endif
DEFINE_GET_MEMBER(SkDump);
bool SkDump::enable(SkAnimateMaker& maker ) {
return true;
}
#include "SkCanvas.h"
#include "SkMatrixParts.h"
#include "SkPaint.h"
#include "SkScript.h"
enum SkRectangle_Properties {
SK_PROPERTY(height),
SK_PROPERTY(needsRedraw),
SK_PROPERTY(width)
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDrawRect::fInfo[] = {
SK_MEMBER_ALIAS(bottom, fRect.fBottom, Float),
SK_MEMBER_PROPERTY(height, Float),
SK_MEMBER_ALIAS(left, fRect.fLeft, Float),
SK_MEMBER_PROPERTY(needsRedraw, Boolean),
SK_MEMBER_ALIAS(right, fRect.fRight, Float),
SK_MEMBER_ALIAS(top, fRect.fTop, Float),
SK_MEMBER_PROPERTY(width, Float)
};
#endif
DEFINE_GET_MEMBER(SkDrawRect);
SkDrawRect::SkDrawRect() : fParent(NULL) {
fRect.setEmpty();
}
};
enum SkDisplayString_Properties {
SK_PROPERTY(length)
};
const SkFunctionParamType SkDisplayString::fFunctionParameters[] = {
(SkFunctionParamType) SkType_Int, // slice
(SkFunctionParamType) SkType_Int,
(SkFunctionParamType) 0
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDisplayString::fInfo[] = {
SK_MEMBER_PROPERTY(length, Int),
SK_MEMBER_FUNCTION(slice, String),
SK_MEMBER(value, String)
};
#endif
DEFINE_GET_MEMBER(SkDisplayString);
SkDisplayString::SkDisplayString() {
}
SkDisplayString::SkDisplayString(SkString& copyFrom) : value(copyFrom) {
}
void SkDisplayString::executeFunction(SkDisplayable* target, int index,
#include "SkAnimateBase.h"
#include "SkAnimateMaker.h"
#include "SkAnimateProperties.h"
#include "SkAnimatorScript.h"
#include "SkDisplayApply.h"
#include "SkDrawable.h"
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkAnimateBase::fInfo[] = {
SK_MEMBER(begin, MSec),
SK_MEMBER_ARRAY(blend, Float),
SK_MEMBER(dur, MSec),
SK_MEMBER_PROPERTY(dynamic, Boolean),
SK_MEMBER(field, String), // name of member info in target
SK_MEMBER(formula, DynamicString),
SK_MEMBER(from, DynamicString),
SK_MEMBER(lval, DynamicString),
SK_MEMBER_PROPERTY(mirror, Boolean),
SK_MEMBER(repeat, Float),
SK_MEMBER_PROPERTY(reset, Boolean),
SK_MEMBER_PROPERTY(step, Int),
SK_MEMBER(target, DynamicString),
SK_MEMBER(to, DynamicString),
SK_MEMBER_PROPERTY(values, DynamicString)
};
#endif
*/
#include "SkDisplayNumber.h"
enum SkDisplayNumber_Properties {
SK_PROPERTY(MAX_VALUE),
SK_PROPERTY(MIN_VALUE),
SK_PROPERTY(NEGATIVE_INFINITY),
SK_PROPERTY(NaN),
SK_PROPERTY(POSITIVE_INFINITY)
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDisplayNumber::fInfo[] = {
SK_MEMBER_PROPERTY(MAX_VALUE, Float),
SK_MEMBER_PROPERTY(MIN_VALUE, Float),
SK_MEMBER_PROPERTY(NEGATIVE_INFINITY, Float),
SK_MEMBER_PROPERTY(NaN, Float),
SK_MEMBER_PROPERTY(POSITIVE_INFINITY, Float)
};
#endif
DEFINE_GET_MEMBER(SkDisplayNumber);
bool SkDisplayNumber::getProperty(int index, SkScriptValue* value) const {
SkScalar constant;
switch (index) {
case SK_PROPERTY(MAX_VALUE):
constant = SK_ScalarMax;
