qdatawidgetmapper.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qdatawidgetmapper.h"
 
#include "qabstractitemmodel.h"
#include "qitemdelegate.h"
#include "qmetaobject.h"
#include "qwidget.h"
#include "qstyleditemdelegate.h"
#include "private/qobject_p.h"
#include "private/qabstractitemmodel_p.h"
 
#include <iterator>
 
QT_BEGIN_NAMESPACE
 
class QDataWidgetMapperPrivate: public QObjectPrivate
{
public:
    Q_DECLARE_PUBLIC(QDataWidgetMapper)
 
    QDataWidgetMapperPrivate()
        : model(QAbstractItemModelPrivate::staticEmptyModel()), delegate(nullptr),
          orientation(Qt::Horizontal), submitPolicy(QDataWidgetMapper::AutoSubmit)
    {
    }
 
    QAbstractItemModel *model;
    QAbstractItemDelegate *delegate;
    Qt::Orientation orientation;
    QDataWidgetMapper::SubmitPolicy submitPolicy;
    QPersistentModelIndex rootIndex;
    QPersistentModelIndex currentTopLeft;
 
    inline int itemCount()
    {
        return orientation == Qt::Horizontal
            ? model->rowCount(rootIndex)
            : model->columnCount(rootIndex);
    }
 
    inline int currentIdx() const
    {
        return orientation == Qt::Horizontal ? currentTopLeft.row() : currentTopLeft.column();
    }
 
    inline QModelIndex indexAt(int itemPos)
    {
        return orientation == Qt::Horizontal
            ? model->index(currentIdx(), itemPos, rootIndex)
            : model->index(itemPos, currentIdx(), rootIndex);
    }
 
    void flipEventFilters(QAbstractItemDelegate *oldDelegate,
                          QAbstractItemDelegate *newDelegate) const
    {
        for (const WidgetMapper &e : widgetMap) {
            QWidget *w = e.widget;
            if (!w)
                continue;
            w->removeEventFilter(oldDelegate);
            w->installEventFilter(newDelegate);
        }
    }
 
    void populate();
 
    // private slots
    void _q_dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight,
                        const QList<int> &);
    void _q_commitData(QWidget *);
    void _q_closeEditor(QWidget *, QAbstractItemDelegate::EndEditHint);
    void _q_modelDestroyed();
 
    struct WidgetMapper
    {
        QPointer<QWidget> widget;
        int section;
        QPersistentModelIndex currentIndex;
        QByteArray property;
    };
 
    void populate(WidgetMapper &m);
    int findWidget(QWidget *w) const;
 
    bool commit(const WidgetMapper &m);
 
    std::vector<WidgetMapper> widgetMap;
};
Q_DECLARE_TYPEINFO(QDataWidgetMapperPrivate::WidgetMapper, Q_RELOCATABLE_TYPE);
 
int QDataWidgetMapperPrivate::findWidget(QWidget *w) const
{
    for (const WidgetMapper &e : widgetMap) {
        if (e.widget == w)
            return int(&e - &widgetMap.front());
    }
    return -1;
}
 
bool QDataWidgetMapperPrivate::commit(const WidgetMapper &m)
{
    if (m.widget.isNull())
        return true; // just ignore
 
    if (!m.currentIndex.isValid())
        return false;
 
    // Create copy to avoid passing the widget mappers data
    QModelIndex idx = m.currentIndex;
    if (m.property.isEmpty())
        delegate->setModelData(m.widget, model, idx);
    else
        model->setData(idx, m.widget->property(m.property), Qt::EditRole);
 
    return true;
}
 
void QDataWidgetMapperPrivate::populate(WidgetMapper &m)
{
    if (m.widget.isNull())
        return;
 
    m.currentIndex = indexAt(m.section);
    if (m.property.isEmpty())
        delegate->setEditorData(m.widget, m.currentIndex);
    else
        m.widget->setProperty(m.property, m.currentIndex.data(Qt::EditRole));
}
 
void QDataWidgetMapperPrivate::populate()
{
    for (WidgetMapper &e : widgetMap)
        populate(e);
}
 
static bool qContainsIndex(const QModelIndex &idx, const QModelIndex &topLeft,
                           const QModelIndex &bottomRight)
{
    return idx.row() >= topLeft.row() && idx.row() <= bottomRight.row()
           && idx.column() >= topLeft.column() && idx.column() <= bottomRight.column();
}
 
void QDataWidgetMapperPrivate::_q_dataChanged(const QModelIndex &topLeft,
                                              const QModelIndex &bottomRight, const QList<int> &)
{
    if (topLeft.parent() != rootIndex)
        return; // not in our hierarchy
 
    for (WidgetMapper &e : widgetMap) {
        if (qContainsIndex(e.currentIndex, topLeft, bottomRight))
            populate(e);
    }
}
 
