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

**

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

#include "private/qdeclarativelistmodelworkeragent_p.h"

#include "private/qdeclarativeopenmetaobject_p.h"

#include <qdeclarativecustomparser_p.h>

#include <qdeclarativeparser_p.h>

#include <qdeclarativeengine_p.h>

#include <qdeclarativecontext.h>

#include <qdeclarativeinfo.h>

#include <QtCore/qdebug.h>

#include <QtCore/qstack.h>

#include <QXmlStreamReader>

#include <QtScript/qscriptvalueiterator.h>

Q_DECLARE_METATYPE(QListModelInterface *)

QT_BEGIN_NAMESPACE

QDeclarativeListModelParser::ListInstruction *QDeclarativeListModelParser::ListModelData::instructions() const

{

    return (QDeclarativeListModelParser::ListInstruction *)((char *)this + sizeof(ListModelData));

}

/*!

    \qmlclass ListModel QDeclarativeListModel

    \since 4.7

    \brief The ListModel element defines a free-form list data source.

    The ListModel is a simple hierarchy of elements containing data roles. The contents can

    be defined dynamically, or explicitly in QML:

    For example:

    \snippet doc/src/snippets/declarative/listmodel.qml 0

    Roles (properties) must begin with a lower-case letter. The above example defines a

    ListModel containing three elements, with the roles "name" and "cost".

    Values must be simple constants - either strings (quoted and optionally within a call to QT_TR_NOOP),

    bools (true, false), numbers, or enum values (like Text.AlignHCenter).

    The defined model can be used in views such as ListView:

    \snippet doc/src/snippets/declarative/listmodel-simple.qml 0

    \dots 8

    \snippet doc/src/snippets/declarative/listmodel-simple.qml 1

    \image listmodel.png

    It is possible for roles to contain list data.  In the example below we create a list of fruit attributes:

    \snippet doc/src/snippets/declarative/listmodel-nested.qml model

    The delegate below displays all the fruit attributes:

    \snippet doc/src/snippets/declarative/listmodel-nested.qml delegate

    \image listmodel-nested.png

    \section2 Modifying list models

    The content of a ListModel may be created and modified using the clear(),

    append(), set() and setProperty() methods.  For example:

    \snippet doc/src/snippets/declarative/listmodel-modify.qml delegate

    \section2 Using threaded list models with WorkerScript

    ListModel can be used together with WorkerScript access a list model

    from multiple threads. This is useful if list modifications are

    synchronous and take some time: the list operations can be moved to a

    different thread to avoid blocking of the main GUI thread.

    Here is an example that uses WorkerScript to periodically append the

    current time to a list model:

    \snippet examples/declarative/threading/threadedlistmodel/timedisplay.qml 0

    The included file, \tt dataloader.js, looks like this:

    \snippet examples/declarative/threading/threadedlistmodel/dataloader.js 0

    worker script by calling \l WorkerScript::sendMessage(). When this message

    is received, \l {WorkerScript::onMessage}{WorkerScript.onMessage()} is invoked in

    \tt dataloader.js, which appends the current time to the list model.

    Note the call to sync() from the \l {WorkerScript::onMessage}{WorkerScript.onMessage()} handler.

    You must call sync() or else the changes made to the list from the external

    thread will not be reflected in the list model in the main thread.

    \section3 Limitations

    If a list model is to be accessed from a WorkerScript, it \bold cannot

    contain list data. So, the following model cannot be used from a WorkerScript

    because of the list contained in the "attributes" property:

    \code

    ListModel {

        id: fruitModel

        ListElement {

            name: "Apple"

            cost: 2.45

            attributes: [

                ListElement { description: "Core" },

                ListElement { description: "Deciduous" }

            ]

        }

    }

    \endcode

    In addition, the WorkerScript cannot add any list data to the model.

    \sa {qmlmodels}{Data Models}, {declarative/threading/threadedlistmodel}{Threaded ListModel example}, QtDeclarative

*/

/*

    A ListModel internally uses either a NestedListModel or FlatListModel.

    A NestedListModel can contain lists of ListElements (which

    when retrieved from get() is accessible as a list model within the list

    model) whereas a FlatListModel cannot.

    ListModel uses a NestedListModel to begin with, and if the model is later 

    used from a WorkerScript, it changes to use a FlatListModel instead. This

    is because ModelNode (which abstracts the nested list model data) needs

    access to the declarative engine and script engine, which cannot be

    safely used from outside of the main thread.

*/

