QDeclarativePropertyPrivate Class Reference

#include <qdeclarativeproperty_p.h>

Inheritance diagram for QDeclarativePropertyPrivate:

Public Types
enum	WriteFlag { BypassInterceptor = 0x01, DontRemoveBinding = 0x02, RemoveBindingOnAliasWrite = 0x04 }

Public Functions
void	initDefault (QObject *obj)
	Initialize from the default property of obj. More...
void	initProperty (QObject *obj, const QString &name)
bool	isValueType () const
int	propertyType () const
QDeclarativeProperty::PropertyTypeCategory	propertyTypeCategory () const
	QDeclarativePropertyPrivate ()
QVariant	readValueProperty ()
QDeclarativeProperty::Type	type () const
bool	writeValueProperty (const QVariant &, WriteFlags)
Public Functions inherited from QDeclarativeRefCount
void	addref ()
	QDeclarativeRefCount ()
void	release ()
virtual	~QDeclarativeRefCount ()

Static Public Functions
static QDeclarativeAbstractBinding *	binding (QObject *, int coreIndex, int valueTypeIndex)
static QDeclarativeAbstractBinding *	binding (const QDeclarativeProperty &that)
	Returns the binding associated with this property, or 0 if no binding exists. More...
static int	bindingIndex (const QDeclarativeProperty &that)
	Returns the "property index" for use in bindings. More...
static bool	canConvert (const QMetaObject *from, const QMetaObject *to)
	Returns true if from inherits to. More...
static bool	connect (QObject *sender, int signal_index, const QObject *receiver, int method_index, int type=0, int *types=0)
	Connect sender signal_index to receiver method_index with the specified type and types. More...
static bool	equal (const QMetaObject *, const QMetaObject *)
	Returns true if lhs and rhs refer to the same metaobject data. More...
static void	findAliasTarget (QObject *, int, QObject **, int *)
static QMetaMethod	findSignalByName (const QMetaObject *mo, const QByteArray &)
	Return the signal corresponding to name. More...
static const QMetaObject *	metaObjectForProperty (const QMetaObject *, int)
	Return metaObject's [super] meta object that provides data for property. More...
static const QMetaObject *	rawMetaObjectForType (QDeclarativeEnginePrivate *, int)
static QDeclarativeProperty	restore (const QByteArray &, QObject *, QDeclarativeContextData *)
static QDeclarativeProperty	restore (const QDeclarativePropertyCache::Data &, const QDeclarativePropertyCache::ValueTypeData &, QObject *, QDeclarativeContextData *)
static QByteArray	saveProperty (const QMetaObject *, int)
static QByteArray	saveValueType (const QMetaObject *, int, const QMetaObject *, int)
static QDeclarativeAbstractBinding *	setBinding (QObject *, int coreIndex, int valueTypeIndex, QDeclarativeAbstractBinding *, WriteFlags flags=DontRemoveBinding)
static QDeclarativeAbstractBinding *	setBinding (const QDeclarativeProperty &that, QDeclarativeAbstractBinding *, WriteFlags flags=DontRemoveBinding)
	Set the binding associated with this property to newBinding. More...
static QDeclarativeAbstractBinding *	setBindingNoEnable (QObject *, int coreIndex, int valueTypeIndex, QDeclarativeAbstractBinding *)
static QDeclarativeExpression *	setSignalExpression (const QDeclarativeProperty &that, QDeclarativeExpression *)
	Set the signal expression associated with this signal property to expr. More...
static QDeclarativeExpression *	signalExpression (const QDeclarativeProperty &that)
	Returns the expression associated with this signal property, or 0 if no signal expression exists. More...
static int	valueTypeCoreIndex (const QDeclarativeProperty &that)
static bool	write (QObject *, const QDeclarativePropertyCache::Data &, const QVariant &, QDeclarativeContextData *, WriteFlags flags=0)
static bool	write (const QDeclarativeProperty &that, const QVariant &, WriteFlags)
static bool	writeEnumProperty (const QMetaProperty &prop, int idx, QObject *object, const QVariant &value, int flags)

Public Variables
QDeclarativeContextData *	context
QDeclarativePropertyCache::Data	core
QDeclarativeEngine *	engine
bool	isNameCached:1
QString	nameCache
QDeclarativeGuard< QObject >	object
QDeclarativePropertyCache::ValueTypeData	valueType

Detailed Description

Definition at line 68 of file qdeclarativeproperty_p.h.

Enumerations

WriteFlag

enum QDeclarativePropertyPrivate::WriteFlag

Enumerator
BypassInterceptor
DontRemoveBinding
RemoveBindingOnAliasWrite

Definition at line 71 of file qdeclarativeproperty_p.h.

{ BypassInterceptor = 0x01, DontRemoveBinding = 0x02, RemoveBindingOnAliasWrite = 0x04 };

Constructors and Destructors

QDeclarativePropertyPrivate()

QDeclarativePropertyPrivate::QDeclarativePropertyPrivate ( )

inline

Definition at line 74 of file qdeclarativeproperty_p.h.

        : context(0), engine(0), object(0), isNameCached(false) {}

Functions

binding() [1/2]

QDeclarativeAbstractBinding * QDeclarativePropertyPrivate::binding ( QObject *  object, int  coreIndex, int  valueTypeIndex  )

static

Definition at line 684 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeState::addEntriesToRevertList(), QDeclarativeState::apply(), QDeclarativePropertyChanges::changeExpression(), QDeclarativePropertyChanges::changeValue(), QDeclarativeEngineDebugService::propertyData(), QDeclarativeSimpleAction::QDeclarativeSimpleAction(), QDeclarativeState::removeAllEntriesFromRevertList(), QDeclarativeState::removeEntryFromRevertList(), QDeclarativeEngineDebugService::resetBinding(), and QDeclarativeAnchorChanges::saveOriginals().

