Merge branch 'master' into metal

src/Ryujinx/UI/ViewModels/AboutWindowViewModel.cs

@@ -1,15 +1,10 @@
 using Avalonia.Media.Imaging;
-using Avalonia.Platform;
 using Avalonia.Styling;
 using Avalonia.Threading;
 using Ryujinx.Ava.Common;
 using Ryujinx.Ava.Common.Locale;
-using Ryujinx.Common.Utilities;
 using Ryujinx.UI.Common.Configuration;
 using System;
-using System.Net.Http;
-using System.Net.NetworkInformation;
-using System.Threading.Tasks;
 
 namespace Ryujinx.Ava.UI.ViewModels
 {
@@ -17,11 +12,8 @@ namespace Ryujinx.Ava.UI.ViewModels
     {
         private Bitmap _githubLogo;
         private Bitmap _discordLogo;
-        private Bitmap _patreonLogo;
-        private Bitmap _twitterLogo;
 
         private string _version;
-        private string _supporters;
 
         public Bitmap GithubLogo
         {
@@ -43,36 +35,6 @@ namespace Ryujinx.Ava.UI.ViewModels
             }
         }
 
-        public Bitmap PatreonLogo
-        {
-            get => _patreonLogo;
-            set
-            {
-                _patreonLogo = value;
-                OnPropertyChanged();
-            }
-        }
-
-        public Bitmap TwitterLogo
-        {
-            get => _twitterLogo;
-            set
-            {
-                _twitterLogo = value;
-                OnPropertyChanged();
-            }
-        }
-
-        public string Supporters
-        {
-            get => _supporters;
-            set
-            {
-                _supporters = value;
-                OnPropertyChanged();
-            }
-        }
-
         public string Version
         {
             get => _version;
@@ -83,13 +45,14 @@ namespace Ryujinx.Ava.UI.ViewModels
             }
         }
 
-        public string Developers => LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.AboutPageDeveloperListMore, "gdkchan, Ac_K, marysaka, rip in peri peri, LDj3SNuD, emmaus, Thealexbarney, GoffyDude, TSRBerry, IsaacMarovitz");
+        public string Developers => "GreemDev";
+
+        public string FormerDevelopers => LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.AboutPageDeveloperListMore, "gdkchan, Ac_K, marysaka, rip in peri peri, LDj3SNuD, emmaus, Thealexbarney, GoffyDude, TSRBerry, IsaacMarovitz");
 
         public AboutWindowViewModel()
         {
-            Version = Program.Version;
+            Version = App.FullAppName + "\n" + Program.Version;
             UpdateLogoTheme(ConfigurationState.Instance.UI.BaseStyle.Value);
-            Dispatcher.UIThread.InvokeAsync(DownloadPatronsJson);
 
             ThemeManager.ThemeChanged += ThemeManager_ThemeChanged;
         }
@@ -108,42 +71,14 @@ namespace Ryujinx.Ava.UI.ViewModels
 
             GithubLogo = LoadBitmap($"{basePath}Logo_GitHub_{themeSuffix}?assembly=Ryujinx.UI.Common");
             DiscordLogo = LoadBitmap($"{basePath}Logo_Discord_{themeSuffix}?assembly=Ryujinx.UI.Common");
-            PatreonLogo = LoadBitmap($"{basePath}Logo_Patreon_{themeSuffix}?assembly=Ryujinx.UI.Common");
-            TwitterLogo = LoadBitmap($"{basePath}Logo_Twitter_{themeSuffix}?assembly=Ryujinx.UI.Common");
         }
 
-        private Bitmap LoadBitmap(string uri)
-        {
-            return new Bitmap(Avalonia.Platform.AssetLoader.Open(new Uri(uri)));
-        }
+        private static Bitmap LoadBitmap(string uri) => new(Avalonia.Platform.AssetLoader.Open(new Uri(uri)));
 
         public void Dispose()
         {
             ThemeManager.ThemeChanged -= ThemeManager_ThemeChanged;
             GC.SuppressFinalize(this);
         }
-
-        private async Task DownloadPatronsJson()
-        {
-            if (!NetworkInterface.GetIsNetworkAvailable())
-            {
-                Supporters = LocaleManager.Instance[LocaleKeys.ConnectionError];
-
-                return;
-            }
-
-            HttpClient httpClient = new();
-
-            try
-            {
-                string patreonJsonString = await httpClient.GetStringAsync("https://patreon.ryujinx.org/");
-
-                Supporters = string.Join(", ", JsonHelper.Deserialize(patreonJsonString, CommonJsonContext.Default.StringArray)) + "\n\n";
-            }
-            catch
-            {
-                Supporters = LocaleManager.Instance[LocaleKeys.ApiError];
-            }
-        }
     }
 }

src/Ryujinx/UI/ViewModels/AmiiboWindowViewModel.cs

@@ -24,13 +24,16 @@ namespace Ryujinx.Ava.UI.ViewModels
 {
     public class AmiiboWindowViewModel : BaseModel, IDisposable
     {
+        // ReSharper disable once InconsistentNaming
+        private static bool _cachedUseRandomUuid;
+
         private const string DefaultJson = "{ \"amiibo\": [] }";
         private const float AmiiboImageSize = 350f;
 
         private readonly string _amiiboJsonPath;
         private readonly byte[] _amiiboLogoBytes;
         private readonly HttpClient _httpClient;
-        private readonly StyleableWindow _owner;
+        private readonly AmiiboWindow _owner;
 
         private Bitmap _amiiboImage;
         private List<AmiiboApi> _amiiboList;
@@ -41,12 +44,12 @@ namespace Ryujinx.Ava.UI.ViewModels
         private int _seriesSelectedIndex;
         private bool _enableScanning;
         private bool _showAllAmiibo;
-        private bool _useRandomUuid;
+        private bool _useRandomUuid = _cachedUseRandomUuid;
         private string _usage;
 
         private static readonly AmiiboJsonSerializerContext _serializerContext = new(JsonHelper.GetDefaultSerializerOptions());
 
-        public AmiiboWindowViewModel(StyleableWindow owner, string lastScannedAmiiboId, string titleId)
+        public AmiiboWindowViewModel(AmiiboWindow owner, string lastScannedAmiiboId, string titleId)
         {
             _owner = owner;
 
@@ -82,7 +85,7 @@ namespace Ryujinx.Ava.UI.ViewModels
             get => _useRandomUuid;
             set
             {
-                _useRandomUuid = value;
+                _cachedUseRandomUuid = _useRandomUuid = value;
 
                 OnPropertyChanged();
             }
@@ -183,6 +186,22 @@ namespace Ryujinx.Ava.UI.ViewModels
             }
         }
 
+        public void Scan()
+        {
+            if (AmiiboSelectedIndex > -1)
+            {
+                _owner.ScannedAmiibo = AmiiboList[AmiiboSelectedIndex];
+                _owner.IsScanned = true;
+                _owner.Close();
+            }
+        }
+
+        public void Cancel()
+        {
+            _owner.IsScanned = false;
+            _owner.Close();
+        }
+
         public void Dispose()
         {
             GC.SuppressFinalize(this);
@@ -301,7 +320,7 @@ namespace Ryujinx.Ava.UI.ViewModels
                 }
             }
 
-            if (LastScannedAmiiboId != "")
+            if (LastScannedAmiiboId != string.Empty)
             {
                 SelectLastScannedAmiibo();
             }
@@ -313,7 +332,7 @@ namespace Ryujinx.Ava.UI.ViewModels
 
         private void SelectLastScannedAmiibo()
         {
-            AmiiboApi scanned = _amiiboList.Find(amiibo => amiibo.GetId() == LastScannedAmiiboId);
+            AmiiboApi scanned = _amiiboList.FirstOrDefault(amiibo => amiibo.GetId() == LastScannedAmiiboId);
 
             SeriesSelectedIndex = AmiiboSeries.IndexOf(scanned.AmiiboSeries);
             AmiiboSelectedIndex = AmiiboList.IndexOf(scanned);
@@ -374,7 +393,7 @@ namespace Ryujinx.Ava.UI.ViewModels
 
             AmiiboApi selected = _amiibos[_amiiboSelectedIndex];
 
-            string imageUrl = _amiiboList.Find(amiibo => amiibo.Equals(selected)).Image;
+            string imageUrl = _amiiboList.FirstOrDefault(amiibo => amiibo.Equals(selected)).Image;
 
             StringBuilder usageStringBuilder = new();
 
@@ -402,7 +421,7 @@ namespace Ryujinx.Ava.UI.ViewModels
                         usageStringBuilder.Append($"{LocaleManager.Instance[LocaleKeys.Unknown]}.");
                     }
 
-                    Usage = $"{LocaleManager.Instance[LocaleKeys.Usage]} {(writable ? $" ({LocaleManager.Instance[LocaleKeys.Writable]})" : "")} : {usageStringBuilder}";
+                    Usage = $"{LocaleManager.Instance[LocaleKeys.Usage]} {(writable ? $" ({LocaleManager.Instance[LocaleKeys.Writable]})" : string.Empty)} : {usageStringBuilder}";
                 }
             }
 
