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 601 of file main.c.

{
    IEnumVARIANT *ev;
    LONG i, child_no;
    HRESULT hr;
 
    TRACE("%p %d %d %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	,
		DWORD	,
		DWORD	,
		IAccessible **	,
		VARIANT *
	)

AccessibleObjectFromPoint()

HRESULT WINAPI AccessibleObjectFromPoint	(	POINT	ptScreen,
		IAccessible **	ppacc,
		VARIANT *	pvarChild
	)

Definition at line 343 of file main.c.

{
    FIXME("{%d,%d} %p %p: stub\n", ptScreen.x, ptScreen.y, ppacc, pvarChild );
    return E_NOTIMPL;
}

AccessibleObjectFromWindow()

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

Definition at line 349 of file main.c.

{
    TRACE("%p %d %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 Client_accHitTest(), Client_EnumVARIANT_Next(), Client_get_accParent(), and test_AccessibleObjectFromWindow().

CreateStdAccessibleObject()

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

Definition at line 154 of file main.c.

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

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

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 448 of file main.c.

{
#ifdef __REACTOS__
    *pVersion = MAKELONG(2,4); /* Windows XP version of oleacc: 4.2.5406.0 */
    *pBuild = MAKELONG(0,5406);
#else
    *pVersion = MAKELONG(0,7); /* Windows 7 version of oleacc: 7.0.0.0 */
    *pBuild = MAKELONG(0,0);
#endif
}

GetRoleTextA()

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

Definition at line 491 of file main.c.

{
    UINT length;
    WCHAR *roletextW;
 
    TRACE("%u %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 471 of file main.c.

{
    INT ret;
    WCHAR *resptr;
 
    TRACE("%u %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 249 of file main.c.

{
    static const WCHAR atom_fmt[] = {'%','0','8','x',':','%','0','8','x',':','%','0','8','x',0};
    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 %ld %p\n", debugstr_guid(riid), wParam, pAcc);
 
    if(wParam)
        FIXME("unsupported wParam = %lx\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), atom_fmt, 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(), and test_window_proc().

ObjectFromLresult()

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

Definition at line 177 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("%ld %s %ld %p\n", result, debugstr_guid(riid), wParam, ppObject );
 
    if(wParam)
        FIXME("unsupported wParam = %lx\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(), START_TEST(), and test_LresultFromObject().

WindowFromAccessibleObject()

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

Definition at line 372 of file main.c.

{
    IDispatch *parent;
    IOleWindow *ow;
    HRESULT hres;
 
    TRACE("%p %p\n", acc, phwnd);
 
    IAccessible_AddRef(acc);
    while(1) {
        hres = IAccessible_QueryInterface(acc, &IID_IOleWindow, (void**)&ow);
        if(SUCCEEDED(hres)) {
            hres = IOleWindow_GetWindow(ow, phwnd);
            IOleWindow_Release(ow);
            IAccessible_Release(acc);
            return hres;
        }
 
        hres = IAccessible_get_accParent(acc, &parent);
        IAccessible_Release(acc);
        if(FAILED(hres))
            return hres;
        if(hres!=S_OK || !parent) {
            *phwnd = NULL;
            return hres;
        }
 
        hres = IDispatch_QueryInterface(parent, &IID_IAccessible, (void**)&acc);
        IDispatch_Release(parent);
        if(FAILED(hres))
            return hres;
    }
}

Referenced by test_default_client_accessible_object().