1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/gfx/skia/trunk/src/animator/SkMemberInfo.cpp Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,559 @@
1.4 +
1.5 +/*
1.6 + * Copyright 2006 The Android Open Source Project
1.7 + *
1.8 + * Use of this source code is governed by a BSD-style license that can be
1.9 + * found in the LICENSE file.
1.10 + */
1.11 +
1.12 +
1.13 +#include "SkMemberInfo.h"
1.14 +#include "SkAnimateMaker.h"
1.15 +#include "SkAnimatorScript.h"
1.16 +#include "SkBase64.h"
1.17 +#include "SkCamera.h"
1.18 +#include "SkDisplayable.h"
1.19 +#include "SkDisplayTypes.h"
1.20 +#include "SkDraw3D.h"
1.21 +#include "SkDrawColor.h"
1.22 +#include "SkParse.h"
1.23 +#include "SkScript.h"
1.24 +#include "SkTSearch.h"
1.25 +#include "SkTypedArray.h"
1.26 +
1.27 +size_t SkMemberInfo::GetSize(SkDisplayTypes type) { // size of simple types only
1.28 + size_t byteSize;
1.29 + switch (type) {
1.30 + case SkType_ARGB:
1.31 + byteSize = sizeof(SkColor);
1.32 + break;
1.33 + case SkType_AddMode:
1.34 + case SkType_Align:
1.35 + case SkType_ApplyMode:
1.36 + case SkType_ApplyTransition:
1.37 + case SkType_BitmapEncoding:
1.38 + case SkType_Boolean:
1.39 + case SkType_Cap:
1.40 + case SkType_EventCode:
1.41 + case SkType_EventKind:
1.42 + case SkType_EventMode:
1.43 + case SkType_FilterType:
1.44 + case SkType_FontStyle:
1.45 + case SkType_FromPathMode:
1.46 + case SkType_Join:
1.47 + case SkType_MaskFilterBlurStyle:
1.48 + case SkType_PathDirection:
1.49 + case SkType_Style:
1.50 + case SkType_TileMode:
1.51 + case SkType_Xfermode:
1.52 + byteSize = sizeof(int);
1.53 + break;
1.54 + case SkType_Base64: // assume base64 data is always const, copied by ref
1.55 + case SkType_Displayable:
1.56 + case SkType_Drawable:
1.57 + case SkType_Matrix:
1.58 + byteSize = sizeof(void*);
1.59 + break;
1.60 + case SkType_MSec:
1.61 + byteSize = sizeof(SkMSec);
1.62 + break;
1.63 + case SkType_Point:
1.64 + byteSize = sizeof(SkPoint);
1.65 + break;
1.66 + case SkType_3D_Point:
1.67 + byteSize = sizeof(Sk3D_Point);
1.68 + break;
1.69 + case SkType_Int:
1.70 + byteSize = sizeof(int32_t);
1.71 + break;
1.72 + case SkType_Float:
1.73 + byteSize = sizeof(SkScalar);
1.74 + break;
1.75 + case SkType_DynamicString:
1.76 + case SkType_String:
1.77 + byteSize = sizeof(SkString); // assume we'll copy by reference, not value
1.78 + break;
1.79 + default:
1.80 +// SkASSERT(0);
1.81 + byteSize = 0;
1.82 + }
1.83 + return byteSize;
1.84 +}
1.85 +
1.86 +bool SkMemberInfo::getArrayValue(const SkDisplayable* displayable, int index, SkOperand* value) const {
1.87 + SkASSERT(fType != SkType_String && fType != SkType_MemberProperty);
1.88 + char* valuePtr = (char*) *(SkOperand**) memberData(displayable);
1.89 + SkDisplayTypes type = (SkDisplayTypes) 0;
1.90 + if (displayable->getType() == SkType_Array) {
1.91 + SkDisplayArray* dispArray = (SkDisplayArray*) displayable;
1.92 + if (dispArray->values.count() <= index)
1.93 + return false;
1.94 + type = dispArray->values.getType();
1.95 + } else {
1.96 + SkASSERT(0); // incomplete
1.97 + }
1.98 + size_t byteSize = GetSize(type);
1.99 + memcpy(value, valuePtr + index * byteSize, byteSize);
1.100 + return true;
1.101 +}
1.102 +
1.103 +size_t SkMemberInfo::getSize(const SkDisplayable* displayable) const {
1.104 + size_t byteSize;
1.105 + switch (fType) {
1.106 + case SkType_MemberProperty:
1.107 + byteSize = GetSize(propertyType());
1.108 + break;
1.109 + case SkType_Array: {
1.110 + SkDisplayTypes type;
1.111 + if (displayable == NULL)
1.112 + return sizeof(int);
1.113 + if (displayable->getType() == SkType_Array) {
1.114 + SkDisplayArray* dispArray = (SkDisplayArray*) displayable;
1.115 + type = dispArray->values.getType();
1.116 + } else
1.117 + type = propertyType();
1.118 + SkTDOperandArray* array = (SkTDOperandArray*) memberData(displayable);
1.119 + byteSize = GetSize(type) * array->count();
1.120 + } break;
1.121 + default:
1.122 + byteSize = GetSize((SkDisplayTypes) fType);
1.123 + }
1.124 + return byteSize;
1.125 +}
1.126 +
1.127 +void SkMemberInfo::getString(const SkDisplayable* displayable, SkString** string) const {
1.128 + if (fType == SkType_MemberProperty) {
1.129 + SkScriptValue value;
1.130 + displayable->getProperty(propertyIndex(), &value);
1.131 + SkASSERT(value.fType == SkType_String);
1.132 + *string = value.fOperand.fString;
1.133 + return;
1.134 + }
1.135 + SkASSERT(fCount == sizeof(SkString) / sizeof(SkScalar));
1.136 + SkASSERT(fType == SkType_String || fType == SkType_DynamicString);
1.137 + void* valuePtr = memberData(displayable);
1.138 + *string = (SkString*) valuePtr;
1.139 +}
1.140 +
1.141 +void SkMemberInfo::getValue(const SkDisplayable* displayable, SkOperand value[], int count) const {
1.142 + SkASSERT(fType != SkType_String && fType != SkType_MemberProperty);
1.143 + SkASSERT(count == fCount);
1.144 + void* valuePtr = memberData(displayable);
1.145 + size_t byteSize = getSize(displayable);
1.146 + SkASSERT(sizeof(value[0].fScalar) == sizeof(value[0])); // no support for 64 bit pointers, yet
1.147 + memcpy(value, valuePtr, byteSize);
1.148 +}
1.149 +
1.150 +void SkMemberInfo::setString(SkDisplayable* displayable, SkString* value) const {
1.151 + SkString* string = (SkString*) memberData(displayable);
1.152 + string->set(*value);
1.153 + displayable->dirty();
1.154 +}
1.155 +
1.156 +void SkMemberInfo::setValue(SkDisplayable* displayable, const SkOperand values[],
1.157 + int count) const {
1.158 + SkASSERT(sizeof(values[0].fScalar) == sizeof(values[0])); // no support for 64 bit pointers, yet
1.159 + char* dst = (char*) memberData(displayable);
1.160 + if (fType == SkType_Array) {
1.161 + SkTDScalarArray* array = (SkTDScalarArray* ) dst;
1.162 + array->setCount(count);
1.163 + dst = (char*) array->begin();
1.164 + }
1.165 + memcpy(dst, values, count * sizeof(SkOperand));
1.166 + displayable->dirty();
1.167 +}
1.168 +
1.169 +
1.170 +static inline bool is_between(int c, int min, int max)
1.171 +{
1.172 + return (unsigned)(c - min) <= (unsigned)(max - min);
1.173 +}
1.174 +
1.175 +static inline bool is_hex(int c)
1.176 +{
1.177 + if (is_between(c, '0', '9'))
1.178 + return true;
1.179 + c |= 0x20; // make us lower-case
1.180 + if (is_between(c, 'a', 'f'))
1.181 + return true;
1.182 + return false;
1.183 +}
1.184 +
1.185 +
1.186 +bool SkMemberInfo::setValue(SkAnimateMaker& maker, SkTDOperandArray* arrayStorage,
1.187 + int storageOffset, int maxStorage, SkDisplayable* displayable, SkDisplayTypes outType,
1.188 + const char rawValue[], size_t rawValueLen) const
1.189 +{
1.190 + SkString valueStr(rawValue, rawValueLen);
1.191 + SkScriptValue scriptValue;
1.192 + scriptValue.fType = SkType_Unknown;
1.193 + scriptValue.fOperand.fS32 = 0;
1.194 + SkDisplayTypes type = getType();
1.195 + SkAnimatorScript engine(maker, displayable, type);
1.196 + if (arrayStorage)
1.197 + displayable = NULL;
1.198 + bool success = true;
1.199 + void* untypedStorage = NULL;
1.200 + if (displayable && fType != SkType_MemberProperty && fType != SkType_MemberFunction)
1.201 + untypedStorage = (SkTDOperandArray*) memberData(displayable);
1.202 +
1.203 + if (type == SkType_ARGB) {
1.204 + // for both SpiderMonkey and SkiaScript, substitute any #xyz or #xxyyzz first
1.205 + // it's enough to expand the colors into 0xFFxxyyzz
1.206 + const char* poundPos;
1.207 + while ((poundPos = strchr(valueStr.c_str(), '#')) != NULL) {
1.208 + size_t offset = poundPos - valueStr.c_str();
1.209 + if (valueStr.size() - offset < 4)
1.210 + break;
1.211 + char r = poundPos[1];
1.212 + char g = poundPos[2];
1.213 + char b = poundPos[3];
1.214 + if (is_hex(r) == false || is_hex(g) == false || is_hex(b) == false)
1.215 + break;
1.216 + char hex = poundPos[4];
1.217 + if (is_hex(hex) == false) {
1.218 + valueStr.insertUnichar(offset + 1, r);
1.219 + valueStr.insertUnichar(offset + 3, g);
1.220 + valueStr.insertUnichar(offset + 5, b);
1.221 + }
1.222 + *(char*) poundPos = '0'; // overwrite '#'
1.223 + valueStr.insert(offset + 1, "xFF");
1.224 + }
1.225 + }
1.226 + if (SkDisplayType::IsDisplayable(&maker, type) || SkDisplayType::IsEnum(&maker, type) || type == SkType_ARGB)
1.227 + goto scriptCommon;
1.228 + switch (type) {
1.229 + case SkType_String:
1.230 +#if 0
1.231 + if (displayable && displayable->isAnimate()) {
1.232 +
1.233 + goto noScriptString;
1.234 + }
1.235 + if (strncmp(rawValue, "#string:", sizeof("#string:") - 1) == 0) {
1.236 + SkASSERT(sizeof("string") == sizeof("script"));
1.237 + char* stringHeader = valueStr.writable_str();
1.238 + memcpy(&stringHeader[1], "script", sizeof("script") - 1);
1.239 + rawValue = valueStr.c_str();
1.240 + goto noScriptString;
1.241 + } else
1.242 +#endif
1.243 + if (strncmp(rawValue, "#script:", sizeof("#script:") - 1) != 0)
1.244 + goto noScriptString;
1.245 + valueStr.remove(0, 8);
1.246 + case SkType_Unknown:
1.247 + case SkType_Int:
1.248 + case SkType_MSec: // for the purposes of script, MSec is treated as a Scalar
1.249 + case SkType_Point:
1.250 + case SkType_3D_Point:
1.251 + case SkType_Float:
1.252 + case SkType_Array:
1.253 +scriptCommon: {
1.254 + const char* script = valueStr.c_str();
1.255 + success = engine.evaluateScript(&script, &scriptValue);
1.256 + if (success == false) {
1.257 + maker.setScriptError(engine);
1.258 + return false;
1.259 + }
1.260 + }
1.261 + SkASSERT(success);
1.262 + if (scriptValue.fType == SkType_Displayable) {
1.263 + if (type == SkType_String) {
1.264 + const char* charPtr = NULL;
1.265 + maker.findKey(scriptValue.fOperand.fDisplayable, &charPtr);
1.266 + scriptValue.fOperand.fString = new SkString(charPtr);
1.267 + scriptValue.fType = SkType_String;
1.268 + engine.SkScriptEngine::track(scriptValue.fOperand.fString);
1.269 + break;
1.270 + }
1.271 + SkASSERT(SkDisplayType::IsDisplayable(&maker, type));
1.272 + if (displayable)
1.273 + displayable->setReference(this, scriptValue.fOperand.fDisplayable);
1.274 + else
1.275 + arrayStorage->begin()[0].fDisplayable = scriptValue.fOperand.fDisplayable;
1.276 + return true;
1.277 + }
1.278 + if (type != scriptValue.fType) {
1.279 + if (scriptValue.fType == SkType_Array) {
1.280 + engine.forget(scriptValue.getArray());
1.281 + goto writeStruct; // real structs have already been written by script
1.282 + }
1.283 + switch (type) {
1.284 + case SkType_String:
1.285 + success = engine.convertTo(SkType_String, &scriptValue);
1.286 + break;
1.287 + case SkType_MSec:
1.288 + case SkType_Float:
1.289 + success = engine.convertTo(SkType_Float, &scriptValue);
1.290 + break;
1.291 + case SkType_Int:
1.292 + success = engine.convertTo(SkType_Int, &scriptValue);
1.293 + break;
1.294 + case SkType_Array:
1.295 + success = engine.convertTo(arrayType(), &scriptValue);
1.296 + // !!! incomplete; create array of appropriate type and add scriptValue to it
1.297 + SkASSERT(0);
1.298 + break;
1.299 + case SkType_Displayable:
1.300 + case SkType_Drawable:
1.301 + return false; // no way to convert other types to this
1.302 + default: // to avoid warnings
1.303 + break;
1.304 + }
1.305 + if (success == false)
1.306 + return false;
1.307 + }
1.308 + if (type == SkType_MSec)
1.309 + scriptValue.fOperand.fMSec = SkScalarRoundToInt(scriptValue.fOperand.fScalar * 1000);
1.310 + scriptValue.fType = type;
1.311 + break;
1.312 + noScriptString:
1.313 + case SkType_DynamicString:
1.314 + if (fType == SkType_MemberProperty && displayable) {
1.315 + SkString string(rawValue, rawValueLen);
1.316 + SkScriptValue scriptValue;
1.317 + scriptValue.fOperand.fString = &string;
1.318 + scriptValue.fType = SkType_String;
1.319 + displayable->setProperty(propertyIndex(), scriptValue);
1.320 + } else if (displayable) {
1.321 + SkString* string = (SkString*) memberData(displayable);
1.322 + string->set(rawValue, rawValueLen);
1.323 + } else {
1.324 + SkASSERT(arrayStorage->count() == 1);
1.325 + arrayStorage->begin()->fString->set(rawValue, rawValueLen);
1.326 + }
1.327 + goto dirty;
1.328 + case SkType_Base64: {
1.329 + SkBase64 base64;
1.330 + base64.decode(rawValue, rawValueLen);
1.331 + *(SkBase64* ) untypedStorage = base64;
1.332 + } goto dirty;
1.333 + default:
1.334 + SkASSERT(0);
1.335 + break;
1.336 + }
1.337 +// if (SkDisplayType::IsStruct(type) == false)
1.338 + {
1.339 +writeStruct:
1.340 + if (writeValue(displayable, arrayStorage, storageOffset, maxStorage,
1.341 + untypedStorage, outType, scriptValue)) {
1.342 + maker.setErrorCode(SkDisplayXMLParserError::kUnexpectedType);
1.343 + return false;
1.344 + }
1.345 + }
1.346 +dirty:
1.347 + if (displayable)
1.348 + displayable->dirty();
1.349 + return true;
1.350 +}
1.351 +
1.352 +bool SkMemberInfo::setValue(SkAnimateMaker& maker, SkTDOperandArray* arrayStorage,
1.353 + int storageOffset, int maxStorage, SkDisplayable* displayable, SkDisplayTypes outType,
1.354 + SkString& raw) const {
1.355 + return setValue(maker, arrayStorage, storageOffset, maxStorage, displayable, outType, raw.c_str(),
1.356 + raw.size());
1.357 +}
1.358 +
1.359 +bool SkMemberInfo::writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage,
1.360 + int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType,
1.361 + SkScriptValue& scriptValue) const
1.362 +{
1.363 + SkOperand* storage = untypedStorage ? (SkOperand*) untypedStorage : arrayStorage ?
1.364 + arrayStorage->begin() : NULL;
1.365 + if (storage)
1.366 + storage += storageOffset;
1.367 + SkDisplayTypes type = getType();
1.368 + if (fType == SkType_MemberProperty) {
1.369 + if(displayable)
1.370 + displayable->setProperty(propertyIndex(), scriptValue);
1.371 + else {
1.372 + SkASSERT(storageOffset < arrayStorage->count());
1.373 + switch (scriptValue.fType) {
1.374 + case SkType_Boolean:
1.375 + case SkType_Float:
1.376 + case SkType_Int:
1.377 + memcpy(&storage->fScalar, &scriptValue.fOperand.fScalar, sizeof(SkScalar));
1.378 + break;
1.379 + case SkType_Array:
1.380 + memcpy(&storage->fScalar, scriptValue.fOperand.fArray->begin(), scriptValue.fOperand.fArray->count() * sizeof(SkScalar));
1.381 + break;
1.382 + case SkType_String:
1.383 + storage->fString->set(*scriptValue.fOperand.fString);
1.384 + break;
1.385 + default:
1.386 + SkASSERT(0); // type isn't handled yet
1.387 + }
1.388 + }
1.389 + } else if (fType == SkType_MemberFunction) {
1.390 + SkASSERT(scriptValue.fType == SkType_Array);
1.391 + if (displayable)
1.392 + displayable->executeFunction(displayable, this, scriptValue.fOperand.fArray, NULL);
1.393 + else {
1.394 + int count = scriptValue.fOperand.fArray->count();
1.395 + // SkASSERT(maxStorage == 0 || count == maxStorage);
1.396 + if (arrayStorage->count() == 2)
1.397 + arrayStorage->setCount(2 * count);
1.398 + else {
1.399 + storageOffset *= count;
1.400 + SkASSERT(count + storageOffset <= arrayStorage->count());
1.401 + }
1.402 + memcpy(&(*arrayStorage)[storageOffset], scriptValue.fOperand.fArray->begin(), count * sizeof(SkOperand));
1.403 + }
1.404 +
1.405 + } else if (fType == SkType_Array) {
1.406 + SkTypedArray* destArray = (SkTypedArray*) (untypedStorage ? untypedStorage : arrayStorage);
1.407 + SkASSERT(destArray);
1.408 + // destArray->setCount(0);
1.409 + if (scriptValue.fType != SkType_Array) {
1.410 + SkASSERT(type == scriptValue.fType);
1.411 + // SkASSERT(storageOffset + 1 <= maxStorage);
1.412 + destArray->setCount(storageOffset + 1);
1.413 + (*destArray)[storageOffset] = scriptValue.fOperand;
1.414 + } else {
1.415 + if (type == SkType_Unknown) {
1.416 + type = scriptValue.fOperand.fArray->getType();
1.417 + destArray->setType(type);
1.418 + }
1.419 + SkASSERT(type == scriptValue.fOperand.fArray->getType());
1.420 + int count = scriptValue.fOperand.fArray->count();
1.421 + // SkASSERT(storageOffset + count <= maxStorage);
1.422 + destArray->setCount(storageOffset + count);
1.423 + memcpy(destArray->begin() + storageOffset, scriptValue.fOperand.fArray->begin(), sizeof(SkOperand) * count);
1.424 + }
1.425 + } else if (type == SkType_String) {
1.426 + SkString* string = untypedStorage ? (SkString*) untypedStorage : (*arrayStorage)[storageOffset].fString;
1.427 + string->set(*scriptValue.fOperand.fString);
1.428 + } else if (type == SkType_ARGB && outType == SkType_Float) {
1.429 + SkTypedArray* array = scriptValue.fOperand.fArray;
1.430 + SkASSERT(scriptValue.fType == SkType_Int || scriptValue.fType == SkType_ARGB ||
1.431 + scriptValue.fType == SkType_Array);
1.432 + SkASSERT(scriptValue.fType != SkType_Array || (array != NULL &&
1.433 + array->getType() == SkType_Int));
1.434 + int numberOfColors = scriptValue.fType == SkType_Array ? array->count() : 1;
1.435 + int numberOfComponents = numberOfColors * 4;
1.436 + // SkASSERT(maxStorage == 0 || maxStorage == numberOfComponents);
1.437 + if (maxStorage == 0)
1.438 + arrayStorage->setCount(numberOfComponents);
1.439 + for (int index = 0; index < numberOfColors; index++) {
1.440 + SkColor color = scriptValue.fType == SkType_Array ?
1.441 + (SkColor) array->begin()[index].fS32 : (SkColor) scriptValue.fOperand.fS32;
1.442 + storage[0].fScalar = SkIntToScalar(SkColorGetA(color));
1.443 + storage[1].fScalar = SkIntToScalar(SkColorGetR(color));
1.444 + storage[2].fScalar = SkIntToScalar(SkColorGetG(color));
1.445 + storage[3].fScalar = SkIntToScalar(SkColorGetB(color));
1.446 + storage += 4;
1.447 + }
1.448 + } else if (SkDisplayType::IsStruct(NULL /* !!! maker*/, type)) {
1.449 + if (scriptValue.fType != SkType_Array)
1.450 + return true; // error
1.451 + SkASSERT(sizeof(SkScalar) == sizeof(SkOperand)); // !!! no 64 bit pointer support yet
1.452 + int count = scriptValue.fOperand.fArray->count();
1.453 + if (count > 0) {
1.454 + SkASSERT(fCount == count);
1.455 + memcpy(storage, scriptValue.fOperand.fArray->begin(), count * sizeof(SkOperand));
1.456 + }
1.457 + } else if (scriptValue.fType == SkType_Array) {
1.458 + SkASSERT(scriptValue.fOperand.fArray->getType() == type);
1.459 + SkASSERT(scriptValue.fOperand.fArray->count() == getCount());
1.460 + memcpy(storage, scriptValue.fOperand.fArray->begin(), getCount() * sizeof(SkOperand));
1.461 + } else {
1.462 + memcpy(storage, &scriptValue.fOperand, sizeof(SkOperand));
1.463 + }
1.464 + return false;
1.465 +}
1.466 +
1.467 +
1.468 +//void SkMemberInfo::setValue(SkDisplayable* displayable, const char value[], const char name[]) const {
1.469 +// void* valuePtr = (void*) ((char*) displayable + fOffset);
1.470 +// switch (fType) {
1.471 +// case SkType_Point3D: {
1.472 +// static const char xyz[] = "x|y|z";
1.473 +// int index = find_one(xyz, name);
1.474 +// SkASSERT(index >= 0);
1.475 +// valuePtr = (void*) ((char*) valuePtr + index * sizeof(SkScalar));
1.476 +// } break;
1.477 +// default:
1.478 +// SkASSERT(0);
1.479 +// }
1.480 +// SkParse::FindScalar(value, (SkScalar*) valuePtr);
1.481 +// displayable->dirty();
1.482 +//}
1.483 +
1.484 +#if SK_USE_CONDENSED_INFO == 0
1.485 +
1.486 +// Find Nth memberInfo
1.487 +const SkMemberInfo* SkMemberInfo::Find(const SkMemberInfo info[], int count, int* index) {
1.488 + SkASSERT(*index >= 0);
1.489 + if (info->fType == SkType_BaseClassInfo) {
1.490 + const SkMemberInfo* inherited = (SkMemberInfo*) info->fName;
1.491 + const SkMemberInfo* result = SkMemberInfo::Find(inherited, info->fCount, index);
1.492 + if (result != NULL)
1.493 + return result;
1.494 + if (--count == 0)
1.495 + return NULL;
1.496 + info++;
1.497 + }
1.498 + SkASSERT(info->fName);
1.499 + SkASSERT(info->fType != SkType_BaseClassInfo);
1.500 + if (*index >= count) {
1.501 + *index -= count;
1.502 + return NULL;
1.503 + }
1.504 + return &info[*index];
1.505 +}
1.506 +
1.507 +// Find named memberinfo
1.508 +const SkMemberInfo* SkMemberInfo::Find(const SkMemberInfo info[], int count, const char** matchPtr) {
1.509 + const char* match = *matchPtr;
1.510 + if (info->fType == SkType_BaseClassInfo) {
1.511 + const SkMemberInfo* inherited = (SkMemberInfo*) info->fName;
1.512 + const SkMemberInfo* result = SkMemberInfo::Find(inherited, info->fCount, matchPtr);
1.513 + if (result != NULL)
1.514 + return result;
1.515 + if (--count == 0)
1.516 + return NULL;
1.517 + info++;
1.518 + }
1.519 + SkASSERT(info->fName);
1.520 + SkASSERT(info->fType != SkType_BaseClassInfo);
1.521 + int index = SkStrSearch(&info->fName, count, match, sizeof(*info));
1.522 + if (index < 0 || index >= count)
1.523 + return NULL;
1.524 + return &info[index];
1.525 +}
1.526 +
1.527 +const SkMemberInfo* SkMemberInfo::getInherited() const {
1.528 + return (SkMemberInfo*) fName;
1.529 +}
1.530 +
1.531 +#endif // SK_USE_CONDENSED_INFO == 0
1.532 +
1.533 +#if 0
1.534 +bool SkMemberInfo::SetValue(void* valuePtr, const char value[], SkDisplayTypes type,
1.535 + int count) {
1.536 + switch (type) {
1.537 + case SkType_Animate:
1.538 + case SkType_BaseBitmap:
1.539 + case SkType_Bitmap:
1.540 + case SkType_Dash:
1.541 + case SkType_Displayable:
1.542 + case SkType_Drawable:
1.543 + case SkType_Matrix:
1.544 + case SkType_Path:
1.545 + case SkType_Text:
1.546 + case SkType_3D_Patch:
1.547 + return false; // ref to object; caller must resolve
1.548 + case SkType_MSec: {
1.549 + SkParse::FindMSec(value, (SkMSec*) valuePtr);
1.550 + } break;
1.551 + case SkType_3D_Point:
1.552 + case SkType_Point:
1.553 + // case SkType_PointArray:
1.554 + case SkType_ScalarArray:
1.555 + SkParse::FindScalars(value, (SkScalar*) valuePtr, count);
1.556 + break;
1.557 + default:
1.558 + SkASSERT(0);
1.559 + }
1.560 + return true;
1.561 +}
1.562 +#endif
