qundogroup.cpp

Go to the documentation of this file.

// Copyright (C) 2020 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 "qundogroup.h"
#include "qundostack.h"
#include "qundostack_p.h"
 
QT_BEGIN_NAMESPACE
 
class QUndoGroupPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QUndoGroup)
public:
    QUndoGroupPrivate() : active(nullptr) {}
 
    QUndoStack *active;
    QList<QUndoStack*> stack_list;
};
 
QUndoGroup::QUndoGroup(QObject *parent)
    : QObject(*new QUndoGroupPrivate(), parent)
{
}
 
QUndoGroup::~QUndoGroup()
{
    // Ensure all QUndoStacks no longer refer to this group.
    Q_D(QUndoGroup);
    QList<QUndoStack *>::iterator it = d->stack_list.begin();
    QList<QUndoStack *>::iterator end = d->stack_list.end();
    while (it != end) {
        (*it)->d_func()->group = nullptr;
        ++it;
    }
}
 
void QUndoGroup::addStack(QUndoStack *stack)
{
    Q_D(QUndoGroup);
 
    if (d->stack_list.contains(stack))
        return;
    d->stack_list.append(stack);
 
    if (QUndoGroup *other = stack->d_func()->group)
        other->removeStack(stack);
    stack->d_func()->group = this;
}
 
void QUndoGroup::removeStack(QUndoStack *stack)
{
    Q_D(QUndoGroup);
 
    if (d->stack_list.removeAll(stack) == 0)
        return;
    if (stack == d->active)
        setActiveStack(nullptr);
    stack->d_func()->group = nullptr;
}
 
QList<QUndoStack*> QUndoGroup::stacks() const
{
    Q_D(const QUndoGroup);
    return d->stack_list;
}
 
void QUndoGroup::setActiveStack(QUndoStack *stack)
{
    Q_D(QUndoGroup);
    if (d->active == stack)
        return;
 
    if (d->active != nullptr) {
        disconnect(d->active, SIGNAL(canUndoChanged(bool)),
                    this, SIGNAL(canUndoChanged(bool)));
        disconnect(d->active, SIGNAL(undoTextChanged(QString)),
                    this, SIGNAL(undoTextChanged(QString)));
        disconnect(d->active, SIGNAL(canRedoChanged(bool)),
                    this, SIGNAL(canRedoChanged(bool)));
        disconnect(d->active, SIGNAL(redoTextChanged(QString)),
                    this, SIGNAL(redoTextChanged(QString)));
        disconnect(d->active, SIGNAL(indexChanged(int)),
                    this, SIGNAL(indexChanged(int)));
        disconnect(d->active, SIGNAL(cleanChanged(bool)),
                    this, SIGNAL(cleanChanged(bool)));
    }
 
    d->active = stack;
 
    if (d->active == nullptr) {
        emit canUndoChanged(false);
        emit undoTextChanged(QString());
        emit canRedoChanged(false);
        emit redoTextChanged(QString());
        emit cleanChanged(true);
        emit indexChanged(0);
    } else {
        connect(d->active, SIGNAL(canUndoChanged(bool)),
                this, SIGNAL(canUndoChanged(bool)));
        connect(d->active, SIGNAL(undoTextChanged(QString)),
                this, SIGNAL(undoTextChanged(QString)));
        connect(d->active, SIGNAL(canRedoChanged(bool)),
                this, SIGNAL(canRedoChanged(bool)));
        connect(d->active, SIGNAL(redoTextChanged(QString)),
                this, SIGNAL(redoTextChanged(QString)));
        connect(d->active, SIGNAL(indexChanged(int)),
                this, SIGNAL(indexChanged(int)));
        connect(d->active, SIGNAL(cleanChanged(bool)),
                this, SIGNAL(cleanChanged(bool)));
        emit canUndoChanged(d->active->canUndo());
        emit undoTextChanged(d->active->undoText());
        emit canRedoChanged(d->active->canRedo());
        emit redoTextChanged(d->active->redoText());
        emit cleanChanged(d->active->isClean());
        emit indexChanged(d->active->index());
    }
 
    emit activeStackChanged(d->active);
}
 
QUndoStack *QUndoGroup::activeStack() const
{
    Q_D(const QUndoGroup);
    return d->active;
}
 
#ifndef QT_NO_ACTION
 
QAction *QUndoGroup::createUndoAction(QObject *parent, const QString &prefix) const
{
    QAction *action = new QAction(parent);
    action->setEnabled(canUndo());
 
    QString effectivePrefix = prefix;
    QString defaultText;
    if (prefix.isEmpty()) {
        effectivePrefix = tr("Undo %1");
        defaultText = tr("Undo", "Default text for undo action");
    }
 
    QUndoStackPrivate::setPrefixedText(action, effectivePrefix, defaultText, undoText());
 
    connect(this, &QUndoGroup::canUndoChanged, action, &QAction::setEnabled);
    connect(this, &QUndoGroup::undoTextChanged, action, [=](const QString &text) {
        QUndoStackPrivate::setPrefixedText(action, effectivePrefix, defaultText, text);
    });
    connect(action, &QAction::triggered, this, &QUndoGroup::undo);
 
    return action;
}
 
QAction *QUndoGroup::createRedoAction(QObject *parent, const QString &prefix) const
{
    QAction *action = new QAction(parent);
    action->setEnabled(canRedo());
 
    QString effectivePrefix = prefix;
    QString defaultText;
    if (prefix.isEmpty()) {
        effectivePrefix = tr("Redo %1");
        defaultText = tr("Redo", "Default text for redo action");
    }
 
    QUndoStackPrivate::setPrefixedText(action, effectivePrefix, defaultText, redoText());
 
    connect(this, &QUndoGroup::canRedoChanged, action, &QAction::setEnabled);
    connect(this, &QUndoGroup::redoTextChanged, action, [=](const QString &text) {
        QUndoStackPrivate::setPrefixedText(action, effectivePrefix, defaultText, text);
    });
    connect(action, &QAction::triggered, this, &QUndoGroup::redo);
    return action;
}
 
#endif // QT_NO_ACTION
 
void QUndoGroup::undo()
{
    Q_D(QUndoGroup);
    if (d->active != nullptr)
        d->active->undo();
}
 
void QUndoGroup::redo()
{
    Q_D(QUndoGroup);
    if (d->active != nullptr)
        d->active->redo();
}
 
bool QUndoGroup::canUndo() const
{
    Q_D(const QUndoGroup);
    return d->active != nullptr && d->active->canUndo();
}
 
bool QUndoGroup::canRedo() const
{
    Q_D(const QUndoGroup);
    return d->active != nullptr && d->active->canRedo();
}
 
QString QUndoGroup::undoText() const
{
    Q_D(const QUndoGroup);
    return d->active == nullptr ? QString() : d->active->undoText();
}
 
QString QUndoGroup::redoText() const
{
    Q_D(const QUndoGroup);
    return d->active == nullptr ? QString() : d->active->redoText();
}
 
bool QUndoGroup::isClean() const
{
    Q_D(const QUndoGroup);
    return d->active == nullptr || d->active->isClean();
}
 
QT_END_NAMESPACE
 
#include "moc_qundogroup.cpp"