// ------------------------------------------------------------- // UIAutomationCore.idl // // UIAutomation interface definitions and related types and enums // // Copyright (c) Microsoft Corporation. All rights reserved. // ------------------------------------------------------------- cpp_quote("// -------------------------------------------------------------") cpp_quote("// UIAutomationCore.H") cpp_quote("//") cpp_quote("// UIAutomation interface definitions and related types and enums") cpp_quote("// (Generated from UIAutomationCore.idl)") cpp_quote("//") cpp_quote("// Copyright (c) Microsoft Corporation. All rights reserved.") cpp_quote("// -------------------------------------------------------------") #define DO_NO_IMPORTS import "oaidl.idl"; import "oleacc.idl"; // Base enums enum NavigateDirection { NavigateDirection_Parent = 0, NavigateDirection_NextSibling = 1, NavigateDirection_PreviousSibling = 2, NavigateDirection_FirstChild = 3, NavigateDirection_LastChild = 4 }; enum ProviderOptions { ProviderOptions_ClientSideProvider = 0x0001, ProviderOptions_ServerSideProvider = 0x0002, ProviderOptions_NonClientAreaProvider = 0x0004, ProviderOptions_OverrideProvider = 0x0008, ProviderOptions_ProviderOwnsSetFocus = 0x0010, ProviderOptions_UseComThreading = 0x0020 }; cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(ProviderOptions)") // Pattern, Event & property enums enum StructureChangeType { StructureChangeType_ChildAdded, StructureChangeType_ChildRemoved, StructureChangeType_ChildrenInvalidated, StructureChangeType_ChildrenBulkAdded, StructureChangeType_ChildrenBulkRemoved, StructureChangeType_ChildrenReordered, }; enum OrientationType { OrientationType_None = 0, OrientationType_Horizontal = 1, OrientationType_Vertical = 2 }; enum DockPosition { DockPosition_Top = 0, DockPosition_Left = 1, DockPosition_Bottom = 2, DockPosition_Right = 3, DockPosition_Fill = 4, DockPosition_None = 5 }; enum ExpandCollapseState { ExpandCollapseState_Collapsed = 0, ExpandCollapseState_Expanded = 1, ExpandCollapseState_PartiallyExpanded = 2, ExpandCollapseState_LeafNode = 3 }; enum ScrollAmount { ScrollAmount_LargeDecrement = 0, ScrollAmount_SmallDecrement = 1, ScrollAmount_NoAmount = 2, ScrollAmount_LargeIncrement = 3, ScrollAmount_SmallIncrement = 4 }; enum RowOrColumnMajor { RowOrColumnMajor_RowMajor = 0, RowOrColumnMajor_ColumnMajor = 1, RowOrColumnMajor_Indeterminate = 2 }; enum ToggleState { ToggleState_Off = 0, ToggleState_On = 1, ToggleState_Indeterminate = 2 }; enum WindowVisualState { WindowVisualState_Normal = 0, WindowVisualState_Maximized = 1, WindowVisualState_Minimized = 2 }; enum SynchronizedInputType { SynchronizedInputType_KeyUp = 0x01, SynchronizedInputType_KeyDown = 0x02, SynchronizedInputType_LeftMouseUp = 0x04, SynchronizedInputType_LeftMouseDown = 0x08, SynchronizedInputType_RightMouseUp = 0x10, SynchronizedInputType_RightMouseDown = 0x20 }; cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(SynchronizedInputType)") enum WindowInteractionState { WindowInteractionState_Running = 0, WindowInteractionState_Closing = 1, WindowInteractionState_ReadyForUserInteraction = 2, WindowInteractionState_BlockedByModalWindow = 3, WindowInteractionState_NotResponding = 4 }; // Text enums enum TextUnit { TextUnit_Character = 0, TextUnit_Format = 1, TextUnit_Word = 2, TextUnit_Line = 3, TextUnit_Paragraph = 4, TextUnit_Page = 5, TextUnit_Document = 6 }; enum TextPatternRangeEndpoint { TextPatternRangeEndpoint_Start = 0, TextPatternRangeEndpoint_End = 1 }; enum SupportedTextSelection { SupportedTextSelection_None = 0, SupportedTextSelection_Single = 1, SupportedTextSelection_Multiple = 2 }; // Text attributes enum AnimationStyle { AnimationStyle_None = 0, AnimationStyle_LasVegasLights = 1, AnimationStyle_BlinkingBackground = 2, AnimationStyle_SparkleText = 3, AnimationStyle_MarchingBlackAnts = 4, AnimationStyle_MarchingRedAnts = 5, AnimationStyle_Shimmer = 6, AnimationStyle_Other = -1 }; enum BulletStyle { BulletStyle_None = 0, BulletStyle_HollowRoundBullet = 1, BulletStyle_FilledRoundBullet = 2, BulletStyle_HollowSquareBullet = 3, BulletStyle_FilledSquareBullet = 4, BulletStyle_DashBullet = 5, BulletStyle_Other = -1 }; enum CapStyle { CapStyle_None = 0, CapStyle_SmallCap = 1, CapStyle_AllCap = 2, CapStyle_AllPetiteCaps = 3, CapStyle_PetiteCaps = 4, CapStyle_Unicase = 5, CapStyle_Titling = 6, CapStyle_Other = -1 }; enum FlowDirections { FlowDirections_Default = 0, FlowDirections_RightToLeft = 1, FlowDirections_BottomToTop = 2, FlowDirections_Vertical = 4 }; enum HorizontalTextAlignment { HorizontalTextAlignment_Left = 0, HorizontalTextAlignment_Centered = 1, HorizontalTextAlignment_Right = 2, HorizontalTextAlignment_Justified = 3 }; enum OutlineStyles { OutlineStyles_None = 0, OutlineStyles_Outline = 1, OutlineStyles_Shadow = 2, OutlineStyles_Engraved = 4, OutlineStyles_Embossed = 8 }; enum TextDecorationLineStyle { TextDecorationLineStyle_None = 0, TextDecorationLineStyle_Single = 1, TextDecorationLineStyle_WordsOnly = 2, TextDecorationLineStyle_Double = 3, TextDecorationLineStyle_Dot = 4, TextDecorationLineStyle_Dash = 5, TextDecorationLineStyle_DashDot = 6, TextDecorationLineStyle_DashDotDot = 7, TextDecorationLineStyle_Wavy = 8, TextDecorationLineStyle_ThickSingle = 9, TextDecorationLineStyle_DoubleWavy = 11, TextDecorationLineStyle_ThickWavy = 12, TextDecorationLineStyle_LongDash = 13, TextDecorationLineStyle_ThickDash = 14, TextDecorationLineStyle_ThickDashDot = 15, TextDecorationLineStyle_ThickDashDotDot = 16, TextDecorationLineStyle_ThickDot = 17, TextDecorationLineStyle_ThickLongDash = 18, TextDecorationLineStyle_Other = -1, }; // Types... typedef int PROPERTYID; typedef int PATTERNID; typedef int EVENTID; typedef int TEXTATTRIBUTEID; typedef int CONTROLTYPEID; struct UiaRect { double left; double top; double width; double height; }; struct UiaPoint { double x; double y; }; [ uuid(930299ce-9965-4dec-b0f4-a54848d4b667), lcid(0), version(1.0), hidden ] library UIA { importlib ("stdole2.tlb"); [dllname("")] module UIA_OtherConstants { const double UIA_ScrollPatternNoScroll = -1; } // // IRawElementProviderSimple // [object, uuid(d6dd68d1-86fd-4332-8666-9abedea2d24c), pointer_default(unique)] interface IRawElementProviderSimple : IUnknown { [propget] HRESULT ProviderOptions ( [out, retval] enum ProviderOptions * pRetVal ); HRESULT GetPatternProvider ( [in] PATTERNID patternId, [out, retval] IUnknown ** pRetVal ); HRESULT GetPropertyValue ( [in] PROPERTYID propertyId, [out, retval] VARIANT * pRetVal ); [propget] HRESULT HostRawElementProvider ( [out, retval] IRawElementProviderSimple ** pRetVal ); } // // IAccessibleEx // [object, uuid(f8b80ada-2c44-48d0-89be-5ff23c9cd875), pointer_default(unique), oleautomation] interface IAccessibleEx: IUnknown { // Returns the IAccessibleEx for specified child. Returns // S_OK/NULL if this implementation does not use child ids, // or does not have an IAccessibleEx for the specified child, // or already represents a child element. // idChild must be normalized; ie. client must have previously // used get_accChild to check whether it actually has its own // IAccessible. Only idChild values that do not have a corresponding // IAccessible can be used here. HRESULT GetObjectForChild ( [in] long idChild, [out, retval] IAccessibleEx ** pRetVal ); // Returns an IAccessible and idChild pair for this IAccessibleEx. // Implementation must return fully normalized idChild values: ie. // it is not required to call get_accChild on the resulting pair. // // For IAccessible implementations that do not use child ids, this // just returns the corresponding IAccessible and CHILDID_SELF. HRESULT GetIAccessiblePair( [out] IAccessible ** ppAcc, [out] long * pidChild ); HRESULT GetRuntimeId ( [out,retval] SAFEARRAY(int) * pRetVal ); // Some wrapper-based implementations (notably UIABridge) can't reasonably wrap all // IRawElementProviderSimple elements returned as property values or patterns, so // these elements won't QI to IAccessibleEx. Where this is the case, the original // IAccessibleEx that the property was retreived from must implement this method // so that the client can get an IAccessibleEx. // // Usage for a client is as follows: // When an IRawElementProviderSimple is obtained as a property value, // - first try to QI to IAccessibleEx // - if that fails, call this method on the source IAccessibleEx HRESULT ConvertReturnedElement ( [in] IRawElementProviderSimple * pIn, [out] IAccessibleEx ** ppRetValOut); } interface IRawElementProviderFragmentRoot; // // IRawElementProviderFragment // [object, uuid(f7063da8-8359-439c-9297-bbc5299a7d87), pointer_default(unique)] interface IRawElementProviderFragment : IUnknown { HRESULT Navigate ( [in] enum NavigateDirection direction, [out, retval] IRawElementProviderFragment ** pRetVal ); HRESULT GetRuntimeId ( [out,retval] SAFEARRAY(int) * pRetVal ); HRESULT get_BoundingRectangle ( [out,retval] struct UiaRect * pRetVal ); HRESULT GetEmbeddedFragmentRoots ( [out,retval] SAFEARRAY(IRawElementProviderFragmentRoot*) * pRetVal ); HRESULT SetFocus (); [propget] HRESULT FragmentRoot ( [out, retval] IRawElementProviderFragmentRoot ** pRetVal ); } // // IRawElementProviderFragmentRoot // [object, uuid(620ce2a5-ab8f-40a9-86cb-de3c75599b58), pointer_default(unique)] interface IRawElementProviderFragmentRoot : IUnknown { HRESULT ElementProviderFromPoint ( [in] double x, [in] double y, [out, retval] IRawElementProviderFragment ** pRetVal ); HRESULT GetFocus ( [out,retval] IRawElementProviderFragment ** pRetVal ); } // // IRawElementProviderAdviseEvents // [object, uuid(a407b27b-0f6d-4427-9292-473c7bf93258), pointer_default(unique)] interface IRawElementProviderAdviseEvents : IUnknown { HRESULT AdviseEventAdded ( [in] EVENTID eventId, [in] SAFEARRAY(PROPERTYID) propertyIDs); HRESULT AdviseEventRemoved( [in] EVENTID eventId, [in] SAFEARRAY(PROPERTYID) propertyIDs); } // // IRawElementProviderHwndOverride // [object, uuid(1d5df27c-8947-4425-b8d9-79787bb460b8), pointer_default(unique)] interface IRawElementProviderHwndOverride : IUnknown { HRESULT GetOverrideProviderForHwnd( [in] HWND hwnd, [out, retval] IRawElementProviderSimple ** pRetVal); } // // IProxyProviderWinEventSink // // This is provided by UiaCore when it calls IProxyProviderWinEventHandler::RespondToWinEvent // It stores up the events added to it, and when RespondToWinEvent returns, it passes // the events back to the client side, where they are actually fired. [object, uuid(4fd82b78-a43e-46ac-9803-0a6969c7c183), pointer_default(unique)] interface IProxyProviderWinEventSink : IUnknown { HRESULT AddAutomationPropertyChangedEvent( [in] IRawElementProviderSimple * pProvider, [in] PROPERTYID id, [in] VARIANT newValue); HRESULT AddAutomationEvent( [in] IRawElementProviderSimple * pProvider, [in] EVENTID id); HRESULT AddStructureChangedEvent( [in] IRawElementProviderSimple * pProvider, [in] enum StructureChangeType structureChangeType, [in] SAFEARRAY(int) runtimeId); } // // IProxyProviderWinEventHandler // // A Proxy that registers to receive certain WinEvents should implement this interface // When the core receives a WinEvent it will create the proxy the call this method on it. // // This pattern is only meant to be used by registered proxies. // // When responding to WinEvents, RespondToWinEvent should not actually fire Events directly, // it should use the Add*Event methods on the provided IProxyProviderWinEventSink [object, uuid(89592ad4-f4e0-43d5-a3b6-bad7e111b435), pointer_default(unique)] interface IProxyProviderWinEventHandler : IUnknown { HRESULT RespondToWinEvent ( [in] DWORD idWinEvent, [in] HWND hwnd, [in] LONG idObject, [in] LONG idChild, [in] IProxyProviderWinEventSink* pSink); } // // Control Pattern Interfaces... // [object, uuid(159bc72c-4ad3-485e-9637-d7052edf0146), pointer_default(unique)] interface IDockProvider : IUnknown { HRESULT SetDockPosition ( [in] enum DockPosition dockPosition ); [propget] HRESULT DockPosition ( [out, retval] enum DockPosition * pRetVal ); }; [object, uuid(d847d3a5-cab0-4a98-8c32-ecb45c59ad24), pointer_default(unique)] interface IExpandCollapseProvider : IUnknown { HRESULT Expand (); HRESULT Collapse (); [propget] HRESULT ExpandCollapseState ( [out, retval] enum ExpandCollapseState * pRetVal ); }; [object, uuid(b17d6187-0907-464b-a168-0ef17a1572b1), pointer_default(unique)] interface IGridProvider : IUnknown { HRESULT GetItem ( [in] int row, [in] int column, [out, retval] IRawElementProviderSimple ** pRetVal ); [propget] HRESULT RowCount ( [out, retval] int * pRetVal ); [propget] HRESULT ColumnCount ( [out, retval] int * pRetVal ); }; [object, uuid(d02541f1-fb81-4d64-ae32-f520f8a6dbd1), pointer_default(unique)] interface IGridItemProvider : IUnknown { [propget] HRESULT Row ( [out, retval] int * pRetVal ); [propget] HRESULT Column ( [out, retval] int * pRetVal ); [propget] HRESULT RowSpan ( [out, retval] int * pRetVal ); [propget] HRESULT ColumnSpan ( [out, retval] int * pRetVal ); [propget] HRESULT ContainingGrid ( [out, retval] IRawElementProviderSimple ** pRetVal ); }; [object, uuid(54fcb24b-e18e-47a2-b4d3-eccbe77599a2), pointer_default(unique)] interface IInvokeProvider : IUnknown { HRESULT Invoke (); }; [object, uuid(6278cab1-b556-4a1a-b4e0-418acc523201), pointer_default(unique)] interface IMultipleViewProvider : IUnknown { HRESULT GetViewName ( [in] int viewId, [out, retval] BSTR * pRetVal ); HRESULT SetCurrentView ( [in] int viewId ); [propget] HRESULT CurrentView ( [out, retval] int * pRetVal ); HRESULT GetSupportedViews ( [out, retval] SAFEARRAY(int) * pRetVal ); }; [object, uuid(36dc7aef-33e6-4691-afe1-2be7274b3d33), pointer_default(unique)] interface IRangeValueProvider : IUnknown { HRESULT SetValue ( [in] double val ); [propget] HRESULT Value ( [out, retval] double * pRetVal ); [propget] HRESULT IsReadOnly ( [out, retval] BOOL * pRetVal ); [propget] HRESULT Maximum ( [out, retval] double * pRetVal ); [propget] HRESULT Minimum ( [out, retval] double * pRetVal ); [propget] HRESULT LargeChange ( [out, retval] double * pRetVal ); [propget] HRESULT SmallChange ( [out, retval] double * pRetVal ); }; [object, uuid(2360c714-4bf1-4b26-ba65-9b21316127eb), pointer_default(unique)] interface IScrollItemProvider : IUnknown { HRESULT ScrollIntoView (); }; [object, uuid(fb8b03af-3bdf-48d4-bd36-1a65793be168), pointer_default(unique)] interface ISelectionProvider : IUnknown { HRESULT GetSelection ( [out, retval] SAFEARRAY(IRawElementProviderSimple *) * pRetVal ); [propget] HRESULT CanSelectMultiple ( [out, retval] BOOL * pRetVal ); [propget] HRESULT IsSelectionRequired ( [out, retval] BOOL * pRetVal ); }; [object, uuid(b38b8077-1fc3-42a5-8cae-d40c2215055a), pointer_default(unique)] interface IScrollProvider : IUnknown { HRESULT Scroll ( [in] enum ScrollAmount horizontalAmount, [in] enum ScrollAmount verticalAmount ); HRESULT SetScrollPercent ( [in] double horizontalPercent, [in] double verticalPercent ); [propget] HRESULT HorizontalScrollPercent ( [out, retval] double * pRetVal ); [propget] HRESULT VerticalScrollPercent ( [out, retval] double * pRetVal ); [propget] HRESULT HorizontalViewSize ( [out, retval] double * pRetVal ); [propget] HRESULT VerticalViewSize ( [out, retval] double * pRetVal ); [propget] HRESULT HorizontallyScrollable ( [out, retval] BOOL * pRetVal ); [propget] HRESULT VerticallyScrollable ( [out, retval] BOOL * pRetVal ); }; [object, uuid(2acad808-b2d4-452d-a407-91ff1ad167b2), pointer_default(unique)] interface ISelectionItemProvider : IUnknown { HRESULT Select (); HRESULT AddToSelection (); HRESULT RemoveFromSelection (); [propget] HRESULT IsSelected ( [out, retval] BOOL * pRetVal ); [propget] HRESULT SelectionContainer ( [out, retval] IRawElementProviderSimple ** pRetVal ); }; [object, uuid(29db1a06-02ce-4cf7-9b42-565d4fab20ee), pointer_default(unique)] interface ISynchronizedInputProvider : IUnknown { HRESULT StartListening ( [in] enum SynchronizedInputType inputType ); HRESULT Cancel (); }; [object, uuid(9c860395-97b3-490a-b52a-858cc22af166), pointer_default(unique)] interface ITableProvider : IUnknown { HRESULT GetRowHeaders ( [out, retval] SAFEARRAY(IRawElementProviderSimple*) * pRetVal ); HRESULT GetColumnHeaders ( [out, retval] SAFEARRAY(IRawElementProviderSimple*) * pRetVal ); [propget] HRESULT RowOrColumnMajor ( [out, retval] enum RowOrColumnMajor * pRetVal ); }; [object, uuid(b9734fa6-771f-4d78-9c90-2517999349cd), pointer_default(unique)] interface ITableItemProvider : IUnknown { HRESULT GetRowHeaderItems ( [out, retval] SAFEARRAY(IRawElementProviderSimple*) * pRetVal ); HRESULT GetColumnHeaderItems ( [out, retval] SAFEARRAY(IRawElementProviderSimple*) * pRetVal ); }; [object, uuid(56d00bd0-c4f4-433c-a836-1a52a57e0892), pointer_default(unique)] interface IToggleProvider : IUnknown { HRESULT Toggle (); [propget] HRESULT ToggleState ( [out, retval] enum ToggleState * pRetVal ); }; [object, uuid(6829ddc4-4f91-4ffa-b86f-bd3e2987cb4c), pointer_default(unique)] interface ITransformProvider : IUnknown { HRESULT Move ( [in] double x, [in] double y ); HRESULT Resize ( [in] double width, [in] double height ); HRESULT Rotate ( [in] double degrees ); [propget] HRESULT CanMove ( [out, retval] BOOL * pRetVal ); [propget] HRESULT CanResize ( [out, retval] BOOL * pRetVal ); [propget] HRESULT CanRotate ( [out, retval] BOOL * pRetVal ); }; [object, uuid(c7935180-6fb3-4201-b174-7df73adbf64a), pointer_default(unique)] interface IValueProvider : IUnknown { HRESULT SetValue ( [in] LPCWSTR val ); [propget] HRESULT Value ( [out, retval] BSTR * pRetVal ); [propget] HRESULT IsReadOnly ( [out, retval] BOOL * pRetVal ); }; [object, uuid(987df77b-db06-4d77-8f8a-86a9c3bb90b9), pointer_default(unique)] interface IWindowProvider : IUnknown { HRESULT SetVisualState ( [in] enum WindowVisualState state ); HRESULT Close (); HRESULT WaitForInputIdle ( [in] int milliseconds, [out, retval] BOOL * pRetVal ); [propget] HRESULT CanMaximize ( [out, retval] BOOL * pRetVal ); [propget] HRESULT CanMinimize ( [out, retval] BOOL * pRetVal ); [propget] HRESULT IsModal ( [out, retval] BOOL * pRetVal ); [propget] HRESULT WindowVisualState ( [out, retval] enum WindowVisualState * pRetVal ); [propget] HRESULT WindowInteractionState ( [out, retval] enum WindowInteractionState * pRetVal ); [propget] HRESULT IsTopmost ( [out, retval] BOOL * pRetVal ); }; [object, uuid(e44c3566-915d-4070-99c6-047bff5a08f5), pointer_default(unique)] interface ILegacyIAccessibleProvider : IUnknown { HRESULT Select ( long flagsSelect ); HRESULT DoDefaultAction (); HRESULT SetValue ( LPCWSTR szValue ); HRESULT GetIAccessible ( [out, retval] IAccessible ** ppAccessible ); [propget] HRESULT ChildId ( [out, retval] int * pRetVal ); [propget] HRESULT Name ( [out, retval] BSTR * pszName ); [propget] HRESULT Value ( [out, retval] BSTR * pszValue ); [propget] HRESULT Description ( [out, retval] BSTR * pszDescription ); [propget] HRESULT Role ( [out, retval] DWORD * pdwRole ); [propget] HRESULT State ( [out, retval] DWORD * pdwState ); [propget] HRESULT Help ( [out, retval] BSTR * pszHelp ); [propget] HRESULT KeyboardShortcut ( [out, retval] BSTR * pszKeyboardShortcut ); HRESULT GetSelection ( [out, retval] SAFEARRAY(IRawElementProviderSimple *) * pvarSelectedChildren ); [propget] HRESULT DefaultAction ( [out, retval] BSTR * pszDefaultAction ); }; [object, uuid(e747770b-39ce-4382-ab30-d8fb3f336f24), pointer_default(unique)] interface IItemContainerProvider : IUnknown { // Find item by specified property/value. May return actual // AutomationElement or a placeholder if the matching element is // virtualized. // Returns E_INVALIDARG if the property requested is not one that the // container supports searching over. Expected that most containers will // support Name property, and if appropriate for the container, // AutomationId and IsSelected. // // This method is expected to be relatively slow, since it may need to // traverse multiple objects in order to find a matching one. // When used in a loop to return multiple items, no specific order is // defined so long as each item is returned only once (ie. loop should // terminate). This method is also item-centric, not UI-centric, so items // with multiple UI representations need only be returned once. // // A special propertyId of 0 means 'match all items'. This can be used // with pStartAfter=NULL to get the first item, and then to get successive // items. Value should be VT_EMPTY in this case. HRESULT FindItemByProperty([in] IRawElementProviderSimple * pStartAfter, [in] PROPERTYID propertyId, [in] VARIANT value, [out, retval] IRawElementProviderSimple ** pFound); }; [object, uuid(cb98b665-2d35-4fac-ad35-f3c60d0c0b8b), pointer_default(unique)] interface IVirtualizedItemProvider : IUnknown { // Request that a placeholder element make itself fully available. Blocks // until element is available, which could take time. // Returns S_OK if item is already available. // Parent control may scroll as a side effect if the container needs to // being the item into view in order to devirtualize it. HRESULT Realize(); }; interface ITextRangeProvider; [object, uuid(3589c92c-63f3-4367-99bb-ada653b77cf2), pointer_default(unique)] interface ITextProvider : IUnknown { HRESULT GetSelection ( [out, retval] SAFEARRAY(ITextRangeProvider *) * pRetVal ); HRESULT GetVisibleRanges ( [out, retval] SAFEARRAY(ITextRangeProvider *) * pRetVal ); HRESULT RangeFromChild ( [in] IRawElementProviderSimple * childElement, [out, retval] ITextRangeProvider ** pRetVal ); HRESULT RangeFromPoint ( [in] struct UiaPoint point, [out, retval] ITextRangeProvider ** pRetVal ); [propget] HRESULT DocumentRange ( [out, retval] ITextRangeProvider ** pRetVal ); [propget] HRESULT SupportedTextSelection ( [out, retval] enum SupportedTextSelection * pRetVal ); }; [object, uuid(5347ad7b-c355-46f8-aff5-909033582f63), pointer_default(unique)] interface ITextRangeProvider : IUnknown { HRESULT Clone ( [out, retval] ITextRangeProvider ** pRetVal ); HRESULT Compare ( [in] ITextRangeProvider * range, [out, retval] BOOL * pRetVal ); HRESULT CompareEndpoints ( [in] enum TextPatternRangeEndpoint endpoint, [in] ITextRangeProvider * targetRange, [in] enum TextPatternRangeEndpoint targetEndpoint, [out, retval] int * pRetVal ); HRESULT ExpandToEnclosingUnit ( [in] enum TextUnit unit ); HRESULT FindAttribute ( [in] TEXTATTRIBUTEID attributeId, [in] VARIANT val, [in] BOOL backward, [out, retval] ITextRangeProvider ** pRetVal ); HRESULT FindText ( [in] BSTR text, [in] BOOL backward, [in] BOOL ignoreCase, [out, retval] ITextRangeProvider ** pRetVal ); HRESULT GetAttributeValue ( [in] TEXTATTRIBUTEID attributeId, [out, retval] VARIANT * pRetVal ); HRESULT GetBoundingRectangles ( [out, retval] SAFEARRAY(double) * pRetVal ); HRESULT GetEnclosingElement ( [out, retval] IRawElementProviderSimple ** pRetVal ); HRESULT GetText ( [in] int maxLength, [out, retval] BSTR * pRetVal ); HRESULT Move ( [in] enum TextUnit unit, [in] int count, [out, retval] int * pRetVal ); HRESULT MoveEndpointByUnit ( [in] enum TextPatternRangeEndpoint endpoint, [in] enum TextUnit unit, [in] int count, [out, retval] int * pRetVal ); HRESULT MoveEndpointByRange ( [in] enum TextPatternRangeEndpoint endpoint, [in] ITextRangeProvider * targetRange, [in] enum TextPatternRangeEndpoint targetEndpoint ); HRESULT Select (); HRESULT AddToSelection (); HRESULT RemoveFromSelection (); HRESULT ScrollIntoView ( [in] BOOL alignToTop ); HRESULT GetChildren ( [out, retval] SAFEARRAY(IRawElementProviderSimple*) * pRetVal ); }; // // User-registered property, event and pattern support... // // Used to specify property types, and method parameter types. // UI Automation needs more information than just a VT_/VARTYPE. Note that some // types get special handling - eg. Rect and Points get translated with DPI. enum UIAutomationType { UIAutomationType_Int = 0x0001, UIAutomationType_Bool = 0x0002, UIAutomationType_String = 0x0003, UIAutomationType_Double = 0x0004, UIAutomationType_Point = 0x0005, UIAutomationType_Rect = 0x0006, UIAutomationType_Element = 0x0007, UIAutomationType_Array = 0x00010000, UIAutomationType_Out = 0x00020000, UIAutomationType_IntArray = (UIAutomationType_Int | UIAutomationType_Array), UIAutomationType_BoolArray = (UIAutomationType_Bool | UIAutomationType_Array), UIAutomationType_StringArray = (UIAutomationType_String | UIAutomationType_Array), UIAutomationType_DoubleArray = (UIAutomationType_Double | UIAutomationType_Array), UIAutomationType_PointArray = (UIAutomationType_Point | UIAutomationType_Array), UIAutomationType_RectArray = (UIAutomationType_Rect | UIAutomationType_Array), UIAutomationType_ElementArray = (UIAutomationType_Element | UIAutomationType_Array), UIAutomationType_OutInt = (UIAutomationType_Int | UIAutomationType_Out), UIAutomationType_OutBool = (UIAutomationType_Bool | UIAutomationType_Out), UIAutomationType_OutString = (UIAutomationType_String | UIAutomationType_Out), UIAutomationType_OutDouble = (UIAutomationType_Double | UIAutomationType_Out), UIAutomationType_OutPoint = (UIAutomationType_Point | UIAutomationType_Out), UIAutomationType_OutRect = (UIAutomationType_Rect | UIAutomationType_Out), UIAutomationType_OutElement = (UIAutomationType_Element | UIAutomationType_Out), UIAutomationType_OutIntArray = (UIAutomationType_Int | UIAutomationType_Array | UIAutomationType_Out), UIAutomationType_OutBoolArray = (UIAutomationType_Bool | UIAutomationType_Array | UIAutomationType_Out), UIAutomationType_OutStringArray = (UIAutomationType_String | UIAutomationType_Array | UIAutomationType_Out), UIAutomationType_OutDoubleArray = (UIAutomationType_Double | UIAutomationType_Array | UIAutomationType_Out), UIAutomationType_OutPointArray = (UIAutomationType_Point | UIAutomationType_Array | UIAutomationType_Out), UIAutomationType_OutRectArray = (UIAutomationType_Rect | UIAutomationType_Array | UIAutomationType_Out), UIAutomationType_OutElementArray = (UIAutomationType_Element | UIAutomationType_Array | UIAutomationType_Out), }; cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(UIAutomationType)") struct UIAutomationParameter { enum UIAutomationType type; void * pData; }; struct UIAutomationPropertyInfo { GUID guid; LPCWSTR pProgrammaticName; enum UIAutomationType type; }; struct UIAutomationEventInfo { GUID guid; LPCWSTR pProgrammaticName; }; struct UIAutomationMethodInfo { LPCWSTR pProgrammaticName; BOOL doSetFocus; UINT cInParameters; UINT cOutParameters; // Parameters are always in params followed by out params [size_is(cInParameters + cOutParameters)] enum UIAutomationType * pParameterTypes; // Param names used for debugging/diagnostics [size_is(cInParameters + cOutParameters)] LPCWSTR * pParameterNames; // Most methods require the object to have focus as a precondition, set this // to true if this is such a method, and UIA will do the SetFocus call // automatically first. }; // For a given pattern, a single index is used to specify both its properties and // its methods. The first property is 0, followed by the other properties, followed // by methods. This index is used in some of the methods below. // Total number of indices == cProperties + cMethods. // This interface is implemented by UIA and represents a pattern object; the // client API wrapper sits on top of this, and implements all property/method // calls in terms of GetProperty and CallMethod. [object, uuid(c03a7fe4-9431-409f-bed8-ae7c2299bc8d), pointer_default(unique)] interface IUIAutomationPatternInstance : IUnknown { // Client wrapper object implements get_CurrentXxxx and get_CachedXxxx // by calling through to this, specifying the property by index. pPtr is // the [out] pointer from the getter, passed as-is. UIA knows its type from // the meta-data, and assigns to it appropriately. [local] HRESULT GetProperty( [in] UINT index, // must be a property index [in] BOOL cached, [in] enum UIAutomationType type, [out] void * pPtr); // Client wrapper implements methods by calling through to this, specifying the // paramters as an array of void*'s; in params (passed by address) followed by // out params (which are passed as-is, since they are already pointers). // (UIA already knows the count and types from the metadata) [local] HRESULT CallMethod( [in] UINT index, // must be a method index [in] const struct UIAutomationParameter * pParams, [in] UINT cParams); }; // This interface is implemented by the 3rd party pattern supplier, and is // responsible for returning a client API wrapper object, and for unmarhalling // property and method requests to an actual provider instance. // The PatternHandler object is stateless, so can be implemented by a singleton. [object, uuid(d97022f3-a947-465e-8b2a-ac4315fa54e8), pointer_default(unique)] interface IUIAutomationPatternHandler : IUnknown { // UIA calls this when it needs to return a wrapper to the client. UIA supplies // the pPatternInstance, which the client wrapper calls through to. HRESULT CreateClientWrapper ( [in] IUIAutomationPatternInstance * pPatternInstance, [out] IUnknown ** pClientWrapper ); // UIA calls this to dispatch a property getter or method call to an actual // provider interface object. The implementation should cast pTarget as // appropriate, and call the property getter or method indicated by index, // passing the parameters from the pParams array, and casting appropriately. // (Since UIA knows what the parameters and types are, it sets up a param // array of the appropriate size and types.) [local] HRESULT Dispatch ( [in] IUnknown * pTarget, // target provider, already QI'd [in] UINT index, // may be property or method index [in] const struct UIAutomationParameter * pParams, [in] UINT cParams); } // This struct specifies a pattern, in terms of its identifiers, properties // methods, events, and handler... struct UIAutomationPatternInfo { GUID guid; LPCWSTR pProgrammaticName; GUID providerInterfaceId; GUID clientInterfaceId; UINT cProperties; [size_is(cProperties)] struct UIAutomationPropertyInfo * pProperties; UINT cMethods; [size_is(cMethods)] struct UIAutomationMethodInfo * pMethods; UINT cEvents; [size_is(cEvents)] struct UIAutomationEventInfo * pEvents; IUIAutomationPatternHandler * pPatternHandler; }; // Additional methods added to new IUIAutomationRegistrar object for registering // patterns, properties and events; and for getting the patterns/properties supported // by an object. [object, uuid(8609c4ec-4a1a-4d88-a357-5a66e060e1cf), pointer_default(unique)] interface IUIAutomationRegistrar : IUnknown { // Register a general element property; the returned ID can then be used in the // various APIs (GetCurrentPropertyValue, PropertyCondition, etc.) // (Can also be used as a WinEvent value for IAccEx property change events) HRESULT RegisterProperty( [in] const struct UIAutomationPropertyInfo * property, [out] PROPERTYID * propertyId); // same as for winevent // Register a general element event; the returned ID can then be used in the // various event APIs. // (Also can be used as a WinEvent value for IAccEx events) HRESULT RegisterEvent( [in] const struct UIAutomationEventInfo * event, [out] EVENTID * eventId); // same as for winevent // Register a pattern; returns identifiers for the pattern (and its availability // property), and an array of ids for associated properties and events. // (Pattern and Event IDs can also can be used as a WinEvent value for IAccEx // events) HRESULT RegisterPattern( [in] const struct UIAutomationPatternInfo * pattern, [out] PATTERNID * pPatternId, [out] PROPERTYID * pPatternAvailablePropertyId, [in] UINT propertyIdCount, [out, size_is(propertyIdCount)] PROPERTYID * pPropertyIds, [in] UINT eventIdCount, [out, size_is(eventIdCount)] EVENTID * pEventIds); }; // // CUIAutomationRegistrar // [ uuid(6e29fabf-9977-42d1-8d0e-ca7e61ad87e6), version(1.0), helpstring("Class for registering UIAutomation patterns, properties and events.") ] coclass CUIAutomationRegistrar { [default] interface IUIAutomationRegistrar; } }