vance/ryujinx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Ryujinx.HLE] Address dotnet-format issues (#5380)

Browse Source 
* dotnet format style --severity info

Some changes were manually reverted.

* dotnet format analyzers --serverity info

Some changes have been minimally adapted.

* Restore a few unused methods and variables

* Silence dotnet format IDE0060 warnings

* Silence dotnet format IDE0052 warnings

* Address or silence dotnet format IDE1006 warnings

* Address dotnet format CA1816 warnings

* Address or silence dotnet format CA2208 warnings

* Address or silence dotnet format CA1806 and a few CA1854 warnings

* Address dotnet format CA2211 warnings

* Address dotnet format CA1822 warnings

* Address or silence dotnet format CA1069 warnings

* Make dotnet format succeed in style mode

* Address or silence dotnet format CA2211 warnings

* Address review comments

* Address dotnet format CA2208 warnings properly

* Make ProcessResult readonly

* Address most dotnet format whitespace warnings

* Apply dotnet format whitespace formatting

A few of them have been manually reverted and the corresponding warning was silenced

* Add previously silenced warnings back

I have no clue how these disappeared

* Revert formatting changes for while and for-loops

* Format if-blocks correctly

* Run dotnet format style after rebase

* Run dotnet format whitespace after rebase

* Run dotnet format style after rebase

* Run dotnet format analyzers after rebase

* Run dotnet format after rebase and remove unused usings

- analyzers
- style
- whitespace

* Disable 'prefer switch expression' rule

* Add comments to disabled warnings

* Fix a few disabled warnings

* Fix naming rule violation, Convert shader properties to auto-property and convert values to const

* Simplify properties and array initialization, Use const when possible, Remove trailing commas

* Start working on disabled warnings

* Fix and silence a few dotnet-format warnings again

* Run dotnet format after rebase

* Use using declaration instead of block syntax

* Address IDE0251 warnings

* Address a few disabled IDE0060 warnings

* Silence IDE0060 in .editorconfig

* Revert "Simplify properties and array initialization, Use const when possible, Remove trailing commas"

This reverts commit 9462e4136c0a2100dc28b20cf9542e06790aa67e.

* dotnet format whitespace after rebase

* First dotnet format pass

* Fix naming rule violations

* Fix typo

* Add trailing commas, use targeted new and use array initializer

* Fix build issues

* Fix remaining build issues

* Remove SuppressMessage for CA1069 where possible

* Address dotnet format issues

* Address formatting issues

Co-authored-by: Ac_K <acoustik666@gmail.com>

* Add GetHashCode implementation for RenderingSurfaceInfo

* Explicitly silence CA1822 for every affected method in Syscall

* Address formatting issues in Demangler.cs

* Address review feedback

Co-authored-by: Ac_K <acoustik666@gmail.com>

* Revert marking service methods as static

* Next dotnet format pass

* Address review feedback

---------

Co-authored-by: Ac_K <acoustik666@gmail.com>
This commit is contained in:
TSRBerry 2023-07-16 19:31:14 +02:00 committed by GitHub
parent fec8291c17
commit 326749498b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1015 changed files with 8173 additions and 7615 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Ryujinx.Ava/Common/ApplicationHelper.cs
View File

@ -114,7 +114,7 @@ namespace Ryujinx.Ava.Common
public static void OpenSaveDir(ulong saveDataId) public static void OpenSaveDir(ulong saveDataId)
{ {
string saveRootPath = Path.Combine(_virtualFileSystem.GetNandPath(), $"user/save/{saveDataId:x16}"); string saveRootPath = Path.Combine(VirtualFileSystem.GetNandPath(), $"user/save/{saveDataId:x16}");
if (!Directory.Exists(saveRootPath)) if (!Directory.Exists(saveRootPath))
{ {

3
src/Ryujinx.Ava/UI/Models/SaveModel.cs
View File

@ -2,6 +2,7 @@ using LibHac.Fs;
using LibHac.Ncm; using LibHac.Ncm;
using Ryujinx.Ava.UI.ViewModels; using Ryujinx.Ava.UI.ViewModels;
using Ryujinx.Ava.UI.Windows; using Ryujinx.Ava.UI.Windows;
using Ryujinx.HLE.FileSystem;
using Ryujinx.Ui.App.Common; using Ryujinx.Ui.App.Common;
using System; using System;
using System.IO; using System.IO;
@ -81,7 +82,7 @@ namespace Ryujinx.Ava.UI.Models
Task.Run(() => Task.Run(() =>
{ {
var saveRoot = Path.Combine(MainWindow.MainWindowViewModel.VirtualFileSystem.GetNandPath(), $"user/save/{info.SaveDataId:x16}"); var saveRoot = Path.Combine(VirtualFileSystem.GetNandPath(), $"user/save/{info.SaveDataId:x16}");
long totalSize = GetDirectorySize(saveRoot); long totalSize = GetDirectorySize(saveRoot);

2
src/Ryujinx.Ava/UI/ViewModels/UserFirmwareAvatarSelectorViewModel.cs
View File

@ -105,7 +105,7 @@ namespace Ryujinx.Ava.UI.ViewModels
} }
string contentPath = contentManager.GetInstalledContentPath(0x010000000000080A, StorageId.BuiltInSystem, NcaContentType.Data); string contentPath = contentManager.GetInstalledContentPath(0x010000000000080A, StorageId.BuiltInSystem, NcaContentType.Data);
string avatarPath = virtualFileSystem.SwitchPathToSystemPath(contentPath); string avatarPath = VirtualFileSystem.SwitchPathToSystemPath(contentPath);
if (!string.IsNullOrWhiteSpace(avatarPath)) if (!string.IsNullOrWhiteSpace(avatarPath))
{ {

2
src/Ryujinx.HLE/AssemblyInfo.cs
View File

@ -1,3 +1,3 @@
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("Ryujinx.Tests")] [assembly: InternalsVisibleTo("Ryujinx.Tests")]

2
src/Ryujinx.HLE/Exceptions/GuestBrokeExecutionException.cs
View File

@ -8,4 +8,4 @@ namespace Ryujinx.HLE.Exceptions
public GuestBrokeExecutionException() : base(ExMsg) { } public GuestBrokeExecutionException() : base(ExMsg) { }
} }
} }

4
src/Ryujinx.HLE/Exceptions/InternalServiceException.cs
View File

@ -2,8 +2,8 @@
namespace Ryujinx.HLE.Exceptions namespace Ryujinx.HLE.Exceptions
{ {
class InternalServiceException: Exception class InternalServiceException : Exception
{ {
public InternalServiceException(string message) : base(message) { } public InternalServiceException(string message) : base(message) { }
} }
} }

2
src/Ryujinx.HLE/Exceptions/InvalidFirmwarePackageException.cs
View File

@ -6,4 +6,4 @@ namespace Ryujinx.HLE.Exceptions
{ {
public InvalidFirmwarePackageException(string message) : base(message) { } public InvalidFirmwarePackageException(string message) : base(message) { }
} }
} }

2
src/Ryujinx.HLE/Exceptions/InvalidNpdmException.cs
View File

@ -6,4 +6,4 @@ namespace Ryujinx.HLE.Exceptions
{ {
public InvalidNpdmException(string message) : base(message) { } public InvalidNpdmException(string message) : base(message) { }
} }
} }

6
src/Ryujinx.HLE/Exceptions/InvalidStructLayoutException.cs
View File

@ -3,13 +3,13 @@ using System.Runtime.CompilerServices;
namespace Ryujinx.HLE.Exceptions namespace Ryujinx.HLE.Exceptions
{ {
public class InvalidStructLayoutException<T> : Exception public class InvalidStructLayoutException<T> : Exception
{ {
static readonly Type _structType = typeof(T); static readonly Type _structType = typeof(T);
public InvalidStructLayoutException(string message) : base(message) { } public InvalidStructLayoutException(string message) : base(message) { }
public InvalidStructLayoutException(int expectedSize) public InvalidStructLayoutException(int expectedSize)
: base($"Type {_structType.Name} has the wrong size. Expected: {expectedSize} bytes, got: {Unsafe.SizeOf<T>()} bytes") { } : base($"Type {_structType.Name} has the wrong size. Expected: {expectedSize} bytes, got: {Unsafe.SizeOf<T>()} bytes") { }
} }
} }

2
src/Ryujinx.HLE/Exceptions/InvalidSystemResourceException.cs
View File

@ -6,4 +6,4 @@ namespace Ryujinx.HLE.Exceptions
{ {
public InvalidSystemResourceException(string message) : base(message) { } public InvalidSystemResourceException(string message) : base(message) { }
} }
} }

16
src/Ryujinx.HLE/Exceptions/ServiceNotImplementedException.cs
View File

@ -47,7 +47,7 @@ namespace Ryujinx.HLE.Exceptions
private string BuildMessage() private string BuildMessage()
{ {
StringBuilder sb = new StringBuilder(); StringBuilder sb = new();
// Print the IPC command details (service name, command ID, and handler) // Print the IPC command details (service name, command ID, and handler)
(Type callingType, MethodBase callingMethod) = WalkStackTrace(new StackTrace(this)); (Type callingType, MethodBase callingMethod) = WalkStackTrace(new StackTrace(this));
@ -58,9 +58,9 @@ namespace Ryujinx.HLE.Exceptions
var ipcCommands = Request.Type > IpcMessageType.TipcCloseSession ? Service.TipcCommands : Service.CmifCommands; var ipcCommands = Request.Type > IpcMessageType.TipcCloseSession ? Service.TipcCommands : Service.CmifCommands;
// Find the handler for the method called // Find the handler for the method called
var ipcHandler = ipcCommands.FirstOrDefault(x => x.Value == callingMethod); var ipcHandler = ipcCommands.FirstOrDefault(x => x.Value == callingMethod);
var ipcCommandId = ipcHandler.Key; var ipcCommandId = ipcHandler.Key;
var ipcMethod = ipcHandler.Value; var ipcMethod = ipcHandler.Value;
if (ipcMethod != null) if (ipcMethod != null)
{ {
@ -73,9 +73,9 @@ namespace Ryujinx.HLE.Exceptions
sb.AppendLine(Context.Thread.GetGuestStackTrace()); sb.AppendLine(Context.Thread.GetGuestStackTrace());
// Print buffer information // Print buffer information
if (Request.PtrBuff.Count > 0 || if (Request.PtrBuff.Count > 0 ||
Request.SendBuff.Count > 0 || Request.SendBuff.Count > 0 ||
Request.ReceiveBuff.Count > 0 || Request.ReceiveBuff.Count > 0 ||
Request.ExchangeBuff.Count > 0 || Request.ExchangeBuff.Count > 0 ||
Request.RecvListBuff.Count > 0) Request.RecvListBuff.Count > 0)
{ {
@ -149,7 +149,7 @@ namespace Ryujinx.HLE.Exceptions
// Find the IIpcService method that threw this exception // Find the IIpcService method that threw this exception
while ((frame = trace.GetFrame(i++)) != null) while ((frame = trace.GetFrame(i++)) != null)
{ {
var method = frame.GetMethod(); var method = frame.GetMethod();
var declType = method.DeclaringType; var declType = method.DeclaringType;
if (typeof(IpcService).IsAssignableFrom(declType)) if (typeof(IpcService).IsAssignableFrom(declType))
@ -161,4 +161,4 @@ namespace Ryujinx.HLE.Exceptions
return (null, null); return (null, null);
} }
} }
} }

2
src/Ryujinx.HLE/Exceptions/TamperCompilationException.cs
View File

@ -6,4 +6,4 @@ namespace Ryujinx.HLE.Exceptions
{ {
public TamperCompilationException(string message) : base(message) { } public TamperCompilationException(string message) : base(message) { }
} }
} }

2
src/Ryujinx.HLE/Exceptions/TamperExecutionException.cs
View File

@ -6,4 +6,4 @@ namespace Ryujinx.HLE.Exceptions
{ {
public TamperExecutionException(string message) : base(message) { } public TamperExecutionException(string message) : base(message) { }
} }
} }

2
src/Ryujinx.HLE/Exceptions/UndefinedInstructionException.cs
View File

@ -10,4 +10,4 @@ namespace Ryujinx.HLE.Exceptions
public UndefinedInstructionException(ulong address, int opCode) : base(string.Format(ExMsg, address, opCode)) { } public UndefinedInstructionException(ulong address, int opCode) : base(string.Format(ExMsg, address, opCode)) { }
} }
} }

407
src/Ryujinx.HLE/FileSystem/ContentManager.cs
View File

