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

**

** 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) {

        QDeclarative_setParent_noEvent(item, 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.

    A VisualItemModel contains the visual items to be used in a view.

    When a VisualItemModel is used in a view, the view does not require

    a delegate since the VisualItemModel already contains the visual

    delegate (items).

    An item can determine its index within the

    model via the \l{VisualItemModel::index}{index} attached property.

    The example below places three colored rectangles in a ListView.

    \code

    import Qt 4.7

    Rectangle {

        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

    \image visualitemmodel.png

    \sa {declarative/modelviews/visualitemmodel}{VisualItemModel example}

*/

QDeclarativeVisualItemModel::QDeclarativeVisualItemModel(QObject *parent)

    : QDeclarativeVisualModel(*(new QDeclarativeVisualItemModelPrivate), parent)

{

}

/*!

    \qmlattachedproperty int VisualItemModel::index

    This attached property holds the index of this delegate's item within the model.

    It is attached to each instance of the delegate.

*/

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 *item)

{

    if (item->scene())

        item->scene()->removeItem(item);

    QDeclarative_setParent_noEvent(item, this);

    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", -1);

            } 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();