{
    QDeclarativeData *data = QDeclarativeData::get(object);
    if (!data)
        return 0;

    QDeclarativePropertyCache::Data *propertyData = 
        data->propertyCache?data->propertyCache->property(coreIndex):0;
    if (propertyData && propertyData->flags & QDeclarativePropertyCache::Data::IsAlias) {
        const QDeclarativeVMEMetaObject *vme = 
            static_cast<const QDeclarativeVMEMetaObject *>(metaObjectForProperty(object->metaObject(), coreIndex));

        QObject *aObject = 0; int aCoreIndex = -1; int aValueTypeIndex = -1;
        if (!vme->aliasTarget(coreIndex, &aObject, &aCoreIndex, &aValueTypeIndex) || aCoreIndex == -1)
            return 0;

        // This will either be a value type sub-reference or an alias to a value-type sub-reference not both
        Q_ASSERT(valueTypeIndex == -1 || aValueTypeIndex == -1);
        return binding(aObject, aCoreIndex, (valueTypeIndex == -1)?aValueTypeIndex:valueTypeIndex);
    }

    if (!data->hasBindingBit(coreIndex))
        return 0;

    QDeclarativeAbstractBinding *binding = data->bindings;
    while (binding && binding->propertyIndex() != coreIndex)
        binding = binding->m_nextBinding;

    if (binding && valueTypeIndex != -1) {
        if (binding->bindingType() == QDeclarativeAbstractBinding::ValueTypeProxy) {
            int index = coreIndex | (valueTypeIndex << 24);
            binding = static_cast<QDeclarativeValueTypeProxyBinding *>(binding)->binding(index);
        }
    }

    return binding;
}

binding() [2/2]

QDeclarativeAbstractBinding * QDeclarativePropertyPrivate::binding ( const QDeclarativeProperty &  that )

static

Returns the binding associated with this property, or 0 if no binding exists.

Definition at line 647 of file qdeclarativeproperty.cpp.

{
    if (!that.d || !that.isProperty() || !that.d->object)
        return 0;

    return binding(that.d->object, that.d->core.coreIndex, that.d->valueType.valueTypeCoreIdx);
}

bindingIndex()

int QDeclarativePropertyPrivate::bindingIndex ( const QDeclarativeProperty &  that )

static

Returns the "property index" for use in bindings.

The top 8 bits are the value type offset, and 0 otherwise. The bottom 24-bits are the regular property index.

Definition at line 1440 of file qdeclarativeproperty.cpp.

{
    if (!that.d)
        return -1;
    int rv = that.d->core.coreIndex;
    if (rv != -1 && that.d->valueType.valueTypeCoreIdx != -1)
        rv = rv | (that.d->valueType.valueTypeCoreIdx << 24);
    return rv;
}

canConvert()

bool QDeclarativePropertyPrivate::canConvert ( const QMetaObject *  from, const QMetaObject *  to  )

static

Returns true if from inherits to.

Definition at line 1533 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeListReference::append(), and QDeclarativeBindingCompilerPrivate::compile().

{
    if (from && to == &QObject::staticMetaObject)
        return true;

    while (from) {
        if (equal(from, to))
            return true;
        from = from->superClass();
    }
    
    return false;
}

connect()

bool QDeclarativePropertyPrivate::connect ( QObject *  sender, int  signal_index, const QObject *  receiver, int  method_index, int  type = 0, int *  types = 0  )

static

Connect sender signal_index to receiver method_index with the specified type and types.

This behaves identically to QMetaObject::connect() except that it connects any lazy "proxy" signal connections set up by QML.

It is possible that this logic should be moved to QMetaObject::connect().

Definition at line 1637 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeNotifierEndpoint::connect(), QDeclarativeVMEMetaObject::connectAlias(), QDeclarativeProperty::connectNotifySignal(), QDeclarativeBoundSignal::init(), QDeclarativeProxyMetaObject::metaCall(), and QDeclarativeWatchProxy::QDeclarativeWatchProxy().

{
    flush_vme_signal(sender, signal_index);
    flush_vme_signal(receiver, method_index);

    const bool result =
            QMetaObject::connect(sender, signal_index, receiver, method_index, type, types);

    // connectNotify() needs to be called after the actual connect, as otherwise QObject::receivers()
    // would return the wrong result inside connectNotify().
    const QMetaMethod signal = sender->metaObject()->method(signal_index);
    QObjectPrivate * const senderPriv = QObjectPrivate::get(sender);
    QVarLengthArray<char> signalSignature;
    QObjectPrivate::signalSignature(signal, &signalSignature);
    senderPriv->connectNotify(signalSignature.constData());

    return result;
}

equal()

bool QDeclarativePropertyPrivate::equal ( const QMetaObject *  lhs, const QMetaObject *  rhs  )

static

Returns true if lhs and rhs refer to the same metaobject data.

Definition at line 1525 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeCompiler::buildPropertyObjectAssignment(), and QDeclarativeCompiler::canCoerce().

{
    return lhs == rhs || (1 && lhs && rhs && lhs->d.stringdata == rhs->d.stringdata);
}

findAliasTarget()

void QDeclarativePropertyPrivate::findAliasTarget ( QObject *  object, int  bindingIndex, QObject **  targetObject, int *  targetBindingIndex  )

static

Definition at line 722 of file qdeclarativeproperty.cpp.

