oleacc.idl File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
interface	IAccessible
interface	IAccessibleHandler
interface	IAccIdentity
interface	IAccPropServer
interface	IAccPropServices
class	Accessibility::CAccPropServices

Modules
library	Accessibility

Macros
#define	threading(model)

Typedefs
typedef GUID	MSAAPROPID
typedef enum AnnoScope	AnnoScope

Enumerations
enum	AnnoScope { ANNO_THIS , ANNO_CONTAINER }

Functions
	Accessibility::importlib ("stdole2.tlb")
	DEFINE_GUID (CLSID_AccPropServices, 0xb5f8350b, 0x0548, 0x48b1, 0xa6, 0xee, 0x88, 0xbd, 0x00, 0xb4, 0xa5, 0xe7)
	DEFINE_GUID (IIS_IsOleaccProxy, 0x902697fa, 0x80e4, 0x4560, 0x80, 0x2a, 0xa1, 0x3f, 0x22, 0xa6, 0x47, 0x09)
LRESULT WINAPI	LresultFromObject (REFIID, WPARAM, LPUNKNOWN)
HRESULT WINAPI	ObjectFromLresult (LRESULT, REFIID, WPARAM, void **)
HRESULT WINAPI	WindowFromAccessibleObject (IAccessible *, HWND *)
HRESULT WINAPI	AccessibleObjectFromWindow (HWND, DWORD, REFIID, void **)
HRESULT WINAPI	AccessibleObjectFromEvent (HWND, DWORD, DWORD, IAccessible **, VARIANT *)
HRESULT WINAPI	AccessibleObjectFromPoint (POINT, IAccessible **, VARIANT *)
HRESULT WINAPI	AccessibleChildren (IAccessible *, LONG, LONG, VARIANT *, LONG *)
void WINAPI	GetOleaccVersionInfo (DWORD *, DWORD *)
HRESULT WINAPI	CreateStdAccessibleObject (HWND, LONG, REFIID, void **)
HRESULT WINAPI	CreateStdAccessibleProxyA (HWND, LPCSTR, LONG, REFIID, void **)
HRESULT WINAPI	CreateStdAccessibleProxyW (HWND, LPCWSTR, LONG, REFIID, void **)
UINT WINAPI	GetRoleTextA (DWORD, LPSTR, UINT)
UINT WINAPI	GetRoleTextW (DWORD, LPWSTR, UINT)
UINT WINAPI	GetStateTextA (DWORD, LPSTR, UINT)
UINT WINAPI	GetStateTextW (DWORD, LPWSTR, UINT)

Macro Definition Documentation

threading

#define threading

(

model

)

Definition at line 22 of file oleacc.idl.

Typedef Documentation

AnnoScope

typedef enum AnnoScope AnnoScope

MSAAPROPID

typedef GUID MSAAPROPID

Definition at line 148 of file oleacc.idl.

Enumeration Type Documentation

AnnoScope

enum AnnoScope

Enumerator
ANNO_THIS
ANNO_CONTAINER

Definition at line 150 of file oleacc.idl.

{
    ANNO_THIS,
    ANNO_CONTAINER
} AnnoScope;

Function Documentation

AccessibleChildren()

HRESULT WINAPI AccessibleChildren	(	IAccessible *	container,
		LONG	start,
		LONG	count,
		VARIANT *	children,
		LONG *	children_cnt
	)

Definition at line 669 of file main.c.

