path: root/src/declarative/qml/qmlmetaproperty.cpp

/****************************************************************************
**
** 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