uia_private.h File Reference

#include "uiautomation.h"
#include "uia_classes.h"
#include "wine/list.h"
#include "wine/rbtree.h"
#include "assert.h"

Include dependency graph for uia_private.h:

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

Go to the source code of this file.

Classes
struct	uia_node
struct	uia_provider
struct	uia_event_args
struct	uia_event

Macros
#define	COBJMACROS

Typedefs
typedef HRESULT	UiaWineEventCallback(struct uia_event *, struct uia_event_args *, SAFEARRAY *, BSTR)
typedef HRESULT	UiaWineEventForEachCallback(struct uia_event *, void *)

Enumerations
enum	uia_prop_type { PROP_TYPE_UNKNOWN , PROP_TYPE_ELEM_PROP , PROP_TYPE_SPECIAL , PROP_TYPE_PATTERN_PROP }
enum	uia_node_prov_type {   PROV_TYPE_OVERRIDE , PROV_TYPE_MAIN , PROV_TYPE_NONCLIENT , PROV_TYPE_HWND ,   PROV_TYPE_COUNT }
enum	uia_node_flags { NODE_FLAG_IGNORE_CLIENTSIDE_HWND_PROVS = 0x01 , NODE_FLAG_NO_PREPARE = 0x02 , NODE_FLAG_IGNORE_COM_THREADING = 0x04 }
enum	uia_event_type { EVENT_TYPE_CLIENTSIDE , EVENT_TYPE_SERVERSIDE }
enum	provider_method_flags { PROV_METHOD_FLAG_RETURN_NODE_LRES = 0x0001 }

Functions
static struct uia_node *	impl_from_IWineUiaNode (IWineUiaNode *iface)
static struct uia_provider *	impl_from_IWineUiaProvider (IWineUiaProvider *iface)
static void	variant_init_bool (VARIANT *v, BOOL val)
static void	variant_init_i4 (VARIANT *v, int val)
static void	get_variant_for_node (HUIANODE node, VARIANT *v)
static BOOL	uia_array_reserve (void **elements, SIZE_T *capacity, SIZE_T count, SIZE_T size)
int	get_node_provider_type_at_idx (struct uia_node *node, int idx)
HRESULT	get_focus_from_node_provider (IWineUiaNode *node, int idx, LONG flags, VARIANT *ret_val)
HRESULT	respond_to_win_event_on_node_provider (IWineUiaNode *node, int idx, DWORD win_event, HWND hwnd, LONG obj_id, LONG child_id, IProxyProviderWinEventSink *sink)
HRESULT	create_node_from_node_provider (IWineUiaNode *node, int idx, LONG flags, VARIANT *ret_val)
HRESULT	attach_event_to_uia_node (HUIANODE node, struct uia_event *event)
HRESULT	clone_uia_node (HUIANODE in_node, HUIANODE *out_node)
HRESULT	navigate_uia_node (struct uia_node *node, int nav_dir, HUIANODE *out_node)
HRESULT	create_uia_node_from_elprov (IRawElementProviderSimple *elprov, HUIANODE *out_node, BOOL get_hwnd_providers, int node_flags)
HRESULT	uia_node_from_lresult (LRESULT lr, HUIANODE *huianode, int node_flags)
void	uia_node_lresult_release (LRESULT lr)
HRESULT	create_uia_node_from_hwnd (HWND hwnd, HUIANODE *out_node, int node_flags)
HRESULT	uia_condition_check (HUIANODE node, struct UiaCondition *condition)
BOOL	uia_condition_matched (HRESULT hr)
HRESULT	uia_com_win_event_callback (DWORD event_id, HWND hwnd, LONG obj_id, LONG child_id, DWORD thread_id, DWORD event_time)
HRESULT	create_uia_iface (IUnknown **iface, BOOL is_cui8)
HRESULT	uia_event_add_win_event_hwnd (struct uia_event *event, HWND hwnd)
HRESULT	uia_event_for_each (int event_id, UiaWineEventForEachCallback *callback, void *user_data, BOOL clientside_only)
BOOL	uia_clientside_event_start_event_thread (struct uia_event *event)
HRESULT	create_msaa_provider_from_hwnd (HWND hwnd, int in_child_id, IRawElementProviderSimple **ret_elprov)
HRESULT	create_serverside_uia_event (struct uia_event **out_event, LONG process_id, LONG event_cookie)
HRESULT	uia_event_add_provider_event_adviser (IRawElementProviderAdviseEvents *advise_events, struct uia_event *event)
HRESULT	uia_event_add_serverside_event_adviser (IWineUiaEvent *serverside_event, struct uia_event *event)
HRESULT	uia_event_advise_node (struct uia_event *event, HUIANODE node)
HRESULT	uia_add_clientside_event (HUIANODE huianode, EVENTID event_id, enum TreeScope scope, PROPERTYID *prop_ids, int prop_ids_count, struct UiaCacheRequest *cache_req, SAFEARRAY *rt_id, UiaWineEventCallback *cback, void *cback_data, HUIAEVENT *huiaevent)
HRESULT	uia_event_invoke (HUIANODE node, HUIANODE nav_start_node, struct uia_event_args *args, struct uia_event *event)
HRESULT	uia_event_check_node_within_event_scope (struct uia_event *event, HUIANODE node, SAFEARRAY *rt_id, HUIANODE *clientside_nav_node_out)
const struct uia_prop_info *	uia_prop_info_from_id (PROPERTYID prop_id)
const struct uia_event_info *	uia_event_info_from_id (EVENTID event_id)
const struct uia_pattern_info *	uia_pattern_info_from_id (PATTERNID pattern_id)
const struct uia_control_type_info *	uia_control_type_info_from_id (CONTROLTYPEID control_type_id)
HRESULT	create_base_hwnd_provider (HWND hwnd, IRawElementProviderSimple **elprov)
void	uia_stop_provider_thread (void)
void	uia_provider_thread_remove_node (HUIANODE node)
LRESULT	uia_lresult_from_node (HUIANODE huianode)
HRESULT	create_msaa_provider (IAccessible *acc, LONG child_id, HWND hwnd, BOOL root_acc_known, BOOL is_root_acc, IRawElementProviderSimple **elprov)
HRESULT	register_interface_in_git (IUnknown *iface, REFIID riid, DWORD *ret_cookie)
HRESULT	unregister_interface_in_git (DWORD git_cookie)
HRESULT	get_interface_in_git (REFIID riid, DWORD git_cookie, IUnknown **ret_iface)
HRESULT	write_runtime_id_base (SAFEARRAY *sa, HWND hwnd)
void	uia_cache_request_destroy (struct UiaCacheRequest *cache_req)
HRESULT	uia_cache_request_clone (struct UiaCacheRequest *dst, struct UiaCacheRequest *src)
HRESULT	get_safearray_dim_bounds (SAFEARRAY *sa, UINT dim, LONG *lbound, LONG *elems)
HRESULT	get_safearray_bounds (SAFEARRAY *sa, LONG *lbound, LONG *elems)
int	uia_compare_safearrays (SAFEARRAY *sa1, SAFEARRAY *sa2, int prop_type)
BOOL	uia_hwnd_is_visible (HWND hwnd)
BOOL	uia_is_top_level_hwnd (HWND hwnd)
BOOL	uia_hwnd_map_check_hwnd (struct rb_tree *hwnd_map, HWND hwnd)
HRESULT	uia_hwnd_map_add_hwnd (struct rb_tree *hwnd_map, HWND hwnd)
void	uia_hwnd_map_remove_hwnd (struct rb_tree *hwnd_map, HWND hwnd)
void	uia_hwnd_map_init (struct rb_tree *hwnd_map)
void	uia_hwnd_map_destroy (struct rb_tree *hwnd_map)

Variables
HMODULE	huia_module

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 19 of file uia_private.h.

Typedef Documentation

UiaWineEventCallback

typedef HRESULT UiaWineEventCallback(struct uia_event *, struct uia_event_args *, SAFEARRAY *, BSTR)

Definition at line 160 of file uia_private.h.

UiaWineEventForEachCallback

typedef HRESULT UiaWineEventForEachCallback(struct uia_event *, void *)

Definition at line 161 of file uia_private.h.

Enumeration Type Documentation

provider_method_flags

enum provider_method_flags

Enumerator
PROV_METHOD_FLAG_RETURN_NODE_LRES

Definition at line 213 of file uia_private.h.

                           {
    PROV_METHOD_FLAG_RETURN_NODE_LRES = 0x0001,
};

uia_event_type

enum uia_event_type

Enumerator
EVENT_TYPE_CLIENTSIDE
EVENT_TYPE_SERVERSIDE

Definition at line 115 of file uia_private.h.

                    {
    EVENT_TYPE_CLIENTSIDE,
    EVENT_TYPE_SERVERSIDE,
};

uia_node_flags

enum uia_node_flags

Enumerator
NODE_FLAG_IGNORE_CLIENTSIDE_HWND_PROVS
NODE_FLAG_NO_PREPARE
NODE_FLAG_IGNORE_COM_THREADING

Definition at line 58 of file uia_private.h.

                    {
    NODE_FLAG_IGNORE_CLIENTSIDE_HWND_PROVS = 0x01,
    NODE_FLAG_NO_PREPARE = 0x02,
    NODE_FLAG_IGNORE_COM_THREADING = 0x04,
};

uia_node_prov_type

enum uia_node_prov_type

Enumerator
PROV_TYPE_OVERRIDE
PROV_TYPE_MAIN
PROV_TYPE_NONCLIENT
PROV_TYPE_HWND
PROV_TYPE_COUNT