@@ -413,7 +432,7 @@ namespace Ryujinx.Ava.UI.ViewModels
         {
             try
             {
-                HttpResponseMessage response = await _httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Head, "https://amiibo.ryujinx.org/"));
+                HttpResponseMessage response = await _httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Head, "https://raw.githubusercontent.com/GreemDev/Ryujinx/refs/heads/master/assets/amiibo/Amiibo.json"));
 
                 if (response.IsSuccessStatusCode)
                 {
@@ -432,7 +451,7 @@ namespace Ryujinx.Ava.UI.ViewModels
         {
             try
             {
-                HttpResponseMessage response = await _httpClient.GetAsync("https://amiibo.ryujinx.org/");
+                HttpResponseMessage response = await _httpClient.GetAsync($"https://raw.githubusercontent.com/GreemDev/Ryujinx/refs/heads/master/assets/amiibo/Amiibo.json");
 
                 if (response.IsSuccessStatusCode)
                 {
@@ -461,7 +480,7 @@ namespace Ryujinx.Ava.UI.ViewModels
             await ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogAmiiboApiTitle],
                 LocaleManager.Instance[LocaleKeys.DialogAmiiboApiFailFetchMessage],
                 LocaleManager.Instance[LocaleKeys.InputDialogOk],
-                "",
+                string.Empty,
                 LocaleManager.Instance[LocaleKeys.RyujinxInfo]);
 
             return null;
@@ -511,7 +530,7 @@ namespace Ryujinx.Ava.UI.ViewModels
             await ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogAmiiboApiTitle],
                 LocaleManager.Instance[LocaleKeys.DialogAmiiboApiConnectErrorMessage],
                 LocaleManager.Instance[LocaleKeys.InputDialogOk],
-                "",
+                string.Empty,
                 LocaleManager.Instance[LocaleKeys.RyujinxInfo]);
         }
     }

src/Ryujinx/UI/ViewModels/DownloadableContentManagerViewModel.cs

@@ -3,47 +3,32 @@ using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Platform.Storage;
 using Avalonia.Threading;
 using DynamicData;
-using LibHac.Common;
-using LibHac.Fs;
-using LibHac.Fs.Fsa;
-using LibHac.Tools.Fs;
-using LibHac.Tools.FsSystem;
-using LibHac.Tools.FsSystem.NcaUtils;
+using FluentAvalonia.UI.Controls;
 using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.UI.Helpers;
-using Ryujinx.Ava.UI.Models;
-using Ryujinx.Common.Configuration;
-using Ryujinx.Common.Logging;
-using Ryujinx.Common.Utilities;
 using Ryujinx.HLE.FileSystem;
-using Ryujinx.HLE.Loaders.Processes.Extensions;
-using Ryujinx.HLE.Utilities;
 using Ryujinx.UI.App.Common;
-using System;
+using Ryujinx.UI.Common.Models;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using Application = Avalonia.Application;
-using Path = System.IO.Path;
 
 namespace Ryujinx.Ava.UI.ViewModels
 {
     public class DownloadableContentManagerViewModel : BaseModel
     {
-        private readonly List<DownloadableContentContainer> _downloadableContentContainerList;
-        private readonly string _downloadableContentJsonPath;
-
-        private readonly VirtualFileSystem _virtualFileSystem;
+        private readonly ApplicationLibrary _applicationLibrary;
         private AvaloniaList<DownloadableContentModel> _downloadableContents = new();
-        private AvaloniaList<DownloadableContentModel> _views = new();
         private AvaloniaList<DownloadableContentModel> _selectedDownloadableContents = new();
+        private AvaloniaList<DownloadableContentModel> _views = new();
+        private bool _showBundledContentNotice = false;
 
         private string _search;
         private readonly ApplicationData _applicationData;
         private readonly IStorageProvider _storageProvider;
 
-        private static readonly DownloadableContentJsonSerializerContext _serializerContext = new(JsonHelper.GetDefaultSerializerOptions());
-
         public AvaloniaList<DownloadableContentModel> DownloadableContents
         {
             get => _downloadableContents;
@@ -92,9 +77,19 @@ namespace Ryujinx.Ava.UI.ViewModels
             get => string.Format(LocaleManager.Instance[LocaleKeys.DlcWindowHeading], DownloadableContents.Count);
         }
 
-        public DownloadableContentManagerViewModel(VirtualFileSystem virtualFileSystem, ApplicationData applicationData)
+        public bool ShowBundledContentNotice
         {
-            _virtualFileSystem = virtualFileSystem;
+            get => _showBundledContentNotice;
+            set
+            {
+                _showBundledContentNotice = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public DownloadableContentManagerViewModel(ApplicationLibrary applicationLibrary, ApplicationData applicationData)
+        {
+            _applicationLibrary = applicationLibrary;
 
             _applicationData = applicationData;
 
@@ -103,109 +98,68 @@ namespace Ryujinx.Ava.UI.ViewModels
                 _storageProvider = desktop.MainWindow.StorageProvider;
             }
 
-            _downloadableContentJsonPath = Path.Combine(AppDataManager.GamesDirPath, applicationData.IdBaseString, "dlc.json");
-
-            if (!File.Exists(_downloadableContentJsonPath))
-            {
-                _downloadableContentContainerList = new List<DownloadableContentContainer>();
-
-                Save();
-            }
-
-            try
-            {
-                _downloadableContentContainerList = JsonHelper.DeserializeFromFile(_downloadableContentJsonPath, _serializerContext.ListDownloadableContentContainer);
-            }
-            catch
-            {
-                Logger.Error?.Print(LogClass.Configuration, "Downloadable Content JSON failed to deserialize.");
-                _downloadableContentContainerList = new List<DownloadableContentContainer>();
-            }
-
             LoadDownloadableContents();
         }
 
         private void LoadDownloadableContents()
         {
-            foreach (DownloadableContentContainer downloadableContentContainer in _downloadableContentContainerList)
+            var dlcs = _applicationLibrary.DownloadableContents.Items
+                .Where(it => it.Dlc.TitleIdBase == _applicationData.IdBase);
+
+            bool hasBundledContent = false;
+            foreach ((DownloadableContentModel dlc, bool isEnabled) in dlcs)
             {
-                if (File.Exists(downloadableContentContainer.ContainerPath))
+                DownloadableContents.Add(dlc);
+                hasBundledContent = hasBundledContent || dlc.IsBundled;
+
+                if (isEnabled)
                 {
-                    using IFileSystem partitionFileSystem = PartitionFileSystemUtils.OpenApplicationFileSystem(downloadableContentContainer.ContainerPath, _virtualFileSystem);
-
-                    foreach (DownloadableContentNca downloadableContentNca in downloadableContentContainer.DownloadableContentNcaList)
-                    {
-                        using UniqueRef<IFile> ncaFile = new();
-
-                        partitionFileSystem.OpenFile(ref ncaFile.Ref, downloadableContentNca.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
-
-                        Nca nca = TryOpenNca(ncaFile.Get.AsStorage(), downloadableContentContainer.ContainerPath);
-                        if (nca != null)
-                        {
-                            var content = new DownloadableContentModel(nca.Header.TitleId.ToString("X16"),
-                                downloadableContentContainer.ContainerPath,
-                                downloadableContentNca.FullPath,
-                                downloadableContentNca.Enabled);
-
-                            DownloadableContents.Add(content);
-
-                            if (content.Enabled)
-                            {
-                                SelectedDownloadableContents.Add(content);
-                            }
-
-                            OnPropertyChanged(nameof(UpdateCount));
-                        }
-                    }
+                    SelectedDownloadableContents.Add(dlc);
                 }
+
+                OnPropertyChanged(nameof(UpdateCount));
             }
 
-            // NOTE: Try to load downloadable contents from PFS last to preserve enabled state.
-            AddDownloadableContent(_applicationData.Path);
+            ShowBundledContentNotice = hasBundledContent;
 
-            // NOTE: Save the list again to remove leftovers.
-            Save();
             Sort();
         }
 
         public void Sort()
         {
-            DownloadableContents.AsObservableChangeSet()
+            DownloadableContents
+                // Sort bundled last
+                .OrderBy(it => it.IsBundled ? 0 : 1)
+                .ThenBy(it => it.TitleId)
+                .AsObservableChangeSet()
                 .Filter(Filter)
                 .Bind(out var view).AsObservableList();
 
+            // NOTE(jpr): this works around a bug where calling _views.Clear also clears SelectedDownloadableContents for
+            // some reason. so we save the items here and add them back after
+            var items = SelectedDownloadableContents.ToArray();
+
             _views.Clear();
             _views.AddRange(view);
+
+            foreach (DownloadableContentModel item in items)
+            {
+                SelectedDownloadableContents.ReplaceOrAdd(item, item);
+            }
+
             OnPropertyChanged(nameof(Views));
         }
 
-        private bool Filter(object arg)
+        private bool Filter<T>(T arg)
         {
             if (arg is DownloadableContentModel content)
             {
-                return string.IsNullOrWhiteSpace(_search) || content.FileName.ToLower().Contains(_search.ToLower()) || content.TitleId.ToLower().Contains(_search.ToLower());
+                return string.IsNullOrWhiteSpace(_search) || content.FileName.ToLower().Contains(_search.ToLower()) || content.TitleIdStr.ToLower().Contains(_search.ToLower());
             }
 
             return false;
         }
 
-        private Nca TryOpenNca(IStorage ncaStorage, string containerPath)
-        {
-            try
-            {
-                return new Nca(_virtualFileSystem.KeySet, ncaStorage);
-            }
-            catch (Exception ex)
-            {
-                Dispatcher.UIThread.InvokeAsync(async () =>
-                {
-                    await ContentDialogHelper.CreateErrorDialog(string.Format(LocaleManager.Instance[LocaleKeys.DialogLoadFileErrorMessage], ex.Message, containerPath));
-                });
-            }
-
-            return null;
-        }
-
         public async void Add()
         {
             var result = await _storageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
@@ -223,78 +177,88 @@ namespace Ryujinx.Ava.UI.ViewModels
                 },
             });
 
+            var totalDlcAdded = 0;
             foreach (var file in result)
             {
-                if (!AddDownloadableContent(file.Path.LocalPath))
+                if (!AddDownloadableContent(file.Path.LocalPath, out var newDlcAdded))
                 {
                     await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogDlcNoDlcErrorMessage]);
                 }
+
+                totalDlcAdded += newDlcAdded;
+            }
+
+            if (totalDlcAdded > 0)
+            {
+                await ShowNewDlcAddedDialog(totalDlcAdded);
             }
         }
 
