MsaaHelper.cs

// =============================================================================
// GPAL - Generally Positive Automation Library
// Copyright © 2026 Software Decisions, Inc. All rights reserved.
//
// This file is part of GPAL.
// Licensed under the Business Source License 1.1
//
// Primary development, architecture, and vision by Michael B. Vederman,
// CEO of Software Decisions, Inc., Texas.
//
// Internal development maintained privately.
// Public releases appear on GitHub: https://github.com/SoftwareDecisionsInc/GPAL.
//
// See LICENSE for full terms, including Additional Use Grant.
// =============================================================================
 
using Accessibility;
using System;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Automation;
using static GenerallyPositive.Enums;
 
namespace GenerallyPositive.Application
{
    internal static class MsaaHelper
    {
        private const uint OBJID_CLIENT = 0xFFFFFFFC;
        private const int STATE_SYSTEM_SELECTED = 0x00000002;
        private const int SELFLAG_TAKEFOCUS = 0x00000001;
        private const int SELFLAG_TAKESELECTION = 0x00000002;
        private const int CHILDID_SELF = 0;
 
        // how far the accessible tree is walked looking for the node, and how many nodes are looked at on the
        // way. A ribbon tab is four deep from the window and these bounds are not near anything real, they stop
        // a provider that answers its own parent as its child from walking forever
        private const int DepthLimit = 12;
        private const int NodeLimit = 4000;
 
        // two rectangles describe the same control when they agree to the pixel. A point of slack covers a
        // provider that rounds where the other truncates
        private const double RectSlack = 2.0;
 
        private static Guid IID_IAccessible = new Guid("618736E0-3C3D-11CF-810C-00AA00389B71");
 
        [DllImport("oleacc.dll")]
        private static extern int AccessibleObjectFromWindow(IntPtr window, uint objectId, ref Guid interfaceId,
                                                             [MarshalAs(UnmanagedType.Interface)] out object accessible);
 
        [DllImport("oleacc.dll")]
        private static extern int AccessibleChildren([MarshalAs(UnmanagedType.Interface)] IAccessible container,
                                                     int startingChild, int wanted,
                                                     [Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.Struct)] object[] children,
                                                     out int obtained);

        private class Node
        {
            internal IAccessible Owner;
            internal object ChildId;
        }

        internal static bool? Selected(Application application, AutomationElement element)
        {
            bool? retVal = null;
            Node node = NodeFor(application, element);
 
            if (null != node)
            {
                int state = StateOf(node);
 
                retVal = STATE_SYSTEM_SELECTED == (state & STATE_SYSTEM_SELECTED);
            }
 
            return retVal;
        }

        internal static bool Select(Application application, AutomationElement element)
        {
            bool retVal = false;
            Node node = NodeFor(application, element);
 
            if (null != node)
            {
                try
                {
                    node.Owner.accSelect(SELFLAG_TAKEFOCUS | SELFLAG_TAKESELECTION, node.ChildId);
 
                    retVal = STATE_SYSTEM_SELECTED == (StateOf(node) & STATE_SYSTEM_SELECTED);
                }
                catch (Exception)
                {
                    // a provider is allowed to refuse a selection it publishes a state for, and says so by
                    // throwing. That is an answer, not a breakage: the caller goes on to the mouse, so this is
                    // said on the channel the routes are said on and not as an exception
                    GPAL.PublishSimpleEvent(GPALEventType.INFO, $"MSAA would not select [{NameOf(node)}], so it was not selected that way.", application, GPALObjectType.Application);
                }
            }
 
            return retVal;
        }

        internal static bool Press(Application application, AutomationElement element)
        {
            bool retVal = false;
            Node node = NodeFor(application, element);
 
            if (null != node)
            {
                try
                {
                    node.Owner.accDoDefaultAction(node.ChildId);
 
                    retVal = true;
                }
                catch (Exception)
                {
                    // a control is allowed to have no default action, and says so by throwing. That is an
                    // answer, not a breakage: the caller goes on to the mouse
                    GPAL.PublishSimpleEvent(GPALEventType.INFO, $"MSAA has no default action for [{NameOf(node)}], so it was not pressed that way.", application, GPALObjectType.Application);
                }
            }
 
            return retVal;
        }

