void SkMemberInfo::getString(const SkDisplayable* displayable, SkString** string) const { if (fType == SkType_MemberProperty) { SkScriptValue value; displayable->getProperty(propertyIndex(), &value); SkASSERT(value.fType == SkType_String); *string = value.fOperand.fString; return; } SkASSERT(fCount == sizeof(SkString) / sizeof(SkScalar)); SkASSERT(fType == SkType_String || fType == SkType_DynamicString); void* valuePtr = memberData(displayable); *string = (SkString*) valuePtr; }
void QDeclarativeAbstractBinding::addToObject(QObject *object) { Q_ASSERT(object); if (m_object == object) return; int index = propertyIndex(); removeFromObject(); Q_ASSERT(!m_prevBinding); m_object = object; QDeclarativeData *data = QDeclarativeData::get(object, true); if (index & 0xFF000000) { // Value type int coreIndex = index & 0xFFFFFF; // Find the value type proxy (if there is one) QDeclarativeValueTypeProxyBinding *proxy = 0; if (data->hasBindingBit(coreIndex)) { QDeclarativeAbstractBinding *b = data->bindings; while (b && b->propertyIndex() != coreIndex) b = b->m_nextBinding; Q_ASSERT(b && b->bindingType() == QDeclarativeAbstractBinding::ValueTypeProxy); proxy = static_cast<QDeclarativeValueTypeProxyBinding *>(b); } if (!proxy) proxy = new QDeclarativeValueTypeProxyBinding(object, coreIndex); proxy->addToObject(object); m_nextBinding = proxy->m_bindings; if (m_nextBinding) m_nextBinding->m_prevBinding = &m_nextBinding; m_prevBinding = &proxy->m_bindings; proxy->m_bindings = this; } else { m_nextBinding = data->bindings; if (m_nextBinding) m_nextBinding->m_prevBinding = &m_nextBinding; m_prevBinding = &data->bindings; data->bindings = this; data->setBindingBit(m_object, index); } }
void QDeclarativeAbstractBinding::removeFromObject() { if (m_prevBinding) { int index = propertyIndex(); *m_prevBinding = m_nextBinding; if (m_nextBinding) m_nextBinding->m_prevBinding = m_prevBinding; m_prevBinding = 0; m_nextBinding = 0; if (index & 0xFF000000) { // Value type - we don't remove the proxy from the object. It will sit their happily // doing nothing for ever more. } else if (m_object) { QDeclarativeData *data = QDeclarativeData::get(m_object, false); if (data) data->clearBindingBit(index); } m_object = 0; } }
bool SkMemberInfo::writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage, int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType, SkScriptValue& scriptValue) const { SkOperand* storage = untypedStorage ? (SkOperand*) untypedStorage : arrayStorage ? arrayStorage->begin() : NULL; if (storage) storage += storageOffset; SkDisplayTypes type = getType(); if (fType == SkType_MemberProperty) { if(displayable) displayable->setProperty(propertyIndex(), scriptValue); else { SkASSERT(storageOffset < arrayStorage->count()); switch (scriptValue.fType) { case SkType_Boolean: case SkType_Float: case SkType_Int: memcpy(&storage->fScalar, &scriptValue.fOperand.fScalar, sizeof(SkScalar)); break; case SkType_Array: memcpy(&storage->fScalar, scriptValue.fOperand.fArray->begin(), scriptValue.fOperand.fArray->count() * sizeof(SkScalar)); break; case SkType_String: storage->fString->set(*scriptValue.fOperand.fString); break; default: SkASSERT(0); // type isn't handled yet } } } else if (fType == SkType_MemberFunction) { SkASSERT(scriptValue.fType == SkType_Array); if (displayable) displayable->executeFunction(displayable, this, scriptValue.fOperand.fArray, NULL); else { int count = scriptValue.fOperand.fArray->count(); // SkASSERT(maxStorage == 0 || count == maxStorage); if (arrayStorage->count() == 2) arrayStorage->setCount(2 * count); else { storageOffset *= count; SkASSERT(count + storageOffset <= arrayStorage->count()); } memcpy(&(*arrayStorage)[storageOffset], scriptValue.fOperand.fArray->begin(), count * sizeof(SkOperand)); } } else if (fType == SkType_Array) { SkTypedArray* destArray = (SkTypedArray*) (untypedStorage ? untypedStorage : arrayStorage); SkASSERT(destArray); // destArray->setCount(0); if (scriptValue.fType != SkType_Array) { SkASSERT(type == scriptValue.fType); // SkASSERT(storageOffset + 1 <= maxStorage); destArray->setCount(storageOffset + 1); (*destArray)[storageOffset] = scriptValue.fOperand; } else { if (type == SkType_Unknown) { type = scriptValue.fOperand.fArray->getType(); destArray->setType(type); } SkASSERT(type == scriptValue.fOperand.fArray->getType()); int count = scriptValue.fOperand.fArray->count(); // SkASSERT(storageOffset + count <= maxStorage); destArray->setCount(storageOffset + count); memcpy(destArray->begin() + storageOffset, scriptValue.fOperand.fArray->begin(), sizeof(SkOperand) * count); } } else if (type == SkType_String) { SkString* string = untypedStorage ? (SkString*) untypedStorage : (*arrayStorage)[storageOffset].fString; 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 || scriptValue.fType == SkType_Array); SkASSERT(scriptValue.fType != SkType_Array || (array != NULL && array->getType() == SkType_Int)); int numberOfColors = scriptValue.fType == SkType_Array ? array->count() : 1; int numberOfComponents = numberOfColors * 4; // SkASSERT(maxStorage == 0 || maxStorage == numberOfComponents); if (maxStorage == 0) arrayStorage->setCount(numberOfComponents); for (int index = 0; index < numberOfColors; index++) { 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)); storage[2].fScalar = SkIntToScalar(SkColorGetG(color)); storage[3].fScalar = SkIntToScalar(SkColorGetB(color)); storage += 4; } } else if (SkDisplayType::IsStruct(NULL /* !!! maker*/, type)) { if (scriptValue.fType != SkType_Array) return true; // error SkASSERT(sizeof(SkScalar) == sizeof(SkOperand)); // !!! no 64 bit pointer support yet int count = scriptValue.fOperand.fArray->count(); if (count > 0) { SkASSERT(fCount == count); memcpy(storage, scriptValue.fOperand.fArray->begin(), count * sizeof(SkOperand)); } } else if (scriptValue.fType == SkType_Array) { SkASSERT(scriptValue.fOperand.fArray->getType() == type); SkASSERT(scriptValue.fOperand.fArray->count() == getCount()); memcpy(storage, scriptValue.fOperand.fArray->begin(), getCount() * sizeof(SkOperand)); } else { memcpy(storage, &scriptValue.fOperand, sizeof(SkOperand)); } return false; }
bool SkMemberInfo::setValue(SkAnimateMaker& maker, SkTDOperandArray* arrayStorage, int storageOffset, int maxStorage, SkDisplayable* displayable, SkDisplayTypes outType, const char rawValue[], size_t rawValueLen) const { SkString valueStr(rawValue, rawValueLen); SkScriptValue scriptValue; scriptValue.fType = SkType_Unknown; scriptValue.fOperand.fS32 = 0; SkDisplayTypes type = getType(); SkAnimatorScript engine(maker, displayable, type); if (arrayStorage) displayable = NULL; bool success = true; void* untypedStorage = NULL; if (displayable && fType != SkType_MemberProperty && fType != SkType_MemberFunction) untypedStorage = (SkTDOperandArray*) memberData(displayable); if (type == SkType_ARGB) { // for both SpiderMonkey and SkiaScript, substitute any #xyz or #xxyyzz first // it's enough to expand the colors into 0xFFxxyyzz const char* poundPos; while ((poundPos = strchr(valueStr.c_str(), '#')) != NULL) { size_t offset = poundPos - valueStr.c_str(); if (valueStr.size() - offset < 4) break; char r = poundPos[1]; char g = poundPos[2]; char b = poundPos[3]; if (is_hex(r) == false || is_hex(g) == false || is_hex(b) == false) break; char hex = poundPos[4]; if (is_hex(hex) == false) { valueStr.insertUnichar(offset + 1, r); valueStr.insertUnichar(offset + 3, g); valueStr.insertUnichar(offset + 5, b); } *(char*) poundPos = '0'; // overwrite '#' valueStr.insert(offset + 1, "xFF"); } } if (SkDisplayType::IsDisplayable(&maker, type) || SkDisplayType::IsEnum(&maker, type) || type == SkType_ARGB) goto scriptCommon; switch (type) { 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 #endif if (strncmp(rawValue, "#script:", sizeof("#script:") - 1) != 0) goto noScriptString; valueStr.remove(0, 8); case SkType_Unknown: case SkType_Int: case SkType_MSec: // for the purposes of script, MSec is treated as a Scalar case SkType_Point: case SkType_3D_Point: case SkType_Float: case SkType_Array: scriptCommon: { const char* script = valueStr.c_str(); success = engine.evaluateScript(&script, &scriptValue); if (success == false) { maker.setScriptError(engine); return false; } } SkASSERT(success); if (scriptValue.fType == SkType_Displayable) { if (type == SkType_String) { const char* charPtr; maker.findKey(scriptValue.fOperand.fDisplayable, &charPtr); scriptValue.fOperand.fString = new SkString(charPtr); scriptValue.fType = SkType_String; engine.SkScriptEngine::track(scriptValue.fOperand.fString); break; } SkASSERT(SkDisplayType::IsDisplayable(&maker, type)); if (displayable) displayable->setReference(this, scriptValue.fOperand.fDisplayable); else arrayStorage->begin()[0].fDisplayable = scriptValue.fOperand.fDisplayable; return true; } if (type != scriptValue.fType) { if (scriptValue.fType == SkType_Array) { engine.forget(scriptValue.getArray()); goto writeStruct; // real structs have already been written by script } switch (type) { case SkType_String: success = engine.convertTo(SkType_String, &scriptValue); break; case SkType_MSec: case SkType_Float: success = engine.convertTo(SkType_Float, &scriptValue); break; case SkType_Int: success = engine.convertTo(SkType_Int, &scriptValue); break; case SkType_Array: success = engine.convertTo(arrayType(), &scriptValue); // !!! incomplete; create array of appropriate type and add scriptValue to it SkASSERT(0); break; case SkType_Displayable: case SkType_Drawable: return false; // no way to convert other types to this default: // to avoid warnings break; } if (success == false) return false; } if (type == SkType_MSec) scriptValue.fOperand.fMSec = SkScalarMulRound(scriptValue.fOperand.fScalar, 1000); scriptValue.fType = type; break; noScriptString: case SkType_DynamicString: if (fType == SkType_MemberProperty && displayable) { SkString string(rawValue, rawValueLen); SkScriptValue scriptValue; scriptValue.fOperand.fString = &string; scriptValue.fType = SkType_String; displayable->setProperty(propertyIndex(), scriptValue); } else if (displayable) { SkString* string = (SkString*) memberData(displayable); string->set(rawValue, rawValueLen); } else { SkASSERT(arrayStorage->count() == 1); arrayStorage->begin()->fString->set(rawValue, rawValueLen); } goto dirty; case SkType_Base64: { SkBase64 base64; base64.decode(rawValue, rawValueLen); *(SkBase64* ) untypedStorage = base64; } goto dirty; default: SkASSERT(0); break; } // if (SkDisplayType::IsStruct(type) == false) { writeStruct: if (writeValue(displayable, arrayStorage, storageOffset, maxStorage, untypedStorage, outType, scriptValue)) { maker.setErrorCode(SkDisplayXMLParserError::kUnexpectedType); return false; } } dirty: if (displayable) displayable->dirty(); return true; }