Lime3DS/src/citra_qt/configuration/configure_hotkeys.cpp

// Copyright Citra Emulator Project / Azahar Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.

#include <QMenu>
#include <QMessageBox>
#include <QStandardItemModel>
#include "citra_qt/configuration/config.h"
#include "citra_qt/configuration/configure_hotkeys.h"
#include "citra_qt/hotkeys.h"
#include "citra_qt/util/sequence_dialog/sequence_dialog.h"
#include "ui_configure_hotkeys.h"

constexpr int name_column = 0;
constexpr int hotkey_column = 1;

ConfigureHotkeys::ConfigureHotkeys(QWidget* parent)
    : QWidget(parent), ui(std::make_unique<Ui::ConfigureHotkeys>()) {
    ui->setupUi(this);
    setFocusPolicy(Qt::ClickFocus);

    model = new QStandardItemModel(this);
    model->setColumnCount(2);
    model->setHorizontalHeaderLabels({tr("Action"), tr("Hotkey")});

    connect(ui->hotkey_list, &QTreeView::doubleClicked, this, &ConfigureHotkeys::Configure);
    connect(ui->hotkey_list, &QTreeView::customContextMenuRequested, this,
            &ConfigureHotkeys::PopupContextMenu);
    ui->hotkey_list->setContextMenuPolicy(Qt::CustomContextMenu);
    ui->hotkey_list->setModel(model);

    ui->hotkey_list->setColumnWidth(0, 250);
    ui->hotkey_list->resizeColumnToContents(hotkey_column);

    connect(ui->button_restore_defaults, &QPushButton::clicked, this,
            &ConfigureHotkeys::RestoreDefaults);
    connect(ui->button_clear_all, &QPushButton::clicked, this, &ConfigureHotkeys::ClearAll);
}

ConfigureHotkeys::~ConfigureHotkeys() = default;

void ConfigureHotkeys::EmitHotkeysChanged() {
    emit HotkeysChanged(GetUsedKeyList());
}

QMap<QKeySequence, ConfigureInput::InputBinding> ConfigureHotkeys::GetUsedKeyList() const {
    QMap<QKeySequence, ConfigureInput::InputBinding> list;
    for (int r = 0; r < model->rowCount(); r++) {
        QStandardItem* parent = model->item(r, 0);
        for (int r2 = 0; r2 < parent->rowCount(); r2++) {
            QStandardItem* keyseq = parent->child(r2, 1);
            auto seq = QKeySequence::fromString(keyseq->text(), QKeySequence::NativeText);
            if (seq.count() == 1 &&
                seq[0].keyboardModifiers() == Qt::KeyboardModifier::NoModifier) {
                auto binding = ConfigureInput::InputBinding(
                    "Hotkey", parent->child(r2, 0)->text().toStdString(), r2);
                list[seq] = binding;
            }
        }
    }
    return list;
}

void ConfigureHotkeys::Populate(const HotkeyRegistry& registry) {
    for (const auto& group : registry.hotkey_groups) {
        QStandardItem* parent_item = new QStandardItem(group.first);
        parent_item->setEditable(false);
        for (const auto& hotkey : group.second) {
            QStandardItem* action = new QStandardItem(hotkey.first);
            QStandardItem* keyseq =
                new QStandardItem(hotkey.second.keyseq.toString(QKeySequence::NativeText));
            QStandardItem* controller_keyseq = new QStandardItem(hotkey.second.controller_keyseq);
            action->setEditable(false);
            keyseq->setEditable(false);
            controller_keyseq->setEditable(false);
            parent_item->appendRow({action, keyseq, controller_keyseq});
        }
        model->appendRow(parent_item);
    }

    ui->hotkey_list->expandAll();
}

void ConfigureHotkeys::OnInputKeysChanged(
    QMap<QKeySequence, ConfigureInput::InputBinding> new_key_list) {
    input_keys_list = new_key_list;
}

