create/src/Gui/CommandCompleter.cpp

/****************************************************************************
 *   Copyright (c) 2022 Zheng Lei (realthunder) <realthunder.dev@gmail.com> *
 *                                                                          *
 *   This file is part of the FreeCAD CAx development system.               *
 *                                                                          *
 *   This library is free software; you can redistribute it and/or          *
 *   modify it under the terms of the GNU Library General Public            *
 *   License as published by the Free Software Foundation; either           *
 *   version 2 of the License, or (at your option) any later version.       *
 *                                                                          *
 *   This library  is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 *   GNU Library General Public License for more details.                   *
 *                                                                          *
 *   You should have received a copy of the GNU Library General Public      *
 *   License along with this library; see the file COPYING.LIB. If not,     *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,          *
 *   Suite 330, Boston, MA  02111-1307, USA                                 *
 *                                                                          *
 ****************************************************************************/

#include <QApplication>
#include <QKeyEvent>
#include <QLineEdit>
#include <QAbstractItemView>

#include "Application.h"
#include "ShortcutManager.h"
#include "Command.h"
#include "Action.h"
#include "BitmapFactory.h"
#include "CommandCompleter.h"

using namespace Gui;

namespace
{

struct CmdInfo
{
    Command* cmd = nullptr;
    QIcon icon;
    bool iconChecked = false;
};
std::vector<CmdInfo> _Commands;
int _CommandRevision;
const int CommandNameRole = Qt::UserRole;
bool _ShortcutSignalConnected = false;

class CommandModel: public QAbstractItemModel
{
    int revision = 0;

public:
    explicit CommandModel(QObject* parent)
        : QAbstractItemModel(parent)
    {
        update();
        if (!_ShortcutSignalConnected) {
            _ShortcutSignalConnected = true;
            QObject::connect(ShortcutManager::instance(), &ShortcutManager::shortcutChanged, [] {
                _CommandRevision = 0;
            });
        }
    }

    void update()
    {
        auto& manager = Application::Instance->commandManager();
        if (revision == _CommandRevision && _CommandRevision == manager.getRevision()) {
            return;
        }
        beginResetModel();
        revision = manager.getRevision();
        if (revision != _CommandRevision) {
            _CommandRevision = revision;
            _CommandRevision = manager.getRevision();
            _Commands.clear();
            for (auto& v : manager.getCommands()) {
                _Commands.emplace_back();
                auto& info = _Commands.back();
                info.cmd = v.second;
            }
        }
        endResetModel();
    }

    QModelIndex parent(const QModelIndex&) const override
    {
        return {};
    }

    QVariant data(const QModelIndex& index, int role) const override
    {
        if (index.row() < 0 || index.row() >= (int)_Commands.size()) {
            return {};
        }

        auto& info = _Commands[index.row()];

        switch (role) {
            case Qt::DisplayRole:
            case Qt::EditRole: {
                QString title = QStringLiteral("%1 (%2)").arg(
                    Action::commandMenuText(info.cmd),
                    QString::fromUtf8(info.cmd->getName())
                );
                QString shortcut = info.cmd->getShortcut();
                if (!shortcut.isEmpty()) {
                    title += QStringLiteral(" (%1)").arg(shortcut);
                }
                return title;
            }
            case Qt::ToolTipRole:
                return Action::commandToolTip(info.cmd);

            case Qt::DecorationRole:
                if (!info.iconChecked) {
                    info.iconChecked = true;
                    if (info.cmd->getPixmap()) {
                        info.icon = BitmapFactory().iconFromTheme(info.cmd->getPixmap());
                    }
                }
                return info.icon;

            case CommandNameRole:
                return QByteArray(info.cmd->getName());

            default:
                break;
        }
        return {};
    }

    QModelIndex index(int row, int, const QModelIndex&) const override
    {
        return this->createIndex(row, 0);
    }

    int rowCount(const QModelIndex&) const override
    {
        return (int)(_Commands.size());
    }

    int columnCount(const QModelIndex&) const override
    {
        return 1;
    }
};

}  // anonymous namespace

// --------------------------------------------------------------------

CommandCompleter::CommandCompleter(QLineEdit* lineedit, QObject* parent)
    : QCompleter(parent)
{
    this->setModel(new CommandModel(this));
    this->setFilterMode(Qt::MatchContains);
    this->setCaseSensitivity(Qt::CaseInsensitive);
    this->setCompletionMode(QCompleter::PopupCompletion);
    this->setWidget(lineedit);
    connect(lineedit, &QLineEdit::textEdited, this, &CommandCompleter::onTextChanged);
    connect(
        this,
        qOverload<const QModelIndex&>(&CommandCompleter::activated),
        this,
        &CommandCompleter::onCommandActivated
    );
    connect(this, qOverload<const QString&>(&CommandCompleter::highlighted), lineedit, &QLineEdit::setText);
}

bool CommandCompleter::eventFilter(QObject* o, QEvent* ev)
{
    if (ev->type() == QEvent::KeyPress && (o == this->widget() || o == this->popup())) {
        QKeyEvent* ke = static_cast<QKeyEvent*>(ev);
        switch (ke->key()) {
            case Qt::Key_Escape: {
                auto edit = qobject_cast<QLineEdit*>(this->widget());
                if (edit && edit->text().size()) {
                    edit->setText(QString());
                    popup()->hide();
                    return true;
                }
                else if (popup()->isVisible()) {
                    popup()->hide();
                    return true;
                }
                break;
            }
            case Qt::Key_Tab: {
                if (this->popup()->isVisible()) {
                    QKeyEvent kevent(ke->type(), Qt::Key_Down, Qt::NoModifier);
                    qApp->sendEvent(this->popup(), &kevent);
                    return true;
                }
                break;
            }
            case Qt::Key_Backtab: {
                if (this->popup()->isVisible()) {
                    QKeyEvent kevent(ke->type(), Qt::Key_Up, Qt::NoModifier);
                    qApp->sendEvent(this->popup(), &kevent);
                    return true;
                }
                break;
            }
            case Qt::Key_Enter:
            case Qt::Key_Return:
                if (o == this->widget()) {
                    auto index = currentIndex();
                    if (index.isValid()) {
                        onCommandActivated(index);
                    }
                    else {
                        complete();
                    }
                    ev->setAccepted(true);
                    return true;
                }
            default:
                break;
        }
    }
    return QCompleter::eventFilter(o, ev);
}

void CommandCompleter::onCommandActivated(const QModelIndex& index)
{
    QByteArray name = completionModel()->data(index, CommandNameRole).toByteArray();
    Q_EMIT commandActivated(name);
}

void CommandCompleter::onTextChanged(const QString& txt)
{
    // Do not activate completer if less than 3 characters for better
    // performance.
    if (txt.size() < 3 || !widget()) {
        return;
    }

    static_cast<CommandModel*>(this->model())->update();

    this->setCompletionPrefix(txt);
    QRect rect = widget()->rect();
    if (rect.width() < 300) {
        rect.setWidth(300);
    }
    this->complete(rect);
}

#include "moc_CommandCompleter.cpp"