forked from eden-emu/eden
400 lines
15 KiB
C++
400 lines
15 KiB
C++
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
#include "qt_game_util.h"
|
|
#include "common/fs/fs.h"
|
|
#include "common/fs/path_util.h"
|
|
#include "core/file_sys/savedata_factory.h"
|
|
#include "frontend_common/content_manager.h"
|
|
#include "qt_common.h"
|
|
#include "qt_common/uisettings.h"
|
|
#include "qt_frontend_util.h"
|
|
|
|
#include <QDesktopServices>
|
|
#include <QUrl>
|
|
|
|
#ifdef _WIN32
|
|
#include "common/scope_exit.h"
|
|
#include "common/string_util.h"
|
|
#include <shlobj.h>
|
|
#include <windows.h>
|
|
#else
|
|
#include "fmt/ostream.h"
|
|
#include <fstream>
|
|
#endif
|
|
|
|
namespace QtCommon::Game {
|
|
|
|
bool CreateShortcutLink(const std::filesystem::path& shortcut_path,
|
|
const std::string& comment,
|
|
const std::filesystem::path& icon_path,
|
|
const std::filesystem::path& command,
|
|
const std::string& arguments,
|
|
const std::string& categories,
|
|
const std::string& keywords,
|
|
const std::string& name)
|
|
try {
|
|
#ifdef _WIN32 // Windows
|
|
HRESULT hr = CoInitialize(nullptr);
|
|
if (FAILED(hr)) {
|
|
LOG_ERROR(Frontend, "CoInitialize failed");
|
|
return false;
|
|
}
|
|
SCOPE_EXIT
|
|
{
|
|
CoUninitialize();
|
|
};
|
|
IShellLinkW* ps1 = nullptr;
|
|
IPersistFile* persist_file = nullptr;
|
|
SCOPE_EXIT
|
|
{
|
|
if (persist_file != nullptr) {
|
|
persist_file->Release();
|
|
}
|
|
if (ps1 != nullptr) {
|
|
ps1->Release();
|
|
}
|
|
};
|
|
HRESULT hres = CoCreateInstance(CLSID_ShellLink,
|
|
nullptr,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IShellLinkW,
|
|
reinterpret_cast<void**>(&ps1));
|
|
if (FAILED(hres)) {
|
|
LOG_ERROR(Frontend, "Failed to create IShellLinkW instance");
|
|
return false;
|
|
}
|
|
hres = ps1->SetPath(command.c_str());
|
|
if (FAILED(hres)) {
|
|
LOG_ERROR(Frontend, "Failed to set path");
|
|
return false;
|
|
}
|
|
if (!arguments.empty()) {
|
|
hres = ps1->SetArguments(Common::UTF8ToUTF16W(arguments).data());
|
|
if (FAILED(hres)) {
|
|
LOG_ERROR(Frontend, "Failed to set arguments");
|
|
return false;
|
|
}
|
|
}
|
|
if (!comment.empty()) {
|
|
hres = ps1->SetDescription(Common::UTF8ToUTF16W(comment).data());
|
|
if (FAILED(hres)) {
|
|
LOG_ERROR(Frontend, "Failed to set description");
|
|
return false;
|
|
}
|
|
}
|
|
if (std::filesystem::is_regular_file(icon_path)) {
|
|
hres = ps1->SetIconLocation(icon_path.c_str(), 0);
|
|
if (FAILED(hres)) {
|
|
LOG_ERROR(Frontend, "Failed to set icon location");
|
|
return false;
|
|
}
|
|
}
|
|
hres = ps1->QueryInterface(IID_IPersistFile, reinterpret_cast<void**>(&persist_file));
|
|
if (FAILED(hres)) {
|
|
LOG_ERROR(Frontend, "Failed to get IPersistFile interface");
|
|
return false;
|
|
}
|
|
hres = persist_file->Save(std::filesystem::path{shortcut_path / (name + ".lnk")}.c_str(), TRUE);
|
|
if (FAILED(hres)) {
|
|
LOG_ERROR(Frontend, "Failed to save shortcut");
|
|
return false;
|
|
}
|
|
return true;
|
|
#elif defined(__unix__) && !defined(__APPLE__) && !defined(__ANDROID__) // Any desktop NIX
|
|
std::filesystem::path shortcut_path_full = shortcut_path / (name + ".desktop");
|
|
std::ofstream shortcut_stream(shortcut_path_full, std::ios::binary | std::ios::trunc);
|
|
if (!shortcut_stream.is_open()) {
|
|
LOG_ERROR(Frontend, "Failed to create shortcut");
|
|
return false;
|
|
}
|
|
// TODO: Migrate fmt::print to std::print in futures STD C++ 23.
|
|
fmt::print(shortcut_stream, "[Desktop Entry]\n");
|
|
fmt::print(shortcut_stream, "Type=Application\n");
|
|
fmt::print(shortcut_stream, "Version=1.0\n");
|
|
fmt::print(shortcut_stream, "Name={}\n", name);
|
|
if (!comment.empty()) {
|
|
fmt::print(shortcut_stream, "Comment={}\n", comment);
|
|
}
|
|
if (std::filesystem::is_regular_file(icon_path)) {
|
|
fmt::print(shortcut_stream, "Icon={}\n", icon_path.string());
|
|
}
|
|
fmt::print(shortcut_stream, "TryExec={}\n", command.string());
|
|
fmt::print(shortcut_stream, "Exec={} {}\n", command.string(), arguments);
|
|
if (!categories.empty()) {
|
|
fmt::print(shortcut_stream, "Categories={}\n", categories);
|
|
}
|
|
if (!keywords.empty()) {
|
|
fmt::print(shortcut_stream, "Keywords={}\n", keywords);
|
|
}
|
|
return true;
|
|
#else // Unsupported platform
|
|
return false;
|
|
#endif
|
|
} catch (const std::exception& e) {
|
|
LOG_ERROR(Frontend, "Failed to create shortcut: {}", e.what());
|
|
return false;
|
|
}
|
|
|
|
bool MakeShortcutIcoPath(const u64 program_id,
|
|
const std::string_view game_file_name,
|
|
std::filesystem::path& out_icon_path)
|
|
{
|
|
// Get path to Yuzu icons directory & icon extension
|
|
std::string ico_extension = "png";
|
|
#if defined(_WIN32)
|
|
out_icon_path = Common::FS::GetEdenPath(Common::FS::EdenPath::IconsDir);
|
|
ico_extension = "ico";
|
|
#elif defined(__linux__) || defined(__FreeBSD__)
|
|
out_icon_path = Common::FS::GetDataDirectory("XDG_DATA_HOME") / "icons/hicolor/256x256";
|
|
#endif
|
|
// Create icons directory if it doesn't exist
|
|
if (!Common::FS::CreateDirs(out_icon_path)) {
|
|
out_icon_path.clear();
|
|
return false;
|
|
}
|
|
|
|
// Create icon file path
|
|
out_icon_path /= (program_id == 0 ? fmt::format("eden-{}.{}", game_file_name, ico_extension)
|
|
: fmt::format("eden-{:016X}.{}", program_id, ico_extension));
|
|
return true;
|
|
}
|
|
|
|
void OpenEdenFolder(const Common::FS::EdenPath& path)
|
|
{
|
|
QDesktopServices::openUrl(QUrl(QString::fromStdString(Common::FS::GetEdenPathString(path))));
|
|
}
|
|
|
|
void OpenRootDataFolder()
|
|
{
|
|
OpenEdenFolder(Common::FS::EdenPath::EdenDir);
|
|
}
|
|
|
|
void OpenNANDFolder()
|
|
{
|
|
OpenEdenFolder(Common::FS::EdenPath::NANDDir);
|
|
}
|
|
|
|
void OpenSDMCFolder()
|
|
{
|
|
OpenEdenFolder(Common::FS::EdenPath::SDMCDir);
|
|
}
|
|
|
|
void OpenModFolder()
|
|
{
|
|
OpenEdenFolder(Common::FS::EdenPath::LoadDir);
|
|
}
|
|
|
|
void OpenLogFolder()
|
|
{
|
|
OpenEdenFolder(Common::FS::EdenPath::LogDir);
|
|
}
|
|
|
|
static QString GetGameListErrorRemoving(QtCommon::Game::InstalledEntryType type)
|
|
{
|
|
switch (type) {
|
|
case QtCommon::Game::InstalledEntryType::Game:
|
|
return tr("Error Removing Contents");
|
|
case QtCommon::Game::InstalledEntryType::Update:
|
|
return tr("Error Removing Update");
|
|
case QtCommon::Game::InstalledEntryType::AddOnContent:
|
|
return tr("Error Removing DLC");
|
|
default:
|
|
return QStringLiteral("Error Removing <Invalid Type>");
|
|
}
|
|
}
|
|
|
|
// Game Content //
|
|
void RemoveBaseContent(u64 program_id, InstalledEntryType type)
|
|
{
|
|
const auto res = ContentManager::RemoveBaseContent(system->GetFileSystemController(),
|
|
program_id);
|
|
if (res) {
|
|
QtCommon::Frontend::Information(rootObject,
|
|
"Successfully Removed",
|
|
"Successfully removed the installed base game.");
|
|
} else {
|
|
QtCommon::Frontend::Warning(
|
|
rootObject,
|
|
GetGameListErrorRemoving(type),
|
|
tr("The base game is not installed in the NAND and cannot be removed."));
|
|
}
|
|
}
|
|
|
|
void RemoveUpdateContent(u64 program_id, InstalledEntryType type)
|
|
{
|
|
const auto res = ContentManager::RemoveUpdate(system->GetFileSystemController(), program_id);
|
|
if (res) {
|
|
QtCommon::Frontend::Information(rootObject,
|
|
"Successfully Removed",
|
|
"Successfully removed the installed update.");
|
|
} else {
|
|
QtCommon::Frontend::Warning(rootObject,
|
|
GetGameListErrorRemoving(type),
|
|
tr("There is no update installed for this title."));
|
|
}
|
|
}
|
|
|
|
void RemoveAddOnContent(u64 program_id, InstalledEntryType type)
|
|
{
|
|
const size_t count = ContentManager::RemoveAllDLC(*system, program_id);
|
|
if (count == 0) {
|
|
QtCommon::Frontend::Warning(rootObject,
|
|
GetGameListErrorRemoving(type),
|
|
tr("There are no DLCs installed for this title."));
|
|
return;
|
|
}
|
|
|
|
QtCommon::Frontend::Information(rootObject,
|
|
tr("Successfully Removed"),
|
|
tr("Successfully removed %1 installed DLC.").arg(count));
|
|
}
|
|
|
|
// Global Content //
|
|
|
|
void RemoveTransferableShaderCache(u64 program_id, GameListRemoveTarget target)
|
|
{
|
|
const auto target_file_name = [target] {
|
|
switch (target) {
|
|
case GameListRemoveTarget::GlShaderCache:
|
|
return "opengl.bin";
|
|
case GameListRemoveTarget::VkShaderCache:
|
|
return "vulkan.bin";
|
|
default:
|
|
return "";
|
|
}
|
|
}();
|
|
const auto shader_cache_dir = Common::FS::GetEdenPath(Common::FS::EdenPath::ShaderDir);
|
|
const auto shader_cache_folder_path = shader_cache_dir / fmt::format("{:016x}", program_id);
|
|
const auto target_file = shader_cache_folder_path / target_file_name;
|
|
|
|
if (!Common::FS::Exists(target_file)) {
|
|
QtCommon::Frontend::Warning(rootObject,
|
|
tr("Error Removing Transferable Shader Cache"),
|
|
tr("A shader cache for this title does not exist."));
|
|
return;
|
|
}
|
|
if (Common::FS::RemoveFile(target_file)) {
|
|
QtCommon::Frontend::Information(rootObject,
|
|
tr("Successfully Removed"),
|
|
tr("Successfully removed the transferable shader cache."));
|
|
} else {
|
|
QtCommon::Frontend::Warning(rootObject,
|
|
tr("Error Removing Transferable Shader Cache"),
|
|
tr("Failed to remove the transferable shader cache."));
|
|
}
|
|
}
|
|
|
|
void RemoveVulkanDriverPipelineCache(u64 program_id)
|
|
{
|
|
static constexpr std::string_view target_file_name = "vulkan_pipelines.bin";
|
|
|
|
const auto shader_cache_dir = Common::FS::GetEdenPath(Common::FS::EdenPath::ShaderDir);
|
|
const auto shader_cache_folder_path = shader_cache_dir / fmt::format("{:016x}", program_id);
|
|
const auto target_file = shader_cache_folder_path / target_file_name;
|
|
|
|
if (!Common::FS::Exists(target_file)) {
|
|
return;
|
|
}
|
|
if (!Common::FS::RemoveFile(target_file)) {
|
|
QtCommon::Frontend::Warning(rootObject,
|
|
tr("Error Removing Vulkan Driver Pipeline Cache"),
|
|
tr("Failed to remove the driver pipeline cache."));
|
|
}
|
|
}
|
|
|
|
void RemoveAllTransferableShaderCaches(u64 program_id)
|
|
{
|
|
const auto shader_cache_dir = Common::FS::GetEdenPath(Common::FS::EdenPath::ShaderDir);
|
|
const auto program_shader_cache_dir = shader_cache_dir / fmt::format("{:016x}", program_id);
|
|
|
|
if (!Common::FS::Exists(program_shader_cache_dir)) {
|
|
QtCommon::Frontend::Warning(rootObject,
|
|
tr("Error Removing Transferable Shader Caches"),
|
|
tr("A shader cache for this title does not exist."));
|
|
return;
|
|
}
|
|
if (Common::FS::RemoveDirRecursively(program_shader_cache_dir)) {
|
|
QtCommon::Frontend::Information(rootObject,
|
|
tr("Successfully Removed"),
|
|
tr("Successfully removed the transferable shader caches."));
|
|
} else {
|
|
QtCommon::Frontend::Warning(
|
|
rootObject,
|
|
tr("Error Removing Transferable Shader Caches"),
|
|
tr("Failed to remove the transferable shader cache directory."));
|
|
}
|
|
}
|
|
|
|
void RemoveCustomConfiguration(u64 program_id, const std::string& game_path)
|
|
{
|
|
const auto file_path = std::filesystem::path(Common::FS::ToU8String(game_path));
|
|
const auto config_file_name = program_id == 0
|
|
? Common::FS::PathToUTF8String(file_path.filename())
|
|
.append(".ini")
|
|
: fmt::format("{:016X}.ini", program_id);
|
|
const auto custom_config_file_path = Common::FS::GetEdenPath(Common::FS::EdenPath::ConfigDir)
|
|
/ "custom" / config_file_name;
|
|
|
|
if (!Common::FS::Exists(custom_config_file_path)) {
|
|
QtCommon::Frontend::Warning(rootObject,
|
|
tr("Error Removing Custom Configuration"),
|
|
tr("A custom configuration for this title does not exist."));
|
|
return;
|
|
}
|
|
|
|
if (Common::FS::RemoveFile(custom_config_file_path)) {
|
|
QtCommon::Frontend::Information(rootObject,
|
|
tr("Successfully Removed"),
|
|
tr("Successfully removed the custom game configuration."));
|
|
} else {
|
|
QtCommon::Frontend::Warning(rootObject,
|
|
tr("Error Removing Custom Configuration"),
|
|
tr("Failed to remove the custom game configuration."));
|
|
}
|
|
}
|
|
|
|
void RemoveCacheStorage(u64 program_id, FileSys::VfsFilesystem* vfs)
|
|
{
|
|
const auto nand_dir = Common::FS::GetEdenPath(Common::FS::EdenPath::NANDDir);
|
|
auto vfs_nand_dir = vfs->OpenDirectory(Common::FS::PathToUTF8String(nand_dir),
|
|
FileSys::OpenMode::Read);
|
|
|
|
const auto cache_storage_path
|
|
= FileSys::SaveDataFactory::GetFullPath({},
|
|
vfs_nand_dir,
|
|
FileSys::SaveDataSpaceId::User,
|
|
FileSys::SaveDataType::Cache,
|
|
0 /* program_id */,
|
|
{},
|
|
0);
|
|
|
|
const auto path = Common::FS::ConcatPathSafe(nand_dir, cache_storage_path);
|
|
|
|
// Not an error if it wasn't cleared.
|
|
Common::FS::RemoveDirRecursively(path);
|
|
}
|
|
|
|
// Metadata //
|
|
void ResetMetadata()
|
|
{
|
|
const QString title = tr("Reset Metadata Cache");
|
|
|
|
if (!Common::FS::Exists(Common::FS::GetEdenPath(Common::FS::EdenPath::CacheDir)
|
|
/ "game_list/")) {
|
|
QtCommon::Frontend::Warning(rootObject, title, tr("The metadata cache is already empty."));
|
|
} else if (Common::FS::RemoveDirRecursively(
|
|
Common::FS::GetEdenPath(Common::FS::EdenPath::CacheDir) / "game_list")) {
|
|
QtCommon::Frontend::Information(rootObject,
|
|
title,
|
|
tr("The operation completed successfully."));
|
|
UISettings::values.is_game_list_reload_pending.exchange(true);
|
|
} else {
|
|
QtCommon::Frontend::Warning(
|
|
rootObject,
|
|
title,
|
|
tr("The metadata cache couldn't be deleted. It might be in use or non-existent."));
|
|
}
|
|
}
|
|
|
|
} // namespace QtCommon::Game
|