using ARMeilleure.Translation;

using Avalonia.Input;

using Avalonia.Threading;

using LibHac.Tools.FsSystem;

using Ryujinx.Ava.UI.Controls;

using Ryujinx.Ava.UI.Helpers;

using Ryujinx.Ava.UI.Models;

using Ryujinx.Ava.UI.Windows;

using Ryujinx.Common;

using Ryujinx.Common.Configuration;

using System.IO;

using System.Threading;

using System.Threading.Tasks;

using InputManager = Ryujinx.Input.HLE.InputManager;

using Key = Ryujinx.Input.Key;

using MouseButton = Ryujinx.Input.MouseButton;

private readonly AccountManager _accountManager;

private readonly UserChannelPersistence _userChannelPersistence;

private readonly InputManager _inputManager;

private readonly IKeyboard _keyboardInterface;

private readonly GraphicsDebugLevel _glLogLevel;

public bool ScreenshotRequested { get; set; }

private object _lockObject = new();

public AppHost(

RendererHost renderer,

ContentManager contentManager,

AccountManager accountManager,

UserChannelPersistence userChannelPersistence,

{

_inputManager = inputManager;

_accountManager = accountManager;

_userChannelPersistence = userChannelPersistence;

_hideCursorOnIdle = ConfigurationState.Instance.HideCursorOnIdle;

_lastCursorMoveTime = Stopwatch.GetTimestamp();

_glLogLevel = ConfigurationState.Instance.Logger.GraphicsDebugLevel;

_keyboardInterface = (IKeyboard)_inputManager.KeyboardDriver.GetGamepad("0");

NpadManager = _inputManager.CreateNpadManager();

if (ApplicationPath.StartsWith("@SystemContent"))

{

_isFirmwareTitle = true;

}

ConfigurationState.Instance.HideCursorOnIdle.Event += HideCursorState_Changed;

ConfigurationState.Instance.System.IgnoreMissingServices.Event += UpdateIgnoreMissingServicesState;

ConfigurationState.Instance.Graphics.AspectRatio.Event += UpdateAspectRatioState;

_gpuCancellationTokenSource = new CancellationTokenSource();

}

{

}

{

_isMouseInRenderer = false;

}

private void SetRendererWindowSize(Size size)

{

if (_renderer != null)

{

_renderer.Window?.SetSize((int)(size.Width * scale), (int)(size.Height * scale));

}

}

NpadManager.Initialize(Device, ConfigurationState.Instance.Hid.InputConfig, ConfigurationState.Instance.Hid.EnableKeyboard, ConfigurationState.Instance.Hid.EnableMouse);

TouchScreenManager.Initialize(Device);

string titleNameSection = string.IsNullOrWhiteSpace(Device.Application.TitleName)

? string.Empty

Dispatcher.UIThread.InvokeAsync(() =>

{

});

Renderer.SizeChanged += Window_SizeChanged;

_renderingThread.Start();

MainLoop();

Dispatcher.UIThread.Post(() =>

{

var value = e.NewValue;

});

}

{

if (Device.Application != null)

{

}

ConfigurationState.Instance.System.IgnoreMissingServices.Event -= UpdateIgnoreMissingServicesState;

ConfigurationState.Instance.System.EnableDockedMode.Event -= UpdateDockedModeState;

ConfigurationState.Instance.System.AudioVolume.Event -= UpdateAudioVolumeState;

_gpuCancellationTokenSource.Cancel();

_gpuCancellationTokenSource.Dispose();

}

else

{

}

});

}

SystemVersion firmwareVersion = ContentManager.GetCurrentFirmwareVersion();

{

{

{

{

}

}

}

Logger.Notice.Print(LogClass.Application, $"Using Firmware Version: {firmwareVersion?.VersionString}");

DiscordIntegrationModule.SwitchToPlayingState(Device.Application.TitleIdText, Device.Application.TitleName);

{

appMetadata.LastPlayed = DateTime.UtcNow.ToString();

});

