mirror of
https://git.citron-emu.org/citron/emulator
synced 2025-12-19 10:43:33 +00:00
3658ae38eb
I messed this file up hardcore too, sorry about that. Made sure to clean it up to look nice again. Signed-off-by: Collecting <collecting@noreply.localhost>
428 lines
19 KiB
C++
428 lines
19 KiB
C++
// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
|
|
// SPDX-FileCopyrightText: Copyright 2025 citron Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include "citron/configuration/configure_filesystem.h"
|
|
#include <QDir>
|
|
#include <QFileDialog>
|
|
#include <QFutureWatcher>
|
|
#include <QMessageBox>
|
|
#include <QProgressDialog>
|
|
#include <QStringList>
|
|
#include <QtConcurrent/QtConcurrent>
|
|
#include <thread>
|
|
#include "citron/main.h"
|
|
#include "citron/uisettings.h"
|
|
#include "common/fs/fs.h"
|
|
#include "common/fs/path_util.h"
|
|
#include "common/literals.h"
|
|
#include "common/settings.h"
|
|
#include "frontend_common/content_manager.h"
|
|
#include "ui_configure_filesystem.h"
|
|
|
|
static constexpr size_t CopyBufferSize = 0x400000;
|
|
|
|
ConfigureFilesystem::ConfigureFilesystem(QWidget* parent)
|
|
: QWidget(parent), ui(std::make_unique<Ui::ConfigureFilesystem>()) {
|
|
ui->setupUi(this);
|
|
SetConfiguration();
|
|
|
|
connect(ui->run_autoloader_button, &QPushButton::clicked, this, &ConfigureFilesystem::OnRunAutoloader);
|
|
connect(ui->nand_directory_button, &QToolButton::pressed, this, [this] { SetDirectory(DirectoryTarget::NAND, ui->nand_directory_edit); });
|
|
connect(ui->sdmc_directory_button, &QToolButton::pressed, this, [this] { SetDirectory(DirectoryTarget::SD, ui->sdmc_directory_edit); });
|
|
connect(ui->gamecard_path_button, &QToolButton::pressed, this, [this] { SetDirectory(DirectoryTarget::Gamecard, ui->gamecard_path_edit); });
|
|
connect(ui->dump_path_button, &QToolButton::pressed, this, [this] { SetDirectory(DirectoryTarget::Dump, ui->dump_path_edit); });
|
|
connect(ui->load_path_button, &QToolButton::pressed, this, [this] { SetDirectory(DirectoryTarget::Load, ui->load_path_edit); });
|
|
connect(ui->reset_game_list_cache, &QPushButton::pressed, this, &ConfigureFilesystem::ResetMetadata);
|
|
connect(ui->gamecard_inserted, &QCheckBox::checkStateChanged, this, &ConfigureFilesystem::UpdateEnabledControls);
|
|
connect(ui->gamecard_current_game, &QCheckBox::checkStateChanged, this, &ConfigureFilesystem::UpdateEnabledControls);
|
|
connect(this, &ConfigureFilesystem::UpdateInstallProgress, this, &ConfigureFilesystem::OnUpdateInstallProgress);
|
|
|
|
#ifdef __linux__
|
|
connect(ui->enable_backups_checkbox, &QCheckBox::toggled, this, &ConfigureFilesystem::UpdateEnabledControls);
|
|
connect(ui->custom_backup_location_checkbox, &QCheckBox::toggled, this, &ConfigureFilesystem::UpdateEnabledControls);
|
|
connect(ui->custom_backup_location_button, &QToolButton::pressed, this, [this] {
|
|
QString dir = QFileDialog::getExistingDirectory(this, tr("Select Backup Directory"));
|
|
if (!dir.isEmpty()) {
|
|
ui->custom_backup_location_edit->setText(dir);
|
|
}
|
|
});
|
|
#endif
|
|
}
|
|
|
|
ConfigureFilesystem::~ConfigureFilesystem() = default;
|
|
|
|
void ConfigureFilesystem::changeEvent(QEvent* event) {
|
|
if (event->type() == QEvent::LanguageChange) {
|
|
RetranslateUI();
|
|
}
|
|
QWidget::changeEvent(event);
|
|
}
|
|
|
|
void ConfigureFilesystem::SetConfiguration() {
|
|
ui->nand_directory_edit->setText(QString::fromStdString(Common::FS::GetCitronPathString(Common::FS::CitronPath::NANDDir)));
|
|
ui->sdmc_directory_edit->setText(QString::fromStdString(Common::FS::GetCitronPathString(Common::FS::CitronPath::SDMCDir)));
|
|
ui->gamecard_path_edit->setText(QString::fromStdString(Settings::values.gamecard_path.GetValue()));
|
|
ui->dump_path_edit->setText(QString::fromStdString(Common::FS::GetCitronPathString(Common::FS::CitronPath::DumpDir)));
|
|
ui->load_path_edit->setText(QString::fromStdString(Common::FS::GetCitronPathString(Common::FS::CitronPath::LoadDir)));
|
|
ui->gamecard_inserted->setChecked(Settings::values.gamecard_inserted.GetValue());
|
|
ui->gamecard_current_game->setChecked(Settings::values.gamecard_current_game.GetValue());
|
|
ui->dump_exefs->setChecked(Settings::values.dump_exefs.GetValue());
|
|
ui->dump_nso->setChecked(Settings::values.dump_nso.GetValue());
|
|
ui->cache_game_list->setChecked(UISettings::values.cache_game_list.GetValue());
|
|
ui->prompt_for_autoloader->setChecked(UISettings::values.prompt_for_autoloader.GetValue());
|
|
|
|
#ifdef __linux__
|
|
ui->enable_backups_checkbox->setChecked(UISettings::values.updater_enable_backups.GetValue());
|
|
const std::string& backup_path = UISettings::values.updater_backup_path.GetValue();
|
|
if (!backup_path.empty()) {
|
|
ui->custom_backup_location_checkbox->setChecked(true);
|
|
ui->custom_backup_location_edit->setText(QString::fromStdString(backup_path));
|
|
} else {
|
|
ui->custom_backup_location_checkbox->setChecked(false);
|
|
}
|
|
m_old_custom_backup_enabled = ui->custom_backup_location_checkbox->isChecked();
|
|
m_old_backup_path = ui->custom_backup_location_edit->text();
|
|
#endif
|
|
|
|
UpdateEnabledControls();
|
|
}
|
|
|
|
void ConfigureFilesystem::ApplyConfiguration() {
|
|
Common::FS::SetCitronPath(Common::FS::CitronPath::NANDDir, ui->nand_directory_edit->text().toStdString());
|
|
Common::FS::SetCitronPath(Common::FS::CitronPath::SDMCDir, ui->sdmc_directory_edit->text().toStdString());
|
|
Common::FS::SetCitronPath(Common::FS::CitronPath::DumpDir, ui->dump_path_edit->text().toStdString());
|
|
Common::FS::SetCitronPath(Common::FS::CitronPath::LoadDir, ui->load_path_edit->text().toStdString());
|
|
Settings::values.gamecard_inserted = ui->gamecard_inserted->isChecked();
|
|
Settings::values.gamecard_current_game = ui->gamecard_current_game->isChecked();
|
|
Settings::values.dump_exefs = ui->dump_exefs->isChecked();
|
|
Settings::values.dump_nso = ui->dump_nso->isChecked();
|
|
UISettings::values.cache_game_list = ui->cache_game_list->isChecked();
|
|
UISettings::values.prompt_for_autoloader = ui->prompt_for_autoloader->isChecked();
|
|
|
|
#ifdef __linux__
|
|
UISettings::values.updater_enable_backups = ui->enable_backups_checkbox->isChecked();
|
|
const bool new_custom_backup_enabled = ui->custom_backup_location_checkbox->isChecked();
|
|
const QString new_backup_path = ui->custom_backup_location_edit->text();
|
|
|
|
if (new_custom_backup_enabled) {
|
|
UISettings::values.updater_backup_path = new_backup_path.toStdString();
|
|
} else {
|
|
UISettings::values.updater_backup_path = "";
|
|
}
|
|
|
|
QByteArray appimage_path_env = qgetenv("APPIMAGE");
|
|
const QString default_path = appimage_path_env.isEmpty() ? QString() : QFileInfo(QString::fromUtf8(appimage_path_env)).dir().filePath(QStringLiteral("backup"));
|
|
|
|
QString old_path_to_check;
|
|
if (m_old_custom_backup_enabled && !m_old_backup_path.isEmpty()) {
|
|
old_path_to_check = m_old_backup_path;
|
|
} else if (!default_path.isEmpty()) {
|
|
old_path_to_check = default_path;
|
|
}
|
|
|
|
QString new_path_to_check;
|
|
if (new_custom_backup_enabled && !new_backup_path.isEmpty()) {
|
|
new_path_to_check = new_backup_path;
|
|
} else if (!default_path.isEmpty()) {
|
|
new_path_to_check = default_path;
|
|
}
|
|
|
|
if (!old_path_to_check.isEmpty() && !new_path_to_check.isEmpty() && old_path_to_check != new_path_to_check) {
|
|
QDir old_dir(old_path_to_check);
|
|
if (old_dir.exists() && !old_dir.entryInfoList({QStringLiteral("citron-backup-*.AppImage")}, QDir::Files).isEmpty()) {
|
|
QMessageBox::StandardButton reply = QMessageBox::question(this, tr("Migrate AppImage Backups?"),
|
|
tr("The backup location has changed. Would you like to move your existing backups from the old location to the new one?"),
|
|
QMessageBox::Yes | QMessageBox::No);
|
|
if (reply == QMessageBox::Yes) {
|
|
MigrateBackups(old_path_to_check, new_path_to_check);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void ConfigureFilesystem::SetDirectory(DirectoryTarget target, QLineEdit* edit) {
|
|
QString caption;
|
|
switch (target) {
|
|
case DirectoryTarget::NAND:
|
|
caption = tr("Select Emulated NAND Directory...");
|
|
break;
|
|
case DirectoryTarget::SD:
|
|
caption = tr("Select Emulated SD Directory...");
|
|
break;
|
|
case DirectoryTarget::Gamecard:
|
|
caption = tr("Select Gamecard Path...");
|
|
break;
|
|
case DirectoryTarget::Dump:
|
|
caption = tr("Select Dump Directory...");
|
|
break;
|
|
case DirectoryTarget::Load:
|
|
caption = tr("Select Mod Load Directory...");
|
|
break;
|
|
}
|
|
|
|
QString str;
|
|
if (target == DirectoryTarget::Gamecard) {
|
|
str = QFileDialog::getOpenFileName(this, caption, QFileInfo(edit->text()).dir().path(),
|
|
QStringLiteral("NX Gamecard;*.xci"));
|
|
} else {
|
|
str = QFileDialog::getExistingDirectory(this, caption, edit->text());
|
|
}
|
|
|
|
if (str.isNull() || str.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
if (str.back() != QChar::fromLatin1('/')) {
|
|
str.append(QChar::fromLatin1('/'));
|
|
}
|
|
edit->setText(str);
|
|
}
|
|
|
|
void ConfigureFilesystem::ResetMetadata() {
|
|
if (!Common::FS::Exists(Common::FS::GetCitronPath(Common::FS::CitronPath::CacheDir) / "game_list/")) {
|
|
QMessageBox::information(this, tr("Reset Metadata Cache"), tr("The metadata cache is already empty."));
|
|
} else if (Common::FS::RemoveDirRecursively(Common::FS::GetCitronPath(Common::FS::CitronPath::CacheDir) / "game_list")) {
|
|
QMessageBox::information(this, tr("Reset Metadata Cache"), tr("The operation completed successfully."));
|
|
UISettings::values.is_game_list_reload_pending.exchange(true);
|
|
} else {
|
|
QMessageBox::warning(this, tr("Reset Metadata Cache"), tr("The metadata cache couldn't be deleted. It might be in use or non-existent."));
|
|
}
|
|
}
|
|
|
|
void ConfigureFilesystem::UpdateEnabledControls() {
|
|
ui->gamecard_current_game->setEnabled(ui->gamecard_inserted->isChecked());
|
|
ui->gamecard_path_edit->setEnabled(ui->gamecard_inserted->isChecked() && !ui->gamecard_current_game->isChecked());
|
|
ui->gamecard_path_button->setEnabled(ui->gamecard_inserted->isChecked() && !ui->gamecard_current_game->isChecked());
|
|
|
|
#ifdef __linux__
|
|
ui->updater_group->setVisible(true);
|
|
bool backups_enabled = ui->enable_backups_checkbox->isChecked();
|
|
ui->custom_backup_location_checkbox->setEnabled(backups_enabled);
|
|
|
|
bool useCustomBackup = backups_enabled && ui->custom_backup_location_checkbox->isChecked();
|
|
ui->custom_backup_location_edit->setEnabled(useCustomBackup);
|
|
ui->custom_backup_location_button->setEnabled(useCustomBackup);
|
|
#else
|
|
ui->updater_group->setVisible(false);
|
|
#endif
|
|
}
|
|
|
|
void ConfigureFilesystem::RetranslateUI() {
|
|
ui->retranslateUi(this);
|
|
}
|
|
|
|
#ifdef __linux__
|
|
void ConfigureFilesystem::MigrateBackups(const QString& old_path, const QString& new_path) {
|
|
QDir old_dir(old_path);
|
|
if (!old_dir.exists()) {
|
|
QMessageBox::warning(this, tr("Migration Error"), tr("The old backup location does not exist."));
|
|
return;
|
|
}
|
|
|
|
QStringList name_filters;
|
|
name_filters << QStringLiteral("citron-backup-*.AppImage");
|
|
QFileInfoList files_to_move = old_dir.entryInfoList(name_filters, QDir::Files);
|
|
|
|
if (files_to_move.isEmpty()) {
|
|
QMessageBox::information(this, tr("Migration Complete"), tr("No backup files were found to migrate."));
|
|
return;
|
|
}
|
|
|
|
auto progress = new QProgressDialog(tr("Moving backup files..."), tr("Cancel"), 0, files_to_move.count(), this);
|
|
progress->setWindowModality(Qt::WindowModal);
|
|
progress->setMinimumDuration(1000);
|
|
progress->show();
|
|
|
|
auto watcher = new QFutureWatcher<bool>(this);
|
|
connect(watcher, &QFutureWatcher<bool>::finished, this, [this, watcher, progress] {
|
|
progress->close();
|
|
if (watcher->future().isCanceled()) {
|
|
QMessageBox::warning(this, tr("Migration Canceled"), tr("The migration was canceled. Some files may have been moved."));
|
|
} else if (watcher->future().result()) {
|
|
QMessageBox::information(this, tr("Migration Complete"), tr("All backup files were successfully moved to the new location."));
|
|
} else {
|
|
QMessageBox::critical(this, tr("Migration Failed"), tr("An error occurred while moving files. Some files may not have been moved. Please check both locations."));
|
|
}
|
|
watcher->deleteLater();
|
|
});
|
|
connect(progress, &QProgressDialog::canceled, watcher, &QFutureWatcher<void>::cancel);
|
|
|
|
QFuture<bool> future = QtConcurrent::run([=] {
|
|
QDir new_dir(new_path);
|
|
if (!new_dir.exists()) {
|
|
if (!new_dir.mkpath(QStringLiteral("."))) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < files_to_move.count(); ++i) {
|
|
if (progress->wasCanceled()) {
|
|
return false;
|
|
}
|
|
progress->setValue(i);
|
|
const auto& file_info = files_to_move.at(i);
|
|
QString new_file_path = new_dir.filePath(file_info.fileName());
|
|
|
|
if (QFile::exists(new_file_path)) {
|
|
if (!QFile::remove(new_file_path)) {
|
|
return false; // Failed to remove existing file
|
|
}
|
|
}
|
|
if (!QFile::copy(file_info.absoluteFilePath(), new_file_path)) {
|
|
return false; // Copy operation failed
|
|
}
|
|
if (!QFile::remove(file_info.absoluteFilePath())) {
|
|
return false; // Delete operation failed
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
|
|
watcher->setFuture(future);
|
|
}
|
|
#endif
|
|
|
|
void ConfigureFilesystem::OnUpdateInstallProgress() {
|
|
if (install_progress) {
|
|
install_progress->setValue(install_progress->value() + 1);
|
|
}
|
|
}
|
|
|
|
void ConfigureFilesystem::OnRunAutoloader(bool skip_confirmation) {
|
|
if (!skip_confirmation) {
|
|
QMessageBox msgBox;
|
|
msgBox.setWindowTitle(tr("Begin Autoloader?"));
|
|
msgBox.setText(tr("The Autoloader will scan your Game Directories for all .nsp files "
|
|
"and attempt to install any found updates or DLC. This may take a while."));
|
|
msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(QMessageBox::Ok);
|
|
if (msgBox.exec() != QMessageBox::Ok) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
GMainWindow* main_window = qobject_cast<GMainWindow*>(this->parent());
|
|
if (!main_window) {
|
|
main_window = qobject_cast<GMainWindow*>(this->window()->parent());
|
|
}
|
|
|
|
if (!main_window) {
|
|
QMessageBox::critical(this, tr("Error"), tr("Could not find the main window."));
|
|
return;
|
|
}
|
|
Core::System* system = main_window->GetSystem();
|
|
const auto& vfs = main_window->GetVFS();
|
|
if (!system) {
|
|
QMessageBox::critical(this, tr("Error"), tr("System is not initialized."));
|
|
return;
|
|
}
|
|
|
|
QStringList files_to_install;
|
|
for (const auto& game_dir : UISettings::values.game_dirs) {
|
|
Common::FS::IterateDirEntriesRecursively(game_dir.path, [&](const auto& entry) {
|
|
if (!entry.is_directory() && entry.path().extension() == ".nsp") {
|
|
files_to_install.append(QString::fromStdString(entry.path().string()));
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
if (files_to_install.isEmpty()) {
|
|
QMessageBox::information(this, tr("Autoloader"), tr("No .nsp files found to install."));
|
|
return;
|
|
}
|
|
|
|
qint64 total_chunks = 0;
|
|
for (const QString& file : files_to_install) {
|
|
total_chunks += (QFileInfo(file).size() + CopyBufferSize - 1) / CopyBufferSize;
|
|
}
|
|
if (total_chunks == 0) {
|
|
QMessageBox::information(this, tr("Autoloader"), tr("Selected files are empty."));
|
|
return;
|
|
}
|
|
|
|
QStringList new_files{}, overwritten_files{}, failed_files{};
|
|
bool detected_base_install{};
|
|
bool was_cancelled = false;
|
|
|
|
install_progress = new QProgressDialog(QString{}, tr("Cancel"), 0, static_cast<int>(total_chunks), this);
|
|
install_progress->setWindowFlags(install_progress->windowFlags() & ~Qt::WindowContextHelpButtonHint);
|
|
install_progress->setAttribute(Qt::WA_DeleteOnClose, true);
|
|
install_progress->setFixedWidth(400);
|
|
connect(install_progress, &QObject::destroyed, this, [this]() { install_progress = nullptr; });
|
|
install_progress->show();
|
|
|
|
int remaining = files_to_install.size();
|
|
for (const QString& file : files_to_install) {
|
|
if (!install_progress || install_progress->wasCanceled()) {
|
|
was_cancelled = true;
|
|
break;
|
|
}
|
|
|
|
install_progress->setWindowTitle(tr("Autoloader - %n file(s) remaining", "", remaining));
|
|
install_progress->setLabelText(tr("Installing: %1").arg(QFileInfo(file).fileName()));
|
|
|
|
auto progress_callback = [this](size_t, size_t) {
|
|
emit UpdateInstallProgress();
|
|
if (!install_progress) return true;
|
|
return install_progress->wasCanceled();
|
|
};
|
|
|
|
QFuture<ContentManager::InstallResult> future =
|
|
QtConcurrent::run([&] { return ContentManager::InstallNSP(*system, *vfs, file.toStdString(), progress_callback); });
|
|
|
|
while (!future.isFinished()) {
|
|
QCoreApplication::processEvents();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
}
|
|
|
|
ContentManager::InstallResult result = future.result();
|
|
|
|
switch (result) {
|
|
case ContentManager::InstallResult::Success:
|
|
new_files.append(QFileInfo(file).fileName());
|
|
break;
|
|
case ContentManager::InstallResult::Overwrite:
|
|
overwritten_files.append(QFileInfo(file).fileName());
|
|
break;
|
|
case ContentManager::InstallResult::Failure:
|
|
failed_files.append(QFileInfo(file).fileName());
|
|
break;
|
|
case ContentManager::InstallResult::BaseInstallAttempted:
|
|
failed_files.append(QFileInfo(file).fileName());
|
|
detected_base_install = true;
|
|
break;
|
|
}
|
|
--remaining;
|
|
}
|
|
|
|
if (install_progress) {
|
|
install_progress->close();
|
|
}
|
|
|
|
if (detected_base_install) {
|
|
QMessageBox::warning(this, tr("Install Results"), tr("Warning: Base games were detected and skipped. The autoloader is intended for updates and DLC."));
|
|
}
|
|
|
|
if (new_files.isEmpty() && overwritten_files.isEmpty() && failed_files.isEmpty()) {
|
|
if (!was_cancelled) {
|
|
QMessageBox::information(this, tr("Autoloader"), tr("No new files were installed."));
|
|
}
|
|
} else {
|
|
QString install_results = tr("Installation Complete!");
|
|
install_results.append(QLatin1String("\n\n"));
|
|
if (!new_files.isEmpty())
|
|
install_results.append(tr("%n file(s) were newly installed.", nullptr, new_files.size()));
|
|
if (!overwritten_files.isEmpty())
|
|
install_results.append(tr("\n%n file(s) were overwritten.", nullptr, overwritten_files.size()));
|
|
if (!failed_files.isEmpty())
|
|
install_results.append(tr("\n%n file(s) failed to install.", nullptr, failed_files.size()));
|
|
QMessageBox::information(this, tr("Install Results"), install_results);
|
|
}
|
|
|
|
Common::FS::RemoveDirRecursively(Common::FS::GetCitronPath(Common::FS::CitronPath::CacheDir) / "game_list");
|
|
emit RequestGameListRefresh();
|
|
}
|