{
    int coreIndex = bindingIndex & 0xFFFFFF;
    int valueTypeIndex = bindingIndex >> 24;
    if (valueTypeIndex == 0) valueTypeIndex = -1;

    QDeclarativeData *data = QDeclarativeData::get(object, false);
    if (data) {
        QDeclarativePropertyCache::Data *propertyData = 
            data->propertyCache?data->propertyCache->property(coreIndex):0;
        if (propertyData && propertyData->flags & QDeclarativePropertyCache::Data::IsAlias) {
            const QDeclarativeVMEMetaObject *vme = 
                static_cast<const QDeclarativeVMEMetaObject *>(metaObjectForProperty(object->metaObject(), coreIndex));
            QObject *aObject = 0; int aCoreIndex = -1; int aValueTypeIndex = -1;
            if (vme->aliasTarget(coreIndex, &aObject, &aCoreIndex, &aValueTypeIndex)) {
                // This will either be a value type sub-reference or an alias to a value-type sub-reference not both
                Q_ASSERT(valueTypeIndex == -1 || aValueTypeIndex == -1);

                int aBindingIndex = aCoreIndex;
                if (aValueTypeIndex != -1) 
                    aBindingIndex |= aValueTypeIndex << 24;
                else if (valueTypeIndex != -1)
                    aBindingIndex |= valueTypeIndex << 24;

                findAliasTarget(aObject, aBindingIndex, targetObject, targetBindingIndex);
                return;
            }
        }
    }

    *targetObject = object; 
    *targetBindingIndex = bindingIndex;
}

findSignalByName()

QMetaMethod QDeclarativePropertyPrivate::findSignalByName ( const QMetaObject *  mo, const QByteArray &  name  )

static

Return the signal corresponding to name.

Definition at line 1550 of file qdeclarativeproperty.cpp.

Referenced by hasValidSignal(), and QDeclarativeCompiler::indexOfSignal().

{
    Q_ASSERT(mo);
    int methods = mo->methodCount();
    for (int ii = methods - 1; ii >= 2; --ii) { // >= 2 to block the destroyed signal
        QMetaMethod method = mo->method(ii);
        QByteArray methodName = method.signature();
        int idx = methodName.indexOf('(');
        methodName = methodName.left(idx);

        if (methodName == name)
            return method;
    }

    // If no signal is found, but the signal is of the form "onBlahChanged",
    // return the notify signal for the property "Blah"
    if (name.endsWith("Changed")) {
        QByteArray propName = name.mid(0, name.length() - 7);
        int propIdx = mo->indexOfProperty(propName.constData());
        if (propIdx >= 0) {
            QMetaProperty prop = mo->property(propIdx);
            if (prop.hasNotifySignal())
                return prop.notifySignal();
        }
    }

    return QMetaMethod();
}

initDefault()

void QDeclarativePropertyPrivate::initDefault

(

QObject *

obj

)

Initialize from the default property of obj.

Definition at line 165 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeProperty::QDeclarativeProperty().

{
    if (!obj)
        return;

    QMetaProperty p = QDeclarativeMetaType::defaultProperty(obj);
    core.load(p);
    if (core.isValid()) 
        object = obj;
}

initProperty()

void QDeclarativePropertyPrivate::initProperty	(	QObject *	obj,
		const QString &	name
	)

Definition at line 218 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeProperty::QDeclarativeProperty().

{
    if (!obj) return;

    QDeclarativeTypeNameCache *typeNameCache = context?context->imports:0;

    QStringList path = name.split(QLatin1Char('.'));
    if (path.isEmpty()) return;

    QObject *currentObject = obj;

    // Everything up to the last property must be an "object type" property
    for (int ii = 0; ii < path.count() - 1; ++ii) {
        const QString &pathName = path.at(ii);

        if (QDeclarativeTypeNameCache::Data *data = typeNameCache?typeNameCache->data(pathName):0) {
            if (data->type) {
                QDeclarativeAttachedPropertiesFunc func = data->type->attachedPropertiesFunction();
                if (!func) return; // Not an attachable type

                currentObject = qmlAttachedPropertiesObjectById(data->type->attachedPropertiesId(), currentObject);
                if (!currentObject) return; // Something is broken with the attachable type
            } else {
                Q_ASSERT(data->typeNamespace);
                if ((ii + 1) == path.count()) return; // No type following the namespace
                
                ++ii; data = data->typeNamespace->data(path.at(ii));
                if (!data || !data->type) return; // Invalid type in namespace 

                QDeclarativeAttachedPropertiesFunc func = data->type->attachedPropertiesFunction();
                if (!func) return; // Not an attachable type

                currentObject = qmlAttachedPropertiesObjectById(data->type->attachedPropertiesId(), currentObject);
                if (!currentObject) return; // Something is broken with the attachable type
            }
        } else {

            QDeclarativePropertyCache::Data local;
            QDeclarativePropertyCache::Data *property = 
                QDeclarativePropertyCache::property(engine, obj, pathName, local);

            if (!property) return; // Not a property
            if (property->flags & QDeclarativePropertyCache::Data::IsFunction) 
                return; // Not an object property 

            if (ii == (path.count() - 2) && QDeclarativeValueTypeFactory::isValueType(property->propType)) {
                // We're now at a value type property.  We can use a global valuetypes array as we 
                // never actually use the objects, just look up their properties.
                QObject *typeObject = (*qmlValueTypes())[property->propType];
                if (!typeObject) return; // Not a value type

                int idx = typeObject->metaObject()->indexOfProperty(path.last().toUtf8().constData());
                if (idx == -1) return; // Value type property does not exist

                QMetaProperty vtProp = typeObject->metaObject()->property(idx);

                object = currentObject;
                core = *property;
                valueType.flags = QDeclarativePropertyCache::Data::flagsForProperty(vtProp);
                valueType.valueTypeCoreIdx = idx;
                valueType.valueTypePropType = vtProp.userType();

                return; 
            } else {
                if (!(property->flags & QDeclarativePropertyCache::Data::IsQObjectDerived)) 
                    return; // Not an object property

                void *args[] = { &currentObject, 0 };
                QMetaObject::metacall(currentObject, QMetaObject::ReadProperty, property->coreIndex, args);
                if (!currentObject) return; // No value

            }
        }

    }

    const QString &terminal = path.last();

    if (terminal.count() >= 3 &&
        terminal.at(0) == QLatin1Char('o') &&
        terminal.at(1) == QLatin1Char('n') &&
        terminal.at(2).isUpper()) {

        QString signalName = terminal.mid(2);
        signalName[0] = signalName.at(0).toLower();

        QMetaMethod method = findSignalByName(currentObject->metaObject(), signalName.toLatin1().constData());
        if (method.signature()) {
            object = currentObject;
            core.load(method);
            return;
        }
    }

    // Property
    QDeclarativePropertyCache::Data local;
    QDeclarativePropertyCache::Data *property = 
        QDeclarativePropertyCache::property(engine, currentObject, terminal, local);
    if (property && !(property->flags & QDeclarativePropertyCache::Data::IsFunction)) {
        object = currentObject;
        core = *property;
        nameCache = terminal;
        isNameCached = true;
    }
}