Definition at line 50 of file uia_private.h.

                        {
    PROV_TYPE_OVERRIDE,
    PROV_TYPE_MAIN,
    PROV_TYPE_NONCLIENT,
    PROV_TYPE_HWND,
    PROV_TYPE_COUNT,
};

uia_prop_type

enum uia_prop_type

Enumerator
PROP_TYPE_UNKNOWN
PROP_TYPE_ELEM_PROP
PROP_TYPE_SPECIAL
PROP_TYPE_PATTERN_PROP

Definition at line 29 of file uia_private.h.

                   {
    PROP_TYPE_UNKNOWN,
    PROP_TYPE_ELEM_PROP,
    PROP_TYPE_SPECIAL,
    PROP_TYPE_PATTERN_PROP,
};

Function Documentation

attach_event_to_uia_node()

HRESULT attach_event_to_uia_node	(	HUIANODE	node,
		struct uia_event *	event
	)

Definition at line 1337 of file uia_client.c.

{
    struct uia_node *node_data = impl_from_IWineUiaNode((IWineUiaNode *)node);
    HRESULT hr = S_OK;
    int i;
 
    for (i = 0; i < node_data->prov_count; i++)
    {
        hr = attach_event_to_node_provider(&node_data->IWineUiaNode_iface, i, (HUIAEVENT)event);
        if (FAILED(hr))
            return hr;
    }
 
    return hr;
}

Referenced by uia_add_clientside_event(), uia_event_advise_node(), and uia_provider_attach_event().

clone_uia_node()

HRESULT clone_uia_node	(	HUIANODE	in_node,
		HUIANODE *	out_node
	)

Definition at line 738 of file uia_client.c.

{
    struct uia_node *in_node_data = impl_from_IWineUiaNode((IWineUiaNode *)in_node);
    struct uia_node *node;
    HRESULT hr = S_OK;
    int i;
 
    *out_node = NULL;
    if (in_node_data->nested_node)
    {
        FIXME("Cloning of nested nodes currently unimplemented\n");
        return E_NOTIMPL;
    }
 
    for (i = 0; i < PROV_TYPE_COUNT; i++)
    {
        if (in_node_data->prov[i] && is_nested_node_provider(in_node_data->prov[i]))
        {
            FIXME("Cloning of nested node providers currently unimplemented\n");
            return E_NOTIMPL;
        }
    }
 
    hr = create_uia_node(&node, 0);
    if (FAILED(hr))
        return hr;
 
    node->hwnd = in_node_data->hwnd;
    for (i = 0; i < PROV_TYPE_COUNT; i++)
    {
        struct uia_provider *in_prov_data;
 
        if (!in_node_data->prov[i])
            continue;
 
        in_prov_data = impl_from_IWineUiaProvider(in_node_data->prov[i]);
        hr = create_wine_uia_provider(node, in_prov_data->elprov, i);
        if (FAILED(hr))
            goto exit;
 
        if (in_node_data->git_cookie[i])
        {
            hr = register_interface_in_git((IUnknown *)node->prov[i], &IID_IWineUiaProvider, &node->git_cookie[i]);
            if (FAILED(hr))
                goto exit;
        }
    }
 
    node->parent_link_idx = in_node_data->parent_link_idx;
    node->creator_prov_idx = in_node_data->creator_prov_idx;
    node->creator_prov_type = in_node_data->creator_prov_type;
 
    *out_node = (void *)&node->IWineUiaNode_iface;
    TRACE("Created clone node %p from node %p\n", *out_node, in_node);
 
exit:
    if (FAILED(hr))
        IWineUiaNode_Release(&node->IWineUiaNode_iface);
 
    return hr;
}

Referenced by uia_event_invoke().

create_base_hwnd_provider()

HRESULT create_base_hwnd_provider	(	HWND	hwnd,
		IRawElementProviderSimple **	elprov
	)

Definition at line 1915 of file uia_provider.c.

{
    struct base_hwnd_provider *base_hwnd_prov;
 
    *elprov = NULL;
 
    if (!hwnd)
        return E_INVALIDARG;
 
    if (!IsWindow(hwnd))
        return UIA_E_ELEMENTNOTAVAILABLE;
 
    if (!(base_hwnd_prov = calloc(1, sizeof(*base_hwnd_prov))))
        return E_OUTOFMEMORY;
 
    base_hwnd_prov->IRawElementProviderSimple_iface.lpVtbl = &base_hwnd_provider_vtbl;
    base_hwnd_prov->IRawElementProviderFragment_iface.lpVtbl = &base_hwnd_fragment_vtbl;
    base_hwnd_prov->refcount = 1;
    base_hwnd_prov->hwnd = hwnd;
    *elprov = &base_hwnd_prov->IRawElementProviderSimple_iface;
 
    return S_OK;
}

Referenced by base_hwnd_fragment_Navigate(), and default_uia_provider_callback().

create_msaa_provider()

HRESULT create_msaa_provider	(	IAccessible *	acc,
		LONG	child_id,
		HWND	hwnd,
		BOOL	root_acc_known,
		BOOL	is_root_acc,
		IRawElementProviderSimple **	elprov
	)

Definition at line 1443 of file uia_provider.c.

{
    struct msaa_provider *msaa_prov = calloc(1, sizeof(*msaa_prov));
 
    if (!msaa_prov)
        return E_OUTOFMEMORY;
 
    msaa_prov->IRawElementProviderSimple_iface.lpVtbl = &msaa_provider_vtbl;
    msaa_prov->IRawElementProviderFragment_iface.lpVtbl = &msaa_fragment_vtbl;
    msaa_prov->IRawElementProviderFragmentRoot_iface.lpVtbl = &msaa_fragment_root_vtbl;
    msaa_prov->ILegacyIAccessibleProvider_iface.lpVtbl = &msaa_acc_provider_vtbl;
    msaa_prov->IProxyProviderWinEventHandler_iface.lpVtbl = &msaa_winevent_handler_vtbl;
    msaa_prov->refcount = 1;
    variant_init_i4(&msaa_prov->cid, child_id);
    msaa_prov->acc = acc;
    IAccessible_AddRef(acc);
    msaa_prov->ia2 = msaa_acc_get_ia2(acc);
 
    if (!hwnd)
    {
        HRESULT hr;
 
        hr = WindowFromAccessibleObject(acc, &msaa_prov->hwnd);
        if (FAILED(hr))
            WARN("WindowFromAccessibleObject failed with hr %#lx\n", hr);
    }
    else
        msaa_prov->hwnd = hwnd;
 
    if (root_acc_known)
    {
        msaa_prov->root_acc_check_ran = TRUE;
        msaa_prov->is_root_acc = is_root_acc;
    }
 
    *elprov = &msaa_prov->IRawElementProviderSimple_iface;
 
    return S_OK;
}

Referenced by create_msaa_provider_from_hwnd(), default_uia_provider_callback(), msaa_acc_get_focus(), msaa_fragment_get_FragmentRoot(), msaa_fragment_Navigate(), msaa_fragment_root_GetFocus(), and UiaProviderFromIAccessible().

create_msaa_provider_from_hwnd()

HRESULT create_msaa_provider_from_hwnd	(	HWND	hwnd,
		int	in_child_id,
		IRawElementProviderSimple **	ret_elprov
	)

Definition at line 677 of file uia_event.c.

{
    IRawElementProviderSimple *elprov;
    IAccessible *acc;
    int child_id;
    HRESULT hr;
 
    *ret_elprov = NULL;
    hr = AccessibleObjectFromWindow(hwnd, OBJID_CLIENT, &IID_IAccessible, (void **)&acc);
    if (FAILED(hr))
        return hr;
 
    child_id = in_child_id;
    if (in_child_id != CHILDID_SELF)
    {
        IDispatch *disp;
        VARIANT cid;
 
        disp = NULL;
        variant_init_i4(&cid, in_child_id);
        hr = IAccessible_get_accChild(acc, cid, &disp);
        if (FAILED(hr))
            TRACE("get_accChild failed with %#lx!\n", hr);
 
        if (SUCCEEDED(hr) && disp)
        {
            IAccessible_Release(acc);
            hr = IDispatch_QueryInterface(disp, &IID_IAccessible, (void **)&acc);
            IDispatch_Release(disp);
            if (FAILED(hr))
                return hr;
 
            child_id = CHILDID_SELF;
        }
    }
 
    hr = create_msaa_provider(acc, child_id, hwnd, TRUE, in_child_id == CHILDID_SELF, &elprov);
    IAccessible_Release(acc);
    if (FAILED(hr))
        return hr;
 
    *ret_elprov = elprov;
    return S_OK;
}

Referenced by uia_com_focus_win_event_msaa_handler(), and uia_win_event_for_each_callback().

create_node_from_node_provider()

HRESULT create_node_from_node_provider	(	IWineUiaNode *	node,
		int	idx,
		LONG	flags,
		VARIANT *	ret_val
	)

Definition at line 397 of file uia_client.c.

{
    IWineUiaProvider *prov;
    HRESULT hr;
 
    VariantInit(ret_val);
    hr = IWineUiaNode_get_provider(node, idx, &prov);
    if (FAILED(hr))
        return hr;
 
    hr = IWineUiaProvider_create_node_from_prov(prov, flags, ret_val);
    IWineUiaProvider_Release(prov);
 
    return hr;
}

Referenced by uia_com_focus_win_event_callback(), and uia_nested_node_provider_create_node_from_prov().

