using Ryujinx.HLE.HOS.SystemState;

using Ryujinx.Input;

using Ryujinx.Input.HLE;

using Ryujinx.Ui.Common;

using Ryujinx.Ui.Common.Configuration;

using Ryujinx.Ui.Common.Helper;

DiscordIntegrationModule.SwitchToPlayingState(Device.Processes.ActiveApplication.ProgramIdText, Device.Processes.ActiveApplication.Name);

{

appMetadata.LastPlayed = DateTime.UtcNow;

});

{

viewModel.SelectedApplication.Favorite = !viewModel.SelectedApplication.Favorite;

{

appMetadata.Favorite = viewModel.SelectedApplication.Favorite;

});

using Ryujinx.Ava.UI.ViewModels;

using Ryujinx.Ava.UI.Windows;

using Ryujinx.HLE.FileSystem;

using System;

using System.IO;

using System.Linq;

}

else

{

Title = appMetadata.Title ?? TitleIdString;

}

IPlatformHandle CreateMacOS()

{

// Create a new CAMetalLayer.

// Create a child NSView to render into.

// Make its renderer our metal layer.

// Ensure the scale factor is up to date.

_updateBoundsCallback = rect =>

{

};

NsView = nsView;

return new PlatformHandle(nsView, "NSView");

{

public ApplicationData AppData { get; set; }

}

{

public class ApplicationCountUpdatedEventArgs : EventArgs

{

public int NumAppsLoaded { get; set; }

}

{

public class ApplicationData

{

public BlitStruct<ApplicationControlProperty> ControlHolder { get; set; }

[JsonIgnore]

codeFs.OpenFile(ref nsoFile.Ref, $"/{MainExeFs}".ToU8Span(), OpenMode.Read).ThrowIfFailure();

reader.Initialize(nsoFile.Release().AsStorage().AsFile(OpenMode.Read)).ThrowIfFailure();

return BitConverter.ToString(reader.Header.ModuleId.ItemsRo.ToArray()).Replace("-", "").ToUpper()[..16];

internal partial class ApplicationJsonSerializerContext : JsonSerializerContext

{

}

using System.Text.Json;

using System.Threading;

using Path = System.IO.Path;

namespace Ryujinx.Ui.App.Common

{

public class ApplicationLibrary

{

public event EventHandler<ApplicationCountUpdatedEventArgs> ApplicationCountUpdated;

private readonly byte[] _nspIcon;

private readonly byte[] _nsoIcon;

private readonly VirtualFileSystem _virtualFileSystem;

public ApplicationLibrary(VirtualFileSystem virtualFileSystem)

{

private static byte[] GetResourceBytes(string resourceName)

{

byte[] resourceByteArray = new byte[resourceStream.Length];

resourceStream.Read(resourceByteArray);

public void LoadApplications(List<string> appDirs, Language desiredTitleLanguage)

{

int numApplicationsLoaded = 0;

_desiredTitleLanguage = desiredTitleLanguage;

IEnumerable<string> files = Directory.EnumerateFiles(appDir, "*", SearchOption.AllDirectories).Where(file =>

{

return

(Path.GetExtension(file).ToLower() is ".pfs0" && ConfigurationState.Instance.Ui.ShownFileTypes.PFS0.Value) ||

});

foreach (string app in files)

{

if (_cancellationToken.Token.IsCancellationRequested)

FileSize = (fileSize < 1) ? (fileSize * 1024).ToString("0.##") + " MiB" : fileSize.ToString("0.##") + " GiB",

FileSizeBytes = fileSize,

Path = applicationPath,

};

numApplicationsLoaded++;

{

});

{

NumAppsFound = numApplicationsFound,

});

}

{

NumAppsFound = numApplicationsFound,

});

}

finally

// Return the ControlFS

controlFs = controlNca?.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.None);

}

{

string metadataFolder = Path.Combine(AppDataManager.GamesDirPath, titleId, "gui");

ApplicationMetadata appMetadata;

appMetadata = new ApplicationMetadata();

}

try

{

}

catch (JsonException)

{

{

modifyFunction(appMetadata);

}

return appMetadata;

}

}

}

{

Logger.Warning?.Print(LogClass.Application, $"Could not retrieve a valid icon for the app. Default icon will be used. Errored File: {applicationPath}");

}

private static string ConvertSecondsToFormattedString(double seconds)

