Add controller dropdown for dev mode.

Author: Mysticial

SerialPrograms/Source/Controllers/ControllerCapability.cpp

@@ -17,10 +17,10 @@ const EnumStringMap<ControllerInterface> CONTROLLER_INTERFACE_STRINGS{
 
 const EnumStringMap<ControllerType> CONTROLLER_TYPE_STRINGS{
     {ControllerType::None,                                  "None"},
-    {ControllerType::NintendoSwitch_WiredProController,     "NintendoSwitch_WiredProController"},
-    {ControllerType::NintendoSwitch_WirelessProController,  "NintendoSwitch_WirelessProController"},
-    {ControllerType::NintendoSwitch_LeftJoycon,             "NintendoSwitch_LeftJoycon"},
-    {ControllerType::NintendoSwitch_RightJoycon,            "NintendoSwitch_RightJoycon"},
+    {ControllerType::NintendoSwitch_WiredProController,     "Switch: Wired Pro Controller"},
+    {ControllerType::NintendoSwitch_WirelessProController,  "Switch: Wireless Pro Controller"},
+    {ControllerType::NintendoSwitch_LeftJoycon,             "Switch: Left Joycon"},
+    {ControllerType::NintendoSwitch_RightJoycon,            "Switch: Right Joycon"},
 };
 
 const EnumStringMap<ControllerFeature> CONTROLLER_FEATURE_STRINGS{

SerialPrograms/Source/Controllers/ControllerDescriptor.cpp

@@ -101,7 +101,7 @@ void ControllerOption::load_json(const JsonValue& json){
         }
         const std::string* controller = obj->get_string("Controller");
         if (controller != nullptr){
-            controller_type = CONTROLLER_TYPE_STRINGS.get_enum(*controller);
+            controller_type = CONTROLLER_TYPE_STRINGS.get_enum(*controller, ControllerType::None);
         }
         const JsonValue* params = obj->get_value("Parameters");
         if (params == nullptr){

SerialPrograms/Source/Controllers/ControllerSelectorWidget.cpp

@@ -6,6 +6,7 @@
 
 #include <QHBoxLayout>
 #include "Common/Qt/NoWheelComboBox.h"
+#include "CommonFramework/GlobalSettingsPanel.h"
 #include "ControllerSelectorWidget.h"
 
 //#include <iostream>
@@ -29,11 +30,20 @@ ControllerSelectorWidget::ControllerSelectorWidget(QWidget& parent, ControllerSe
     serial_row->addWidget(new QLabel("<b>Controller:</b>", this), 1);
     serial_row->addSpacing(5);
 
-    m_devices_dropdown = new NoWheelComboBox(this);
-    serial_row->addWidget(m_devices_dropdown, 5);
-    refresh();
+    QHBoxLayout* dropdowns = new QHBoxLayout();
+    serial_row->addLayout(dropdowns, 5);
     serial_row->addSpacing(5);
 
+    m_devices_dropdown = new NoWheelComboBox(this);
+    dropdowns->addWidget(m_devices_dropdown, 3);
+    refresh_devices();
+
+    if (PreloadSettings::instance().DEVELOPER_MODE){
+        dropdowns->addSpacing(5);
+        m_controllers_dropdown = new NoWheelComboBox(this);
+        dropdowns->addWidget(m_controllers_dropdown, 2);
+    }
+
     m_status_text = new QLabel(this);
     serial_row->addWidget(m_status_text, 3);
     serial_row->addSpacing(5);
@@ -60,9 +70,25 @@ ControllerSelectorWidget::ControllerSelectorWidget(QWidget& parent, ControllerSe
             }
 
             m_session.set_device(selected);
-            refresh();
+            refresh_devices();
         }
     );
+    if (PreloadSettings::instance().DEVELOPER_MODE){
+        connect(
+            m_controllers_dropdown, static_cast<void(QComboBox::*)(int)>(&QComboBox::activated),
+            this, [this](int index){
+                index = std::max(index, 0);
+                ControllerType new_value = CONTROLLER_TYPE_STRINGS.get_enum(
+                    m_controllers_dropdown->itemText(index).toStdString(),
+                    ControllerType::None
+                );
+                if (new_value == m_session.controller_type()){
+                    return;
+                }
+                m_session.set_controller(new_value);
+            }
+        );
+    }
     connect(
         m_reset_button, &QPushButton::clicked,
         this, [this](bool){
@@ -75,7 +101,7 @@ ControllerSelectorWidget::ControllerSelectorWidget(QWidget& parent, ControllerSe
 
 
 
-void ControllerSelectorWidget::refresh(){
+void ControllerSelectorWidget::refresh_devices(){
     m_device_list.clear();
     m_devices_dropdown->clear();
 
@@ -100,13 +126,45 @@ void ControllerSelectorWidget::refresh(){
 //    cout << "items = " << m_devices_dropdown->count() << endl;
     m_devices_dropdown->setCurrentIndex((int)index);
 }
+void ControllerSelectorWidget::refresh_controllers(
+    ControllerType controller_type,
+    const std::vector<ControllerType>& available_controllers
+){
+    if (m_controllers_dropdown == nullptr){
+        return;
+    }
+//    cout << "refresh_controllers()" << endl;
 
+    m_controllers_dropdown->clear();
 
+    size_t index = 0;
+    for (size_t c = 0; c < available_controllers.size(); c++){
+        const std::string& name = CONTROLLER_TYPE_STRINGS.get_string(available_controllers[c]);
+        m_controllers_dropdown->addItem(QString::fromStdString(name));
+        if (controller_type == available_controllers[c]){
+            index = c;
+        }
+    }
+    m_controllers_dropdown->setCurrentIndex((int)index);
+}
 
-void ControllerSelectorWidget::controller_changed(const std::shared_ptr<const ControllerDescriptor>& descriptor){
+
+
+void ControllerSelectorWidget::descriptor_changed(
+    const std::shared_ptr<const ControllerDescriptor>& descriptor
+){
     QMetaObject::invokeMethod(this, [this]{
-        refresh();
-    });
+        refresh_devices();
+    }, Qt::QueuedConnection);
+}
+void ControllerSelectorWidget::controller_changed(
+    ControllerType controller_type,
+    const std::vector<ControllerType>& available_controllers
+){
+//    cout << "ControllerSelectorWidget::controller_changed()" << endl;
+    QMetaObject::invokeMethod(this, [=, this]{
+        refresh_controllers(controller_type, available_controllers);
+    }, Qt::QueuedConnection);
 }
 void ControllerSelectorWidget::post_status_text_changed(const std::string& text){
 //    cout << "ControllerSelectorWidget::status_text_changed(): " << text << endl;

SerialPrograms/Source/Controllers/ControllerSelectorWidget.h

@@ -24,19 +24,30 @@ class ControllerSelectorWidget : public QWidget, private ControllerSession::List
     ControllerSelectorWidget(QWidget& parent, ControllerSession& session);
 
 public:
-    virtual void controller_changed(const std::shared_ptr<const ControllerDescriptor>& descriptor) override;
+    virtual void descriptor_changed(
+        const std::shared_ptr<const ControllerDescriptor>& descriptor
+    ) override;
+    virtual void controller_changed(
+        ControllerType controller_type,
+        const std::vector<ControllerType>& available_controllers
+    ) override;
     virtual void post_status_text_changed(const std::string& text) override;
     virtual void options_locked(bool locked) override;
 
 private:
-    void refresh();
+    void refresh_devices();
+    void refresh_controllers(
+        ControllerType controller_type,
+        const std::vector<ControllerType>& available_controllers
+    );
 
 private:
     ControllerSession& m_session;
 
-    QComboBox* m_devices_dropdown;
-    QLabel* m_status_text;
-    QPushButton* m_reset_button;
+    QComboBox* m_devices_dropdown = nullptr;
+    QComboBox* m_controllers_dropdown = nullptr;
+    QLabel* m_status_text = nullptr;
+    QPushButton* m_reset_button = nullptr;
 
     std::vector<std::shared_ptr<const ControllerDescriptor>> m_device_list;
 };

SerialPrograms/Source/Controllers/ControllerSession.cpp

@@ -15,11 +15,14 @@ namespace PokemonAutomation{
 
 
 void ControllerSession::add_listener(Listener& listener){
-    std::lock_guard<std::mutex> lg0(m_state_lock);
+    std::lock_guard<std::mutex> lg(m_state_lock);
     m_listeners.add(listener);
+//    if (m_connection && m_connection->is_ready()){
+        signal_controller_changed(m_option.m_controller_type, m_available_controllers);
+//    }
 }
 void ControllerSession::remove_listener(Listener& listener){
-    std::lock_guard<std::mutex> lg0(m_state_lock);
+    std::lock_guard<std::mutex> lg(m_state_lock);
     m_listeners.remove(listener);
 }
 
@@ -73,6 +76,10 @@ std::shared_ptr<const ControllerDescriptor> ControllerSession::descriptor() cons
     std::lock_guard<std::mutex> lg(m_state_lock);
     return m_descriptor;
 }
+ControllerType ControllerSession::controller_type() const{
+    std::lock_guard<std::mutex> lg(m_state_lock);
+    return m_option.m_controller_type;
+}
 std::string ControllerSession::status_text() const{
     std::lock_guard<std::mutex> lg(m_state_lock);
     if (!m_connection){
@@ -157,7 +164,29 @@ bool ControllerSession::set_device(const std::shared_ptr<const ControllerDescrip
         m_option.m_descriptor = device;
         m_descriptor = device;
     }
-    signal_controller_changed(device);
+    signal_descriptor_changed(device);
+    signal_status_text_changed(status_text());
+    return true;
+}
+bool ControllerSession::set_controller(ControllerType controller_type){
+//    cout << "set_controller()" << endl;
+    {
+        std::lock_guard<std::mutex> lg(m_state_lock);
+        if (m_option.m_controller_type == controller_type){
+            return true;
+        }
+        if (m_options_locked){
+            return false;
+        }
+        m_option.m_controller_type = controller_type;
+
+        m_controller.reset();
+        m_connection.reset();
+        m_connection = m_descriptor->open_connection(m_logger);
+        if (m_connection){
+            m_connection->add_status_listener(*this);
+        }
+    }
     signal_status_text_changed(status_text());
     return true;
 }
@@ -190,34 +219,58 @@ void ControllerSession::pre_not_ready(){
     m_listeners.run_method_unique(&Listener::pre_not_ready);
 }
 void ControllerSession::post_ready(const std::map<ControllerType, std::set<ControllerFeature>>& controllers){
-    if (controllers.empty()){
-        return;
-    }
-
-    auto iter = controllers.begin();
-
-    if (controllers.size() == 1){
-        //  Only one controller available. Force the option to it.
-        m_option.m_controller_type = iter->first;
-    }else{
-        //  Otherwise, try to use the option setting. If it's not valid,
-        //  clear it.
-        iter = controllers.find(m_option.m_controller_type);
-        if (iter == controllers.end()){
-            m_option.m_controller_type = ControllerType::None;
-            m_controller.reset();
+    std::vector<ControllerType> available_controllers;
+
+    if (controllers.size() > 1){
+        available_controllers.emplace_back(ControllerType::None);
+    }
+
+    ControllerType selected_controller = ControllerType::None;
+    bool ready = false;
+    {
+        std::lock_guard<std::mutex> lg(m_state_lock);
+
+        for (const auto& item : controllers){
+            available_controllers.emplace_back(item.first);
+        }
+        m_available_controllers = available_controllers;
+        m_controller.reset();
+
+        if (controllers.empty()){
             return;
         }
-    }
 
-//    cout << "post_ready()" << endl;
+        auto iter = controllers.begin();
+
+        if (controllers.size() == 1){
+            //  Only one controller available. Force the option to it.
+            selected_controller = iter->first;
+        }else{
+            //  Keep the current controller only if it exists.
+            iter = controllers.find(m_option.m_controller_type);
+            if (iter != controllers.end()){
+                selected_controller = m_option.m_controller_type;
+            }
+        }
+
+//        cout << "post_ready()" << endl;
+
+        if (selected_controller != ControllerType::None){
+            m_controller = m_descriptor->make_controller(m_logger, *m_connection, selected_controller, m_requirements);
+        }
+        m_option.m_controller_type = selected_controller;
 
-    m_controller.reset();
-    m_controller = m_descriptor->make_controller(m_logger, *m_connection, iter->first, m_requirements);
-    m_listeners.run_method_unique(&Listener::post_ready, controllers);
-    signal_ready_changed(m_controller->is_ready());
+        ready = m_controller && m_controller->is_ready();
+        signal_controller_changed(selected_controller, available_controllers);
+    }
+    if (ready){
+        m_listeners.run_method_unique(&Listener::post_ready, controllers);
+        signal_ready_changed(m_controller->is_ready());
+    }
 }
 void ControllerSession::post_status_text_changed(const std::string& text){
+    std::lock_guard<std::mutex> lg(m_state_lock);
+
     do{
         if (m_controller == nullptr){
             break;
@@ -239,8 +292,16 @@ void ControllerSession::post_status_text_changed(const std::string& text){
 void ControllerSession::signal_ready_changed(bool ready){
     m_listeners.run_method_unique(&Listener::ready_changed, ready);
 }
-void ControllerSession::signal_controller_changed(const std::shared_ptr<const ControllerDescriptor>& descriptor){
-    m_listeners.run_method_unique(&Listener::controller_changed, descriptor);
+void ControllerSession::signal_descriptor_changed(
+    const std::shared_ptr<const ControllerDescriptor>& descriptor
+){
+    m_listeners.run_method_unique(&Listener::descriptor_changed, descriptor);
+}
+void ControllerSession::signal_controller_changed(
+    ControllerType controller_type,
+    const std::vector<ControllerType>& available_controllers
+){
+    m_listeners.run_method_unique(&Listener::controller_changed, controller_type, available_controllers);
 }
 void ControllerSession::signal_status_text_changed(const std::string& text){
     m_listeners.run_method_unique(&Listener::post_status_text_changed, text);

SerialPrograms/Source/Controllers/ControllerSession.h

@@ -24,7 +24,13 @@ class ControllerSession : private ControllerConnection::StatusListener{
 public:
     struct Listener : ControllerConnection::StatusListener{
         virtual void ready_changed(bool ready){}
-        virtual void controller_changed(const std::shared_ptr<const ControllerDescriptor>& descriptor){}
+        virtual void descriptor_changed(
+            const std::shared_ptr<const ControllerDescriptor>& descriptor
+        ){}
+        virtual void controller_changed(
+            ControllerType controller_type,
+            const std::vector<ControllerType>& available_controllers
+        ){}
         virtual void post_status_text_changed(const std::string& text){}
         virtual void options_locked(bool locked){}
     };
@@ -53,6 +59,7 @@ class ControllerSession : private ControllerConnection::StatusListener{
 
     bool ready() const;
     std::shared_ptr<const ControllerDescriptor> descriptor() const;
+    ControllerType controller_type() const;
     std::string status_text() const;
 
     const ControllerOption& option() const{
@@ -73,6 +80,7 @@ class ControllerSession : private ControllerConnection::StatusListener{
 
 public:
     bool set_device(const std::shared_ptr<const ControllerDescriptor>& device);
+    bool set_controller(ControllerType controller_type);
 
 
 public:
@@ -113,7 +121,13 @@ class ControllerSession : private ControllerConnection::StatusListener{
     virtual void post_status_text_changed(const std::string& text) override;
 
     void signal_ready_changed(bool ready);
-    void signal_controller_changed(const std::shared_ptr<const ControllerDescriptor>& descriptor);
+    void signal_descriptor_changed(
+        const std::shared_ptr<const ControllerDescriptor>& descriptor
+    );
+    void signal_controller_changed(
+        ControllerType controller_type,
+        const std::vector<ControllerType>& available_controllers
+    );
     void signal_status_text_changed(const std::string& text);
     void signal_options_locked(bool locked);
 
@@ -130,6 +144,8 @@ class ControllerSession : private ControllerConnection::StatusListener{
     std::unique_ptr<ControllerConnection> m_connection;
     std::unique_ptr<AbstractController> m_controller;
 
+    std::vector<ControllerType> m_available_controllers;
+
     ListenerSet<Listener> m_listeners;
 };