add ScreenGrab

imradv3.sln

@@ -17,6 +17,10 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WeChatOcrCpp", "src\WeChatO
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WpfEditor", "src\WpfEditor\WpfEditor.csproj", "{A995A5F1-6A44-463F-9284-A3F058575206}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ScreenGrab", "src\ScreenGrab\ScreenGrab.csproj", "{998A5C87-48A5-B8CF-4435-452B526C6235}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ScreenGrab.Sample", "src\ScreenGrab.Sample\ScreenGrab.Sample.csproj", "{34691787-AE69-7042-FB4F-9EE5535A4D5A}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -111,6 +115,30 @@ Global
 		{A995A5F1-6A44-463F-9284-A3F058575206}.Release|x64.Build.0 = Debug|x64
 		{A995A5F1-6A44-463F-9284-A3F058575206}.Release|x86.ActiveCfg = Release|Any CPU
 		{A995A5F1-6A44-463F-9284-A3F058575206}.Release|x86.Build.0 = Release|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Debug|x64.Build.0 = Debug|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Debug|x86.Build.0 = Debug|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Release|Any CPU.Build.0 = Release|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Release|x64.ActiveCfg = Release|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Release|x64.Build.0 = Release|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Release|x86.ActiveCfg = Release|Any CPU
+		{998A5C87-48A5-B8CF-4435-452B526C6235}.Release|x86.Build.0 = Release|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Debug|x64.Build.0 = Debug|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Debug|x86.Build.0 = Debug|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Release|x64.ActiveCfg = Release|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Release|x64.Build.0 = Release|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Release|x86.ActiveCfg = Release|Any CPU
+		{34691787-AE69-7042-FB4F-9EE5535A4D5A}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

reame.txt

@@ -1,3 +1,7 @@
+
+see github\echodict\cut\wpf\ScreenGrab\ScreenGrabber.cs
+
+
 0001.bmp 这张图 "第一部分 基础知识" 因为是反色的，所以 wechat OCR 没有识别出来，可以做为区分 ali ocr 和 wechat ocr api 的特征
 
 

src/ScreenGrab.Sample/App.xaml

@@ -0,0 +1,15 @@
+<Application x:Class="ScreenGrab.Sample.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
+             xmlns:local="clr-namespace:ScreenGrab.Sample"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <ui:ThemesDictionary Theme="Dark" />
+                <ui:ControlsDictionary />
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>

src/ScreenGrab.Sample/App.xaml.cs

@@ -0,0 +1,14 @@
+using System.Configuration;
+using System.Data;
+using System.Windows;
+
+namespace ScreenGrab.Sample
+{
+    /// <summary>
+    /// Interaction logic for App.xaml
+    /// </summary>
+    public partial class App : Application
+    {
+    }
+
+}

src/ScreenGrab.Sample/AssemblyInfo.cs

@@ -0,0 +1,10 @@
+using System.Windows;
+
+[assembly: ThemeInfo(
+    ResourceDictionaryLocation.None,            //where theme specific resource dictionaries are located
+                                                //(used if a resource is not found in the page,
+                                                // or application resource dictionaries)
+    ResourceDictionaryLocation.SourceAssembly   //where the generic resource dictionary is located
+                                                //(used if a resource is not found in the page,
+                                                // app, or any theme specific resource dictionaries)
+)]

src/ScreenGrab.Sample/MainWindow.xaml

@@ -0,0 +1,56 @@
+<ui:FluentWindow x:Class="ScreenGrab.Sample.MainWindow"
+                 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:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+                 xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
+                 xmlns:tray="http://schemas.lepo.co/wpfui/2022/xaml/tray"
+                 mc:Ignorable="d"
+                 Loaded="MainWindow_OnLoaded"
+                 Unloaded="MainWindow_OnUnloaded"
+                 WindowStartupLocation="CenterScreen"
+                 Title="ScreenGrab Sample" Height="450" Width="800">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="38" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+        </Grid.RowDefinitions>
+        <ui:TitleBar Title="ScreenGrab Sample" />
+        <tray:NotifyIcon Grid.Row="0"
+                         FocusOnLeftClick="True"
+                         Icon="nuget.png"
+                         LeftClick="NotifyIcon_OnLeftClick"
+                         MenuOnRightClick="True"
+                         TooltipText="ScreenGrab.Sample">
+            <tray:NotifyIcon.Menu>
+                <ContextMenu>
+                    <MenuItem Header="Grab"
+                              Click="Capture_Click"
+                              InputGestureText="Win+Shift+A">
+                        <MenuItem.Icon>
+                            <ui:SymbolIcon Symbol="Screenshot24" />
+                        </MenuItem.Icon>
+                    </MenuItem>
+                    <Separator />
+                    <MenuItem Header="Exit"
+                              Click="MenuItem_OnClick">
+                        <MenuItem.Icon>
+                            <ui:SymbolIcon Symbol="PictureInPictureExit24" />
+                        </MenuItem.Icon>
+                    </MenuItem>
+                </ContextMenu>
+            </tray:NotifyIcon.Menu>
+        </tray:NotifyIcon>
+        <ui:Card Grid.Row="1" Margin="8">
+            <StackPanel Orientation="Horizontal">
+                <Button Margin="2 0" Content="Capture(Win+Shift+A)" Click="Capture_Click" />
+                <Button Margin="2 0" Content="Clean" Click="Clean_Click" />
+                <CheckBox Margin="2 0" Content="Auxiliary" Name="AuxiliaryCb" />
+            </StackPanel>
+        </ui:Card>
+        <ui:DynamicScrollViewer Grid.Row="2" Margin="8">
+            <Image x:Name="Img" />
+        </ui:DynamicScrollViewer>
+    </Grid>
+</ui:FluentWindow>

src/ScreenGrab.Sample/MainWindow.xaml.cs

@@ -0,0 +1,98 @@
+using NHotkey;
+using NHotkey.Wpf;
+using ScreenGrab.Extensions;
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows;
+using System.Windows.Input;
+using Wpf.Ui.Tray.Controls;
+
+namespace ScreenGrab.Sample;
+
+public partial class MainWindow
+{
+    public MainWindow()
+    {
+        InitializeComponent();
+    }
+
+    private void Capture()
+    {
+        Clean();
+
+        //ScreenGrabber.OnCaptured = bitmap =>
+        //{
+        //    Img.Source = bitmap.ToImageSource();
+        //    if (WindowState != WindowState.Normal)
+        //        WindowState = WindowState.Normal;
+        //    if (!IsVisible)
+        //        Show();
+        //    Activate();
+        //};
+        //ScreenGrabber.Capture(AuxiliaryCb.IsChecked ?? false);
+
+        if (ScreenGrabber.IsCapturing) return;
+        // https://github.com/wuqinchao/ScreenCapturer
+            // 替代品 
+        ScreenGrabber.OnCaptured = async bitmap => await ScreenshotCallbackAsync(bitmap, null);
+        ScreenGrabber.Capture(true);
+    }
+
+    internal async Task ScreenshotCallbackAsync(Bitmap? bitmap, CancellationToken? token = null)
+    {
+        if (bitmap == null)
+        {
+            //ShowBalloonTip("图像不存在");
+            return;
+        }
+    }
+
+    private void Capture(object? sender, HotkeyEventArgs e)
+    {
+        Capture();
+    }
+
+    private void Capture_Click(object sender, RoutedEventArgs e)
+    {
+        Capture();
+    }
+
+    private void Clean_Click(object sender, RoutedEventArgs e)
+    {
+        Clean();
+    }
+
+    private void Clean()
+    {
+        Img.Source?.Freeze();
+        Img.Source = null;
+        GC.Collect();
+    }
+
+    private void MainWindow_OnLoaded(object sender, RoutedEventArgs e)
+    {
+        HotkeyManager.Current.AddOrReplace("Capture", Key.A, ModifierKeys.Windows | ModifierKeys.Shift, Capture);
+    }
+
+    private void MainWindow_OnUnloaded(object sender, RoutedEventArgs e)
+    {
+        HotkeyManager.Current.Remove("Capture");
+    }
+
+    protected override void OnClosing(CancelEventArgs e)
+    {
+        e.Cancel = true;
+        Hide();
+    }
+
+    private void NotifyIcon_OnLeftClick(NotifyIcon sender, RoutedEventArgs e)
+    {
+        Show();
+        Activate();
+    }
+
+    private void MenuItem_OnClick(object sender, RoutedEventArgs e)
+    {
+        Application.Current.Shutdown();
+    }
+}

src/ScreenGrab.Sample/ScreenGrab.Sample.csproj

@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UseWPF>true</UseWPF>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <Optimize>False</Optimize>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Remove="nuget.png" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="NHotkey" Version="3.0.0" />
+    <PackageReference Include="NHotkey.Wpf" Version="3.0.0" />
+    <PackageReference Include="WPF-UI" Version="3.0.5" />
+    <PackageReference Include="WPF-UI.Tray" Version="3.0.5" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ScreenGrab\ScreenGrab.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Resource Include="nuget.png" />
+  </ItemGroup>
+
+</Project>

src/ScreenGrab/AutoGrid.cs