{
    IEnumVARIANT *ev;
    LONG i, child_no;
    HRESULT hr;
 
    TRACE("%p %ld %ld %p %p\n", container, start, count, children, children_cnt);
 
    if(!container || !children || !children_cnt)
        return E_INVALIDARG;
 
    for(i=0; i<count; i++)
        VariantInit(children+i);
 
    hr = IAccessible_QueryInterface(container, &IID_IEnumVARIANT, (void**)&ev);
    if(SUCCEEDED(hr)) {
        hr = IEnumVARIANT_Reset(ev);
        if(SUCCEEDED(hr))
            hr = IEnumVARIANT_Skip(ev, start);
        if(SUCCEEDED(hr))
            hr = IEnumVARIANT_Next(ev, count, children, (ULONG*)children_cnt);
        IEnumVARIANT_Release(ev);
        return hr;
    }
 
    hr = IAccessible_get_accChildCount(container, &child_no);
    if(FAILED(hr))
        return hr;
 
    for(i=0; i<count && start+i+1<=child_no; i++) {
        IDispatch *disp;
 
        V_VT(children+i) = VT_I4;
        V_I4(children+i) = start+i+1;
 
        hr = IAccessible_get_accChild(container, children[i], &disp);
        if(SUCCEEDED(hr) && disp) {
            V_VT(children+i) = VT_DISPATCH;
            V_DISPATCH(children+i) = disp;
        }
    }
 
    *children_cnt = i;
    return i==count ? S_OK : S_FALSE;
}

Referenced by test_AccessibleChildren().

AccessibleObjectFromEvent()

HRESULT WINAPI AccessibleObjectFromEvent	(	HWND	hwnd,
		DWORD	object_id,
		DWORD	child_id,
		IAccessible **	acc_out,
		VARIANT *	child_id_out
	)

Definition at line 345 of file main.c.

{
    VARIANT child_id_variant;
    IAccessible *acc = NULL;
    IDispatch *child = NULL;
    HRESULT hr;
 
    TRACE("%p %ld %ld %p %p\n", hwnd, object_id, child_id, acc_out, child_id_out);
 
    if (!acc_out)
        return E_INVALIDARG;
    *acc_out = NULL;
    VariantInit(child_id_out);
 
    hr = AccessibleObjectFromWindow(hwnd, object_id, &IID_IAccessible, (void **)&acc);
    if (FAILED(hr))
        return hr;
 
    variant_init_i4(&child_id_variant, child_id);
    hr = IAccessible_get_accChild(acc, child_id_variant, &child);
    if (FAILED(hr))
        TRACE("get_accChild failed with %#lx!\n", hr);
 
    if (SUCCEEDED(hr) && child)
    {
        IAccessible_Release(acc);
        hr = IDispatch_QueryInterface(child, &IID_IAccessible, (void **)&acc);
        IDispatch_Release(child);
        if (FAILED(hr))
            return hr;
 
        variant_init_i4(&child_id_variant, CHILDID_SELF);
    }
 
    *acc_out = acc;
    *child_id_out = child_id_variant;
 
    return S_OK;
}

Referenced by test_AccessibleObjectFromEvent().

AccessibleObjectFromPoint()

HRESULT WINAPI AccessibleObjectFromPoint	(	POINT	point,
		IAccessible **	acc,
		VARIANT *	child_id
	)

Definition at line 280 of file main.c.

{
    IAccessible *cur;
    HRESULT hr;
    VARIANT v;
    HWND hwnd;
 
    TRACE("{%ld,%ld} %p %p\n", point.x, point.y, acc, child_id);
 
    if (!acc || !child_id)
        return E_INVALIDARG;
 
    *acc = NULL;
    V_VT(child_id) = VT_EMPTY;
 
    hwnd = WindowFromPoint(point);
    if (!hwnd)
        return E_FAIL;
    hwnd = GetAncestor(hwnd, GA_ROOT);
 
    hr = AccessibleObjectFromWindow(hwnd, OBJID_WINDOW, &IID_IAccessible, (void **)&cur);
    if (FAILED(hr))
        return hr;
    if (!cur)
        return E_FAIL;
 
    V_VT(&v) = VT_EMPTY;
    while (1)
    {
        hr = IAccessible_accHitTest(cur, point.x, point.y, &v);
        if (FAILED(hr))
        {
            IAccessible_Release(cur);
            return hr;
        }
 
        if (V_VT(&v) == VT_I4)
        {
            *acc = cur;
            variant_init_i4(child_id, V_I4(&v));
            return S_OK;
        }
        else if (V_VT(&v) == VT_DISPATCH)
        {
            IAccessible_Release(cur);
 
            hr = IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IAccessible, (void**)&cur);
            VariantClear(&v);
            if (FAILED(hr))
                return hr;
            if (!cur)
                return E_FAIL;
        }
        else
        {
            VariantClear(&v);
            IAccessible_Release(cur);
            FIXME("unhandled variant type: %d\n", V_VT(&v));
            return E_NOTIMPL;
        }
    }
 
    return S_OK;
}