-        private bool AddDownloadableContent(string path)
+        private bool AddDownloadableContent(string path, out int numDlcAdded)
         {
-            if (!File.Exists(path) || _downloadableContentContainerList.Any(x => x.ContainerPath == path))
+            numDlcAdded = 0;
+
+            if (!File.Exists(path))
             {
-                return true;
+                return false;
             }
 
-            using IFileSystem partitionFileSystem = PartitionFileSystemUtils.OpenApplicationFileSystem(path, _virtualFileSystem);
-
-            bool success = false;
-            foreach (DirectoryEntryEx fileEntry in partitionFileSystem.EnumerateEntries("/", "*.nca"))
+            if (!_applicationLibrary.TryGetDownloadableContentFromFile(path, out var dlcs) || dlcs.Count == 0)
             {
-                using var ncaFile = new UniqueRef<IFile>();
+                return false;
+            }
 
-                partitionFileSystem.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
+            var dlcsForThisGame = dlcs.Where(it => it.TitleIdBase == _applicationData.IdBase).ToList();
+            if (dlcsForThisGame.Count == 0)
+            {
+                return false;
+            }
 
-                Nca nca = TryOpenNca(ncaFile.Get.AsStorage(), path);
-                if (nca == null)
+            foreach (var dlc in dlcsForThisGame)
+            {
+                if (!DownloadableContents.Contains(dlc))
                 {
-                    continue;
-                }
+                    DownloadableContents.Add(dlc);
+                    SelectedDownloadableContents.ReplaceOrAdd(dlc, dlc);
 
-                if (nca.Header.ContentType == NcaContentType.PublicData)
-                {
-                    if (nca.GetProgramIdBase() != _applicationData.IdBase)
-                    {
-                        continue;
-                    }
-
-                    var content = new DownloadableContentModel(nca.Header.TitleId.ToString("X16"), path, fileEntry.FullPath, true);
-                    DownloadableContents.Add(content);
-                    Dispatcher.UIThread.InvokeAsync(() => SelectedDownloadableContents.Add(content));
-
-                    success = true;
+                    numDlcAdded++;
                 }
             }
 
-            if (success)
+            if (numDlcAdded > 0)
             {
                 OnPropertyChanged(nameof(UpdateCount));
                 Sort();
             }
 
-            return success;
+            return true;
         }
 
         public void Remove(DownloadableContentModel model)
         {
-            DownloadableContents.Remove(model);
-            OnPropertyChanged(nameof(UpdateCount));
-            Sort();
+            SelectedDownloadableContents.Remove(model);
+
+            if (!model.IsBundled)
+            {
+                DownloadableContents.Remove(model);
+                OnPropertyChanged(nameof(UpdateCount));
+                Sort();
+            }
         }
 
         public void RemoveAll()
         {
-            DownloadableContents.Clear();
+            SelectedDownloadableContents.Clear();
+            DownloadableContents.RemoveMany(DownloadableContents.Where(it => !it.IsBundled));
+
             OnPropertyChanged(nameof(UpdateCount));
             Sort();
         }
 
         public void EnableAll()
         {
-            SelectedDownloadableContents = new(DownloadableContents);
+            SelectedDownloadableContents.Clear();
+            SelectedDownloadableContents.AddRange(DownloadableContents);
         }
 
         public void DisableAll()
@@ -302,43 +266,36 @@ namespace Ryujinx.Ava.UI.ViewModels
             SelectedDownloadableContents.Clear();
         }
 
-        public void Save()
+        public void Enable(DownloadableContentModel model)
         {
-            _downloadableContentContainerList.Clear();
-
-            DownloadableContentContainer container = default;
-
-            foreach (DownloadableContentModel downloadableContent in DownloadableContents)
-            {
-                if (container.ContainerPath != downloadableContent.ContainerPath)
-                {
-                    if (!string.IsNullOrWhiteSpace(container.ContainerPath))
-                    {
-                        _downloadableContentContainerList.Add(container);
-                    }
-
-                    container = new DownloadableContentContainer
-                    {
-                        ContainerPath = downloadableContent.ContainerPath,
-                        DownloadableContentNcaList = new List<DownloadableContentNca>(),
-                    };
-                }
-
-                container.DownloadableContentNcaList.Add(new DownloadableContentNca
-                {
-                    Enabled = downloadableContent.Enabled,
-                    TitleId = Convert.ToUInt64(downloadableContent.TitleId, 16),
-                    FullPath = downloadableContent.FullPath,
-                });
-            }
-
-            if (!string.IsNullOrWhiteSpace(container.ContainerPath))
-            {
-                _downloadableContentContainerList.Add(container);
-            }
-
-            JsonHelper.SerializeToFile(_downloadableContentJsonPath, _downloadableContentContainerList, _serializerContext.ListDownloadableContentContainer);
+            SelectedDownloadableContents.ReplaceOrAdd(model, model);
         }
 
+        public void Disable(DownloadableContentModel model)
+        {
+            SelectedDownloadableContents.Remove(model);
+        }
+
+        public void Save()
+        {
+            var dlcs = DownloadableContents.Select(it => (it, SelectedDownloadableContents.Contains(it))).ToList();
+            _applicationLibrary.SaveDownloadableContentsForGame(_applicationData, dlcs);
+        }
+
+        private Task ShowNewDlcAddedDialog(int numAdded)
+        {
+            var msg = string.Format(LocaleManager.Instance[LocaleKeys.DlcWindowDlcAddedMessage], numAdded);
+            return Dispatcher.UIThread.InvokeAsync(async () =>
+            {
+                await ContentDialogHelper.ShowTextDialog(
+                    LocaleManager.Instance[LocaleKeys.DialogConfirmationTitle], 
+                    msg, 
+                    string.Empty, 
+                    string.Empty, 
+                    string.Empty, 
+                    LocaleManager.Instance[LocaleKeys.InputDialogOk], 
+                    (int)Symbol.Checkmark);
+            });
+        }
     }
 }

src/Ryujinx/UI/ViewModels/Input/InputViewModel.cs

@@ -44,8 +44,8 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
         private readonly MainWindow _mainWindow;
 
         private PlayerIndex _playerId;
+        private PlayerIndex _playerIdChoose;
         private int _controller;
-        private int _controllerNumber;
         private string _controllerImage;
         private int _device;
         private object _configViewModel;
@@ -84,6 +84,12 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
             }
         }
 
