Qt: Add Create game shortcut functionality

Author: kamfretoz

bin/resources/icons/AppIconLarge.ico

@@ -214,4 +214,10 @@ namespace Common
 	void SetMousePosition(int x, int y);
 	bool AttachMousePositionCb(std::function<void(int,int)> cb);
 	void DetachMousePositionCb();
+
+#if !defined(__APPLE__)
+	// Create desktop shortcut for games
+	void CreateShortcut(const std::string name, const std::string game_path, const std::string passed_cli_args, bool is_desktop);
+#endif
+
 } // namespace Common

common/HostSys.h

@@ -3,6 +3,7 @@
 
 #include "common/Pcsx2Types.h"
 #include "common/Console.h"
+#include "common/FileSystem.h"
 #include "common/HostSys.h"
 #include "common/Path.h"
 #include "common/ScopedGuard.h"
@@ -11,6 +12,7 @@
 #include "common/Threading.h"
 #include "common/WindowInfo.h"
 
+#include "pcsx2/Host.h"
 #include "fmt/format.h"
 
 #include <dbus/dbus.h>
@@ -366,6 +368,112 @@ bool Common::PlaySoundAsync(const char* path)
 #endif
 }
 
+void Common::CreateShortcut(const std::string name, const std::string game_path, const std::string passed_cli_args, bool is_desktop)
+{
+	if (name.empty())
+	{
+		Host::ReportErrorAsync(TRANSLATE_SV("LnxMisc", "Failed to create shortcut"), TRANSLATE_SV("LnxMisc", "Cannot create shortcut without a name."));
+		return;
+	}
+
+	// Sanitize filename and game path
+	const std::string clean_name = Path::SanitizeFileName(name);
+	const std::string clean_path = Path::Canonicalize(Path::RealPath(game_path));
+	if (!Path::IsValidFileName(clean_name))
+	{
+		Host::ReportErrorAsync(TRANSLATE_SV("LnxMisc", "Failed to create shortcut"), TRANSLATE_SV("LnxMisc", "Filename contains illegal character."));
+		return;
+	}
+
+	// Find the executable path
+	const std::string executable_path = FileSystem::GetPackagePath();
+	if (executable_path.empty())
+	{
+		Host::ReportErrorAsync(TRANSLATE_SV("LnxMisc", "Failed to create shortcut"), TRANSLATE_SV("LnxMisc", "Executable path is empty."));
+		return;
+	}
+
+	// Find home directory
+	std::string link_path;
+	if (const char* home = getenv("HOME"))
+	{
+		if (is_desktop)
+		{
+			if (const char* xdg_desktop_dir = getenv("XDG_DESKTOP_DIR"))
+			{
+				link_path = fmt::format("{}/{}.desktop", xdg_desktop_dir, clean_name);
+			}
+			else
+			{
+				link_path = fmt::format("{}/Desktop/{}.desktop", home, clean_name);
+			}
+		}
+		else
+		{
+			if (const char* xdg_data_home = getenv("XDG_DATA_HOME"))
+			{
+				link_path = fmt::format("{}/applications/{}.desktop", xdg_data_home, clean_name);
+			}
+			else
+			{
+				link_path = fmt::format("{}/.local/share/applications/{}.desktop", home, clean_name);
+			}
+		}
+	}
+	else
+	{
+		Host::ReportErrorAsync(TRANSLATE_SV("LnxMisc", "Failed to create shortcut"), TRANSLATE_SV("LnxMisc", "Home path is empty."));
+		return;
+	}
+
+	// Checks if a shortcut already exist
+	if (FileSystem::FileExists(link_path.c_str()))
+	{
+		Host::ReportErrorAsync(TRANSLATE_SV("LnxMisc", "Failed to create shortcut"), TRANSLATE_SV("LnxMisc", "A shortcut with the same name already exist."));
+		return;
+	}
+
+	const std::string final_args = fmt::format(" {} -- '{}'", StringUtil::StripWhitespace(passed_cli_args), clean_path);
+	std::string clean_args;
+
+	for (size_t i = 0; i < final_args.size(); i++)
+	{
+		if (final_args[i] == '\n')
+			clean_args.push_back(' ');
+		else
+			clean_args.push_back(final_args[i]);
+	}
+
+	// Shortcut content
+	Console.WriteLnFmt("Creating a shortcut for '{}' with arguments '{}'", name, passed_cli_args);
+	std::string file_content =
+		"[Desktop Entry]\n"
+		"Encoding=UTF-8\n"
+		"Version=1.0\n"
+		"Type=Application\n"
+		"Terminal=false\n"
+		"StartupWMClass=PCSX2\n"
+		"Exec=\'" + executable_path + "'" + clean_args + "\n"
+		"Name=" + name + "\n"
+		"Icon=PCSX2\n"
+		"Categories=Game;Emulator;\n";
+	std::string_view sv(file_content);
+
+	// Write to .desktop file
+	if (!FileSystem::WriteStringToFile(link_path.c_str(), sv))
+	{
+		Host::ReportErrorAsync(TRANSLATE_SV("LnxMisc", "Error"), TRANSLATE_SV("LnxMisc", "Failed to create .desktop file"));
+		return;
+	}
+
+	Console.WriteLnFmt(Color_StrongGreen, "{} shortcut for {} has been created succesfully.", is_desktop ? "Desktop" : "Start Menu", clean_name);
+
+	if (chmod(link_path.c_str(), S_IRWXU) != 0) // enables user to execute file
+	{
+		Console.ErrorFmt("Failed to change file permissions for .desktop file: {} ({})", strerror(errno), errno);
+	}
+}
+
 void Threading::Sleep(int ms)
 {
 	usleep(1000 * ms);

common/Linux/LnxMisc.cpp

@@ -4,15 +4,29 @@
 #include "common/Console.h"
 #include "common/FileSystem.h"
 #include "common/HostSys.h"
+#include "common/Path.h"
 #include "common/RedtapeWindows.h"
 #include "common/StringUtil.h"
 #include "common/Threading.h"
 #include "common/WindowInfo.h"
 
+#include "pcsx2/Host.h"
+#include "fmt/format.h"
+
+#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 <mmsystem.h>
 #include <timeapi.h>
 #include <VersionHelpers.h>
 
+#include <wrl/client.h>
+
 // If anything tries to read this as an initializer, we're in trouble.
 static const LARGE_INTEGER lfreq = []() {
 	LARGE_INTEGER ret = {};
@@ -156,6 +170,150 @@ bool Common::PlaySoundAsync(const char* path)
 	return PlaySoundW(wpath.c_str(), NULL, SND_ASYNC | SND_NODEFAULT);
 }
 
+void Common::CreateShortcut(const std::string name, const std::string game_path, const std::string passed_cli_args, bool is_desktop)
+{
+	if (name.empty())
+	{
+		Console.Error("Cannot create shortcuts without a name.");
+		return;
+	}
+
+	// Sanitize filename
+	const std::string clean_name = Path::SanitizeFileName(name).c_str();
+	if (!Path::IsValidFileName(clean_name))
+	{
+		Host::ReportErrorAsync(TRANSLATE_SV("WinMisc", "Failed to create shortcut"), TRANSLATE_SV("WinMisc", "Filename contains illegal character."));
+		return;
+	}
+	
+	// Locate home directory
+	std::string link_file;
+	if (const char* home = getenv("USERPROFILE"))
+	{
+		if (is_desktop)
+		{
+			link_file = Path::ToNativePath(fmt::format("{}/Desktop/{}.lnk", home, clean_name));
+		}
+		else
+		{
+			const std::string start_menu_dir = Path::ToNativePath(fmt::format("{}/AppData/Roaming/Microsoft/Windows/Start Menu/Programs/PCSX2", home));
+			if (!FileSystem::EnsureDirectoryExists(start_menu_dir.c_str(), false))
+			{
+				Host::ReportErrorAsync(TRANSLATE_SV("WinMisc", "Failed to create shortcut"), TRANSLATE_SV("WinMisc", "Could not create start menu directory."));
+				return;
+			}
+
+			link_file = Path::ToNativePath(fmt::format("{}/{}.lnk", start_menu_dir, clean_name));
+		}
+	}
+	else
+	{
+		Host::ReportErrorAsync(TRANSLATE_SV("WinMisc", "Failed to create shortcut"), TRANSLATE_SV("WinMisc", "Home path is empty."));
+		return;
+	}
+
+	// Check if the same shortcut already exists
+	if (FileSystem::FileExists(link_file.c_str()))
+	{
+		Host::ReportErrorAsync(TRANSLATE_SV("WinMisc", "Failed to create shortcut"), TRANSLATE_SV("WinMisc", "A shortcut with the same name already exist."));
+		return;
+	}
+
+	const std::string final_args = fmt::format(" {} -- \"{}\"", StringUtil::StripWhitespace(passed_cli_args), game_path);
+	Console.WriteLnFmt("Creating a shortcut '{}' with arguments '{}'", link_file, final_args);
+	const auto str_error = [](HRESULT hr) -> std::string {
+		_com_error err(hr);
+		const TCHAR* errMsg = err.ErrorMessage();
+		return fmt::format("{} [{}]", StringUtil::WideStringToUTF8String(errMsg), hr);
+	};
+
+	// Construct the shortcut
+	// https://stackoverflow.com/questions/3906974/how-to-programmatically-create-a-shortcut-using-win32
+	HRESULT res = CoInitialize(NULL);
+	if (FAILED(res))
+	{
+		Console.ErrorFmt("Failed to create shortcut: CoInitialize failed ({})", str_error(res));
+		return;
+	}
+
+	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)
+			Console.ErrorFmt("Failed to create shortcut: {}", fail_reason);
+		CoUninitialize();
+		return return_value;
+	};
+
+	res = CoCreateInstance(__uuidof(ShellLink), NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pShellLink));
+	if (FAILED(res))
+	{
+		cleanup(false, "CoCreateInstance failed");
+		return;
+	}
+
+	// Set path to the executable
+	const std::wstring target_file = StringUtil::UTF8StringToWideString(FileSystem::GetProgramPath());
+	res = pShellLink->SetPath(target_file.c_str());
+	if (FAILED(res))
+	{
+		cleanup(false, fmt::format("SetPath failed ({})", str_error(res)));
+		return;
+	}
+
+	// Set the working directory
+	const std::wstring working_dir = StringUtil::UTF8StringToWideString(FileSystem::GetWorkingDirectory());
+	res = pShellLink->SetWorkingDirectory(working_dir.c_str());
+	if (FAILED(res))
+	{
+		cleanup(false, fmt::format("SetWorkingDirectory failed ({})", str_error(res)));
+		return;
+	}
+
+	// Set the launch arguments
+	if (!final_args.empty())
+	{
+		const std::wstring target_cli_args = StringUtil::UTF8StringToWideString(final_args);
+		res = pShellLink->SetArguments(target_cli_args.c_str());
+		if (FAILED(res))
+		{
+			cleanup(false, fmt::format("SetArguments failed ({})", str_error(res)));
+			return;
+		}
+	}
+	
+	// Set the icon
+	std::string icon_path = Path::ToNativePath(Path::Combine(Path::GetDirectory(FileSystem::GetProgramPath()), "resources/icons/AppIconLarge.ico"));
+	const std::wstring w_icon_path = StringUtil::UTF8StringToWideString(icon_path);
+	res = pShellLink->SetIconLocation(w_icon_path.c_str(), 0);
+	if (FAILED(res))
+	{
+		cleanup(false, fmt::format("SetIconLocation failed ({})", str_error(res)));
+		return;
+	}
+
+	// Use the IPersistFile object to save the shell link
+	res = pShellLink.As(&pPersistFile);
+	if (FAILED(res))
+	{
+		cleanup(false, fmt::format("QueryInterface failed ({})", str_error(res)));
+		return;
+	}
+
+	// Save shortcut link to disk
+	const std::wstring w_link_file = StringUtil::UTF8StringToWideString(link_file);
+	res = pPersistFile->Save(w_link_file.c_str(), TRUE);
+	if (FAILED(res))
+	{
+		cleanup(false, fmt::format("Failed to save the shortcut ({})", str_error(res)));
+		return;
+	}
+
+	Console.WriteLnFmt(Color_StrongGreen, "{} shortcut for {} has been created succesfully.", is_desktop ? "Desktop" : "Start Menu", clean_name);
+	cleanup(true, {});
+}
+
 void Threading::Sleep(int ms)
 {
 	::Sleep(ms);

common/Windows/WinMisc.cpp

@@ -264,6 +264,14 @@ target_sources(pcsx2-qt PRIVATE
 	resources/resources.qrc
 )
 
+if (NOT APPLE)
+    target_sources(pcsx2-qt PRIVATE
+        ShortcutCreationDialog.cpp
+        ShortcutCreationDialog.h
+        ShortcutCreationDialog.ui
+    )
+endif()
+
 file(GLOB TS_FILES ${CMAKE_CURRENT_SOURCE_DIR}/Translations/*.ts)
 
 target_precompile_headers(pcsx2-qt PRIVATE PrecompiledHeader.h)

pcsx2-qt/CMakeLists.txt

@@ -21,7 +21,12 @@
 #include "Tools/InputRecording/InputRecordingViewer.h"
 #include "Tools/InputRecording/NewInputRecordingDlg.h"
 
+#if !defined(__APPLE__)
+#include "ShortcutCreationDialog.h"
+#endif
+
 #include "pcsx2/Achievements.h"
+#include "common/HostSys.h"
 #include "pcsx2/CDVD/CDVDcommon.h"
 #include "pcsx2/CDVD/CDVDdiscReader.h"
 #include "pcsx2/GS.h"
@@ -1448,6 +1453,10 @@ void MainWindow::onGameListEntryContextMenuRequested(const QPoint& point)
 		action = menu.addAction(tr("Set Cover Image..."));
 		connect(action, &QAction::triggered, [this, entry]() { setGameListEntryCoverImage(entry); });
 
+#if !defined(__APPLE__)
+		connect(menu.addAction(tr("Create Game Shortcut")), &QAction::triggered, [this]() { MainWindow::onCreateGameShortcutTriggered(); });
+#endif
+
 		connect(menu.addAction(tr("Exclude From List")), &QAction::triggered,
 			[this, entry]() { getSettingsWindow()->getGameListSettingsWidget()->addExcludedPath(entry->path); });
 
@@ -1751,6 +1760,17 @@ void MainWindow::onToolsCoverDownloaderTriggered()
 	dlg.exec();
 }
 
+#if !defined(__APPLE__)
+void MainWindow::onCreateGameShortcutTriggered()
+{
+	const GameList::Entry* entry = m_game_list_widget->getSelectedEntry();
+	const QString title = QString::fromStdString(entry->GetTitle());
+	const QString path = QString::fromStdString(entry->path);
+	VMLock lock(pauseAndLockVM());
+	ShortcutCreationDialog dlg(lock.getDialogParent(), title, path);
+	dlg.exec();
+}
+#endif
 void MainWindow::onToolsEditCheatsPatchesTriggered(bool cheats)
 {
 	if (s_current_disc_serial.isEmpty() || s_current_running_crc == 0)

pcsx2-qt/MainWindow.cpp

@@ -170,6 +170,9 @@ private Q_SLOTS:
 	void onAboutActionTriggered();
 	void onToolsOpenDataDirectoryTriggered();
 	void onToolsCoverDownloaderTriggered();
+#if !defined(__APPLE__)
+	void onCreateGameShortcutTriggered();
+#endif
 	void onToolsEditCheatsPatchesTriggered(bool cheats);
 	void onCreateMemoryCardOpenRequested();
 	void updateTheme();