{

string timeString;

if (time.Days != 0)

pfs.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();

int ncaProgramIndex = (int)(nca.Header.TitleId & 0xF);

pfs.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();

int ncaProgramIndex = (int)(nca.Header.TitleId & 0xF);

if (File.Exists(titleUpdateMetadataPath))

{

if (File.Exists(updatePath))

{

return GetGameUpdateDataFromPartition(fileSystem, nsp, titleIdBase.ToString("x16"), programIndex);

}

}

}

}

public class ApplicationMetadata

{

public string Title { get; set; }

public double TimePlayed { get; set; }

[JsonPropertyName("last_played_utc")]

[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]

public string LastPlayedOld { get; set; }

}

Dummy,

OpenAl,

SoundIo,

}

JsonHelper.SerializeToFile(path, this, ConfigurationFileFormatSettings.SerializerContext.ConfigurationFileFormat);

}

}

{

public static readonly ConfigurationJsonSerializerContext SerializerContext = new(JsonHelper.GetDefaultSerializerOptions());

}

internal partial class ConfigurationJsonSerializerContext : JsonSerializerContext

{

}

{

Success = 0,

NotLoaded = 1,

}

{

public class Columns

{

public ReactiveObject<bool> TimePlayedColumn { get; private set; }

public ReactiveObject<bool> LastPlayedColumn { get; private set; }

public Columns()

{

TimePlayedColumn = new ReactiveObject<bool>();

LastPlayedColumn = new ReactiveObject<bool>();

}

}

public class ColumnSortSettings

{

public ReactiveObject<bool> SortAscending { get; private set; }

public ColumnSortSettings()

{

SortAscending = new ReactiveObject<bool>();

}

}

public ShownFileTypeSettings()

{

PFS0 = new ReactiveObject<bool>();

}

}

public UiSection()

{

EnableCustomTheme = new ReactiveObject<bool>();

ShowConsole.Event += static (s, e) => { ConsoleHelper.SetConsoleWindowState(e.NewValue); };

}

}

public LoggerSection()

{

}

}

public SystemSection()

{

}

}

public HidSection()

{

EnableKeyboard = new ReactiveObject<bool>();

}

}

public GraphicsSection()

{

}

}

private ConfigurationState()

{

EnableDiscordIntegration = new ReactiveObject<bool>();

}

public ConfigurationFileFormat ToFileFormat()

{

{

EnableTextureRecompression = Graphics.EnableTextureRecompression,

{

TimePlayedColumn = Ui.GuiColumns.TimePlayedColumn,

LastPlayedColumn = Ui.GuiColumns.LastPlayedColumn,

},

{

},

{

NSP = Ui.ShownFileTypes.NSP,

PFS0 = Ui.ShownFileTypes.PFS0,

NRO = Ui.ShownFileTypes.NRO,

NSO = Ui.ShownFileTypes.NSO,

},

{

WindowSizeWidth = Ui.WindowStartup.WindowSizeWidth,

WindowSizeHeight = Ui.WindowStartup.WindowSizeHeight,

WindowPositionY = Ui.WindowStartup.WindowPositionY,

WindowMaximized = Ui.WindowStartup.WindowMaximized,

},

};

return configurationFile;

public void LoadDefault()

{

Graphics.EnableTextureRecompression.Value = false;

Hid.Hotkeys.Value = new KeyboardHotkeys

{

ToggleVsync = Key.F1,

ResScaleUp = Key.Unbound,

ResScaleDown = Key.Unbound,

VolumeUp = Key.Unbound,

};

Hid.InputConfig.Value = new List<InputConfig>

{

};

}

configurationFileFormat.ColumnSort = new ColumnSort

{

};

configurationFileFormat.Hotkeys = new KeyboardHotkeys

{

};

configurationFileUpdated = true;

configurationFileFormat.InputConfig = new List<InputConfig>

{

};

configurationFileUpdated = true;

configurationFileFormat.Hotkeys = new KeyboardHotkeys

{

ToggleVsync = Key.F1,

};

configurationFileUpdated = true;

{

ToggleVsync = Key.F1,

Screenshot = Key.F8,

};

configurationFileUpdated = true;

{

Ryujinx.Common.Logging.Logger.Warning?.Print(LogClass.Application, $"Outdated configuration version {configurationFileFormat.Version}, migrating to version 30.");

{

if (config is StandardControllerInputConfig controllerConfig)

{

{

EnableRumble = false,

StrongRumble = 1f,

};

}

}

ToggleVsync = configurationFileFormat.Hotkeys.ToggleVsync,

Screenshot = configurationFileFormat.Hotkeys.Screenshot,

ShowUi = configurationFileFormat.Hotkeys.ShowUi,

};

configurationFileUpdated = true;

Screenshot = configurationFileFormat.Hotkeys.Screenshot,

ShowUi = configurationFileFormat.Hotkeys.ShowUi,

Pause = configurationFileFormat.Hotkeys.Pause,

};

