Say hello to QtQuick module

This change moves the QtQuick 2 types and C++ API (including
SceneGraph) to a new module (AKA library), QtQuick.

99% of this change is moving files from src/declarative to
src/quick, and from tests/auto/declarative to
tests/auto/qtquick2.

The loading of QtQuick 2 ("import QtQuick 2.0") is now delegated to
a plugin, src/imports/qtquick2, just like it's done for QtQuick 1.

All tools, examples, and tests that use QtQuick C++ API have gotten
"QT += quick" or "QT += quick-private" added to their .pro file.

A few additional internal QtDeclarative classes had to be exported
(via Q_DECLARATIVE_PRIVATE_EXPORT) since they're needed by the
QtQuick 2 implementation.

The old header locations (e.g. QtDeclarative/qquickitem.h) will
still be supported for some time, but will produce compile-time
warnings. (To avoid the QtQuick implementation using the
compatibility headers (since QtDeclarative's includepath comes
first), a few include statements were modified, e.g. from
"#include <qsgnode.h>" to "#include <QtQuick/qsgnode.h>".)

There's a change in qtbase that automatically adds QtQuick to the
module list if QtDeclarative is used. Together with the compatibility
headers, this should help reduce the migration pain for existing
projects.

In theory, simply getting an existing QtDeclarative-based project
to compile and link shouldn't require any changes for now -- but
porting to the new scheme is of course recommended, and will
eventually become mandatory.

Task-number: QTBUG-22889
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
Change-Id: Ia52be9373172ba2f37e7623231ecb060316c96a7
Reviewed-by: Kent Hansen <kent.hansen@nokia.com>
Reviewed-by: Sergio Ahumada <sergio.ahumada@nokia.com>

1 files changed, 476 insertions, 0 deletions