@@ -0,0 +1,529 @@
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Controls;
+using ScreenGrab.Extensions;
+
+namespace ScreenGrab;
+
+/// <summary>
+///     Source <see href="https://github.com/budul100/WpfAutoGrid.Core" />
+///     Defines a flexible grid area that consists of columns and rows.
+///     Depending on the orientation, either the rows or the columns are auto-generated,
+///     and the children's position is set according to their index.
+///     Partially based on work at http://rachel53461.wordpress.com/2011/09/17/wpf-grids-rowcolumn-count-properties/
+/// </summary>
+public class AutoGrid : Grid
+{
+    #region Protected Methods
+
+    /// <summary>
+    ///     Measures the children of a <see cref="T:System.Windows.Controls.Grid" /> in anticipation of arranging them during
+    ///     the <see cref="M:ArrangeOverride" /> pass.
+    /// </summary>
+    /// <param name="constraint">Indicates an upper limit size that should not be exceeded.</param>
+    /// <returns>
+    ///     <see cref="Size" /> that represents the required size to arrange child content.
+    /// </returns>
+    protected override Size MeasureOverride(Size constraint)
+    {
+        PerformLayout();
+        return base.MeasureOverride(constraint);
+    }
+
+    #endregion Protected Methods
+
+    #region Public Fields
+
+    public static readonly DependencyProperty ChildHorizontalAlignmentProperty = DependencyProperty.Register(
+        "ChildHorizontalAlignment",
+        typeof(HorizontalAlignment?),
+        typeof(AutoGrid),
+        new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsMeasure,
+            OnChildHorizontalAlignmentChanged));
+
+    public static readonly DependencyProperty ChildMarginProperty = DependencyProperty.Register(
+        "ChildMargin",
+        typeof(Thickness?),
+        typeof(AutoGrid),
+        new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsMeasure, OnChildMarginChanged));
+
+    public static readonly DependencyProperty ChildVerticalAlignmentProperty = DependencyProperty.Register(
+        "ChildVerticalAlignment",
+        typeof(VerticalAlignment?),
+        typeof(AutoGrid),
+        new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsMeasure,
+            OnChildVerticalAlignmentChanged));
+
+    public static readonly DependencyProperty ColumnCountProperty = DependencyProperty.RegisterAttached(
+        "ColumnCount",
+        typeof(int),
+        typeof(AutoGrid),
+        new FrameworkPropertyMetadata(1, FrameworkPropertyMetadataOptions.AffectsMeasure, ColumnCountChanged));
+
+    public static readonly DependencyProperty ColumnsProperty = DependencyProperty.RegisterAttached(
+        "Columns",
+        typeof(string),
+        typeof(AutoGrid),
+        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.AffectsMeasure, ColumnsChanged));
+
+    public static readonly DependencyProperty ColumnWidthProperty = DependencyProperty.RegisterAttached(
+        "ColumnWidth",
+        typeof(GridLength),
+        typeof(AutoGrid),
+        new FrameworkPropertyMetadata(GridLength.Auto, FrameworkPropertyMetadataOptions.AffectsMeasure,
+            FixedColumnWidthChanged));
+
+    public static readonly DependencyProperty IsAutoIndexingProperty = DependencyProperty.Register(
+        "IsAutoIndexing",
+        typeof(bool),
+        typeof(AutoGrid),
+        new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsMeasure));
+
+    public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register(
+        "Orientation",
+        typeof(Orientation),
+        typeof(AutoGrid),
+        new FrameworkPropertyMetadata(Orientation.Horizontal, FrameworkPropertyMetadataOptions.AffectsMeasure));
+
+    public static readonly DependencyProperty RowCountProperty = DependencyProperty.RegisterAttached(
+        "RowCount",
+        typeof(int),
+        typeof(AutoGrid),
+        new FrameworkPropertyMetadata(1, FrameworkPropertyMetadataOptions.AffectsMeasure, RowCountChanged));
+
+    public static readonly DependencyProperty RowHeightProperty = DependencyProperty.RegisterAttached(
+        "RowHeight",
+        typeof(GridLength),
+        typeof(AutoGrid),
+        new FrameworkPropertyMetadata(GridLength.Auto, FrameworkPropertyMetadataOptions.AffectsMeasure,
+            FixedRowHeightChanged));
+
+    public static readonly DependencyProperty RowsProperty = DependencyProperty.RegisterAttached(
+        "Rows",
+        typeof(string),
+        typeof(AutoGrid),
+        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.AffectsMeasure, RowsChanged));
+
+    #endregion Public Fields
+
+    #region Public Properties
+
+    /// <summary>
+    ///     Gets or sets the child horizontal alignment.
+    /// </summary>
+    /// <value>The child horizontal alignment.</value>
+    [Category("Layout")]
+    [Description("Presets the horizontal alignment of all child controls")]
+    public HorizontalAlignment? ChildHorizontalAlignment
+    {
+        get => (HorizontalAlignment?)GetValue(ChildHorizontalAlignmentProperty);
+        set => SetValue(ChildHorizontalAlignmentProperty, value);
+    }
+
+    /// <summary>
+    ///     Gets or sets the child margin.
+    /// </summary>
+    /// <value>The child margin.</value>
+    [Category("Layout")]
+    [Description("Presets the margin of all child controls")]
+    public Thickness? ChildMargin
+    {
+        get => (Thickness?)GetValue(ChildMarginProperty);
+        set => SetValue(ChildMarginProperty, value);
+    }
+
+    /// <summary>
+    ///     Gets or sets the child vertical alignment.
+    /// </summary>
+    /// <value>The child vertical alignment.</value>
+    [Category("Layout")]
+    [Description("Presets the vertical alignment of all child controls")]
+    public VerticalAlignment? ChildVerticalAlignment
+    {
+        get => (VerticalAlignment?)GetValue(ChildVerticalAlignmentProperty);
+        set => SetValue(ChildVerticalAlignmentProperty, value);
+    }
+
+    /// <summary>
+    ///     Gets or sets the column count
+    /// </summary>
+    [Category("Layout")]
+    [Description("Defines a set number of columns")]
+    public int ColumnCount
+    {
+        get => (int)GetValue(ColumnCountProperty);
+        set => SetValue(ColumnCountProperty, value);
+    }
+
+    /// <summary>
+    ///     Gets or sets the columns
+    /// </summary>
+    [Category("Layout")]
+    [Description("Defines all columns using comma separated grid length notation")]
+    public string Columns
+    {
+        get => (string)GetValue(ColumnsProperty);
+        set => SetValue(ColumnsProperty, value);
+    }
+
+    /// <summary>
+    ///     Gets or sets the fixed column width
+    /// </summary>
+    [Category("Layout")]
+    [Description("Presets the width of all columns set using the ColumnCount property")]
+    public GridLength ColumnWidth
+    {
+        get => (GridLength)GetValue(ColumnWidthProperty);
+        set => SetValue(ColumnWidthProperty, value);
+    }
+
+    /// <summary>
+    ///     Gets or sets a value indicating whether the children are automatically indexed.
+    ///     <remarks>
+    ///         The default is <c>true</c>.
+    ///         Note that if children are already indexed, setting this property to <c>false</c> will not remove their indices.
+    ///     </remarks>
+    /// </summary>
+    [Category("Layout")]
+    [Description("Set to false to disable the auto layout functionality")]
+    public bool IsAutoIndexing
+    {
+        get => (bool)GetValue(IsAutoIndexingProperty);
+        set => SetValue(IsAutoIndexingProperty, value);
+    }
+
+    /// <summary>
+    ///     Gets or sets the orientation.
+    ///     <remarks>The default is Vertical.</remarks>
+    /// </summary>
+    /// <value>The orientation.</value>
+    [Category("Layout")]
+    [Description(
+        "Defines the directionality of the autolayout. Use vertical for a column first layout, horizontal for a row first layout.")]
+    public Orientation Orientation
+    {
+        get => (Orientation)GetValue(OrientationProperty);
+        set => SetValue(OrientationProperty, value);
+    }
+
+    /// <summary>
+    ///     Gets or sets the number of rows
+    /// </summary>
+    [Category("Layout")]
+    [Description("Defines a set number of rows")]
+    public int RowCount
+    {
+        get => (int)GetValue(RowCountProperty);
+        set => SetValue(RowCountProperty, value);
+    }
+
+    /// <summary>
+    ///     Gets or sets the fixed row height
+    /// </summary>
+    [Category("Layout")]
+    [Description("Presets the height of all rows set using the RowCount property")]
+    public GridLength RowHeight
+    {
+        get => (GridLength)GetValue(RowHeightProperty);
+        set => SetValue(RowHeightProperty, value);
+    }
+
+    /// <summary>
+    ///     Gets or sets the rows
+    /// </summary>
+    [Category("Layout")]
+    [Description("Defines all rows using comma separated grid length notation")]
+    public string Rows
+    {
+        get => (string)GetValue(RowsProperty);
+        set => SetValue(RowsProperty, value);
+    }
+
+    #endregion Public Properties
+
+    #region Public Methods
+
+    /// <summary>
+    ///     Handles the column count changed event
+    /// </summary>
+    public static void ColumnCountChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if ((int)e.NewValue < 0)
+            return;
+
+        if (d is not AutoGrid grid) return;
+        //var grid = d as AutoGrid;
+
+        // look for an existing column definition for the height
+        var width = GridLength.Auto;
+        if (grid.ColumnDefinitions.Count > 0)
+            width = grid.ColumnDefinitions[0].Width;
+
+        // clear and rebuild
+        grid.ColumnDefinitions.Clear();
+        for (var i = 0; i < (int)e.NewValue; i++)
+            grid.ColumnDefinitions.Add(
+                new ColumnDefinition { Width = width });
+    }
+
+    /// <summary>
+    ///     Handle the columns changed event
+    /// </summary>
+    public static void ColumnsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (string.IsNullOrEmpty((string)e.NewValue))
+            return;
+
+        if (d is not AutoGrid grid) return;
+        //var grid = d as AutoGrid;
+        grid.ColumnDefinitions.Clear();
+
+        var defs = Parse((string)e.NewValue);
+        foreach (var def in defs)
+            grid.ColumnDefinitions.Add(new ColumnDefinition { Width = def });
+    }
+
+    /// <summary>
+    ///     Handle the fixed column width changed event
+    /// </summary>
+    public static void FixedColumnWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is not AutoGrid grid) return;
+        //var grid = d as AutoGrid;
+
+        // add a default column if missing
+        if (grid.ColumnDefinitions.Count == 0)
+            grid.ColumnDefinitions.Add(new ColumnDefinition());
+
+        // set all existing columns to this width
+        for (var i = 0; i < grid.ColumnDefinitions.Count; i++)
+            grid.ColumnDefinitions[i].Width = (GridLength)e.NewValue;
+    }
+
+    /// <summary>
+    ///     Handle the fixed row height changed event
+    /// </summary>
+    public static void FixedRowHeightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is not AutoGrid grid) return;
+        //var grid = d as AutoGrid;
+
+        // add a default row if missing
+        if (grid.RowDefinitions.Count == 0)
+            grid.RowDefinitions.Add(new RowDefinition());
+
+        // set all existing rows to this height
+        for (var i = 0; i < grid.RowDefinitions.Count; i++)
+            grid.RowDefinitions[i].Height = (GridLength)e.NewValue;
+    }
+
+    /// <summary>
+    ///     Parse an array of grid lengths from comma delim text
+    /// </summary>
+    public static GridLength[] Parse(string text)
+    {
+        var tokens = text.Split(',');
+        var definitions = new GridLength[tokens.Length];
+        for (var i = 0; i < tokens.Length; i++)
+        {
+            var str = tokens[i];
+            double value;
+
+            // ratio
+            if (str.Contains('*'))
+            {
+                if (!double.TryParse(str.Replace("*", ""), out value))
+                    value = 1.0;
+
+                definitions[i] = new GridLength(value, GridUnitType.Star);
+                continue;
+            }
+
+            // pixels
+            if (double.TryParse(str, out value))
+            {
+                definitions[i] = new GridLength(value);
+                continue;
+            }
+
+            // auto
+            definitions[i] = GridLength.Auto;
+        }
+
+        return definitions;
+    }
+
+    /// <summary>
+    ///     Handles the row count changed event
+    /// </summary>
+    public static void RowCountChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if ((int)e.NewValue < 0)
+            return;
+
+        if (d is not AutoGrid grid) return;
+        //var grid = d as AutoGrid;
+
+        // look for an existing row to get the height
+        var height = GridLength.Auto;
+        if (grid.RowDefinitions.Count > 0)
+            height = grid.RowDefinitions[0].Height;
+
+        // clear and rebuild
+        grid.RowDefinitions.Clear();
+        for (var i = 0; i < (int)e.NewValue; i++)
+            grid.RowDefinitions.Add(
+                new RowDefinition { Height = height });
+    }
+
+    /// <summary>
+    ///     Handle the rows changed event
+    /// </summary>
+    public static void RowsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (string.IsNullOrEmpty((string)e.NewValue))
+            return;
+
+        if (d is not AutoGrid grid) return;
+        //var grid = d as AutoGrid;
+        grid.RowDefinitions.Clear();
+
+        var defs = Parse((string)e.NewValue);
+        foreach (var def in defs)
+            grid.RowDefinitions.Add(new RowDefinition { Height = def });
+    }
+
+    #endregion Public Methods
+
+    #region Private Methods
+
+    /// <summary>
+    ///     Called when [child horizontal alignment changed].
+    /// </summary>
+    private static void OnChildHorizontalAlignmentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is not AutoGrid grid) return;
+        //var grid = d as AutoGrid;
+        foreach (UIElement child in grid.Children)
+            if (grid.ChildHorizontalAlignment.HasValue)
+                child.SetValue(HorizontalAlignmentProperty, grid.ChildHorizontalAlignment);
+            else
+                child.SetValue(HorizontalAlignmentProperty, DependencyProperty.UnsetValue);
+    }
+
+    /// <summary>
+    ///     Called when [child layout changed].
+    /// </summary>
+    private static void OnChildMarginChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is not AutoGrid grid) return;
+        //var grid = d as AutoGrid;
+        foreach (UIElement child in grid.Children)
+            if (grid.ChildMargin.HasValue)
+                child.SetValue(MarginProperty, grid.ChildMargin);
+            else
+                child.SetValue(MarginProperty, DependencyProperty.UnsetValue);
+    }
+
+    /// <summary>
+    ///     Called when [child vertical alignment changed].
+    /// </summary>
+    private static void OnChildVerticalAlignmentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is not AutoGrid grid) return;
+        //var grid = d as AutoGrid;
+        foreach (UIElement child in grid.Children)
+            if (grid.ChildVerticalAlignment.HasValue)
+                child.SetValue(VerticalAlignmentProperty, grid.ChildVerticalAlignment);
+            else
+                child.SetValue(VerticalAlignmentProperty, DependencyProperty.UnsetValue);
+    }
+
+    ///// <summary>
+    ///// Handled the redraw properties changed event
+    ///// </summary>
+    //private static void OnPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    //{ }
+
+    /// <summary>
+    ///     Apply child margins and layout effects such as alignment
+    /// </summary>
+    private void ApplyChildLayout(UIElement child)
+    {
+        if (ChildMargin != null) child.SetIfDefault(MarginProperty, ChildMargin.Value);
+        if (ChildHorizontalAlignment != null)
+            child.SetIfDefault(HorizontalAlignmentProperty, ChildHorizontalAlignment.Value);
+        if (ChildVerticalAlignment != null) child.SetIfDefault(VerticalAlignmentProperty, ChildVerticalAlignment.Value);
+    }
+
+    /// <summary>
+    ///     Clamp a value to its maximum.
+    /// </summary>
+    private int Clamp(int value, int max)
+    {
+        return value > max ? max : value;
+    }
+
+    /// <summary>
+    ///     Perform the grid layout of row and column indexes
+    /// </summary>
+    private void PerformLayout()
+    {
+        var fillRowFirst = Orientation == Orientation.Horizontal;
+        var rowCount = RowDefinitions.Count;
+        var colCount = ColumnDefinitions.Count;
+
+        if (rowCount == 0 || colCount == 0)
+            return;
+
+        var position = 0;
+        var skip = new bool[rowCount, colCount];
+        foreach (UIElement child in Children)
+        {
+            var childIsCollapsed = child.Visibility == Visibility.Collapsed;
+            if (IsAutoIndexing && !childIsCollapsed)
+            {
+                if (fillRowFirst)
+                {
+                    var row = Clamp(position / colCount, rowCount - 1);
+                    var col = Clamp(position % colCount, colCount - 1);
+                    if (skip[row, col])
+                    {
+                        position++;
+                        row = position / colCount;
+                        col = position % colCount;
+                    }
+
+                    SetRow(child, row);
+                    SetColumn(child, col);
+                    position += GetColumnSpan(child);
+
+                    var offset = GetRowSpan(child) - 1;
+                    while (offset > 0) skip[row + offset--, col] = true;
+                }
+                else
+                {
+                    var row = Clamp(position % rowCount, rowCount - 1);
+                    var col = Clamp(position / rowCount, colCount - 1);
+                    if (skip[row, col])
+                    {
+                        position++;
+                        row = position % rowCount;
+                        col = position / rowCount;
+                    }
+
+                    SetRow(child, row);
+                    SetColumn(child, col);
+                    position += GetRowSpan(child);
+
+                    var offset = GetColumnSpan(child) - 1;
+                    while (offset > 0) skip[row, col + offset--] = true;
+                }
+            }
+
+            ApplyChildLayout(child);
+        }
+    }
+
+    #endregion Private Methods
+}