internal void Resume()

{

Device?.System.TogglePauseEmulation(false);

}

internal void Pause()

{

Device?.System.TogglePauseEmulation(true);

}

private void InitializeSwitchInstance()

Logger.Warning?.Print(LogClass.Audio, "Found OpenAL, changing configuration.");

ConfigurationState.Instance.System.AudioBackend.Value = AudioBackend.OpenAl;

deviceDriver = new OpenALHardwareDeviceDriver();

}

Logger.Warning?.Print(LogClass.Audio, "Found SoundIO, changing configuration.");

ConfigurationState.Instance.System.AudioBackend.Value = AudioBackend.SoundIo;

deviceDriver = new SoundIoHardwareDeviceDriver();

}

Logger.Warning?.Print(LogClass.Audio, "Found SDL2, changing configuration.");

ConfigurationState.Instance.System.AudioBackend.Value = AudioBackend.SDL2;

deviceDriver = new SDL2HardwareDeviceDriver();

}

Logger.Warning?.Print(LogClass.Audio, "Found OpenAL, changing configuration.");

ConfigurationState.Instance.System.AudioBackend.Value = AudioBackend.OpenAl;

deviceDriver = new OpenALHardwareDeviceDriver();

}

Logger.Warning?.Print(LogClass.Audio, "Found SDL2, changing configuration.");

ConfigurationState.Instance.System.AudioBackend.Value = AudioBackend.SDL2;

deviceDriver = new SDL2HardwareDeviceDriver();

}

Logger.Warning?.Print(LogClass.Audio, "Found SoundIO, changing configuration.");

ConfigurationState.Instance.System.AudioBackend.Value = AudioBackend.SoundIo;

deviceDriver = new SoundIoHardwareDeviceDriver();

}

IntegrityCheckLevel fsIntegrityCheckLevel = ConfigurationState.Instance.System.EnableFsIntegrityChecks ? IntegrityCheckLevel.ErrorOnInvalid : IntegrityCheckLevel.None;

HLE.HLEConfiguration configuration = new HLE.HLEConfiguration(VirtualFileSystem,

ContentManager,

_accountManager,

_userChannelPersistence,

renderer,

deviceDriver,

memoryConfiguration,

(SystemLanguage)ConfigurationState.Instance.System.Language.Value,

(RegionCode)ConfigurationState.Instance.System.Region.Value,

ConfigurationState.Instance.Graphics.EnableVsync,

{

Dispatcher.UIThread.InvokeAsync(() =>

{

{

}

{

}

});

Width = (int)Renderer.Bounds.Width;

Height = (int)Renderer.Bounds.Height;

_chrono.Start();

if (!_renderingStarted)

{

_renderingStarted = true;

}

Device.PresentFrame(() => Renderer?.SwapBuffers());

{

Dispatcher.UIThread.Post(() =>

{

});

}

else

Dispatcher.UIThread.Post(() =>

{

});

}

}

return false;

}