isValueType()

bool QDeclarativePropertyPrivate::isValueType

(

)

const

Definition at line 445 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeProperty::name(), and QDeclarativeProperty::propertyTypeName().

{
    return valueType.valueTypeCoreIdx != -1;
}

metaObjectForProperty()

const QMetaObject * QDeclarativePropertyPrivate::metaObjectForProperty ( const QMetaObject *  metaObject, int  property  )

static

Return metaObject's [super] meta object that provides data for property.

Definition at line 1661 of file qdeclarativeproperty.cpp.

{
    int propertyOffset = metaObject->propertyOffset();

    while (propertyOffset > property) {
        metaObject = metaObject->d.superdata;
        propertyOffset -= QMetaObject_properties(metaObject);
    }

    return metaObject;
}

propertyType()

int QDeclarativePropertyPrivate::propertyType

(

)

const

Definition at line 450 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeProperty::propertyType().

{
    uint type = this->type();
    if (isValueType()) {
        return valueType.valueTypePropType;
    } else if (type & QDeclarativeProperty::Property) {
        if (core.propType == (int)QVariant::LastType)
            return qMetaTypeId<QVariant>();
        else
            return core.propType;
    } else {
        return QVariant::Invalid;
    }
}

propertyTypeCategory()

QDeclarativeProperty::PropertyTypeCategory QDeclarativePropertyPrivate::propertyTypeCategory

(

)

const

Definition at line 370 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeProperty::propertyTypeCategory().

{
    uint type = this->type();

    if (isValueType()) {
        return QDeclarativeProperty::Normal;
    } else if (type & QDeclarativeProperty::Property) {
        int type = propertyType();
        if (type == QVariant::Invalid)
            return QDeclarativeProperty::InvalidCategory;
        else if (QDeclarativeValueTypeFactory::isValueType((uint)type))
            return QDeclarativeProperty::Normal;
        else if (core.flags & QDeclarativePropertyCache::Data::IsQObjectDerived)
            return QDeclarativeProperty::Object;
        else if (core.flags & QDeclarativePropertyCache::Data::IsQList)
            return QDeclarativeProperty::List;
        else 
            return QDeclarativeProperty::Normal;
    } else {
        return QDeclarativeProperty::InvalidCategory;
    }
}

rawMetaObjectForType()

const QMetaObject * QDeclarativePropertyPrivate::rawMetaObjectForType ( QDeclarativeEnginePrivate *  engine, int  userType  )

static

Definition at line 1257 of file qdeclarativeproperty.cpp.

{
    if (engine) {
        return engine->rawMetaObjectForType(userType);
    } else {
        QDeclarativeType *type = QDeclarativeMetaType::qmlType(userType);
        return type?type->baseMetaObject():0;
    }
}

readValueProperty()

QVariant QDeclarativePropertyPrivate::readValueProperty

(

)

Definition at line 986 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeProperty::read().

{
    if (isValueType()) {

        QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(context);
        QDeclarativeValueType *valueType = 0;
        if (ep) valueType = ep->valueTypes[core.propType];
        else valueType = QDeclarativeValueTypeFactory::valueType(core.propType);
        Q_ASSERT(valueType);

        valueType->read(object, core.coreIndex);

        QVariant rv =
            valueType->metaObject()->property(this->valueType.valueTypeCoreIdx).read(valueType);

        if (!ep) delete valueType;
        return rv;

    } else if (core.flags & QDeclarativePropertyCache::Data::IsQList) {

        QDeclarativeListProperty<QObject> prop;
        void *args[] = { &prop, 0 };
        QMetaObject::metacall(object, QMetaObject::ReadProperty, core.coreIndex, args);
        return QVariant::fromValue(QDeclarativeListReferencePrivate::init(prop, core.propType, engine)); 

    } else if (core.flags & QDeclarativePropertyCache::Data::IsQObjectDerived) {

        QObject *rv = 0;
        void *args[] = { &rv, 0 };
        QMetaObject::metacall(object, QMetaObject::ReadProperty, core.coreIndex, args);
        return QVariant::fromValue(rv);

    } else {

        return object->metaObject()->property(core.coreIndex).read(object.data());

    }
}

restore() [1/2]

QDeclarativeProperty QDeclarativePropertyPrivate::restore ( const QByteArray &  data, QObject *  object, QDeclarativeContextData *  ctxt  )

static

Definition at line 1489 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeValueTypeScriptClass::setProperty(), and QDeclarativeObjectScriptClass::setProperty().

{
    QDeclarativeProperty prop;

    if (data.isEmpty())
        return prop;

    const SerializedData *sd = (const SerializedData *)data.constData();
    if (sd->isValueType) {
        const ValueTypeSerializedData *vt = (const ValueTypeSerializedData *)sd;
        return restore(vt->core, vt->valueType, object, ctxt);
    } else {
        QDeclarativePropertyCache::ValueTypeData data;
        return restore(sd->core, data, object, ctxt);
    }
}

restore() [2/2]

