refactor: consolidate controllers, themes, visualization & performance

Spectrum
- Simplified spectrum analyzer architecture
- Fixed namespace conflict by using FftSharp.Windows

Controllers/UI
- Replaced 10+ managers with AppController, ViewManager and UIManager
- Removed redundant interfaces (controller/view/ui/rendering/cleanup)
- Simplified IMainController (removed inheritance chain)
- Updated XAML bindings to direct paths:
  - View.BarCount, View.RenderQuality, View.SelectedStyle
  - Audio.MinDbLevel, Audio.AmplificationFactor
  - UI.IsOverlayActive, UI.IsPopupOpen
- Reduced controller code size (~800 LOC -> ~460 LOC)

Themes/Settings/DI
- Merged ThemeManager, IThemes and CommonResources
- Switched to Microsoft.Extensions.DependencyInjection
- Settings refactor: 13 files -> 3 (-600 LOC)
- Fixed theme persistence and Space key binding; instant save on theme change
- Consolidated Colors/Brushes; removed redundant interfaces
- SmartLogger: lazy init + auto-configuration

Windows/Layout
- ControlPanelWindow: replaced Popup with Grid overlay; added StereoMode selector
- SettingsWindow: reduced size; added SettingSlider; fixed key bindings
- Removed XAML event handlers and code-behind subscriptions where possible

Visualization/Performance
- Consolidated visualization into core files: SpectrumRenderer, RendererCore, PerformanceCore, Placeholder, Interfaces
- Simplified renderer hierarchy (4 levels -> 2)
- Centralized spectrum processing and shared SKPaint/SKPath pooling
- Unified performance metrics and FPS limiter in PerformanceCore
- Added IRendererContext; simplified RendererFactory/cache; moved perf overlay renderer
- Fixed DI registration for performance and transparency managers
- Reduced overall code size (~30%) and added new renderers

Overlay
- Resolved transparency and performance issues
- Removed BitmapCache from SKElement to fix FPS drops
- Refactored overlay module structure
- Optimized overlay rendering and fixed click-through

Repo hygiene
- Removed tracked test project and stray file; added test project to .gitignore

Author: diqezit

.editorconfig

@@ -363,3 +363,4 @@ MigrationBackup/
 FodyWeavers.xsd
 /SpectrumNet/EventHandlers.cs
 /SpectrumNet/MainWindow copy.xaml.cs
+SpectrumNetXUnit/

.gitignore

@@ -0,0 +1,4 @@
+[*.cs]
+
+# CA1515: Consider making public types internal
+dotnet_diagnostic.CA1515.severity = silent

SpectrumNet/.editorconfig

@@ -1 +1,52 @@
-/SpectrumNetXUnit/
+# Test project
+/SpectrumNetXUnit/
+
+# Build outputs
+bin/
+obj/
+out/
+
+# Visual Studio
+.vs/
+*.user
+*.suo
+*.userosscache
+*.sln.docstates
+
+# Rider / JetBrains
+.idea/
+*.sln.iml
+
+# NuGet
+packages/
+*.nupkg
+project.lock.json
+project.fragment.lock.json
+
+# Build results
+[Dd]ebug/
+[Rr]elease/
+x64/
+x86/
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Ll]og/
+[Ll]ogs/
+
+# Temp files
+*.tmp
+*.temp
+*.log
+*.cache
+~$*
+
+# OS files
+Thumbs.db
+ehthumbs.db
+.DS_Store
+
+# Publish
+publish/
+PublishProfiles/

SpectrumNet/.gitignore

@@ -1,24 +1,18 @@
-<Application x:Class="SpectrumNet.App"
+<Application x:Class="SpectrumNet.App"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:local="clr-namespace:SpectrumNet"
              xmlns:service="clr-namespace:SpectrumNet.SN.Themes"
              xmlns:skia="clr-namespace:SkiaSharp.Views.WPF;assembly=SkiaSharp.Views.WPF"
-             xmlns:sys="clr-namespace:System;assembly=mscorlib"
-             StartupUri="MainWindow.xaml">
+             xmlns:sys="clr-namespace:System;assembly=mscorlib">
     <Application.Resources>
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
                 <ResourceDictionary Source="SN.Themes/Resources/CommonConstants.xaml"/>
-
                 <ResourceDictionary Source="SN.Themes/Resources/BaseStyles.xaml"/>
-
                 <ResourceDictionary Source="SN.Themes/Resources/Animations.xaml"/>
-
                 <ResourceDictionary Source="SN.Themes/Resources/Converters.xaml"/>
-
                 <ResourceDictionary Source="SN.Themes/Resources/DarkTheme.xaml"/>
-
                 <ResourceDictionary Source="SN.Themes/Resources/TextStyles.xaml"/>
                 <ResourceDictionary Source="SN.Themes/Resources/ButtonStyles.xaml"/>
                 <ResourceDictionary Source="SN.Themes/Resources/ComboboxStyles.xaml"/>