{

Dispatcher.UIThread.Post(() =>

{

HandleScreenState();

{

Device.Application.DiskCacheLoadState?.Cancel();

}

NpadManager.Update(ConfigurationState.Instance.Graphics.AspectRatio.Value.ToFloat());

{

KeyboardHotkeyState currentHotkeyState = GetHotkeyState();

ScreenshotRequested = true;

break;

case KeyboardHotkeyState.ShowUi:

break;

case KeyboardHotkeyState.Pause:

{

Resume();

}

Device.SetVolume(0);

}

break;

case KeyboardHotkeyState.ResScaleUp:

GraphicsConfig.ResScale = GraphicsConfig.ResScale % MaxResolutionScale + 1;

_newVolume = MathF.Round((Device.GetVolume() + VolumeDelta), 2);

Device.SetVolume(_newVolume);

break;

case KeyboardHotkeyState.VolumeDown:

_newVolume = MathF.Round((Device.GetVolume() - VolumeDelta), 2);

Device.SetVolume(_newVolume);

break;

case KeyboardHotkeyState.None:

(_keyboardInterface as AvaloniaKeyboard).Clear();

// Touchscreen

bool hasTouch = false;

{

hasTouch = TouchScreenManager.Update(true, (_inputManager.MouseDriver as AvaloniaMouseDriver).IsButtonPressed(MouseButton.Button1), ConfigurationState.Instance.Graphics.AspectRatio.Value.ToFloat());

}

<Color x:Key="DataGridSelectionColor">#FF00FABB</Color>

<Color x:Key="ThemeContentBackgroundColor">#FF2D2D2D</Color>

<Color x:Key="ThemeControlBorderColor">#FF505050</Color>

<x:Double x:Key="ScrollBarThickness">15</x:Double>

<x:Double x:Key="FontSizeSmall">8</x:Double>

<x:Double x:Key="FontSizeNormal">10</x:Double>

{

internal class AvaloniaMouseDriver : IGamepadDriver

{

public bool[] PressedButtons { get; }

public Vector2 CurrentPosition { get; private set; }

public string DriverName => "AvaloniaMouseDriver";

public ReadOnlySpan<string> GamepadsIds => new[] { "0" };

{

_widget = parent;

_window = window;

}

Running = true;

// Detect current platform

if (OperatingSystem.IsMacOS())

}

Running = false;

return;

}

public void ExecuteProgram(Switch device, ProgramSpecifyKind kind, ulong value)

{

device.Configuration.UserChannelPersistence.ExecuteProgram(kind, value);

{

}

}

Dispatcher.UIThread.Post(() =>

{

_hiddenTextBox.Clear();

_parent = null;

});

DefaultBackgroundColor = BrushToThemeColor(parent.Background);

DefaultForegroundColor = BrushToThemeColor(parent.Foreground);

DefaultBorderColor = BrushToThemeColor(parent.BorderBrush);

}

public string FontFamily { get; }

_mainWindow.InputManager.GamepadDriver.OnGamepadConnected += HandleOnGamepadConnected;

_mainWindow.InputManager.GamepadDriver.OnGamepadDisconnected += HandleOnGamepadDisconnected;

{

}

_isLoaded = false;

}

}

// Atomically replace and signal input change.

// NOTE: Do not modify InputConfig.Value directly as other code depends on the on-change event.

_mainWindow.InputManager.GamepadDriver.OnGamepadConnected -= HandleOnGamepadConnected;

_mainWindow.InputManager.GamepadDriver.OnGamepadDisconnected -= HandleOnGamepadDisconnected;

SelectedGamepad?.Dispose();

using Avalonia.Controls;

using Avalonia.Input;

using Avalonia.Media;

using Avalonia.Threading;

using DynamicData.Binding;

using LibHac.Fs;

using LibHac.FsSystem;

using Ryujinx.Ava.Common;

using Ryujinx.Ava.Common.Locale;

using Ryujinx.Ava.Input;

using Ryujinx.Ava.UI.Controls;

using Ryujinx.Ava.UI.Helpers;

using Ryujinx.Ava.UI.Windows;

using Ryujinx.Common;

using Ryujinx.Common.Configuration;

using Ryujinx.HLE;

using Ryujinx.HLE.FileSystem;

using Ryujinx.HLE.HOS;

using Ryujinx.Ui.App.Common;

using Ryujinx.Ui.Common;

using Ryujinx.Ui.Common.Configuration;

using Ryujinx.Ui.Common.Helper;

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Threading.Tasks;

using Path = System.IO.Path;

using ShaderCacheLoadingState = Ryujinx.Graphics.Gpu.Shader.ShaderCacheState;

namespace Ryujinx.Ava.UI.ViewModels