+        public PlayerIndex PlayerIdChoose
+        {
+            get => _playerIdChoose;
+            set { }
+        }
+
         public PlayerIndex PlayerId
         {
             get => _playerId;
@@ -91,16 +97,20 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
             {
                 if (IsModified)
                 {
+
+                    _playerIdChoose = value;
                     return;
                 }
 
                 IsModified = false;
                 _playerId = value;
 
-                if (!Enum.IsDefined(typeof(PlayerIndex), _playerId))
+                if (!Enum.IsDefined<PlayerIndex>(_playerId))
                 {
                     _playerId = PlayerIndex.Player1;
+
                 }
+                _isLoaded = false;
 
                 LoadConfiguration();
                 LoadDevice();
@@ -277,7 +287,7 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
 
         private void LoadConfiguration(InputConfig inputConfig = null)
         {
-            Config = inputConfig ?? ConfigurationState.Instance.Hid.InputConfig.Value.Find(inputConfig => inputConfig.PlayerIndex == _playerId);
+            Config = inputConfig ?? ConfigurationState.Instance.Hid.InputConfig.Value.FirstOrDefault(inputConfig => inputConfig.PlayerIndex == _playerId);
 
             if (Config is StandardKeyboardInputConfig keyboardInputConfig)
             {
@@ -357,18 +367,12 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
 
         private void HandleOnGamepadDisconnected(string id)
         {
-            Dispatcher.UIThread.Post(() =>
-            {
-                LoadDevices();
-            });
+            Dispatcher.UIThread.Post(LoadDevices);
         }
 
         private void HandleOnGamepadConnected(string id)
         {
-            Dispatcher.UIThread.Post(() =>
-            {
-                LoadDevices();
-            });
+            Dispatcher.UIThread.Post(LoadDevices);
         }
 
         private string GetCurrentGamepadId()
@@ -439,12 +443,28 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
 
         public void LoadDevices()
         {
+            string GetGamepadName(IGamepad gamepad, int controllerNumber)
+            {
+                return $"{GetShortGamepadName(gamepad.Name)} ({controllerNumber})";
+            }
+            string GetUniqueGamepadName(IGamepad gamepad, ref int controllerNumber)
+            {
+                string name = GetGamepadName(gamepad, controllerNumber);
+                if (Devices.Any(controller => controller.Name == name))
+                {
+                    controllerNumber++;
+                    name = GetGamepadName(gamepad, controllerNumber);
+                }
+                return name;
+            }
+
             lock (Devices)
             {
                 Devices.Clear();
                 DeviceList.Clear();
                 Devices.Add((DeviceType.None, Disabled, LocaleManager.Instance[LocaleKeys.ControllerSettingsDeviceDisabled]));
 
+                int controllerNumber = 0;
                 foreach (string id in _mainWindow.InputManager.KeyboardDriver.GamepadsIds)
                 {
                     using IGamepad gamepad = _mainWindow.InputManager.KeyboardDriver.GetGamepad(id);
@@ -461,17 +481,11 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
 
                     if (gamepad != null)
                     {
-                        if (Devices.Any(controller => GetShortGamepadId(controller.Id) == GetShortGamepadId(gamepad.Id)))
-                        {
-                            _controllerNumber++;
-                        }
-
-                        Devices.Add((DeviceType.Controller, id, $"{GetShortGamepadName(gamepad.Name)} ({_controllerNumber})"));
+                        string name = GetUniqueGamepadName(gamepad, ref controllerNumber);
+                        Devices.Add((DeviceType.Controller, id, name));
                     }
                 }
 
-                _controllerNumber = 0;
-
                 DeviceList.AddRange(Devices.Select(x => x.Name));
                 Device = Math.Min(Device, DeviceList.Count);
             }
@@ -583,7 +597,7 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
             }
             else if (activeDevice.Type == DeviceType.Controller)
             {
-                bool isNintendoStyle = Devices.ToList().Find(x => x.Id == activeDevice.Id).Name.Contains("Nintendo");
+                bool isNintendoStyle = Devices.ToList().FirstOrDefault(x => x.Id == activeDevice.Id).Name.Contains("Nintendo");
 
                 string id = activeDevice.Id.Split(" ")[0];
 
@@ -685,7 +699,7 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
 
                 if (!File.Exists(path))
                 {
-                    var index = ProfilesList.IndexOf(ProfileName);
+                    int index = ProfilesList.IndexOf(ProfileName);
                     if (index != -1)
                     {
                         ProfilesList.RemoveAt(index);
@@ -809,11 +823,11 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
 
             newConfig.AddRange(ConfigurationState.Instance.Hid.InputConfig.Value);
 
-            newConfig.Remove(newConfig.Find(x => x == null));
+            newConfig.Remove(newConfig.FirstOrDefault(x => x == null));
 
             if (Device == 0)
             {
-                newConfig.Remove(newConfig.Find(x => x.PlayerIndex == this.PlayerId));
+                newConfig.Remove(newConfig.FirstOrDefault(x => x.PlayerIndex == this.PlayerId));
             }
             else
             {

src/Ryujinx/UI/ViewModels/ModManagerViewModel.cs

@@ -4,6 +4,7 @@ using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Platform.Storage;
 using Avalonia.Threading;
 using DynamicData;
+using Gommon;
 using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.Models;
@@ -182,7 +183,7 @@ namespace Ryujinx.Ava.UI.ViewModels
             JsonHelper.SerializeToFile(_modJsonPath, modData, _serializerContext.ModMetadata);
         }
 
-        public void Delete(ModModel model)
+        public void Delete(ModModel model, bool removeFromList = true)
         {
             var isSubdir = true;
             var pathToDelete = model.Path;
@@ -222,8 +223,11 @@ namespace Ryujinx.Ava.UI.ViewModels
             Logger.Info?.Print(LogClass.Application, $"Deleting mod at \"{pathToDelete}\"");
             Directory.Delete(pathToDelete, true);
 
-            Mods.Remove(model);
-            OnPropertyChanged(nameof(ModCount));
+            if (removeFromList)
+            {
+                Mods.Remove(model);
+                OnPropertyChanged(nameof(ModCount));
+            }
             Sort();
         }
 
@@ -313,11 +317,7 @@ namespace Ryujinx.Ava.UI.ViewModels
 
         public void DeleteAll()
         {
-            foreach (var mod in Mods)
-            {
-                Delete(mod);
-            }
-
+            Mods.ForEach(it => Delete(it, false));
             Mods.Clear();
             OnPropertyChanged(nameof(ModCount));
             Sort();

src/Ryujinx/UI/ViewModels/SettingsViewModel.cs

@@ -14,6 +14,7 @@ using Ryujinx.Common.Configuration.Multiplayer;
 using Ryujinx.Common.GraphicsDriver;
 using Ryujinx.Common.Logging;
 using Ryujinx.Graphics.Vulkan;
+using Ryujinx.HLE;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.HOS.Services.Time.TimeZone;
 using Ryujinx.UI.Common.Configuration;
@@ -24,12 +25,13 @@ using System.Collections.ObjectModel;
 using System.Linq;
 using System.Net.NetworkInformation;
 using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using TimeZone = Ryujinx.Ava.UI.Models.TimeZone;
 
 namespace Ryujinx.Ava.UI.ViewModels
 {
-    public class SettingsViewModel : BaseModel
+    public partial class SettingsViewModel : BaseModel
     {
         private readonly VirtualFileSystem _virtualFileSystem;
         private readonly ContentManager _contentManager;
@@ -44,16 +46,23 @@ namespace Ryujinx.Ava.UI.ViewModels
         private int _graphicsBackendMultithreadingIndex;
         private float _volume;
         private bool _isVulkanAvailable = true;
-        private bool _directoryChanged;
+        private bool _gameDirectoryChanged;
+        private bool _autoloadDirectoryChanged;
         private readonly List<string> _gpuIds = new();
         private int _graphicsBackendIndex;
         private int _scalingFilter;
         private int _scalingFilterLevel;
+        private int _customVSyncInterval;
+        private bool _enableCustomVSyncInterval;
+        private int _customVSyncIntervalPercentageProxy;
+        private VSyncMode _vSyncMode;
 
         public event Action CloseWindow;
         public event Action SaveSettingsEvent;
         private int _networkInterfaceIndex;
         private int _multiplayerModeIndex;
+        private string _ldnPassphrase;
+        private string _LdnServer;
 
         public int ResolutionScale
         {
@@ -78,8 +87,8 @@ namespace Ryujinx.Ava.UI.ViewModels
                 {
                     Dispatcher.UIThread.InvokeAsync(() =>
                          ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogSettingsBackendThreadingWarningMessage],
-                            "",
-                            "",
+                             string.Empty,
+                             string.Empty,
                             LocaleManager.Instance[LocaleKeys.InputDialogOk],
                             LocaleManager.Instance[LocaleKeys.DialogSettingsBackendThreadingWarningTitle])
                     );
@@ -117,12 +126,23 @@ namespace Ryujinx.Ava.UI.ViewModels
 
         public bool IsHypervisorAvailable => OperatingSystem.IsMacOS() && RuntimeInformation.ProcessArchitecture == Architecture.Arm64;
 
-        public bool DirectoryChanged
+        public bool GameDirectoryChanged
         {
-            get => _directoryChanged;
+            get => _gameDirectoryChanged;
             set
             {
-                _directoryChanged = value;
+                _gameDirectoryChanged = value;
+
+                OnPropertyChanged();
+            }
+        }
+
+        public bool AutoloadDirectoryChanged
+        {
+            get => _autoloadDirectoryChanged;
+            set
+            {
+                _autoloadDirectoryChanged = value;
 
                 OnPropertyChanged();
             }
@@ -133,17 +153,87 @@ namespace Ryujinx.Ava.UI.ViewModels
         public bool EnableDiscordIntegration { get; set; }
         public bool CheckUpdatesOnStart { get; set; }
         public bool ShowConfirmExit { get; set; }
+        public bool IgnoreApplet { get; set; }
         public bool RememberWindowState { get; set; }
+        public bool ShowTitleBar { get; set; }
         public int HideCursor { get; set; }
         public bool EnableDockedMode { get; set; }
         public bool EnableKeyboard { get; set; }
         public bool EnableMouse { get; set; }
-        public bool EnableVsync { get; set; }
+        public VSyncMode VSyncMode
+        {
+            get => _vSyncMode;
+            set
+            {
+                if (value == VSyncMode.Custom ||
+                    value == VSyncMode.Switch ||
+                    value == VSyncMode.Unbounded)
+                {
+                    _vSyncMode = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+
+        public int CustomVSyncIntervalPercentageProxy
+        {
+            get => _customVSyncIntervalPercentageProxy;
+            set
+            {
+                int newInterval = (int)((value / 100f) * 60);
+                _customVSyncInterval = newInterval;
+                _customVSyncIntervalPercentageProxy = value;
+                OnPropertyChanged((nameof(CustomVSyncInterval)));
+                OnPropertyChanged((nameof(CustomVSyncIntervalPercentageText)));
+            }
+        }
+
+        public string CustomVSyncIntervalPercentageText
+        {
+            get
+            {
+                string text = CustomVSyncIntervalPercentageProxy.ToString() + "%";
+                return text;
+            }
+        }
+
+        public bool EnableCustomVSyncInterval
+        {
+            get => _enableCustomVSyncInterval;
+            set
+            {
+                _enableCustomVSyncInterval = value;
+                if (_vSyncMode == VSyncMode.Custom && !value)
+                {
+                    VSyncMode = VSyncMode.Switch;
+                }
+                else if (value)
+                {
+                    VSyncMode = VSyncMode.Custom;
+                }
+                OnPropertyChanged();
+            }
+        }
+
+        public int CustomVSyncInterval
+        {
+            get => _customVSyncInterval;
+            set
+            {
+                _customVSyncInterval = value;
+                int newPercent = (int)((value / 60f) * 100);
+                _customVSyncIntervalPercentageProxy = newPercent;
+                OnPropertyChanged(nameof(CustomVSyncIntervalPercentageProxy));
+                OnPropertyChanged(nameof(CustomVSyncIntervalPercentageText));
+                OnPropertyChanged();
+            }
+        }
         public bool EnablePptc { get; set; }
+        public bool EnableLowPowerPptc { get; set; }
         public bool EnableInternetAccess { get; set; }
         public bool EnableFsIntegrityChecks { get; set; }
         public bool IgnoreMissingServices { get; set; }
-        public bool ExpandDramSize { get; set; }
+        public MemoryConfiguration DramSize { get; set; }
         public bool EnableShaderCache { get; set; }
         public bool EnableTextureRecompression { get; set; }
         public bool EnableMacroHLE { get; set; }
@@ -166,10 +256,24 @@ namespace Ryujinx.Ava.UI.ViewModels
 
         public bool IsVulkanSelected => GraphicsBackendIndex == 0;
         public bool UseHypervisor { get; set; }
+        public bool DisableP2P { get; set; }
 
         public string TimeZone { get; set; }
         public string ShaderDumpPath { get; set; }
 
+        public string LdnPassphrase
+        {
+            get => _ldnPassphrase;
+            set
+            {
+                _ldnPassphrase = value;
+                IsInvalidLdnPassphraseVisible = !ValidateLdnPassphrase(value);
+
+                OnPropertyChanged();
+                OnPropertyChanged(nameof(IsInvalidLdnPassphraseVisible));
+            }
+        }
+
         public int Language { get; set; }
         public int Region { get; set; }
         public int FsGlobalAccessLogMode { get; set; }
@@ -228,10 +332,12 @@ namespace Ryujinx.Ava.UI.ViewModels
         }
 
         public DateTimeOffset CurrentDate { get; set; }
+
         public TimeSpan CurrentTime { get; set; }
 
         internal AvaloniaList<TimeZone> TimeZones { get; set; }
         public AvaloniaList<string> GameDirectories { get; set; }
+        public AvaloniaList<string> AutoloadDirectories { get; set; }
         public ObservableCollection<ComboBoxItem> AvailableGpus { get; set; }
 
         public AvaloniaList<string> NetworkInterfaceList
@@ -261,6 +367,21 @@ namespace Ryujinx.Ava.UI.ViewModels
             }
         }
 
+        [GeneratedRegex("Ryujinx-[0-9a-f]{8}")]
+        private static partial Regex LdnPassphraseRegex();
+
+        public bool IsInvalidLdnPassphraseVisible { get; set; }
+
+        public string LdnServer
+        {
+            get => _LdnServer;
+            set
+            {
+                _LdnServer = value;
+                OnPropertyChanged();
+            }
+        }
+
         public SettingsViewModel(VirtualFileSystem virtualFileSystem, ContentManager contentManager) : this()
         {
             _virtualFileSystem = virtualFileSystem;
@@ -273,10 +394,11 @@ namespace Ryujinx.Ava.UI.ViewModels
 
         public SettingsViewModel()
         {
-            GameDirectories = new AvaloniaList<string>();
-            TimeZones = new AvaloniaList<TimeZone>();
-            AvailableGpus = new ObservableCollection<ComboBoxItem>();
-            _validTzRegions = new List<string>();
+            GameDirectories = [];
+            AutoloadDirectories = [];
+            TimeZones = [];
+            AvailableGpus = [];
+            _validTzRegions = [];
             _networkInterfaces = new Dictionary<string, string>();
 
             Task.Run(CheckSoundBackends);
@@ -322,7 +444,7 @@ namespace Ryujinx.Ava.UI.ViewModels
                     {
                         _gpuIds.Add(device.Id);
 
-                        AvailableGpus.Add(new ComboBoxItem { Content = $"{device.Name} {(device.IsDiscrete ? "(dGPU)" : "")}" });
+                        AvailableGpus.Add(new ComboBoxItem { Content = $"{device.Name} {(device.IsDiscrete ? "(dGPU)" : string.Empty)}" });
                     });
                 }
             }
@@ -334,6 +456,18 @@ namespace Ryujinx.Ava.UI.ViewModels
             Dispatcher.UIThread.Post(() => OnPropertyChanged(nameof(PreferredGpuIndex)));
         }
 
+        public void MatchSystemTime()
+        {
+            var dto = DateTimeOffset.Now;
+
+            CurrentDate = new DateTimeOffset(dto.Year, dto.Month, dto.Day, 0, 0, 0, dto.Offset);
+            
+            CurrentTime = dto.TimeOfDay;
+            
+            OnPropertyChanged(nameof(CurrentDate));
+            OnPropertyChanged(nameof(CurrentTime));
+        }
+
         public async Task LoadTimeZones()
         {
             _timeZoneContentManager = new TimeZoneContentManager();
@@ -377,6 +511,11 @@ namespace Ryujinx.Ava.UI.ViewModels
             Dispatcher.UIThread.Post(() => OnPropertyChanged(nameof(NetworkInterfaceIndex)));
         }
 
+        private bool ValidateLdnPassphrase(string passphrase)
+        {
+            return string.IsNullOrEmpty(passphrase) || (passphrase.Length == 16 && LdnPassphraseRegex().IsMatch(passphrase));
+        }
+
         public void ValidateAndSetTimeZone(string location)
         {
             if (_validTzRegions.Contains(location))
@@ -393,12 +532,17 @@ namespace Ryujinx.Ava.UI.ViewModels
             EnableDiscordIntegration = config.EnableDiscordIntegration;
             CheckUpdatesOnStart = config.CheckUpdatesOnStart;
             ShowConfirmExit = config.ShowConfirmExit;
+            IgnoreApplet = config.IgnoreApplet;
             RememberWindowState = config.RememberWindowState;
+            ShowTitleBar = config.ShowTitleBar;
             HideCursor = (int)config.HideCursor.Value;
 
             GameDirectories.Clear();
             GameDirectories.AddRange(config.UI.GameDirs.Value);
 
+            AutoloadDirectories.Clear();
+            AutoloadDirectories.AddRange(config.UI.AutoloadDirs.Value);
+
             BaseStyleIndex = config.UI.BaseStyle.Value switch
             {
                 "Auto" => 0,
@@ -426,26 +570,29 @@ namespace Ryujinx.Ava.UI.ViewModels
             CurrentDate = currentDateTime.Date;
             CurrentTime = currentDateTime.TimeOfDay;
 
-            EnableVsync = config.Graphics.EnableVsync;
+            EnableCustomVSyncInterval = config.Graphics.EnableCustomVSyncInterval.Value;
+            CustomVSyncInterval = config.Graphics.CustomVSyncInterval;
+            VSyncMode = config.Graphics.VSyncMode;
             EnableFsIntegrityChecks = config.System.EnableFsIntegrityChecks;
-            ExpandDramSize = config.System.ExpandRam;
+            DramSize = config.System.DramSize;
             IgnoreMissingServices = config.System.IgnoreMissingServices;
 
             // CPU
             EnablePptc = config.System.EnablePtc;
+            EnableLowPowerPptc = config.System.EnableLowPowerPtc;
             MemoryMode = (int)config.System.MemoryManagerMode.Value;
             UseHypervisor = config.System.UseHypervisor;
 
             // Graphics
             GraphicsBackendIndex = (int)config.Graphics.GraphicsBackend.Value;
-            // Physical devices are queried asynchronously hence the prefered index config value is loaded in LoadAvailableGpus().
+            // Physical devices are queried asynchronously hence the preferred index config value is loaded in LoadAvailableGpus().
             EnableShaderCache = config.Graphics.EnableShaderCache;
             EnableTextureRecompression = config.Graphics.EnableTextureRecompression;
             EnableMacroHLE = config.Graphics.EnableMacroHLE;
             EnableColorSpacePassthrough = config.Graphics.EnableColorSpacePassthrough;
             ResolutionScale = config.Graphics.ResScale == -1 ? 4 : config.Graphics.ResScale - 1;
             CustomResolutionScale = config.Graphics.ResScaleCustom;
-            MaxAnisotropy = config.Graphics.MaxAnisotropy == -1 ? 0 : (int)(MathF.Log2(config.Graphics.MaxAnisotropy));
+            MaxAnisotropy = config.Graphics.MaxAnisotropy == -1 ? 0 : (int)MathF.Log2(config.Graphics.MaxAnisotropy);
             AspectRatio = (int)config.Graphics.AspectRatio.Value;
             GraphicsBackendMultithreadingIndex = (int)config.Graphics.BackendThreading.Value;
             ShaderDumpPath = config.Graphics.ShadersDumpPath;
@@ -475,6 +622,9 @@ namespace Ryujinx.Ava.UI.ViewModels
             OpenglDebugLevel = (int)config.Logger.GraphicsDebugLevel.Value;
 
             MultiplayerModeIndex = (int)config.Multiplayer.Mode.Value;
+            DisableP2P = config.Multiplayer.DisableP2p.Value;
+            LdnPassphrase = config.Multiplayer.LdnPassphrase.Value;
+            LdnServer = config.Multiplayer.LdnServer.Value;
         }
 
         public void SaveSettings()
@@ -485,15 +635,23 @@ namespace Ryujinx.Ava.UI.ViewModels
             config.EnableDiscordIntegration.Value = EnableDiscordIntegration;
             config.CheckUpdatesOnStart.Value = CheckUpdatesOnStart;
             config.ShowConfirmExit.Value = ShowConfirmExit;
+            config.IgnoreApplet.Value = IgnoreApplet;
             config.RememberWindowState.Value = RememberWindowState;
+            config.ShowTitleBar.Value = ShowTitleBar;
             config.HideCursor.Value = (HideCursorMode)HideCursor;
 
-            if (_directoryChanged)
+            if (_gameDirectoryChanged)
             {
                 List<string> gameDirs = new(GameDirectories);
                 config.UI.GameDirs.Value = gameDirs;
             }
 
+            if (_autoloadDirectoryChanged)
+            {
+                List<string> autoloadDirs = new(AutoloadDirectories);
+                config.UI.AutoloadDirs.Value = autoloadDirs;
+            }
+
             config.UI.BaseStyle.Value = BaseStyleIndex switch
             {
                 0 => "Auto",
@@ -520,13 +678,16 @@ namespace Ryujinx.Ava.UI.ViewModels
             }
 
             config.System.SystemTimeOffset.Value = Convert.ToInt64((CurrentDate.ToUnixTimeSeconds() + CurrentTime.TotalSeconds) - DateTimeOffset.Now.ToUnixTimeSeconds());
-            config.Graphics.EnableVsync.Value = EnableVsync;
+            config.Graphics.VSyncMode.Value = VSyncMode;
+            config.Graphics.EnableCustomVSyncInterval.Value = EnableCustomVSyncInterval;
+            config.Graphics.CustomVSyncInterval.Value = CustomVSyncInterval;
             config.System.EnableFsIntegrityChecks.Value = EnableFsIntegrityChecks;
-            config.System.ExpandRam.Value = ExpandDramSize;
+            config.System.DramSize.Value = DramSize;
             config.System.IgnoreMissingServices.Value = IgnoreMissingServices;
 
             // CPU
             config.System.EnablePtc.Value = EnablePptc;
+            config.System.EnableLowPowerPtc.Value = EnableLowPowerPptc;
             config.System.MemoryManagerMode.Value = (MemoryManagerMode)MemoryMode;
             config.System.UseHypervisor.Value = UseHypervisor;
 
@@ -582,14 +743,19 @@ namespace Ryujinx.Ava.UI.ViewModels
 
             config.Multiplayer.LanInterfaceId.Value = _networkInterfaces[NetworkInterfaceList[NetworkInterfaceIndex]];
             config.Multiplayer.Mode.Value = (MultiplayerMode)MultiplayerModeIndex;
+            config.Multiplayer.DisableP2p.Value = DisableP2P;
+            config.Multiplayer.LdnPassphrase.Value = LdnPassphrase;
+            config.Multiplayer.LdnServer.Value = LdnServer;
 
             config.ToFileFormat().SaveConfig(Program.ConfigurationPath);
 
             MainWindow.UpdateGraphicsConfig();
+            MainWindow.MainWindowViewModel.VSyncModeSettingChanged();
 
             SaveSettingsEvent?.Invoke();
 
-            _directoryChanged = false;
+            _gameDirectoryChanged = false;
+            _autoloadDirectoryChanged = false;
         }
 
         private static void RevertIfNotSaved()

src/Ryujinx/UI/ViewModels/TitleUpdateViewModel.cs

@@ -2,48 +2,31 @@ using Avalonia.Collections;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Platform.Storage;
 using Avalonia.Threading;
-using LibHac.Common;
-using LibHac.Fs;
-using LibHac.Fs.Fsa;
-using LibHac.Ncm;
-using LibHac.Ns;
-using LibHac.Tools.FsSystem;
-using LibHac.Tools.FsSystem.NcaUtils;
+using FluentAvalonia.UI.Controls;
 using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.UI.Helpers;
-using Ryujinx.Ava.UI.Models;
-using Ryujinx.Common.Configuration;
-using Ryujinx.Common.Logging;
-using Ryujinx.Common.Utilities;
 using Ryujinx.HLE.FileSystem;
-using Ryujinx.HLE.Loaders.Processes.Extensions;
-using Ryujinx.HLE.Utilities;
 using Ryujinx.UI.App.Common;
-using Ryujinx.UI.Common.Configuration;
-using System;
+using Ryujinx.UI.Common.Models;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Application = Avalonia.Application;
-using ContentType = LibHac.Ncm.ContentType;
-using Path = System.IO.Path;
-using SpanHelpers = LibHac.Common.SpanHelpers;
 
 namespace Ryujinx.Ava.UI.ViewModels
 {
+    public record TitleUpdateViewNoUpdateSentinal();
+
     public class TitleUpdateViewModel : BaseModel
     {
-        public TitleUpdateMetadata TitleUpdateWindowData;
-        public readonly string TitleUpdateJsonPath;
-        private VirtualFileSystem VirtualFileSystem { get; }
+        private ApplicationLibrary ApplicationLibrary { get; }
         private ApplicationData ApplicationData { get; }
 
         private AvaloniaList<TitleUpdateModel> _titleUpdates = new();
         private AvaloniaList<object> _views = new();
-        private object _selectedUpdate;
-
-        private static readonly TitleUpdateMetadataJsonSerializerContext _serializerContext = new(JsonHelper.GetDefaultSerializerOptions());
+        private object _selectedUpdate = new TitleUpdateViewNoUpdateSentinal();
+        private bool _showBundledContentNotice = false;
 
         public AvaloniaList<TitleUpdateModel> TitleUpdates
         {
@@ -75,11 +58,21 @@ namespace Ryujinx.Ava.UI.ViewModels
             }
         }
 
+        public bool ShowBundledContentNotice
+        {
+            get => _showBundledContentNotice;
+            set
+            {
+                _showBundledContentNotice = value;
+                OnPropertyChanged();
+            }
+        }
+
         public IStorageProvider StorageProvider;
 
-        public TitleUpdateViewModel(VirtualFileSystem virtualFileSystem, ApplicationData applicationData)
+        public TitleUpdateViewModel(ApplicationLibrary applicationLibrary, ApplicationData applicationData)
         {
-            VirtualFileSystem = virtualFileSystem;
+            ApplicationLibrary = applicationLibrary;
 
             ApplicationData = applicationData;
 
@@ -88,44 +81,29 @@ namespace Ryujinx.Ava.UI.ViewModels
                 StorageProvider = desktop.MainWindow.StorageProvider;
             }
 
-            TitleUpdateJsonPath = Path.Combine(AppDataManager.GamesDirPath, ApplicationData.IdBaseString, "updates.json");
-
-            try
-            {
-                TitleUpdateWindowData = JsonHelper.DeserializeFromFile(TitleUpdateJsonPath, _serializerContext.TitleUpdateMetadata);
-            }
-            catch
-            {
-                Logger.Warning?.Print(LogClass.Application, $"Failed to deserialize title update data for {ApplicationData.IdBaseString} at {TitleUpdateJsonPath}");
-
-                TitleUpdateWindowData = new TitleUpdateMetadata
-                {
-                    Selected = "",
-                    Paths = new List<string>(),
-                };
-
-                Save();
-            }
-
             LoadUpdates();
         }
 
         private void LoadUpdates()
         {
-            // Try to load updates from PFS first
-            AddUpdate(ApplicationData.Path, true);
+            var updates = ApplicationLibrary.TitleUpdates.Items
+                .Where(it => it.TitleUpdate.TitleIdBase == ApplicationData.IdBase);
 
-            foreach (string path in TitleUpdateWindowData.Paths)
+            bool hasBundledContent = false;
+            SelectedUpdate = new TitleUpdateViewNoUpdateSentinal();
+            foreach ((TitleUpdateModel update, bool isSelected) in updates)
             {
-                AddUpdate(path);
+                TitleUpdates.Add(update);
+                hasBundledContent = hasBundledContent || update.IsBundled;
+
+                if (isSelected)
+                {
+                    SelectedUpdate = update;
+                }
             }
 
-            TitleUpdateModel selected = TitleUpdates.FirstOrDefault(x => x.Path == TitleUpdateWindowData.Selected, null);
+            ShowBundledContentNotice = hasBundledContent;
 
-            SelectedUpdate = selected;
-
-            // NOTE: Save the list again to remove leftovers.
-            Save();
             SortUpdates();
         }
 
@@ -133,89 +111,76 @@ namespace Ryujinx.Ava.UI.ViewModels
         {
             var sortedUpdates = TitleUpdates.OrderByDescending(update => update.Version);
 
+            // NOTE(jpr): this works around a bug where calling Views.Clear also clears SelectedUpdate for
+            // some reason. so we save the item here and restore it after
+            var selected = SelectedUpdate;
+
             Views.Clear();
-            Views.Add(new BaseModel());
+            Views.Add(new TitleUpdateViewNoUpdateSentinal());
             Views.AddRange(sortedUpdates);
 
-            if (SelectedUpdate == null)
+            SelectedUpdate = selected;
+
+            if (SelectedUpdate is TitleUpdateViewNoUpdateSentinal)
             {
                 SelectedUpdate = Views[0];
             }
-            else if (!TitleUpdates.Contains(SelectedUpdate))
+            // this is mainly to handle a scenario where the user removes the selected update
+            else if (!TitleUpdates.Contains((TitleUpdateModel)SelectedUpdate))
             {
-                if (Views.Count > 1)
-                {
-                    SelectedUpdate = Views[1];
-                }
-                else
-                {
-                    SelectedUpdate = Views[0];
-                }
+                SelectedUpdate = Views.Count > 1 ? Views[1] : Views[0];
             }
         }
 
-        private void AddUpdate(string path, bool ignoreNotFound = false, bool selected = false)
+        private bool AddUpdate(string path, out int numUpdatesAdded)
         {
-            if (!File.Exists(path) || TitleUpdates.Any(x => x.Path == path))
+            numUpdatesAdded = 0;
+
+            if (!File.Exists(path))
             {
-                return;
+                return false;
             }
 
-            IntegrityCheckLevel checkLevel = ConfigurationState.Instance.System.EnableFsIntegrityChecks
-                ? IntegrityCheckLevel.ErrorOnInvalid
-                : IntegrityCheckLevel.None;
-
-            try
+            if (!ApplicationLibrary.TryGetTitleUpdatesFromFile(path, out var updates))
             {
-                using IFileSystem pfs = PartitionFileSystemUtils.OpenApplicationFileSystem(path, VirtualFileSystem);
+                return false;
+            }
 
-                Dictionary<ulong, ContentMetaData> updates = pfs.GetContentData(ContentMetaType.Patch, VirtualFileSystem, checkLevel);
+            var updatesForThisGame = updates.Where(it => it.TitleIdBase == ApplicationData.Id).ToList();
+            if (updatesForThisGame.Count == 0)
+            {
+                return false;
+            }
 
-                Nca patchNca = null;
-                Nca controlNca = null;
-
-                if (updates.TryGetValue(ApplicationData.Id, out ContentMetaData content))
+            foreach (var update in updatesForThisGame)
+            {
+                if (!TitleUpdates.Contains(update))
                 {
-                    patchNca = content.GetNcaByType(VirtualFileSystem.KeySet, ContentType.Program);
-                    controlNca = content.GetNcaByType(VirtualFileSystem.KeySet, ContentType.Control);
-                }
-
-                if (controlNca != null && patchNca != null)
-                {
-                    ApplicationControlProperty controlData = new();
-
-                    using UniqueRef<IFile> nacpFile = new();
-
-                    controlNca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.None).OpenFile(ref nacpFile.Ref, "/control.nacp".ToU8Span(), OpenMode.Read).ThrowIfFailure();
-                    nacpFile.Get.Read(out _, 0, SpanHelpers.AsByteSpan(ref controlData), ReadOption.None).ThrowIfFailure();
-
-                    var displayVersion = controlData.DisplayVersionString.ToString();
-                    var update = new TitleUpdateModel(content.Version.Version, displayVersion, path);
-
                     TitleUpdates.Add(update);
+                    SelectedUpdate = update;
 
-                    if (selected)
-                    {
-                        Dispatcher.UIThread.InvokeAsync(() => SelectedUpdate = update);
-                    }
-                }
-                else
-                {
-                    if (!ignoreNotFound)
-                    {
-                        Dispatcher.UIThread.InvokeAsync(() => ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogUpdateAddUpdateErrorMessage]));
-                    }
+                    numUpdatesAdded++;
                 }
             }
-            catch (Exception ex)
+
+            if (numUpdatesAdded > 0)
             {
-                Dispatcher.UIThread.InvokeAsync(() => ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogLoadFileErrorMessage, ex.Message, path)));
+                SortUpdates();
             }
+
+            return true;
         }
 
         public void RemoveUpdate(TitleUpdateModel update)
         {
-            TitleUpdates.Remove(update);
+            if (!update.IsBundled)
+            {
+                TitleUpdates.Remove(update);
+            }
+            else if (update == SelectedUpdate as TitleUpdateModel)
+            {
+                SelectedUpdate = new TitleUpdateViewNoUpdateSentinal();
+            }
 
             SortUpdates();
         }
@@ -236,30 +201,42 @@ namespace Ryujinx.Ava.UI.ViewModels
                 },
             });
 
+            var totalUpdatesAdded = 0;
             foreach (var file in result)
             {
-                AddUpdate(file.Path.LocalPath, selected: true);
+                if (!AddUpdate(file.Path.LocalPath, out var newUpdatesAdded))
+                {
+                    await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogUpdateAddUpdateErrorMessage]);
+                }
+
+                totalUpdatesAdded += newUpdatesAdded;
             }
 
