Screen Reader Can't access

[11Jou]

Currently, the TextEditor control in AvaloniaEdit does not work well with screen readers (NVDA, Narrator, Orca). Screen readers either treat it as a generic control or fail to read text properly. This makes the control inaccessible to users who rely on assistive technology.

[maxkatz6]

When AvaloniaEdit was ported from AvalonEdit, we didn't have automation peer API.
But it should be realatively easy to port these classes as well:

• https://github.com/icsharpcode/AvalonEdit/blob/master/ICSharpCode.AvalonEdit/TextEditorAutomationPeer.cs
• https://github.com/icsharpcode/AvalonEdit/blob/master/ICSharpCode.AvalonEdit/Editing/TextAreaAutomationPeer.cs
• https://github.com/icsharpcode/AvalonEdit/blob/862415d51eddc9eac93f462dbc522ffbf929cd52/ICSharpCode.AvalonEdit/Editing/TextArea.cs#L1089
• https://github.com/icsharpcode/AvalonEdit/blob/862415d51eddc9eac93f462dbc522ffbf929cd52/ICSharpCode.AvalonEdit/TextEditor.cs#L82

[maxkatz6]

Although, it still won't be complete without ITextRangeProvider or equivalent on the Avalonia side

[11Jou]

Is this issue planned to be fixed in future releases?

[maxkatz6]

@11Jou no immediate plans. Any help is appreciated though.

[11Jou]

Hello, I made some updates to make the TextEditor accessible to screen readers by integrating it with AutomationPeer, and it works — but only partially. When navigating between lines, the screen reader doesn’t announce the text immediately. It only starts reading after I move the mouse away from the TextEditor and then return to it (similar to how Notepad behaves). How can I make the screen reader announce the line as soon as I navigate between line?

i want to share the 3 main scripts of this achievement

TextEditorHelper.cs
using Avalonia;
using AvaloniaEdit;
using AvaloniaEdit.Document;
using System;
using Avalonia.Automation;
using Avalonia.Automation.Peers;

namespace BraillePrinterApp.Helpers
{
public static class TextEditorHelper
{
public static readonly AttachedProperty<string?> BoundTextProperty =
AvaloniaProperty.RegisterAttached<TextEditor, string?>(
"BoundText",
typeof(TextEditorHelper),
defaultValue: string.Empty,
defaultBindingMode: Avalonia.Data.BindingMode.TwoWay);

    public static readonly AttachedProperty<bool> EnableAccessibilityProperty =
        AvaloniaProperty.RegisterAttached<TextEditor, bool>(
            "EnableAccessibility",
            typeof(TextEditorHelper),
            defaultValue: false,
            defaultBindingMode: Avalonia.Data.BindingMode.OneWay);

    private static readonly AttachedProperty<TextEditorAutomationPeer?> AutomationPeerProperty =
        AvaloniaProperty.RegisterAttached<TextEditor, TextEditorAutomationPeer?>(
            "AutomationPeer",
            typeof(TextEditorHelper),
            defaultValue: null);


    private static readonly AttachedProperty<EventHandler<Avalonia.Input.TextInputEventArgs>?> TextEnteringHandlerProperty =
        AvaloniaProperty.RegisterAttached<TextEditor, EventHandler<Avalonia.Input.TextInputEventArgs>?>(
            "TextEnteringHandler",
            typeof(TextEditorHelper),
            defaultValue: null);

    static TextEditorHelper()
    {
        BoundTextProperty.Changed.AddClassHandler<TextEditor>((editor, e) =>
        {
            editor.TextChanged -= EditorOnTextChanged;

            if (e.NewValue is string newText && editor.Text != newText)
            {
                editor.Text = newText;
            }

            editor.TextChanged += EditorOnTextChanged;
        });

        EnableAccessibilityProperty.Changed.AddClassHandler<TextEditor>((editor, e) =>
        {
            if (e.NewValue is bool enabled && enabled)
            {
                SetupAccessibility(editor);
            }
        });
    }

    public static string? GetBoundText(TextEditor editor) =>
        editor.GetValue(BoundTextProperty);

    public static void SetBoundText(TextEditor editor, string? value) =>
        editor.SetValue(BoundTextProperty, value);

    public static bool GetEnableAccessibility(TextEditor editor) =>
        editor.GetValue(EnableAccessibilityProperty);

