qundostack.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 <QtCore/qdebug.h>
#include "qundostack.h"
#if QT_CONFIG(undogroup)
#include "qundogroup.h"
#endif
#include "qundostack_p.h"
 
QT_BEGIN_NAMESPACE
 
QUndoCommand::QUndoCommand(const QString &text, QUndoCommand *parent)
    : QUndoCommand(parent)
{
    setText(text);
}
 
QUndoCommand::QUndoCommand(QUndoCommand *parent)
{
    d = new QUndoCommandPrivate;
    if (parent != nullptr)
        parent->d->child_list.append(this);
}
 
QUndoCommand::~QUndoCommand()
{
    qDeleteAll(d->child_list);
    delete d;
}
 
bool QUndoCommand::isObsolete() const
{
    return d->obsolete;
}
 
void QUndoCommand::setObsolete(bool obsolete)
{
    d->obsolete = obsolete;
}
 
int QUndoCommand::id() const
{
    return -1;
}
 
bool QUndoCommand::mergeWith(const QUndoCommand *command)
{
    Q_UNUSED(command);
    return false;
}
 
void QUndoCommand::redo()
{
    for (int i = 0; i < d->child_list.size(); ++i)
        d->child_list.at(i)->redo();
}
 
void QUndoCommand::undo()
{
    for (int i = d->child_list.size() - 1; i >= 0; --i)
        d->child_list.at(i)->undo();
}
 
QString QUndoCommand::text() const
{
    return d->text;
}
 
QString QUndoCommand::actionText() const
{
    return d->actionText;
}
 
void QUndoCommand::setText(const QString &text)
{
    int cdpos = text.indexOf(u'\n');
    if (cdpos > 0) {
        d->text = text.left(cdpos);
        d->actionText = text.mid(cdpos + 1);
    } else {
        d->text = text;
        d->actionText = text;
    }
}
 
int QUndoCommand::childCount() const
{
    return d->child_list.size();
}
 
const QUndoCommand *QUndoCommand::child(int index) const
{
    if (index < 0 || index >= d->child_list.size())
        return nullptr;
    return d->child_list.at(index);
}
 
#if QT_CONFIG(undostack)
 
void QUndoStackPrivate::setIndex(int idx, bool clean)
{
    Q_Q(QUndoStack);
 
    bool was_clean = index == clean_index;
 
    if (idx != index) {
        index = idx;
        emit q->indexChanged(index);
        emit q->canUndoChanged(q->canUndo());
        emit q->undoTextChanged(q->undoText());
        emit q->canRedoChanged(q->canRedo());
        emit q->redoTextChanged(q->redoText());
    }
 
    if (clean)
        clean_index = index;
 
    bool is_clean = index == clean_index;
    if (is_clean != was_clean)
        emit q->cleanChanged(is_clean);
}
 
bool QUndoStackPrivate::checkUndoLimit()
{
    if (undo_limit <= 0 || !macro_stack.isEmpty() || undo_limit >= command_list.size())
        return false;
 
    int del_count = command_list.size() - undo_limit;
 
    for (int i = 0; i < del_count; ++i)
        delete command_list.takeFirst();
 
    index -= del_count;
    if (clean_index != -1) {
        if (clean_index < del_count)
            clean_index = -1; // we've deleted the clean command
        else
            clean_index -= del_count;
    }
 
    return true;
}
 
QUndoStack::QUndoStack(QObject *parent)
    : QObject(*(new QUndoStackPrivate), parent)
{
#if QT_CONFIG(undogroup)
    if (QUndoGroup *group = qobject_cast<QUndoGroup*>(parent))
        group->addStack(this);
#endif
}
 
QUndoStack::~QUndoStack()
{
#if QT_CONFIG(undogroup)
    Q_D(QUndoStack);
    if (d->group != nullptr)
        d->group->removeStack(this);
#endif
    clear();
}
 
void QUndoStack::clear()
{
    Q_D(QUndoStack);
 
    if (d->command_list.isEmpty())
        return;
 
    bool was_clean = isClean();
 
    d->macro_stack.clear();
    qDeleteAll(d->command_list);
    d->command_list.clear();
 
    d->index = 0;
    d->clean_index = 0;
 
    emit indexChanged(0);
    emit canUndoChanged(false);
    emit undoTextChanged(QString());
    emit canRedoChanged(false);
    emit redoTextChanged(QString());
 
    if (!was_clean)
        emit cleanChanged(true);
}
 