QDeclarativeProperty QDeclarativePropertyPrivate::restore ( const QDeclarativePropertyCache::Data &  data, const QDeclarativePropertyCache::ValueTypeData &  valueType, QObject *  object, QDeclarativeContextData *  ctxt  )

static

Definition at line 1507 of file qdeclarativeproperty.cpp.

{
    QDeclarativeProperty prop;

    prop.d = new QDeclarativePropertyPrivate;
    prop.d->object = object;
    prop.d->context = ctxt;
    prop.d->engine = ctxt->engine;

    prop.d->core = data;
    prop.d->valueType = valueType;

    return prop;
}

saveProperty()

QByteArray QDeclarativePropertyPrivate::saveProperty ( const QMetaObject *  metaObject, int  index  )

static

Definition at line 1477 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeCompiler::genPropertyData().

{
    SerializedData sd;
    memset(&sd, 0, sizeof(sd));
    sd.isValueType = false;
    sd.core.load(metaObject->property(index));

    QByteArray rv((const char *)&sd, sizeof(sd));
    return rv;
}

saveValueType()

QByteArray QDeclarativePropertyPrivate::saveValueType ( const QMetaObject *  metaObject, int  index, const QMetaObject *  subObject, int  subIndex  )

static

Definition at line 1459 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeCompiler::genValueTypeData().

{
    QMetaProperty subProp = subObject->property(subIndex);

    ValueTypeSerializedData sd;
    memset(&sd, 0, sizeof(sd));
    sd.isValueType = true;
    sd.core.load(metaObject->property(index));
    sd.valueType.flags = QDeclarativePropertyCache::Data::flagsForProperty(subProp);
    sd.valueType.valueTypeCoreIdx = subIndex;
    sd.valueType.valueTypePropType = subProp.userType();

    QByteArray rv((const char *)&sd, sizeof(sd));

    return rv;
}

setBinding() [1/2]

QDeclarativeAbstractBinding * QDeclarativePropertyPrivate::setBinding ( QObject *  object, int  coreIndex, int  valueTypeIndex, QDeclarativeAbstractBinding *  newBinding, WriteFlags  flags = DontRemoveBinding  )

static

Definition at line 758 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeState::addEntriesToRevertList(), QDeclarativeState::apply(), QDeclarativeTransitionManagerPrivate::applyBindings(), QDeclarativeTransitionManager::cancel(), QDeclarativePropertyChanges::changeExpression(), QDeclarativePropertyChanges::changeValue(), QDeclarativeAnchorChanges::clearBindings(), QDeclarativeAction::deleteFromBinding(), QDeclarativeAnchorChanges::execute(), QDeclarativeVMEMetaObject::metaCall(), QDeclarativeState::removeAllEntriesFromRevertList(), removeBindingOnProperty(), QDeclarativeState::removeEntryFromRevertList(), QDeclarativeEngineDebugService::resetBinding(), QDeclarativeAnchorChanges::reverse(), QDeclarativeEngineDebugService::setBinding(), setBinding(), QDeclarativeValueTypeScriptClass::setProperty(), QDeclarativeObjectScriptClass::setProperty(), and QDeclarativeTransitionManager::transition().

{
    QDeclarativeData *data = QDeclarativeData::get(object, 0 != newBinding);
    QDeclarativeAbstractBinding *binding = 0;

    if (data) {
        QDeclarativePropertyCache::Data *propertyData = 
            data->propertyCache?data->propertyCache->property(coreIndex):0;
        if (propertyData && propertyData->flags & QDeclarativePropertyCache::Data::IsAlias) {
            const QDeclarativeVMEMetaObject *vme = 
                static_cast<const QDeclarativeVMEMetaObject *>(metaObjectForProperty(object->metaObject(), coreIndex));

            QObject *aObject = 0; int aCoreIndex = -1; int aValueTypeIndex = -1;
            if (!vme->aliasTarget(coreIndex, &aObject, &aCoreIndex, &aValueTypeIndex)) {
                if (newBinding) newBinding->destroy();
                return 0;
            }

            // This will either be a value type sub-reference or an alias to a value-type sub-reference not both
            Q_ASSERT(valueTypeIndex == -1 || aValueTypeIndex == -1);
            return setBinding(aObject, aCoreIndex, (valueTypeIndex == -1)?aValueTypeIndex:valueTypeIndex,
                              newBinding, flags);
        }
    }

    if (data && data->hasBindingBit(coreIndex)) {
        binding = data->bindings;

        while (binding && binding->propertyIndex() != coreIndex) 
            binding = binding->m_nextBinding;
    }

    int index = coreIndex;
    if (valueTypeIndex != -1)
        index |= (valueTypeIndex << 24);

    if (binding && valueTypeIndex != -1 && binding->bindingType() == QDeclarativeAbstractBinding::ValueTypeProxy) 
        binding = static_cast<QDeclarativeValueTypeProxyBinding *>(binding)->binding(index);

    if (binding) {
        binding->removeFromObject();
        binding->setEnabled(false, 0);
    }

    if (newBinding) {
        newBinding->addToObject(object, index);
        newBinding->setEnabled(true, flags);
    }

    return binding;
}

setBinding() [2/2]

QDeclarativeAbstractBinding * QDeclarativePropertyPrivate::setBinding ( const QDeclarativeProperty &  that, QDeclarativeAbstractBinding *  newBinding, WriteFlags  flags = DontRemoveBinding  )

static

Set the binding associated with this property to newBinding.

Returns the existing binding (if any), otherwise 0.

newBinding will be enabled, and the returned binding (if any) will be disabled.

Ownership of newBinding transfers to QML. Ownership of the return value is assumed by the caller.

flags is passed through to the binding and is used for the initial update (when the binding sets the initial value, it will use these flags for the write).

Definition at line 669 of file qdeclarativeproperty.cpp.

