public EnumVariantObject(AccessibleObject owner) { Debug.Assert(owner != null, "Cannot create EnumVariantObject with a null owner"); this.owner = owner; }
public DataGridViewRow () { cells = new DataGridViewCellCollection(this); minimumHeight = 3; height = -1; explicit_height = -1; headerCell = new DataGridViewRowHeaderCell(); headerCell.SetOwningRow (this); accessibilityObject = new AccessibleObject (); SetState (DataGridViewElementStates.Visible); }
internal virtual bool GetSysChild(AccessibleNavigation navdir, out AccessibleObject accessibleObject) { accessibleObject = null; return false; }
internal InternalAccessibleObject(AccessibleObject accessibleImplemention) { this.publicIAccessible = accessibleImplemention; this.publicIEnumVariant = accessibleImplemention; this.publicIOleWindow = accessibleImplemention; this.publicIReflect = accessibleImplemention; }
/// <summary> /// Get an array of selected accessible objects /// </summary> public AccessibleObject[] GetSelectedAccessibleObjects() { DiagramClientView view = myClientView; SelectedShapesCollection shapes = view.Selection; int selectionCount = shapes.Count; AccessibleObject[] retVal = new AccessibleObject[shapes.Count]; int i = 0; foreach (DiagramItem item in shapes) { retVal[i] = item.GetAccessibleObject(view); ++i; } return retVal; }
/// <summary> /// Start a drag operation on an accessible object. The caller should make sure that the /// accessible object is visible before making this call. /// </summary> /// <param name="accessibleObject">A child accessible object to drag</param> /// <param name="location">The location in the accessible object to drag from</param> /// <param name="xOffset">A horizontal offset (in pixels) from the specified drag location.</param> /// <param name="yOffset">A vertical offset (in pixels) from the specified drag location.</param> public void DragAccessibleObject(AccessibleObject accessibleObject, ClickLocation location, int xOffset, int yOffset) { Rectangle rect = accessibleObject.Bounds; PointF pt; switch (location) { case ClickLocation.UpperLeft: pt = new PointF((float)rect.Left + xOffset, (float)rect.Top + yOffset); break; case ClickLocation.Center: default: pt = new PointF(((float)rect.Left + rect.Right) / 2 + xOffset, ((float)rect.Top + rect.Bottom) / 2 + yOffset); break; } Rectangle screenBounds = Screen.GetBounds(myClientView); MoveMouseClose(screenBounds, pt); int dx = (int)(pt.X / screenBounds.Width * 65535f); int dy = (int)(pt.Y / screenBounds.Height * 65535f); Size dragSize = SystemInformation.DragSize; float dxDrag = (dragSize.Width / screenBounds.Width * 65535f); float dyDrag = (dragSize.Height / screenBounds.Height * 65535f); SendKeys.Flush(); mouse_event(MouseEventFlags.Move | MouseEventFlags.Absolute, dx, dy, 0, 0); SendKeys.Flush(); mouse_event(MouseEventFlags.LeftDown | MouseEventFlags.Absolute, dx, dy, 0, 0); // Move .5 the drag size, the full drag size, and 1.5 the drag size to make sure we got it mouse_event(MouseEventFlags.Move | MouseEventFlags.Absolute, dx + (int)(dxDrag * .5), dy + (int)(dyDrag * .5), 0, 0); SendKeys.Flush(); mouse_event(MouseEventFlags.Move | MouseEventFlags.Absolute, dx + (int)dxDrag, dy + (int)dyDrag, 0, 0); SendKeys.Flush(); mouse_event(MouseEventFlags.Move | MouseEventFlags.Absolute, dx + (int)(dxDrag * 1.5), dy + (int)(dyDrag * 1.5), 0, 0); SendKeys.Flush(); }
/// <summary> /// End a drag operation with a drop on an accessible object. The caller should make sure that the /// accessible object is visible before making this call. /// </summary> /// <param name="accessibleObject">A child accessible object to drop on</param> /// <param name="location">The location in the accessible object to drop on</param> /// <param name="xOffset">A horizontal offset (in pixels) from the specified drop location.</param> /// <param name="yOffset">A vertical offset (in pixels) from the specified drop location.</param> public void DropOnAccessibleObject(AccessibleObject accessibleObject, ClickLocation location, int xOffset, int yOffset) { Rectangle rect = accessibleObject.Bounds; PointF pt; switch (location) { case ClickLocation.UpperLeft: pt = new PointF((float)rect.Left + xOffset, (float)rect.Top + yOffset); break; case ClickLocation.Center: default: pt = new PointF(((float)rect.Left + rect.Right) / 2 + xOffset, ((float)rect.Top + rect.Bottom) / 2 + yOffset); break; } Rectangle screenBounds = Screen.GetBounds(myClientView); MoveMouseClose(screenBounds, pt); int dx = (int)(pt.X / screenBounds.Width * 65535f); int dy = (int)(pt.Y / screenBounds.Height * 65535f); SendKeys.Flush(); mouse_event(MouseEventFlags.Move | MouseEventFlags.Absolute, dx, dy, 0, 0); SendKeys.Flush(); mouse_event(MouseEventFlags.LeftUp | MouseEventFlags.Absolute, dx, dy, 0, 0); SendKeys.Flush(); }
/// <summary> /// Helper function for TranslateAccessibleObject and EnsureAccessibleObjectVisible /// </summary> private DiagramItem TranslateAccessibleObjectToDiagramItem(AccessibleObject accessibleObject, bool returnShape) { if (accessibleObject == null) { return null; } DiagramItem hitItem = null; DiagramClientView clientView = myClientView; DiagramHitTestInfo hitInfo = new DiagramHitTestInfo(clientView); RectangleD boundsD = clientView.DeviceToWorld(clientView.RectangleToClient(accessibleObject.Bounds)); if (clientView.Diagram.DoHitTest(boundsD.Center, hitInfo, false)) { hitItem = hitInfo.HitDiagramItem; if (!returnShape) { // Wind back out the parent stack if the hit test went too far if (hitItem.SubField != null) { if (!(accessibleObject is SubfieldAccessibleObject)) { if (!(accessibleObject is FieldAccessibleObject)) { hitItem = new DiagramItem(hitItem.Shape); } else { hitItem = new DiagramItem(hitItem.Shape, hitItem.Field); } } } else if (hitItem.Field != null && !(accessibleObject is FieldAccessibleObject)) { hitItem = new DiagramItem(hitItem.Shape); } } } return hitItem; }
/// <summary> /// Click on an accessible object. The caller should make sure that the /// accessible object is visible before making this call. /// </summary> /// <param name="accessibleObject">A child accessible object to click on</param> public void ClickAccessibleObject(AccessibleObject accessibleObject) { ClickAccessibleObject(accessibleObject, 1, ClickLocation.Center, 0, 0); }
/// <include file='doc\DomainUpDown.uex' path='docs/doc[@for="DomainUpDown.DomainItemAccessibleObject.DomainItemAccessibleObject"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public DomainItemAccessibleObject(string name, AccessibleObject parent) : base() { this.name = name; this.parent = (DomainItemListAccessibleObject)parent; }
internal Rectangle GetAccessibleObjectBounds(AccessibleObject parentAccObject) { if (this.owner == null) { throw new InvalidOperationException(SR.GetString(SR.DataGridViewCellAccessibleObject_OwnerNotSet)); } if (this.owner.OwningColumn == null) { return Rectangle.Empty; } // use the accessibility bounds from the parent row acc obj Rectangle rowRect = parentAccObject.Bounds; Rectangle columnRect; int firstVisibleColumnIndex = this.owner.DataGridView.Columns.ColumnIndexToActualDisplayIndex(this.owner.DataGridView.FirstDisplayedScrollingColumnIndex, DataGridViewElementStates.Visible); int visibleColumnIndex = this.owner.DataGridView.Columns.ColumnIndexToActualDisplayIndex(this.owner.ColumnIndex, DataGridViewElementStates.Visible); bool rowHeadersVisible = this.owner.DataGridView.RowHeadersVisible; if (visibleColumnIndex < firstVisibleColumnIndex) { // Get the bounds for the cell to the RIGHT columnRect = parentAccObject.GetChild(visibleColumnIndex + 1 // + 1 for the next cell to the RIGHT + (rowHeadersVisible ? 1 : 0)).Bounds; // + 1 but only if the row headers are visible // From the bounds of the cell to the RIGHT decrement the width of the owning column if (this.Owner.DataGridView.RightToLeft == RightToLeft.No) { columnRect.X -= this.owner.OwningColumn.Width; } else { columnRect.X = columnRect.Right; } columnRect.Width = this.owner.OwningColumn.Width; } else if (visibleColumnIndex == firstVisibleColumnIndex) { columnRect = this.owner.DataGridView.GetColumnDisplayRectangle(this.owner.ColumnIndex, false /*cutOverflow*/); int negOffset = this.owner.DataGridView.FirstDisplayedScrollingColumnHiddenWidth; if (negOffset != 0) { if (this.owner.DataGridView.RightToLeft == RightToLeft.No) { columnRect.X -= negOffset; } columnRect.Width += negOffset; } columnRect = this.owner.DataGridView.RectangleToScreen(columnRect); } else { // Get the bounds for the cell to the LEFT columnRect = parentAccObject.GetChild(visibleColumnIndex - 1 // -1 because we want the previous cell to the LEFT + (rowHeadersVisible ? 1 : 0)).Bounds; // +1 but only if the row headers are visible // From the bounds of the cell to the LEFT increment the width of the owning column if (this.owner.DataGridView.RightToLeft == RightToLeft.No) { columnRect.X = columnRect.Right; } else { columnRect.X -= this.owner.OwningColumn.Width; } columnRect.Width = this.owner.OwningColumn.Width; } rowRect.X = columnRect.X; rowRect.Width = columnRect.Width; return rowRect; }
internal Rectangle GetAccessibleObjectBounds(AccessibleObject parentAccObject) { Rectangle columnDisplayRectangle; if (this.owner == null) { throw new InvalidOperationException(System.Windows.Forms.SR.GetString("DataGridViewCellAccessibleObject_OwnerNotSet")); } if (this.owner.OwningColumn == null) { return Rectangle.Empty; } Rectangle bounds = parentAccObject.Bounds; int num = this.owner.DataGridView.Columns.ColumnIndexToActualDisplayIndex(this.owner.DataGridView.FirstDisplayedScrollingColumnIndex, DataGridViewElementStates.Visible); int num2 = this.owner.DataGridView.Columns.ColumnIndexToActualDisplayIndex(this.owner.ColumnIndex, DataGridViewElementStates.Visible); bool rowHeadersVisible = this.owner.DataGridView.RowHeadersVisible; if (num2 < num) { columnDisplayRectangle = parentAccObject.GetChild((num2 + 1) + (rowHeadersVisible ? 1 : 0)).Bounds; if (this.Owner.DataGridView.RightToLeft == RightToLeft.No) { columnDisplayRectangle.X -= this.owner.OwningColumn.Width; } else { columnDisplayRectangle.X = columnDisplayRectangle.Right; } columnDisplayRectangle.Width = this.owner.OwningColumn.Width; } else if (num2 == num) { columnDisplayRectangle = this.owner.DataGridView.GetColumnDisplayRectangle(this.owner.ColumnIndex, false); int firstDisplayedScrollingColumnHiddenWidth = this.owner.DataGridView.FirstDisplayedScrollingColumnHiddenWidth; if (firstDisplayedScrollingColumnHiddenWidth != 0) { if (this.owner.DataGridView.RightToLeft == RightToLeft.No) { columnDisplayRectangle.X -= firstDisplayedScrollingColumnHiddenWidth; } columnDisplayRectangle.Width += firstDisplayedScrollingColumnHiddenWidth; } columnDisplayRectangle = this.owner.DataGridView.RectangleToScreen(columnDisplayRectangle); } else { columnDisplayRectangle = parentAccObject.GetChild((num2 - 1) + (rowHeadersVisible ? 1 : 0)).Bounds; if (this.owner.DataGridView.RightToLeft == RightToLeft.No) { columnDisplayRectangle.X = columnDisplayRectangle.Right; } else { columnDisplayRectangle.X -= this.owner.OwningColumn.Width; } columnDisplayRectangle.Width = this.owner.OwningColumn.Width; } bounds.X = columnDisplayRectangle.X; bounds.Width = columnDisplayRectangle.Width; return bounds; }
/// <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; }
internal AccessibleObject GetNext(AccessibleObject child) { int children = GetChildCount(); bool hit = false; for (int i=0; i<children; i++) { if (hit) { return GetChild(i); } if (GetChild(i) == child) { hit = true; } } return null; }
internal AccessibleObject GetPrev(AccessibleObject child) { int children = GetChildCount(); bool hit = false; for (int i=children-1; i>=0; i--) { if (hit) { return GetChild(i); } if (GetChild(i) == child) { hit = true; } } return null; }
public DomainItemAccessibleObject(string name, AccessibleObject parent) { throw null; }
public string GetCalendarChildName(int calendarIndex, CalendarChildType calendarChildType, AccessibleObject parentAccessibleObject = null, int index = -1) { switch (calendarChildType) { case CalendarChildType.CalendarHeader: GetCalendarGridInfoText(ComCtl32.MCGIP.CALENDARHEADER, calendarIndex, 0, 0, out string text); return(text); case CalendarChildType.TodayLink: return(string.Format(SR.MonthCalendarTodayButtonAccessibleName, _owner.TodayDate.ToShortDateString())); } ; return(string.Empty); }
public DomainItemAccessibleObject(string name, AccessibleObject parent) { this.name = name; this.parent = parent; }
public EnumVariantObject(AccessibleObject owner, uint currentChild) { Debug.Assert(owner != null, "Cannot create EnumVariantObject with a null owner"); this.owner = owner; this.currentChild = currentChild; }
/// <summary> /// Dump a hierarchical accessibility report to the debug output window /// </summary> /// <param name="parent">The top element to report on</param> public static void DumpAccessibilityReport(AccessibleObject parent) { DumpAccessibilityReport(parent, ""); }
public CalendarChildAccessibleObject GetCalendarChildAccessibleObject(int calendarIndex, CalendarChildType calendarChildType, AccessibleObject parentAccessibleObject = null, int index = -1) => calendarChildType switch {
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); } } }
protected override AccessibleObject CreateAccessibilityInstance() { AccessibleObject acc; acc = new AccessibleObject(this); acc.role = AccessibleRole.SpinButton; return acc; }
void TypeShortcut(AccessibleObject item) { Sleep(1000); AccessibleObject parent = item.Parent; if (parent.Role == AccessibleRole.MenuItem) { TypeShortcut(parent); } string shortcut = item.KeyboardShortcut; if (!string.IsNullOrEmpty(shortcut)) { SendShortcut(shortcut); } else { throw new NotImplementedException("InvokeAsyncMenuItem can't work without menu item shortcuts"); } if (item.Role == AccessibleRole.MenuItem) { // this isn't working for some reason. // WaitForPopupMenu(); Sleep(200); } }
internal override void SetParent(AccessibleObject parent) { _parentAccessibleObject = parent; }
internal override void SetDetachableChild(AccessibleObject child) { _child = child; }
/// <summary> /// Turn an accessibleObject into an element in the underlying model. /// </summary> /// <param name="accessibleObject">The accessible object</param> /// <param name="returnShape">True to return the shape object corresponding to the /// accessible object instead of the underlying model element. Note that you may get /// a shape for a parent object if the requested accessible object is drawn as part /// of another object and does not have its own shape (roles, internal uniqueness constraints, etc)</param> /// <returns>ModelElement, or null</returns> public ModelElement TranslateAccessibleObject(AccessibleObject accessibleObject, bool returnShape) { DiagramItem hitItem = TranslateAccessibleObjectToDiagramItem(accessibleObject, returnShape); if (hitItem == null) { return null; } else if (returnShape) { return hitItem.Shape; } else { ModelElement retVal = null; foreach (object element in hitItem.RepresentedElements) { retVal = element as ModelElement; break; } PresentationElement pel = retVal as PresentationElement; if (pel != null) { // Resolve to a ModelElement if we don't have one already retVal = pel.ModelElement; } return retVal; } }
internal InternalAccessibleObject(AccessibleObject accessibleImplemention) { // Get all the casts done here to catch any issues early publicIAccessible = (IAccessible) accessibleImplemention; publicIEnumVariant = (UnsafeNativeMethods.IEnumVariant) accessibleImplemention; publicIOleWindow = (UnsafeNativeMethods.IOleWindow) accessibleImplemention; publicIReflect = (IReflect) accessibleImplemention; // Note: Deliberately not holding onto AccessibleObject to enforce all access through the interfaces }
/// <summary> /// Click on an accessible object. The caller should make sure that the /// accessible object is visible before making this call. /// </summary> /// <param name="accessibleObject">A child accessible object to click on</param> /// <param name="clicks">The number of clicks (1 for single click, 2 for double)</param> public void ClickAccessibleObject(AccessibleObject accessibleObject, int clicks) { ClickAccessibleObject(accessibleObject, clicks, ClickLocation.Center, 0, 0); }
public EnumVariantObject(AccessibleObject owner) { this.owner = owner; }
/// <summary> /// End a drag operation with a drop on an accessible object. The caller should make sure that the /// accessible object is visible before making this call. /// </summary> /// <param name="accessibleObject">A child accessible object to drop on</param> public void DropOnAccessibleObject(AccessibleObject accessibleObject) { DropOnAccessibleObject(accessibleObject, ClickLocation.Center, 0, 0); }
public EnumVariantObject(AccessibleObject owner, int currentChild) { this.owner = owner; this.currentChild = currentChild; }
/// <summary> /// Make sure an accessible object is visible. Returns a new AccessibleObject with /// different bounds. Using this method with an "ORMDiagram" accessible object is not /// recommended (it will zoom out the diagram until the full diagram fits in the window). /// Use the EnsurePointVisible method instead to show a specific point on the diagram. /// </summary> /// <param name="accessibleObject">Accessible object to bring into view</param> /// <returns>Updated accessible object</returns> public AccessibleObject EnsureAccessibleObjectVisible(AccessibleObject accessibleObject) { AccessibleObject retVal = accessibleObject; DiagramItem hitItem = TranslateAccessibleObjectToDiagramItem(accessibleObject, false); if (hitItem != null) { myClientView.EnsureVisible(hitItem.AbsoluteBoundingBox); retVal = hitItem.GetAccessibleObject(myClientView); SendKeys.Flush(); } return retVal; }
private IAccessible AsIAccessible(AccessibleObject obj) { if ((obj != null) && obj.systemWrapper) { return obj.systemIAccessible; } return obj; }
private object AsVariant(AccessibleObject obj) { if (obj == this) { return 0; } return this.AsIAccessible(obj); }
/// <summary> /// Perform custom navigation between parent/child/sibling accessible objects, /// using tab index order as the guide, rather than letting the system default /// behavior do navigation based on z-order. /// /// For a container control and its child controls, the accessible object tree /// looks like this... /// /// [client area of container] /// [non-client area of child #1] /// [random non-client elements] /// [client area of child #1] /// [random non-client elements] /// [non-client area of child #2] /// [random non-client elements] /// [client area of child #2] /// [random non-client elements] /// [non-client area of child #3] /// [random non-client elements] /// [client area of child #3] /// [random non-client elements] /// /// We need to intercept first-child / last-child navigation from the container's /// client object, and next-sibling / previous-sibling navigation from each child's /// non-client object. All other navigation operations must be allowed to fall back /// on the system's deafult behavior (provided by OLEACC.DLL). /// /// When combined with the re-ordering behavior of GetSysChildOrder() above, this /// allows us to present the end user with the illusion of accessible objects in /// tab index order, even though the system behavior only supports z-order. /// </summary> internal override bool GetSysChild(AccessibleNavigation navdir, out AccessibleObject accessibleObject) { // Clear the out parameter accessibleObject = null; // Get the owning control's parent, if it has one Control parentControl = Owner.ParentInternal; // ctrls[index] will indicate the control at the destination of this navigation operation int index = -1; Control[] ctrls = null; // Now handle any 'appropriate' navigation requests... switch (navdir) { case AccessibleNavigation.FirstChild: if (IsClientObject) { ctrls = Owner.GetChildControlsInTabOrder(true); index = 0; } break; case AccessibleNavigation.LastChild: if (IsClientObject) { ctrls = Owner.GetChildControlsInTabOrder(true); index = ctrls.Length - 1; } break; case AccessibleNavigation.Previous: if (IsNonClientObject && parentControl != null) { ctrls = parentControl.GetChildControlsInTabOrder(true); index = Array.IndexOf(ctrls, Owner); if (index != -1) { --index; } } break; case AccessibleNavigation.Next: if (IsNonClientObject && parentControl != null) { ctrls = parentControl.GetChildControlsInTabOrder(true); index = Array.IndexOf(ctrls, Owner); if (index != -1) { ++index; } } break; } // Unsupported navigation operation for this object, or unexpected error. // Return false to force fall back on default system navigation behavior. if (ctrls == null || ctrls.Length == 0) { return(false); } // If ctrls[index] is a valid control, return its non-client accessible object. // If index is invalid, return null pointer meaning "end of list reached". if (index >= 0 && index < ctrls.Length) { accessibleObject = ctrls[index].NcAccessibilityObject; } // Return true to use the found accessible object and block default system behavior return(true); }
public EnumVariantObject(AccessibleObject owner, int currentChild) { Debug.Assert(owner != null, "Cannot create EnumVariantObject with a null owner"); this.owner = owner; this.currentChild = currentChild; }
private void WmGetObject(ref Message m) { if (m.LParam == (IntPtr)NativeMethods.UiaRootObjectId) { AccessibleObject uiaProvider = GetChildAccessibleObject(_childWindowType); // If the requested object identifier is UiaRootObjectId, // we should return an UI Automation provider using the UiaReturnRawElementProvider function. InternalAccessibleObject internalAccessibleObject = new InternalAccessibleObject(uiaProvider); m.Result = UiaCore.UiaReturnRawElementProvider( new HandleRef(this, Handle), m.WParam, m.LParam, internalAccessibleObject); return; } // See "How to Handle WM_GETOBJECT" in MSDN // if (unchecked ((int)(long)m.LParam) == OBJID.CLIENT) { // Get the IAccessible GUID // Guid IID_IAccessible = new Guid(NativeMethods.uuid_IAccessible); // Get an Lresult for the accessibility Object for this control // IntPtr punkAcc; try { AccessibleObject wfAccessibleObject = null; UiaCore.IAccessibleInternal iacc = null; if (_accessibilityObject is null) { wfAccessibleObject = GetChildAccessibleObject(_childWindowType); _accessibilityObject = new InternalAccessibleObject(wfAccessibleObject); } iacc = (UiaCore.IAccessibleInternal)_accessibilityObject; // Obtain the Lresult // punkAcc = Marshal.GetIUnknownForObject(iacc); try { m.Result = Oleacc.LresultFromObject(ref IID_IAccessible, m.WParam, new HandleRef(this, punkAcc)); } finally { Marshal.Release(punkAcc); } } catch (Exception e) { throw new InvalidOperationException(SR.RichControlLresult, e); } } else { // m.lparam != OBJID_CLIENT, so do default message processing DefWndProc(ref m); } }
private void WmGetObject(ref Message m) { if (m.LParam == (IntPtr)NativeMethods.UiaRootObjectId && // Managed UIAutomation providers are supplied for child list windows but not for the child edit window. // Child list accessibility object provides all necessary patterns and UIAutomation notifications, // so there is no need to native provider supplement. // Child edit accessibility object has only partial support of edit box accessibility, most of the patterns // and notifications for child edit window are supplied by native providers, so here is no need to // override root UIA object for child edit window. (_childWindowType == ChildWindowType.ListBox || _childWindowType == ChildWindowType.DropDownList)) { AccessibleObject uiaProvider = GetChildAccessibleObject(_childWindowType); // If the requested object identifier is UiaRootObjectId, // we should return an UI Automation provider using the UiaReturnRawElementProvider function. InternalAccessibleObject internalAccessibleObject = new InternalAccessibleObject(uiaProvider); m.Result = UiaCore.UiaReturnRawElementProvider( new HandleRef(this, Handle), m.WParam, m.LParam, internalAccessibleObject); return; } // See "How to Handle WM_GETOBJECT" in MSDN // if (unchecked ((int)(long)m.LParam) == OBJID.CLIENT) { // Get the IAccessible GUID // Guid IID_IAccessible = new Guid(NativeMethods.uuid_IAccessible); // Get an Lresult for the accessibility Object for this control // IntPtr punkAcc; try { AccessibleObject wfAccessibleObject = null; UiaCore.IAccessibleInternal iacc = null; if (_accessibilityObject is null) { wfAccessibleObject = GetChildAccessibleObject(_childWindowType); _accessibilityObject = new InternalAccessibleObject(wfAccessibleObject); } iacc = (UiaCore.IAccessibleInternal)_accessibilityObject; // Obtain the Lresult // punkAcc = Marshal.GetIUnknownForObject(iacc); try { m.Result = Oleacc.LresultFromObject(ref IID_IAccessible, m.WParam, new HandleRef(this, punkAcc)); } finally { Marshal.Release(punkAcc); } } catch (Exception e) { throw new InvalidOperationException(SR.RichControlLresult, e); } } else { // m.lparam != OBJID_CLIENT, so do default message processing DefWndProc(ref m); } }
public CalendarCellAccessibleObject(MonthCalendarAccessibleObject calendarAccessibleObject, int calendarIndex, AccessibleObject parentAccessibleObject, int rowIndex, int columnIndex, string name) : base(calendarAccessibleObject, calendarIndex, CalendarChildType.CalendarCell, parentAccessibleObject, rowIndex * columnIndex) { _rowIndex = rowIndex; _columnIndex = columnIndex; _name = name; }
public AutoHideStripAccessibleObject(AutoHideStrip strip, DockState state, AccessibleObject parent) { _strip = strip; _state = state; Parent = parent; }