{

{

private const int HotKeyPressDelayMs = 500;

private ObservableCollection<ApplicationData> _applications;

private string _aspectStatusText;

private string _gpuStatusText;

private bool _isAmiiboRequested;

private bool _isGameRunning;

private int _progressMaximum;

private int _progressValue;

private long _lastFullscreenToggle = Environment.TickCount64;

private bool _isLoadingIndeterminate = true;

private bool _showAll;

private string _lastScannedAmiiboId;

private ReadOnlyObservableCollection<ApplicationData> _appsObservableList;

public MainWindowViewModel()

{

.Sort(GetComparer())

.Bind(out _appsObservableList).AsObservableList();

if (Program.PreviewerDetached)

{

LoadConfigurableHotKeys();

}

}

{

}

public string SearchText

{

get => _searchText;

_searchTimer = null;

}

public ReadOnlyObservableCollection<ApplicationData> AppsObservableList

{

get => _appsObservableList;

}

}

public bool EnableNonGameRunningControls => !IsGameRunning;

public bool ShowFirmwareStatus => !ShowLoadProgress;

OnPropertyChanged();

OnPropertyChanged(nameof(EnableNonGameRunningControls));

OnPropertyChanged(nameof(ShowFirmwareStatus));

}

}

}

}

public ApplicationData SelectedApplication

{

{

return Glyph switch

{

};

}

}

if (_isGameRunning)

{

}

OnPropertyChanged(nameof(VolumeStatusText));

}

}

public bool ShowContent

{

get => _showContent;

}

}

public bool IsGrid => Glyph == Glyph.Grid;

public bool IsList => Glyph == Glyph.List;

RefreshView();

}

public bool StartGamesInFullscreen

{

get => ConfigurationState.Instance.Ui.StartFullscreen;

}

}

public bool ShowConsoleVisible

{

get => ConsoleHelper.SetConsoleWindowStateSupported;

OnPropertyChanged();

OnPropertyChanged(nameof(GridSizeScale));

ConfigurationState.Instance.ToFileFormat().SaveConfig(Program.ConfigurationPath);

}

}

}

public string SortName

{

{

return SortMode switch

{

ApplicationSort.TotalTimePlayed => LocaleManager.Instance[LocaleKeys.GameListHeaderTimePlayed],

};

}

}

public KeyGesture ShowUiKey

{

{

OnPropertyChanged();

}

public KeyGesture ScreenshotKey

{

{

OnPropertyChanged();

}

}

}

public bool IsGridMedium => ConfigurationState.Instance.Ui.GridSize == 2;