@ -26,17 +26,17 @@ namespace Ryujinx.HLE.FileSystem
public class ContentManager public class ContentManager
{ {
private const ulong SystemVersionTitleId = 0x0100000000000809; private const ulong SystemVersionTitleId = 0x0100000000000809;
private const ulong SystemUpdateTitleId = 0x0100000000000816; private const ulong SystemUpdateTitleId = 0x0100000000000816;
private Dictionary<StorageId, LinkedList<LocationEntry>> _locationEntries; private Dictionary<StorageId, LinkedList<LocationEntry>> _locationEntries;
private Dictionary<string, ulong> _sharedFontTitleDictionary; private readonly Dictionary<string, ulong> _sharedFontTitleDictionary;
private Dictionary<ulong, string> _systemTitlesNameDictionary; private readonly Dictionary<ulong, string> _systemTitlesNameDictionary;
private Dictionary<string, string> _sharedFontFilenameDictionary; private readonly Dictionary<string, string> _sharedFontFilenameDictionary;
private SortedDictionary<(ulong titleId, NcaContentType type), string> _contentDictionary; private SortedDictionary<(ulong titleId, NcaContentType type), string> _contentDictionary;
private struct AocItem private readonly struct AocItem
{ {
public readonly string ContainerPath; public readonly string ContainerPath;
public readonly string NcaPath; public readonly string NcaPath;
@ -48,16 +48,16 @@ namespace Ryujinx.HLE.FileSystem
} }
} }
private SortedList<ulong, AocItem> _aocData { get; } private SortedList<ulong, AocItem> AocData { get; }
private VirtualFileSystem _virtualFileSystem; private readonly VirtualFileSystem _virtualFileSystem;
private readonly object _lock = new(); private readonly object _lock = new();
public ContentManager(VirtualFileSystem virtualFileSystem) public ContentManager(VirtualFileSystem virtualFileSystem)
{ {
_contentDictionary = new SortedDictionary<(ulong, NcaContentType), string>(); _contentDictionary = new SortedDictionary<(ulong, NcaContentType), string>();
_locationEntries = new Dictionary<StorageId, LinkedList<LocationEntry>>(); _locationEntries = new Dictionary<StorageId, LinkedList<LocationEntry>>();
_sharedFontTitleDictionary = new Dictionary<string, ulong> _sharedFontTitleDictionary = new Dictionary<string, ulong>
{ {
@ -66,7 +66,7 @@ namespace Ryujinx.HLE.FileSystem
{ "FontExtendedChineseSimplified", 0x0100000000000814 }, { "FontExtendedChineseSimplified", 0x0100000000000814 },
{ "FontKorean", 0x0100000000000812 }, { "FontKorean", 0x0100000000000812 },
{ "FontChineseTraditional", 0x0100000000000813 }, { "FontChineseTraditional", 0x0100000000000813 },
{ "FontNintendoExtended", 0x0100000000000810 } { "FontNintendoExtended", 0x0100000000000810 },
}; };
_systemTitlesNameDictionary = new Dictionary<ulong, string>() _systemTitlesNameDictionary = new Dictionary<ulong, string>()
@ -86,12 +86,12 @@ namespace Ryujinx.HLE.FileSystem
{ "FontExtendedChineseSimplified", "nintendo_udsg-r_ext_zh-cn_003.bfttf" }, { "FontExtendedChineseSimplified", "nintendo_udsg-r_ext_zh-cn_003.bfttf" },
{ "FontKorean", "nintendo_udsg-r_ko_003.bfttf" }, { "FontKorean", "nintendo_udsg-r_ko_003.bfttf" },
{ "FontChineseTraditional", "nintendo_udjxh-db_zh-tw_003.bfttf" }, { "FontChineseTraditional", "nintendo_udjxh-db_zh-tw_003.bfttf" },
{ "FontNintendoExtended", "nintendo_ext_003.bfttf" } { "FontNintendoExtended", "nintendo_ext_003.bfttf" },
}; };
_virtualFileSystem = virtualFileSystem; _virtualFileSystem = virtualFileSystem;
_aocData = new SortedList<ulong, AocItem>(); AocData = new SortedList<ulong, AocItem>();
} }
public void LoadEntries(Switch device = null) public void LoadEntries(Switch device = null)
@ -99,18 +99,18 @@ namespace Ryujinx.HLE.FileSystem
lock (_lock) lock (_lock)
{ {
_contentDictionary = new SortedDictionary<(ulong, NcaContentType), string>(); _contentDictionary = new SortedDictionary<(ulong, NcaContentType), string>();
_locationEntries = new Dictionary<StorageId, LinkedList<LocationEntry>>(); _locationEntries = new Dictionary<StorageId, LinkedList<LocationEntry>>();
foreach (StorageId storageId in Enum.GetValues<StorageId>()) foreach (StorageId storageId in Enum.GetValues<StorageId>())
{ {
string contentDirectory = null; string contentDirectory = null;
string contentPathString = null; string contentPathString = null;
string registeredDirectory = null; string registeredDirectory = null;
try try
{ {
contentPathString = ContentPath.GetContentPath(storageId); contentPathString = ContentPath.GetContentPath(storageId);
contentDirectory = ContentPath.GetRealPath(_virtualFileSystem, contentPathString); contentDirectory = ContentPath.GetRealPath(contentPathString);
registeredDirectory = Path.Combine(contentDirectory, "registered"); registeredDirectory = Path.Combine(contentDirectory, "registered");
} }
catch (NotSupportedException) catch (NotSupportedException)
@ -120,7 +120,7 @@ namespace Ryujinx.HLE.FileSystem
Directory.CreateDirectory(registeredDirectory); Directory.CreateDirectory(registeredDirectory);
LinkedList<LocationEntry> locationList = new LinkedList<LocationEntry>(); LinkedList<LocationEntry> locationList = new();
void AddEntry(LocationEntry entry) void AddEntry(LocationEntry entry)
{ {
@ -133,24 +133,19 @@ namespace Ryujinx.HLE.FileSystem
{ {
string ncaName = new DirectoryInfo(directoryPath).Name.Replace(".nca", string.Empty); string ncaName = new DirectoryInfo(directoryPath).Name.Replace(".nca", string.Empty);
using (FileStream ncaFile = File.OpenRead(Directory.GetFiles(directoryPath)[0])) using FileStream ncaFile = File.OpenRead(Directory.GetFiles(directoryPath)[0]);
{ Nca nca = new(_virtualFileSystem.KeySet, ncaFile.AsStorage());
Nca nca = new Nca(_virtualFileSystem.KeySet, ncaFile.AsStorage());
string switchPath = contentPathString + ":/" + ncaFile.Name.Replace(contentDirectory, string.Empty).TrimStart(Path.DirectorySeparatorChar); string switchPath = contentPathString + ":/" + ncaFile.Name.Replace(contentDirectory, string.Empty).TrimStart(Path.DirectorySeparatorChar);
// Change path format to switch's // Change path format to switch's
switchPath = switchPath.Replace('\\', '/'); switchPath = switchPath.Replace('\\', '/');
LocationEntry entry = new LocationEntry(switchPath, LocationEntry entry = new(switchPath, 0, nca.Header.TitleId, nca.Header.ContentType);
0,
nca.Header.TitleId,
nca.Header.ContentType);
AddEntry(entry); AddEntry(entry);
_contentDictionary.Add((nca.Header.TitleId, nca.Header.ContentType), ncaName); _contentDictionary.Add((nca.Header.TitleId, nca.Header.ContentType), ncaName);
}
} }
} }
@ -160,24 +155,19 @@ namespace Ryujinx.HLE.FileSystem
{ {
string ncaName = Path.GetFileNameWithoutExtension(filePath); string ncaName = Path.GetFileNameWithoutExtension(filePath);
using (FileStream ncaFile = new FileStream(filePath, FileMode.Open, FileAccess.Read)) using FileStream ncaFile = new(filePath, FileMode.Open, FileAccess.Read);
{ Nca nca = new(_virtualFileSystem.KeySet, ncaFile.AsStorage());
Nca nca = new Nca(_virtualFileSystem.KeySet, ncaFile.AsStorage());
string switchPath = contentPathString + ":/" + filePath.Replace(contentDirectory, string.Empty).TrimStart(Path.DirectorySeparatorChar); string switchPath = contentPathString + ":/" + filePath.Replace(contentDirectory, string.Empty).TrimStart(Path.DirectorySeparatorChar);
// Change path format to switch's // Change path format to switch's
switchPath = switchPath.Replace('\\', '/'); switchPath = switchPath.Replace('\\', '/');
LocationEntry entry = new LocationEntry(switchPath, LocationEntry entry = new(switchPath, 0, nca.Header.TitleId, nca.Header.ContentType);
0,
nca.Header.TitleId,
nca.Header.ContentType);
AddEntry(entry); AddEntry(entry);
_contentDictionary.Add((nca.Header.TitleId, nca.Header.ContentType), ncaName); _contentDictionary.Add((nca.Header.TitleId, nca.Header.ContentType), ncaName);
}
} }
} }
@ -186,10 +176,7 @@ namespace Ryujinx.HLE.FileSystem
_locationEntries.Remove(storageId); _locationEntries.Remove(storageId);
} }
if (!_locationEntries.ContainsKey(storageId)) _locationEntries.TryAdd(storageId, locationList);
{
_locationEntries.Add(storageId, locationList);
}
} }
if (device != null) if (device != null)
@ -239,7 +226,7 @@ namespace Ryujinx.HLE.FileSystem
public void AddAocItem(ulong titleId, string containerPath, string ncaPath, bool mergedToContainer = false) public void AddAocItem(ulong titleId, string containerPath, string ncaPath, bool mergedToContainer = false)
{ {
// TODO: Check Aoc version. // TODO: Check Aoc version.
if (!_aocData.TryAdd(titleId, new AocItem(containerPath, ncaPath))) if (!AocData.TryAdd(titleId, new AocItem(containerPath, ncaPath)))
{ {
Logger.Warning?.Print(LogClass.Application, $"Duplicate AddOnContent detected. TitleId {titleId:X16}"); Logger.Warning?.Print(LogClass.Application, $"Duplicate AddOnContent detected. TitleId {titleId:X16}");
} }
@ -249,7 +236,7 @@ namespace Ryujinx.HLE.FileSystem
if (!mergedToContainer) if (!mergedToContainer)
{ {
using FileStream fileStream = File.OpenRead(containerPath); using FileStream fileStream = File.OpenRead(containerPath);
using PartitionFileSystem partitionFileSystem = new(fileStream.AsStorage()); using PartitionFileSystem partitionFileSystem = new(fileStream.AsStorage());
_virtualFileSystem.ImportTickets(partitionFileSystem); _virtualFileSystem.ImportTickets(partitionFileSystem);
@ -257,17 +244,17 @@ namespace Ryujinx.HLE.FileSystem
} }
} }
public void ClearAocData() => _aocData.Clear(); public void ClearAocData() => AocData.Clear();
public int GetAocCount() => _aocData.Count; public int GetAocCount() => AocData.Count;
public IList<ulong> GetAocTitleIds() => _aocData.Select(e => e.Key).ToList(); public IList<ulong> GetAocTitleIds() => AocData.Select(e => e.Key).ToList();
public bool GetAocDataStorage(ulong aocTitleId, out IStorage aocStorage, IntegrityCheckLevel integrityCheckLevel) public bool GetAocDataStorage(ulong aocTitleId, out IStorage aocStorage, IntegrityCheckLevel integrityCheckLevel)
{ {
aocStorage = null; aocStorage = null;
if (_aocData.TryGetValue(aocTitleId, out AocItem aoc)) if (AocData.TryGetValue(aocTitleId, out AocItem aoc))
{ {
var file = new FileStream(aoc.ContainerPath, FileMode.Open, FileAccess.Read); var file = new FileStream(aoc.ContainerPath, FileMode.Open, FileAccess.Read);
using var ncaFile = new UniqueRef<IFile>(); using var ncaFile = new UniqueRef<IFile>();
@ -307,7 +294,7 @@ namespace Ryujinx.HLE.FileSystem
{ {
lock (_lock) lock (_lock)
{ {
LinkedList<LocationEntry> locationList = _locationEntries[storageId]; LinkedList<LocationEntry> locationList = _locationEntries[storageId];
LinkedListNode<LocationEntry> locationEntry = locationList.First; LinkedListNode<LocationEntry> locationEntry = locationList.First;
while (locationEntry != null) while (locationEntry != null)
@ -331,7 +318,7 @@ namespace Ryujinx.HLE.FileSystem
if (_contentDictionary.ContainsValue(ncaId)) if (_contentDictionary.ContainsValue(ncaId))
{ {
var content = _contentDictionary.FirstOrDefault(x => x.Value == ncaId); var content = _contentDictionary.FirstOrDefault(x => x.Value == ncaId);
ulong titleId = content.Key.Item1; ulong titleId = content.Key.titleId;
NcaContentType contentType = content.Key.type; NcaContentType contentType = content.Key.type;
StorageId storage = GetInstalledStorage(titleId, contentType, storageId); StorageId storage = GetInstalledStorage(titleId, contentType, storageId);
@ -403,19 +390,17 @@ namespace Ryujinx.HLE.FileSystem
return false; return false;
} }
string installedPath = _virtualFileSystem.SwitchPathToSystemPath(locationEntry.ContentPath); string installedPath = VirtualFileSystem.SwitchPathToSystemPath(locationEntry.ContentPath);
if (!string.IsNullOrWhiteSpace(installedPath)) if (!string.IsNullOrWhiteSpace(installedPath))
{ {
if (File.Exists(installedPath)) if (File.Exists(installedPath))
{ {
using (FileStream file = new FileStream(installedPath, FileMode.Open, FileAccess.Read)) using FileStream file = new(installedPath, FileMode.Open, FileAccess.Read);
{ Nca nca = new(_virtualFileSystem.KeySet, file.AsStorage());
Nca nca = new Nca(_virtualFileSystem.KeySet, file.AsStorage()); bool contentCheck = nca.Header.ContentType == contentType;
bool contentCheck = nca.Header.ContentType == contentType;
return contentCheck; return contentCheck;
}
} }
} }
@ -426,9 +411,9 @@ namespace Ryujinx.HLE.FileSystem
{ {
LinkedList<LocationEntry> locationList = null; LinkedList<LocationEntry> locationList = null;
if (_locationEntries.ContainsKey(storageId)) if (_locationEntries.TryGetValue(storageId, out LinkedList<LocationEntry> locationEntry))
{ {
locationList = _locationEntries[storageId]; locationList = locationEntry;
} }
if (locationList != null) if (locationList != null)
@ -446,9 +431,9 @@ namespace Ryujinx.HLE.FileSystem
{ {
LinkedList<LocationEntry> locationList = null; LinkedList<LocationEntry> locationList = null;
if (_locationEntries.ContainsKey(storageId)) if (_locationEntries.TryGetValue(storageId, out LinkedList<LocationEntry> locationEntry))
{ {
locationList = _locationEntries[storageId]; locationList = locationEntry;
} }
if (locationList != null) if (locationList != null)
@ -487,10 +472,10 @@ namespace Ryujinx.HLE.FileSystem
public void InstallFirmware(string firmwareSource) public void InstallFirmware(string firmwareSource)
{ {
string contentPathString = ContentPath.GetContentPath(StorageId.BuiltInSystem); string contentPathString = ContentPath.GetContentPath(StorageId.BuiltInSystem);
string contentDirectory = ContentPath.GetRealPath(_virtualFileSystem, contentPathString); string contentDirectory = ContentPath.GetRealPath(contentPathString);
string registeredDirectory = Path.Combine(contentDirectory, "registered"); string registeredDirectory = Path.Combine(contentDirectory, "registered");
string temporaryDirectory = Path.Combine(contentDirectory, "temp"); string temporaryDirectory = Path.Combine(contentDirectory, "temp");
if (Directory.Exists(temporaryDirectory)) if (Directory.Exists(temporaryDirectory))
{ {
@ -510,28 +495,27 @@ namespace Ryujinx.HLE.FileSystem
throw new FileNotFoundException("Firmware file does not exist."); throw new FileNotFoundException("Firmware file does not exist.");
} }
FileInfo info = new FileInfo(firmwareSource); FileInfo info = new(firmwareSource);
using (FileStream file = File.OpenRead(firmwareSource)) using FileStream file = File.OpenRead(firmwareSource);
switch (info.Extension)
{ {
switch (info.Extension) case ".zip":
{ using (ZipArchive archive = ZipFile.OpenRead(firmwareSource))
case ".zip": {
using (ZipArchive archive = ZipFile.OpenRead(firmwareSource)) InstallFromZip(archive, temporaryDirectory);
{ }
InstallFromZip(archive, temporaryDirectory); break;
} case ".xci":
break; Xci xci = new(_virtualFileSystem.KeySet, file.AsStorage());
case ".xci": InstallFromCart(xci, temporaryDirectory);
Xci xci = new Xci(_virtualFileSystem.KeySet, file.AsStorage()); break;
InstallFromCart(xci, temporaryDirectory); default:
break; throw new InvalidFirmwarePackageException("Input file is not a valid firmware package");
default:
throw new InvalidFirmwarePackageException("Input file is not a valid firmware package");
}
FinishInstallation(temporaryDirectory, registeredDirectory);
} }
FinishInstallation(temporaryDirectory, registeredDirectory);
} }
private void FinishInstallation(string temporaryDirectory, string registeredDirectory) private void FinishInstallation(string temporaryDirectory, string registeredDirectory)
@ -555,7 +539,7 @@ namespace Ryujinx.HLE.FileSystem
{ {
foreach (var entry in filesystem.EnumerateEntries("/", "*.nca")) foreach (var entry in filesystem.EnumerateEntries("/", "*.nca"))
{ {
Nca nca = new Nca(_virtualFileSystem.KeySet, OpenPossibleFragmentedFile(filesystem, entry.FullPath, OpenMode.Read).AsStorage()); Nca nca = new(_virtualFileSystem.KeySet, OpenPossibleFragmentedFile(filesystem, entry.FullPath, OpenMode.Read).AsStorage());
SaveNca(nca, entry.Name.Remove(entry.Name.IndexOf('.')), temporaryDirectory); SaveNca(nca, entry.Name.Remove(entry.Name.IndexOf('.')), temporaryDirectory);
} }
@ -575,52 +559,47 @@ namespace Ryujinx.HLE.FileSystem
} }
} }
private void InstallFromZip(ZipArchive archive, string temporaryDirectory) private static void InstallFromZip(ZipArchive archive, string temporaryDirectory)
{ {
using (archive) foreach (var entry in archive.Entries)
{ {
foreach (var entry in archive.Entries) if (entry.FullName.EndsWith(".nca") || entry.FullName.EndsWith(".nca/00"))
{ {
if (entry.FullName.EndsWith(".nca") || entry.FullName.EndsWith(".nca/00")) // Clean up the name and get the NcaId
string[] pathComponents = entry.FullName.Replace(".cnmt", "").Split('/');
string ncaId = pathComponents[^1];
// If this is a fragmented nca, we need to get the previous element.GetZip
if (ncaId.Equals("00"))
{ {
// Clean up the name and get the NcaId ncaId = pathComponents[^2];
}
string[] pathComponents = entry.FullName.Replace(".cnmt", "").Split('/'); if (ncaId.Contains(".nca"))
{
string newPath = Path.Combine(temporaryDirectory, ncaId);
string ncaId = pathComponents[pathComponents.Length - 1]; Directory.CreateDirectory(newPath);
// If this is a fragmented nca, we need to get the previous element.GetZip entry.ExtractToFile(Path.Combine(newPath, "00"));
if (ncaId.Equals("00"))
{
ncaId = pathComponents[pathComponents.Length - 2];
}
if (ncaId.Contains(".nca"))
{
string newPath = Path.Combine(temporaryDirectory, ncaId);
Directory.CreateDirectory(newPath);
entry.ExtractToFile(Path.Combine(newPath, "00"));
}
} }
} }
} }
} }
public void SaveNca(Nca nca, string ncaId, string temporaryDirectory) public static void SaveNca(Nca nca, string ncaId, string temporaryDirectory)
{ {
string newPath = Path.Combine(temporaryDirectory, ncaId + ".nca"); string newPath = Path.Combine(temporaryDirectory, ncaId + ".nca");
Directory.CreateDirectory(newPath); Directory.CreateDirectory(newPath);
using (FileStream file = File.Create(Path.Combine(newPath, "00"))) using FileStream file = File.Create(Path.Combine(newPath, "00"));
{ nca.BaseStorage.AsStream().CopyTo(file);
nca.BaseStorage.AsStream().CopyTo(file);
}
} }
private IFile OpenPossibleFragmentedFile(IFileSystem filesystem, string path, OpenMode mode) private static IFile OpenPossibleFragmentedFile(IFileSystem filesystem, string path, OpenMode mode)
{ {
using var file = new UniqueRef<IFile>(); using var file = new UniqueRef<IFile>();
@ -636,14 +615,12 @@ namespace Ryujinx.HLE.FileSystem
return file.Release(); return file.Release();
} }
private Stream GetZipStream(ZipArchiveEntry entry) private static Stream GetZipStream(ZipArchiveEntry entry)
{ {
MemoryStream dest = MemoryStreamManager.Shared.GetStream(); MemoryStream dest = MemoryStreamManager.Shared.GetStream();
using (Stream src = entry.Open()) using Stream src = entry.Open();
{ src.CopyTo(dest);
src.CopyTo(dest);
}
return dest; return dest;
} }
@ -659,7 +636,7 @@ namespace Ryujinx.HLE.FileSystem
throw new MissingKeyException("HeaderKey is empty. Cannot decrypt NCA headers."); throw new MissingKeyException("HeaderKey is empty. Cannot decrypt NCA headers.");
} }
Dictionary<ulong, List<(NcaContentType type, string path)>> updateNcas = new Dictionary<ulong, List<(NcaContentType, string)>>(); Dictionary<ulong, List<(NcaContentType type, string path)>> updateNcas = new();
if (Directory.Exists(firmwarePackage)) if (Directory.Exists(firmwarePackage))
{ {
@ -671,33 +648,32 @@ namespace Ryujinx.HLE.FileSystem
throw new FileNotFoundException("Firmware file does not exist."); throw new FileNotFoundException("Firmware file does not exist.");
} }
FileInfo info = new FileInfo(firmwarePackage); FileInfo info = new(firmwarePackage);
using (FileStream file = File.OpenRead(firmwarePackage)) using FileStream file = File.OpenRead(firmwarePackage);
switch (info.Extension)
{ {
switch (info.Extension) case ".zip":
{ using (ZipArchive archive = ZipFile.OpenRead(firmwarePackage))
case ".zip": {
using (ZipArchive archive = ZipFile.OpenRead(firmwarePackage)) return VerifyAndGetVersionZip(archive);
{ }
return VerifyAndGetVersionZip(archive); case ".xci":
} Xci xci = new(_virtualFileSystem.KeySet, file.AsStorage());
case ".xci":
Xci xci = new Xci(_virtualFileSystem.KeySet, file.AsStorage());
if (xci.HasPartition(XciPartitionType.Update)) if (xci.HasPartition(XciPartitionType.Update))
{ {
XciPartition partition = xci.OpenPartition(XciPartitionType.Update); XciPartition partition = xci.OpenPartition(XciPartitionType.Update);
return VerifyAndGetVersion(partition); return VerifyAndGetVersion(partition);
} }
else else
{ {
throw new InvalidFirmwarePackageException("Update not found in xci file."); throw new InvalidFirmwarePackageException("Update not found in xci file.");
} }
default: default:
break; break;
}
} }
SystemVersion VerifyAndGetVersionDirectory(string firmwareDirectory) SystemVersion VerifyAndGetVersionDirectory(string firmwareDirectory)
@ -713,21 +689,19 @@ namespace Ryujinx.HLE.FileSystem
{ {
if (entry.FullName.EndsWith(".nca") || entry.FullName.EndsWith(".nca/00")) if (entry.FullName.EndsWith(".nca") || entry.FullName.EndsWith(".nca/00"))
{ {
using (Stream ncaStream = GetZipStream(entry)) using Stream ncaStream = GetZipStream(entry);
IStorage storage = ncaStream.AsStorage();
Nca nca = new(_virtualFileSystem.KeySet, storage);
if (updateNcas.TryGetValue(nca.Header.TitleId, out var updateNcasItem))
{ {
IStorage storage = ncaStream.AsStorage(); updateNcasItem.Add((nca.Header.ContentType, entry.FullName));
}
Nca nca = new Nca(_virtualFileSystem.KeySet, storage); else
{
if (updateNcas.TryGetValue(nca.Header.TitleId, out var updateNcasItem)) updateNcas.Add(nca.Header.TitleId, new List<(NcaContentType, string)>());
{ updateNcas[nca.Header.TitleId].Add((nca.Header.ContentType, entry.FullName));
updateNcasItem.Add((nca.Header.ContentType, entry.FullName));
}
else
{
updateNcas.Add(nca.Header.TitleId, new List<(NcaContentType, string)>());
updateNcas[nca.Header.TitleId].Add((nca.Header.ContentType, entry.FullName));
}
} }
} }
} }
@ -742,7 +716,7 @@ namespace Ryujinx.HLE.FileSystem
using (Stream ncaStream = GetZipStream(fileEntry)) using (Stream ncaStream = GetZipStream(fileEntry))
{ {
Nca metaNca = new Nca(_virtualFileSystem.KeySet, ncaStream.AsStorage()); Nca metaNca = new(_virtualFileSystem.KeySet, ncaStream.AsStorage());
IFileSystem fs = metaNca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.ErrorOnInvalid); IFileSystem fs = metaNca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.ErrorOnInvalid);
@ -772,18 +746,16 @@ namespace Ryujinx.HLE.FileSystem
{ {
string versionEntry = updateNcasItem.Find(x => x.type != NcaContentType.Meta).path; string versionEntry = updateNcasItem.Find(x => x.type != NcaContentType.Meta).path;
using (Stream ncaStream = GetZipStream(archive.GetEntry(versionEntry))) using Stream ncaStream = GetZipStream(archive.GetEntry(versionEntry));
Nca nca = new(_virtualFileSystem.KeySet, ncaStream.AsStorage());
var romfs = nca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.ErrorOnInvalid);
using var systemVersionFile = new UniqueRef<IFile>();
if (romfs.OpenFile(ref systemVersionFile.Ref, "/file".ToU8Span(), OpenMode.Read).IsSuccess())
{ {
Nca nca = new Nca(_virtualFileSystem.KeySet, ncaStream.AsStorage()); systemVersion = new SystemVersion(systemVersionFile.Get.AsStream());
var romfs = nca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.ErrorOnInvalid);
using var systemVersionFile = new UniqueRef<IFile>();
if (romfs.OpenFile(ref systemVersionFile.Ref, "/file".ToU8Span(), OpenMode.Read).IsSuccess())
{
systemVersion = new SystemVersion(systemVersionFile.Get.AsStream());
}
} }
} }
@ -804,43 +776,39 @@ namespace Ryujinx.HLE.FileSystem
continue; continue;
} }
ZipArchiveEntry metaZipEntry = archive.GetEntry(metaPath); ZipArchiveEntry metaZipEntry = archive.GetEntry(metaPath);
ZipArchiveEntry contentZipEntry = archive.GetEntry(contentPath); ZipArchiveEntry contentZipEntry = archive.GetEntry(contentPath);
using (Stream metaNcaStream = GetZipStream(metaZipEntry)) using Stream metaNcaStream = GetZipStream(metaZipEntry);
using Stream contentNcaStream = GetZipStream(contentZipEntry);
Nca metaNca = new(_virtualFileSystem.KeySet, metaNcaStream.AsStorage());
IFileSystem fs = metaNca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.ErrorOnInvalid);
string cnmtPath = fs.EnumerateEntries("/", "*.cnmt").Single().FullPath;
using var metaFile = new UniqueRef<IFile>();
if (fs.OpenFile(ref metaFile.Ref, cnmtPath.ToU8Span(), OpenMode.Read).IsSuccess())
{ {
using (Stream contentNcaStream = GetZipStream(contentZipEntry)) var meta = new Cnmt(metaFile.Get.AsStream());
IStorage contentStorage = contentNcaStream.AsStorage();
if (contentStorage.GetSize(out long size).IsSuccess())
{ {
Nca metaNca = new Nca(_virtualFileSystem.KeySet, metaNcaStream.AsStorage()); byte[] contentData = new byte[size];
IFileSystem fs = metaNca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.ErrorOnInvalid); Span<byte> content = new(contentData);
string cnmtPath = fs.EnumerateEntries("/", "*.cnmt").Single().FullPath; contentStorage.Read(0, content);
using var metaFile = new UniqueRef<IFile>(); Span<byte> hash = new(new byte[32]);
if (fs.OpenFile(ref metaFile.Ref, cnmtPath.ToU8Span(), OpenMode.Read).IsSuccess()) LibHac.Crypto.Sha256.GenerateSha256Hash(content, hash);
if (LibHac.Common.Utilities.ArraysEqual(hash.ToArray(), meta.ContentEntries[0].Hash))
{ {
var meta = new Cnmt(metaFile.Get.AsStream()); updateNcas.Remove(metaEntry.TitleId);
IStorage contentStorage = contentNcaStream.AsStorage();
if (contentStorage.GetSize(out long size).IsSuccess())
{
byte[] contentData = new byte[size];
Span<byte> content = new Span<byte>(contentData);
contentStorage.Read(0, content);
Span<byte> hash = new Span<byte>(new byte[32]);
LibHac.Crypto.Sha256.GenerateSha256Hash(content, hash);
if (LibHac.Common.Utilities.ArraysEqual(hash.ToArray(), meta.ContentEntries[0].Hash))
{
updateNcas.Remove(metaEntry.TitleId);
}
}
} }
} }
} }
@ -853,9 +821,9 @@ namespace Ryujinx.HLE.FileSystem
foreach (var entry in updateNcas) foreach (var entry in updateNcas)
{ {
foreach (var nca in entry.Value) foreach (var (type, path) in entry.Value)
{ {
extraNcas += nca.path + Environment.NewLine; extraNcas += path + Environment.NewLine;
} }
} }
@ -880,7 +848,7 @@ namespace Ryujinx.HLE.FileSystem
{ {
IStorage ncaStorage = OpenPossibleFragmentedFile(filesystem, entry.FullPath, OpenMode.Read).AsStorage(); IStorage ncaStorage = OpenPossibleFragmentedFile(filesystem, entry.FullPath, OpenMode.Read).AsStorage();
Nca nca = new Nca(_virtualFileSystem.KeySet, ncaStorage); Nca nca = new(_virtualFileSystem.KeySet, ncaStorage);
if (nca.Header.TitleId == SystemUpdateTitleId && nca.Header.ContentType == NcaContentType.Meta) if (nca.Header.TitleId == SystemUpdateTitleId && nca.Header.ContentType == NcaContentType.Meta)
{ {
@ -936,8 +904,8 @@ namespace Ryujinx.HLE.FileSystem
{ {
if (updateNcas.TryGetValue(metaEntry.TitleId, out var ncaEntry)) if (updateNcas.TryGetValue(metaEntry.TitleId, out var ncaEntry))
{ {
var metaNcaEntry = ncaEntry.Find(x => x.type == NcaContentType.Meta); string metaNcaPath = ncaEntry.Find(x => x.type == NcaContentType.Meta).path;
string contentPath = ncaEntry.Find(x => x.type != NcaContentType.Meta).path; string contentPath = ncaEntry.Find(x => x.type != NcaContentType.Meta).path;
// Nintendo in 9.0.0, removed PPC and only kept the meta nca of it. // Nintendo in 9.0.0, removed PPC and only kept the meta nca of it.
// This is a perfect valid case, so we should just ignore the missing content nca and continue. // This is a perfect valid case, so we should just ignore the missing content nca and continue.
@ -948,10 +916,10 @@ namespace Ryujinx.HLE.FileSystem
continue; continue;
} }
IStorage metaStorage = OpenPossibleFragmentedFile(filesystem, metaNcaEntry.path, OpenMode.Read).AsStorage(); IStorage metaStorage = OpenPossibleFragmentedFile(filesystem, metaNcaPath, OpenMode.Read).AsStorage();
IStorage contentStorage = OpenPossibleFragmentedFile(filesystem, contentPath, OpenMode.Read).AsStorage(); IStorage contentStorage = OpenPossibleFragmentedFile(filesystem, contentPath, OpenMode.Read).AsStorage();
Nca metaNca = new Nca(_virtualFileSystem.KeySet, metaStorage); Nca metaNca = new(_virtualFileSystem.KeySet, metaStorage);
IFileSystem fs = metaNca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.ErrorOnInvalid); IFileSystem fs = metaNca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.ErrorOnInvalid);
@ -967,11 +935,11 @@ namespace Ryujinx.HLE.FileSystem
{ {
byte[] contentData = new byte[size]; byte[] contentData = new byte[size];
Span<byte> content = new Span<byte>(contentData); Span<byte> content = new(contentData);
contentStorage.Read(0, content); contentStorage.Read(0, content);
Span<byte> hash = new Span<byte>(new byte[32]); Span<byte> hash = new(new byte[32]);
LibHac.Crypto.Sha256.GenerateSha256Hash(content, hash); LibHac.Crypto.Sha256.GenerateSha256Hash(content, hash);
@ -1017,24 +985,21 @@ namespace Ryujinx.HLE.FileSystem
{ {
if (entry.ContentType == NcaContentType.Data) if (entry.ContentType == NcaContentType.Data)
{ {
var path = _virtualFileSystem.SwitchPathToSystemPath(entry.ContentPath); var path = VirtualFileSystem.SwitchPathToSystemPath(entry.ContentPath);
using (FileStream fileStream = File.OpenRead(path)) using FileStream fileStream = File.OpenRead(path);
Nca nca = new(_virtualFileSystem.KeySet, fileStream.AsStorage());
if (nca.Header.TitleId == SystemVersionTitleId && nca.Header.ContentType == NcaContentType.Data)
{ {
Nca nca = new Nca(_virtualFileSystem.KeySet, fileStream.AsStorage()); var romfs = nca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.ErrorOnInvalid);
if (nca.Header.TitleId == SystemVersionTitleId && nca.Header.ContentType == NcaContentType.Data) using var systemVersionFile = new UniqueRef<IFile>();
if (romfs.OpenFile(ref systemVersionFile.Ref, "/file".ToU8Span(), OpenMode.Read).IsSuccess())
{ {
var romfs = nca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.ErrorOnInvalid); return new SystemVersion(systemVersionFile.Get.AsStream());
using var systemVersionFile = new UniqueRef<IFile>();
if (romfs.OpenFile(ref systemVersionFile.Ref, "/file".ToU8Span(), OpenMode.Read).IsSuccess())
{
return new SystemVersion(systemVersionFile.Get.AsStream());
}
} }
} }
} }
} }

57
src/Ryujinx.HLE/FileSystem/ContentPath.cs
View File

@ -2,7 +2,6 @@
using LibHac.Ncm; using LibHac.Ncm;
using Ryujinx.Common.Configuration; using Ryujinx.Common.Configuration;
using System; using System;
using static Ryujinx.HLE.FileSystem.VirtualFileSystem; using static Ryujinx.HLE.FileSystem.VirtualFileSystem;
using Path = System.IO.Path; using Path = System.IO.Path;
@ -10,33 +9,33 @@ namespace Ryujinx.HLE.FileSystem
{ {
internal static class ContentPath internal static class ContentPath
{ {
public const string SystemContent = "@SystemContent"; public const string SystemContent = "@SystemContent";
public const string UserContent = "@UserContent"; public const string UserContent = "@UserContent";
public const string SdCardContent = "@SdCardContent"; public const string SdCardContent = "@SdCardContent";
public const string SdCard = "@Sdcard"; public const string SdCard = "@Sdcard";
public const string CalibFile = "@CalibFile"; public const string CalibFile = "@CalibFile";
public const string Safe = "@Safe"; public const string Safe = "@Safe";
public const string User = "@User"; public const string User = "@User";
public const string System = "@System"; public const string System = "@System";
public const string Host = "@Host"; public const string Host = "@Host";
public const string GamecardApp = "@GcApp"; public const string GamecardApp = "@GcApp";
public const string GamecardContents = "@GcS00000001"; public const string GamecardContents = "@GcS00000001";
public const string GamecardUpdate = "@upp"; public const string GamecardUpdate = "@upp";
public const string RegisteredUpdate = "@RegUpdate"; public const string RegisteredUpdate = "@RegUpdate";
public const string Nintendo = "Nintendo"; public const string Nintendo = "Nintendo";
public const string Contents = "Contents"; public const string Contents = "Contents";
public static string GetRealPath(VirtualFileSystem fileSystem, string switchContentPath) public static string GetRealPath(string switchContentPath)
{ {
return switchContentPath switch return switchContentPath switch
{ {
SystemContent => Path.Combine(AppDataManager.BaseDirPath, SystemNandPath, Contents), SystemContent => Path.Combine(AppDataManager.BaseDirPath, SystemNandPath, Contents),
UserContent => Path.Combine(AppDataManager.BaseDirPath, UserNandPath, Contents), UserContent => Path.Combine(AppDataManager.BaseDirPath, UserNandPath, Contents),
SdCardContent => Path.Combine(fileSystem.GetSdCardPath(), Nintendo, Contents), SdCardContent => Path.Combine(GetSdCardPath(), Nintendo, Contents),
System => Path.Combine(AppDataManager.BaseDirPath, SystemNandPath), System => Path.Combine(AppDataManager.BaseDirPath, SystemNandPath),
User => Path.Combine(AppDataManager.BaseDirPath, UserNandPath), User => Path.Combine(AppDataManager.BaseDirPath, UserNandPath),
_ => throw new NotSupportedException($"Content Path \"`{switchContentPath}`\" is not supported.") _ => throw new NotSupportedException($"Content Path \"`{switchContentPath}`\" is not supported."),
}; };
} }
@ -45,9 +44,9 @@ namespace Ryujinx.HLE.FileSystem
return contentStorageId switch return contentStorageId switch
{ {
ContentStorageId.System => SystemContent, ContentStorageId.System => SystemContent,
ContentStorageId.User => UserContent, ContentStorageId.User => UserContent,
ContentStorageId.SdCard => SdCardContent, ContentStorageId.SdCard => SdCardContent,
_ => throw new NotSupportedException($"Content Storage Id \"`{contentStorageId}`\" is not supported.") _ => throw new NotSupportedException($"Content Storage Id \"`{contentStorageId}`\" is not supported."),
}; };
} }
@ -56,9 +55,9 @@ namespace Ryujinx.HLE.FileSystem
return storageId switch return storageId switch
{ {
StorageId.BuiltInSystem => SystemContent, StorageId.BuiltInSystem => SystemContent,
StorageId.BuiltInUser => UserContent, StorageId.BuiltInUser => UserContent,
StorageId.SdCard => SdCardContent, StorageId.SdCard => SdCardContent,
_ => throw new NotSupportedException($"Storage Id \"`{storageId}`\" is not supported.") _ => throw new NotSupportedException($"Storage Id \"`{storageId}`\" is not supported."),
}; };
} }
@ -67,16 +66,16 @@ namespace Ryujinx.HLE.FileSystem
return contentPathString.Split(':')[0] switch return contentPathString.Split(':')[0] switch
{ {
SystemContent or SystemContent or
System => StorageId.BuiltInSystem, System => StorageId.BuiltInSystem,
UserContent or UserContent or
User => StorageId.BuiltInUser, User => StorageId.BuiltInUser,
SdCardContent => StorageId.SdCard, SdCardContent => StorageId.SdCard,
Host => StorageId.Host, Host => StorageId.Host,
GamecardApp or GamecardApp or
GamecardContents or GamecardContents or
GamecardUpdate => StorageId.GameCard, GamecardUpdate => StorageId.GameCard,
_ => StorageId.None _ => StorageId.None,
}; };
} }
} }
} }

2
src/Ryujinx.HLE/FileSystem/EncryptedFileSystemCreator.cs
View File

@ -23,4 +23,4 @@ namespace Ryujinx.HLE.FileSystem
return Result.Success; return Result.Success;
} }
} }
} }

10
src/Ryujinx.HLE/FileSystem/LocationEntry.cs
View File

