applets: Remove the previous software keyboard applet implementation

src/core/frontend/applets/software_keyboard.cpp

@@ -2,28 +2,10 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "common/logging/backend.h"
-#include "common/string_util.h"
 #include "core/frontend/applets/software_keyboard.h"
 
 namespace Core::Frontend {
-SoftwareKeyboardApplet::~SoftwareKeyboardApplet() = default;
-
-void DefaultSoftwareKeyboardApplet::RequestText(
-    std::function<void(std::optional<std::u16string>)> out,
-    SoftwareKeyboardParameters parameters) const {
-    if (parameters.initial_text.empty())
-        out(u"yuzu");
 
-    out(parameters.initial_text);
-}
+SoftwareKeyboardApplet::~SoftwareKeyboardApplet() = default;
 
-void DefaultSoftwareKeyboardApplet::SendTextCheckDialog(
-    std::u16string error_message, std::function<void()> finished_check) const {
-    LOG_WARNING(Service_AM,
-                "(STUBBED) called - Default fallback software keyboard does not support text "
-                "check! (error_message={})",
-                Common::UTF16ToUTF8(error_message));
-    finished_check();
-}
 } // namespace Core::Frontend

src/core/frontend/applets/software_keyboard.h

@@ -4,51 +4,17 @@
 
 #pragma once
 
-#include <functional>
-#include <optional>
-#include <string>
-#include "common/bit_field.h"
 #include "common/common_types.h"
 
 namespace Core::Frontend {
-struct SoftwareKeyboardParameters {
-    std::u16string submit_text;
-    std::u16string header_text;
-    std::u16string sub_text;
-    std::u16string guide_text;
-    std::u16string initial_text;
-    std::size_t max_length;
-    bool password;
-    bool cursor_at_beginning;
-
-    union {
-        u8 value;
-
-        BitField<1, 1, u8> disable_space;
-        BitField<2, 1, u8> disable_address;
-        BitField<3, 1, u8> disable_percent;
-        BitField<4, 1, u8> disable_slash;
-        BitField<6, 1, u8> disable_number;
-        BitField<7, 1, u8> disable_download_code;
-    };
-};
 
 class SoftwareKeyboardApplet {
 public:
     virtual ~SoftwareKeyboardApplet();
-
-    virtual void RequestText(std::function<void(std::optional<std::u16string>)> out,
-                             SoftwareKeyboardParameters parameters) const = 0;
-    virtual void SendTextCheckDialog(std::u16string error_message,
-                                     std::function<void()> finished_check) const = 0;
 };
 
 class DefaultSoftwareKeyboardApplet final : public SoftwareKeyboardApplet {
 public:
-    void RequestText(std::function<void(std::optional<std::u16string>)> out,
-                     SoftwareKeyboardParameters parameters) const override;
-    void SendTextCheckDialog(std::u16string error_message,
-                             std::function<void()> finished_check) const override;
 };
 
 } // namespace Core::Frontend

src/core/hle/service/am/applets/software_keyboard.cpp