create_serverside_uia_event()

HRESULT create_serverside_uia_event	(	struct uia_event **	out_event,
		LONG	process_id,
		LONG	event_cookie
	)

Definition at line 1234 of file uia_event.c.

{
    struct uia_event_identifier event_identifier = { event_cookie, process_id };
    struct rb_entry *rb_entry;
    struct uia_event *event;
    HRESULT hr = S_OK;
 
    /*
     * Attempt to lookup an existing event for this PID/event_cookie. If there
     * is one, return S_FALSE.
     */
    *out_event = NULL;
    EnterCriticalSection(&event_map_cs);
    if (uia_event_map.serverside_event_count && (rb_entry = rb_get(&uia_event_map.serverside_event_map, &event_identifier)))
    {
        *out_event = RB_ENTRY_VALUE(rb_entry, struct uia_event, u.serverside.serverside_event_entry);
        hr = S_FALSE;
        goto exit;
    }
 
    hr = create_uia_event(&event, event_cookie, EVENT_TYPE_SERVERSIDE);
    if (FAILED(hr))
        goto exit;
 
    if (!uia_start_event_thread())
    {
        free(event);
        hr = E_FAIL;
        goto exit;
    }
 
    event->u.serverside.proc_id = process_id;
    uia_event_map.serverside_event_count++;
    if (uia_event_map.serverside_event_count == 1)
        rb_init(&uia_event_map.serverside_event_map, uia_serverside_event_id_compare);
    rb_put(&uia_event_map.serverside_event_map, &event_identifier, &event->u.serverside.serverside_event_entry);
    *out_event = event;
 
exit:
    LeaveCriticalSection(&event_map_cs);
    return hr;
}

Referenced by uia_node_attach_event().

create_uia_iface()

HRESULT create_uia_iface	(	IUnknown **	iface,
		BOOL	is_cui8
	)

Definition at line 4402 of file uia_com_client.c.

{
    struct uia_iface *uia;
 
    uia = calloc(1, sizeof(*uia));
    if (!uia)
        return E_OUTOFMEMORY;
 
    uia->IUIAutomation6_iface.lpVtbl = &uia_iface_vtbl;
    uia->is_cui8 = is_cui8;
    uia->ref = 1;
 
    *iface = (IUnknown *)&uia->IUIAutomation6_iface;
    return S_OK;
}

Referenced by uia_cf_CreateInstance().

create_uia_node_from_elprov()

HRESULT create_uia_node_from_elprov	(	IRawElementProviderSimple *	elprov,
		HUIANODE *	out_node,
		BOOL	get_hwnd_providers,
		int	node_flags
	)

Definition at line 2049 of file uia_client.c.

{
    static const int unsupported_prov_opts = ProviderOptions_ProviderOwnsSetFocus | ProviderOptions_HasNativeIAccessible |
        ProviderOptions_UseClientCoordinates;
    enum ProviderOptions prov_opts;
    struct uia_node *node;
    int prov_type;
    HRESULT hr;
 
    *out_node = NULL;
 
    hr = IRawElementProviderSimple_get_ProviderOptions(elprov, &prov_opts);
    if (FAILED(hr))
        return hr;
 
    if (prov_opts & unsupported_prov_opts)
        FIXME("Ignoring unsupported ProviderOption(s) %#x\n", prov_opts & unsupported_prov_opts);
 
    if (prov_opts & ProviderOptions_OverrideProvider)
        prov_type = PROV_TYPE_OVERRIDE;
    else if (prov_opts & ProviderOptions_NonClientAreaProvider)
        prov_type = PROV_TYPE_NONCLIENT;
    else if (prov_opts & ProviderOptions_ServerSideProvider)
        prov_type = PROV_TYPE_MAIN;
    else if (prov_opts & ProviderOptions_ClientSideProvider)
        prov_type = PROV_TYPE_HWND;
    else
        prov_type = PROV_TYPE_MAIN;
 
    hr = create_uia_node(&node, node_flags);
    if (FAILED(hr))
        return hr;
 
    node->hwnd = get_hwnd_from_provider(elprov);
 
    hr = create_wine_uia_provider(node, elprov, prov_type);
    if (FAILED(hr))
    {
        free(node);
        return hr;
    }
 
    if (node->hwnd && get_hwnd_providers)
    {
        hr = uia_get_providers_for_hwnd(node);
        if (FAILED(hr))
            WARN("uia_get_providers_for_hwnd failed with hr %#lx\n", hr);
    }
 
    hr = prepare_uia_node(node);
    if (FAILED(hr))
    {
        IWineUiaNode_Release(&node->IWineUiaNode_iface);
        return hr;
    }
 
    *out_node = (void *)&node->IWineUiaNode_iface;
 
    return S_OK;
}

Referenced by get_variant_for_elprov_node(), uia_com_focus_win_event_msaa_handler(), uia_provider_attach_event(), uia_raise_elprov_event_callback(), uia_win_event_for_each_callback(), UiaDisconnectProvider(), UiaNodeFromProvider(), and UiaReturnRawElementProvider().

create_uia_node_from_hwnd()

HRESULT create_uia_node_from_hwnd	(	HWND	hwnd,
		HUIANODE *	out_node,
		int	node_flags
	)

Definition at line 2721 of file uia_client.c.

{
    struct uia_node *node;
    HRESULT hr;
 
    if (!out_node)
        return E_INVALIDARG;
 
    *out_node = NULL;
 
    if (!IsWindow(hwnd))
        return UIA_E_ELEMENTNOTAVAILABLE;
 
    hr = create_uia_node(&node, node_flags);
    if (FAILED(hr))
        return hr;
 
    node->hwnd = hwnd;
    hr = uia_get_providers_for_hwnd(node);
    if (FAILED(hr))
    {
        free(node);
        return hr;
    }
 
    hr = prepare_uia_node(node);
    if (FAILED(hr))
    {
        IWineUiaNode_Release(&node->IWineUiaNode_iface);
        return hr;
    }
 
    *out_node = (void *)&node->IWineUiaNode_iface;
 
    return S_OK;
}

Referenced by uia_com_win_event_callback(), uia_event_handlers_add_handler(), UiaHasServerSideProvider(), and UiaNodeFromHandle().

get_focus_from_node_provider()

HRESULT get_focus_from_node_provider	(	IWineUiaNode *	node,
		int	idx,
		LONG	flags,
		VARIANT *	ret_val
	)

Definition at line 350 of file uia_client.c.

{
    IWineUiaProvider *prov;
    HRESULT hr;
 
    VariantInit(ret_val);
    hr = IWineUiaNode_get_provider(node, idx, &prov);
    if (FAILED(hr))
        return hr;
 
    hr = IWineUiaProvider_get_focus(prov, flags, ret_val);
    IWineUiaProvider_Release(prov);
 
    return hr;
}

Referenced by get_focused_uia_node(), uia_com_focus_win_event_handler(), and uia_nested_node_provider_get_focus().

get_interface_in_git()

HRESULT get_interface_in_git	(	REFIID	riid,
		DWORD	git_cookie,
		IUnknown **	ret_iface
	)

Definition at line 79 of file uia_utils.c.

{
    IGlobalInterfaceTable *git;
    IUnknown *iface;
    HRESULT hr;
 
    hr = get_global_interface_table(&git);
    if (FAILED(hr))
        return hr;
 
    hr = IGlobalInterfaceTable_GetInterfaceFromGlobal(git, git_cookie, riid, (void **)&iface);
    if (FAILED(hr))
    {
        ERR("Failed to get interface from Global Interface Table, hr %#lx\n", hr);
        return hr;
    }
 
    *ret_iface = iface;
 
    return S_OK;
}

Referenced by uia_com_event_callback(), uia_event_advise(), uia_event_adviser_advise(), and uia_node_get_provider().

get_node_provider_type_at_idx()

int get_node_provider_type_at_idx	(	struct uia_node *	node,
		int	idx
	)

Definition at line 266 of file uia_client.c.

{
    int i, prov_idx;
 
    for (i = prov_idx = 0; i < PROV_TYPE_COUNT; i++)
    {
        if (node->prov[i])
        {
            if (prov_idx == idx)
                return i;
            else
                prov_idx++;
        }
    }
 
    ERR("Node %p has no provider at idx %d\n", node, idx);
    return 0;
}

Referenced by create_wine_uia_nested_node_provider(), get_focused_uia_node(), get_node_provider_description_string(), set_refuse_hwnd_providers(), uia_node_disconnect(), uia_node_get_provider(), and uia_provider_thread_add_node().

get_safearray_bounds()

HRESULT get_safearray_bounds	(	SAFEARRAY *	sa,
		LONG *	lbound,
		LONG *	elems
	)

Definition at line 319 of file uia_utils.c.

{
    UINT dims;
 
    *lbound = *elems = 0;
    dims = SafeArrayGetDim(sa);
    if (dims != 1)
    {
        WARN("Invalid dimensions %d for safearray.\n", dims);
        return E_FAIL;
    }
 
    return get_safearray_dim_bounds(sa, 1, lbound, elems);
}

Referenced by append_uia_runtime_id(), create_uia_node_safearray(), get_element_variant_from_node_variant(), uia_compare_safearrays(), uia_element_FindAllBuildCache(), uia_element_FindFirstBuildCache(), uia_get_clientside_provider(), uia_iface_IntSafeArrayToNativeArray(), and uia_provider_attach_event().

get_safearray_dim_bounds()

HRESULT get_safearray_dim_bounds	(	SAFEARRAY *	sa,
		UINT	dim,
		LONG *	lbound,
		LONG *	elems
	)