void QDataWidgetMapperPrivate::_q_commitData(QWidget *w)
{
    if (submitPolicy == QDataWidgetMapper::ManualSubmit)
        return;
 
    int idx = findWidget(w);
    if (idx == -1)
        return; // not our widget
 
    commit(widgetMap[idx]);
}
 
void QDataWidgetMapperPrivate::_q_closeEditor(QWidget *w, QAbstractItemDelegate::EndEditHint hint)
{
    int idx = findWidget(w);
    if (idx == -1)
        return; // not our widget
 
    switch (hint) {
    case QAbstractItemDelegate::RevertModelCache: {
        populate(widgetMap[idx]);
        break; }
    case QAbstractItemDelegate::EditNextItem:
        w->focusNextChild();
        break;
    case QAbstractItemDelegate::EditPreviousItem:
        w->focusPreviousChild();
        break;
    case QAbstractItemDelegate::SubmitModelCache:
    case QAbstractItemDelegate::NoHint:
        // nothing
        break;
    }
}
 
void QDataWidgetMapperPrivate::_q_modelDestroyed()
{
    Q_Q(QDataWidgetMapper);
 
    model = nullptr;
    q->setModel(QAbstractItemModelPrivate::staticEmptyModel());
}
 
QDataWidgetMapper::QDataWidgetMapper(QObject *parent)
    : QObject(*new QDataWidgetMapperPrivate, parent)
{
    setItemDelegate(new QStyledItemDelegate(this));
}
 
QDataWidgetMapper::~QDataWidgetMapper()
{
}
 
void QDataWidgetMapper::setModel(QAbstractItemModel *model)
{
    Q_D(QDataWidgetMapper);
 
    if (d->model == model)
        return;
 
    if (d->model) {
        disconnect(d->model, SIGNAL(dataChanged(QModelIndex, QModelIndex, QList<int>)), this,
                   SLOT(_q_dataChanged(QModelIndex, QModelIndex, QList<int>)));
        disconnect(d->model, SIGNAL(destroyed()), this,
                   SLOT(_q_modelDestroyed()));
    }
    clearMapping();
    d->rootIndex = QModelIndex();
    d->currentTopLeft = QModelIndex();
 
    d->model = model;
 
    connect(model, SIGNAL(dataChanged(QModelIndex, QModelIndex, QList<int>)),
            SLOT(_q_dataChanged(QModelIndex, QModelIndex, QList<int>)));
    connect(model, SIGNAL(destroyed()), SLOT(_q_modelDestroyed()));
}
 
QAbstractItemModel *QDataWidgetMapper::model() const
{
    Q_D(const QDataWidgetMapper);
    return d->model == QAbstractItemModelPrivate::staticEmptyModel()
            ? static_cast<QAbstractItemModel *>(nullptr)
            : d->model;
}
 
void QDataWidgetMapper::setItemDelegate(QAbstractItemDelegate *delegate)
{
    Q_D(QDataWidgetMapper);
    QAbstractItemDelegate *oldDelegate = d->delegate;
    if (oldDelegate) {
        disconnect(oldDelegate, SIGNAL(commitData(QWidget*)), this, SLOT(_q_commitData(QWidget*)));
        disconnect(oldDelegate, SIGNAL(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)),
                   this, SLOT(_q_closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)));
    }
 
    d->delegate = delegate;
 
    if (delegate) {
        connect(delegate, SIGNAL(commitData(QWidget*)), SLOT(_q_commitData(QWidget*)));
        connect(delegate, SIGNAL(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)),
                SLOT(_q_closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)));
    }
 
    d->flipEventFilters(oldDelegate, delegate);
}
 
QAbstractItemDelegate *QDataWidgetMapper::itemDelegate() const
{
    Q_D(const QDataWidgetMapper);
    return d->delegate;
}
 
void QDataWidgetMapper::setRootIndex(const QModelIndex &index)
{
    Q_D(QDataWidgetMapper);
    d->rootIndex = index;
}
 
QModelIndex QDataWidgetMapper::rootIndex() const
{
    Q_D(const QDataWidgetMapper);
    return QModelIndex(d->rootIndex);
}
 
void QDataWidgetMapper::addMapping(QWidget *widget, int section)
{
    Q_D(QDataWidgetMapper);
 
    removeMapping(widget);
    d->widgetMap.push_back({widget, section, d->indexAt(section), QByteArray()});
    widget->installEventFilter(d->delegate);
}
 