{
    if (!that.d || !that.isProperty() || !that.d->object) {
        if (newBinding)
            newBinding->destroy();
        return 0;
    }

    return that.d->setBinding(that.d->object, that.d->core.coreIndex, 
                              that.d->valueType.valueTypeCoreIdx, newBinding, flags);
}

setBindingNoEnable()

QDeclarativeAbstractBinding * QDeclarativePropertyPrivate::setBindingNoEnable ( QObject *  object, int  coreIndex, int  valueTypeIndex, QDeclarativeAbstractBinding *  newBinding  )

static

Definition at line 812 of file qdeclarativeproperty.cpp.

{
    QDeclarativeData *data = QDeclarativeData::get(object, 0 != newBinding);
    QDeclarativeAbstractBinding *binding = 0;

    if (data) {
        QDeclarativePropertyCache::Data *propertyData = 
            data->propertyCache?data->propertyCache->property(coreIndex):0;
        if (propertyData && propertyData->flags & QDeclarativePropertyCache::Data::IsAlias) {
            const QDeclarativeVMEMetaObject *vme = 
                static_cast<const QDeclarativeVMEMetaObject *>(metaObjectForProperty(object->metaObject(), coreIndex));

            QObject *aObject = 0; int aCoreIndex = -1; int aValueTypeIndex = -1;
            if (!vme->aliasTarget(coreIndex, &aObject, &aCoreIndex, &aValueTypeIndex)) {
                if (newBinding) newBinding->destroy();
                return 0;
            }

            // This will either be a value type sub-reference or an alias to a value-type sub-reference not both
            Q_ASSERT(valueTypeIndex == -1 || aValueTypeIndex == -1);
            return setBindingNoEnable(aObject, aCoreIndex, (valueTypeIndex == -1)?aValueTypeIndex:valueTypeIndex,
                                      newBinding);
        }
    }

    if (data && data->hasBindingBit(coreIndex)) {
        binding = data->bindings;

        while (binding && binding->propertyIndex() != coreIndex) 
            binding = binding->m_nextBinding;
    }

    int index = coreIndex;
    if (valueTypeIndex != -1)
        index |= (valueTypeIndex << 24);

    if (binding && valueTypeIndex != -1 && binding->bindingType() == QDeclarativeAbstractBinding::ValueTypeProxy) 
        binding = static_cast<QDeclarativeValueTypeProxyBinding *>(binding)->binding(index);

    if (binding) 
        binding->removeFromObject();

    if (newBinding) 
        newBinding->addToObject(object, index);

    return binding;
}

setSignalExpression()

QDeclarativeExpression * QDeclarativePropertyPrivate::setSignalExpression ( const QDeclarativeProperty &  that, QDeclarativeExpression *  expr  )

static

Set the signal expression associated with this signal property to expr.

Returns the existing signal expression (if any), otherwise 0.

Ownership of expr transfers to QML. Ownership of the return value is assumed by the caller.

Definition at line 892 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeReplaceSignalHandler::execute(), QDeclarativeEngineDebugService::resetBinding(), QDeclarativeReplaceSignalHandler::reverse(), QDeclarativeReplaceSignalHandler::rewind(), and QDeclarativeEngineDebugService::setBinding().

{
    if (!(that.type() & QDeclarativeProperty::SignalProperty)) {
        delete expr;
        return 0;
    }

    const QObjectList &children = that.d->object->children();
    
    for (int ii = 0; ii < children.count(); ++ii) {
        QObject *child = children.at(ii);

        QDeclarativeBoundSignal *signal = QDeclarativeBoundSignal::cast(child);
        if (signal && signal->index() == that.index()) 
            return signal->setExpression(expr);
    }

    if (expr) {
        QDeclarativeBoundSignal *signal = new QDeclarativeBoundSignal(that.d->object, that.method(), that.d->object);
        return signal->setExpression(expr);
    } else {
        return 0;
    }
}

signalExpression()

QDeclarativeExpression * QDeclarativePropertyPrivate::signalExpression ( const QDeclarativeProperty &  that )

static

Returns the expression associated with this signal property, or 0 if no signal expression exists.

Definition at line 866 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeReplaceSignalHandler::saveCurrentValues().

{
    if (!(that.type() & QDeclarativeProperty::SignalProperty))
        return 0;

    const QObjectList &children = that.d->object->children();
    
    for (int ii = 0; ii < children.count(); ++ii) {
        QObject *child = children.at(ii);

        QDeclarativeBoundSignal *signal = QDeclarativeBoundSignal::cast(child);
        if (signal && signal->index() == that.index()) 
            return signal->expression();
    }

    return 0;
}

type()

QDeclarativeProperty::Type QDeclarativePropertyPrivate::type

(

)

const

Definition at line 465 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeProperty::type().

{
    if (core.flags & QDeclarativePropertyCache::Data::IsFunction)
        return QDeclarativeProperty::SignalProperty;
    else if (core.isValid())
        return QDeclarativeProperty::Property;
    else
        return QDeclarativeProperty::Invalid;
}

valueTypeCoreIndex()

int QDeclarativePropertyPrivate::valueTypeCoreIndex ( const QDeclarativeProperty &  that )

static

Definition at line 1431 of file qdeclarativeproperty.cpp.

{
    return that.d ? that.d->valueType.valueTypeCoreIdx : -1;
}

write() [1/2]

bool QDeclarativePropertyPrivate::write ( QObject *  object, const QDeclarativePropertyCache::Data &  property, const QVariant &  value, QDeclarativeContextData *  context, WriteFlags  flags = 0  )

static

Definition at line 1104 of file qdeclarativeproperty.cpp.

Referenced by QDeclarativeSpringAnimationPrivate::animate(), QSmoothedAnimation::init(), QDeclarativeObjectScriptClass::setProperty(), QDeclarativeAnimationPropertyUpdater::setValue(), QDeclarativeTransitionManager::transition(), QDeclarativePropertyAction::transition(), QDeclarativeBinding::update(), QSmoothedAnimation::updateCurrentTime(), QDeclarativeBehavior::write(), and QDeclarativeProperty::write().

