Initial import of kinetic-dui branch from the old kinetic

1 files changed, 847 insertions, 0 deletions

diff --git a/src/declarative/qml/qmlmetaproperty.cpp b/src/declarative/qml/qmlmetaproperty.cpp
new file mode 100644
index 0000000..79db6ce
--- /dev/null
+++ b/src/declarative/qml/qmlmetaproperty.cpp
@@ -0,0 +1,847 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmlmetaproperty.h"
+#include "qmlmetaproperty_p.h"
+#include <qml.h>
+#include <qfxperf.h>
+#include <QStringList>
+#include <qmlbindablevalue.h>
+#include <qmlcontext.h>
+#include "qmlboundsignal_p.h"
+#include <math.h>
+#include <QtCore/qdebug.h>
+
+
+QT_BEGIN_NAMESPACE
+
+class QMetaPropertyEx : public QMetaProperty
+{
+public:
+    QMetaPropertyEx()
+        : propertyType(-1) {}
+
+    QMetaPropertyEx(const QMetaProperty &p)
+        : QMetaProperty(p), propertyType(p.userType()) {}
+
+    QMetaPropertyEx(const QMetaPropertyEx &o)
+        : QMetaProperty(o),
+          propertyType(o.propertyType) {}
+
+    QMetaPropertyEx &operator=(const QMetaPropertyEx &o)
+    {
+        static_cast<QMetaProperty *>(this)->operator=(o);
+        propertyType = o.propertyType;
+        return *this;
+    }
+
+    private:
+    friend class QmlMetaProperty;
+    int propertyType;
+};
+
+
+/*!
+    \class QmlMetaProperty
+    \brief The QmlMetaProperty class abstracts accessing QML properties.
+ */
+
+/*!
+    Create an invalid QmlMetaProperty.
+*/
+QmlMetaProperty::QmlMetaProperty()
+: d(new QmlMetaPropertyPrivate)
+{
+}
+
+QmlMetaProperty::~QmlMetaProperty()
+{
+    delete d; d = 0;
+}
+
+// ### not thread safe
+static QHash<const QMetaObject *, QMetaPropertyEx> qmlCacheDefProp;
+
+/*!
+    Creates a QmlMetaProperty for the default property of \a obj. If there is no
+    default property, an invalid QmlMetaProperty will be created.
+ */
+QmlMetaProperty::QmlMetaProperty(QObject *obj, QmlContext *ctxt)
+: d(new QmlMetaPropertyPrivate)
+{
+    d->context = ctxt;
+    if(!obj)
+        return;
+
+    d->object = obj;
+    QHash<const QMetaObject *, QMetaPropertyEx>::ConstIterator iter =
+        qmlCacheDefProp.find(obj->metaObject());
+    if(iter != qmlCacheDefProp.end()) {
+        d->prop = *iter;
+        d->propType = iter->propertyType;
+        d->coreIdx = iter->propertyType;
+    } else {
+        QMetaPropertyEx p(QmlMetaType::defaultProperty(obj));
+        d->prop = p;
+        d->propType = p.propertyType;
+        d->coreIdx = d->prop.propertyIndex();
+        if(!QObjectPrivate::get(obj)->metaObject)
+            qmlCacheDefProp.insert(obj->metaObject(), d->prop);
+    }
+    if(d->prop.name() != 0) {
+        d->type = Property | Default;
+        d->name = QLatin1String(d->prop.name());
+    }
+}
+
+/*!
+    \internal
+
+    Creates a QmlMetaProperty for the property at index \a idx of \a obj.
+
+    The QmlMetaProperty is assigned category \a cat.
+ */
+QmlMetaProperty::QmlMetaProperty(QObject *obj, int idx, PropertyCategory cat, QmlContext *ctxt)
+: d(new QmlMetaPropertyPrivate)
+{
+    d->context = ctxt;
+    d->object = obj;
+    d->type = Property;
+    d->category = cat;
+    QMetaPropertyEx p(obj->metaObject()->property(idx));
+    d->prop = p;
+    d->propType = p.propertyType;
+    d->coreIdx = idx;
+    if(d->prop.name() != 0)
+        d->name = QLatin1String(d->prop.name());
+}
+
+// ### Not thread safe!!!!
+static QHash<const QMetaObject *, QHash<QString, QMetaPropertyEx> > qmlCacheProps;
+/*!
+    Creates a QmlMetaProperty for the property \a name of \a obj.
+ */
+QmlMetaProperty::QmlMetaProperty(QObject *obj, const QString &name, QmlContext *ctxt)
+: d(new QmlMetaPropertyPrivate)
+{
+#ifdef Q_ENABLE_PERFORMANCE_LOG
+    QFxPerfTimer<QFxPerf::MetaProperty> perf;
+#endif
+
+    d->context = ctxt;
+    d->name = name;
+    d->object = obj;
+    if(name.isEmpty() || !obj)
+        return;
+
+    if(name.at(0).isUpper()) {
+        // Attached property
+        d->attachedFunc = QmlMetaType::attachedPropertiesFuncId(name.toLatin1());
+        if(d->attachedFunc != -1)
+            d->type  = Property | Attached;
+        return;
+    } else if(name.count() >= 3 && name.startsWith(QLatin1String("on")) && name.at(2).isUpper()) {
+        // Signal
+        QString signalName = name.mid(2);
+        signalName[0] = signalName.at(0).toLower();
+
+        d->findSignalInt(obj, signalName);
+        if(d->signal.signature() != 0) {
+            d->type = SignalProperty;
+            return;
+        }
+    } 
+
+    // Property
+    QHash<QString, QMetaPropertyEx> &props = qmlCacheProps[obj->metaObject()];
+    QHash<QString, QMetaPropertyEx>::ConstIterator iter = props.find(name);
+    if(iter != props.end()) {
+        d->prop = *iter;
+        d->propType = iter->propertyType;
+        d->coreIdx = iter->propertyIndex();
+    } else {
+        QMetaPropertyEx p = QmlMetaType::property(obj, name.toLatin1().constData());
+        d->prop = p;
+        d->propType = p.propertyType;
+        d->coreIdx = p.propertyIndex();
+        if (!QObjectPrivate::get(obj)->metaObject)
+            props.insert(name, p);
+    }
+    if(d->prop.name() != 0) 
+        d->type = Property;
+
+    if(d->type == Invalid) {
+        int sig = findSignal(obj, name.toLatin1());
+        if(sig != -1) {
+            d->signal = obj->metaObject()->method(sig);
+            d->type = Signal;
+            d->coreIdx = sig;
+        } 
+    }
+}
+
+/*!
+    Create a copy of \a other.
+*/
+QmlMetaProperty::QmlMetaProperty(const QmlMetaProperty &other)
+: d(new QmlMetaPropertyPrivate(*other.d))
+{
+}
+
+/*!
+    Returns the property category.
+*/
+QmlMetaProperty::PropertyCategory QmlMetaProperty::propertyCategory() const
+{
+    if(d->category == Unknown) {
+        int type = propertyType();
+        if(!isValid())
+            d->category = InvalidProperty;
+        else if(type == qMetaTypeId<QmlBindableValue *>())
+            d->category = Bindable;
+        else if(QmlMetaType::isList(type))
+            d->category = List;
+        else if(QmlMetaType::isQmlList(type))
+            d->category = QmlList;
+        else if(QmlMetaType::isObject(type))
+            d->category = Object;
+        else 
+            d->category = Normal;
+    }
+    return d->category;
+}
+
+/*!
+    Returns the property category of \a prop.
+*/
+QmlMetaProperty::PropertyCategory 
+QmlMetaProperty::propertyCategory(const QMetaProperty &prop)
+{
+    if(prop.name()) {
+        int type = 0;
+        if(prop.type() == QVariant::LastType)
+            type = qMetaTypeId<QVariant>();
+        else if(prop.type() == QVariant::UserType)
+            type = prop.userType();
+        else
+            type = prop.type();
+
+        if(type == qMetaTypeId<QmlBindableValue *>())
+            return Bindable;
+        else if(QmlMetaType::isList(type))
+            return List;
+        else if(QmlMetaType::isQmlList(type))
+            return QmlList;
+        else if(QmlMetaType::isObject(type))
+            return Object;
+        else 
+            return Normal;
+    } else {
+        return InvalidProperty;
+    }
+}
+
+/*!
+    Returns the type name of the property, or 0 if the property has no type
+    name.
+*/
+const char *QmlMetaProperty::propertyTypeName() const
+{
+    if(d->prop.name()) {
+        return d->prop.typeName();
+    } else {
+        return 0;
+    }
+}
+
+/*!
+    Returns true if \a other and this QmlMetaProperty represent the same 
+    property.
+*/
+bool QmlMetaProperty::operator==(const QmlMetaProperty &other) const
+{
+    return d->prop.name() == other.d->prop.name() &&
+           d->signal.signature() == other.d->signal.signature() &&
+           d->type == other.d->type &&
+           d->object == other.d->object;
+}
+
+/*!
+    Returns the QVariant type of the property, or QVariant::Invalid if the 
+    property has no QVariant type.
+*/
+int QmlMetaProperty::propertyType() const
+{
+    int rv = QVariant::Invalid;
+
+    if(d->prop.name()) {
+        if(d->propType == (int)QVariant::LastType)
+            rv = qMetaTypeId<QVariant>();
+        else
+            rv = d->propType;
+    } else if(d->attachedFunc) {
+        rv = qMetaTypeId<QObject *>();
+    } 
+
+    return rv;
+}
+
+/*!
+    Returns the type of the property.
+*/
+QmlMetaProperty::Type QmlMetaProperty::type() const
+{
+    return (Type)d->type;
+}
+
+/*!
+    Returns true if this QmlMetaProperty represents a regular Qt property.
+*/
+bool QmlMetaProperty::isProperty() const
+{
+    return type() & Property;
+}
+
+/*!
+    Returns true if this QmlMetaProperty represents a default property.
+*/
+bool QmlMetaProperty::isDefault() const
+{
+    return type() & Default;
+}
+
+/*!
+    Returns the QmlMetaProperty's QObject.
+*/
+QObject *QmlMetaProperty::object() const
+{
+    return d->object;
+}
+
+/*!
+    Assign \a other to this QmlMetaProperty.
+*/
+QmlMetaProperty &QmlMetaProperty::operator=(const QmlMetaProperty &other)
+{
+    d->name = other.d->name;
+    d->prop = other.d->prop;
+    d->propType = other.d->propType;
+    d->type = other.d->type;
+    d->signal = other.d->signal;
+    d->coreIdx = other.d->coreIdx;
+    d->attachedFunc = other.d->attachedFunc;
+    d->object = other.d->object;
+    d->category = other.d->category;
+    return *this;
+}
+
+/*!
+    Returns true if the property is writable, otherwise false.
+*/
+bool QmlMetaProperty::isWritable() const
+{
+    if(propertyCategory() == List || propertyCategory() == QmlList)
+        return true;
+    else if(d->prop.name() != 0)
+        return d->prop.isWritable();
+    else if(type() & SignalProperty)
+        return true;
+    else
+        return false;
+}
+
+/*!
+    Returns true if the property is designable, otherwise false.
+*/
+bool QmlMetaProperty::isDesignable() const
+{
+    if(d->prop.name() != 0)
+        return d->prop.isDesignable();
+    else
+        return false;
+}
+
+/*!
+    Returns true if the QmlMetaProperty refers to a valid property, otherwise
+    false.
+*/
+bool QmlMetaProperty::isValid() const
+{
+    return type() != Invalid;
+}
+
+/*!
+    Returns all of \a obj's Qt properties.
+*/
+QStringList QmlMetaProperty::properties(QObject *obj)
+{
+    if(!obj)
+        return QStringList();
+
+    QStringList rv;
+    const QMetaObject *mo = obj->metaObject();
+    for(int ii = 0; ii < mo->propertyCount(); ++ii) {
+        QMetaProperty prop = mo->property(ii);
+        rv << QLatin1String(prop.name());
+    }
+
+    return rv;
+}
+
+/*!
+    Return the name of this property.
+*/
+QString QmlMetaProperty::name() const
+{
+    return d->name;
+}
+
+const QMetaProperty &QmlMetaProperty::property() const
+{
+    return d->prop;
+}
+
+/*!
+    Returns the binding associated with this property, or 0 if no binding 
+    exists.
+*/
+QmlBindableValue *QmlMetaProperty::binding()
+{
+    if(!isProperty() || type() & Attached)
+        return 0;
+
+    const QObjectList &children = object()->children();
+    for(QObjectList::ConstIterator iter = children.begin();
+            iter != children.end(); ++iter) {
+        QObject *child = *iter;
+        if(child->metaObject() == &QmlBindableValue::staticMetaObject) {
+            QmlBindableValue *v = static_cast<QmlBindableValue *>(child);
+            if(v->property() == *this)
+                return v;
+        }
+    }
+    return 0;
+}
+
+/*! \internal */
+int QmlMetaProperty::findSignal(const QObject *obj, const char *name)
+{
+    const QMetaObject *mo = obj->metaObject();
+    int methods = mo->methodCount();
+    for(int ii = 0; ii < methods; ++ii) {
+        QMetaMethod method = mo->method(ii);
+        if(method.methodType() != QMetaMethod::Signal)
+            continue;
+
+        QByteArray methodName = method.signature();
+        int idx = methodName.indexOf('(');
+        methodName = methodName.left(idx);
+
+        if(methodName == name) 
+            return ii;
+    }
+    return -1;
+}
+
+void QmlMetaPropertyPrivate::findSignalInt(QObject *obj, const QString &name)
+{
+    const QMetaObject *mo = obj->metaObject();
+
+    int methods = mo->methodCount();
+    for(int ii = 0; ii < methods; ++ii) {
+        QMetaMethod method = mo->method(ii);
+        QString methodName = QLatin1String(method.signature());
+        int idx = methodName.indexOf(QLatin1Char('('));
+        methodName = methodName.left(idx);
+
+        if(methodName == name) {
+            signal = method;
+            coreIdx = ii;
+            return;
+        }
+    }
+}
+
+QObject *QmlMetaPropertyPrivate::attachedObject() const
+{
+    if(attachedFunc == -1)
+        return 0;
+    else
+        return QmlMetaType::attachedPropertiesFuncById(attachedFunc)(object);
+}
+
+/*!
+    Returns the property value.
+*/
+QVariant QmlMetaProperty::read() const
+{
+    if(type() & SignalProperty) {
+
+        const QObjectList &children = object()->children();
+
+        for(int ii = 0; ii < children.count(); ++ii) {
+            QmlBoundSignal *sig = qobject_cast<QmlBoundSignal *>(children.at(ii));
+            if(sig && sig->index() == d->coreIdx) 
+                return sig->expression();
+        }
+    } else if(type() & Property) {
+        if(type() & Attached) 
+            return QVariant::fromValue(d->attachedObject());
+        else
+            return d->prop.read(object());
+    }
+    return QVariant();
+}
+
+Q_DECLARE_METATYPE(QList<QObject *>);
+/*!
+    Set the property value to \a value.
+*/
+void QmlMetaProperty::write(const QVariant &value) const
+{
+    if(type() & SignalProperty) {
+
+        QString expr = value.toString();
+        const QObjectList &children = object()->children();
+
+        for(int ii = 0; ii < children.count(); ++ii) {
+            QmlBoundSignal *sig = qobject_cast<QmlBoundSignal *>(children.at(ii));
+            if(sig && sig->index() == d->coreIdx) {
+                if(expr.isEmpty()) {
+                    sig->disconnect();
+                    sig->deleteLater();
+                } else {
+                    sig->setExpression(expr);
+                }
+                return;
+            }
+        }
+
+        if(!expr.isEmpty()) {
+            // XXX scope
+            (void *)new QmlBoundSignal(QmlContext::activeContext(), expr, object(), d->coreIdx, object());
+        }
+
+    } else if(d->prop.name()) {
+
+        if(d->prop.isEnumType()) {
+            QVariant v = value;
+            if (value.type() == QVariant::Double) {   //enum values come through the script engine as doubles
+                double integral;
+                double fractional = modf(value.toDouble(), &integral);
+                if (qFuzzyCompare(fractional, (double)0.0))
+                    v.convert(QVariant::Int);
+            }
+            d->prop.write(object(), v);
+        } else {
+            if(!value.isValid())
+                return;
+
+            int t = propertyType();
+            int vt = value.type();
+
+            if(vt == t ||
+               value.userType() == t) {
+
+                void *a[1];
+                a[0] = (void *)value.constData();
+                QMetaObject::metacall(object(), QMetaObject::WriteProperty, d->coreIdx, a);
+
+            } else if(qMetaTypeId<QVariant>() == t) {
+
+                d->prop.write(object(), value);
+
+            } else if(propertyCategory() == Object) {
+
+                QObject *o = QmlMetaType::toQObject(value);
+                if(o) 
+                    d->prop.write(object(), QmlMetaType::fromObject(o, propertyType()));
+
+            } else if (propertyCategory() == List) {
+
+                int listType = QmlMetaType::listType(t);
+                if(value.userType() == qMetaTypeId<QList<QObject *> >()) {
+                    const QList<QObject *> &list =
+                        qvariant_cast<QList<QObject *> >(value);
+                    QVariant listVar = d->prop.read(object());
+                    QmlMetaType::clear(listVar);
+                    for(int ii = 0; ii < list.count(); ++ii) {
+                        QVariant v = QmlMetaType::fromObject(list.at(ii), listType);
+                        QmlMetaType::append(listVar, v);
+                    }
+
+                } else if(vt == listType ||
+                          value.userType() == listType) {
+                    QVariant listVar = d->prop.read(object());
+                    if (!QmlMetaType::append(listVar, value)) {
+                        qWarning() << "QmlMetaProperty: Unable to assign object to list";
+                    }
+                }
+            } else if (propertyCategory() == QmlList) {
+                // XXX - optimize!
+                QVariant list = d->prop.read(object());
+                QmlPrivate::ListInterface *li =
+                    *(QmlPrivate::ListInterface **)list.constData();
+
+                int type = li->type();
+
+                if (QObject *obj = QmlMetaType::toQObject(value)) {
+                    const QMetaObject *mo =
+                        QmlMetaType::rawMetaObjectForType(type);
+
+                    const QMetaObject *objMo = obj->metaObject();
+                    bool found = false;
+                    while(!found && objMo) {
+                        if(objMo == mo)
+                            found = true;
+                        else
+                            objMo = objMo->superClass();
+                    }
+
+                    if(!found) {
+                        qWarning() << "Unable to assign object to list";
+                        return;
+                    }
+
+                    // NOTE: This assumes a cast to QObject does not alter
+                    // the object pointer
+                    void *d = (void *)&obj;
+                    li->append(d);
+                }
+            } else if(propertyCategory() == Normal) {
+
+                switch(t) {
+                case QVariant::Double:
+                    {
+                        qreal r;
+                        bool found = true;
+                        if(vt == QVariant::Int) {
+                            r = value.toInt();
+                        } else if(vt == QVariant::UInt) {
+                            r = value.toUInt();
+                        } else {
+                            found = false;
+                        }
+
+                        if(found) {
+                            void *a[1];
+                            a[0] = &r;
+                            QMetaObject::metacall(object(), 
+                                                  QMetaObject::WriteProperty,
+                                                  d->coreIdx, a);
+                            return;
+                        }
+                    }
+                    break;
+
+                case QVariant::Int:
+                    {
+                        int i;
+                        bool found = true;
+                        if(vt == QVariant::Double) {
+                            i = (int)value.toDouble();
+                        } else if(vt == QVariant::UInt) {
+                            i = (int)value.toUInt();
+                        } else {
+                            found = false;
+                        }
+
+                        if(found) {
+                            void *a[1];
+                            a[0] = &i;
+                            QMetaObject::metacall(object(), 
+                                                  QMetaObject::WriteProperty,
+                                                  d->coreIdx, a);
+                            return;
+                        }
+                    }
+                    break;
+
+                case QVariant::String:
+                    {
+                        QString s;
+                        bool found = true;
+                        if(vt == QVariant::ByteArray) {
+                            s = QLatin1String(value.toByteArray());
+                        } else {
+                            found = false;
+                        }
+
+                        if(found) {
+                            void *a[1];
+                            a[0] = &s;
+                            QMetaObject::metacall(object(), 
+                                                  QMetaObject::WriteProperty,
+                                                  d->coreIdx, a);
+                            return;
+                        }
+                    }
+                    break;
+
+
+                default:
+                    break;
+                }
+                d->prop.write(object(), value);
+            }
+
+        }
+    }
+}
+
+/*!
+    Returns true if the property has a change notifier signal, otherwise false.
+*/
+bool QmlMetaProperty::hasChangedNotifier() const
+{
+    if(type() & Property && !(type() & Attached)) {
+        return d->prop.hasNotifySignal();
+    }
+    return false;
+}
+
+/*!
+    Connect the property's change notifier signal to the \a dest \a method.
+*/
+bool QmlMetaProperty::connectNotifier(QObject *dest, int method) const
+{
+    if(!(type() & Property) || type() & Attached)
+        return false;
+
+    if(d->prop.hasNotifySignal()) {
+        return QMetaObject::connect(d->object, d->prop.notifySignalIndex(), dest, method, Qt::DirectConnection);
+    } else {
+        return false;
+    }
+}
+
+/*!
+    Connect the property's change notifier signal to the \a dest \a slot.
+*/
+bool QmlMetaProperty::connectNotifier(QObject *dest, const char *slot) const
+{
+    if(!(type() & Property) || type() & Attached)
+        return false;
+
+    if(d->prop.hasNotifySignal()) {
+        QByteArray signal(QByteArray("2") + d->prop.notifySignal().signature());
+        return QObject::connect(d->object, signal.constData(), dest, slot);
+    } else  {
+        return false;
+    }
+}
+
+/*! \internal */
+void QmlMetaProperty::emitSignal()
+{
+    if(type() & Signal) {
+        if(d->signal.parameterTypes().isEmpty())
+            d->object->metaObject()->activate(d->object, d->coreIdx, 0);
+        else
+            qWarning() << "QmlMetaProperty: Cannot emit signal with parameters";
+    }
+}
+
+/*!
+    Return the Qt metaobject index of the property.
+*/
+int QmlMetaProperty::coreIndex() const
+{
+    return d->coreIdx;
+}
+
+/*!
+    Returns the property information serialized into a single integer.  
+    QmlMetaProperty uses the bottom 24 bits only.
+*/
+quint32 QmlMetaProperty::save() const
+{
+    quint32 rv = 0;
+    if(type() & Attached) {
+        rv = d->attachedFunc;
+    } else if(type() != Invalid) {
+        rv = d->coreIdx;
+    }
+
+    Q_ASSERT(rv <= 0xFFFF);
+    Q_ASSERT(type() <= 0xFF);
+    rv |= (type() << 16);
+
+    return rv;
+}
+
+/*!
+    Restore a QmlMetaProperty from a previously saved id.  \a obj must be the
+    same object as used in the previous call to QmlMetaProperty::save().  Only
+    the bottom 24-bits are used, the high bits can be set to any value.
+*/
+void QmlMetaProperty::restore(quint32 id, QObject *obj)
+{
+    *this = QmlMetaProperty();
+    d->object = obj;
+
+    id &= 0xFFFFFF;
+    d->type = id >> 16;
+    id &= 0xFFFF;
+
+    if(d->type & Attached) {
+        d->attachedFunc = id;
+    } else if(d->type & Property) {
+        QMetaPropertyEx p(obj->metaObject()->property(id));
+        d->prop = p;
+        d->propType = p.propertyType;
+        d->coreIdx = id;
+    } else if(d->type & SignalProperty || d->type & Signal) {
+        d->signal = obj->metaObject()->method(id);
+        d->coreIdx = id;
+    } 
+}
+
+/*!
+    Return the QMetaMethod for this property if it is a SignalProperty, 
+    otherwise returns an invalid QMetaMethod.
+*/
+QMetaMethod QmlMetaProperty::method() const
+{
+    return d->signal;
+}
+
+QT_END_NAMESPACE