src/ScreenGrab/Extensions/DapploExtensions.cs

@@ -0,0 +1,32 @@
+using System.Windows;
+using Dapplo.Windows.User32;
+
+namespace ScreenGrab.Extensions;
+
+public static class DapploExtensions
+{
+    public static Point ScaledCenterPoint(this DisplayInfo displayInfo)
+    {
+        Rect displayRect = displayInfo.Bounds;
+        NativeMethods.GetScaleFactorForMonitor(displayInfo.MonitorHandle, out var scaleFactor);
+        var scaleFraction = scaleFactor / 100.0;
+        var rawCenter = displayRect.CenterPoint();
+        Point displayScaledCenterPoint = new(rawCenter.X / scaleFraction, rawCenter.Y / scaleFraction);
+        return displayScaledCenterPoint;
+    }
+
+    public static Rect ScaledBounds(this DisplayInfo displayInfo)
+    {
+        Rect displayRect = displayInfo.Bounds;
+        NativeMethods.GetScaleFactorForMonitor(displayInfo.MonitorHandle, out var scaleFactor);
+        var scaleFraction = scaleFactor / 100.0;
+
+        // Scale size and position
+        Rect scaledBounds = new(
+            displayRect.X / scaleFraction,
+            displayRect.Y / scaleFraction,
+            displayRect.Width / scaleFraction,
+            displayRect.Height / scaleFraction);
+        return scaledBounds;
+    }
+}

src/ScreenGrab/Extensions/DependencyExtensions.cs

@@ -0,0 +1,25 @@
+using System.Windows;
+
+namespace ScreenGrab.Extensions;
+
+public static class DependencyExtensions
+{
+    #region Public Methods
+
+    /// <summary>
+    ///     Sets the value of the <paramref name="property" /> only if it hasn't been explicitly set.
+    /// </summary>
+    public static bool SetIfDefault<T>(this DependencyObject o, DependencyProperty property, T value)
+    {
+        if (DependencyPropertyHelper.GetValueSource(o, property).BaseValueSource == BaseValueSource.Default)
+        {
+            o.SetValue(property, value);
+
+            return true;
+        }
+
+        return false;
+    }
+
+    #endregion Public Methods
+}

src/ScreenGrab/Extensions/ImageExtensions.cs

@@ -0,0 +1,92 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using ScreenGrab.Utilities;
+using PixelFormat = System.Drawing.Imaging.PixelFormat;
+
+namespace ScreenGrab.Extensions;
+
+public static class ImageExtensions
+{
+    public static ImageSource? GetWindowBoundsImage(this Window passedWindow)
+    {
+        var bmp = passedWindow.GetWindowsBoundsBitmap();
+        return bmp.ToImageSource();
+    }
+
+    public static Tuple<double, double> GetWidthHeight(this Window window)
+    {
+        var dpi = VisualTreeHelper.GetDpi(window);
+        return new Tuple<double, double>(window.ActualWidth * dpi.DpiScaleX, window.ActualHeight * dpi.DpiScaleY);
+    }
+
+    public static Bitmap GetWindowsBoundsBitmap(this Window passedWindow)
+    {
+        var (windowWidth, windowHeight) = passedWindow.GetWidthHeight();
+
+        var absPosPoint = passedWindow.GetAbsolutePosition();
+
+        var thisCorrectedLeft = (int)absPosPoint.X;
+        var thisCorrectedTop = (int)absPosPoint.Y;
+
+        Bitmap bmp = new((int)windowWidth, (int)windowHeight, PixelFormat.Format32bppArgb);
+        using var g = Graphics.FromImage(bmp);
+
+        g.CopyFromScreen(thisCorrectedLeft, thisCorrectedTop, 0, 0, bmp.Size, CopyPixelOperation.SourceCopy);
+        return bmp;
+    }
+
+    public static BitmapImage? ToImageSource(this Bitmap? bitmap)
+    {
+        if (bitmap == null) return default;
+        using MemoryStream memory = new();
+        using WrappingStream wrapper = new(memory);
+
+        bitmap.Save(wrapper, ImageFormat.Bmp);
+        wrapper.Position = 0;
+        BitmapImage bitmapImage = new();
+        bitmapImage.BeginInit();
+        bitmapImage.StreamSource = wrapper;
+        bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
+        bitmapImage.EndInit();
+        bitmapImage.StreamSource = null;
+        bitmapImage.Freeze();
+
+        memory.Flush();
+        wrapper.Flush();
+
+        return bitmapImage;
+    }
+
+    public static Bitmap GetRegionOfScreenAsBitmap(this Rectangle region)
+    {
+        Bitmap bmp = new(region.Width, region.Height, PixelFormat.Format32bppArgb);
+        using var g = Graphics.FromImage(bmp);
+
+        g.CopyFromScreen(region.Left, region.Top, 0, 0, bmp.Size, CopyPixelOperation.SourceCopy);
+        bmp = bmp.PadImage();
+
+        return bmp;
+    }
+
+    public static Bitmap PadImage(this Bitmap image, int minW = 64, int minH = 64)
+    {
+        if (image.Height >= minH && image.Width >= minW)
+            return image;
+
+        var width = Math.Max(image.Width + 16, minW + 16);
+        var height = Math.Max(image.Height + 16, minH + 16);
+
+        // Create a compatible bitmap
+        Bitmap destination = new(width, height, image.PixelFormat);
+        using var gd = Graphics.FromImage(destination);
+
+        gd.Clear(image.GetPixel(0, 0));
+        gd.DrawImageUnscaled(image, 8, 8);
+
+        return destination;
+    }
+}

src/ScreenGrab/Extensions/ShapeExtensions.cs