Referenced by test_AccessibleObjectFromPoint().

AccessibleObjectFromWindow()

HRESULT WINAPI AccessibleObjectFromWindow	(	HWND	hwnd,
		DWORD	dwObjectID,
		REFIID	riid,
		void **	ppvObject
	)

Definition at line 386 of file main.c.

{
    TRACE("%p %ld %s %p\n", hwnd, dwObjectID,
          debugstr_guid( riid ), ppvObject );
 
    if(!ppvObject)
        return E_INVALIDARG;
    *ppvObject = NULL;
 
    if(IsWindow(hwnd)) {
        LRESULT lres;
 
        lres = SendMessageW(hwnd, WM_GETOBJECT, 0xffffffff, dwObjectID);
        if(FAILED(lres))
            return lres;
        else if(lres)
            return ObjectFromLresult(lres, riid, 0, ppvObject);
    }
 
    return CreateStdAccessibleObject(hwnd, dwObjectID, riid, ppvObject);
}

Referenced by AccessibleObjectFromEvent(), AccessibleObjectFromPoint(), Client_accHitTest(), Client_EnumVARIANT_Next(), Client_get_accFocus(), Client_get_accParent(), create_msaa_provider_from_hwnd(), default_uia_provider_callback(), msaa_check_root_acc(), msaa_fragment_get_FragmentRoot(), test_AccessibleObjectFromWindow(), and Window_accHitTest().

CreateStdAccessibleObject()

HRESULT WINAPI CreateStdAccessibleObject	(	HWND	hwnd,
		LONG	idObject,
		REFIID	riidInterface,
		void **	ppvObject
	)

Definition at line 92 of file main.c.

{
    TRACE("%p %ld %s %p\n", hwnd, idObject,
          debugstr_guid( riidInterface ), ppvObject );
 
    switch(idObject) {
    case OBJID_CLIENT:
        return create_client_object(hwnd, riidInterface, ppvObject);
    case OBJID_WINDOW:
        return create_window_object(hwnd, riidInterface, ppvObject);
    default:
        FIXME("unhandled object id: %ld\n", idObject);
        return E_NOTIMPL;
    }
}

Referenced by AccessibleObjectFromWindow(), CTipbarAccessible::Initialize(), test_CreateStdAccessibleObject_classes(), test_default_client_accessible_object(), test_default_edit_accessible_object(), and test_UiaProviderFromIAccessible().

CreateStdAccessibleProxyA()

HRESULT WINAPI CreateStdAccessibleProxyA	(	HWND	,
		LPCSTR	,
		LONG	,
		REFIID	,
		void **
	)

CreateStdAccessibleProxyW()

HRESULT WINAPI CreateStdAccessibleProxyW	(	HWND	,
		LPCWSTR	,
		LONG	,
		REFIID	,
		void **
	)

DEFINE_GUID() [1/2]

DEFINE_GUID	(	CLSID_AccPropServices	,
		0xb5f8350b	,
		0x0548	,
		0x48b1	,
		0xa6	,
		0xee	,
		0x88	,
		0xbd	,
		0x00	,
		0xb4	,
		0xa5	,
		0xe7
	)

DEFINE_GUID() [2/2]

DEFINE_GUID	(	IIS_IsOleaccProxy	,
		0x902697fa	,
		0x80e4	,
		0x4560	,
		0x80	,
		0x2a	,
		0xa1	,
		0x3f	,
		0x22	,
		0xa6	,
		0x47	,
		0x09
	)

GetOleaccVersionInfo()

