edafce57be
* Added GUI to Ryujinx * Updated to use Glade Also added scrollbar and default dark theme * Added support for loading icon from .nro files and cleaned up the code a bit * Added General Settings Menu (read-only for now) and moved some functionality from MainMenu.cs to ApplicationLibrary.cs * Added custom GUI theme support and changed the defualt theme to one I just wrote * Added GTK to process path, fixed a bug and minor edits * some more edits and a bug fix * general settings menu is now fully functional. also fixed the bug where ryujinx crashes when it trys to load an invalid gamedir * big rewrite * aesthetic changes to General Settings menu * Added Control Settings one day done feature :P * minor changes * 1st wave of changes * 2nd wave of changes * 3rd wave of changes * Cleanup settings ui * minor edits * new about window added, still needs styling * added spin button for new option and tooltips to settings * Game icons and names are now shown in the games list * add nuget package which contains gtk dependencies * requested changes have been changed * put CreateGameWindow on a new thread and stopped destroying the main menu when a game loads * fixed bug that allowed a user to attempt to load multiple games at a time which causes a crash * Added LastPlayed and TimePlayed columns to the game list * Did some testing and fixed some bugs Im not happy with one of the fixes so i will do it properly an upcoming commit * did some more bug testing and fixed another 2 bugs * caught an exception when ryujinx tries to load non-homebrew as homebrew * Large changes Rewrote ApplicationLibrary.cs (added comments too) so any devs reading it wont get eye cancer, also its probably more efficient now. Added 2 new columns (Developer name and application version) to the game list and wrote the logic for it. Ryujinx now loads NRO's TitleName and TitleID from the NACP file instead of the default NPDM. I also killed a lot of bugs * Moved Files moved ApplicationLibrary.cs to Ryujinx.HLE as that is a better place for it. Moved contents of GUI folder to Ui folder and changed the namespaces of the gui files from Ryujinx to Ryujinx.Ui * Added 'Open Ryujinx Folder' button to the file menu and did some small fixes * New features * updated nuget package with missing dlls and changed emmauss' requested changes * fixed some minor issues * all requested changes marked as resolved have been changed * gdkchan's requested changes * fixed an issue with settings window getting chopped on small res * fixed 2 problems caused by rebase * changed the default theme * applied Thog's patch to fix issue on linux * fixed issue caused by rebase * added update check button that runs ryujinx-updater * reads version info from installer and displays it in about menu * changes completed * requested changes changed * fixed issue with default theme * fixed a bug and completed requested changes * added more tooltips and changed some text
451 lines
20 KiB
C#
451 lines
20 KiB
C#
using LibHac;
|
|
using LibHac.Fs;
|
|
using LibHac.Fs.NcaUtils;
|
|
using Ryujinx.Common.Logging;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using SystemState = Ryujinx.HLE.HOS.SystemState;
|
|
|
|
namespace Ryujinx.UI
|
|
{
|
|
public class ApplicationLibrary
|
|
{
|
|
private static Keyset KeySet;
|
|
private static SystemState.TitleLanguage DesiredTitleLanguage;
|
|
|
|
private const double SecondsPerMinute = 60.0;
|
|
private const double SecondsPerHour = SecondsPerMinute * 60;
|
|
private const double SecondsPerDay = SecondsPerHour * 24;
|
|
|
|
public static byte[] RyujinxNspIcon { get; private set; }
|
|
public static byte[] RyujinxXciIcon { get; private set; }
|
|
public static byte[] RyujinxNcaIcon { get; private set; }
|
|
public static byte[] RyujinxNroIcon { get; private set; }
|
|
public static byte[] RyujinxNsoIcon { get; private set; }
|
|
|
|
public static List<ApplicationData> ApplicationLibraryData { get; private set; }
|
|
|
|
public struct ApplicationData
|
|
{
|
|
public byte[] Icon;
|
|
public string TitleName;
|
|
public string TitleId;
|
|
public string Developer;
|
|
public string Version;
|
|
public string TimePlayed;
|
|
public string LastPlayed;
|
|
public string FileExt;
|
|
public string FileSize;
|
|
public string Path;
|
|
}
|
|
|
|
public static void Init(List<string> AppDirs, Keyset keySet, SystemState.TitleLanguage desiredTitleLanguage)
|
|
{
|
|
KeySet = keySet;
|
|
DesiredTitleLanguage = desiredTitleLanguage;
|
|
|
|
// Loads the default application Icons
|
|
RyujinxNspIcon = GetResourceBytes("Ryujinx.Ui.assets.ryujinxNSPIcon.png");
|
|
RyujinxXciIcon = GetResourceBytes("Ryujinx.Ui.assets.ryujinxXCIIcon.png");
|
|
RyujinxNcaIcon = GetResourceBytes("Ryujinx.Ui.assets.ryujinxNCAIcon.png");
|
|
RyujinxNroIcon = GetResourceBytes("Ryujinx.Ui.assets.ryujinxNROIcon.png");
|
|
RyujinxNsoIcon = GetResourceBytes("Ryujinx.Ui.assets.ryujinxNSOIcon.png");
|
|
|
|
// Builds the applications list with paths to found applications
|
|
List<string> applications = new List<string>();
|
|
foreach (string appDir in AppDirs)
|
|
{
|
|
if (Directory.Exists(appDir) == false)
|
|
{
|
|
Logger.PrintWarning(LogClass.Application, $"The \"game_dirs\" section in \"Config.json\" contains an invalid directory: \"{appDir}\"");
|
|
|
|
continue;
|
|
}
|
|
|
|
DirectoryInfo AppDirInfo = new DirectoryInfo(appDir);
|
|
foreach (FileInfo App in AppDirInfo.GetFiles())
|
|
{
|
|
if ((Path.GetExtension(App.ToString()) == ".xci") ||
|
|
(Path.GetExtension(App.ToString()) == ".nca") ||
|
|
(Path.GetExtension(App.ToString()) == ".nsp") ||
|
|
(Path.GetExtension(App.ToString()) == ".pfs0") ||
|
|
(Path.GetExtension(App.ToString()) == ".nro") ||
|
|
(Path.GetExtension(App.ToString()) == ".nso"))
|
|
{
|
|
applications.Add(App.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Loops through applications list, creating a struct for each application and then adding the struct to a list of structs
|
|
ApplicationLibraryData = new List<ApplicationData>();
|
|
foreach (string applicationPath in applications)
|
|
{
|
|
double filesize = new FileInfo(applicationPath).Length * 0.000000000931;
|
|
string titleName = null;
|
|
string titleId = null;
|
|
string developer = null;
|
|
string version = null;
|
|
byte[] applicationIcon = null;
|
|
|
|
using (FileStream file = new FileStream(applicationPath, FileMode.Open, FileAccess.Read))
|
|
{
|
|
if ((Path.GetExtension(applicationPath) == ".nsp") ||
|
|
(Path.GetExtension(applicationPath) == ".pfs0") ||
|
|
(Path.GetExtension(applicationPath) == ".xci"))
|
|
{
|
|
try
|
|
{
|
|
IFileSystem controlFs = null;
|
|
|
|
// Store the ControlFS in variable called controlFs
|
|
if (Path.GetExtension(applicationPath) == ".xci")
|
|
{
|
|
Xci xci = new Xci(KeySet, file.AsStorage());
|
|
|
|
controlFs = GetControlFs(xci.OpenPartition(XciPartitionType.Secure));
|
|
}
|
|
else
|
|
{
|
|
controlFs = GetControlFs(new PartitionFileSystem(file.AsStorage()));
|
|
}
|
|
|
|
// Creates NACP class from the NACP file
|
|
IFile controlNacp = controlFs.OpenFile("/control.nacp", OpenMode.Read);
|
|
Nacp controlData = new Nacp(controlNacp.AsStream());
|
|
|
|
// Get the title name, title ID, developer name and version number from the NACP
|
|
version = controlData.DisplayVersion;
|
|
|
|
titleName = controlData.Descriptions[(int)DesiredTitleLanguage].Title;
|
|
|
|
if (string.IsNullOrWhiteSpace(titleName))
|
|
{
|
|
titleName = controlData.Descriptions.ToList().Find(x => !string.IsNullOrWhiteSpace(x.Title)).Title;
|
|
}
|
|
|
|
titleId = controlData.PresenceGroupId.ToString("x16");
|
|
|
|
if (string.IsNullOrWhiteSpace(titleId))
|
|
{
|
|
titleId = controlData.SaveDataOwnerId.ToString("x16");
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(titleId))
|
|
{
|
|
titleId = (controlData.AddOnContentBaseId - 0x1000).ToString("x16");
|
|
}
|
|
|
|
developer = controlData.Descriptions[(int)DesiredTitleLanguage].Developer;
|
|
|
|
if (string.IsNullOrWhiteSpace(developer))
|
|
{
|
|
developer = controlData.Descriptions.ToList().Find(x => !string.IsNullOrWhiteSpace(x.Developer)).Developer;
|
|
}
|
|
|
|
// Read the icon from the ControlFS and store it as a byte array
|
|
try
|
|
{
|
|
IFile icon = controlFs.OpenFile($"/icon_{DesiredTitleLanguage}.dat", OpenMode.Read);
|
|
using (MemoryStream stream = new MemoryStream())
|
|
{
|
|
icon.AsStream().CopyTo(stream);
|
|
applicationIcon = stream.ToArray();
|
|
}
|
|
}
|
|
catch (HorizonResultException)
|
|
{
|
|
IDirectory controlDir = controlFs.OpenDirectory("./", OpenDirectoryMode.All);
|
|
foreach (DirectoryEntry entry in controlDir.Read())
|
|
{
|
|
if (entry.Name == "control.nacp")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
IFile icon = controlFs.OpenFile(entry.FullPath, OpenMode.Read);
|
|
using (MemoryStream stream = new MemoryStream())
|
|
{
|
|
icon.AsStream().CopyTo(stream);
|
|
applicationIcon = stream.ToArray();
|
|
}
|
|
|
|
if (applicationIcon != null)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (applicationIcon == null)
|
|
{
|
|
applicationIcon = NspOrXciIcon(applicationPath);
|
|
}
|
|
}
|
|
}
|
|
catch (MissingKeyException exception)
|
|
{
|
|
titleName = "Unknown";
|
|
titleId = "Unknown";
|
|
developer = "Unknown";
|
|
version = "?";
|
|
applicationIcon = NspOrXciIcon(applicationPath);
|
|
|
|
Logger.PrintWarning(LogClass.Application, $"Your key set is missing a key with the name: {exception.Name}");
|
|
}
|
|
catch (InvalidDataException)
|
|
{
|
|
titleName = "Unknown";
|
|
titleId = "Unknown";
|
|
developer = "Unknown";
|
|
version = "?";
|
|
applicationIcon = NspOrXciIcon(applicationPath);
|
|
|
|
Logger.PrintWarning(LogClass.Application, $"The file is not an NCA file or the header key is incorrect. Errored File: {applicationPath}");
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Logger.PrintWarning(LogClass.Application, $"This warning usualy means that you have a DLC in one of you game directories\n{exception}");
|
|
|
|
continue;
|
|
}
|
|
}
|
|
else if (Path.GetExtension(applicationPath) == ".nro")
|
|
{
|
|
BinaryReader reader = new BinaryReader(file);
|
|
|
|
byte[] Read(long Position, int Size)
|
|
{
|
|
file.Seek(Position, SeekOrigin.Begin);
|
|
|
|
return reader.ReadBytes(Size);
|
|
}
|
|
|
|
file.Seek(24, SeekOrigin.Begin);
|
|
int AssetOffset = reader.ReadInt32();
|
|
|
|
if (Encoding.ASCII.GetString(Read(AssetOffset, 4)) == "ASET")
|
|
{
|
|
byte[] IconSectionInfo = Read(AssetOffset + 8, 0x10);
|
|
|
|
long iconOffset = BitConverter.ToInt64(IconSectionInfo, 0);
|
|
long iconSize = BitConverter.ToInt64(IconSectionInfo, 8);
|
|
|
|
ulong nacpOffset = reader.ReadUInt64();
|
|
ulong nacpSize = reader.ReadUInt64();
|
|
|
|
// Reads and stores game icon as byte array
|
|
applicationIcon = Read(AssetOffset + iconOffset, (int)iconSize);
|
|
|
|
// Creates memory stream out of byte array which is the NACP
|
|
using (MemoryStream stream = new MemoryStream(Read(AssetOffset + (int)nacpOffset, (int)nacpSize)))
|
|
{
|
|
// Creates NACP class from the memory stream
|
|
Nacp controlData = new Nacp(stream);
|
|
|
|
// Get the title name, title ID, developer name and version number from the NACP
|
|
version = controlData.DisplayVersion;
|
|
|
|
titleName = controlData.Descriptions[(int)DesiredTitleLanguage].Title;
|
|
|
|
if (string.IsNullOrWhiteSpace(titleName))
|
|
{
|
|
titleName = controlData.Descriptions.ToList().Find(x => !string.IsNullOrWhiteSpace(x.Title)).Title;
|
|
}
|
|
|
|
titleId = controlData.PresenceGroupId.ToString("x16");
|
|
|
|
if (string.IsNullOrWhiteSpace(titleId))
|
|
{
|
|
titleId = controlData.SaveDataOwnerId.ToString("x16");
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(titleId))
|
|
{
|
|
titleId = (controlData.AddOnContentBaseId - 0x1000).ToString("x16");
|
|
}
|
|
|
|
developer = controlData.Descriptions[(int)DesiredTitleLanguage].Developer;
|
|
|
|
if (string.IsNullOrWhiteSpace(developer))
|
|
{
|
|
developer = controlData.Descriptions.ToList().Find(x => !string.IsNullOrWhiteSpace(x.Developer)).Developer;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
applicationIcon = RyujinxNroIcon;
|
|
titleName = "Application";
|
|
titleId = "0000000000000000";
|
|
developer = "Unknown";
|
|
version = "?";
|
|
}
|
|
}
|
|
// If its an NCA or NSO we just set defaults
|
|
else if ((Path.GetExtension(applicationPath) == ".nca") || (Path.GetExtension(applicationPath) == ".nso"))
|
|
{
|
|
if (Path.GetExtension(applicationPath) == ".nca")
|
|
{
|
|
applicationIcon = RyujinxNcaIcon;
|
|
}
|
|
else if (Path.GetExtension(applicationPath) == ".nso")
|
|
{
|
|
applicationIcon = RyujinxNsoIcon;
|
|
}
|
|
|
|
string fileName = Path.GetFileName(applicationPath);
|
|
string fileExt = Path.GetExtension(applicationPath);
|
|
|
|
StringBuilder titlename = new StringBuilder();
|
|
titlename.Append(fileName);
|
|
titlename.Remove(fileName.Length - fileExt.Length, fileExt.Length);
|
|
|
|
titleName = titlename.ToString();
|
|
titleId = "0000000000000000";
|
|
version = "?";
|
|
developer = "Unknown";
|
|
}
|
|
}
|
|
|
|
string[] playedData = GetPlayedData(titleId, "00000000000000000000000000000001");
|
|
|
|
ApplicationData data = new ApplicationData()
|
|
{
|
|
Icon = applicationIcon,
|
|
TitleName = titleName,
|
|
TitleId = titleId,
|
|
Developer = developer,
|
|
Version = version,
|
|
TimePlayed = playedData[0],
|
|
LastPlayed = playedData[1],
|
|
FileExt = Path.GetExtension(applicationPath).ToUpper().Remove(0 ,1),
|
|
FileSize = (filesize < 1) ? (filesize * 1024).ToString("0.##") + "MB" : filesize.ToString("0.##") + "GB",
|
|
Path = applicationPath,
|
|
};
|
|
|
|
ApplicationLibraryData.Add(data);
|
|
}
|
|
}
|
|
|
|
private static byte[] GetResourceBytes(string resourceName)
|
|
{
|
|
Stream resourceStream = Assembly.GetCallingAssembly().GetManifestResourceStream(resourceName);
|
|
byte[] resourceByteArray = new byte[resourceStream.Length];
|
|
|
|
resourceStream.Read(resourceByteArray);
|
|
|
|
return resourceByteArray;
|
|
}
|
|
|
|
private static IFileSystem GetControlFs(PartitionFileSystem Pfs)
|
|
{
|
|
Nca controlNca = null;
|
|
|
|
// Add keys to keyset if needed
|
|
foreach (DirectoryEntry ticketEntry in Pfs.EnumerateEntries("*.tik"))
|
|
{
|
|
Ticket ticket = new Ticket(Pfs.OpenFile(ticketEntry.FullPath, OpenMode.Read).AsStream());
|
|
|
|
if (!KeySet.TitleKeys.ContainsKey(ticket.RightsId))
|
|
{
|
|
KeySet.TitleKeys.Add(ticket.RightsId, ticket.GetTitleKey(KeySet));
|
|
}
|
|
}
|
|
|
|
// Find the Control NCA and store it in variable called controlNca
|
|
foreach (DirectoryEntry fileEntry in Pfs.EnumerateEntries("*.nca"))
|
|
{
|
|
Nca nca = new Nca(KeySet, Pfs.OpenFile(fileEntry.FullPath, OpenMode.Read).AsStorage());
|
|
if (nca.Header.ContentType == ContentType.Control)
|
|
{
|
|
controlNca = nca;
|
|
}
|
|
}
|
|
|
|
// Return the ControlFS
|
|
return controlNca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.None);
|
|
}
|
|
|
|
private static string[] GetPlayedData(string TitleId, string UserId)
|
|
{
|
|
try
|
|
{
|
|
string[] playedData = new string[2];
|
|
string savePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "RyuFS", "nand", "user", "save", "0000000000000000", UserId, TitleId);
|
|
|
|
if (File.Exists(Path.Combine(savePath, "TimePlayed.dat")) == false)
|
|
{
|
|
Directory.CreateDirectory(savePath);
|
|
using (FileStream file = File.OpenWrite(Path.Combine(savePath, "TimePlayed.dat")))
|
|
{
|
|
file.Write(Encoding.ASCII.GetBytes("0"));
|
|
}
|
|
}
|
|
using (FileStream fs = File.OpenRead(Path.Combine(savePath, "TimePlayed.dat")))
|
|
{
|
|
using (StreamReader sr = new StreamReader(fs))
|
|
{
|
|
float timePlayed = float.Parse(sr.ReadLine());
|
|
|
|
if (timePlayed < SecondsPerMinute)
|
|
{
|
|
playedData[0] = $"{timePlayed}s";
|
|
}
|
|
else if (timePlayed < SecondsPerHour)
|
|
{
|
|
playedData[0] = $"{Math.Round(timePlayed / SecondsPerMinute, 2, MidpointRounding.AwayFromZero)} mins";
|
|
}
|
|
else if (timePlayed < SecondsPerDay)
|
|
{
|
|
playedData[0] = $"{Math.Round(timePlayed / SecondsPerHour , 2, MidpointRounding.AwayFromZero)} hrs";
|
|
}
|
|
else
|
|
{
|
|
playedData[0] = $"{Math.Round(timePlayed / SecondsPerDay , 2, MidpointRounding.AwayFromZero)} days";
|
|
}
|
|
}
|
|
}
|
|
|
|
if (File.Exists(Path.Combine(savePath, "LastPlayed.dat")) == false)
|
|
{
|
|
Directory.CreateDirectory(savePath);
|
|
using (FileStream file = File.OpenWrite(Path.Combine(savePath, "LastPlayed.dat")))
|
|
{
|
|
file.Write(Encoding.ASCII.GetBytes("Never"));
|
|
}
|
|
}
|
|
|
|
using (FileStream fs = File.OpenRead(Path.Combine(savePath, "LastPlayed.dat")))
|
|
{
|
|
using (StreamReader sr = new StreamReader(fs))
|
|
{
|
|
playedData[1] = sr.ReadLine();
|
|
}
|
|
}
|
|
|
|
return playedData;
|
|
}
|
|
catch
|
|
{
|
|
return new string[] { "Unknown", "Unknown" };
|
|
}
|
|
}
|
|
|
|
private static byte[] NspOrXciIcon(string applicationPath)
|
|
{
|
|
if (Path.GetExtension(applicationPath) == ".xci")
|
|
{
|
|
return RyujinxXciIcon;
|
|
}
|
|
else
|
|
{
|
|
return RyujinxNspIcon;
|
|
}
|
|
}
|
|
}
|
|
}
|