{

{

}

{

{

}

{

{

}

}

{

}

}

{

{

}

{

}

{

{

}

{

{

}

{

{

}

{

}

{

{

{

{

}

}

{

{

}

}

public void LoadConfigurableHotKeys()

{

if (AvaloniaKeyboardMappingHelper.TryGetAvaKey((Ryujinx.Input.Key)ConfigurationState.Instance.Hid.Hotkeys.Value.ShowUi, out var showUiKey))

{

}

if (AvaloniaKeyboardMappingHelper.TryGetAvaKey((Ryujinx.Input.Key)ConfigurationState.Instance.Hid.Hotkeys.Value.Screenshot, out var screenshotKey))

{

}

if (AvaloniaKeyboardMappingHelper.TryGetAvaKey((Ryujinx.Input.Key)ConfigurationState.Instance.Hid.Hotkeys.Value.Pause, out var pauseKey))

{

}

}

public void TakeScreenshot()

{

}

public void HideUi()

Glyph = Glyph.Grid;

}

{

{

}

}

OpenHelper.OpenFolder(logPath);

}

public void ToggleDockMode()

{

if (IsGameRunning)

public async void ExitCurrentState()

{

{

ToggleFullscreen();

}

{

await Task.Delay(100);

}

}

public void ChangeLanguage(object obj)

{

LocaleManager.Instance.LoadDefaultLanguage();

LocaleManager.Instance.LoadLanguage((string)obj);

}

{

}

public void OpenPtcDirectory()

ApplicationData selection = SelectedApplication;

if (selection != null)

{

string backupPath = Path.Combine(ptcDir, "1");

if (!Directory.Exists(ptcDir))

ApplicationData selection = SelectedApplication;

if (selection != null)

{

DirectoryInfo backupDir = new(Path.Combine(AppDataManager.GamesDirPath, selection.TitleId, "cache", "cpu", "1"));

// FIXME: Found a way to reproduce the bold effect on the title name (fork?).

public void SimulateWakeUpMessage()

{

}

public async void PurgeShaderCache()

LocaleManager.Instance[LocaleKeys.RyujinxConfirm]);

List<DirectoryInfo> oldCacheDirectories = new();

if (shaderCacheDir.Exists)

{

}

}

{

ApplicationData selection = SelectedApplication;

if (selection != null)

{

}

}

{

ApplicationData selection = SelectedApplication;

if (selection != null)

{

}

}

{

ApplicationData selection = SelectedApplication;

if (selection != null)

{

}

}

{

ApplicationData selection = SelectedApplication;

if (selection != null)

{

if (!ulong.TryParse(selection.TitleId, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out ulong titleIdNumber))

{

{

await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogRyujinxErrorMessage], LocaleManager.Instance[LocaleKeys.DialogInvalidTitleIdErrorMessage]);

return;

}

OpenSaveDirectory(in saveDataFilter, selection, titleIdNumber);

});

}

}

{

ApplicationData selection = SelectedApplication;

if (selection != null)

{

}

}

{

}

{

if (selection != null)

{

}

}

{

if (selection != null)

{

}

}

{

if (selection != null)

{

}

}

{

}

{

{

{

{

}

{

}

}

{

}

{

}

}

{

{

}

}

{

{

}

}

}

} \ No newline at end of file

x:Class="Ryujinx.Ava.UI.Windows.MainWindow"

xmlns="https://github.com/avaloniaui"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

xmlns:window="clr-namespace:Ryujinx.Ava.UI.Windows"

xmlns:helpers="clr-namespace:Ryujinx.Ava.UI.Helpers"

Width="1280"

Height="777"

MinWidth="1092"

VerticalAlignment="Stretch"

IsVisible="{Binding ShowMenuAndStatusBar}"

Orientation="Vertical">

</StackPanel>

<ContentControl

Name="MainContent"

BorderThickness="0,0,0,0"

DockPanel.Dock="Top"

IsVisible="{Binding ShowContent}">

<Grid.RowDefinitions>

<RowDefinition Height="Auto" />

<RowDefinition Height="*" />

</Grid.RowDefinitions>

<controls:GameListView

x:Name="GameList"

Grid.Row="1"

IsVisible="{Binding ShowLoadProgress}"

Text="{Binding LoadHeading}"

TextAlignment="Left"

<Border

Grid.Row="1"

Margin="10"

Margin="0"

Padding="0"

HorizontalAlignment="Stretch"

ClipToBounds="True"

CornerRadius="5"

Foreground="{Binding ProgressBarForegroundColor}"

FontSize="18"

IsVisible="{Binding ShowLoadProgress}"

Text="{Binding CacheLoadStatus}"

</Grid>

</Grid>

</Grid>

</Grid>

</Grid>

using Avalonia;

using Avalonia.Controls;

using Avalonia.Input;

using Avalonia.Threading;

using FluentAvalonia.UI.Controls;

using Ryujinx.Ava.Common;

using Ryujinx.Ava.Common.Locale;

using Ryujinx.Ava.Input;

using Ryujinx.Ava.UI.Applet;

using Ryujinx.Ava.UI.Helpers;

using Ryujinx.Ava.UI.ViewModels;

using Ryujinx.Common.Logging;

using Ryujinx.Graphics.Gpu;

using Ryujinx.HLE.FileSystem;

using Ryujinx.Ui.Common;

using Ryujinx.Ui.Common.Configuration;

using Ryujinx.Ui.Common.Helper;

using System;

using System.ComponentModel;

using System.IO;

using System.Threading.Tasks;

using InputManager = Ryujinx.Input.HLE.InputManager;

public partial class MainWindow : StyleableWindow

{

internal static MainWindowViewModel MainWindowViewModel { get; private set; }

private UserChannelPersistence _userChannelPersistence;

private static bool _deferLoad;

private static string _launchPath;

private static bool _startFullscreen;

internal readonly AvaHostUiHandler UiHandler;

public VirtualFileSystem VirtualFileSystem { get; private set; }

public ContentManager ContentManager { get; private set; }

public LibHacHorizonManager LibHacHorizonManager { get; private set; }

public InputManager InputManager { get; private set; }

internal MainWindowViewModel ViewModel { get; private set; }

public SettingsWindow SettingsWindow { get; set; }

public static bool ShowKeyErrorOnLoad { get; set; }

public ApplicationLibrary ApplicationLibrary { get; set; }

public MainWindow()

{

MainWindowViewModel = ViewModel;

UiHandler = new AvaHostUiHandler(this);

// NOTE: Height of MenuBar and StatusBar is not usable here, since it would still be 0 at this point.

Height = ((Height - barHeight) / Program.WindowScaleFactor) + barHeight;

Width /= Program.WindowScaleFactor;

{

Initialize();

InputManager = new InputManager(new AvaloniaKeyboardDriver(this), new SDL2GamepadDriver());

LoadGameList();

}

}

public void LoadGameList()

_isLoading = true;

_isLoading = false;

}

protected override void HandleScalingChanged(double scale)

{

Program.DesktopScaleFactor = scale;

base.HandleScalingChanged(scale);

}

{

{

}

{

}

{

{

{

}

{

});

}

{

}

{

}

public void SwitchToGameControl(bool startFullscreen = false)

Dispatcher.UIThread.InvokeAsync(() =>

{

{

ViewModel.ToggleFullscreen();

}

});

}

Dispatcher.UIThread.InvokeAsync(() =>

{

{

ViewModel.ToggleFullscreen();

}

});

}

protected override void HandleWindowStateChanged(WindowState state)

{

if (state != WindowState.Minimized)

{

}

}

private void Initialize()

{

_userChannelPersistence = new UserChannelPersistence();

VirtualFileSystem.ReloadKeySet();

ApplicationHelper.Initialize(VirtualFileSystem, AccountManager, LibHacHorizonManager.RyujinxClient, this);

}

protected void CheckLaunchState()

{

_deferLoad = false;

}

if (ConfigurationState.Instance.CheckUpdatesOnStart.Value && Updater.CanUpdate(false, this))

}

}

private void Load()

{

GameGrid.ApplicationOpened += Application_Opened;

CheckLaunchState();

}

public static void UpdateGraphicsConfig()

{

GraphicsConfig.ResScale = ConfigurationState.Instance.Graphics.ResScale == -1 ? ConfigurationState.Instance.Graphics.ResScaleCustom : ConfigurationState.Instance.Graphics.ResScale;

HotKeyManager.SetHotKey(ExitHotKey, new KeyGesture(Key.Escape));

}

private void VolumeStatus_CheckedChanged(object sender, SplitButtonClickEventArgs e)

{

var volumeSplitButton = sender as ToggleSplitButton;

{

if (!volumeSplitButton.IsChecked)

{

}

else

{

}

}

}

protected override void OnClosing(CancelEventArgs e)

{

{

e.Cancel = true;

return;

}

{

{

Dispatcher.UIThread.Post(() =>

{

Close();

});

};

e.Cancel = true;

{

Dispatcher.UIThread.InvokeAsync(async () =>

{

{

Close();

}

});

}

}

} \ No newline at end of file