1 files changed, 901 insertions, 271 deletions
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index 15ac30f12a..56ab32a35c 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -4,19 +4,28 @@
 
 #include <algorithm>
 #include <memory>
+#include <thread>
 #include <utility>
-#include <QColorDialog>
 #include <QGridLayout>
+#include <QInputDialog>
 #include <QKeyEvent>
 #include <QMenu>
 #include <QMessageBox>
 #include <QTimer>
-#include "common/assert.h"
 #include "common/param_package.h"
+#include "core/core.h"
+#include "core/hle/service/hid/controllers/npad.h"
+#include "core/hle/service/hid/hid.h"
+#include "core/hle/service/sm/sm.h"
+#include "input_common/gcadapter/gc_poller.h"
 #include "input_common/main.h"
+#include "input_common/udp/udp.h"
 #include "ui_configure_input_player.h"
 #include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_input_player.h"
+#include "yuzu/configuration/configure_vibration.h"
+#include "yuzu/configuration/input_profiles.h"
+#include "yuzu/util/limitable_input_dialog.h"
 
 const std::array<std::string, ConfigureInputPlayer::ANALOG_SUB_BUTTONS_NUM>
     ConfigureInputPlayer::analog_sub_buttons{{
@@ -24,20 +33,74 @@ const std::array<std::string, ConfigureInputPlayer::ANALOG_SUB_BUTTONS_NUM>
         "down",
         "left",
         "right",
-        "modifier",
     }};
 
