/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (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 Technology Preview License Agreement accompanying

** this package.

**

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qdeclarativeproperty.h"

#include "private/qdeclarativeproperty_p.h"

#include "private/qdeclarativecompositetypedata_p.h"

#include "qdeclarative.h"

#include "private/qdeclarativebinding_p.h"

#include "qdeclarativecontext.h"

#include "private/qdeclarativecontext_p.h"

#include "private/qdeclarativeboundsignal_p.h"

#include "qdeclarativeengine.h"

#include "private/qdeclarativeengine_p.h"

#include "private/qdeclarativedata_p.h"

#include "private/qdeclarativestringconverters_p.h"

#include "private/qdeclarativelist_p.h"

#include "private/qdeclarativecompiler_p.h"

#include <QStringList>

#include <QtCore/qdebug.h>

#include <math.h>

QT_BEGIN_NAMESPACE

/*!

\class QDeclarativeProperty

\since 4.7

\brief The QDeclarativeProperty class abstracts accessing properties on objects created from  QML.

As QML uses Qt's meta-type system all of the existing QMetaObject classes can be used to introspect

and interact with objects created by QML.  However, some of the new features provided by QML - such 

as type safety and attached properties - are most easily used through the QDeclarativeProperty class 

that simplifies some of their natural complexity.

Unlike QMetaProperty which represents a property on a class type, QDeclarativeProperty encapsulates 

a property on a specific object instance.  To read a property's value, programmers create a 

QDeclarativeProperty instance and call the read() method.  Likewise to write a property value the

write() method is used.

\code

QObject *object = declarativeComponent.create();

QDeclarativeProperty property(object, "font.pixelSize");

qWarning() << "Current pixel size:" << property.read().toInt();

property.write(24);

qWarning() << "Pixel size should now be 24:" << property.read().toInt();

\endcode

*/

/*!

    Create an invalid QDeclarativeProperty.

*/

QDeclarativeProperty::QDeclarativeProperty()

: d(new QDeclarativePropertyPrivate)

{

    d->q = this;

}

/*!  \internal */

QDeclarativeProperty::~QDeclarativeProperty()

{

    delete d; d = 0;

}

/*!

    Creates a QDeclarativeProperty for the default property of \a obj. If there is no

    default property, an invalid QDeclarativeProperty will be created.

 */

QDeclarativeProperty::QDeclarativeProperty(QObject *obj)

: d(new QDeclarativePropertyPrivate)

{

    d->q = this;

    d->initDefault(obj);

}

/*!

    Creates a QDeclarativeProperty for the default property of \a obj

    using the \l{QDeclarativeContext} {context} \a ctxt. If there is

    no default property, an invalid QDeclarativeProperty will be

    created.

 */

QDeclarativeProperty::QDeclarativeProperty(QObject *obj, QDeclarativeContext *ctxt)

: d(new QDeclarativePropertyPrivate)

{

    d->q = this;

    d->context = ctxt?QDeclarativeContextData::get(ctxt):0;

    d->engine = ctxt?ctxt->engine():0;

    d->initDefault(obj);

}

/*!

    Creates a QDeclarativeProperty for the default property of \a obj

    using the environment for instantiating QML components that is

    provided by \a engine.  If there is no default property, an

    invalid QDeclarativeProperty will be created.

 */

QDeclarativeProperty::QDeclarativeProperty(QObject *obj, QDeclarativeEngine *engine)

  : d(new QDeclarativePropertyPrivate)

{

    d->q = this;

    d->context = 0;

    d->engine = engine;

    d->initDefault(obj);

}

/*!

    Initialize from the default property of \a obj

*/

void QDeclarativePropertyPrivate::initDefault(QObject *obj)

{

    if (!obj)

        return;

    QMetaProperty p = QDeclarativeMetaType::defaultProperty(obj);

    core.load(p);

    if (core.isValid()) 

        object = obj;

}

/*!

    Creates a QDeclarativeProperty for the property \a name of \a obj.

 */

QDeclarativeProperty::QDeclarativeProperty(QObject *obj, const QString &name)

: d(new QDeclarativePropertyPrivate)

{

    d->q = this;

    d->initProperty(obj, name);

    if (!isValid()) d->object = 0;

}

/*!

    Creates a QDeclarativeProperty for the property \a name of \a obj

    using the \l{QDeclarativeContext} {context} \a ctxt.

*/

QDeclarativeProperty::QDeclarativeProperty(QObject *obj, const QString &name, QDeclarativeContext *ctxt)

: d(new QDeclarativePropertyPrivate)

{

    d->q = this;

    d->context = ctxt?QDeclarativeContextData::get(ctxt):0;

    d->engine = ctxt?ctxt->engine():0;

    d->initProperty(obj, name);

    if (!isValid()) { d->object = 0; d->context = 0; d->engine = 0; }

}

/*!

    Creates a QDeclarativeProperty for the property \a name of \a obj

    using the environment for instantiating QML components that is

    provided by \a engine.

 */

QDeclarativeProperty::QDeclarativeProperty(QObject *obj, const QString &name, QDeclarativeEngine *engine)

: d(new QDeclarativePropertyPrivate)

{

    d->q = this;

    d->context = 0;

    d->engine = engine;

    d->initProperty(obj, name);

    if (!isValid()) { d->object = 0; d->context = 0; d->engine = 0; }

}

Q_GLOBAL_STATIC(QDeclarativeValueTypeFactory, qmlValueTypes);

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

{

    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->index(), 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->index(), 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;

    }

}

