Avalonia migration

Flow.Launcher.Avalonia/App.axaml

@@ -0,0 +1,21 @@
+<Application xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="using:Flow.Launcher.Avalonia"
+             x:Class="Flow.Launcher.Avalonia.App"
+             RequestedThemeVariant="Default">
+    <!-- "Default" ThemeVariant follows system theme variant. 
+         "Dark" or "Light" are other available options. -->
+
+    <Application.Styles>
+        <FluentTheme />
+        <StyleInclude Source="avares://Flow.Launcher.Avalonia/Themes/Base.axaml"/>
+    </Application.Styles>
+
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <!-- Additional resources can be added here -->
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>

Flow.Launcher.Avalonia/App.axaml.cs

@@ -0,0 +1,100 @@
+using Avalonia;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Markup.Xaml;
+using Avalonia.Threading;
+using CommunityToolkit.Mvvm.DependencyInjection;
+using Flow.Launcher.Avalonia.Helper;
+using Flow.Launcher.Avalonia.ViewModel;
+using Flow.Launcher.Core.Plugin;
+using Flow.Launcher.Infrastructure;
+using Flow.Launcher.Infrastructure.Logger;
+using Flow.Launcher.Infrastructure.Storage;
+using Flow.Launcher.Infrastructure.UserSettings;
+using Flow.Launcher.Plugin;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Threading.Tasks;
+
+namespace Flow.Launcher.Avalonia;
+
+public partial class App : Application
+{
+    private static readonly string ClassName = nameof(App);
+    private Settings? _settings;
+    private MainViewModel? _mainVM;
+
+    public static IPublicAPI? API { get; private set; }
+
+    public override void Initialize() => AvaloniaXamlLoader.Load(this);
+
+    public override void OnFrameworkInitializationCompleted()
+    {
+        if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
+        {
+            LoadSettings();
+            ConfigureDI();
+
+            API = Ioc.Default.GetRequiredService<IPublicAPI>();
+            _mainVM = Ioc.Default.GetRequiredService<MainViewModel>();
+
+            desktop.MainWindow = new MainWindow();
+
+            // Initialize hotkeys after window is created
+            HotKeyMapper.Initialize();
+
+            Dispatcher.UIThread.Post(async () => await InitializePluginsAsync(), DispatcherPriority.Background);
+
+            // Cleanup on exit
+            desktop.Exit += (_, _) => HotKeyMapper.Shutdown();
+        }
+        base.OnFrameworkInitializationCompleted();
+    }
+
+    private void LoadSettings()
+    {
+        try
+        {
+            var storage = new FlowLauncherJsonStorage<Settings>();
+            _settings = storage.Load();
+            _settings.SetStorage(storage);
+        }
+        catch (Exception e)
+        {
+            Log.Exception(ClassName, "Settings load failed", e);
+            _settings = new Settings
+            {
+                WindowSize = 580, WindowHeightSize = 42, QueryBoxFontSize = 24,
+                ItemHeightSize = 50, ResultItemFontSize = 14, ResultSubItemFontSize = 12, MaxResultsToShow = 6
+            };
+        }
+    }
+
+    private void ConfigureDI()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton(_settings!);
+        services.AddSingleton<IAlphabet, PinyinAlphabet>();
+        services.AddSingleton<StringMatcher>();
+        services.AddSingleton<MainViewModel>();
+        services.AddSingleton<IPublicAPI>(sp => new AvaloniaPublicAPI(
+            sp.GetRequiredService<Settings>(),
+            () => sp.GetRequiredService<MainViewModel>()));
+        Ioc.Default.ConfigureServices(services.BuildServiceProvider());
+    }
+
+    private async Task InitializePluginsAsync()
+    {
+        try
+        {
+            Log.Info(ClassName, "Loading plugins...");
+            PluginManager.LoadPlugins(_settings!.PluginSettings);
+            Log.Info(ClassName, $"Loaded {PluginManager.AllPlugins.Count} plugins");
+
+            await PluginManager.InitializePluginsAsync();
+            Log.Info(ClassName, "Plugins initialized");
+
+            _mainVM?.OnPluginsReady();
+        }
+        catch (Exception e) { Log.Exception(ClassName, "Plugin init failed", e); }
+    }
+}

