debuggerx/eden
1
0
Fork 0
mirror of https://git.eden-emu.dev/eden-emu/eden.git synced 2026-08-23 07:56:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

[desktop] refactor profile management and fix some misc bugs with it (#3415)

Browse Source 
Adding and editing users is now done in a single dialog rather than all those other individual buttons and dialogs like before.

Fixed some bugs with profile management too, and made edit/delete a right-click menu.

Signed-off-by: crueter <crueter@eden-emu.dev>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3415
This commit is contained in:
crueter
2026-01-29 17:17:28 +01:00
parent 9cf3a04af3
commit b2b98ac83a
12 changed files with 959 additions and 469 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/yuzu/configuration/configure_profile_manager.cpp
+127 -382
View File
@@ -6,7 +6,7 @@
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <QColorDialog>
#include <QDialog>
#include <QDialogButtonBox>
@@ -14,27 +14,25 @@
#include <QGraphicsItem>
#include <QHeaderView>
#include <QListWidget>
#include <QMenu>
#include <QMessageBox>
#include <QStandardItemModel>
#include <QTreeView>
#include <qnamespace.h>
#include <qtreeview.h>
#include "common/assert.h"
#include "common/fs/path_util.h"
#include "common/settings.h"
#include "common/string_util.h"
#include "common/swap.h"
#include "configuration/system/new_user_dialog.h"
#include "core/constants.h"
#include "core/core.h"
#include "core/file_sys/content_archive.h"
#include "core/file_sys/nca_metadata.h"
#include "core/file_sys/registered_cache.h"
#include "core/file_sys/romfs.h"
#include "core/file_sys/vfs/vfs.h"
#include "core/hle/service/acc/profile_manager.h"
#include "core/hle/service/filesystem/filesystem.h"
#include "ui_configure_profile_manager.h"
#include "yuzu/util/limitable_input_dialog.h"
#include "yuzu/configuration/configure_profile_manager.h"
#include "yuzu/util/limitable_input_dialog.h"
namespace {
@@ -75,9 +73,6 @@ QPixmap GetIcon(const Common::UUID& uuid) {
return icon.scaled(64, 64, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
}
QString GetProfileUsernameFromUser(QWidget* parent, const QString& title, const QString& text) {
return LimitableInputDialog::GetText(parent, title, text, 1, int(Service::Account::profile_username_size));
}
} // Anonymous namespace
ConfigureProfileManager::ConfigureProfileManager(Core::System& system_, QWidget* parent)
@@ -98,7 +93,7 @@ ConfigureProfileManager::ConfigureProfileManager(Core::System& system_, QWidget*
tree_view->setEditTriggers(QHeaderView::NoEditTriggers);
tree_view->setUniformRowHeights(true);
tree_view->setIconSize({64, 64});
tree_view->setContextMenuPolicy(Qt::NoContextMenu);
tree_view->setContextMenuPolicy(Qt::CustomContextMenu);
// We must register all custom types with the Qt Automoc system so that we are able to use it
// with signals/slots. In this case, QList falls under the umbrells of custom types.
@@ -111,18 +106,12 @@ ConfigureProfileManager::ConfigureProfileManager(Core::System& system_, QWidget*
ui->scrollArea->setLayout(layout);
connect(tree_view, &QTreeView::customContextMenuRequested, this, &ConfigureProfileManager::showContextMenu);
connect(tree_view, &QTreeView::clicked, this, &ConfigureProfileManager::SelectUser);
connect(ui->pm_add, &QPushButton::clicked, this, &ConfigureProfileManager::AddUser);
connect(ui->pm_rename, &QPushButton::clicked, this, &ConfigureProfileManager::RenameUser);
connect(ui->pm_remove, &QPushButton::clicked, this,
&ConfigureProfileManager::ConfirmDeleteUser);
connect(ui->pm_set_image, &QPushButton::clicked, this,
&ConfigureProfileManager::SelectImageFile);
connect(ui->pm_select_avatar, &QPushButton::clicked, this,
&ConfigureProfileManager::SelectFirmwareAvatar);
avatar_dialog = new ConfigureProfileManagerAvatarDialog(this);
confirm_dialog = new ConfigureProfileManagerDeleteDialog(this);
scene = new QGraphicsScene;
@@ -160,8 +149,9 @@ void ConfigureProfileManager::PopulateUserList() {
const auto& profiles = profile_manager.GetAllUsers();
for (const auto& user : profiles) {
Service::Account::ProfileBase profile{};
if (!profile_manager.GetProfileBase(user, profile))
if (!profile_manager.GetProfileBase(user, profile)) {
continue;
}
const auto username = Common::StringFromFixedZeroTerminatedBuffer(
reinterpret_cast<const char*>(profile.username.data()), profile.username.size());
@@ -183,7 +173,7 @@ void ConfigureProfileManager::UpdateCurrentUser() {
scene->clear();
scene->addPixmap(
GetIcon(*current_user).scaled(48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
GetIcon(*current_user).scaled(64, 64, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
ui->current_user_username->setText(username);
}
@@ -193,100 +183,8 @@ void ConfigureProfileManager::ApplyConfiguration() {
}
}
void ConfigureProfileManager::SelectUser(const QModelIndex& index) {
Settings::values.current_user =
std::clamp<s32>(index.row(), 0, static_cast<s32>(profile_manager.GetUserCount() - 1));
UpdateCurrentUser();
ui->pm_remove->setEnabled(profile_manager.GetUserCount() >= 2);
ui->pm_rename->setEnabled(true);
ui->pm_set_image->setEnabled(true);
ui->pm_select_avatar->setEnabled(true);
}
void ConfigureProfileManager::AddUser() {
auto const username = GetProfileUsernameFromUser(this, tr("New Username"), tr("Enter a username:"));
if (username.isEmpty())
return;
auto const uuid_str = GetProfileUsernameFromUser(this, tr("New User UUID"), tr("Enter a UUID (leave empty to autogenerate):"));
auto uuid = Common::UUID::MakeRandom();
if (uuid_str.length() > 0) {
if (size_t(uuid_str.length()) != uuid.uuid.size())
return;
for (size_t i = 0; i < size_t(uuid_str.length()); ++i)
uuid.uuid[i] = u8(uuid_str[i].toLatin1());
}
profile_manager.CreateNewUser(uuid, username.toStdString());
profile_manager.WriteUserSaveFile();
item_model->appendRow(new QStandardItem{GetIcon(uuid), FormatUserEntryText(username, uuid)});
}
void ConfigureProfileManager::RenameUser() {
const auto user = tree_view->currentIndex().row();
const auto uuid = profile_manager.GetUser(user);
ASSERT(uuid);
Service::Account::ProfileBase profile{};
if (!profile_manager.GetProfileBase(*uuid, profile))
return;
const auto new_username = GetProfileUsernameFromUser(this, tr("New Username"), tr("Enter a new username:"));
if (new_username.isEmpty()) {
return;
}
const auto username_std = new_username.toStdString();
std::fill(profile.username.begin(), profile.username.end(), '\0');
std::copy(username_std.begin(), username_std.end(), profile.username.begin());
profile_manager.SetProfileBase(*uuid, profile);
profile_manager.WriteUserSaveFile();
item_model->setItem(
user, 0,
new QStandardItem{GetIcon(*uuid),
FormatUserEntryText(QString::fromStdString(username_std), *uuid)});
UpdateCurrentUser();
}
void ConfigureProfileManager::ConfirmDeleteUser() {
const auto index = tree_view->currentIndex().row();
const auto uuid = profile_manager.GetUser(index);
ASSERT(uuid);
const auto username = GetAccountUsername(profile_manager, *uuid);
confirm_dialog->SetInfo(username, *uuid, [this, uuid]() { DeleteUser(*uuid); });
confirm_dialog->show();
}
void ConfigureProfileManager::DeleteUser(const Common::UUID& uuid) {
if (Settings::values.current_user.GetValue() == tree_view->currentIndex().row()) {
Settings::values.current_user = 0;
}
UpdateCurrentUser();
if (!profile_manager.RemoveUser(uuid)) {
return;
}
profile_manager.WriteUserSaveFile();
item_model->removeRows(tree_view->currentIndex().row(), 1);
tree_view->clearSelection();
ui->pm_remove->setEnabled(false);
ui->pm_rename->setEnabled(false);
}
void ConfigureProfileManager::SetUserImage(const QImage& image) {
const auto index = tree_view->currentIndex().row();
const auto uuid = profile_manager.GetUser(index);
ASSERT(uuid);
const auto image_path = GetImagePath(*uuid);
void ConfigureProfileManager::saveImage(QPixmap pixmap, Common::UUID uuid) {
const auto image_path = GetImagePath(uuid);
if (QFile::exists(image_path) && !QFile::remove(image_path)) {
QMessageBox::warning(
this, tr("Error deleting image"),
@@ -311,227 +209,140 @@ void ConfigureProfileManager::SetUserImage(const QImage& image) {
return;
}
if (!image.save(image_path, "JPEG", 100)) {
if (!pixmap.save(image_path, "JPEG", 100)) {
QMessageBox::warning(this, tr("Error saving user image"),
tr("Unable to save image to file"));
return;
}
}
void ConfigureProfileManager::showContextMenu(const QPoint& pos) {
const QModelIndex index = tree_view->indexAt(pos);
if (!index.isValid())
return;
QMenu menu(this);
QAction* edit = menu.addAction(tr("&Edit"));
QAction* remove = menu.addAction(tr("&Delete"));
QAction* chosen =
menu.exec(tree_view->viewport()->mapToGlobal(pos));
if (!chosen)
return;
if (chosen == edit) {
EditUser();
} else if (chosen == remove) {
ConfirmDeleteUser();
}
}
void ConfigureProfileManager::SelectUser(const QModelIndex& index) {
Settings::values.current_user =
std::clamp<s32>(index.row(), 0, static_cast<s32>(profile_manager.GetUserCount() - 1));
const auto username = GetAccountUsername(profile_manager, *uuid);
item_model->setItem(index, 0,
new QStandardItem{GetIcon(*uuid), FormatUserEntryText(username, *uuid)});
UpdateCurrentUser();
}
void ConfigureProfileManager::SelectImageFile() {
const auto file = QFileDialog::getOpenFileName(this, tr("Select User Image"), QString(),
tr("Image Formats (*.jpg *.jpeg *.png *.bmp)"));
if (file.isEmpty()) {
return;
}
void ConfigureProfileManager::AddUser() {
NewUserDialog *dialog = new NewUserDialog(this);
// Profile image must be 256x256
QImage image(file);
if (image.width() != 256 || image.height() != 256) {
image = image.scaled(256, 256, Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation);
}
SetUserImage(image);
}
connect(dialog, &NewUserDialog::userAdded, this, [dialog, this](User user) {
auto uuid = user.uuid;
auto username = user.username;
auto pixmap = user.pixmap;
void ConfigureProfileManager::SelectFirmwareAvatar() {
if (!avatar_dialog->AreImagesLoaded()) {
if (!LoadAvatarData()) {
return;
}
}
if (avatar_dialog->exec() == QDialog::Accepted) {
SetUserImage(avatar_dialog->GetSelectedAvatar().toImage());
}
}
profile_manager.CreateNewUser(uuid, username.toStdString());
profile_manager.WriteUserSaveFile();
item_model->appendRow(new QStandardItem{pixmap, FormatUserEntryText(username, uuid)});
bool ConfigureProfileManager::LoadAvatarData() {
constexpr u64 AvatarImageDataId = 0x010000000000080AULL;
saveImage(pixmap, uuid);
UpdateCurrentUser();
// Attempt to load avatar data archive from installed firmware
auto* bis_system = system.GetFileSystemController().GetSystemNANDContents();
if (!bis_system) {
QMessageBox::warning(this, tr("No firmware available"),
tr("Please install the firmware to use firmware avatars."));
return false;
}
const auto nca = bis_system->GetEntry(AvatarImageDataId, FileSys::ContentRecordType::Data);
if (!nca) {
QMessageBox::warning(this, tr("Error loading archive"),
tr("Archive is not available. Please install/reinstall firmware."));
return false;
}
const auto romfs = nca->GetRomFS();
if (!romfs) {
QMessageBox::warning(this, tr("Error loading archive"),
tr("Could not locate RomFS. Your file or decryption keys may be corrupted."));
return false;
}
const auto extracted = FileSys::ExtractRomFS(romfs);
if (!extracted) {
QMessageBox::warning(this, tr("Error extracting archive"),
tr("Could not extract RomFS. Your file or decryption keys may be corrupted."));
return false;
}
const auto chara_dir = extracted->GetSubdirectory("chara");
if (!chara_dir) {
QMessageBox::warning(this, tr("Error finding image directory"),
tr("Failed to find image directory in the archive."));
return false;
}
QVector<QPixmap> images;
for (const auto& item : chara_dir->GetFiles()) {
if (item->GetExtension() != "szs") {
continue;
}
auto image_data = DecompressYaz0(item);
if (image_data.empty()) {
continue;
}
QImage image(reinterpret_cast<const uchar*>(image_data.data()), 256, 256,
QImage::Format_RGBA8888);
images.append(QPixmap::fromImage(image));
}
if (images.isEmpty()) {
QMessageBox::warning(this, tr("No images found"),
tr("No avatar images were found in the archive."));
return false;
}
// Load the image data into the dialog
avatar_dialog->LoadImages(images);
return true;
}
ConfigureProfileManagerAvatarDialog::ConfigureProfileManagerAvatarDialog(QWidget* parent)
: QDialog{parent}, avatar_list{new QListWidget(this)}, bg_color_button{new QPushButton(this)} {
auto* main_layout = new QVBoxLayout(this);
auto* button_layout = new QHBoxLayout();
auto* select_button = new QPushButton(tr("Select"), this);
auto* cancel_button = new QPushButton(tr("Cancel"), this);
auto* bg_color_label = new QLabel(tr("Background Color"), this);
SetBackgroundColor(Qt::white);
avatar_list->setViewMode(QListView::IconMode);
avatar_list->setIconSize(QSize(64, 64));
avatar_list->setSpacing(4);
avatar_list->setResizeMode(QListView::Adjust);
avatar_list->setSelectionMode(QAbstractItemView::SingleSelection);
avatar_list->setEditTriggers(QAbstractItemView::NoEditTriggers);
avatar_list->setDragDropMode(QAbstractItemView::NoDragDrop);
avatar_list->setDragEnabled(false);
avatar_list->setDropIndicatorShown(false);
avatar_list->setAcceptDrops(false);
button_layout->addWidget(bg_color_button);
button_layout->addWidget(bg_color_label);
button_layout->addStretch();
button_layout->addWidget(select_button);
button_layout->addWidget(cancel_button);
this->setWindowTitle(tr("Select Firmware Avatar"));
main_layout->addWidget(avatar_list);
main_layout->addLayout(button_layout);
connect(bg_color_button, &QPushButton::clicked, this, [this]() {
const auto new_color = QColorDialog::getColor(avatar_bg_color);
if (new_color.isValid()) {
SetBackgroundColor(new_color);
RefreshAvatars();
}
dialog->deleteLater();
});
connect(select_button, &QPushButton::clicked, this, [this]() { accept(); });
connect(cancel_button, &QPushButton::clicked, this, [this]() { reject(); });
connect(dialog, &QDialog::rejected, dialog, &QObject::deleteLater);
dialog->show();
}
ConfigureProfileManagerAvatarDialog::~ConfigureProfileManagerAvatarDialog() = default;
void ConfigureProfileManager::EditUser() {
const auto user_data = tree_view->currentIndex();
const auto user_idx = user_data.row();
const auto uuid = profile_manager.GetUser(user_idx);
ASSERT(uuid);
void ConfigureProfileManagerAvatarDialog::SetBackgroundColor(const QColor& color) {
avatar_bg_color = color;
Service::Account::ProfileBase profile{};
if (!profile_manager.GetProfileBase(*uuid, profile))
return;
bg_color_button->setStyleSheet(
QStringLiteral("background-color: %1; min-width: 60px;").arg(avatar_bg_color.name()));
std::string username;
username.reserve(32);
std::ranges::copy_if(profile.username, std::back_inserter(username), [](u8 byte) { return byte != 0; });
NewUserDialog *dialog = new NewUserDialog(uuid.value(), username, tr("Edit User"), this);
connect(dialog, &NewUserDialog::userAdded, this, [dialog, profile, user_idx, uuid, this](User user) mutable {
// TODO: MOVE UUID
// auto new_uuid = user.uuid;
auto new_username = user.username;
auto pixmap = user.pixmap;
auto const uuid_val = uuid.value();
const auto username_std = new_username.toStdString();
std::fill(profile.username.begin(), profile.username.end(), '\0');
std::copy(username_std.begin(), username_std.end(), profile.username.begin());
profile_manager.SetProfileBase(uuid_val, profile);
profile_manager.WriteUserSaveFile();
item_model->setItem(
user_idx, 0,
new QStandardItem{pixmap,
FormatUserEntryText(QString::fromStdString(username_std), uuid_val)});
saveImage(pixmap, uuid_val);
UpdateCurrentUser();
dialog->deleteLater();
});
connect(dialog, &QDialog::rejected, dialog, &QObject::deleteLater);
dialog->show();
}
QPixmap ConfigureProfileManagerAvatarDialog::CreateAvatar(const QPixmap& avatar) {
QPixmap output(avatar.size());
output.fill(avatar_bg_color);
void ConfigureProfileManager::ConfirmDeleteUser() {
const auto index = tree_view->currentIndex().row();
const auto uuid = profile_manager.GetUser(index);
ASSERT(uuid);
const auto username = GetAccountUsername(profile_manager, *uuid);
// Scale the image and fill it black to become our shadow
QPixmap shadow_pixmap = avatar.transformed(QTransform::fromScale(1.04, 1.04));
QPainter shadow_painter(&shadow_pixmap);
shadow_painter.setCompositionMode(QPainter::CompositionMode_SourceIn);
shadow_painter.fillRect(shadow_pixmap.rect(), Qt::black);
shadow_painter.end();
QPainter painter(&output);
painter.setOpacity(0.10);
painter.drawPixmap(0, 0, shadow_pixmap);
painter.setOpacity(1.0);
painter.drawPixmap(0, 0, avatar);
painter.end();
return output;
confirm_dialog->SetInfo(username, *uuid, [this, uuid]() { DeleteUser(*uuid); });
confirm_dialog->show();
}
void ConfigureProfileManagerAvatarDialog::RefreshAvatars() {
if (avatar_list->count() != avatar_image_store.size()) {
void ConfigureProfileManager::DeleteUser(const Common::UUID& uuid) {
if (Settings::values.current_user.GetValue() == tree_view->currentIndex().row()) {
Settings::values.current_user = 0;
}
if (!profile_manager.RemoveUser(uuid)) {
return;
}
for (int i = 0; i < avatar_image_store.size(); ++i) {
const auto icon =
QIcon(CreateAvatar(avatar_image_store[i])
.scaled(64, 64, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
avatar_list->item(i)->setIcon(icon);
}
}
void ConfigureProfileManagerAvatarDialog::LoadImages(const QVector<QPixmap>& avatar_images) {
avatar_image_store = avatar_images;
avatar_list->clear();
profile_manager.WriteUserSaveFile();
profile_manager.ResetUserSaveFile();
for (int i = 0; i < avatar_image_store.size(); ++i) {
avatar_list->addItem(new QListWidgetItem);
}
RefreshAvatars();
UpdateCurrentUser();
// Determine window size now that avatars are loaded into the grid
// There is probably a better way to handle this that I'm unaware of
const auto* style = avatar_list->style();
const int icon_size = avatar_list->iconSize().width();
const int icon_spacing = avatar_list->spacing() * 2;
const int icon_margin = style->pixelMetric(QStyle::PM_FocusFrameHMargin);
const int icon_full_size = icon_size + icon_spacing + icon_margin;
const int horizontal_margin = style->pixelMetric(QStyle::PM_LayoutLeftMargin) +
style->pixelMetric(QStyle::PM_LayoutRightMargin) +
style->pixelMetric(QStyle::PM_ScrollBarExtent);
const int vertical_margin = style->pixelMetric(QStyle::PM_LayoutTopMargin) +
style->pixelMetric(QStyle::PM_LayoutBottomMargin);
// Set default list size so that it is 6 icons wide and 4.5 tall
const int columns = 6;
const double rows = 4.5;
const int total_width = icon_full_size * columns + horizontal_margin;
const int total_height = icon_full_size * rows + vertical_margin;
avatar_list->setMinimumSize(total_width, total_height);
}
bool ConfigureProfileManagerAvatarDialog::AreImagesLoaded() const {
return !avatar_image_store.isEmpty();
}
QPixmap ConfigureProfileManagerAvatarDialog::GetSelectedAvatar() {
return CreateAvatar(avatar_image_store[avatar_list->currentRow()]);
item_model->removeRows(tree_view->currentIndex().row(), 1);
tree_view->clearSelection();
}
ConfigureProfileManagerDeleteDialog::ConfigureProfileManagerDeleteDialog(QWidget* parent)
@@ -548,18 +359,24 @@ ConfigureProfileManagerDeleteDialog::ConfigureProfileManagerDeleteDialog(QWidget
auto icon_view = new QGraphicsView(icon_scene, this);
dialog_hbox_layout_widget->setLayout(dialog_hbox_layout);
icon_view->setMinimumSize(64, 64);
icon_view->setMaximumSize(64, 64);
icon_view->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
icon_view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
icon_view->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
this->setLayout(dialog_vbox_layout);
this->setWindowTitle(tr("Confirm Delete"));
this->setSizeGripEnabled(false);
dialog_vbox_layout->addWidget(label_message);
dialog_vbox_layout->addWidget(dialog_hbox_layout_widget);
dialog_vbox_layout->addWidget(dialog_button_box);
dialog_hbox_layout->addWidget(icon_view);
dialog_hbox_layout->addWidget(label_info);
setMinimumSize(380, 160);
connect(dialog_button_box, &QDialogButtonBox::rejected, this, [this]() { close(); });
}
@@ -577,75 +394,3 @@ void ConfigureProfileManagerDeleteDialog::SetInfo(const QString& username, const
accept_callback();
});
}
std::vector<uint8_t> ConfigureProfileManager::DecompressYaz0(const FileSys::VirtualFile& file) {
if (!file) {
throw std::invalid_argument("Null file pointer passed to DecompressYaz0");
}
uint32_t magic{};
file->ReadObject(&magic, 0);
if (magic != Common::MakeMagic('Y', 'a', 'z', '0')) {
return std::vector<uint8_t>();
}
uint32_t decoded_length{};
file->ReadObject(&decoded_length, 4);
decoded_length = Common::swap32(decoded_length);
std::size_t input_size = file->GetSize() - 16;
std::vector<uint8_t> input(input_size);
file->ReadBytes(input.data(), input_size, 16);
uint32_t input_offset{};
uint32_t output_offset{};
std::vector<uint8_t> output(decoded_length);
uint16_t mask{};
uint8_t header{};
while (output_offset < decoded_length) {
if ((mask >>= 1) == 0) {
header = input[input_offset++];
mask = 0x80;
}
if ((header & mask) != 0) {
if (output_offset == output.size()) {
break;
}
output[output_offset++] = input[input_offset++];
} else {
uint8_t byte1 = input[input_offset++];
uint8_t byte2 = input[input_offset++];
uint32_t dist = ((byte1 & 0xF) << 8) | byte2;
uint32_t position = output_offset - (dist + 1);
uint32_t length = byte1 >> 4;
if (length == 0) {
length = static_cast<uint32_t>(input[input_offset++]) + 0x12;
} else {
length += 2;
}
uint32_t gap = output_offset - position;
uint32_t non_overlapping_length = length;
if (non_overlapping_length > gap) {
non_overlapping_length = gap;
}
std::memcpy(&output[output_offset], &output[position], non_overlapping_length);
output_offset += non_overlapping_length;
position += non_overlapping_length;
length -= non_overlapping_length;
while (length-- > 0) {
output[output_offset++] = output[position++];
}
}
}
return output;
}