        private static Node NodeFor(Application application, AutomationElement element)
        {
            Node retVal = null;
            Rect wanted = Rect.Empty;
            IntPtr window = IntPtr.Zero;
 
            // a dialog closes the instant its button is pressed, and a button on a closed dialog answers every
            // question by throwing. Asking is how this finds out the control has gone, which is not a failure,
            // it is the answer
            try
            {
                wanted = null == element ? Rect.Empty : element.Current.BoundingRectangle;
                window = WindowOf(element);
            }
            catch (Exception)
            {
                wanted = Rect.Empty;
            }
 
            // a control with no rectangle is one nothing can be matched on, and a control in no window is one
            // there is no accessible tree to search
            if (false == wanted.IsEmpty && IntPtr.Zero != window)
            {
                object root;
 
                if (0 == AccessibleObjectFromWindow(window, OBJID_CLIENT, ref IID_IAccessible, out root) && root is IAccessible accessible)
                {
                    int looked = 0;
 
                    try
                    {
                        retVal = Search(new Node { Owner = accessible, ChildId = CHILDID_SELF }, wanted, 0, ref looked);
                    }
                    catch (Exception)
                    {
                        // the same again for the tree itself: a window that closes while it is being walked
                        // takes its nodes with it
                        retVal = null;
                    }
                }
            }
 
            GPAL.PublishSimpleEvent(GPALEventType.DEBUG, $"MSAA node at [{wanted}] in window [{window}] was [{(null == retVal ? "not found" : NameOf(retVal))}].", application, GPALObjectType.Application);
 
            return retVal;
        }

        private static Node Search(Node node, Rect wanted, int depth, ref int looked)
        {
            Node retVal = null;
 
            if (depth <= DepthLimit && ++looked <= NodeLimit)
            {
                if (true == Matches(node, wanted))
                    retVal = node;
                else
                {
                    foreach (Node child in ChildrenOf(node))
                    {
                        retVal = Search(child, wanted, depth + 1, ref looked);
 
                        if (null != retVal)
                            break;
                    }
                }
            }
 
            return retVal;
        }

        private static System.Collections.Generic.List<Node> ChildrenOf(Node node)
        {
            var retVal = new System.Collections.Generic.List<Node>();
 
            // only an object of its own has children. A numbered child is a leaf by definition, and asking the
            // owner for its children again from inside one is how a walk goes round in circles
            if (true == IsSelf(node.ChildId))
            {
                int count = 0;
 
                try
                {
                    count = node.Owner.accChildCount;
                }
                catch (Exception)
                {
                    // a provider that will not count its children has none as far as this is concerned
                    count = 0;
                }
 
                if (0 < count)
                {
                    object[] children = new object[count];
                    int obtained;
 
                    if (0 == AccessibleChildren(node.Owner, 0, count, children, out obtained))
                        for (int child = 0; child < obtained; child++)
                            if (children[child] is IAccessible ownObject)
                                retVal.Add(new Node { Owner = ownObject, ChildId = CHILDID_SELF });
                            else if (null != children[child])
                                retVal.Add(new Node { Owner = node.Owner, ChildId = children[child] });
                }
            }
 
            return retVal;
        }

        private static bool Matches(Node node, Rect wanted)
        {
            bool retVal = false;
            int left, top, width, height;
 
            try
            {
                node.Owner.accLocation(out left, out top, out width, out height, node.ChildId);
 
                retVal = RectSlack > Math.Abs(left - wanted.Left)
                      && RectSlack > Math.Abs(top - wanted.Top)
                      && RectSlack > Math.Abs(width - wanted.Width)
                      && RectSlack > Math.Abs(height - wanted.Height);
            }
            catch (Exception)
            {
                // MSAA answers "I do not implement that" by failing the call, which the interop raises. A node
                // that will not give its location is a node that cannot be the one being looked for
                retVal = false;
            }
 
            return retVal;
        }

        private static int StateOf(Node node)
        {
            int retVal = 0;
 
            try
            {
                object state = node.Owner.get_accState(node.ChildId);
 
                if (state is int bits)
                    retVal = bits;
            }
            catch (Exception)
            {
                retVal = 0;
            }
 
            return retVal;
        }

        private static string NameOf(Node node)
        {
            string retVal = "unnamed";
 
            try
            {
                string name = node.Owner.get_accName(node.ChildId);
 
                if (false == string.IsNullOrWhiteSpace(name))
                    retVal = name;
            }
            catch (Exception)
            {
                retVal = "unnamed";
            }
 
            return retVal;
        }

        private static bool IsSelf(object childId)
        {
            return childId is int id && CHILDID_SELF == id;
        }

        private static IntPtr WindowOf(AutomationElement element)
        {
            IntPtr retVal = IntPtr.Zero;
            AutomationElement current = element;
 
            for (int level = 0; level <= DepthLimit && IntPtr.Zero == retVal && null != current; level++)
            {
                if (0 != current.Current.NativeWindowHandle)
                    retVal = new IntPtr(current.Current.NativeWindowHandle);
                else
                    current = TreeWalker.ControlViewWalker.GetParent(current);
            }
 
            return retVal;
        }
    }
}