create/src/Gui/ShortcutManager.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 <limits>
# include <QShortcutEvent>
# include <QApplication>

#include <boost/algorithm/string/predicate.hpp>

#include <Base/Console.h>
#include <Base/Tools.h>
#include "ShortcutManager.h"
#include "Command.h"
#include "Window.h"
#include "Action.h"

using namespace Gui;

ShortcutManager::ShortcutManager()
{
    hShortcuts = WindowParameter::getDefaultParameter()->GetGroup("Shortcut");
    hShortcuts->Attach(this);
    hPriorities = hShortcuts->GetGroup("Priorities");
    hPriorities->Attach(this);
    hSetting = hShortcuts->GetGroup("Settings");
    hSetting->Attach(this);
    timeout = hSetting->GetInt("ShortcutTimeout", 300);
    timer.setSingleShot(true);

    QObject::connect(&timer, &QTimer::timeout, [this](){onTimer();});

    topPriority = 0;
    for (const auto &v : hPriorities->GetIntMap()) {
        priorities[v.first] = v.second;
        if (topPriority < v.second)
            topPriority = v.second;
    }
    if (topPriority == 0)
        topPriority = 100;

    QApplication::instance()->installEventFilter(this);
}

ShortcutManager::~ShortcutManager()
{
    hShortcuts->Detach(this);
    hSetting->Detach(this);
    hPriorities->Detach(this);
}

static ShortcutManager *Instance;
ShortcutManager *ShortcutManager::instance()
{
    if (!Instance)
        Instance = new ShortcutManager;
    return Instance;
}

void ShortcutManager::destroy()
{
    delete Instance;
    Instance = nullptr;
}

void ShortcutManager::OnChange(Base::Subject<const char*> &src, const char *reason)
{
    if (hSetting == &src) {
        if (boost::equals(reason, "ShortcutTimeout"))
            timeout = hSetting->GetInt("ShortcutTimeout");
        return;
    }

    if (busy)
        return;

    if (hPriorities == &src) {
        int p = hPriorities->GetInt(reason, 0);
        if (p == 0)
            priorities.erase(reason);
        else
            priorities[reason] = p;
        if (topPriority < p)
            topPriority = p;
        priorityChanged(reason, p);
        return;
    }

    Base::StateLocker lock(busy);
    auto cmd = Application::Instance->commandManager().getCommandByName(reason);
    if (cmd) {
        auto accel = cmd->getAccel();
        if (!accel) accel = "";
        QKeySequence oldShortcut = cmd->getShortcut();
        QKeySequence newShortcut = getShortcut(reason, accel);
        if (oldShortcut != newShortcut) {
            cmd->setShortcut(newShortcut.toString());
            shortcutChanged(reason, oldShortcut);
        }
    }
}

void ShortcutManager::reset(const char *cmd)
{
    if (!Base::Tools::isNullOrEmpty(cmd)) {
        QKeySequence oldShortcut = getShortcut(cmd);
        hShortcuts->RemoveASCII(cmd);
        if (oldShortcut != getShortcut(cmd))
            shortcutChanged(cmd, oldShortcut);

        int oldPriority = getPriority(cmd);
        hPriorities->RemoveInt(cmd);
        if (oldPriority != getPriority(cmd))
            priorityChanged(cmd, oldPriority);
    }
}

void ShortcutManager::resetAll()
{
    {
        Base::StateLocker lock(busy);
        hShortcuts->Clear();
        hPriorities->Clear();
        for (auto cmd : Application::Instance->commandManager().getAllCommands()) {
            if (cmd->getAction()) {
                auto accel = cmd->getAccel();
                if (!accel) accel = "";
                cmd->setShortcut(getShortcut(nullptr, accel));
            }
        }
    }
    shortcutChanged("", QKeySequence());
    priorityChanged("", 0);
}

QString ShortcutManager::getShortcut(const char *cmdName, const char *accel)
{
    if (!accel) {
        if (auto cmd = Application::Instance->commandManager().getCommandByName(cmdName)) {
            accel = cmd->getAccel();
            if (!accel)
                accel = "";
        }
    }
    QString shortcut;
    if (cmdName)
        shortcut = QString::fromLatin1(hShortcuts->GetASCII(cmdName, accel).c_str());
    else
        shortcut = QString::fromLatin1(accel);
    return QKeySequence(shortcut).toString(QKeySequence::NativeText);
}