-            SortUpdates();
+            if (totalUpdatesAdded > 0)
+            {
+                await ShowNewUpdatesAddedDialog(totalUpdatesAdded);
+            }
         }
 
         public void Save()
         {
-            TitleUpdateWindowData.Paths.Clear();
-            TitleUpdateWindowData.Selected = "";
+            var updates = TitleUpdates.Select(it => (it, it == SelectedUpdate as TitleUpdateModel)).ToList();
+            ApplicationLibrary.SaveTitleUpdatesForGame(ApplicationData, updates);
+        }
 
-            foreach (TitleUpdateModel update in TitleUpdates)
-            {
-                TitleUpdateWindowData.Paths.Add(update.Path);
-
-                if (update == SelectedUpdate)
-                {
-                    TitleUpdateWindowData.Selected = update.Path;
-                }
-            }
-
-            JsonHelper.SerializeToFile(TitleUpdateJsonPath, TitleUpdateWindowData, _serializerContext.TitleUpdateMetadata);
+        private Task ShowNewUpdatesAddedDialog(int numAdded)
+        {
+            var msg = string.Format(LocaleManager.Instance[LocaleKeys.UpdateWindowUpdateAddedMessage], numAdded);
+            return Dispatcher.UIThread.InvokeAsync(async () => 
+                await ContentDialogHelper.ShowTextDialog(
+                    LocaleManager.Instance[LocaleKeys.DialogConfirmationTitle], 
+                    msg, 
+                    string.Empty, 
+                    string.Empty, 
+                    string.Empty, 
+                    LocaleManager.Instance[LocaleKeys.InputDialogOk], 
+                    (int)Symbol.Checkmark
+                ));
         }
     }
 }