@ -4,16 +4,16 @@ namespace Ryujinx.HLE.FileSystem
{ {
public struct LocationEntry public struct LocationEntry
{ {
public string ContentPath { get; private set; } public string ContentPath { get; private set; }
public int Flag { get; private set; } public int Flag { get; private set; }
public ulong TitleId { get; private set; } public ulong TitleId { get; private set; }
public NcaContentType ContentType { get; private set; } public NcaContentType ContentType { get; private set; }
public LocationEntry(string contentPath, int flag, ulong titleId, NcaContentType contentType) public LocationEntry(string contentPath, int flag, ulong titleId, NcaContentType contentType)
{ {
ContentPath = contentPath; ContentPath = contentPath;
Flag = flag; Flag = flag;
TitleId = titleId; TitleId = titleId;
ContentType = contentType; ContentType = contentType;
} }

44
src/Ryujinx.HLE/FileSystem/SystemVersion.cs
View File

@ -5,36 +5,34 @@ namespace Ryujinx.HLE.FileSystem
{ {
public class SystemVersion public class SystemVersion
{ {
public byte Major { get; } public byte Major { get; }
public byte Minor { get; } public byte Minor { get; }
public byte Micro { get; } public byte Micro { get; }
public byte RevisionMajor { get; } public byte RevisionMajor { get; }
public byte RevisionMinor { get; } public byte RevisionMinor { get; }
public string PlatformString { get; } public string PlatformString { get; }
public string Hex { get; } public string Hex { get; }
public string VersionString { get; } public string VersionString { get; }
public string VersionTitle { get; } public string VersionTitle { get; }
public SystemVersion(Stream systemVersionFile) public SystemVersion(Stream systemVersionFile)
{ {
using (BinaryReader reader = new BinaryReader(systemVersionFile)) using BinaryReader reader = new(systemVersionFile);
{ Major = reader.ReadByte();
Major = reader.ReadByte(); Minor = reader.ReadByte();
Minor = reader.ReadByte(); Micro = reader.ReadByte();
Micro = reader.ReadByte();
reader.ReadByte(); // Padding reader.ReadByte(); // Padding
RevisionMajor = reader.ReadByte(); RevisionMajor = reader.ReadByte();
RevisionMinor = reader.ReadByte(); RevisionMinor = reader.ReadByte();
reader.ReadBytes(2); // Padding reader.ReadBytes(2); // Padding
PlatformString = StringUtils.ReadInlinedAsciiString(reader, 0x20); PlatformString = StringUtils.ReadInlinedAsciiString(reader, 0x20);
Hex = StringUtils.ReadInlinedAsciiString(reader, 0x40); Hex = StringUtils.ReadInlinedAsciiString(reader, 0x40);
VersionString = StringUtils.ReadInlinedAsciiString(reader, 0x18); VersionString = StringUtils.ReadInlinedAsciiString(reader, 0x18);
VersionTitle = StringUtils.ReadInlinedAsciiString(reader, 0x80); VersionTitle = StringUtils.ReadInlinedAsciiString(reader, 0x80);
}
} }
} }
} }

125
src/Ryujinx.HLE/FileSystem/VirtualFileSystem.cs
View File

@ -26,14 +26,14 @@ namespace Ryujinx.HLE.FileSystem
{ {
public class VirtualFileSystem : IDisposable public class VirtualFileSystem : IDisposable
{ {
public static string SafeNandPath = Path.Combine(AppDataManager.DefaultNandDir, "safe"); public static readonly string SafeNandPath = Path.Combine(AppDataManager.DefaultNandDir, "safe");
public static string SystemNandPath = Path.Combine(AppDataManager.DefaultNandDir, "system"); public static readonly string SystemNandPath = Path.Combine(AppDataManager.DefaultNandDir, "system");
public static string UserNandPath = Path.Combine(AppDataManager.DefaultNandDir, "user"); public static readonly string UserNandPath = Path.Combine(AppDataManager.DefaultNandDir, "user");
public KeySet KeySet { get; private set; } public KeySet KeySet { get; private set; }
public EmulatedGameCard GameCard { get; private set; } public EmulatedGameCard GameCard { get; private set; }
public EmulatedSdCard SdCard { get; private set; } public EmulatedSdCard SdCard { get; private set; }
public ModLoader ModLoader { get; private set; } public ModLoader ModLoader { get; private set; }
private readonly ConcurrentDictionary<ulong, Stream> _romFsByPid; private readonly ConcurrentDictionary<ulong, Stream> _romFsByPid;
@ -85,15 +85,15 @@ namespace Ryujinx.HLE.FileSystem
return _romFsByPid[pid]; return _romFsByPid[pid];
} }
public string GetFullPath(string basePath, string fileName) public static string GetFullPath(string basePath, string fileName)
{ {
if (fileName.StartsWith("//")) if (fileName.StartsWith("//"))
{ {
fileName = fileName.Substring(2); fileName = fileName[2..];
} }
else if (fileName.StartsWith('/')) else if (fileName.StartsWith('/'))
{ {
fileName = fileName.Substring(1); fileName = fileName[1..];
} }
else else
{ {
@ -110,10 +110,10 @@ namespace Ryujinx.HLE.FileSystem
return fullPath; return fullPath;
} }
internal string GetSdCardPath() => MakeFullPath(AppDataManager.DefaultSdcardDir); internal static string GetSdCardPath() => MakeFullPath(AppDataManager.DefaultSdcardDir);
public string GetNandPath() => MakeFullPath(AppDataManager.DefaultNandDir); public static string GetNandPath() => MakeFullPath(AppDataManager.DefaultNandDir);
public string SwitchPathToSystemPath(string switchPath) public static string SwitchPathToSystemPath(string switchPath)
{ {
string[] parts = switchPath.Split(":"); string[] parts = switchPath.Split(":");
@ -125,7 +125,7 @@ namespace Ryujinx.HLE.FileSystem
return GetFullPath(MakeFullPath(parts[0]), parts[1]); return GetFullPath(MakeFullPath(parts[0]), parts[1]);
} }
public string SystemPathToSwitchPath(string systemPath) public static string SystemPathToSwitchPath(string systemPath)
{ {
string baseSystemPath = AppDataManager.BaseDirPath + Path.DirectorySeparatorChar; string baseSystemPath = AppDataManager.BaseDirPath + Path.DirectorySeparatorChar;
@ -148,7 +148,7 @@ namespace Ryujinx.HLE.FileSystem
return null; return null;
} }
private string MakeFullPath(string path, bool isDirectory = true) private static string MakeFullPath(string path, bool isDirectory = true)
{ {
// Handles Common Switch Content Paths // Handles Common Switch Content Paths
switch (path) switch (path)
@ -185,7 +185,7 @@ namespace Ryujinx.HLE.FileSystem
public void InitializeFsServer(LibHac.Horizon horizon, out HorizonClient fsServerClient) public void InitializeFsServer(LibHac.Horizon horizon, out HorizonClient fsServerClient)
{ {
LocalFileSystem serverBaseFs = new LocalFileSystem(AppDataManager.BaseDirPath); LocalFileSystem serverBaseFs = new(AppDataManager.BaseDirPath);
fsServerClient = horizon.CreatePrivilegedHorizonClient(); fsServerClient = horizon.CreatePrivilegedHorizonClient();
var fsServer = new FileSystemServer(fsServerClient); var fsServer = new FileSystemServer(fsServerClient);
@ -207,7 +207,7 @@ namespace Ryujinx.HLE.FileSystem
DeviceOperator = fsServerObjects.DeviceOperator, DeviceOperator = fsServerObjects.DeviceOperator,
ExternalKeySet = KeySet.ExternalKeySet, ExternalKeySet = KeySet.ExternalKeySet,
FsCreators = fsServerObjects.FsCreators, FsCreators = fsServerObjects.FsCreators,
RandomGenerator = randomGenerator RandomGenerator = randomGenerator,
}; };
FileSystemServerInitializer.InitializeWithConfig(fsServerClient, fsServer, fsServerConfig); FileSystemServerInitializer.InitializeWithConfig(fsServerClient, fsServer, fsServerConfig);
@ -282,16 +282,28 @@ namespace Ryujinx.HLE.FileSystem
public static Result FixExtraData(HorizonClient hos) public static Result FixExtraData(HorizonClient hos)
{ {
Result rc = GetSystemSaveList(hos, out List<ulong> systemSaveIds); Result rc = GetSystemSaveList(hos, out List<ulong> systemSaveIds);
if (rc.IsFailure()) return rc; if (rc.IsFailure())
{
return rc;
}
rc = FixUnindexedSystemSaves(hos, systemSaveIds); rc = FixUnindexedSystemSaves(hos, systemSaveIds);
if (rc.IsFailure()) return rc; if (rc.IsFailure())
{
return rc;
}
rc = FixExtraDataInSpaceId(hos, SaveDataSpaceId.System); rc = FixExtraDataInSpaceId(hos, SaveDataSpaceId.System);
if (rc.IsFailure()) return rc; if (rc.IsFailure())
{
return rc;
}
rc = FixExtraDataInSpaceId(hos, SaveDataSpaceId.User); rc = FixExtraDataInSpaceId(hos, SaveDataSpaceId.User);
if (rc.IsFailure()) return rc; if (rc.IsFailure())
{
return rc;
}
return Result.Success; return Result.Success;
} }
@ -303,15 +315,23 @@ namespace Ryujinx.HLE.FileSystem
using var iterator = new UniqueRef<SaveDataIterator>(); using var iterator = new UniqueRef<SaveDataIterator>();
Result rc = hos.Fs.OpenSaveDataIterator(ref iterator.Ref, spaceId); Result rc = hos.Fs.OpenSaveDataIterator(ref iterator.Ref, spaceId);
if (rc.IsFailure()) return rc; if (rc.IsFailure())
{
return rc;
}
while (true) while (true)
{ {
rc = iterator.Get.ReadSaveDataInfo(out long count, info); rc = iterator.Get.ReadSaveDataInfo(out long count, info);
if (rc.IsFailure()) return rc; if (rc.IsFailure())
{
return rc;
}
if (count == 0) if (count == 0)
{
return Result.Success; return Result.Success;
}
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
{ {
@ -351,7 +371,9 @@ namespace Ryujinx.HLE.FileSystem
private static Result CreateSaveDataDirectory(HorizonClient hos, in SaveDataInfo info) private static Result CreateSaveDataDirectory(HorizonClient hos, in SaveDataInfo info)
{ {
if (info.SpaceId != SaveDataSpaceId.User && info.SpaceId != SaveDataSpaceId.System) if (info.SpaceId != SaveDataSpaceId.User && info.SpaceId != SaveDataSpaceId.System)
{
return Result.Success; return Result.Success;
}
const string MountName = "SaveDir"; const string MountName = "SaveDir";
var mountNameU8 = MountName.ToU8Span(); var mountNameU8 = MountName.ToU8Span();
@ -360,11 +382,15 @@ namespace Ryujinx.HLE.FileSystem
{ {
SaveDataSpaceId.System => BisPartitionId.System, SaveDataSpaceId.System => BisPartitionId.System,
SaveDataSpaceId.User => BisPartitionId.User, SaveDataSpaceId.User => BisPartitionId.User,
_ => throw new ArgumentOutOfRangeException() _ => throw new ArgumentOutOfRangeException(nameof(info), info.SpaceId, null),
}; };
Result rc = hos.Fs.MountBis(mountNameU8, partitionId); Result rc = hos.Fs.MountBis(mountNameU8, partitionId);
if (rc.IsFailure()) return rc; if (rc.IsFailure())
{
return rc;
}
try try
{ {
var path = $"{MountName}:/save/{info.SaveDataId:x16}".ToU8Span(); var path = $"{MountName}:/save/{info.SaveDataId:x16}".ToU8Span();
@ -391,28 +417,38 @@ namespace Ryujinx.HLE.FileSystem
var mountName = "system".ToU8Span(); var mountName = "system".ToU8Span();
DirectoryHandle handle = default; DirectoryHandle handle = default;
List<ulong> localList = new List<ulong>(); List<ulong> localList = new();
try try
{ {
Result rc = hos.Fs.MountBis(mountName, BisPartitionId.System); Result rc = hos.Fs.MountBis(mountName, BisPartitionId.System);
if (rc.IsFailure()) return rc; if (rc.IsFailure())
{
return rc;
}
rc = hos.Fs.OpenDirectory(out handle, "system:/save".ToU8Span(), OpenDirectoryMode.All); rc = hos.Fs.OpenDirectory(out handle, "system:/save".ToU8Span(), OpenDirectoryMode.All);
if (rc.IsFailure()) return rc; if (rc.IsFailure())
{
return rc;
}
DirectoryEntry entry = new DirectoryEntry(); DirectoryEntry entry = new();
while (true) while (true)
{ {
rc = hos.Fs.ReadDirectory(out long readCount, SpanHelpers.AsSpan(ref entry), handle); rc = hos.Fs.ReadDirectory(out long readCount, SpanHelpers.AsSpan(ref entry), handle);
if (rc.IsFailure()) return rc; if (rc.IsFailure())
{
return rc;
}
if (readCount == 0) if (readCount == 0)
{
break; break;
}
if (Utf8Parser.TryParse(entry.Name, out ulong saveDataId, out int bytesRead, 'x') && if (Utf8Parser.TryParse(entry.Name, out ulong saveDataId, out int bytesRead, 'x') && bytesRead == 16 && (long)saveDataId < 0)
bytesRead == 16 && (long)saveDataId < 0)
{ {
localList.Add(saveDataId); localList.Add(saveDataId);
} }
@ -440,7 +476,7 @@ namespace Ryujinx.HLE.FileSystem
// Only save data IDs added to SystemExtraDataFixInfo will be fixed. // Only save data IDs added to SystemExtraDataFixInfo will be fixed.
private static Result FixUnindexedSystemSaves(HorizonClient hos, List<ulong> existingSaveIds) private static Result FixUnindexedSystemSaves(HorizonClient hos, List<ulong> existingSaveIds)
{ {
foreach (var fixInfo in SystemExtraDataFixInfo) foreach (var fixInfo in _systemExtraDataFixInfo)
{ {
if (!existingSaveIds.Contains(fixInfo.StaticSaveDataId)) if (!existingSaveIds.Contains(fixInfo.StaticSaveDataId))
{ {
@ -472,7 +508,9 @@ namespace Ryujinx.HLE.FileSystem
if (!rc.IsSuccess()) if (!rc.IsSuccess())
{ {
if (!ResultFs.TargetNotFound.Includes(rc)) if (!ResultFs.TargetNotFound.Includes(rc))
{
return rc; return rc;
}
// We'll reach this point only if the save data directory exists but it's not in the save data indexer. // We'll reach this point only if the save data directory exists but it's not in the save data indexer.
// Creating the save will add it to the indexer while leaving its existing contents intact. // Creating the save will add it to the indexer while leaving its existing contents intact.
@ -492,7 +530,7 @@ namespace Ryujinx.HLE.FileSystem
OwnerId = info.OwnerId, OwnerId = info.OwnerId,
Flags = info.Flags, Flags = info.Flags,
DataSize = info.DataSize, DataSize = info.DataSize,
JournalSize = info.JournalSize JournalSize = info.JournalSize,
}; };
// Make a mask for writing the entire extra data // Make a mask for writing the entire extra data
@ -507,9 +545,11 @@ namespace Ryujinx.HLE.FileSystem
{ {
wasFixNeeded = true; wasFixNeeded = true;
Result rc = hos.Fs.Impl.ReadSaveDataFileSystemExtraData(out SaveDataExtraData extraData, info.SpaceId, Result rc = hos.Fs.Impl.ReadSaveDataFileSystemExtraData(out SaveDataExtraData extraData, info.SpaceId, info.SaveDataId);
info.SaveDataId); if (rc.IsFailure())
if (rc.IsFailure()) return rc; {
return rc;
}
// The extra data should have program ID or static save data ID set if it's valid. // The extra data should have program ID or static save data ID set if it's valid.
// We only try to fix the extra data if the info from the save data indexer has a program ID or static save data ID. // We only try to fix the extra data if the info from the save data indexer has a program ID or static save data ID.
@ -543,7 +583,7 @@ namespace Ryujinx.HLE.FileSystem
else else
{ {
// Try to match the system save with one of the known saves // Try to match the system save with one of the known saves
foreach (ExtraDataFixInfo fixInfo in SystemExtraDataFixInfo) foreach (ExtraDataFixInfo fixInfo in _systemExtraDataFixInfo)
{ {
if (extraData.Attribute.StaticSaveDataId == fixInfo.StaticSaveDataId) if (extraData.Attribute.StaticSaveDataId == fixInfo.StaticSaveDataId)
{ {
@ -573,7 +613,7 @@ namespace Ryujinx.HLE.FileSystem
public long JournalSize; public long JournalSize;
} }
private static readonly ExtraDataFixInfo[] SystemExtraDataFixInfo = private static readonly ExtraDataFixInfo[] _systemExtraDataFixInfo =
{ {
new ExtraDataFixInfo() new ExtraDataFixInfo()
{ {
@ -581,7 +621,7 @@ namespace Ryujinx.HLE.FileSystem
OwnerId = 0x010000000000001F, OwnerId = 0x010000000000001F,
Flags = SaveDataFlags.KeepAfterResettingSystemSaveDataWithoutUserSaveData, Flags = SaveDataFlags.KeepAfterResettingSystemSaveDataWithoutUserSaveData,
DataSize = 0x10000, DataSize = 0x10000,
JournalSize = 0x10000 JournalSize = 0x10000,
}, },
new ExtraDataFixInfo() new ExtraDataFixInfo()
{ {
@ -589,12 +629,13 @@ namespace Ryujinx.HLE.FileSystem
OwnerId = 0x0100000000001009, OwnerId = 0x0100000000001009,
Flags = SaveDataFlags.None, Flags = SaveDataFlags.None,
DataSize = 0xC000, DataSize = 0xC000,
JournalSize = 0xC000 JournalSize = 0xC000,
} },
}; };
public void Dispose() public void Dispose()
{ {
GC.SuppressFinalize(this);
Dispose(true); Dispose(true);
} }

98
src/Ryujinx.HLE/HLEConfiguration.cs
View File

@ -163,57 +163,57 @@ namespace Ryujinx.HLE
/// </summary> /// </summary>
public Action RefreshInputConfig { internal get; set; } public Action RefreshInputConfig { internal get; set; }
public HLEConfiguration(VirtualFileSystem virtualFileSystem, public HLEConfiguration(VirtualFileSystem virtualFileSystem,
LibHacHorizonManager libHacHorizonManager, LibHacHorizonManager libHacHorizonManager,
ContentManager contentManager, ContentManager contentManager,
AccountManager accountManager, AccountManager accountManager,
UserChannelPersistence userChannelPersistence, UserChannelPersistence userChannelPersistence,
IRenderer gpuRenderer, IRenderer gpuRenderer,
IHardwareDeviceDriver audioDeviceDriver, IHardwareDeviceDriver audioDeviceDriver,
MemoryConfiguration memoryConfiguration, MemoryConfiguration memoryConfiguration,
IHostUiHandler hostUiHandler, IHostUiHandler hostUiHandler,
SystemLanguage systemLanguage, SystemLanguage systemLanguage,
RegionCode region, RegionCode region,
bool enableVsync, bool enableVsync,
bool enableDockedMode, bool enableDockedMode,
bool enablePtc, bool enablePtc,
bool enableInternetAccess, bool enableInternetAccess,
IntegrityCheckLevel fsIntegrityCheckLevel, IntegrityCheckLevel fsIntegrityCheckLevel,
int fsGlobalAccessLogMode, int fsGlobalAccessLogMode,
long systemTimeOffset, long systemTimeOffset,
string timeZone, string timeZone,
MemoryManagerMode memoryManagerMode, MemoryManagerMode memoryManagerMode,
bool ignoreMissingServices, bool ignoreMissingServices,
AspectRatio aspectRatio, AspectRatio aspectRatio,
float audioVolume, float audioVolume,
bool useHypervisor, bool useHypervisor,
string multiplayerLanInterfaceId) string multiplayerLanInterfaceId)
{ {
VirtualFileSystem = virtualFileSystem; VirtualFileSystem = virtualFileSystem;
LibHacHorizonManager = libHacHorizonManager; LibHacHorizonManager = libHacHorizonManager;
AccountManager = accountManager; AccountManager = accountManager;
ContentManager = contentManager; ContentManager = contentManager;
UserChannelPersistence = userChannelPersistence; UserChannelPersistence = userChannelPersistence;
GpuRenderer = gpuRenderer; GpuRenderer = gpuRenderer;
AudioDeviceDriver = audioDeviceDriver; AudioDeviceDriver = audioDeviceDriver;
MemoryConfiguration = memoryConfiguration; MemoryConfiguration = memoryConfiguration;
HostUiHandler = hostUiHandler; HostUiHandler = hostUiHandler;
SystemLanguage = systemLanguage; SystemLanguage = systemLanguage;
Region = region; Region = region;
EnableVsync = enableVsync; EnableVsync = enableVsync;
EnableDockedMode = enableDockedMode; EnableDockedMode = enableDockedMode;
EnablePtc = enablePtc; EnablePtc = enablePtc;
EnableInternetAccess = enableInternetAccess; EnableInternetAccess = enableInternetAccess;
FsIntegrityCheckLevel = fsIntegrityCheckLevel; FsIntegrityCheckLevel = fsIntegrityCheckLevel;
FsGlobalAccessLogMode = fsGlobalAccessLogMode; FsGlobalAccessLogMode = fsGlobalAccessLogMode;
SystemTimeOffset = systemTimeOffset; SystemTimeOffset = systemTimeOffset;
TimeZone = timeZone; TimeZone = timeZone;
MemoryManagerMode = memoryManagerMode; MemoryManagerMode = memoryManagerMode;
IgnoreMissingServices = ignoreMissingServices; IgnoreMissingServices = ignoreMissingServices;
AspectRatio = aspectRatio; AspectRatio = aspectRatio;
AudioVolume = audioVolume; AudioVolume = audioVolume;
UseHypervisor = useHypervisor; UseHypervisor = useHypervisor;
MultiplayerLanInterfaceId = multiplayerLanInterfaceId; MultiplayerLanInterfaceId = multiplayerLanInterfaceId;
} }
} }
} }

4
src/Ryujinx.HLE/HOS/Applets/AppletManager.cs
View File

@ -8,7 +8,7 @@ namespace Ryujinx.HLE.HOS.Applets
{ {
static class AppletManager static class AppletManager
{ {
private static Dictionary<AppletId, Type> _appletMapping; private static readonly Dictionary<AppletId, Type> _appletMapping;
static AppletManager() static AppletManager()
{ {
@ -20,7 +20,7 @@ namespace Ryujinx.HLE.HOS.Applets
{ AppletId.SoftwareKeyboard, typeof(SoftwareKeyboardApplet) }, { AppletId.SoftwareKeyboard, typeof(SoftwareKeyboardApplet) },
{ AppletId.LibAppletWeb, typeof(BrowserApplet) }, { AppletId.LibAppletWeb, typeof(BrowserApplet) },
{ AppletId.LibAppletShop, typeof(BrowserApplet) }, { AppletId.LibAppletShop, typeof(BrowserApplet) },
{ AppletId.LibAppletOff, typeof(BrowserApplet) } { AppletId.LibAppletOff, typeof(BrowserApplet) },
}; };
} }

2
src/Ryujinx.HLE/HOS/Applets/Browser/BootDisplayKind.cs
View File

@ -6,6 +6,6 @@
Offline, Offline,
Black, Black,
Share, Share,
Lobby Lobby,
} }
} }

55
src/Ryujinx.HLE/HOS/Applets/Browser/BrowserApplet.cs
View File

@ -13,13 +13,12 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
public event EventHandler AppletStateChanged; public event EventHandler AppletStateChanged;
private AppletSession _normalSession; private AppletSession _normalSession;
private AppletSession _interactiveSession;
private CommonArguments _commonArguments; private CommonArguments _commonArguments;
private List<BrowserArgument> _arguments; private List<BrowserArgument> _arguments;
private ShimKind _shimKind; private ShimKind _shimKind;
public BrowserApplet(Horizon system) {} public BrowserApplet(Horizon system) { }
public ResultCode GetResult() public ResultCode GetResult()
{ {
@ -29,7 +28,6 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession) public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession)
{ {
_normalSession = normalSession; _normalSession = normalSession;
_interactiveSession = interactiveSession;
_commonArguments = IApplet.ReadStruct<CommonArguments>(_normalSession.Pop()); _commonArguments = IApplet.ReadStruct<CommonArguments>(_normalSession.Pop());
@ -48,17 +46,18 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
if ((_commonArguments.AppletVersion >= 0x80000 && _shimKind == ShimKind.Web) || (_commonArguments.AppletVersion >= 0x30000 && _shimKind == ShimKind.Share)) if ((_commonArguments.AppletVersion >= 0x80000 && _shimKind == ShimKind.Web) || (_commonArguments.AppletVersion >= 0x30000 && _shimKind == ShimKind.Share))
{ {
List<BrowserOutput> result = new List<BrowserOutput>(); List<BrowserOutput> result = new()
{
result.Add(new BrowserOutput(BrowserOutputType.ExitReason, (uint)WebExitReason.ExitButton)); new BrowserOutput(BrowserOutputType.ExitReason, (uint)WebExitReason.ExitButton),
};
_normalSession.Push(BuildResponseNew(result)); _normalSession.Push(BuildResponseNew(result));
} }
else else
{ {
WebCommonReturnValue result = new WebCommonReturnValue() WebCommonReturnValue result = new()
{ {
ExitReason = WebExitReason.ExitButton, ExitReason = WebExitReason.ExitButton,
}; };
_normalSession.Push(BuildResponseOld(result)); _normalSession.Push(BuildResponseOld(result));
@ -69,36 +68,32 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
return ResultCode.Success; return ResultCode.Success;
} }
private byte[] BuildResponseOld(WebCommonReturnValue result) private static byte[] BuildResponseOld(WebCommonReturnValue result)
{ {
using (MemoryStream stream = MemoryStreamManager.Shared.GetStream()) using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{ writer.WriteStruct(result);
writer.WriteStruct(result);
return stream.ToArray(); return stream.ToArray();
}
} }
private byte[] BuildResponseNew(List<BrowserOutput> outputArguments) private byte[] BuildResponseNew(List<BrowserOutput> outputArguments)
{ {
using (MemoryStream stream = MemoryStreamManager.Shared.GetStream()) using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
writer.WriteStruct(new WebArgHeader
{ {
writer.WriteStruct(new WebArgHeader Count = (ushort)outputArguments.Count,
{ ShimKind = _shimKind,
Count = (ushort)outputArguments.Count, });
ShimKind = _shimKind
});
foreach (BrowserOutput output in outputArguments) foreach (BrowserOutput output in outputArguments)
{ {
output.Write(writer); output.Write(writer);
}
writer.Write(new byte[0x2000 - writer.BaseStream.Position]);
return stream.ToArray();
} }
writer.Write(new byte[0x2000 - writer.BaseStream.Position]);
return stream.ToArray();
} }
} }
} }

16
src/Ryujinx.HLE/HOS/Applets/Browser/BrowserArgument.cs
View File

@ -8,16 +8,16 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
{ {
class BrowserArgument class BrowserArgument
{ {
public WebArgTLVType Type { get; } public WebArgTLVType Type { get; }
public byte[] Value { get; } public byte[] Value { get; }
public BrowserArgument(WebArgTLVType type, byte[] value) public BrowserArgument(WebArgTLVType type, byte[] value)
{ {
Type = type; Type = type;
Value = value; Value = value;
} }
private static readonly Dictionary<WebArgTLVType, Type> _typeRegistry = new Dictionary<WebArgTLVType, Type> private static readonly Dictionary<WebArgTLVType, Type> _typeRegistry = new()
{ {
{ WebArgTLVType.InitialURL, typeof(string) }, { WebArgTLVType.InitialURL, typeof(string) },
{ WebArgTLVType.CallbackUrl, typeof(string) }, { WebArgTLVType.CallbackUrl, typeof(string) },
@ -64,11 +64,11 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
public static (ShimKind, List<BrowserArgument>) ParseArguments(ReadOnlySpan<byte> data) public static (ShimKind, List<BrowserArgument>) ParseArguments(ReadOnlySpan<byte> data)
{ {
List<BrowserArgument> browserArguments = new List<BrowserArgument>(); List<BrowserArgument> browserArguments = new();
WebArgHeader header = IApplet.ReadStruct<WebArgHeader>(data.Slice(0, 8)); WebArgHeader header = IApplet.ReadStruct<WebArgHeader>(data[..8]);
ReadOnlySpan<byte> rawTLVs = data.Slice(8); ReadOnlySpan<byte> rawTLVs = data[8..];
for (int i = 0; i < header.Count; i++) for (int i = 0; i < header.Count; i++)
{ {
@ -77,7 +77,7 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
browserArguments.Add(new BrowserArgument((WebArgTLVType)tlv.Type, tlvData.ToArray())); browserArguments.Add(new BrowserArgument((WebArgTLVType)tlv.Type, tlvData.ToArray()));
rawTLVs = rawTLVs.Slice(Unsafe.SizeOf<WebArgTLV>() + tlv.Size); rawTLVs = rawTLVs[(Unsafe.SizeOf<WebArgTLV>() + tlv.Size)..];
} }
return (header.ShimKind, browserArguments); return (header.ShimKind, browserArguments);

12
src/Ryujinx.HLE/HOS/Applets/Browser/BrowserOutput.cs
View File

@ -11,25 +11,25 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
public BrowserOutput(BrowserOutputType type, byte[] value) public BrowserOutput(BrowserOutputType type, byte[] value)
{ {
Type = type; Type = type;
Value = value; Value = value;
} }
public BrowserOutput(BrowserOutputType type, uint value) public BrowserOutput(BrowserOutputType type, uint value)
{ {
Type = type; Type = type;
Value = BitConverter.GetBytes(value); Value = BitConverter.GetBytes(value);
} }
public BrowserOutput(BrowserOutputType type, ulong value) public BrowserOutput(BrowserOutputType type, ulong value)
{ {
Type = type; Type = type;
Value = BitConverter.GetBytes(value); Value = BitConverter.GetBytes(value);
} }
public BrowserOutput(BrowserOutputType type, bool value) public BrowserOutput(BrowserOutputType type, bool value)
{ {
Type = type; Type = type;
Value = BitConverter.GetBytes(value); Value = BitConverter.GetBytes(value);
} }
@ -38,7 +38,7 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
writer.WriteStruct(new WebArgTLV writer.WriteStruct(new WebArgTLV
{ {
Type = (ushort)Type, Type = (ushort)Type,
Size = (ushort)Value.Length Size = (ushort)Value.Length,
}); });
writer.Write(Value); writer.Write(Value);

16
src/Ryujinx.HLE/HOS/Applets/Browser/BrowserOutputType.cs
View File

@ -2,13 +2,13 @@
{ {
enum BrowserOutputType : ushort enum BrowserOutputType : ushort
{ {
ExitReason = 0x1, ExitReason = 0x1,
LastUrl = 0x2, LastUrl = 0x2,
LastUrlSize = 0x3, LastUrlSize = 0x3,
SharePostResult = 0x4, SharePostResult = 0x4,
PostServiceName = 0x5, PostServiceName = 0x5,
PostServiceNameSize = 0x6, PostServiceNameSize = 0x6,
PostId = 0x7, PostId = 0x7,
MediaPlayerAutoClosedByCompletion = 0x8 MediaPlayerAutoClosedByCompletion = 0x8,
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/Browser/DocumentKind.cs
View File

@ -4,6 +4,6 @@
{ {
OfflineHtmlPage = 1, OfflineHtmlPage = 1,
ApplicationLegalInformation, ApplicationLegalInformation,
SystemDataPage SystemDataPage,
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/Browser/LeftStickMode.cs
View File

@ -3,6 +3,6 @@
enum LeftStickMode enum LeftStickMode
{ {
Pointer = 0, Pointer = 0,
Cursor Cursor,
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/Browser/ShimKind.cs
View File

@ -8,6 +8,6 @@
Share, Share,
Web, Web,
Wifi, Wifi,
Lobby Lobby,
} }
} }

4
src/Ryujinx.HLE/HOS/Applets/Browser/WebArgHeader.cs
View File

@ -2,8 +2,8 @@
{ {
public struct WebArgHeader public struct WebArgHeader
{ {
public ushort Count; public ushort Count;
public ushort Padding; public ushort Padding;
public ShimKind ShimKind; public ShimKind ShimKind;
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/Browser/WebArgTLV.cs
View File

@ -4,6 +4,6 @@
{ {
public ushort Type; public ushort Type;
public ushort Size; public ushort Size;
public uint Padding; public uint Padding;
} }
} }

110
src/Ryujinx.HLE/HOS/Applets/Browser/WebArgTLVType.cs
View File

@ -2,61 +2,61 @@
{ {
enum WebArgTLVType : ushort enum WebArgTLVType : ushort
{ {
InitialURL = 0x1, InitialURL = 0x1,
CallbackUrl = 0x3, CallbackUrl = 0x3,
CallbackableUrl = 0x4, CallbackableUrl = 0x4,
ApplicationId = 0x5, ApplicationId = 0x5,
DocumentPath = 0x6, DocumentPath = 0x6,
DocumentKind = 0x7, DocumentKind = 0x7,
SystemDataId = 0x8, SystemDataId = 0x8,
ShareStartPage = 0x9, ShareStartPage = 0x9,
Whitelist = 0xA, Whitelist = 0xA,
NewsFlag = 0xB, NewsFlag = 0xB,
UserID = 0xE, UserID = 0xE,
AlbumEntry0 = 0xF, AlbumEntry0 = 0xF,
ScreenShotEnabled = 0x10, ScreenShotEnabled = 0x10,
EcClientCertEnabled = 0x11, EcClientCertEnabled = 0x11,
PlayReportEnabled = 0x13, PlayReportEnabled = 0x13,
UnknownFlag0x14 = 0x14, UnknownFlag0x14 = 0x14,
UnknownFlag0x15 = 0x15, UnknownFlag0x15 = 0x15,
BootDisplayKind = 0x17, BootDisplayKind = 0x17,
BackgroundKind = 0x18, BackgroundKind = 0x18,
FooterEnabled = 0x19, FooterEnabled = 0x19,
PointerEnabled = 0x1A, PointerEnabled = 0x1A,
LeftStickMode = 0x1B, LeftStickMode = 0x1B,
KeyRepeatFrame1 = 0x1C, KeyRepeatFrame1 = 0x1C,
KeyRepeatFrame2 = 0x1D, KeyRepeatFrame2 = 0x1D,
BootAsMediaPlayerInverted = 0x1E, BootAsMediaPlayerInverted = 0x1E,
DisplayUrlKind = 0x1F, DisplayUrlKind = 0x1F,
BootAsMediaPlayer = 0x21, BootAsMediaPlayer = 0x21,
ShopJumpEnabled = 0x22, ShopJumpEnabled = 0x22,
MediaAutoPlayEnabled = 0x23, MediaAutoPlayEnabled = 0x23,
LobbyParameter = 0x24, LobbyParameter = 0x24,
ApplicationAlbumEntry = 0x26, ApplicationAlbumEntry = 0x26,
JsExtensionEnabled = 0x27, JsExtensionEnabled = 0x27,
AdditionalCommentText = 0x28, AdditionalCommentText = 0x28,
TouchEnabledOnContents = 0x29, TouchEnabledOnContents = 0x29,
UserAgentAdditionalString = 0x2A, UserAgentAdditionalString = 0x2A,
AdditionalMediaData0 = 0x2B, AdditionalMediaData0 = 0x2B,
MediaPlayerAutoCloseEnabled = 0x2C, MediaPlayerAutoCloseEnabled = 0x2C,
PageCacheEnabled = 0x2D, PageCacheEnabled = 0x2D,
WebAudioEnabled = 0x2E, WebAudioEnabled = 0x2E,
FooterFixedKind = 0x32, FooterFixedKind = 0x32,
PageFadeEnabled = 0x33, PageFadeEnabled = 0x33,
MediaCreatorApplicationRatingAge = 0x34, MediaCreatorApplicationRatingAge = 0x34,
BootLoadingIconEnabled = 0x35, BootLoadingIconEnabled = 0x35,
PageScrollIndicatorEnabled = 0x36, PageScrollIndicatorEnabled = 0x36,
MediaPlayerSpeedControlEnabled = 0x37, MediaPlayerSpeedControlEnabled = 0x37,
AlbumEntry1 = 0x38, AlbumEntry1 = 0x38,
AlbumEntry2 = 0x39, AlbumEntry2 = 0x39,
AlbumEntry3 = 0x3A, AlbumEntry3 = 0x3A,
AdditionalMediaData1 = 0x3B, AdditionalMediaData1 = 0x3B,
AdditionalMediaData2 = 0x3C, AdditionalMediaData2 = 0x3C,
AdditionalMediaData3 = 0x3D, AdditionalMediaData3 = 0x3D,
BootFooterButton = 0x3E, BootFooterButton = 0x3E,
OverrideWebAudioVolume = 0x3F, OverrideWebAudioVolume = 0x3F,
OverrideMediaAudioVolume = 0x40, OverrideMediaAudioVolume = 0x40,
BootMode = 0x41, BootMode = 0x41,
MediaPlayerUiEnabled = 0x43 MediaPlayerUiEnabled = 0x43,
} }
} }

4
src/Ryujinx.HLE/HOS/Applets/Browser/WebCommonReturnValue.cs
View File

@ -5,8 +5,8 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
public struct WebCommonReturnValue public struct WebCommonReturnValue
{ {
public WebExitReason ExitReason; public WebExitReason ExitReason;
public uint Padding; public uint Padding;
public ByteArray4096 LastUrl; public ByteArray4096 LastUrl;
public ulong LastUrlSize; public ulong LastUrlSize;
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/Browser/WebExitReason.cs
View File

@ -6,6 +6,6 @@
BackButton, BackButton,
Requested, Requested,
LastUrl, LastUrl,
ErrorDialog = 7 ErrorDialog = 7,
} }
} }

10
src/Ryujinx.HLE/HOS/Applets/CommonArguments.cs
View File

@ -5,12 +5,12 @@ namespace Ryujinx.HLE.HOS.Applets
[StructLayout(LayoutKind.Sequential, Pack = 8)] [StructLayout(LayoutKind.Sequential, Pack = 8)]
struct CommonArguments struct CommonArguments
{ {
public uint Version; public uint Version;
public uint StructureSize; public uint StructureSize;
public uint AppletVersion; public uint AppletVersion;
public uint ThemeColor; public uint ThemeColor;
[MarshalAs(UnmanagedType.I1)] [MarshalAs(UnmanagedType.I1)]
public bool PlayStartupSound; public bool PlayStartupSound;
public ulong SystemTicks; public ulong SystemTicks;
} }
} }

42
src/Ryujinx.HLE/HOS/Applets/Controller/ControllerApplet.cs
View File

@ -13,7 +13,7 @@ namespace Ryujinx.HLE.HOS.Applets
{ {
internal class ControllerApplet : IApplet internal class ControllerApplet : IApplet
{ {
private Horizon _system; private readonly Horizon _system;
private AppletSession _normalSession; private AppletSession _normalSession;
@ -65,7 +65,7 @@ namespace Ryujinx.HLE.HOS.Applets
} }
else else
{ {
Logger.Stub?.PrintStub(LogClass.ServiceHid, $"ControllerSupportArg Version Unknown"); Logger.Stub?.PrintStub(LogClass.ServiceHid, "ControllerSupportArg Version Unknown");
argHeader = IApplet.ReadStruct<ControllerSupportArgHeader>(controllerSupportArg); // Read just the header argHeader = IApplet.ReadStruct<ControllerSupportArgHeader>(controllerSupportArg); // Read just the header
} }
@ -82,17 +82,17 @@ namespace Ryujinx.HLE.HOS.Applets
playerMin = playerMax = 1; playerMin = playerMax = 1;
} }
int configuredCount = 0; int configuredCount;
PlayerIndex primaryIndex = PlayerIndex.Unknown; PlayerIndex primaryIndex;
while (!_system.Device.Hid.Npads.Validate(playerMin, playerMax, (ControllerType)privateArg.NpadStyleSet, out configuredCount, out primaryIndex)) while (!_system.Device.Hid.Npads.Validate(playerMin, playerMax, (ControllerType)privateArg.NpadStyleSet, out configuredCount, out primaryIndex))
{ {
ControllerAppletUiArgs uiArgs = new ControllerAppletUiArgs ControllerAppletUiArgs uiArgs = new()
{ {
PlayerCountMin = playerMin, PlayerCountMin = playerMin,
PlayerCountMax = playerMax, PlayerCountMax = playerMax,
SupportedStyles = (ControllerType)privateArg.NpadStyleSet, SupportedStyles = (ControllerType)privateArg.NpadStyleSet,
SupportedPlayers = _system.Device.Hid.Npads.GetSupportedPlayers(), SupportedPlayers = _system.Device.Hid.Npads.GetSupportedPlayers(),
IsDocked = _system.State.DockedMode IsDocked = _system.State.DockedMode,
}; };
if (!_system.Device.UiHandler.DisplayMessageDialog(uiArgs)) if (!_system.Device.UiHandler.DisplayMessageDialog(uiArgs))
@ -101,10 +101,10 @@ namespace Ryujinx.HLE.HOS.Applets
} }
} }
ControllerSupportResultInfo result = new ControllerSupportResultInfo ControllerSupportResultInfo result = new()
{ {
PlayerCount = (sbyte)configuredCount, PlayerCount = (sbyte)configuredCount,
SelectedId = (uint)GetNpadIdTypeFromIndex(primaryIndex) SelectedId = (uint)GetNpadIdTypeFromIndex(primaryIndex),
}; };
Logger.Stub?.PrintStub(LogClass.ServiceHid, $"ControllerApplet ReturnResult {result.PlayerCount} {result.SelectedId}"); Logger.Stub?.PrintStub(LogClass.ServiceHid, $"ControllerApplet ReturnResult {result.PlayerCount} {result.SelectedId}");
@ -122,26 +122,24 @@ namespace Ryujinx.HLE.HOS.Applets
return ResultCode.Success; return ResultCode.Success;
} }
private byte[] BuildResponse(ControllerSupportResultInfo result) private static byte[] BuildResponse(ControllerSupportResultInfo result)
{ {
using (MemoryStream stream = MemoryStreamManager.Shared.GetStream()) using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
writer.Write(MemoryMarshal.AsBytes(MemoryMarshal.CreateReadOnlySpan(ref result, Unsafe.SizeOf<ControllerSupportResultInfo>())));
return stream.ToArray(); writer.Write(MemoryMarshal.AsBytes(MemoryMarshal.CreateReadOnlySpan(ref result, Unsafe.SizeOf<ControllerSupportResultInfo>())));
}
return stream.ToArray();
} }
private byte[] BuildResponse() private static byte[] BuildResponse()
{ {
using (MemoryStream stream = MemoryStreamManager.Shared.GetStream()) using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
writer.Write((ulong)ResultCode.Success);
return stream.ToArray(); writer.Write((ulong)ResultCode.Success);
}
return stream.ToArray();
} }
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/Controller/ControllerAppletUiArgs.cs
View File

@ -11,4 +11,4 @@ namespace Ryujinx.HLE.HOS.Applets
public IEnumerable<PlayerIndex> SupportedPlayers; public IEnumerable<PlayerIndex> SupportedPlayers;
public bool IsDocked; public bool IsDocked;
} }
} }

4
src/Ryujinx.HLE/HOS/Applets/Controller/ControllerSupportArgHeader.cs
View File

@ -2,7 +2,7 @@ using System.Runtime.InteropServices;
namespace Ryujinx.HLE.HOS.Applets namespace Ryujinx.HLE.HOS.Applets
{ {
#pragma warning disable CS0649 #pragma warning disable CS0649 // Field is never assigned to
[StructLayout(LayoutKind.Sequential, Pack = 1)] [StructLayout(LayoutKind.Sequential, Pack = 1)]
struct ControllerSupportArgHeader struct ControllerSupportArgHeader
{ {
@ -15,4 +15,4 @@ namespace Ryujinx.HLE.HOS.Applets
public byte EnableIdentificationColor; public byte EnableIdentificationColor;
} }
#pragma warning restore CS0649 #pragma warning restore CS0649
} }

4
src/Ryujinx.HLE/HOS/Applets/Controller/ControllerSupportArgPrivate.cs
View File

@ -1,6 +1,6 @@
namespace Ryujinx.HLE.HOS.Applets namespace Ryujinx.HLE.HOS.Applets
{ {
#pragma warning disable CS0649 #pragma warning disable CS0649 // Field is never assigned to
struct ControllerSupportArgPrivate struct ControllerSupportArgPrivate
{ {
public uint PrivateSize; public uint PrivateSize;
@ -13,4 +13,4 @@ namespace Ryujinx.HLE.HOS.Applets
public uint NpadJoyHoldType; public uint NpadJoyHoldType;
} }
#pragma warning restore CS0649 #pragma warning restore CS0649
} }

4
src/Ryujinx.HLE/HOS/Applets/Controller/ControllerSupportArgV7.cs
View File

@ -4,7 +4,7 @@ using System.Runtime.InteropServices;
namespace Ryujinx.HLE.HOS.Applets namespace Ryujinx.HLE.HOS.Applets
{ {
#pragma warning disable CS0649 #pragma warning disable CS0649 // Field is never assigned to
// (8.0.0+ version) // (8.0.0+ version)
[StructLayout(LayoutKind.Sequential, Pack = 1)] [StructLayout(LayoutKind.Sequential, Pack = 1)]
struct ControllerSupportArgV7 struct ControllerSupportArgV7
@ -23,4 +23,4 @@ namespace Ryujinx.HLE.HOS.Applets
} }
} }
#pragma warning restore CS0649 #pragma warning restore CS0649
} }

4
src/Ryujinx.HLE/HOS/Applets/Controller/ControllerSupportArgVPre7.cs
View File

@ -4,7 +4,7 @@ using System.Runtime.InteropServices;
namespace Ryujinx.HLE.HOS.Applets namespace Ryujinx.HLE.HOS.Applets
{ {
#pragma warning disable CS0649 #pragma warning disable CS0649 // Field is never assigned to
// (1.0.0+ version) // (1.0.0+ version)
[StructLayout(LayoutKind.Sequential, Pack = 1)] [StructLayout(LayoutKind.Sequential, Pack = 1)]
struct ControllerSupportArgVPre7 struct ControllerSupportArgVPre7
@ -23,4 +23,4 @@ namespace Ryujinx.HLE.HOS.Applets
} }
} }
#pragma warning restore CS0649 #pragma warning restore CS0649
} }

4
src/Ryujinx.HLE/HOS/Applets/Controller/ControllerSupportMode.cs
View File

@ -4,6 +4,6 @@ namespace Ryujinx.HLE.HOS.Applets
{ {
ShowControllerSupport = 0, ShowControllerSupport = 0,
ShowControllerStrapGuide = 1, ShowControllerStrapGuide = 1,
ShowControllerFirmwareUpdate = 2 ShowControllerFirmwareUpdate = 2,
} }
} }

4
src/Ryujinx.HLE/HOS/Applets/Controller/ControllerSupportResultInfo.cs
View File

@ -3,7 +3,7 @@ using System.Runtime.InteropServices;
namespace Ryujinx.HLE.HOS.Applets namespace Ryujinx.HLE.HOS.Applets
{ {
#pragma warning disable CS0649 #pragma warning disable CS0649 // Field is never assigned to
[StructLayout(LayoutKind.Sequential, Pack = 1)] [StructLayout(LayoutKind.Sequential, Pack = 1)]
struct ControllerSupportResultInfo struct ControllerSupportResultInfo
{ {
@ -13,4 +13,4 @@ namespace Ryujinx.HLE.HOS.Applets
public uint Result; public uint Result;
} }
#pragma warning restore CS0649 #pragma warning restore CS0649
} }

6
src/Ryujinx.HLE/HOS/Applets/Error/ApplicationErrorArg.cs
View File

@ -6,9 +6,9 @@ namespace Ryujinx.HLE.HOS.Applets.Error
[StructLayout(LayoutKind.Sequential, Pack = 1)] [StructLayout(LayoutKind.Sequential, Pack = 1)]
struct ApplicationErrorArg struct ApplicationErrorArg
{ {
public uint ErrorNumber; public uint ErrorNumber;
public ulong LanguageCode; public ulong LanguageCode;
public ByteArray2048 MessageText; public ByteArray2048 MessageText;
public ByteArray2048 DetailsText; public ByteArray2048 DetailsText;
} }
} }

63
src/Ryujinx.HLE/HOS/Applets/Error/ErrorApplet.cs
View File

@ -22,11 +22,11 @@ namespace Ryujinx.HLE.HOS.Applets.Error
{ {
private const long ErrorMessageBinaryTitleId = 0x0100000000000801; private const long ErrorMessageBinaryTitleId = 0x0100000000000801;
private Horizon _horizon; private readonly Horizon _horizon;
private AppletSession _normalSession; private AppletSession _normalSession;
private CommonArguments _commonArguments; private CommonArguments _commonArguments;
private ErrorCommonHeader _errorCommonHeader; private ErrorCommonHeader _errorCommonHeader;
private byte[] _errorStorage; private byte[] _errorStorage;
public event EventHandler AppletStateChanged; public event EventHandler AppletStateChanged;
@ -40,14 +40,14 @@ namespace Ryujinx.HLE.HOS.Applets.Error
public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession) public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession)
{ {
_normalSession = normalSession; _normalSession = normalSession;
_commonArguments = IApplet.ReadStruct<CommonArguments>(_normalSession.Pop()); _commonArguments = IApplet.ReadStruct<CommonArguments>(_normalSession.Pop());
Logger.Info?.PrintMsg(LogClass.ServiceAm, $"ErrorApplet version: 0x{_commonArguments.AppletVersion:x8}"); Logger.Info?.PrintMsg(LogClass.ServiceAm, $"ErrorApplet version: 0x{_commonArguments.AppletVersion:x8}");
_errorStorage = _normalSession.Pop(); _errorStorage = _normalSession.Pop();
_errorCommonHeader = IApplet.ReadStruct<ErrorCommonHeader>(_errorStorage); _errorCommonHeader = IApplet.ReadStruct<ErrorCommonHeader>(_errorStorage);
_errorStorage = _errorStorage.Skip(Marshal.SizeOf<ErrorCommonHeader>()).ToArray(); _errorStorage = _errorStorage.Skip(Marshal.SizeOf<ErrorCommonHeader>()).ToArray();
switch (_errorCommonHeader.Type) switch (_errorCommonHeader.Type)
{ {
@ -63,7 +63,8 @@ namespace Ryujinx.HLE.HOS.Applets.Error
break; break;
} }
default: throw new NotImplementedException($"ErrorApplet type {_errorCommonHeader.Type} is not implemented."); default:
throw new NotImplementedException($"ErrorApplet type {_errorCommonHeader.Type} is not implemented.");
} }
AppletStateChanged?.Invoke(this, null); AppletStateChanged?.Invoke(this, null);
@ -71,15 +72,16 @@ namespace Ryujinx.HLE.HOS.Applets.Error
return ResultCode.Success; return ResultCode.Success;
} }
private (uint module, uint description) HexToResultCode(uint resultCode) private static (uint module, uint description) HexToResultCode(uint resultCode)
{ {
return ((resultCode & 0x1FF) + 2000, (resultCode >> 9) & 0x3FFF); return ((resultCode & 0x1FF) + 2000, (resultCode >> 9) & 0x3FFF);
} }
private string SystemLanguageToLanguageKey(SystemLanguage systemLanguage) private static string SystemLanguageToLanguageKey(SystemLanguage systemLanguage)
{ {
return systemLanguage switch return systemLanguage switch
{ {
#pragma warning disable IDE0055 // Disable formatting
SystemLanguage.Japanese => "ja", SystemLanguage.Japanese => "ja",
SystemLanguage.AmericanEnglish => "en-US", SystemLanguage.AmericanEnglish => "en-US",
SystemLanguage.French => "fr", SystemLanguage.French => "fr",
@ -98,7 +100,8 @@ namespace Ryujinx.HLE.HOS.Applets.Error
SystemLanguage.SimplifiedChinese => "zh-Hans", SystemLanguage.SimplifiedChinese => "zh-Hans",
SystemLanguage.TraditionalChinese => "zh-Hant", SystemLanguage.TraditionalChinese => "zh-Hant",
SystemLanguage.BrazilianPortuguese => "pt-BR", SystemLanguage.BrazilianPortuguese => "pt-BR",
_ => "en-US" _ => "en-US",
#pragma warning restore IDE0055
}; };
} }
@ -111,26 +114,24 @@ namespace Ryujinx.HLE.HOS.Applets.Error
{ {
string binaryTitleContentPath = _horizon.ContentManager.GetInstalledContentPath(ErrorMessageBinaryTitleId, StorageId.BuiltInSystem, NcaContentType.Data); string binaryTitleContentPath = _horizon.ContentManager.GetInstalledContentPath(ErrorMessageBinaryTitleId, StorageId.BuiltInSystem, NcaContentType.Data);
using (LibHac.Fs.IStorage ncaFileStream = new LocalStorage(_horizon.Device.FileSystem.SwitchPathToSystemPath(binaryTitleContentPath), FileAccess.Read, FileMode.Open)) using LibHac.Fs.IStorage ncaFileStream = new LocalStorage(FileSystem.VirtualFileSystem.SwitchPathToSystemPath(binaryTitleContentPath), FileAccess.Read, FileMode.Open);
Nca nca = new(_horizon.Device.FileSystem.KeySet, ncaFileStream);
IFileSystem romfs = nca.OpenFileSystem(NcaSectionType.Data, _horizon.FsIntegrityCheckLevel);
string languageCode = SystemLanguageToLanguageKey(_horizon.State.DesiredSystemLanguage);
string filePath = $"/{module}/{description:0000}/{languageCode}_{key}";
if (romfs.FileExists(filePath))
{ {
Nca nca = new Nca(_horizon.Device.FileSystem.KeySet, ncaFileStream); using var binaryFile = new UniqueRef<IFile>();
IFileSystem romfs = nca.OpenFileSystem(NcaSectionType.Data, _horizon.FsIntegrityCheckLevel);
string languageCode = SystemLanguageToLanguageKey(_horizon.State.DesiredSystemLanguage);
string filePath = $"/{module}/{description:0000}/{languageCode}_{key}";
if (romfs.FileExists(filePath)) romfs.OpenFile(ref binaryFile.Ref, filePath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
{ StreamReader reader = new(binaryFile.Get.AsStream(), Encoding.Unicode);
using var binaryFile = new UniqueRef<IFile>();
romfs.OpenFile(ref binaryFile.Ref, filePath.ToU8Span(), OpenMode.Read).ThrowIfFailure(); return CleanText(reader.ReadToEnd());
StreamReader reader = new StreamReader(binaryFile.Get.AsStream(), Encoding.Unicode); }
else
return CleanText(reader.ReadToEnd()); {
} return "";
else
{
return "";
}
} }
} }
@ -145,7 +146,7 @@ namespace Ryujinx.HLE.HOS.Applets.Error
{ {
ErrorCommonArg errorCommonArg = IApplet.ReadStruct<ErrorCommonArg>(_errorStorage); ErrorCommonArg errorCommonArg = IApplet.ReadStruct<ErrorCommonArg>(_errorStorage);
uint module = errorCommonArg.Module; uint module = errorCommonArg.Module;
uint description = errorCommonArg.Description; uint description = errorCommonArg.Description;
if (_errorCommonHeader.MessageFlag == 0) if (_errorCommonHeader.MessageFlag == 0)
@ -188,7 +189,7 @@ namespace Ryujinx.HLE.HOS.Applets.Error
string messageText = Encoding.ASCII.GetString(messageTextBuffer.TakeWhile(b => !b.Equals(0)).ToArray()); string messageText = Encoding.ASCII.GetString(messageTextBuffer.TakeWhile(b => !b.Equals(0)).ToArray());
string detailsText = Encoding.ASCII.GetString(detailsTextBuffer.TakeWhile(b => !b.Equals(0)).ToArray()); string detailsText = Encoding.ASCII.GetString(detailsTextBuffer.TakeWhile(b => !b.Equals(0)).ToArray());
List<string> buttons = new List<string>(); List<string> buttons = new();
// TODO: Handle the LanguageCode to return the translated "OK" and "Details". // TODO: Handle the LanguageCode to return the translated "OK" and "Details".
@ -213,4 +214,4 @@ namespace Ryujinx.HLE.HOS.Applets.Error
return ResultCode.Success; return ResultCode.Success;
} }
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/Error/ErrorCommonArg.cs
View File

@ -9,4 +9,4 @@ namespace Ryujinx.HLE.HOS.Applets.Error
public uint Description; public uint Description;
public uint ResultCode; public uint ResultCode;
} }
} }

16
src/Ryujinx.HLE/HOS/Applets/Error/ErrorCommonHeader.cs
View File

@ -6,12 +6,12 @@ namespace Ryujinx.HLE.HOS.Applets.Error
struct ErrorCommonHeader struct ErrorCommonHeader
{ {
public ErrorType Type; public ErrorType Type;
public byte JumpFlag; public byte JumpFlag;
public byte ReservedFlag1; public byte ReservedFlag1;
public byte ReservedFlag2; public byte ReservedFlag2;
public byte ReservedFlag3; public byte ReservedFlag3;
public byte ContextFlag; public byte ContextFlag;
public byte MessageFlag; public byte MessageFlag;
public byte ContextFlag2; public byte ContextFlag2;
} }
} }

4
src/Ryujinx.HLE/HOS/Applets/Error/ErrorType.cs
View File

@ -8,6 +8,6 @@
ErrorEulaArg, ErrorEulaArg,
ErrorPctlArg, ErrorPctlArg,
ErrorRecordArg, ErrorRecordArg,
SystemUpdateEulaArg = 8 SystemUpdateEulaArg = 8,
} }
} }

19
src/Ryujinx.HLE/HOS/Applets/PlayerSelect/PlayerSelectApplet.cs
View File

@ -8,10 +8,12 @@ namespace Ryujinx.HLE.HOS.Applets
{ {
internal class PlayerSelectApplet : IApplet internal class PlayerSelectApplet : IApplet
{ {
private Horizon _system; private readonly Horizon _system;
private AppletSession _normalSession; private AppletSession _normalSession;
#pragma warning disable IDE0052 // Remove unread private member
private AppletSession _interactiveSession; private AppletSession _interactiveSession;
#pragma warning restore IDE0052
public event EventHandler AppletStateChanged; public event EventHandler AppletStateChanged;
@ -22,7 +24,7 @@ namespace Ryujinx.HLE.HOS.Applets
public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession) public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession)
{ {
_normalSession = normalSession; _normalSession = normalSession;
_interactiveSession = interactiveSession; _interactiveSession = interactiveSession;
// TODO(jduncanator): Parse PlayerSelectConfig from input data // TODO(jduncanator): Parse PlayerSelectConfig from input data
@ -44,15 +46,14 @@ namespace Ryujinx.HLE.HOS.Applets
{ {
UserProfile currentUser = _system.AccountManager.LastOpenedUser; UserProfile currentUser = _system.AccountManager.LastOpenedUser;
using (MemoryStream stream = MemoryStreamManager.Shared.GetStream()) using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
writer.Write((ulong)PlayerSelectResult.Success);
currentUser.UserId.Write(writer); writer.Write((ulong)PlayerSelectResult.Success);
return stream.ToArray(); currentUser.UserId.Write(writer);
}
return stream.ToArray();
} }
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/PlayerSelect/PlayerSelectResult.cs
View File

@ -3,6 +3,6 @@
enum PlayerSelectResult : ulong enum PlayerSelectResult : ulong
{ {
Success = 0, Success = 0,
Failure = 2 Failure = 2,
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/CJKCharacterValidation.cs
View File

@ -14,4 +14,4 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
[GeneratedRegex("\\p{IsHangulJamo}|\\p{IsCJKRadicalsSupplement}|\\p{IsCJKSymbolsandPunctuation}|\\p{IsEnclosedCJKLettersandMonths}|\\p{IsCJKCompatibility}|\\p{IsCJKUnifiedIdeographsExtensionA}|\\p{IsCJKUnifiedIdeographs}|\\p{IsHangulSyllables}|\\p{IsCJKCompatibilityForms}")] [GeneratedRegex("\\p{IsHangulJamo}|\\p{IsCJKRadicalsSupplement}|\\p{IsCJKSymbolsandPunctuation}|\\p{IsEnclosedCJKLettersandMonths}|\\p{IsCJKCompatibility}|\\p{IsCJKUnifiedIdeographsExtensionA}|\\p{IsCJKUnifiedIdeographs}|\\p{IsHangulSyllables}|\\p{IsCJKCompatibilityForms}")]
private static partial Regex CJKRegex(); private static partial Regex CJKRegex();
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/InitialCursorPosition.cs
View File

@ -13,6 +13,6 @@
/// <summary> /// <summary>
/// Position the cursor at the end of the text /// Position the cursor at the end of the text
/// </summary> /// </summary>
End End,
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/InlineKeyboardRequest.cs
View File

@ -43,6 +43,6 @@
/// <summary> /// <summary>
/// [8.0.0+] Request the keyboard applet to use the MovedCursorV2 response when notifying changes in cursor position. /// [8.0.0+] Request the keyboard applet to use the MovedCursorV2 response when notifying changes in cursor position.
/// </summary> /// </summary>
UseMovedCursorV2 = 0xE UseMovedCursorV2 = 0xE,
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/InlineKeyboardResponse.cs
View File

@ -88,6 +88,6 @@
/// <summary> /// <summary>
/// Same as MovedCursorUtf8, but with additional fields. /// Same as MovedCursorUtf8, but with additional fields.
/// </summary> /// </summary>
MovedCursorUtf8V2 = 0x10 MovedCursorUtf8V2 = 0x10,
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/InlineKeyboardState.cs
View File

@ -28,6 +28,6 @@
/// <summary> /// <summary>
/// software keyboard is transitioning to a hidden state because the user pressed either OK or Cancel. /// software keyboard is transitioning to a hidden state because the user pressed either OK or Cancel.
/// </summary> /// </summary>
Disappearing = 0x4 Disappearing = 0x4,
} }
} }

219
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/InlineResponses.cs
View File

@ -60,55 +60,51 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
{ {
uint resSize = 2 * sizeof(uint) + 0x1; uint resSize = 2 * sizeof(uint) + 0x1;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.FinishedInitialize, writer);
writer.Write((byte)1); // Data (ignored by the program)
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.FinishedInitialize, writer);
} writer.Write((byte)1); // Data (ignored by the program)
return stream.ToArray();
} }
public static byte[] Default(InlineKeyboardState state) public static byte[] Default(InlineKeyboardState state)
{ {
uint resSize = 2 * sizeof(uint); uint resSize = 2 * sizeof(uint);
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.Default, writer);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.Default, writer);
}
return stream.ToArray();
} }
public static byte[] ChangedString(string text, uint cursor, InlineKeyboardState state) public static byte[] ChangedString(string text, uint cursor, InlineKeyboardState state)
{ {
uint resSize = 6 * sizeof(uint) + MaxStrLenUTF16; uint resSize = 6 * sizeof(uint) + MaxStrLenUTF16;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.ChangedString, writer);
WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF16, Encoding.Unicode, true);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.ChangedString, writer);
} WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF16, Encoding.Unicode, true);
return stream.ToArray();
} }
public static byte[] MovedCursor(string text, uint cursor, InlineKeyboardState state) public static byte[] MovedCursor(string text, uint cursor, InlineKeyboardState state)
{ {
uint resSize = 4 * sizeof(uint) + MaxStrLenUTF16; uint resSize = 4 * sizeof(uint) + MaxStrLenUTF16;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.MovedCursor, writer);
WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF16, Encoding.Unicode, false);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.MovedCursor, writer);
} WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF16, Encoding.Unicode, false);
return stream.ToArray();
} }
public static byte[] MovedTab(string text, uint cursor, InlineKeyboardState state) public static byte[] MovedTab(string text, uint cursor, InlineKeyboardState state)
@ -117,182 +113,169 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
uint resSize = 4 * sizeof(uint) + MaxStrLenUTF16; uint resSize = 4 * sizeof(uint) + MaxStrLenUTF16;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.MovedTab, writer);
WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF16, Encoding.Unicode, false);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.MovedTab, writer);
} WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF16, Encoding.Unicode, false);
return stream.ToArray();
} }
public static byte[] DecidedEnter(string text, InlineKeyboardState state) public static byte[] DecidedEnter(string text, InlineKeyboardState state)
{ {
uint resSize = 3 * sizeof(uint) + MaxStrLenUTF16; uint resSize = 3 * sizeof(uint) + MaxStrLenUTF16;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.DecidedEnter, writer);
WriteString(text, writer, MaxStrLenUTF16, Encoding.Unicode);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.DecidedEnter, writer);
} WriteString(text, writer, MaxStrLenUTF16, Encoding.Unicode);
return stream.ToArray();
} }
public static byte[] DecidedCancel(InlineKeyboardState state) public static byte[] DecidedCancel(InlineKeyboardState state)
{ {
uint resSize = 2 * sizeof(uint); uint resSize = 2 * sizeof(uint);
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.DecidedCancel, writer);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.DecidedCancel, writer);
}
return stream.ToArray();
} }
public static byte[] ChangedStringUtf8(string text, uint cursor, InlineKeyboardState state) public static byte[] ChangedStringUtf8(string text, uint cursor, InlineKeyboardState state)
{ {
uint resSize = 6 * sizeof(uint) + MaxStrLenUTF8; uint resSize = 6 * sizeof(uint) + MaxStrLenUTF8;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.ChangedStringUtf8, writer);
WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF8, Encoding.UTF8, true);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.ChangedStringUtf8, writer);
} WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF8, Encoding.UTF8, true);
return stream.ToArray();
} }
public static byte[] MovedCursorUtf8(string text, uint cursor, InlineKeyboardState state) public static byte[] MovedCursorUtf8(string text, uint cursor, InlineKeyboardState state)
{ {
uint resSize = 4 * sizeof(uint) + MaxStrLenUTF8; uint resSize = 4 * sizeof(uint) + MaxStrLenUTF8;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.MovedCursorUtf8, writer);
WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF8, Encoding.UTF8, false);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.MovedCursorUtf8, writer);
} WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF8, Encoding.UTF8, false);
return stream.ToArray();
} }
public static byte[] DecidedEnterUtf8(string text, InlineKeyboardState state) public static byte[] DecidedEnterUtf8(string text, InlineKeyboardState state)
{ {
uint resSize = 3 * sizeof(uint) + MaxStrLenUTF8; uint resSize = 3 * sizeof(uint) + MaxStrLenUTF8;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.DecidedEnterUtf8, writer);
WriteString(text, writer, MaxStrLenUTF8, Encoding.UTF8);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.DecidedEnterUtf8, writer);
} WriteString(text, writer, MaxStrLenUTF8, Encoding.UTF8);
return stream.ToArray();
} }
public static byte[] UnsetCustomizeDic(InlineKeyboardState state) public static byte[] UnsetCustomizeDic(InlineKeyboardState state)
{ {
uint resSize = 2 * sizeof(uint); uint resSize = 2 * sizeof(uint);
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.UnsetCustomizeDic, writer);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.UnsetCustomizeDic, writer);
}
return stream.ToArray();
} }
public static byte[] ReleasedUserWordInfo(InlineKeyboardState state) public static byte[] ReleasedUserWordInfo(InlineKeyboardState state)
{ {
uint resSize = 2 * sizeof(uint); uint resSize = 2 * sizeof(uint);
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.ReleasedUserWordInfo, writer);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.ReleasedUserWordInfo, writer);
}
return stream.ToArray();
} }
public static byte[] UnsetCustomizedDictionaries(InlineKeyboardState state) public static byte[] UnsetCustomizedDictionaries(InlineKeyboardState state)
{ {
uint resSize = 2 * sizeof(uint); uint resSize = 2 * sizeof(uint);
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.UnsetCustomizedDictionaries, writer);
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.UnsetCustomizedDictionaries, writer);
}
return stream.ToArray();
} }
public static byte[] ChangedStringV2(string text, uint cursor, InlineKeyboardState state) public static byte[] ChangedStringV2(string text, uint cursor, InlineKeyboardState state)
{ {
uint resSize = 6 * sizeof(uint) + MaxStrLenUTF16 + 0x1; uint resSize = 6 * sizeof(uint) + MaxStrLenUTF16 + 0x1;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.ChangedStringV2, writer);
WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF16, Encoding.Unicode, true);
writer.Write((byte)0); // Flag == 0
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.ChangedStringV2, writer);
} WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF16, Encoding.Unicode, true);
writer.Write((byte)0); // Flag == 0
return stream.ToArray();
} }
public static byte[] MovedCursorV2(string text, uint cursor, InlineKeyboardState state) public static byte[] MovedCursorV2(string text, uint cursor, InlineKeyboardState state)
{ {
uint resSize = 4 * sizeof(uint) + MaxStrLenUTF16 + 0x1; uint resSize = 4 * sizeof(uint) + MaxStrLenUTF16 + 0x1;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.MovedCursorV2, writer);
WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF16, Encoding.Unicode, false);
writer.Write((byte)0); // Flag == 0
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.MovedCursorV2, writer);
} WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF16, Encoding.Unicode, false);
writer.Write((byte)0); // Flag == 0
return stream.ToArray();
} }
public static byte[] ChangedStringUtf8V2(string text, uint cursor, InlineKeyboardState state) public static byte[] ChangedStringUtf8V2(string text, uint cursor, InlineKeyboardState state)
{ {
uint resSize = 6 * sizeof(uint) + MaxStrLenUTF8 + 0x1; uint resSize = 6 * sizeof(uint) + MaxStrLenUTF8 + 0x1;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.ChangedStringUtf8V2, writer);
WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF8, Encoding.UTF8, true);
writer.Write((byte)0); // Flag == 0
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.ChangedStringUtf8V2, writer);
} WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF8, Encoding.UTF8, true);
writer.Write((byte)0); // Flag == 0
return stream.ToArray();
} }
public static byte[] MovedCursorUtf8V2(string text, uint cursor, InlineKeyboardState state) public static byte[] MovedCursorUtf8V2(string text, uint cursor, InlineKeyboardState state)
{ {
uint resSize = 4 * sizeof(uint) + MaxStrLenUTF8 + 0x1; uint resSize = 4 * sizeof(uint) + MaxStrLenUTF8 + 0x1;
using (MemoryStream stream = new MemoryStream(new byte[resSize])) using MemoryStream stream = new(new byte[resSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
{
BeginResponse(state, InlineKeyboardResponse.MovedCursorUtf8V2, writer);
WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF8, Encoding.UTF8, false);
writer.Write((byte)0); // Flag == 0
return stream.ToArray(); BeginResponse(state, InlineKeyboardResponse.MovedCursorUtf8V2, writer);
} WriteStringWithCursor(text, cursor, writer, MaxStrLenUTF8, Encoding.UTF8, false);
writer.Write((byte)0); // Flag == 0
return stream.ToArray();
} }
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/InputFormMode.cs
View File

@ -13,6 +13,6 @@
/// <summary> /// <summary>
/// Displays the text entry area as a multi-line field. /// Displays the text entry area as a multi-line field.
/// </summary> /// </summary>
MultiLine MultiLine,
} }
} }

