qundoview.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 "qundoview.h"
 
#if QT_CONFIG(undogroup)
#include <QtGui/qundogroup.h>
#endif
#include <QtGui/qundostack.h>
#include <QtCore/qabstractitemmodel.h>
#include <QtCore/qpointer.h>
#include <QtGui/qicon.h>
#include <private/qlistview_p.h>
 
QT_BEGIN_NAMESPACE
 
class QUndoModel : public QAbstractItemModel
{
    Q_OBJECT
public:
    QUndoModel(QObject *parent = nullptr);
 
    QUndoStack *stack() const;
 
    virtual QModelIndex index(int row, int column,
                const QModelIndex &parent = QModelIndex()) const override;
    virtual QModelIndex parent(const QModelIndex &child) const override;
    virtual int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    virtual int columnCount(const QModelIndex &parent = QModelIndex()) const override;
    virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 
    QModelIndex selectedIndex() const;
    QItemSelectionModel *selectionModel() const;
 
    QString emptyLabel() const;
    void setEmptyLabel(const QString &label);
 
    void setCleanIcon(const QIcon &icon);
    QIcon cleanIcon() const;
 
public slots:
    void setStack(QUndoStack *stack);
 
private slots:
    void stackChanged();
    void stackDestroyed(QObject *obj);
    void setStackCurrentIndex(const QModelIndex &index);
 
private:
    QUndoStack *m_stack;
    QItemSelectionModel *m_sel_model;
    QString m_emty_label;
    QIcon m_clean_icon;
};
 
QUndoModel::QUndoModel(QObject *parent)
    : QAbstractItemModel(parent)
{
    m_stack = nullptr;
    m_sel_model = new QItemSelectionModel(this, this);
    connect(m_sel_model, SIGNAL(currentChanged(QModelIndex,QModelIndex)),
            this, SLOT(setStackCurrentIndex(QModelIndex)));
    m_emty_label = tr("<empty>");
}
 
QItemSelectionModel *QUndoModel::selectionModel() const
{
    return m_sel_model;
}
 
QUndoStack *QUndoModel::stack() const
{
    return m_stack;
}
 
void QUndoModel::setStack(QUndoStack *stack)
{
    if (m_stack == stack)
        return;
 
    if (m_stack != nullptr) {
        disconnect(m_stack, SIGNAL(cleanChanged(bool)), this, SLOT(stackChanged()));
        disconnect(m_stack, SIGNAL(indexChanged(int)), this, SLOT(stackChanged()));
        disconnect(m_stack, SIGNAL(destroyed(QObject*)), this, SLOT(stackDestroyed(QObject*)));
    }
    m_stack = stack;
    if (m_stack != nullptr) {
        connect(m_stack, SIGNAL(cleanChanged(bool)), this, SLOT(stackChanged()));
        connect(m_stack, SIGNAL(indexChanged(int)), this, SLOT(stackChanged()));
        connect(m_stack, SIGNAL(destroyed(QObject*)), this, SLOT(stackDestroyed(QObject*)));
    }
 
    stackChanged();
}
 
void QUndoModel::stackDestroyed(QObject *obj)
{
    if (obj != m_stack)
        return;
    m_stack = nullptr;
 
    stackChanged();
}
 
void QUndoModel::stackChanged()
{
    beginResetModel();
    endResetModel();
    m_sel_model->setCurrentIndex(selectedIndex(), QItemSelectionModel::ClearAndSelect);
}
 
void QUndoModel::setStackCurrentIndex(const QModelIndex &index)
{
    if (m_stack == nullptr)
        return;
 
    if (index == selectedIndex())
        return;
 
    if (index.column() != 0)
        return;
 
    m_stack->setIndex(index.row());
}
 
QModelIndex QUndoModel::selectedIndex() const
{
    return m_stack == nullptr ? QModelIndex() : createIndex(m_stack->index(), 0);
}
 
QModelIndex QUndoModel::index(int row, int column, const QModelIndex &parent) const
{
    if (m_stack == nullptr)
        return QModelIndex();
 
    if (parent.isValid())
        return QModelIndex();
 
    if (column != 0)
        return QModelIndex();
 
    if (row < 0 || row > m_stack->count())
        return QModelIndex();
 
    return createIndex(row, column);
}
 
QModelIndex QUndoModel::parent(const QModelIndex&) const
{
    return QModelIndex();
}
 
int QUndoModel::rowCount(const QModelIndex &parent) const
{
    if (m_stack == nullptr)
        return 0;
 
    if (parent.isValid())
        return 0;
 
    return m_stack->count() + 1;
}
 