void QUndoStack::push(QUndoCommand *cmd)
{
    Q_D(QUndoStack);
    if (!cmd->isObsolete())
        cmd->redo();
 
    bool macro = !d->macro_stack.isEmpty();
 
    QUndoCommand *cur = nullptr;
    if (macro) {
        QUndoCommand *macro_cmd = d->macro_stack.constLast();
        if (!macro_cmd->d->child_list.isEmpty())
            cur = macro_cmd->d->child_list.constLast();
    } else {
        if (d->index > 0)
            cur = d->command_list.at(d->index - 1);
        while (d->index < d->command_list.size())
            delete d->command_list.takeLast();
        if (d->clean_index > d->index)
            d->clean_index = -1; // we've deleted the clean state
    }
 
    bool try_merge = cur != nullptr
                        && cur->id() != -1
                        && cur->id() == cmd->id()
                        && (macro || d->index != d->clean_index);
 
    if (try_merge && cur->mergeWith(cmd)) {
        delete cmd;
 
        if (macro) {
            if (cur->isObsolete())
                delete d->macro_stack.constLast()->d->child_list.takeLast();
        } else {
            if (cur->isObsolete()) {
                delete d->command_list.takeLast();
 
                d->setIndex(d->index - 1, false);
            } else {
                emit indexChanged(d->index);
                emit canUndoChanged(canUndo());
                emit undoTextChanged(undoText());
                emit canRedoChanged(canRedo());
                emit redoTextChanged(redoText());
            }
        }
    } else if (cmd->isObsolete()) {
        delete cmd; // command should be deleted and NOT added to the stack
    } else {
        if (macro) {
            d->macro_stack.constLast()->d->child_list.append(cmd);
        } else {
            d->command_list.append(cmd);
            d->checkUndoLimit();
            d->setIndex(d->index + 1, false);
        }
    }
}
 
void QUndoStack::setClean()
{
    Q_D(QUndoStack);
    if (Q_UNLIKELY(!d->macro_stack.isEmpty())) {
        qWarning("QUndoStack::setClean(): cannot set clean in the middle of a macro");
        return;
    }
 
    d->setIndex(d->index, true);
}
 
void QUndoStack::resetClean()
{
    Q_D(QUndoStack);
    const bool was_clean = isClean();
    d->clean_index = -1;
    if (was_clean)
        emit cleanChanged(false);
}
 
bool QUndoStack::isClean() const
{
    Q_D(const QUndoStack);
    if (!d->macro_stack.isEmpty())
        return false;
    return d->clean_index == d->index;
}
 
int QUndoStack::cleanIndex() const
{
    Q_D(const QUndoStack);
    return d->clean_index;
}
 
void QUndoStack::undo()
{
    Q_D(QUndoStack);
    if (d->index == 0)
        return;
 
    if (Q_UNLIKELY(!d->macro_stack.isEmpty())) {
        qWarning("QUndoStack::undo(): cannot undo in the middle of a macro");
        return;
    }
 
    int idx = d->index - 1;
    QUndoCommand *cmd = d->command_list.at(idx);
 
    if (!cmd->isObsolete())
        cmd->undo();
 
    if (cmd->isObsolete()) { // A separate check is done b/c the undo command may set obsolete flag
        delete d->command_list.takeAt(idx);
 
        if (d->clean_index > idx)
            resetClean();
    }
 
    d->setIndex(idx, false);
}
 
void QUndoStack::redo()
{
    Q_D(QUndoStack);
    if (d->index == d->command_list.size())
        return;
 
    if (Q_UNLIKELY(!d->macro_stack.isEmpty())) {
        qWarning("QUndoStack::redo(): cannot redo in the middle of a macro");
        return;
    }
 
    int idx = d->index;
    QUndoCommand *cmd = d->command_list.at(idx);
 
    if (!cmd->isObsolete())
        cmd->redo(); // A separate check is done b/c the undo command may set obsolete flag
 
    if (cmd->isObsolete()) {
        delete d->command_list.takeAt(idx);
 
        if (d->clean_index > idx)
            resetClean();
    } else {
        d->setIndex(d->index + 1, false);
    }
}
 
int QUndoStack::count() const
{
    Q_D(const QUndoStack);
    return d->command_list.size();
}
 
int QUndoStack::index() const
{
    Q_D(const QUndoStack);
    return d->index;
}
 
void QUndoStack::setIndex(int idx)
{
    Q_D(QUndoStack);
    if (Q_UNLIKELY(!d->macro_stack.isEmpty())) {
        qWarning("QUndoStack::setIndex(): cannot set index in the middle of a macro");
        return;
    }
 
    if (idx < 0)
        idx = 0;
    else if (idx > d->command_list.size())
        idx = d->command_list.size();
 
    int i = d->index;
    while (i < idx) {
        QUndoCommand *cmd = d->command_list.at(i);
 
        if (!cmd->isObsolete())
            cmd->redo();  // A separate check is done b/c the undo command may set obsolete flag
 
        if (cmd->isObsolete()) {
            delete d->command_list.takeAt(i);
 
            if (d->clean_index > i)
                resetClean();
 
            idx--; // Subtract from idx because we removed a command
        } else {
            i++;
        }
    }
 
    while (i > idx) {
        QUndoCommand *cmd = d->command_list.at(--i);
 
        cmd->undo();
        if (cmd->isObsolete()) {
            delete d->command_list.takeAt(i);
 
            if (d->clean_index > i)
                resetClean();
        }
    }
 
    d->setIndex(idx, false);
}
 
bool QUndoStack::canUndo() const
{
    Q_D(const QUndoStack);
    if (!d->macro_stack.isEmpty())
        return false;
    return d->index > 0;
}
 
