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

**

** 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 "private/qdeclarativevisualitemmodel_p.h"

#include "qdeclarativeitem.h"

#include <qdeclarativecontext.h>

#include <qdeclarativecontext_p.h>

#include <qdeclarativeengine.h>

#include <qdeclarativeexpression.h>

#include <qdeclarativepackage_p.h>

#include <qdeclarativeopenmetaobject_p.h>

#include <qdeclarativelistaccessor_p.h>

#include <qdeclarativeinfo.h>

#include <qdeclarativedata_p.h>

#include <qdeclarativepropertycache_p.h>

#include <qdeclarativeguard_p.h>

#include <qdeclarativeglobal_p.h>

#include <qgraphicsscene.h>

#include <qlistmodelinterface_p.h>

#include <qhash.h>

#include <qlist.h>

#include <qmetaobjectbuilder_p.h>

#include <QtCore/qdebug.h>

#include <private/qobject_p.h>

QT_BEGIN_NAMESPACE

QHash<QObject*, QDeclarativeVisualItemModelAttached*> QDeclarativeVisualItemModelAttached::attachedProperties;

class QDeclarativeVisualItemModelPrivate : public QObjectPrivate

{

    Q_DECLARE_PUBLIC(QDeclarativeVisualItemModel)

public:

    QDeclarativeVisualItemModelPrivate() : QObjectPrivate() {}

    static void children_append(QDeclarativeListProperty<QDeclarativeItem> *prop, QDeclarativeItem *item) {

        item->QObject::setParent(prop->object);

        static_cast<QDeclarativeVisualItemModelPrivate *>(prop->data)->children.append(item);

        static_cast<QDeclarativeVisualItemModelPrivate *>(prop->data)->itemAppended();

        static_cast<QDeclarativeVisualItemModelPrivate *>(prop->data)->emitChildrenChanged();

    }

    static int children_count(QDeclarativeListProperty<QDeclarativeItem> *prop) {

        return static_cast<QDeclarativeVisualItemModelPrivate *>(prop->data)->children.count();

    }

    static QDeclarativeItem *children_at(QDeclarativeListProperty<QDeclarativeItem> *prop, int index) {

        return static_cast<QDeclarativeVisualItemModelPrivate *>(prop->data)->children.at(index);

    }

    void itemAppended() {

        Q_Q(QDeclarativeVisualItemModel);

        QDeclarativeVisualItemModelAttached *attached = QDeclarativeVisualItemModelAttached::properties(children.last());

        attached->setIndex(children.count()-1);

        emit q->itemsInserted(children.count()-1, 1);

        emit q->countChanged();

    }

    void emitChildrenChanged() {

        Q_Q(QDeclarativeVisualItemModel);

        emit q->childrenChanged();

    }

    QList<QDeclarativeItem *> children;

};

/*!

    \qmlclass VisualItemModel QDeclarativeVisualItemModel

  \since 4.7

    \brief The VisualItemModel allows items to be provided to a view.

    The children of the VisualItemModel are provided in a model which

    can be used in a view.  Note that no delegate should be

    provided to a view since the VisualItemModel contains the

    visual delegate (items).

    An item can determine its index within the

    model via the VisualItemModel.index attached property.

    The example below places three colored rectangles in a ListView.

    \code

    Item {

        VisualItemModel {

            id: itemModel

            Rectangle { height: 30; width: 80; color: "red" }

            Rectangle { height: 30; width: 80; color: "green" }

            Rectangle { height: 30; width: 80; color: "blue" }

        }

        ListView {

            anchors.fill: parent

            model: itemModel

        }

    }

    \endcode

*/

QDeclarativeVisualItemModel::QDeclarativeVisualItemModel(QObject *parent)

    : QDeclarativeVisualModel(*(new QDeclarativeVisualItemModelPrivate), parent)

{

}

QDeclarativeListProperty<QDeclarativeItem> QDeclarativeVisualItemModel::children()

{

    Q_D(QDeclarativeVisualItemModel);

    return QDeclarativeListProperty<QDeclarativeItem>(this, d, d->children_append,

                                                      d->children_count, d->children_at);

}

/*!

    \qmlproperty int VisualItemModel::count

    The number of items in the model.  This property is readonly.

*/

int QDeclarativeVisualItemModel::count() const

{

    Q_D(const QDeclarativeVisualItemModel);

    return d->children.count();

}