6
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/InvalidButtonFlags.cs
View File

@ -8,10 +8,10 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
[Flags] [Flags]
enum InvalidButtonFlags : uint enum InvalidButtonFlags : uint
{ {
None = 0, None = 0,
AnalogStickL = 1 << 1, AnalogStickL = 1 << 1,
AnalogStickR = 1 << 2, AnalogStickR = 1 << 2,
ZL = 1 << 3, ZL = 1 << 3,
ZR = 1 << 4, ZR = 1 << 4,
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/InvalidCharFlags.cs
View File

@ -51,6 +51,6 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
/// <summary> /// <summary>
/// Prohibits characters outside of those allowed in Mii Nicknames. /// Prohibits characters outside of those allowed in Mii Nicknames.
/// </summary> /// </summary>
Username = 1 << 8 Username = 1 << 8,
} }
} }

26
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/KeyboardCalcFlags.cs
View File

@ -8,19 +8,19 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
[Flags] [Flags]
enum KeyboardCalcFlags : ulong enum KeyboardCalcFlags : ulong
{ {
Initialize = 0x1, Initialize = 0x1,
SetVolume = 0x2, SetVolume = 0x2,
Appear = 0x4, Appear = 0x4,
SetInputText = 0x8, SetInputText = 0x8,
SetCursorPos = 0x10, SetCursorPos = 0x10,
SetUtf8Mode = 0x20, SetUtf8Mode = 0x20,
SetKeyboardBackground = 0x100, SetKeyboardBackground = 0x100,
SetKeyboardOptions1 = 0x200, SetKeyboardOptions1 = 0x200,
SetKeyboardOptions2 = 0x800, SetKeyboardOptions2 = 0x800,
EnableSeGroup = 0x2000, EnableSeGroup = 0x2000,
DisableSeGroup = 0x4000, DisableSeGroup = 0x4000,
SetBackspaceEnabled = 0x8000, SetBackspaceEnabled = 0x8000,
AppearTrigger = 0x10000, AppearTrigger = 0x10000,
MustShow = Appear | SetInputText | AppearTrigger MustShow = Appear | SetInputText | AppearTrigger,
} }
} }