QDeclarativeListModel::QDeclarativeListModel(QObject *parent)

: QListModelInterface(parent), m_agent(0), m_nested(new NestedListModel(this)), m_flat(0), m_isWorkerCopy(false)

{

}

QDeclarativeListModel::QDeclarativeListModel(bool workerCopy, QObject *parent)

: QListModelInterface(parent), m_agent(0), m_nested(0), m_flat(0), m_isWorkerCopy(workerCopy)

{

    if (workerCopy)

        m_flat = new FlatListModel(this);

    else

        m_nested = new NestedListModel(this);

}

QDeclarativeListModel::~QDeclarativeListModel()

{

    if (m_agent)

        m_agent->release();

    delete m_nested;

    delete m_flat;

}

bool QDeclarativeListModel::flatten()

{

    if (m_flat)

        return true;

    QList<int> roles = m_nested->roles();

    QList<QHash<int, QVariant> > values;

    bool hasNested = false;

    for (int i=0; i<m_nested->count(); i++) {

        values.append(m_nested->data(i, roles, &hasNested));

        if (hasNested)

            return false;

    }

    FlatListModel *flat = new FlatListModel(this);

    flat->m_values = values;

    for (int i=0; i<roles.count(); i++) {

        QString s = m_nested->toString(roles[i]);

        flat->m_roles.insert(roles[i], s);

        flat->m_strings.insert(s, roles[i]);

    }

    m_flat = flat;

    delete m_nested;

    m_nested = 0;

    return true;

}

QDeclarativeListModelWorkerAgent *QDeclarativeListModel::agent()

{

    if (m_agent)

        return m_agent;

    if (!flatten()) {

        qmlInfo(this) << "List contains nested list values and cannot be used from a worker script";

        return 0;

    }

    m_agent = new QDeclarativeListModelWorkerAgent(this);

    return m_agent;

}

QList<int> QDeclarativeListModel::roles() const

{

    return m_flat ? m_flat->roles() : m_nested->roles();

}

QString QDeclarativeListModel::toString(int role) const

{

    return m_flat ? m_flat->toString(role) : m_nested->toString(role);

}

QHash<int,QVariant> QDeclarativeListModel::data(int index, const QList<int> &roles) const

{

    if (index >= count() || index < 0)

        return QHash<int, QVariant>();

    return m_flat ? m_flat->data(index, roles) : m_nested->data(index, roles);

}

QVariant QDeclarativeListModel::data(int index, int role) const

{

    if (index >= count() || index < 0)

        return QVariant();

    return m_flat ? m_flat->data(index, role) : m_nested->data(index, role);

}

/*!

    \qmlproperty int ListModel::count

    The number of data entries in the model.

*/

int QDeclarativeListModel::count() const

{

    return m_flat ? m_flat->count() : m_nested->count();

}

/*!

    \qmlmethod ListModel::clear()

    \sa append() remove()

*/

void QDeclarativeListModel::clear()

{

    int cleared = count();

    if (m_flat)

        m_flat->clear();

    else

        m_nested->clear();

    if (!m_isWorkerCopy) {

        emit itemsRemoved(0, cleared);

        emit countChanged();

    }

}

/*!

    \qmlmethod ListModel::remove(int index)

    Deletes the content at \a index from the model.

    \sa clear()

*/

void QDeclarativeListModel::remove(int index)

{

    if (index < 0 || index >= count()) {

        qmlInfo(this) << tr("remove: index %1 out of range").arg(index);

        return;

    }

    if (m_flat)

        m_flat->remove(index);

    else

        m_nested->remove(index);

    if (!m_isWorkerCopy) {

        emit itemsRemoved(index, 1);

        emit countChanged();

    }

}

/*!

    \qmlmethod ListModel::insert(int index, jsobject dict)

    Adds a new item to the list model at position \a index, with the

    values in \a dict.

    \code

        fruitModel.insert(2, {"cost": 5.95, "name":"Pizza"})

    \endcode

    The \a index must be to an existing item in the list, or one past

    the end of the list (equivalent to append).

    \sa set() append()

*/

void QDeclarativeListModel::insert(int index, const QScriptValue& valuemap)

{

    if (!valuemap.isObject() || valuemap.isArray()) {

        qmlInfo(this) << tr("insert: value is not an object");

        return;

    }

    if (index < 0 || index > count()) {

        qmlInfo(this) << tr("insert: index %1 out of range").arg(index);

        return;

    }

    bool ok = m_flat ?  m_flat->insert(index, valuemap) : m_nested->insert(index, valuemap);

    if (ok && !m_isWorkerCopy) {

        emit itemsInserted(index, 1);

        emit countChanged();

    }

}