bool QDeclarativeVisualItemModel::isValid() const

{

    return true;

}

QDeclarativeItem *QDeclarativeVisualItemModel::item(int index, bool)

{

    Q_D(QDeclarativeVisualItemModel);

    return d->children.at(index);

}

QDeclarativeVisualModel::ReleaseFlags QDeclarativeVisualItemModel::release(QDeclarativeItem *)

{

    // Nothing to do

    return 0;

}

bool QDeclarativeVisualItemModel::completePending() const

{

    return false;

}

void QDeclarativeVisualItemModel::completeItem()

{

    // Nothing to do

}

QString QDeclarativeVisualItemModel::stringValue(int index, const QString &name)

{

    Q_D(QDeclarativeVisualItemModel);

    if (index < 0 || index >= d->children.count())

        return QString();

    return QDeclarativeEngine::contextForObject(d->children.at(index))->contextProperty(name).toString();

}

QVariant QDeclarativeVisualItemModel::evaluate(int index, const QString &expression, QObject *objectContext)

{

    Q_D(QDeclarativeVisualItemModel);

    if (index < 0 || index >= d->children.count())

        return QVariant();

    QDeclarativeContext *ccontext = qmlContext(this);

    QDeclarativeContext *ctxt = new QDeclarativeContext(ccontext);

    ctxt->setContextObject(d->children.at(index));

    QDeclarativeExpression e(ctxt, objectContext, expression);

    QVariant value = e.evaluate();

    delete ctxt;

    return value;

}

int QDeclarativeVisualItemModel::indexOf(QDeclarativeItem *item, QObject *) const

{

    Q_D(const QDeclarativeVisualItemModel);

    return d->children.indexOf(item);

}

QDeclarativeVisualItemModelAttached *QDeclarativeVisualItemModel::qmlAttachedProperties(QObject *obj)

{

    return QDeclarativeVisualItemModelAttached::properties(obj);

}

//============================================================================

class VDMDelegateDataType : public QDeclarativeOpenMetaObjectType

{

public:

    VDMDelegateDataType(const QMetaObject *base, QDeclarativeEngine *engine) : QDeclarativeOpenMetaObjectType(base, engine) {}

    void propertyCreated(int, QMetaPropertyBuilder &prop) {

        prop.setWritable(false);

    }

};

class QDeclarativeVisualDataModelParts;

class QDeclarativeVisualDataModelData;

class QDeclarativeVisualDataModelPrivate : public QObjectPrivate

{

public:

    QDeclarativeVisualDataModelPrivate(QDeclarativeContext *);

    static QDeclarativeVisualDataModelPrivate *get(QDeclarativeVisualDataModel *m) {

        return static_cast<QDeclarativeVisualDataModelPrivate *>(QObjectPrivate::get(m));

    }

    QDeclarativeGuard<QListModelInterface> m_listModelInterface;

    QDeclarativeGuard<QAbstractItemModel> m_abstractItemModel;

    QDeclarativeGuard<QDeclarativeVisualDataModel> m_visualItemModel;

    QString m_part;

    QDeclarativeComponent *m_delegate;

    QDeclarativeGuard<QDeclarativeContext> m_context;

    QList<int> m_roles;

    QHash<QByteArray,int> m_roleNames;

    void ensureRoles() {

        if (m_roleNames.isEmpty()) {

            if (m_listModelInterface) {

                m_roles = m_listModelInterface->roles();

                for (int ii = 0; ii < m_roles.count(); ++ii)

                    m_roleNames.insert(m_listModelInterface->toString(m_roles.at(ii)).toUtf8(), m_roles.at(ii));

                if (m_roles.count() == 1)

                    m_roleNames.insert("modelData", m_roles.at(0));

            } else if (m_abstractItemModel) {

                for (QHash<int,QByteArray>::const_iterator it = m_abstractItemModel->roleNames().begin();

                        it != m_abstractItemModel->roleNames().end(); ++it) {

                    m_roles.append(it.key());

                    m_roleNames.insert(*it, it.key());

                }

                if (m_roles.count() == 1)

                    m_roleNames.insert("modelData", m_roles.at(0));

                if (m_roles.count())

                    m_roleNames.insert("hasModelChildren", 0);

            } else if (m_listAccessor) {

                m_roleNames.insert("modelData", 0);

                if (m_listAccessor->type() == QDeclarativeListAccessor::Instance) {

                    if (QObject *object = m_listAccessor->at(0).value<QObject*>()) {

                        int count = object->metaObject()->propertyCount();

                        for (int ii = 1; ii < count; ++ii) {

                            const QMetaProperty &prop = object->metaObject()->property(ii);

                            m_roleNames.insert(prop.name(), 0);

                        }

                    }

                }

            }

        }

    }