int QUndoModel::columnCount(const QModelIndex&) const
{
    return 1;
}
 
QVariant QUndoModel::data(const QModelIndex &index, int role) const
{
    if (m_stack == nullptr)
        return QVariant();
 
    if (index.column() != 0)
        return QVariant();
 
    if (index.row() < 0 || index.row() > m_stack->count())
        return QVariant();
 
    if (role == Qt::DisplayRole) {
        if (index.row() == 0)
            return m_emty_label;
        return m_stack->text(index.row() - 1);
    } else if (role == Qt::DecorationRole) {
        if (index.row() == m_stack->cleanIndex() && !m_clean_icon.isNull())
            return m_clean_icon;
        return QVariant();
    }
 
    return QVariant();
}
 
QString QUndoModel::emptyLabel() const
{
    return m_emty_label;
}
 
void QUndoModel::setEmptyLabel(const QString &label)
{
    m_emty_label = label;
    stackChanged();
}
 
void QUndoModel::setCleanIcon(const QIcon &icon)
{
    m_clean_icon = icon;
    stackChanged();
}
 
QIcon QUndoModel::cleanIcon() const
{
    return m_clean_icon;
}
 
class QUndoViewPrivate : public QListViewPrivate
{
    Q_DECLARE_PUBLIC(QUndoView)
public:
    QUndoViewPrivate() :
#if QT_CONFIG(undogroup)
        group(nullptr),
#endif
        model(nullptr) {}
 
#if QT_CONFIG(undogroup)
    QPointer<QUndoGroup> group;
#endif
    QUndoModel *model;
 
    void init();
};
 
void QUndoViewPrivate::init()
{
    Q_Q(QUndoView);
 
    model = new QUndoModel(q);
    q->setModel(model);
    q->setSelectionModel(model->selectionModel());
}
 
QUndoView::QUndoView(QWidget *parent)
    : QListView(*new QUndoViewPrivate(), parent)
{
    Q_D(QUndoView);
    d->init();
}
 
QUndoView::QUndoView(QUndoStack *stack, QWidget *parent)
    : QListView(*new QUndoViewPrivate(), parent)
{
    Q_D(QUndoView);
    d->init();
    setStack(stack);
}
 
#if QT_CONFIG(undogroup)
 
QUndoView::QUndoView(QUndoGroup *group, QWidget *parent)
    : QListView(*new QUndoViewPrivate(), parent)
{
    Q_D(QUndoView);
    d->init();
    setGroup(group);
}
 
#endif // QT_CONFIG(undogroup)
 
QUndoView::~QUndoView()
{
}
 
QUndoStack *QUndoView::stack() const
{
    Q_D(const QUndoView);
    return d->model->stack();
}
 
void QUndoView::setStack(QUndoStack *stack)
{
    Q_D(QUndoView);
#if QT_CONFIG(undogroup)
    setGroup(nullptr);
#endif
    d->model->setStack(stack);
}
 
#if QT_CONFIG(undogroup)
 
void QUndoView::setGroup(QUndoGroup *group)
{
    Q_D(QUndoView);
 
    if (d->group == group)
        return;
 
    if (d->group != nullptr) {
        disconnect(d->group, SIGNAL(activeStackChanged(QUndoStack*)),
                d->model, SLOT(setStack(QUndoStack*)));
    }
 
    d->group = group;
 
    if (d->group != nullptr) {
        connect(d->group, SIGNAL(activeStackChanged(QUndoStack*)),
                d->model, SLOT(setStack(QUndoStack*)));
        d->model->setStack(d->group->activeStack());
    } else {
        d->model->setStack(nullptr);
    }
}
 
QUndoGroup *QUndoView::group() const
{
    Q_D(const QUndoView);
    return d->group;
}
 
#endif // QT_CONFIG(undogroup)
 
void QUndoView::setEmptyLabel(const QString &label)
{
    Q_D(QUndoView);
    d->model->setEmptyLabel(label);
}
 
QString QUndoView::emptyLabel() const
{
    Q_D(const QUndoView);
    return d->model->emptyLabel();
}
 
void QUndoView::setCleanIcon(const QIcon &icon)
{
    Q_D(const QUndoView);
    d->model->setCleanIcon(icon);
 
}
 
QIcon QUndoView::cleanIcon() const
{
    Q_D(const QUndoView);
    return d->model->cleanIcon();
}
 
QT_END_NAMESPACE
 
#include "qundoview.moc"
#include "moc_qundoview.cpp"