qt: Use ProfileSelectionDialog when selecting user for save data

This allows us to present a much nicer UI to the user over a simple combo box and is made easy with the modular nature of the profile-selection applet frontend.

src/core/hle/kernel/errors.h

@@ -27,7 +27,7 @@ constexpr ResultCode ERR_SYNCHRONIZATION_CANCELED{ErrorModule::Kernel, 118};
 constexpr ResultCode ERR_OUT_OF_RANGE{ErrorModule::Kernel, 119};
 constexpr ResultCode ERR_INVALID_ENUM_VALUE{ErrorModule::Kernel, 120};
 constexpr ResultCode ERR_NOT_FOUND{ErrorModule::Kernel, 121};
-constexpr ResultCode ERR_BUSY{ErrorModule::Kernel, 122};
+constexpr ResultCode ERR_ALREADY_REGISTERED{ErrorModule::Kernel, 122};
 constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE{ErrorModule::Kernel, 123};
 constexpr ResultCode ERR_INVALID_STATE{ErrorModule::Kernel, 125};
 constexpr ResultCode ERR_RESOURCE_LIMIT_EXCEEDED{ErrorModule::Kernel, 132};

src/core/hle/kernel/svc.cpp

@@ -932,35 +932,8 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
 }
 
 /// Sets the thread activity
-static ResultCode SetThreadActivity(Handle handle, u32 activity) {
-    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, activity=0x{:08X}", handle, activity);
-    if (activity > static_cast<u32>(ThreadActivity::Paused)) {
-        return ERR_INVALID_ENUM_VALUE;
-    }
-
-    const auto* current_process = Core::CurrentProcess();
-    const SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
-    if (!thread) {
-        LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}", handle);
-        return ERR_INVALID_HANDLE;
-    }
-
-    if (thread->GetOwnerProcess() != current_process) {
-        LOG_ERROR(Kernel_SVC,
-                  "The current process does not own the current thread, thread_handle={:08X} "
-                  "thread_pid={}, "
-                  "current_process_pid={}",
-                  handle, thread->GetOwnerProcess()->GetProcessID(),
-                  current_process->GetProcessID());
-        return ERR_INVALID_HANDLE;
-    }
-
-    if (thread == GetCurrentThread()) {
-        LOG_ERROR(Kernel_SVC, "The thread handle specified is the current running thread");
-        return ERR_BUSY;
-    }
-
-    thread->SetActivity(static_cast<ThreadActivity>(activity));
+static ResultCode SetThreadActivity(Handle handle, u32 unknown) {
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x{:08X}, unknown=0x{:08X}", handle, unknown);
     return RESULT_SUCCESS;
 }
 