Definition at line 301 of file uia_utils.c.

{
    LONG ubound;
    HRESULT hr;
 
    *lbound = *elems = 0;
    hr = SafeArrayGetLBound(sa, dim, lbound);
    if (FAILED(hr))
        return hr;
 
    hr = SafeArrayGetUBound(sa, dim, &ubound);
    if (FAILED(hr))
        return hr;
 
    *elems = (ubound - (*lbound)) + 1;
    return S_OK;
}

Referenced by get_safearray_bounds(), uia_cache_request_combine(), and UiaFind().

get_variant_for_node()

static void get_variant_for_node ( HUIANODE  node, VARIANT *  v  )

inlinestatic

Definition at line 175 of file uia_private.h.

{
#ifdef _WIN64
    V_VT(v) = VT_I8;
    V_I8(v) = (UINT64)node;
#else
    V_VT(v) = VT_I4;
    V_I4(v) = (UINT32)node;
#endif
}

Referenced by get_variant_for_elprov_node(), uia_nested_node_provider_create_node_from_prov(), uia_nested_node_provider_get_focus(), uia_nested_node_provider_get_prop_val(), uia_nested_node_provider_navigate(), and UiaGetUpdatedCache().

impl_from_IWineUiaNode()

static struct uia_node * impl_from_IWineUiaNode ( IWineUiaNode *  iface )

inlinestatic

Definition at line 87 of file uia_private.h.

{
    return CONTAINING_RECORD(iface, struct uia_node, IWineUiaNode_iface);
}

Referenced by attach_event_to_uia_node(), clone_uia_node(), get_child_for_node(), get_sibling_from_node_provider(), navigate_uia_node(), uia_com_focus_win_event_callback(), uia_event_check_node_within_event_scope(), uia_node_AddRef(), uia_node_attach_event(), uia_node_disconnect(), uia_node_get_hwnd(), uia_node_get_prop_val(), uia_node_get_provider(), uia_node_normalize(), uia_node_Release(), uia_provider_thread_add_node(), uia_provider_thread_remove_node(), and uia_win_event_for_each_callback().

impl_from_IWineUiaProvider()

static struct uia_provider * impl_from_IWineUiaProvider ( IWineUiaProvider *  iface )

inlinestatic

Definition at line 104 of file uia_private.h.

{
    return CONTAINING_RECORD(iface, struct uia_provider, IWineUiaProvider_iface);
}

Referenced by clone_uia_node(), create_wine_uia_nested_node_provider(), prepare_uia_node(), set_refuse_hwnd_providers(), uia_provider_AddRef(), uia_provider_attach_event(), uia_provider_create_node_from_prov(), uia_provider_get_focus(), uia_provider_get_prop_val(), uia_provider_get_prov_opts(), uia_provider_has_parent(), uia_provider_navigate(), uia_provider_Release(), uia_provider_respond_to_win_event(), and uia_provider_thread_add_node().

navigate_uia_node()

HRESULT navigate_uia_node	(	struct uia_node *	node,
		int	nav_dir,
		HUIANODE *	out_node
	)

Definition at line 914 of file uia_client.c.

{
    HRESULT hr;
    VARIANT v;
 
    *out_node = NULL;
 
    VariantInit(&v);
    switch (nav_dir)
    {
    case NavigateDirection_FirstChild:
    case NavigateDirection_LastChild:
        /* First child always comes from last provider index. */
        if (nav_dir == NavigateDirection_FirstChild)
            hr = get_child_for_node(node, node->prov_count - 1, nav_dir, &v);
        else
            hr = get_child_for_node(node, 0, nav_dir, &v);
        if (FAILED(hr))
            WARN("Child navigation failed with hr %#lx\n", hr);
        break;
 
    case NavigateDirection_NextSibling:
    case NavigateDirection_PreviousSibling:
    {
        struct uia_node *node_data;
        HUIANODE parent;
        VARIANT tmp;
 
        hr = get_sibling_from_node_provider(node, node->parent_link_idx, nav_dir, &v);
        if (FAILED(hr))
        {
            WARN("Sibling navigation failed with hr %#lx\n", hr);
            break;
        }
 
        if (V_VT(&v) != VT_EMPTY)
            break;
 
        hr = get_navigate_from_node_provider(&node->IWineUiaNode_iface, node->parent_link_idx,
                NavigateDirection_Parent, &tmp);
        if (FAILED(hr))
        {
            WARN("Parent navigation failed with hr %#lx\n", hr);
            break;
        }
 
        hr = UiaHUiaNodeFromVariant(&tmp, &parent);
        if (FAILED(hr))
            break;
 
        /*
         * If the parent node has multiple providers, attempt to get a sibling
         * from one of them.
         */
        node_data = impl_from_IWineUiaNode((IWineUiaNode *)parent);
        if (node_data->prov_count > 1)
        {
            if (nav_dir == NavigateDirection_NextSibling)
                hr = get_child_for_node(node_data, node_data->creator_prov_idx - 1, NavigateDirection_FirstChild, &v);
            else
                hr = get_child_for_node(node_data, node_data->creator_prov_idx + 1, NavigateDirection_LastChild, &v);
        }
 
        UiaNodeRelease(parent);
        break;
    }
 
    case NavigateDirection_Parent:
        hr = get_navigate_from_node_provider(&node->IWineUiaNode_iface, node->parent_link_idx, nav_dir, &v);
        if (FAILED(hr))
            WARN("Parent navigation failed with hr %#lx\n", hr);
        break;
 
    default:
        WARN("Invalid NavigateDirection %d\n", nav_dir);
        return E_INVALIDARG;
    }
 
    if (V_VT(&v) != VT_EMPTY)
    {
        hr = UiaHUiaNodeFromVariant(&v, (HUIANODE *)out_node);
        if (FAILED(hr))
            WARN("UiaHUiaNodeFromVariant failed with hr %#lx\n", hr);
    }
 
    return S_OK;
}

Referenced by conditional_navigate_uia_node(), traverse_uia_node_tree(), traverse_uia_node_tree_siblings(), and uia_event_check_node_within_event_scope().

register_interface_in_git()

HRESULT register_interface_in_git	(	IUnknown *	iface,
		REFIID	riid,
		DWORD *	ret_cookie
	)

Definition at line 40 of file uia_utils.c.

{
    IGlobalInterfaceTable *git;
    DWORD git_cookie;
    HRESULT hr;
 
    *ret_cookie = 0;
    hr = get_global_interface_table(&git);
    if (FAILED(hr))
        return hr;
 
    hr = IGlobalInterfaceTable_RegisterInterfaceInGlobal(git, iface, riid, &git_cookie);
    if (FAILED(hr))
    {
        WARN("Failed to register interface in GlobalInterfaceTable, hr %#lx\n", hr);
        return hr;
    }
 
    *ret_cookie = git_cookie;
 
    return S_OK;
}

Referenced by clone_uia_node(), create_wine_uia_nested_node_provider(), prepare_uia_node(), uia_add_com_event_handler(), uia_event_add_provider_event_adviser(), and uia_event_add_serverside_event_adviser().

respond_to_win_event_on_node_provider()

HRESULT respond_to_win_event_on_node_provider	(	IWineUiaNode *	node,
		int	idx,
		DWORD	win_event,
		HWND	hwnd,
		LONG	obj_id,
		LONG	child_id,
		IProxyProviderWinEventSink *	sink
	)

Definition at line 381 of file uia_client.c.

{
    IWineUiaProvider *prov;
    HRESULT hr;
 
    hr = IWineUiaNode_get_provider(node, idx, &prov);
    if (FAILED(hr))
        return hr;
 
    hr = IWineUiaProvider_respond_to_win_event(prov, win_event, HandleToUlong(hwnd), obj_id, child_id, sink);
    IWineUiaProvider_Release(prov);
 
    return hr;
}

Referenced by uia_win_event_for_each_callback().

uia_add_clientside_event()

HRESULT uia_add_clientside_event	(	HUIANODE	huianode,
		EVENTID	event_id,
		enum TreeScope	scope,
		PROPERTYID *	prop_ids,
		int	prop_ids_count,
		struct UiaCacheRequest *	cache_req,
		SAFEARRAY *	rt_id,
		UiaWineEventCallback *	cback,
		void *	cback_data,
		HUIAEVENT *	huiaevent
	)

Definition at line 1628 of file uia_event.c.

{
    struct uia_event *event;
    SAFEARRAY *sa;
    HRESULT hr;
 
    hr = SafeArrayCopy(rt_id, &sa);
    if (FAILED(hr))
        return hr;
 
    hr = create_clientside_uia_event(&event, event_id, scope, cback, cback_data, sa);
    if (FAILED(hr))
    {
        SafeArrayDestroy(sa);
        return hr;
    }
 
    hr = uia_cache_request_clone(&event->u.clientside.cache_req, cache_req);
    if (FAILED(hr))
        goto exit;
 
    hr = attach_event_to_uia_node(huianode, event);
    if (FAILED(hr))
        goto exit;
 
    hr = uia_event_advise(event, TRUE, 0);
    if (FAILED(hr))
        goto exit;
 
    hr = uia_event_map_add_event(event);
    if (FAILED(hr))
        goto exit;
 
    *huiaevent = (HUIAEVENT)event;
 
exit:
    if (FAILED(hr))
        IWineUiaEvent_Release(&event->IWineUiaEvent_iface);
 
    return hr;
}

Referenced by uia_add_com_event_handler(), and UiaAddEvent().

