借助网络配置,控制Modbus工具的日志显示,避免卡死界面
智能大石头 authored at 2021-12-11 22:09:19
9.96 KiB
XCoder
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using NewLife;
using NewLife.Log;

namespace NewLife.XCoder.Services;

/// <summary>热键组合</summary>
/// <param name="Control">是否含 Ctrl</param>
/// <param name="Alt">是否含 Alt</param>
/// <param name="Shift">是否含 Shift</param>
/// <param name="Win">是否含 Win 键</param>
/// <param name="Key">主键(大写,如 A、F5、SPACE)</param>
public sealed record HotkeyGesture(Boolean Control, Boolean Alt, Boolean Shift, Boolean Win, String Key)
{
    /// <summary>规范化的显示文本,如 Ctrl+Alt+S</summary>
    public override String ToString()
    {
        var sb = new StringBuilder();
        if (Control) sb.Append("Ctrl+");
        if (Alt) sb.Append("Alt+");
        if (Shift) sb.Append("Shift+");
        if (Win) sb.Append("Win+");
        sb.Append(Key);

        return sb.ToString();
    }
}

/// <summary>全局热键(Windows 专用,用线程级 RegisterHotKey 实现)</summary>
/// <remarks>
/// 思路:另起一个后台线程做消息循环,在该线程上以 <c>hWnd = IntPtr.Zero</c> 注册热键,
/// 这样 WM_HOTKEY 直接投递到该线程的消息队列,<b>不需要子类化 Avalonia 窗口的 WndProc</b>,
/// 不会影响界面自身的输入与渲染。非 Windows 平台注册直接返回 false。
/// </remarks>
public sealed class GlobalHotkeyService : IDisposable
{
    private Thread? _thread;
    private UInt32 _threadId;
    private Int32 _id;
    private readonly ManualResetEventSlim _ready = new(false);
    private Boolean _registered;
    private Boolean _disposed;

    /// <summary>当前平台是否支持</summary>
    public static Boolean IsSupported => OperatingSystem.IsWindows();

    /// <summary>解析热键文本</summary>
    /// <param name="text">如 "Ctrl+Alt+S"、"alt+f5"、"Shift+Win+D"</param>
    /// <returns>解析结果</returns>
    /// <exception cref="ArgumentException">格式非法或缺少主键</exception>
    public static HotkeyGesture Parse(String? text)
    {
        if (text.IsNullOrWhiteSpace()) throw new ArgumentException("热键不能为空", nameof(text));

        var control = false;
        var alt = false;
        var shift = false;
        var win = false;
        String? key = null;

        foreach (var raw in text!.Split(['+', '-'], StringSplitOptions.RemoveEmptyEntries))
        {
            var part = raw.Trim();
            switch (part.ToLowerInvariant())
            {
                case "ctrl":
                case "control":
                    control = true;
                    break;
                case "alt":
                    alt = true;
                    break;
                case "shift":
                    shift = true;
                    break;
                case "win":
                case "windows":
                case "meta":
                    win = true;
                    break;
                default:
                    if (key != null) throw new ArgumentException($"热键只能有一个主键:{text}", nameof(text));
                    key = part.ToUpperInvariant();
                    break;
            }
        }

        if (key.IsNullOrEmpty()) throw new ArgumentException($"热键缺少主键:{text}", nameof(text));
        if (VirtualKeyOf(key!) == 0) throw new ArgumentException($"不支持的主键:{key}", nameof(text));
        if (!control && !alt && !shift && !win) throw new ArgumentException($"热键至少需要一个修饰键:{text}", nameof(text));

        return new HotkeyGesture(control, alt, shift, win, key!);
    }

    /// <summary>注册全局热键</summary>
    /// <param name="text">热键文本,如 "Ctrl+Alt+S"</param>
    /// <param name="callback">按下时回调(可能不在 UI 线程)</param>
    /// <returns>注册成功返回 true;平台不支持、被占用或已在运行时返回 false</returns>
    public Boolean Register(String? text, Action callback)
    {
        if (_disposed) return false;
        if (!IsSupported) return false;
        if (_registered) return false;

        HotkeyGesture gesture;
        try
        {
            gesture = Parse(text);
        }
        catch (ArgumentException ex)
        {
            XTrace.WriteLine($"热键无效:{ex.Message}");
            return false;
        }

        if (callback == null) throw new ArgumentNullException(nameof(callback));

        var modifiers = 0u;
        if (gesture.Control) modifiers |= MOD_CONTROL;
        if (gesture.Alt) modifiers |= MOD_ALT;
        if (gesture.Shift) modifiers |= MOD_SHIFT;
        if (gesture.Win) modifiers |= MOD_WIN;
        modifiers |= MOD_NOREPEAT;

        var vk = VirtualKeyOf(gesture.Key);
        var id = Environment.TickCount & 0x3FFF;

        _ready.Reset();
        _thread = new Thread(() => MessageLoop(id, modifiers, vk, callback))
        {
            IsBackground = true,
            Name = "GlobalHotkey",
        };
        _thread.Start();

        // 等消息循环完成注册(最多 2 秒),保证调用方拿到确定结果
        _ready.Wait(2000);

        if (!_registered)
        {
            Stop();
            return false;
        }

        _id = id;

        return true;
    }