@@ -29,7 +23,6 @@
                 <ResourceDictionary Source="SN.Themes/Resources/GroupBoxStyles.xaml"/>
                 <ResourceDictionary Source="SN.Themes/Resources/TabControlStyles.xaml"/>
                 <ResourceDictionary Source="SN.Themes/Resources/SpecialStyles.xaml"/>
-                
             </ResourceDictionary.MergedDictionaries>
 
             <Style TargetType="ScrollBar" BasedOn="{StaticResource ModernScrollBarStyle}"/>
@@ -46,7 +39,6 @@
                 <Setter Property="SnapsToDevicePixels" Value="True"/>
                 <Setter Property="UseLayoutRounding" Value="True"/>
             </Style>
-            
         </ResourceDictionary>
     </Application.Resources>
-</Application>
+</Application>

SpectrumNet/App.xaml

@@ -1,149 +1,184 @@
-#nullable enable
-
 namespace SpectrumNet;
 
 public partial class App : Application
 {
-    private const string LogPrefix = nameof(App);
-    private readonly ISmartLogger _logger = Instance;
-    private const int SHUTDOWN_TIMEOUT_MS = 5000;
+    private const int Timeout = 5000;
+
+    private IServiceProvider? _svc;
+    private ISmartLogger? _log;
+    private ISettingsService? _cfg;
+
+    public static IServiceProvider Services => ((App)Current)._svc!;
+
+    public static T Get<T>() where T : class =>
+        Services.GetRequiredService<T>();
 
     protected override void OnStartup(StartupEventArgs e)
     {
+        base.OnStartup(e);
+
         try
         {
-            RenderOptions.ProcessRenderMode = RenderMode.Default;
-            Initialize();
-            SetupExceptionHandling();
-            InitializeApplication();
-            RegisterApplicationExitHandler();
+            Configure();
+
+            _log = _svc!.GetRequiredService<ISmartLogger>();
+            _cfg = _svc!.GetRequiredService<ISettingsService>();
+
+            SetupExc();
+            CommonResources.InitialiseResources();
+
+            _cfg.Load();
+            InitTheme();
+            InitBrush();
+            CreateMain();
         }
         catch (Exception ex)
         {
-            LogCriticalStartupError(ex);
+            _log?.Error(nameof(App), "Startup error", ex);
             Shutdown(-1);
         }
     }
 
-    private void SetupExceptionHandling()
+    private void Configure()
     {
-        AppDomain.CurrentDomain.UnhandledException += (_, args) =>
+        var sc = new ServiceCollection();
+
+        sc.AddSingleton<ISmartLogger>(_ => Instance);
+        sc.AddSingleton<ISettingsService>(_ => SettingsService.Instance);
+        sc.AddSingleton<IThemes>(_ => Theme.Instance);
+        sc.AddSingleton<ITransparencyManager>(_ => TransparencyManager.Instance);
+        sc.AddSingleton<IBrushProvider>(_ => SpectrumBrushes.Instance);
+
+        sc.AddSingleton<IRendererFactory>(p =>
         {
-            if (args.ExceptionObject is Exception ex)
-            {
-                _logger.Error(LogPrefix, "Unhandled exception in application", ex);
-            }
-            else
-            {
-                _logger.Fatal(LogPrefix, $"Unhandled non-Exception object in application: {args.ExceptionObject}");
-            }
-        };
+            RendererFactory r = RendererFactory.Instance;
+            r.Initialize(
+                p.GetRequiredService<ISmartLogger>(),
+                p.GetRequiredService<ITransparencyManager>(),
+                RenderQuality.Medium);
+            return r;
+        });
+
+        sc.AddSingleton<IPerformanceMetricsManager>(_ =>
+        {
+            PerformanceMetricsManager m = PerformanceMetricsManager.Instance;
+            m.Initialize();
+            return m;
+        });
+
+        sc.AddSingleton<MainWindow>();
+        sc.AddSingleton(CreateCtrl);
+
+        sc.AddTransient(p =>
+            new ControlPanelWindow(p.GetRequiredService<AppController>()));
+
+        sc.AddTransient<SettingsWindow>();
+
+        _svc = sc.BuildServiceProvider();
     }
 
-    private void InitializeApplication()
+    private AppController CreateCtrl(IServiceProvider p)
     {
-        base.OnStartup(null);
-        CommonResources.InitialiseResources();
-        SettingsWindow.Instance.LoadSettings();
-        InitializeBrushProvider();
+        MainWindow mw = p.GetRequiredService<MainWindow>();
+
+        return new AppController(
+            mw,
+            mw.SpectrumCanvas,
+            p.GetRequiredService<ISettingsService>(),
+            p.GetRequiredService<ISmartLogger>(),
+            p.GetRequiredService<IRendererFactory>(),
+            p.GetRequiredService<IBrushProvider>(),
+            p.GetRequiredService<IThemes>(),
+            p.GetRequiredService<ITransparencyManager>(),
+            p.GetRequiredService<IPerformanceMetricsManager>());
     }
 
