bool SkAnimateBase::getProperty(int index, SkScriptValue* value) const { int boolResult; switch (index) { case SK_PROPERTY(dynamic): boolResult = fDynamic; goto returnBool; case SK_PROPERTY(mirror): boolResult = fMirror; goto returnBool; case SK_PROPERTY(reset): boolResult = fReset; returnBool: value->fOperand.fS32 = SkToBool(boolResult); value->fType = SkType_Boolean; break; case SK_PROPERTY(step): if (fApply == NULL) return false; // !!! notify there's an error? fApply->getStep(value); break; case SK_PROPERTY(values): value->fOperand.fString = (SkString*) &to; value->fType = SkType_String; break; default: SkASSERT(0); return false; } return true; }
bool SkDisplayNumber::getProperty(int index, SkScriptValue* value) const { SkScalar constant; switch (index) { case SK_PROPERTY(MAX_VALUE): constant = SK_ScalarMax; break; case SK_PROPERTY(MIN_VALUE): constant = SK_ScalarMin; break; case SK_PROPERTY(NEGATIVE_INFINITY): constant = -SK_ScalarInfinity; break; case SK_PROPERTY(NaN): constant = SK_ScalarNaN; break; case SK_PROPERTY(POSITIVE_INFINITY): constant = SK_ScalarInfinity; break; default: SkASSERT(0); return false; } value->fOperand.fScalar = constant; value->fType = SkType_Float; return true; }
bool SkDrawMatrix::getProperty(int index, SkScriptValue* value) const { value->fType = SkType_Float; SkScalar result; switch (index) { case SK_PROPERTY(perspectX): result = fMatrix.getPerspX(); break; case SK_PROPERTY(perspectY): result = fMatrix.getPerspY(); break; case SK_PROPERTY(scaleX): result = fMatrix.getScaleX(); break; case SK_PROPERTY(scaleY): result = fMatrix.getScaleY(); break; case SK_PROPERTY(skewX): result = fMatrix.getSkewX(); break; case SK_PROPERTY(skewY): result = fMatrix.getSkewY(); break; case SK_PROPERTY(translateX): result = fMatrix.getTranslateX(); break; case SK_PROPERTY(translateY): result = fMatrix.getTranslateY(); break; default: // SkASSERT(0); return false; } value->fOperand.fScalar = result; return true; }
bool SkApply::setProperty(int index, SkScriptValue& scriptValue) { switch (index) { case SK_PROPERTY(animator): { SkAnimateBase* animate = (SkAnimateBase*) scriptValue.fOperand.fDisplayable; SkASSERT(animate->isAnimate()); *fAnimators.append() = animate; return true; } case SK_PROPERTY(steps): steps = scriptValue.fOperand.fS32; if (fActive) fActive->setSteps(steps); return true; } return false; }
bool SkImageBaseBitmap::getProperty(int index, SkScriptValue* value) const { if (fDirty) resolve(); switch (index) { case SK_PROPERTY(height): value->fOperand.fS32 = fBitmap.height(); break; case SK_PROPERTY(width): value->fOperand.fS32 = fBitmap.width(); break; default: SkASSERT(0); return false; } value->fType = SkType_Int; return true; }
bool SkDrawColor::getProperty(int index, SkScriptValue* value) const { value->fType = SkType_Float; SkScalar result; switch(index) { case SK_PROPERTY(alpha): result = SkIntToScalar(SkColorGetA(color)) / 255; break; case SK_PROPERTY(blue): result = SkIntToScalar(SkColorGetB(color)); break; case SK_PROPERTY(green): result = SkIntToScalar(SkColorGetG(color)); break; case SK_PROPERTY(hue): result = RGB_to_HSV(color, kGetHue); break; case SK_PROPERTY(red): result = SkIntToScalar(SkColorGetR(color)); break; case SK_PROPERTY(saturation): result = RGB_to_HSV(color, kGetSaturation); break; case SK_PROPERTY(value): result = RGB_to_HSV(color, kGetValue); break; default: SkASSERT(0); return false; } value->fOperand.fScalar = result; return true; }
bool SkDrawRect::setProperty(int index, SkScriptValue& value) { SkScalar scalar = value.fOperand.fScalar; switch (index) { case SK_PROPERTY(height): SkASSERT(value.fType == SkType_Float); fRect.fBottom = scalar + fRect.fTop; return true; case SK_PROPERTY(needsRedraw): return false; case SK_PROPERTY(width): SkASSERT(value.fType == SkType_Float); fRect.fRight = scalar + fRect.fLeft; return true; default: SkASSERT(0); } return false; }
bool SkDisplayEvent::setProperty(int index, SkScriptValue& value) { SkASSERT(index == SK_PROPERTY(key) || index == SK_PROPERTY(keys)); SkASSERT(value.fType == SkType_String); SkString* string = value.fOperand.fString; const char* chars = string->c_str(); int count = SkUTF8_CountUnichars(chars); SkASSERT(count >= 1); code = (SkKey) SkUTF8_NextUnichar(&chars); fMax = code; SkASSERT(count == 1 || index == SK_PROPERTY(keys)); if (--count > 0) { SkASSERT(*chars == '-'); chars++; fMax = (SkKey) SkUTF8_NextUnichar(&chars); SkASSERT(fMax >= code); } return true; }
bool SkApply::getProperty(int index, SkScriptValue* value) const { switch (index) { case SK_PROPERTY(step): value->fType = SkType_Int; value->fOperand.fS32 = fLastTime / SK_MSec1; break; case SK_PROPERTY(steps): value->fType = SkType_Int; value->fOperand.fS32 = steps; break; case SK_PROPERTY(time): value->fType = SkType_MSec; value->fOperand.fS32 = fLastTime; break; default: // SkASSERT(0); return false; } return true; }
bool SkDrawPaint::getProperty(int index, SkScriptValue* value) const { SkPaint::FontMetrics metrics; SkPaint paint; setupPaint(&paint); paint.getFontMetrics(&metrics); switch (index) { case SK_PROPERTY(ascent): value->fOperand.fScalar = metrics.fAscent; break; case SK_PROPERTY(descent): value->fOperand.fScalar = metrics.fDescent; break; // should consider returning fLeading as well (or roll it into ascent/descent somehow default: SkASSERT(0); return false; } value->fType = SkType_Float; return true; }
bool SkDrawPath::getProperty(int index, SkScriptValue* value) const { switch (index) { case SK_PROPERTY(length): if (SkScalarIsNaN(fLength)) { const SkPath& path = ((SkDrawPath*) this)->getPath(); SkPathMeasure pathMeasure(path, false); fLength = pathMeasure.getLength(); } value->fType = SkType_Float; value->fOperand.fScalar = fLength; break; case SK_PROPERTY(fillType): value->fType = SkType_FillType; value->fOperand.fS32 = (int) fPath.getFillType(); break; default: SkASSERT(0); return false; } return true; }
bool SkDisplayArray::getProperty(int index, SkScriptValue* value) const { switch (index) { case SK_PROPERTY(length): value->fType = SkType_Int; value->fOperand.fS32 = values.count(); break; default: SkASSERT(0); return false; } return true; }
bool SkDisplayString::getProperty(int index, SkScriptValue* scriptValue) const { switch (index) { case SK_PROPERTY(length): scriptValue->fType = SkType_Int; scriptValue->fOperand.fS32 = (int32_t) value.size(); break; default: SkASSERT(0); return false; } return true; }
bool SkDrawRect::getProperty(int index, SkScriptValue* value) const { SkScalar result; switch (index) { case SK_PROPERTY(height): result = fRect.height(); break; case SK_PROPERTY(needsRedraw): value->fType = SkType_Boolean; value->fOperand.fS32 = fBounds.isEmpty() == false; return true; case SK_PROPERTY(width): result = fRect.width(); break; default: SkASSERT(0); return false; } value->fType = SkType_Float; value->fOperand.fScalar = result; return true; }
bool SkDisplayEvent::getProperty(int index, SkScriptValue* value) const { switch (index) { case SK_PROPERTY(key): case SK_PROPERTY(keys): { value->fType = SkType_String; char scratch[8]; SkKey convert = index == SK_PROPERTY(keys) ? code : fLastCode; size_t size = convert > 0 ? SkUTF8_FromUnichar(convert, scratch) : 0; fKeyString.set(scratch, size); value->fOperand.fString = &fKeyString; if (index != SK_PROPERTY(keys) || fMax == (SkKey) -1 || fMax == code) break; value->fOperand.fString->append("-"); size = SkUTF8_FromUnichar(fMax, scratch); value->fOperand.fString->append(scratch, size); } break; default: SkASSERT(0); return false; } return true; }
bool SkDrawBitmap::setProperty(int index, SkScriptValue& value) { switch (index) { case SK_PROPERTY(erase): SkASSERT(value.fType == SkType_ARGB); fColor = value.fOperand.fS32; fColorSet = true; break; default: SkASSERT(0); return false; } return true; }
bool SkDisplayRandom::getProperty(int index, SkScriptValue* value) const { switch(index) { case SK_PROPERTY(random): { SkScalar random = fRandom.nextUScalar1(); SkScalar relativeT = SkUnitCubicInterp(random, SK_Scalar1 - blend, 0, 0, SK_Scalar1 - blend); value->fOperand.fScalar = min + SkScalarMul(max - min, relativeT); value->fType = SkType_Float; return true; } default: SkASSERT(0); } return false; }
bool SkDrawPath::setProperty(int index, SkScriptValue& value) { switch (index) { case SK_PROPERTY(fillType): SkASSERT(value.fType == SkType_FillType); SkASSERT(value.fOperand.fS32 >= SkPath::kWinding_FillType && value.fOperand.fS32 <= SkPath::kEvenOdd_FillType); fPath.setFillType((SkPath::FillType) value.fOperand.fS32); break; default: SkASSERT(0); return false; } return true; }
bool SkAnimateBase::setProperty(int index, SkScriptValue& value) { bool boolValue = SkToBool(value.fOperand.fS32); switch (index) { case SK_PROPERTY(dynamic): fDynamic = boolValue; goto checkForBool; case SK_PROPERTY(values): fHasValues = true; SkASSERT(value.fType == SkType_String); to = *value.fOperand.fString; break; case SK_PROPERTY(mirror): fMirror = boolValue; goto checkForBool; case SK_PROPERTY(reset): fReset = boolValue; checkForBool: SkASSERT(value.fType == SkType_Boolean); break; default: return false; } return true; }
bool SkDrawColor::setProperty(int index, SkScriptValue& value) { SkASSERT(value.fType == SkType_Float); SkScalar scalar = value.fOperand.fScalar; switch (index) { case SK_PROPERTY(alpha): uint8_t alpha; #ifdef SK_SCALAR_IS_FLOAT alpha = scalar == SK_Scalar1 ? 255 : SkToU8((U8CPU) (scalar * 256)); #else alpha = SkToU8((scalar - (scalar >= SK_ScalarHalf)) >> 8); #endif 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), SkColorGetG(color), SkToU8((U8CPU) scalar)); break; case SK_PROPERTY(green): scalar = SkScalarClampMax(scalar, 255 * SK_Scalar1); color = SkColorSetARGB(SkColorGetA(color), SkColorGetR(color), SkToU8((U8CPU) scalar), SkColorGetB(color)); break; case SK_PROPERTY(hue): fHue = scalar;//RGB_to_HSV(color, kGetHue); fDirty = true; break; case SK_PROPERTY(red): scalar = SkScalarClampMax(scalar, 255 * SK_Scalar1); color = SkColorSetARGB(SkColorGetA(color), SkToU8((U8CPU) scalar), SkColorGetG(color), SkColorGetB(color)); break; case SK_PROPERTY(saturation): fSaturation = scalar;//RGB_to_HSV(color, kGetSaturation); fDirty = true; break; case SK_PROPERTY(value): fValue = scalar;//RGB_to_HSV(color, kGetValue); fDirty = true; break; default: SkASSERT(0); return false; } return true; }
#include "SkAnimateMaker.h" #include "SkDisplayApply.h" #include "SkDisplayInput.h" #include "SkDisplayList.h" #ifdef SK_DEBUG #include "SkDump.h" #endif #include "SkEvent.h" #include "SkDisplayInput.h" #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) };
/* * Copyright 2006 The Android Open Source Project * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "SkDisplayMath.h" enum SkDisplayMath_Properties { SK_PROPERTY(E), SK_PROPERTY(LN10), SK_PROPERTY(LN2), SK_PROPERTY(LOG10E), SK_PROPERTY(LOG2E), SK_PROPERTY(PI), SK_PROPERTY(SQRT1_2), SK_PROPERTY(SQRT2) }; const SkScalar SkDisplayMath::gConstants[] = { #ifdef SK_SCALAR_IS_FLOAT 2.718281828f, // E 2.302585093f, // LN10 0.693147181f, // LN2 0.434294482f, // LOG10E 1.442695041f, // LOG2E 3.141592654f, // PI 0.707106781f, // SQRT1_2
*/ #include "SkDrawPaint.h" #include "SkAnimateMaker.h" #include "SkDrawColor.h" #include "SkDrawShader.h" #include "SkMaskFilter.h" #include "SkPaintPart.h" #include "SkPathEffect.h" enum SkPaint_Functions { SK_FUNCTION(measureText) }; enum SkPaint_Properties { SK_PROPERTY(ascent), 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),
DEFINE_GET_MEMBER(SkBaseBitmap); SkBaseBitmap::SkBaseBitmap() : x(0), y(0) { } SkBaseBitmap::~SkBaseBitmap() { } 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
case 3: red = p; green = q; blue = value; break; case 4: red = t; green = p; blue = value; break; case 5: red = value; green = p; blue = q; break; } } //used to say SkToU8((U8CPU) red) etc return SkColorSetARGB(SkColorGetA(color), SkScalarRound(red), SkScalarRound(green), SkScalarRound(blue)); } #if defined _WIN32 && _MSC_VER >= 1300 #pragma warning ( pop ) #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),
bool SkDrawMatrix::setProperty(int index, SkScriptValue& scriptValue) { SkScalar number = scriptValue.fOperand.fScalar; switch (index) { case SK_PROPERTY(translate): // SkScalar xy[2]; SkASSERT(scriptValue.fType == SkType_Array); SkASSERT(scriptValue.fOperand.fArray->getType() == SkType_Float); SkASSERT(scriptValue.fOperand.fArray->count() == 2); // SkParse::FindScalars(scriptValue.fOperand.fString->c_str(), xy, 2); fMatrix.setTranslateX((*scriptValue.fOperand.fArray)[0].fScalar); fMatrix.setTranslateY((*scriptValue.fOperand.fArray)[1].fScalar); return true; case SK_PROPERTY(perspectX): fMatrix.setPerspX(SkScalarToPersp((number))); break; case SK_PROPERTY(perspectY): fMatrix.setPerspY(SkScalarToPersp((number))); break; case SK_PROPERTY(rotate): { SkMatrix temp; temp.setRotate(number, 0, 0); fMatrix.setScaleX(temp.getScaleX()); fMatrix.setScaleY(temp.getScaleY()); fMatrix.setSkewX(temp.getSkewX()); fMatrix.setSkewY(temp.getSkewY()); } break; case SK_PROPERTY(scale): fMatrix.setScaleX(number); fMatrix.setScaleY(number); break; case SK_PROPERTY(scaleX): fMatrix.setScaleX(number); break; case SK_PROPERTY(scaleY): fMatrix.setScaleY(number); break; case SK_PROPERTY(skewX): fMatrix.setSkewX(number); break; case SK_PROPERTY(skewY): fMatrix.setSkewY(number); break; case SK_PROPERTY(translateX): fMatrix.setTranslateX(number); break; case SK_PROPERTY(translateY): fMatrix.setTranslateY(number); break; default: SkASSERT(0); return false; } fConcat = fMatrix; return true; }
** distributed under the License is distributed on an "AS IS" BASIS, ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** See the License for the specific language governing permissions and ** limitations under the License. */ #include "SkDrawPath.h" #include "SkAnimateMaker.h" #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);
* Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "SkDrawMatrix.h" #include "SkAnimateMaker.h" #include "SkCanvas.h" #include "SkPaint.h" #include "SkParse.h" #include "SkMatrixParts.h" #include "SkScript.h" #include "SkTypedArray.h" enum SkDrawMatrix_Properties { SK_PROPERTY(perspectX), SK_PROPERTY(perspectY), 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[] = {
bool SkDisplayRandom::setProperty(int index, SkScriptValue& value) { SkASSERT(index == SK_PROPERTY(seed)); SkASSERT(value.fType == SkType_Int); fRandom.setSeed(value.fOperand.fS32); return true; }
/* * Copyright 2006 The Android Open Source Project * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "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);