    QHash<int,int> roleToPropId;

    void createMetaData() {

        if (!m_metaDataCreated) {

            ensureRoles();

            if (m_roleNames.count()) {

                QHash<QByteArray, int>::const_iterator it = m_roleNames.begin();

                while (it != m_roleNames.end()) {

                    int propId = m_delegateDataType->createProperty(it.key()) - m_delegateDataType->propertyOffset();

                    roleToPropId.insert(*it, propId);

                    ++it;

                }

                m_metaDataCreated = true;

            }

        }

    }

    struct ObjectRef {

        ObjectRef(QObject *object=0) : obj(object), ref(1) {}

        QObject *obj;

        int ref;

    };

    class Cache : public QHash<int, ObjectRef> {

    public:

        QObject *getItem(int index) {

            QObject *item = 0;

            QHash<int,ObjectRef>::iterator it = find(index);

            if (it != end()) {

                (*it).ref++;

                item = (*it).obj;

            }

            return item;

        }

        QObject *item(int index) {

            QObject *item = 0;

            QHash<int, ObjectRef>::const_iterator it = find(index);

            if (it != end())

                item = (*it).obj;

            return item;

        }

        void insertItem(int index, QObject *obj) {

            insert(index, ObjectRef(obj));

        }

        bool releaseItem(QObject *obj) {

            QHash<int, ObjectRef>::iterator it = begin();

            for (; it != end(); ++it) {

                ObjectRef &objRef = *it;

                if (objRef.obj == obj) {

                    if (--objRef.ref == 0) {

                        erase(it);

                        return true;

                    }

                    break;

                }

            }

            return false;

        }

    };

    int modelCount() const {

        if (m_visualItemModel)

            return m_visualItemModel->count();

        if (m_listModelInterface)

            return m_listModelInterface->count();

        if (m_abstractItemModel)

            return m_abstractItemModel->rowCount(m_root);

        if (m_listAccessor)

            return m_listAccessor->count();

        return 0;

    }

    Cache m_cache;

    QHash<QObject *, QDeclarativePackage*> m_packaged;

    QDeclarativeVisualDataModelParts *m_parts;

    friend class QDeclarativeVisualItemParts;

    VDMDelegateDataType *m_delegateDataType;

    friend class QDeclarativeVisualDataModelData;

    bool m_metaDataCreated : 1;

    bool m_metaDataCacheable : 1;

    bool m_delegateValidated : 1;

    bool m_completePending : 1;

    QDeclarativeVisualDataModelData *data(QObject *item);

    QVariant m_modelVariant;

    QDeclarativeListAccessor *m_listAccessor;

    QModelIndex m_root;

};

class QDeclarativeVisualDataModelDataMetaObject : public QDeclarativeOpenMetaObject

{

public:

    QDeclarativeVisualDataModelDataMetaObject(QObject *parent, QDeclarativeOpenMetaObjectType *type)

    : QDeclarativeOpenMetaObject(parent, type) {}

    virtual QVariant initialValue(int);

    virtual int createProperty(const char *, const char *);

private:

    friend class QDeclarativeVisualDataModelData;

};

class QDeclarativeVisualDataModelData : public QObject

{

Q_OBJECT

public:

    QDeclarativeVisualDataModelData(int index, QDeclarativeVisualDataModel *model);

    ~QDeclarativeVisualDataModelData();

    Q_PROPERTY(int index READ index NOTIFY indexChanged)

    int index() const;

    void setIndex(int index);

    int propForRole(int) const;

    void setValue(int, const QVariant &);

    void ensureProperties();

Q_SIGNALS:

    void indexChanged();

private:

    friend class QDeclarativeVisualDataModelDataMetaObject;

    int m_index;

    QDeclarativeGuard<QDeclarativeVisualDataModel> m_model;

    QDeclarativeVisualDataModelDataMetaObject *m_meta;

};

int QDeclarativeVisualDataModelData::propForRole(int id) const