-    private void InitializeBrushProvider()
+    private void CreateMain()
     {
-        if (Resources["PaletteNameToBrushConverter"] is PaletteNameToBrushConverter conv)
-            conv.BrushesProvider = SpectrumBrushes.Instance;
+        MainWindow mw = _svc!.GetRequiredService<MainWindow>();
+        AppController c = _svc!.GetRequiredService<AppController>();
+
+        mw.Initialize(c);
+        mw.Show();
     }
 
-    private void RegisterApplicationExitHandler()
+    private void InitTheme()
     {
-        Current.Exit += (_, _) =>
-            _logger.Log(LogLevel.Information,
-                LogPrefix,
-                "Application is shutting down normally",
-                forceLog: true);
+        if (_svc == null || _cfg == null) return;
+
+        IThemes t = _svc.GetRequiredService<IThemes>();
+
+        if (t.IsDarkTheme != _cfg.Current.General.IsDarkTheme)
+            t.SetTheme(_cfg.Current.General.IsDarkTheme);
     }
 
-    private void LogCriticalStartupError(Exception ex) =>
-        _logger.Error(LogPrefix, "Critical error during startup", ex);
+    private void InitBrush()
+    {
+        if (_svc == null) return;
+
+        if (Resources["PaletteNameToBrushConverter"] is PaletteNameToBrushConverter c)
+            c.BrushesProvider =
+                _svc.GetRequiredService<IBrushProvider>() as SpectrumBrushes;
+    }
+
+    private void SetupExc()
+    {
+        AppDomain.CurrentDomain.UnhandledException += (_, a) =>
+        {
+            if (a.ExceptionObject is Exception ex)
+                _log?.Error(nameof(App), "Unhandled", ex);
+            else
+                _log?.Fatal(nameof(App), $"Unhandled: {a.ExceptionObject}");
+        };
+    }
 
     protected override void OnExit(ExitEventArgs e)
     {
+        DoShutdown();
         base.OnExit(e);
-        PerformShutdownCleanup();
     }
 
-    private void PerformShutdownCleanup()
+    private void DoShutdown()
     {
         try
         {
-            var shutdownTask = Task.Run(CleanupResources);
+            _cfg?.Apply(_cfg.Current);
 
-            if (!shutdownTask.Wait(SHUTDOWN_TIMEOUT_MS))
-            {
-                LogShutdownTimeout();
-            }
+            var t = Task.Run(DisposeAsync);
+
+            if (!t.Wait(Timeout))
+                _log?.Log(
+                    LogLevel.Warning,
+                    nameof(App),
+                    "Timeout",
+                    forceLog: true);
         }
         catch (Exception ex)
         {
-            LogShutdownError(ex);
+            _log?.Log(
+                LogLevel.Error,
+                nameof(App),
+                ex.Message,
+                forceLog: true);
         }
     }
 
-    private void CleanupResources()
+    private async Task DisposeAsync()
     {
         try
         {
-            DisposeSpectrumBrushes();
-            LogResourceCleanupCompleted();
+            if (_svc is IAsyncDisposable ad)
+                await ad.DisposeAsync().ConfigureAwait(false);
+            else
+                (_svc as IDisposable)?.Dispose();
         }
         catch (Exception ex)
         {
-            LogResourceCleanupError(ex);
-        }
-    }
-
-    private void DisposeSpectrumBrushes()
-    {
-        if (SpectrumBrushes.Instance != null)
-        {
-            _logger.Log(LogLevel.Information,
-                LogPrefix,
-                "Disposing SpectrumBrushes instance",
+            _log?.Log(
+                LogLevel.Error,
+                nameof(App),
+                ex.Message,
                 forceLog: true);
-
-            SpectrumBrushes.Instance.Dispose();
         }
     }
-
-    private void LogResourceCleanupCompleted()
-    {
-        _logger.Log(LogLevel.Information,
-            LogPrefix,
-            "Resource cleanup completed",
-            forceLog: true);
-    }
-
-    private void LogResourceCleanupError(Exception ex)
-    {
-        _logger.Log(LogLevel.Error,
-            LogPrefix,
-            $"Error during shutdown resource cleanup: {ex.Message}",
-            forceLog: true);
-    }
-
-    private void LogShutdownTimeout()
-    {
-        _logger.Log(LogLevel.Warning,
-            LogPrefix,
-            "Shutdown resources cleanup taking too long, continuing with exit",
-            forceLog: true);
-    }
-
-    private void LogShutdownError(Exception ex)
-    {
-        _logger.Log(LogLevel.Error,
-            LogPrefix,
-            $"Error during shutdown: {ex.Message}",
-            forceLog: true);
-    }
-}
+}