@@ -987,7 +960,7 @@ static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {
 
     if (thread == GetCurrentThread()) {
         LOG_ERROR(Kernel_SVC, "The thread handle specified is the current running thread");
-        return ERR_BUSY;
+        return ERR_ALREADY_REGISTERED;
     }
 
     Core::ARM_Interface::ThreadContext ctx = thread->GetContext();
@@ -1272,10 +1245,7 @@ static ResultCode StartThread(Handle thread_handle) {
     ASSERT(thread->GetStatus() == ThreadStatus::Dormant);
 
     thread->ResumeFromWait();
-
-    if (thread->GetStatus() == ThreadStatus::Ready) {
-        Core::System::GetInstance().CpuCore(thread->GetProcessorID()).PrepareReschedule();
-    }
+    Core::System::GetInstance().CpuCore(thread->GetProcessorID()).PrepareReschedule();
 
     return RESULT_SUCCESS;
 }

src/core/hle/kernel/thread.cpp

@@ -50,7 +50,7 @@ void Thread::Stop() {
 
     // Clean up thread from ready queue
     // This is only needed when the thread is terminated forcefully (SVC TerminateProcess)
-    if (status == ThreadStatus::Ready || status == ThreadStatus::Paused) {
+    if (status == ThreadStatus::Ready) {
         scheduler->UnscheduleThread(this, current_priority);
     }
 
@@ -140,11 +140,6 @@ void Thread::ResumeFromWait() {
 
     wakeup_callback = nullptr;
 
-    if (activity == ThreadActivity::Paused) {
-        status = ThreadStatus::Paused;
-        return;
-    }
-
     status = ThreadStatus::Ready;
 
     ChangeScheduler();
@@ -396,23 +391,6 @@ bool Thread::InvokeWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> t
     return wakeup_callback(reason, std::move(thread), std::move(object), index);
 }
 
-void Thread::SetActivity(ThreadActivity value) {
-    activity = value;
-
-    if (value == ThreadActivity::Paused) {
-        // Set status if not waiting
-        if (status == ThreadStatus::Ready) {
-            status = ThreadStatus::Paused;
-        } else if (status == ThreadStatus::Running) {
-            status = ThreadStatus::Paused;
-            Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
-        }
-    } else if (status == ThreadStatus::Paused) {
-        // Ready to reschedule
-        ResumeFromWait();
-    }
-}
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**

src/core/hle/kernel/thread.h

@@ -45,7 +45,6 @@ enum ThreadProcessorId : s32 {
 enum class ThreadStatus {
     Running,      ///< Currently running
     Ready,        ///< Ready to run
-    Paused,       ///< Paused by SetThreadActivity or debug
     WaitHLEEvent, ///< Waiting for hle event to finish
     WaitSleep,    ///< Waiting due to a SleepThread SVC
     WaitIPC,      ///< Waiting for the reply from an IPC request
@@ -62,11 +61,6 @@ enum class ThreadWakeupReason {
     Timeout // The thread was woken up due to a wait timeout.
 };
 
-enum class ThreadActivity : u32 {
-    Normal = 0,
-    Paused = 1,
-};
-
 class Thread final : public WaitObject {
 public:
     using TLSMemory = std::vector<u8>;
@@ -377,12 +371,6 @@ public:
         return affinity_mask;
     }
 
-    ThreadActivity GetActivity() const {
-        return activity;
-    }
-
-    void SetActivity(ThreadActivity value);
-
 private:
     explicit Thread(KernelCore& kernel);
     ~Thread() override;
@@ -451,8 +439,6 @@ private:
     TLSMemoryPtr tls_memory = std::make_shared<TLSMemory>();
 
     std::string name;
-
-    ThreadActivity activity = ThreadActivity::Normal;
 };
 
 /**

src/video_core/engines/shader_bytecode.h

@@ -1049,7 +1049,7 @@ union Instruction {
         BitField<49, 1, u64> nodep_flag;
         BitField<50, 3, u64> component_mask_selector;
         BitField<53, 4, u64> texture_info;
-        BitField<59, 1, u64> fp32_flag;
+        BitField<60, 1, u64> fp32_flag;
 
         TextureType GetTextureType() const {
             // The TEXS instruction has a weird encoding for the texture type.

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -1755,7 +1755,7 @@ private:
             instr.tlds.GetTextureProcessMode() == Tegra::Shader::TextureProcessMode::LL;
 
         constexpr std::array<const char*, 4> coord_container{
-            {"", "int coords = (", "ivec2 coords = ivec2(", "ivec3 coords = ivec3("}};
+            {"", "int coord = (", "ivec2 coord = ivec2(", "ivec3 coord = ivec3("}};
 
         std::string coord = coord_container[total_coord_count];
 

src/video_core/renderer_opengl/renderer_opengl.h

@@ -17,7 +17,7 @@ class EmuWindow;
 }
 
 namespace Layout {
-struct FramebufferLayout;
+class FramebufferLayout;
 }
 
 namespace OpenGL {

src/yuzu/debugger/wait_tree.cpp

@@ -221,9 +221,6 @@ QString WaitTreeThread::GetText() const {
     case Kernel::ThreadStatus::Ready:
         status = tr("ready");
         break;
-    case Kernel::ThreadStatus::Paused:
-        status = tr("paused");
-        break;
     case Kernel::ThreadStatus::WaitHLEEvent:
         status = tr("waiting for HLE return");
         break;
@@ -265,8 +262,6 @@ QColor WaitTreeThread::GetColor() const {
         return QColor(Qt::GlobalColor::darkGreen);
     case Kernel::ThreadStatus::Ready:
         return QColor(Qt::GlobalColor::darkBlue);
-    case Kernel::ThreadStatus::Paused:
-        return QColor(Qt::GlobalColor::lightGray);
     case Kernel::ThreadStatus::WaitHLEEvent:
     case Kernel::ThreadStatus::WaitIPC:
         return QColor(Qt::GlobalColor::darkRed);

src/yuzu/main.cpp

@@ -827,31 +827,25 @@ void GMainWindow::OnGameListOpenFolder(u64 program_id, GameListOpenTarget target
         const std::string nand_dir = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir);
         ASSERT(program_id != 0);
 
-        Service::Account::ProfileManager manager{};
-        const auto user_ids = manager.GetAllUsers();
-        QStringList list;
-        for (const auto& user_id : user_ids) {
-            if (user_id == Service::Account::UUID{})
-                continue;
-            Service::Account::ProfileBase base;
-            if (!manager.GetProfileBase(user_id, base))
-                continue;
+        const auto select_profile = [this]() -> s32 {
+            QtProfileSelectionDialog dialog(this);
+            dialog.setWindowFlags(Qt::Dialog | Qt::CustomizeWindowHint | Qt::WindowTitleHint |
+                                  Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint);
+            dialog.setWindowModality(Qt::WindowModal);
+            dialog.exec();
 
-            list.push_back(QString::fromStdString(Common::StringFromFixedZeroTerminatedBuffer(
-                reinterpret_cast<const char*>(base.username.data()), base.username.size())));
-        }
+            if (!dialog.GetStatus()) {
+                return -1;
+            }
 
-        bool ok = false;
-        const auto index_string =
-            QInputDialog::getItem(this, tr("Select User"),
-                                  tr("Please select the user's save data you would like to open."),
-                                  list, Settings::values.current_user, false, &ok);
-        if (!ok)
+            return dialog.GetIndex();
+        };
+
+        const auto index = select_profile();
+        if (index == -1)
             return;
 
-        const auto index = list.indexOf(index_string);
-        ASSERT(index != -1 && index < 8);
-
+        Service::Account::ProfileManager manager;
         const auto user_id = manager.GetUser(index);
         ASSERT(user_id);
         path = nand_dir + FileSys::SaveDataFactory::GetFullPath(FileSys::SaveDataSpaceId::NandUser,