Flow.Launcher.Avalonia/AvaloniaPublicAPI.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Media;
+using Flow.Launcher.Infrastructure;
+using Flow.Launcher.Infrastructure.Logger;
+using Flow.Launcher.Infrastructure.UserSettings;
+using Flow.Launcher.Plugin;
+using Flow.Launcher.Plugin.SharedModels;
+using Flow.Launcher.Core.Plugin;
+using Flow.Launcher.Avalonia.ViewModel;
+using CommunityToolkit.Mvvm.DependencyInjection;
+
+namespace Flow.Launcher.Avalonia;
+
+/// <summary>
+/// Minimal IPublicAPI for Avalonia - just enough for plugin queries to work.
+/// </summary>
+public class AvaloniaPublicAPI : IPublicAPI
+{
+    private readonly Settings _settings;
+    private readonly Func<MainViewModel> _getMainViewModel;
+
+    public AvaloniaPublicAPI(Settings settings, Func<MainViewModel> getMainViewModel)
+    {
+        _settings = settings;
+        _getMainViewModel = getMainViewModel;
+    }
+
+#pragma warning disable CS0067
+    public event VisibilityChangedEventHandler? VisibilityChanged;
+    public event ActualApplicationThemeChangedEventHandler? ActualApplicationThemeChanged;
+#pragma warning restore CS0067
+
+    // Essential for plugins
+    public void ChangeQuery(string query, bool requery = false) => _getMainViewModel().QueryText = query;
+    public string GetTranslation(string key) => key;
+    public List<PluginPair> GetAllPlugins() => PluginManager.AllPlugins;
+    public MatchResult FuzzySearch(string query, string stringToCompare) => 
+        Ioc.Default.GetRequiredService<StringMatcher>().FuzzyMatch(query, stringToCompare);
+
+    // Logging
+    public void LogDebug(string className, string message, [CallerMemberName] string methodName = "") => Log.Debug(className, message, methodName);
+    public void LogInfo(string className, string message, [CallerMemberName] string methodName = "") => Log.Info(className, message, methodName);
+    public void LogWarn(string className, string message, [CallerMemberName] string methodName = "") => Log.Warn(className, message, methodName);
+    public void LogError(string className, string message, [CallerMemberName] string methodName = "") => Log.Error(className, message, methodName);
+    public void LogException(string className, string message, Exception e, [CallerMemberName] string methodName = "") => Log.Exception(className, message, e, methodName);
+
+    // Shell/URL operations
+    public void ShellRun(string cmd, string filename = "cmd.exe") => 
+        System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo { FileName = filename, Arguments = $"/c {cmd}", UseShellExecute = true });
+    public void OpenUrl(string url, bool? inPrivate = null) => 
+        System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo { FileName = url, UseShellExecute = true });
+    public void OpenUrl(Uri url, bool? inPrivate = null) => OpenUrl(url.ToString(), inPrivate);
+    public void OpenWebUrl(string url, bool? inPrivate = null) => OpenUrl(url, inPrivate);
+    public void OpenWebUrl(Uri url, bool? inPrivate = null) => OpenUrl(url.ToString(), inPrivate);
+    public void OpenAppUri(Uri appUri) => OpenUrl(appUri);
+    public void OpenAppUri(string appUri) => OpenUrl(appUri);
+    public void OpenDirectory(string DirectoryPath, string? FileNameOrFilePath = null) => 
+        System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo { FileName = DirectoryPath, UseShellExecute = true });
+
+    // Clipboard
+    public void CopyToClipboard(string text, bool directCopy = false, bool showDefaultNotification = true)
+    {
+        if (global::Avalonia.Application.Current?.ApplicationLifetime is global::Avalonia.Controls.ApplicationLifetimes.IClassicDesktopStyleApplicationLifetime desktop)
+            desktop.MainWindow?.Clipboard?.SetTextAsync(text);
+    }
+
+    // HTTP (delegate to Infrastructure)
+    public Task<string> HttpGetStringAsync(string url, CancellationToken token = default) => Infrastructure.Http.Http.GetAsync(url, token);
+    public Task<Stream> HttpGetStreamAsync(string url, CancellationToken token = default) => Infrastructure.Http.Http.GetStreamAsync(url, token);
+    public Task HttpDownloadAsync(string url, string filePath, Action<double>? reportProgress = null, CancellationToken token = default) => 
+        Infrastructure.Http.Http.DownloadAsync(url, filePath, reportProgress, token);
+
+    // Plugin management
+    public void AddActionKeyword(string pluginId, string newActionKeyword) => PluginManager.AddActionKeyword(pluginId, newActionKeyword);
+    public void RemoveActionKeyword(string pluginId, string oldActionKeyword) => PluginManager.RemoveActionKeyword(pluginId, oldActionKeyword);
+    public bool ActionKeywordAssigned(string actionKeyword) => PluginManager.ActionKeywordRegistered(actionKeyword);
+    public bool PluginModified(string id) => PluginManager.PluginModified(id);
+
+    // Paths
+    public string GetDataDirectory() => DataLocation.DataDirectory();
+    public string GetLogDirectory() => Log.CurrentLogDirectory;
+
+    // Stubs - not critical for basic queries
+    public void RestartApp() { }
+    public void SaveAppAllSettings() { }
+    public void SavePluginSettings() { }
+    public Task ReloadAllPluginData() => Task.CompletedTask;
+    public void CheckForNewUpdate() { }
+    public void ShowMsgError(string title, string subTitle = "") => LogError("API", $"{title}: {subTitle}");
+    public void ShowMsgErrorWithButton(string title, string buttonText, Action buttonAction, string subTitle = "") { }
+    public void ShowMainWindow() { }
+    public void FocusQueryTextBox() { }
+    public void HideMainWindow() => _getMainViewModel()?.RequestHide();
+    public bool IsMainWindowVisible() => true;
+    public void ShowMsg(string title, string subTitle = "", string iconPath = "") { }
+    public void ShowMsg(string title, string subTitle, string iconPath, bool useMainWindowAsOwner = true) { }
+    public void ShowMsgWithButton(string title, string buttonText, Action buttonAction, string subTitle = "", string iconPath = "") { }
+    public void ShowMsgWithButton(string title, string buttonText, Action buttonAction, string subTitle, string iconPath, bool useMainWindowAsOwner = true) { }
+    public void OpenSettingDialog() { }
+    public void RegisterGlobalKeyboardCallback(Func<int, int, SpecialKeyState, bool> callback) { }
+    public void RemoveGlobalKeyboardCallback(Func<int, int, SpecialKeyState, bool> callback) { }
+    public T LoadSettingJsonStorage<T>() where T : new() => new T();
+    public void SaveSettingJsonStorage<T>() where T : new() { }
+    public void ToggleGameMode() { }
+    public void SetGameMode(bool value) { }
+    public bool IsGameModeOn() => false;
+    public void ReQuery(bool reselect = true) { var q = _getMainViewModel().QueryText; _getMainViewModel().QueryText = ""; _getMainViewModel().QueryText = q; }
+    public void BackToQueryResults() { }
+    public MessageBoxResult ShowMsgBox(string messageBoxText, string caption = "", MessageBoxButton button = MessageBoxButton.OK, MessageBoxImage icon = MessageBoxImage.None, MessageBoxResult defaultResult = MessageBoxResult.OK) => defaultResult;
+    public Task ShowProgressBoxAsync(string caption, Func<Action<double>, Task> reportProgressAsync, Action? cancelProgress = null) => reportProgressAsync(_ => { });
+    public void StartLoadingBar() => _getMainViewModel().IsQueryRunning = true;
+    public void StopLoadingBar() => _getMainViewModel().IsQueryRunning = false;
+    public List<ThemeData> GetAvailableThemes() => new();
+    public ThemeData? GetCurrentTheme() => null;
+    public bool SetCurrentTheme(ThemeData theme) => false;
+    public void SavePluginCaches() { }
+    public Task<T> LoadCacheBinaryStorageAsync<T>(string cacheName, string cacheDirectory, T defaultData) where T : new() => Task.FromResult(defaultData);
+    public Task SaveCacheBinaryStorageAsync<T>(string cacheName, string cacheDirectory) where T : new() => Task.CompletedTask;
+    public ValueTask<ImageSource> LoadImageAsync(string path, bool loadFullImage = false, bool cacheImage = true) => new((ImageSource)null!);
+    public Task<bool> UpdatePluginManifestAsync(bool usePrimaryUrlOnly = false, CancellationToken token = default) => Task.FromResult(true);
+    public IReadOnlyList<UserPlugin> GetPluginManifest() => new List<UserPlugin>();
+    public Task<bool> UpdatePluginAsync(PluginMetadata pluginMetadata, UserPlugin plugin, string zipFilePath) => Task.FromResult(false);
+    public bool InstallPlugin(UserPlugin plugin, string zipFilePath) => false;
+    public Task<bool> UninstallPluginAsync(PluginMetadata pluginMetadata, bool removePluginSettings = false) => Task.FromResult(false);
+    public bool IsApplicationDarkTheme() => true;
+
+    public long StopwatchLogDebug(string className, string message, Action action, [CallerMemberName] string methodName = "")
+    { var sw = System.Diagnostics.Stopwatch.StartNew(); action(); sw.Stop(); LogDebug(className, $"{message}: {sw.ElapsedMilliseconds}ms", methodName); return sw.ElapsedMilliseconds; }
+    public async Task<long> StopwatchLogDebugAsync(string className, string message, Func<Task> action, [CallerMemberName] string methodName = "")
+    { var sw = System.Diagnostics.Stopwatch.StartNew(); await action(); sw.Stop(); LogDebug(className, $"{message}: {sw.ElapsedMilliseconds}ms", methodName); return sw.ElapsedMilliseconds; }
+    public long StopwatchLogInfo(string className, string message, Action action, [CallerMemberName] string methodName = "")
+    { var sw = System.Diagnostics.Stopwatch.StartNew(); action(); sw.Stop(); LogInfo(className, $"{message}: {sw.ElapsedMilliseconds}ms", methodName); return sw.ElapsedMilliseconds; }
+    public async Task<long> StopwatchLogInfoAsync(string className, string message, Func<Task> action, [CallerMemberName] string methodName = "")
+    { var sw = System.Diagnostics.Stopwatch.StartNew(); await action(); sw.Stop(); LogInfo(className, $"{message}: {sw.ElapsedMilliseconds}ms", methodName); return sw.ElapsedMilliseconds; }
+}

Flow.Launcher.Avalonia/Converters/BoolToIsVisibleConverter.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Globalization;
+using Avalonia.Data.Converters;
+
+namespace Flow.Launcher.Avalonia.Converters;
+
+/// <summary>
+/// Converts a boolean value to IsVisible (Avalonia uses bool for visibility, not Visibility enum)
+/// </summary>
+public class BoolToIsVisibleConverter : IValueConverter
+{
+    /// <summary>
+    /// If true, inverts the boolean value (true becomes false, false becomes true)
+    /// </summary>
+    public bool Invert { get; set; }
+
+    public object? Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        if (value is bool boolValue)
+        {
+            return Invert ? !boolValue : boolValue;
+        }
+        return false;
+    }
+
+    public object? ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        if (value is bool boolValue)
+        {
+            return Invert ? !boolValue : boolValue;
+        }
+        return false;
+    }
+}