void WINAPI GetOleaccVersionInfo	(	DWORD *	pVersion,
		DWORD *	pBuild
	)

Definition at line 521 of file main.c.

{
    *pVersion = MAKELONG(0,7); /* Windows 7 version of oleacc: 7.0.0.0 */
    *pBuild = MAKELONG(0,0);
}

GetRoleTextA()

UINT WINAPI GetRoleTextA	(	DWORD	role,
		LPSTR	lpRole,
		UINT	rolemax
	)

Definition at line 559 of file main.c.

{
    UINT length;
    WCHAR *roletextW;
 
    TRACE("%lu %p %u\n", role, lpRole, rolemax);
 
    if(lpRole && !rolemax)
        return 0;
 
    length = GetRoleTextW(role, NULL, 0);
    if(!length) {
        if(lpRole && rolemax)
            lpRole[0] = 0;
        return 0;
    }
 
    roletextW = HeapAlloc(GetProcessHeap(), 0, (length + 1)*sizeof(WCHAR));
    if(!roletextW)
        return 0;
 
    GetRoleTextW(role, roletextW, length + 1);
 
    length = WideCharToMultiByte( CP_ACP, 0, roletextW, -1, NULL, 0, NULL, NULL );
 
    if(!lpRole){
        HeapFree(GetProcessHeap(), 0, roletextW);
        return length - 1;
    }
 
    if(rolemax < length) {
        HeapFree(GetProcessHeap(), 0, roletextW);
        lpRole[0] = 0;
        return 0;
    }
 
    WideCharToMultiByte( CP_ACP, 0, roletextW, -1, lpRole, rolemax, NULL, NULL );
 
    if(rolemax < length){
        lpRole[rolemax-1] = '\0';
        length = rolemax;
    }
 
    HeapFree(GetProcessHeap(), 0, roletextW);
 
    return length - 1;
}

Referenced by test_getroletext().

GetRoleTextW()

UINT WINAPI GetRoleTextW	(	DWORD	role,
		LPWSTR	lpRole,
		UINT	rolemax
	)

Definition at line 539 of file main.c.

{
    INT ret;
    WCHAR *resptr;
 
    TRACE("%lu %p %u\n", role, lpRole, rolemax);
 
    /* return role text length */
    if(!lpRole)
        return LoadStringW(oleacc_handle, role, (LPWSTR)&resptr, 0);
 
    ret = LoadStringW(oleacc_handle, role, lpRole, rolemax);
    if(!(ret > 0)){
        if(rolemax > 0) lpRole[0] = '\0';
        return 0;
    }
 
    return ret;
}

Referenced by GetRoleTextA(), and test_getroletext().

GetStateTextA()

UINT WINAPI GetStateTextA	(	DWORD	,
		LPSTR	,
		UINT
	)

GetStateTextW()

UINT WINAPI GetStateTextW	(	DWORD	,
		LPWSTR	,
		UINT
	)

LresultFromObject()

LRESULT WINAPI LresultFromObject	(	REFIID	riid,
		WPARAM	wParam,
		LPUNKNOWN	pAcc
	)

Definition at line 181 of file main.c.

