BlazorKeyboardAdapter.cs

using System.Runtime.CompilerServices;
using Gondwana.Blazor.Rendering;
using Gondwana.Input.Keyboard;
using Microsoft.AspNetCore.Components.Web;
using Microsoft.Extensions.Logging;
 
namespace Gondwana.Blazor.Input.Keyboard;

public sealed class BlazorKeyboardAdapter : IKeyboardAdapter, IDisposable
{
    private static readonly int KeyArraySize = Enum.GetValues<BlazorKey>().Cast<int>().Max() + 1;
 
    private readonly BlazorRenderSurfaceComponentBase _component;
    private readonly int[] _down;
    private int _modsBits;
    private bool _isDisposed;

    public KeyboardModifierState CurrentKeyboardModifiers =>
        (KeyboardModifierState)Volatile.Read(ref _modsBits);

    public BlazorKeyboardAdapter(BlazorBitmapRenderSurfaceComponent component)
        : this((BlazorRenderSurfaceComponentBase)component)
    {
    }

    public BlazorKeyboardAdapter(BlazorRenderSurfaceComponentBase component)
    {
        _component = component ?? throw new ArgumentNullException(nameof(component));
        _down = new int[KeyArraySize];
 
        _component.KeyDown += OnKeyDown;
        _component.KeyUp += OnKeyUp;
 
        Engine.Logger.LogInformation("BlazorKeyboardAdapter initialized.");
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public bool IsDown(int keyCode)
    {
        if ((uint)keyCode >= (uint)_down.Length) return false;
        return Volatile.Read(ref _down[keyCode]) != 0;
    }

    public static int? GetKeyCodeFromString(string keyName)
    {
        if (Enum.TryParse<BlazorKey>(keyName, true, out var key) && key != BlazorKey.None)
            return (int)key;
 
        Engine.Logger.LogWarning("Invalid Blazor key name: {KeyName}", keyName);
        return null;
    }
 
    private void OnKeyDown(KeyboardEventArgs e)
    {
        if (_isDisposed) return;
        SetDown(e.Code, true);
        UpdateMods(e);
    }
 
    private void OnKeyUp(KeyboardEventArgs e)
    {
        if (_isDisposed) return;
        SetDown(e.Code, false);
        UpdateMods(e);
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void SetDown(string code, bool down)
    {
        if (!Enum.TryParse<BlazorKey>(code, false, out var key) || key == BlazorKey.None) return;
        var index = (int)key;
        if ((uint)index >= (uint)_down.Length) return;
        Volatile.Write(ref _down[index], down ? 1 : 0);
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void UpdateMods(KeyboardEventArgs e)
    {
        int mods = 0;
        if (e.ShiftKey) mods |= (int)KeyboardModifierState.Shift;
        if (e.CtrlKey) mods |= (int)KeyboardModifierState.Ctrl;
        if (e.AltKey) mods |= (int)KeyboardModifierState.Alt;
        Volatile.Write(ref _modsBits, mods);
    }

    public void Dispose()
    {
        if (_isDisposed) return;
        _isDisposed = true;
 
        _component.KeyDown -= OnKeyDown;
        _component.KeyUp -= OnKeyUp;
 
        Engine.Logger.LogInformation("BlazorKeyboardAdapter disposed.");
    }
}