diff --git a/src/quick/items/qquickrepeater.cpp b/src/quick/items/qquickrepeater.cpp
new file mode 100644
index 0000000000..efa83eec38
--- /dev/null
+++ b/src/quick/items/qquickrepeater.cpp
@@ -0,0 +1,476 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** 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.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickrepeater_p.h"
+#include "qquickrepeater_p_p.h"
+#include "qquickvisualdatamodel_p.h"
+
+#include <private/qdeclarativeglobal_p.h>
+#include <private/qdeclarativelistaccessor_p.h>
+#include <private/qlistmodelinterface_p.h>
+#include <private/qdeclarativechangeset_p.h>
+
+QT_BEGIN_NAMESPACE
+
+QQuickRepeaterPrivate::QQuickRepeaterPrivate()
+    : model(0), ownModel(false), inRequest(false), itemCount(0), createFrom(-1)
+{
+}
+
+QQuickRepeaterPrivate::~QQuickRepeaterPrivate()
+{
+    if (ownModel)
+        delete model;
+}
+
+/*!
+    \qmlclass Repeater QQuickRepeater
+    \inqmlmodule QtQuick 2
+    \ingroup qml-utility-elements
+    \inherits Item
+
+    \brief The Repeater element allows you to repeat an Item-based component using a model.
+
+    The Repeater element is used to create a large number of
+    similar items. Like other view elements, a Repeater has a \l model and a \l delegate:
+    for each entry in the model, the delegate is instantiated
+    in a context seeded with data from the model. A Repeater item is usually
+    enclosed in a positioner element such as \l Row or \l Column to visually
+    position the multiple delegate items created by the Repeater.
+
+    The following Repeater creates three instances of a \l Rectangle item within
+    a \l Row:
+
+    \snippet doc/src/snippets/declarative/repeaters/repeater.qml import
+    \codeline
+    \snippet doc/src/snippets/declarative/repeaters/repeater.qml simple
+
+    \image repeater-simple.png
+
+    A Repeater's \l model can be any of the supported \l {qmlmodels}{data models}.
+    Additionally, like delegates for other views, a Repeater delegate can access
+    its index within the repeater, as well as the model data relevant to the
+    delegate. See the \l delegate property documentation for details.
+
+    Items instantiated by the Repeater are inserted, in order, as
+    children of the Repeater's parent.  The insertion starts immediately after
+    the repeater's position in its parent stacking list.  This allows
+    a Repeater to be used inside a layout. For example, the following Repeater's
+    items are stacked between a red rectangle and a blue rectangle:
+
+    \snippet doc/src/snippets/declarative/repeaters/repeater.qml layout
+
+    \image repeater.png
+
+
+    \note A Repeater item owns all items it instantiates. Removing or dynamically destroying
+    an item created by a Repeater results in unpredictable behavior.
+
+
+    \section2 Considerations when using Repeater
+
+    The Repeater element creates all of its delegate items when the repeater is first
+    created. This can be inefficient if there are a large number of delegate items and
+    not all of the items are required to be visible at the same time. If this is the case,
+    consider using other view elements like ListView (which only creates delegate items
+    when they are scrolled into view) or use the \l {Dynamic Object Creation} methods to
+    create items as they are required.
+
+    Also, note that Repeater is \l {Item}-based, and can only repeat \l {Item}-derived objects.
+    For example, it cannot be used to repeat QtObjects:
+    \badcode
+    Item {
+        //XXX does not work! Can't repeat QtObject as it doesn't derive from Item.
+        Repeater {
+            model: 10
+            QtObject {}
+        }
+    }
+    \endcode
+ */
+
+/*!
+    \qmlsignal QtQuick2::Repeater::onItemAdded(int index, Item item)
+
+    This handler is called when an item is added to the repeater. The \a index
+    parameter holds the index at which the item has been inserted within the
+    repeater, and the \a item parameter holds the \l Item that has been added.
+*/
+
+/*!
+    \qmlsignal QtQuick2::Repeater::onItemRemoved(int index, Item item)
+
+    This handler is called when an item is removed from the repeater. The \a index
+    parameter holds the index at which the item was removed from the repeater,
+    and the \a item parameter holds the \l Item that was removed.
+
+    Do not keep a reference to \a item if it was created by this repeater, as
+    in these cases it will be deleted shortly after the handler is called.
+*/
+QQuickRepeater::QQuickRepeater(QQuickItem *parent)
+  : QQuickItem(*(new QQuickRepeaterPrivate), parent)
+{
+}
+
+QQuickRepeater::~QQuickRepeater()
+{
+}
+
+/*!
+    \qmlproperty any QtQuick2::Repeater::model
+
+    The model providing data for the repeater.
+
+    This property can be set to any of the supported \l {qmlmodels}{data models}:
+
+    \list
+    \o A number that indicates the number of delegates to be created by the repeater
+    \o A model (e.g. a ListModel item, or a QAbstractItemModel subclass)
+    \o A string list
+    \o An object list
+    \endlist
+
+    The type of model affects the properties that are exposed to the \l delegate.
+
+    \sa {qmlmodels}{Data Models}
+*/
+QVariant QQuickRepeater::model() const
+{
+    Q_D(const QQuickRepeater);
+    return d->dataSource;
+}
+
+void QQuickRepeater::setModel(const QVariant &model)
+{
+    Q_D(QQuickRepeater);
+    if (d->dataSource == model)
+        return;
+
+    clear();
+    if (d->model) {
+        disconnect(d->model, SIGNAL(modelUpdated(QDeclarativeChangeSet,bool)),
+                this, SLOT(modelUpdated(QDeclarativeChangeSet,bool)));
+        disconnect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
+        disconnect(d->model, SIGNAL(initItem(int,QQuickItem*)), this, SLOT(initItem(int,QQuickItem*)));
+//        disconnect(d->model, SIGNAL(destroyingItem(QQuickItem*)), this, SLOT(destroyingItem(QQuickItem*)));
+    }
+    d->dataSource = model;
+    QObject *object = qvariant_cast<QObject*>(model);
+    QQuickVisualModel *vim = 0;
+    if (object && (vim = qobject_cast<QQuickVisualModel *>(object))) {
+        if (d->ownModel) {
+            delete d->model;
+            d->ownModel = false;
+        }
+        d->model = vim;
+    } else {
+        if (!d->ownModel) {
+            d->model = new QQuickVisualDataModel(qmlContext(this));
+            d->ownModel = true;
+            if (isComponentComplete())
+                static_cast<QQuickVisualDataModel *>(d->model)->componentComplete();
+        }
+        if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
+            dataModel->setModel(model);
+    }
+    if (d->model) {
+        connect(d->model, SIGNAL(modelUpdated(QDeclarativeChangeSet,bool)),
+                this, SLOT(modelUpdated(QDeclarativeChangeSet,bool)));
+        connect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
+        connect(d->model, SIGNAL(initItem(int,QQuickItem*)), this, SLOT(initItem(int,QQuickItem*)));
+//        connect(d->model, SIGNAL(destroyingItem(QQuickItem*)), this, SLOT(destroyingItem(QQuickItem*)));
+        regenerate();
+    }
+    emit modelChanged();
+    emit countChanged();
+}
+
+/*!
+    \qmlproperty Component QtQuick2::Repeater::delegate
+    \default
+
+    The delegate provides a template defining each item instantiated by the repeater.
+
+    Delegates are exposed to a read-only \c index property that indicates the index
+    of the delegate within the repeater. For example, the following \l Text delegate
+    displays the index of each repeated item:
+
+    \table
+    \row
+    \o \snippet doc/src/snippets/declarative/repeaters/repeater.qml index
+    \o \image repeater-index.png
+    \endtable
+
+    If the \l model is a \l{QStringList-based model}{string list} or
+    \l{QObjectList-based model}{object list}, the delegate is also exposed to
+    a read-only \c modelData property that holds the string or object data. For
+    example:
+
+    \table
+    \row
+    \o \snippet doc/src/snippets/declarative/repeaters/repeater.qml modeldata
+    \o \image repeater-modeldata.png
+    \endtable
+
+    If the \l model is a model object (such as a \l ListModel) the delegate
+    can access all model roles as named properties, in the same way that delegates
+    do for view classes like ListView.
+
+    \sa {QML Data Models}
+ */
+QDeclarativeComponent *QQuickRepeater::delegate() const
+{
+    Q_D(const QQuickRepeater);
+    if (d->model) {
+        if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
+            return dataModel->delegate();
+    }
+
+    return 0;
+}
+
+void QQuickRepeater::setDelegate(QDeclarativeComponent *delegate)
+{
+    Q_D(QQuickRepeater);
+    if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
+       if (delegate == dataModel->delegate())
+           return;
+
+    if (!d->ownModel) {
+        d->model = new QQuickVisualDataModel(qmlContext(this));
+        d->ownModel = true;
+    }
+    if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model)) {
+        dataModel->setDelegate(delegate);
+        regenerate();
+        emit delegateChanged();
+    }
+}
+
+/*!
+    \qmlproperty int QtQuick2::Repeater::count
+
+    This property holds the number of items in the repeater.
+*/
+int QQuickRepeater::count() const
+{
+    Q_D(const QQuickRepeater);
+    if (d->model)
+        return d->model->count();
+    return 0;
+}
+
+/*!
+    \qmlmethod Item QtQuick2::Repeater::itemAt(index)
+
+    Returns the \l Item that has been created at the given \a index, or \c null
+    if no item exists at \a index.
+*/
+QQuickItem *QQuickRepeater::itemAt(int index) const
+{
+    Q_D(const QQuickRepeater);
+    if (index >= 0 && index < d->deletables.count())
+        return d->deletables[index];
+    return 0;
+}
+
+void QQuickRepeater::componentComplete()
+{
+    Q_D(QQuickRepeater);
+    if (d->model && d->ownModel)
+        static_cast<QQuickVisualDataModel *>(d->model)->componentComplete();
+    QQuickItem::componentComplete();
+    regenerate();
+    if (d->model && d->model->count())
+        emit countChanged();
+}
+
+void QQuickRepeater::itemChange(ItemChange change, const ItemChangeData &value)
+{
+    QQuickItem::itemChange(change, value);
+    if (change == ItemParentHasChanged) {
+        regenerate();
+    }
+}
+
+void QQuickRepeater::clear()
+{
+    Q_D(QQuickRepeater);
+    bool complete = isComponentComplete();
+
+    if (d->model) {
+        for (int i = 0; i < d->deletables.count(); ++i) {
+            QQuickItem *item = d->deletables.at(i);
+            if (complete)
+                emit itemRemoved(i, item);
+            d->model->release(item);
+        }
+    }
+    d->deletables.clear();
+    d->itemCount = 0;
+}
+
+void QQuickRepeater::regenerate()
+{
+    Q_D(QQuickRepeater);
+    if (!isComponentComplete())
+        return;
+
+    clear();
+
+    if (!d->model || !d->model->count() || !d->model->isValid() || !parentItem() || !isComponentComplete())
+        return;
+
+    d->itemCount = count();
+    d->deletables.resize(d->itemCount);
+    d->createFrom = 0;
+    d->createItems();
+}
+
+void QQuickRepeaterPrivate::createItems()
+{
+    Q_Q(QQuickRepeater);
+    if (createFrom == -1)
+        return;
+    inRequest = true;
+    for (int ii = createFrom; ii < itemCount; ++ii) {
+        if (!deletables.at(ii)) {
+            QQuickItem *item = model->item(ii, false);
+            if (!item) {
+                createFrom = ii;
+                break;
+            }
+            deletables[ii] = item;
+            QDeclarative_setParent_noEvent(item, q->parentItem());
+            item->setParentItem(q->parentItem());
+            if (ii > 0 && deletables.at(ii-1)) {
+                item->stackAfter(deletables.at(ii-1));
+            } else {
+                QQuickItem *after = q;
+                for (int si = ii+1; si < itemCount; ++si) {
+                    if (deletables.at(si)) {
+                        after = deletables.at(si);
+                        break;
+                    }
+                }
+                item->stackBefore(after);
+            }
+            emit q->itemAdded(ii, item);
+        }
+    }
+    inRequest = false;
+}
+
+void QQuickRepeater::createdItem(int, QQuickItem *)
+{
+    Q_D(QQuickRepeater);
+    if (!d->inRequest)
+        d->createItems();
+}
+
+void QQuickRepeater::initItem(int, QQuickItem *item)
+{
+    QDeclarative_setParent_noEvent(item, parentItem());
+    item->setParentItem(parentItem());
+}
+
+void QQuickRepeater::modelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
+{
+    Q_D(QQuickRepeater);
+
+    if (!isComponentComplete())
+        return;
+
+    if (reset) {
+        regenerate();
+        emit countChanged();
+    }
+
+    int difference = 0;
+    QHash<int, QVector<QPointer<QQuickItem> > > moved;
+    foreach (const QDeclarativeChangeSet::Remove &remove, changeSet.removes()) {
+        int index = qMin(remove.index, d->deletables.count());
+        int count = qMin(remove.index + remove.count, d->deletables.count()) - index;
+        if (remove.isMove()) {
+            moved.insert(remove.moveId, d->deletables.mid(index, count));
+            d->deletables.erase(
+                    d->deletables.begin() + index,
+                    d->deletables.begin() + index + count);
+        } else while (count--) {
+            QQuickItem *item = d->deletables.at(index);
+            d->deletables.remove(index);
+            emit itemRemoved(index, item);
+            if (item)
+                d->model->release(item);
+            --d->itemCount;
+        }
+
+        difference -= remove.count;
+    }
+
+    d->createFrom = -1;
+    foreach (const QDeclarativeChangeSet::Insert &insert, changeSet.inserts()) {
+        int index = qMin(insert.index, d->deletables.count());
+        if (insert.isMove()) {
+            QVector<QPointer<QQuickItem> > items = moved.value(insert.moveId);
+            d->deletables = d->deletables.mid(0, index) + items + d->deletables.mid(index);
+            QQuickItem *stackBefore = index + items.count() < d->deletables.count()
+                    ? d->deletables.at(index + items.count())
+                    : this;
+            for (int i = index; i < index + items.count(); ++i)
+                d->deletables.at(i)->stackBefore(stackBefore);
+        } else for (int i = 0; i < insert.count; ++i) {
+            int modelIndex = index + i;
+            ++d->itemCount;
+            d->deletables.insert(modelIndex, 0);
+            if (d->createFrom == -1)
+                d->createFrom = modelIndex;
+        }
+        difference += insert.count;
+    }
+
+    d->createItems();
+
+    if (difference != 0)
+        emit countChanged();
+}
+
+QT_END_NAMESPACE