void ConfigureHotkeys::Configure(QModelIndex index) {
    if (!index.parent().isValid()) {
        return;
    }

    // Swap to the hotkey column
    index = index.sibling(index.row(), hotkey_column);

    const auto previous_key = model->data(index);

    SequenceDialog hotkey_dialog{this};

    const int return_code = hotkey_dialog.exec();
    const auto key_sequence = hotkey_dialog.GetSequence();
    if (return_code == QDialog::Rejected || key_sequence.isEmpty()) {
        return;
    }
    const auto [key_sequence_used, current_binding] = IsUsedKey(key_sequence);

    // Check for turbo/per-game speed conflict. Needed to prevent the user from binding both hotkeys
    // to the same action. Which cuases problems resetting the frame limit.to the inititla value.
    const QString current_action =
        model->data(model->index(index.row(), 0, index.parent())).toString();
    const bool is_turbo = current_action == tr("Toggle Turbo Mode");
    const bool is_per_game = current_action == tr("Toggle Per-Application Speed");

    if (is_turbo || is_per_game) {
        QString other_action =
            is_turbo ? tr("Toggle Per-Application Speed") : tr("Toggle Turbo Mode");
        QKeySequence other_sequence;

        for (int r = 0; r < model->rowCount(); ++r) {
            const QStandardItem* const parent = model->item(r, 0);
            for (int r2 = 0; r2 < parent->rowCount(); ++r2) {
                if (parent->child(r2, 0)->text() == other_action) {
                    other_sequence = QKeySequence::fromString(
                        parent->child(r2, hotkey_column)->text(), QKeySequence::NativeText);
                    break;
                }
            }
        }

        // Show warning if either hotkey is already set
        if (!key_sequence.isEmpty() && !other_sequence.isEmpty()) {
            QMessageBox::warning(this, tr("Conflicting Key Sequence"),
                                 tr("The per-application speed and turbo speed hotkeys cannot be "
                                    "bound at the same time."));
            return;
        }
    }

    if (key_sequence_used && key_sequence != QKeySequence(previous_key.toString())) {
        auto response =
            QMessageBox::question(this, QStringLiteral("Duplicate mapping"),
                                  QString::fromStdString("This will clear the mapping for " +
                                                         current_binding.name + ". Proceed?"),
                                  QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
        if (response == QMessageBox::No) {
            return;
        } else {
            if (current_binding.binding_type == "Hotkey") {
                model->setData(index.sibling(current_binding.index, hotkey_column),
                               QStringLiteral(""));
            } else {
                emit ClearInputBinding(current_binding);
            }
        }
    }

    model->setData(index, key_sequence.toString(QKeySequence::NativeText));
    EmitHotkeysChanged();
}

void ConfigureHotkeys::OnClearBinding(ConfigureInput::InputBinding hotkey_to_clear) {
    const auto index = ui->hotkey_list->currentIndex();
    if (hotkey_to_clear.binding_type == "Hotkey") {
        model->setData(index.sibling(hotkey_to_clear.index, hotkey_column), QStringLiteral(""));
    }
    EmitHotkeysChanged();
}

std::pair<bool, ConfigureInput::InputBinding> ConfigureHotkeys::IsUsedKey(
    QKeySequence key_sequence) const {
    if (key_sequence == QKeySequence::fromString(QStringLiteral(""), QKeySequence::NativeText)) {
        return std::make_pair(false, ConfigureInput::InputBinding{"", "", -1});
    }

    if (input_keys_list.contains(key_sequence)) {
        return std::make_pair(true, input_keys_list[key_sequence]);
    }

    for (int r = 0; r < model->rowCount(); ++r) {
        const QStandardItem* const parent = model->item(r, 0);

        for (int r2 = 0; r2 < parent->rowCount(); ++r2) {
            const QStandardItem* const key_seq_item = parent->child(r2, hotkey_column);
            const auto key_seq_str = key_seq_item->text();
            const auto key_seq = QKeySequence::fromString(key_seq_str, QKeySequence::NativeText);

            if (key_sequence == key_seq) {
                return std::make_pair(
                    true, ConfigureInput::InputBinding{
                              "Hotkey", parent->child(r2, 0)->text().toStdString(), r2});
            }
        }
    }

    return std::make_pair(false, ConfigureInput::InputBinding{"", "", -1});
}

void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) {
    for (int key_id = 0; key_id < model->rowCount(); key_id++) {
        QStandardItem* parent = model->item(key_id, 0);
        for (int key_column_id = 0; key_column_id < parent->rowCount(); key_column_id++) {
            const QStandardItem* action = parent->child(key_column_id, name_column);
            const QStandardItem* keyseq = parent->child(key_column_id, hotkey_column);
            for (auto& [group, sub_actions] : registry.hotkey_groups) {
                if (group != parent->text())
                    continue;
                for (auto& [action_name, hotkey] : sub_actions) {
                    if (action_name != action->text())
                        continue;
                    hotkey.keyseq = QKeySequence(keyseq->text());
                }
            }
        }
    }

    registry.SaveHotkeys();
}

void ConfigureHotkeys::RestoreDefaults() {
    for (int r = 0; r < model->rowCount(); ++r) {
        const QStandardItem* parent = model->item(r, 0);

        for (int r2 = 0; r2 < parent->rowCount(); ++r2) {
            model->item(r, 0)
                ->child(r2, hotkey_column)
                ->setText(QtConfig::default_hotkeys[r2].shortcut.keyseq);
        }
    }
    EmitHotkeysChanged();
}

void ConfigureHotkeys::ClearAll() {
    for (int r = 0; r < model->rowCount(); ++r) {
        const QStandardItem* parent = model->item(r, 0);

        for (int r2 = 0; r2 < parent->rowCount(); ++r2) {
            model->item(r, 0)->child(r2, hotkey_column)->setText(QString{});
        }
    }
    EmitHotkeysChanged();
}

void ConfigureHotkeys::PopupContextMenu(const QPoint& menu_location) {
    const auto index = ui->hotkey_list->indexAt(menu_location);
    if (!index.parent().isValid()) {
        return;
    }

    QMenu context_menu;
    QAction* restore_default = context_menu.addAction(tr("Restore Default"));
    QAction* clear = context_menu.addAction(tr("Clear"));

    const auto hotkey_index = index.sibling(index.row(), hotkey_column);
    connect(restore_default, &QAction::triggered, this,
            [this, hotkey_index] { RestoreHotkey(hotkey_index); });
    connect(clear, &QAction::triggered, this,
            [this, hotkey_index] { model->setData(hotkey_index, QString{}); });

    context_menu.exec(ui->hotkey_list->viewport()->mapToGlobal(menu_location));
}

void ConfigureHotkeys::RestoreHotkey(QModelIndex index) {
    const QKeySequence& default_key_sequence = QKeySequence::fromString(
        QtConfig::default_hotkeys[index.row()].shortcut.keyseq, QKeySequence::NativeText);
    const auto [key_sequence_used, used_action] = IsUsedKey(default_key_sequence);

    if (key_sequence_used && default_key_sequence != QKeySequence(model->data(index).toString())) {
        QMessageBox::warning(this, tr("Conflicting Key Sequence"),
                             tr("The default key sequence is already assigned to: %1")
                                 .arg(QString::fromStdString(used_action.name)));
    } else {
        model->setData(index, default_key_sequence.toString(QKeySequence::NativeText));
    }
    EmitHotkeysChanged();
}

void ConfigureHotkeys::RetranslateUI() {
    ui->retranslateUi(this);
}