Merge pull request #10 from jayfunc/dev

1.0.9.0

.gitignore

@@ -404,4 +404,5 @@ FodyWeavers.xsd
 *.msp
 
 # JetBrains Rider
-*.sln.iml
+*.sln.iml
+/BetterLyrics.WinUI3/BetterLyrics.WinUI3 (Package)/BetterLyrics.WinUI3 (Package)_TemporaryKey.pfx

BetterLyrics.WinUI3/BetterLyrics.WinUI3 (Package)/BetterLyrics.WinUI3 (Package).wapproj

@@ -40,15 +40,16 @@
     <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
     <AssetTargetFallback>net8.0-windows$(TargetPlatformVersion);$(AssetTargetFallback)</AssetTargetFallback>
     <DefaultLanguage>zh-CN</DefaultLanguage>
-    <AppxPackageSigningEnabled>false</AppxPackageSigningEnabled>
+    <AppxPackageSigningEnabled>True</AppxPackageSigningEnabled>
     <EntryPointProjectUniqueName>..\BetterLyrics.WinUI3\BetterLyrics.WinUI3.csproj</EntryPointProjectUniqueName>
     <GenerateAppInstallerFile>False</GenerateAppInstallerFile>
     <AppxPackageSigningTimestampDigestAlgorithm>SHA256</AppxPackageSigningTimestampDigestAlgorithm>
-    <AppxAutoIncrementPackageRevision>True</AppxAutoIncrementPackageRevision>
+    <AppxAutoIncrementPackageRevision>False</AppxAutoIncrementPackageRevision>
     <GenerateTestArtifacts>True</GenerateTestArtifacts>
-    <AppxBundlePlatforms>x86|x64|arm64</AppxBundlePlatforms>
+    <AppxBundlePlatforms>x86|x64</AppxBundlePlatforms>
     <GenerateTemporaryStoreCertificate>True</GenerateTemporaryStoreCertificate>
     <HoursBetweenUpdateChecks>0</HoursBetweenUpdateChecks>
+    <PackageCertificateKeyFile>BetterLyrics.WinUI3 %28Package%29_TemporaryKey.pfx</PackageCertificateKeyFile>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <AppxBundle>Always</AppxBundle>
@@ -80,6 +81,7 @@
     </AppxManifest>
   </ItemGroup>
   <ItemGroup>
+    <None Include="BetterLyrics.WinUI3 %28Package%29_TemporaryKey.pfx" />
     <Content Include="Images\LargeTile.scale-100.png" />
     <Content Include="Images\LargeTile.scale-125.png" />
     <Content Include="Images\LargeTile.scale-150.png" />

BetterLyrics.WinUI3/BetterLyrics.WinUI3 (Package)/Package.appxmanifest

@@ -5,47 +5,62 @@
   xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
   xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
   xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
-  IgnorableNamespaces="uap rescap">
+  xmlns:uap5="http://schemas.microsoft.com/appx/manifest/uap/windows10/5"
+  xmlns:uap18="http://schemas.microsoft.com/appx/manifest/uap/windows10/18"
+  IgnorableNamespaces="uap rescap uap18">
 
-  <Identity
-    Name="37412.BetterLyrics"
-    Publisher="CN=E1428B0E-DC1D-4EA4-ACB1-4556569D5BA9"
-    Version="1.0.1.0" />
+	<Identity
+	  Name="37412.BetterLyrics"
+	  Publisher="CN=E1428B0E-DC1D-4EA4-ACB1-4556569D5BA9"
+	  Version="1.0.9.0" />
 
-  <mp:PhoneIdentity PhoneProductId="ca4a4830-fc19-40d9-b823-53e2bff3d816" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
+	<mp:PhoneIdentity PhoneProductId="ca4a4830-fc19-40d9-b823-53e2bff3d816" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
 
-  <Properties>
-    <DisplayName>BetterLyrics</DisplayName>
-    <PublisherDisplayName>founchoo</PublisherDisplayName>
-    <Logo>Images\StoreLogo.png</Logo>
-  </Properties>
+	<Properties>
+		<DisplayName>BetterLyrics</DisplayName>
+		<PublisherDisplayName>founchoo</PublisherDisplayName>
+		<Logo>Images\StoreLogo.png</Logo>
+	</Properties>
 
-  <Dependencies>
-    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26100.0" />
-    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26100.0" />
-  </Dependencies>
+	<Dependencies>
+		<TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26100.0" />
+		<TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26100.0" />
+	</Dependencies>
 
-  <Resources>
-    <Resource Language="x-generate"/>
-  </Resources>
+	<Resources>
+		<Resource Language="en-US"/>
+		<Resource Language="zh-CN"/>
+		<Resource Language="zh-TW"/>
+		<Resource Language="ja-JP"/>
+		<Resource Language="ko-KR"/>
+	</Resources>
 
-  <Applications>
-    <Application Id="App"
-      Executable="$targetnametoken$.exe"
-      EntryPoint="$targetentrypoint$">
-      <uap:VisualElements
-        DisplayName="BetterLyrics"
-        Description="BetterLyrics.WinUI3 (Package)"
-        BackgroundColor="transparent"
-        Square150x150Logo="Images\Square150x150Logo.png"
-        Square44x44Logo="Images\Square44x44Logo.png">
-        <uap:DefaultTile Wide310x150Logo="Images\Wide310x150Logo.png"  Square71x71Logo="Images\SmallTile.png" Square310x310Logo="Images\LargeTile.png"/>
-        <uap:SplashScreen Image="Images\SplashScreen.png" />
-      </uap:VisualElements>
-    </Application>
-  </Applications>
+	<Applications>
+		<Application Id="App"
+		  Executable="$targetnametoken$.exe"
+		  EntryPoint="$targetentrypoint$">
+			<uap:VisualElements
+			  DisplayName="BetterLyrics"
+			  Description="BetterLyrics.WinUI3 (Package)"
+			  BackgroundColor="transparent"
+			  Square150x150Logo="Images\Square150x150Logo.png"
+			  Square44x44Logo="Images\Square44x44Logo.png">
+				<uap:DefaultTile Wide310x150Logo="Images\Wide310x150Logo.png"  Square71x71Logo="Images\SmallTile.png" Square310x310Logo="Images\LargeTile.png"/>
+				<uap:SplashScreen Image="Images\SplashScreen.png" />
+			</uap:VisualElements>
+			<Extensions>
+				<uap5:Extension
+				  Category="windows.startupTask">
+					<uap5:StartupTask
+					  TaskId="AutoStartup"
+					  Enabled="false"
+					  DisplayName="BetterLyrics" />
+				</uap5:Extension>
+			</Extensions>
+		</Application>
+	</Applications>
 
-  <Capabilities>
-    <rescap:Capability Name="runFullTrust" />
-  </Capabilities>
+	<Capabilities>
+		<rescap:Capability Name="runFullTrust" />
+	</Capabilities>
 </Package>

BetterLyrics.WinUI3/BetterLyrics.WinUI3/App.xaml

@@ -5,7 +5,8 @@
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:converter="using:BetterLyrics.WinUI3.Converter"
     xmlns:converters="using:CommunityToolkit.WinUI.Converters"
-    xmlns:local="using:BetterLyrics.WinUI3">
+    xmlns:local="using:BetterLyrics.WinUI3"
+    xmlns:media="using:CommunityToolkit.WinUI.Media">
     <Application.Resources>
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
@@ -16,12 +17,8 @@
 
             <!--  Theme  -->
             <ResourceDictionary.ThemeDictionaries>
-                <ResourceDictionary x:Key="Light">
-                    <Color x:Key="SemiTransparentSystemBaseHighColor">#80000000</Color>
-                </ResourceDictionary>
-                <ResourceDictionary x:Key="Dark">
-                    <Color x:Key="SemiTransparentSystemBaseHighColor">#80FFFFFF</Color>
-                </ResourceDictionary>
+                <ResourceDictionary x:Key="Light" />
+                <ResourceDictionary x:Key="Dark" />
             </ResourceDictionary.ThemeDictionaries>
 
             <!--  Brush  -->
@@ -44,14 +41,19 @@
             <ExponentialEase x:Key="EaseIn" EasingMode="EaseIn" />
 
             <!--  Converter  -->
-            <converter:ThemeTypeToElementThemeConverter x:Key="ThemeTypeToElementThemeConverter" />
+            <converter:EnumToIntConverter x:Key="EnumToIntConverter" />
             <converter:ColorToBrushConverter x:Key="ColorToBrushConverter" />
+            <converter:MatchedLocalFilesPathToVisibilityConverter x:Key="MatchedLocalFilesPathToVisibilityConverter" />
+            <converter:IntToCornerRadius x:Key="IntToCornerRadius" />
+            <converter:CornerRadiusToDoubleConverter x:Key="CornerRadiusToDoubleConverter" />
+            <converter:LyricsSearchProviderToDisplayNameConverter x:Key="LyricsSearchProviderToDisplayNameConverter" />
             <converters:BoolToVisibilityConverter x:Key="BoolToVisibilityConverter" />
             <converters:BoolNegationConverter x:Key="BoolNegationConverter" />
+            <converters:ColorToDisplayNameConverter x:Key="ColorToDisplayNameConverter" />
 
             <x:Double x:Key="SettingsCardSpacing">4</x:Double>
 
-            <!--  Style (inc. the correct spacing) of a section header  -->
+            <!--  Style  -->
             <Style
                 x:Key="SettingsSectionHeaderTextBlockStyle"
                 BasedOn="{StaticResource BodyStrongTextBlockStyle}"
@@ -60,7 +62,40 @@
                     <Setter Property="Margin" Value="1,30,0,6" />
                 </Style.Setters>
             </Style>
+            <Style x:Key="TitleBarButtonStyle" TargetType="Button">
+                <Setter Property="VerticalAlignment" Value="Top" />
+                <Setter Property="CornerRadius" Value="0" />
+                <Setter Property="BorderThickness" Value="0" />
+                <Setter Property="Padding" Value="16,9,16,11" />
+                <Setter Property="Margin" Value="0" />
+                <Setter Property="Background" Value="Transparent" />
+            </Style>
+            <Style x:Key="GhostButtonStyle" TargetType="Button">
+                <Setter Property="VerticalAlignment" Value="Stretch" />
+                <Setter Property="Padding" Value="8" />
+                <Setter Property="CornerRadius" Value="4" />
+                <Setter Property="BorderThickness" Value="0" />
+                <Setter Property="Background" Value="Transparent" />
+            </Style>
+            <Style x:Key="TitleBarToggleButtonStyle" TargetType="ToggleButton">
+                <Setter Property="CornerRadius" Value="4" />
+                <Setter Property="VerticalAlignment" Value="Stretch" />
+                <Setter Property="BorderThickness" Value="0" />
+                <Setter Property="Padding" Value="16,0" />
+                <Setter Property="Background" Value="Transparent" />
+            </Style>
+            <Style x:Key="GhostToggleButtonStyle" TargetType="ToggleButton">
+                <Setter Property="CornerRadius" Value="4" />
+                <Setter Property="VerticalAlignment" Value="Stretch" />
+                <Setter Property="BorderThickness" Value="0" />
+                <Setter Property="Padding" Value="8" />
+                <Setter Property="Background" Value="Transparent" />
+            </Style>
 
+            <!--  Dimensions  -->
+
+            <!--  Fonts  -->
+            <FontFamily x:Key="IconFontFamily">Segoe Fluent Icons, Segoe MDL2 Assets</FontFamily>
         </ResourceDictionary>
     </Application.Resources>
 </Application>

BetterLyrics.WinUI3/BetterLyrics.WinUI3/App.xaml.cs

@@ -1,63 +1,128 @@
-using BetterLyrics.WinUI3.Services.Database;
-using BetterLyrics.WinUI3.Services.Settings;
+// 2025/6/23 by Zhe Fang
+
+using BetterLyrics.WinUI3.Enums;
+using BetterLyrics.WinUI3.Helper;
+using BetterLyrics.WinUI3.Services;
 using BetterLyrics.WinUI3.ViewModels;
 using BetterLyrics.WinUI3.Views;
 using CommunityToolkit.Mvvm.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Microsoft.UI.Dispatching;
 using Microsoft.UI.Xaml;
 using Microsoft.Windows.ApplicationModel.Resources;
+using Serilog;
+using ShadowViewer.Controls;
+using System;
+using System.Linq;
 using System.Text;
+using System.Threading.Tasks;
 