@@ -2,199 +2,27 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cstring>
-#include "common/assert.h"
-#include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/applets/software_keyboard.h"
-#include "core/hle/result.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/software_keyboard.h"
 
 namespace Service::AM::Applets {
 
-namespace {
-enum class Request : u32 {
-    Finalize = 0x4,
-    SetUserWordInfo = 0x6,
-    SetCustomizeDic = 0x7,
-    Calc = 0xa,
-    SetCustomizedDictionaries = 0xb,
-    UnsetCustomizedDictionaries = 0xc,
-    UnknownD = 0xd,
-    UnknownE = 0xe,
-};
-constexpr std::size_t SWKBD_INLINE_INIT_SIZE = 0x8;
-constexpr std::size_t SWKBD_OUTPUT_BUFFER_SIZE = 0x7D8;
-constexpr std::size_t SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE = 0x7D4;
-constexpr std::size_t DEFAULT_MAX_LENGTH = 500;
-constexpr bool INTERACTIVE_STATUS_OK = false;
-} // Anonymous namespace
-static Core::Frontend::SoftwareKeyboardParameters ConvertToFrontendParameters(
-    KeyboardConfig config, std::u16string initial_text) {
-    Core::Frontend::SoftwareKeyboardParameters params{};
-
-    params.submit_text = Common::UTF16StringFromFixedZeroTerminatedBuffer(
-        config.submit_text.data(), config.submit_text.size());
-    params.header_text = Common::UTF16StringFromFixedZeroTerminatedBuffer(
-        config.header_text.data(), config.header_text.size());
-    params.sub_text = Common::UTF16StringFromFixedZeroTerminatedBuffer(config.sub_text.data(),
-                                                                       config.sub_text.size());
-    params.guide_text = Common::UTF16StringFromFixedZeroTerminatedBuffer(config.guide_text.data(),
-                                                                         config.guide_text.size());
-    params.initial_text = std::move(initial_text);
-    params.max_length = config.length_limit == 0 ? DEFAULT_MAX_LENGTH : config.length_limit;
-    params.password = static_cast<bool>(config.is_password);
-    params.cursor_at_beginning = static_cast<bool>(config.initial_cursor_position);
-    params.value = static_cast<u8>(config.keyset_disable_bitmask);
-
-    return params;
-}
-
 SoftwareKeyboard::SoftwareKeyboard(Core::System& system_,
                                    const Core::Frontend::SoftwareKeyboardApplet& frontend_)
     : Applet{system_.Kernel()}, frontend{frontend_}, system{system_} {}
 
 SoftwareKeyboard::~SoftwareKeyboard() = default;
 
-void SoftwareKeyboard::Initialize() {
-    complete = false;
-    is_inline = false;
-    initial_text.clear();
-    final_data.clear();
-
-    Applet::Initialize();
-
-    const auto keyboard_config_storage = broker.PopNormalDataToApplet();
-    ASSERT(keyboard_config_storage != nullptr);
-    const auto& keyboard_config = keyboard_config_storage->GetData();
-
-    if (keyboard_config.size() == SWKBD_INLINE_INIT_SIZE) {
-        is_inline = true;
-        return;
-    }
-
-    ASSERT(keyboard_config.size() >= sizeof(KeyboardConfig));
-    std::memcpy(&config, keyboard_config.data(), sizeof(KeyboardConfig));
-
-    const auto work_buffer_storage = broker.PopNormalDataToApplet();
-    ASSERT_OR_EXECUTE(work_buffer_storage != nullptr, { return; });
-    const auto& work_buffer = work_buffer_storage->GetData();
-
-    if (config.initial_string_size == 0)
-        return;
-
-    std::vector<char16_t> string(config.initial_string_size);
-    std::memcpy(string.data(), work_buffer.data() + config.initial_string_offset,
-                string.size() * 2);
-    initial_text = Common::UTF16StringFromFixedZeroTerminatedBuffer(string.data(), string.size());
-}
-
-bool SoftwareKeyboard::TransactionComplete() const {
-    return complete;
-}
-
-ResultCode SoftwareKeyboard::GetStatus() const {
-    return RESULT_SUCCESS;
-}
-
-void SoftwareKeyboard::ExecuteInteractive() {
-    if (complete)
-        return;
-
-    const auto storage = broker.PopInteractiveDataToApplet();
-    ASSERT(storage != nullptr);
-    const auto data = storage->GetData();
-    if (!is_inline) {
-        const auto status = static_cast<bool>(data[0]);
-        if (status == INTERACTIVE_STATUS_OK) {
-            complete = true;
-        } else {
-            std::array<char16_t, SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE / 2 - 2> string;
-            std::memcpy(string.data(), data.data() + 4, string.size() * 2);
-            frontend.SendTextCheckDialog(
-                Common::UTF16StringFromFixedZeroTerminatedBuffer(string.data(), string.size()),
-                [this] { broker.SignalStateChanged(); });
-        }
-    } else {
-        Request request{};
-        std::memcpy(&request, data.data(), sizeof(Request));
-
-        switch (request) {
-        case Request::Finalize:
-            complete = true;
-            broker.SignalStateChanged();
-            break;
-        case Request::Calc: {
-            broker.PushNormalDataFromApplet(std::make_shared<IStorage>(system, std::vector<u8>{1}));
-            broker.SignalStateChanged();
-            break;
-        }
-        default:
-            UNIMPLEMENTED_MSG("Request {:X} is not implemented", request);
-            break;
-        }
-    }
-}
-
-void SoftwareKeyboard::Execute() {
-    if (complete) {
-        broker.PushNormalDataFromApplet(std::make_shared<IStorage>(system, std::move(final_data)));
-        broker.SignalStateChanged();
-        return;
-    }
-
-    const auto parameters = ConvertToFrontendParameters(config, initial_text);
-    if (!is_inline) {
-        frontend.RequestText(
-            [this](std::optional<std::u16string> text) { WriteText(std::move(text)); }, parameters);
-    }
-}
-
-void SoftwareKeyboard::WriteText(std::optional<std::u16string> text) {
-    std::vector<u8> output_main(SWKBD_OUTPUT_BUFFER_SIZE);
-
-    if (text.has_value()) {
-        std::vector<u8> output_sub(SWKBD_OUTPUT_BUFFER_SIZE);
-
-        if (config.utf_8) {
-            const u64 size = text->size() + sizeof(u64);
-            const auto new_text = Common::UTF16ToUTF8(*text);
+void SoftwareKeyboard::Initialize() {}
 
-            std::memcpy(output_sub.data(), &size, sizeof(u64));
-            std::memcpy(output_sub.data() + 8, new_text.data(),
-                        std::min(new_text.size(), SWKBD_OUTPUT_BUFFER_SIZE - 8));
+bool SoftwareKeyboard::TransactionComplete() const {}
 
-            output_main[0] = INTERACTIVE_STATUS_OK;
-            std::memcpy(output_main.data() + 4, new_text.data(),
-                        std::min(new_text.size(), SWKBD_OUTPUT_BUFFER_SIZE - 4));
-        } else {
-            const u64 size = text->size() * 2 + sizeof(u64);
-            std::memcpy(output_sub.data(), &size, sizeof(u64));
-            std::memcpy(output_sub.data() + 8, text->data(),
-                        std::min(text->size() * 2, SWKBD_OUTPUT_BUFFER_SIZE - 8));
+ResultCode SoftwareKeyboard::GetStatus() const {}
 
-            output_main[0] = INTERACTIVE_STATUS_OK;
-            std::memcpy(output_main.data() + 4, text->data(),
-                        std::min(text->size() * 2, SWKBD_OUTPUT_BUFFER_SIZE - 4));
-        }
+void SoftwareKeyboard::ExecuteInteractive() {}
 
-        complete = !config.text_check;
-        final_data = output_main;
+void SoftwareKeyboard::Execute() {}
 
-        if (complete) {
-            broker.PushNormalDataFromApplet(
-                std::make_shared<IStorage>(system, std::move(output_main)));
-            broker.SignalStateChanged();
-        } else {
-            broker.PushInteractiveDataFromApplet(
-                std::make_shared<IStorage>(system, std::move(output_sub)));
-        }
-    } else {
-        output_main[0] = 1;
-        complete = true;
-        broker.PushNormalDataFromApplet(std::make_shared<IStorage>(system, std::move(output_main)));
-        broker.SignalStateChanged();
-    }
-}
 } // namespace Service::AM::Applets