/*!

    \qmlmethod ListModel::move(int from, int to, int n)

    Moves \a n items \a from one position \a to another.

    The from and to ranges must exist; for example, to move the first 3 items

    to the end of the list:

    \code

        fruitModel.move(0, fruitModel.count - 3, 3)

    \endcode

    \sa append()

*/

void QDeclarativeListModel::move(int from, int to, int n)

{

    if (n==0 || from==to)

        return;

    if (from+n > count() || to+n > count() || from < 0 || to < 0 || n < 0) {

        qmlInfo(this) << tr("move: out of range");

        return;

    }

    int origfrom = from;

    int origto = to;

    int orign = n;

    if (from > to) {

        // Only move forwards - flip if backwards moving

        int tfrom = from;

        int tto = to;

        from = tto;

        to = tto+n;

        n = tfrom-tto;

    }

    if (m_flat)

        m_flat->move(from, to, n);

    else

        m_nested->move(from, to, n);

    if (!m_isWorkerCopy)

        emit itemsMoved(origfrom, origto, orign);

}

/*!

    \qmlmethod ListModel::append(jsobject dict)

    Adds a new item to the end of the list model, with the

    values in \a dict.

    \code

        fruitModel.append({"cost": 5.95, "name":"Pizza"})

    \endcode

    \sa set() remove()

*/

void QDeclarativeListModel::append(const QScriptValue& valuemap)

{

    if (!valuemap.isObject() || valuemap.isArray()) {

        qmlInfo(this) << tr("append: value is not an object");

        return;

    }

    insert(count(), valuemap);

}

/*!

    \qmlmethod object ListModel::get(int index)

    Returns the item at \a index in the list model.

    \code

        fruitModel.append({"cost": 5.95, "name":"Jackfruit"})

        fruitModel.get(0).cost

    \endcode

    The \a index must be an element in the list.

    Note that properties of the returned object that are themselves objects

    will also be models, and this get() method is used to access elements:

    \code

        fruitModel.append(..., "attributes":

            [{"name":"spikes","value":"7mm"},

             {"name":"color","value":"green"}]);

        fruitModel.get(0).attributes.get(1).value; // == "green"

    \endcode

    \sa append()

*/

QScriptValue QDeclarativeListModel::get(int index) const

{

    // the internal flat/nested class checks for bad index

    return m_flat ? m_flat->get(index) : m_nested->get(index);

}

/*!

    \qmlmethod ListModel::set(int index, jsobject dict)

    Changes the item at \a index in the list model with the

    values in \a dict. Properties not appearing in \a dict

    are left unchanged.

    \code

        fruitModel.set(3, {"cost": 5.95, "name":"Pizza"})

    \endcode

    The \a index must be an element in the list.

    \sa append()

*/

void QDeclarativeListModel::set(int index, const QScriptValue& valuemap)

{

    if (!valuemap.isObject() || valuemap.isArray()) {

        qmlInfo(this) << tr("set: value is not an object");

        return;

    }

    if (count() == 0 || index > count() || index < 0) {

        qmlInfo(this) << tr("set: index %1 out of range").arg(index);

        return;

    }

    if (index == count()) {

        append(valuemap);

    } else {

        QList<int> roles;

        if (m_flat)

            m_flat->set(index, valuemap, &roles);

        else

            m_nested->set(index, valuemap, &roles);

        if (!m_isWorkerCopy)

            emit itemsChanged(index, 1, roles);

    }

}

/*!

    \qmlmethod ListModel::setProperty(int index, string property, variant value)

    Changes the \a property of the item at \a index in the list model to \a value.

    \code

        fruitModel.setProperty(3, "cost", 5.95)

    \endcode

    The \a index must be an element in the list.

    \sa append()

*/

void QDeclarativeListModel::setProperty(int index, const QString& property, const QVariant& value)

{

    if (count() == 0 || index >= count() || index < 0) {

        qmlInfo(this) << tr("set: index %1 out of range").arg(index);

        return;

    }

    QList<int> roles;

    if (m_flat)

        m_flat->setProperty(index, property, value, &roles);

    else

        m_nested->setProperty(index, property, value, &roles);

    if (!m_isWorkerCopy)

        emit itemsChanged(index, 1, roles);

}