{
    static const LARGE_INTEGER seek_zero = {{0}};
 
    WCHAR atom_str[ARRAY_SIZE(lresult_atom_prefix)+3*8+3];
    IStream *stream;
    HANDLE mapping;
    STATSTG stat;
    HRESULT hr;
    ATOM atom;
    void *view;
 
    TRACE("%s %Id %p\n", debugstr_guid(riid), wParam, pAcc);
 
    if(wParam)
        FIXME("unsupported wParam = %Ix\n", wParam);
 
    if(!pAcc)
        return E_INVALIDARG;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    if(FAILED(hr))
        return hr;
 
    hr = CoMarshalInterface(stream, riid, pAcc, MSHCTX_LOCAL, NULL, MSHLFLAGS_NORMAL);
    if(FAILED(hr)) {
        IStream_Release(stream);
        return hr;
    }
 
    hr = IStream_Seek(stream, seek_zero, STREAM_SEEK_SET, NULL);
    if(FAILED(hr)) {
        IStream_Release(stream);
        return hr;
    }
 
    hr = IStream_Stat(stream, &stat, STATFLAG_NONAME);
    if(FAILED(hr)) {
        CoReleaseMarshalData(stream);
        IStream_Release(stream);
        return hr;
    }else if(stat.cbSize.u.HighPart) {
        FIXME("stream size to big\n");
        CoReleaseMarshalData(stream);
        IStream_Release(stream);
        return E_NOTIMPL;
    }
 
    mapping = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
            stat.cbSize.u.HighPart, stat.cbSize.u.LowPart, NULL);
    if(!mapping) {
        CoReleaseMarshalData(stream);
        IStream_Release(stream);
        return hr;
    }
 
    view = MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0);
    if(!view) {
        CloseHandle(mapping);
        CoReleaseMarshalData(stream);
        IStream_Release(stream);
        return E_FAIL;
    }
 
    hr = IStream_Read(stream, view, stat.cbSize.u.LowPart, NULL);
    UnmapViewOfFile(view);
    if(FAILED(hr)) {
        CloseHandle(mapping);
        hr = IStream_Seek(stream, seek_zero, STREAM_SEEK_SET, NULL);
        if(SUCCEEDED(hr))
            CoReleaseMarshalData(stream);
        IStream_Release(stream);
        return hr;
 
    }
 
    memcpy(atom_str, lresult_atom_prefix, sizeof(lresult_atom_prefix));
    swprintf(atom_str+ARRAY_SIZE(lresult_atom_prefix), 3*8 + 3, L"%08x:%08x:%08x", GetCurrentProcessId(),
             HandleToUlong(mapping), stat.cbSize.u.LowPart);
    atom = GlobalAddAtomW(atom_str);
    if(!atom) {
        CloseHandle(mapping);
        hr = IStream_Seek(stream, seek_zero, STREAM_SEEK_SET, NULL);
        if(SUCCEEDED(hr))
            CoReleaseMarshalData(stream);
        IStream_Release(stream);
        return E_FAIL;
    }
 
    IStream_Release(stream);
    return atom;
}

Referenced by test_LresultFromObject(), test_window_proc(), test_wnd_proc(), and uia_provider_thread_msg_proc().

ObjectFromLresult()

HRESULT WINAPI ObjectFromLresult	(	LRESULT	result,
		REFIID	riid,
		WPARAM	wParam,
		void **	ppObject
	)

Definition at line 109 of file main.c.

{
    WCHAR atom_str[ARRAY_SIZE(lresult_atom_prefix)+3*8+3];
    HANDLE server_proc, server_mapping, mapping;
    DWORD proc_id, size;
    IStream *stream;
    HGLOBAL data;
    void *view;
    HRESULT hr;
    WCHAR *p;
 
    TRACE("%Id %s %Id %p\n", result, debugstr_guid(riid), wParam, ppObject );
 
    if(wParam)
        FIXME("unsupported wParam = %Ix\n", wParam);
 
    if(!ppObject)
        return E_INVALIDARG;
    *ppObject = NULL;
 
    if(result != (ATOM)result)
        return E_FAIL;
 
    if(!GlobalGetAtomNameW(result, atom_str, ARRAY_SIZE(atom_str)))
        return E_FAIL;
    if(memcmp(atom_str, lresult_atom_prefix, sizeof(lresult_atom_prefix)))
        return E_FAIL;
    p = atom_str + ARRAY_SIZE(lresult_atom_prefix);
    proc_id = wcstoul(p, &p, 16);
    if(*p != ':')
        return E_FAIL;
    server_mapping = ULongToHandle( wcstoul(p+1, &p, 16) );
    if(*p != ':')
        return E_FAIL;
    size = wcstoul(p+1, &p, 16);
    if(*p != 0)
        return E_FAIL;
 
    server_proc = OpenProcess(PROCESS_DUP_HANDLE, FALSE, proc_id);
    if(!server_proc)
        return E_FAIL;
 
    if(!DuplicateHandle(server_proc, server_mapping, GetCurrentProcess(), &mapping,
                0, FALSE, DUPLICATE_CLOSE_SOURCE|DUPLICATE_SAME_ACCESS))
        return E_FAIL;
    CloseHandle(server_proc);
    GlobalDeleteAtom(result);
 
    view = MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
    CloseHandle(mapping);
    if(!view)
        return E_FAIL;
 
    data = GlobalAlloc(GMEM_FIXED, size);
    if(!data) {
        UnmapViewOfFile(view);
        return E_OUTOFMEMORY;
    }
    memcpy(data, view, size);
    UnmapViewOfFile(view);
 
    hr = CreateStreamOnHGlobal(data, TRUE, &stream);
    if(FAILED(hr)) {
        GlobalFree(data);
        return hr;
    }
 
    hr = CoUnmarshalInterface(stream, riid, ppObject);
    IStream_Release(stream);
    return hr;
}