configurationFileFormat.AudioVolume = 1;

{

if (config is StandardControllerInputConfig controllerConfig)

{

controllerConfig.RangeRight = 1.0f;

}

}

{

Ryujinx.Common.Logging.Logger.Warning?.Print(LogClass.Application, $"Outdated configuration version {configurationFileFormat.Version}, migrating to version 38.");

configurationFileFormat.GameListViewMode = 0;

configurationFileUpdated = true;

}

Pause = configurationFileFormat.Hotkeys.Pause,

ToggleMute = configurationFileFormat.Hotkeys.ToggleMute,

ResScaleUp = Key.Unbound,

};

configurationFileUpdated = true;

ResScaleUp = configurationFileFormat.Hotkeys.ResScaleUp,

ResScaleDown = configurationFileFormat.Hotkeys.ResScaleDown,

VolumeUp = Key.Unbound,

};

}

configurationFileFormat.ShownFileTypes = new ShownFileTypes

{

PFS0 = true,

};

configurationFileUpdated = true;

WindowSizeWidth = 1280,

WindowMaximized = false,

};

configurationFileUpdated = true;

}

Graphics.EnableTextureRecompression.Value = configurationFileFormat.EnableTextureRecompression;

if (Hid.InputConfig.Value == null)

{

return result;

}

{

Ryujinx.Common.Logging.Logger.Info?.Print(LogClass.Configuration, $"{valueName} set to: {eventArgs.NewValue}");

}

{

public static void Initialize()

{

ConfigurationState.Instance.Logger.EnableFsAccessLog.Event += ReloadEnableFsAccessLog;

}

private static void ReloadEnableDebug(object sender, ReactiveEventArgs<bool> e)

LatinAmericanSpanish,

SimplifiedChinese,

TraditionalChinese,

}

}

Australia,

China,

Korea,

}

}

{

public struct ColumnSort

{

public bool SortAscending { get; set; }

}

{

public struct GuiColumns

{

public bool TimePlayedColumn { get; set; }

public bool LastPlayedColumn { get; set; }

}

}

{

public struct ShownFileTypes

{

public bool PFS0 { get; set; }

}

}

public static class DiscordIntegrationModule

{

private const string Description = "A simple, experimental Nintendo Switch emulator.";

private static DiscordRpcClient _discordClient;

public static void Initialize()

{

{

Assets = new Assets

{

},

Timestamps = Timestamps.Now,

{

};

ConfigurationState.Instance.EnableDiscordIntegration.Event += Update;

{

Assets = new Assets

{

LargeImageText = titleName,

SmallImageText = Description,

},

Timestamps = Timestamps.Now,

{

{

Label = "Website",

});

}

_discordClient?.Dispose();

}

}

FileTypes.NCA => config.NCA.Value,

FileTypes.NRO => config.NRO.Value,

FileTypes.NSO => config.NSO.Value,

};

}

}

{

public static string[] Arguments { get; private set; }

public static string OverrideGraphicsBackend { get; private set; }

public static void ParseArguments(string[] args)

{

Arguments = arguments.ToArray();

}

}

[return: MarshalAs(UnmanagedType.Bool)]

private static partial bool ShowWindow(IntPtr hWnd, int nCmdShow);

}

private static readonly string _mimeDbPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".local", "share", "mime");

private const int SHCNE_ASSOCCHANGED = 0x8000000;

[LibraryImport("shell32.dll", SetLastError = true)]

public static partial void SHChangeNotify(uint wEventId, uint uFlags, IntPtr dwItem1, IntPtr dwItem2);

return false;

}

}

StartInfo =

{

FileName = PkExecPath,

};

process.Start();

return process.ExitCode;

}

}

using System;

using System.Runtime.InteropServices;

using System.Runtime.Versioning;

namespace Ryujinx.Ui.Common.Helper