void QDataWidgetMapper::addMapping(QWidget *widget, int section, const QByteArray &propertyName)
{
    Q_D(QDataWidgetMapper);
 
    removeMapping(widget);
    d->widgetMap.push_back({widget, section, d->indexAt(section), propertyName});
    widget->installEventFilter(d->delegate);
}
 
void QDataWidgetMapper::removeMapping(QWidget *widget)
{
    Q_D(QDataWidgetMapper);
 
    int idx = d->findWidget(widget);
    if (idx == -1)
        return;
 
    d->widgetMap.erase(d->widgetMap.begin() + idx);
    widget->removeEventFilter(d->delegate);
}
 
int QDataWidgetMapper::mappedSection(QWidget *widget) const
{
    Q_D(const QDataWidgetMapper);
 
    int idx = d->findWidget(widget);
    if (idx == -1)
        return -1;
 
    return d->widgetMap[idx].section;
}
 
QByteArray QDataWidgetMapper::mappedPropertyName(QWidget *widget) const
{
    Q_D(const QDataWidgetMapper);
 
    int idx = d->findWidget(widget);
    if (idx == -1)
        return QByteArray();
    const auto &m = d->widgetMap[idx];
    if (m.property.isEmpty())
        return m.widget->metaObject()->userProperty().name();
    else
        return m.property;
}
 
QWidget *QDataWidgetMapper::mappedWidgetAt(int section) const
{
    Q_D(const QDataWidgetMapper);
 
    for (auto &e : d->widgetMap) {
        if (e.section == section)
            return e.widget;
    }
 
    return nullptr;
}
 
void QDataWidgetMapper::revert()
{
    Q_D(QDataWidgetMapper);
 
    d->populate();
}
 
bool QDataWidgetMapper::submit()
{
    Q_D(QDataWidgetMapper);
 
    for (auto &e : d->widgetMap) {
        if (!d->commit(e))
            return false;
    }
 
    return d->model->submit();
}
 
void QDataWidgetMapper::toFirst()
{
    setCurrentIndex(0);
}
 
void QDataWidgetMapper::toLast()
{
    Q_D(QDataWidgetMapper);
    setCurrentIndex(d->itemCount() - 1);
}
 
 
void QDataWidgetMapper::toNext()
{
    Q_D(QDataWidgetMapper);
    setCurrentIndex(d->currentIdx() + 1);
}
 
void QDataWidgetMapper::toPrevious()
{
    Q_D(QDataWidgetMapper);
    setCurrentIndex(d->currentIdx() - 1);
}
 
void QDataWidgetMapper::setCurrentIndex(int index)
{
    Q_D(QDataWidgetMapper);
 
    if (index < 0 || index >= d->itemCount())
        return;
    d->currentTopLeft = d->orientation == Qt::Horizontal
                            ? d->model->index(index, 0, d->rootIndex)
                            : d->model->index(0, index, d->rootIndex);
    d->populate();
 
    emit currentIndexChanged(index);
}
 
int QDataWidgetMapper::currentIndex() const
{
    Q_D(const QDataWidgetMapper);
    return d->currentIdx();
}
 
void QDataWidgetMapper::setCurrentModelIndex(const QModelIndex &index)
{
    Q_D(QDataWidgetMapper);
 
    if (!index.isValid()
        || index.model() != d->model
        || index.parent() != d->rootIndex)
        return;
 
    setCurrentIndex(d->orientation == Qt::Horizontal ? index.row() : index.column());
}
 
void QDataWidgetMapper::clearMapping()
{
    Q_D(QDataWidgetMapper);
 
    decltype(d->widgetMap) copy;
    d->widgetMap.swap(copy); // a C++98 move
    for (auto it = copy.crbegin(), end = copy.crend(); it != end; ++it) {
        if (it->widget)
            it->widget->removeEventFilter(d->delegate);
    }
}
 
void QDataWidgetMapper::setOrientation(Qt::Orientation orientation)
{
    Q_D(QDataWidgetMapper);
 
    if (d->orientation == orientation)
        return;
 
    clearMapping();
    d->orientation = orientation;
}
 
Qt::Orientation QDataWidgetMapper::orientation() const
{
    Q_D(const QDataWidgetMapper);
    return d->orientation;
}
 
void QDataWidgetMapper::setSubmitPolicy(SubmitPolicy policy)
{
    Q_D(QDataWidgetMapper);
    if (policy == d->submitPolicy)
        return;
 
    revert();
    d->submitPolicy = policy;
}
 
QDataWidgetMapper::SubmitPolicy QDataWidgetMapper::submitPolicy() const
{
    Q_D(const QDataWidgetMapper);
    return d->submitPolicy;
}
 
QT_END_NAMESPACE
 
#include "moc_qdatawidgetmapper.cpp"