    public static void SetEnableAccessibility(TextEditor editor, bool value) =>
        editor.SetValue(EnableAccessibilityProperty, value);

    internal static void RegisterAutomationPeer(TextEditor editor, TextEditorAutomationPeer peer) =>
        editor.SetValue(AutomationPeerProperty, peer);

    private static TextEditorAutomationPeer? GetAutomationPeer(TextEditor editor) =>
        editor.GetValue(AutomationPeerProperty);

        
    private static void SetupAccessibility(TextEditor editor)
    {
        AutomationProperties.SetLiveSetting(editor, AutomationLiveSetting.Assertive);
        AutomationProperties.SetName(editor, "Text Editor");

        AutomationProperties.SetIsRequiredForForm(editor, true);

        int lastAnnouncedLine = -1;
        bool pendingAnnounce = false; 

        editor.TextArea.Caret.PositionChanged += (s, e) =>
        {
            try
            {
                var currentLine = editor.TextArea.Caret.Line;

                if (currentLine != lastAnnouncedLine)
                {
                    lastAnnouncedLine = currentLine;

                    var automationPeer = GetAutomationPeer(editor);
                    if (automationPeer != null && pendingAnnounce)
                    {
                        pendingAnnounce = false;
                        Avalonia.Threading.Dispatcher.UIThread.InvokeAsync(() =>
                        {
                            automationPeer.AnnounceCurrentLine();
                        }, Avalonia.Threading.DispatcherPriority.Normal);
                    }
                    else if (automationPeer != null && !pendingAnnounce)
                    {
                        Avalonia.Threading.Dispatcher.UIThread.InvokeAsync(() =>
                        {
                            automationPeer.AnnounceCurrentLine();
                        }, Avalonia.Threading.DispatcherPriority.Normal);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[Accessibility] Caret PositionChanged error: {ex.Message}");
            }
        };

        editor.TextArea.TextEntered += (s, e) =>
        {
            if (!string.IsNullOrEmpty(e.Text))
            {
                var automationPeer = GetAutomationPeer(editor);
                if (automationPeer != null)
                {
                    if (e.Text.Length > 1)
                    {
                        Avalonia.Threading.Dispatcher.UIThread.Post(() =>
                        {
                            automationPeer.AnnounceCurrentLine();
                        }, Avalonia.Threading.DispatcherPriority.Send);
                    }
                    else
                    {
                        automationPeer.EnsureInitialized();
                    }
                }
                else
                {
                    Console.WriteLine("[Accessibility] WARNING: Peer not available for text input");
                }
            }
        };
    }

    private static void EditorOnTextChanged(object? sender, EventArgs e)
    {
        if (sender is TextEditor editor)
        {
            editor.SetValue(BoundTextProperty, editor.Text);
        }
    }

}

}

TextEditorAutomationPeer.cs

using Avalonia.Automation.Peers;
using Avalonia.Automation.Provider;
using AvaloniaEdit;
using System;
using Avalonia.Automation;
using System.Runtime.InteropServices;

namespace BraillePrinterApp.Helpers
{
public class TextEditorAutomationPeer : ControlAutomationPeer, IValueProvider
{
private readonly TextEditor _editor;
private string? _lastAnnouncedLine;
private bool _isInitialized;

    public TextEditorAutomationPeer(TextEditor owner) : base(owner)
    {
        _editor = owner;
        _isInitialized = false;
    }
    
public void EnsureInitialized()
{

    if (_isInitialized) return;

    _isInitialized = true;

    var currentLine = GetCurrentLineText();

    RaisePropertyChangedEvent(
        ValuePatternIdentifiers.ValueProperty,
        string.Empty,
        currentLine);

    if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
    {
        TryRaiseNotification(currentLine, isCharacterMode: false);
    }
}


    public void SetValue(string? value) 
    {
        if (_editor != null)
        {
            _editor.Text = value ?? string.Empty;
        }
    }

    public string Value
    {
        get
        {
            var lineText = GetCurrentLineText();
            return lineText;
        }
    }

    public bool IsReadOnly => _editor?.IsReadOnly ?? false;

    protected override AutomationControlType GetAutomationControlTypeCore()
        => AutomationControlType.Edit;

    protected override string GetClassNameCore()
        => "TextEditor";

    protected override string GetNameCore()
        => string.Empty;

    protected override bool IsKeyboardFocusableCore()
        => true;

    protected override bool IsContentElementCore()
        => true;