6
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/KeyboardMiniaturizationMode.cs
View File

@ -5,8 +5,8 @@
/// </summary> /// </summary>
enum KeyboardMiniaturizationMode : byte enum KeyboardMiniaturizationMode : byte
{ {
None = 0, None = 0,
Auto = 1, Auto = 1,
Forced = 2 Forced = 2,
} }
} }

12
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/KeyboardMode.cs
View File

@ -24,16 +24,16 @@
/// Synonymous with default. /// Synonymous with default.
/// </summary> /// </summary>
FullLatin = 3, FullLatin = 3,
/// <summary> /// <summary>
/// All UTF-16 characters except CJK characters allowed. /// All UTF-16 characters except CJK characters allowed.
/// </summary> /// </summary>
Alphabet = 4, Alphabet = 4,
SimplifiedChinese = 5, SimplifiedChinese = 5,
TraditionalChinese = 6, TraditionalChinese = 6,
Korean = 7, Korean = 7,
LanguageSet2 = 8, LanguageSet2 = 8,
LanguageSet2Latin = 9, LanguageSet2Latin = 9,
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/KeyboardResult.cs
View File

@ -9,4 +9,4 @@
Accept = 1, Accept = 1,
Cancel = 2, Cancel = 2,
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/PasswordMode.cs
View File

@ -13,6 +13,6 @@
/// <summary> /// <summary>
/// Hide input characters. /// Hide input characters.
/// </summary> /// </summary>
Enabled Enabled,
} }
} }

63
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardAppear.cs
View File

@ -77,41 +77,42 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
[MarshalAs(UnmanagedType.I1)] [MarshalAs(UnmanagedType.I1)]
public bool UseSaveData; public bool UseSaveData;
public uint Reserved3; public uint Reserved3;
public ushort Reserved4; public ushort Reserved4;
public byte Reserved5; public byte Reserved5;
public ulong Reserved6; public ulong Reserved6;
public ulong Reserved7; public ulong Reserved7;
public SoftwareKeyboardAppearEx ToExtended() public SoftwareKeyboardAppearEx ToExtended()
{ {
SoftwareKeyboardAppearEx appear = new SoftwareKeyboardAppearEx(); SoftwareKeyboardAppearEx appear = new()
{
appear.KeyboardMode = KeyboardMode; KeyboardMode = KeyboardMode,
appear.OkText = OkText; OkText = OkText,
appear.LeftOptionalSymbolKey = LeftOptionalSymbolKey; LeftOptionalSymbolKey = LeftOptionalSymbolKey,
appear.RightOptionalSymbolKey = RightOptionalSymbolKey; RightOptionalSymbolKey = RightOptionalSymbolKey,
appear.PredictionEnabled = PredictionEnabled; PredictionEnabled = PredictionEnabled,
appear.CancelButtonDisabled = CancelButtonDisabled; CancelButtonDisabled = CancelButtonDisabled,
appear.InvalidChars = InvalidChars; InvalidChars = InvalidChars,
appear.TextMaxLength = TextMaxLength; TextMaxLength = TextMaxLength,
appear.TextMinLength = TextMinLength; TextMinLength = TextMinLength,
appear.UseNewLine = UseNewLine; UseNewLine = UseNewLine,
appear.MiniaturizationMode = MiniaturizationMode; MiniaturizationMode = MiniaturizationMode,
appear.Reserved1 = Reserved1; Reserved1 = Reserved1,
appear.Reserved2 = Reserved2; Reserved2 = Reserved2,
appear.InvalidButtons = InvalidButtons; InvalidButtons = InvalidButtons,
appear.UseSaveData = UseSaveData; UseSaveData = UseSaveData,
appear.Reserved3 = Reserved3; Reserved3 = Reserved3,
appear.Reserved4 = Reserved4; Reserved4 = Reserved4,
appear.Reserved5 = Reserved5; Reserved5 = Reserved5,
appear.Uid0 = Reserved6; Uid0 = Reserved6,
appear.Uid1 = Reserved7; Uid1 = Reserved7,
appear.SamplingNumber = 0; SamplingNumber = 0,
appear.Reserved6 = 0; Reserved6 = 0,
appear.Reserved7 = 0; Reserved7 = 0,
appear.Reserved8 = 0; Reserved8 = 0,
appear.Reserved9 = 0; Reserved9 = 0,
};
return appear; return appear;
} }

4
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardAppearEx.cs
View File

@ -77,9 +77,9 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
[MarshalAs(UnmanagedType.I1)] [MarshalAs(UnmanagedType.I1)]
public bool UseSaveData; public bool UseSaveData;
public uint Reserved3; public uint Reserved3;
public ushort Reserved4; public ushort Reserved4;
public byte Reserved5; public byte Reserved5;
/// <summary> /// <summary>
/// The id of the user associated with the appear request. /// The id of the user associated with the appear request.

389
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardApplet.cs
View File