uia_array_reserve()

static BOOL uia_array_reserve ( void **  elements, SIZE_T *  capacity, SIZE_T  count, SIZE_T  size  )

inlinestatic

Definition at line 186 of file uia_private.h.

{
    SIZE_T max_capacity, new_capacity;
    void *new_elements;
 
    if (count <= *capacity)
        return TRUE;
 
    max_capacity = ~(SIZE_T)0 / size;
    if (count > max_capacity)
        return FALSE;
 
    new_capacity = max(1, *capacity);
    while (new_capacity < count && new_capacity <= max_capacity / 2)
        new_capacity *= 2;
    if (new_capacity < count)
        new_capacity = count;
 
    new_elements = _recalloc(*elements, new_capacity, size);
    if (!new_elements)
        return FALSE;
 
    *elements = new_elements;
    *capacity = new_capacity;
    return TRUE;
}

Referenced by add_node_to_node_array(), uia_cache_request_AddProperty(), and uia_event_add_event_adviser().

uia_cache_request_clone()

HRESULT uia_cache_request_clone	(	struct UiaCacheRequest *	dst,
		struct UiaCacheRequest *	src
	)

Definition at line 264 of file uia_utils.c.

{
    HRESULT hr;
 
    hr = uia_condition_clone(&dst->pViewCondition, src->pViewCondition);
    if (FAILED(hr))
        return hr;
 
    dst->Scope = src->Scope;
    dst->automationElementMode = src->automationElementMode;
    if (src->cProperties)
    {
        if (!(dst->pProperties = calloc(src->cProperties, sizeof(*dst->pProperties))))
        {
            uia_cache_request_destroy(dst);
            return E_OUTOFMEMORY;
        }
 
        dst->cProperties = src->cProperties;
        memcpy(dst->pProperties, src->pProperties, sizeof(*dst->pProperties) * dst->cProperties);
    }
 
    if (src->cPatterns)
    {
        if (!(dst->pPatterns = calloc(src->cPatterns, sizeof(*dst->pPatterns))))
        {
            uia_cache_request_destroy(dst);
            return E_OUTOFMEMORY;
        }
 
        dst->cPatterns = src->cPatterns;
        memcpy(dst->pPatterns, src->pPatterns, sizeof(*dst->pPatterns) * dst->cPatterns);
    }
 
    return S_OK;
}

Referenced by uia_add_clientside_event().

uia_cache_request_destroy()

void uia_cache_request_destroy

(

struct UiaCacheRequest *

cache_req

)

Definition at line 257 of file uia_utils.c.

{
    uia_condition_destroy(cache_req->pViewCondition);
    free(cache_req->pProperties);
    free(cache_req->pPatterns);
}

Referenced by uia_cache_request_clone(), and uia_event_Release().

uia_clientside_event_start_event_thread()

BOOL uia_clientside_event_start_event_thread

(

struct uia_event *

event

)

Definition at line 988 of file uia_event.c.

{
    if (!event->u.clientside.event_thread_started)
        event->u.clientside.event_thread_started = uia_start_event_thread();
 
    return event->u.clientside.event_thread_started;
}

Referenced by uia_add_com_event_handler(), uia_event_add_serverside_event_adviser(), and uia_event_add_win_event_hwnd().

uia_com_win_event_callback()

HRESULT uia_com_win_event_callback	(	DWORD	event_id,
		HWND	hwnd,
		LONG	obj_id,
		LONG	child_id,
		DWORD	thread_id,
		DWORD	event_time
	)

Definition at line 1154 of file uia_com_client.c.

{
    LONG handler_count;
 
    TRACE("%ld, %p, %ld, %ld, %ld, %ld\n", event_id, hwnd, obj_id, child_id, thread_id, event_time);
 
    EnterCriticalSection(&com_event_handlers_cs);
    handler_count = com_event_handlers.handler_count;
    LeaveCriticalSection(&com_event_handlers_cs);
 
    if (!handler_count)
        return S_OK;
 
    switch (event_id)
    {
    case EVENT_OBJECT_SHOW:
    {
        struct uia_event_handler_map_entry *entry;
        SAFEARRAY *rt_id = NULL;
        HUIANODE node;
        HRESULT hr;
 
        if (obj_id != OBJID_WINDOW || !uia_hwnd_is_visible(hwnd))
            break;
 
        hr = UiaNodeFromHandle(hwnd, &node);
        if (FAILED(hr))
            return hr;
 
        hr = UiaGetRuntimeId(node, &rt_id);
        if (FAILED(hr))
        {
            UiaNodeRelease(node);
            return hr;
        }
 
        EnterCriticalSection(&com_event_handlers_cs);
 
        RB_FOR_EACH_ENTRY(entry, &com_event_handlers.handler_map, struct uia_event_handler_map_entry, entry)
        {
            struct uia_com_event *event;
 
            /*
             * Focus change event handlers only listen for EVENT_OBJECT_SHOW
             * on the desktop HWND.
             */
            if ((entry->event_id == UIA_AutomationFocusChangedEventId) && (hwnd != GetDesktopWindow()))
                continue;
 
            LIST_FOR_EACH_ENTRY(event, &entry->handlers_list, struct uia_com_event, event_handler_map_list_entry)
            {
                hr = uia_event_check_node_within_event_scope((struct uia_event *)event->event, node, rt_id, NULL);
                if (FAILED(hr))
                    WARN("uia_event_check_node_within_scope failed with hr %#lx\n", hr);
                else if (hr == S_OK)
                {
                    hr = uia_event_advise_node((struct uia_event *)event->event, node);
                    if (FAILED(hr))
                        WARN("uia_event_advise_node failed with hr %#lx\n", hr);
                }
            }
        }
 
        LeaveCriticalSection(&com_event_handlers_cs);
 
        UiaNodeRelease(node);
        break;
    }
 
    case EVENT_OBJECT_FOCUS:
    {
        static const int uia_event_id = UIA_AutomationFocusChangedEventId;
        struct rb_entry *rb_entry;
        HRESULT hr;
 
        if (obj_id != OBJID_CLIENT)
            break;
 
        EnterCriticalSection(&com_event_handlers_cs);
 
        if ((rb_entry = rb_get(&com_event_handlers.handler_event_id_map, &uia_event_id)))
        {
            struct uia_event_handler_event_id_map_entry *event_id_map;
            HUIANODE node = NULL;
 
            event_id_map = RB_ENTRY_VALUE(rb_entry, struct uia_event_handler_event_id_map_entry, entry);
            hr = create_uia_node_from_hwnd(hwnd, &node, NODE_FLAG_IGNORE_CLIENTSIDE_HWND_PROVS);
            if (SUCCEEDED(hr))
                uia_com_focus_win_event_handler(node, hwnd, event_id_map);
            else
                uia_com_focus_win_event_msaa_handler(hwnd, child_id);
 
            UiaNodeRelease(node);
        }
 
        LeaveCriticalSection(&com_event_handlers_cs);
        break;
    }
 
    case EVENT_OBJECT_DESTROY:
    {
        static const int uia_event_id = UIA_AutomationFocusChangedEventId;
        struct rb_entry *rb_entry;
 
        if (obj_id != OBJID_WINDOW)
            break;
 
        EnterCriticalSection(&com_event_handlers_cs);
 
        if ((rb_entry = rb_get(&com_event_handlers.handler_event_id_map, &uia_event_id)))
        {
            struct uia_event_handler_event_id_map_entry *event_id_map;
            struct uia_event_handler_map_entry *entry;
 
            event_id_map = RB_ENTRY_VALUE(rb_entry, struct uia_event_handler_event_id_map_entry, entry);
            LIST_FOR_EACH_ENTRY(entry, &event_id_map->handlers_list, struct uia_event_handler_map_entry,
                    handler_event_id_map_list_entry)
            {
                struct uia_com_event *event;
 
                LIST_FOR_EACH_ENTRY(event, &entry->handlers_list, struct uia_com_event, event_handler_map_list_entry)
                {
                    uia_hwnd_map_remove_hwnd(&event->focus_hwnd_map, hwnd);
                }
            }
        }
 
        LeaveCriticalSection(&com_event_handlers_cs);
        break;
    }
 
    default:
        break;
    }
 
    return S_OK;
}

Referenced by uia_event_thread_process_queue().

uia_compare_safearrays()

int uia_compare_safearrays	(	SAFEARRAY *	sa1,
		SAFEARRAY *	sa2,
		int	prop_type
	)

Definition at line 334 of file uia_utils.c.

{
    LONG i, idx, lbound[2], elems[2];
    int val[2];
    HRESULT hr;
 
    hr = get_safearray_bounds(sa1, &lbound[0], &elems[0]);
    if (FAILED(hr))
    {
        ERR("Failed to get safearray bounds from sa1 with hr %#lx\n", hr);
        return -1;
    }
 
    hr = get_safearray_bounds(sa2, &lbound[1], &elems[1]);
    if (FAILED(hr))
    {
        ERR("Failed to get safearray bounds from sa2 with hr %#lx\n", hr);
        return -1;
    }
 
    if (elems[0] != elems[1])
        return (elems[0] > elems[1]) - (elems[0] < elems[1]);
 
    if (prop_type != UIAutomationType_IntArray)
    {
        FIXME("Array type %#x value comparison currently unimplemented.\n", prop_type);
        return -1;
    }
 
    for (i = 0; i < elems[0]; i++)
    {
        idx = lbound[0] + i;
        hr = SafeArrayGetElement(sa1, &idx, &val[0]);
        if (FAILED(hr))
        {
            ERR("Failed to get element from sa1 with hr %#lx\n", hr);
            return -1;
        }
 
        idx = lbound[1] + i;
        hr = SafeArrayGetElement(sa2, &idx, &val[1]);
        if (FAILED(hr))
        {
            ERR("Failed to get element from sa2 with hr %#lx\n", hr);
            return -1;
        }
 
        if (val[0] != val[1])
            return (val[0] > val[1]) - (val[0] < val[1]);
    }
 
    return 0;
}