bool QUndoStack::canRedo() const
{
    Q_D(const QUndoStack);
    if (!d->macro_stack.isEmpty())
        return false;
    return d->index < d->command_list.size();
}
 
QString QUndoStack::undoText() const
{
    Q_D(const QUndoStack);
    if (!d->macro_stack.isEmpty())
        return QString();
    if (d->index > 0)
        return d->command_list.at(d->index - 1)->actionText();
    return QString();
}
 
QString QUndoStack::redoText() const
{
    Q_D(const QUndoStack);
    if (!d->macro_stack.isEmpty())
        return QString();
    if (d->index < d->command_list.size())
        return d->command_list.at(d->index)->actionText();
    return QString();
}
 
#ifndef QT_NO_ACTION
 
void QUndoStackPrivate::setPrefixedText(QAction *action, const QString &prefix, const QString &defaultText, const QString &text)
{
    if (defaultText.isEmpty()) {
        QString s = prefix;
        if (!prefix.isEmpty() && !text.isEmpty())
            s.append(u' ');
        s.append(text);
        action->setText(s);
    } else {
        if (text.isEmpty())
            action->setText(defaultText);
        else
            action->setText(prefix.arg(text));
    }
};
 
QAction *QUndoStack::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, &QUndoStack::canUndoChanged, action, &QAction::setEnabled);
    connect(this, &QUndoStack::undoTextChanged, action, [=](const QString &text) {
        QUndoStackPrivate::setPrefixedText(action, effectivePrefix, defaultText, text);
    });
    connect(action, &QAction::triggered, this, &QUndoStack::undo);
 
    return action;
}
 
QAction *QUndoStack::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, &QUndoStack::canRedoChanged, action, &QAction::setEnabled);
    connect(this, &QUndoStack::redoTextChanged, action, [=](const QString &text) {
        QUndoStackPrivate::setPrefixedText(action, effectivePrefix, defaultText, text);
    });
    connect(action, &QAction::triggered, this, &QUndoStack::redo);
 
    return action;
}
 
#endif // QT_NO_ACTION
 
void QUndoStack::beginMacro(const QString &text)
{
    Q_D(QUndoStack);
    QUndoCommand *cmd = new QUndoCommand();
    cmd->setText(text);
 
    if (d->macro_stack.isEmpty()) {
        while (d->index < d->command_list.size())
            delete d->command_list.takeLast();
        if (d->clean_index > d->index)
            d->clean_index = -1; // we've deleted the clean state
        d->command_list.append(cmd);
    } else {
        d->macro_stack.constLast()->d->child_list.append(cmd);
    }
    d->macro_stack.append(cmd);
 
    if (d->macro_stack.size() == 1) {
        emit canUndoChanged(false);
        emit undoTextChanged(QString());
        emit canRedoChanged(false);
        emit redoTextChanged(QString());
    }
}
 
void QUndoStack::endMacro()
{
    Q_D(QUndoStack);
    if (Q_UNLIKELY(d->macro_stack.isEmpty())) {
        qWarning("QUndoStack::endMacro(): no matching beginMacro()");
        return;
    }
 
    d->macro_stack.removeLast();
 
    if (d->macro_stack.isEmpty()) {
        d->checkUndoLimit();
        d->setIndex(d->index + 1, false);
    }
}
 
const QUndoCommand *QUndoStack::command(int index) const
{
    Q_D(const QUndoStack);
 
    if (index < 0 || index >= d->command_list.size())
        return nullptr;
    return d->command_list.at(index);
}
 
QString QUndoStack::text(int idx) const
{
    Q_D(const QUndoStack);
 
    if (idx < 0 || idx >= d->command_list.size())
        return QString();
    return d->command_list.at(idx)->text();
}
 
void QUndoStack::setUndoLimit(int limit)
{
    Q_D(QUndoStack);
 
    if (Q_UNLIKELY(!d->command_list.isEmpty())) {
        qWarning("QUndoStack::setUndoLimit(): an undo limit can only be set when the stack is empty");
        return;
    }
 
    if (limit == d->undo_limit)
        return;
    d->undo_limit = limit;
    d->checkUndoLimit();
}
 
int QUndoStack::undoLimit() const
{
    Q_D(const QUndoStack);
 
    return d->undo_limit;
}
 
void QUndoStack::setActive(bool active)
{
#if !QT_CONFIG(undogroup)
    Q_UNUSED(active);
#else
    Q_D(QUndoStack);
 
    if (d->group != nullptr) {
        if (active)
            d->group->setActiveStack(this);
        else if (d->group->activeStack() == this)
            d->group->setActiveStack(nullptr);
    }
#endif
}
 
bool QUndoStack::isActive() const
{
#if !QT_CONFIG(undogroup)
    return true;
#else
    Q_D(const QUndoStack);
    return d->group == nullptr || d->group->activeStack() == this;
#endif
}
 
QT_END_NAMESPACE
 
#include "moc_qundostack.cpp"
 
#endif // QT_CONFIG(undostack)