@ -21,16 +21,16 @@ namespace Ryujinx.HLE.HOS.Applets
{ {
private const string DefaultInputText = "Ryujinx"; private const string DefaultInputText = "Ryujinx";
private const int StandardBufferSize = 0x7D8; private const int StandardBufferSize = 0x7D8;
private const int InteractiveBufferSize = 0x7D4; private const int InteractiveBufferSize = 0x7D4;
private const int MaxUserWords = 0x1388; private const int MaxUserWords = 0x1388;
private const int MaxUiTextSize = 100; private const int MaxUiTextSize = 100;
private const Key CycleInputModesKey = Key.F6; private const Key CycleInputModesKey = Key.F6;
private readonly Switch _device; private readonly Switch _device;
private SoftwareKeyboardState _foregroundState = SoftwareKeyboardState.Uninitialized; private SoftwareKeyboardState _foregroundState = SoftwareKeyboardState.Uninitialized;
private volatile InlineKeyboardState _backgroundState = InlineKeyboardState.Uninitialized; private volatile InlineKeyboardState _backgroundState = InlineKeyboardState.Uninitialized;
private bool _isBackground = false; private bool _isBackground = false;
@ -42,23 +42,25 @@ namespace Ryujinx.HLE.HOS.Applets
private SoftwareKeyboardConfig _keyboardForegroundConfig; private SoftwareKeyboardConfig _keyboardForegroundConfig;
// Configuration for background (inline) mode. // Configuration for background (inline) mode.
private SoftwareKeyboardInitialize _keyboardBackgroundInitialize; #pragma warning disable IDE0052 // Remove unread private member
private SoftwareKeyboardInitialize _keyboardBackgroundInitialize;
private SoftwareKeyboardCustomizeDic _keyboardBackgroundDic; private SoftwareKeyboardCustomizeDic _keyboardBackgroundDic;
private SoftwareKeyboardDictSet _keyboardBackgroundDictSet; private SoftwareKeyboardDictSet _keyboardBackgroundDictSet;
private SoftwareKeyboardUserWord[] _keyboardBackgroundUserWords; #pragma warning restore IDE0052
private SoftwareKeyboardUserWord[] _keyboardBackgroundUserWords;
private byte[] _transferMemory; private byte[] _transferMemory;
private string _textValue = ""; private string _textValue = "";
private int _cursorBegin = 0; private int _cursorBegin = 0;
private Encoding _encoding = Encoding.Unicode; private Encoding _encoding = Encoding.Unicode;
private KeyboardResult _lastResult = KeyboardResult.NotSet; private KeyboardResult _lastResult = KeyboardResult.NotSet;
private IDynamicTextInputHandler _dynamicTextInputHandler = null; private IDynamicTextInputHandler _dynamicTextInputHandler = null;
private SoftwareKeyboardRenderer _keyboardRenderer = null; private SoftwareKeyboardRenderer _keyboardRenderer = null;
private NpadReader _npads = null; private NpadReader _npads = null;
private bool _canAcceptController = false; private bool _canAcceptController = false;
private KeyboardInputMode _inputMode = KeyboardInputMode.ControllerAndKeyboard; private KeyboardInputMode _inputMode = KeyboardInputMode.ControllerAndKeyboard;
private readonly object _lock = new(); private readonly object _lock = new();
@ -73,12 +75,12 @@ namespace Ryujinx.HLE.HOS.Applets
{ {
lock (_lock) lock (_lock)
{ {
_normalSession = normalSession; _normalSession = normalSession;
_interactiveSession = interactiveSession; _interactiveSession = interactiveSession;
_interactiveSession.DataAvailable += OnInteractiveData; _interactiveSession.DataAvailable += OnInteractiveData;
var launchParams = _normalSession.Pop(); var launchParams = _normalSession.Pop();
var keyboardConfig = _normalSession.Pop(); var keyboardConfig = _normalSession.Pop();
_isBackground = keyboardConfig.Length == Unsafe.SizeOf<SoftwareKeyboardInitialize>(); _isBackground = keyboardConfig.Length == Unsafe.SizeOf<SoftwareKeyboardInitialize>();
@ -88,7 +90,7 @@ namespace Ryujinx.HLE.HOS.Applets
// Initialize the keyboard applet in background mode. // Initialize the keyboard applet in background mode.
_keyboardBackgroundInitialize = MemoryMarshal.Read<SoftwareKeyboardInitialize>(keyboardConfig); _keyboardBackgroundInitialize = MemoryMarshal.Read<SoftwareKeyboardInitialize>(keyboardConfig);
_backgroundState = InlineKeyboardState.Uninitialized; _backgroundState = InlineKeyboardState.Uninitialized;
if (_device.UiHandler == null) if (_device.UiHandler == null)
{ {
@ -99,11 +101,11 @@ namespace Ryujinx.HLE.HOS.Applets
// Create a text handler that converts keyboard strokes to strings. // Create a text handler that converts keyboard strokes to strings.
_dynamicTextInputHandler = _device.UiHandler.CreateDynamicTextInputHandler(); _dynamicTextInputHandler = _device.UiHandler.CreateDynamicTextInputHandler();
_dynamicTextInputHandler.TextChangedEvent += HandleTextChangedEvent; _dynamicTextInputHandler.TextChangedEvent += HandleTextChangedEvent;
_dynamicTextInputHandler.KeyPressedEvent += HandleKeyPressedEvent; _dynamicTextInputHandler.KeyPressedEvent += HandleKeyPressedEvent;
_npads = new NpadReader(_device); _npads = new NpadReader(_device);
_npads.NpadButtonDownEvent += HandleNpadButtonDownEvent; _npads.NpadButtonDownEvent += HandleNpadButtonDownEvent;
_npads.NpadButtonUpEvent += HandleNpadButtonUpEvent; _npads.NpadButtonUpEvent += HandleNpadButtonUpEvent;
_keyboardRenderer = new SoftwareKeyboardRenderer(_device.UiHandler.HostUiTheme); _keyboardRenderer = new SoftwareKeyboardRenderer(_device.UiHandler.HostUiTheme);
} }
@ -217,7 +219,7 @@ namespace Ryujinx.HLE.HOS.Applets
_keyboardForegroundConfig.SubmitText : "OK"), _keyboardForegroundConfig.SubmitText : "OK"),
StringLengthMin = _keyboardForegroundConfig.StringLengthMin, StringLengthMin = _keyboardForegroundConfig.StringLengthMin,
StringLengthMax = _keyboardForegroundConfig.StringLengthMax, StringLengthMax = _keyboardForegroundConfig.StringLengthMax,
InitialText = initialText InitialText = initialText,
}; };
_lastResult = _device.UiHandler.DisplayInputDialog(args, out _textValue) ? KeyboardResult.Accept : KeyboardResult.Cancel; _lastResult = _device.UiHandler.DisplayInputDialog(args, out _textValue) ? KeyboardResult.Accept : KeyboardResult.Cancel;
@ -237,7 +239,7 @@ namespace Ryujinx.HLE.HOS.Applets
// we truncate it. // we truncate it.
if (_textValue.Length > _keyboardForegroundConfig.StringLengthMax) if (_textValue.Length > _keyboardForegroundConfig.StringLengthMax)
{ {
_textValue = _textValue.Substring(0, _keyboardForegroundConfig.StringLengthMax); _textValue = _textValue[.._keyboardForegroundConfig.StringLengthMax];
} }
// Does the application want to validate the text itself? // Does the application want to validate the text itself?
@ -319,178 +321,177 @@ namespace Ryujinx.HLE.HOS.Applets
// request from the game, this is because the inline keyboard is expected to // request from the game, this is because the inline keyboard is expected to
// keep running in the background sending data by itself. // keep running in the background sending data by itself.
using (MemoryStream stream = new MemoryStream(data)) using MemoryStream stream = new(data);
using (BinaryReader reader = new BinaryReader(stream)) using BinaryReader reader = new(stream);
var request = (InlineKeyboardRequest)reader.ReadUInt32();
long remaining;
Logger.Debug?.Print(LogClass.ServiceAm, $"Keyboard received command {request} in state {_backgroundState}");
switch (request)
{ {
var request = (InlineKeyboardRequest)reader.ReadUInt32(); case InlineKeyboardRequest.UseChangedStringV2:
Logger.Stub?.Print(LogClass.ServiceAm, "Inline keyboard request UseChangedStringV2");
long remaining; break;
case InlineKeyboardRequest.UseMovedCursorV2:
Logger.Debug?.Print(LogClass.ServiceAm, $"Keyboard received command {request} in state {_backgroundState}"); Logger.Stub?.Print(LogClass.ServiceAm, "Inline keyboard request UseMovedCursorV2");
break;
switch (request) case InlineKeyboardRequest.SetUserWordInfo:
{ // Read the user word info data.
case InlineKeyboardRequest.UseChangedStringV2: remaining = stream.Length - stream.Position;
Logger.Stub?.Print(LogClass.ServiceAm, "Inline keyboard request UseChangedStringV2"); if (remaining < sizeof(int))
break; {
case InlineKeyboardRequest.UseMovedCursorV2: Logger.Warning?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard User Word Info of {remaining} bytes");
Logger.Stub?.Print(LogClass.ServiceAm, "Inline keyboard request UseMovedCursorV2"); }
break; else
case InlineKeyboardRequest.SetUserWordInfo: {
// Read the user word info data. int wordsCount = reader.ReadInt32();
int wordSize = Unsafe.SizeOf<SoftwareKeyboardUserWord>();
remaining = stream.Length - stream.Position; remaining = stream.Length - stream.Position;
if (remaining < sizeof(int))
if (wordsCount > MaxUserWords)
{ {
Logger.Warning?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard User Word Info of {remaining} bytes"); Logger.Warning?.Print(LogClass.ServiceAm, $"Received {wordsCount} User Words but the maximum is {MaxUserWords}");
}
else if (wordsCount * wordSize != remaining)
{
Logger.Warning?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard User Word Info data of {remaining} bytes for {wordsCount} words");
} }
else else
{ {
int wordsCount = reader.ReadInt32(); _keyboardBackgroundUserWords = new SoftwareKeyboardUserWord[wordsCount];
int wordSize = Unsafe.SizeOf<SoftwareKeyboardUserWord>();
remaining = stream.Length - stream.Position;
if (wordsCount > MaxUserWords) for (int word = 0; word < wordsCount; word++)
{ {
Logger.Warning?.Print(LogClass.ServiceAm, $"Received {wordsCount} User Words but the maximum is {MaxUserWords}"); _keyboardBackgroundUserWords[word] = reader.ReadStruct<SoftwareKeyboardUserWord>();
}
else if (wordsCount * wordSize != remaining)
{
Logger.Warning?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard User Word Info data of {remaining} bytes for {wordsCount} words");
}
else
{
_keyboardBackgroundUserWords = new SoftwareKeyboardUserWord[wordsCount];
for (int word = 0; word < wordsCount; word++)
{
_keyboardBackgroundUserWords[word] = reader.ReadStruct<SoftwareKeyboardUserWord>();
}
} }
} }
_interactiveSession.Push(InlineResponses.ReleasedUserWordInfo(_backgroundState)); }
break; _interactiveSession.Push(InlineResponses.ReleasedUserWordInfo(_backgroundState));
case InlineKeyboardRequest.SetCustomizeDic: break;
// Read the custom dic data. case InlineKeyboardRequest.SetCustomizeDic:
remaining = stream.Length - stream.Position; // Read the custom dic data.
if (remaining != Unsafe.SizeOf<SoftwareKeyboardCustomizeDic>()) remaining = stream.Length - stream.Position;
{ if (remaining != Unsafe.SizeOf<SoftwareKeyboardCustomizeDic>())
Logger.Warning?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard Customize Dic of {remaining} bytes"); {
} Logger.Warning?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard Customize Dic of {remaining} bytes");
else }
{ else
_keyboardBackgroundDic = reader.ReadStruct<SoftwareKeyboardCustomizeDic>(); {
} _keyboardBackgroundDic = reader.ReadStruct<SoftwareKeyboardCustomizeDic>();
break; }
case InlineKeyboardRequest.SetCustomizedDictionaries: break;
// Read the custom dictionaries data. case InlineKeyboardRequest.SetCustomizedDictionaries:
remaining = stream.Length - stream.Position; // Read the custom dictionaries data.
if (remaining != Unsafe.SizeOf<SoftwareKeyboardDictSet>()) remaining = stream.Length - stream.Position;
{ if (remaining != Unsafe.SizeOf<SoftwareKeyboardDictSet>())
Logger.Warning?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard DictSet of {remaining} bytes"); {
} Logger.Warning?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard DictSet of {remaining} bytes");
else }
{ else
_keyboardBackgroundDictSet = reader.ReadStruct<SoftwareKeyboardDictSet>(); {
} _keyboardBackgroundDictSet = reader.ReadStruct<SoftwareKeyboardDictSet>();
break; }
case InlineKeyboardRequest.Calc: break;
// The Calc request is used to communicate configuration changes and commands to the keyboard. case InlineKeyboardRequest.Calc:
// Fields in the Calc struct and operations are masked by the Flags field. // The Calc request is used to communicate configuration changes and commands to the keyboard.
// Fields in the Calc struct and operations are masked by the Flags field.
// Read the Calc data. // Read the Calc data.
SoftwareKeyboardCalcEx newCalc; SoftwareKeyboardCalcEx newCalc;
remaining = stream.Length - stream.Position; remaining = stream.Length - stream.Position;
if (remaining == Marshal.SizeOf<SoftwareKeyboardCalc>()) if (remaining == Marshal.SizeOf<SoftwareKeyboardCalc>())
{ {
var keyboardCalcData = reader.ReadBytes((int)remaining); var keyboardCalcData = reader.ReadBytes((int)remaining);
var keyboardCalc = ReadStruct<SoftwareKeyboardCalc>(keyboardCalcData); var keyboardCalc = ReadStruct<SoftwareKeyboardCalc>(keyboardCalcData);
newCalc = keyboardCalc.ToExtended(); newCalc = keyboardCalc.ToExtended();
} }
else if (remaining == Marshal.SizeOf<SoftwareKeyboardCalcEx>() || remaining == SoftwareKeyboardCalcEx.AlternativeSize) else if (remaining == Marshal.SizeOf<SoftwareKeyboardCalcEx>() || remaining == SoftwareKeyboardCalcEx.AlternativeSize)
{ {
var keyboardCalcData = reader.ReadBytes((int)remaining); var keyboardCalcData = reader.ReadBytes((int)remaining);
newCalc = ReadStruct<SoftwareKeyboardCalcEx>(keyboardCalcData); newCalc = ReadStruct<SoftwareKeyboardCalcEx>(keyboardCalcData);
} }
else else
{ {
Logger.Error?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard Calc of {remaining} bytes"); Logger.Error?.Print(LogClass.ServiceAm, $"Received invalid Software Keyboard Calc of {remaining} bytes");
newCalc = new SoftwareKeyboardCalcEx(); newCalc = new SoftwareKeyboardCalcEx();
} }
// Process each individual operation specified in the flags. // Process each individual operation specified in the flags.
bool updateText = false; bool updateText = false;
if ((newCalc.Flags & KeyboardCalcFlags.Initialize) != 0) if ((newCalc.Flags & KeyboardCalcFlags.Initialize) != 0)
{ {
_interactiveSession.Push(InlineResponses.FinishedInitialize(_backgroundState)); _interactiveSession.Push(InlineResponses.FinishedInitialize(_backgroundState));
_backgroundState = InlineKeyboardState.Initialized; _backgroundState = InlineKeyboardState.Initialized;
} }
if ((newCalc.Flags & KeyboardCalcFlags.SetCursorPos) != 0) if ((newCalc.Flags & KeyboardCalcFlags.SetCursorPos) != 0)
{ {
_cursorBegin = newCalc.CursorPos; _cursorBegin = newCalc.CursorPos;
updateText = true; updateText = true;
Logger.Debug?.Print(LogClass.ServiceAm, $"Cursor position set to {_cursorBegin}"); Logger.Debug?.Print(LogClass.ServiceAm, $"Cursor position set to {_cursorBegin}");
} }
if ((newCalc.Flags & KeyboardCalcFlags.SetInputText) != 0) if ((newCalc.Flags & KeyboardCalcFlags.SetInputText) != 0)
{ {
_textValue = newCalc.InputText; _textValue = newCalc.InputText;
updateText = true; updateText = true;
Logger.Debug?.Print(LogClass.ServiceAm, $"Input text set to {_textValue}"); Logger.Debug?.Print(LogClass.ServiceAm, $"Input text set to {_textValue}");
} }
if ((newCalc.Flags & KeyboardCalcFlags.SetUtf8Mode) != 0) if ((newCalc.Flags & KeyboardCalcFlags.SetUtf8Mode) != 0)
{ {
_encoding = newCalc.UseUtf8 ? Encoding.UTF8 : Encoding.Default; _encoding = newCalc.UseUtf8 ? Encoding.UTF8 : Encoding.Default;
Logger.Debug?.Print(LogClass.ServiceAm, $"Encoding set to {_encoding}"); Logger.Debug?.Print(LogClass.ServiceAm, $"Encoding set to {_encoding}");
} }
if (updateText) if (updateText)
{ {
_dynamicTextInputHandler.SetText(_textValue, _cursorBegin); _dynamicTextInputHandler.SetText(_textValue, _cursorBegin);
_keyboardRenderer.UpdateTextState(_textValue, _cursorBegin, _cursorBegin, null, null); _keyboardRenderer.UpdateTextState(_textValue, _cursorBegin, _cursorBegin, null, null);
} }
if ((newCalc.Flags & KeyboardCalcFlags.MustShow) != 0) if ((newCalc.Flags & KeyboardCalcFlags.MustShow) != 0)
{ {
ActivateFrontend(); ActivateFrontend();
_backgroundState = InlineKeyboardState.Shown; _backgroundState = InlineKeyboardState.Shown;
PushChangedString(_textValue, (uint)_cursorBegin, _backgroundState); PushChangedString(_textValue, (uint)_cursorBegin, _backgroundState);
} }
// Send the response to the Calc // Send the response to the Calc
_interactiveSession.Push(InlineResponses.Default(_backgroundState)); _interactiveSession.Push(InlineResponses.Default(_backgroundState));
break; break;
case InlineKeyboardRequest.Finalize: case InlineKeyboardRequest.Finalize:
// Destroy the frontend. // Destroy the frontend.
DestroyFrontend(); DestroyFrontend();
// The calling application wants to close the keyboard applet and will wait for a state change. // The calling application wants to close the keyboard applet and will wait for a state change.
_backgroundState = InlineKeyboardState.Uninitialized; _backgroundState = InlineKeyboardState.Uninitialized;
AppletStateChanged?.Invoke(this, null); AppletStateChanged?.Invoke(this, null);
break; break;
default: default:
// We shouldn't be able to get here through standard swkbd execution. // We shouldn't be able to get here through standard swkbd execution.
Logger.Warning?.Print(LogClass.ServiceAm, $"Invalid Software Keyboard request {request} during state {_backgroundState}"); Logger.Warning?.Print(LogClass.ServiceAm, $"Invalid Software Keyboard request {request} during state {_backgroundState}");
_interactiveSession.Push(InlineResponses.Default(_backgroundState)); _interactiveSession.Push(InlineResponses.Default(_backgroundState));
break; break;
}
} }
} }
private void ActivateFrontend() private void ActivateFrontend()
{ {
Logger.Debug?.Print(LogClass.ServiceAm, $"Activating software keyboard frontend"); Logger.Debug?.Print(LogClass.ServiceAm, "Activating software keyboard frontend");
_inputMode = KeyboardInputMode.ControllerAndKeyboard; _inputMode = KeyboardInputMode.ControllerAndKeyboard;
@ -509,9 +510,9 @@ namespace Ryujinx.HLE.HOS.Applets
private void DeactivateFrontend() private void DeactivateFrontend()
{ {
Logger.Debug?.Print(LogClass.ServiceAm, $"Deactivating software keyboard frontend"); Logger.Debug?.Print(LogClass.ServiceAm, "Deactivating software keyboard frontend");
_inputMode = KeyboardInputMode.ControllerAndKeyboard; _inputMode = KeyboardInputMode.ControllerAndKeyboard;
_canAcceptController = false; _canAcceptController = false;
_dynamicTextInputHandler.TextProcessingEnabled = false; _dynamicTextInputHandler.TextProcessingEnabled = false;
@ -520,7 +521,7 @@ namespace Ryujinx.HLE.HOS.Applets
private void DestroyFrontend() private void DestroyFrontend()
{ {
Logger.Debug?.Print(LogClass.ServiceAm, $"Destroying software keyboard frontend"); Logger.Debug?.Print(LogClass.ServiceAm, "Destroying software keyboard frontend");
_keyboardRenderer?.Dispose(); _keyboardRenderer?.Dispose();
_keyboardRenderer = null; _keyboardRenderer = null;
@ -528,7 +529,7 @@ namespace Ryujinx.HLE.HOS.Applets
if (_dynamicTextInputHandler != null) if (_dynamicTextInputHandler != null)
{ {
_dynamicTextInputHandler.TextChangedEvent -= HandleTextChangedEvent; _dynamicTextInputHandler.TextChangedEvent -= HandleTextChangedEvent;
_dynamicTextInputHandler.KeyPressedEvent -= HandleKeyPressedEvent; _dynamicTextInputHandler.KeyPressedEvent -= HandleKeyPressedEvent;
_dynamicTextInputHandler.Dispose(); _dynamicTextInputHandler.Dispose();
_dynamicTextInputHandler = null; _dynamicTextInputHandler = null;
} }
@ -536,7 +537,7 @@ namespace Ryujinx.HLE.HOS.Applets
if (_npads != null) if (_npads != null)
{ {
_npads.NpadButtonDownEvent -= HandleNpadButtonDownEvent; _npads.NpadButtonDownEvent -= HandleNpadButtonDownEvent;
_npads.NpadButtonUpEvent -= HandleNpadButtonUpEvent; _npads.NpadButtonUpEvent -= HandleNpadButtonUpEvent;
_npads = null; _npads = null;
} }
} }
@ -551,7 +552,7 @@ namespace Ryujinx.HLE.HOS.Applets
{ {
AdvanceInputMode(); AdvanceInputMode();
bool typingEnabled = InputModeTypingEnabled(); bool typingEnabled = InputModeTypingEnabled();
bool controllerEnabled = InputModeControllerEnabled(); bool controllerEnabled = InputModeControllerEnabled();
_dynamicTextInputHandler.TextProcessingEnabled = typingEnabled; _dynamicTextInputHandler.TextProcessingEnabled = typingEnabled;
@ -575,14 +576,14 @@ namespace Ryujinx.HLE.HOS.Applets
if (text.Length > MaxUiTextSize) if (text.Length > MaxUiTextSize)
{ {
// Limit the text size and change it back. // Limit the text size and change it back.
text = text.Substring(0, MaxUiTextSize); text = text[..MaxUiTextSize];
cursorBegin = Math.Min(cursorBegin, MaxUiTextSize); cursorBegin = Math.Min(cursorBegin, MaxUiTextSize);
cursorEnd = Math.Min(cursorEnd, MaxUiTextSize); cursorEnd = Math.Min(cursorEnd, MaxUiTextSize);
_dynamicTextInputHandler.SetText(text, cursorBegin, cursorEnd); _dynamicTextInputHandler.SetText(text, cursorBegin, cursorEnd);
} }
_textValue = text; _textValue = text;
_cursorBegin = cursorBegin; _cursorBegin = cursorBegin;
_keyboardRenderer.UpdateTextState(text, cursorBegin, cursorEnd, overwriteMode, null); _keyboardRenderer.UpdateTextState(text, cursorBegin, cursorEnd, overwriteMode, null);
@ -646,7 +647,7 @@ namespace Ryujinx.HLE.HOS.Applets
private void PushUpdatedState(string text, int cursorBegin, KeyboardResult result) private void PushUpdatedState(string text, int cursorBegin, KeyboardResult result)
{ {
_lastResult = result; _lastResult = result;
_textValue = text; _textValue = text;
bool cancel = result == KeyboardResult.Cancel; bool cancel = result == KeyboardResult.Cancel;
bool accept = result == KeyboardResult.Accept; bool accept = result == KeyboardResult.Accept;
@ -734,33 +735,31 @@ namespace Ryujinx.HLE.HOS.Applets
{ {
int bufferSize = interactive ? InteractiveBufferSize : StandardBufferSize; int bufferSize = interactive ? InteractiveBufferSize : StandardBufferSize;
using (MemoryStream stream = new MemoryStream(new byte[bufferSize])) using MemoryStream stream = new(new byte[bufferSize]);
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
byte[] output = _encoding.GetBytes(_textValue);
if (!interactive)
{ {
byte[] output = _encoding.GetBytes(_textValue); // Result Code.
writer.Write(_lastResult == KeyboardResult.Accept ? 0U : 1U);
}
else
{
// In interactive mode, we write the length of the text as a long, rather than
// a result code. This field is inclusive of the 64-bit size.
writer.Write((long)output.Length + 8);
}
if (!interactive) writer.Write(output);
{
// Result Code.
writer.Write(_lastResult == KeyboardResult.Accept ? 0U : 1U);
}
else
{
// In interactive mode, we write the length of the text as a long, rather than
// a result code. This field is inclusive of the 64-bit size.
writer.Write((long)output.Length + 8);
}
writer.Write(output); if (!interactive)
{
if (!interactive) _normalSession.Push(stream.ToArray());
{ }
_normalSession.Push(stream.ToArray()); else
} {
else _interactiveSession.Push(stream.ToArray());
{
_interactiveSession.Push(stream.ToArray());
}
} }
} }
@ -787,7 +786,7 @@ namespace Ryujinx.HLE.HOS.Applets
return string.Empty; return string.Empty;
} }
StringBuilder sb = new StringBuilder(capacity: input.Length); StringBuilder sb = new(capacity: input.Length);
foreach (char c in input) foreach (char c in input)
{ {
if (!char.IsControl(c)) if (!char.IsControl(c))

79
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardCalc.cs
View File

@ -174,45 +174,46 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
public SoftwareKeyboardCalcEx ToExtended() public SoftwareKeyboardCalcEx ToExtended()
{ {
SoftwareKeyboardCalcEx calc = new SoftwareKeyboardCalcEx(); SoftwareKeyboardCalcEx calc = new()
{
calc.Unknown = Unknown; Unknown = Unknown,
calc.Size = Size; Size = Size,
calc.Unknown1 = Unknown1; Unknown1 = Unknown1,
calc.Unknown2 = Unknown2; Unknown2 = Unknown2,
calc.Flags = Flags; Flags = Flags,
calc.Initialize = Initialize; Initialize = Initialize,
calc.Volume = Volume; Volume = Volume,
calc.CursorPos = CursorPos; CursorPos = CursorPos,
calc.Appear = Appear.ToExtended(); Appear = Appear.ToExtended(),
calc.InputText = InputText; InputText = InputText,
calc.UseUtf8 = UseUtf8; UseUtf8 = UseUtf8,
calc.Unknown3 = Unknown3; Unknown3 = Unknown3,
calc.BackspaceEnabled = BackspaceEnabled; BackspaceEnabled = BackspaceEnabled,
calc.Unknown4 = Unknown4; Unknown4 = Unknown4,
calc.Unknown5 = Unknown5; Unknown5 = Unknown5,
calc.KeytopAsFloating = KeytopAsFloating; KeytopAsFloating = KeytopAsFloating,
calc.FooterScalable = FooterScalable; FooterScalable = FooterScalable,
calc.AlphaEnabledInInputMode = AlphaEnabledInInputMode; AlphaEnabledInInputMode = AlphaEnabledInInputMode,
calc.InputModeFadeType = InputModeFadeType; InputModeFadeType = InputModeFadeType,
calc.TouchDisabled = TouchDisabled; TouchDisabled = TouchDisabled,
calc.HardwareKeyboardDisabled = HardwareKeyboardDisabled; HardwareKeyboardDisabled = HardwareKeyboardDisabled,
calc.Unknown6 = Unknown6; Unknown6 = Unknown6,
calc.Unknown7 = Unknown7; Unknown7 = Unknown7,
calc.KeytopScale0 = KeytopScale0; KeytopScale0 = KeytopScale0,
calc.KeytopScale1 = KeytopScale1; KeytopScale1 = KeytopScale1,
calc.KeytopTranslate0 = KeytopTranslate0; KeytopTranslate0 = KeytopTranslate0,
calc.KeytopTranslate1 = KeytopTranslate1; KeytopTranslate1 = KeytopTranslate1,
calc.KeytopBgAlpha = KeytopBgAlpha; KeytopBgAlpha = KeytopBgAlpha,
calc.FooterBgAlpha = FooterBgAlpha; FooterBgAlpha = FooterBgAlpha,
calc.BalloonScale = BalloonScale; BalloonScale = BalloonScale,
calc.Unknown8 = Unknown8; Unknown8 = Unknown8,
calc.Unknown9 = Unknown9; Unknown9 = Unknown9,
calc.Unknown10 = Unknown10; Unknown10 = Unknown10,
calc.Unknown11 = Unknown11; Unknown11 = Unknown11,
calc.SeGroup = SeGroup; SeGroup = SeGroup,
calc.TriggerFlag = TriggerFlag; TriggerFlag = TriggerFlag,
calc.Trigger = Trigger; Trigger = Trigger,
};
return calc; return calc;
} }

6
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardConfig.cs
View File

@ -8,10 +8,10 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
struct SoftwareKeyboardConfig struct SoftwareKeyboardConfig
{ {
private const int SubmitTextLength = 8; private const int SubmitTextLength = 8;
private const int HeaderTextLength = 64; private const int HeaderTextLength = 64;
private const int SubtitleTextLength = 128; private const int SubtitleTextLength = 128;
private const int GuideTextLength = 256; private const int GuideTextLength = 256;
/// <summary> /// <summary>
/// Type of keyboard. /// Type of keyboard.

32
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardRenderer.cs
View File

@ -10,16 +10,16 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
/// </summary> /// </summary>
internal class SoftwareKeyboardRenderer : IDisposable internal class SoftwareKeyboardRenderer : IDisposable
{ {
private const int TextBoxBlinkSleepMilliseconds = 100; private const int TextBoxBlinkSleepMilliseconds = 100;
private const int RendererWaitTimeoutMilliseconds = 100; private const int RendererWaitTimeoutMilliseconds = 100;
private readonly object _stateLock = new(); private readonly object _stateLock = new();
private SoftwareKeyboardUiState _state = new SoftwareKeyboardUiState(); private readonly SoftwareKeyboardUiState _state = new();
private SoftwareKeyboardRendererBase _renderer; private readonly SoftwareKeyboardRendererBase _renderer;
private TimedAction _textBoxBlinkTimedAction = new TimedAction(); private readonly TimedAction _textBoxBlinkTimedAction = new();
private TimedAction _renderAction = new TimedAction(); private readonly TimedAction _renderAction = new();
public SoftwareKeyboardRenderer(IHostUiTheme uiTheme) public SoftwareKeyboardRenderer(IHostUiTheme uiTheme)
{ {
@ -47,10 +47,10 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
private static void StartRenderer(TimedAction timedAction, SoftwareKeyboardRendererBase renderer, SoftwareKeyboardUiState state, object stateLock) private static void StartRenderer(TimedAction timedAction, SoftwareKeyboardRendererBase renderer, SoftwareKeyboardUiState state, object stateLock)
{ {
SoftwareKeyboardUiState internalState = new SoftwareKeyboardUiState(); SoftwareKeyboardUiState internalState = new();
bool canCreateSurface = false; bool canCreateSurface = false;
bool needsUpdate = true; bool needsUpdate = true;
timedAction.Reset(() => timedAction.Reset(() =>
{ {
@ -61,6 +61,7 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
return; return;
} }
#pragma warning disable IDE0055 // Disable formatting
needsUpdate = UpdateStateField(ref state.InputText, ref internalState.InputText); needsUpdate = UpdateStateField(ref state.InputText, ref internalState.InputText);
needsUpdate |= UpdateStateField(ref state.CursorBegin, ref internalState.CursorBegin); needsUpdate |= UpdateStateField(ref state.CursorBegin, ref internalState.CursorBegin);
needsUpdate |= UpdateStateField(ref state.CursorEnd, ref internalState.CursorEnd); needsUpdate |= UpdateStateField(ref state.CursorEnd, ref internalState.CursorEnd);
@ -70,6 +71,7 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
needsUpdate |= UpdateStateField(ref state.TypingEnabled, ref internalState.TypingEnabled); needsUpdate |= UpdateStateField(ref state.TypingEnabled, ref internalState.TypingEnabled);
needsUpdate |= UpdateStateField(ref state.ControllerEnabled, ref internalState.ControllerEnabled); needsUpdate |= UpdateStateField(ref state.ControllerEnabled, ref internalState.ControllerEnabled);
needsUpdate |= UpdateStateField(ref state.TextBoxBlinkCounter, ref internalState.TextBoxBlinkCounter); needsUpdate |= UpdateStateField(ref state.TextBoxBlinkCounter, ref internalState.TextBoxBlinkCounter);
#pragma warning restore IDE0055
canCreateSurface = state.SurfaceInfo != null && internalState.SurfaceInfo == null; canCreateSurface = state.SurfaceInfo != null && internalState.SurfaceInfo == null;
@ -104,16 +106,14 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
return false; return false;
} }
#pragma warning disable CS8632 public void UpdateTextState(string inputText, int? cursorBegin, int? cursorEnd, bool? overwriteMode, bool? typingEnabled)
public void UpdateTextState(string? inputText, int? cursorBegin, int? cursorEnd, bool? overwriteMode, bool? typingEnabled)
#pragma warning restore CS8632
{ {
lock (_stateLock) lock (_stateLock)
{ {
// Update the parameters that were provided. // Update the parameters that were provided.
_state.InputText = inputText != null ? inputText : _state.InputText; _state.InputText = inputText ?? _state.InputText;
_state.CursorBegin = cursorBegin.GetValueOrDefault(_state.CursorBegin); _state.CursorBegin = cursorBegin.GetValueOrDefault(_state.CursorBegin);
_state.CursorEnd = cursorEnd.GetValueOrDefault(_state.CursorEnd); _state.CursorEnd = cursorEnd.GetValueOrDefault(_state.CursorEnd);
_state.OverwriteMode = overwriteMode.GetValueOrDefault(_state.OverwriteMode); _state.OverwriteMode = overwriteMode.GetValueOrDefault(_state.OverwriteMode);
_state.TypingEnabled = typingEnabled.GetValueOrDefault(_state.TypingEnabled); _state.TypingEnabled = typingEnabled.GetValueOrDefault(_state.TypingEnabled);
@ -130,8 +130,8 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
lock (_stateLock) lock (_stateLock)
{ {
// Update the parameters that were provided. // Update the parameters that were provided.
_state.AcceptPressed = acceptPressed.GetValueOrDefault(_state.AcceptPressed); _state.AcceptPressed = acceptPressed.GetValueOrDefault(_state.AcceptPressed);
_state.CancelPressed = cancelPressed.GetValueOrDefault(_state.CancelPressed); _state.CancelPressed = cancelPressed.GetValueOrDefault(_state.CancelPressed);
_state.ControllerEnabled = controllerEnabled.GetValueOrDefault(_state.ControllerEnabled); _state.ControllerEnabled = controllerEnabled.GetValueOrDefault(_state.ControllerEnabled);
// Tell the render thread there is something new to render. // Tell the render thread there is something new to render.

210
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardRendererBase.cs
View File

@ -21,47 +21,47 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
{ {
public const int TextBoxBlinkThreshold = 8; public const int TextBoxBlinkThreshold = 8;
const string MessageText = "Please use the keyboard to input text"; const string MessageText = "Please use the keyboard to input text";
const string AcceptText = "Accept"; const string AcceptText = "Accept";
const string CancelText = "Cancel"; const string CancelText = "Cancel";
const string ControllerToggleText = "Toggle input"; const string ControllerToggleText = "Toggle input";
private readonly object _bufferLock = new(); private readonly object _bufferLock = new();
private RenderingSurfaceInfo _surfaceInfo = null; private RenderingSurfaceInfo _surfaceInfo = null;
private Image<Argb32> _surface = null; private Image<Argb32> _surface = null;
private byte[] _bufferData = null; private byte[] _bufferData = null;
private Image _ryujinxLogo = null; private readonly Image _ryujinxLogo = null;
private Image _padAcceptIcon = null; private readonly Image _padAcceptIcon = null;
private Image _padCancelIcon = null; private readonly Image _padCancelIcon = null;
private Image _keyModeIcon = null; private readonly Image _keyModeIcon = null;
private float _textBoxOutlineWidth; private readonly float _textBoxOutlineWidth;
private float _padPressedPenWidth; private readonly float _padPressedPenWidth;
private Color _textNormalColor; private readonly Color _textNormalColor;
private Color _textSelectedColor; private readonly Color _textSelectedColor;
private Color _textOverCursorColor; private readonly Color _textOverCursorColor;
private IBrush _panelBrush; private readonly IBrush _panelBrush;
private IBrush _disabledBrush; private readonly IBrush _disabledBrush;
private IBrush _cursorBrush; private readonly IBrush _cursorBrush;
private IBrush _selectionBoxBrush; private readonly IBrush _selectionBoxBrush;
private Pen _textBoxOutlinePen; private readonly Pen _textBoxOutlinePen;
private Pen _cursorPen; private readonly Pen _cursorPen;
private Pen _selectionBoxPen; private readonly Pen _selectionBoxPen;
private Pen _padPressedPen; private readonly Pen _padPressedPen;
private int _inputTextFontSize; private readonly int _inputTextFontSize;
private Font _messageFont; private Font _messageFont;
private Font _inputTextFont; private Font _inputTextFont;
private Font _labelsTextFont; private Font _labelsTextFont;
private RectangleF _panelRectangle; private RectangleF _panelRectangle;
private Point _logoPosition; private Point _logoPosition;
private float _messagePositionY; private float _messagePositionY;
public SoftwareKeyboardRendererBase(IHostUiTheme uiTheme) public SoftwareKeyboardRendererBase(IHostUiTheme uiTheme)
{ {
@ -72,35 +72,35 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
string padAcceptIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Icon_BtnA.png"; string padAcceptIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Icon_BtnA.png";
string padCancelIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Icon_BtnB.png"; string padCancelIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Icon_BtnB.png";
string keyModeIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Icon_KeyF6.png"; string keyModeIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Icon_KeyF6.png";
_padAcceptIcon = LoadResource(Assembly.GetExecutingAssembly(), padAcceptIconPath , 0, 0); _padAcceptIcon = LoadResource(Assembly.GetExecutingAssembly(), padAcceptIconPath, 0, 0);
_padCancelIcon = LoadResource(Assembly.GetExecutingAssembly(), padCancelIconPath , 0, 0); _padCancelIcon = LoadResource(Assembly.GetExecutingAssembly(), padCancelIconPath, 0, 0);
_keyModeIcon = LoadResource(Assembly.GetExecutingAssembly(), keyModeIconPath , 0, 0); _keyModeIcon = LoadResource(Assembly.GetExecutingAssembly(), keyModeIconPath, 0, 0);
Color panelColor = ToColor(uiTheme.DefaultBackgroundColor, 255); Color panelColor = ToColor(uiTheme.DefaultBackgroundColor, 255);
Color panelTransparentColor = ToColor(uiTheme.DefaultBackgroundColor, 150); Color panelTransparentColor = ToColor(uiTheme.DefaultBackgroundColor, 150);
Color borderColor = ToColor(uiTheme.DefaultBorderColor); Color borderColor = ToColor(uiTheme.DefaultBorderColor);
Color selectionBackgroundColor = ToColor(uiTheme.SelectionBackgroundColor); Color selectionBackgroundColor = ToColor(uiTheme.SelectionBackgroundColor);
_textNormalColor = ToColor(uiTheme.DefaultForegroundColor); _textNormalColor = ToColor(uiTheme.DefaultForegroundColor);
_textSelectedColor = ToColor(uiTheme.SelectionForegroundColor); _textSelectedColor = ToColor(uiTheme.SelectionForegroundColor);
_textOverCursorColor = ToColor(uiTheme.DefaultForegroundColor, null, true); _textOverCursorColor = ToColor(uiTheme.DefaultForegroundColor, null, true);
float cursorWidth = 2; float cursorWidth = 2;
_textBoxOutlineWidth = 2; _textBoxOutlineWidth = 2;
_padPressedPenWidth = 2; _padPressedPenWidth = 2;
_panelBrush = new SolidBrush(panelColor); _panelBrush = new SolidBrush(panelColor);
_disabledBrush = new SolidBrush(panelTransparentColor); _disabledBrush = new SolidBrush(panelTransparentColor);
_cursorBrush = new SolidBrush(_textNormalColor); _cursorBrush = new SolidBrush(_textNormalColor);
_selectionBoxBrush = new SolidBrush(selectionBackgroundColor); _selectionBoxBrush = new SolidBrush(selectionBackgroundColor);
_textBoxOutlinePen = new Pen(borderColor, _textBoxOutlineWidth); _textBoxOutlinePen = new Pen(borderColor, _textBoxOutlineWidth);
_cursorPen = new Pen(_textNormalColor, cursorWidth); _cursorPen = new Pen(_textNormalColor, cursorWidth);
_selectionBoxPen = new Pen(selectionBackgroundColor, cursorWidth); _selectionBoxPen = new Pen(selectionBackgroundColor, cursorWidth);
_padPressedPen = new Pen(borderColor, _padPressedPenWidth); _padPressedPen = new Pen(borderColor, _padPressedPenWidth);
_inputTextFontSize = 20; _inputTextFontSize = 20;
@ -111,22 +111,21 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
{ {
// Try a list of fonts in case any of them is not available in the system. // Try a list of fonts in case any of them is not available in the system.
string[] availableFonts = new string[] string[] availableFonts = {
{
uiThemeFontFamily, uiThemeFontFamily,
"Liberation Sans", "Liberation Sans",
"FreeSans", "FreeSans",
"DejaVu Sans", "DejaVu Sans",
"Lucida Grande" "Lucida Grande",
}; };
foreach (string fontFamily in availableFonts) foreach (string fontFamily in availableFonts)
{ {
try try
{ {
_messageFont = SystemFonts.CreateFont(fontFamily, 26, FontStyle.Regular); _messageFont = SystemFonts.CreateFont(fontFamily, 26, FontStyle.Regular);
_inputTextFont = SystemFonts.CreateFont(fontFamily, _inputTextFontSize, FontStyle.Regular); _inputTextFont = SystemFonts.CreateFont(fontFamily, _inputTextFontSize, FontStyle.Regular);
_labelsTextFont = SystemFonts.CreateFont(fontFamily, 24, FontStyle.Regular); _labelsTextFont = SystemFonts.CreateFont(fontFamily, 24, FontStyle.Regular);
return; return;
} }
@ -138,7 +137,7 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
throw new Exception($"None of these fonts were found in the system: {String.Join(", ", availableFonts)}!"); throw new Exception($"None of these fonts were found in the system: {String.Join(", ", availableFonts)}!");
} }
private Color ToColor(ThemeColor color, byte? overrideAlpha = null, bool flipRgb = false) private static Color ToColor(ThemeColor color, byte? overrideAlpha = null, bool flipRgb = false)
{ {
var a = (byte)(color.A * 255); var a = (byte)(color.A * 255);
var r = (byte)(color.R * 255); var r = (byte)(color.R * 255);
@ -155,14 +154,14 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
return Color.FromRgba(r, g, b, overrideAlpha.GetValueOrDefault(a)); return Color.FromRgba(r, g, b, overrideAlpha.GetValueOrDefault(a));
} }
private Image LoadResource(Assembly assembly, string resourcePath, int newWidth, int newHeight) private static Image LoadResource(Assembly assembly, string resourcePath, int newWidth, int newHeight)
{ {
Stream resourceStream = assembly.GetManifestResourceStream(resourcePath); Stream resourceStream = assembly.GetManifestResourceStream(resourcePath);
return LoadResource(resourceStream, newWidth, newHeight); return LoadResource(resourceStream, newWidth, newHeight);
} }
private Image LoadResource(Stream resourceStream, int newWidth, int newHeight) private static Image LoadResource(Stream resourceStream, int newWidth, int newHeight)
{ {
Debug.Assert(resourceStream != null); Debug.Assert(resourceStream != null);
@ -176,7 +175,7 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
return image; return image;
} }
private void SetGraphicsOptions(IImageProcessingContext context) private static void SetGraphicsOptions(IImageProcessingContext context)
{ {
context.GetGraphicsOptions().Antialias = true; context.GetGraphicsOptions().Antialias = true;
context.GetShapeGraphicsOptions().GraphicsOptions.Antialias = true; context.GetShapeGraphicsOptions().GraphicsOptions.Antialias = true;
@ -198,9 +197,9 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
context.DrawImage(_ryujinxLogo, _logoPosition, 1); context.DrawImage(_ryujinxLogo, _logoPosition, 1);
float halfWidth = _panelRectangle.Width / 2; float halfWidth = _panelRectangle.Width / 2;
float buttonsY = _panelRectangle.Y + 185; float buttonsY = _panelRectangle.Y + 185;
PointF disableButtonPosition = new PointF(halfWidth + 180, buttonsY); PointF disableButtonPosition = new(halfWidth + 180, buttonsY);
DrawControllerToggle(context, disableButtonPosition); DrawControllerToggle(context, disableButtonPosition);
}); });
@ -215,11 +214,11 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
_surface.Mutate(context => _surface.Mutate(context =>
{ {
var messageRectangle = MeasureString(MessageText, _messageFont); var messageRectangle = MeasureString(MessageText, _messageFont);
float messagePositionX = (_panelRectangle.Width - messageRectangle.Width) / 2 - messageRectangle.X; float messagePositionX = (_panelRectangle.Width - messageRectangle.Width) / 2 - messageRectangle.X;
float messagePositionY = _messagePositionY - messageRectangle.Y; float messagePositionY = _messagePositionY - messageRectangle.Y;
var messagePosition = new PointF(messagePositionX, messagePositionY); var messagePosition = new PointF(messagePositionX, messagePositionY);
var messageBoundRectangle = new RectangleF(messagePositionX, messagePositionY, messageRectangle.Width, messageRectangle.Height); var messageBoundRectangle = new RectangleF(messagePositionX, messagePositionY, messageRectangle.Width, messageRectangle.Height);
SetGraphicsOptions(context); SetGraphicsOptions(context);
@ -238,11 +237,11 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
DrawTextBox(context, state); DrawTextBox(context, state);
float halfWidth = _panelRectangle.Width / 2; float halfWidth = _panelRectangle.Width / 2;
float buttonsY = _panelRectangle.Y + 185; float buttonsY = _panelRectangle.Y + 185;
PointF acceptButtonPosition = new PointF(halfWidth - 180, buttonsY); PointF acceptButtonPosition = new(halfWidth - 180, buttonsY);
PointF cancelButtonPosition = new PointF(halfWidth , buttonsY); PointF cancelButtonPosition = new(halfWidth, buttonsY);
PointF disableButtonPosition = new PointF(halfWidth + 180, buttonsY); PointF disableButtonPosition = new(halfWidth + 180, buttonsY);
DrawPadButton(context, acceptButtonPosition, _padAcceptIcon, AcceptText, state.AcceptPressed, state.ControllerEnabled); DrawPadButton(context, acceptButtonPosition, _padAcceptIcon, AcceptText, state.AcceptPressed, state.ControllerEnabled);
DrawPadButton(context, cancelButtonPosition, _padCancelIcon, CancelText, state.CancelPressed, state.ControllerEnabled); DrawPadButton(context, cancelButtonPosition, _padCancelIcon, CancelText, state.CancelPressed, state.ControllerEnabled);
@ -262,7 +261,7 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
// Use the whole area of the image to draw, even the alignment, otherwise it may shear the final // Use the whole area of the image to draw, even the alignment, otherwise it may shear the final
// image if the pitch is different. // image if the pitch is different.
uint totalWidth = _surfaceInfo.Pitch / 4; uint totalWidth = _surfaceInfo.Pitch / 4;
uint totalHeight = _surfaceInfo.Size / _surfaceInfo.Pitch; uint totalHeight = _surfaceInfo.Size / _surfaceInfo.Pitch;
Debug.Assert(_surfaceInfo.Width <= totalWidth); Debug.Assert(_surfaceInfo.Width <= totalWidth);
@ -277,10 +276,10 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
private void ComputeConstants() private void ComputeConstants()
{ {
int totalWidth = (int)_surfaceInfo.Width; int totalWidth = (int)_surfaceInfo.Width;
int totalHeight = (int)_surfaceInfo.Height; int totalHeight = (int)_surfaceInfo.Height;
int panelHeight = 240; int panelHeight = 240;
int panelPositionY = totalHeight - panelHeight; int panelPositionY = totalHeight - panelHeight;
_panelRectangle = new RectangleF(0, panelPositionY, totalWidth, panelHeight); _panelRectangle = new RectangleF(0, panelPositionY, totalWidth, panelHeight);
@ -294,7 +293,7 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
} }
private static RectangleF MeasureString(string text, Font font) private static RectangleF MeasureString(string text, Font font)
{ {
RendererOptions options = new RendererOptions(font); RendererOptions options = new(font);
if (text == "") if (text == "")
{ {
@ -310,7 +309,7 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
private static RectangleF MeasureString(ReadOnlySpan<char> text, Font font) private static RectangleF MeasureString(ReadOnlySpan<char> text, Font font)
{ {
RendererOptions options = new RendererOptions(font); RendererOptions options = new(font);
if (text == "") if (text == "")
{ {
@ -327,14 +326,14 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
{ {
var inputTextRectangle = MeasureString(state.InputText, _inputTextFont); var inputTextRectangle = MeasureString(state.InputText, _inputTextFont);
float boxWidth = (int)(Math.Max(300, inputTextRectangle.Width + inputTextRectangle.X + 8)); float boxWidth = (int)(Math.Max(300, inputTextRectangle.Width + inputTextRectangle.X + 8));
float boxHeight = 32; float boxHeight = 32;
float boxY = _panelRectangle.Y + 110; float boxY = _panelRectangle.Y + 110;
float boxX = (int)((_panelRectangle.Width - boxWidth) / 2); float boxX = (int)((_panelRectangle.Width - boxWidth) / 2);
RectangleF boxRectangle = new RectangleF(boxX, boxY, boxWidth, boxHeight); RectangleF boxRectangle = new(boxX, boxY, boxWidth, boxHeight);
RectangleF boundRectangle = new RectangleF(_panelRectangle.X, boxY - _textBoxOutlineWidth, RectangleF boundRectangle = new(_panelRectangle.X, boxY - _textBoxOutlineWidth,
_panelRectangle.Width, boxHeight + 2 * _textBoxOutlineWidth); _panelRectangle.Width, boxHeight + 2 * _textBoxOutlineWidth);
context.Fill(_panelBrush, boundRectangle); context.Fill(_panelBrush, boundRectangle);
@ -350,11 +349,11 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
// Draw the cursor on top of the text and redraw the text with a different color if necessary. // Draw the cursor on top of the text and redraw the text with a different color if necessary.
Color cursorTextColor; Color cursorTextColor;
IBrush cursorBrush; IBrush cursorBrush;
Pen cursorPen; Pen cursorPen;
float cursorPositionYTop = inputTextY + 1; float cursorPositionYTop = inputTextY + 1;
float cursorPositionYBottom = cursorPositionYTop + _inputTextFontSize + 1; float cursorPositionYBottom = cursorPositionYTop + _inputTextFontSize + 1;
float cursorPositionXLeft; float cursorPositionXLeft;
float cursorPositionXRight; float cursorPositionXRight;
@ -366,34 +365,34 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
Debug.Assert(state.InputText.Length > 0); Debug.Assert(state.InputText.Length > 0);
cursorTextColor = _textSelectedColor; cursorTextColor = _textSelectedColor;
cursorBrush = _selectionBoxBrush; cursorBrush = _selectionBoxBrush;
cursorPen = _selectionBoxPen; cursorPen = _selectionBoxPen;
ReadOnlySpan<char> textUntilBegin = state.InputText.AsSpan(0, state.CursorBegin); ReadOnlySpan<char> textUntilBegin = state.InputText.AsSpan(0, state.CursorBegin);
ReadOnlySpan<char> textUntilEnd = state.InputText.AsSpan(0, state.CursorEnd); ReadOnlySpan<char> textUntilEnd = state.InputText.AsSpan(0, state.CursorEnd);
var selectionBeginRectangle = MeasureString(textUntilBegin, _inputTextFont); var selectionBeginRectangle = MeasureString(textUntilBegin, _inputTextFont);
var selectionEndRectangle = MeasureString(textUntilEnd , _inputTextFont); var selectionEndRectangle = MeasureString(textUntilEnd, _inputTextFont);
cursorVisible = true; cursorVisible = true;
cursorPositionXLeft = inputTextX + selectionBeginRectangle.Width + selectionBeginRectangle.X; cursorPositionXLeft = inputTextX + selectionBeginRectangle.Width + selectionBeginRectangle.X;
cursorPositionXRight = inputTextX + selectionEndRectangle.Width + selectionEndRectangle.X; cursorPositionXRight = inputTextX + selectionEndRectangle.Width + selectionEndRectangle.X;
} }
else else
{ {
cursorTextColor = _textOverCursorColor; cursorTextColor = _textOverCursorColor;
cursorBrush = _cursorBrush; cursorBrush = _cursorBrush;
cursorPen = _cursorPen; cursorPen = _cursorPen;
if (state.TextBoxBlinkCounter < TextBoxBlinkThreshold) if (state.TextBoxBlinkCounter < TextBoxBlinkThreshold)
{ {
// Show the blinking cursor. // Show the blinking cursor.
int cursorBegin = Math.Min(state.InputText.Length, state.CursorBegin); int cursorBegin = Math.Min(state.InputText.Length, state.CursorBegin);
ReadOnlySpan<char> textUntilCursor = state.InputText.AsSpan(0, cursorBegin); ReadOnlySpan<char> textUntilCursor = state.InputText.AsSpan(0, cursorBegin);
var cursorTextRectangle = MeasureString(textUntilCursor, _inputTextFont); var cursorTextRectangle = MeasureString(textUntilCursor, _inputTextFont);
cursorVisible = true; cursorVisible = true;
cursorPositionXLeft = inputTextX + cursorTextRectangle.Width + cursorTextRectangle.X; cursorPositionXLeft = inputTextX + cursorTextRectangle.Width + cursorTextRectangle.X;
if (state.OverwriteMode) if (state.OverwriteMode)
@ -402,8 +401,8 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
if (state.CursorBegin < state.InputText.Length) if (state.CursorBegin < state.InputText.Length)
{ {
textUntilCursor = state.InputText.AsSpan(0, cursorBegin + 1); textUntilCursor = state.InputText.AsSpan(0, cursorBegin + 1);
cursorTextRectangle = MeasureString(textUntilCursor, _inputTextFont); cursorTextRectangle = MeasureString(textUntilCursor, _inputTextFont);
cursorPositionXRight = inputTextX + cursorTextRectangle.Width + cursorTextRectangle.X; cursorPositionXRight = inputTextX + cursorTextRectangle.Width + cursorTextRectangle.X;
} }
else else
@ -419,20 +418,19 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
} }
else else
{ {
cursorPositionXLeft = inputTextX; cursorPositionXLeft = inputTextX;
cursorPositionXRight = inputTextX; cursorPositionXRight = inputTextX;
} }
} }
if (state.TypingEnabled && cursorVisible) if (state.TypingEnabled && cursorVisible)
{ {
float cursorWidth = cursorPositionXRight - cursorPositionXLeft; float cursorWidth = cursorPositionXRight - cursorPositionXLeft;
float cursorHeight = cursorPositionYBottom - cursorPositionYTop; float cursorHeight = cursorPositionYBottom - cursorPositionYTop;
if (cursorWidth == 0) if (cursorWidth == 0)
{ {
PointF[] points = new PointF[] PointF[] points = {
{
new PointF(cursorPositionXLeft, cursorPositionYTop), new PointF(cursorPositionXLeft, cursorPositionYTop),
new PointF(cursorPositionXLeft, cursorPositionYBottom), new PointF(cursorPositionXLeft, cursorPositionYBottom),
}; };
@ -443,10 +441,10 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
{ {
var cursorRectangle = new RectangleF(cursorPositionXLeft, cursorPositionYTop, cursorWidth, cursorHeight); var cursorRectangle = new RectangleF(cursorPositionXLeft, cursorPositionYTop, cursorWidth, cursorHeight);
context.Draw(cursorPen , cursorRectangle); context.Draw(cursorPen, cursorRectangle);
context.Fill(cursorBrush, cursorRectangle); context.Fill(cursorBrush, cursorRectangle);
Image<Argb32> textOverCursor = new Image<Argb32>((int)cursorRectangle.Width, (int)cursorRectangle.Height); Image<Argb32> textOverCursor = new((int)cursorRectangle.Width, (int)cursorRectangle.Height);
textOverCursor.Mutate(context => textOverCursor.Mutate(context =>
{ {
var textRelativePosition = new PointF(inputTextPosition.X - cursorRectangle.X, inputTextPosition.Y - cursorRectangle.Y); var textRelativePosition = new PointF(inputTextPosition.X - cursorRectangle.X, inputTextPosition.Y - cursorRectangle.Y);
@ -470,9 +468,9 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
{ {
// Use relative positions so we can center the the entire drawing later. // Use relative positions so we can center the the entire drawing later.
float iconX = 0; float iconX = 0;
float iconY = 0; float iconY = 0;
float iconWidth = icon.Width; float iconWidth = icon.Width;
float iconHeight = icon.Height; float iconHeight = icon.Height;
var labelRectangle = MeasureString(label, _labelsTextFont); var labelRectangle = MeasureString(label, _labelsTextFont);
@ -480,18 +478,18 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
float labelPositionX = iconWidth + 8 - labelRectangle.X; float labelPositionX = iconWidth + 8 - labelRectangle.X;
float labelPositionY = 3; float labelPositionY = 3;
float fullWidth = labelPositionX + labelRectangle.Width + labelRectangle.X; float fullWidth = labelPositionX + labelRectangle.Width + labelRectangle.X;
float fullHeight = iconHeight; float fullHeight = iconHeight;
// Convert all relative positions into absolute. // Convert all relative positions into absolute.
float originX = (int)(point.X - fullWidth / 2); float originX = (int)(point.X - fullWidth / 2);
float originY = (int)(point.Y - fullHeight / 2); float originY = (int)(point.Y - fullHeight / 2);
iconX += originX; iconX += originX;
iconY += originY; iconY += originY;
var iconPosition = new Point((int)iconX, (int)iconY); var iconPosition = new Point((int)iconX, (int)iconY);
var labelPosition = new PointF(labelPositionX + originX, labelPositionY + originY); var labelPosition = new PointF(labelPositionX + originX, labelPositionY + originY);
var selectedRectangle = new RectangleF(originX - 2 * _padPressedPenWidth, originY - 2 * _padPressedPenWidth, var selectedRectangle = new RectangleF(originX - 2 * _padPressedPenWidth, originY - 2 * _padPressedPenWidth,
@ -526,7 +524,7 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
// Use relative positions so we can center the the entire drawing later. // Use relative positions so we can center the the entire drawing later.
float keyWidth = _keyModeIcon.Width; float keyWidth = _keyModeIcon.Width;
float keyHeight = _keyModeIcon.Height; float keyHeight = _keyModeIcon.Height;
float labelPositionX = keyWidth + 8 - labelRectangle.X; float labelPositionX = keyWidth + 8 - labelRectangle.X;
@ -535,18 +533,18 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
float keyX = 0; float keyX = 0;
float keyY = (int)((labelPositionY + labelRectangle.Height - keyHeight) / 2); float keyY = (int)((labelPositionY + labelRectangle.Height - keyHeight) / 2);
float fullWidth = labelPositionX + labelRectangle.Width; float fullWidth = labelPositionX + labelRectangle.Width;
float fullHeight = Math.Max(labelPositionY + labelRectangle.Height, keyHeight); float fullHeight = Math.Max(labelPositionY + labelRectangle.Height, keyHeight);
// Convert all relative positions into absolute. // Convert all relative positions into absolute.
float originX = (int)(point.X - fullWidth / 2); float originX = (int)(point.X - fullWidth / 2);
float originY = (int)(point.Y - fullHeight / 2); float originY = (int)(point.Y - fullHeight / 2);
keyX += originX; keyX += originX;
keyY += originY; keyY += originY;
var labelPosition = new PointF(labelPositionX + originX, labelPositionY + originY); var labelPosition = new PointF(labelPositionX + originX, labelPositionY + originY);
var overlayPosition = new Point((int)keyX, (int)keyY); var overlayPosition = new Point((int)keyX, (int)keyY);
context.DrawImage(_keyModeIcon, overlayPosition, 1); context.DrawImage(_keyModeIcon, overlayPosition, 1);

4
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardState.cs
View File

@ -23,6 +23,6 @@
/// <summary> /// <summary>
/// swkbd has completed. /// swkbd has completed.
/// </summary> /// </summary>
Complete Complete,
} }
} }

2
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardUiArgs.cs
View File

@ -13,4 +13,4 @@ namespace Ryujinx.HLE.HOS.Applets
public int StringLengthMin; public int StringLengthMin;
public int StringLengthMax; public int StringLengthMax;
} }
} }

18
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardUiState.cs
View File

@ -7,15 +7,15 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
/// </summary> /// </summary>
internal class SoftwareKeyboardUiState internal class SoftwareKeyboardUiState
{ {
public string InputText = ""; public string InputText = "";
public int CursorBegin = 0; public int CursorBegin = 0;
public int CursorEnd = 0; public int CursorEnd = 0;
public bool AcceptPressed = false; public bool AcceptPressed = false;
public bool CancelPressed = false; public bool CancelPressed = false;
public bool OverwriteMode = false; public bool OverwriteMode = false;
public bool TypingEnabled = true; public bool TypingEnabled = true;
public bool ControllerEnabled = true; public bool ControllerEnabled = true;
public int TextBoxBlinkCounter = 0; public int TextBoxBlinkCounter = 0;
public RenderingSurfaceInfo SurfaceInfo = null; public RenderingSurfaceInfo SurfaceInfo = null;
} }

4
src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/TimedAction.cs
View File

@ -19,8 +19,8 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
public SleepSubstepData(int sleepMilliseconds) public SleepSubstepData(int sleepMilliseconds)
{ {
SleepMilliseconds = Math.Min(sleepMilliseconds, MaxThreadSleep); SleepMilliseconds = Math.Min(sleepMilliseconds, MaxThreadSleep);
SleepCount = sleepMilliseconds / SleepMilliseconds; SleepCount = sleepMilliseconds / SleepMilliseconds;
SleepRemainderMilliseconds = sleepMilliseconds - SleepCount * SleepMilliseconds; SleepRemainderMilliseconds = sleepMilliseconds - SleepCount * SleepMilliseconds;
} }
} }

2
src/Ryujinx.HLE/HOS/ArmProcessContextFactory.cs
View File

@ -96,7 +96,7 @@ namespace Ryujinx.HLE.HOS
break; break;
default: default:
throw new ArgumentOutOfRangeException(); throw new InvalidOperationException($"{nameof(mode)} contains an invalid value: {mode}");
} }
} }

10
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/ArraySubscriptingExpression.cs
View File

@ -4,12 +4,12 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class ArraySubscriptingExpression : BaseNode public class ArraySubscriptingExpression : BaseNode
{ {
private BaseNode _leftNode; private readonly BaseNode _leftNode;
private BaseNode _subscript; private readonly BaseNode _subscript;
public ArraySubscriptingExpression(BaseNode leftNode, BaseNode subscript) : base(NodeType.ArraySubscriptingExpression) public ArraySubscriptingExpression(BaseNode leftNode, BaseNode subscript) : base(NodeType.ArraySubscriptingExpression)
{ {
_leftNode = leftNode; _leftNode = leftNode;
_subscript = subscript; _subscript = subscript;
} }
@ -19,7 +19,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
_leftNode.Print(writer); _leftNode.Print(writer);
writer.Write(")["); writer.Write(")[");
_subscript.Print(writer); _subscript.Print(writer);
writer.Write("]"); writer.Write("]");
} }
} }
} }

16
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/ArrayType.cs
View File

@ -4,19 +4,19 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class ArrayType : BaseNode public class ArrayType : BaseNode
{ {
private BaseNode _base; private readonly BaseNode _base;
private BaseNode _dimensionExpression; private readonly BaseNode _dimensionExpression;
private string _dimensionString; private readonly string _dimensionString;
public ArrayType(BaseNode Base, BaseNode dimensionExpression = null) : base(NodeType.ArrayType) public ArrayType(BaseNode Base, BaseNode dimensionExpression = null) : base(NodeType.ArrayType)
{ {
_base = Base; _base = Base;
_dimensionExpression = dimensionExpression; _dimensionExpression = dimensionExpression;
} }
public ArrayType(BaseNode Base, string dimensionString) : base(NodeType.ArrayType) public ArrayType(BaseNode Base, string dimensionString) : base(NodeType.ArrayType)
{ {
_base = Base; _base = Base;
_dimensionString = dimensionString; _dimensionString = dimensionString;
} }
@ -46,9 +46,9 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
writer.Write(_dimensionString); writer.Write(_dimensionString);
} }
else if (_dimensionExpression != null) else
{ {
_dimensionExpression.Print(writer); _dimensionExpression?.Print(writer);
} }
writer.Write("]"); writer.Write("]");
@ -56,4 +56,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
_base.PrintRight(writer); _base.PrintRight(writer);
} }
} }
} }

8
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/BaseNode.cs
View File

@ -55,7 +55,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
ConversionOperatorType, ConversionOperatorType,
LocalName, LocalName,
CtorVtableSpecialName, CtorVtableSpecialName,
ArrayType ArrayType,
} }
public abstract class BaseNode public abstract class BaseNode
@ -99,15 +99,15 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
return null; return null;
} }
public virtual void PrintRight(TextWriter writer) {} public virtual void PrintRight(TextWriter writer) { }
public override string ToString() public override string ToString()
{ {
StringWriter writer = new StringWriter(); StringWriter writer = new();
Print(writer); Print(writer);
return writer.ToString(); return writer.ToString();
} }
} }
} }

12
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/BinaryExpression.cs
View File

@ -4,14 +4,14 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class BinaryExpression : BaseNode public class BinaryExpression : BaseNode
{ {
private BaseNode _leftPart; private readonly BaseNode _leftPart;
private string _name; private readonly string _name;
private BaseNode _rightPart; private readonly BaseNode _rightPart;
public BinaryExpression(BaseNode leftPart, string name, BaseNode rightPart) : base(NodeType.BinaryExpression) public BinaryExpression(BaseNode leftPart, string name, BaseNode rightPart) : base(NodeType.BinaryExpression)
{ {
_leftPart = leftPart; _leftPart = leftPart;
_name = name; _name = name;
_rightPart = rightPart; _rightPart = rightPart;
} }
@ -38,4 +38,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
} }
} }
} }
} }

10
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/BracedExpression.cs
View File

@ -4,14 +4,14 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class BracedExpression : BaseNode public class BracedExpression : BaseNode
{ {
private BaseNode _element; private readonly BaseNode _element;
private BaseNode _expression; private readonly BaseNode _expression;
private bool _isArrayExpression; private readonly bool _isArrayExpression;
public BracedExpression(BaseNode element, BaseNode expression, bool isArrayExpression) : base(NodeType.BracedExpression) public BracedExpression(BaseNode element, BaseNode expression, bool isArrayExpression) : base(NodeType.BracedExpression)
{ {
_element = element; _element = element;
_expression = expression; _expression = expression;
_isArrayExpression = isArrayExpression; _isArrayExpression = isArrayExpression;
} }

10
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/BracedRangeExpression.cs
View File

@ -4,14 +4,14 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class BracedRangeExpression : BaseNode public class BracedRangeExpression : BaseNode
{ {
private BaseNode _firstNode; private readonly BaseNode _firstNode;
private BaseNode _lastNode; private readonly BaseNode _lastNode;
private BaseNode _expression; private readonly BaseNode _expression;
public BracedRangeExpression(BaseNode firstNode, BaseNode lastNode, BaseNode expression) : base(NodeType.BracedRangeExpression) public BracedRangeExpression(BaseNode firstNode, BaseNode lastNode, BaseNode expression) : base(NodeType.BracedRangeExpression)
{ {
_firstNode = firstNode; _firstNode = firstNode;
_lastNode = lastNode; _lastNode = lastNode;
_expression = expression; _expression = expression;
} }

4
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/CallExpression.cs
View File

@ -5,7 +5,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class CallExpression : NodeArray public class CallExpression : NodeArray
{ {
private BaseNode _callee; private readonly BaseNode _callee;
public CallExpression(BaseNode callee, List<BaseNode> nodes) : base(nodes, NodeType.CallExpression) public CallExpression(BaseNode callee, List<BaseNode> nodes) : base(nodes, NodeType.CallExpression)
{ {
@ -21,4 +21,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
writer.Write(")"); writer.Write(")");
} }
} }
} }

10
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/CastExpression.cs
View File

@ -4,14 +4,14 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class CastExpression : BaseNode public class CastExpression : BaseNode
{ {
private string _kind; private readonly string _kind;
private BaseNode _to; private readonly BaseNode _to;
private BaseNode _from; private readonly BaseNode _from;
public CastExpression(string kind, BaseNode to, BaseNode from) : base(NodeType.CastExpression) public CastExpression(string kind, BaseNode to, BaseNode from) : base(NodeType.CastExpression)
{ {
_kind = kind; _kind = kind;
_to = to; _to = to;
_from = from; _from = from;
} }
@ -25,4 +25,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
writer.Write(")"); writer.Write(")");
} }
} }
} }

12
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/ConditionalExpression.cs
View File

@ -4,15 +4,15 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class ConditionalExpression : BaseNode public class ConditionalExpression : BaseNode
{ {
private BaseNode _thenNode; private readonly BaseNode _thenNode;
private BaseNode _elseNode; private readonly BaseNode _elseNode;
private BaseNode _conditionNode; private readonly BaseNode _conditionNode;
public ConditionalExpression(BaseNode conditionNode, BaseNode thenNode, BaseNode elseNode) : base(NodeType.ConditionalExpression) public ConditionalExpression(BaseNode conditionNode, BaseNode thenNode, BaseNode elseNode) : base(NodeType.ConditionalExpression)
{ {
_thenNode = thenNode; _thenNode = thenNode;
_conditionNode = conditionNode; _conditionNode = conditionNode;
_elseNode = elseNode; _elseNode = elseNode;
} }
public override void PrintLeft(TextWriter writer) public override void PrintLeft(TextWriter writer)
@ -26,4 +26,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
writer.Write(")"); writer.Write(")");
} }
} }
} }

8
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/ConversionExpression.cs
View File

@ -4,12 +4,12 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class ConversionExpression : BaseNode public class ConversionExpression : BaseNode
{ {
private BaseNode _typeNode; private readonly BaseNode _typeNode;
private BaseNode _expressions; private readonly BaseNode _expressions;
public ConversionExpression(BaseNode typeNode, BaseNode expressions) : base(NodeType.ConversionExpression) public ConversionExpression(BaseNode typeNode, BaseNode expressions) : base(NodeType.ConversionExpression)
{ {
_typeNode = typeNode; _typeNode = typeNode;
_expressions = expressions; _expressions = expressions;
} }
@ -21,4 +21,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
_expressions.Print(writer); _expressions.Print(writer);
} }
} }
} }

2
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/ConversionOperatorType.cs
View File

@ -12,4 +12,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
Child.Print(writer); Child.Print(writer);
} }
} }
} }