Referenced by AccessibleObjectFromWindow(), create_wine_uia_nested_node_provider(), START_TEST(), test_LresultFromObject(), and uia_node_lresult_release().

WindowFromAccessibleObject()

HRESULT WINAPI WindowFromAccessibleObject	(	IAccessible *	acc,
		HWND *	phwnd
	)

Definition at line 409 of file main.c.

{
    IServiceProvider *sp;
    IAccessible *acc2;
    IDispatch *parent;
    IOleWindow *ow;
    VARIANT v, cid;
    HRESULT hres;
 
    TRACE("%p %p\n", acc, phwnd);
 
    hres = IAccessible_QueryInterface(acc, &IID_IOleWindow, (void**)&ow);
    if(SUCCEEDED(hres)) {
        hres = IOleWindow_GetWindow(ow, phwnd);
        IOleWindow_Release(ow);
        if(SUCCEEDED(hres) && *phwnd)
            return S_OK;
    }
 
    VariantInit(&v);
    variant_init_i4(&cid, CHILDID_SELF);
    hres = IAccessible_accNavigate(acc, NAVDIR_INTERNAL_HWND, cid, &v);
    if(SUCCEEDED(hres)) {
        if(hres == S_OK && V_VT(&v) == VT_I4 && V_I4(&v)) {
            *phwnd = LongToHandle(V_I4(&v));
            return S_OK;
        }
        /* native leaks v here */
        VariantClear(&v);
    }
 
    hres = IAccessible_QueryInterface(acc, &IID_IServiceProvider, (void**)&sp);
    if(SUCCEEDED(hres)) {
        hres = IServiceProvider_QueryService(sp, &SID_AccFromDAWrapper,
                &IID_IAccessible, (void**)&acc2);
        IServiceProvider_Release(sp);
    }
    if(FAILED(hres)) {
        acc2 = acc;
        IAccessible_AddRef(acc2);
    }
 
    while(1) {
        hres = IAccessible_QueryInterface(acc2, &IID_IOleWindow, (void**)&ow);
        if(SUCCEEDED(hres)) {
            hres = IOleWindow_GetWindow(ow, phwnd);
            IOleWindow_Release(ow);
            if(SUCCEEDED(hres)) {
                IAccessible_Release(acc2);
                return hres;
            }
        }
 
        hres = IAccessible_get_accParent(acc, &parent);
        IAccessible_Release(acc2);
        if(FAILED(hres))
            return hres;
        if(!parent) {
            *phwnd = NULL;
            return hres;
        }
 
        hres = IDispatch_QueryInterface(parent, &IID_IAccessible, (void**)&acc2);
        IDispatch_Release(parent);
        if(FAILED(hres))
            return hres;
        acc = acc2;
    }
}

Referenced by check_acc_vals_(), create_msaa_provider(), msaa_acc_get_focus(), test_default_client_accessible_object(), test_WindowFromAccessibleObject(), and UiaProviderFromIAccessible().