// -------------------------------------------------------------
// 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("<no entry points>")]
    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;
    }

}