4
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/CtorDtorNameType.cs
View File

@ -4,7 +4,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class CtorDtorNameType : ParentNode public class CtorDtorNameType : ParentNode
{ {
private bool _isDestructor; private readonly bool _isDestructor;
public CtorDtorNameType(BaseNode name, bool isDestructor) : base(NodeType.CtorDtorNameType, name) public CtorDtorNameType(BaseNode name, bool isDestructor) : base(NodeType.CtorDtorNameType, name)
{ {
@ -21,4 +21,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
writer.Write(Child.GetName()); writer.Write(Child.GetName());
} }
} }
} }

8
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/CtorVtableSpecialName.cs
View File

@ -4,12 +4,12 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class CtorVtableSpecialName : BaseNode public class CtorVtableSpecialName : BaseNode
{ {
private BaseNode _firstType; private readonly BaseNode _firstType;
private BaseNode _secondType; private readonly BaseNode _secondType;
public CtorVtableSpecialName(BaseNode firstType, BaseNode secondType) : base(NodeType.CtorVtableSpecialName) public CtorVtableSpecialName(BaseNode firstType, BaseNode secondType) : base(NodeType.CtorVtableSpecialName)
{ {
_firstType = firstType; _firstType = firstType;
_secondType = secondType; _secondType = secondType;
} }
@ -21,4 +21,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
_secondType.Print(writer); _secondType.Print(writer);
} }
} }
} }