    /// <summary>注销热键并结束消息循环</summary>
    public void Dispose()
    {
        if (_disposed) return;
        _disposed = true;

        Stop();
    }

    private void Stop()
    {
        if (_threadId != 0) PostThreadMessage(_threadId, WM_QUIT, IntPtr.Zero, IntPtr.Zero);

        _thread?.Join(1500);
        _thread = null;
        _threadId = 0;
        _registered = false;
    }

    private void MessageLoop(Int32 id, UInt32 modifiers, UInt32 vk, Action callback)
    {
        _threadId = GetCurrentThreadId();

        try
        {
            if (!RegisterHotKey(IntPtr.Zero, id, modifiers, vk))
            {
                _ready.Set();
                return;
            }

            _registered = true;
            _ready.Set();

            while (GetMessage(out var msg, IntPtr.Zero, 0, 0) > 0)
            {
                if (msg.message == WM_HOTKEY)
                {
                    try
                    {
                        callback();
                    }
                    catch (Exception ex)
                    {
                        XTrace.WriteException(ex);
                    }
                }

                TranslateMessage(ref msg);
                DispatchMessage(ref msg);
            }

            UnregisterHotKey(IntPtr.Zero, id);
        }
        catch (Exception ex)
        {
            XTrace.WriteException(ex);
            _ready.Set();
        }
    }

    #region Win32
    private const UInt32 MOD_ALT = 0x0001;
    private const UInt32 MOD_CONTROL = 0x0002;
    private const UInt32 MOD_SHIFT = 0x0004;
    private const UInt32 MOD_WIN = 0x0008;
    private const UInt32 MOD_NOREPEAT = 0x4000;
    private const UInt32 WM_HOTKEY = 0x0312;
    private const UInt32 WM_QUIT = 0x0012;

    [StructLayout(LayoutKind.Sequential)]
    private struct MSG
    {
        public IntPtr hwnd;
        public UInt32 message;
        public IntPtr wParam;
        public IntPtr lParam;
        public UInt32 time;
        public Int32 x;
        public Int32 y;
        public UInt32 lPrivate;
    }

    [DllImport("user32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern Boolean RegisterHotKey(IntPtr hWnd, Int32 id, UInt32 fsModifiers, UInt32 vk);

    [DllImport("user32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern Boolean UnregisterHotKey(IntPtr hWnd, Int32 id);

    [DllImport("user32.dll")]
    private static extern Int32 GetMessage(out MSG lpMsg, IntPtr hWnd, UInt32 wMsgFilterMin, UInt32 wMsgFilterMax);

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern Boolean TranslateMessage(ref MSG lpMsg);

    [DllImport("user32.dll")]
    private static extern IntPtr DispatchMessage(ref MSG lpMsg);

    [DllImport("user32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern Boolean PostThreadMessage(UInt32 idThread, UInt32 msg, IntPtr wParam, IntPtr lParam);

    [DllImport("kernel32.dll")]
    private static extern UInt32 GetCurrentThreadId();
    #endregion

    /// <summary>主键名到虚拟键码(0 表示不支持)</summary>
    /// <param name="key">主键名</param>
    /// <returns>虚拟键码</returns>
    public static UInt32 VirtualKeyOf(String? key)
    {
        if (key.IsNullOrWhiteSpace()) return 0;

        var text = key!.Trim().ToUpperInvariant();

        // 单字符:A-Z、0-9
        if (text.Length == 1)
        {
            var c = text[0];
            if (c is >= 'A' and <= 'Z' or >= '0' and <= '9') return c;
        }

        // 功能键 F1~F24
        if (text.StartsWith("F", StringComparison.Ordinal) && Int32.TryParse(text[1..], out var f) && f is >= 1 and <= 24)
            return (UInt32)(0x70 + f - 1);

        return text switch
        {
            "SPACE" => 0x20,
            "ENTER" or "RETURN" => 0x0D,
            "ESC" or "ESCAPE" => 0x1B,
            "TAB" => 0x09,
            "INSERT" => 0x2D,
            "DELETE" or "DEL" => 0x2E,
            "HOME" => 0x24,
            "END" => 0x23,
            "PAGEUP" => 0x21,
            "PAGEDOWN" => 0x22,
            "LEFT" => 0x25,
            "UP" => 0x26,
            "RIGHT" => 0x27,
            "DOWN" => 0x28,
            _ => 0,
        };
    }

    /// <summary>列出支持的主键名,供界面提示</summary>
    public static IReadOnlyList<String> SupportedKeys { get; } =
    [
        "A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z",
        "0","1","2","3","4","5","6","7","8","9",
        "F1","F2","F3","F4","F5","F6","F7","F8","F9","F10","F11","F12",
        "SPACE","ENTER","ESC","TAB","INSERT","DELETE","HOME","END","PAGEUP","PAGEDOWN","LEFT","UP","RIGHT","DOWN",
    ];
}