src/core/hle/service/am/applets/software_keyboard.h

@@ -4,59 +4,17 @@
 
 #pragma once
 
-#include <array>
-#include <string>
-#include <vector>
-
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/am/am.h"
+#include "core/hle/result.h"
 #include "core/hle/service/am/applets/applets.h"
 
-union ResultCode;
-
 namespace Core {
 class System;
 }
 
 namespace Service::AM::Applets {
 
-enum class KeysetDisable : u32 {
-    Space = 0x02,
-    Address = 0x04,
-    Percent = 0x08,
-    Slashes = 0x10,
-    Numbers = 0x40,
-    DownloadCode = 0x80,
-};
-
-struct KeyboardConfig {
-    INSERT_PADDING_BYTES(4);
-    std::array<char16_t, 9> submit_text;
-    u16_le left_symbol_key;
-    u16_le right_symbol_key;
-    INSERT_PADDING_BYTES(1);
-    KeysetDisable keyset_disable_bitmask;
-    u32_le initial_cursor_position;
-    std::array<char16_t, 65> header_text;
-    std::array<char16_t, 129> sub_text;
-    std::array<char16_t, 257> guide_text;
-    u32_le length_limit;
-    INSERT_PADDING_BYTES(4);
-    u32_le is_password;
-    INSERT_PADDING_BYTES(5);
-    bool utf_8;
-    bool draw_background;
-    u32_le initial_string_offset;
-    u32_le initial_string_size;
-    u32_le user_dictionary_offset;
-    u32_le user_dictionary_size;
-    bool text_check;
-    u64_le text_check_callback;
-};
-static_assert(sizeof(KeyboardConfig) == 0x3E0, "KeyboardConfig has incorrect size.");
-
 class SoftwareKeyboard final : public Applet {
 public:
     explicit SoftwareKeyboard(Core::System& system_,
@@ -70,16 +28,9 @@ public:
     void ExecuteInteractive() override;
     void Execute() override;
 
-    void WriteText(std::optional<std::u16string> text);
-
 private:
     const Core::Frontend::SoftwareKeyboardApplet& frontend;
 
-    KeyboardConfig config;
-    std::u16string initial_text;
-    bool complete = false;
-    bool is_inline = false;
-    std::vector<u8> final_data;
     Core::System& system;
 };
 

src/yuzu/applets/software_keyboard.cpp

@@ -2,152 +2,17 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
-#include <mutex>
-#include <QDialogButtonBox>
-#include <QFont>
-#include <QLabel>
-#include <QLineEdit>
-#include <QVBoxLayout>
-#include "core/hle/lock.h"
 #include "yuzu/applets/software_keyboard.h"
 #include "yuzu/main.h"
 
-QtSoftwareKeyboardValidator::QtSoftwareKeyboardValidator(
-    Core::Frontend::SoftwareKeyboardParameters parameters)
-    : parameters(std::move(parameters)) {}
+QtSoftwareKeyboardValidator::QtSoftwareKeyboardValidator() {}
 
-QValidator::State QtSoftwareKeyboardValidator::validate(QString& input, int& pos) const {
-    if (input.size() > static_cast<s64>(parameters.max_length)) {
-        return Invalid;
-    }
-    if (parameters.disable_space && input.contains(QLatin1Char{' '})) {
-        return Invalid;
-    }
-    if (parameters.disable_address && input.contains(QLatin1Char{'@'})) {
-        return Invalid;
-    }
-    if (parameters.disable_percent && input.contains(QLatin1Char{'%'})) {
-        return Invalid;
-    }
-    if (parameters.disable_slash &&
-        (input.contains(QLatin1Char{'/'}) || input.contains(QLatin1Char{'\\'}))) {
-        return Invalid;
-    }
-    if (parameters.disable_number &&
-        std::any_of(input.begin(), input.end(), [](QChar c) { return c.isDigit(); })) {
-        return Invalid;
-    }
+QValidator::State QtSoftwareKeyboardValidator::validate(QString& input, int& pos) const {}
 
-    if (parameters.disable_download_code && std::any_of(input.begin(), input.end(), [](QChar c) {
-            return c == QLatin1Char{'O'} || c == QLatin1Char{'I'};
-        })) {
-        return Invalid;
-    }
-
-    return Acceptable;
-}
-
-QtSoftwareKeyboardDialog::QtSoftwareKeyboardDialog(
-    QWidget* parent, Core::Frontend::SoftwareKeyboardParameters parameters_)
-    : QDialog(parent), parameters(std::move(parameters_)) {
-    layout = new QVBoxLayout;
-
-    header_label = new QLabel(QString::fromStdU16String(parameters.header_text));
-    header_label->setFont({header_label->font().family(), 11, QFont::Bold});
-    if (header_label->text().isEmpty())
-        header_label->setText(tr("Enter text:"));
-
-    sub_label = new QLabel(QString::fromStdU16String(parameters.sub_text));
-    sub_label->setFont({sub_label->font().family(), sub_label->font().pointSize(),
-                        sub_label->font().weight(), true});
-    sub_label->setHidden(parameters.sub_text.empty());
-
-    guide_label = new QLabel(QString::fromStdU16String(parameters.guide_text));
-    guide_label->setHidden(parameters.guide_text.empty());
-
-    length_label = new QLabel(QStringLiteral("0/%1").arg(parameters.max_length));
-    length_label->setAlignment(Qt::AlignRight);
-    length_label->setFont({length_label->font().family(), 8});
-
-    line_edit = new QLineEdit;
-    line_edit->setValidator(new QtSoftwareKeyboardValidator(parameters));
-    line_edit->setMaxLength(static_cast<int>(parameters.max_length));
-    line_edit->setText(QString::fromStdU16String(parameters.initial_text));
-    line_edit->setCursorPosition(
-        parameters.cursor_at_beginning ? 0 : static_cast<int>(parameters.initial_text.size()));
-    line_edit->setEchoMode(parameters.password ? QLineEdit::Password : QLineEdit::Normal);
-
-    connect(line_edit, &QLineEdit::textChanged, this, [this](const QString& text) {
-        length_label->setText(QStringLiteral("%1/%2").arg(text.size()).arg(parameters.max_length));
-    });
-
-    buttons = new QDialogButtonBox(QDialogButtonBox::Cancel);
-    if (parameters.submit_text.empty()) {
-        buttons->addButton(QDialogButtonBox::Ok);
-    } else {
-        buttons->addButton(QString::fromStdU16String(parameters.submit_text),
-                           QDialogButtonBox::AcceptRole);
-    }
-    connect(buttons, &QDialogButtonBox::accepted, this, &QtSoftwareKeyboardDialog::accept);
-    connect(buttons, &QDialogButtonBox::rejected, this, &QtSoftwareKeyboardDialog::reject);
-    layout->addWidget(header_label);
-    layout->addWidget(sub_label);
-    layout->addWidget(guide_label);
-    layout->addWidget(length_label);
-    layout->addWidget(line_edit);
-    layout->addWidget(buttons);
-    setLayout(layout);
-    setWindowTitle(tr("Software Keyboard"));
-}
+QtSoftwareKeyboardDialog::QtSoftwareKeyboardDialog(QWidget* parent) : QDialog(parent) {}
 
 QtSoftwareKeyboardDialog::~QtSoftwareKeyboardDialog() = default;
 
-void QtSoftwareKeyboardDialog::accept() {
-    text = line_edit->text().toStdU16String();
-    QDialog::accept();
-}
-
-void QtSoftwareKeyboardDialog::reject() {
-    text.clear();
-    QDialog::reject();
-}
-
-std::u16string QtSoftwareKeyboardDialog::GetText() const {
-    return text;
-}
-
-QtSoftwareKeyboard::QtSoftwareKeyboard(GMainWindow& main_window) {
-    connect(this, &QtSoftwareKeyboard::MainWindowGetText, &main_window,
-            &GMainWindow::SoftwareKeyboardGetText, Qt::QueuedConnection);
-    connect(this, &QtSoftwareKeyboard::MainWindowTextCheckDialog, &main_window,
-            &GMainWindow::SoftwareKeyboardInvokeCheckDialog, Qt::BlockingQueuedConnection);
-    connect(&main_window, &GMainWindow::SoftwareKeyboardFinishedText, this,
-            &QtSoftwareKeyboard::MainWindowFinishedText, Qt::QueuedConnection);
-}
+QtSoftwareKeyboard::QtSoftwareKeyboard(GMainWindow& main_window) {}
 
 QtSoftwareKeyboard::~QtSoftwareKeyboard() = default;
-
-void QtSoftwareKeyboard::RequestText(std::function<void(std::optional<std::u16string>)> out,
-                                     Core::Frontend::SoftwareKeyboardParameters parameters) const {
-    text_output = std::move(out);
-    emit MainWindowGetText(parameters);
-}
-
-void QtSoftwareKeyboard::SendTextCheckDialog(std::u16string error_message,
-                                             std::function<void()> finished_check_) const {
-    finished_check = std::move(finished_check_);
-    emit MainWindowTextCheckDialog(error_message);
-}
-
-void QtSoftwareKeyboard::MainWindowFinishedText(std::optional<std::u16string> text) {
-    // Acquire the HLE mutex
-    std::lock_guard lock{HLE::g_hle_lock};
-    text_output(std::move(text));
-}
-
-void QtSoftwareKeyboard::MainWindowFinishedCheckDialog() {
-    // Acquire the HLE mutex
-    std::lock_guard lock{HLE::g_hle_lock};
-    finished_check();
-}

src/yuzu/applets/software_keyboard.h

@@ -6,49 +6,23 @@
 
 #include <QDialog>
 #include <QValidator>
+
 #include "core/frontend/applets/software_keyboard.h"
 
 class GMainWindow;
-class QDialogButtonBox;
-class QLabel;
-class QLineEdit;
-class QVBoxLayout;
-class QtSoftwareKeyboard;
 
 class QtSoftwareKeyboardValidator final : public QValidator {
 public:
-    explicit QtSoftwareKeyboardValidator(Core::Frontend::SoftwareKeyboardParameters parameters);
+    explicit QtSoftwareKeyboardValidator();
     State validate(QString& input, int& pos) const override;
-
-private:
-    Core::Frontend::SoftwareKeyboardParameters parameters;
 };
 
 class QtSoftwareKeyboardDialog final : public QDialog {
     Q_OBJECT
 
 public:
-    QtSoftwareKeyboardDialog(QWidget* parent,
-                             Core::Frontend::SoftwareKeyboardParameters parameters);
+    QtSoftwareKeyboardDialog(QWidget* parent);
     ~QtSoftwareKeyboardDialog() override;
-
-    void accept() override;
-    void reject() override;
-
-    std::u16string GetText() const;
-
-private:
-    std::u16string text;
-
-    QDialogButtonBox* buttons;
-    QLabel* header_label;
-    QLabel* sub_label;
-    QLabel* guide_label;
-    QLabel* length_label;
-    QLineEdit* line_edit;
-    QVBoxLayout* layout;
-
-    Core::Frontend::SoftwareKeyboardParameters parameters;
 };
 
 class QtSoftwareKeyboard final : public QObject, public Core::Frontend::SoftwareKeyboardApplet {
@@ -57,20 +31,4 @@ class QtSoftwareKeyboard final : public QObject, public Core::Frontend::Software
 public:
     explicit QtSoftwareKeyboard(GMainWindow& parent);
     ~QtSoftwareKeyboard() override;
-
-    void RequestText(std::function<void(std::optional<std::u16string>)> out,
-                     Core::Frontend::SoftwareKeyboardParameters parameters) const override;
-    void SendTextCheckDialog(std::u16string error_message,
-                             std::function<void()> finished_check_) const override;
-
-signals:
-    void MainWindowGetText(Core::Frontend::SoftwareKeyboardParameters parameters) const;
-    void MainWindowTextCheckDialog(std::u16string error_message) const;
-
-private:
-    void MainWindowFinishedText(std::optional<std::u16string> text);
-    void MainWindowFinishedCheckDialog();
-
-    mutable std::function<void(std::optional<std::u16string>)> text_output;
-    mutable std::function<void()> finished_check;
 };

src/yuzu/main.cpp

@@ -414,27 +414,6 @@ void GMainWindow::ProfileSelectorSelectProfile() {
     emit ProfileSelectorFinishedSelection(uuid);
 }
 
-void GMainWindow::SoftwareKeyboardGetText(
-    const Core::Frontend::SoftwareKeyboardParameters& parameters) {
-    QtSoftwareKeyboardDialog dialog(this, parameters);
-    dialog.setWindowFlags(Qt::Dialog | Qt::CustomizeWindowHint | Qt::WindowStaysOnTopHint |
-                          Qt::WindowTitleHint | Qt::WindowSystemMenuHint |
-                          Qt::WindowCloseButtonHint);
-    dialog.setWindowModality(Qt::WindowModal);
-
-    if (dialog.exec() == QDialog::Rejected) {
-        emit SoftwareKeyboardFinishedText(std::nullopt);
-        return;
-    }
-
-    emit SoftwareKeyboardFinishedText(dialog.GetText());
-}
-
-void GMainWindow::SoftwareKeyboardInvokeCheckDialog(std::u16string error_message) {
-    QMessageBox::warning(this, tr("Text Check Failed"), QString::fromStdU16String(error_message));
-    emit SoftwareKeyboardFinishedCheckDialog();
-}
-
 void GMainWindow::WebBrowserOpenWebPage(std::string_view main_url, std::string_view additional_args,
                                         bool is_local) {
 #ifdef YUZU_USE_QT_WEB_ENGINE
@@ -2188,8 +2167,6 @@ void GMainWindow::OnStartGame() {
     emu_thread->SetRunning(true);
 
     qRegisterMetaType<Core::Frontend::ControllerParameters>("Core::Frontend::ControllerParameters");
-    qRegisterMetaType<Core::Frontend::SoftwareKeyboardParameters>(
-        "Core::Frontend::SoftwareKeyboardParameters");
     qRegisterMetaType<Core::System::ResultStatus>("Core::System::ResultStatus");
     qRegisterMetaType<std::string>("std::string");
     qRegisterMetaType<std::optional<std::u16string>>("std::optional<std::u16string>");

src/yuzu/main.h

@@ -128,9 +128,6 @@ signals:
 
     void ProfileSelectorFinishedSelection(std::optional<Common::UUID> uuid);
 
-    void SoftwareKeyboardFinishedText(std::optional<std::u16string> text);
-    void SoftwareKeyboardFinishedCheckDialog();
-
     void WebBrowserExtractOfflineRomFS();
     void WebBrowserClosed(Service::AM::Applets::WebExitReason exit_reason, std::string last_url);
 
@@ -141,8 +138,6 @@ public slots:
         const Core::Frontend::ControllerParameters& parameters);
     void ErrorDisplayDisplayError(QString body);
     void ProfileSelectorSelectProfile();
-    void SoftwareKeyboardGetText(const Core::Frontend::SoftwareKeyboardParameters& parameters);
-    void SoftwareKeyboardInvokeCheckDialog(std::u16string error_message);
     void WebBrowserOpenWebPage(std::string_view main_url, std::string_view additional_args,
                                bool is_local);
     void OnAppFocusStateChanged(Qt::ApplicationState state);