Merge remote-tracking branch 'origin/dsTouchpad' into my_master

Author: DavidRGriswold

src/citra_qt/configuration/config.cpp

@@ -403,8 +403,14 @@ void QtConfig::ReadControlValues() {
             ReadSetting(QStringLiteral("touch_device"), QStringLiteral("engine:emu_window"))
                 .toString()
                 .toStdString();
+        profile.controller_touch_device =
+            ReadSetting(QStringLiteral("controller_touch_device"),QStringLiteral(""))
+                .toString()
+                .toStdString();
         profile.use_touch_from_button =
             ReadSetting(QStringLiteral("use_touch_from_button"), false).toBool();
+        profile.use_touchpad =
+            ReadSetting(QStringLiteral("use_touchpad"), false).toBool();
         profile.touch_from_button_map_index =
             ReadSetting(QStringLiteral("touch_from_button_map"), 0).toInt();
         profile.touch_from_button_map_index =
@@ -990,6 +996,8 @@ void QtConfig::SaveControlValues() {
         WriteSetting(QStringLiteral("touch_device"), QString::fromStdString(profile.touch_device),
                      QStringLiteral("engine:emu_window"));
         WriteSetting(QStringLiteral("use_touch_from_button"), profile.use_touch_from_button, false);
+        WriteSetting(QStringLiteral("use_touchpad"), profile.use_touchpad, false);
+        WriteSetting(QStringLiteral("controller_touch_device"), QString::fromStdString(profile.controller_touch_device), QStringLiteral(""));
         WriteSetting(QStringLiteral("touch_from_button_map"), profile.touch_from_button_map_index,
                      0);
         WriteSetting(QStringLiteral("udp_input_address"),

src/citra_qt/configuration/configure_motion_touch.cpp

@@ -139,6 +139,8 @@ void ConfigureMotionTouch::SetConfiguration() {
         ui->touch_provider->findData(QString::fromStdString(touch_engine)));
     ui->touch_from_button_checkbox->setChecked(
         Settings::values.current_input_profile.use_touch_from_button);
+    ui->touchpad_checkbox->setChecked(
+        Settings::values.current_input_profile.use_touchpad);
     touch_from_button_maps = Settings::values.touch_from_button_maps;
     for (const auto& touch_map : touch_from_button_maps) {
         ui->touch_from_button_map->addItem(QString::fromStdString(touch_map.name));
@@ -164,7 +166,9 @@ void ConfigureMotionTouch::SetConfiguration() {
 void ConfigureMotionTouch::UpdateUiDisplay() {
     const std::string motion_engine = ui->motion_provider->currentData().toString().toStdString();
     const std::string touch_engine = ui->touch_provider->currentData().toString().toStdString();
-
+    ui->touchpad_config_btn->setEnabled(
+        ui->touchpad_checkbox->isChecked()
+    );
     if (motion_engine == "motion_emu") {
         ui->motion_sensitivity_label->setVisible(true);
         ui->motion_sensitivity->setVisible(true);
@@ -229,6 +233,32 @@ void ConfigureMotionTouch::ConnectEvents() {
             poll_timer->start(200);     // Check for new inputs every 200ms
         }
     });
+    connect(ui->touchpad_checkbox,&QCheckBox::checkStateChanged, this, [this]() {UpdateUiDisplay(); });
+    connect(ui->touchpad_config_btn, &QPushButton::clicked, this, [this]() {
+        if (QMessageBox::information(this, tr("Information"),
+                                     tr("After pressing OK, tap the trackpad on the controller"
+                                        "that you want to track."),
+                                     QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok) {
+            ui->touchpad_config_btn->setText(tr("[press touchpad]"));
+            ui->touchpad_config_btn->setFocus();
+
+            input_setter = [this](const Common::ParamPackage& params) {
+                tpguid = params.Get("guid", "0");
+                tpport = params.Get("port", 0);
+                tp = params.Get("touchpad",0);
+            };
+
+            device_pollers =
+                InputCommon::Polling::GetPollers(InputCommon::Polling::DeviceType::Touchpad);
+
+            for (auto& poller : device_pollers) {
+                poller->Start();
+            }
+
+            timeout_timer->start(5000); // Cancel after 5 seconds
+            poll_timer->start(200);     // Check for new inputs every 200ms
+        }
+    });
     connect(ui->udp_test, &QPushButton::clicked, this, &ConfigureMotionTouch::OnCemuhookUDPTest);
     connect(ui->touch_calibration_config, &QPushButton::clicked, this,
             &ConfigureMotionTouch::OnConfigureTouchCalibration);
@@ -253,7 +283,7 @@ void ConfigureMotionTouch::SetPollingResult(const Common::ParamPackage& params,
     if (!abort && input_setter) {
         (*input_setter)(params);
     }
-
+    ui->touchpad_config_btn->setText(tr("Configure"));
     ui->motion_controller_button->setText(tr("Configure"));
     input_setter.reset();
 }
@@ -291,7 +321,6 @@ void ConfigureMotionTouch::OnConfigureTouchCalibration() {
                  "UDP touchpad calibration config success: min_x={}, min_y={}, max_x={}, max_y={}",
                  min_x, min_y, max_x, max_y);
         UpdateUiDisplay();
-    } else {
         LOG_ERROR(Frontend, "UDP touchpad calibration config failed");
     }
     ui->touch_calibration_config->setEnabled(true);
@@ -374,12 +403,22 @@ void ConfigureMotionTouch::ApplyConfiguration() {
         touch_param.Set("max_y", max_y);
     }
 
+    Common::ParamPackage touchpad_param{};
+    if (ui->touchpad_checkbox->isChecked()) {
+        touchpad_param.Set("engine", "sdl");
+        touchpad_param.Set("guid", tpguid);
+        touchpad_param.Set("port", tpport);
+        touchpad_param.Set("touchpad",tp);
+    }
     Settings::values.current_input_profile.motion_device = motion_param.Serialize();
     Settings::values.current_input_profile.touch_device = touch_param.Serialize();
     Settings::values.current_input_profile.use_touch_from_button =
         ui->touch_from_button_checkbox->isChecked();
     Settings::values.current_input_profile.touch_from_button_map_index =
         ui->touch_from_button_map->currentIndex();
+    Settings::values.current_input_profile.use_touchpad =
+        ui->touchpad_checkbox->isChecked();
+    Settings::values.current_input_profile.controller_touch_device = touchpad_param.Serialize();
     Settings::values.touch_from_button_maps = touch_from_button_maps;
     Settings::values.current_input_profile.udp_input_address = ui->udp_server->text().toStdString();
     Settings::values.current_input_profile.udp_input_port =

src/citra_qt/configuration/configure_motion_touch.h

@@ -76,6 +76,9 @@ private slots:
     // Used for SDL input polling
     std::string guid;
     int port;
+    std::string tpguid; // guid for touchpad
+    int tpport; //port for touchpad
+    int tp; //which touchpad
     std::unique_ptr<QTimer> timeout_timer;
     std::unique_ptr<QTimer> poll_timer;
     std::vector<std::unique_ptr<InputCommon::Polling::DevicePoller>> device_pollers;

src/citra_qt/configuration/configure_motion_touch.ui

@@ -2,17 +2,17 @@
 <ui version="4.0">
  <class>ConfigureMotionTouch</class>
  <widget class="QDialog" name="ConfigureMotionTouch">
-  <property name="windowTitle">
-   <string>Configure Motion / Touch</string>
-  </property>
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>500</width>
-    <height>450</height>
+    <width>517</width>
+    <height>659</height>
    </rect>
   </property>
+  <property name="windowTitle">
+   <string>Configure Motion / Touch</string>
+  </property>
   <layout class="QVBoxLayout">
    <item>
     <widget class="QGroupBox" name="motion_group_box">
@@ -175,6 +175,24 @@
         </item>
        </layout>
       </item>
+      <item>
+       <layout class="QHBoxLayout" name="touchpad_hlayout">
+        <item>
+         <widget class="QCheckBox" name="touchpad_checkbox">
+          <property name="text">
+           <string>Use controller (e.g. DualSense) touchpad</string>
+          </property>
+         </widget>
+        </item>
+        <item alignment="Qt::AlignRight">
+         <widget class="QPushButton" name="touchpad_config_btn">
+          <property name="text">
+           <string>Configure</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
      </layout>
     </widget>
    </item>
@@ -324,4 +342,5 @@
   </layout>
  </widget>
  <resources/>
+ <connections/>
 </ui>

src/citra_sdl/config.cpp

@@ -121,6 +121,8 @@ void SdlConfig::ReadValues() {
         "engine:motion_emu,update_period:100,sensitivity:0.01,tilt_clamp:90.0");
     Settings::values.current_input_profile.touch_device =
         sdl2_config->GetString("Controls", "touch_device", "engine:emu_window");
+    Settings::values.current_input_profile.controller_touch_device =
+        sdl2_config->GetString("Controls","controller_touch_device","");
     Settings::values.current_input_profile.udp_input_address = sdl2_config->GetString(
         "Controls", "udp_input_address", InputCommon::CemuhookUDP::DEFAULT_ADDR);
     Settings::values.current_input_profile.udp_input_port =

src/common/settings.h

@@ -431,6 +431,8 @@ struct InputProfile {
     std::array<std::string, NativeAnalog::NumAnalogs> analogs;
     std::string motion_device;
     std::string touch_device;
+    std::string controller_touch_device;
+    bool use_touchpad;
     bool use_touch_from_button;
     int touch_from_button_map_index;
     std::string udp_input_address;

src/core/hle/service/hid/hid.cpp

@@ -115,6 +115,7 @@ DirectionState GetStickDirectionState(s16 circle_pad_x, s16 circle_pad_y) {
 }
 
 void Module::LoadInputDevices() {
+    LOG_DEBUG(Frontend,"Loading input devices");
     std::transform(Settings::values.current_input_profile.buttons.begin() +
                        Settings::NativeButton::BUTTON_HID_BEGIN,
                    Settings::values.current_input_profile.buttons.begin() +
@@ -126,6 +127,12 @@ void Module::LoadInputDevices() {
         Settings::values.current_input_profile.motion_device);
     touch_device = Input::CreateDevice<Input::TouchDevice>(
         Settings::values.current_input_profile.touch_device);
+    if (Settings::values.current_input_profile.use_touchpad &&
+        Settings::values.current_input_profile.controller_touch_device != "") {
+        controller_touch_device = Input::CreateDevice<Input::TouchDevice>(Settings::values.current_input_profile.controller_touch_device);
+    } else {
+        controller_touch_device.reset();
+    }
     if (Settings::values.current_input_profile.use_touch_from_button) {
         touch_btn_device = Input::CreateDevice<Input::TouchDevice>("engine:touch_from_button");
     } else {
@@ -278,6 +285,9 @@ void Module::UpdatePadCallback(std::uintptr_t user_data, s64 cycles_late) {
         if (!pressed && touch_btn_device) {
             std::tie(x, y, pressed) = touch_btn_device->GetStatus();
         }
+        if (!pressed && controller_touch_device) {
+            std::tie(x,y,pressed) = controller_touch_device->GetStatus();
+        }
         touch_entry.x = static_cast<u16>(x * Core::kScreenBottomWidth);
         touch_entry.y = static_cast<u16>(y * Core::kScreenBottomHeight);
         touch_entry.valid.Assign(pressed ? 1 : 0);

src/core/hle/service/hid/hid.h

@@ -390,6 +390,7 @@ class Module final {
         buttons;
     std::unique_ptr<Input::AnalogDevice> circle_pad;
     std::unique_ptr<Input::MotionDevice> motion_device;
+    std::unique_ptr<Input::TouchDevice> controller_touch_device;
     std::unique_ptr<Input::TouchDevice> touch_device;
     std::unique_ptr<Input::TouchDevice> touch_btn_device;
 

src/input_common/main.h

@@ -45,7 +45,7 @@ void ReloadInputDevices();
 
 namespace Polling {
 
-enum class DeviceType { Button, Analog };
+enum class DeviceType { Button, Analog, Touchpad};
 
 /**
  * A class that can be used to get inputs from an input device like controllers without having to