void ShortcutManager::setShortcut(const char *cmdName, const char *accel)
{
    if (!Base::Tools::isNullOrEmpty(cmdName)) {
        setTopPriority(cmdName);
        if (!accel)
            accel = "";
        if (auto cmd = Application::Instance->commandManager().getCommandByName(cmdName)) {
            auto defaultAccel = cmd->getAccel();
            if (!defaultAccel)
               defaultAccel = "";
           if (QKeySequence(QString::fromLatin1(accel)) == QKeySequence(QString::fromLatin1(defaultAccel))) {
                hShortcuts->RemoveASCII(cmdName);
                return;
           }
        }
        hShortcuts->SetASCII(cmdName, accel);
    }
}

bool ShortcutManager::checkShortcut(QObject *o, const QKeySequence &key)
{
    auto focus = QApplication::focusWidget();
    if (!focus)
        return false;
    auto action = qobject_cast<QAction*>(o);
    if (!action)
        return false;

    const auto &index = actionMap.get<1>();
    auto iter = index.lower_bound(ActionKey(key));
    if (iter == index.end())
        return false;

    // disable and enqueue the action in order to try other alternativeslll
    action->setEnabled(false);
    pendingActions.emplace_back(action, key.count(), 0);

    // check for potential partial match, i.e. longer key sequences
    bool flush = true;
    bool found = false;
    for (auto it = iter; it != index.end(); ++it) {
        if (key.matches(it->key.shortcut) == QKeySequence::NoMatch)
            break;
        if (action == it->action) {
            // There maybe more than one action with the exact same shortcut.
            // However, we only disable and enqueue the triggered action.
            // Because, QAction::isEnabled() does not check if the action is
            // active under its current ShortcutContext. We would have to check
            // its parent widgets visibility which may or may not be reliable.
            // Instead, we rely on QEvent::Shortcut to be sure to enqueue only
            // active shortcuts. We'll fake the current key sequence below,
            // which will trigger all possible matches one by one.
            pendingActions.back().priority = getPriority(it->key.name);
            found = true;
        }
        else if (it->action && it->action->isEnabled()) {
            flush = false;
            if (found)
                break;
        }
    }

    if (flush) {
        // We'll flush now because there is no potential match with further
        // keystrokes, so no need to wait for timer.
        lastFocus = nullptr;
        onTimer();
        return true;
    }

    lastFocus = focus;
    pendingSequence = key;

    // Qt's shortcut state machine favors shortest match (which is ridiculous,
    // unless I'm mistaken?). We'll do longest match. We've disabled all
    // shortcuts that can match the current key sequence. Now replay the sequence
    // and wait for the next keystroke.
    for (int i=0; i<key.count(); ++i) {
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
        int k = key[i];
#else
        int k = key[i].key();
#endif
        Qt::KeyboardModifiers modifiers;
        if ((k & Qt::SHIFT) == Qt::SHIFT)
            modifiers |= Qt::ShiftModifier;
        if ((k & Qt::CTRL) == Qt::CTRL)
            modifiers |= Qt::ControlModifier;
        if ((k & Qt::ALT) == Qt::ALT)
            modifiers |= Qt::AltModifier;
        if ((k & Qt::META) == Qt::META)
            modifiers |= Qt::MetaModifier;
        k &= ~(Qt::SHIFT|Qt::CTRL|Qt::ALT|Qt::META);
        QKeyEvent *kev = new QKeyEvent(QEvent::KeyPress, k, modifiers, 0, 0, 0);
        QApplication::postEvent(focus, kev);
        kev = new QKeyEvent(QEvent::KeyRelease, k, modifiers, 0, 0, 0);
        QApplication::postEvent(focus, kev);
    }
    timer.start(timeout);
    return true;
}

bool ShortcutManager::eventFilter(QObject *o, QEvent *ev)
{
    switch(ev->type()) {
    case QEvent::KeyPress:
        lastFocus = nullptr;
        break;
    case QEvent::Shortcut:
        if (timeout > 0) {
            auto sev = static_cast<QShortcutEvent*>(ev);
            if (checkShortcut(o, sev->key())) {
                // shortcut event handled here, so filter out the event
                return true;
            } else {
                // Not handled. Clear any existing pending actions.
                timer.stop();
                for (const auto &info : pendingActions) {
                    if (info.action)
                        info.action->setEnabled(true);
                }
                pendingActions.clear();
                lastFocus = nullptr;
            }
        }
        break;
    case QEvent::ActionChanged:
        if (auto action = qobject_cast<QAction*>(o)) {
            auto &index = actionMap.get<0>();
            auto it = index.find(reinterpret_cast<intptr_t>(action));
            if (action->shortcut().isEmpty()) {
                if (it != index.end()) {
                    QKeySequence oldShortcut = it->key.shortcut;
                    index.erase(it);
                    actionShortcutChanged(action, oldShortcut);
                }
                break;
            }

            QByteArray name;
            if (auto fcAction = qobject_cast<Action*>(action->parent())) {
                if (fcAction->command() && fcAction->command()->getName())
                    name = fcAction->command()->getName();
            }
            if (name.isEmpty()) {
                name = action->objectName().size() ?
                    action->objectName().toUtf8() : action->text().toUtf8();
                if (name.isEmpty())
                    name = "~";
                else
                    name = QByteArray("~ ") + name;
            }
            if (it != index.end()) {
                if (it->key.shortcut == action->shortcut() && it->key.name == name)
                    break;
                QKeySequence oldShortcut = it->key.shortcut;
                index.replace(it, ActionData{action, name});
                actionShortcutChanged(action, oldShortcut);
            } else {
                index.insert(ActionData{action, name});
                actionShortcutChanged(action, QKeySequence());
            }
        }
        break;
    default:
        break;
    }
    return false;
}

