Code style - Use file scoped namespaces

Code style - Ran code cleanup

src/Artemis.UI/Screens/Plugins/Dialogs/PluginPrerequisitesInstallDialogView.axaml.cs

@@ -1,11 +1,9 @@
-using Avalonia;
-using Avalonia.Controls;
-using Avalonia.Markup.Xaml;
+using Avalonia.Markup.Xaml;
 using Avalonia.ReactiveUI;
 
 namespace Artemis.UI.Screens.Plugins;
 
-public partial class PluginPrerequisitesInstallDialogView : ReactiveUserControl<PluginPrerequisitesInstallDialogViewModel>
+public class PluginPrerequisitesInstallDialogView : ReactiveUserControl<PluginPrerequisitesInstallDialogViewModel>
 {
     public PluginPrerequisitesInstallDialogView()
     {

src/Artemis.UI/Screens/Plugins/Dialogs/PluginPrerequisitesInstallDialogViewModel.cs

@@ -15,136 +15,135 @@ using FluentAvalonia.UI.Controls;
 using ReactiveUI;
 using ContentDialogButton = Artemis.UI.Shared.Services.Builders.ContentDialogButton;
 
-namespace Artemis.UI.Screens.Plugins
+namespace Artemis.UI.Screens.Plugins;
+
+public class PluginPrerequisitesInstallDialogViewModel : ContentDialogViewModelBase
 {
-    public class PluginPrerequisitesInstallDialogViewModel : ContentDialogViewModelBase
+    private PluginPrerequisiteViewModel? _activePrerequisite;
+    private bool _canInstall;
+    private bool _showFailed;
+    private bool _showInstall = true;
+    private bool _showIntro = true;
+    private bool _showProgress;
+    private CancellationTokenSource? _tokenSource;
+
+    public PluginPrerequisitesInstallDialogViewModel(List<IPrerequisitesSubject> subjects, IPrerequisitesVmFactory prerequisitesVmFactory)
     {
-        private PluginPrerequisiteViewModel? _activePrerequisite;
-        private bool _canInstall;
-        private bool _showFailed;
-        private bool _showInstall = true;
-        private bool _showIntro = true;
-        private bool _showProgress;
-        private CancellationTokenSource? _tokenSource;
+        Prerequisites = new ObservableCollection<PluginPrerequisiteViewModel>();
+        foreach (PluginPrerequisite prerequisite in subjects.SelectMany(prerequisitesSubject => prerequisitesSubject.PlatformPrerequisites))
+            Prerequisites.Add(prerequisitesVmFactory.PluginPrerequisiteViewModel(prerequisite, false));
+        Install = ReactiveCommand.CreateFromTask(ExecuteInstall, this.WhenAnyValue(vm => vm.CanInstall));
 
-        public PluginPrerequisitesInstallDialogViewModel(List<IPrerequisitesSubject> subjects, IPrerequisitesVmFactory prerequisitesVmFactory)
+        Dispatcher.UIThread.Post(() => CanInstall = Prerequisites.Any(p => !p.PluginPrerequisite.IsMet()), DispatcherPriority.Background);
+        this.WhenActivated(d =>
         {
-            Prerequisites = new ObservableCollection<PluginPrerequisiteViewModel>();
-            foreach (PluginPrerequisite prerequisite in subjects.SelectMany(prerequisitesSubject => prerequisitesSubject.PlatformPrerequisites))
-                Prerequisites.Add(prerequisitesVmFactory.PluginPrerequisiteViewModel(prerequisite, false));
-            Install = ReactiveCommand.CreateFromTask(ExecuteInstall, this.WhenAnyValue(vm => vm.CanInstall));
-
-            Dispatcher.UIThread.Post(() => CanInstall = Prerequisites.Any(p => !p.PluginPrerequisite.IsMet()), DispatcherPriority.Background);
-            this.WhenActivated(d =>
+            Disposable.Create(() =>
             {
-                Disposable.Create(() =>
-                {
-                    _tokenSource?.Cancel();
-                    _tokenSource?.Dispose();
-                    _tokenSource = null;
-                }).DisposeWith(d);
-            });
-        }
+                _tokenSource?.Cancel();
+                _tokenSource?.Dispose();
+                _tokenSource = null;
+            }).DisposeWith(d);
+        });
+    }
 
-        public ReactiveCommand<Unit, Unit> Install { get; }
-        public ObservableCollection<PluginPrerequisiteViewModel> Prerequisites { get; }
+    public ReactiveCommand<Unit, Unit> Install { get; }
+    public ObservableCollection<PluginPrerequisiteViewModel> Prerequisites { get; }
 
-        public PluginPrerequisiteViewModel? ActivePrerequisite
+    public PluginPrerequisiteViewModel? ActivePrerequisite
+    {
+        get => _activePrerequisite;
+        set => RaiseAndSetIfChanged(ref _activePrerequisite, value);
+    }
+
+    public bool ShowProgress
+    {
+        get => _showProgress;
+        set => RaiseAndSetIfChanged(ref _showProgress, value);
+    }
+
+    public bool ShowIntro
+    {
+        get => _showIntro;
+        set => RaiseAndSetIfChanged(ref _showIntro, value);
+    }
+
+    public bool ShowFailed
+    {
+        get => _showFailed;
+        set => RaiseAndSetIfChanged(ref _showFailed, value);
+    }
+
+    public bool ShowInstall
+    {
+        get => _showInstall;
+        set => RaiseAndSetIfChanged(ref _showInstall, value);
+    }
+
+    public bool CanInstall
+    {
+        get => _canInstall;
+        set => RaiseAndSetIfChanged(ref _canInstall, value);
+    }
+
+    public static async Task Show(IWindowService windowService, List<IPrerequisitesSubject> subjects)
+    {
+        await windowService.CreateContentDialog()
+            .WithTitle("Plugin prerequisites")
+            .WithViewModel(out PluginPrerequisitesInstallDialogViewModel vm, ("subjects", subjects))
+            .WithCloseButtonText("Cancel")
+            .HavingPrimaryButton(b => b.WithText("Install").WithCommand(vm.Install))
+            .WithDefaultButton(ContentDialogButton.Primary)
+            .ShowAsync();
+    }
+
+    private async Task ExecuteInstall()
+    {
+        ContentDialogClosingDeferral? deferral = null;
+        if (ContentDialog != null)
+            ContentDialog.Closing += (_, args) => deferral = args.GetDeferral();
+
+        CanInstall = false;
+        ShowFailed = false;
+        ShowIntro = false;
+        ShowProgress = true;
+
+        _tokenSource?.Dispose();
+        _tokenSource = new CancellationTokenSource();
+
+        try
         {
-            get => _activePrerequisite;
-            set => RaiseAndSetIfChanged(ref _activePrerequisite, value);
-        }
-
-        public bool ShowProgress
-        {
-            get => _showProgress;
-            set => RaiseAndSetIfChanged(ref _showProgress, value);
-        }
-
-        public bool ShowIntro
-        {
-            get => _showIntro;
-            set => RaiseAndSetIfChanged(ref _showIntro, value);
-        }
-
-        public bool ShowFailed
-        {
-            get => _showFailed;
-            set => RaiseAndSetIfChanged(ref _showFailed, value);
-        }
-
-        public bool ShowInstall
-        {
-            get => _showInstall;
-            set => RaiseAndSetIfChanged(ref _showInstall, value);
-        }
-
-        public bool CanInstall
-        {
-            get => _canInstall;
-            set => RaiseAndSetIfChanged(ref _canInstall, value);
-        }
-
-        private async Task ExecuteInstall()
-        {
-            ContentDialogClosingDeferral? deferral = null;
-            if (ContentDialog != null)
-                ContentDialog.Closing += (_, args) => deferral = args.GetDeferral();
-
-            CanInstall = false;
-            ShowFailed = false;
-            ShowIntro = false;
-            ShowProgress = true;
-
-            _tokenSource?.Dispose();
-            _tokenSource = new CancellationTokenSource();
-
-            try
+            foreach (PluginPrerequisiteViewModel pluginPrerequisiteViewModel in Prerequisites)
             {
-                foreach (PluginPrerequisiteViewModel pluginPrerequisiteViewModel in Prerequisites)
+                pluginPrerequisiteViewModel.IsMet = pluginPrerequisiteViewModel.PluginPrerequisite.IsMet();
+                if (pluginPrerequisiteViewModel.IsMet)
+                    continue;
+
+                ActivePrerequisite = pluginPrerequisiteViewModel;
+                await ActivePrerequisite.Install(_tokenSource.Token);
+
+                if (!ActivePrerequisite.IsMet)
                 {
-                    pluginPrerequisiteViewModel.IsMet = pluginPrerequisiteViewModel.PluginPrerequisite.IsMet();
-                    if (pluginPrerequisiteViewModel.IsMet)
-                        continue;
-
-                    ActivePrerequisite = pluginPrerequisiteViewModel;
-                    await ActivePrerequisite.Install(_tokenSource.Token);
-
-                    if (!ActivePrerequisite.IsMet)
-                    {
-                        CanInstall = true;
-                        ShowFailed = true;
-                        ShowProgress = false;
-                        return;
-                    }
-
-                    // Wait after the task finished for the user to process what happened
-                    if (pluginPrerequisiteViewModel != Prerequisites.Last())
-                        await Task.Delay(250);
-                    else
-                        await Task.Delay(1000);
+                    CanInstall = true;
+                    ShowFailed = true;
+                    ShowProgress = false;
+                    return;
                 }
 
-                if (deferral != null)
-                    deferral.Complete();
+                // Wait after the task finished for the user to process what happened
+                if (pluginPrerequisiteViewModel != Prerequisites.Last())
+                    await Task.Delay(250);
                 else
-                    ContentDialog?.Hide(ContentDialogResult.Primary);
+                    await Task.Delay(1000);
             }
-            catch (OperationCanceledException)
-            {
-                // ignored
-            }
-        }
 
-        public static async Task Show(IWindowService windowService, List<IPrerequisitesSubject> subjects)
+            if (deferral != null)
+                deferral.Complete();
+            else
+                ContentDialog?.Hide(ContentDialogResult.Primary);
+        }
+        catch (OperationCanceledException)
         {
-            await windowService.CreateContentDialog()
-                .WithTitle("Plugin prerequisites")
-                .WithViewModel(out PluginPrerequisitesInstallDialogViewModel vm, ("subjects", subjects))
-                .WithCloseButtonText("Cancel")
-                .HavingPrimaryButton(b => b.WithText("Install").WithCommand(vm.Install))
-                .WithDefaultButton(ContentDialogButton.Primary)
-                .ShowAsync();
+            // ignored
         }
     }
 }

