Allow DelegateModel-based views to support multiple delegate types

This patch adds a specific abstract QQmlComponent subclass,
QQmlAbstractDelegateComponent, and a default implementation,
DelegateChooser, that, together with the type DelegateChoice
allows determining the delegate type by role and/or index.

The patch also adds QQmlAbstractDelegateComponent support
to QQmlTableInstanceModel, that is a simplified version of
the delegate model, currently only used in the new table view.

DelegateChoosers are intended to behave just like Components
in the context of the view. This means that they can be declared
outside of the view, and also in separate files, and the same
delegate component can be used at the same time in multiple views.

[ChangeLog][QtQuick][Item Views] Added a DelegateChooser Component
to host DelegateChoice instances to choose different delegates in
an Item View (e.g. TableView) depending on model roles.

Done-with: Michael Brasser <michael.brasser@live.com>
Task-number: QTBUG-26681
Change-Id: Ibe24a31daf9142c8a9ff45ef6c65da0aec8a14dc
Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>

1 files changed, 285 insertions, 0 deletions

diff --git a/src/qml/types/qqmldelegatecomponent.cpp b/src/qml/types/qqmldelegatecomponent.cpp
new file mode 100644
index 0000000000..e52a7879a4
--- /dev/null
+++ b/src/qml/types/qqmldelegatecomponent.cpp
@@ -0,0 +1,285 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qqmldelegatecomponent_p.h"
+#include <QtQml/private/qqmladaptormodel_p.h>
+
+QT_BEGIN_NAMESPACE
+
+QQmlAbstractDelegateComponent::QQmlAbstractDelegateComponent(QObject *parent)
+    : QQmlComponent(parent)
+{
+}
+
+QQmlAbstractDelegateComponent::~QQmlAbstractDelegateComponent()
+{
+}
+
+QVariant QQmlAbstractDelegateComponent::value(QQmlAdaptorModel *adaptorModel, int row, int column, const QString &role) const
+{
+    if (!adaptorModel)
+        return QVariant();
+    return adaptorModel->value(adaptorModel->indexAt(row, column), role);
+}
+
+/*!
+    \qmltype DelegateChoice
+    \instantiates QQmlDelegateChoice
+    \inqmlmodule Qt.labs.qmlmodels
+    \brief Encapsulates a delegate and when to use it
+
+    The DelegateChoice type wraps a delegate and defines the circumstances
+    in which it should be chosen.
+    DelegateChoices can be nested inside a DelegateChooser.
+
+    \sa DelegateChooser
+*/
+
+/*!
+    \qmlproperty string QtQml.Models::DelegateChoice::roleValue
+    This property holds the value used to match the role data for the role provided by \l DefaultDelegateChooser::role.
+*/
+QVariant QQmlDelegateChoice::roleValue() const
+{
+    return m_value;
+}
+
+void QQmlDelegateChoice::setRoleValue(const QVariant &value)
+{
+    if (m_value == value)
+        return;
+    m_value = value;
+    emit roleValueChanged();
+    emit changed();
+}
+
+/*!
+    \qmlproperty index QtQml.Models::DelegateChoice::row
+    This property holds the value used to match the row value of model elements.
+    With models that have only the index property (and thus only one column), this property
+    should be intended as index, and set to the desired index value.
+
+    \note Setting both row and index has undefined behavior. The two are equivalent and only
+    one should be used.
+
+    \sa QtQml.Models::DelegateChoice::index
+*/
+
+/*!
+    \qmlproperty index QtQml.Models::DelegateChoice::index
+    This property holds the value used to match the index value of model elements.
+    This is effectively an alias for \l QtQml.Models::DelegateChoice::row
+
+    \sa QtQml.Models::DelegateChoice::row
+*/
+int QQmlDelegateChoice::row() const
+{
+    return m_row;
+}
+
+void QQmlDelegateChoice::setRow(int r)
+{
+    if (m_row == r)
+        return;
+    m_row = r;
+    emit rowChanged();
+    emit indexChanged();
+    emit changed();
+}
+
+/*!
+    \qmlproperty index QtQml.Models::DelegateChoice::column
+    This property holds the value used to match the column value of model elements.
+*/
+int QQmlDelegateChoice::column() const
+{
+    return m_column;
+}
+
+void QQmlDelegateChoice::setColumn(int c)
+{
+    if (m_column == c)
+        return;
+    m_column = c;
+    emit columnChanged();
+    emit changed();
+}
+
+QQmlComponent *QQmlDelegateChoice::delegate() const
+{
+    return m_delegate;
+}
+
+/*!
+    \qmlproperty Component QtQml.Models::DelegateChoice::delegate
+    This property holds the delegate to use if this choice matches the model item.
+*/
+void QQmlDelegateChoice::setDelegate(QQmlComponent *delegate)
+{
+    if (m_delegate == delegate)
+        return;
+    QQmlAbstractDelegateComponent *adc = static_cast<QQmlAbstractDelegateComponent *>(m_delegate);
+    if (adc)
+        disconnect(adc, &QQmlAbstractDelegateComponent::delegateChanged, this, &QQmlDelegateChoice::delegateChanged);
+    m_delegate = delegate;
+    adc = static_cast<QQmlAbstractDelegateComponent *>(delegate);
+    if (adc)
+        connect(adc, &QQmlAbstractDelegateComponent::delegateChanged, this, &QQmlDelegateChoice::delegateChanged);
+    emit delegateChanged();
+    emit changed();
+}
+
+bool QQmlDelegateChoice::match(int row, int column, const QVariant &value) const
+{
+    if (!m_value.isValid() && m_row < 0 && m_column < 0)
+        return true;
+
+    const bool roleMatched = (m_value.isValid()) ? value == m_value : true;
+    const bool rowMatched = (m_row < 0 ) ? true : m_row == row;
+    const bool columnMatched = (m_column < 0 ) ? true : m_column == column;
+    return roleMatched && rowMatched && columnMatched;
+}
+
+/*!
+    \qmltype QQmlDelegateChooser
+    \instantiates QQmlDelegateChooser
+    \inqmlmodule Qt.labs.qmlmodels
+    \brief Allows a view to use different delegates for different types of items in the model.
+
+    The DelegateChooser is a special \l Component type intended for those scenarios where a Component is required
+    by a view and used as a delegate.
+    DelegateChooser encapsulates a set of \l DelegateChoices.
+    These choices are used determine the delegate that will be instantiated for each
+    item in the model.
+    The selection of the choice is performed based on the value that a model item has for \l role,
+    and also based on index.
+
+    \note This type is intended to transparently work only with TableView and any DelegateModel-based view.
+    Views (including user-defined views) that aren't internally based on a DelegateModel need to explicitly support
+    this type of component to make it function as described.
+
+    \sa DelegateChoice
+*/
+
+/*!
+    \qmlproperty string QtQml.Models::DelegateChooser::role
+    This property holds the role used to determine the delegate for a given model item.
+
+    \sa DelegateChoice
+*/
+void QQmlDelegateChooser::setRole(const QString &role)
+{
+    if (m_role == role)
+        return;
+    m_role = role;
+    emit roleChanged();
+}
+
+/*!
+    \qmlproperty list<DelegateChoice> QtQml.Models::DelegateChooser::choices
+    \default
+    The list of DelegateChoices for the chooser.
+
+    The list is treated as an ordered list, where the first DelegateChoice to match
+    will be used be a view.
+
+    It should not generally be necessary to refer to the \c choices property,
+    as it is the default property for DefaultDelegateChooser and thus all child items are
+    automatically assigned to this property.
+*/
+
+QQmlListProperty<QQmlDelegateChoice> QQmlDelegateChooser::choices()
+{
+    return QQmlListProperty<QQmlDelegateChoice>(this, nullptr,
+                                                QQmlDelegateChooser::choices_append,
+                                                QQmlDelegateChooser::choices_count,
+                                                QQmlDelegateChooser::choices_at,
+                                                QQmlDelegateChooser::choices_clear);
+}
+
+void QQmlDelegateChooser::choices_append(QQmlListProperty<QQmlDelegateChoice> *prop, QQmlDelegateChoice *choice)
+{
+    QQmlDelegateChooser *q = static_cast<QQmlDelegateChooser *>(prop->object);
+    q->m_choices.append(choice);
+    connect(choice, &QQmlDelegateChoice::changed, q, &QQmlAbstractDelegateComponent::delegateChanged);
+    q->delegateChanged();
+}
+
+int QQmlDelegateChooser::choices_count(QQmlListProperty<QQmlDelegateChoice> *prop)
+{
+    QQmlDelegateChooser *q = static_cast<QQmlDelegateChooser*>(prop->object);
+    return q->m_choices.count();
+}
+
+QQmlDelegateChoice *QQmlDelegateChooser::choices_at(QQmlListProperty<QQmlDelegateChoice> *prop, int index)
+{
+    QQmlDelegateChooser *q = static_cast<QQmlDelegateChooser*>(prop->object);
+    return q->m_choices.at(index);
+}
+
+void QQmlDelegateChooser::choices_clear(QQmlListProperty<QQmlDelegateChoice> *prop)
+{
+    QQmlDelegateChooser *q = static_cast<QQmlDelegateChooser *>(prop->object);
+    for (QQmlDelegateChoice *choice : q->m_choices)
+        disconnect(choice, &QQmlDelegateChoice::changed, q, &QQmlAbstractDelegateComponent::delegateChanged);
+    q->m_choices.clear();
+    q->delegateChanged();
+}
+
+QQmlComponent *QQmlDelegateChooser::delegate(QQmlAdaptorModel *adaptorModel, int row, int column) const
+{
+    QVariant v;
+    if (!m_role.isNull())
+        v = value(adaptorModel, row, column, m_role);
+    if (!v.isValid()) { // check if the row only has modelData, for example if the row is a QVariantMap
+        v = value(adaptorModel, row, column, QStringLiteral("modelData"));
+        if (v.isValid())
+            v = v.toMap().value(m_role);
+    }
+    // loop through choices, finding first one that fits
+    for (int i = 0; i < m_choices.count(); ++i) {
+        const QQmlDelegateChoice *choice = m_choices.at(i);
+        if (choice->match(row, column, v))
+            return choice->delegate();
+    }
+
+    return nullptr;
+}
+
+QT_END_NAMESPACE