-// To learn more about WinUI, the WinUI project structure,
-// and more about our project templates, see: http://aka.ms/winui-project-info.
+namespace BetterLyrics.WinUI3
+{
+    public partial class App : Application
+    {
 
-namespace BetterLyrics.WinUI3 {
-    /// <summary>
-    /// Provides application-specific behavior to supplement the default Application class.
-    /// </summary>
-    public partial class App : Application {
-        public static App Current => (App)Application.Current;
-        public MainWindow? MainWindow { get; private set; }
-        public MainWindow? SettingsWindow { get; set; }
+        private readonly ILogger<App> _logger;
 
-        public static ResourceLoader ResourceLoader = new();
+        public static new App Current => (App)Application.Current;
+        public static DispatcherQueue? DispatcherQueue { get; private set; }
+        public static DispatcherQueueTimer? DispatcherQueueTimer { get; private set; }
+        public static ResourceLoader? ResourceLoader { get; private set; }
 
-        public static DispatcherQueue DispatcherQueue => DispatcherQueue.GetForCurrentThread();
+        public NotificationPanel? LyricsWindowNotificationPanel { get; set; }
+        public NotificationPanel? SettingsWindowNotificationPanel { get; set; }
 
-        /// <summary>
-        /// Initializes the singleton application object.  This is the first line of authored code
-        /// executed, and as such is the logical equivalent of main() or WinMain().
-        /// </summary>
-        public App() {
+        public App()
+        {
             this.InitializeComponent();
+
+            DispatcherQueue = DispatcherQueue.GetForCurrentThread();
+            DispatcherQueueTimer = DispatcherQueue.CreateTimer();
+            ResourceLoader = new ResourceLoader();
+
+            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
+            AppInfo.EnsureDirectories();
+            ConfigureServices();
+
+            _logger = Ioc.Default.GetRequiredService<ILogger<App>>();
+
+            UnhandledException += App_UnhandledException;
+            AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
+            AppDomain.CurrentDomain.FirstChanceException += CurrentDomain_FirstChanceException;
+            TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
         }
 
-        /// <summary>
-        /// Invoked when the application is launched.
-        /// </summary>
-        /// <param name="args">Details about the launch request and process.</param>
-        protected override void OnLaunched(Microsoft.UI.Xaml.LaunchActivatedEventArgs args) {
+        protected override void OnLaunched(LaunchActivatedEventArgs args)
+        {
+            WindowHelper.OpenOrShowWindow<LyricsWindow>();
+            var lyricsWindow = WindowHelper.GetWindowByWindowType<LyricsWindow>();
+            if (lyricsWindow == null) return;
+
+            string[] commandLineArguments = Environment.GetCommandLineArgs();
+            if (commandLineArguments.Length > 1)
+            {
+                commandLineArguments = commandLineArguments.Skip(1).ToArray();
+                if (commandLineArguments.First() == AppInfo.UnlockWindowTag)
+                {
+                    lyricsWindow.AutoSelectLyricsMode(AutoStartWindowType.DesktopMode, false);
+                    return;
+                }
+            }
+            lyricsWindow.AutoSelectLyricsMode();
+        }
+
+        private static void ConfigureServices()
+        {
+            Log.Logger = new LoggerConfiguration()
+                .MinimumLevel.Is(Serilog.Events.LogEventLevel.Verbose)
+                .WriteTo.File(AppInfo.LogFilePattern, rollingInterval: RollingInterval.Day)
+                .CreateLogger();
 
             // Register services
             Ioc.Default.ConfigureServices(
                 new ServiceCollection()
-                .AddSingleton(DispatcherQueue.GetForCurrentThread())
-                // Services
-                .AddSingleton<SettingsService>()
-                .AddSingleton<DatabaseService>()
-                // ViewModels
-                .AddSingleton<MainViewModel>()
-                .AddSingleton<SettingsViewModel>()
-                .BuildServiceProvider());
-
-            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
-
-            // Activate the window
-            MainWindow = new MainWindow();
-            MainWindow!.Navigate(typeof(MainPage));
-            MainWindow.Activate();
+                    .AddLogging(loggingBuilder =>
+                    {
+                        loggingBuilder.ClearProviders();
+                        loggingBuilder.AddSerilog();
+                    })
+                    // Services
+                    .AddSingleton<ISettingsService, SettingsService>()
+                    .AddSingleton<IPlaybackService, PlaybackService>()
+                    .AddSingleton<IMusicSearchService, MusicSearchService>()
+                    .AddSingleton<ILibWatcherService, LibWatcherService>()
+                    .AddSingleton<ILibreTranslateService, LibreTranslateService>()
+                    // ViewModels
+                    .AddSingleton<LyricsWindowViewModel>()
+                    .AddSingleton<SettingsWindowViewModel>()
+                    .AddSingleton<SystemTrayViewModel>()
+                    .AddSingleton<SettingsPageViewModel>()
+                    .AddSingleton<LyricsPageViewModel>()
+                    .AddSingleton<LyricsRendererViewModel>()
+                    .BuildServiceProvider()
+            );
         }
 
+        private void App_UnhandledException(object sender, Microsoft.UI.Xaml.UnhandledExceptionEventArgs e)
+        {
+            _logger.LogError(e.Exception, "App_UnhandledException");
+            e.Handled = true;
+        }
+
+        private void CurrentDomain_FirstChanceException(object? sender, System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs e)
+        {
+            _logger.LogError(e.Exception, "CurrentDomain_FirstChanceException");
+        }
+
+        private void CurrentDomain_UnhandledException(object sender, System.UnhandledExceptionEventArgs e)
+        {
+            _logger.LogError(e.ExceptionObject.ToString(), "CurrentDomain_UnhandledException");
+        }
+
+        private void TaskScheduler_UnobservedTaskException(object? sender, UnobservedTaskExceptionEventArgs e)
+        {
+            _logger.LogError(e.Exception, "TaskScheduler_UnobservedTaskException");
+        }
     }
 }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/BetterLyrics.WinUI3.csproj

@@ -2,42 +2,92 @@
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
     <TargetFramework>net8.0-windows10.0.26100.0</TargetFramework>
-    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
+    <TargetPlatformMinVersion>10.0.19041.0</TargetPlatformMinVersion>
     <RootNamespace>BetterLyrics.WinUI3</RootNamespace>
-    <ApplicationManifest>app.manifest</ApplicationManifest>
     <Platforms>x86;x64;ARM64</Platforms>
     <RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
     <UseWinUI>true</UseWinUI>
     <Nullable>enable</Nullable>
+    <LangVersion>preview</LangVersion>
   </PropertyGroup>
-
+  <ItemGroup>
+    <Compile Remove="ViewModels\Lyrics\**" />
+    <Content Remove="ViewModels\Lyrics\**" />
+    <EmbeddedResource Remove="ViewModels\Lyrics\**" />
+    <None Remove="ViewModels\Lyrics\**" />
+    <Page Remove="ViewModels\Lyrics\**" />
+    <PRIResource Remove="ViewModels\Lyrics\**" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Remove="Controls\SystemTray.xaml" />
+    <None Remove="Views\SettingsWindow.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Logo.ico" />
+  </ItemGroup>
   <ItemGroup>
     <Manifest Include="$(ApplicationManifest)" />
   </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="CommunityToolkit.Labs.WinUI.MarqueeText" Version="0.1.230830" />
     <PackageReference Include="CommunityToolkit.Labs.WinUI.OpacityMaskView" Version="0.1.250513-build.2126" />
     <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.0" />
     <PackageReference Include="CommunityToolkit.WinUI.Behaviors" Version="8.2.250402" />
+    <PackageReference Include="CommunityToolkit.WinUI.Controls.Primitives" Version="8.2.250402" />
+    <PackageReference Include="CommunityToolkit.WinUI.Controls.Segmented" Version="8.2.250402" />
     <PackageReference Include="CommunityToolkit.WinUI.Controls.SettingsControls" Version="8.2.250402" />
     <PackageReference Include="CommunityToolkit.WinUI.Converters" Version="8.2.250402" />
     <PackageReference Include="CommunityToolkit.WinUI.Extensions" Version="8.2.250402" />
+    <PackageReference Include="CommunityToolkit.WinUI.Helpers" Version="8.2.250402" />
     <PackageReference Include="CommunityToolkit.WinUI.Media" Version="8.2.250402" />
-    <PackageReference Include="DevWinUI" Version="8.2.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.5" />
+    <PackageReference Include="Dubya.WindowsMediaController" Version="2.5.5" />
+    <PackageReference Include="H.NotifyIcon.WinUI" Version="2.3.0" />
+    <PackageReference Include="iTunesSearch" Version="1.0.44" />
+    <PackageReference Include="Lyricify.Lyrics.Helper-NativeAot" Version="0.1.4-alpha.5" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.6" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.6" />
     <PackageReference Include="Microsoft.Graphics.Win2D" Version="1.3.2" />
     <PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.26100.4188" />
-    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.7.250513003" />
-    <PackageReference Include="Microsoft.Xaml.Behaviors.WinUI.Managed" Version="3.0.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="sqlite-net-pcl" Version="1.9.172" />
-    <PackageReference Include="System.Text.Encoding.CodePages" Version="9.0.5" />
+    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.7.250606001" />
+    <PackageReference Include="Serilog.Extensions.Logging" Version="9.0.2" />
+    <PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
+    <PackageReference Include="ShadowViewer.Controls.Notification" Version="1.2.1" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.10" />
+    <PackageReference Include="System.Drawing.Common" Version="9.0.6" />
+    <PackageReference Include="System.Text.Encoding.CodePages" Version="9.0.6" />
+    <PackageReference Include="TagLibSharp" Version="2.3.0" />
     <PackageReference Include="Ude.NetStandard" Version="1.2.0" />
-    <PackageReference Include="z440.atl.core" Version="6.24.0" />
+    <PackageReference Include="Vanara.PInvoke.Gdi32" Version="4.1.6" />
+    <PackageReference Include="Vanara.PInvoke.Shell32" Version="4.1.6" />
+    <PackageReference Include="Vanara.PInvoke.User32" Version="4.1.6" />
+    <PackageReference Include="WinUIEx" Version="2.6.0" />
+    <PackageReference Include="z440.atl.core" Version="7.0.0" />
   </ItemGroup>
-
-    <!-- Publish Properties -->
+  <ItemGroup>
+    <Page Update="Rendering\InAppLyricsRenderer.xaml">
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <Page Update="Rendering\DesktopLyricsRenderer.xaml">
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <!--Disable Trimming for Specific Packages-->
+  <ItemGroup>
+    <TrimmerRootAssembly Include="TagLibSharp" />
+  </ItemGroup>
+  <ItemGroup>
+    <Page Update="Views\SettingsWindow.xaml">
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <Page Update="Controls\SystemTray.xaml">
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <!-- Publish Properties -->
   <PropertyGroup>
     <PublishReadyToRun Condition="'$(Configuration)' == 'Debug'">False</PublishReadyToRun>
     <PublishReadyToRun Condition="'$(Configuration)' != 'Debug'">True</PublishReadyToRun>
@@ -45,4 +95,22 @@
     <PublishTrimmed Condition="'$(Configuration)' != 'Debug'">True</PublishTrimmed>
     <SupportedOSPlatformVersion>10.0.19041.0</SupportedOSPlatformVersion>
   </PropertyGroup>
-</Project>
+  <PropertyGroup>
+    <DefineConstants>$(DefineConstants)</DefineConstants>
+    <ApplicationManifest>app.manifest</ApplicationManifest>
+    <ApplicationIcon>Logo.ico</ApplicationIcon>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <ShouldCreateLogs>True</ShouldCreateLogs>
+    <AdvancedSettingsExpanded>True</AdvancedSettingsExpanded>
+    <UpdateAssemblyVersion>False</UpdateAssemblyVersion>
+    <UpdateAssemblyFileVersion>False</UpdateAssemblyFileVersion>
+    <UpdateAssemblyInfoVersion>False</UpdateAssemblyInfoVersion>
+    <UpdatePackageVersion>True</UpdatePackageVersion>
+    <AssemblyInfoVersionType>SettingsVersion</AssemblyInfoVersionType>
+    <InheritWinAppVersionFrom>AssemblyVersion</InheritWinAppVersionFrom>
+    <PackageVersionSettings>AssemblyVersion.None.None</PackageVersionSettings>
+    <Version>2025.6.0</Version>
+    <AssemblyVersion>2025.6.18.0110</AssemblyVersion>
+    <FileVersion>2025.6.18.0110</FileVersion>
+  </PropertyGroup>
+</Project>

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Controls/SystemTray.xaml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<UserControl
+    x:Class="BetterLyrics.WinUI3.Controls.SystemTray"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:local="using:BetterLyrics.WinUI3.Controls"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:tb="using:H.NotifyIcon"
+    xmlns:ui="using:CommunityToolkit.WinUI"
+    mc:Ignorable="d">
+
+    <tb:TaskbarIcon
+        x:Name="TrayIcon"
+        x:FieldModifier="public"
+        ContextMenuMode="SecondWindow"
+        IconSource="ms-appx:///Assets/Logo.ico"
+        NoLeftClickDelay="True"
+        ToolTipText="{x:Bind ViewModel.ToolTipText, Mode=OneWay}">
+        <tb:TaskbarIcon.ContextFlyout>
+            <MenuFlyout
+                AreOpenCloseAnimationsEnabled="True"
+                LightDismissOverlayMode="On"
+                ShowMode="TransientWithDismissOnPointerMoveAway">
+                <MenuFlyoutItem x:Uid="SystemTraySettings" Command="{x:Bind ViewModel.OpenSettingsCommand}" />
+                <MenuFlyoutItem x:Uid="SystemTrayExit" Command="{x:Bind ViewModel.ExitAppCommand}" />
+                <MenuFlyoutItem
+                    x:Uid="SystemTrayUnlock"
+                    Command="{x:Bind ViewModel.UnlockWindowCommand}"
+                    Visibility="{x:Bind ViewModel.IsLyricsWindowLocked, Mode=OneWay, Converter={StaticResource BoolToVisibilityConverter}}" />
+            </MenuFlyout>
+        </tb:TaskbarIcon.ContextFlyout>
+    </tb:TaskbarIcon>
+</UserControl>

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Controls/SystemTray.xaml.cs

@@ -0,0 +1,17 @@
+using BetterLyrics.WinUI3.ViewModels;
+using CommunityToolkit.Mvvm.DependencyInjection;
+using Microsoft.UI.Xaml.Controls;
+
+namespace BetterLyrics.WinUI3.Controls
+{
+    public sealed partial class SystemTray : UserControl
+    {
+        public SystemTrayViewModel ViewModel => (SystemTrayViewModel)DataContext;
+
+        public SystemTray()
+        {
+            InitializeComponent();
+            DataContext = Ioc.Default.GetService<SystemTrayViewModel>();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/ColorToBrushConverter.cs

@@ -1,22 +1,25 @@
-using Microsoft.UI.Xaml.Data;
-using Microsoft.UI.Xaml.Media;
+// 2025/6/23 by Zhe Fang
+
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using Microsoft.UI.Xaml.Data;
+using Microsoft.UI.Xaml.Media;
 using Windows.UI;
 
-namespace BetterLyrics.WinUI3.Converter {
-    public class ColorToBrushConverter : IValueConverter {
-        public object Convert(object value, Type targetType, object parameter, string language) {
-            if (value is Color color) {
+namespace BetterLyrics.WinUI3.Converter
+{
+    public partial class ColorToBrushConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is Color color)
+            {
                 return new SolidColorBrush(color);
             }
             return new SolidColorBrush();
         }
 
-        public object ConvertBack(object value, Type targetType, object parameter, string language) {
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
             throw new NotImplementedException();
         }
     }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/CornerRadiusToDoubleConverter.cs

@@ -0,0 +1,22 @@
+using System;
+using Microsoft.UI.Xaml.Data;
+
+namespace BetterLyrics.WinUI3.Converter
+{
+    internal partial class CornerRadiusToDoubleConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is Microsoft.UI.Xaml.CornerRadius cornerRadius)
+            {
+                return (double)cornerRadius.TopLeft;
+            }
+            return .0;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/EnumToIntConverter.cs

@@ -0,0 +1,28 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using Microsoft.UI.Xaml.Data;
+
+namespace BetterLyrics.WinUI3.Converter
+{
+    internal partial class EnumToIntConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is Enum)
+            {
+                return System.Convert.ToInt32(value);
+            }
+            return 0;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
+            if (value is int && targetType.IsEnum)
+            {
+                return Enum.ToObject(targetType, value);
+            }
+            return Enum.ToObject(targetType, 0);
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/IntToCornerRadius.cs

@@ -0,0 +1,24 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using Microsoft.UI.Xaml.Data;
+
+namespace BetterLyrics.WinUI3.Converter
+{
+    public partial class IntToCornerRadius : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is int intValue && parameter is double controlHeight)
+            {
+                return new Microsoft.UI.Xaml.CornerRadius(intValue / 100f * controlHeight / 2);
+            }
+            return new Microsoft.UI.Xaml.CornerRadius(0);
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/LyricsSearchProviderToDisplayNameConverter.cs

@@ -0,0 +1,37 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using BetterLyrics.WinUI3.Enums;
+using Microsoft.UI.Xaml.Data;
+
+namespace BetterLyrics.WinUI3.Converter
+{
+    public partial class LyricsSearchProviderToDisplayNameConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is LyricsSearchProvider provider)
+            {
+                return provider switch
+                {
+                    LyricsSearchProvider.LrcLib => App.ResourceLoader!.GetString("LyricsSearchProviderLrcLib"),
+                    LyricsSearchProvider.QQ => App.ResourceLoader!.GetString("LyricsSearchProviderQQ"),
+                    LyricsSearchProvider.Netease => App.ResourceLoader!.GetString("LyricsSearchProviderNetease"),
+                    LyricsSearchProvider.Kugou => App.ResourceLoader!.GetString("LyricsSearchProviderKugou"),
+                    LyricsSearchProvider.AmllTtmlDb => App.ResourceLoader!.GetString("LyricsSearchProviderAmllTtmlDb"),
+                    LyricsSearchProvider.LocalLrcFile => App.ResourceLoader!.GetString("LyricsSearchProviderLocalLrcFile"),
+                    LyricsSearchProvider.LocalMusicFile => App.ResourceLoader!.GetString("LyricsSearchProviderLocalMusicFile"),
+                    LyricsSearchProvider.LocalEslrcFile => App.ResourceLoader!.GetString("LyricsSearchProviderEslrcFile"),
+                    LyricsSearchProvider.LocalTtmlFile => App.ResourceLoader!.GetString("LyricsSearchProviderTtmlFile"),
+                    _ => "",
+                };
+            }
+            return "";
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/MatchedLocalFilesPathToVisibilityConverter.cs

@@ -0,0 +1,32 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Data;
+
+namespace BetterLyrics.WinUI3.Converter
+{
+    public partial class MatchedLocalFilesPathToVisibilityConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is string path)
+            {
+                if (path == App.ResourceLoader!.GetString("MainPageNoLocalFilesMatched"))
+                {
+                    return Visibility.Collapsed;
+                }
+                else
+                {
+                    return Visibility.Visible;
+                }
+            }
+            return Visibility.Collapsed;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/ThemeTypeToElementThemeConverter.cs

@@ -1,22 +0,0 @@
-using Microsoft.UI.Xaml;
-using Microsoft.UI.Xaml.Data;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BetterLyrics.WinUI3.Converter {
-    internal class ThemeTypeToElementThemeConverter : IValueConverter {
-        public object Convert(object value, Type targetType, object parameter, string language) {
-            if (value is int themeType) {
-                return (ElementTheme)themeType;
-            }
-            return ElementTheme.Default;
-        }
-
-        public object ConvertBack(object value, Type targetType, object parameter, string language) {
-            return 0;
-        }
-    }
-}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/AutoStartWindowType.cs

@@ -0,0 +1,11 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum AutoStartWindowType
+    {
+        StandardMode,
+        DockMode,
+        DesktopMode,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/BackdropType.cs

@@ -0,0 +1,13 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum BackdropType
+    {
+        None = 0,
+        Mica = 1,
+        MicaAlt = 2,
+        DesktopAcrylic = 3,
+        Transparent = 4,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/EasingType.cs

@@ -0,0 +1,20 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum EasingType
+    {
+        Linear,
+        SmoothStep,
+        EaseInOutSine,
+        EaseInOutQuad,
+        EaseInOutCubic,
+        EaseInOutQuart,
+        EaseInOutQuint,
+        EaseInOutExpo,
+        EaseInOutCirc,
+        EaseInOutBack,
+        EaseInOutElastic,
+        EaseInOutBounce,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/Language.cs

@@ -1,14 +1,20 @@
-using System;
+// 2025/6/23 by Zhe Fang
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace BetterLyrics.WinUI3.Models {
-    public enum Language {
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum Language
+    {
         FollowSystem,
         English,
         SimplifiedChinese,
         TraditionalChinese,
+        Japanese,
+        Korean,
     }
 }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LineMaskType.cs

@@ -4,10 +4,11 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace BetterLyrics.WinUI3.Models {
-    public enum LyricsAlignmentType {
-        Left,
-        Center,
-        Right,
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LineMaskType
+    {
+        Glow,
+        Highlight,
     }
 }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LineRenderingType.cs

@@ -0,0 +1,10 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LineRenderingType
+    {
+        UntilCurrentChar,
+        CurrentCharOnly,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LocalSearchTargetProps.cs

@@ -0,0 +1,10 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LocalSearchTargetProps
+    {
+        LyricsOnly,
+        LyricsAndAlbumArt,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LyricsDisplayType.cs

@@ -0,0 +1,12 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LyricsDisplayType
+    {
+        AlbumArtOnly,
+        LyricsOnly,
+        SplitView,
+        PlaceholderOnly,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LyricsFontColorType.cs

@@ -0,0 +1,11 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LyricsFontColorType
+    {
+        AdaptiveColored,
+        AdaptiveGrayed,
+        Custom,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LyricsFontWeight.cs

@@ -0,0 +1,45 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using Microsoft.UI.Text;
+using Windows.UI.Text;
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LyricsFontWeight
+    {
+        Thin,
+        ExtraLight,
+        Light,
+        SemiLight,
+        Normal,
+        Medium,
+        SemiBold,
+        Bold,
+        ExtraBold,
+        Black,
+        ExtraBlack,
+    }
+
+    public static class LyricsFontWeightExtensions
+    {
+        public static FontWeight ToFontWeight(this LyricsFontWeight weight)
+        {
+            return weight switch
+            {
+                LyricsFontWeight.Thin => FontWeights.Thin,
+                LyricsFontWeight.ExtraLight => FontWeights.ExtraLight,
+                LyricsFontWeight.Light => FontWeights.Light,
+                LyricsFontWeight.SemiLight => FontWeights.SemiLight,
+                LyricsFontWeight.Normal => FontWeights.Normal,
+                LyricsFontWeight.Medium => FontWeights.Medium,
+                LyricsFontWeight.SemiBold => FontWeights.SemiBold,
+                LyricsFontWeight.Bold => FontWeights.Bold,
+                LyricsFontWeight.ExtraBold => FontWeights.ExtraBold,
+                LyricsFontWeight.Black => FontWeights.Black,
+                LyricsFontWeight.ExtraBlack => FontWeights.ExtraBlack,
+                LyricsFontWeight _ => throw new ArgumentOutOfRangeException(nameof(weight), weight, null),
+            };
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LyricsFormat.cs

@@ -0,0 +1,68 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LyricsFormat
+    {
+        Lrc,
+        Eslrc,
+        Ttml,
+        Qrc,
+        Krc,
+        NotSpecified,
+    }
+
+    public static class LyricsFormatExtensions
+    {
+        public static LyricsFormat? DetectFormat(this string content)
+        {
+            if (string.IsNullOrWhiteSpace(content))
+                return null;
+
+            // TTML
+            if (content.StartsWith("<?xml") && System.Text.RegularExpressions.Regex.IsMatch(content, @"<tt(:\w+)?\b"))
+            {
+                return LyricsFormat.Ttml;
+            }
+            // KRC: 检测主内容格式 [start,duration]<offset,duration,0>字...
+            else if (System.Text.RegularExpressions.Regex.IsMatch(
+                         content,
+                         @"^\[\d+,\d+\](<\d+,\d+,0>.+)+",
+                         System.Text.RegularExpressions.RegexOptions.Multiline))
+            {
+                return LyricsFormat.Krc;
+            }
+            // QRC: 检测主内容格式 [start,duration]字(offset,duration)
+            else if (System.Text.RegularExpressions.Regex.IsMatch(
+                         content,
+                         @"^\[\d+,\d+\].*?\(\d+,\d+\)",
+                         System.Text.RegularExpressions.RegexOptions.Multiline))
+            {
+                return LyricsFormat.Qrc;
+            }
+            // 标准LRC和增强型LRC
+            else if (System.Text.RegularExpressions.Regex.IsMatch(content, @"\[\d{1,2}:\d{2}") ||
+                     System.Text.RegularExpressions.Regex.IsMatch(content, @"<\d{1,2}:\d{2}\.\d{2,3}>"))
+            {
+                return LyricsFormat.Lrc;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public static string ToFileExtension(this LyricsFormat format)
+        {
+            return format switch
+            {
+                LyricsFormat.Lrc => ".lrc",
+                LyricsFormat.Qrc => ".qrc",
+                LyricsFormat.Krc => ".krc",
+                LyricsFormat.Eslrc => ".eslrc",
+                LyricsFormat.Ttml => ".ttml",
+                _ => ".*",
+            };
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LyricsSearchProvider.cs

@@ -0,0 +1,65 @@
+// 2025/6/23 by Zhe Fang
+
+using BetterLyrics.WinUI3.Helper;
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LyricsSearchProvider
+    {
+        QQ,
+        Kugou,
+        Netease,
+        LrcLib,
+        AmllTtmlDb,
+        LocalMusicFile,
+        LocalLrcFile,
+        LocalEslrcFile,
+        LocalTtmlFile,
+    }
+
+    public static class LyricsSearchProviderExtensions
+    {
+        public static string GetCacheDirectory(this LyricsSearchProvider provider)
+        {
+            return provider switch
+            {
+                LyricsSearchProvider.LrcLib => AppInfo.LrcLibLyricsCacheDirectory,
+                LyricsSearchProvider.QQ => AppInfo.QQLyricsCacheDirectory,
+                LyricsSearchProvider.Netease => AppInfo.NeteaseLyricsCacheDirectory,
+                LyricsSearchProvider.Kugou => AppInfo.KugouLyricsCacheDirectory,
+                LyricsSearchProvider.AmllTtmlDb => AppInfo.AmllTtmlDbLyricsCacheDirectory,
+                _ => throw new System.ArgumentOutOfRangeException(nameof(provider)),
+            };
+        }
+
+        public static LyricsFormat GetLyricsFormat(this LyricsSearchProvider provider)
+        {
+            return provider switch
+            {
+                LyricsSearchProvider.LrcLib => LyricsFormat.Lrc,
+                LyricsSearchProvider.QQ => LyricsFormat.Qrc,
+                LyricsSearchProvider.Kugou => LyricsFormat.Krc,
+                LyricsSearchProvider.Netease => LyricsFormat.Lrc,
+                LyricsSearchProvider.AmllTtmlDb => LyricsFormat.Ttml,
+                LyricsSearchProvider.LocalLrcFile => LyricsFormat.Lrc,
+                LyricsSearchProvider.LocalEslrcFile => LyricsFormat.Eslrc,
+                LyricsSearchProvider.LocalTtmlFile => LyricsFormat.Ttml,
+                _ => LyricsFormat.NotSpecified,
+            };
+        }
+
+        public static bool IsLocal(this LyricsSearchProvider provider)
+        {
+            return provider
+                is LyricsSearchProvider.LocalMusicFile
+                    or LyricsSearchProvider.LocalLrcFile
+                    or LyricsSearchProvider.LocalEslrcFile
+                    or LyricsSearchProvider.LocalTtmlFile;
+        }
+
+        public static bool IsRemote(this LyricsSearchProvider provider)
+        {
+            return !provider.IsLocal();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/MusicSearchMatchMode.cs

@@ -0,0 +1,10 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum MusicSearchMatchMode
+    {
+        TitleAndArtist,
+        TitleArtistAlbumAndDuration,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/TextAlignmentType.cs

@@ -0,0 +1,28 @@
+// 2025/6/23 by Zhe Fang
+
+using Microsoft.Graphics.Canvas.Text;
+using System;
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum TextAlignmentType
+    {
+        Left,
+        Center,
+        Right,
+    }
+
+    public static class LyricsAlignmentTypeExtensions
+    {
+        public static CanvasHorizontalAlignment ToCanvasHorizontalAlignment(this TextAlignmentType alignmentType)
+        {
+            return alignmentType switch
+            {
+                TextAlignmentType.Left => CanvasHorizontalAlignment.Left,
+                TextAlignmentType.Center => CanvasHorizontalAlignment.Center,
+                TextAlignmentType.Right => CanvasHorizontalAlignment.Right,
+                _ => throw new ArgumentOutOfRangeException(nameof(alignmentType), alignmentType, null),
+            };
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/WindowColorSampleMode.cs

@@ -0,0 +1,9 @@
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum WindowColorSampleMode
+    {
+        BelowWindow,
+        WindowArea,
+        WindowEdge,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Events/IsPlayingChangedEventArgs.cs

@@ -0,0 +1,11 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+
+namespace BetterLyrics.WinUI3.Events
+{
+    public class IsPlayingChangedEventArgs(bool isPlaying) : EventArgs
+    {
+        public bool IsPlaying { get; set; } = isPlaying;
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Events/LibChangedEventArgs.cs

@@ -0,0 +1,18 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BetterLyrics.WinUI3.Events
+{
+    public class LibChangedEventArgs(string folder, string filePath, WatcherChangeTypes changeType) : EventArgs
+    {
+        public WatcherChangeTypes ChangeType { get; } = changeType;
+        public string FilePath { get; } = filePath;
+        public string Folder { get; } = folder;
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Events/MediaSourceProvidersInfoEventArgs.cs

@@ -0,0 +1,14 @@
+using BetterLyrics.WinUI3.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BetterLyrics.WinUI3.Events
+{
+    public class MediaSourceProvidersInfoEventArgs(List<MediaSourceProviderInfo> sessionIds):EventArgs
+    {
+        public List<MediaSourceProviderInfo> MediaSourceProviersInfo { get; set; } = sessionIds;
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Events/PositionChangedEventArgs.cs

@@ -0,0 +1,11 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+
+namespace BetterLyrics.WinUI3.Events
+{
+    public class PositionChangedEventArgs(TimeSpan position) : EventArgs()
+    {
+        public TimeSpan Position { get; set; } = position;
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Events/SongInfoChangedEventArgs.cs

@@ -0,0 +1,12 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using BetterLyrics.WinUI3.Models;
+
+namespace BetterLyrics.WinUI3.Events
+{
+    public class SongInfoChangedEventArgs(SongInfo? songInfo) : EventArgs
+    {
+        public SongInfo? SongInfo { get; set; } = songInfo;
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/AnimationHelper.cs

@@ -1,44 +1,180 @@
-using Microsoft.UI.Xaml;
-using Microsoft.UI.Xaml.Media.Animation;
+// 2025/6/23 by Zhe Fang
+
 using System;
+using System.Diagnostics;
+using BetterLyrics.WinUI3.Enums;
 
-namespace BetterLyrics.WinUI3.Helper {
-
-    /// <summary>
-    /// Edited based on: https://stackoverflow.com/a/25236507/11048731
-    /// </summary>
-    public class AnimationHelper : DependencyObject {
-        public static int GetAnimationDuration(DependencyObject obj) {
-            return (int)obj.GetValue(AnimationDurationProperty);
-        }
-
-        public static void SetAnimationDuration(DependencyObject obj, int value) {
-            obj.SetValue(AnimationDurationProperty, value);
-        }
-
-        // Using a DependencyProperty as the backing store for AnimationDuration.
-        // This enables animation, styling, binding, etc...
-        public static readonly DependencyProperty AnimationDurationProperty =
-            DependencyProperty.RegisterAttached("AnimationDuration", typeof(int),
-            typeof(AnimationHelper), new PropertyMetadata(0,
-            OnAnimationDurationChanged));
-
-        private static void OnAnimationDurationChanged(DependencyObject d,
-            DependencyPropertyChangedEventArgs e) {
-            FrameworkElement element = d as FrameworkElement;
-
-            var ms = (int)e.NewValue;
-
-            if (ms < 0) return;
-
-            var key = "LyricsLineCharGradientInTextBlock";
-            foreach (var timeline in (element.Resources[key] as Storyboard).Children) {
-                foreach (var keyFrame in (timeline as DoubleAnimationUsingKeyFrames).KeyFrames) {
-                    (keyFrame as LinearDoubleKeyFrame).KeyTime =
-                        KeyTime.FromTimeSpan(TimeSpan.FromMilliseconds(ms));
-                }
-            }
-        }
+namespace BetterLyrics.WinUI3.Helper
+{
+    public class AnimationHelper
+    {
+        public const int DebounceDefaultDuration = 200;
+        public const int StackedNotificationsShowingDuration = 3900;
+        public const int StoryboardDefaultDuration = 200;
     }
 
+    public class ValueTransition<T>
+        where T : struct
+    {
+        private T _currentValue;
+        private float _durationSeconds;
+        private EasingType? _easingType;
+        private Func<T, T, float, T> _interpolator;
+        private bool _isTransitioning;
+        private float _progress;
+        private T _startValue;
+        private T _targetValue;
+
+        public float DurationSeconds => _durationSeconds;
+
+        public bool IsTransitioning => _isTransitioning;
+        public T Value => _currentValue;
+        public T TargetValue => _targetValue;
+
+        public ValueTransition(T initialValue, float durationSeconds, Func<T, T, float, T>? interpolator = null, EasingType? easingType = null)
+        {
+            _currentValue = initialValue;
+            _startValue = initialValue;
+            _targetValue = initialValue;
+            _durationSeconds = durationSeconds;
+            _progress = 1f;
+            _isTransitioning = false;
+
+            if (interpolator != null)
+            {
+                _interpolator = interpolator;
+                _easingType = null;
+            }
+            else if (easingType.HasValue)
+            {
+                _easingType = easingType;
+                _interpolator = GetInterpolatorByEasingType(_easingType.Value);
+            }
+            else
+            {
+                _easingType = EasingType.SmoothStep;
+                _interpolator = GetInterpolatorByEasingType(_easingType.Value);
+            }
+        }
+
+        private void JumpTo(T value)
+        {
+            _currentValue = value;
+            _startValue = value;
+            _targetValue = value;
+            _progress = 1f;
+            _isTransitioning = false;
+        }
+
+        public void Reset(T value)
+        {
+            _currentValue = value;
+            _startValue = value;
+            _targetValue = value;
+            _progress = 0f;
+            _isTransitioning = false;
+        }
+
+        public void StartTransition(T targetValue, bool jumpTo = false)
+        {
+            if (jumpTo)
+            {
+                JumpTo(targetValue);
+                return;
+            }
+
+            if (!targetValue.Equals(_currentValue))
+            {
+                _startValue = _currentValue;
+                _targetValue = targetValue;
+                _progress = 0f;
+                _isTransitioning = true;
+            }
+        }
+
+        public static bool Equals(double x, double y, double tolerance)
+        {
+            var diff = Math.Abs(x - y);
+            return diff <= tolerance || diff <= Math.Max(Math.Abs(x), Math.Abs(y)) * tolerance;
+        }
+
+        public void Update(TimeSpan elapsedTime)
+        {
+            if (!_isTransitioning) return;
+
+            _progress += (float)elapsedTime.TotalSeconds / _durationSeconds;
+            if (_progress >= 1f)
+            {
+                _progress = 1f;
+                _currentValue = _targetValue;
+                _isTransitioning = false;
+            }
+            else
+            {
+                _currentValue = _interpolator(_startValue, _targetValue, _progress);
+            }
+        }
+
+        private Func<T, T, float, T> GetInterpolatorByEasingType(EasingType type)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                return (start, end, progress) =>
+                {
+                    float s = (float)(object)start;
+                    float e = (float)(object)end;
+                    float t = progress;
+                    switch (type)
+                    {
+                        case EasingType.EaseInOutSine:
+                            t = EasingHelper.EaseInOutSine(t);
+                            break;
+                        case EasingType.EaseInOutQuad:
+                            t = EasingHelper.EaseInOutQuad(t);
+                            break;
+                        case EasingType.EaseInOutCubic:
+                            t = EasingHelper.EaseInOutCubic(t);
+                            break;
+                        case EasingType.EaseInOutQuart:
+                            t = EasingHelper.EaseInOutQuart(t);
+                            break;
+                        case EasingType.EaseInOutQuint:
+                            t = EasingHelper.EaseInOutQuint(t);
+                            break;
+                        case EasingType.EaseInOutExpo:
+                            t = EasingHelper.EaseInOutExpo(t);
+                            break;
+                        case EasingType.EaseInOutCirc:
+                            t = EasingHelper.EaseInOutCirc(t);
+                            break;
+                        case EasingType.EaseInOutBack:
+                            t = EasingHelper.EaseInOutBack(t);
+                            break;
+                        case EasingType.EaseInOutElastic:
+                            t = EasingHelper.EaseInOutElastic(t);
+                            break;
+                        case EasingType.EaseInOutBounce:
+                            t = EasingHelper.EaseInOutBounce(t);
+                            break;
+                        case EasingType.SmoothStep:
+                            t = EasingHelper.SmoothStep(t);
+                            break;
+                        case EasingType.Linear:
+                            t = EasingHelper.Linear(t);
+                            break;
+                        default:
+                            break;
+                    }
+                    return (T)(object)(s + (e - s) * t);
+                };
+            }
+            throw new NotSupportedException($"Easing type {type} is not supported for type {typeof(T)}.");
+        }
+
+        public void SetEasingType(EasingType easingType)
+        {
+            _easingType = easingType;
+            _interpolator = GetInterpolatorByEasingType(easingType);
+        }
+    }
 }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/AppInfo.cs

@@ -0,0 +1,115 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Helper
+{
+    using BetterLyrics.WinUI3.Models;
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Reflection;
+    using System.Threading.Tasks;
+    using Windows.ApplicationModel;
+    using Windows.Storage;
+    using Windows.Storage.FileProperties;
+
+    public static class AppInfo
+    {
+        public const string AppAuthor = "Zhe Fang";
+        public const string AppDisplayName = "Better Lyrics";
+        public const string AppName = "BetterLyrics";
+        public static string AppVersion
+        {
+            get
+            {
+                var version = Package.Current.Id.Version;
+                return $"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}";
+            }
+        }
+
+        public const string GithubUrl = "https://github.com/jayfunc/BetterLyrics";
+
+        public static string CacheFolder => ApplicationData.Current.LocalCacheFolder.Path;
+
+
+        public const string UnlockWindowTag = "UnlockWindow";
+
+        public static string AmllTtmlDbIndexPath => Path.Combine(CacheFolder, "amll-ttml-db-index.json");
+
+        public static string AssetsFolder => Path.Combine(Package.Current.InstalledPath, "Assets");
+        public static string LogDirectory => Path.Combine(CacheFolder, "logs");
+        public static string LogFilePattern => Path.Combine(LogDirectory, "log-.txt");
+
+        public static string LrcLibLyricsCacheDirectory => Path.Combine(CacheFolder, "lrclib-lyrics");
+        public static string NeteaseLyricsCacheDirectory => Path.Combine(CacheFolder, "netease-lyrics");
+        public static string QQLyricsCacheDirectory => Path.Combine(CacheFolder, "qq-lyrics");
+        public static string KugouLyricsCacheDirectory => Path.Combine(CacheFolder, "kugou-lyrics");
+        public static string AmllTtmlDbLyricsCacheDirectory => Path.Combine(CacheFolder, "amll-ttml-db-lyrics");
+
+        public static string iTunesAlbumArtCacheDirectory => Path.Combine(CacheFolder, "itunes-album-art");
+
+
+        private static string LocalFolder => ApplicationData.Current.LocalFolder.Path;
+
+        public static void EnsureDirectories()
+        {
+            Directory.CreateDirectory(LocalFolder);
+            Directory.CreateDirectory(LogDirectory);
+
+            Directory.CreateDirectory(LrcLibLyricsCacheDirectory);
+            Directory.CreateDirectory(QQLyricsCacheDirectory);
+            Directory.CreateDirectory(KugouLyricsCacheDirectory);
+            Directory.CreateDirectory(NeteaseLyricsCacheDirectory);
+            Directory.CreateDirectory(AmllTtmlDbLyricsCacheDirectory);
+
+            Directory.CreateDirectory(iTunesAlbumArtCacheDirectory);
+        }
+
+        public static async Task<DateTime> GetBuildDate()
+        {
+            var assembly = Assembly.GetExecutingAssembly();
+            var filePath = assembly.Location;
+            if (!File.Exists(filePath))
+                return DateTime.MinValue;
+
+            StorageFile file = await StorageFile.GetFileFromPathAsync(filePath);
+            // 获取文件基本属性
+            BasicProperties props = await file.GetBasicPropertiesAsync();
+            // 返回修改日期
+            return props.DateModified.DateTime;
+        }
+
+        public static List<LanguageInfo> GetAllTranslationLanguagesInfo() =>
+        [
+            new LanguageInfo("ar", "العربية"),
+            new LanguageInfo("az", "Azərbaycan dili"),
+            new LanguageInfo("zh", "中文"),
+            new LanguageInfo("cs", "Čeština"),
+            new LanguageInfo("da", "Dansk"),
+            new LanguageInfo("nl", "Nederlands"),
+            new LanguageInfo("en", "English"),
+            new LanguageInfo("eo", "Esperanto"),
+            new LanguageInfo("fi", "Suomi"),
+            new LanguageInfo("fr", "Français"),
+            new LanguageInfo("de", "Deutsch"),
+            new LanguageInfo("el", "Ελληνικά"),
+            new LanguageInfo("he", "עברית"),
+            new LanguageInfo("hi", "हिन्दी"),
+            new LanguageInfo("hu", "Magyar"),
+            new LanguageInfo("id", "Bahasa Indonesia"),
+            new LanguageInfo("ga", "Gaeilge"),
+            new LanguageInfo("it", "Italiano"),
+            new LanguageInfo("ja", "日本語"),
+            new LanguageInfo("ko", "한국어"),
+            new LanguageInfo("fa", "فارسی"),
+            new LanguageInfo("pl", "Polski"),
+            new LanguageInfo("pt", "Português"),
+            new LanguageInfo("ru", "Русский"),
+            new LanguageInfo("sk", "Slovenčina"),
+            new LanguageInfo("es", "Español"),
+            new LanguageInfo("sv", "Svenska"),
+            new LanguageInfo("tr", "Türkçe"),
+            new LanguageInfo("uk", "Українська"),
+            new LanguageInfo("vi", "Tiếng Việt"),
+        ];
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/CollectionHelper.cs

@@ -1,14 +1,14 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+// 2025/6/23 by Zhe Fang
 
-namespace BetterLyrics.WinUI3.Helper {
-    public static class CollectionHelper {
-        public static T? SafeGet<T>(this IList<T> list, int index) {
-            if (list == null || index < 0 || index >= list.Count)
-                return default;
+using System.Collections.Generic;
+
+namespace BetterLyrics.WinUI3.Helper
+{
+    public static class CollectionHelper
+    {
+        public static T? SafeGet<T>(this IList<T> list, int index)
+        {
+            if (list == null || index < 0 || index >= list.Count) return default;
             return list[index];
         }
     }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/ColorHelper.cs

@@ -1,12 +1,102 @@
-namespace BetterLyrics.WinUI3.Helper {
-    public class ColorHelper {
-        public static Windows.UI.Color LerpColor(Windows.UI.Color a, Windows.UI.Color b, double t) {
-            byte A = (byte)(a.A + (b.A - a.A) * t);
-            byte R = (byte)(a.R + (b.R - a.R) * t);
-            byte G = (byte)(a.G + (b.G - a.G) * t);
-            byte B = (byte)(a.B + (b.B - a.B) * t);
-            return Windows.UI.Color.FromArgb(A, R, G, B);
+// 2025/6/23 by Zhe Fang
+
+using System;
+using Microsoft.UI;
+using Microsoft.UI.Xaml;
+using Windows.UI;
+
+namespace BetterLyrics.WinUI3.Helper
+{
+    public static class ColorHelper
+    {
+        public static ElementTheme GetElementThemeFromBackgroundColor(Color backgroundColor)
+        {
+            // 计算亮度（YIQ公式）
+            double yiq =
+                ((backgroundColor.R * 299) + (backgroundColor.G * 587) + (backgroundColor.B * 114))
+                / 1000.0;
+            return yiq >= 128 ? ElementTheme.Light : ElementTheme.Dark;
         }
 
+        public static Color GetForegroundColor(Color background)
+        {
+            // 转为 HSL
+            var hsl = CommunityToolkit.WinUI.Helpers.ColorHelper.ToHsl(background);
+            double h = hsl.H;
+            double s = hsl.S;
+            double l = hsl.L;
+
+            // 目标亮度与背景错开，但不极端
+            double targetL;
+            if (l >= 0.7)
+                targetL = 0.35; // 背景很亮，前景适中偏暗
+            else if (l <= 0.3)
+                targetL = 0.75; // 背景很暗，前景适中偏亮
+            else
+                targetL = l > 0.5 ? l - 0.35 : l + 0.35; // 其余情况适度错开
+
+            // 保持色相，适当提升饱和度
+            double targetS = Math.Min(1.0, s + 0.2);
+
+            // 转回 Color
+            var fg = CommunityToolkit.WinUI.Helpers.ColorHelper.FromHsl(h, targetS, targetL);
+
+            // 保持不透明
+            return Color.FromArgb(255, fg.R, fg.G, fg.B);
+        }
+
+        public static Color GetInterpolatedColor(float progress, Color startColor, Color targetColor)
+        {
+            byte Lerp(byte a, byte b) => (byte)(a + (progress * (b - a)));
+            return Color.FromArgb(
+                Lerp(startColor.A, targetColor.A),
+                Lerp(startColor.R, targetColor.R),
+                Lerp(startColor.G, targetColor.G),
+                Lerp(startColor.B, targetColor.B)
+            );
+        }
+
+        public static Color ToColor(this int argb)
+        {
+            byte a = (byte)(argb >> 24);
+            byte r = (byte)(argb >> 16);
+            byte g = (byte)(argb >> 8);
+            byte b = (byte)argb;
+
+            // 还原非预乘分量
+            if (a == 0)
+                return Color.FromArgb(0, 0, 0, 0);
+
+            // 预乘解码
+            // 这里 a+1 是编码时的分母
+            int ap1 = a + 1;
+            r = (byte)Math.Min(255, (r * 255 + (ap1 / 2)) / ap1);
+            g = (byte)Math.Min(255, (g * 255 + (ap1 / 2)) / ap1);
+            b = (byte)Math.Min(255, (b * 255 + (ap1 / 2)) / ap1);
+
+            return Color.FromArgb(a, r, g, b);
+        }
+
+        public static Color ToColor(this System.Drawing.Color color)
+        {
+            return Color.FromArgb(color.A, color.R, color.G, color.B);
+        }
+
+        public static Color WithAlpha(this Color color, byte alpha)
+        {
+            return Color.FromArgb(alpha, color.R, color.G, color.B);
+        }
+
+        public static Color WithBrightness(this Color color, double brightness)
+        {
+            // 确保亮度因子在合理范围内
+            brightness = Math.Max(0, Math.Min(1, brightness));
+
+            var hsl = CommunityToolkit.WinUI.Helpers.ColorHelper.ToHsl(color);
+            double h = hsl.H;
+            double s = hsl.S;
+
+            return CommunityToolkit.WinUI.Helpers.ColorHelper.FromHsl(h, s, brightness);
+        }
     }
 }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/ColorThief.cs

@@ -1,928 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Windows.Graphics.Imaging;
-
-namespace BetterLyrics.WinUI3.Helper
-{
-    /// <summary>
-    ///     Color map
-    /// </summary>
-    internal class CMap
-    {
-        private readonly List<VBox> vboxes = new List<VBox>();
-        private List<QuantizedColor> palette;
-
-        public void Push(VBox box)
-        {
-            palette = null;
-            vboxes.Add(box);
-        }
-
-        public List<QuantizedColor> GeneratePalette()
-        {
-            if (palette == null)
-            {
-                palette = (from vBox in vboxes
-                           let rgb = vBox.Avg(false)
-                           let color = FromRgb(rgb[0], rgb[1], rgb[2])
-                           select new QuantizedColor(color, vBox.Count(false))).ToList();
-            }
-
-            return palette;
-        }
-
-        public int Size()
-        {
-            return vboxes.Count;
-        }
-
-        public int[] Map(int[] color)
-        {
-            foreach (var vbox in vboxes.Where(vbox => vbox.Contains(color)))
-            {
-                return vbox.Avg(false);
-            }
-            return Nearest(color);
-        }
-
-        public int[] Nearest(int[] color)
-        {
-            var d1 = double.MaxValue;
-            int[] pColor = null;
-
-            foreach (var t in vboxes)
-            {
-                var vbColor = t.Avg(false);
-                var d2 = Math.Sqrt(Math.Pow(color[0] - vbColor[0], 2)
-                                   + Math.Pow(color[1] - vbColor[1], 2)
-                                   + Math.Pow(color[2] - vbColor[2], 2));
-                if (d2 < d1)
-                {
-                    d1 = d2;
-                    pColor = vbColor;
-                }
-            }
-            return pColor;
-        }
-
-        public VBox FindColor(double targetLuma, double minLuma, double maxLuma, double targetSaturation, double minSaturation, double maxSaturation)
-        {
-            VBox max = null;
-            double maxValue = 0;
-            var highestPopulation = vboxes.Select(p => p.Count(false)).Max();
-
-            foreach (var swatch in vboxes)
-            {
-                var avg = swatch.Avg(false);
-                var hsl = FromRgb(avg[0], avg[1], avg[2]).ToHsl();
-                var sat = hsl.S;
-                var luma = hsl.L;
-
-                if (sat >= minSaturation && sat <= maxSaturation &&
-                   luma >= minLuma && luma <= maxLuma)
-                {
-                    var thisValue = Mmcq.CreateComparisonValue(sat, targetSaturation, luma, targetLuma,
-                        swatch.Count(false), highestPopulation);
-
-                    if (max == null || thisValue > maxValue)
-                    {
-                        max = swatch;
-                        maxValue = thisValue;
-                    }
-                }
-            }
-
-            return max;
-        }
-
-        public Color FromRgb(int red, int green, int blue)
-        {
-            var color = new Color
-            {
-                A = 255,
-                R = (byte)red,
-                G = (byte)green,
-                B = (byte)blue
-            };
-
-            return color;
-        }
-    }
-
-    /// <summary>
-    ///     Defines a color in RGB space.
-    /// </summary>
-    public struct Color
-    {
-        /// <summary>
-        ///     Get or Set the Alpha component value for sRGB.
-        /// </summary>
-        public byte A;
-
-        /// <summary>
-        ///     Get or Set the Blue component value for sRGB.
-        /// </summary>
-        public byte B;
-
-        /// <summary>
-        ///     Get or Set the Green component value for sRGB.
-        /// </summary>
-        public byte G;
-
-        /// <summary>
-        ///     Get or Set the Red component value for sRGB.
-        /// </summary>
-        public byte R;
-
-        /// <summary>
-        ///     Get HSL color.
-        /// </summary>
-        /// <returns></returns>
-        public HslColor ToHsl()
-        {
-            const double toDouble = 1.0 / 255;
-            var r = toDouble * R;
-            var g = toDouble * G;
-            var b = toDouble * B;
-            var max = Math.Max(Math.Max(r, g), b);
-            var min = Math.Min(Math.Min(r, g), b);
-            var chroma = max - min;
-            double h1;
-
-            // ReSharper disable CompareOfFloatsByEqualityOperator
-            if (chroma == 0)
-            {
-                h1 = 0;
-            }
-            else if (max == r)
-            {
-                h1 = (g - b) / chroma % 6;
-            }
-            else if (max == g)
-            {
-                h1 = 2 + (b - r) / chroma;
-            }
-            else //if (max == b)
-            {
-                h1 = 4 + (r - g) / chroma;
-            }
-
-            var lightness = 0.5 * (max - min);
-            var saturation = chroma == 0 ? 0 : chroma / (1 - Math.Abs(2 * lightness - 1));
-            HslColor ret;
-            ret.H = 60 * h1;
-            ret.S = saturation;
-            ret.L = lightness;
-            ret.A = toDouble * A;
-            return ret;
-            // ReSharper restore CompareOfFloatsByEqualityOperator
-        }
-
-        public string ToHexString()
-        {
-            return "#" + R.ToString("X2") + G.ToString("X2") + B.ToString("X2");
-        }
-
-        public string ToHexAlphaString()
-        {
-            return "#" + A.ToString("X2") + R.ToString("X2") + G.ToString("X2") + B.ToString("X2");
-        }
-
-        public override string ToString()
-        {
-            if (A == 255)
-            {
-                return ToHexString();
-            }
-
-            return ToHexAlphaString();
-        }
-    }
-
-    /// <summary>
-    ///     Defines a color in Hue/Saturation/Lightness (HSL) space.
-    /// </summary>
-    public struct HslColor
-    {
-        /// <summary>
-        ///     The Alpha/opacity in 0..1 range.
-        /// </summary>
-        public double A;
-
-        /// <summary>
-        ///     The Hue in 0..360 range.
-        /// </summary>
-        public double H;
-
-        /// <summary>
-        ///     The Lightness in 0..1 range.
-        /// </summary>
-        public double L;
-
-        /// <summary>
-        ///     The Saturation in 0..1 range.
-        /// </summary>
-        public double S;
-    }
-
-    internal static class Mmcq
-    {
-        public const int Sigbits = 5;
-        public const int Rshift = 8 - Sigbits;
-        public const int Mult = 1 << Rshift;
-        public const int Histosize = 1 << (3 * Sigbits);
-        public const int VboxLength = 1 << Sigbits;
-        public const double FractByPopulation = 0.75;
-        public const int MaxIterations = 1000;
-        public const double WeightSaturation = 3d;
-        public const double WeightLuma = 6d;
-        public const double WeightPopulation = 1d;
-        private static readonly VBoxComparer ComparatorProduct = new VBoxComparer();
-        private static readonly VBoxCountComparer ComparatorCount = new VBoxCountComparer();
-
-        public static int GetColorIndex(int r, int g, int b)
-        {
-            return (r << (2 * Sigbits)) + (g << Sigbits) + b;
-        }
-
-        /// <summary>
-        ///     Gets the histo.
-        /// </summary>
-        /// <param name="pixels">The pixels.</param>
-        /// <returns>Histo (1-d array, giving the number of pixels in each quantized region of color space), or null on error.</returns>
-        private static int[] GetHisto(IEnumerable<byte[]> pixels)
-        {
-            var histo = new int[Histosize];
-
-            foreach (var pixel in pixels)
-            {
-                var rval = pixel[0] >> Rshift;
-                var gval = pixel[1] >> Rshift;
-                var bval = pixel[2] >> Rshift;
-                var index = GetColorIndex(rval, gval, bval);
-                histo[index]++;
-            }
-            return histo;
-        }
-
-        private static VBox VboxFromPixels(IList<byte[]> pixels, int[] histo)
-        {
-            int rmin = 1000000, rmax = 0;
-            int gmin = 1000000, gmax = 0;
-            int bmin = 1000000, bmax = 0;
-
-            // find min/max
-            var numPixels = pixels.Count;
-            for (var i = 0; i < numPixels; i++)
-            {
-                var pixel = pixels[i];
-                var rval = pixel[0] >> Rshift;
-                var gval = pixel[1] >> Rshift;
-                var bval = pixel[2] >> Rshift;
-
-                if (rval < rmin)
-                {
-                    rmin = rval;
-                }
-                else if (rval > rmax)
-                {
-                    rmax = rval;
-                }
-
-                if (gval < gmin)
-                {
-                    gmin = gval;
-                }
-                else if (gval > gmax)
-                {
-                    gmax = gval;
-                }
-
-                if (bval < bmin)
-                {
-                    bmin = bval;
-                }
-                else if (bval > bmax)
-                {
-                    bmax = bval;
-                }
-            }
-
-            return new VBox(rmin, rmax, gmin, gmax, bmin, bmax, histo);
-        }
-
-        private static VBox[] DoCut(char color, VBox vbox, IList<int> partialsum, IList<int> lookaheadsum, int total)
-        {
-            int vboxDim1;
-            int vboxDim2;
-
-            switch (color)
-            {
-                case 'r':
-                    vboxDim1 = vbox.R1;
-                    vboxDim2 = vbox.R2;
-                    break;
-                case 'g':
-                    vboxDim1 = vbox.G1;
-                    vboxDim2 = vbox.G2;
-                    break;
-                default:
-                    vboxDim1 = vbox.B1;
-                    vboxDim2 = vbox.B2;
-                    break;
-            }
-
-            for (var i = vboxDim1; i <= vboxDim2; i++)
-            {
-                if (partialsum[i] > total / 2)
-                {
-                    var vbox1 = vbox.Clone();
-                    var vbox2 = vbox.Clone();
-
-                    var left = i - vboxDim1;
-                    var right = vboxDim2 - i;
-
-                    var d2 = left <= right
-                        ? Math.Min(vboxDim2 - 1, Math.Abs(i + right / 2))
-                        : Math.Max(vboxDim1, Math.Abs(Convert.ToInt32(i - 1 - left / 2.0)));
-
-                    // avoid 0-count boxes
-                    while (d2 < 0 || partialsum[d2] <= 0)
-                    {
-                        d2++;
-                    }
-                    var count2 = lookaheadsum[d2];
-                    while (count2 == 0 && d2 > 0 && partialsum[d2 - 1] > 0)
-                    {
-                        count2 = lookaheadsum[--d2];
-                    }
-
-                    // set dimensions
-                    switch (color)
-                    {
-                        case 'r':
-                            vbox1.R2 = d2;
-                            vbox2.R1 = d2 + 1;
-                            break;
-                        case 'g':
-                            vbox1.G2 = d2;
-                            vbox2.G1 = d2 + 1;
-                            break;
-                        default:
-                            vbox1.B2 = d2;
-                            vbox2.B1 = d2 + 1;
-                            break;
-                    }
-
-                    return new[] { vbox1, vbox2 };
-                }
-            }
-
-            throw new Exception("VBox can't be cut");
-        }
-
-        private static VBox[] MedianCutApply(IList<int> histo, VBox vbox)
-        {
-            if (vbox.Count(false) == 0)
-            {
-                return null;
-            }
-            if (vbox.Count(false) == 1)
-            {
-                return new[] { vbox.Clone(), null };
-            }
-
-            // only one pixel, no split
-
-            var rw = vbox.R2 - vbox.R1 + 1;
-            var gw = vbox.G2 - vbox.G1 + 1;
-            var bw = vbox.B2 - vbox.B1 + 1;
-            var maxw = Math.Max(Math.Max(rw, gw), bw);
-
-            // Find the partial sum arrays along the selected axis.
-            var total = 0;
-            var partialsum = new int[VboxLength];
-            // -1 = not set / 0 = 0
-            for (var l = 0; l < partialsum.Length; l++)
-            {
-                partialsum[l] = -1;
-            }
-
-            // -1 = not set / 0 = 0
-            var lookaheadsum = new int[VboxLength];
-            for (var l = 0; l < lookaheadsum.Length; l++)
-            {
-                lookaheadsum[l] = -1;
-            }
-
-            int i, j, k, sum, index;
-
-            if (maxw == rw)
-            {
-                for (i = vbox.R1; i <= vbox.R2; i++)
-                {
-                    sum = 0;
-                    for (j = vbox.G1; j <= vbox.G2; j++)
-                    {
-                        for (k = vbox.B1; k <= vbox.B2; k++)
-                        {
-                            index = GetColorIndex(i, j, k);
-                            sum += histo[index];
-                        }
-                    }
-                    total += sum;
-                    partialsum[i] = total;
-                }
-            }
-            else if (maxw == gw)
-            {
-                for (i = vbox.G1; i <= vbox.G2; i++)
-                {
-                    sum = 0;
-                    for (j = vbox.R1; j <= vbox.R2; j++)
-                    {
-                        for (k = vbox.B1; k <= vbox.B2; k++)
-                        {
-                            index = GetColorIndex(j, i, k);
-                            sum += histo[index];
-                        }
-                    }
-                    total += sum;
-                    partialsum[i] = total;
-                }
-            }
-            else /* maxw == bw */
-            {
-                for (i = vbox.B1; i <= vbox.B2; i++)
-                {
-                    sum = 0;
-                    for (j = vbox.R1; j <= vbox.R2; j++)
-                    {
-                        for (k = vbox.G1; k <= vbox.G2; k++)
-                        {
-                            index = GetColorIndex(j, k, i);
-                            sum += histo[index];
-                        }
-                    }
-                    total += sum;
-                    partialsum[i] = total;
-                }
-            }
-
-            for (i = 0; i < VboxLength; i++)
-            {
-                if (partialsum[i] != -1)
-                {
-                    lookaheadsum[i] = total - partialsum[i];
-                }
-            }
-
-            // determine the cut planes
-            return maxw == rw ? DoCut('r', vbox, partialsum, lookaheadsum, total) : maxw == gw
-                    ? DoCut('g', vbox, partialsum, lookaheadsum, total) : DoCut('b', vbox, partialsum, lookaheadsum, total);
-        }
-
-        /// <summary>
-        ///     Inner function to do the iteration.
-        /// </summary>
-        /// <param name="lh">The lh.</param>
-        /// <param name="comparator">The comparator.</param>
-        /// <param name="target">The target.</param>
-        /// <param name="histo">The histo.</param>
-        /// <exception cref="System.Exception">vbox1 not defined; shouldn't happen!</exception>
-        private static void Iter(List<VBox> lh, IComparer<VBox> comparator, int target, IList<int> histo)
-        {
-            var ncolors = 1;
-            var niters = 0;
-
-            while (niters < MaxIterations)
-            {
-                var vbox = lh[lh.Count - 1];
-                if (vbox.Count(false) == 0)
-                {
-                    lh.Sort(comparator);
-                    niters++;
-                    continue;
-                }
-
-                lh.RemoveAt(lh.Count - 1);
-
-                // do the cut
-                var vboxes = MedianCutApply(histo, vbox);
-                var vbox1 = vboxes[0];
-                var vbox2 = vboxes[1];
-
-                if (vbox1 == null)
-                {
-                    throw new Exception(
-                        "vbox1 not defined; shouldn't happen!");
-                }
-
-                lh.Add(vbox1);
-                if (vbox2 != null)
-                {
-                    lh.Add(vbox2);
-                    ncolors++;
-                }
-                lh.Sort(comparator);
-
-                if (ncolors >= target)
-                {
-                    return;
-                }
-                if (niters++ > MaxIterations)
-                {
-                    return;
-                }
-            }
-        }
-
-        public static CMap Quantize(byte[][] pixels, int maxcolors)
-        {
-            // short-circuit
-            if (pixels.Length == 0 || maxcolors < 2 || maxcolors > 256)
-            {
-                return null;
-            }
-
-            var histo = GetHisto(pixels);
-
-            // get the beginning vbox from the colors
-            var vbox = VboxFromPixels(pixels, histo);
-            var pq = new List<VBox> { vbox };
-
-            // Round up to have the same behaviour as in JavaScript
-            var target = (int)Math.Ceiling(FractByPopulation * maxcolors);
-
-            // first set of colors, sorted by population
-            Iter(pq, ComparatorCount, target, histo);
-
-            // Re-sort by the product of pixel occupancy times the size in color
-            // space.
-            pq.Sort(ComparatorProduct);
-
-            // next set - generate the median cuts using the (npix * vol) sorting.
-            Iter(pq, ComparatorProduct, maxcolors - pq.Count, histo);
-
-            // Reverse to put the highest elements first into the color map
-            pq.Reverse();
-
-            // calculate the actual colors
-            var cmap = new CMap();
-            foreach (var vb in pq)
-            {
-                cmap.Push(vb);
-            }
-
-            return cmap;
-        }
-
-        public static double CreateComparisonValue(double saturation, double targetSaturation, double luma, double targetLuma, int population, int highestPopulation)
-        {
-            return WeightedMean(InvertDiff(saturation, targetSaturation), WeightSaturation,
-                InvertDiff(luma, targetLuma), WeightLuma,
-                population / (double)highestPopulation, WeightPopulation);
-        }
-
-        private static double WeightedMean(params double[] values)
-        {
-            double sum = 0;
-            double sumWeight = 0;
-
-            for (var i = 0; i < values.Length; i += 2)
-            {
-                var value = values[i];
-                var weight = values[i + 1];
-
-                sum += value * weight;
-                sumWeight += weight;
-            }
-
-            return sum / sumWeight;
-        }
-
-        private static double InvertDiff(double value, double targetValue)
-        {
-            return 1 - Math.Abs(value - targetValue);
-        }
-    }
-
-    public class QuantizedColor
-    {
-        public QuantizedColor(Color color, int population)
-        {
-            Color = color;
-            Population = population;
-            IsDark = CalculateYiqLuma(color) < 128;
-        }
-
-        public Color Color { get; private set; }
-        public int Population { get; private set; }
-        public bool IsDark { get; private set; }
-
-        public int CalculateYiqLuma(Color color)
-        {
-            return Convert.ToInt32(Math.Round((299 * color.R + 587 * color.G + 114 * color.B) / 1000f));
-        }
-    }
-
-    /// <summary>
-    ///     3D color space box.
-    /// </summary>
-    internal class VBox
-    {
-        private readonly int[] histo;
-        private int[] avg;
-        public int B1;
-        public int B2;
-        private int? count;
-        public int G1;
-        public int G2;
-        public int R1;
-        public int R2;
-        private int? volume;
-
-        public VBox(int r1, int r2, int g1, int g2, int b1, int b2, int[] histo)
-        {
-            R1 = r1;
-            R2 = r2;
-            G1 = g1;
-            G2 = g2;
-            B1 = b1;
-            B2 = b2;
-
-            this.histo = histo;
-        }
-
-        public int Volume(bool force)
-        {
-            if (volume == null || force)
-            {
-                volume = (R2 - R1 + 1) * (G2 - G1 + 1) * (B2 - B1 + 1);
-            }
-
-            return volume.Value;
-        }
-
-        public int Count(bool force)
-        {
-            if (count == null || force)
-            {
-                var npix = 0;
-                int i;
-
-                for (i = R1; i <= R2; i++)
-                {
-                    int j;
-                    for (j = G1; j <= G2; j++)
-                    {
-                        int k;
-                        for (k = B1; k <= B2; k++)
-                        {
-                            var index = Mmcq.GetColorIndex(i, j, k);
-                            npix += histo[index];
-                        }
-                    }
-                }
-
-                count = npix;
-            }
-
-            return count.Value;
-        }
-
-        public VBox Clone()
-        {
-            return new VBox(R1, R2, G1, G2, B1, B2, histo);
-        }
-
-        public int[] Avg(bool force)
-        {
-            if (avg == null || force)
-            {
-                var ntot = 0;
-
-                var rsum = 0;
-                var gsum = 0;
-                var bsum = 0;
-
-                int i;
-
-                for (i = R1; i <= R2; i++)
-                {
-                    int j;
-                    for (j = G1; j <= G2; j++)
-                    {
-                        int k;
-                        for (k = B1; k <= B2; k++)
-                        {
-                            var histoindex = Mmcq.GetColorIndex(i, j, k);
-                            var hval = histo[histoindex];
-                            ntot += hval;
-                            rsum += Convert.ToInt32((hval * (i + 0.5) * Mmcq.Mult));
-                            gsum += Convert.ToInt32((hval * (j + 0.5) * Mmcq.Mult));
-                            bsum += Convert.ToInt32((hval * (k + 0.5) * Mmcq.Mult));
-                        }
-                    }
-                }
-
-                if (ntot > 0)
-                {
-                    avg = new[]
-                    {
-                        Math.Abs(rsum / ntot), Math.Abs(gsum / ntot),
-                        Math.Abs(bsum / ntot)
-                    };
-                }
-                else
-                {
-                    avg = new[]
-                    {
-                        Math.Abs(Mmcq.Mult * (R1 + R2 + 1) / 2),
-                        Math.Abs(Mmcq.Mult * (G1 + G2 + 1) / 2),
-                        Math.Abs(Mmcq.Mult * (B1 + B2 + 1) / 2)
-                    };
-                }
-            }
-
-            return avg;
-        }
-
-        public bool Contains(int[] pixel)
-        {
-            var rval = pixel[0] >> Mmcq.Rshift;
-            var gval = pixel[1] >> Mmcq.Rshift;
-            var bval = pixel[2] >> Mmcq.Rshift;
-
-            return rval >= R1 && rval <= R2 && gval >= G1 && gval <= G2 && bval >= B1 && bval <= B2;
-        }
-    }
-
-    internal class VBoxCountComparer : IComparer<VBox>
-    {
-        public int Compare(VBox x, VBox y)
-        {
-            var a = x.Count(false);
-            var b = y.Count(false);
-            return a < b ? -1 : (a > b ? 1 : 0);
-        }
-    }
-
-    internal class VBoxComparer : IComparer<VBox>
-    {
-        public int Compare(VBox x, VBox y)
-        {
-            var aCount = x.Count(false);
-            var bCount = y.Count(false);
-            var aVolume = x.Volume(false);
-            var bVolume = y.Volume(false);
-
-            // Otherwise sort by products
-            var a = aCount * aVolume;
-            var b = bCount * bVolume;
-            return a < b ? -1 : (a > b ? 1 : 0);
-        }
-    }
-
-    public class ColorThief
-    {
-        public const int DefaultColorCount = 5;
-        public const int DefaultQuality = 10;
-        public const bool DefaultIgnoreWhite = true;
-        public const int ColorDepth = 4;
-
-        private CMap GetColorMap(byte[][] pixelArray, int colorCount)
-        {
-            // Send array to quantize function which clusters values using median
-            // cut algorithm
-
-            if (colorCount > 0)
-            {
-                --colorCount;
-            }
-
-            var cmap = Mmcq.Quantize(pixelArray, colorCount);
-            return cmap;
-        }
-
-        private byte[][] ConvertPixels(byte[] pixels, int pixelCount, int quality, bool ignoreWhite)
-        {
-
-
-            var expectedDataLength = pixelCount * ColorDepth;
-            if (expectedDataLength != pixels.Length)
-            {
-                throw new ArgumentException("(expectedDataLength = "
-                                            + expectedDataLength + ") != (pixels.length = "
-                                            + pixels.Length + ")");
-            }
-
-            // Store the RGB values in an array format suitable for quantize
-            // function
-
-            // numRegardedPixels must be rounded up to avoid an
-            // ArrayIndexOutOfBoundsException if all pixels are good.
-
-            var numRegardedPixels = (pixelCount + quality - 1) / quality;
-
-            var numUsedPixels = 0;
-            var pixelArray = new byte[numRegardedPixels][];
-
-            for (var i = 0; i < pixelCount; i += quality)
-            {
-                var offset = i * ColorDepth;
-                var b = pixels[offset];
-                var g = pixels[offset + 1];
-                var r = pixels[offset + 2];
-                var a = pixels[offset + 3];
-
-                // If pixel is mostly opaque and not white
-                if (a >= 125 && !(ignoreWhite && r > 250 && g > 250 && b > 250))
-                {
-                    pixelArray[numUsedPixels] = new[] { r, g, b };
-                    numUsedPixels++;
-                }
-            }
-
-            // Remove unused pixels from the array
-            var copy = new byte[numUsedPixels][];
-            Array.Copy(pixelArray, copy, numUsedPixels);
-            return copy;
-        }
-
-        /// <summary>
-        ///     Use the median cut algorithm to cluster similar colors and return the base color from the largest cluster.
-        /// </summary>
-        /// <param name="sourceImage">The source image.</param>
-        /// <param name="quality">
-        ///     1 is the highest quality settings. 10 is the default. There is
-        ///     a trade-off between quality and speed. The bigger the number,
-        ///     the faster a color will be returned but the greater the
-        ///     likelihood that it will not be the visually most dominant color.
-        /// </param>
-        /// <param name="ignoreWhite">if set to <c>true</c> [ignore white].</param>
-        /// <returns></returns>
-        public async Task<QuantizedColor> GetColor(BitmapDecoder sourceImage, int quality = DefaultQuality, bool ignoreWhite = DefaultIgnoreWhite)
-        {
-            var palette = await GetPalette(sourceImage, 3, quality, ignoreWhite);
-
-            var dominantColor = new QuantizedColor(new Color
-            {
-                A = Convert.ToByte(palette.Average(a => a.Color.A)),
-                R = Convert.ToByte(palette.Average(a => a.Color.R)),
-                G = Convert.ToByte(palette.Average(a => a.Color.G)),
-                B = Convert.ToByte(palette.Average(a => a.Color.B))
-            }, Convert.ToInt32(palette.Average(a => a.Population)));
-
-            return dominantColor;
-        }
-
-        /// <summary>
-        ///     Use the median cut algorithm to cluster similar colors.
-        /// </summary>
-        /// <param name="sourceImage">The source image.</param>
-        /// <param name="colorCount">The color count.</param>
-        /// <param name="quality">
-        ///     1 is the highest quality settings. 10 is the default. There is
-        ///     a trade-off between quality and speed. The bigger the number,
-        ///     the faster a color will be returned but the greater the
-        ///     likelihood that it will not be the visually most dominant color.
-        /// </param>
-        /// <param name="ignoreWhite">if set to <c>true</c> [ignore white].</param>
-        /// <returns></returns>
-        /// <code>true</code>
-        public async Task<List<QuantizedColor>> GetPalette(BitmapDecoder sourceImage, int colorCount = DefaultColorCount, int quality = DefaultQuality, bool ignoreWhite = DefaultIgnoreWhite)
-        {
-            var pixelArray = await GetPixelsFast(sourceImage, quality, ignoreWhite);
-            var cmap = GetColorMap(pixelArray, colorCount);
-            if (cmap != null)
-            {
-                var colors = cmap.GeneratePalette();
-                return colors;
-            }
-            return new List<QuantizedColor>();
-        }
-
-        private async Task<byte[]> GetIntFromPixel(BitmapDecoder decoder)
-        {
-            var pixelsData = await decoder.GetPixelDataAsync();
-            var pixels = pixelsData.DetachPixelData();
-            return pixels;
-        }
-
-        private async Task<byte[][]> GetPixelsFast(BitmapDecoder sourceImage, int quality, bool ignoreWhite)
-        {
-            if (quality < 1)
-            {
-                quality = DefaultQuality;
-            }
-
-            var pixels = await GetIntFromPixel(sourceImage);
-            var pixelCount = sourceImage.PixelWidth * sourceImage.PixelHeight;
-
-            return ConvertPixels(pixels, Convert.ToInt32(pixelCount), quality, ignoreWhite);
-        }
-    }
-}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/DatabaseHelper.cs

@@ -1,21 +0,0 @@
-using BetterLyrics.WinUI3.Models;
-using SQLite;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BetterLyrics.WinUI3.Helper {
-    public class DatabaseHelper {
-        private static SQLiteConnection _database;
-
-        public static SQLiteConnection InitializeDatabase() {
-            string dbPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "MusicMetadataIndex.db");
-            _database = new SQLiteConnection(dbPath);
-            _database.CreateTable<MetadataIndex>(); // Create table if it doesn't exist
-            return _database;
-        }
-    }
-}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/DesktopModeHelper.cs

@@ -0,0 +1,144 @@
+using BetterLyrics.WinUI3.Enums;
+using BetterLyrics.WinUI3.Services;
+using CommunityToolkit.Mvvm.DependencyInjection;
+using Microsoft.UI.Xaml;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Vanara.PInvoke;
+using WinRT.Interop;
+using WinUIEx;
+
+namespace BetterLyrics.WinUI3.Helper
+{
+    public static class DesktopModeHelper
+    {
+        private static readonly ISettingsService _settingsService = Ioc.Default.GetRequiredService<ISettingsService>();
+
+        private static readonly Dictionary<IntPtr, bool> _clickThroughStates = [];
+        private static readonly Dictionary<IntPtr, bool> _originalTopmostStates = [];
+        private static readonly Dictionary<IntPtr, (double X, double Y, double Width, double Height)> _originalWindowBounds = [];
+        private static readonly Dictionary<IntPtr, WindowStyle> _originalWindowStyles = [];
+
+        private delegate nint WndProcDelegate(nint hWnd, uint msg, nint wParam, nint lParam);
+
+        public static void Disable(Window window)
+        {
+            IntPtr hwnd = WindowNative.GetWindowHandle(window);
+
+            // <20>ָ<EFBFBD>TopMost״̬
+            if (_originalTopmostStates.TryGetValue(hwnd, out var wasTopMost))
+            {
+                window.SetIsAlwaysOnTop(wasTopMost);
+                _originalTopmostStates.Remove(hwnd);
+            }
+
+            // <20>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD>úʹ<C3BA>С
+            if (_originalWindowBounds.TryGetValue(hwnd, out var bounds))
+            {
+                window.AppWindow.MoveAndResize(
+                    new Windows.Graphics.RectInt32(
+                        (int)bounds.X,
+                        (int)bounds.Y,
+                        (int)bounds.Width,
+                        (int)bounds.Height
+                    )
+                );
+                _originalWindowBounds.Remove(hwnd);
+            }
+
+            // <20>ָ<EFBFBD><D6B8><EFBFBD>ʽ
+            if (_originalWindowStyles.TryGetValue(hwnd, out var style))
+            {
+                window.SetWindowStyle(style);
+                _originalWindowStyles.Remove(hwnd);
+            }
+
+            window.SetIsShownInSwitchers(true);
+        }
+
+        public static void Enable(Window window)
+        {
+            IntPtr hwnd = WindowNative.GetWindowHandle(window);
+
+            // <20><>¼ԭʼ<D4AD><CABC><EFBFBD><EFBFBD>λ<EFBFBD>úʹ<C3BA>С
+            if (!_originalWindowBounds.ContainsKey(hwnd))
+            {
+                _originalWindowBounds[hwnd] = (
+                    window.AppWindow.Position.X,
+                    window.AppWindow.Position.Y,
+                    window.AppWindow.Size.Width,
+                    window.AppWindow.Size.Height
+                );
+            }
+
+            // <20>Ӵ洢<D3B4><E6B4A2><EFBFBD><EFBFBD>ȡĿ<C8A1><C4BF><EFBFBD><EFBFBD><EFBFBD>ߺ<EFBFBD>λ<EFBFBD><CEBB>
+            int targetWidth = _settingsService.DesktopWindowWidth;
+            int targetHeight = _settingsService.DesktopWindowHeight;
+            int targetX = _settingsService.DesktopWindowLeft;
+            int targetY = _settingsService.DesktopWindowTop;
+
+            // <20><><EFBFBD>ô<EFBFBD><C3B4>ڴ<EFBFBD>С<EFBFBD><D0A1>λ<EFBFBD><CEBB>
+            window.AppWindow.MoveAndResize(
+                new Windows.Graphics.RectInt32(targetX, targetY, targetWidth, targetHeight)
+            );
+
+            // <20><><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>ʽ
+            if (!_originalWindowStyles.ContainsKey(hwnd))
+                _originalWindowStyles[hwnd] = window.GetWindowStyle();
+
+            // <20><><EFBFBD><EFBFBD>ԭTopMost״̬
+            if (!_originalTopmostStates.ContainsKey(hwnd))
+                _originalTopmostStates[hwnd] = window.GetIsAlwaysOnTop();
+
+            // <20><><EFBFBD>ô<EFBFBD><C3B4><EFBFBD><EFBFBD>ö<EFBFBD>
+            window.SetIsAlwaysOnTop(true);
+
+            window.SetIsShownInSwitchers(false);
+        }
+
+        public static void Lock(Window window)
+        {
+            window.SystemBackdrop = SystemBackdropHelper.CreateSystemBackdrop(BackdropType.Transparent);
+
+            // <20><><EFBFBD><EFBFBD><EFBFBD>ޱ߿<DEB1><DFBF><EFBFBD>͸<EFBFBD><CDB8>
+            window.ToggleWindowStyle(true, WindowStyle.Popup | WindowStyle.Visible);
+            window.ExtendsContentIntoTitleBar = false;
+
+            SetClickThrough(window, true);
+        }
+
+        public static void SetClickThrough(Window window, bool enable)
+        {
+            IntPtr hwnd = WindowNative.GetWindowHandle(window);
+            int exStyle = User32.GetWindowLong(hwnd, User32.WindowLongFlags.GWL_EXSTYLE);
+            if (enable)
+            {
+                User32.SetWindowLong(hwnd, User32.WindowLongFlags.GWL_EXSTYLE, exStyle | (int)User32.WindowStylesEx.WS_EX_TRANSPARENT | (int)User32.WindowStylesEx.WS_EX_LAYERED);
+                _clickThroughStates[hwnd] = true;
+            }
+            else
+            {
+                User32.SetWindowLong(hwnd, User32.WindowLongFlags.GWL_EXSTYLE, exStyle & ~(int)User32.WindowStylesEx.WS_EX_TRANSPARENT);
+                _clickThroughStates[hwnd] = false;
+            }
+        }
+
+        public static void Unlock(Window window)
+        {
+            IntPtr hwnd = WindowNative.GetWindowHandle(window);
+
+            // <20>ָ<EFBFBD><D6B8><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƴ<EFBFBD><C6B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD>ֻ<EFBFBD><D6BB><EFBFBD><EFBFBD> Disable ʱ<><CAB1><EFBFBD>Ƴ<EFBFBD><C6B3><EFBFBD>
+            if (_originalWindowStyles.TryGetValue(hwnd, out var style))
+            {
+                window.SetWindowStyle(style);
+            }
+            window.ExtendsContentIntoTitleBar = true;
+
+            SetClickThrough(window, false);
+
+            // To recover the system backdrop, we need to reopen the window
+            WindowHelper.RestartApp(AppInfo.UnlockWindowTag);
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/DockModeHelper.cs

@@ -0,0 +1,158 @@
+using Microsoft.UI.Xaml;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using Vanara.PInvoke;
+using WinRT.Interop;
+using WinUIEx;
+
+namespace BetterLyrics.WinUI3.Helper
+{
+    public static class DockModeHelper
+    {
+        private static readonly HashSet<IntPtr> _registered = [];
+        private static readonly Dictionary<IntPtr, RECT> _originalPositions = [];
+        private static readonly Dictionary<IntPtr, WindowStyle> _originalWindowStyle = [];
+
+        public static void Disable(Window window)
+        {
+            window.SetIsShownInSwitchers(true);
+            window.ExtendsContentIntoTitleBar = true;
+            window.SetIsAlwaysOnTop(false);
+
+            IntPtr hwnd = WindowNative.GetWindowHandle(window);
+
+            window.SetWindowStyle(_originalWindowStyle[hwnd]);
+            _originalWindowStyle.Remove(hwnd);
+
+            if (_originalPositions.TryGetValue(hwnd, out var rect))
+            {
+                User32.SetWindowPos(
+                    hwnd,
+                    IntPtr.Zero,
+                    rect.Left,
+                    rect.Top,
+                    rect.Right - rect.Left,
+                    rect.Bottom - rect.Top,
+                    User32.SetWindowPosFlags.SWP_SHOWWINDOW
+                );
+                _originalPositions.Remove(hwnd);
+            }
+
+            UnregisterAppBar(hwnd);
+        }
+
+        public static void Enable(Window window, int appBarHeight)
+        {
+            window.SetIsShownInSwitchers(false);
+            window.ExtendsContentIntoTitleBar = false;
+            window.SetIsAlwaysOnTop(true);
+
+            IntPtr hwnd = WindowNative.GetWindowHandle(window);
+
+            if (!_originalWindowStyle.ContainsKey(hwnd))
+            {
+                _originalWindowStyle[hwnd] = window.GetWindowStyle();
+            }
+            window.SetWindowStyle(WindowStyle.Popup | WindowStyle.Visible);
+
+            if (!_originalPositions.ContainsKey(hwnd))
+            {
+                if (User32.GetWindowRect(hwnd, out var rect))
+                {
+                    _originalPositions[hwnd] = rect;
+                }
+            }
+
+            RegisterAppBar(hwnd, appBarHeight);
+
+            int screenWidth = User32.GetSystemMetrics(User32.SystemMetric.SM_CXSCREEN);
+            int screenHeight = User32.GetSystemMetrics(User32.SystemMetric.SM_CYSCREEN);
+            User32.SetWindowPos(
+                hwnd,
+                IntPtr.Zero,
+                0,
+                0,
+                screenWidth,
+                appBarHeight,
+                User32.SetWindowPosFlags.SWP_SHOWWINDOW
+            );
+        }
+
+        private static void RegisterAppBar(IntPtr hwnd, int height)
+        {
+            if (_registered.Contains(hwnd)) return;
+
+            Shell32.APPBARDATA abd = new()
+            {
+                cbSize = (uint)Marshal.SizeOf<Shell32.APPBARDATA>(),
+                hWnd = hwnd,
+                uEdge = Shell32.ABE.ABE_TOP,
+                rc = new RECT
+                {
+                    Left = 0,
+                    Top = 0,
+                    Right = User32.GetSystemMetrics(User32.SystemMetric.SM_CXSCREEN),
+                    Bottom = height,
+                },
+            };
+
+            Shell32.SHAppBarMessage(Shell32.ABM.ABM_NEW, ref abd);
+            Shell32.SHAppBarMessage(Shell32.ABM.ABM_SETPOS, ref abd);
+
+            _registered.Add(hwnd);
+        }
+
+        private static void UnregisterAppBar(IntPtr hwnd)
+        {
+            if (!_registered.Contains(hwnd))
+                return;
+
+            Shell32.APPBARDATA abd = new()
+            {
+                cbSize = (uint)Marshal.SizeOf<Shell32.APPBARDATA>(),
+                hWnd = hwnd
+            };
+
+            Shell32.SHAppBarMessage(Shell32.ABM.ABM_REMOVE, ref abd);
+            _registered.Remove(hwnd);
+        }
+
+        public static void UpdateAppBarHeight(IntPtr hwnd, int newHeight)
+        {
+            if (!_registered.Contains(hwnd))
+                return;
+
+            Shell32.APPBARDATA abd = new()
+            {
+                cbSize = (uint)Marshal.SizeOf<Shell32.APPBARDATA>(),
+                hWnd = hwnd,
+                uEdge = Shell32.ABE.ABE_TOP,
+                rc = new RECT
+                {
+                    Left = 0,
+                    Top = 0,
+                    Right = User32.GetSystemMetrics(User32.SystemMetric.SM_CXSCREEN),
+                    Bottom = newHeight,
+                },
+            };
+
+            Shell32.SHAppBarMessage(Shell32.ABM.ABM_SETPOS, ref abd);
+
+            // 同步窗口实际高度
+            User32.SetWindowPos(
+                hwnd,
+                IntPtr.Zero,
+                0,
+                0,
+                User32.GetSystemMetrics(User32.SystemMetric.SM_CXSCREEN),
+                newHeight,
+                User32.SetWindowPosFlags.SWP_SHOWWINDOW
+            );
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/EasingHelper.cs

@@ -1,48 +1,112 @@
-using System;
+// 2025/6/23 by Zhe Fang
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace BetterLyrics.WinUI3.Helper {
-    public class EasingHelper {
+namespace BetterLyrics.WinUI3.Helper
+{
+    public class EasingHelper
+    {
+        public static float EaseInOutSine(float t)
+        {
+            return -(MathF.Cos(MathF.PI * t) - 1f) / 2f;
+        }
+        public static float EaseInOutQuad(float t)
+        {
+            return t < 0.5f ? 2 * t * t : -1 + (4 - 2 * t) * t;
+        }
 
-        /// <summary>
-        /// No easing
-        /// </summary>
-        public static float Linear(float t) => t;
+        public static float EaseInOutCubic(float t)
+        {
+            return t < 0.5f ? 4 * t * t * t : 1 - MathF.Pow(-2 * t + 2, 3) / 2;
+        }
+        public static float EaseInOutQuart(float t)
+        {
+            return t < 0.5f ? 8 * t * t * t * t : 1 - MathF.Pow(-2 * t + 2, 4) / 2;
+        }
 
-        /// <summary>
-        /// Accelerating from 0
-        /// </summary>
-        public static float EaseInQuad(float t) => t * t;
+        public static float EaseInOutQuint(float t)
+        {
+            return t < 0.5f ? 16 * t * t * t * t * t : 1 - MathF.Pow(-2 * t + 2, 5) / 2;
+        }
 
-        /// <summary>
-        /// Decelerating to 0
-        /// </summary>
-        public static float EaseOutQuad(float t) => t * (2 - t);
+        public static float EaseInOutExpo(float t)
+        {
+            return t == 0
+              ? 0
+              : t == 1
+              ? 1
+              : t < 0.5 ? MathF.Pow(2, 20 * t - 10) / 2
+              : (2 - MathF.Pow(2, -20 * t + 10)) / 2;
+        }
 
-        /// <summary>
-        /// Acceleration until halfway then deceleration
-        /// </summary>
-        public static float EaseInOutQuad(float t) {
+        public static float EaseInOutCirc(float t)
+        {
             return t < 0.5f
-                ? 2 * t * t
-                : -1 + (4 - 2 * t) * t;
+              ? (1 - MathF.Sqrt(1 - MathF.Pow(2 * t, 2))) / 2
+              : (MathF.Sqrt(1 - MathF.Pow(-2 * t + 2, 2)) + 1) / 2;
         }
 
-        /// <summary>
-        /// Smoother transition than linear
-        /// </summary>
-        public static float SmoothStep(float t) {
-            return t * t * (3 - 2 * t);
+        public static float EaseInOutBack(float t)
+        {
+            float c1 = 1.70158f;
+            float c2 = c1 * 1.525f;
+
+            return t < 0.5
+              ? (MathF.Pow(2 * t, 2) * ((c2 + 1) * 2 * t - c2)) / 2
+              : (MathF.Pow(2 * t - 2, 2) * ((c2 + 1) * (t * 2 - 2) + c2) + 2) / 2;
         }
 
-        /// <summary>
-        /// Even smoother transition with continuous first and second derivatives
-        /// </summary>
-        public static float SmootherStep(float t) {
-            return t * t * t * (t * (6 * t - 15) + 10);
+        public static float EaseInOutElastic(float t)
+        {
+            if (t == 0 || t == 1) return t;
+            float p = 0.3f;
+            float s = p / 4;
+            return t < 0.5f
+              ? -(MathF.Pow(2, 20 * t - 10) * MathF.Sin((20 * t - 11.125f) * (2 * MathF.PI) / p)) / 2
+              : (MathF.Pow(2, -20 * t + 10) * MathF.Sin((20 * t - 11.125f) * (2 * MathF.PI) / p)) / 2 + 1;
         }
+
+        private static float EaseOutBounce(float t)
+        {
+            if (t < 4 / 11f)
+            {
+                return (121 * t * t) / 16f;
+            }
+            else if (t < 8 / 11f)
+            {
+                return (363 / 40f * t * t) - (99 / 10f * t) + 17 / 5f;
+            }
+            else if (t < 9 / 10f)
+            {
+                return (4356 / 361f * t * t) - (35442 / 1805f * t) + 16061 / 1805f;
+            }
+            else
+            {
+                return (54 / 5f * t * t) - (513 / 25f * t) + 268 / 25f;
+            }
+        }
+
+        public static float EaseInOutBounce(float t)
+        {
+            if (t < 0.5f)
+            {
+                return (1 - EaseOutBounce(1 - 2 * t)) / 2;
+            }
+            else
+            {
+                return (1 + EaseOutBounce(2 * t - 1)) / 2;
+            }
+        }
+
+        public static float SmoothStep(float t)
+        {
+            return t * t * (3f - 2f * t);
+        }
+
+        public static float Linear(float t) => t;
     }
 }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/FileHelper.cs

@@ -0,0 +1,25 @@
+// 2025/6/23 by Zhe Fang
+
+using System.IO;
+using System.Text;
+using Ude;
+
+namespace BetterLyrics.WinUI3.Helper
+{
+    public class FileHelper
+    {
+        public static Encoding GetEncoding(string filename)
+        {
+            var bytes = File.ReadAllBytes(filename);
+            var cdet = new CharsetDetector();
+            cdet.Feed(bytes, 0, bytes.Length);
+            cdet.DataEnd();
+            var encoding = cdet.Charset;
+            if (encoding == null)
+            {
+                return Encoding.UTF8;
+            }
+            return Encoding.GetEncoding(encoding);
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/ForegroundWindowWatcherHelper.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.UI.Xaml;
+using Vanara.PInvoke;
+using Windows.System;
+
+namespace BetterLyrics.WinUI3.Helper
+{
+    public class ForegroundWindowWatcherHelper
+    {
+        private readonly User32.WinEventProc _winEventDelegate;
+        private readonly List<User32.HWINEVENTHOOK> _hooks = new();
+        private HWND _currentForeground = HWND.NULL;
+        private readonly IntPtr _selfHwnd;
+        private readonly DispatcherTimer _pollingTimer;
+        private DateTime _lastEventTime = DateTime.MinValue;
+        private const int ThrottleIntervalMs = 1000;
+
+        public delegate void WindowChangedHandler(HWND hwnd);
+        private readonly WindowChangedHandler _onWindowChanged;
+
+        public ForegroundWindowWatcherHelper(IntPtr selfHwnd, WindowChangedHandler onWindowChanged)
+        {
+            _selfHwnd = selfHwnd;
+            _onWindowChanged = onWindowChanged;
+            _winEventDelegate = new User32.WinEventProc(WinEventProc);
+
+            _pollingTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(200) };
+            _pollingTimer.Tick += (_, _) =>
+            {
+                if (_currentForeground != IntPtr.Zero && _currentForeground != _selfHwnd)
+                    _onWindowChanged?.Invoke(_currentForeground);
+            };
+        }
+
+        public void Start()
+        {
+            // Hook: foreground changes and minimize end
+            _hooks.Add(
+                User32.SetWinEventHook(
+                    User32.EventConstants.EVENT_SYSTEM_FOREGROUND,
+                    User32.EventConstants.EVENT_SYSTEM_MINIMIZEEND,
+                    HINSTANCE.NULL,
+                    _winEventDelegate,
+                    0,
+                    0,
+                    User32.WINEVENT.WINEVENT_OUTOFCONTEXT
+                )
+            );
+
+            // Hook: window move/resize (location change)
+            _hooks.Add(
+                User32.SetWinEventHook(
+                    User32.EventConstants.EVENT_OBJECT_LOCATIONCHANGE,
+                    User32.EventConstants.EVENT_OBJECT_LOCATIONCHANGE,
+                    HINSTANCE.NULL,
+                    _winEventDelegate,
+                    0,
+                    0,
+                    User32.WINEVENT.WINEVENT_OUTOFCONTEXT
+                )
+            );
+
+            _pollingTimer.Start();
+        }
+
+        public void Stop()
+        {
+            foreach (var hook in _hooks)
+                User32.UnhookWinEvent(hook);
+
+            _hooks.Clear();
+            _pollingTimer.Stop();
+        }
+
+        private void WinEventProc(
+            User32.HWINEVENTHOOK hWinEventHook,
+            uint eventType,
+            HWND hwnd,
+            int idObject,
+            int idChild,
+            uint dwEventThread,
+            uint dwmsEventTime
+        )
+        {
+            if (hwnd == IntPtr.Zero || hwnd == _selfHwnd)
+                return;
+
+            var now = DateTime.Now;
+            if ((now - _lastEventTime).TotalMilliseconds < ThrottleIntervalMs)
+                return;
+
+            _lastEventTime = now;
+
+            if (eventType == User32.EventConstants.EVENT_SYSTEM_FOREGROUND)
+            {
+                _currentForeground = hwnd;
+                _onWindowChanged?.Invoke(hwnd);
+            }
+            else if ((eventType == User32.EventConstants.EVENT_OBJECT_LOCATIONCHANGE || eventType == User32.EventConstants.EVENT_SYSTEM_MINIMIZEEND) && hwnd == _currentForeground)
+            {
+                _onWindowChanged?.Invoke(hwnd);
+            }
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/ImageHelper.cs

@@ -1,16 +1,158 @@
-using Microsoft.UI.Xaml.Media;
-using Microsoft.UI.Xaml.Media.Imaging;
+// 2025/6/23 by Zhe Fang
+
 using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Numerics;
 using System.Runtime.InteropServices.WindowsRuntime;
 using System.Threading.Tasks;
+using Microsoft.Graphics.Canvas;
+using Microsoft.Graphics.Canvas.Text;
+using Microsoft.UI;
+using Microsoft.UI.Xaml.Media.Imaging;
 using Windows.Graphics.Imaging;
-using Windows.Storage;
 using Windows.Storage.Streams;
+using Windows.UI;
 
 namespace BetterLyrics.WinUI3.Helper
 {
     public class ImageHelper
     {
+        public const int AccentColorCount = 3;
+
+        public static async Task<InMemoryRandomAccessStream> ByteArrayToStream(byte[] bytes)
+        {
+            var stream = new InMemoryRandomAccessStream();
+            await stream.WriteAsync(bytes.AsBuffer());
+            stream.Seek(0);
+
+            return stream;
+        }
+
+        public static async Task<byte[]> CreateTextPlaceholderBytesAsync(string text, int width, int height)
+        {
+            var device = CanvasDevice.GetSharedDevice();
+            var renderTarget = new CanvasRenderTarget(device, width, height, 96);
+
+            // 居中绘制文字
+            using (var ds = renderTarget.CreateDrawingSession())
+            {
+                // 背景色
+                ds.Clear(Colors.LightGray);
+
+                // 文字格式
+                var format = new CanvasTextFormat
+                {
+                    FontSize = Math.Min(width, height) / 6f,
+                    FontWeight = Microsoft.UI.Text.FontWeights.SemiBold,
+                    HorizontalAlignment = CanvasHorizontalAlignment.Center,
+                    VerticalAlignment = CanvasVerticalAlignment.Center,
+                    WordWrapping = CanvasWordWrapping.Wrap,
+                    TrimmingGranularity = CanvasTextTrimmingGranularity.Character,
+                    Options = CanvasDrawTextOptions.Default,
+                };
+
+                // 设定边距
+                float margin = Math.Min(width, height) / 12f;
+                float availableWidth = width - 2 * margin;
+                float availableHeight = height - 2 * margin;
+
+                // 计算合适的字体大小以适应内容区域
+                float fontSize = format.FontSize;
+                float minFontSize = 8f;
+                float maxFontSize = format.FontSize;
+                CanvasTextLayout layout;
+                do
+                {
+                    format.FontSize = fontSize;
+                    layout = new CanvasTextLayout(
+                        ds,
+                        text,
+                        format,
+                        availableWidth,
+                        availableHeight
+                    );
+                    if (
+                        layout.LayoutBounds.Width <= availableWidth
+                        && layout.LayoutBounds.Height <= availableHeight
+                    )
+                        break;
+                    fontSize -= 1f;
+                } while (fontSize >= minFontSize);
+
+                // 居中绘制文字（在内容区域内居中）
+                var bounds = layout.LayoutBounds;
+                var x = margin + (availableWidth - (float)bounds.Width) / 2f - (float)bounds.X;
+                var y = margin + (availableHeight - (float)bounds.Height) / 2f - (float)bounds.Y;
+                ds.DrawTextLayout(layout, new Vector2(x, y), Colors.DarkGray);
+            }
+
+            // 保存为 PNG 并转为 byte[]
+            using (var stream = new InMemoryRandomAccessStream())
+            {
+                await renderTarget.SaveAsync(stream, CanvasBitmapFileFormat.Png);
+                var buffer = new byte[stream.Size];
+                using (var reader = new DataReader(stream.GetInputStreamAt(0)))
+                {
+                    await reader.LoadAsync((uint)stream.Size);
+                    reader.ReadBytes(buffer);
+                }
+                return buffer;
+            }
+        }
+
+        public static List<Windows.UI.Color> GetAccentColorsFromByte(byte[] bytes)
+        {
+            // 使用 ImageSharp 读取图片
+            using var image = SixLabors.ImageSharp.Image.Load<SixLabors.ImageSharp.PixelFormats.Rgba32>(bytes);
+
+            // 简单聚类法：统计所有像素出现频率，取出现最多的前 AccentColorCount 个颜色
+            var colorCount = new Dictionary<SixLabors.ImageSharp.PixelFormats.Rgba32, int>();
+
+            for (int y = 0; y < image.Height; y++)
+            {
+                for (int x = 0; x < image.Width; x++)
+                {
+                    var color = image[x, y];
+                    // 可选：忽略透明像素
+                    if (color.A < 32) continue;
+                    if (colorCount.ContainsKey(color))
+                        colorCount[color]++;
+                    else
+                        colorCount[color] = 1;
+                }
+            }
+
+            // 按出现次数排序，取前 AccentColorCount 个
+            var topColors = colorCount
+                .OrderByDescending(kv => kv.Value)
+                .Take(AccentColorCount)
+                .Select(kv => kv.Key)
+                .ToList();
+
+            // 转换为 Windows.UI.Color
+            return topColors
+                .Select(c => Windows.UI.Color.FromArgb(c.A, c.R, c.G, c.B))
+                .ToList();
+        }
+
+
+        public static async Task<BitmapImage> GetBitmapImageFromBytesAsync(byte[] imageBytes)
+        {
+            var stream = new InMemoryRandomAccessStream();
+            await stream.WriteAsync(imageBytes.AsBuffer());
+            stream.Seek(0);
+
+            var bitmapImage = new BitmapImage();
+            await bitmapImage.SetSourceAsync(stream);
+
+            return bitmapImage;
+        }
+
+        public static async Task<BitmapDecoder> GetDecoderFromByte(byte[] bytes) =>
+            await BitmapDecoder.CreateAsync(await ByteArrayToStream(bytes));
+
         public static async Task<InMemoryRandomAccessStream> GetStreamFromBytesAsync(byte[] imageBytes)
         {
             if (imageBytes == null || imageBytes.Length == 0)
@@ -18,9 +160,33 @@ namespace BetterLyrics.WinUI3.Helper
 
             InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
             await stream.WriteAsync(imageBytes.AsBuffer());
-            stream.Seek(0);
 
             return stream;
         }
+
+        public static async Task<byte[]> ToByteArrayAsync(IRandomAccessStreamReference streamRef)
+        {
+            using IRandomAccessStream stream = await streamRef.OpenReadAsync();
+            using var memoryStream = new MemoryStream();
+            await stream.AsStreamForRead().CopyToAsync(memoryStream);
+            return memoryStream.ToArray();
+        }
+
+        public static float GetAverageLuminance(CanvasBitmap bitmap)
+        {
+            var pixels = bitmap.GetPixelBytes();
+            double sum = 0;
+            for (int i = 0; i < pixels.Length; i += 4)
+            {
+                // BGRA
+                byte b = pixels[i];
+                byte g = pixels[i + 1];
+                byte r = pixels[i + 2];
+                // 忽略A
+                double y = 0.299 * r + 0.587 * g + 0.114 * b;
+                sum += y / 255.0;
+            }
+            return (float)(sum / (pixels.Length / 4));
+        }
     }
 }