    protected override bool IsControlElementCore()
        => true;

    public string GetCurrentLineText()
    {
        if (_editor?.Document == null)
            return string.Empty;

        try
        {
            var line = _editor.Document.GetLineByNumber(_editor.TextArea.Caret.Line);
            return _editor.Document.GetText(line.Offset, line.Length);
        }
        catch
        {
            return string.Empty;
        }
    }

    public string GetCurrentLineInfo()
    {
        if (_editor?.Document == null)
            return string.Empty;

        var lineNumber = _editor.TextArea.Caret.Line;
        var columnNumber = _editor.TextArea.Caret.Column;
        var lineText = GetCurrentLineText();

        return $"Line {lineNumber}, Column {columnNumber}: {lineText}";
    }

    public void AnnounceText(string text)
    {
        Console.WriteLine($"[NVDA] Announcing text: {text}");
        if (string.IsNullOrEmpty(text))
            return;
        try
        {
            TryRaiseNotification(text, isCharacterMode: true);
            _lastAnnouncedLine = GetCurrentLineText(); // keep track
        }
        catch (Exception ex)
        {
            Console.WriteLine($"[NVDA] Text Error: {ex.Message}");
        }
    }

    public void AnnounceCurrentLine()
    {
        if (_editor?.Document == null)
            return;

        try
        {
            var lineText = GetCurrentLineText();
            if (lineText == _lastAnnouncedLine)
            {
                return;
            }

            _lastAnnouncedLine = lineText;
            var announcement = string.IsNullOrWhiteSpace(lineText) ? "blank" : lineText;
            TryRaiseNotification(announcement, isCharacterMode: false);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"[NVDA] Line Error: {ex.Message}");
        }
    }

    private void TryRaiseNotification(string text, bool isCharacterMode = false)
    {
        if (string.IsNullOrEmpty(text))
            return;

        try
        {
            var method = typeof(AutomationPeer).GetMethod(
                "RaiseNotification",
                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance,
                null,
                new[] { typeof(string), typeof(string), typeof(string) },
                null);

            if (method != null)
            {
                string notificationKind = isCharacterMode ? "assertive" : "assertive";
                string activityId = isCharacterMode ? "typeCharacter" : "lineNavigation";

                method.Invoke(this, new object[] { text, notificationKind, activityId });
            }
            else
            {
                Console.WriteLine("[NVDA] RaiseNotification method not found");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"[NVDA] Notification error: {ex.Message}");
        }
    }
}

}

AccessibleTextEditor.cs

using Avalonia.Automation.Peers;
using Avalonia.Styling;
using AvaloniaEdit;
using BraillePrinterApp.Helpers;
using System;
using Avalonia.Automation;

namespace BraillePrinterApp.Controls
{
public class AccessibleTextEditor : TextEditor
{
private TextEditorAutomationPeer? _automationPeer;

    static AccessibleTextEditor()
    {
    }

    protected override Type StyleKeyOverride => typeof(TextEditor);

    public AccessibleTextEditor()
    {
        AutomationProperties.SetIsRequiredForForm(this, false);
        AutomationProperties.SetLiveSetting(this, AutomationLiveSetting.Assertive);
        this.Focusable = true;

        _automationPeer = new TextEditorAutomationPeer(this);
        TextEditorHelper.RegisterAutomationPeer(this, _automationPeer);

        _automationPeer.EnsureInitialized();

        this.AttachedToVisualTree += (s, e) => EnsurePeerCreated();
    }

    private void EnsurePeerCreated()
    {
        if (_automationPeer == null)
        {
            _automationPeer = new TextEditorAutomationPeer(this);
            TextEditorHelper.RegisterAutomationPeer(this, _automationPeer);
            _automationPeer.EnsureInitialized();
        }
        else
        {
            Console.WriteLine("[Accessibility] Peer already exists");
        }
    }

    protected override AutomationPeer OnCreateAutomationPeer()
    {
        return _automationPeer ??= new TextEditorAutomationPeer(this);
    }
    
    protected override void OnGotFocus(Avalonia.Input.GotFocusEventArgs e)
    {
        base.OnGotFocus(e);
        EnsurePeerCreated();
    }
}

}

[11Jou]

the problem that the getter method of value which is screen reader notify the change from it is called only in mouse movement
public string Value
{
get
{
var lineText = GetCurrentLineText();
return lineText;
}
}