{
    int coreIdx = property.coreIndex;
    int status = -1;    //for dbus

    if (property.flags & QDeclarativePropertyCache::Data::IsEnumType) {
        QMetaProperty prop = object->metaObject()->property(property.coreIndex);
        QVariant v = value;
        // Enum values come through the script engine as doubles
        if (value.userType() == QVariant::Double) { 
            double integral;
            double fractional = modf(value.toDouble(), &integral);
            if (qFuzzyIsNull(fractional))
                v.convert(QVariant::Int);
        }
        return writeEnumProperty(prop, coreIdx, object, v, flags);
    }

    int propertyType = property.propType;
    int variantType = value.userType();

    QDeclarativeEnginePrivate *enginePriv = QDeclarativeEnginePrivate::get(context);

    if (propertyType == QVariant::Url) {

        QUrl u;
        bool found = false;
        if (variantType == QVariant::Url) {
            u = value.toUrl();
            found = true;
        } else if (variantType == QVariant::ByteArray) {
            u = QUrl(QString::fromUtf8(value.toByteArray()));
            found = true;
        } else if (variantType == QVariant::String) {
            u = QUrl(value.toString());
            found = true;
        }

        if (!found)
            return false;

        if (context && u.isRelative() && !u.isEmpty())
            u = context->resolvedUrl(u);
        int status = -1;
        void *argv[] = { &u, 0, &status, &flags };
        QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, argv);

    } else if (variantType == propertyType) {

        void *a[] = { (void *)value.constData(), 0, &status, &flags };
        QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, a);

    } else if (qMetaTypeId<QVariant>() == propertyType) {

        void *a[] = { (void *)&value, 0, &status, &flags };
        QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, a);

    } else if (property.flags & QDeclarativePropertyCache::Data::IsQObjectDerived) {

        const QMetaObject *valMo = rawMetaObjectForType(enginePriv, value.userType());
        
        if (!valMo)
            return false;

        QObject *o = *(QObject **)value.constData();
        const QMetaObject *propMo = rawMetaObjectForType(enginePriv, propertyType);

        if (o) valMo = o->metaObject();

        if (canConvert(valMo, propMo)) {
            void *args[] = { &o, 0, &status, &flags };
            QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, 
                                  args);
        } else if (!o && canConvert(propMo, valMo)) {
            // In the case of a null QObject, we assign the null if there is 
            // any change that the null variant type could be up or down cast to 
            // the property type.
            void *args[] = { &o, 0, &status, &flags };
            QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, 
                                  args);
        } else {
            return false;
        }

    } else if (property.flags & QDeclarativePropertyCache::Data::IsQList) {

        const QMetaObject *listType = 0;
        if (enginePriv) {
            listType = enginePriv->rawMetaObjectForType(enginePriv->listType(property.propType));
        } else {
            QDeclarativeType *type = QDeclarativeMetaType::qmlType(QDeclarativeMetaType::listType(property.propType));
            if (!type) return false;
            listType = type->baseMetaObject();
        }
        if (!listType) return false;

        QDeclarativeListProperty<void> prop;
        void *args[] = { &prop, 0 };
        QMetaObject::metacall(object, QMetaObject::ReadProperty, coreIdx, args);

        if (!prop.clear) return false;

        prop.clear(&prop);

        if (value.userType() == qMetaTypeId<QList<QObject *> >()) {
            const QList<QObject *> &list = qvariant_cast<QList<QObject *> >(value);

            for (int ii = 0; ii < list.count(); ++ii) {
                QObject *o = list.at(ii);
                if (o && !canConvert(o->metaObject(), listType))
                    o = 0;
                prop.append(&prop, (void *)o);
            }
        } else {
            QObject *o = enginePriv?enginePriv->toQObject(value):QDeclarativeMetaType::toQObject(value);
            if (o && !canConvert(o->metaObject(), listType))
                o = 0;
            prop.append(&prop, (void *)o);
        }

    } else {
        Q_ASSERT(variantType != propertyType);

        bool ok = false;
        QVariant v;
        if (variantType == QVariant::String)
            v = QDeclarativeStringConverters::variantFromString(value.toString(), propertyType, &ok);
        if (!ok) {
            v = value;
            if (v.convert((QVariant::Type)propertyType)) {
                ok = true;
            } else if ((uint)propertyType >= QVariant::UserType && variantType == QVariant::String) {
                QDeclarativeMetaType::StringConverter con = QDeclarativeMetaType::customStringConverter(propertyType);
                if (con) {
                    v = con(value.toString());
                    if (v.userType() == propertyType)
                        ok = true;
                }
            }
        }
        if (ok) {
            void *a[] = { (void *)v.constData(), 0, &status, &flags};
            QMetaObject::metacall(object, QMetaObject::WriteProperty, coreIdx, a);
        } else {
            return false;
        }
    }

    return true;
}

write() [2/2]

bool QDeclarativePropertyPrivate::write ( const QDeclarativeProperty &  that, const QVariant &  value, WriteFlags  flags  )

static

Definition at line 1345 of file qdeclarativeproperty.cpp.

{
    if (!that.d)
        return false;
    if (that.d->object && that.type() & QDeclarativeProperty::Property && 
        that.d->core.isValid() && that.isWritable()) 
        return that.d->writeValueProperty(value, flags);
    else 
        return false;
}

writeEnumProperty()

bool QDeclarativePropertyPrivate::writeEnumProperty ( const QMetaProperty &  prop, int  idx, QObject *  object, const QVariant &  value, int  flags  )

static

Definition at line 1026 of file qdeclarativeproperty.cpp.