src/Ryujinx/UI/ViewModels/XCITrimmerViewModel.cs

@@ -0,0 +1,540 @@
+using Avalonia.Collections;
+using DynamicData;
+using Gommon;
+using Avalonia.Threading;
+using Ryujinx.Ava.Common;
+using Ryujinx.Ava.Common.Locale;
+using Ryujinx.Ava.UI.Helpers;
+using Ryujinx.Common.Utilities;
+using Ryujinx.UI.App.Common;
+using Ryujinx.UI.Common.Models;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using static Ryujinx.Common.Utilities.XCIFileTrimmer;
+
+namespace Ryujinx.Ava.UI.ViewModels
+{
+    public class XCITrimmerViewModel : BaseModel
+    {
+        private const long _bytesPerMB = 1024 * 1024;
+        private enum ProcessingMode
+        {
+            Trimming,
+            Untrimming
+        }
+
+        public enum SortField
+        {
+            Name,
+            Saved
+        }
+
+        private const string _FileExtXCI = "XCI";
+
+        private readonly Ryujinx.Common.Logging.XCIFileTrimmerLog _logger;
+        private ApplicationLibrary ApplicationLibrary => _mainWindowViewModel.ApplicationLibrary;
+        private Optional<XCITrimmerFileModel> _processingApplication = null;
+        private AvaloniaList<XCITrimmerFileModel> _allXCIFiles = new();
+        private AvaloniaList<XCITrimmerFileModel> _selectedXCIFiles = new();
+        private AvaloniaList<XCITrimmerFileModel> _displayedXCIFiles = new();
+        private MainWindowViewModel _mainWindowViewModel;
+        private CancellationTokenSource _cancellationTokenSource;
+        private string _search;
+        private ProcessingMode _processingMode;
+        private SortField _sortField = SortField.Name;
+        private bool _sortAscending = true;
+
+        public XCITrimmerViewModel(MainWindowViewModel mainWindowViewModel)
+        {
+            _logger = new XCITrimmerLog.TrimmerWindow(this);
+            _mainWindowViewModel = mainWindowViewModel;
+            LoadXCIApplications();
+        }
+
+        private void LoadXCIApplications()
+        {
+            var apps = ApplicationLibrary.Applications.Items
+                .Where(app => app.FileExtension == _FileExtXCI);
+
+            foreach (var xciApp in apps)
+                AddOrUpdateXCITrimmerFile(CreateXCITrimmerFile(xciApp.Path));
+
+            ApplicationsChanged();
+        }
+
+        private XCITrimmerFileModel CreateXCITrimmerFile(
+            string path,
+            OperationOutcome operationOutcome = OperationOutcome.Undetermined)
+        {
+            var xciApp = ApplicationLibrary.Applications.Items.First(app => app.FileExtension == _FileExtXCI && app.Path == path);
+            return XCITrimmerFileModel.FromApplicationData(xciApp, _logger) with { ProcessingOutcome = operationOutcome };
+        }
+
+        private bool AddOrUpdateXCITrimmerFile(XCITrimmerFileModel xci, bool suppressChanged = true, bool autoSelect = true)
+        {
+            bool replaced = _allXCIFiles.ReplaceWith(xci);
+            _displayedXCIFiles.ReplaceWith(xci, Filter(xci));
+            _selectedXCIFiles.ReplaceWith(xci, xci.Trimmable && autoSelect);
+
+            if (!suppressChanged)
+                ApplicationsChanged();
+
+            return replaced;
+        }
+
+        private void FilteringChanged()
+        {
+            OnPropertyChanged(nameof(Search));
+            SortAndFilter();
+        }
+
+        private void SortingChanged()
+        {
+            OnPropertyChanged(nameof(IsSortedByName));
+            OnPropertyChanged(nameof(IsSortedBySaved));
+            OnPropertyChanged(nameof(SortingAscending));
+            OnPropertyChanged(nameof(SortingField));
+            OnPropertyChanged(nameof(SortingFieldName));
+            SortAndFilter();
+        }
+
+        private void DisplayedChanged()
+        {
+            OnPropertyChanged(nameof(Status));
+            OnPropertyChanged(nameof(DisplayedXCIFiles));
+            OnPropertyChanged(nameof(SelectedDisplayedXCIFiles));
+        }
+
+        private void ApplicationsChanged()
+        {
+            OnPropertyChanged(nameof(AllXCIFiles));
+            OnPropertyChanged(nameof(Status));
+            OnPropertyChanged(nameof(PotentialSavings));
+            OnPropertyChanged(nameof(ActualSavings));
+            OnPropertyChanged(nameof(CanTrim));
+            OnPropertyChanged(nameof(CanUntrim));
+            DisplayedChanged();
+            SortAndFilter();
+        }
+
+        private void SelectionChanged(bool displayedChanged = true)
+        {
+            OnPropertyChanged(nameof(Status));
+            OnPropertyChanged(nameof(CanTrim));
+            OnPropertyChanged(nameof(CanUntrim));
+            OnPropertyChanged(nameof(SelectedXCIFiles));
+
+            if (displayedChanged)
+                OnPropertyChanged(nameof(SelectedDisplayedXCIFiles));
+        }
+
+        private void ProcessingChanged()
+        {
+            OnPropertyChanged(nameof(Processing));
+            OnPropertyChanged(nameof(Cancel));
+            OnPropertyChanged(nameof(Status));
+            OnPropertyChanged(nameof(CanTrim));
+            OnPropertyChanged(nameof(CanUntrim));
+        }
+
+        private IEnumerable<XCITrimmerFileModel> GetSelectedDisplayedXCIFiles()
+        {
+            return _displayedXCIFiles.Where(xci => _selectedXCIFiles.Contains(xci));
+        }
+
+        private void PerformOperation(ProcessingMode processingMode)
+        {
+            if (Processing)
+            {
+                return;
+            }
+
+            _processingMode = processingMode;
+            Processing = true;
+            var cancellationToken = _cancellationTokenSource.Token;
+
+            Thread XCIFileTrimThread = new(() =>
+            {
+                var toProcess = Sort(SelectedXCIFiles
+                    .Where(xci =>
+                        (processingMode == ProcessingMode.Untrimming && xci.Untrimmable) ||
+                        (processingMode == ProcessingMode.Trimming && xci.Trimmable)
+                    )).ToList();
+
+                var viewsSaved = DisplayedXCIFiles.ToList();
+
+                Dispatcher.UIThread.Post(() =>
+                {
+                    _selectedXCIFiles.Clear();
+                    _displayedXCIFiles.Clear();
+                    _displayedXCIFiles.AddRange(toProcess);
+                });
+
+                try
+                {
+                    foreach (var xciApp in toProcess)
+                    {
+                        if (cancellationToken.IsCancellationRequested)
+                            break;
+
+                        var trimmer = new XCIFileTrimmer(xciApp.Path, _logger);
+
+                        Dispatcher.UIThread.Post(() =>
+                        {
+                            ProcessingApplication = xciApp;
+                        });
+
+                        var outcome = OperationOutcome.Undetermined;
+
+                        try
+                        {
+                            if (cancellationToken.IsCancellationRequested)
+                                break;
+
+                            switch (processingMode)
+                            {
+                                case ProcessingMode.Trimming:
+                                    outcome = trimmer.Trim(cancellationToken);
+                                    break;
+                                case ProcessingMode.Untrimming:
+                                    outcome = trimmer.Untrim(cancellationToken);
+                                    break;
+                            }
+
+                            if (outcome == OperationOutcome.Cancelled)
+                                outcome = OperationOutcome.Undetermined;
+                        }
+                        finally
+                        {
+                            Dispatcher.UIThread.Post(() =>
+                            {
+                                ProcessingApplication = CreateXCITrimmerFile(xciApp.Path);
+                                AddOrUpdateXCITrimmerFile(ProcessingApplication, false, false);
+                                ProcessingApplication = null;
+                            });
+                        }
+                    }
+                }
+                finally
+                {
+                    Dispatcher.UIThread.Post(() =>
+                    {
+                        _displayedXCIFiles.AddOrReplaceMatching(_allXCIFiles, viewsSaved);
+                        _selectedXCIFiles.AddOrReplaceMatching(_allXCIFiles, toProcess);
+                        Processing = false;
+                        ApplicationsChanged();
+                    });
+                }
+            })
+            {
+                Name = "GUI.XCIFilesTrimmerThread",
+                IsBackground = true,
+            };
+
+            XCIFileTrimThread.Start();
+        }
+
+        private bool Filter<T>(T arg)
+        {
+            if (arg is XCITrimmerFileModel content)
+            {
+                return string.IsNullOrWhiteSpace(_search)
+                    || content.Name.ToLower().Contains(_search.ToLower())
+                    || content.Path.ToLower().Contains(_search.ToLower());
+            }
+
+            return false;
+        }
+
+        private class CompareXCITrimmerFiles : IComparer<XCITrimmerFileModel>
+        {
+            private XCITrimmerViewModel _viewModel;
+
+            public CompareXCITrimmerFiles(XCITrimmerViewModel ViewModel)
+            {
+                _viewModel = ViewModel;
+            }
+
+            public int Compare(XCITrimmerFileModel x, XCITrimmerFileModel y)
+            {
+                int result = 0;
+
+                switch (_viewModel.SortingField)
+                {
+                    case SortField.Name:
+                        result = x.Name.CompareTo(y.Name);
+                        break;
+                    case SortField.Saved:
+                        result = x.PotentialSavingsB.CompareTo(y.PotentialSavingsB);
+                        break;
+                }
+
+                if (!_viewModel.SortingAscending)
+                    result = -result;
+
+                if (result == 0)
+                    result = x.Path.CompareTo(y.Path);
+
+                return result;
+            }
+        }
+
+        private IOrderedEnumerable<XCITrimmerFileModel> Sort(IEnumerable<XCITrimmerFileModel> list)
+        {
+            return list
+                .OrderBy(xci => xci, new CompareXCITrimmerFiles(this))
+                .ThenBy(it => it.Path);
+        }
+
+        public void TrimSelected()
+        {
+            PerformOperation(ProcessingMode.Trimming);
+        }
+
+        public void UntrimSelected()
+        {
+            PerformOperation(ProcessingMode.Untrimming);
+        }
+
+        public void SetProgress(int current, int maximum)
+        {
+            if (_processingApplication != null)
+            {
+                int percentageProgress = 100 * current / maximum;
+                if (!ProcessingApplication.HasValue || (ProcessingApplication.Value.PercentageProgress != percentageProgress))
+                    ProcessingApplication = ProcessingApplication.Value with { PercentageProgress = percentageProgress };
+            }
+        }
+
+        public void SelectDisplayed()
+        {
+            SelectedXCIFiles.AddRange(DisplayedXCIFiles);
+            SelectionChanged();
+        }
+
+        public void DeselectDisplayed()
+        {
+            SelectedXCIFiles.RemoveMany(DisplayedXCIFiles);
+            SelectionChanged();
+        }
+
+        public void Select(XCITrimmerFileModel model)
+        {
+            bool selectionChanged = !SelectedXCIFiles.Contains(model);
+            bool displayedSelectionChanged = !SelectedDisplayedXCIFiles.Contains(model);
+            SelectedXCIFiles.ReplaceOrAdd(model, model);
+            if (selectionChanged)
+                SelectionChanged(displayedSelectionChanged);
+        }
+
+        public void Deselect(XCITrimmerFileModel model)
+        {
+            bool displayedSelectionChanged = !SelectedDisplayedXCIFiles.Contains(model);
+            if (SelectedXCIFiles.Remove(model))
+                SelectionChanged(displayedSelectionChanged);
+        }
+
+        public void SortAndFilter()
+        {
+            if (Processing)
+                return;
+
+            Sort(AllXCIFiles)
+                .AsObservableChangeSet()
+                .Filter(Filter)
+                .Bind(out var view).AsObservableList();
+
+            _displayedXCIFiles.Clear();
+            _displayedXCIFiles.AddRange(view);
+
+            DisplayedChanged();
+        }
+
+        public Optional<XCITrimmerFileModel> ProcessingApplication
+        {
+            get => _processingApplication;
+            set
+            {
+                if (!value.HasValue && _processingApplication.HasValue)
+                    value = _processingApplication.Value with { PercentageProgress = null };
+
+                if (value.HasValue)
+                    _displayedXCIFiles.ReplaceWith(value.Value);
+
+                _processingApplication = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public bool Processing
+        {
+            get => _cancellationTokenSource != null;
+            private set
+            {
+                if (value && !Processing)
+                {
+                    _cancellationTokenSource = new CancellationTokenSource();
+                }
+                else if (!value && Processing)
+                {
+                    _cancellationTokenSource.Dispose();
+                    _cancellationTokenSource = null;
+                }
+
+                ProcessingChanged();
+            }
+        }
+
+        public bool Cancel
+        {
+            get => _cancellationTokenSource != null && _cancellationTokenSource.IsCancellationRequested;
+            set
+            {
+                if (value)
+                {
+                    if (!Processing)
+                        return;
+
+                    _cancellationTokenSource.Cancel();
+                }
+
+                ProcessingChanged();
+            }
+        }
+
+        public string Status
+        {
+            get
+            {
+                if (Processing)
+                {
+                    return _processingMode switch
+                    {
+                        ProcessingMode.Trimming => string.Format(LocaleManager.Instance[LocaleKeys.XCITrimmerTitleStatusTrimming], DisplayedXCIFiles.Count),
+                        ProcessingMode.Untrimming => string.Format(LocaleManager.Instance[LocaleKeys.XCITrimmerTitleStatusUntrimming], DisplayedXCIFiles.Count),
+                        _ => string.Empty
+                    };
+                }
+                else
+                {
+                    return string.IsNullOrEmpty(Search) ?
+                        string.Format(LocaleManager.Instance[LocaleKeys.XCITrimmerTitleStatusCount], SelectedXCIFiles.Count, AllXCIFiles.Count) :
+                        string.Format(LocaleManager.Instance[LocaleKeys.XCITrimmerTitleStatusCountWithFilter], SelectedXCIFiles.Count, AllXCIFiles.Count, DisplayedXCIFiles.Count);
+                }
+            }
+        }
+
+        public string Search
+        {
+            get => _search;
+            set
+            {
+                _search = value;
+                FilteringChanged();
+            }
+        }
+
+        public SortField SortingField
+        {
+            get => _sortField;
+            set
+            {
+                _sortField = value;
+                SortingChanged();
+            }
+        }
+
+        public string SortingFieldName
+        {
+            get
+            {
+                return SortingField switch
+                {
+                    SortField.Name => LocaleManager.Instance[LocaleKeys.XCITrimmerSortName],
+                    SortField.Saved => LocaleManager.Instance[LocaleKeys.XCITrimmerSortSaved],
+                    _ => string.Empty,
+                };
+            }
+        }
+        public bool SortingAscending
+        {
+            get => _sortAscending;
+            set
+            {
+                _sortAscending = value;
+                SortingChanged();
+            }
+        }
+
+        public bool IsSortedByName
+        {
+            get => _sortField == SortField.Name;
+        }
+
+        public bool IsSortedBySaved
+        {
+            get => _sortField == SortField.Saved;
+        }
+
+        public AvaloniaList<XCITrimmerFileModel> SelectedXCIFiles
+        {
+            get => _selectedXCIFiles;
+            set
+            {
+                _selectedXCIFiles = value;
+                SelectionChanged();
+            }
+        }
+
+        public AvaloniaList<XCITrimmerFileModel> AllXCIFiles
+        {
+            get => _allXCIFiles;
+        }
+
+        public AvaloniaList<XCITrimmerFileModel> DisplayedXCIFiles
+        {
+            get => _displayedXCIFiles;
+        }
+
+        public string PotentialSavings
+        {
+            get
+            {
+                return string.Format(LocaleManager.Instance[LocaleKeys.XCITrimmerSavingsMb], AllXCIFiles.Sum(xci => xci.PotentialSavingsB / _bytesPerMB));
+            }
+        }
+
+        public string ActualSavings
+        {
+            get
+            {
+                return string.Format(LocaleManager.Instance[LocaleKeys.XCITrimmerSavingsMb], AllXCIFiles.Sum(xci => xci.CurrentSavingsB / _bytesPerMB));
+            }
+        }
+
+        public IEnumerable<XCITrimmerFileModel> SelectedDisplayedXCIFiles
+        {
+            get
+            {
+                return GetSelectedDisplayedXCIFiles().ToList();
+            }
+        }
+
+        public bool CanTrim
+        {
+            get
+            {
+                return !Processing && _selectedXCIFiles.Any(xci => xci.Trimmable);
+            }
+        }
+
+        public bool CanUntrim
+        {
+            get
+            {
+                return !Processing && _selectedXCIFiles.Any(xci => xci.Untrimmable);
+            }
+        }
+    }
+}