Stuff for tunesync

Toolkit.Foundation/HandlerInitialization.cs

@@ -11,7 +11,15 @@ public class HandlerInitialization<TMessage, TResponse, THandler>(IServiceProvid
             (provider, args) => args.Reply(provider.GetRequiredService<THandler>().Handle(args.Message)));
 }
 
-public class HandlerInitialization<TMessage, THandler>(string key, IServiceProvider provider) :
+public class HandlerInitialization<TMessage, THandler>(IServiceProvider provider) :
+    IInitialization where THandler : class, IHandler<TMessage>
+        where TMessage : class
+{
+    public void Initialize() => WeakReferenceMessenger.Default.Register<IServiceProvider, TMessage>(provider,
+        (provider, args) => provider.GetRequiredService<THandler>().Handle(args));
+}
+
+public class HandlerKeyedInitialization<TMessage, THandler>(string key, IServiceProvider provider) :
     IInitialization where THandler : class, IHandler<TMessage>
         where TMessage : class
 {

Toolkit.Foundation/IServiceCollectionExtensions.cs

@@ -4,6 +4,28 @@ namespace Toolkit.Foundation;
 
 public static class IServiceCollectionExtensions
 {
+    public static IServiceCollection AddAsyncHandler<TMessage, TResponse, THandler>(this IServiceCollection services,
+        ServiceLifetime lifetime = ServiceLifetime.Transient)
+        where THandler : class, IAsyncHandler<TMessage, TResponse>
+        where TMessage : class
+    {
+        services.Add(new ServiceDescriptor(typeof(THandler), typeof(THandler), lifetime));
+        services.AddInitialization<AsyncHandlerInitialization<TMessage, TResponse, THandler>>();
+
+        return services;
+    }
+
+    public static IServiceCollection AddAsyncHandler<TMessage, THandler>(this IServiceCollection services,
+        ServiceLifetime lifetime = ServiceLifetime.Transient)
+        where THandler : class, IAsyncHandler<TMessage>
+        where TMessage : class
+    {
+        services.Add(new ServiceDescriptor(typeof(THandler), typeof(THandler), lifetime));
+        services.AddInitialization<AsyncHandlerInitialization<TMessage, THandler>>();
+
+        return services;
+    }
+
     public static IServiceCollection AddAsyncInitialization<TInitialization>(this IServiceCollection services)
         where TInitialization : class,
         IAsyncInitialization
@@ -49,28 +71,6 @@ public static class IServiceCollectionExtensions
         return services;
     }
 
-    public static IServiceCollection AddAsyncHandler<TMessage, TResponse, THandler>(this IServiceCollection services,
-        ServiceLifetime lifetime = ServiceLifetime.Transient)
-        where THandler : class, IAsyncHandler<TMessage, TResponse>
-        where TMessage : class
-    {
-        services.Add(new ServiceDescriptor(typeof(THandler), typeof(THandler), lifetime));
-        services.AddInitialization<AsyncHandlerInitialization<TMessage, TResponse, THandler>>();
-
-        return services;
-    }
-
-    public static IServiceCollection AddAsyncHandler<TMessage, THandler>(this IServiceCollection services,
-        ServiceLifetime lifetime = ServiceLifetime.Transient)
-        where THandler : class, IAsyncHandler<TMessage>
-        where TMessage : class
-    {
-        services.Add(new ServiceDescriptor(typeof(THandler), typeof(THandler), lifetime));
-        services.AddInitialization<AsyncHandlerInitialization<TMessage, THandler>>();
-
-        return services;
-    }
-
     public static IServiceCollection AddHandler<TMessage, THandler>(this IServiceCollection services,
         string key)
         where THandler : class, IHandler<TMessage>
@@ -85,7 +85,7 @@ public static class IServiceCollectionExtensions
         if (key is { Length: > 0})
         {
             services.Add(new ServiceDescriptor(typeof(THandler), key, typeof(THandler), lifetime));
-            services.AddInitialization<HandlerInitialization<TMessage, THandler>>(key);
+            services.AddInitialization<HandlerKeyedInitialization<TMessage, THandler>>(key);
         }
         else
         {
@@ -96,6 +96,18 @@ public static class IServiceCollectionExtensions
         return services;
     }
 
+    public static IServiceCollection AddInitialization<TInitialization, TInitializationImplementation>(this IServiceCollection services,
+        ServiceLifetime lifetime = ServiceLifetime.Transient)
+        where TInitialization : class,
+        IInitialization
+        where TInitializationImplementation : class,
+        TInitialization
+    {
+        services.Add(new ServiceDescriptor(typeof(TInitialization), typeof(TInitializationImplementation), lifetime));
+        services.AddTransient<IInitialization>(provider => provider.GetRequiredService<TInitialization>());
+        return services;
+    }
+
     public static IServiceCollection AddInitialization<TInitialization>(this IServiceCollection services)
         where TInitialization : class,
         IInitialization

Toolkit.Foundation/ResponseEventArgs.cs

@@ -5,5 +5,5 @@ namespace Toolkit.Foundation;
 public class ResponseEventArgs<TMessage, TResponse> :
     RequestMessage<TResponse>
 {
-    public TMessage? Message { get; set; }
+    public required TMessage Message { get; set; }
 }

Toolkit.UI.WinUI/Toolkit.UI.WinUI.csproj

@@ -11,6 +11,8 @@
 		</RuntimeIdentifiers>
 		<UseWinUI>true</UseWinUI>
 		<WindowsSdkPackageVersion>10.0.19041.41</WindowsSdkPackageVersion>
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<Nullable>enable</Nullable>
 	</PropertyGroup>
 
 	<ItemGroup>
@@ -18,4 +20,8 @@
 		<PackageReference Include="Microsoft.WindowsAppSDK" Version="1.6.240923002" />
 		<PackageReference Include="WinUIEx" Version="2.4.2" />
 	</ItemGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\Toolkit.Windows\Toolkit.Windows.csproj" />
+	</ItemGroup>
 </Project>

Toolkit.UI.WinUI/WindowExtensions.cs

@@ -1,25 +1,96 @@
+using Microsoft.UI.Windowing;
 using Microsoft.UI.Xaml;
-using WinUIEx;
+using Windows.Win32;
+using Windows.Win32.Foundation;
+using WinRT.Interop;
+using Windows.Win32.Graphics.Gdi;
+using System.Drawing;
+using Windows.Win32.UI.Shell;
+using Windows.Win32.UI.WindowsAndMessaging;
 
 namespace Toolkit.UI.WinUI;
 
 public static partial class WindowExtensions
 {
-    public static void SetWindowStyle(this Window window,
-        WindowStyle style)
-    {
-        WinUIEx.WindowStyle windowStyle = window.GetWindowStyle();
+    private static SUBCLASSPROC? SubClassDelegate;
 
-        switch (style)
+    public static void SetBorderless(this Window window,
+        bool value)
     {
-            case WindowStyle.None:
-                windowStyle &= ~(WinUIEx.WindowStyle.Caption |
-                WinUIEx.WindowStyle.ThickFrame |
-                WinUIEx.WindowStyle.Border |
-                WinUIEx.WindowStyle.SysMenu);
-                break;
+        if (window.AppWindow is AppWindow appWindow && 
+            appWindow.Presenter is OverlappedPresenter presenter)
+        {
+            presenter.IsMaximizable = !value;
+            presenter.IsMinimizable = !value;
+            presenter.IsResizable = !value;
+            presenter.SetBorderAndTitleBar(!value, !value);
+        }
     }
 
-        window.SetWindowStyle(windowStyle);
+    public static void SetTransparency(this Window window, 
+        bool value)
+    {
+        nint handle = WindowNative.GetWindowHandle(window);
+        if (handle == 0) return;
+
+        HWND hWnd = new(handle);
+        if (value)
+        {
+            EnableTransparency(hWnd);
+        }
+        else
+        {
+            DisableTransparency(hWnd);
+        }
+    }
+
+    private static unsafe void EnableTransparency(HWND hWnd)
+    {
+        SubClassDelegate = new SUBCLASSPROC(WindowSubClass);
+        _ = PInvoke.SetWindowSubclass(hWnd, SubClassDelegate, 0, 0);
+
+        WINDOW_EX_STYLE exStyle = (WINDOW_EX_STYLE)PInvoke.GetWindowLong(hWnd, WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE);
+        _ = PInvoke.SetWindowLong(hWnd, WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE,
+            (int)(exStyle | WINDOW_EX_STYLE.WS_EX_LAYERED));
+
+        COLORREF blackColor = new COLORREF((uint)ToWin32(Color.Black));
+        _ = PInvoke.SetLayeredWindowAttributes(hWnd, blackColor, 0, LAYERED_WINDOW_ATTRIBUTES_FLAGS.LWA_COLORKEY | 
+            LAYERED_WINDOW_ATTRIBUTES_FLAGS.LWA_ALPHA);
+    }
+
+    private static unsafe void DisableTransparency(HWND hWnd)
+    {
+        if (SubClassDelegate != null)
+        {
+            _ = PInvoke.RemoveWindowSubclass(hWnd, SubClassDelegate, 0);
+            SubClassDelegate = null;
+        }
+
+        WINDOW_EX_STYLE exStyle = (WINDOW_EX_STYLE)PInvoke.GetWindowLong(hWnd, WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE);
+        _ = PInvoke.SetWindowLong(hWnd, WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE, (int)(exStyle & ~WINDOW_EX_STYLE.WS_EX_LAYERED));
+    }
+
+    private static int ToWin32(Color c) => c.B << 16 | c.G << 8 | c.R;
+
+    private static unsafe LRESULT WindowSubClass(HWND hWnd,
+        uint uMsg, WPARAM wParam, LPARAM lParam, nuint uIdSubclass, nuint dwRefData)
+    {
+        switch (uMsg)
+        {
+            case PInvoke.WM_ERASEBKGND:
+                {
+                    RECT rect;
+                    PInvoke.GetClientRect(hWnd, &rect);
+
+                    HBRUSH hBrush = PInvoke.CreateSolidBrush(new COLORREF((uint)ToWin32(Color.Black)));
+                    _ = PInvoke.FillRect(new HDC((nint)wParam.Value),
+                        &rect, hBrush);
+                    _ = PInvoke.DeleteObject(new HGDIOBJ(hBrush));
+
+                    return new LRESULT(1);
+                }
+        }
+
+        return PInvoke.DefSubclassProc(hWnd, uMsg, wParam, lParam);
     }
 }

Toolkit.UI.WinUI/WindowStyle.cs

@@ -1,9 +0,0 @@
-namespace Toolkit.UI.WinUI;
-
-public enum WindowStyle
-{
-    None,
-    SingleBorderWindow,
-    ThreeDBorderWindow,
-    ToolWindow
-}

Toolkit.WinUI/IServiceCollectionExtensions.cs

@@ -9,6 +9,7 @@ public static class IServiceCollectionExtensions
     {
         services.AddTransient<IDispatcher, WinUIDispatcher>();
         services.AddTransient<IDispatcherTimerFactory, DispatcherTimerFactory>();
+        services.AddSingleton<IWindowRegistry, WindowRegistry>();
 
         services.AddTransient((Func<IServiceProvider, IProxyServiceCollection<IComponentBuilder>>)(provider =>
             new ProxyServiceCollection<IComponentBuilder>(services =>

Toolkit.WinUI/IWindowRegistry.cs

@@ -0,0 +1,12 @@
+using Microsoft.UI.Xaml;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Toolkit.WinUI;
+
+public interface IWindowRegistry
+{
+    void Add(Window window);
+
+    bool TryGet<TWindow>([DisallowNull] out TWindow? window)
+        where TWindow : Window;
+}

Toolkit.WinUI/ImageSourceExtensions.cs

@@ -0,0 +1,25 @@
+using Microsoft.UI.Xaml.Media;
+using Microsoft.UI.Xaml.Media.Imaging;
+using System.Drawing;
+using Windows.Storage;
+using Windows.Win32;
+using Windows.Win32.UI.WindowsAndMessaging;
+
+namespace Toolkit.WinUI;
+
+public static class ImageSourceExtensions
+{
+    public static Icon? ConvertToIcon(this Stream stream, uint dpi)
+    {
+        return ExtractIcon(dpi, stream);
+    }
+
+    private static Icon? ExtractIcon(uint dpi, Stream stream)
+    {
+        Bitmap bitmap = (Bitmap)Image.FromStream(stream);
+        Icon icon = Icon.FromHandle(bitmap.GetHicon());
+
+        return new Icon(icon, new Size(PInvoke.GetSystemMetricsForDpi(SYSTEM_METRICS_INDEX.SM_CXICON, dpi),
+            PInvoke.GetSystemMetricsForDpi(SYSTEM_METRICS_INDEX.SM_CYICON, dpi)));
+    }
+}

Toolkit.WinUI/Toolkit.WinUI.csproj

@@ -23,6 +23,7 @@
 
 	<ItemGroup>
 		<ProjectReference Include="..\Toolkit.Foundation\Toolkit.Foundation.csproj" />
+		<ProjectReference Include="..\Toolkit.Windows\Toolkit.Windows.csproj" />
 	</ItemGroup>
 
 </Project>

Toolkit.WinUI/WindowRegistry.cs

@@ -0,0 +1,32 @@
+using Microsoft.UI.Xaml;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Toolkit.WinUI;
+
+public class WindowRegistry : 
+    IWindowRegistry
+{
+    private readonly List<Window> windows = [];
+
+    public void Add(Window window)
+    {
+        if (!windows.Contains(window))
+        {
+            void OnWindowClosed(object sender, WindowEventArgs args)
+            {
+                window.Closed -= OnWindowClosed;
+                windows.Remove(window);
+            }
+
+            windows.Add(window);
+            window.Closed += OnWindowClosed;
+        }
+    }
+
+    public bool TryGet<TWindow>([DisallowNull] out TWindow? window)
+        where TWindow : Window
+    {
+        window = windows.OfType<TWindow>().FirstOrDefault() ?? null;
+        return window is not null;
+    }
+}

Toolkit.Windows/EfficiencyMode.cs

@@ -0,0 +1,73 @@
+using Windows.Win32;
+using Windows.Win32.System.Threading;
+
+namespace Toolkit.Windows;
+
+public class EfficiencyMode : 
+    IEfficiencyMode
+{
+    public unsafe void SetProcessQualityOfServiceLevel(QualityOfService level)
+    {
+        PROCESS_POWER_THROTTLING_STATE powerThrottling = new PROCESS_POWER_THROTTLING_STATE
+        {
+            Version = PInvoke.PROCESS_POWER_THROTTLING_CURRENT_VERSION
+        };
+
+        switch (level)
+        {
+            case QualityOfService.Default:
+                powerThrottling.ControlMask = 0;
+                powerThrottling.StateMask = 0;
+                break;
+
+            case QualityOfService.Eco when Environment.OSVersion.Version >= new Version(11, 0):
+            case QualityOfService.Low:
+                powerThrottling.ControlMask = PInvoke.PROCESS_POWER_THROTTLING_EXECUTION_SPEED;
+                powerThrottling.StateMask = PInvoke.PROCESS_POWER_THROTTLING_EXECUTION_SPEED;
+                break;
+
+            case QualityOfService.High:
+                powerThrottling.ControlMask = PInvoke.PROCESS_POWER_THROTTLING_EXECUTION_SPEED;
+                powerThrottling.StateMask = 0;
+                break;
+
+            default:
+                throw new NotImplementedException();
+        }
+
+        _ = PInvoke.SetProcessInformation(
+            hProcess: PInvoke.GetCurrentProcess(),
+            ProcessInformationClass: PROCESS_INFORMATION_CLASS.ProcessPowerThrottling,
+            ProcessInformation: &powerThrottling,
+            ProcessInformationSize: (uint)sizeof(PROCESS_POWER_THROTTLING_STATE));
+    }
+
+    public unsafe void SetProcessPriorityClass(ProcessPriority priorityClass)
+    {
+        PROCESS_CREATION_FLAGS flags = priorityClass switch
+        {
+            ProcessPriority.Default => PROCESS_CREATION_FLAGS.NORMAL_PRIORITY_CLASS,
+            ProcessPriority.Idle => PROCESS_CREATION_FLAGS.IDLE_PRIORITY_CLASS,
+            ProcessPriority.BelowNormal => PROCESS_CREATION_FLAGS.BELOW_NORMAL_PRIORITY_CLASS,
+            ProcessPriority.Normal => PROCESS_CREATION_FLAGS.NORMAL_PRIORITY_CLASS,
+            ProcessPriority.AboveNormal => PROCESS_CREATION_FLAGS.ABOVE_NORMAL_PRIORITY_CLASS,
+            ProcessPriority.High => PROCESS_CREATION_FLAGS.HIGH_PRIORITY_CLASS,
+            ProcessPriority.Realtime => PROCESS_CREATION_FLAGS.REALTIME_PRIORITY_CLASS,
+            _ => throw new NotImplementedException(),
+        };
+
+        _ = PInvoke.SetPriorityClass(
+            hProcess: PInvoke.GetCurrentProcess(),
+            dwPriorityClass: flags);
+    }
+
+    public void SetEfficiencyMode(bool value)
+    {
+        QualityOfService ecoLevel = Environment.OSVersion.Version >= new Version(11, 0)
+            ? QualityOfService.Eco
+            : QualityOfService.Low;
+
+        SetProcessQualityOfServiceLevel(value ? ecoLevel : QualityOfService.Default);
+        SetProcessPriorityClass(value ? ProcessPriority.Idle : ProcessPriority.Default);
+    }
+}

Toolkit.Windows/IEfficiencyMode.cs

@@ -0,0 +1,9 @@
+namespace Toolkit.Windows
+{
+    public interface IEfficiencyMode
+    {
+        void SetEfficiencyMode(bool value);
+        void SetProcessPriorityClass(ProcessPriority priorityClass);
+        void SetProcessQualityOfServiceLevel(QualityOfService level);
+    }
+}

Toolkit.Windows/INotifyIcon.cs

@@ -0,0 +1,10 @@
+using Toolkit.Foundation;
+
+namespace Toolkit.Windows;
+
+public interface INotifyIcon :
+    IInitialization,
+    IDisposable
+{
+    void SetIcon(IntPtr iconHandle);
+}

Toolkit.Windows/IWndProc.cs

@@ -2,6 +2,10 @@
 
 namespace Toolkit.Windows;
 
-public interface IWndProcMonitor :
+public interface IWndProc :
     IInitialization, 
-    IDisposable;
+    IDisposable
+{
+
+    IntPtr Handle { get; }
+}

Toolkit.Windows/NativeMethods.txt

@@ -15,3 +15,27 @@ RegisterWindowMessage
 GetDpiForWindow
 SetWindowPos
 SHCreateShellItemArrayFromDataObject
+Shell_NotifyIcon
+GetSystemMetricsForDpi
+GetSystemMetrics
+GetCurrentProcess
+SetProcessInformation
+PROCESS_POWER_THROTTLING_STATE
+PROCESS_POWER_THROTTLING_CURRENT_VERSION
+PROCESS_POWER_THROTTLING_EXECUTION_SPEED
+SetPriorityClass
+WINDOW_STYLE
+DefSubclassProc
+SetLayeredWindowAttributes
+WM_ERASEBKGND
+SetWindowSubclass
+GetClientRect
+CreateSolidBrush
+DwmSetWindowAttribute
+DWM_WINDOW_CORNER_PREFERENCE
+FillRect
+SetLayeredWindowAttributes
+DeleteObject
+RemoveWindowSubclass
+GetWindowLong
+SetWindowLong

Toolkit.Windows/NotifyIcon.cs

@@ -0,0 +1,183 @@
+using CommunityToolkit.Mvvm.Messaging;
+using System.Runtime.InteropServices;
+using Toolkit.Foundation;
+
+namespace Toolkit.Windows;
+
+
+public partial class NotifyIcon(IWndProc wndProc,
+    IMessenger messenger) :
+    INotifyIcon,
+    IRecipient<WndProcEventArgs>
+{
+    private const int CallbackMessage = 0x400;
+    private const uint IconVersion = 0x4;
+
+    private readonly Lock notifyLock = new();
+    private bool isDisposed;
+    private NotifyIconData notifyIconData;
+
+    ~NotifyIcon()
+    {
+        Dispose(false);
+    }
+
+    private enum NotifyIconBalloonType
+    {
+        None = 0x00,
+        Info = 0x01,
+        Warning = 0x02,
+        Error = 0x03,
+        User = 0x04,
+        NoSound = 0x10,
+        LargeIcon = 0x20,
+        RespectQuietTime = 0x80
+    }
+
+    private enum NotifyIconCommand : uint
+    {
+        Add = 0x0,
+        Delete = 0x2,
+        Modify = 0x1,
+        SetVersion = 0x4
+    }
+
+    [Flags]
+    private enum NotifyIconDataMember : uint
+    {
+        Message = 0x01,
+        Icon = 0x02,
+        Tip = 0x04,
+        State = 0x08,
+        Info = 0x10,
+        Realtime = 0x40,
+        UseLegacyToolTips = 0x80
+    }
+
+    private enum NotifyIconState : uint
+    {
+        Visible = 0x00,
+        Hidden = 0x01
+    }
+
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    public void Initialize()
+    {
+        messenger.RegisterAll(this);
+        CreateNotificationIcon();
+    }
+
+    public void Receive(WndProcEventArgs message)
+    {
+        if (message.Message == CallbackMessage)
+        {
+            switch (message.LParam)
+            {
+                case (uint)WndProcMessages.WM_LBUTTONUP:
+                    messenger.Send(new NotifyIconInvokedEventArgs(PointerButton.Left));
+                    break;
+
+                case (uint)WndProcMessages.WM_MBUTTONUP:
+                    messenger.Send(new NotifyIconInvokedEventArgs(PointerButton.Middle));
+                    break;
+
+                case (uint)WndProcMessages.WM_RBUTTONUP:
+                    messenger.Send(new NotifyIconInvokedEventArgs(PointerButton.Right));
+                    break;
+            }
+        }
+    }
+
+    public void SetIcon(IntPtr iconHandle)
+    {
+        lock (notifyLock)
+        {
+            notifyIconData.IconHandle = iconHandle;
+            WriteNotifyIconData(NotifyIconCommand.Modify, NotifyIconDataMember.Icon);
+        }
+    }
+
+    [DllImport("user32.dll", SetLastError = true)]
+    private static extern IntPtr DefWindowProcW(IntPtr handle, uint msg, IntPtr wParam, IntPtr lParam);
+
+    [DllImport("shell32.dll", SetLastError = true)]
+    private static extern int Shell_NotifyIcon(NotifyIconCommand notifyCommand, ref NotifyIconData notifyIconData);
+
+    private void CreateNotificationIcon()
+    {
+        lock (notifyLock)
+        {
+            notifyIconData = new NotifyIconData();
+
+            notifyIconData.cbSize = (uint)Marshal.SizeOf(notifyIconData);
+            notifyIconData.WindowHandle = wndProc.Handle;
+            notifyIconData.TaskbarIconId = 0x0;
+            notifyIconData.CallbackMessageId = CallbackMessage;
+            notifyIconData.VersionOrTimeout = IconVersion;
+
+            notifyIconData.IconHandle = IntPtr.Zero;
+
+            notifyIconData.IconState = NotifyIconState.Hidden;
+            notifyIconData.StateMask = NotifyIconState.Hidden;
+
+            WriteNotifyIconData(NotifyIconCommand.Add, NotifyIconDataMember.Message | NotifyIconDataMember.Icon | NotifyIconDataMember.Tip);
+        }
+    }
+
+    private void Dispose(bool disposing)
+    {
+        if (isDisposed || !disposing) return;
+        lock (notifyLock)
+        {
+            isDisposed = true;
+
+            messenger.UnregisterAll(this);
+            RemoveNotificationIcon();
+        }
+    }
+
+    private void RemoveNotificationIcon() => WriteNotifyIconData(NotifyIconCommand.Delete, NotifyIconDataMember.Message);
+
+    private void WriteNotifyIconData(NotifyIconCommand command, NotifyIconDataMember flags)
+    {
+        notifyIconData.ValidMembers = flags;
+        lock (notifyLock)
+        {
+            Shell_NotifyIcon(command, ref notifyIconData);
+        }
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct NotifyIconData
+    {
+        public uint cbSize;
+        public IntPtr WindowHandle;
+        public uint TaskbarIconId;
+        public NotifyIconDataMember ValidMembers;
+        public uint CallbackMessageId;
+        public IntPtr IconHandle;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
+        public string ToolTipText;
+
+        public NotifyIconState IconState;
+        public NotifyIconState StateMask;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+        public string BalloonText;
+
+        public uint VersionOrTimeout;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
+        public string BalloonTitle;
+
+        public NotifyIconBalloonType BalloonFlags;
+        public Guid TaskbarIconGuid;
+        public IntPtr CustomBalloonIconHandle;
+    }
+}

Toolkit.Windows/NotifyIconInvokedEventArgs.cs

@@ -0,0 +1,3 @@
+namespace Toolkit.Windows;
+
+public record NotifyIconInvokedEventArgs(PointerButton PointerButton);

Toolkit.Windows/ProcessPriority.cs

@@ -0,0 +1,12 @@
+namespace Toolkit.Windows;
+
+public enum ProcessPriority
+{
+    Default,
+    Idle,
+    BelowNormal,
+    Normal,
+    AboveNormal,
+    High,
+    Realtime
+}

Toolkit.Windows/QualityOfService.cs

@@ -0,0 +1,23 @@
+using System.Runtime.Versioning;
+
+namespace Toolkit.Windows;
+
+[SupportedOSPlatform("windows8.0")]
+public enum QualityOfService
+{
+    Default,
+    [SupportedOSPlatform("windows10.0.16299.0")]
+    High,
+    [SupportedOSPlatform("windows10.0.16299.0")]
+    Medium,
+    [SupportedOSPlatform("windows10.0.16299.0")]
+    Low,
+    [SupportedOSPlatform("windows11.0.22621.0")]
+    Utility,
+    [SupportedOSPlatform("windows11.0")]
+    Eco,
+    [SupportedOSPlatform("windows10.0.19041.0")]
+    Media,
+    [SupportedOSPlatform("windows10.0.19041.0")]
+    Deadline
+}

Toolkit.Windows/WindowHelper.cs

@@ -7,6 +7,10 @@ namespace Toolkit.Windows;
 
 public class WindowHelper
 {
+    public static IntPtr GetHandle(string windowName) => PInvoke.FindWindow(windowName, null);
+
+    public static uint GetDpi(IntPtr handle) => PInvoke.GetDpiForWindow((HWND)handle);
+
     public static void BringToForeground(HWND handle)
     {
         if (TryGetBoundsUnsafe(handle, out RECT bounds))

Toolkit.Windows/WndProc.cs

@@ -6,8 +6,8 @@ using Windows.Win32.UI.WindowsAndMessaging;
 
 namespace Toolkit.Windows;
 
-public class WndProcMonitor(IMessenger messenger) : 
-    IWndProcMonitor
+public class WndProc(IMessenger messenger) : 
+    IWndProc
 {
     private WNDPROC? handler;
 

Toolkit.sln

@@ -83,8 +83,8 @@ Global
 		{08F06CCE-86F9-4885-84F0-B23B2E5A0813}.Debug|x64.Build.0 = Debug|x64
 		{08F06CCE-86F9-4885-84F0-B23B2E5A0813}.Debug|x86.ActiveCfg = Debug|x86
 		{08F06CCE-86F9-4885-84F0-B23B2E5A0813}.Debug|x86.Build.0 = Debug|x86
-		{08F06CCE-86F9-4885-84F0-B23B2E5A0813}.Release|Any CPU.ActiveCfg = Release|x64
-		{08F06CCE-86F9-4885-84F0-B23B2E5A0813}.Release|Any CPU.Build.0 = Release|x64
+		{08F06CCE-86F9-4885-84F0-B23B2E5A0813}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{08F06CCE-86F9-4885-84F0-B23B2E5A0813}.Release|Any CPU.Build.0 = Release|Any CPU
 		{08F06CCE-86F9-4885-84F0-B23B2E5A0813}.Release|x64.ActiveCfg = Release|x64
 		{08F06CCE-86F9-4885-84F0-B23B2E5A0813}.Release|x64.Build.0 = Release|x64
 		{08F06CCE-86F9-4885-84F0-B23B2E5A0813}.Release|x86.ActiveCfg = Release|x86