Referenced by uia_com_event_handler_id_compare(), uia_event_check_node_within_event_scope(), uia_event_map_add_event(), uia_property_condition_check(), and uia_runtime_id_compare().

uia_condition_check()

HRESULT uia_condition_check	(	HUIANODE	node,
		struct UiaCondition *	condition
	)

Definition at line 3363 of file uia_client.c.

{
    HRESULT hr;
 
    switch (condition->ConditionType)
    {
    case ConditionType_True:
        return S_OK;
 
    case ConditionType_False:
        return S_FALSE;
 
    case ConditionType_Not:
    {
        struct UiaNotCondition *not_cond = (struct UiaNotCondition *)condition;
 
        hr = uia_condition_check(node, not_cond->pConditions);
        if (FAILED(hr))
            return hr;
 
        if (uia_condition_matched(hr))
            return S_FALSE;
        else
            return S_OK;
    }
 
    case ConditionType_And:
    case ConditionType_Or:
    {
        struct UiaAndOrCondition *and_or_cond = (struct UiaAndOrCondition *)condition;
        int i;
 
        for (i = 0; i < and_or_cond->cConditions; i++)
        {
            hr = uia_condition_check(node, and_or_cond->ppConditions[i]);
            if (FAILED(hr))
                return hr;
 
            if (condition->ConditionType == ConditionType_And && !uia_condition_matched(hr))
                return S_FALSE;
            else if (condition->ConditionType == ConditionType_Or && uia_condition_matched(hr))
                return S_OK;
        }
 
        if (condition->ConditionType == ConditionType_Or)
            return S_FALSE;
        else
            return S_OK;
    }
 
    case ConditionType_Property:
        return uia_property_condition_check(node, (struct UiaPropertyCondition *)condition);
 
    default:
        WARN("Invalid condition type %d\n", condition->ConditionType);
        return E_INVALIDARG;
    }
}

Referenced by conditional_navigate_uia_node(), traverse_uia_node_tree(), traverse_uia_node_tree_siblings(), uia_condition_check(), uia_event_check_node_within_event_scope(), and uia_node_normalize().

uia_condition_matched()

BOOL uia_condition_matched

(

HRESULT

hr

)

Definition at line 3302 of file uia_client.c.

{
    if (hr == S_FALSE)
        return FALSE;
    else
        return TRUE;
}

Referenced by conditional_navigate_uia_node(), traverse_uia_node_tree(), traverse_uia_node_tree_siblings(), uia_condition_check(), uia_event_check_node_within_event_scope(), and uia_node_normalize().

uia_control_type_info_from_id()

const struct uia_control_type_info * uia_control_type_info_from_id

(

CONTROLTYPEID

control_type_id

)

Definition at line 616 of file uia_ids.c.

{
    if ((control_type_id < CONTROL_TYPE_ID_MIN) || (control_type_id >= CONTROL_TYPE_ID_MAX))
        return NULL;
 
    return &default_uia_control_types[control_type_id_idx[control_type_id - CONTROL_TYPE_ID_MIN]];
}

Referenced by uia_elem_get_control_type().

uia_event_add_provider_event_adviser()

HRESULT uia_event_add_provider_event_adviser	(	IRawElementProviderAdviseEvents *	advise_events,
		struct uia_event *	event
	)

Definition at line 1385 of file uia_event.c.

{
    struct uia_event_adviser *adv_events;
    IRawElementProviderSimple *elprov;
    enum ProviderOptions prov_opts;
    HRESULT hr;
 
    hr = IRawElementProviderAdviseEvents_QueryInterface(advise_events, &IID_IRawElementProviderSimple,
            (void **)&elprov);
    if (FAILED(hr))
    {
        ERR("Failed to get IRawElementProviderSimple from advise events\n");
        return E_FAIL;
    }
 
    hr = IRawElementProviderSimple_get_ProviderOptions(elprov, &prov_opts);
    IRawElementProviderSimple_Release(elprov);
    if (FAILED(hr))
        return hr;
 
    if (!(adv_events = calloc(1, sizeof(*adv_events))))
        return E_OUTOFMEMORY;
 
    if (prov_opts & ProviderOptions_UseComThreading)
    {
        hr = register_interface_in_git((IUnknown *)advise_events, &IID_IRawElementProviderAdviseEvents,
                &adv_events->git_cookie);
        if (FAILED(hr))
        {
            free(adv_events);
            return hr;
        }
    }
 
    adv_events->IWineUiaEventAdviser_iface.lpVtbl = &uia_event_adviser_vtbl;
    adv_events->ref = 1;
    adv_events->advise_events = advise_events;
    IRawElementProviderAdviseEvents_AddRef(advise_events);
 
    hr = uia_event_add_event_adviser(&adv_events->IWineUiaEventAdviser_iface, event);
    IWineUiaEventAdviser_Release(&adv_events->IWineUiaEventAdviser_iface);
 
    return hr;
}

Referenced by uia_provider_attach_event().

uia_event_add_serverside_event_adviser()

HRESULT uia_event_add_serverside_event_adviser	(	IWineUiaEvent *	serverside_event,
		struct uia_event *	event
	)

Definition at line 1519 of file uia_event.c.

{
    struct uia_serverside_event_adviser *adv_events;
    HRESULT hr;
 
    /*
     * Need to create a proxy IWineUiaEvent for our clientside event to use
     * this serverside IWineUiaEvent proxy from the appropriate apartment.
     */
    if (!event->u.clientside.git_cookie)
    {
        if (!uia_clientside_event_start_event_thread(event))
            return E_FAIL;
 
        hr = register_interface_in_git((IUnknown *)&event->IWineUiaEvent_iface, &IID_IWineUiaEvent,
                &event->u.clientside.git_cookie);
        if (FAILED(hr))
            return hr;
    }
 
    if (!(adv_events = calloc(1, sizeof(*adv_events))))
        return E_OUTOFMEMORY;
 
    adv_events->IWineUiaEventAdviser_iface.lpVtbl = &uia_serverside_event_adviser_vtbl;
    adv_events->ref = 1;
    adv_events->event_iface = serverside_event;
    IWineUiaEvent_AddRef(serverside_event);
 
    hr = uia_event_add_event_adviser(&adv_events->IWineUiaEventAdviser_iface, event);
    IWineUiaEventAdviser_Release(&adv_events->IWineUiaEventAdviser_iface);
 
    return hr;
}

Referenced by uia_nested_node_provider_attach_event().

uia_event_add_win_event_hwnd()

HRESULT uia_event_add_win_event_hwnd	(	struct uia_event *	event,
		HWND	hwnd
	)

Definition at line 83 of file uia_event.c.

{
    if (!uia_clientside_event_start_event_thread(event))
        return E_FAIL;
 
    if (hwnd == GetDesktopWindow())
        EnumWindows(uia_win_event_enum_top_level_hwnds, (LPARAM)&event->u.clientside.win_event_hwnd_map);
 
    return uia_hwnd_map_add_hwnd(&event->u.clientside.win_event_hwnd_map, hwnd);
}

Referenced by uia_provider_attach_event().

uia_event_advise_node()

HRESULT uia_event_advise_node	(	struct uia_event *	event,
		HUIANODE	node
	)

Definition at line 1577 of file uia_event.c.

{
    int old_event_advisers_count = event->event_advisers_count;
    HRESULT hr;
 
    hr = attach_event_to_uia_node(node, event);
    if (FAILED(hr))
        return hr;
 
    if (event->event_advisers_count != old_event_advisers_count)
        hr = uia_event_advise(event, TRUE, old_event_advisers_count);
 
    return hr;
}

Referenced by uia_com_focus_handler_advise_node(), uia_com_win_event_callback(), and UiaEventAddWindow().

uia_event_check_node_within_event_scope()

HRESULT uia_event_check_node_within_event_scope	(	struct uia_event *	event,
		HUIANODE	node,
		SAFEARRAY *	rt_id,
		HUIANODE *	clientside_nav_node_out
	)

Definition at line 1814 of file uia_event.c.