8
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/DeleteExpression.cs
View File

@ -4,12 +4,12 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class DeleteExpression : ParentNode public class DeleteExpression : ParentNode
{ {
private bool _isGlobal; private readonly bool _isGlobal;
private bool _isArrayExpression; private readonly bool _isArrayExpression;
public DeleteExpression(BaseNode child, bool isGlobal, bool isArrayExpression) : base(NodeType.DeleteExpression, child) public DeleteExpression(BaseNode child, bool isGlobal, bool isArrayExpression) : base(NodeType.DeleteExpression, child)
{ {
_isGlobal = isGlobal; _isGlobal = isGlobal;
_isArrayExpression = isArrayExpression; _isArrayExpression = isArrayExpression;
} }
@ -30,4 +30,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
Child.Print(writer); Child.Print(writer);
} }
} }
} }

2
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/DtorName.cs
View File

@ -12,4 +12,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
Child.PrintLeft(writer); Child.PrintLeft(writer);
} }
} }
} }

2
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/DynamicExceptionSpec.cs
View File

@ -13,4 +13,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
writer.Write(")"); writer.Write(")");
} }
} }
} }

4
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/ElaboratedType.cs
View File

@ -4,7 +4,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class ElaboratedType : ParentNode public class ElaboratedType : ParentNode
{ {
private string _elaborated; private readonly string _elaborated;
public ElaboratedType(string elaborated, BaseNode type) : base(NodeType.ElaboratedType, type) public ElaboratedType(string elaborated, BaseNode type) : base(NodeType.ElaboratedType, type)
{ {
@ -18,4 +18,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
Child.Print(writer); Child.Print(writer);
} }
} }
} }

12
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/EnclosedExpression.cs
View File

@ -4,15 +4,15 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class EnclosedExpression : BaseNode public class EnclosedExpression : BaseNode
{ {
private string _prefix; private readonly string _prefix;
private BaseNode _expression; private readonly BaseNode _expression;
private string _postfix; private readonly string _postfix;
public EnclosedExpression(string prefix, BaseNode expression, string postfix) : base(NodeType.EnclosedExpression) public EnclosedExpression(string prefix, BaseNode expression, string postfix) : base(NodeType.EnclosedExpression)
{ {
_prefix = prefix; _prefix = prefix;
_expression = expression; _expression = expression;
_postfix = postfix; _postfix = postfix;
} }
public override void PrintLeft(TextWriter writer) public override void PrintLeft(TextWriter writer)
@ -22,4 +22,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
writer.Write(_postfix); writer.Write(_postfix);
} }
} }
} }

55
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/EncodedFunction.cs
View File

@ -4,21 +4,21 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class EncodedFunction : BaseNode public class EncodedFunction : BaseNode
{ {
private BaseNode _name; private readonly BaseNode _name;
private BaseNode _params; private readonly BaseNode _params;
private BaseNode _cv; private readonly BaseNode _cv;
private BaseNode _ref; private readonly BaseNode _ref;
private BaseNode _attrs; private readonly BaseNode _attrs;
private BaseNode _ret; private readonly BaseNode _ret;
public EncodedFunction(BaseNode name, BaseNode Params, BaseNode cv, BaseNode Ref, BaseNode attrs, BaseNode ret) : base(NodeType.NameType) public EncodedFunction(BaseNode name, BaseNode Params, BaseNode cv, BaseNode Ref, BaseNode attrs, BaseNode ret) : base(NodeType.NameType)
{ {
_name = name; _name = name;
_params = Params; _params = Params;
_cv = cv; _cv = cv;
_ref = Ref; _ref = Ref;
_attrs = attrs; _attrs = attrs;
_ret = ret; _ret = ret;
} }
public override void PrintLeft(TextWriter writer) public override void PrintLeft(TextWriter writer)
@ -45,33 +45,12 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
public override void PrintRight(TextWriter writer) public override void PrintRight(TextWriter writer)
{ {
writer.Write("("); writer.Write("(");
_params?.Print(writer);
if (_params != null)
{
_params.Print(writer);
}
writer.Write(")"); writer.Write(")");
_ret?.PrintRight(writer);
if (_ret != null) _cv?.Print(writer);
{ _ref?.Print(writer);
_ret.PrintRight(writer); _attrs?.Print(writer);
}
if (_cv != null)
{
_cv.Print(writer);
}
if (_ref != null)
{
_ref.Print(writer);
}
if (_attrs != null)
{
_attrs.Print(writer);
}
} }
} }
} }

16
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/FoldExpression.cs
View File

@ -4,17 +4,17 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class FoldExpression : BaseNode public class FoldExpression : BaseNode
{ {
private bool _isLeftFold; private readonly bool _isLeftFold;
private string _operatorName; private readonly string _operatorName;
private BaseNode _expression; private readonly BaseNode _expression;
private BaseNode _initializer; private readonly BaseNode _initializer;
public FoldExpression(bool isLeftFold, string operatorName, BaseNode expression, BaseNode initializer) : base(NodeType.FunctionParameter) public FoldExpression(bool isLeftFold, string operatorName, BaseNode expression, BaseNode initializer) : base(NodeType.FunctionParameter)
{ {
_isLeftFold = isLeftFold; _isLeftFold = isLeftFold;
_operatorName = operatorName; _operatorName = operatorName;
_expression = expression; _expression = expression;
_initializer = initializer; _initializer = initializer;
} }
public override void PrintLeft(TextWriter writer) public override void PrintLeft(TextWriter writer)
@ -45,4 +45,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
writer.Write(")"); writer.Write(")");
} }
} }
} }

4
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/ForwardTemplateReference.cs
View File

@ -6,7 +6,9 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
// TODO: Compute inside the Demangler // TODO: Compute inside the Demangler
public BaseNode Reference; public BaseNode Reference;
private int _index; #pragma warning disable IDE0052 // Remove unread private member
private readonly int _index;
#pragma warning restore IDE0052
public ForwardTemplateReference(int index) : base(NodeType.ForwardTemplateReference) public ForwardTemplateReference(int index) : base(NodeType.ForwardTemplateReference)
{ {

4
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/FunctionParameter.cs
View File

@ -4,7 +4,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class FunctionParameter : BaseNode public class FunctionParameter : BaseNode
{ {
private string _number; private readonly string _number;
public FunctionParameter(string number) : base(NodeType.FunctionParameter) public FunctionParameter(string number) : base(NodeType.FunctionParameter)
{ {
@ -21,4 +21,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
} }
} }
} }
} }

20
src/Ryujinx.HLE/HOS/Diagnostics/Demangler/Ast/FunctionType.cs
View File

@ -4,19 +4,19 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
{ {
public class FunctionType : BaseNode public class FunctionType : BaseNode
{ {
private BaseNode _returnType; private readonly BaseNode _returnType;
private BaseNode _params; private readonly BaseNode _params;
private BaseNode _cvQualifier; private readonly BaseNode _cvQualifier;
private SimpleReferenceType _referenceQualifier; private readonly SimpleReferenceType _referenceQualifier;
private BaseNode _exceptionSpec; private readonly BaseNode _exceptionSpec;
public FunctionType(BaseNode returnType, BaseNode Params, BaseNode cvQualifier, SimpleReferenceType referenceQualifier, BaseNode exceptionSpec) : base(NodeType.FunctionType) public FunctionType(BaseNode returnType, BaseNode Params, BaseNode cvQualifier, SimpleReferenceType referenceQualifier, BaseNode exceptionSpec) : base(NodeType.FunctionType)
{ {
_returnType = returnType; _returnType = returnType;
_params = Params; _params = Params;
_cvQualifier = cvQualifier; _cvQualifier = cvQualifier;
_referenceQualifier = referenceQualifier; _referenceQualifier = referenceQualifier;
_exceptionSpec = exceptionSpec; _exceptionSpec = exceptionSpec;
} }
public override void PrintLeft(TextWriter writer) public override void PrintLeft(TextWriter writer)
@ -58,4 +58,4 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler.Ast
return true; return true;
} }
} }
} }

Some files were not shown because too many files have changed in this diff Show More