mirror of
https://github.com/RPCS3/rpcs3.git
synced 2026-03-17 18:55:19 +01:00
558 lines
17 KiB
C++
558 lines
17 KiB
C++
#include "stdafx.h"
|
|
#include "shortcut_utils.h"
|
|
#include "steam_utils.h"
|
|
#include "qt_utils.h"
|
|
#include "Emu/VFS.h"
|
|
#include "Utilities/File.h"
|
|
#include "Utilities/StrUtil.h"
|
|
#include "Loader/ISO.h"
|
|
|
|
#ifdef _WIN32
|
|
#include <Windows.h>
|
|
#include <shlobj.h>
|
|
#include <winnls.h>
|
|
#include <shobjidl.h>
|
|
#include <objbase.h>
|
|
#include <objidl.h>
|
|
#include <shlguid.h>
|
|
#include <comdef.h>
|
|
|
|
#include "Emu/system_utils.hpp"
|
|
#include <wrl/client.h>
|
|
#else
|
|
#include <sys/stat.h>
|
|
#include <errno.h>
|
|
#endif
|
|
|
|
#include <QFile>
|
|
#include <QImageWriter>
|
|
#include <QPixmap>
|
|
#include <QStandardPaths>
|
|
|
|
LOG_CHANNEL(sys_log, "SYS");
|
|
|
|
template <>
|
|
void fmt_class_string<gui::utils::shortcut_location>::format(std::string& out, u64 arg)
|
|
{
|
|
format_enum(out, arg, [](gui::utils::shortcut_location value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case gui::utils::shortcut_location::desktop: return "desktop";
|
|
case gui::utils::shortcut_location::applications: return "applications";
|
|
case gui::utils::shortcut_location::steam: return "steam";
|
|
#ifdef _WIN32
|
|
case gui::utils::shortcut_location::rpcs3_shortcuts: return "rpcs3";
|
|
#endif
|
|
}
|
|
|
|
return unknown;
|
|
});
|
|
}
|
|
|
|
namespace gui::utils
|
|
{
|
|
#ifdef _WIN32
|
|
static const std::string icon_extension = "ico";
|
|
#elif defined(__APPLE__)
|
|
static const std::string icon_extension = "icns";
|
|
#else
|
|
static const std::string icon_extension = "png";
|
|
#endif
|
|
|
|
bool create_square_shortcut_icon_file(const std::string& path, const std::string& src_icon_path, const std::string& target_icon_dir, std::string& target_icon_path, int size)
|
|
{
|
|
if (src_icon_path.empty() || target_icon_dir.empty())
|
|
{
|
|
sys_log.error("Failed to create shortcut. Icon parameters empty.");
|
|
return false;
|
|
}
|
|
|
|
const bool is_archive = is_file_iso(path);
|
|
|
|
QPixmap icon;
|
|
if (!load_icon(icon, src_icon_path, is_archive ? path : ""))
|
|
{
|
|
sys_log.error("Failed to create shortcut. Failed to load %sicon: '%s'", is_archive ? "iso " : "", src_icon_path);
|
|
return false;
|
|
}
|
|
|
|
if (!gui::utils::create_square_pixmap(icon, size))
|
|
{
|
|
sys_log.error("Failed to create shortcut. Icon empty.");
|
|
return false;
|
|
}
|
|
|
|
target_icon_path = target_icon_dir + "shortcut." + fmt::to_lower(icon_extension);
|
|
|
|
QFile icon_file(QString::fromStdString(target_icon_path));
|
|
if (!icon_file.open(QFile::OpenModeFlag::ReadWrite | QFile::OpenModeFlag::Truncate))
|
|
{
|
|
sys_log.error("Failed to create icon file '%s': %s", target_icon_path, icon_file.errorString());
|
|
return false;
|
|
}
|
|
|
|
// Use QImageWriter instead of QPixmap::save in order to be able to log errors
|
|
if (QImageWriter writer(&icon_file, fmt::to_upper(icon_extension).c_str()); !writer.write(icon.toImage()))
|
|
{
|
|
sys_log.error("Failed to write icon file '%s': %s", target_icon_path, writer.errorString());
|
|
return false;
|
|
}
|
|
|
|
icon_file.close();
|
|
|
|
sys_log.notice("Created shortcut icon file '%s'", target_icon_path);
|
|
return true;
|
|
}
|
|
|
|
bool create_shortcut(const std::string& name,
|
|
const std::string& path,
|
|
[[maybe_unused]] const std::string& serial,
|
|
[[maybe_unused]] const std::string& target_cli_args,
|
|
[[maybe_unused]] const std::string& description,
|
|
[[maybe_unused]] const std::string& src_icon_path,
|
|
[[maybe_unused]] const std::string& target_icon_dir,
|
|
shortcut_location location)
|
|
{
|
|
if (name.empty())
|
|
{
|
|
sys_log.error("Cannot create shortcuts without a name");
|
|
return false;
|
|
}
|
|
|
|
// Remove illegal characters from filename
|
|
const std::string simple_name = QString::fromStdString(vfs::escape(name, true)).simplified().toStdString();
|
|
if (simple_name.empty() || simple_name == "." || simple_name == "..")
|
|
{
|
|
sys_log.error("Failed to create shortcut: Cleaned file name empty or not allowed");
|
|
return false;
|
|
}
|
|
|
|
std::string link_path;
|
|
bool append_rpcs3 = false;
|
|
|
|
switch (location)
|
|
{
|
|
case shortcut_location::desktop:
|
|
link_path = QStandardPaths::writableLocation(QStandardPaths::StandardLocation::DesktopLocation).toStdString();
|
|
break;
|
|
case shortcut_location::applications:
|
|
link_path = QStandardPaths::writableLocation(QStandardPaths::StandardLocation::ApplicationsLocation).toStdString();
|
|
append_rpcs3 = true;
|
|
break;
|
|
case shortcut_location::steam:
|
|
#ifdef __APPLE__
|
|
link_path = QStandardPaths::writableLocation(QStandardPaths::StandardLocation::ApplicationsLocation).toStdString();
|
|
append_rpcs3 = true;
|
|
#endif
|
|
break;
|
|
#ifdef _WIN32
|
|
case shortcut_location::rpcs3_shortcuts:
|
|
link_path = rpcs3::utils::get_games_shortcuts_dir();
|
|
fs::create_dir(link_path);
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
if (!link_path.empty() && !fs::is_dir(link_path) && !fs::create_dir(link_path))
|
|
{
|
|
sys_log.error("Failed to create shortcut. Folder does not exist: %s", link_path);
|
|
return false;
|
|
}
|
|
|
|
if (append_rpcs3)
|
|
{
|
|
link_path += "/RPCS3";
|
|
|
|
if (!fs::create_path(link_path))
|
|
{
|
|
sys_log.error("Failed to create shortcut. Could not create path: %s (%s)", link_path, fs::g_tls_error);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
const std::string working_dir{fs::get_executable_dir()};
|
|
const std::string rpcs3_path{fs::get_executable_path()};
|
|
std::string target_icon_path;
|
|
|
|
if (!src_icon_path.empty() && !target_icon_dir.empty())
|
|
{
|
|
if (!create_square_shortcut_icon_file(path, src_icon_path, target_icon_dir, target_icon_path, 512))
|
|
{
|
|
sys_log.error("Failed to create shortcut: .ico creation failed");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (location == shortcut_location::steam)
|
|
{
|
|
sys_log.notice("Creating %s shortcut with arguments '%s' and icon path '%s'", location, target_cli_args, target_icon_path);
|
|
steam_shortcut steam_sc{};
|
|
steam_sc.add_shortcut(simple_name, rpcs3_path, working_dir, target_cli_args, target_icon_path);
|
|
return steam_sc.write_file();
|
|
}
|
|
|
|
sys_log.notice("Creating %s shortcut '%s' with arguments '%s' and .ico dir '%s'", location, link_path, target_cli_args, target_icon_dir);
|
|
|
|
const auto str_error = [](HRESULT hr) -> std::string
|
|
{
|
|
_com_error err(hr);
|
|
const TCHAR* errMsg = err.ErrorMessage();
|
|
return fmt::format("%s [%d]", wchar_to_utf8(errMsg), hr);
|
|
};
|
|
|
|
fmt::append(link_path, "/%s.lnk", simple_name);
|
|
|
|
// https://stackoverflow.com/questions/3906974/how-to-programmatically-create-a-shortcut-using-win32
|
|
HRESULT res = CoInitialize(NULL);
|
|
if (FAILED(res))
|
|
{
|
|
sys_log.error("Failed to create shortcut: CoInitialize failed (%s)", str_error(res));
|
|
return false;
|
|
}
|
|
|
|
Microsoft::WRL::ComPtr<IShellLink> pShellLink;
|
|
Microsoft::WRL::ComPtr<IPersistFile> pPersistFile;
|
|
|
|
const auto cleanup = [&](bool return_value, const std::string& fail_reason) -> bool
|
|
{
|
|
if (!return_value) sys_log.error("Failed to create shortcut: %s", fail_reason);
|
|
CoUninitialize();
|
|
return return_value;
|
|
};
|
|
|
|
res = CoCreateInstance(__uuidof(ShellLink), NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pShellLink));
|
|
if (FAILED(res))
|
|
return cleanup(false, "CoCreateInstance failed");
|
|
|
|
const std::wstring w_target_file = utf8_to_wchar(rpcs3_path);
|
|
res = pShellLink->SetPath(w_target_file.c_str());
|
|
if (FAILED(res))
|
|
return cleanup(false, fmt::format("SetPath failed (%s)", str_error(res)));
|
|
|
|
const std::wstring w_working_dir = utf8_to_wchar(working_dir);
|
|
res = pShellLink->SetWorkingDirectory(w_working_dir.c_str());
|
|
if (FAILED(res))
|
|
return cleanup(false, fmt::format("SetWorkingDirectory failed (%s)", str_error(res)));
|
|
|
|
if (!target_cli_args.empty())
|
|
{
|
|
const std::wstring w_target_cli_args = utf8_to_wchar(target_cli_args);
|
|
res = pShellLink->SetArguments(w_target_cli_args.c_str());
|
|
if (FAILED(res))
|
|
return cleanup(false, fmt::format("SetArguments failed (%s)", str_error(res)));
|
|
}
|
|
|
|
if (!description.empty())
|
|
{
|
|
const std::wstring w_descpription = utf8_to_wchar(description);
|
|
res = pShellLink->SetDescription(w_descpription.c_str());
|
|
if (FAILED(res))
|
|
return cleanup(false, fmt::format("SetDescription failed (%s)", str_error(res)));
|
|
}
|
|
|
|
if (!target_icon_path.empty())
|
|
{
|
|
const std::wstring w_icon_path = utf8_to_wchar(target_icon_path);
|
|
res = pShellLink->SetIconLocation(w_icon_path.c_str(), 0);
|
|
if (FAILED(res))
|
|
return cleanup(false, fmt::format("SetIconLocation failed (%s)", str_error(res)));
|
|
}
|
|
|
|
// Use the IPersistFile object to save the shell link
|
|
res = pShellLink.As(&pPersistFile);
|
|
if (FAILED(res))
|
|
return cleanup(false, fmt::format("QueryInterface failed (%s)", str_error(res)));
|
|
|
|
// Save shortcut
|
|
const std::wstring w_link_file = utf8_to_wchar(link_path);
|
|
res = pPersistFile->Save(w_link_file.c_str(), TRUE);
|
|
if (FAILED(res))
|
|
{
|
|
if (location == shortcut_location::desktop)
|
|
{
|
|
return cleanup(false, fmt::format("Saving file to desktop failed (%s)", str_error(res)));
|
|
}
|
|
else
|
|
{
|
|
return cleanup(false, fmt::format("Saving file to start menu failed (%s)", str_error(res)));
|
|
}
|
|
}
|
|
|
|
return cleanup(true, {});
|
|
|
|
#elif defined(__APPLE__)
|
|
|
|
fmt::append(link_path, "/%s.app", simple_name);
|
|
|
|
sys_log.notice("Creating %s shortcut '%s' with arguments '%s'", location, link_path, target_cli_args);
|
|
|
|
const std::string contents_dir = link_path + "/Contents/";
|
|
const std::string macos_dir = contents_dir + "MacOS/";
|
|
const std::string resources_dir = contents_dir + "Resources/";
|
|
|
|
if (!fs::create_path(contents_dir) || !fs::create_path(macos_dir) || !fs::create_path(resources_dir))
|
|
{
|
|
sys_log.error("Failed to create shortcut. Could not create app bundle structure. (%s)", fs::g_tls_error);
|
|
return false;
|
|
}
|
|
|
|
const std::string plist_path = contents_dir + "Info.plist";
|
|
const std::string launcher_path = macos_dir + "launcher";
|
|
|
|
std::string launcher_content;
|
|
fmt::append(launcher_content, "#!/bin/bash\nopen -b net.rpcs3.rpcs3 --args %s", target_cli_args);
|
|
|
|
fs::file launcher_file(launcher_path, fs::read + fs::rewrite);
|
|
if (!launcher_file)
|
|
{
|
|
sys_log.error("Failed to create launcher file: %s (%s)", launcher_path, fs::g_tls_error);
|
|
return false;
|
|
}
|
|
if (launcher_file.write(launcher_content.data(), launcher_content.size()) != launcher_content.size())
|
|
{
|
|
sys_log.error("Failed to write launcher file: %s", launcher_path);
|
|
return false;
|
|
}
|
|
launcher_file.close();
|
|
|
|
if (chmod(launcher_path.c_str(), S_IRWXU) != 0)
|
|
{
|
|
sys_log.error("Failed to change file permissions for launcher file: %s (%d)", strerror(errno), errno);
|
|
return false;
|
|
}
|
|
|
|
const std::string plist_content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
|
|
"<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
|
|
"<plist version=\"1.0\">\n"
|
|
"<dict>\n"
|
|
"\t<key>CFBundleExecutable</key>\n"
|
|
"\t<string>launcher</string>\n"
|
|
"\t<key>CFBundleIconFile</key>\n"
|
|
"\t<string>shortcut.icns</string>\n"
|
|
"\t<key>CFBundleInfoDictionaryVersion</key>\n"
|
|
"\t<string>1.0</string>\n"
|
|
"\t<key>CFBundlePackageType</key>\n"
|
|
"\t<string>APPL</string>\n"
|
|
"\t<key>CFBundleSignature</key>\n"
|
|
"\t<string>\?\?\?\?</string>\n"
|
|
#if defined(ARCH_ARM64)
|
|
"\t<key>CFBundleIdentifier</key>\n"
|
|
"\t<string>net.rpcs3" + (serial.empty() ? "" : ("." + serial)) + "</string>\n"
|
|
"\t<key>LSArchitecturePriority</key>\n"
|
|
"\t<array>\n"
|
|
"\t\t<string>arm64</string>\n"
|
|
"\t</array>\n"
|
|
"\t<key>LSRequiresNativeExecution</key>\n"
|
|
"\t<true/>\n"
|
|
#endif
|
|
"</dict>\n"
|
|
"</plist>\n";
|
|
|
|
fs::file plist_file(plist_path, fs::read + fs::rewrite);
|
|
if (!plist_file)
|
|
{
|
|
sys_log.error("Failed to create plist file: %s (%s)", plist_path, fs::g_tls_error);
|
|
return false;
|
|
}
|
|
if (plist_file.write(plist_content.data(), plist_content.size()) != plist_content.size())
|
|
{
|
|
sys_log.error("Failed to write plist file: %s", plist_path);
|
|
return false;
|
|
}
|
|
plist_file.close();
|
|
|
|
std::string target_icon_path;
|
|
if (!src_icon_path.empty())
|
|
{
|
|
target_icon_path = resources_dir;
|
|
if (!create_square_shortcut_icon_file(path, src_icon_path, resources_dir, target_icon_path, 512))
|
|
{
|
|
// Error is logged in create_square_shortcut_icon_file
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (location == shortcut_location::steam)
|
|
{
|
|
steam_shortcut steam_sc{};
|
|
steam_sc.add_shortcut(simple_name, launcher_path, macos_dir, ""/*target_cli_args are already in the launcher*/, target_icon_path);
|
|
return steam_sc.write_file();
|
|
}
|
|
|
|
return true;
|
|
|
|
#else
|
|
const std::string exe_path = fs::get_executable_path();
|
|
if (exe_path.empty())
|
|
{
|
|
sys_log.error("Failed to create shortcut. Executable path empty.");
|
|
return false;
|
|
}
|
|
|
|
std::string target_icon_path;
|
|
if (!src_icon_path.empty() && !target_icon_dir.empty())
|
|
{
|
|
if (!create_square_shortcut_icon_file(path, src_icon_path, target_icon_dir, target_icon_path, 512))
|
|
{
|
|
// Error is logged in create_square_shortcut_icon_file
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (location == shortcut_location::steam)
|
|
{
|
|
sys_log.notice("Creating %s shortcut with arguments '%s' and icon path '%s'", location, target_cli_args, target_icon_path);
|
|
const std::string working_dir{fs::get_executable_dir()};
|
|
steam_shortcut steam_sc{};
|
|
steam_sc.add_shortcut(simple_name, exe_path, working_dir, target_cli_args, target_icon_path);
|
|
return steam_sc.write_file();
|
|
}
|
|
|
|
fmt::append(link_path, "/%s.desktop", simple_name);
|
|
|
|
sys_log.notice("Creating %s shortcut '%s' for '%s' with arguments '%s'", location, link_path, exe_path, target_cli_args);
|
|
|
|
std::string file_content;
|
|
fmt::append(file_content, "[Desktop Entry]\n");
|
|
fmt::append(file_content, "Encoding=UTF-8\n");
|
|
fmt::append(file_content, "Version=1.0\n");
|
|
fmt::append(file_content, "Type=Application\n");
|
|
fmt::append(file_content, "Terminal=false\n");
|
|
fmt::append(file_content, "Exec=\"%s\" %s\n", exe_path, target_cli_args);
|
|
fmt::append(file_content, "Name=%s\n", name);
|
|
fmt::append(file_content, "Categories=Application;Game\n");
|
|
|
|
if (!description.empty())
|
|
{
|
|
fmt::append(file_content, "Comment=%s\n", QString::fromStdString(description).simplified());
|
|
}
|
|
|
|
if (!target_icon_path.empty())
|
|
{
|
|
fmt::append(file_content, "Icon=%s\n", target_icon_path);
|
|
}
|
|
|
|
fs::file shortcut_file(link_path, fs::read + fs::rewrite);
|
|
if (!shortcut_file)
|
|
{
|
|
sys_log.error("Failed to create .desktop file: %s (%s)", link_path, fs::g_tls_error);
|
|
return false;
|
|
}
|
|
if (shortcut_file.write(file_content.data(), file_content.size()) != file_content.size())
|
|
{
|
|
sys_log.error("Failed to write .desktop file: %s", link_path);
|
|
return false;
|
|
}
|
|
shortcut_file.close();
|
|
|
|
if (location == shortcut_location::desktop)
|
|
{
|
|
if (chmod(link_path.c_str(), S_IRWXU) != 0) // enables user to execute file
|
|
{
|
|
// Simply log failure. At least we have the file.
|
|
sys_log.error("Failed to change file permissions for .desktop file: %s (%d)", strerror(errno), errno);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
void remove_shortcuts(const std::string& name, [[maybe_unused]] const std::string& serial)
|
|
{
|
|
const std::string simple_name = QString::fromStdString(vfs::escape(name, true)).simplified().toStdString();
|
|
if (simple_name.empty() || simple_name == "." || simple_name == "..")
|
|
{
|
|
sys_log.error("Failed to remove shortcuts: Cleaned file name empty or not allowed");
|
|
return;
|
|
}
|
|
|
|
const auto remove_path = [](const std::string& path, bool is_file)
|
|
{
|
|
if (!path.empty())
|
|
{
|
|
if (is_file && fs::is_file(path))
|
|
{
|
|
if (fs::remove_file(path))
|
|
{
|
|
sys_log.success("Removed shortcut file '%s'", path);
|
|
}
|
|
else
|
|
{
|
|
sys_log.error("Failed to remove shortcut file '%s': error='%s'", path, fs::g_tls_error);
|
|
}
|
|
}
|
|
else if (!is_file && fs::is_dir(path))
|
|
{
|
|
if (fs::remove_all(path))
|
|
{
|
|
sys_log.success("Removed shortcut directory '%s'", path);
|
|
}
|
|
else
|
|
{
|
|
sys_log.error("Failed to remove shortcut directory '%s': error='%s'", path, fs::g_tls_error);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
std::vector<shortcut_location> locations = {
|
|
shortcut_location::desktop,
|
|
shortcut_location::applications,
|
|
shortcut_location::steam,
|
|
};
|
|
#ifdef _WIN32
|
|
locations.push_back(shortcut_location::rpcs3_shortcuts);
|
|
#endif
|
|
|
|
for (shortcut_location location : locations)
|
|
{
|
|
std::string link_path;
|
|
|
|
switch (location)
|
|
{
|
|
case shortcut_location::desktop:
|
|
link_path = QStandardPaths::writableLocation(QStandardPaths::StandardLocation::DesktopLocation).toStdString();
|
|
break;
|
|
case shortcut_location::applications:
|
|
link_path = QStandardPaths::writableLocation(QStandardPaths::StandardLocation::ApplicationsLocation).toStdString();
|
|
link_path += "/RPCS3";
|
|
break;
|
|
case shortcut_location::steam:
|
|
{
|
|
const std::string exe_path = fs::get_executable_path();
|
|
const std::string working_dir = fs::get_executable_dir();
|
|
steam_shortcut steam_sc{};
|
|
steam_sc.remove_shortcut(simple_name, exe_path, working_dir);
|
|
if (!steam_sc.write_file())
|
|
{
|
|
sys_log.error("Failed to remove steam shortcut for '%s'", simple_name);
|
|
}
|
|
continue;
|
|
}
|
|
#ifdef _WIN32
|
|
case shortcut_location::rpcs3_shortcuts:
|
|
link_path = rpcs3::utils::get_games_shortcuts_dir();
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
fmt::append(link_path, "/%s.lnk", simple_name);
|
|
remove_path(link_path, true);
|
|
#elif defined(__APPLE__)
|
|
fmt::append(link_path, "/%s.app", simple_name);
|
|
remove_path(link_path, false);
|
|
#else
|
|
fmt::append(link_path, "/%s.desktop", simple_name);
|
|
remove_path(link_path, true);
|
|
#endif
|
|
}
|
|
|
|
const std::string icon_path = fmt::format("%sIcons/game_icons/%s/shortcut.%s", fs::get_config_dir(), serial, icon_extension);
|
|
remove_path(icon_path, true);
|
|
}
|
|
}
|