src/Artemis.UI/Screens/Plugins/Dialogs/PluginPrerequisitesUninstallDialogView.axaml.cs

@@ -1,11 +1,9 @@
-using Avalonia;
-using Avalonia.Controls;
-using Avalonia.Markup.Xaml;
+using Avalonia.Markup.Xaml;
 using Avalonia.ReactiveUI;
 
 namespace Artemis.UI.Screens.Plugins;
 
-public partial class PluginPrerequisitesUninstallDialogView : ReactiveUserControl<PluginPrerequisitesUninstallDialogViewModel>
+public class PluginPrerequisitesUninstallDialogView : ReactiveUserControl<PluginPrerequisitesUninstallDialogViewModel>
 {
     public PluginPrerequisitesUninstallDialogView()
     {

src/Artemis.UI/Screens/Plugins/Dialogs/PluginPrerequisitesUninstallDialogViewModel.cs

@@ -16,144 +16,143 @@ using FluentAvalonia.UI.Controls;
 using ReactiveUI;
 using ContentDialogButton = Artemis.UI.Shared.Services.Builders.ContentDialogButton;
 
-namespace Artemis.UI.Screens.Plugins
+namespace Artemis.UI.Screens.Plugins;
+
+public class PluginPrerequisitesUninstallDialogViewModel : ContentDialogViewModelBase
 {
-    public class PluginPrerequisitesUninstallDialogViewModel : ContentDialogViewModelBase
+    private readonly IPluginManagementService _pluginManagementService;
+    private readonly List<IPrerequisitesSubject> _subjects;
+    private readonly IWindowService _windowService;
+    private PluginPrerequisiteViewModel? _activePrerequisite;
+    private bool _canUninstall;
+    private CancellationTokenSource? _tokenSource;
+
+    public PluginPrerequisitesUninstallDialogViewModel(List<IPrerequisitesSubject> subjects,
+        IPrerequisitesVmFactory prerequisitesVmFactory,
+        IWindowService windowService,
+        IPluginManagementService pluginManagementService)
     {
-        private readonly IPluginManagementService _pluginManagementService;
-        private readonly List<IPrerequisitesSubject> _subjects;
-        private readonly IWindowService _windowService;
-        private PluginPrerequisiteViewModel? _activePrerequisite;
-        private bool _canUninstall;
-        private CancellationTokenSource? _tokenSource;
+        _subjects = subjects;
+        _windowService = windowService;
+        _pluginManagementService = pluginManagementService;
 
-        public PluginPrerequisitesUninstallDialogViewModel(List<IPrerequisitesSubject> subjects,
-            IPrerequisitesVmFactory prerequisitesVmFactory,
-            IWindowService windowService,
-            IPluginManagementService pluginManagementService)
+        Prerequisites = new ObservableCollection<PluginPrerequisiteViewModel>();
+        foreach (PluginPrerequisite prerequisite in subjects.SelectMany(prerequisitesSubject => prerequisitesSubject.PlatformPrerequisites))
+            Prerequisites.Add(prerequisitesVmFactory.PluginPrerequisiteViewModel(prerequisite, true));
+        Uninstall = ReactiveCommand.CreateFromTask(ExecuteUninstall, this.WhenAnyValue(vm => vm.CanUninstall));
+
+        // Could be slow so take it off of the UI thread
+        Dispatcher.UIThread.Post(() => CanUninstall = Prerequisites.Any(p => p.PluginPrerequisite.IsMet()), DispatcherPriority.Background);
+
+        this.WhenActivated(d =>
         {
-            _subjects = subjects;
-            _windowService = windowService;
-            _pluginManagementService = pluginManagementService;
-
-            Prerequisites = new ObservableCollection<PluginPrerequisiteViewModel>();
-            foreach (PluginPrerequisite prerequisite in subjects.SelectMany(prerequisitesSubject => prerequisitesSubject.PlatformPrerequisites))
-                Prerequisites.Add(prerequisitesVmFactory.PluginPrerequisiteViewModel(prerequisite, true));
-            Uninstall = ReactiveCommand.CreateFromTask(ExecuteUninstall, this.WhenAnyValue(vm => vm.CanUninstall));
-
-            // Could be slow so take it off of the UI thread
-            Dispatcher.UIThread.Post(() => CanUninstall = Prerequisites.Any(p => p.PluginPrerequisite.IsMet()), DispatcherPriority.Background);
-
-            this.WhenActivated(d =>
+            Disposable.Create(() =>
             {
-                Disposable.Create(() =>
-                {
-                    _tokenSource?.Cancel();
-                    _tokenSource?.Dispose();
-                    _tokenSource = null;
-                }).DisposeWith(d);
-            });
+                _tokenSource?.Cancel();
+                _tokenSource?.Dispose();
+                _tokenSource = null;
+            }).DisposeWith(d);
+        });
+    }
+
+    public ReactiveCommand<Unit, Unit> Uninstall { get; }
+    public ObservableCollection<PluginPrerequisiteViewModel> Prerequisites { get; }
+
+    public PluginPrerequisiteViewModel? ActivePrerequisite
+    {
+        get => _activePrerequisite;
+        set => RaiseAndSetIfChanged(ref _activePrerequisite, value);
+    }
+
+    public bool CanUninstall
+    {
+        get => _canUninstall;
+        set => RaiseAndSetIfChanged(ref _canUninstall, value);
+    }
+
+    public static async Task Show(IWindowService windowService, List<IPrerequisitesSubject> subjects, string cancelLabel = "Cancel")
+    {
+        await windowService.CreateContentDialog()
+            .WithTitle("Plugin prerequisites")
+            .WithViewModel(out PluginPrerequisitesUninstallDialogViewModel vm, ("subjects", subjects))
+            .WithCloseButtonText(cancelLabel)
+            .HavingPrimaryButton(b => b.WithText("Uninstall").WithCommand(vm.Uninstall))
+            .WithDefaultButton(ContentDialogButton.Primary)
+            .ShowAsync();
+    }
+
+    private async Task ExecuteUninstall()
+    {
+        ContentDialogClosingDeferral? deferral = null;
+        if (ContentDialog != null)
+            ContentDialog.Closing += (_, args) => deferral = args.GetDeferral();
+
+        CanUninstall = false;
+
+        // Disable all subjects that are plugins, this will disable their features too
+        foreach (IPrerequisitesSubject prerequisitesSubject in _subjects)
+        {
+            if (prerequisitesSubject is PluginInfo pluginInfo)
+                _pluginManagementService.DisablePlugin(pluginInfo.Plugin, true);
         }
 
-        public ReactiveCommand<Unit, Unit> Uninstall { get; }
-        public ObservableCollection<PluginPrerequisiteViewModel> Prerequisites { get; }
-
-        public PluginPrerequisiteViewModel? ActivePrerequisite
+        // Disable all subjects that are features if still required
+        foreach (IPrerequisitesSubject prerequisitesSubject in _subjects)
         {
-            get => _activePrerequisite;
-            set => RaiseAndSetIfChanged(ref _activePrerequisite, value);
+            if (prerequisitesSubject is not PluginFeatureInfo featureInfo)
+                continue;
+
+            // Disable the parent plugin if the feature is AlwaysEnabled
+            if (featureInfo.AlwaysEnabled)
+                _pluginManagementService.DisablePlugin(featureInfo.Plugin, true);
+            else if (featureInfo.Instance != null)
+                _pluginManagementService.DisablePluginFeature(featureInfo.Instance, true);
         }
 
-        public bool CanUninstall
+        _tokenSource?.Dispose();
+        _tokenSource = new CancellationTokenSource();
+
+        try
         {
-            get => _canUninstall;
-            set => RaiseAndSetIfChanged(ref _canUninstall, value);
-        }
-
-        private async Task ExecuteUninstall()
-        {
-            ContentDialogClosingDeferral? deferral = null;
-            if (ContentDialog != null)
-                ContentDialog.Closing += (_, args) => deferral = args.GetDeferral();
-
-            CanUninstall = false;
-
-            // Disable all subjects that are plugins, this will disable their features too
-            foreach (IPrerequisitesSubject prerequisitesSubject in _subjects)
+            foreach (PluginPrerequisiteViewModel pluginPrerequisiteViewModel in Prerequisites)
             {
-                if (prerequisitesSubject is PluginInfo pluginInfo)
-                    _pluginManagementService.DisablePlugin(pluginInfo.Plugin, true);
-            }
-
-            // Disable all subjects that are features if still required
-            foreach (IPrerequisitesSubject prerequisitesSubject in _subjects)
-            {
-                if (prerequisitesSubject is not PluginFeatureInfo featureInfo)
+                pluginPrerequisiteViewModel.IsMet = pluginPrerequisiteViewModel.PluginPrerequisite.IsMet();
+                if (!pluginPrerequisiteViewModel.IsMet)
                     continue;
 
-                // Disable the parent plugin if the feature is AlwaysEnabled
-                if (featureInfo.AlwaysEnabled)
-                    _pluginManagementService.DisablePlugin(featureInfo.Plugin, true);
-                else if (featureInfo.Instance != null)
-                    _pluginManagementService.DisablePluginFeature(featureInfo.Instance, true);
-            }
+                ActivePrerequisite = pluginPrerequisiteViewModel;
+                await ActivePrerequisite.Uninstall(_tokenSource.Token);
 
-            _tokenSource?.Dispose();
-            _tokenSource = new CancellationTokenSource();
-
-            try
-            {
-                foreach (PluginPrerequisiteViewModel pluginPrerequisiteViewModel in Prerequisites)
-                {
-                    pluginPrerequisiteViewModel.IsMet = pluginPrerequisiteViewModel.PluginPrerequisite.IsMet();
-                    if (!pluginPrerequisiteViewModel.IsMet)
-                        continue;
-
-                    ActivePrerequisite = pluginPrerequisiteViewModel;
-                    await ActivePrerequisite.Uninstall(_tokenSource.Token);
-
-                    // Wait after the task finished for the user to process what happened
-                    if (pluginPrerequisiteViewModel != Prerequisites.Last())
-                        await Task.Delay(250);
-                    else
-                        await Task.Delay(1000);
-                }
-
-                if (deferral != null)
-                    deferral.Complete();
+                // Wait after the task finished for the user to process what happened
+                if (pluginPrerequisiteViewModel != Prerequisites.Last())
+                    await Task.Delay(250);
                 else
-                    ContentDialog?.Hide(ContentDialogResult.Primary);
-                
-                // This shouldn't be happening and the experience isn't very nice for the user (too lazy to make a nice UI for such an edge case)
-                // but at least give some feedback
-                if (Prerequisites.Any(p => p.IsMet))
-                {
-                    await _windowService.CreateContentDialog()
-                        .WithTitle("Plugin prerequisites")
-                        .WithContent("The plugin was not able to fully remove all prerequisites. \r\nPlease try again or contact the plugin creator.")
-                        .ShowAsync();
-                    await Show(_windowService, _subjects);
-                }
+                    await Task.Delay(1000);
             }
-            catch (OperationCanceledException)
+
+            if (deferral != null)
+                deferral.Complete();
+            else
+                ContentDialog?.Hide(ContentDialogResult.Primary);
+
+            // This shouldn't be happening and the experience isn't very nice for the user (too lazy to make a nice UI for such an edge case)
+            // but at least give some feedback
+            if (Prerequisites.Any(p => p.IsMet))
             {
-                // ignored
-            }
-            finally
-            {
-                CanUninstall = true;
+                await _windowService.CreateContentDialog()
+                    .WithTitle("Plugin prerequisites")
+                    .WithContent("The plugin was not able to fully remove all prerequisites. \r\nPlease try again or contact the plugin creator.")
+                    .ShowAsync();
+                await Show(_windowService, _subjects);
             }
         }
-
-        public static async Task Show(IWindowService windowService, List<IPrerequisitesSubject> subjects, string cancelLabel = "Cancel")
+        catch (OperationCanceledException)
         {
-            await windowService.CreateContentDialog()
-                .WithTitle("Plugin prerequisites")
-                .WithViewModel(out PluginPrerequisitesUninstallDialogViewModel vm, ("subjects", subjects))
-                .WithCloseButtonText(cancelLabel)
-                .HavingPrimaryButton(b => b.WithText("Uninstall").WithCommand(vm.Uninstall))
-                .WithDefaultButton(ContentDialogButton.Primary)
-                .ShowAsync();
+            // ignored
+        }
+        finally
+        {
+            CanUninstall = true;
         }
     }
 }

src/Artemis.UI/Screens/Plugins/PluginFeatureView.axaml.cs

@@ -1,18 +1,17 @@
 using Avalonia.Markup.Xaml;
 using Avalonia.ReactiveUI;
 
-namespace Artemis.UI.Screens.Plugins
-{
-    public partial class PluginFeatureView : ReactiveUserControl<PluginFeatureViewModel>
-    {
-        public PluginFeatureView()
-        {
-            InitializeComponent();
-        }
+namespace Artemis.UI.Screens.Plugins;
 
-        private void InitializeComponent()
-        {
-            AvaloniaXamlLoader.Load(this);
-        }
+public class PluginFeatureView : ReactiveUserControl<PluginFeatureViewModel>
+{
+    public PluginFeatureView()
+    {
+        InitializeComponent();
     }
-}
+
+    private void InitializeComponent()
+    {
+        AvaloniaXamlLoader.Load(this);
+    }
+}

src/Artemis.UI/Screens/Plugins/PluginFeatureViewModel.cs

@@ -9,209 +9,207 @@ using Artemis.Core.Services;
 using Artemis.UI.Shared;
 using Artemis.UI.Shared.Services;
 using Artemis.UI.Shared.Services.Builders;
-using Avalonia;
 using Avalonia.Threading;
 using ReactiveUI;
 
-namespace Artemis.UI.Screens.Plugins
+namespace Artemis.UI.Screens.Plugins;
+
+public class PluginFeatureViewModel : ActivatableViewModelBase
 {
-    public class PluginFeatureViewModel : ActivatableViewModelBase
+    private readonly ICoreService _coreService;
+    private readonly INotificationService _notificationService;
+    private readonly IPluginManagementService _pluginManagementService;
+    private readonly IWindowService _windowService;
+    private bool _enabling;
+
+    public PluginFeatureViewModel(PluginFeatureInfo pluginFeatureInfo,
+        bool showShield,
+        ICoreService coreService,
+        IWindowService windowService,
+        INotificationService notificationService,
+        IPluginManagementService pluginManagementService)
     {
-        private readonly ICoreService _coreService;
-        private readonly INotificationService _notificationService;
-        private readonly IPluginManagementService _pluginManagementService;
-        private readonly IWindowService _windowService;
-        private bool _enabling;
+        _coreService = coreService;
+        _windowService = windowService;
+        _notificationService = notificationService;
+        _pluginManagementService = pluginManagementService;
 
-        public PluginFeatureViewModel(PluginFeatureInfo pluginFeatureInfo,
-            bool showShield,
-            ICoreService coreService,
-            IWindowService windowService,
-            INotificationService notificationService,
-            IPluginManagementService pluginManagementService)
+        FeatureInfo = pluginFeatureInfo;
+        ShowShield = FeatureInfo.Plugin.Info.RequiresAdmin && showShield;
+
+        ShowLogsFolder = ReactiveCommand.Create(ExecuteShowLogsFolder);
+        ViewLoadException = ReactiveCommand.Create(ExecuteViewLoadException);
+        InstallPrerequisites = ReactiveCommand.CreateFromTask(ExecuteInstallPrerequisites);
+        RemovePrerequisites = ReactiveCommand.CreateFromTask(ExecuteRemovePrerequisites);
+
+        this.WhenActivated(d =>
         {
-            _coreService = coreService;
-            _windowService = windowService;
-            _notificationService = notificationService;
-            _pluginManagementService = pluginManagementService;
+            _pluginManagementService.PluginFeatureEnabling += OnFeatureEnabling;
+            _pluginManagementService.PluginFeatureEnabled += OnFeatureEnableStopped;
+            _pluginManagementService.PluginFeatureEnableFailed += OnFeatureEnableStopped;
 
-            FeatureInfo = pluginFeatureInfo;
-            ShowShield = FeatureInfo.Plugin.Info.RequiresAdmin && showShield;
+            FeatureInfo.Plugin.Enabled += PluginOnToggled;
+            FeatureInfo.Plugin.Disabled += PluginOnToggled;
 
-            ShowLogsFolder = ReactiveCommand.Create(ExecuteShowLogsFolder);
-            ViewLoadException = ReactiveCommand.Create(ExecuteViewLoadException);
-            InstallPrerequisites = ReactiveCommand.CreateFromTask(ExecuteInstallPrerequisites);
-            RemovePrerequisites = ReactiveCommand.CreateFromTask(ExecuteRemovePrerequisites);
-
-            this.WhenActivated(d =>
+            Disposable.Create(() =>
             {
-                _pluginManagementService.PluginFeatureEnabling += OnFeatureEnabling;
-                _pluginManagementService.PluginFeatureEnabled += OnFeatureEnableStopped;
-                _pluginManagementService.PluginFeatureEnableFailed += OnFeatureEnableStopped;
+                _pluginManagementService.PluginFeatureEnabling -= OnFeatureEnabling;
+                _pluginManagementService.PluginFeatureEnabled -= OnFeatureEnableStopped;
+                _pluginManagementService.PluginFeatureEnableFailed -= OnFeatureEnableStopped;
 
-                FeatureInfo.Plugin.Enabled += PluginOnToggled;
-                FeatureInfo.Plugin.Disabled += PluginOnToggled;
+                FeatureInfo.Plugin.Enabled -= PluginOnToggled;
+                FeatureInfo.Plugin.Disabled -= PluginOnToggled;
+            }).DisposeWith(d);
+        });
+    }
 
-                Disposable.Create(() =>
-                {
-                    _pluginManagementService.PluginFeatureEnabling -= OnFeatureEnabling;
-                    _pluginManagementService.PluginFeatureEnabled -= OnFeatureEnableStopped;
-                    _pluginManagementService.PluginFeatureEnableFailed -= OnFeatureEnableStopped;
+    public ReactiveCommand<Unit, Unit> ShowLogsFolder { get; }
+    public ReactiveCommand<Unit, Unit> ViewLoadException { get; }
+    public ReactiveCommand<Unit, Unit> InstallPrerequisites { get; }
+    public ReactiveCommand<Unit, Unit> RemovePrerequisites { get; }
 
-                    FeatureInfo.Plugin.Enabled -= PluginOnToggled;
-                    FeatureInfo.Plugin.Disabled -= PluginOnToggled;
-                }).DisposeWith(d);
-            });
+    public PluginFeatureInfo FeatureInfo { get; }
+    public Exception? LoadException => FeatureInfo.LoadException;
+
+    public bool ShowShield { get; }
+
+    public bool Enabling
+    {
+        get => _enabling;
+        set => RaiseAndSetIfChanged(ref _enabling, value);
+    }
+
+    public bool IsEnabled
+    {
+        get => FeatureInfo.AlwaysEnabled || (FeatureInfo.Instance != null && FeatureInfo.Instance.IsEnabled);
+        set => Dispatcher.UIThread.InvokeAsync(() => UpdateEnabled(value));
+    }
+
+    public bool CanToggleEnabled => FeatureInfo.Plugin.IsEnabled && !FeatureInfo.AlwaysEnabled;
+    public bool CanInstallPrerequisites => FeatureInfo.PlatformPrerequisites.Any();
+    public bool CanRemovePrerequisites => FeatureInfo.PlatformPrerequisites.Any(p => p.UninstallActions.Any());
+    public bool IsPopupEnabled => CanInstallPrerequisites || CanRemovePrerequisites;
+
+    private void ExecuteShowLogsFolder()
+    {
+        try
+        {
+            Utilities.OpenFolder(Constants.LogsFolder);
+        }
+        catch (Exception e)
+        {
+            _windowService.ShowExceptionDialog("Welp, we couldn\'t open the logs folder for you", e);
+        }
+    }
+
+    private void ExecuteViewLoadException()
+    {
+        if (LoadException != null)
+            _windowService.ShowExceptionDialog("Feature failed to enable", LoadException);
+    }
+
+    private async Task ExecuteInstallPrerequisites()
+    {
+        if (FeatureInfo.PlatformPrerequisites.Any())
+            await PluginPrerequisitesInstallDialogViewModel.Show(_windowService, new List<IPrerequisitesSubject> {FeatureInfo});
+    }
+
+    private async Task ExecuteRemovePrerequisites()
+    {
+        if (FeatureInfo.PlatformPrerequisites.Any(p => p.UninstallActions.Any()))
+        {
+            await PluginPrerequisitesUninstallDialogViewModel.Show(_windowService, new List<IPrerequisitesSubject> {FeatureInfo});
+            this.RaisePropertyChanged(nameof(IsEnabled));
+        }
+    }
+
+    private async Task UpdateEnabled(bool enable)
+    {
+        if (IsEnabled == enable)
+        {
+            this.RaisePropertyChanged(nameof(IsEnabled));
+            return;
         }
 
-        public ReactiveCommand<Unit, Unit> ShowLogsFolder { get; }
-        public ReactiveCommand<Unit, Unit> ViewLoadException { get; }
-        public ReactiveCommand<Unit, Unit> InstallPrerequisites { get; }
-        public ReactiveCommand<Unit, Unit> RemovePrerequisites { get; }
-        
-        public PluginFeatureInfo FeatureInfo { get; }
-        public Exception? LoadException => FeatureInfo.LoadException;
-
-        public bool ShowShield { get; }
-
-        public bool Enabling
+        if (FeatureInfo.Instance == null)
         {
-            get => _enabling;
-            set => RaiseAndSetIfChanged(ref _enabling, value);
+            this.RaisePropertyChanged(nameof(IsEnabled));
+            _notificationService.CreateNotification()
+                .WithMessage($"Feature '{FeatureInfo.Name}' is in a broken state and cannot enable.")
+                .HavingButton(b => b.WithText("View logs").WithCommand(ShowLogsFolder))
+                .WithSeverity(NotificationSeverity.Error)
+                .Show();
+            return;
         }
 
-        public bool IsEnabled
+        if (enable)
         {
-            get => FeatureInfo.AlwaysEnabled || FeatureInfo.Instance != null && FeatureInfo.Instance.IsEnabled;
-            set => Dispatcher.UIThread.InvokeAsync(() => UpdateEnabled(value));
-        }
+            Enabling = true;
 
-        public bool CanToggleEnabled => FeatureInfo.Plugin.IsEnabled && !FeatureInfo.AlwaysEnabled;
-        public bool CanInstallPrerequisites => FeatureInfo.PlatformPrerequisites.Any();
-        public bool CanRemovePrerequisites => FeatureInfo.PlatformPrerequisites.Any(p => p.UninstallActions.Any());
-        public bool IsPopupEnabled => CanInstallPrerequisites || CanRemovePrerequisites;
-
-        private void ExecuteShowLogsFolder()
-        {
             try
             {
-                Utilities.OpenFolder(Constants.LogsFolder);
+                if (FeatureInfo.Plugin.Info.RequiresAdmin && !_coreService.IsElevated)
+                {
+                    bool confirmed = await _windowService.ShowConfirmContentDialog("Enable feature", "The plugin of this feature requires admin rights, are you sure you want to enable it?");
+                    if (!confirmed)
+                    {
+                        this.RaisePropertyChanged(nameof(IsEnabled));
+                        return;
+                    }
+                }
+
+                // Check if all prerequisites are met async
+                if (!FeatureInfo.ArePrerequisitesMet())
+                {
+                    await PluginPrerequisitesInstallDialogViewModel.Show(_windowService, new List<IPrerequisitesSubject> {FeatureInfo});
+                    if (!FeatureInfo.ArePrerequisitesMet())
+                    {
+                        this.RaisePropertyChanged(nameof(IsEnabled));
+                        return;
+                    }
+                }
+
+                await Dispatcher.UIThread.InvokeAsync(() => _pluginManagementService.EnablePluginFeature(FeatureInfo.Instance!, true));
             }
             catch (Exception e)
             {
-                _windowService.ShowExceptionDialog("Welp, we couldn\'t open the logs folder for you", e);
-            }
-        }
-
-        private void ExecuteViewLoadException()
-        {
-            if (LoadException != null)
-                _windowService.ShowExceptionDialog("Feature failed to enable", LoadException);
-        }
-
-        private async Task ExecuteInstallPrerequisites()
-        {
-            if (FeatureInfo.PlatformPrerequisites.Any())
-                await PluginPrerequisitesInstallDialogViewModel.Show(_windowService, new List<IPrerequisitesSubject> {FeatureInfo});
-        }
-
-        private async Task ExecuteRemovePrerequisites()
-        {
-            if (FeatureInfo.PlatformPrerequisites.Any(p => p.UninstallActions.Any()))
-            {
-                await PluginPrerequisitesUninstallDialogViewModel.Show(_windowService, new List<IPrerequisitesSubject> {FeatureInfo});
-                this.RaisePropertyChanged(nameof(IsEnabled));
-            }
-        }
-
-        private async Task UpdateEnabled(bool enable)
-        {
-            if (IsEnabled == enable)
-            {
-                this.RaisePropertyChanged(nameof(IsEnabled));
-                return;
-            }
-
-            if (FeatureInfo.Instance == null)
-            {
-                this.RaisePropertyChanged(nameof(IsEnabled));
                 _notificationService.CreateNotification()
-                    .WithMessage($"Feature '{FeatureInfo.Name}' is in a broken state and cannot enable.")
+                    .WithMessage($"Failed to enable '{FeatureInfo.Name}'.\r\n{e.Message}")
                     .HavingButton(b => b.WithText("View logs").WithCommand(ShowLogsFolder))
                     .WithSeverity(NotificationSeverity.Error)
                     .Show();
-                return;
             }
-
-            if (enable)
+            finally
             {
-                Enabling = true;
-
-                try
-                {
-                    if (FeatureInfo.Plugin.Info.RequiresAdmin && !_coreService.IsElevated)
-                    {
-                        bool confirmed = await _windowService.ShowConfirmContentDialog("Enable feature", "The plugin of this feature requires admin rights, are you sure you want to enable it?");
-                        if (!confirmed)
-                        {
-                            this.RaisePropertyChanged(nameof(IsEnabled));
-                            return;
-                        }
-                    }
-
-                    // Check if all prerequisites are met async
-                    if (!FeatureInfo.ArePrerequisitesMet())
-                    {
-                        await PluginPrerequisitesInstallDialogViewModel.Show(_windowService, new List<IPrerequisitesSubject> {FeatureInfo});
-                        if (!FeatureInfo.ArePrerequisitesMet())
-                        {
-                            this.RaisePropertyChanged(nameof(IsEnabled));
-                            return;
-                        }
-                    }
-
-                    await Dispatcher.UIThread.InvokeAsync(() => _pluginManagementService.EnablePluginFeature(FeatureInfo.Instance!, true));
-                }
-                catch (Exception e)
-                {
-                    _notificationService.CreateNotification()
-                        .WithMessage($"Failed to enable '{FeatureInfo.Name}'.\r\n{e.Message}")
-                        .HavingButton(b => b.WithText("View logs").WithCommand(ShowLogsFolder))
-                        .WithSeverity(NotificationSeverity.Error)
-                        .Show();
-                }
-                finally
-                {
-                    Enabling = false;
-                }
-            }
-            else
-            {
-                _pluginManagementService.DisablePluginFeature(FeatureInfo.Instance, true);
-                this.RaisePropertyChanged(nameof(IsEnabled));
+                Enabling = false;
             }
         }
-
-        private void OnFeatureEnabling(object? sender, PluginFeatureEventArgs e)
+        else
         {
-            if (e.PluginFeature != FeatureInfo.Instance) return;
-
-            Enabling = true;
-        }
-
-        private void OnFeatureEnableStopped(object? sender, PluginFeatureEventArgs e)
-        {
-            if (e.PluginFeature != FeatureInfo.Instance) return;
-
-            Enabling = false;
-
+            _pluginManagementService.DisablePluginFeature(FeatureInfo.Instance, true);
             this.RaisePropertyChanged(nameof(IsEnabled));
-            this.RaisePropertyChanged(nameof(LoadException));
-        }
-
-        private void PluginOnToggled(object? sender, EventArgs e)
-        {
-            this.RaisePropertyChanged(nameof(CanToggleEnabled));
         }
     }
+
+    private void OnFeatureEnabling(object? sender, PluginFeatureEventArgs e)
+    {
+        if (e.PluginFeature != FeatureInfo.Instance) return;
+
+        Enabling = true;
+    }
+
+    private void OnFeatureEnableStopped(object? sender, PluginFeatureEventArgs e)
+    {
+        if (e.PluginFeature != FeatureInfo.Instance) return;
+
+        Enabling = false;
+
+        this.RaisePropertyChanged(nameof(IsEnabled));
+        this.RaisePropertyChanged(nameof(LoadException));
+    }
+
+    private void PluginOnToggled(object? sender, EventArgs e)
+    {
+        this.RaisePropertyChanged(nameof(CanToggleEnabled));
+    }
 }

src/Artemis.UI/Screens/Plugins/PluginPlatformView.axaml.cs

@@ -1,10 +1,9 @@
-using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Markup.Xaml;
 
 namespace Artemis.UI.Screens.Plugins;
 
-public partial class PluginPlatformView : UserControl
+public class PluginPlatformView : UserControl
 {
     public PluginPlatformView()
     {

src/Artemis.UI/Screens/Plugins/PluginPrerequisiteActionView.axaml.cs

@@ -1,10 +1,9 @@
-using Avalonia;
-using Avalonia.Controls;
+using Avalonia.Controls;
 using Avalonia.Markup.Xaml;
 
 namespace Artemis.UI.Screens.Plugins;
 
-public partial class PluginPrerequisiteActionView : UserControl
+public class PluginPrerequisiteActionView : UserControl
 {
     public PluginPrerequisiteActionView()
     {

src/Artemis.UI/Screens/Plugins/PluginPrerequisiteActionViewModel.cs

@@ -1,15 +1,14 @@
 using Artemis.Core;
 using Artemis.UI.Shared;
 
-namespace Artemis.UI.Screens.Plugins
-{
-    public class PluginPrerequisiteActionViewModel : ViewModelBase
-    {
-        public PluginPrerequisiteActionViewModel(PluginPrerequisiteAction action)
-        {
-            Action = action;
-        }
+namespace Artemis.UI.Screens.Plugins;
 
-        public PluginPrerequisiteAction Action { get; }
+public class PluginPrerequisiteActionViewModel : ViewModelBase
+{
+    public PluginPrerequisiteActionViewModel(PluginPrerequisiteAction action)
+    {
+        Action = action;
     }
+
+    public PluginPrerequisiteAction Action { get; }
 }

src/Artemis.UI/Screens/Plugins/PluginPrerequisiteView.axaml.cs

@@ -1,11 +1,9 @@
-using Avalonia;
-using Avalonia.Controls;
-using Avalonia.Markup.Xaml;
+using Avalonia.Markup.Xaml;
 using Avalonia.ReactiveUI;
 
 namespace Artemis.UI.Screens.Plugins;
 
-public partial class PluginPrerequisiteView : ReactiveUserControl<PluginPrerequisiteViewModel>
+public class PluginPrerequisiteView : ReactiveUserControl<PluginPrerequisiteViewModel>
 {
     public PluginPrerequisiteView()
     {

src/Artemis.UI/Screens/Plugins/PluginPrerequisiteViewModel.cs

@@ -8,120 +8,119 @@ using Artemis.Core;
 using Artemis.UI.Shared;
 using ReactiveUI;
 
-namespace Artemis.UI.Screens.Plugins
+namespace Artemis.UI.Screens.Plugins;
+
+public class PluginPrerequisiteViewModel : ActivatableViewModelBase
 {
-    public class PluginPrerequisiteViewModel : ActivatableViewModelBase
+    private readonly ObservableAsPropertyHelper<int> _activeStepNumber;
+    private readonly ObservableAsPropertyHelper<bool> _busy;
+    private readonly bool _uninstall;
+
+    private PluginPrerequisiteActionViewModel? _activeAction;
+
+    private bool _installing;
+    private bool _isMet;
+    private bool _uninstalling;
+
+    public PluginPrerequisiteViewModel(PluginPrerequisite pluginPrerequisite, bool uninstall)
     {
-        private readonly ObservableAsPropertyHelper<int> _activeStepNumber;
-        private readonly ObservableAsPropertyHelper<bool> _busy;
-        private readonly bool _uninstall;
+        _uninstall = uninstall;
 
-        private PluginPrerequisiteActionViewModel? _activeAction;
+        PluginPrerequisite = pluginPrerequisite;
+        Actions = new ObservableCollection<PluginPrerequisiteActionViewModel>(!_uninstall
+            ? PluginPrerequisite.InstallActions.Select(a => new PluginPrerequisiteActionViewModel(a))
+            : PluginPrerequisite.UninstallActions.Select(a => new PluginPrerequisiteActionViewModel(a)));
 
-        private bool _installing;
-        private bool _isMet;
-        private bool _uninstalling;
+        _busy = this.WhenAnyValue(x => x.Installing, x => x.Uninstalling, (i, u) => i || u).ToProperty(this, x => x.Busy);
+        _activeStepNumber = this.WhenAnyValue(x => x.ActiveAction, a => Actions.IndexOf(a!) + 1).ToProperty(this, x => x.ActiveStepNumber);
 
-        public PluginPrerequisiteViewModel(PluginPrerequisite pluginPrerequisite, bool uninstall)
+        this.WhenActivated(d =>
         {
-            _uninstall = uninstall;
+            PluginPrerequisite.PropertyChanged += PluginPrerequisiteOnPropertyChanged;
+            Disposable.Create(() => PluginPrerequisite.PropertyChanged -= PluginPrerequisiteOnPropertyChanged).DisposeWith(d);
+        });
 
-            PluginPrerequisite = pluginPrerequisite;
-            Actions = new ObservableCollection<PluginPrerequisiteActionViewModel>(!_uninstall
-                ? PluginPrerequisite.InstallActions.Select(a => new PluginPrerequisiteActionViewModel(a))
-                : PluginPrerequisite.UninstallActions.Select(a => new PluginPrerequisiteActionViewModel(a)));
+        // Could be slow so take it off of the UI thread
+        Task.Run(() => IsMet = PluginPrerequisite.IsMet());
+    }
 
-            _busy = this.WhenAnyValue(x => x.Installing, x => x.Uninstalling, (i, u) => i || u).ToProperty(this, x => x.Busy);
-            _activeStepNumber = this.WhenAnyValue(x => x.ActiveAction, a => Actions.IndexOf(a!) + 1).ToProperty(this, x => x.ActiveStepNumber);
+    public ObservableCollection<PluginPrerequisiteActionViewModel> Actions { get; }
 
-            this.WhenActivated(d =>
-            {
-                PluginPrerequisite.PropertyChanged += PluginPrerequisiteOnPropertyChanged;
-                Disposable.Create(() => PluginPrerequisite.PropertyChanged -= PluginPrerequisiteOnPropertyChanged).DisposeWith(d);
-            });
+    public PluginPrerequisiteActionViewModel? ActiveAction
+    {
+        get => _activeAction;
+        set => RaiseAndSetIfChanged(ref _activeAction, value);
+    }
 
-            // Could be slow so take it off of the UI thread
-            Task.Run(() => IsMet = PluginPrerequisite.IsMet());
+    public PluginPrerequisite PluginPrerequisite { get; }
+
+    public bool Installing
+    {
+        get => _installing;
+        set => RaiseAndSetIfChanged(ref _installing, value);
+    }
+
+    public bool Uninstalling
+    {
+        get => _uninstalling;
+        set => RaiseAndSetIfChanged(ref _uninstalling, value);
+    }
+
+    public bool IsMet
+    {
+        get => _isMet;
+        set => RaiseAndSetIfChanged(ref _isMet, value);
+    }
+
+    public bool Busy => _busy.Value;
+    public int ActiveStepNumber => _activeStepNumber.Value;
+
+    public async Task Install(CancellationToken cancellationToken)
+    {
+        if (Busy)
+            return;
+
+        Installing = true;
+        try
+        {
+            await PluginPrerequisite.Install(cancellationToken);
         }
-
-        public ObservableCollection<PluginPrerequisiteActionViewModel> Actions { get; }
-
-        public PluginPrerequisiteActionViewModel? ActiveAction
+        finally
         {
-            get => _activeAction;
-            set => RaiseAndSetIfChanged(ref _activeAction, value);
-        }
-
-        public PluginPrerequisite PluginPrerequisite { get; }
-
-        public bool Installing
-        {
-            get => _installing;
-            set => RaiseAndSetIfChanged(ref _installing, value);
-        }
-
-        public bool Uninstalling
-        {
-            get => _uninstalling;
-            set => RaiseAndSetIfChanged(ref _uninstalling, value);
-        }
-
-        public bool IsMet
-        {
-            get => _isMet;
-            set => RaiseAndSetIfChanged(ref _isMet, value);
-        }
-
-        public bool Busy => _busy.Value;
-        public int ActiveStepNumber => _activeStepNumber.Value;
-
-        public async Task Install(CancellationToken cancellationToken)
-        {
-            if (Busy)
-                return;
-
-            Installing = true;
-            try
-            {
-                await PluginPrerequisite.Install(cancellationToken);
-            }
-            finally
-            {
-                Installing = false;
-                IsMet = PluginPrerequisite.IsMet();
-            }
-        }
-
-        public async Task Uninstall(CancellationToken cancellationToken)
-        {
-            if (Busy)
-                return;
-
-            Uninstalling = true;
-            try
-            {
-                await PluginPrerequisite.Uninstall(cancellationToken);
-            }
-            finally
-            {
-                Uninstalling = false;
-                IsMet = PluginPrerequisite.IsMet();
-            }
-        }
-
-        private void PluginPrerequisiteOnPropertyChanged(object? sender, PropertyChangedEventArgs e)
-        {
-            if (e.PropertyName == nameof(PluginPrerequisite.CurrentAction))
-                ActivateCurrentAction();
-        }
-
-        private void ActivateCurrentAction()
-        {
-            PluginPrerequisiteActionViewModel? activeAction = Actions.FirstOrDefault(i => i.Action == PluginPrerequisite.CurrentAction);
-            if (activeAction == null)
-                return;
-
-            ActiveAction = activeAction;
+            Installing = false;
+            IsMet = PluginPrerequisite.IsMet();
         }
     }
+
+    public async Task Uninstall(CancellationToken cancellationToken)
+    {
+        if (Busy)
+            return;
+
+        Uninstalling = true;
+        try
+        {
+            await PluginPrerequisite.Uninstall(cancellationToken);
+        }
+        finally
+        {
+            Uninstalling = false;
+            IsMet = PluginPrerequisite.IsMet();
+        }
+    }
+
+    private void PluginPrerequisiteOnPropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName == nameof(PluginPrerequisite.CurrentAction))
+            ActivateCurrentAction();
+    }
+
+    private void ActivateCurrentAction()
+    {
+        PluginPrerequisiteActionViewModel? activeAction = Actions.FirstOrDefault(i => i.Action == PluginPrerequisite.CurrentAction);
+        if (activeAction == null)
+            return;
+
+        ActiveAction = activeAction;
+    }
 }

src/Artemis.UI/Screens/Plugins/PluginSettingsView.axaml.cs

@@ -1,18 +1,17 @@
 using Avalonia.Markup.Xaml;
 using Avalonia.ReactiveUI;
 
-namespace Artemis.UI.Screens.Plugins
-{
-    public partial class PluginSettingsView : ReactiveUserControl<PluginSettingsViewModel>
-    {
-        public PluginSettingsView()
-        {
-            InitializeComponent();
-        }
+namespace Artemis.UI.Screens.Plugins;
 
-        private void InitializeComponent()
-        {
-            AvaloniaXamlLoader.Load(this);
-        }
+public class PluginSettingsView : ReactiveUserControl<PluginSettingsViewModel>
+{
+    public PluginSettingsView()
+    {
+        InitializeComponent();
+    }
+
+    private void InitializeComponent()
+    {
+        AvaloniaXamlLoader.Load(this);
     }
 }

src/Artemis.UI/Screens/Plugins/PluginSettingsViewModel.cs

@@ -13,10 +13,10 @@ namespace Artemis.UI.Screens.Plugins;
 
 public class PluginSettingsViewModel : ActivatableViewModelBase
 {
+    private readonly INotificationService _notificationService;
     private readonly Plugin _plugin;
 
     private readonly IPluginManagementService _pluginManagementService;
-    private readonly INotificationService _notificationService;
 
     public PluginSettingsViewModel(Plugin plugin, ISettingsVmFactory settingsVmFactory, IPluginManagementService pluginManagementService, INotificationService notificationService)
     {
@@ -48,6 +48,8 @@ public class PluginSettingsViewModel : ActivatableViewModelBase
             _notificationService.CreateNotification().WithTitle("Reloaded plugin.").Show();
         }
         else if (plugin == null)
+        {
             _notificationService.CreateNotification().WithTitle("Failed to load plugin after unloading it.").Show();
+        }
     }
 }

src/Artemis.UI/Screens/Plugins/PluginSettingsWindowView.axaml.cs

@@ -4,35 +4,33 @@ using System.Reactive.Linq;
 using Artemis.UI.Shared;
 using Avalonia;
 using Avalonia.Markup.Xaml;
-using Avalonia.ReactiveUI;
 using ReactiveUI;
 
-namespace Artemis.UI.Screens.Plugins
+namespace Artemis.UI.Screens.Plugins;
+
+public class PluginSettingsWindowView : ReactiveCoreWindow<PluginSettingsWindowViewModel>
 {
-    public class PluginSettingsWindowView : ReactiveCoreWindow<PluginSettingsWindowViewModel>
+    public PluginSettingsWindowView()
     {
-        public PluginSettingsWindowView()
-        {
-            InitializeComponent();
+        InitializeComponent();
 #if DEBUG
-            this.AttachDevTools();
+        this.AttachDevTools();
 #endif
 
-            this.WhenActivated(disposables =>
-                {
-                    Observable.FromEventPattern(
-                            x => ViewModel!.ConfigurationViewModel.CloseRequested += x,
-                            x => ViewModel!.ConfigurationViewModel.CloseRequested -= x
-                        )
-                        .Subscribe(_ => Close())
-                        .DisposeWith(disposables);
-                }
-            );
-        }
+        this.WhenActivated(disposables =>
+            {
+                Observable.FromEventPattern(
+                        x => ViewModel!.ConfigurationViewModel.CloseRequested += x,
+                        x => ViewModel!.ConfigurationViewModel.CloseRequested -= x
+                    )
+                    .Subscribe(_ => Close())
+                    .DisposeWith(disposables);
+            }
+        );
+    }
 
-        private void InitializeComponent()
-        {
-            AvaloniaXamlLoader.Load(this);
-        }
+    private void InitializeComponent()
+    {
+        AvaloniaXamlLoader.Load(this);
     }
 }

src/Artemis.UI/Screens/Plugins/PluginSettingsWindowViewModel.cs

@@ -2,19 +2,18 @@
 using Artemis.Core;
 using Artemis.UI.Shared;
 
-namespace Artemis.UI.Screens.Plugins
+namespace Artemis.UI.Screens.Plugins;
+
+public class PluginSettingsWindowViewModel : ActivatableViewModelBase
 {
-    public class PluginSettingsWindowViewModel : ActivatableViewModelBase
+    public PluginSettingsWindowViewModel(PluginConfigurationViewModel configurationViewModel)
     {
-        public PluginSettingsWindowViewModel(PluginConfigurationViewModel configurationViewModel)
-        {
-            ConfigurationViewModel = configurationViewModel ?? throw new ArgumentNullException(nameof(configurationViewModel));
-            Plugin = configurationViewModel.Plugin;
+        ConfigurationViewModel = configurationViewModel ?? throw new ArgumentNullException(nameof(configurationViewModel));
+        Plugin = configurationViewModel.Plugin;
 
-            DisplayName = $"{Plugin.Info.Name} | Settings";
-        }
-
-        public PluginConfigurationViewModel ConfigurationViewModel { get; }
-        public Plugin Plugin { get; }
+        DisplayName = $"{Plugin.Info.Name} | Settings";
     }
+
+    public PluginConfigurationViewModel ConfigurationViewModel { get; }
+    public Plugin Plugin { get; }
 }

src/Artemis.UI/Screens/Plugins/PluginView.axaml.cs

@@ -1,5 +1,4 @@
 using System;
-using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
 using Avalonia.Markup.Xaml;
@@ -8,9 +7,9 @@ using Avalonia.Threading;
 
 namespace Artemis.UI.Screens.Plugins;
 
-public partial class PluginView : ReactiveUserControl<PluginViewModel>
+public class PluginView : ReactiveUserControl<PluginViewModel>
 {
-    private CheckBox _enabledToggle;
+    private readonly CheckBox _enabledToggle;
 
     public PluginView()
     {
@@ -23,7 +22,7 @@ public partial class PluginView : ReactiveUserControl<PluginViewModel>
     {
         AvaloniaXamlLoader.Load(this);
     }
-    
+
     private void EnabledToggleOnClick(object? sender, RoutedEventArgs e)
     {
         Dispatcher.UIThread.Post(() => ViewModel?.UpdateEnabled(!ViewModel.Plugin.IsEnabled));

src/Artemis.UI/Screens/Plugins/PluginViewModel.cs

@@ -116,122 +116,6 @@ public class PluginViewModel : ActivatableViewModelBase
         set => RaiseAndSetIfChanged(ref _canRemovePrerequisites, value);
     }
 
-    private void ExecuteOpenSettings()
-    {
-        if (Plugin.ConfigurationDialog == null)
-            return;
-
-        if (_window != null)
-        {
-            _window.WindowState = WindowState.Normal;
-            _window.Activate();
-            return;
-        }
-
-        try
-        {
-            PluginConfigurationViewModel? viewModel = Plugin.Kernel!.Get(Plugin.ConfigurationDialog.Type) as PluginConfigurationViewModel;
-            if (viewModel == null)
-                throw new ArtemisUIException($"The type of a plugin configuration dialog must inherit {nameof(PluginConfigurationViewModel)}");
-
-            _window = _windowService.ShowWindow(new PluginSettingsWindowViewModel(viewModel));
-            _window.Closed += (_, _) => _window = null;
-        }
-        catch (Exception e)
-        {
-            _windowService.ShowExceptionDialog("An exception occured while trying to show the plugin's settings window", e);
-            throw;
-        }
-    }
-
-    private void ExecuteOpenPluginDirectory()
-    {
-        try
-        {
-            Utilities.OpenFolder(Plugin.Directory.FullName);
-        }
-        catch (Exception e)
-        {
-            _windowService.ShowExceptionDialog("Welp, we couldn't open the device's plugin folder for you", e);
-        }
-    }
-
-    private async Task ExecuteInstallPrerequisites()
-    {
-        List<IPrerequisitesSubject> subjects = new() {Plugin.Info};
-        subjects.AddRange(Plugin.Features.Where(f => f.AlwaysEnabled));
-
-        if (subjects.Any(s => s.PlatformPrerequisites.Any()))
-            await PluginPrerequisitesInstallDialogViewModel.Show(_windowService, subjects);
-    }
-
-    private async Task ExecuteRemovePrerequisites(bool forPluginRemoval = false)
-    {
-        List<IPrerequisitesSubject> subjects = new() {Plugin.Info};
-        subjects.AddRange(!forPluginRemoval ? Plugin.Features.Where(f => f.AlwaysEnabled) : Plugin.Features);
-
-        if (subjects.Any(s => s.PlatformPrerequisites.Any(p => p.UninstallActions.Any())))
-        {
-            await PluginPrerequisitesUninstallDialogViewModel.Show(_windowService, subjects, forPluginRemoval ? "Skip, remove plugin" : "Cancel");
-        }
-    }
-
-    private async Task ExecuteRemoveSettings()
-    {
-        bool confirmed = await _windowService.ShowConfirmContentDialog("Clear plugin settings", "Are you sure you want to clear the settings of this plugin?");
-        if (!confirmed)
-            return;
-
-        bool wasEnabled = IsEnabled;
-
-        if (IsEnabled)
-            await UpdateEnabled(false);
-
-        _pluginManagementService.RemovePluginSettings(Plugin);
-
-        if (wasEnabled)
-            await UpdateEnabled(true);
-
-        _notificationService.CreateNotification().WithTitle("Cleared plugin settings.").Show();
-    }
-
-    private async Task ExecuteRemove()
-    {
-        bool confirmed = await _windowService.ShowConfirmContentDialog("Remove plugin", "Are you sure you want to remove this plugin?");
-        if (!confirmed)
-            return;
-
-        // If the plugin or any of its features has uninstall actions, offer to run these
-        List<IPrerequisitesSubject> subjects = new() {Plugin.Info};
-        subjects.AddRange(Plugin.Features);
-        if (subjects.Any(s => s.PlatformPrerequisites.Any(p => p.UninstallActions.Any())))
-            await ExecuteRemovePrerequisites(true);
-
-        try
-        {
-            _pluginManagementService.RemovePlugin(Plugin, false);
-        }
-        catch (Exception e)
-        {
-            _windowService.ShowExceptionDialog("Failed to remove plugin", e);
-            throw;
-        }
-
-        _notificationService.CreateNotification().WithTitle("Removed plugin.").Show();
-    }
-
-    private void ExecuteShowLogsFolder()
-    {
-        try
-        {
-            Utilities.OpenFolder(Constants.LogsFolder);
-        }
-        catch (Exception e)
-        {
-            _windowService.ShowExceptionDialog("Welp, we couldn\'t open the logs folder for you", e);
-        }
-    }
-
     public async Task UpdateEnabled(bool enable)
     {
         if (Enabling)
@@ -311,6 +195,120 @@ public class PluginViewModel : ActivatableViewModelBase
         });
     }
 
+    private void ExecuteOpenSettings()
+    {
+        if (Plugin.ConfigurationDialog == null)
+            return;
+
+        if (_window != null)
+        {
+            _window.WindowState = WindowState.Normal;
+            _window.Activate();
+            return;
+        }
+
+        try
+        {
+            PluginConfigurationViewModel? viewModel = Plugin.Kernel!.Get(Plugin.ConfigurationDialog.Type) as PluginConfigurationViewModel;
+            if (viewModel == null)
+                throw new ArtemisUIException($"The type of a plugin configuration dialog must inherit {nameof(PluginConfigurationViewModel)}");
+
+            _window = _windowService.ShowWindow(new PluginSettingsWindowViewModel(viewModel));
+            _window.Closed += (_, _) => _window = null;
+        }
+        catch (Exception e)
+        {
+            _windowService.ShowExceptionDialog("An exception occured while trying to show the plugin's settings window", e);
+            throw;
+        }
+    }
+
+    private void ExecuteOpenPluginDirectory()
+    {
+        try
+        {
+            Utilities.OpenFolder(Plugin.Directory.FullName);
+        }
+        catch (Exception e)
+        {
+            _windowService.ShowExceptionDialog("Welp, we couldn't open the device's plugin folder for you", e);
+        }
+    }
+
+    private async Task ExecuteInstallPrerequisites()
+    {
+        List<IPrerequisitesSubject> subjects = new() {Plugin.Info};
+        subjects.AddRange(Plugin.Features.Where(f => f.AlwaysEnabled));
+
+        if (subjects.Any(s => s.PlatformPrerequisites.Any()))
+            await PluginPrerequisitesInstallDialogViewModel.Show(_windowService, subjects);
+    }
+
+    private async Task ExecuteRemovePrerequisites(bool forPluginRemoval = false)
+    {
+        List<IPrerequisitesSubject> subjects = new() {Plugin.Info};
+        subjects.AddRange(!forPluginRemoval ? Plugin.Features.Where(f => f.AlwaysEnabled) : Plugin.Features);
+
+        if (subjects.Any(s => s.PlatformPrerequisites.Any(p => p.UninstallActions.Any())))
+            await PluginPrerequisitesUninstallDialogViewModel.Show(_windowService, subjects, forPluginRemoval ? "Skip, remove plugin" : "Cancel");
+    }
+
+    private async Task ExecuteRemoveSettings()
+    {
+        bool confirmed = await _windowService.ShowConfirmContentDialog("Clear plugin settings", "Are you sure you want to clear the settings of this plugin?");
+        if (!confirmed)
+            return;
+
+        bool wasEnabled = IsEnabled;
+
+        if (IsEnabled)
+            await UpdateEnabled(false);
+
+        _pluginManagementService.RemovePluginSettings(Plugin);
+
+        if (wasEnabled)
+            await UpdateEnabled(true);
+
+        _notificationService.CreateNotification().WithTitle("Cleared plugin settings.").Show();
+    }
+
+    private async Task ExecuteRemove()
+    {
+        bool confirmed = await _windowService.ShowConfirmContentDialog("Remove plugin", "Are you sure you want to remove this plugin?");
+        if (!confirmed)
+            return;
+
+        // If the plugin or any of its features has uninstall actions, offer to run these
+        List<IPrerequisitesSubject> subjects = new() {Plugin.Info};
+        subjects.AddRange(Plugin.Features);
+        if (subjects.Any(s => s.PlatformPrerequisites.Any(p => p.UninstallActions.Any())))
+            await ExecuteRemovePrerequisites(true);
+
+        try
+        {
+            _pluginManagementService.RemovePlugin(Plugin, false);
+        }
+        catch (Exception e)
+        {
+            _windowService.ShowExceptionDialog("Failed to remove plugin", e);
+            throw;
+        }
+
+        _notificationService.CreateNotification().WithTitle("Removed plugin.").Show();
+    }
+
+    private void ExecuteShowLogsFolder()
+    {
+        try
+        {
+            Utilities.OpenFolder(Constants.LogsFolder);
+        }
+        catch (Exception e)
+        {
+            _windowService.ShowExceptionDialog("Welp, we couldn\'t open the logs folder for you", e);
+        }
+    }
+
     private void OnPluginToggled(object? sender, EventArgs e)
     {
         Dispatcher.UIThread.Post(() =>