private AccessibleObject NavigateBackward(bool wrapAround) { if (_owner.OwningColumn == _owner.DataGridView.Columns.GetFirstColumn(DataGridViewElementStates.Visible)) { if (wrapAround) { // Return the last accessible object in the previous row AccessibleObject previousRow = Owner.OwningRow.AccessibilityObject.Navigate(AccessibleNavigation.Previous); if (previousRow != null && previousRow.GetChildCount() > 0) { return(previousRow.GetChild(previousRow.GetChildCount() - 1)); } else { return(null); } } else { // return the row header cell if the row headers are visible. if (_owner.DataGridView.RowHeadersVisible) { return(_owner.OwningRow.AccessibilityObject.GetChild(0)); } else { return(null); } } } else { int previousVisibleColumnIndex = _owner.DataGridView.Columns.GetPreviousColumn(_owner.OwningColumn, DataGridViewElementStates.Visible, DataGridViewElementStates.None).Index; return(_owner.OwningRow.Cells[previousVisibleColumnIndex].AccessibilityObject); } }
public override AccessibleObject Navigate(AccessibleNavigation navigationDirection) { if (Owner.OwningColumn == null) { return(null); } switch (navigationDirection) { case AccessibleNavigation.Right: if (Owner.DataGridView.RightToLeft == RightToLeft.No) { return(NavigateForward()); } else { return(NavigateBackward()); } case AccessibleNavigation.Next: return(NavigateForward()); case AccessibleNavigation.Left: if (Owner.DataGridView.RightToLeft == RightToLeft.No) { return(NavigateBackward()); } else { return(NavigateForward()); } case AccessibleNavigation.Previous: return(NavigateBackward()); case AccessibleNavigation.FirstChild: // return the top left header cell accessible object return(Owner.DataGridView.AccessibilityObject.GetChild(0).GetChild(0)); case AccessibleNavigation.LastChild: // return the last column header cell in the top row header accessible object AccessibleObject topRowHeaderAccessibleObject = Owner.DataGridView.AccessibilityObject.GetChild(0); return(topRowHeaderAccessibleObject.GetChild(topRowHeaderAccessibleObject.GetChildCount() - 1)); default: return(null); } }
/// <summary> /// Gets the next n child accessible objects. /// </summary> unsafe HRESULT Oleaut32.IEnumVariant.Next(uint celt, IntPtr rgVar, uint *pCeltFetched) { // NOTE: rgvar is a pointer to an array of variants if (owner.IsClientObject) { Debug.WriteLineIf(CompModSwitches.MSAA.TraceInfo, "EnumVariantObject: owner = " + owner.ToString() + ", celt = " + celt); Debug.Indent(); int childCount; int[]? newOrder; if ((childCount = owner.GetChildCount()) >= 0) { NextFromChildCollection(celt, rgVar, pCeltFetched, childCount); } else if (owner.systemIEnumVariant is null) { NextEmpty(celt, rgVar, pCeltFetched); } else if ((newOrder = owner.GetSysChildOrder()) != null) { NextFromSystemReordered(celt, rgVar, pCeltFetched, newOrder); } else { NextFromSystem(celt, rgVar, pCeltFetched); } Debug.Unindent(); } else { NextFromSystem(celt, rgVar, pCeltFetched); } if (pCeltFetched is null) { return(HRESULT.S_OK); } // Tell caller whether requested number of items was returned. Once list of items has // been exhausted, we return S_FALSE so that caller knows to stop calling this method. return(*pCeltFetched == celt ? HRESULT.S_OK : HRESULT.S_FALSE); }
private AccessibleObject NavigateForward(bool wrapAround) { if (_owner.OwningColumn == _owner.DataGridView.Columns.GetLastColumn(DataGridViewElementStates.Visible, DataGridViewElementStates.None)) { if (wrapAround) { // Return the first cell in the next visible row. // AccessibleObject nextRow = Owner.OwningRow.AccessibilityObject.Navigate(AccessibleNavigation.Next); if (nextRow != null && nextRow.GetChildCount() > 0) { if (Owner.DataGridView.RowHeadersVisible) { return(nextRow.GetChild(1)); } else { return(nextRow.GetChild(0)); } } else { return(null); } } else { return(null); } } else { int nextVisibleColumnIndex = _owner.DataGridView.Columns.GetNextColumn(_owner.OwningColumn, DataGridViewElementStates.Visible, DataGridViewElementStates.None).Index; return(_owner.OwningRow.Cells[nextVisibleColumnIndex].AccessibilityObject); } }
public override AccessibleObject Navigate(AccessibleNavigation navigationDirection) { if (base.Owner.OwningColumn != null) { switch (navigationDirection) { case AccessibleNavigation.Left: if (base.Owner.DataGridView.RightToLeft != RightToLeft.No) { return(this.NavigateForward()); } return(this.NavigateBackward()); case AccessibleNavigation.Right: if (base.Owner.DataGridView.RightToLeft != RightToLeft.No) { return(this.NavigateBackward()); } return(this.NavigateForward()); case AccessibleNavigation.Next: return(this.NavigateForward()); case AccessibleNavigation.Previous: return(this.NavigateBackward()); case AccessibleNavigation.FirstChild: return(base.Owner.DataGridView.AccessibilityObject.GetChild(0).GetChild(0)); case AccessibleNavigation.LastChild: { AccessibleObject child = base.Owner.DataGridView.AccessibilityObject.GetChild(0); return(child.GetChild(child.GetChildCount() - 1)); } } } return(null); }
private static void DumpAccessibilityReport(AccessibleObject parent, string indent) { Debug.WriteLine(string.Format("{0}Name: {1}, Value: {2}, Role: {3}, Description: {4}", indent, parent.Name, parent.Value, parent.Role.ToString(), parent.Description)); int childCount = parent.GetChildCount(); if (childCount != 0) { string childIndent = indent + "\t"; for (int i = 0; i < childCount; ++i) { DumpAccessibilityReport(parent.GetChild(i), childIndent); } } }
/// <summary> /// Find the accessible object matching the given path /// </summary> /// <param name="parent">The starting accessible object</param> /// <param name="nodePath">A list of AccessiblePathNode structures. Note that the /// easiest way to populate this is with an array of path nodes</param> /// <returns>Matching AccessibleObject, or null</returns> public static AccessibleObject FindAccessibleObject(AccessibleObject parent, IList<AccessiblePathNode> nodePath) { int pathCount = nodePath.Count; if (pathCount == 0) { return null; } AccessibleObject nextParent = parent; for (int currentNodeIndex = 0; currentNodeIndex < pathCount && nextParent != null; ++currentNodeIndex) { parent = nextParent; nextParent = null; int childCount = parent.GetChildCount(); if (childCount != 0) { AccessiblePathNode currentNode = nodePath[currentNodeIndex]; int testIndex = currentNode.Index; for (int i = 0; i < childCount; ++i) { AccessibleObject child = parent.GetChild(i); if (child != null && child.Name == currentNode.Name && (currentNode.Value == null || currentNode.Value == child.Value)) { if (testIndex > 0) { --testIndex; } else { nextParent = child; break; } } } } } return nextParent; }
void CheckProperties(AccessibleObject node) { // Get code coverage on the boring stuff. Trace.WriteLine("Name=" + node.Name); Trace.WriteLine("\tValue=" + node.Value); Trace.WriteLine("\tParent=" + node.Parent.Name); Trace.WriteLine("\tChildCount=" + node.GetChildCount()); Trace.WriteLine("\tBounds=" + node.Bounds.ToString()); Trace.WriteLine("\tDefaultAction=" + node.DefaultAction); Trace.WriteLine("\tDescription=" + node.Description); Trace.WriteLine("\tHelp=" + node.Help); Trace.WriteLine("\tKeyboardShortcut=" + node.KeyboardShortcut); Trace.WriteLine("\tRole=" + node.Role); Trace.WriteLine("\tState=" + node.State); string filename = null; Trace.WriteLine("\tHelpTopic=" + node.GetHelpTopic(out filename)); }