{
    struct UiaPropertyCondition prop_cond = { ConditionType_Property, UIA_RuntimeIdPropertyId };
    struct uia_node *node_data = impl_from_IWineUiaNode((IWineUiaNode *)node);
    BOOL in_scope = FALSE;
    HRESULT hr = S_FALSE;
 
    if (clientside_nav_node_out)
        *clientside_nav_node_out = NULL;
 
    if (event->event_type == EVENT_TYPE_SERVERSIDE)
        assert(clientside_nav_node_out);
 
    /* Event is no longer valid. */
    if (InterlockedCompareExchange(&event->event_defunct, 0, 0) != 0)
        return S_FALSE;
 
    /* Can't match an event that doesn't have a runtime ID, early out. */
    if (!event->runtime_id)
        return S_FALSE;
 
    if (event->desktop_subtree_event)
        return S_OK;
 
    if (rt_id && !uia_compare_safearrays(rt_id, event->runtime_id, UIAutomationType_IntArray))
        return (event->scope & TreeScope_Element) ? S_OK : S_FALSE;
 
    if (!(event->scope & (TreeScope_Descendants | TreeScope_Children)))
        return S_FALSE;
 
    V_VT(&prop_cond.Value) = VT_I4 | VT_ARRAY;
    V_ARRAY(&prop_cond.Value) = event->runtime_id;
 
    IWineUiaNode_AddRef(&node_data->IWineUiaNode_iface);
    while (1)
    {
        HUIANODE node2 = NULL;
 
        /*
         * When trying to match serverside events through navigation, we
         * don't want any clientside providers added in the server process.
         * Once we encounter a provider with an HWND, we pass it off to the
         * client for any further navigation.
         */
        if (event->event_type == EVENT_TYPE_SERVERSIDE)
        {
            if (node_data->hwnd)
            {
                *clientside_nav_node_out = (HUIANODE)&node_data->IWineUiaNode_iface;
                IWineUiaNode_AddRef(&node_data->IWineUiaNode_iface);
                in_scope = TRUE;
                break;
            }
            set_refuse_hwnd_providers(node_data, TRUE);
        }
 
        hr = navigate_uia_node(node_data, NavigateDirection_Parent, &node2);
        if (FAILED(hr) || !node2)
            break;
 
        IWineUiaNode_Release(&node_data->IWineUiaNode_iface);
 
        node_data = impl_from_IWineUiaNode((IWineUiaNode *)node2);
        hr = uia_condition_check(node2, (struct UiaCondition *)&prop_cond);
        if (FAILED(hr))
            break;
 
        if (uia_condition_matched(hr))
        {
            in_scope = TRUE;
            break;
        }
 
        if (!(event->scope & TreeScope_Descendants))
            break;
    }
    IWineUiaNode_Release(&node_data->IWineUiaNode_iface);
 
    if (FAILED(hr))
        return hr;
 
    return in_scope ? S_OK : S_FALSE;
}

Referenced by uia_com_win_event_callback(), uia_event_invoke(), and uia_raise_elprov_event_callback().

uia_event_for_each()

HRESULT uia_event_for_each	(	int	event_id,
		UiaWineEventForEachCallback *	callback,
		void *	user_data,
		BOOL	clientside_only
	)

Definition at line 255 of file uia_event.c.

{
    struct uia_event_map_entry *event_entry;
    HRESULT hr = S_OK;
    int i;
 
    EnterCriticalSection(&event_map_cs);
    if ((event_entry = uia_get_event_map_entry_for_event(event_id)))
        InterlockedIncrement(&event_entry->refs);
    LeaveCriticalSection(&event_map_cs);
 
    if (!event_entry)
        return S_OK;
 
    for (i = 0; i < 2; i++)
    {
        struct list *events = !i ? &event_entry->events_list : &event_entry->serverside_events_list;
        struct list *cursor, *cursor2;
 
        if (i && clientside_only)
            break;
 
        LIST_FOR_EACH_SAFE(cursor, cursor2, events)
        {
            struct uia_event *event = LIST_ENTRY(cursor, struct uia_event, event_list_entry);
 
            /* Event is no longer valid. */
            if (InterlockedCompareExchange(&event->event_defunct, 0, 0) != 0)
                continue;
 
            hr = callback(event, user_data);
            if (FAILED(hr))
                goto exit;
        }
    }
 
exit:
    if (FAILED(hr))
        WARN("Event callback failed with hr %#lx\n", hr);
    uia_event_map_entry_release(event_entry);
    return hr;
}

Referenced by uia_com_focus_win_event_handler(), uia_com_focus_win_event_msaa_handler(), uia_event_thread_process_queue(), and uia_raise_elprov_event().

uia_event_info_from_id()

const struct uia_event_info * uia_event_info_from_id

(

EVENTID

event_id

)

Definition at line 438 of file uia_ids.c.

{
    if ((event_id < EVENT_ID_MIN) || (event_id >= EVENT_ID_MAX))
        return NULL;
 
    return &default_uia_events[event_id_idx[event_id - EVENT_ID_MIN]];
}

Referenced by uia_event_raise_event(), uia_proxy_win_event_sink_AddAutomationEvent(), uia_serverside_event_adviser_advise(), UiaAddEvent(), and UiaRaiseAutomationEvent().

uia_event_invoke()

HRESULT uia_event_invoke	(	HUIANODE	node,
		HUIANODE	nav_start_node,
		struct uia_event_args *	args,
		struct uia_event *	event
	)

Definition at line 1738 of file uia_event.c.

{
    HRESULT hr = S_OK;
 
    if (event->event_type == EVENT_TYPE_CLIENTSIDE)
    {
        SAFEARRAY *out_req;
        BSTR tree_struct;
 
        if (nav_start_node && (hr = uia_event_check_node_within_event_scope(event, nav_start_node, NULL, NULL)) != S_OK)
            return hr;
 
        hr = UiaGetUpdatedCache(node, &event->u.clientside.cache_req, NormalizeState_View, NULL, &out_req,
                &tree_struct);
        if (SUCCEEDED(hr))
        {
            hr = event->u.clientside.event_callback(event, args, out_req, tree_struct);
            if (FAILED(hr))
                WARN("Event callback failed with hr %#lx\n", hr);
            SafeArrayDestroy(out_req);
            SysFreeString(tree_struct);
        }
    }
    else
    {
        struct uia_queue_uia_event *queue_event;
        HUIANODE node2, nav_start_node2;
 
        if (!(queue_event = calloc(1, sizeof(*queue_event))))
            return E_OUTOFMEMORY;
 
        node2 = nav_start_node2 = NULL;
        hr = clone_uia_node(node, &node2);
        if (FAILED(hr))
        {
            free(queue_event);
            return hr;
        }
 
        if (nav_start_node)
        {
            hr = clone_uia_node(nav_start_node, &nav_start_node2);
            if (FAILED(hr))
            {
                free(queue_event);
                UiaNodeRelease(node2);
                return hr;
            }
        }
 
        queue_event->args = args;
        queue_event->event = event;
        queue_event->u.serverside.node = node2;
        queue_event->u.serverside.nav_start_node = nav_start_node2;
 
        InterlockedIncrement(&args->ref);
        IWineUiaEvent_AddRef(&event->IWineUiaEvent_iface);
        uia_event_queue_push(&queue_event->queue_entry, QUEUE_EVENT_TYPE_SERVERSIDE);
    }
 
    return hr;
}

Referenced by uia_com_focus_win_event_msaa_callback(), uia_raise_clientside_event(), and uia_raise_elprov_event_callback().

uia_hwnd_is_visible()

BOOL uia_hwnd_is_visible

(

HWND

hwnd

)

Definition at line 391 of file uia_utils.c.

{
    RECT rect;
 
    if (!IsWindowVisible(hwnd))
        return FALSE;
 
    if (!GetWindowRect(hwnd, &rect))
        return FALSE;
 
    if ((rect.right - rect.left) <= 0 || (rect.bottom - rect.top) <= 0)
        return FALSE;
 
    return TRUE;
}

Referenced by uia_com_win_event_callback(), and uia_win_event_enum_top_level_hwnds().

uia_hwnd_map_add_hwnd()

HRESULT uia_hwnd_map_add_hwnd	(	struct rb_tree *	hwnd_map,
		HWND	hwnd
	)

Definition at line 442 of file uia_utils.c.

{
    struct uia_hwnd_map_entry *entry;
 
    if (uia_hwnd_map_check_hwnd(hwnd_map, hwnd))
    {
        TRACE("hwnd %p already in map %p\n", hwnd, hwnd_map);
        return S_OK;
    }
 
    if (!(entry = calloc(1, sizeof(*entry))))
        return E_OUTOFMEMORY;
 
    TRACE("Adding hwnd %p to map %p\n", hwnd, hwnd_map);
    entry->hwnd = hwnd;
    rb_put(hwnd_map, hwnd, &entry->entry);
 
    return S_OK;
}

Referenced by uia_com_focus_handler_advise_node(), uia_event_add_win_event_hwnd(), and uia_win_event_enum_top_level_hwnds().

uia_hwnd_map_check_hwnd()

BOOL uia_hwnd_map_check_hwnd	(	struct rb_tree *	hwnd_map,
		HWND	hwnd
	)

Definition at line 437 of file uia_utils.c.

{
    return !!rb_get(hwnd_map, hwnd);
}

Referenced by uia_com_focus_win_event_handler(), uia_hwnd_map_add_hwnd(), uia_win_event_for_each_callback(), and uia_win_event_hwnd_map_contains_ancestors().

uia_hwnd_map_destroy()

void uia_hwnd_map_destroy

(

struct rb_tree *

hwnd_map

)

Definition at line 484 of file uia_utils.c.

{
    rb_destroy(hwnd_map, uia_hwnd_map_free, hwnd_map);
}

Referenced by uia_event_handler_destroy(), and uia_event_Release().

uia_hwnd_map_init()

void uia_hwnd_map_init

(

struct rb_tree *

hwnd_map

)

Definition at line 479 of file uia_utils.c.

{
    rb_init(hwnd_map, uia_hwnd_map_hwnd_compare);
}

Referenced by create_clientside_uia_event(), and uia_add_com_event_handler().

uia_hwnd_map_remove_hwnd()

void uia_hwnd_map_remove_hwnd	(	struct rb_tree *	hwnd_map,
		HWND	hwnd
	)

Definition at line 462 of file uia_utils.c.