{
    if (!object || !prop.isWritable())
        return false;

    QVariant v = value;
    if (prop.isEnumType()) {
        QMetaEnum menum = prop.enumerator();
        if (v.userType() == QVariant::String
#ifdef QT3_SUPPORT
            || v.userType() == QVariant::CString
#endif
            ) {
            if (prop.isFlagType())
                v = QVariant(menum.keysToValue(value.toByteArray()));
            else
                v = QVariant(menum.keyToValue(value.toByteArray()));
        } else if (v.userType() != QVariant::Int && v.userType() != QVariant::UInt) {
            int enumMetaTypeId = QMetaType::type(QByteArray(menum.scope() + QByteArray("::") + menum.name()));
            if ((enumMetaTypeId == 0) || (v.userType() != enumMetaTypeId) || !v.constData())
                return false;
            v = QVariant(*reinterpret_cast<const int *>(v.constData()));
        }
        v.convert(QVariant::Int);
    }

    // the status variable is changed by qt_metacall to indicate what it did
    // this feature is currently only used by QtDBus and should not be depended
    // upon. Don't change it without looking into QDBusAbstractInterface first
    // -1 (unchanged): normal qt_metacall, result stored in argv[0]
    // changed: result stored directly in value, return the value of status
    int status = -1;
    void *argv[] = { v.data(), &v, &status, &flags };
    QMetaObject::metacall(object, QMetaObject::WriteProperty, idx, argv);
    return status;
}

writeValueProperty()

bool QDeclarativePropertyPrivate::writeValueProperty	(	const QVariant &	value,
		WriteFlags	flags
	)

Definition at line 1063 of file qdeclarativeproperty.cpp.

Referenced by write().

{
    // Remove any existing bindings on this property
    if (!(flags & DontRemoveBinding) &&
        (type() & QDeclarativeProperty::Property) && object) {
        QDeclarativeAbstractBinding *binding = setBinding(object, core.coreIndex,
                                                          valueType.valueTypeCoreIdx, 0, flags);
        if (binding) binding->destroy();
    }

    bool rv = false;
    if (isValueType()) {
        QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(context);

        QDeclarativeValueType *writeBack = 0;
        if (ep) {
            writeBack = ep->valueTypes[core.propType];
        } else {
            writeBack = QDeclarativeValueTypeFactory::valueType(core.propType);
        }

        writeBack->read(object, core.coreIndex);

        QDeclarativePropertyCache::Data data = core;
        data.flags = valueType.flags;
        data.coreIndex = valueType.valueTypeCoreIdx;
        data.propType = valueType.valueTypePropType;
        rv = write(writeBack, data, value, context, flags);

        writeBack->write(object, core.coreIndex, flags);
        if (!ep) delete writeBack;

    } else {

        rv = write(object, core, value, context, flags);

    }

    return rv;
}

Properties

context

QDeclarativeContextData* QDeclarativePropertyPrivate::context

Definition at line 77 of file qdeclarativeproperty_p.h.

Referenced by QDeclarativeProperty::propertyTypeName(), QDeclarativeProperty::QDeclarativeProperty(), and restore().

core

QDeclarativePropertyCache::Data QDeclarativePropertyPrivate::core

Definition at line 82 of file qdeclarativeproperty_p.h.

Referenced by binding(), bindingIndex(), QDeclarativeProperty::connectNotifySignal(), QDeclarativeProperty::hasNotifySignal(), QDeclarativeProperty::index(), QDeclarativeProperty::isDesignable(), QDeclarativeProperty::isResettable(), QDeclarativeProperty::isWritable(), QDeclarativeProperty::method(), QDeclarativeProperty::name(), QDeclarativeProperty::operator==(), QDeclarativeProperty::property(), QDeclarativeProperty::propertyTypeName(), QDeclarativeProperty::reset(), restore(), setBinding(), and write().

engine

QDeclarativeEngine* QDeclarativePropertyPrivate::engine

Definition at line 78 of file qdeclarativeproperty_p.h.

Referenced by QDeclarativeProperty::name(), QDeclarativeProperty::QDeclarativeProperty(), and restore().

isNameCached

bool QDeclarativePropertyPrivate::isNameCached

Definition at line 81 of file qdeclarativeproperty_p.h.

Referenced by QDeclarativeProperty::name().

nameCache

QString QDeclarativePropertyPrivate::nameCache

Definition at line 83 of file qdeclarativeproperty_p.h.

Referenced by QDeclarativeProperty::name().

object

QDeclarativeGuard<QObject> QDeclarativePropertyPrivate::object

Definition at line 79 of file qdeclarativeproperty_p.h.

Referenced by binding(), QDeclarativeProperty::connectNotifySignal(), QDeclarativeProperty::hasNotifySignal(), QDeclarativeProperty::isDesignable(), QDeclarativeProperty::isResettable(), QDeclarativeProperty::isWritable(), QDeclarativeProperty::method(), QDeclarativeProperty::name(), QDeclarativeProperty::object(), QDeclarativeProperty::operator==(), QDeclarativeProperty::property(), QDeclarativeProperty::propertyTypeName(), QDeclarativeProperty::QDeclarativeProperty(), QDeclarativeProperty::read(), QDeclarativeProperty::reset(), restore(), setBinding(), setSignalExpression(), signalExpression(), and write().

valueType

QDeclarativePropertyCache::ValueTypeData QDeclarativePropertyPrivate::valueType

Definition at line 86 of file qdeclarativeproperty_p.h.

Referenced by binding(), bindingIndex(), QDeclarativeProperty::name(), QDeclarativeProperty::operator==(), QDeclarativeProperty::propertyTypeName(), restore(), setBinding(), and valueTypeCoreIndex().

---

The documentation for this class was generated from the following files:

• /src/declarative/qml/qdeclarativeproperty_p.h
• /src/declarative/qml/qdeclarativeproperty.cpp