{

    QDeclarativeVisualDataModelPrivate *model = QDeclarativeVisualDataModelPrivate::get(m_model);

    QHash<int,int>::const_iterator it = model->roleToPropId.find(id);

    if (it != model->roleToPropId.end())

        return *it;

    return -1;

}

void QDeclarativeVisualDataModelData::setValue(int id, const QVariant &val)

{

    m_meta->setValue(id, val);

}

int QDeclarativeVisualDataModelDataMetaObject::createProperty(const char *name, const char *type)

{

    QDeclarativeVisualDataModelData *data =

        static_cast<QDeclarativeVisualDataModelData *>(object());

    if (!data->m_model)

        return -1;

    QDeclarativeVisualDataModelPrivate *model = QDeclarativeVisualDataModelPrivate::get(data->m_model);

    if (data->m_index < 0 || data->m_index >= model->modelCount())

        return -1;

    if ((!model->m_listModelInterface || !model->m_abstractItemModel) && model->m_listAccessor) {

        if (model->m_listAccessor->type() == QDeclarativeListAccessor::ListProperty) {

            model->ensureRoles();

            if (qstrcmp(name,"modelData") == 0)

                return QDeclarativeOpenMetaObject::createProperty(name, type);

        }

    }

    return -1;

}

QVariant QDeclarativeVisualDataModelDataMetaObject::initialValue(int propId)

{

    QDeclarativeVisualDataModelData *data =

        static_cast<QDeclarativeVisualDataModelData *>(object());

    Q_ASSERT(data->m_model);

    QDeclarativeVisualDataModelPrivate *model = QDeclarativeVisualDataModelPrivate::get(data->m_model);

    QByteArray propName = name(propId);

    if ((!model->m_listModelInterface || !model->m_abstractItemModel) && model->m_listAccessor) {

        if (propName == "modelData") {

            if (model->m_listAccessor->type() == QDeclarativeListAccessor::Instance) {

                QObject *object = model->m_listAccessor->at(0).value<QObject*>();

                return object->metaObject()->property(1).read(object); // the first property after objectName

            }

            return model->m_listAccessor->at(data->m_index);

        } else {

            // return any property of a single object instance.

            QObject *object = model->m_listAccessor->at(data->m_index).value<QObject*>();

            return object->property(propName);

        }

    } else if (model->m_listModelInterface) {

        model->ensureRoles();

        QHash<QByteArray,int>::const_iterator it = model->m_roleNames.find(propName);

        if (it != model->m_roleNames.end()) {

            QVariant value = model->m_listModelInterface->data(data->m_index, *it);

            return value;

        } else if (model->m_roles.count() == 1 && propName == "modelData") {

            //for compatability with other lists, assign modelData if there is only a single role

            QVariant value = model->m_listModelInterface->data(data->m_index, model->m_roles.first());

            return value;

        }

    } else if (model->m_abstractItemModel) {

        model->ensureRoles();

        if (propName == "hasModelChildren") {

            QModelIndex index = model->m_abstractItemModel->index(data->m_index, 0, model->m_root);

            return model->m_abstractItemModel->hasChildren(index);

        } else {

            QHash<QByteArray,int>::const_iterator it = model->m_roleNames.find(propName);

            if (it != model->m_roleNames.end()) {

                QModelIndex index = model->m_abstractItemModel->index(data->m_index, 0, model->m_root);

                return model->m_abstractItemModel->data(index, *it);

            }

        }

    }

    Q_ASSERT(!"Can never be reached");

    return QVariant();

}

QDeclarativeVisualDataModelData::QDeclarativeVisualDataModelData(int index,

                                               QDeclarativeVisualDataModel *model)

: m_index(index), m_model(model),

m_meta(new QDeclarativeVisualDataModelDataMetaObject(this, QDeclarativeVisualDataModelPrivate::get(model)->m_delegateDataType))

{

    ensureProperties();

}

QDeclarativeVisualDataModelData::~QDeclarativeVisualDataModelData()

{

}

void QDeclarativeVisualDataModelData::ensureProperties()

{

    QDeclarativeVisualDataModelPrivate *modelPriv = QDeclarativeVisualDataModelPrivate::get(m_model);

    if (modelPriv->m_metaDataCacheable && !modelPriv->m_metaDataCreated) {

        modelPriv->createMetaData();

        if (modelPriv->m_metaDataCreated)

            m_meta->setCached(true);

    }

}

int QDeclarativeVisualDataModelData::index() const

{