{

private const string ObjCRuntime = "/usr/lib/libobjc.A.dylib";

[LibraryImport(ObjCRuntime, StringMarshalling = StringMarshalling.Utf8)]

[LibraryImport(ObjCRuntime, StringMarshalling = StringMarshalling.Utf8)]

[LibraryImport(ObjCRuntime)]

[LibraryImport(ObjCRuntime)]

[LibraryImport(ObjCRuntime)]

[LibraryImport(ObjCRuntime)]

[LibraryImport(ObjCRuntime)]

[LibraryImport(ObjCRuntime, EntryPoint = "objc_msgSend")]

[LibraryImport(ObjCRuntime, EntryPoint = "objc_msgSend")]

[LibraryImport(ObjCRuntime, EntryPoint = "objc_msgSend", StringMarshalling = StringMarshalling.Utf8)]

[LibraryImport(ObjCRuntime, EntryPoint = "objc_msgSend")]

[return: MarshalAs(UnmanagedType.Bool)]

{

public readonly IntPtr SelPtr;

{

SelPtr = sel_getUid(name);

}

public static implicit operator Selector(string value) => new(value);

}

{

public readonly IntPtr StrPtr;

}

}

}

public static partial class OpenHelper

{

[LibraryImport("shell32.dll", SetLastError = true)]

[LibraryImport("shell32.dll", SetLastError = true)]

[LibraryImport("shell32.dll", SetLastError = true)]

public static void OpenFolder(string path)

{

{

Process.Start(new ProcessStartInfo

{

UseShellExecute = true,

});

}

else

else if (OperatingSystem.IsMacOS())

{

ObjectiveC.NSString nsStringPath = new(path);

}

else if (OperatingSystem.IsLinux())

{

else if (OperatingSystem.IsMacOS())

{

ObjectiveC.NSString nsStringPath = new(url);

}

else

{

}

}

}

return true;

}

}

public static bool CanFixStartApplication(ContentManager contentManager, string baseApplicationPath, UserError error, out SystemVersion firmwareVersion)

return IsFirmwareValid(contentManager, out error);

}

}

}

}

[JsonPropertyName("gamesSwitch")]

public List<AmiiboApiGamesSwitch> GamesSwitch { get; set; }

{

return Name;

}

{

return Head + Tail;

}

{

return Head + Tail == other.Head + other.Tail;

}

{

return obj is AmiiboApi other && Equals(other);

}

{

return HashCode.Combine(Head, Tail);

}

}

[JsonPropertyName("gameName")]

public string GameName { get; set; }

}

[JsonPropertyName("write")]

public bool Write { get; set; }

}

[JsonPropertyName("lastUpdated")]

public DateTime LastUpdated { get; set; }

}

public partial class AmiiboJsonSerializerContext : JsonSerializerContext

{

}

public string State { get; set; }

public string BrowserDownloadUrl { get; set; }

}

public string Name { get; set; }

public List<GithubReleaseAssetJsonResponse> Assets { get; set; }

}

public partial class GithubReleasesJsonSerializerContext : JsonSerializerContext

{

}

/// <summary>

/// An unknown error.

/// </summary>

}

DiscordIntegrationModule.SwitchToPlayingState(_emulationContext.Processes.ActiveApplication.ProgramIdText,

_emulationContext.Processes.ActiveApplication.ApplicationControlProperties.Title[(int)_emulationContext.System.State.DesiredTitleLanguage].NameString.ToString());

{

appMetadata.LastPlayed = DateTime.UtcNow;

});

{

if (_gameLoaded)

{

{

if (appMetadata.LastPlayed.HasValue)

{

_tableStore.SetValue(treeIter, 0, newToggleValue);

{

appMetadata.Favorite = newToggleValue;

});

{

if (!_gameLoaded || !ConfigurationState.Instance.ShowConfirmExit || GtkDialog.CreateExitDialog())

{

End();

}

else

Move(ConfigurationState.Instance.Ui.WindowStartup.WindowPositionX, ConfigurationState.Instance.Ui.WindowStartup.WindowPositionY);

}

}

ConfigurationState.Instance.Ui.WindowStartup.WindowPositionX.Value = windowXPos;

ConfigurationState.Instance.Ui.WindowStartup.WindowPositionY.Value = windowYPos;

}

private void StopEmulation_Pressed(object sender, EventArgs args)

_virtualFileSystem,

_emulationContext.Processes.ActiveApplication.ProgramId,

_emulationContext.Processes.ActiveApplication.ApplicationControlProperties

_currentEmulatedGamePath);

window.Destroyed += CheatWindow_Destroyed;

UpdateGameTable();

}

}