-static void LayerGridElements(QGridLayout* grid, QWidget* item, QWidget* onTopOf) {
-    const int index1 = grid->indexOf(item);
-    const int index2 = grid->indexOf(onTopOf);
-    int row, column, rowSpan, columnSpan;
-    grid->getItemPosition(index2, &row, &column, &rowSpan, &columnSpan);
-    grid->takeAt(index1);
-    grid->addWidget(item, row, column, rowSpan, columnSpan);
+namespace {
+
+constexpr std::size_t HANDHELD_INDEX = 8;
+
+void UpdateController(Settings::ControllerType controller_type, std::size_t npad_index,
+                      bool connected) {
+    Core::System& system{Core::System::GetInstance()};
+    if (!system.IsPoweredOn()) {
+        return;
+    }
+    Service::SM::ServiceManager& sm = system.ServiceManager();
+
+    auto& npad =
+        sm.GetService<Service::HID::Hid>("hid")
+            ->GetAppletResource()
+            ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad);
+
+    npad.UpdateControllerAt(npad.MapSettingsTypeToNPad(controller_type), npad_index, connected);
+}
+
+/// Maps the controller type combobox index to Controller Type enum
+constexpr Settings::ControllerType GetControllerTypeFromIndex(int index) {
+    switch (index) {
+    case 0:
+    default:
+        return Settings::ControllerType::ProController;
+    case 1:
+        return Settings::ControllerType::DualJoyconDetached;
+    case 2:
+        return Settings::ControllerType::LeftJoycon;
+    case 3:
+        return Settings::ControllerType::RightJoycon;
+    case 4:
+        return Settings::ControllerType::Handheld;
+    }
+}
+
+/// Maps the Controller Type enum to controller type combobox index
+constexpr int GetIndexFromControllerType(Settings::ControllerType type) {
+    switch (type) {
+    case Settings::ControllerType::ProController:
+    default:
+        return 0;
+    case Settings::ControllerType::DualJoyconDetached:
+        return 1;
+    case Settings::ControllerType::LeftJoycon:
+        return 2;
+    case Settings::ControllerType::RightJoycon:
+        return 3;
+    case Settings::ControllerType::Handheld:
+        return 4;
+    }
 }
 
-static QString GetKeyName(int key_code) {
+QString GetKeyName(int key_code) {
     switch (key_code) {
+    case Qt::LeftButton:
+        return QObject::tr("Click 0");
+    case Qt::RightButton:
+        return QObject::tr("Click 1");
+    case Qt::MiddleButton:
+        return QObject::tr("Click 2");
+    case Qt::BackButton:
+        return QObject::tr("Click 3");
+    case Qt::ForwardButton:
+        return QObject::tr("Click 4");
     case Qt::Key_Shift:
         return QObject::tr("Shift");
     case Qt::Key_Control:
@@ -51,18 +114,24 @@ static QString GetKeyName(int key_code) {
     }
 }
 
-static void SetAnalogButton(const Common::ParamPackage& input_param,
-                            Common::ParamPackage& analog_param, const std::string& button_name) {
-    if (analog_param.Get("engine", "") != "analog_from_button") {
+void SetAnalogParam(const Common::ParamPackage& input_param, Common::ParamPackage& analog_param,
+                    const std::string& button_name) {
+    // The poller returned a complete axis, so set all the buttons
+    if (input_param.Has("axis_x") && input_param.Has("axis_y")) {
+        analog_param = input_param;
+        return;
+    }
+    // Check if the current configuration has either no engine or an axis binding.
+    // Clears out the old binding and adds one with analog_from_button.
+    if (!analog_param.Has("engine") || analog_param.Has("axis_x") || analog_param.Has("axis_y")) {
         analog_param = {
             {"engine", "analog_from_button"},
-            {"modifier_scale", "0.5"},
         };
     }
     analog_param.Set(button_name, input_param.Serialize());
 }
 
-static QString ButtonToText(const Common::ParamPackage& param) {
+QString ButtonToText(const Common::ParamPackage& param) {
     if (!param.Has("engine")) {
         return QObject::tr("[not set]");
     }
@@ -71,6 +140,28 @@ static QString ButtonToText(const Common::ParamPackage& param) {
         return GetKeyName(param.Get("code", 0));
     }
 
+    if (param.Get("engine", "") == "gcpad") {
+        if (param.Has("axis")) {
+            const QString axis_str = QString::fromStdString(param.Get("axis", ""));
+            const QString direction_str = QString::fromStdString(param.Get("direction", ""));
+
+            return QObject::tr("GC Axis %1%2").arg(axis_str, direction_str);
+        }
+        if (param.Has("button")) {
+            const QString button_str = QString::number(int(std::log2(param.Get("button", 0))));
+            return QObject::tr("GC Button %1").arg(button_str);
+        }
+        return GetKeyName(param.Get("code", 0));
+    }
+
+    if (param.Get("engine", "") == "cemuhookudp") {
+        if (param.Has("pad_index")) {
+            const QString motion_str = QString::fromStdString(param.Get("pad_index", ""));
+            return QObject::tr("Motion %1").arg(motion_str);
+        }
+        return GetKeyName(param.Get("code", 0));
+    }
+
     if (param.Get("engine", "") == "sdl") {
         if (param.Has("hat")) {
             const QString hat_str = QString::fromStdString(param.Get("hat", ""));
@@ -98,7 +189,7 @@ static QString ButtonToText(const Common::ParamPackage& param) {
     return QObject::tr("[unknown]");
 }
 
-static QString AnalogToText(const Common::ParamPackage& param, const std::string& dir) {
+QString AnalogToText(const Common::ParamPackage& param, const std::string& dir) {
     if (!param.Has("engine")) {
         return QObject::tr("[not set]");
     }
@@ -127,24 +218,47 @@ static QString AnalogToText(const Common::ParamPackage& param, const std::string
         return {};
     }
 
+    if (param.Get("engine", "") == "gcpad") {
+        if (dir == "modifier") {
+            return QObject::tr("[unused]");
+        }
+
+        if (dir == "left" || dir == "right") {
+            const QString axis_x_str = QString::fromStdString(param.Get("axis_x", ""));
+
+            return QObject::tr("GC Axis %1").arg(axis_x_str);
+        }
+
+        if (dir == "up" || dir == "down") {
+            const QString axis_y_str = QString::fromStdString(param.Get("axis_y", ""));
+
+            return QObject::tr("GC Axis %1").arg(axis_y_str);
+        }
+
+        return {};
+    }
     return QObject::tr("[unknown]");
 }
-
-ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_index, bool debug)
-    : QDialog(parent), ui(std::make_unique<Ui::ConfigureInputPlayer>()), player_index(player_index),
-      debug(debug), timeout_timer(std::make_unique<QTimer>()),
-      poll_timer(std::make_unique<QTimer>()) {
+} // namespace
+
+ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_index,
+                                           QWidget* bottom_row,
+                                           InputCommon::InputSubsystem* input_subsystem_,
+                                           InputProfiles* profiles_, bool debug)
+    : QWidget(parent), ui(std::make_unique<Ui::ConfigureInputPlayer>()), player_index(player_index),
+      debug(debug), input_subsystem{input_subsystem_}, profiles(profiles_),
+      timeout_timer(std::make_unique<QTimer>()), poll_timer(std::make_unique<QTimer>()),
+      bottom_row(bottom_row) {
     ui->setupUi(this);
+
     setFocusPolicy(Qt::ClickFocus);
 
     button_map = {
-        ui->buttonA,          ui->buttonB,        ui->buttonX,           ui->buttonY,
-        ui->buttonLStick,     ui->buttonRStick,   ui->buttonL,           ui->buttonR,
-        ui->buttonZL,         ui->buttonZR,       ui->buttonPlus,        ui->buttonMinus,
-        ui->buttonDpadLeft,   ui->buttonDpadUp,   ui->buttonDpadRight,   ui->buttonDpadDown,
-        ui->buttonLStickLeft, ui->buttonLStickUp, ui->buttonLStickRight, ui->buttonLStickDown,
-        ui->buttonRStickLeft, ui->buttonRStickUp, ui->buttonRStickRight, ui->buttonRStickDown,
-        ui->buttonSL,         ui->buttonSR,       ui->buttonHome,        ui->buttonScreenshot,
+        ui->buttonA,        ui->buttonB,      ui->buttonX,         ui->buttonY,
+        ui->buttonLStick,   ui->buttonRStick, ui->buttonL,         ui->buttonR,
+        ui->buttonZL,       ui->buttonZR,     ui->buttonPlus,      ui->buttonMinus,
+        ui->buttonDpadLeft, ui->buttonDpadUp, ui->buttonDpadRight, ui->buttonDpadDown,
+        ui->buttonSL,       ui->buttonSR,     ui->buttonHome,      ui->buttonScreenshot,
     };
 
     analog_map_buttons = {{
@@ -153,219 +267,292 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
             ui->buttonLStickDown,
             ui->buttonLStickLeft,
             ui->buttonLStickRight,
-            ui->buttonLStickMod,
         },
         {
             ui->buttonRStickUp,
             ui->buttonRStickDown,
             ui->buttonRStickLeft,
             ui->buttonRStickRight,
-            ui->buttonRStickMod,
         },
     }};
 
-    debug_hidden = {
-        ui->buttonSL,         ui->labelSL,
-        ui->buttonSR,         ui->labelSR,
-        ui->buttonLStick,     ui->labelLStickPressed,
-        ui->buttonRStick,     ui->labelRStickPressed,
-        ui->buttonHome,       ui->labelHome,
-        ui->buttonScreenshot, ui->labelScreenshot,
+    motion_map = {
+        ui->buttonMotionLeft,
+        ui->buttonMotionRight,
     };
 
-    auto layout = Settings::values.players[player_index].type;
-    if (debug)
-        layout = Settings::ControllerType::DualJoycon;
-
-    switch (layout) {
-    case Settings::ControllerType::ProController:
-    case Settings::ControllerType::DualJoycon:
-        layout_hidden = {
-            ui->buttonSL,
-            ui->labelSL,
-            ui->buttonSR,
-            ui->labelSR,
-        };
-        break;
-    case Settings::ControllerType::LeftJoycon:
-        layout_hidden = {
-            ui->right_body_button,
-            ui->right_buttons_button,
-            ui->right_body_label,
-            ui->right_buttons_label,
-            ui->buttonR,
-            ui->labelR,
-            ui->buttonZR,
-            ui->labelZR,
-            ui->labelHome,
-            ui->buttonHome,
-            ui->buttonPlus,
-            ui->labelPlus,
-            ui->RStick,
-            ui->faceButtons,
-        };
-        break;
-    case Settings::ControllerType::RightJoycon:
-        layout_hidden = {
-            ui->left_body_button, ui->left_buttons_button,
-            ui->left_body_label,  ui->left_buttons_label,
-            ui->buttonL,          ui->labelL,
-            ui->buttonZL,         ui->labelZL,
-            ui->labelScreenshot,  ui->buttonScreenshot,
-            ui->buttonMinus,      ui->labelMinus,
-            ui->LStick,           ui->Dpad,
-        };
-        break;
-    }
+    analog_map_deadzone_label = {ui->labelLStickDeadzone, ui->labelRStickDeadzone};
+    analog_map_deadzone_slider = {ui->sliderLStickDeadzone, ui->sliderRStickDeadzone};
+    analog_map_modifier_groupbox = {ui->buttonLStickModGroup, ui->buttonRStickModGroup};
+    analog_map_modifier_button = {ui->buttonLStickMod, ui->buttonRStickMod};
+    analog_map_modifier_label = {ui->labelLStickModifierRange, ui->labelRStickModifierRange};
+    analog_map_modifier_slider = {ui->sliderLStickModifierRange, ui->sliderRStickModifierRange};
+    analog_map_range_groupbox = {ui->buttonLStickRangeGroup, ui->buttonRStickRangeGroup};
+    analog_map_range_spinbox = {ui->spinboxLStickRange, ui->spinboxRStickRange};
+
+    const auto ConfigureButtonClick = [&](QPushButton* button, Common::ParamPackage* param,
+                                          int default_val, InputCommon::Polling::DeviceType type) {
+        connect(button, &QPushButton::clicked, [=, this] {
+            HandleClick(
+                button,
+                [=, this](Common::ParamPackage params) {
+                    // Workaround for ZL & ZR for analog triggers like on XBOX
+                    // controllers. Analog triggers (from controllers like the XBOX
+                    // controller) would not work due to a different range of their
+                    // signals (from 0 to 255 on analog triggers instead of -32768 to
+                    // 32768 on analog joysticks). The SDL driver misinterprets analog
+                    // triggers as analog joysticks.
+                    // TODO: reinterpret the signal range for analog triggers to map the
+                    // values correctly. This is required for the correct emulation of
+                    // the analog triggers of the GameCube controller.
+                    if (button == ui->buttonZL || button == ui->buttonZR) {
+                        params.Set("direction", "+");
+                        params.Set("threshold", "0.5");
+                    }
+                    *param = std::move(params);
+                },
+                type);
+        });
+    };
 
-    if (debug || layout == Settings::ControllerType::ProController) {
-        ui->controller_color->hide();
-    } else {
-        if (layout == Settings::ControllerType::LeftJoycon ||
-            layout == Settings::ControllerType::RightJoycon) {
-            ui->horizontalSpacer_4->setGeometry({0, 0, 0, 0});
+    for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; ++button_id) {
+        auto* const button = button_map[button_id];
 
-            LayerGridElements(ui->buttons, ui->shoulderButtons, ui->Dpad);
-            LayerGridElements(ui->buttons, ui->misc, ui->RStick);
-            LayerGridElements(ui->buttons, ui->Dpad, ui->faceButtons);
-            LayerGridElements(ui->buttons, ui->RStick, ui->LStick);
+        if (button == nullptr) {
+            continue;
         }
-    }
 
-    for (auto* widget : layout_hidden)
-        widget->setVisible(false);
+        ConfigureButtonClick(button_map[button_id], &buttons_param[button_id],
+                             Config::default_buttons[button_id],
+                             InputCommon::Polling::DeviceType::Button);
 
-    analog_map_stick = {ui->buttonLStickAnalog, ui->buttonRStickAnalog};
-    analog_map_deadzone = {ui->sliderLStickDeadzone, ui->sliderRStickDeadzone};
-    analog_map_deadzone_label = {ui->labelLStickDeadzone, ui->labelRStickDeadzone};
+        button->setContextMenuPolicy(Qt::CustomContextMenu);
 
-    for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; button_id++) {
-        auto* const button = button_map[button_id];
+        connect(button, &QPushButton::customContextMenuRequested,
+                [=, this](const QPoint& menu_location) {
+                    QMenu context_menu;
+                    context_menu.addAction(tr("Clear"), [&] {
+                        buttons_param[button_id].Clear();
+                        button_map[button_id]->setText(tr("[not set]"));
+                    });
+                    context_menu.exec(button_map[button_id]->mapToGlobal(menu_location));
+                });
+    }
+
+    for (int motion_id = 0; motion_id < Settings::NativeMotion::NumMotions; ++motion_id) {
+        auto* const button = motion_map[motion_id];
         if (button == nullptr) {
             continue;
         }
 
+        ConfigureButtonClick(motion_map[motion_id], &motions_param[motion_id],
+                             Config::default_motions[motion_id],
+                             InputCommon::Polling::DeviceType::Motion);
+
         button->setContextMenuPolicy(Qt::CustomContextMenu);
-        connect(button, &QPushButton::clicked, [=] {
-            HandleClick(button_map[button_id],
-                        [=](Common::ParamPackage params) {
-                            // Workaround for ZL & ZR for analog triggers like on XBOX controllors.
-                            // Analog triggers (from controllers like the XBOX controller) would not
-                            // work due to a different range of their signals (from 0 to 255 on
-                            // analog triggers instead of -32768 to 32768 on analog joysticks). The
-                            // SDL driver misinterprets analog triggers as analog joysticks.
-                            // TODO: reinterpret the signal range for analog triggers to map the
-                            // values correctly. This is required for the correct emulation of the
-                            // analog triggers of the GameCube controller.
-                            if (button_id == Settings::NativeButton::ZL ||
-                                button_id == Settings::NativeButton::ZR) {
-                                params.Set("direction", "+");
-                                params.Set("threshold", "0.5");
-                            }
-                            buttons_param[button_id] = std::move(params);
-                        },
-                        InputCommon::Polling::DeviceType::Button);
-        });
-        connect(button, &QPushButton::customContextMenuRequested, [=](const QPoint& menu_location) {
-            QMenu context_menu;
-            context_menu.addAction(tr("Clear"), [&] {
-                buttons_param[button_id].Clear();
-                button_map[button_id]->setText(tr("[not set]"));
-            });
-            context_menu.addAction(tr("Restore Default"), [&] {
-                buttons_param[button_id] = Common::ParamPackage{
-                    InputCommon::GenerateKeyboardParam(Config::default_buttons[button_id])};
-                button_map[button_id]->setText(ButtonToText(buttons_param[button_id]));
-            });
-            context_menu.exec(button_map[button_id]->mapToGlobal(menu_location));
-        });
+
+        connect(button, &QPushButton::customContextMenuRequested,
+                [=, this](const QPoint& menu_location) {
+                    QMenu context_menu;
+                    context_menu.addAction(tr("Clear"), [&] {
+                        motions_param[motion_id].Clear();
+                        motion_map[motion_id]->setText(tr("[not set]"));
+                    });
+                    context_menu.exec(motion_map[motion_id]->mapToGlobal(menu_location));
+                });
     }
 
-    for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; analog_id++) {
-        for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; sub_button_id++) {
+    for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; ++analog_id) {
+        for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; ++sub_button_id) {
             auto* const analog_button = analog_map_buttons[analog_id][sub_button_id];
+
             if (analog_button == nullptr) {
                 continue;
             }
 
-            analog_button->setContextMenuPolicy(Qt::CustomContextMenu);
-            connect(analog_button, &QPushButton::clicked, [=]() {
-                HandleClick(analog_map_buttons[analog_id][sub_button_id],
-                            [=](const Common::ParamPackage& params) {
-                                SetAnalogButton(params, analogs_param[analog_id],
-                                                analog_sub_buttons[sub_button_id]);
-                            },
-                            InputCommon::Polling::DeviceType::Button);
+            connect(analog_button, &QPushButton::clicked, [=, this] {
+                if (!map_analog_stick_accepted) {
+                    map_analog_stick_accepted =
+                        QMessageBox::information(
+                            this, tr("Map Analog Stick"),
+                            tr("After pressing OK, first move your joystick horizontally, and then "
+                               "vertically.\nTo invert the axes, first move your joystick "
+                               "vertically, and then horizontally."),
+                            QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok;
+                    if (!map_analog_stick_accepted) {
+                        return;
+                    }
+                }
+                HandleClick(
+                    analog_map_buttons[analog_id][sub_button_id],
+                    [=, this](const Common::ParamPackage& params) {
+                        SetAnalogParam(params, analogs_param[analog_id],
+                                       analog_sub_buttons[sub_button_id]);
+                    },
+                    InputCommon::Polling::DeviceType::AnalogPreferred);
             });
+
+            analog_button->setContextMenuPolicy(Qt::CustomContextMenu);
+
             connect(analog_button, &QPushButton::customContextMenuRequested,
-                    [=](const QPoint& menu_location) {
+                    [=, this](const QPoint& menu_location) {
                         QMenu context_menu;
                         context_menu.addAction(tr("Clear"), [&] {
-                            analogs_param[analog_id].Erase(analog_sub_buttons[sub_button_id]);
+                            analogs_param[analog_id].Clear();
                             analog_map_buttons[analog_id][sub_button_id]->setText(tr("[not set]"));
                         });
-                        context_menu.addAction(tr("Restore Default"), [&] {
-                            Common::ParamPackage params{InputCommon::GenerateKeyboardParam(
-                                Config::default_analogs[analog_id][sub_button_id])};
-                            SetAnalogButton(params, analogs_param[analog_id],
-                                            analog_sub_buttons[sub_button_id]);
-                            analog_map_buttons[analog_id][sub_button_id]->setText(AnalogToText(
-                                analogs_param[analog_id], analog_sub_buttons[sub_button_id]));
-                        });
                         context_menu.exec(analog_map_buttons[analog_id][sub_button_id]->mapToGlobal(
                             menu_location));
                     });
         }
-        connect(analog_map_stick[analog_id], &QPushButton::clicked, [=] {
-            if (QMessageBox::information(
-                    this, tr("Information"),
-                    tr("After pressing OK, first move your joystick horizontally, "
-                       "and then vertically."),
-                    QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok) {
-                HandleClick(
-                    analog_map_stick[analog_id],
-                    [=](const Common::ParamPackage& params) { analogs_param[analog_id] = params; },
-                    InputCommon::Polling::DeviceType::Analog);
-            }
+
+        // Handle clicks for the modifier buttons as well.
+        connect(analog_map_modifier_button[analog_id], &QPushButton::clicked, [=, this] {
+            HandleClick(
+                analog_map_modifier_button[analog_id],
+                [=, this](const Common::ParamPackage& params) {
+                    analogs_param[analog_id].Set("modifier", params.Serialize());
+                },
+                InputCommon::Polling::DeviceType::Button);
         });
-        connect(analog_map_deadzone[analog_id], &QSlider::valueChanged, [=] {
-            const float deadzone = analog_map_deadzone[analog_id]->value() / 100.0f;
-            analog_map_deadzone_label[analog_id]->setText(tr("Deadzone: %1").arg(deadzone));
-            analogs_param[analog_id].Set("deadzone", deadzone);
+
+        analog_map_modifier_button[analog_id]->setContextMenuPolicy(Qt::CustomContextMenu);
+
+        connect(analog_map_modifier_button[analog_id], &QPushButton::customContextMenuRequested,
+                [=, this](const QPoint& menu_location) {
+                    QMenu context_menu;
+                    context_menu.addAction(tr("Clear"), [&] {
+                        analogs_param[analog_id].Set("modifier", "");
+                        analog_map_modifier_button[analog_id]->setText(tr("[not set]"));
+                    });
+                    context_menu.exec(
+                        analog_map_modifier_button[analog_id]->mapToGlobal(menu_location));
+                });
+
+        connect(analog_map_range_spinbox[analog_id], qOverload<int>(&QSpinBox::valueChanged),
+                [=, this] {
+                    const auto spinbox_value = analog_map_range_spinbox[analog_id]->value();
+                    analogs_param[analog_id].Set("range", spinbox_value / 100.0f);
+                });
+
+        connect(analog_map_deadzone_slider[analog_id], &QSlider::valueChanged, [=, this] {
+            const auto slider_value = analog_map_deadzone_slider[analog_id]->value();
+            analog_map_deadzone_label[analog_id]->setText(tr("Deadzone: %1%").arg(slider_value));
+            analogs_param[analog_id].Set("deadzone", slider_value / 100.0f);
+        });
+
+        connect(analog_map_modifier_slider[analog_id], &QSlider::valueChanged, [=, this] {
+            const auto slider_value = analog_map_modifier_slider[analog_id]->value();
+            analog_map_modifier_label[analog_id]->setText(
+                tr("Modifier Range: %1%").arg(slider_value));
+            analogs_param[analog_id].Set("modifier_scale", slider_value / 100.0f);
         });
     }
 
-    connect(ui->buttonClearAll, &QPushButton::clicked, [this] { ClearAll(); });
-    connect(ui->buttonRestoreDefaults, &QPushButton::clicked, [this] { RestoreDefaults(); });
+    // Player Connected checkbox
+    connect(ui->groupConnectedController, &QGroupBox::toggled,
+            [this](bool checked) { emit Connected(checked); });
+
+    // Set up controller type. Only Player 1 can choose Handheld.
+    ui->comboControllerType->clear();
+
+    QStringList controller_types = {
+        tr("Pro Controller"),
+        tr("Dual Joycons"),
+        tr("Left Joycon"),
+        tr("Right Joycon"),
+    };
+
+    if (player_index == 0) {
+        controller_types.append(tr("Handheld"));
+        connect(ui->comboControllerType, qOverload<int>(&QComboBox::currentIndexChanged),
+                [this](int index) {
+                    emit HandheldStateChanged(GetControllerTypeFromIndex(index) ==
+                                              Settings::ControllerType::Handheld);
+                });
+    }
+
+    if (debug || player_index == 9) {
+        ui->groupConnectedController->setCheckable(false);
+    }
+
+    // The Debug Controller can only choose the Pro Controller.
+    if (debug) {
+        ui->buttonScreenshot->setEnabled(false);
+        ui->buttonHome->setEnabled(false);
+        QStringList debug_controller_types = {
+            tr("Pro Controller"),
+        };
+        ui->comboControllerType->addItems(debug_controller_types);
+    } else {
+        ui->comboControllerType->addItems(controller_types);
+    }
+
+    UpdateControllerIcon();
+    UpdateControllerAvailableButtons();
+    UpdateMotionButtons();
+    connect(ui->comboControllerType, qOverload<int>(&QComboBox::currentIndexChanged), [this](int) {
+        UpdateControllerIcon();
+        UpdateControllerAvailableButtons();
+        UpdateMotionButtons();
+    });
+
+    connect(ui->comboDevices, qOverload<int>(&QComboBox::activated), this,
+            &ConfigureInputPlayer::UpdateMappingWithDefaults);
+
+    ui->comboDevices->setCurrentIndex(-1);
+
+    ui->buttonRefreshDevices->setIcon(QIcon::fromTheme(QStringLiteral("view-refresh")));
+    connect(ui->buttonRefreshDevices, &QPushButton::clicked,
+            [this] { emit RefreshInputDevices(); });
 
     timeout_timer->setSingleShot(true);
     connect(timeout_timer.get(), &QTimer::timeout, [this] { SetPollingResult({}, true); });
 
     connect(poll_timer.get(), &QTimer::timeout, [this] {
         Common::ParamPackage params;
+        if (input_subsystem->GetGCButtons()->IsPolling()) {
+            params = input_subsystem->GetGCButtons()->GetNextInput();
+            if (params.Has("engine") && IsInputAcceptable(params)) {
+                SetPollingResult(params, false);
+                return;
+            }
+        }
+        if (input_subsystem->GetGCAnalogs()->IsPolling()) {
+            params = input_subsystem->GetGCAnalogs()->GetNextInput();
+            if (params.Has("engine") && IsInputAcceptable(params)) {
+                SetPollingResult(params, false);
+                return;
+            }
+        }
+        if (input_subsystem->GetUDPMotions()->IsPolling()) {
+            params = input_subsystem->GetUDPMotions()->GetNextInput();
+            if (params.Has("engine")) {
+                SetPollingResult(params, false);
+                return;
+            }
+        }
         for (auto& poller : device_pollers) {
             params = poller->GetNextInput();
-            if (params.Has("engine")) {
+            if (params.Has("engine") && IsInputAcceptable(params)) {
                 SetPollingResult(params, false);
                 return;
             }
         }
     });
 
-    controller_color_buttons = {
-        ui->left_body_button,
-        ui->left_buttons_button,
-        ui->right_body_button,
-        ui->right_buttons_button,
-    };
+    UpdateInputProfiles();
 
-    for (std::size_t i = 0; i < controller_color_buttons.size(); ++i) {
-        connect(controller_color_buttons[i], &QPushButton::clicked, this,
-                [this, i] { OnControllerButtonClick(static_cast<int>(i)); });
-    }
+    connect(ui->buttonProfilesNew, &QPushButton::clicked, this,
+            &ConfigureInputPlayer::CreateProfile);
+    connect(ui->buttonProfilesDelete, &QPushButton::clicked, this,
+            &ConfigureInputPlayer::DeleteProfile);
+    connect(ui->comboProfiles, qOverload<int>(&QComboBox::activated), this,
+            &ConfigureInputPlayer::LoadProfile);
+    connect(ui->buttonProfilesSave, &QPushButton::clicked, this,
+            &ConfigureInputPlayer::SaveProfile);
 
     LoadConfiguration();
-    resize(0, 0);
 
     // TODO(wwylele): enable this when we actually emulate it
     ui->buttonHome->setEnabled(false);
@@ -374,27 +561,72 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
 ConfigureInputPlayer::~ConfigureInputPlayer() = default;
 
 void ConfigureInputPlayer::ApplyConfiguration() {
-    auto& buttons =
-        debug ? Settings::values.debug_pad_buttons : Settings::values.players[player_index].buttons;
-    auto& analogs =
-        debug ? Settings::values.debug_pad_analogs : Settings::values.players[player_index].analogs;
+    auto& player = Settings::values.players.GetValue()[player_index];
+    auto& buttons = debug ? Settings::values.debug_pad_buttons : player.buttons;
+    auto& analogs = debug ? Settings::values.debug_pad_analogs : player.analogs;
 
     std::transform(buttons_param.begin(), buttons_param.end(), buttons.begin(),
                    [](const Common::ParamPackage& param) { return param.Serialize(); });
     std::transform(analogs_param.begin(), analogs_param.end(), analogs.begin(),
                    [](const Common::ParamPackage& param) { return param.Serialize(); });
 
-    if (debug)
+    if (debug) {
+        return;
+    }
+
+    auto& motions = player.motions;
+
+    std::transform(motions_param.begin(), motions_param.end(), motions.begin(),
+                   [](const Common::ParamPackage& param) { return param.Serialize(); });
+
+    const auto controller_type =
+        GetControllerTypeFromIndex(ui->comboControllerType->currentIndex());
+    const auto player_connected = ui->groupConnectedController->isChecked() &&
+                                  controller_type != Settings::ControllerType::Handheld;
+
+    if (player.controller_type == controller_type && player.connected == player_connected) {
+        // Set vibration devices in the event that the input device has changed.
+        ConfigureVibration::SetVibrationDevices(player_index);
+        return;
+    }
+
+    // Disconnect the controller first.
+    UpdateController(controller_type, player_index, false);
+
+    player.controller_type = controller_type;
+    player.connected = player_connected;
+
+    ConfigureVibration::SetVibrationDevices(player_index);
+
+    // Handheld
+    if (player_index == 0) {
+        auto& handheld = Settings::values.players.GetValue()[HANDHELD_INDEX];
+        if (controller_type == Settings::ControllerType::Handheld) {
+            handheld = player;
+        }
+        handheld.connected = ui->groupConnectedController->isChecked() &&
+                             controller_type == Settings::ControllerType::Handheld;
+        UpdateController(Settings::ControllerType::Handheld, HANDHELD_INDEX, handheld.connected);
+    }
+
+    if (!player.connected) {
         return;
+    }
 
-    std::array<u32, 4> colors{};
-    std::transform(controller_colors.begin(), controller_colors.end(), colors.begin(),
-                   [](QColor color) { return color.rgb(); });
+    // This emulates a delay between disconnecting and reconnecting controllers as some games
+    // do not respond to a change in controller type if it was instantaneous.
+    using namespace std::chrono_literals;
+    std::this_thread::sleep_for(20ms);
 
-    Settings::values.players[player_index].body_color_left = colors[0];
-    Settings::values.players[player_index].button_color_left = colors[1];
-    Settings::values.players[player_index].body_color_right = colors[2];
-    Settings::values.players[player_index].button_color_right = colors[3];
+    UpdateController(controller_type, player_index, player_connected);
+}
+
+void ConfigureInputPlayer::showEvent(QShowEvent* event) {
+    if (bottom_row == nullptr) {
+        return;
+    }
+    QWidget::showEvent(event);
+    ui->main->addWidget(bottom_row);
 }
 
 void ConfigureInputPlayer::changeEvent(QEvent* event) {
@@ -402,24 +634,16 @@ void ConfigureInputPlayer::changeEvent(QEvent* event) {
         RetranslateUI();
     }
 
-    QDialog::changeEvent(event);
+    QWidget::changeEvent(event);
 }
 
 void ConfigureInputPlayer::RetranslateUI() {
     ui->retranslateUi(this);
-    UpdateButtonLabels();
-}
-
-void ConfigureInputPlayer::OnControllerButtonClick(int i) {
-    const QColor new_bg_color = QColorDialog::getColor(controller_colors[i]);
-    if (!new_bg_color.isValid())
-        return;
-    controller_colors[i] = new_bg_color;
-    controller_color_buttons[i]->setStyleSheet(
-        QStringLiteral("QPushButton { background-color: %1 }").arg(controller_colors[i].name()));
+    UpdateUI();
 }
 
 void ConfigureInputPlayer::LoadConfiguration() {
+    auto& player = Settings::values.players.GetValue()[player_index];
     if (debug) {
         std::transform(Settings::values.debug_pad_buttons.begin(),
                        Settings::values.debug_pad_buttons.end(), buttons_param.begin(),
@@ -428,66 +652,109 @@ void ConfigureInputPlayer::LoadConfiguration() {
                        Settings::values.debug_pad_analogs.end(), analogs_param.begin(),
                        [](const std::string& str) { return Common::ParamPackage(str); });
     } else {
-        std::transform(Settings::values.players[player_index].buttons.begin(),
-                       Settings::values.players[player_index].buttons.end(), buttons_param.begin(),
+        std::transform(player.buttons.begin(), player.buttons.end(), buttons_param.begin(),
+                       [](const std::string& str) { return Common::ParamPackage(str); });
+        std::transform(player.analogs.begin(), player.analogs.end(), analogs_param.begin(),
                        [](const std::string& str) { return Common::ParamPackage(str); });
-        std::transform(Settings::values.players[player_index].analogs.begin(),
-                       Settings::values.players[player_index].analogs.end(), analogs_param.begin(),
+        std::transform(player.motions.begin(), player.motions.end(), motions_param.begin(),
                        [](const std::string& str) { return Common::ParamPackage(str); });
     }
 
-    UpdateButtonLabels();
+    UpdateUI();
+    UpdateInputDeviceCombobox();
 
-    if (debug)
+    if (debug) {
         return;
+    }
 
-    std::array<u32, 4> colors = {
-        Settings::values.players[player_index].body_color_left,
-        Settings::values.players[player_index].button_color_left,
-        Settings::values.players[player_index].body_color_right,
-        Settings::values.players[player_index].button_color_right,
-    };
+    ui->comboControllerType->setCurrentIndex(static_cast<int>(player.controller_type));
+    ui->groupConnectedController->setChecked(
+        player.connected ||
+        (player_index == 0 && Settings::values.players.GetValue()[HANDHELD_INDEX].connected));
+}
 
-    std::transform(colors.begin(), colors.end(), controller_colors.begin(),
-                   [](u32 rgb) { return QColor::fromRgb(rgb); });
+void ConfigureInputPlayer::ConnectPlayer(bool connected) {
+    ui->groupConnectedController->setChecked(connected);
+}
 
-    for (std::size_t i = 0; i < colors.size(); ++i) {
-        controller_color_buttons[i]->setStyleSheet(
-            QStringLiteral("QPushButton { background-color: %1 }")
-                .arg(controller_colors[i].name()));
+void ConfigureInputPlayer::UpdateInputDeviceCombobox() {
+    // Skip input device persistence if "Input Devices" is set to "Any".
+    if (ui->comboDevices->currentIndex() == 0) {
+        UpdateInputDevices();
+        return;
     }
-}
 
-void ConfigureInputPlayer::RestoreDefaults() {
-    for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; button_id++) {
-        buttons_param[button_id] = Common::ParamPackage{
-            InputCommon::GenerateKeyboardParam(Config::default_buttons[button_id])};
+    // Find the first button that isn't empty.
+    const auto button_param =
+        std::find_if(buttons_param.begin(), buttons_param.end(),
+                     [](const Common::ParamPackage param) { return param.Has("engine"); });
+    const bool buttons_empty = button_param == buttons_param.end();
+
+    const auto current_engine = button_param->Get("engine", "");
+    const auto current_guid = button_param->Get("guid", "");
+    const auto current_port = button_param->Get("port", "");
+
+    const bool is_keyboard_mouse = current_engine == "keyboard" || current_engine == "mouse";
+
+    UpdateInputDevices();
+
+    if (buttons_empty) {
+        return;
     }
 
-    for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; analog_id++) {
-        for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; sub_button_id++) {
-            Common::ParamPackage params{InputCommon::GenerateKeyboardParam(
-                Config::default_analogs[analog_id][sub_button_id])};
-            SetAnalogButton(params, analogs_param[analog_id], analog_sub_buttons[sub_button_id]);
+    const bool all_one_device =
+        std::all_of(buttons_param.begin(), buttons_param.end(),
+                    [current_engine, current_guid, current_port,
+                     is_keyboard_mouse](const Common::ParamPackage param) {
+                        if (is_keyboard_mouse) {
+                            return !param.Has("engine") || param.Get("engine", "") == "keyboard" ||
+                                   param.Get("engine", "") == "mouse";
+                        }
+                        return !param.Has("engine") || (param.Get("engine", "") == current_engine &&
+                                                        param.Get("guid", "") == current_guid &&
+                                                        param.Get("port", "") == current_port);
+                    });
+
+    if (all_one_device) {
+        if (is_keyboard_mouse) {
+            ui->comboDevices->setCurrentIndex(1);
+            return;
         }
+        const auto devices_it = std::find_if(
+            input_devices.begin(), input_devices.end(),
+            [current_engine, current_guid, current_port](const Common::ParamPackage param) {
+                return param.Get("class", "") == current_engine &&
+                       param.Get("guid", "") == current_guid &&
+                       param.Get("port", "") == current_port;
+            });
+        const int device_index =
+            devices_it != input_devices.end()
+                ? static_cast<int>(std::distance(input_devices.begin(), devices_it))
+                : 0;
+        ui->comboDevices->setCurrentIndex(device_index);
+    } else {
+        ui->comboDevices->setCurrentIndex(0);
     }
-    UpdateButtonLabels();
+}
+
+void ConfigureInputPlayer::RestoreDefaults() {
+    UpdateMappingWithDefaults();
 }
 
 void ConfigureInputPlayer::ClearAll() {
-    for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; button_id++) {
+    for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; ++button_id) {
         const auto* const button = button_map[button_id];
-        if (button == nullptr || !button->isEnabled()) {
+        if (button == nullptr) {
             continue;
         }
 
         buttons_param[button_id].Clear();
     }
 
-    for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; analog_id++) {
-        for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; sub_button_id++) {
+    for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; ++analog_id) {
+        for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; ++sub_button_id) {
             const auto* const analog_button = analog_map_buttons[analog_id][sub_button_id];
-            if (analog_button == nullptr || !analog_button->isEnabled()) {
+            if (analog_button == nullptr) {
                 continue;
             }
 
@@ -495,16 +762,30 @@ void ConfigureInputPlayer::ClearAll() {
         }
     }
 
-    UpdateButtonLabels();
+    for (int motion_id = 0; motion_id < Settings::NativeMotion::NumMotions; ++motion_id) {
+        const auto* const motion_button = motion_map[motion_id];
+        if (motion_button == nullptr) {
+            continue;
+        }
+
+        motions_param[motion_id].Clear();
+    }
+
+    UpdateUI();
+    UpdateInputDevices();
 }
 
-void ConfigureInputPlayer::UpdateButtonLabels() {
-    for (int button = 0; button < Settings::NativeButton::NumButtons; button++) {
+void ConfigureInputPlayer::UpdateUI() {
+    for (int button = 0; button < Settings::NativeButton::NumButtons; ++button) {
         button_map[button]->setText(ButtonToText(buttons_param[button]));
     }
 
-    for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; analog_id++) {
-        for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; sub_button_id++) {
+    for (int motion_id = 0; motion_id < Settings::NativeMotion::NumMotions; ++motion_id) {
+        motion_map[motion_id]->setText(ButtonToText(motions_param[motion_id]));
+    }
+
+    for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; ++analog_id) {
+        for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; ++sub_button_id) {
             auto* const analog_button = analog_map_buttons[analog_id][sub_button_id];
 
             if (analog_button == nullptr) {
@@ -514,80 +795,329 @@ void ConfigureInputPlayer::UpdateButtonLabels() {
             analog_button->setText(
                 AnalogToText(analogs_param[analog_id], analog_sub_buttons[sub_button_id]));
         }
-        analog_map_stick[analog_id]->setText(tr("Set Analog Stick"));
 
+        analog_map_modifier_button[analog_id]->setText(
+            ButtonToText(Common::ParamPackage{analogs_param[analog_id].Get("modifier", "")}));
+
+        const auto deadzone_label = analog_map_deadzone_label[analog_id];
+        const auto deadzone_slider = analog_map_deadzone_slider[analog_id];
+        const auto modifier_groupbox = analog_map_modifier_groupbox[analog_id];
+        const auto modifier_label = analog_map_modifier_label[analog_id];
+        const auto modifier_slider = analog_map_modifier_slider[analog_id];
+        const auto range_groupbox = analog_map_range_groupbox[analog_id];
+        const auto range_spinbox = analog_map_range_spinbox[analog_id];
+
+        int slider_value;
         auto& param = analogs_param[analog_id];
-        auto* const analog_deadzone_slider = analog_map_deadzone[analog_id];
-        auto* const analog_deadzone_label = analog_map_deadzone_label[analog_id];
+        const bool is_controller =
+            param.Get("engine", "") == "sdl" || param.Get("engine", "") == "gcpad";
 
-        if (param.Has("engine") && param.Get("engine", "") == "sdl") {
+        if (is_controller) {
             if (!param.Has("deadzone")) {
                 param.Set("deadzone", 0.1f);
             }
+            slider_value = static_cast<int>(param.Get("deadzone", 0.1f) * 100);
+            deadzone_label->setText(tr("Deadzone: %1%").arg(slider_value));
+            deadzone_slider->setValue(slider_value);
+            if (!param.Has("range")) {
+                param.Set("range", 1.0f);
+            }
+            range_spinbox->setValue(static_cast<int>(param.Get("range", 1.0f) * 100));
+        } else {
+            if (!param.Has("modifier_scale")) {
+                param.Set("modifier_scale", 0.5f);
+            }
+            slider_value = static_cast<int>(param.Get("modifier_scale", 0.5f) * 100);
+            modifier_label->setText(tr("Modifier Range: %1%").arg(slider_value));
+            modifier_slider->setValue(slider_value);
+        }
 
-            analog_deadzone_slider->setValue(static_cast<int>(param.Get("deadzone", 0.1f) * 100));
-            analog_deadzone_slider->setVisible(true);
-            analog_deadzone_label->setVisible(true);
+        deadzone_label->setVisible(is_controller);
+        deadzone_slider->setVisible(is_controller);
+        modifier_groupbox->setVisible(!is_controller);
+        modifier_label->setVisible(!is_controller);
+        modifier_slider->setVisible(!is_controller);
+        range_groupbox->setVisible(is_controller);
+    }
+}
+
+void ConfigureInputPlayer::UpdateInputDevices() {
+    input_devices = input_subsystem->GetInputDevices();
+    ui->comboDevices->clear();
+    for (auto device : input_devices) {
+        ui->comboDevices->addItem(QString::fromStdString(device.Get("display", "Unknown")), {});
+    }
+}
+
+void ConfigureInputPlayer::UpdateControllerIcon() {
+    // We aren't using Qt's built in theme support here since we aren't drawing an icon (and its
+    // "nonstandard" to use an image through the icon support)
+    const QString stylesheet = [this] {
+        switch (GetControllerTypeFromIndex(ui->comboControllerType->currentIndex())) {
+        case Settings::ControllerType::ProController:
+            return QStringLiteral("image: url(:/controller/pro_controller%0)");
+        case Settings::ControllerType::DualJoyconDetached:
+            return QStringLiteral("image: url(:/controller/dual_joycon%0)");
+        case Settings::ControllerType::LeftJoycon:
+            return QStringLiteral("image: url(:/controller/single_joycon_left_vertical%0)");
+        case Settings::ControllerType::RightJoycon:
+            return QStringLiteral("image: url(:/controller/single_joycon_right_vertical%0)");
+        case Settings::ControllerType::Handheld:
+            return QStringLiteral("image: url(:/controller/handheld%0)");
+        default:
+            return QString{};
+        }
+    }();
+
+    const QString theme = [] {
+        if (QIcon::themeName().contains(QStringLiteral("dark"))) {
+            return QStringLiteral("_dark");
+        } else if (QIcon::themeName().contains(QStringLiteral("midnight"))) {
+            return QStringLiteral("_midnight");
         } else {
-            analog_deadzone_slider->setVisible(false);
-            analog_deadzone_label->setVisible(false);
+            return QString{};
         }
+    }();
+
+    ui->controllerFrame->setStyleSheet(stylesheet.arg(theme));
+}
+
+void ConfigureInputPlayer::UpdateControllerAvailableButtons() {
+    auto layout = GetControllerTypeFromIndex(ui->comboControllerType->currentIndex());
+    if (debug) {
+        layout = Settings::ControllerType::ProController;
+    }
+
+    // List of all the widgets that will be hidden by any of the following layouts that need
+    // "unhidden" after the controller type changes
+    const std::array<QWidget*, 9> layout_show = {
+        ui->buttonShoulderButtonsSLSR,
+        ui->horizontalSpacerShoulderButtonsWidget,
+        ui->horizontalSpacerShoulderButtonsWidget2,
+        ui->buttonShoulderButtonsLeft,
+        ui->buttonMiscButtonsMinusScreenshot,
+        ui->bottomLeft,
+        ui->buttonShoulderButtonsRight,
+        ui->buttonMiscButtonsPlusHome,
+        ui->bottomRight,
+    };
+
+    for (auto* widget : layout_show) {
+        widget->show();
+    }
+
+    std::vector<QWidget*> layout_hidden;
+    switch (layout) {
+    case Settings::ControllerType::ProController:
+    case Settings::ControllerType::DualJoyconDetached:
+    case Settings::ControllerType::Handheld:
+        layout_hidden = {
+            ui->buttonShoulderButtonsSLSR,
+            ui->horizontalSpacerShoulderButtonsWidget2,
+        };
+        break;
+    case Settings::ControllerType::LeftJoycon:
+        layout_hidden = {
+            ui->horizontalSpacerShoulderButtonsWidget2,
+            ui->buttonShoulderButtonsRight,
+            ui->buttonMiscButtonsPlusHome,
+            ui->bottomRight,
+        };
+        break;
+    case Settings::ControllerType::RightJoycon:
+        layout_hidden = {
+            ui->horizontalSpacerShoulderButtonsWidget,
+            ui->buttonShoulderButtonsLeft,
+            ui->buttonMiscButtonsMinusScreenshot,
+            ui->bottomLeft,
+        };
+        break;
+    }
+
+    for (auto* widget : layout_hidden) {
+        widget->hide();
     }
 }
 
+void ConfigureInputPlayer::UpdateMotionButtons() {
+    if (debug) {
+        // Motion isn't used with the debug controller, hide both groupboxes.
+        ui->buttonMotionLeftGroup->hide();
+        ui->buttonMotionRightGroup->hide();
+        return;
+    }
+
+    // Show/hide the "Motion 1/2" groupboxes depending on the currently selected controller.
+    switch (GetControllerTypeFromIndex(ui->comboControllerType->currentIndex())) {
+    case Settings::ControllerType::ProController:
+    case Settings::ControllerType::LeftJoycon:
+    case Settings::ControllerType::Handheld:
+        // Show "Motion 1" and hide "Motion 2".
+        ui->buttonMotionLeftGroup->show();
+        ui->buttonMotionRightGroup->hide();
+        break;
+    case Settings::ControllerType::RightJoycon:
+        // Show "Motion 2" and hide "Motion 1".
+        ui->buttonMotionLeftGroup->hide();
+        ui->buttonMotionRightGroup->show();
+        break;
+    case Settings::ControllerType::DualJoyconDetached:
+    default:
+        // Show both "Motion 1/2".
+        ui->buttonMotionLeftGroup->show();
+        ui->buttonMotionRightGroup->show();
+        break;
+    }
+}
+
+void ConfigureInputPlayer::UpdateMappingWithDefaults() {
+    if (ui->comboDevices->currentIndex() == 0) {
+        return;
+    }
+
+    if (ui->comboDevices->currentIndex() == 1) {
+        // Reset keyboard bindings
+        for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; ++button_id) {
+            buttons_param[button_id] = Common::ParamPackage{
+                InputCommon::GenerateKeyboardParam(Config::default_buttons[button_id])};
+        }
+        for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; ++analog_id) {
+            for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; ++sub_button_id) {
+                Common::ParamPackage params{InputCommon::GenerateKeyboardParam(
+                    Config::default_analogs[analog_id][sub_button_id])};
+                SetAnalogParam(params, analogs_param[analog_id], analog_sub_buttons[sub_button_id]);
+            }
+
+            analogs_param[analog_id].Set("modifier", InputCommon::GenerateKeyboardParam(
+                                                         Config::default_stick_mod[analog_id]));
+        }
+
+        for (int motion_id = 0; motion_id < Settings::NativeMotion::NumMotions; ++motion_id) {
+            motions_param[motion_id] = Common::ParamPackage{
+                InputCommon::GenerateKeyboardParam(Config::default_motions[motion_id])};
+        }
+
+        UpdateUI();
+        return;
+    }
+
+    // Reset controller bindings
+    const auto& device = input_devices[ui->comboDevices->currentIndex()];
+    auto button_mapping = input_subsystem->GetButtonMappingForDevice(device);
+    auto analog_mapping = input_subsystem->GetAnalogMappingForDevice(device);
+    for (std::size_t i = 0; i < buttons_param.size(); ++i) {
+        buttons_param[i] = button_mapping[static_cast<Settings::NativeButton::Values>(i)];
+    }
+    for (std::size_t i = 0; i < analogs_param.size(); ++i) {
+        analogs_param[i] = analog_mapping[static_cast<Settings::NativeAnalog::Values>(i)];
+    }
+
+    UpdateUI();
+}
+
 void ConfigureInputPlayer::HandleClick(
     QPushButton* button, std::function<void(const Common::ParamPackage&)> new_input_setter,
     InputCommon::Polling::DeviceType type) {
-    button->setText(tr("[press key]"));
+    if (button == ui->buttonMotionLeft || button == ui->buttonMotionRight) {
+        button->setText(tr("Shake!"));
+    } else {
+        button->setText(tr("[waiting]"));
+    }
     button->setFocus();
 
-    // Keyboard keys can only be used as button devices
-    want_keyboard_keys = type == InputCommon::Polling::DeviceType::Button;
-    if (want_keyboard_keys) {
-        const auto iter = std::find(button_map.begin(), button_map.end(), button);
-        ASSERT(iter != button_map.end());
-        const auto index = std::distance(button_map.begin(), iter);
-        ASSERT(index < Settings::NativeButton::NumButtons && index >= 0);
-    }
+    // The first two input devices are always Any and Keyboard/Mouse. If the user filtered to a
+    // controller, then they don't want keyboard/mouse input
+    want_keyboard_mouse = ui->comboDevices->currentIndex() < 2;
 
     input_setter = new_input_setter;
 
-    device_pollers = InputCommon::Polling::GetPollers(type);
+    device_pollers = input_subsystem->GetPollers(type);
 
     for (auto& poller : device_pollers) {
         poller->Start();
     }
 
-    grabKeyboard();
-    grabMouse();
-    timeout_timer->start(5000); // Cancel after 5 seconds
-    poll_timer->start(200);     // Check for new inputs every 200ms
+    QWidget::grabMouse();
+    QWidget::grabKeyboard();
+
+    if (type == InputCommon::Polling::DeviceType::Button) {
+        input_subsystem->GetGCButtons()->BeginConfiguration();
+    } else {
+        input_subsystem->GetGCAnalogs()->BeginConfiguration();
+    }
+
+    if (type == InputCommon::Polling::DeviceType::Motion) {
+        input_subsystem->GetUDPMotions()->BeginConfiguration();
+    }
+
+    timeout_timer->start(2500); // Cancel after 2.5 seconds
+    poll_timer->start(50);      // Check for new inputs every 50ms
 }
 
 void ConfigureInputPlayer::SetPollingResult(const Common::ParamPackage& params, bool abort) {
-    releaseKeyboard();
-    releaseMouse();
     timeout_timer->stop();
     poll_timer->stop();
     for (auto& poller : device_pollers) {
         poller->Stop();
     }
 
+    QWidget::releaseMouse();
+    QWidget::releaseKeyboard();
+
+    input_subsystem->GetGCButtons()->EndConfiguration();
+    input_subsystem->GetGCAnalogs()->EndConfiguration();
+
+    input_subsystem->GetUDPMotions()->EndConfiguration();
+
     if (!abort) {
         (*input_setter)(params);
     }
 
-    UpdateButtonLabels();
+    UpdateUI();
+    UpdateInputDeviceCombobox();
+
     input_setter = std::nullopt;
 }
 
+bool ConfigureInputPlayer::IsInputAcceptable(const Common::ParamPackage& params) const {
+    if (ui->comboDevices->currentIndex() == 0) {
+        return true;
+    }
+
+    // Keyboard/Mouse
+    if (ui->comboDevices->currentIndex() == 1) {
+        return params.Get("engine", "") == "keyboard" || params.Get("engine", "") == "mouse";
+    }
+
+    const auto current_input_device = input_devices[ui->comboDevices->currentIndex()];
+    return params.Get("engine", "") == current_input_device.Get("class", "") &&
+           params.Get("guid", "") == current_input_device.Get("guid", "") &&
+           params.Get("port", "") == current_input_device.Get("port", "");
+}
+
+void ConfigureInputPlayer::mousePressEvent(QMouseEvent* event) {
+    if (!input_setter || !event) {
+        return;
+    }
+
+    if (want_keyboard_mouse) {
+        SetPollingResult(Common::ParamPackage{InputCommon::GenerateKeyboardParam(event->button())},
+                         false);
+    } else {
+        // We don't want any mouse buttons, so don't stop polling
+        return;
+    }
+
+    SetPollingResult({}, true);
+}
+
 void ConfigureInputPlayer::keyPressEvent(QKeyEvent* event) {
     if (!input_setter || !event) {
         return;
     }
 
     if (event->key() != Qt::Key_Escape) {
-        if (want_keyboard_keys) {
+        if (want_keyboard_mouse) {
             SetPollingResult(Common::ParamPackage{InputCommon::GenerateKeyboardParam(event->key())},
                              false);
         } else {
@@ -595,5 +1125,105 @@ void ConfigureInputPlayer::keyPressEvent(QKeyEvent* event) {
             return;
         }
     }
+
     SetPollingResult({}, true);
 }
+
+void ConfigureInputPlayer::CreateProfile() {
+    const auto profile_name =
+        LimitableInputDialog::GetText(this, tr("New Profile"), tr("Enter a profile name:"), 1, 20);
+
+    if (profile_name.isEmpty()) {
+        return;
+    }
+
+    if (!InputProfiles::IsProfileNameValid(profile_name.toStdString())) {
+        QMessageBox::critical(this, tr("Create Input Profile"),
+                              tr("The given profile name is not valid!"));
+        return;
+    }
+
+    ApplyConfiguration();
+
+    if (!profiles->CreateProfile(profile_name.toStdString(), player_index)) {
+        QMessageBox::critical(this, tr("Create Input Profile"),
+                              tr("Failed to create the input profile \"%1\"").arg(profile_name));
+        UpdateInputProfiles();
+        emit RefreshInputProfiles(player_index);
+        return;
+    }
+
+    emit RefreshInputProfiles(player_index);
+
+    ui->comboProfiles->addItem(profile_name);
+    ui->comboProfiles->setCurrentIndex(ui->comboProfiles->count() - 1);
+}
+
+void ConfigureInputPlayer::DeleteProfile() {
+    const QString profile_name = ui->comboProfiles->itemText(ui->comboProfiles->currentIndex());
+
+    if (profile_name.isEmpty()) {
+        return;
+    }
+
+    if (!profiles->DeleteProfile(profile_name.toStdString())) {
+        QMessageBox::critical(this, tr("Delete Input Profile"),
+                              tr("Failed to delete the input profile \"%1\"").arg(profile_name));
+        UpdateInputProfiles();
+        emit RefreshInputProfiles(player_index);
+        return;
+    }
+
+    emit RefreshInputProfiles(player_index);
+
+    ui->comboProfiles->removeItem(ui->comboProfiles->currentIndex());
+    ui->comboProfiles->setCurrentIndex(-1);
+}
+
+void ConfigureInputPlayer::LoadProfile() {
+    const QString profile_name = ui->comboProfiles->itemText(ui->comboProfiles->currentIndex());
+
+    if (profile_name.isEmpty()) {
+        return;
+    }
+
+    ApplyConfiguration();
+
+    if (!profiles->LoadProfile(profile_name.toStdString(), player_index)) {
+        QMessageBox::critical(this, tr("Load Input Profile"),
+                              tr("Failed to load the input profile \"%1\"").arg(profile_name));
+        UpdateInputProfiles();
+        emit RefreshInputProfiles(player_index);
+        return;
+    }
+
+    LoadConfiguration();
+}
+
+void ConfigureInputPlayer::SaveProfile() {
+    const QString profile_name = ui->comboProfiles->itemText(ui->comboProfiles->currentIndex());
+
+    if (profile_name.isEmpty()) {
+        return;
+    }
+
+    ApplyConfiguration();
+
+    if (!profiles->SaveProfile(profile_name.toStdString(), player_index)) {
+        QMessageBox::critical(this, tr("Save Input Profile"),
+                              tr("Failed to save the input profile \"%1\"").arg(profile_name));
+        UpdateInputProfiles();
+        emit RefreshInputProfiles(player_index);
+        return;
+    }
+}
+
+void ConfigureInputPlayer::UpdateInputProfiles() {
+    ui->comboProfiles->clear();
+
+    for (const auto& profile_name : profiles->GetInputProfileNames()) {
+        ui->comboProfiles->addItem(QString::fromStdString(profile_name));
+    }
+
+    ui->comboProfiles->setCurrentIndex(-1);
+}