std::vector<std::pair<QByteArray, QAction*>> ShortcutManager::getActionsByShortcut(const QKeySequence &shortcut)
{
    const auto &index = actionMap.get<1>();
    std::vector<std::pair<QByteArray, QAction*>> res;
    std::multimap<int, const ActionData*, std::greater<>> map;
    for (auto it = index.lower_bound(ActionKey(shortcut)); it != index.end(); ++it) {
        if (it->key.shortcut != shortcut)
            break;
        if (it->key.name != "~" && it->action)
            map.emplace(getPriority(it->key.name), &(*it));
    }
    for (const auto &v : map)
        res.emplace_back(v.second->key.name, v.second->action);
    return res;
}

void ShortcutManager::setPriorities(const std::vector<QByteArray> &actions)
{
    if (actions.empty())
        return;
    // Keep the same top priority of the given action, and adjust the rest. Can
    // go negative if necessary
    int current = 0;
    for (const auto &name : actions)
        current = std::max(current, getPriority(name));
    if (current == 0)
        current = (int)actions.size();
    setPriority(actions.front(), current);
    ++current;
    for (const auto &name : actions) {
        int p = getPriority(name);
        if (p <= 0 || p >= current) {
            if (--current == 0)
                --current;
            setPriority(name, current);
        } else
            current = p;
    }
}

int ShortcutManager::getPriority(const char *cmdName)
{
    if (!cmdName)
        return 0;
    auto it = priorities.find(cmdName);
    if (it == priorities.end())
        return 0;
    return it->second;
}

void ShortcutManager::setPriority(const char *cmdName, int p)
{
    if (p == 0)
        hPriorities->RemoveInt(cmdName);
    else
        hPriorities->SetInt(cmdName, p);
}

void ShortcutManager::setTopPriority(const char *cmdName)
{
    ++topPriority;
    hPriorities->SetInt(cmdName, topPriority);
}

void ShortcutManager::onTimer()
{
    timer.stop();

    QAction *found = nullptr;
    int priority = -std::numeric_limits<int>::max();
    int seq_length = 0;
    for (const auto &info : pendingActions) {
        if (info.action) {
            info.action->setEnabled(true);
            if (info.seq_length > seq_length
                    || (info.seq_length == seq_length
                        && info.priority > priority))
            {
                priority = info.priority;
                seq_length = info.seq_length;
                found = info.action;
            }
        }
    }
    if (found)
        found->activate(QAction::Trigger);
    pendingActions.clear();

    if (lastFocus && lastFocus == QApplication::focusWidget()) {
        // We are here because we have withheld some previous triggered action.
        // We then disabled the action, and faked the same key strokes in order
        // to wait for more potential match of longer key sequence. We use
        // a timer to end the wait and trigger the pending action.
        //
        // However, Qt's internal shorcutmap state machine is still armed with
        // our fake key strokes. So we try to fake some more obscure symbol key
        // stroke below, hoping to reset Qt's state machine.

        const auto &index = actionMap.get<1>();
        static const std::string symbols = "~!@#$%^&*()_+";
        QString shortcut = pendingSequence.toString() + QStringLiteral(", Ctrl+");
        for (int s : symbols) {
            QKeySequence k(shortcut + QLatin1Char(s));
            auto it = index.lower_bound(ActionKey(k));
            if (it->key.shortcut != k) {
                QKeyEvent *kev = new QKeyEvent(QEvent::KeyPress, s, Qt::ControlModifier, 0, 0, 0);
                QApplication::postEvent(lastFocus, kev);
                kev = new QKeyEvent(QEvent::KeyRelease, s, Qt::ControlModifier, 0, 0, 0);
                QApplication::postEvent(lastFocus, kev);
                break;
            }
        }
    }
}

#include "moc_ShortcutManager.cpp"