@@ -0,0 +1,84 @@
+using System.Drawing;
+using System.Windows;
+using Point = System.Windows.Point;
+
+namespace ScreenGrab.Extensions;
+
+public static class ShapeExtensions
+{
+    public static Rect AsRect(this Rectangle rectangle)
+    {
+        return new Rect(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
+    }
+
+    public static Rectangle AsRectangle(this Rect rect)
+    {
+        return new Rectangle((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height);
+    }
+
+    public static Rect GetScaledDownByDpi(this Rect rect, DpiScale dpi)
+    {
+        return new Rect(rect.X / dpi.DpiScaleX,
+            rect.Y / dpi.DpiScaleY,
+            rect.Width / dpi.DpiScaleX,
+            rect.Height / dpi.DpiScaleY);
+    }
+
+    public static Rect GetScaledUpByDpi(this Rect rect, DpiScale dpi)
+    {
+        return new Rect(rect.X * dpi.DpiScaleX,
+            rect.Y * dpi.DpiScaleY,
+            rect.Width * dpi.DpiScaleX,
+            rect.Height * dpi.DpiScaleY);
+    }
+
+    public static Rect GetScaledUpByFraction(this Rect rect, double scaleFactor)
+    {
+        return new Rect(rect.X * scaleFactor,
+            rect.Y * scaleFactor,
+            rect.Width * scaleFactor,
+            rect.Height * scaleFactor);
+    }
+
+    public static Rect GetScaleSizeByFraction(this Rect rect, double scaleFactor)
+    {
+        return new Rect(rect.X,
+            rect.Y,
+            rect.Width * scaleFactor,
+            rect.Height * scaleFactor);
+    }
+
+    public static bool IsGood(this Rect rect)
+    {
+        if (double.IsNaN(rect.X)
+            || double.IsNegativeInfinity(rect.X)
+            || double.IsPositiveInfinity(rect.X))
+            return false;
+
+        if (double.IsNaN(rect.Y)
+            || double.IsNegativeInfinity(rect.Y)
+            || double.IsPositiveInfinity(rect.Y))
+            return false;
+
+        if (double.IsNaN(rect.Height)
+            || rect.Height == 0
+            || double.IsNegativeInfinity(rect.Height)
+            || double.IsPositiveInfinity(rect.Height))
+            return false;
+
+        if (double.IsNaN(rect.Width)
+            || rect.Width == 0
+            || double.IsNegativeInfinity(rect.Width)
+            || double.IsPositiveInfinity(rect.Width))
+            return false;
+
+        return true;
+    }
+
+    public static Point CenterPoint(this Rect rect)
+    {
+        var x = rect.Left + rect.Width / 2;
+        var y = rect.Top + rect.Height / 2;
+        return new Point(x, y);
+    }
+}

src/ScreenGrab/Extensions/WpfExtensions.cs

@@ -0,0 +1,43 @@
+using System.Runtime.InteropServices;
+using System.Windows;
+using System.Windows.Interop;
+
+namespace ScreenGrab.Extensions;
+
+public static class WpfExtensions
+{
+    /// <summary>
+    ///     Gets the absolute position of the specified window.
+    /// </summary>
+    /// <param name="w">The window for which to get the absolute position.</param>
+    /// <returns>A <see cref="Point" /> representing the absolute position of the window.</returns>
+    public static Point GetAbsolutePosition(this Window w)
+    {
+        // If the window is not maximized, return the top-left corner position of the window
+        if (w.WindowState != WindowState.Maximized)
+            return new Point(w.Left, w.Top);
+
+        Int32Rect r;
+        // Check if the system supports multiple monitors
+        var multimonSupported = OSInterop.GetSystemMetrics(OSInterop.SM_CMONITORS) != 0;
+        if (!multimonSupported)
+        {
+            // If multiple monitors are not supported, get the work area rectangle of the primary monitor
+            var rc = new OSInterop.RECT();
+            OSInterop.SystemParametersInfo(48, 0, ref rc, 0);
+            r = new Int32Rect(rc.left, rc.top, rc.width, rc.height);
+        }
+        else
+        {
+            // If multiple monitors are supported, get the monitor information for the monitor containing the window
+            var helper = new WindowInteropHelper(w);
+            var hmonitor = OSInterop.MonitorFromWindow(new HandleRef(null, helper.EnsureHandle()), 2);
+            var info = new OSInterop.MONITORINFOEX();
+            OSInterop.GetMonitorInfo(new HandleRef(null, hmonitor), info);
+            r = new Int32Rect(info.rcMonitor.left, info.rcMonitor.top, info.rcMonitor.width, info.rcMonitor.height);
+        }
+
+        // Return the top-left corner position of the monitor
+        return new Point(r.X, r.Y);
+    }
+}

src/ScreenGrab/Models/NullAsyncResult.cs

@@ -0,0 +1,16 @@
+namespace ScreenGrab.Models;
+
+public class NullAsyncResult : IAsyncResult
+{
+    public object? AsyncState => null;
+
+    public WaitHandle AsyncWaitHandle => new NullWaitHandle();
+
+    public bool CompletedSynchronously => true;
+
+    public bool IsCompleted => true;
+}
+
+public class NullWaitHandle : WaitHandle
+{
+}

src/ScreenGrab/NativeMethods.cs

@@ -0,0 +1,13 @@
+using System.Runtime.InteropServices;
+
+internal static partial class NativeMethods
+{
+#if NET7_0_OR_GREATER
+
+    [LibraryImport("shcore.dll")]
+    public static partial void GetScaleFactorForMonitor(IntPtr hMon, out uint pScale);
+#else
+    [DllImport("shcore.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    public static extern void GetScaleFactorForMonitor(IntPtr hMon, out uint pScale);
+#endif
+}

src/ScreenGrab/OSInterop.cs

@@ -0,0 +1,1197 @@
+using System.Runtime.InteropServices;
+
+internal static partial class OSInterop
+{
+    public delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam);
+
+    public enum InputType : uint
+    {
+        INPUT_MOUSE,
+        INPUT_KEYBOARD,
+        INPUT_HARDWARE
+    }
+
+    public const int SM_CMONITORS = 80;
+
+    public const int WH_KEYBOARD_LL = 13;
+    public const int VK_SHIFT = 0x10;
+    public const int VK_CONTROL = 0x11;
+    public const int VK_MENU = 0x12;
+    public const int VK_LWIN = 0x5B;
+    public const int VK_RWIN = 0x5C;
+    public const int VK_ESCAPE = 0x1B;
+    public const int WM_HOTKEY = 0x0312;
+    public const int WM_KEYDOWN = 0x0100;
+    public const int WM_KEYUP = 0x0101;
+
+    [DllImport("user32.dll", CharSet = CharSet.Auto)]
+    public static extern bool GetMonitorInfo(HandleRef hmonitor, [In] [Out] MONITORINFOEX info);
+
+    [DllImport("user32.dll")]
+    public static extern IntPtr MonitorFromWindow(HandleRef handle, int flags);
+#if NET7_0_OR_GREATER
+    [LibraryImport("user32.dll")]
+    public static partial int GetSystemMetrics(int smIndex);
+
+    [LibraryImport("user32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static partial bool SystemParametersInfo(int nAction, int nParam, ref RECT rc, int nUpdate);
+
+    [LibraryImport("user32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static partial bool ClipCursor(ref RECT lpRect);
+#else
+    [DllImport("user32.dll", SetLastError = true)]
+    public static extern int GetSystemMetrics(int smIndex);
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool SystemParametersInfo(int nAction, int nParam, ref RECT rc, int nUpdate);
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool ClipCursor(ref RECT lpRect);
+#endif
+
+    [DllImport("user32.dll")]
+    public static extern bool ClipCursor([In] IntPtr lpRect);
+
+    public struct RECT
+    {
+        public int left;
+        public int top;
+        public int right;
+        public int bottom;
+        public int width => right - left;
+        public int height => bottom - top;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 4, CharSet = CharSet.Auto)]
+    public class MONITORINFOEX
+    {
+        public int cbSize = Marshal.SizeOf(typeof(MONITORINFOEX));
+        public RECT rcMonitor = new();
+        public RECT rcWork = new();
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
+        public char[] szDevice = new char[32];
+
+        public int dwFlags;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct INPUT
+    {
+        public InputType Type;
+        public InputUnion U;
+
+        public static int Size => Marshal.SizeOf(typeof(INPUT));
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    public struct InputUnion
+    {
+        [FieldOffset(0)] internal MOUSEINPUT Mi;
+        [FieldOffset(0)] internal KEYBDINPUT Ki;
+        [FieldOffset(0)] internal HARDWAREINPUT Hi;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct MOUSEINPUT
+    {
+        internal int Dx;
+        internal int Dy;
+        internal int MouseData;
+        internal MOUSEEVENTF DwFlags;
+        internal uint Time;
+        internal UIntPtr DwExtraInfo;
+    }
+
+    [Flags]
+    internal enum MOUSEEVENTF : uint
+    {
+        ABSOLUTE = 0x8000,
+        HWHEEL = 0x01000,
+        MOVE = 0x0001,
+        MOVE_NOCOALESCE = 0x2000,
+        LEFTDOWN = 0x0002,
+        LEFTUP = 0x0004,
+        RIGHTDOWN = 0x0008,
+        RIGHTUP = 0x0010,
+        MIDDLEDOWN = 0x0020,
+        MIDDLEUP = 0x0040,
+        VIRTUALDESK = 0x4000,
+        WHEEL = 0x0800,
+        XDOWN = 0x0080,
+        XUP = 0x0100
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct KEYBDINPUT
+    {
+        internal VirtualKeyShort WVk;
+        internal ScanCodeShort WScan;
+        internal KEYEVENTF DwFlags;
+        internal int Time;
+        internal UIntPtr DwExtraInfo;
+    }
+
+    [Flags]
+    internal enum KEYEVENTF : uint
+    {
+        EXTENDEDKEY = 0x0001,
+        KEYUP = 0x0002,
+        SCANCODE = 0x0008,
+        UNICODE = 0x0004
+    }
+
+    internal enum VirtualKeyShort : short
+    {
+        /// <summary>
+        ///     Left mouse button
+        /// </summary>
+        LBUTTON = 0x01,
+
+        /// <summary>
+        ///     Right mouse button
+        /// </summary>
+        RBUTTON = 0x02,
+
+        /// <summary>
+        ///     Control-break processing
+        /// </summary>
+        CANCEL = 0x03,
+
+        /// <summary>
+        ///     Middle mouse button (three-button mouse)
+        /// </summary>
+        MBUTTON = 0x04,
+
+        /// <summary>
+        ///     Windows 2000/XP: X1 mouse button
+        /// </summary>
+        XBUTTON1 = 0x05,
+
+        /// <summary>
+        ///     Windows 2000/XP: X2 mouse button
+        /// </summary>
+        XBUTTON2 = 0x06,
+
+        /// <summary>
+        ///     BACKSPACE key
+        /// </summary>
+        BACK = 0x08,
+
+        /// <summary>
+        ///     TAB key
+        /// </summary>
+        TAB = 0x09,
+
+        /// <summary>
+        ///     CLEAR key
+        /// </summary>
+        CLEAR = 0x0C,
+
+        /// <summary>
+        ///     ENTER key
+        /// </summary>
+        RETURN = 0x0D,
+
+        /// <summary>
+        ///     SHIFT key
+        /// </summary>
+        SHIFT = 0x10,
+
+        /// <summary>
+        ///     CTRL key
+        /// </summary>
+        CONTROL = 0x11,
+
+        /// <summary>
+        ///     ALT key
+        /// </summary>
+        MENU = 0x12,
+
+        /// <summary>
+        ///     PAUSE key
+        /// </summary>
+        PAUSE = 0x13,
+
+        /// <summary>
+        ///     CAPS LOCK key
+        /// </summary>
+        CAPITAL = 0x14,
+
+        /// <summary>
+        ///     Input Method Editor (IME) Kana mode
+        /// </summary>
+        KANA = 0x15,
+
+        /// <summary>
+        ///     IME Hangul mode
+        /// </summary>
+        HANGUL = 0x15,
+
+        /// <summary>
+        ///     IME Junja mode
+        /// </summary>
+        JUNJA = 0x17,
+
+        /// <summary>
+        ///     IME final mode
+        /// </summary>
+        FINAL = 0x18,
+
+        /// <summary>
+        ///     IME Hanja mode
+        /// </summary>
+        HANJA = 0x19,
+
+        /// <summary>
+        ///     IME Kanji mode
+        /// </summary>
+        KANJI = 0x19,
+
+        /// <summary>
+        ///     ESC key
+        /// </summary>
+        ESCAPE = 0x1B,
+
+        /// <summary>
+        ///     IME convert
+        /// </summary>
+        CONVERT = 0x1C,
+
+        /// <summary>
+        ///     IME nonconvert
+        /// </summary>
+        NONCONVERT = 0x1D,
+
+        /// <summary>
+        ///     IME accept
+        /// </summary>
+        ACCEPT = 0x1E,
+
+        /// <summary>
+        ///     IME mode change request
+        /// </summary>
+        MODECHANGE = 0x1F,
+
+        /// <summary>
+        ///     SPACEBAR
+        /// </summary>
+        SPACE = 0x20,
+
+        /// <summary>
+        ///     PAGE UP key
+        /// </summary>
+        PRIOR = 0x21,
+
+        /// <summary>
+        ///     PAGE DOWN key
+        /// </summary>
+        NEXT = 0x22,
+
+        /// <summary>
+        ///     END key
+        /// </summary>
+        END = 0x23,
+
+        /// <summary>
+        ///     HOME key
+        /// </summary>
+        HOME = 0x24,
+
+        /// <summary>
+        ///     LEFT ARROW key
+        /// </summary>
+        LEFT = 0x25,
+
+        /// <summary>
+        ///     UP ARROW key
+        /// </summary>
+        UP = 0x26,
+
+        /// <summary>
+        ///     RIGHT ARROW key
+        /// </summary>
+        RIGHT = 0x27,
+
+        /// <summary>
+        ///     DOWN ARROW key
+        /// </summary>
+        DOWN = 0x28,
+
+        /// <summary>
+        ///     SELECT key
+        /// </summary>
+        SELECT = 0x29,
+
+        /// <summary>
+        ///     PRINT key
+        /// </summary>
+        PRINT = 0x2A,
+
+        /// <summary>
+        ///     EXECUTE key
+        /// </summary>
+        EXECUTE = 0x2B,
+
+        /// <summary>
+        ///     PRINT SCREEN key
+        /// </summary>
+        SNAPSHOT = 0x2C,
+
+        /// <summary>
+        ///     INS key
+        /// </summary>
+        INSERT = 0x2D,
+
+        /// <summary>
+        ///     DEL key
+        /// </summary>
+        DELETE = 0x2E,
+
+        /// <summary>
+        ///     HELP key
+        /// </summary>
+        HELP = 0x2F,
+
+        /// <summary>
+        ///     0 key
+        /// </summary>
+        KEY_0 = 0x30,
+
+        /// <summary>
+        ///     1 key
+        /// </summary>
+        KEY_1 = 0x31,
+
+        /// <summary>
+        ///     2 key
+        /// </summary>
+        KEY_2 = 0x32,
+
+        /// <summary>
+        ///     3 key
+        /// </summary>
+        KEY_3 = 0x33,
+
+        /// <summary>
+        ///     4 key
+        /// </summary>
+        KEY_4 = 0x34,
+
+        /// <summary>
+        ///     5 key
+        /// </summary>
+        KEY_5 = 0x35,
+
+        /// <summary>
+        ///     6 key
+        /// </summary>
+        KEY_6 = 0x36,
+
+        /// <summary>
+        ///     7 key
+        /// </summary>
+        KEY_7 = 0x37,
+
+        /// <summary>
+        ///     8 key
+        /// </summary>
+        KEY_8 = 0x38,
+
+        /// <summary>
+        ///     9 key
+        /// </summary>
+        KEY_9 = 0x39,
+
+        /// <summary>
+        ///     A key
+        /// </summary>
+        KEY_A = 0x41,
+
+        /// <summary>
+        ///     B key
+        /// </summary>
+        KEY_B = 0x42,
+
+        /// <summary>
+        ///     C key
+        /// </summary>
+        KEY_C = 0x43,
+
+        /// <summary>
+        ///     D key
+        /// </summary>
+        KEY_D = 0x44,
+
+        /// <summary>
+        ///     E key
+        /// </summary>
+        KEY_E = 0x45,
+
+        /// <summary>
+        ///     F key
+        /// </summary>
+        KEY_F = 0x46,
+
+        /// <summary>
+        ///     G key
+        /// </summary>
+        KEY_G = 0x47,
+
+        /// <summary>
+        ///     H key
+        /// </summary>
+        KEY_H = 0x48,
+
+        /// <summary>
+        ///     I key
+        /// </summary>
+        KEY_I = 0x49,
+
+        /// <summary>
+        ///     J key
+        /// </summary>
+        KEY_J = 0x4A,
+
+        /// <summary>
+        ///     K key
+        /// </summary>
+        KEY_K = 0x4B,
+
+        /// <summary>
+        ///     L key
+        /// </summary>
+        KEY_L = 0x4C,
+
+        /// <summary>
+        ///     M key
+        /// </summary>
+        KEY_M = 0x4D,
+
+        /// <summary>
+        ///     N key
+        /// </summary>
+        KEY_N = 0x4E,
+
+        /// <summary>
+        ///     O key
+        /// </summary>
+        KEY_O = 0x4F,
+
+        /// <summary>
+        ///     P key
+        /// </summary>
+        KEY_P = 0x50,
+
+        /// <summary>
+        ///     Q key
+        /// </summary>
+        KEY_Q = 0x51,
+
+        /// <summary>
+        ///     R key
+        /// </summary>
+        KEY_R = 0x52,
+
+        /// <summary>
+        ///     S key
+        /// </summary>
+        KEY_S = 0x53,
+
+        /// <summary>
+        ///     T key
+        /// </summary>
+        KEY_T = 0x54,
+
+        /// <summary>
+        ///     U key
+        /// </summary>
+        KEY_U = 0x55,
+
+        /// <summary>
+        ///     V key
+        /// </summary>
+        KEY_V = 0x56,
+
+        /// <summary>
+        ///     W key
+        /// </summary>
+        KEY_W = 0x57,
+
+        /// <summary>
+        ///     X key
+        /// </summary>
+        KEY_X = 0x58,
+
+        /// <summary>
+        ///     Y key
+        /// </summary>
+        KEY_Y = 0x59,
+
+        /// <summary>
+        ///     Z key
+        /// </summary>
+        KEY_Z = 0x5A,
+
+        /// <summary>
+        ///     Left Windows key (Microsoft Natural keyboard)
+        /// </summary>
+        LWIN = 0x5B,
+
+        /// <summary>
+        ///     Right Windows key (Natural keyboard)
+        /// </summary>
+        RWIN = 0x5C,
+
+        /// <summary>
+        ///     Applications key (Natural keyboard)
+        /// </summary>
+        APPS = 0x5D,
+
+        /// <summary>
+        ///     Computer Sleep key
+        /// </summary>
+        SLEEP = 0x5F,
+
+        /// <summary>
+        ///     Numeric keypad 0 key
+        /// </summary>
+        NUMPAD0 = 0x60,
+
+        /// <summary>
+        ///     Numeric keypad 1 key
+        /// </summary>
+        NUMPAD1 = 0x61,
+
+        /// <summary>
+        ///     Numeric keypad 2 key
+        /// </summary>
+        NUMPAD2 = 0x62,
+
+        /// <summary>
+        ///     Numeric keypad 3 key
+        /// </summary>
+        NUMPAD3 = 0x63,
+
+        /// <summary>
+        ///     Numeric keypad 4 key
+        /// </summary>
+        NUMPAD4 = 0x64,
+
+        /// <summary>
+        ///     Numeric keypad 5 key
+        /// </summary>
+        NUMPAD5 = 0x65,
+
+        /// <summary>
+        ///     Numeric keypad 6 key
+        /// </summary>
+        NUMPAD6 = 0x66,
+
+        /// <summary>
+        ///     Numeric keypad 7 key
+        /// </summary>
+        NUMPAD7 = 0x67,
+
+        /// <summary>
+        ///     Numeric keypad 8 key
+        /// </summary>
+        NUMPAD8 = 0x68,
+
+        /// <summary>
+        ///     Numeric keypad 9 key
+        /// </summary>
+        NUMPAD9 = 0x69,
+
+        /// <summary>
+        ///     Multiply key
+        /// </summary>
+        MULTIPLY = 0x6A,
+
+        /// <summary>
+        ///     Add key
+        /// </summary>
+        ADD = 0x6B,
+
+        /// <summary>
+        ///     Separator key
+        /// </summary>
+        SEPARATOR = 0x6C,
+
+        /// <summary>
+        ///     Subtract key
+        /// </summary>
+        SUBTRACT = 0x6D,
+
+        /// <summary>
+        ///     Decimal key
+        /// </summary>
+        DECIMAL = 0x6E,
+
+        /// <summary>
+        ///     Divide key
+        /// </summary>
+        DIVIDE = 0x6F,
+
+        /// <summary>
+        ///     F1 key
+        /// </summary>
+        F1 = 0x70,
+
+        /// <summary>
+        ///     F2 key
+        /// </summary>
+        F2 = 0x71,
+
+        /// <summary>
+        ///     F3 key
+        /// </summary>
+        F3 = 0x72,
+
+        /// <summary>
+        ///     F4 key
+        /// </summary>
+        F4 = 0x73,
+
+        /// <summary>
+        ///     F5 key
+        /// </summary>
+        F5 = 0x74,
+
+        /// <summary>
+        ///     F6 key
+        /// </summary>
+        F6 = 0x75,
+
+        /// <summary>
+        ///     F7 key
+        /// </summary>
+        F7 = 0x76,
+
+        /// <summary>
+        ///     F8 key
+        /// </summary>
+        F8 = 0x77,
+
+        /// <summary>
+        ///     F9 key
+        /// </summary>
+        F9 = 0x78,
+
+        /// <summary>
+        ///     F10 key
+        /// </summary>
+        F10 = 0x79,
+
+        /// <summary>
+        ///     F11 key
+        /// </summary>
+        F11 = 0x7A,
+
+        /// <summary>
+        ///     F12 key
+        /// </summary>
+        F12 = 0x7B,
+
+        /// <summary>
+        ///     F13 key
+        /// </summary>
+        F13 = 0x7C,
+
+        /// <summary>
+        ///     F14 key
+        /// </summary>
+        F14 = 0x7D,
+
+        /// <summary>
+        ///     F15 key
+        /// </summary>
+        F15 = 0x7E,
+
+        /// <summary>
+        ///     F16 key
+        /// </summary>
+        F16 = 0x7F,
+
+        /// <summary>
+        ///     F17 key
+        /// </summary>
+        F17 = 0x80,
+
+        /// <summary>
+        ///     F18 key
+        /// </summary>
+        F18 = 0x81,
+
+        /// <summary>
+        ///     F19 key
+        /// </summary>
+        F19 = 0x82,
+
+        /// <summary>
+        ///     F20 key
+        /// </summary>
+        F20 = 0x83,
+
+        /// <summary>
+        ///     F21 key
+        /// </summary>
+        F21 = 0x84,
+
+        /// <summary>
+        ///     F22 key, (PPC only) Key used to lock device.
+        /// </summary>
+        F22 = 0x85,
+
+        /// <summary>
+        ///     F23 key
+        /// </summary>
+        F23 = 0x86,
+
+        /// <summary>
+        ///     F24 key
+        /// </summary>
+        F24 = 0x87,
+
+        /// <summary>
+        ///     NUM LOCK key
+        /// </summary>
+        NUMLOCK = 0x90,
+
+        /// <summary>
+        ///     SCROLL LOCK key
+        /// </summary>
+        SCROLL = 0x91,
+
+        /// <summary>
+        ///     Left SHIFT key
+        /// </summary>
+        LSHIFT = 0xA0,
+
+        /// <summary>
+        ///     Right SHIFT key
+        /// </summary>
+        RSHIFT = 0xA1,
+
+        /// <summary>
+        ///     Left CONTROL key
+        /// </summary>
+        LCONTROL = 0xA2,
+
+        /// <summary>
+        ///     Right CONTROL key
+        /// </summary>
+        RCONTROL = 0xA3,
+
+        /// <summary>
+        ///     Left MENU key
+        /// </summary>
+        LMENU = 0xA4,
+
+        /// <summary>
+        ///     Right MENU key
+        /// </summary>
+        RMENU = 0xA5,
+
+        /// <summary>
+        ///     Windows 2000/XP: Browser Back key
+        /// </summary>
+        BROWSER_BACK = 0xA6,
+
+        /// <summary>
+        ///     Windows 2000/XP: Browser Forward key
+        /// </summary>
+        BROWSER_FORWARD = 0xA7,
+
+        /// <summary>
+        ///     Windows 2000/XP: Browser Refresh key
+        /// </summary>
+        BROWSER_REFRESH = 0xA8,
+
+        /// <summary>
+        ///     Windows 2000/XP: Browser Stop key
+        /// </summary>
+        BROWSER_STOP = 0xA9,
+
+        /// <summary>
+        ///     Windows 2000/XP: Browser Search key
+        /// </summary>
+        BROWSER_SEARCH = 0xAA,
+
+        /// <summary>
+        ///     Windows 2000/XP: Browser Favorites key
+        /// </summary>
+        BROWSER_FAVORITES = 0xAB,
+
+        /// <summary>
+        ///     Windows 2000/XP: Browser Start and Home key
+        /// </summary>
+        BROWSER_HOME = 0xAC,
+
+        /// <summary>
+        ///     Windows 2000/XP: Volume Mute key
+        /// </summary>
+        VOLUME_MUTE = 0xAD,
+
+        /// <summary>
+        ///     Windows 2000/XP: Volume Down key
+        /// </summary>
+        VOLUME_DOWN = 0xAE,
+
+        /// <summary>
+        ///     Windows 2000/XP: Volume Up key
+        /// </summary>
+        VOLUME_UP = 0xAF,
+
+        /// <summary>
+        ///     Windows 2000/XP: Next Track key
+        /// </summary>
+        MEDIA_NEXT_TRACK = 0xB0,
+
+        /// <summary>
+        ///     Windows 2000/XP: Previous Track key
+        /// </summary>
+        MEDIA_PREV_TRACK = 0xB1,
+
+        /// <summary>
+        ///     Windows 2000/XP: Stop Media key
+        /// </summary>
+        MEDIA_STOP = 0xB2,
+
+        /// <summary>
+        ///     Windows 2000/XP: Play/Pause Media key
+        /// </summary>
+        MEDIA_PLAY_PAUSE = 0xB3,
+
+        /// <summary>
+        ///     Windows 2000/XP: Start Mail key
+        /// </summary>
+        LAUNCH_MAIL = 0xB4,
+
+        /// <summary>
+        ///     Windows 2000/XP: Select Media key
+        /// </summary>
+        LAUNCH_MEDIA_SELECT = 0xB5,
+
+        /// <summary>
+        ///     Windows 2000/XP: Start Application 1 key
+        /// </summary>
+        LAUNCH_APP1 = 0xB6,
+
+        /// <summary>
+        ///     Windows 2000/XP: Start Application 2 key
+        /// </summary>
+        LAUNCH_APP2 = 0xB7,
+
+        /// <summary>
+        ///     Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+        OEM_1 = 0xBA,
+
+        /// <summary>
+        ///     Windows 2000/XP: For any country/region, the '+' key
+        /// </summary>
+        OEM_PLUS = 0xBB,
+
+        /// <summary>
+        ///     Windows 2000/XP: For any country/region, the ',' key
+        /// </summary>
+        OEM_COMMA = 0xBC,
+
+        /// <summary>
+        ///     Windows 2000/XP: For any country/region, the '-' key
+        /// </summary>
+        OEM_MINUS = 0xBD,
+
+        /// <summary>
+        ///     Windows 2000/XP: For any country/region, the '.' key
+        /// </summary>
+        OEM_PERIOD = 0xBE,
+
+        /// <summary>
+        ///     Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+        OEM_2 = 0xBF,
+
+        /// <summary>
+        ///     Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+        OEM_3 = 0xC0,
+
+        /// <summary>
+        ///     Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+        OEM_4 = 0xDB,
+
+        /// <summary>
+        ///     Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+        OEM_5 = 0xDC,
+
+        /// <summary>
+        ///     Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+        OEM_6 = 0xDD,
+
+        /// <summary>
+        ///     Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+        OEM_7 = 0xDE,
+
+        /// <summary>
+        ///     Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+        OEM_8 = 0xDF,
+
+        /// <summary>
+        ///     Windows 2000/XP: Either the angle bracket key or the backslash key on the RT 102-key keyboard
+        /// </summary>
+        OEM_102 = 0xE2,
+
+        /// <summary>
+        ///     Windows 95/98/Me, Windows NT 4.0, Windows 2000/XP: IME PROCESS key
+        /// </summary>
+        PROCESSKEY = 0xE5,
+
+        /// <summary>
+        ///     Windows 2000/XP: Used to pass Unicode characters as if they were keystrokes.
+        ///     The VK_PACKET key is the low word of a 32-bit Virtual Key value used for non-keyboard input methods. For more
+        ///     information,
+        ///     see Remark in KEYBDINPUT, SendInput, WM_KEYDOWN, and WM_KEYUP
+        /// </summary>
+        PACKET = 0xE7,
+
+        /// <summary>
+        ///     Attn key
+        /// </summary>
+        ATTN = 0xF6,
+
+        /// <summary>
+        ///     CrSel key
+        /// </summary>
+        CRSEL = 0xF7,
+
+        /// <summary>
+        ///     ExSel key
+        /// </summary>
+        EXSEL = 0xF8,
+
+        /// <summary>
+        ///     Erase EOF key
+        /// </summary>
+        EREOF = 0xF9,
+
+        /// <summary>
+        ///     Play key
+        /// </summary>
+        PLAY = 0xFA,
+
+        /// <summary>
+        ///     Zoom key
+        /// </summary>
+        ZOOM = 0xFB,
+
+        /// <summary>
+        ///     Reserved
+        /// </summary>
+        NONAME = 0xFC,
+
+        /// <summary>
+        ///     PA1 key
+        /// </summary>
+        PA1 = 0xFD,
+
+        /// <summary>
+        ///     Clear key
+        /// </summary>
+        OEM_CLEAR = 0xFE
+    }
+
+    internal enum ScanCodeShort : short
+    {
+        LBUTTON = 0,
+        RBUTTON = 0,
+        CANCEL = 70,
+        MBUTTON = 0,
+        XBUTTON1 = 0,
+        XBUTTON2 = 0,
+        BACK = 14,
+        TAB = 15,
+        CLEAR = 76,
+        RETURN = 28,
+        SHIFT = 42,
+        CONTROL = 29,
+        MENU = 56,
+        PAUSE = 0,
+        CAPITAL = 58,
+        KANA = 0,
+        HANGUL = 0,
+        JUNJA = 0,
+        FINAL = 0,
+        HANJA = 0,
+        KANJI = 0,
+        ESCAPE = 1,
+        CONVERT = 0,
+        NONCONVERT = 0,
+        ACCEPT = 0,
+        MODECHANGE = 0,
+        SPACE = 57,
+        PRIOR = 73,
+        NEXT = 81,
+        END = 79,
+        HOME = 71,
+        LEFT = 75,
+        UP = 72,
+        RIGHT = 77,
+        DOWN = 80,
+        SELECT = 0,
+        PRINT = 0,
+        EXECUTE = 0,
+        SNAPSHOT = 84,
+        INSERT = 82,
+        DELETE = 83,
+        HELP = 99,
+        KEY_0 = 11,
+        KEY_1 = 2,
+        KEY_2 = 3,
+        KEY_3 = 4,
+        KEY_4 = 5,
+        KEY_5 = 6,
+        KEY_6 = 7,
+        KEY_7 = 8,
+        KEY_8 = 9,
+        KEY_9 = 10,
+        KEY_A = 30,
+        KEY_B = 48,
+        KEY_C = 46,
+        KEY_D = 32,
+        KEY_E = 18,
+        KEY_F = 33,
+        KEY_G = 34,
+        KEY_H = 35,
+        KEY_I = 23,
+        KEY_J = 36,
+        KEY_K = 37,
+        KEY_L = 38,
+        KEY_M = 50,
+        KEY_N = 49,
+        KEY_O = 24,
+        KEY_P = 25,
+        KEY_Q = 16,
+        KEY_R = 19,
+        KEY_S = 31,
+        KEY_T = 20,
+        KEY_U = 22,
+        KEY_V = 47,
+        KEY_W = 17,
+        KEY_X = 45,
+        KEY_Y = 21,
+        KEY_Z = 44,
+        LWIN = 91,
+        RWIN = 92,
+        APPS = 93,
+        SLEEP = 95,
+        NUMPAD0 = 82,
+        NUMPAD1 = 79,
+        NUMPAD2 = 80,
+        NUMPAD3 = 81,
+        NUMPAD4 = 75,
+        NUMPAD5 = 76,
+        NUMPAD6 = 77,
+        NUMPAD7 = 71,
+        NUMPAD8 = 72,
+        NUMPAD9 = 73,
+        MULTIPLY = 55,
+        ADD = 78,
+        SEPARATOR = 0,
+        SUBTRACT = 74,
+        DECIMAL = 83,
+        DIVIDE = 53,
+        F1 = 59,
+        F2 = 60,
+        F3 = 61,
+        F4 = 62,
+        F5 = 63,
+        F6 = 64,
+        F7 = 65,
+        F8 = 66,
+        F9 = 67,
+        F10 = 68,
+        F11 = 87,
+        F12 = 88,
+        F13 = 100,
+        F14 = 101,
+        F15 = 102,
+        F16 = 103,
+        F17 = 104,
+        F18 = 105,
+        F19 = 106,
+        F20 = 107,
+        F21 = 108,
+        F22 = 109,
+        F23 = 110,
+        F24 = 118,
+        NUMLOCK = 69,
+        SCROLL = 70,
+        LSHIFT = 42,
+        RSHIFT = 54,
+        LCONTROL = 29,
+        RCONTROL = 29,
+        LMENU = 56,
+        RMENU = 56,
+        BROWSER_BACK = 106,
+        BROWSER_FORWARD = 105,
+        BROWSER_REFRESH = 103,
+        BROWSER_STOP = 104,
+        BROWSER_SEARCH = 101,
+        BROWSER_FAVORITES = 102,
+        BROWSER_HOME = 50,
+        VOLUME_MUTE = 32,
+        VOLUME_DOWN = 46,
+        VOLUME_UP = 48,
+        MEDIA_NEXT_TRACK = 25,
+        MEDIA_PREV_TRACK = 16,
+        MEDIA_STOP = 36,
+        MEDIA_PLAY_PAUSE = 34,
+        LAUNCH_MAIL = 108,
+        LAUNCH_MEDIA_SELECT = 109,
+        LAUNCH_APP1 = 107,
+        LAUNCH_APP2 = 33,
+        OEM_1 = 39,
+        OEM_PLUS = 13,
+        OEM_COMMA = 51,
+        OEM_MINUS = 12,
+        OEM_PERIOD = 52,
+        OEM_2 = 53,
+        OEM_3 = 41,
+        OEM_4 = 26,
+        OEM_5 = 43,
+        OEM_6 = 27,
+        OEM_7 = 40,
+        OEM_8 = 0,
+        OEM_102 = 86,
+        PROCESSKEY = 0,
+        PACKET = 0,
+        ATTN = 0,
+        CRSEL = 0,
+        EXSEL = 0,
+        EREOF = 93,
+        PLAY = 0,
+        ZOOM = 98,
+        NONAME = 0,
+        PA1 = 0,
+        OEM_CLEAR = 0
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct HARDWAREINPUT
+    {
+        internal int UMsg;
+        internal short WParamL;
+        internal short WParamH;
+    }
+}

src/ScreenGrab/ScreenGrab.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <Nullable>enable</Nullable>
+    <UseWPF>true</UseWPF>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <Optimize>False</Optimize>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Dapplo.Windows.User32" Version="1.0.28" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Extensions\" />
+  </ItemGroup>
+
+</Project>

src/ScreenGrab/ScreenGrabView.xaml

@@ -0,0 +1,104 @@
+<Window
+    x:Class="ScreenGrab.ScreenGrabView"
+    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="clr-namespace:ScreenGrab"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    Title="ScreenGrab"
+    Width="800"
+    Height="450"
+    AllowsTransparency="True"
+    Background="Transparent"
+    Closed="Window_Closed"
+    Loaded="Window_Loaded"
+    ResizeMode="NoResize"
+    ShowInTaskbar="False"
+    Topmost="True"
+    Unloaded="Window_Unloaded"
+    WindowStyle="None"
+    mc:Ignorable="d">
+
+    <Grid d:Background="NavajoWhite">
+        <Viewbox>
+            <Image x:Name="BackgroundImage" Stretch="UniformToFill" />
+        </Viewbox>
+        <Canvas
+            x:Name="RegionClickCanvas"
+            Cursor="Cross"
+            MouseDown="RegionClickCanvas_MouseDown"
+            MouseEnter="RegionClickCanvas_MouseEnter"
+            MouseLeave="RegionClickCanvas_MouseLeave"
+            MouseMove="RegionClickCanvas_MouseMove"
+            MouseUp="RegionClickCanvas_MouseUp">
+            <Canvas.Clip>
+                <CombinedGeometry GeometryCombineMode="Exclude">
+                    <CombinedGeometry.Geometry1>
+                        <RectangleGeometry x:Name="FullWindow" />
+                    </CombinedGeometry.Geometry1>
+                    <CombinedGeometry.Geometry2>
+                        <RectangleGeometry x:Name="ClippingGeometry" />
+                    </CombinedGeometry.Geometry2>
+                </CombinedGeometry>
+            </Canvas.Clip>
+            <Canvas.Background>
+                <SolidColorBrush
+                    x:Name="BackgroundBrush"
+                    Opacity="0"
+                    Color="#FF202020" />
+            </Canvas.Background>
+            <!--  Horizontal Line  -->
+            <Line
+                x:Name="HorizontalLine"
+                Stroke="#92caf4"
+                StrokeThickness="1"
+                Visibility="Collapsed" />
+            <!--  Vertical Line  -->
+            <Line
+                x:Name="VerticalLine"
+                Stroke="#92caf4"
+                StrokeThickness="1"
+                Visibility="Collapsed" />
+        </Canvas>
+
+        <Border
+            x:Name="PromptMsg"
+            Margin="15"
+            HorizontalAlignment="Left"
+            VerticalAlignment="Bottom"
+            Background="#424242"
+            BorderBrush="WhiteSmoke"
+            BorderThickness=".6"
+            Opacity="0.9"
+            Visibility="Collapsed">
+            <local:AutoGrid
+                ChildMargin="3"
+                ChildVerticalAlignment="Center"
+                Columns="*, *"
+                RowCount="2"
+                RowHeight="30">
+                <Grid.Resources>
+                    <Style TargetType="StackPanel">
+                        <Setter Property="Orientation" Value="Horizontal" />
+                        <Setter Property="HorizontalAlignment" Value="Right" />
+                    </Style>
+                    <Style TargetType="TextBlock">
+                        <Setter Property="Foreground" Value="White" />
+                        <Setter Property="FontSize" Value="16" />
+                        <Setter Property="HorizontalAlignment" Value="Left" />
+
+                    </Style>
+                </Grid.Resources>
+                <StackPanel>
+                    <local:UcCharacter DisplayChar="Shift" />
+                    <local:UcCharacter DisplayChar="🖱" />
+                </StackPanel>
+                <TextBlock Text="移动选区" />
+                <StackPanel>
+                    <local:UcCharacter DisplayChar="F" />
+                </StackPanel>
+                <TextBlock x:Name="FreezeTb" Text="取消冻结窗口" />
+            </local:AutoGrid>
+        </Border>
+    </Grid>
+</Window>

src/ScreenGrab/ScreenGrabView.xaml.cs

@@ -0,0 +1,442 @@
+using System.Drawing;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using Dapplo.Windows.User32;
+using ScreenGrab.Extensions;
+using ScreenGrab.Utilities;
+using Color = System.Windows.Media.Color;
+using Point = System.Windows.Point;
+using Size = System.Windows.Size;
+
+namespace ScreenGrab;
+
+/// <summary>
+///     Extracted from the project <see href="https://github.com/TheJoeFin/Text-Grab" />
+/// </summary>
+public partial class ScreenGrabView
+{
+    #region Constructors
+
+    public ScreenGrabView(Action<Bitmap>? action, bool isAuxiliary = false)
+    {
+        InitializeComponent();
+        _onImageCaptured = action;
+        _isAuxiliary = isAuxiliary;
+    }
+
+    #endregion Constructors
+
+    #region Properties
+
+    public Action? OnGrabClose { get; set; }
+    private DisplayInfo? CurrentScreen { get; set; }
+
+    #endregion Properties
+
+    #region Fields
+
+    private Point _clickedPoint;
+    private DpiScale? _dpiScale;
+    private bool _isSelecting;
+    private bool _isShiftDown;
+    private double _selectLeft;
+    private double _selectTop;
+    private Point _shiftPoint;
+    private double _xShiftDelta;
+    private double _yShiftDelta;
+    private Point _promptMsgTopLeft;
+    private Point _promptMsgBottomRight;
+    private bool _isFreezeHandle;
+
+    private readonly Border _selectBorder = new();
+    private const double SelectBorderThickness = 2;
+    private readonly Color _borderColor = Color.FromArgb(255, 146, 202, 244);
+
+    private readonly Action<Bitmap>? _onImageCaptured;
+    private readonly bool _isAuxiliary;
+
+    #endregion Fields
+
+    #region Window Events
+
+    private void Window_Closed(object? sender, EventArgs e)
+    {
+        InputMethodOperate(false);
+
+        Close();
+
+        GC.Collect();
+    }
+
+    private void Window_Loaded(object sender, RoutedEventArgs e)
+    {
+        WindowState = WindowState.Maximized;
+        FullWindow.Rect = new Rect(0, 0, Width, Height);
+        KeyDown += ScreenGrab_KeyDown;
+        KeyUp += ScreenGrab_KeyUp;
+
+        SetImageToBackground();
+
+#if DEBUG
+        Topmost = false;
+#endif
+        InputMethodOperate();
+
+        if (this.IsMouseInWindow())
+            SetPromptMsgVisibility(true);
+
+        if (!_isAuxiliary) return;
+        (HorizontalLine.X1, VerticalLine.Y1, (HorizontalLine.X2, VerticalLine.Y2)) = (0, 0, this.GetWidthHeight());
+
+        // Set the Auxiliary to be visible when the mouse in the window
+        if (this.IsMouseInWindow())
+            SetAuxiliaryVisibility(true);
+    }
+
+    private void Window_Unloaded(object sender, RoutedEventArgs e)
+    {
+        FreezeBgImage();
+        BackgroundImage.UpdateLayout();
+        CurrentScreen = null;
+        _dpiScale = null;
+
+        Loaded -= Window_Loaded;
+        Unloaded -= Window_Unloaded;
+
+        RegionClickCanvas.MouseDown -= RegionClickCanvas_MouseDown;
+        RegionClickCanvas.MouseMove -= RegionClickCanvas_MouseMove;
+        RegionClickCanvas.MouseUp -= RegionClickCanvas_MouseUp;
+
+        KeyDown -= ScreenGrab_KeyDown;
+        KeyUp -= ScreenGrab_KeyUp;
+    }
+
+    private void ScreenGrab_KeyDown(object sender, KeyEventArgs e)
+    {
+        switch (e.Key)
+        {
+            case Key.Escape:
+                CloseAllScreenGrabs();
+                break;
+            case Key.F:
+                FreezeUnfreezeAllScreenGrabs();
+                break;
+        }
+    }
+
+    private void ScreenGrab_KeyUp(object sender, KeyEventArgs e)
+    {
+        switch (e.Key)
+        {
+            case Key.LeftShift:
+            case Key.RightShift:
+                _isShiftDown = false;
+                _clickedPoint = new Point(_clickedPoint.X + _xShiftDelta, _clickedPoint.Y + _yShiftDelta);
+                break;
+        }
+    }
+
+    private void SetImageToBackground()
+    {
+        FreezeBgImage();
+        BackgroundImage.Source = this.GetWindowBoundsImage();
+        BackgroundBrush.Opacity = 0.2;
+    }
+
+    private async void FreezeUnfreeze()
+    {
+        _isFreezeHandle = true;
+        if (BackgroundImage.Source == null)
+        {
+            if (_isAuxiliary)
+                SetAuxiliaryVisibility(false);
+
+            SetPromptMsgVisibility(false);
+            BackgroundBrush.Opacity = 0;
+            await Task.Delay(150);
+            SetImageToBackground();
+
+            if (this.IsMouseInWindow())
+            {
+                SetAuxiliaryVisibility(_isAuxiliary);
+                SetPromptMsgVisibility(true);
+            }
+
+            // 刷新提示词
+            FreezeTb.Text = "取消冻结窗口";
+        }
+        else
+        {
+            FreezeBgImage();
+            // 刷新提示词
+            FreezeTb.Text = "冻结窗口";
+        }
+        _isFreezeHandle = false;
+    }
+
+    private void CloseAllScreenGrabs()
+    {
+        foreach (var window in Application.Current.Windows)
+            if (window is ScreenGrabView sgv)
+                sgv.Close();
+        OnGrabClose?.Invoke();
+    }
+
+    private void FreezeUnfreezeAllScreenGrabs()
+    {
+        foreach (var window in Application.Current.Windows)
+            if (window is ScreenGrabView sgv)
+                sgv.FreezeUnfreeze();
+    }
+
+    private void FreezeBgImage()
+    {
+        BackgroundImage.Source?.Freeze();
+        BackgroundImage.Source = null;
+    }
+
+    private void SetAuxiliaryVisibility(bool isVisible)
+    {
+        var setVisibility = isVisible ? Visibility.Visible : Visibility.Collapsed;
+        if (HorizontalLine.Visibility == setVisibility && VerticalLine.Visibility == setVisibility)
+            return;
+        HorizontalLine.Visibility = setVisibility;
+        VerticalLine.Visibility = setVisibility;
+    }
+
+    private void SetPromptMsgVisibility(bool isVisible)
+    {
+        var setVisibility = isVisible ? Visibility.Visible : Visibility.Collapsed;
+        if (PromptMsg.Visibility == setVisibility)
+            return;
+
+        PromptMsg.Visibility = setVisibility;
+    }
+
+    #endregion
+
+    #region Mouse Events
+
+    private void RegionClickCanvas_MouseLeave(object sender, MouseEventArgs e)
+    {
+        SetAuxiliaryVisibility(false);
+        SetPromptMsgVisibility(false);
+    }
+
+    private void RegionClickCanvas_MouseEnter(object sender, MouseEventArgs e)
+    {
+        SetAuxiliaryVisibility(_isAuxiliary);
+        SetPromptMsgVisibility(true);
+
+        // 获取 PromptMsg 控件的边界
+        _promptMsgTopLeft = PromptMsg.TranslatePoint(new Point(0, 0), this);
+        _promptMsgBottomRight =
+            PromptMsg.TranslatePoint(new Point(PromptMsg.ActualWidth, PromptMsg.ActualHeight), this);
+    }
+
+    private void RegionClickCanvas_MouseDown(object sender, MouseButtonEventArgs e)
+    {
+        // Right click to close
+        if (e.RightButton == MouseButtonState.Pressed)
+        {
+            CloseAllScreenGrabs();
+            return;
+        }
+
+        _isSelecting = true;
+        SetAuxiliaryVisibility(false);
+        SetPromptMsgVisibility(false);
+        RegionClickCanvas.CaptureMouse();
+        CursorClipper.ClipCursor(this);
+        _clickedPoint = e.GetPosition(this);
+        _selectBorder.Height = 2;
+        _selectBorder.Width = 2;
+
+        _dpiScale = VisualTreeHelper.GetDpi(this);
+
+        try
+        {
+            RegionClickCanvas.Children.Remove(_selectBorder);
+        }
+        catch (Exception)
+        {
+            // ignored
+        }
+
+        _selectBorder.BorderThickness = new Thickness(SelectBorderThickness);
+        _selectBorder.BorderBrush = new SolidColorBrush(_borderColor);
+        _ = RegionClickCanvas.Children.Add(_selectBorder);
+        Canvas.SetLeft(_selectBorder, _clickedPoint.X);
+        Canvas.SetTop(_selectBorder, _clickedPoint.Y);
+
+        // Initialize ClippingGeometry.Rect with a valid Rect
+        ClippingGeometry.Rect = new Rect(_clickedPoint, new Size(0, 0));
+
+        WindowUtilities.GetMousePosition(out var mousePoint);
+        foreach (var screen in DisplayInfo.AllDisplayInfos)
+        {
+            var bound = screen.ScaledBounds();
+            if (bound.Contains(mousePoint))
+                CurrentScreen = screen;
+        }
+    }
+
+    private void RegionClickCanvas_MouseMove(object sender, MouseEventArgs e)
+    {
+        if (_isFreezeHandle) return;
+
+        var movingPoint = e.GetPosition(this);
+
+        if (!_isSelecting)
+        {
+            // 检查鼠标是否在 PromptMsg 控件区域内
+            var isMouseInPromptMsg = movingPoint.X >= _promptMsgTopLeft.X && movingPoint.X <= _promptMsgBottomRight.X &&
+                                     movingPoint.Y >= _promptMsgTopLeft.Y && movingPoint.Y <= _promptMsgBottomRight.Y;
+
+            SetPromptMsgVisibility(!isMouseInPromptMsg);
+
+            // Determine whether to update auxiliary line information based on configuration
+            if (!_isAuxiliary) return;
+
+            // Update the horizontal line to match the mouse Y position
+            HorizontalLine.Y1 = HorizontalLine.Y2 = movingPoint.Y;
+
+            // Update the vertical line to match the mouse X position
+            VerticalLine.X1 = VerticalLine.X2 = movingPoint.X;
+            return;
+        }
+
+        if (Keyboard.Modifiers == ModifierKeys.Shift)
+        {
+            PanSelection(movingPoint);
+            return;
+        }
+
+        _isShiftDown = false;
+
+        var left = Math.Min(_clickedPoint.X, movingPoint.X);
+        var top = Math.Min(_clickedPoint.Y, movingPoint.Y);
+
+        _selectBorder.Height = Math.Max(_clickedPoint.Y, movingPoint.Y) - top;
+        _selectBorder.Width = Math.Max(_clickedPoint.X, movingPoint.X) - left;
+        _selectBorder.Height += SelectBorderThickness;
+        _selectBorder.Width += SelectBorderThickness;
+
+        ClippingGeometry.Rect = new Rect(
+            new Point(left, top),
+            new Size(_selectBorder.Width - SelectBorderThickness, _selectBorder.Height - SelectBorderThickness));
+        Canvas.SetLeft(_selectBorder, left - 1);
+        Canvas.SetTop(_selectBorder, top - 1);
+    }
+
+    private void RegionClickCanvas_MouseUp(object sender, MouseButtonEventArgs e)
+    {
+        if (!_isSelecting || _dpiScale is null)
+            return;
+
+        _isSelecting = false;
+        CurrentScreen = null;
+        CursorClipper.UnClipCursor();
+        RegionClickCanvas.ReleaseMouseCapture();
+        ClippingGeometry.Rect = new Rect(new Point(0, 0), new Size(0, 0));
+
+        // Get the scaled dimensions of the selection border except the border thickness
+        var xDimScaled = (Canvas.GetLeft(_selectBorder) + SelectBorderThickness) * _dpiScale.Value.DpiScaleX;
+        var yDimScaled = (Canvas.GetTop(_selectBorder) + SelectBorderThickness) * _dpiScale.Value.DpiScaleY;
+
+        // Get the scaled dimensions of the selection border except the border thickness
+        Rectangle regionScaled = new(
+            (int)xDimScaled,
+            (int)yDimScaled,
+            (int)((_selectBorder.Width - 2 * SelectBorderThickness) * _dpiScale.Value.DpiScaleX),
+            (int)((_selectBorder.Height - 2 * SelectBorderThickness) * _dpiScale.Value.DpiScaleY));
+
+        try
+        {
+            RegionClickCanvas.Children.Remove(_selectBorder);
+        }
+        catch
+        {
+            // ignored
+        }
+
+        var absPosPoint = this.GetAbsolutePosition();
+
+        var thisCorrectedLeft = (int)absPosPoint.X + regionScaled.Left;
+        var thisCorrectedTop = (int)absPosPoint.Y + regionScaled.Top;
+
+        var correctedRegion = regionScaled with { X = thisCorrectedLeft, Y = thisCorrectedTop };
+        var bitmap = correctedRegion.GetRegionOfScreenAsBitmap();
+        CloseAllScreenGrabs();
+
+        _onImageCaptured?.Invoke(bitmap);
+    }
+
+    private void PanSelection(Point movingPoint)
+    {
+        if (!_isShiftDown)
+        {
+            _shiftPoint = movingPoint;
+            _selectLeft = Canvas.GetLeft(_selectBorder);
+            _selectTop = Canvas.GetTop(_selectBorder);
+        }
+
+        _isShiftDown = true;
+        _xShiftDelta = movingPoint.X - _shiftPoint.X;
+        _yShiftDelta = movingPoint.Y - _shiftPoint.Y;
+
+        var leftValue = _selectLeft + _xShiftDelta;
+        var topValue = _selectTop + _yShiftDelta;
+
+        if (CurrentScreen is not null && _dpiScale is not null)
+        {
+            double currentScreenLeft = 0;
+            double currentScreenTop = 0;
+            var currentScreenRight = CurrentScreen.Bounds.Width / _dpiScale.Value.DpiScaleX;
+            var currentScreenBottom = CurrentScreen.Bounds.Height / _dpiScale.Value.DpiScaleY;
+
+            leftValue = Clamp(leftValue, currentScreenLeft, currentScreenRight - _selectBorder.Width);
+            topValue = Clamp(topValue, currentScreenTop, currentScreenBottom - _selectBorder.Height);
+        }
+
+        ClippingGeometry.Rect = new Rect(
+            new Point(leftValue, topValue),
+            new Size(_selectBorder.Width - 2, _selectBorder.Height - 2));
+        Canvas.SetLeft(_selectBorder, leftValue - 1);
+        Canvas.SetTop(_selectBorder, topValue - 1);
+    }
+
+    private double Clamp(double value, double min, double max)
+    {
+#if NETFRAMEWORK
+        if (value < min) return min;
+        if (value > max) return max;
+        return value;
+#else
+        return Math.Clamp(value, min, max);
+#endif
+    }
+
+    private void InputMethodOperate(bool isDisableInputMethod = true)
+    {
+        if (isDisableInputMethod)
+        {
+            // 禁用输入法编辑器
+            InputMethod.SetIsInputMethodEnabled(this, false);
+            // 设置输入法状态为英文
+            InputMethod.SetPreferredImeState(this, InputMethodState.Off);
+            // 设置为英文输入模式
+            InputMethod.SetPreferredImeConversionMode(this, ImeConversionModeValues.Alphanumeric);
+        }
+        else
+        {
+            // 恢复输入法状态
+            InputMethod.SetIsInputMethodEnabled(this, true);
+            InputMethod.SetPreferredImeState(this, InputMethodState.DoNotCare);
+        }
+    }
+
+    #endregion
+}

src/ScreenGrab/ScreenGrabber.cs

@@ -0,0 +1,51 @@
+using System.Drawing;
+using System.Windows;
+using Dapplo.Windows.User32;
+using ScreenGrab.Extensions;
+
+namespace ScreenGrab;
+
+public abstract class ScreenGrabber
+{
+    public static bool IsCapturing { get; private set; }
+
+    public static Action<Bitmap>? OnCaptured { get; set; }
+
+    public static void Capture(bool isAuxiliary = false)
+    {
+        if (IsCapturing) return;
+
+        IsCapturing = true;
+
+        var allDisplayInfos = DisplayInfo.AllDisplayInfos;
+        var allScreenGrab = Application.Current.Windows.OfType<ScreenGrabView>().ToList();
+        var numberOfScreenGrabWindowsToCreate = allDisplayInfos.Length - allScreenGrab.Count;
+
+        for (var i = 0; i < numberOfScreenGrabWindowsToCreate; i++)
+        {
+            var view = new ScreenGrabView(OnCaptured, isAuxiliary)
+            {
+                OnGrabClose = () => IsCapturing = false
+            };
+            allScreenGrab.Add(view);
+        }
+
+        const double sideLength = 40;
+
+        foreach (var (displayInfo, screenGrab) in allDisplayInfos.Zip(allScreenGrab,
+                     (displayInfo, screenGrab) => (displayInfo, screenGrab)))
+        {
+            screenGrab.WindowStartupLocation = WindowStartupLocation.Manual;
+            screenGrab.Width = sideLength;
+            screenGrab.Height = sideLength;
+            screenGrab.WindowState = WindowState.Normal;
+
+            var screenCenterPoint = displayInfo.ScaledCenterPoint();
+            screenGrab.Left = screenCenterPoint.X - sideLength / 2;
+            screenGrab.Top = screenCenterPoint.Y - sideLength / 2;
+
+            screenGrab.Show();
+            screenGrab.Activate();
+        }
+    }
+}

src/ScreenGrab/UcCharacter.xaml

@@ -0,0 +1,26 @@
+<UserControl
+    d:DesignHeight="450"
+    d:DesignWidth="800"
+    mc:Ignorable="d"
+    x:Class="ScreenGrab.UcCharacter"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    <Border
+        BorderBrush="White"
+        BorderThickness="1"
+        Margin="2,0"
+        MinWidth="26"
+        Padding="3">
+        <Border.Resources>
+            <Style TargetType="TextBlock">
+                <Setter Property="Foreground" Value="White" />
+                <Setter Property="FontSize" Value="14" />
+                <Setter Property="HorizontalAlignment" Value="Center" />
+                <Setter Property="VerticalAlignment" Value="Center" />
+            </Style>
+        </Border.Resources>
+        <TextBlock Text="{Binding DisplayChar, RelativeSource={RelativeSource AncestorType=UserControl}}" x:Name="CharacterText" />
+    </Border>
+</UserControl>

src/ScreenGrab/UcCharacter.xaml.cs

@@ -0,0 +1,25 @@
+using System.Windows;
+using System.Windows.Controls;
+
+namespace ScreenGrab;
+
+public partial class UcCharacter : UserControl
+{
+    public static readonly DependencyProperty DisplayCharProperty =
+        DependencyProperty.Register(
+            "DisplayChar",
+            typeof(string),
+            typeof(UcCharacter),
+            new PropertyMetadata(string.Empty));
+
+    public UcCharacter()
+    {
+        InitializeComponent();
+    }
+
+    public string DisplayChar
+    {
+        get => (string)GetValue(DisplayCharProperty);
+        set => SetValue(DisplayCharProperty, value);
+    }
+}

src/ScreenGrab/Utilities/CursorClipper.cs

@@ -0,0 +1,49 @@
+using System.Windows;
+
+namespace ScreenGrab.Utilities;
+
+/// <summary>
+///     Functions to constrain the mouse cursor (typically used when dragging)
+/// </summary>
+public static class CursorClipper
+{
+    /// <summary>
+    ///     Constrain mouse cursor to the area of the specified UI element.
+    /// </summary>
+    /// <param name="element">Target UI element.</param>
+    /// <returns>True on success.</returns>
+    public static bool ClipCursor(FrameworkElement element)
+    {
+        const double dpi96 = 96.0;
+
+        var topLeft = element.PointToScreen(new Point(0, 0));
+
+        var source = PresentationSource.FromVisual(element);
+        if (source?.CompositionTarget == null) return false;
+
+        var dpiX = dpi96 * source.CompositionTarget.TransformToDevice.M11;
+        var dpiY = dpi96 * source.CompositionTarget.TransformToDevice.M22;
+
+        var width = (int)((element.ActualWidth + 1) * dpiX / dpi96);
+        var height = (int)((element.ActualHeight + 1) * dpiY / dpi96);
+
+        var rect = new OSInterop.RECT
+        {
+            left = (int)topLeft.X,
+            top = (int)topLeft.Y,
+            right = (int)topLeft.X + width,
+            bottom = (int)topLeft.Y + height
+        };
+
+        return OSInterop.ClipCursor(ref rect);
+    }
+
+    /// <summary>
+    ///     Remove any mouse cursor constraint.
+    /// </summary>
+    /// <returns>True on success.</returns>
+    public static bool UnClipCursor()
+    {
+        return OSInterop.ClipCursor(IntPtr.Zero);
+    }
+}

src/ScreenGrab/Utilities/WindowUtilities.cs

@@ -0,0 +1,68 @@
+using System.Runtime.InteropServices;
+using System.Windows;
+using System.Windows.Media;
+using ScreenGrab.Extensions;
+
+namespace ScreenGrab.Utilities;
+
+public static class WindowUtilities
+{
+    public static bool GetMousePosition(out Point mousePosition)
+    {
+        if (GetCursorPos(out var point))
+        {
+            mousePosition = new Point(point.X, point.Y);
+            return true;
+        }
+
+        mousePosition = default;
+        return false;
+    }
+
+    public static bool IsMouseInWindow(this Window window)
+    {
+        GetMousePosition(out var mousePosition);
+
+        var dpi = VisualTreeHelper.GetDpi(window);
+        var absPosPoint = window.GetAbsolutePosition();
+        Rect windowRect = new(absPosPoint.X, absPosPoint.Y,
+            window.ActualWidth * dpi.DpiScaleX,
+            window.ActualHeight * dpi.DpiScaleY);
+        return windowRect.Contains(mousePosition);
+    }
+
+    #region Dll Import
+
+    [DllImport("user32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool GetCursorPos(out POINT lpPoint);
+
+    #endregion
+
+    #region Dll Helper Structures
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct POINT
+    {
+        /// <summary>
+        ///     x coordinate of point.
+        /// </summary>
+        public int X;
+
+        /// <summary>
+        ///     y coordinate of point.
+        /// </summary>
+        public int Y;
+
+        /// <summary>
+        ///     Construct a point of coordinates (x,y).
+        /// </summary>
+        public POINT(int x, int y)
+        {
+            X = x;
+            Y = y;
+        }
+    }
+
+    #endregion
+}

src/ScreenGrab/Utilities/WrappingStream.cs

@@ -0,0 +1,252 @@
+using System.IO;
+using ScreenGrab.Models;
+
+namespace ScreenGrab.Utilities;
+
+/// <summary>
+///     A <see cref="Stream" /> that wraps another stream. The major feature of <see cref="WrappingStream" /> is that it
+///     does not dispose the
+///     underlying stream when it is disposed; this is useful when using classes such as <see cref="BinaryReader" /> and
+///     <see cref="System.Security.Cryptography.CryptoStream" /> that take ownership of the stream passed to their
+///     constructors.
+/// </summary>
+public class WrappingStream : Stream
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="WrappingStream" /> class.
+    /// </summary>
+    /// <param name="streamBase">The wrapped stream.</param>
+    public WrappingStream(Stream streamBase)
+    {
+        // check parameters
+
+        if (streamBase == null)
+            throw new ArgumentNullException("streamBase");
+        WrappedStream = streamBase;
+    }
+
+    /// <summary>
+    ///     Gets a value indicating whether the current stream supports reading.
+    /// </summary>
+    /// <returns><c>true</c> if the stream supports reading; otherwise, <c>false</c>.</returns>
+    public override bool CanRead => WrappedStream == null ? false : WrappedStream.CanRead;
+
+    /// <summary>
+    ///     Gets a value indicating whether the current stream supports seeking.
+    /// </summary>
+    /// <returns><c>true</c> if the stream supports seeking; otherwise, <c>false</c>.</returns>
+    public override bool CanSeek => WrappedStream == null ? false : WrappedStream.CanSeek;
+
+    /// <summary>
+    ///     Gets a value indicating whether the current stream supports writing.
+    /// </summary>
+    /// <returns><c>true</c> if the stream supports writing; otherwise, <c>false</c>.</returns>
+    public override bool CanWrite => WrappedStream == null ? false : WrappedStream.CanWrite;
+
+    /// <summary>
+    ///     Gets the length in bytes of the stream.
+    /// </summary>
+    public override long Length
+    {
+        get
+        {
+            ThrowIfDisposed();
+            if (WrappedStream is not null)
+                return WrappedStream.Length;
+
+            return 0;
+        }
+    }
+
+    /// <summary>
+    ///     Gets or sets the position within the current stream.
+    /// </summary>
+    public override long Position
+    {
+        get
+        {
+            ThrowIfDisposed();
+            if (WrappedStream is not null)
+                return WrappedStream.Position;
+            return 0;
+        }
+        set
+        {
+            ThrowIfDisposed();
+            if (WrappedStream is not null)
+                WrappedStream.Position = value;
+        }
+    }
+
+    /// <summary>
+    ///     Gets the wrapped stream.
+    /// </summary>
+    /// <value>The wrapped stream.</value>
+    protected Stream? WrappedStream { get; private set; }
+
+    /// <summary>
+    ///     Begins an asynchronous read operation.
+    /// </summary>
+    public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
+    {
+        ThrowIfDisposed();
+
+        if (WrappedStream is not null && callback is not null && state is not null)
+            return WrappedStream.BeginRead(buffer, offset, count, callback, state);
+
+        return new NullAsyncResult();
+    }
+
+    /// <summary>
+    ///     Begins an asynchronous write operation.
+    /// </summary>
+    public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback? callback,
+        object? state)
+    {
+        ThrowIfDisposed();
+
+        if (WrappedStream is not null && callback is not null && state is not null)
+            return WrappedStream.BeginWrite(buffer, offset, count, callback, state);
+
+        return new NullAsyncResult();
+    }
+
+    /// <summary>
+    ///     Waits for the pending asynchronous read to complete.
+    /// </summary>
+    public override int EndRead(IAsyncResult asyncResult)
+    {
+        ThrowIfDisposed();
+
+        if (WrappedStream is not null)
+            return WrappedStream.EndRead(asyncResult);
+
+        return 0;
+    }
+
+    /// <summary>
+    ///     Ends an asynchronous write operation.
+    /// </summary>
+    public override void EndWrite(IAsyncResult asyncResult)
+    {
+        ThrowIfDisposed();
+
+        if (WrappedStream is not null)
+            WrappedStream.EndWrite(asyncResult);
+    }
+
+    /// <summary>
+    ///     Clears all buffers for this stream and causes any buffered data to be written to the underlying device.
+    /// </summary>
+    public override void Flush()
+    {
+        ThrowIfDisposed();
+
+        if (WrappedStream is not null)
+            WrappedStream.Flush();
+    }
+
+    /// <summary>
+    ///     Reads a sequence of bytes from the current stream and advances the position
+    ///     within the stream by the number of bytes read.
+    /// </summary>
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        ThrowIfDisposed();
+
+        if (WrappedStream is not null)
+            return WrappedStream.Read(buffer, offset, count);
+        return 0;
+    }
+
+    /// <summary>
+    ///     Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end
+    ///     of the stream.
+    /// </summary>
+    public override int ReadByte()
+    {
+        ThrowIfDisposed();
+
+        if (WrappedStream is not null)
+            return WrappedStream.ReadByte();
+        return 0;
+    }
+
+    /// <summary>
+    ///     Sets the position within the current stream.
+    /// </summary>
+    /// <param name="offset">A byte offset relative to the <paramref name="origin" /> parameter.</param>
+    /// <param name="origin">
+    ///     A value of type <see cref="T:System.IO.SeekOrigin" /> indicating the reference point used to
+    ///     obtain the new position.
+    /// </param>
+    /// <returns>The new position within the current stream.</returns>
+    public override long Seek(long offset, SeekOrigin origin)
+    {
+        ThrowIfDisposed();
+
+        if (WrappedStream is not null)
+            return WrappedStream.Seek(offset, origin);
+        return 0;
+    }
+
+    /// <summary>
+    ///     Sets the length of the current stream.
+    /// </summary>
+    /// <param name="value">The desired length of the current stream in bytes.</param>
+    public override void SetLength(long value)
+    {
+        ThrowIfDisposed();
+
+        if (WrappedStream is not null)
+            WrappedStream.SetLength(value);
+    }
+
+    /// <summary>
+    ///     Writes a sequence of bytes to the current stream and advances the current position
+    ///     within this stream by the number of bytes written.
+    /// </summary>
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+        ThrowIfDisposed();
+
+        if (WrappedStream is not null)
+            WrappedStream.Write(buffer, offset, count);
+    }
+
+    /// <summary>
+    ///     Writes a byte to the current position in the stream and advances the position within the stream by one byte.
+    /// </summary>
+    public override void WriteByte(byte value)
+    {
+        ThrowIfDisposed();
+
+        if (WrappedStream is not null)
+            WrappedStream.WriteByte(value);
+    }
+
+    /// <summary>
+    ///     Releases the unmanaged resources used by the <see cref="WrappingStream" /> and optionally releases the managed
+    ///     resources.
+    /// </summary>
+    /// <param name="disposing">
+    ///     true to release both managed and unmanaged resources; false to release only unmanaged
+    ///     resources.
+    /// </param>
+    protected override void Dispose(bool disposing)
+    {
+        // doesn't close the base stream, but just prevents access to it through this WrappingStream
+
+        if (disposing)
+            WrappedStream = null;
+        base.Dispose(disposing);
+    }
+
+    private void ThrowIfDisposed()
+    {
+        // throws an ObjectDisposedException if this object has been disposed
+
+        if (WrappedStream == null)
+            throw new ObjectDisposedException(GetType().Name);
+    }
+}

src/WeChatOcrCpp/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:conda",
+    "python-envs.defaultPackageManager": "ms-python.python:conda",
+    "python-envs.pythonProjects": []
+}

src/WpfEditor/ComicOcr.cs

@@ -21,13 +21,7 @@ using Formatting = Newtonsoft.Json.Formatting;
 namespace WpfEditor
 {
 
-    // see huggingface\imradv3\src\WeChatOcrCpp\ocr_aliyunV2.js
-    // see huggingface\imradv3\src\WeChatOcrCpp\ocr_aliyun.py
-
-    // // https://help.aliyun.com/zh/ocr/developer-reference/api-ocr-api-2021-07-07-recognizeadvanced#api-detail-35
-    // https://github.com/aliyun/alibabacloud-csharp-sdk
-    // https://github.com/aliyun/alibabacloud-csharp-sdk/blob/master/ocr-api-20210707/core/Client.cs
-    // dotnet add package AlibabaCloud.SDK.Ocr-api20210707
+    // see huggingface/comicocr/main.py
 
     public static class ComicOcr
     {

src/WpfEditor/MainWindow.xaml.cs

@@ -38,6 +38,9 @@ using Window = System.Windows.Window;
         # 图片导出
     see huggingface/project/ocr/ocrClient
         # 图片压缩
+    see https://github.com/lellid/LediReader
+        # epub wpf显示
+
 */
 
 namespace WpfEditor