{
    struct rb_entry *rb_entry = rb_get(hwnd_map, hwnd);
    struct uia_hwnd_map_entry *entry;
 
    if (!rb_entry)
    {
        TRACE("hwnd %p not in map %p, nothing to remove.\n", hwnd, hwnd_map);
        return;
    }
 
    TRACE("Removing hwnd %p from map %p\n", hwnd, hwnd_map);
    entry = RB_ENTRY_VALUE(rb_entry, struct uia_hwnd_map_entry, entry);
    rb_remove(hwnd_map, &entry->entry);
    free(entry);
}

Referenced by uia_com_win_event_callback().

uia_is_top_level_hwnd()

BOOL uia_is_top_level_hwnd

(

HWND

hwnd

)

Definition at line 407 of file uia_utils.c.

{
    return GetAncestor(hwnd, GA_PARENT) == GetDesktopWindow();
}

Referenced by base_hwnd_fragment_get_BoundingRectangle(), base_hwnd_fragment_Navigate(), and get_uia_control_type_for_hwnd().

uia_lresult_from_node()

LRESULT uia_lresult_from_node

(

HUIANODE

huianode

)

Definition at line 2236 of file uia_provider.c.

{
    SAFEARRAY *rt_id;
    LRESULT lr = 0;
    HRESULT hr;
 
    hr = UiaGetRuntimeId(huianode, &rt_id);
    if (SUCCEEDED(hr) && uia_start_provider_thread())
        lr = SendMessageW(provider_thread.hwnd, WM_GET_OBJECT_UIA_NODE, (WPARAM)rt_id, (LPARAM)huianode);
 
    if (FAILED(hr))
        WARN("UiaGetRuntimeId failed with hr %#lx\n", hr);
 
    /*
     * LresultFromObject increases refcnt by 1. If LresultFromObject
     * failed or wasn't called, this is expected to release the node.
     */
    UiaNodeRelease(huianode);
    SafeArrayDestroy(rt_id);
    return lr;
}

Referenced by get_variant_for_elprov_node(), uia_raise_serverside_event(), and UiaReturnRawElementProvider().

uia_node_from_lresult()

HRESULT uia_node_from_lresult	(	LRESULT	lr,
		HUIANODE *	huianode,
		int	node_flags
	)

Definition at line 2642 of file uia_client.c.

{
    struct uia_node *node;
    HRESULT hr;
 
    *huianode = NULL;
 
    hr = create_uia_node(&node, node_flags);
    if (FAILED(hr))
    {
        uia_node_lresult_release(lr);
        return hr;
    }
 
    uia_start_client_thread();
    hr = create_wine_uia_nested_node_provider(node, lr, FALSE);
    if (FAILED(hr))
    {
        free(node);
        return hr;
    }
 
    if (node->hwnd)
    {
        hr = uia_get_providers_for_hwnd(node);
        if (FAILED(hr))
            WARN("uia_get_providers_for_hwnd failed with hr %#lx\n", hr);
    }
 
    hr = prepare_uia_node(node);
    if (FAILED(hr))
    {
        IWineUiaNode_Release(&node->IWineUiaNode_iface);
        return hr;
    }
 
    *huianode = (void *)&node->IWineUiaNode_iface;
 
    return hr;
}

Referenced by uia_com_focus_win_event_handler(), uia_nested_node_provider_create_node_from_prov(), uia_nested_node_provider_get_focus(), uia_nested_node_provider_get_prop_val(), uia_nested_node_provider_navigate(), and uia_raise_clientside_event().

uia_node_lresult_release()

void uia_node_lresult_release

(

LRESULT

lr

)

Definition at line 2683 of file uia_client.c.

{
    IWineUiaNode *node;
 
    if (lr && SUCCEEDED(ObjectFromLresult(lr, &IID_IWineUiaNode, 0, (void **)&node)))
        IWineUiaNode_Release(node);
}

Referenced by uia_com_focus_win_event_callback(), uia_node_from_lresult(), uia_raise_clientside_event(), and uia_raise_serverside_event().

uia_pattern_info_from_id()

const struct uia_pattern_info * uia_pattern_info_from_id

(

PATTERNID

pattern_id

)

Definition at line 540 of file uia_ids.c.

{
    if ((pattern_id < PATTERN_ID_MIN) || (pattern_id >= PATTERN_ID_MAX))
        return NULL;
 
    return &default_uia_patterns[pattern_id_idx[pattern_id - PATTERN_ID_MIN]];
}

Referenced by uia_provider_get_pattern_prop_val().

uia_prop_info_from_id()

const struct uia_prop_info * uia_prop_info_from_id

(

PROPERTYID

prop_id

)

Definition at line 332 of file uia_ids.c.

{
    if ((prop_id < PROP_ID_MIN) || (prop_id >= PROP_ID_MAX))
        return NULL;
 
    return &default_uia_properties[prop_id_idx[prop_id - PROP_ID_MIN]];
}

Referenced by create_uia_element_from_cache_req(), create_uia_property_condition_iface(), get_node_provider_description_string(), uia_cache_request_AddProperty(), uia_element_GetCachedPropertyValueEx(), uia_element_GetCurrentPropertyValueEx(), uia_property_condition_check(), UiaGetPropertyValue(), UiaGetRuntimeId(), and UiaGetUpdatedCache().

uia_provider_thread_remove_node()

void uia_provider_thread_remove_node

(

HUIANODE

node

)

Definition at line 1975 of file uia_provider.c.

{
    struct uia_node *node_data = impl_from_IWineUiaNode((IWineUiaNode *)node);
 
    TRACE("Removing node %p\n", node);
 
    EnterCriticalSection(&provider_thread_cs);
 
    list_remove(&node_data->prov_thread_list_entry);
    list_init(&node_data->prov_thread_list_entry);
    if (!list_empty(&node_data->node_map_list_entry))
    {
        list_remove(&node_data->node_map_list_entry);
        list_init(&node_data->node_map_list_entry);
        if (list_empty(&node_data->map->nodes_list))
        {
            rb_remove(&provider_thread.node_map, &node_data->map->entry);
            SafeArrayDestroy(node_data->map->runtime_id);
            free(node_data->map);
        }
        node_data->map = NULL;
    }
 
    LeaveCriticalSection(&provider_thread_cs);
}

Referenced by uia_node_Release().

uia_stop_provider_thread()

void uia_stop_provider_thread

(

void

)

Definition at line 2217 of file uia_provider.c.

{
    EnterCriticalSection(&provider_thread_cs);
    if (!--provider_thread.ref)
    {
        PostMessageW(provider_thread.hwnd, WM_UIA_PROVIDER_THREAD_STOP, 0, 0);
        CloseHandle(provider_thread.hthread);
        if (!list_empty(&provider_thread.nodes_list))
            ERR("Provider thread shutdown with nodes still in the list\n");
        memset(&provider_thread, 0, sizeof(provider_thread));
    }
    LeaveCriticalSection(&provider_thread_cs);
}

Referenced by uia_node_Release().

unregister_interface_in_git()

HRESULT unregister_interface_in_git

(

DWORD

git_cookie

)

Definition at line 63 of file uia_utils.c.

{
    IGlobalInterfaceTable *git;
    HRESULT hr;
 
    hr = get_global_interface_table(&git);
    if (FAILED(hr))
        return hr;
 
    hr = IGlobalInterfaceTable_RevokeInterfaceFromGlobal(git, git_cookie);
    if (FAILED(hr))
        WARN("Failed to revoke interface from GlobalInterfaceTable, hr %#lx\n", hr);
 
    return hr;
}

Referenced by uia_event_adviser_Release(), uia_event_handler_destroy(), uia_node_disconnect(), uia_node_Release(), and UiaRemoveEvent().

variant_init_bool()

static void variant_init_bool ( VARIANT *  v, BOOL  val  )

inlinestatic

Definition at line 163 of file uia_private.h.

{
    V_VT(v) = VT_BOOL;
    V_BOOL(v) = val ? VARIANT_TRUE : VARIANT_FALSE;
}

Referenced by msaa_provider_GetPropertyValue(), and uia_provider_get_pattern_prop_val().

variant_init_i4()

static void variant_init_i4 ( VARIANT *  v, int  val  )

inlinestatic

Definition at line 169 of file uia_private.h.

{
    V_VT(v) = VT_I4;
    V_I4(v) = val;
}

Referenced by create_msaa_provider(), create_msaa_provider_from_hwnd(), msaa_acc_compare(), msaa_acc_get_next_child(), msaa_acc_prop_match(), msaa_provider_GetPropertyValue(), uia_provider_get_pattern_prop_val(), and uia_raise_serverside_event().

write_runtime_id_base()

HRESULT write_runtime_id_base	(	SAFEARRAY *	sa,
		HWND	hwnd
	)

Definition at line 102 of file uia_utils.c.

{
    const int rt_id[2] = { UIA_RUNTIME_ID_PREFIX, HandleToUlong(hwnd) };
    HRESULT hr;
    LONG idx;
 
    for (idx = 0; idx < ARRAY_SIZE(rt_id); idx++)
    {
        hr = SafeArrayPutElement(sa, &idx, (void *)&rt_id[idx]);
        if (FAILED(hr))
            return hr;
    }
 
    return S_OK;
}

Referenced by append_uia_runtime_id(), uia_init_desktop_rt_id(), and UiaGetRuntimeId().

Variable Documentation

huia_module

HMODULE huia_module

extern

Definition at line 29 of file uia_main.c.

Referenced by DllMain(), uia_client_thread_proc(), uia_event_thread_proc(), and uia_provider_thread_proc().