/*!

    Create a copy of \a other.

*/

QDeclarativeProperty::QDeclarativeProperty(const QDeclarativeProperty &other)

: d(new QDeclarativePropertyPrivate(*other.d))

{

    d->q = this;

}

/*!

  \enum QDeclarativeProperty::PropertyTypeCategory

  This enum specifies a category of QML property.

  \value InvalidCategory The property is invalid, or is a signal property.

  \value List The property is a QDeclarativeListProperty list property

  \value Object The property is a QObject derived type pointer

  \value Normal The property is a normal value property.

 */

/*!

  \enum QDeclarativeProperty::Type

  This enum specifies a type of QML property.

  \value Invalid The property is invalid.

  \value Property The property is a regular Qt property.

  \value SignalProperty The property is a signal property.

*/

/*!

    Returns the property category.

*/

QDeclarativeProperty::PropertyTypeCategory QDeclarativeProperty::propertyTypeCategory() const

{

    return d->propertyTypeCategory();

}

QDeclarativeProperty::PropertyTypeCategory 

QDeclarativePropertyPrivate::propertyTypeCategory() const

{

    uint type = q->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;

    }

}

/*!

    Returns the type name of the property, or 0 if the property has no type

    name.

*/

const char *QDeclarativeProperty::propertyTypeName() const

{

    if (d->isValueType()) {

        QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(d->context);

        QDeclarativeValueType *valueType = 0;

        if (ep) valueType = ep->valueTypes[d->core.propType];

        else valueType = QDeclarativeValueTypeFactory::valueType(d->core.propType);

        Q_ASSERT(valueType);

        const char *rv = valueType->metaObject()->property(d->valueType.valueTypeCoreIdx).typeName();

        if (!ep) delete valueType;

        return rv;

    } else if (d->object && type() & Property && d->core.isValid()) {

        return d->object->metaObject()->property(d->core.coreIndex).typeName();

    } else {

        return 0;

    }

}

/*!

    Returns true if \a other and this QDeclarativeProperty represent the same 

    property.

*/

bool QDeclarativeProperty::operator==(const QDeclarativeProperty &other) const

{

    // category is intentially omitted here as it is generated 

    // from the other members

    return d->object == other.d->object &&

           d->core == other.d->core &&

           d->valueType == other.d->valueType;

}

/*!

    Returns the QVariant type of the property, or QVariant::Invalid if the 

    property has no QVariant type.

*/

int QDeclarativeProperty::propertyType() const

{

    return d->propertyType();

}

bool QDeclarativePropertyPrivate::isValueType() const

{

    return valueType.valueTypeCoreIdx != -1;

}

int QDeclarativePropertyPrivate::propertyType() const

{

    uint type = q->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;

    }

}

/*!

    Returns the type of the property.

*/

QDeclarativeProperty::Type QDeclarativeProperty::type() const

{

    if (d->core.flags & QDeclarativePropertyCache::Data::IsFunction)

        return SignalProperty;

    else if (d->core.isValid())

        return Property;

    else

        return Invalid;

}

/*!

    Returns true if this QDeclarativeProperty represents a regular Qt property.

*/

bool QDeclarativeProperty::isProperty() const

{

    return type() & Property;

}

/*!

    Returns true if this QDeclarativeProperty represents a QML signal property.

*/

bool QDeclarativeProperty::isSignalProperty() const

{

    return type() & SignalProperty;

}

/*!

    Returns the QDeclarativeProperty's QObject.

*/

QObject *QDeclarativeProperty::object() const

{

    return d->object;

}

/*!

    Assign \a other to this QDeclarativeProperty.

*/

QDeclarativeProperty &QDeclarativeProperty::operator=(const QDeclarativeProperty &other)

{

    d->context = other.d->context;

    d->engine = other.d->engine;

    d->object = other.d->object;

    d->isNameCached = other.d->isNameCached;

    d->core = other.d->core;

    d->nameCache = other.d->nameCache;

    d->valueType = other.d->valueType;

    return *this;

}

/*!

    Returns true if the property is writable, otherwise false.

*/

bool QDeclarativeProperty::isWritable() const

{

    if (!d->object)

        return false;

    if (d->core.flags & QDeclarativePropertyCache::Data::IsQList)           //list

        return true;

    else if (d->core.flags & QDeclarativePropertyCache::Data::IsFunction)   //signal handler

        return false;

    else if (d->core.isValid())                                             //normal property

        return d->core.flags & QDeclarativePropertyCache::Data::IsWritable;

    else

        return false;

}

/*!

    Returns true if the property is designable, otherwise false.

*/

bool QDeclarativeProperty::isDesignable() const

{

    if (type() & Property && d->core.isValid() && d->object)

        return d->object->metaObject()->property(d->core.coreIndex).isDesignable();

    else

        return false;

}

/*!

    Returns true if the property is resettable, otherwise false.

*/

bool QDeclarativeProperty::isResettable() const

{

    if (type() & Property && d->core.isValid() && d->object)

        return d->core.flags & QDeclarativePropertyCache::Data::IsResettable;

    else