uia_event.c File Reference

#include "uia_private.h"
#include "wine/debug.h"
#include "wine/rbtree.h"

Include dependency graph for uia_event.c:

Go to the source code of this file.

Classes
struct	uia_event_map
struct	uia_event_map_entry
struct	uia_event_identifier
struct	event_sink_event
struct	uia_proxy_win_event_sink
struct	uia_event_thread
struct	uia_queue_event
struct	uia_queue_uia_event
struct	uia_queue_win_event
struct	uia_elprov_event_data
struct	uia_event_adviser
struct	uia_serverside_event_adviser

Macros
#define	WM_UIA_EVENT_THREAD_STOP   (WM_USER + 1)
#define	WM_UIA_EVENT_THREAD_PROCESS_QUEUE   (WM_USER + 2)

Enumerations
enum	uia_queue_event_type { QUEUE_EVENT_TYPE_SERVERSIDE , QUEUE_EVENT_TYPE_CLIENTSIDE , QUEUE_EVENT_TYPE_WIN_EVENT }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (uiautomation)
static BOOL WINAPI	uia_init_desktop_rt_id (INIT_ONCE *once, void *param, void **ctx)
static SAFEARRAY *	uia_get_desktop_rt_id (void)
static int	win_event_to_uia_event_id (int win_event)
static BOOL CALLBACK	uia_win_event_enum_top_level_hwnds (HWND hwnd, LPARAM lparam)
HRESULT	uia_event_add_win_event_hwnd (struct uia_event *event, HWND hwnd)
static int	uia_serverside_event_id_compare (const void *key, const struct rb_entry *entry)
static int	uia_event_map_id_compare (const void *key, const struct rb_entry *entry)
static struct uia_event_map_entry *	uia_get_event_map_entry_for_event (int event_id)
static HRESULT	uia_event_map_add_event (struct uia_event *event)
static void	uia_event_map_entry_release (struct uia_event_map_entry *entry)
HRESULT	uia_event_for_each (int event_id, UiaWineEventForEachCallback *callback, void *user_data, BOOL clientside_only)
static struct uia_event_args *	create_uia_event_args (const struct uia_event_info *event_info)
static void	uia_event_args_release (struct uia_event_args *args)
static HRESULT	uia_event_sink_list_add_event (struct list *sink_events, IRawElementProviderSimple *elprov, struct uia_event_args *args)
static struct uia_proxy_win_event_sink *	impl_from_IProxyProviderWinEventSink (IProxyProviderWinEventSink *iface)
static HRESULT WINAPI	uia_proxy_win_event_sink_QueryInterface (IProxyProviderWinEventSink *iface, REFIID riid, void **obj)
static ULONG WINAPI	uia_proxy_win_event_sink_AddRef (IProxyProviderWinEventSink *iface)
static ULONG WINAPI	uia_proxy_win_event_sink_Release (IProxyProviderWinEventSink *iface)
static HRESULT WINAPI	uia_proxy_win_event_sink_AddAutomationPropertyChangedEvent (IProxyProviderWinEventSink *iface, IRawElementProviderSimple *elprov, PROPERTYID prop_id, VARIANT new_value)
static HRESULT WINAPI	uia_proxy_win_event_sink_AddAutomationEvent (IProxyProviderWinEventSink *iface, IRawElementProviderSimple *elprov, EVENTID event_id)
static HRESULT WINAPI	uia_proxy_win_event_sink_AddStructureChangedEvent (IProxyProviderWinEventSink *iface, IRawElementProviderSimple *elprov, enum StructureChangeType structure_change_type, SAFEARRAY *runtime_id)
static HRESULT	create_proxy_win_event_sink (struct uia_proxy_win_event_sink **out_sink, int event_id)
static void	uia_event_queue_push (struct uia_queue_event *event, int queue_event_type)
static struct uia_queue_event *	uia_event_queue_pop (struct list *event_queue)
static HRESULT	uia_raise_clientside_event (struct uia_queue_uia_event *event)
static HRESULT	uia_raise_serverside_event (struct uia_queue_uia_event *event)
static BOOL	uia_win_event_hwnd_map_contains_ancestors (struct rb_tree *hwnd_map, HWND hwnd)
HRESULT	create_msaa_provider_from_hwnd (HWND hwnd, int in_child_id, IRawElementProviderSimple **ret_elprov)
static HRESULT	uia_raise_elprov_event_callback (struct uia_event *event, void *data)
static HRESULT	uia_win_event_for_each_callback (struct uia_event *event, void *data)
static void	uia_event_thread_process_queue (struct list *event_queue)
static void CALLBACK	uia_event_thread_win_event_proc (HWINEVENTHOOK hook, DWORD event_id, HWND hwnd, LONG obj_id, LONG child_id, DWORD thread_id, DWORD event_time)
static DWORD WINAPI	uia_event_thread_proc (void *arg)
static BOOL	uia_start_event_thread (void)
static void	uia_stop_event_thread (void)
BOOL	uia_clientside_event_start_event_thread (struct uia_event *event)
static void	uia_event_clear_advisers (struct uia_event *event)
static struct uia_event *	impl_from_IWineUiaEvent (IWineUiaEvent *iface)
static HRESULT WINAPI	uia_event_QueryInterface (IWineUiaEvent *iface, REFIID riid, void **ppv)
static ULONG WINAPI	uia_event_AddRef (IWineUiaEvent *iface)
static ULONG WINAPI	uia_event_Release (IWineUiaEvent *iface)
static HRESULT WINAPI	uia_event_advise_events (IWineUiaEvent *iface, BOOL advise_added, LONG adviser_start_idx)
static HRESULT WINAPI	uia_event_set_event_data (IWineUiaEvent *iface, const GUID *event_guid, LONG scope, VARIANT runtime_id, IWineUiaEvent *event_iface)
static HRESULT WINAPI	uia_event_raise_event (IWineUiaEvent *iface, VARIANT in_node, VARIANT in_nav_start_node)
static struct uia_event *	unsafe_impl_from_IWineUiaEvent (IWineUiaEvent *iface)
static HRESULT	create_uia_event (struct uia_event **out_event, LONG event_cookie, int event_type)
static HRESULT	create_clientside_uia_event (struct uia_event **out_event, int event_id, int scope, UiaWineEventCallback *cback, void *cback_data, SAFEARRAY *runtime_id)
HRESULT	create_serverside_uia_event (struct uia_event **out_event, LONG process_id, LONG event_cookie)
static HRESULT	uia_event_add_event_adviser (IWineUiaEventAdviser *adviser, struct uia_event *event)
static struct uia_event_adviser *	impl_from_IWineUiaEventAdviser (IWineUiaEventAdviser *iface)
static HRESULT WINAPI	uia_event_adviser_QueryInterface (IWineUiaEventAdviser *iface, REFIID riid, void **ppv)
static ULONG WINAPI	uia_event_adviser_AddRef (IWineUiaEventAdviser *iface)
static ULONG WINAPI	uia_event_adviser_Release (IWineUiaEventAdviser *iface)
static HRESULT WINAPI	uia_event_adviser_advise (IWineUiaEventAdviser *iface, BOOL advise_added, LONG_PTR huiaevent)
HRESULT	uia_event_add_provider_event_adviser (IRawElementProviderAdviseEvents *advise_events, struct uia_event *event)
static struct uia_serverside_event_adviser *	impl_from_serverside_IWineUiaEventAdviser (IWineUiaEventAdviser *iface)
static HRESULT WINAPI	uia_serverside_event_adviser_QueryInterface (IWineUiaEventAdviser *iface, REFIID riid, void **ppv)
static ULONG WINAPI	uia_serverside_event_adviser_AddRef (IWineUiaEventAdviser *iface)
static ULONG WINAPI	uia_serverside_event_adviser_Release (IWineUiaEventAdviser *iface)
static HRESULT WINAPI	uia_serverside_event_adviser_advise (IWineUiaEventAdviser *iface, BOOL advise_added, LONG_PTR huiaevent)
HRESULT	uia_event_add_serverside_event_adviser (IWineUiaEvent *serverside_event, struct uia_event *event)
static HRESULT	uia_event_advise (struct uia_event *event, BOOL advise_added, LONG start_idx)
HRESULT	uia_event_advise_node (struct uia_event *event, HUIANODE node)
HRESULT WINAPI	UiaEventAddWindow (HUIAEVENT huiaevent, HWND hwnd)
static HRESULT	uia_clientside_event_callback (struct uia_event *event, struct uia_event_args *args, SAFEARRAY *cache_req, BSTR tree_struct)
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 WINAPI	UiaAddEvent (HUIANODE huianode, EVENTID event_id, UiaEventCallback *callback, enum TreeScope scope, PROPERTYID *prop_ids, int prop_ids_count, struct UiaCacheRequest *cache_req, HUIAEVENT *huiaevent)
HRESULT WINAPI	UiaRemoveEvent (HUIAEVENT huiaevent)
HRESULT	uia_event_invoke (HUIANODE node, HUIANODE nav_start_node, struct uia_event_args *args, struct uia_event *event)
static void	set_refuse_hwnd_providers (struct uia_node *node, BOOL refuse_hwnd_providers)
HRESULT	uia_event_check_node_within_event_scope (struct uia_event *event, HUIANODE node, SAFEARRAY *rt_id, HUIANODE *clientside_nav_node_out)
static HRESULT	uia_raise_elprov_event (IRawElementProviderSimple *elprov, struct uia_event_args *args)
HRESULT WINAPI	UiaRaiseAutomationEvent (IRawElementProviderSimple *elprov, EVENTID id)

Variables
static SAFEARRAY *	uia_desktop_node_rt_id
static struct uia_event_map	uia_event_map
static CRITICAL_SECTION	event_map_cs = { &event_map_cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	event_map_cs_debug
static const IProxyProviderWinEventSinkVtbl	uia_proxy_event_sink_vtbl
static struct uia_event_thread	event_thread
static CRITICAL_SECTION	event_thread_cs = { &event_thread_cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	event_thread_cs_debug
static const IWineUiaEventVtbl	uia_event_vtbl
static const IWineUiaEventAdviserVtbl	uia_event_adviser_vtbl
static const IWineUiaEventAdviserVtbl	uia_serverside_event_adviser_vtbl

Macro Definition Documentation

WM_UIA_EVENT_THREAD_PROCESS_QUEUE

#define WM_UIA_EVENT_THREAD_PROCESS_QUEUE   (WM_USER + 2)

Definition at line 496 of file uia_event.c.

WM_UIA_EVENT_THREAD_STOP

#define WM_UIA_EVENT_THREAD_STOP   (WM_USER + 1)

Definition at line 495 of file uia_event.c.

Enumeration Type Documentation

uia_queue_event_type

enum uia_queue_event_type

Enumerator
QUEUE_EVENT_TYPE_SERVERSIDE
QUEUE_EVENT_TYPE_CLIENTSIDE
QUEUE_EVENT_TYPE_WIN_EVENT

Definition at line 507 of file uia_event.c.

                          {
    QUEUE_EVENT_TYPE_SERVERSIDE,
    QUEUE_EVENT_TYPE_CLIENTSIDE,
    QUEUE_EVENT_TYPE_WIN_EVENT,
};

Function Documentation

create_clientside_uia_event()

static HRESULT create_clientside_uia_event ( struct uia_event **  out_event, int  event_id, int  scope, UiaWineEventCallback *  cback, void *  cback_data, SAFEARRAY *  runtime_id  )

static

Definition at line 1211 of file uia_event.c.

{
    struct uia_event *event = NULL;
    static LONG next_event_cookie;
    HRESULT hr;
 
    *out_event = NULL;
    hr = create_uia_event(&event, InterlockedIncrement(&next_event_cookie), EVENT_TYPE_CLIENTSIDE);
    if (FAILED(hr))
        return hr;
 
    event->runtime_id = runtime_id;
    event->event_id = event_id;
    event->scope = scope;
    event->u.clientside.event_callback = cback;
    event->u.clientside.callback_data = cback_data;
    uia_hwnd_map_init(&event->u.clientside.win_event_hwnd_map);
 
    *out_event = event;
    return S_OK;
}

Referenced by uia_add_clientside_event().

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_proxy_win_event_sink()

static HRESULT create_proxy_win_event_sink ( struct uia_proxy_win_event_sink **  out_sink, int  event_id  )

static

Definition at line 457 of file uia_event.c.

{
    struct uia_proxy_win_event_sink *sink = calloc(1, sizeof(*sink));
    HRESULT hr;
 
    *out_sink = NULL;
    if (!sink)
        return E_OUTOFMEMORY;
 
    sink->IProxyProviderWinEventSink_iface.lpVtbl = &uia_proxy_event_sink_vtbl;
    sink->ref = 1;
    sink->event_id = event_id;
    list_init(&sink->sink_events);
 
    hr = CoCreateFreeThreadedMarshaler((IUnknown *)&sink->IProxyProviderWinEventSink_iface, &sink->marshal);
    if (FAILED(hr))
    {
        free(sink);
        return hr;
    }
 
    *out_sink = sink;
    return S_OK;
}

Referenced by uia_win_event_for_each_callback().

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_event()

static HRESULT create_uia_event ( struct uia_event **  out_event, LONG  event_cookie, int  event_type  )

static

Definition at line 1194 of file uia_event.c.

{
    struct uia_event *event = calloc(1, sizeof(*event));
 
    *out_event = NULL;
    if (!event)
        return E_OUTOFMEMORY;
 
    event->IWineUiaEvent_iface.lpVtbl = &uia_event_vtbl;
    event->ref = 1;
    event->event_cookie = event_cookie;
    event->event_type = event_type;
    *out_event = event;
 
    return S_OK;
}

Referenced by create_clientside_uia_event(), and create_serverside_uia_event().

create_uia_event_args()

static struct uia_event_args * create_uia_event_args ( const struct uia_event_info *  event_info )

static

Definition at line 305 of file uia_event.c.

{
    struct uia_event_args *args = calloc(1, sizeof(*args));
 
    if (!args)
        return NULL;
 
    args->simple_args.Type = event_info->event_arg_type;
    args->simple_args.EventId = event_info->event_id;
    args->ref = 1;
 
    return args;
}

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

impl_from_IProxyProviderWinEventSink()

static struct uia_proxy_win_event_sink * impl_from_IProxyProviderWinEventSink ( IProxyProviderWinEventSink *  iface )

inlinestatic

Definition at line 364 of file uia_event.c.

{
    return CONTAINING_RECORD(iface, struct uia_proxy_win_event_sink, IProxyProviderWinEventSink_iface);
}

Referenced by uia_proxy_win_event_sink_AddAutomationEvent(), uia_proxy_win_event_sink_AddRef(), uia_proxy_win_event_sink_QueryInterface(), and uia_proxy_win_event_sink_Release().

impl_from_IWineUiaEvent()

static struct uia_event * impl_from_IWineUiaEvent ( IWineUiaEvent *  iface )

inlinestatic

Definition at line 1010 of file uia_event.c.

{
    return CONTAINING_RECORD(iface, struct uia_event, IWineUiaEvent_iface);
}

Referenced by uia_event_AddRef(), uia_event_advise_events(), uia_event_raise_event(), uia_event_Release(), and uia_event_set_event_data().

impl_from_IWineUiaEventAdviser()

static struct uia_event_adviser * impl_from_IWineUiaEventAdviser ( IWineUiaEventAdviser *  iface )

inlinestatic

Definition at line 1301 of file uia_event.c.

{
    return CONTAINING_RECORD(iface, struct uia_event_adviser, IWineUiaEventAdviser_iface);
}

Referenced by uia_event_adviser_AddRef(), uia_event_adviser_advise(), and uia_event_adviser_Release().

impl_from_serverside_IWineUiaEventAdviser()

static struct uia_serverside_event_adviser * impl_from_serverside_IWineUiaEventAdviser ( IWineUiaEventAdviser *  iface )

inlinestatic

Definition at line 1440 of file uia_event.c.

{
    return CONTAINING_RECORD(iface, struct uia_serverside_event_adviser, IWineUiaEventAdviser_iface);
}

Referenced by uia_serverside_event_adviser_AddRef(), uia_serverside_event_adviser_advise(), and uia_serverside_event_adviser_Release().

set_refuse_hwnd_providers()

static void set_refuse_hwnd_providers ( struct uia_node *  node, BOOL  refuse_hwnd_providers  )

static

Definition at line 1801 of file uia_event.c.

{
    struct uia_provider *prov_data = impl_from_IWineUiaProvider(node->prov[get_node_provider_type_at_idx(node, 0)]);
 
    prov_data->refuse_hwnd_node_providers = refuse_hwnd_providers;
}

Referenced by uia_event_check_node_within_event_scope().

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_clientside_event_callback()

static HRESULT uia_clientside_event_callback ( struct uia_event *  event, struct uia_event_args *  args, SAFEARRAY *  cache_req, BSTR  tree_struct  )

static

Definition at line 1618 of file uia_event.c.

{
    UiaEventCallback *event_callback = (UiaEventCallback *)event->u.clientside.callback_data;
 
    event_callback(&args->simple_args, cache_req, tree_struct);
 
    return S_OK;
}

Referenced by UiaAddEvent().

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_event_add_event_adviser()

static HRESULT uia_event_add_event_adviser ( IWineUiaEventAdviser *  adviser, struct uia_event *  event  )

static

Definition at line 1277 of file uia_event.c.

{
    if (!uia_array_reserve((void **)&event->event_advisers, &event->event_advisers_arr_size,
                event->event_advisers_count + 1, sizeof(*event->event_advisers)))
        return E_OUTOFMEMORY;
 
    event->event_advisers[event->event_advisers_count] = adviser;
    IWineUiaEventAdviser_AddRef(adviser);
    event->event_advisers_count++;
 
    return S_OK;
}

Referenced by uia_event_add_provider_event_adviser(), and uia_event_add_serverside_event_adviser().

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_AddRef()

static ULONG WINAPI uia_event_AddRef ( IWineUiaEvent *  iface )

static

Definition at line 1027 of file uia_event.c.

{
    struct uia_event *event = impl_from_IWineUiaEvent(iface);
    ULONG ref = InterlockedIncrement(&event->ref);
 
    TRACE("%p, refcount %ld\n", event, ref);
    return ref;
}

uia_event_advise()

static HRESULT uia_event_advise ( struct uia_event *  event, BOOL  advise_added, LONG  start_idx  )

static

Definition at line 1553 of file uia_event.c.

{
    IWineUiaEvent *event_iface;
    HRESULT hr;
 
    if (event->u.clientside.git_cookie)
    {
        hr = get_interface_in_git(&IID_IWineUiaEvent, event->u.clientside.git_cookie,
                (IUnknown **)&event_iface);
        if (FAILED(hr))
            return hr;
    }
    else
    {
        event_iface = &event->IWineUiaEvent_iface;
        IWineUiaEvent_AddRef(event_iface);
    }
 
    hr = IWineUiaEvent_advise_events(event_iface, advise_added, start_idx);
    IWineUiaEvent_Release(event_iface);
 
    return hr;
}

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

uia_event_advise_events()

static HRESULT WINAPI uia_event_advise_events ( IWineUiaEvent *  iface, BOOL  advise_added, LONG  adviser_start_idx  )

static

Definition at line 1076 of file uia_event.c.

{
    struct uia_event *event = impl_from_IWineUiaEvent(iface);
    HRESULT hr;
    int i;
 
    TRACE("%p, %d, %ld\n", event, advise_added, adviser_start_idx);
 
    for (i = adviser_start_idx; i < event->event_advisers_count; i++)
    {
        hr = IWineUiaEventAdviser_advise(event->event_advisers[i], advise_added, (UINT_PTR)event);
        if (FAILED(hr))
            return hr;
    }
 
    /*
     * First call to advise events on a serverside provider, add it to the
     * events list so it can be raised.
     */
    if (!adviser_start_idx && advise_added && event->event_type == EVENT_TYPE_SERVERSIDE)
    {
        hr = uia_event_map_add_event(event);
        if (FAILED(hr))
            WARN("Failed to add event to event map, hr %#lx\n", hr);
    }
 
    /*
     * Once we've advised of removal, no need to keep the advisers around.
     * We can also release our reference to the event map.
     */
    if (!advise_added)
    {
        InterlockedIncrement(&event->event_defunct);
        uia_event_map_entry_release(event->event_map_entry);
        event->event_map_entry = NULL;
 
        uia_event_clear_advisers(event);
    }
 
    return S_OK;
}

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_adviser_AddRef()

static ULONG WINAPI uia_event_adviser_AddRef ( IWineUiaEventAdviser *  iface )

static

Definition at line 1318 of file uia_event.c.

{
    struct uia_event_adviser *adv_events = impl_from_IWineUiaEventAdviser(iface);
    ULONG ref = InterlockedIncrement(&adv_events->ref);
 
    TRACE("%p, refcount %ld\n", adv_events, ref);
    return ref;
}

uia_event_adviser_advise()

static HRESULT WINAPI uia_event_adviser_advise ( IWineUiaEventAdviser *  iface, BOOL  advise_added, LONG_PTR  huiaevent  )

static

Definition at line 1347 of file uia_event.c.

{
    struct uia_event_adviser *adv_events = impl_from_IWineUiaEventAdviser(iface);
    struct uia_event *event_data = (struct uia_event *)huiaevent;
    IRawElementProviderAdviseEvents *advise_events;
    HRESULT hr;
 
    TRACE("%p, %d, %#Ix\n", adv_events, advise_added, huiaevent);
 
    if (adv_events->git_cookie)
    {
        hr = get_interface_in_git(&IID_IRawElementProviderAdviseEvents, adv_events->git_cookie,
                (IUnknown **)&advise_events);
        if (FAILED(hr))
            return hr;
    }
    else
    {
        advise_events = adv_events->advise_events;
        IRawElementProviderAdviseEvents_AddRef(advise_events);
    }
 
    if (advise_added)
        hr = IRawElementProviderAdviseEvents_AdviseEventAdded(advise_events, event_data->event_id, NULL);
    else
        hr = IRawElementProviderAdviseEvents_AdviseEventRemoved(advise_events, event_data->event_id, NULL);
 
    IRawElementProviderAdviseEvents_Release(advise_events);
    return hr;
}

uia_event_adviser_QueryInterface()

static HRESULT WINAPI uia_event_adviser_QueryInterface ( IWineUiaEventAdviser *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 1306 of file uia_event.c.

{
    *ppv = NULL;
    if (IsEqualIID(riid, &IID_IWineUiaEventAdviser) || IsEqualIID(riid, &IID_IUnknown))
        *ppv = iface;
    else
        return E_NOINTERFACE;
 
    IWineUiaEventAdviser_AddRef(iface);
    return S_OK;
}

uia_event_adviser_Release()

static ULONG WINAPI uia_event_adviser_Release ( IWineUiaEventAdviser *  iface )

static

Definition at line 1327 of file uia_event.c.

{
    struct uia_event_adviser *adv_events = impl_from_IWineUiaEventAdviser(iface);
    ULONG ref = InterlockedDecrement(&adv_events->ref);
 
    TRACE("%p, refcount %ld\n", adv_events, ref);
    if (!ref)
    {
        if (adv_events->git_cookie)
        {
            if (FAILED(unregister_interface_in_git(adv_events->git_cookie)))
                WARN("Failed to revoke advise events interface from GIT\n");
        }
        IRawElementProviderAdviseEvents_Release(adv_events->advise_events);
        free(adv_events);
    }
 
    return ref;
}

uia_event_args_release()

static void uia_event_args_release ( struct uia_event_args *  args )

static

Definition at line 319 of file uia_event.c.

{
    if (!InterlockedDecrement(&args->ref))
        free(args);
}

Referenced by uia_event_thread_process_queue(), uia_proxy_win_event_sink_AddAutomationEvent(), uia_win_event_for_each_callback(), and UiaRaiseAutomationEvent().

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_clear_advisers()

static void uia_event_clear_advisers ( struct uia_event *  event )

static

Definition at line 996 of file uia_event.c.

{
    int i;
 
    for (i = 0; i < event->event_advisers_count; i++)
        IWineUiaEventAdviser_Release(event->event_advisers[i]);
    free(event->event_advisers);
    event->event_advisers = NULL;
    event->event_advisers_count = event->event_advisers_arr_size = 0;
}

Referenced by uia_event_advise_events(), and uia_event_Release().

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_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_event_map_add_event()

static HRESULT uia_event_map_add_event ( struct uia_event *  event )

static

Definition at line 170 of file uia_event.c.

{
    const int subtree_scope = TreeScope_Element | TreeScope_Descendants;
    struct uia_event_map_entry *event_entry;
 
    if (((event->scope & subtree_scope) == subtree_scope) && event->runtime_id &&
            !uia_compare_safearrays(uia_get_desktop_rt_id(), event->runtime_id, UIAutomationType_IntArray))
        event->desktop_subtree_event = TRUE;
 
    EnterCriticalSection(&event_map_cs);
 
    if (!(event_entry = uia_get_event_map_entry_for_event(event->event_id)))
    {
        if (!(event_entry = calloc(1, sizeof(*event_entry))))
        {
            LeaveCriticalSection(&event_map_cs);
            return E_OUTOFMEMORY;
        }
 
        event_entry->event_id = event->event_id;
        list_init(&event_entry->events_list);
        list_init(&event_entry->serverside_events_list);
 
        if (!uia_event_map.event_count)
            rb_init(&uia_event_map.event_map, uia_event_map_id_compare);
        rb_put(&uia_event_map.event_map, &event->event_id, &event_entry->entry);
        uia_event_map.event_count++;
    }
 
    IWineUiaEvent_AddRef(&event->IWineUiaEvent_iface);
    if (event->event_type == EVENT_TYPE_SERVERSIDE)
        list_add_head(&event_entry->serverside_events_list, &event->event_list_entry);
    else
        list_add_head(&event_entry->events_list, &event->event_list_entry);
    InterlockedIncrement(&event_entry->refs);
 
    event->event_map_entry = event_entry;
    LeaveCriticalSection(&event_map_cs);
 
    return S_OK;
}

Referenced by uia_add_clientside_event(), and uia_event_advise_events().

uia_event_map_entry_release()

static void uia_event_map_entry_release ( struct uia_event_map_entry *  entry )

static

Definition at line 212 of file uia_event.c.

{
    ULONG ref = InterlockedDecrement(&entry->refs);
 
    if (!ref)
    {
        struct list *cursor, *cursor2;
 
        EnterCriticalSection(&event_map_cs);
 
        /*
         * Someone grabbed this while we were waiting to enter the CS, abort
         * destruction.
         */
        if (InterlockedCompareExchange(&entry->refs, 0, 0) != 0)
        {
            LeaveCriticalSection(&event_map_cs);
            return;
        }
 
        rb_remove(&uia_event_map.event_map, &entry->entry);
        uia_event_map.event_count--;
        LeaveCriticalSection(&event_map_cs);
 
        /* Release all events in the list. */
        LIST_FOR_EACH_SAFE(cursor, cursor2, &entry->events_list)
        {
            struct uia_event *event = LIST_ENTRY(cursor, struct uia_event, event_list_entry);
 
            IWineUiaEvent_Release(&event->IWineUiaEvent_iface);
        }
 
        LIST_FOR_EACH_SAFE(cursor, cursor2, &entry->serverside_events_list)
        {
            struct uia_event *event = LIST_ENTRY(cursor, struct uia_event, event_list_entry);
 
            IWineUiaEvent_Release(&event->IWineUiaEvent_iface);
        }
 
        free(entry);
    }
}

Referenced by uia_event_advise_events(), and uia_event_for_each().

uia_event_map_id_compare()

static int uia_event_map_id_compare ( const void *  key, const struct rb_entry *  entry  )

static

Definition at line 151 of file uia_event.c.

{
    struct uia_event_map_entry *event_entry = RB_ENTRY_VALUE(entry, struct uia_event_map_entry, entry);
    int event_id = *((int *)key);
 
    return (event_entry->event_id > event_id) - (event_entry->event_id < event_id);
}

Referenced by uia_event_map_add_event().

uia_event_QueryInterface()

static HRESULT WINAPI uia_event_QueryInterface ( IWineUiaEvent *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 1015 of file uia_event.c.

{
    *ppv = NULL;
    if (IsEqualIID(riid, &IID_IWineUiaEvent) || IsEqualIID(riid, &IID_IUnknown))
        *ppv = iface;
    else
        return E_NOINTERFACE;
 
    IWineUiaEvent_AddRef(iface);
    return S_OK;
}

uia_event_queue_pop()

static struct uia_queue_event * uia_event_queue_pop ( struct list *  event_queue )

static

Definition at line 574 of file uia_event.c.

{
    struct uia_queue_event *queue_event = NULL;
 
    EnterCriticalSection(&event_thread_cs);
 
    if (!list_empty(event_queue))
    {
        queue_event = LIST_ENTRY(list_head(event_queue), struct uia_queue_event, event_queue_entry);
        list_remove(list_head(event_queue));
    }
 
    LeaveCriticalSection(&event_thread_cs);
    return queue_event;
}

Referenced by uia_event_thread_process_queue().

uia_event_queue_push()

static void uia_event_queue_push ( struct uia_queue_event *  event, int  queue_event_type  )

static

Definition at line 550 of file uia_event.c.

{
    event->queue_event_type = queue_event_type;
    EnterCriticalSection(&event_thread_cs);
 
    if (queue_event_type == QUEUE_EVENT_TYPE_WIN_EVENT)
    {
        struct uia_queue_win_event *win_event = (struct uia_queue_win_event *)event;
 
        if (win_event->hook != event_thread.hook)
        {
            free(event);
            goto exit;
        }
    }
 
    assert(event_thread.event_queue);
    list_add_tail(event_thread.event_queue, &event->event_queue_entry);
    PostMessageW(event_thread.hwnd, WM_UIA_EVENT_THREAD_PROCESS_QUEUE, 0, 0);
 
exit:
    LeaveCriticalSection(&event_thread_cs);
}

Referenced by uia_event_invoke(), uia_event_raise_event(), and uia_event_thread_win_event_proc().

uia_event_raise_event()

static HRESULT WINAPI uia_event_raise_event ( IWineUiaEvent *  iface, VARIANT  in_node, VARIANT  in_nav_start_node  )

static

Definition at line 1146 of file uia_event.c.

{
    struct uia_event *event = impl_from_IWineUiaEvent(iface);
    struct uia_queue_uia_event *queue_event;
    struct uia_event_args *args;
 
    TRACE("%p, %s, %s\n", iface, debugstr_variant(&in_node), debugstr_variant(&in_nav_start_node));
 
    assert(event->event_type != EVENT_TYPE_SERVERSIDE);
 
    if (!(queue_event = calloc(1, sizeof(*queue_event))))
        return E_OUTOFMEMORY;
 
    if (!(args = create_uia_event_args(uia_event_info_from_id(event->event_id))))
    {
        free(queue_event);
        return E_OUTOFMEMORY;
    }
 
    queue_event->args = args;
    queue_event->event = event;
    queue_event->u.clientside.node = V_I4(&in_node);
    if (V_VT(&in_nav_start_node) == VT_I4)
        queue_event->u.clientside.nav_start_node = V_I4(&in_nav_start_node);
 
    IWineUiaEvent_AddRef(&event->IWineUiaEvent_iface);
    uia_event_queue_push(&queue_event->queue_entry, QUEUE_EVENT_TYPE_CLIENTSIDE);
 
    return S_OK;
}

uia_event_Release()

static ULONG WINAPI uia_event_Release ( IWineUiaEvent *  iface )

static

Definition at line 1036 of file uia_event.c.

{
    struct uia_event *event = impl_from_IWineUiaEvent(iface);
    ULONG ref = InterlockedDecrement(&event->ref);
 
    TRACE("%p, refcount %ld\n", event, ref);
    if (!ref)
    {
        /*
         * If this event has an event_map_entry, it should've been released
         * before hitting a reference count of 0.
         */
        assert(!event->event_map_entry);
 
        SafeArrayDestroy(event->runtime_id);
        if (event->event_type == EVENT_TYPE_CLIENTSIDE)
        {
            uia_cache_request_destroy(&event->u.clientside.cache_req);
            if (event->u.clientside.event_thread_started)
                uia_stop_event_thread();
            uia_hwnd_map_destroy(&event->u.clientside.win_event_hwnd_map);
        }
        else
        {
            EnterCriticalSection(&event_map_cs);
            rb_remove(&uia_event_map.serverside_event_map, &event->u.serverside.serverside_event_entry);
            uia_event_map.serverside_event_count--;
            LeaveCriticalSection(&event_map_cs);
            if (event->u.serverside.event_iface)
                IWineUiaEvent_Release(event->u.serverside.event_iface);
            uia_stop_event_thread();
        }
 
        uia_event_clear_advisers(event);
        free(event);
    }
 
    return ref;
}

uia_event_set_event_data()

static HRESULT WINAPI uia_event_set_event_data ( IWineUiaEvent *  iface, const GUID *  event_guid, LONG  scope, VARIANT  runtime_id, IWineUiaEvent *  event_iface  )

static

Definition at line 1118 of file uia_event.c.

{
    struct uia_event *event = impl_from_IWineUiaEvent(iface);
 
    TRACE("%p, %s, %ld, %s, %p\n", event, debugstr_guid(event_guid), scope, debugstr_variant(&runtime_id), event_iface);
 
    assert(event->event_type == EVENT_TYPE_SERVERSIDE);
 
    event->event_id = UiaLookupId(AutomationIdentifierType_Event, event_guid);
    event->scope = scope;
    if (V_VT(&runtime_id) == (VT_I4 | VT_ARRAY))
    {
        HRESULT hr;
 
        hr = SafeArrayCopy(V_ARRAY(&runtime_id), &event->runtime_id);
        if (FAILED(hr))
        {
            WARN("Failed to copy runtime id, hr %#lx\n", hr);
            return hr;
        }
    }
    event->u.serverside.event_iface = event_iface;
    IWineUiaEvent_AddRef(event_iface);
 
    return S_OK;
}

uia_event_sink_list_add_event()

static HRESULT uia_event_sink_list_add_event ( struct list *  sink_events, IRawElementProviderSimple *  elprov, struct uia_event_args *  args  )

static

Definition at line 333 of file uia_event.c.

{
    struct event_sink_event *sink_event = calloc(1, sizeof(*sink_event));
 
    if (!sink_event)
        return E_OUTOFMEMORY;
 
    IRawElementProviderSimple_AddRef(elprov);
    InterlockedIncrement(&args->ref);
 
    sink_event->elprov = elprov;
    sink_event->args = args;
    list_add_tail(sink_events, &sink_event->event_sink_list_entry);
 
    return S_OK;
}

Referenced by uia_proxy_win_event_sink_AddAutomationEvent().

uia_event_thread_proc()

static DWORD WINAPI uia_event_thread_proc ( void *  arg )

static

Definition at line 884 of file uia_event.c.

{
    HANDLE initialized_event = arg;
    struct list event_queue;
    HWINEVENTHOOK hook;
    HWND hwnd;
    MSG msg;
 
    list_init(&event_queue);
    CoInitializeEx(NULL, COINIT_MULTITHREADED);
    hwnd = CreateWindowW(L"Message", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
    if (!hwnd)
    {
        WARN("CreateWindow failed: %ld\n", GetLastError());
        CoUninitialize();
        FreeLibraryAndExitThread(huia_module, 1);
    }
 
    event_thread.hwnd = hwnd;
    event_thread.event_queue = &event_queue;
    event_thread.hook = hook = SetWinEventHook(EVENT_MIN, EVENT_MAX, 0, uia_event_thread_win_event_proc, 0, 0,
            WINEVENT_OUTOFCONTEXT);
 
    /* Initialization complete, thread can now process window messages. */
    SetEvent(initialized_event);
    TRACE("Event thread started.\n");
    while (GetMessageW(&msg, NULL, 0, 0))
    {
        if ((msg.hwnd == hwnd) && ((msg.message == WM_UIA_EVENT_THREAD_STOP) ||
                    (msg.message == WM_UIA_EVENT_THREAD_PROCESS_QUEUE)))
        {
            uia_event_thread_process_queue(&event_queue);
            if (msg.message == WM_UIA_EVENT_THREAD_STOP)
                break;
        }
 
        TranslateMessage(&msg);
        DispatchMessageW(&msg);
    }
 
    TRACE("Shutting down UI Automation event thread.\n");
 
    UnhookWinEvent(hook);
    DestroyWindow(hwnd);
    CoUninitialize();
    FreeLibraryAndExitThread(huia_module, 0);
}

Referenced by uia_start_event_thread().

uia_event_thread_process_queue()

static void uia_event_thread_process_queue ( struct list *  event_queue )

static

Definition at line 806 of file uia_event.c.

{
    while (1)
    {
        struct uia_queue_event *event;
        HRESULT hr = S_OK;
 
        if (!(event = uia_event_queue_pop(event_queue)))
            break;
 
        switch (event->queue_event_type)
        {
        case QUEUE_EVENT_TYPE_SERVERSIDE:
        case QUEUE_EVENT_TYPE_CLIENTSIDE:
        {
            struct uia_queue_uia_event *uia_event = (struct uia_queue_uia_event *)event;
 
            if (event->queue_event_type == QUEUE_EVENT_TYPE_SERVERSIDE)
                hr = uia_raise_serverside_event(uia_event);
            else
                hr = uia_raise_clientside_event(uia_event);
 
            uia_event_args_release(uia_event->args);
            IWineUiaEvent_Release(&uia_event->event->IWineUiaEvent_iface);
            break;
        }
 
        case QUEUE_EVENT_TYPE_WIN_EVENT:
        {
            struct uia_queue_win_event *win_event = (struct uia_queue_win_event *)event;
 
            hr = uia_com_win_event_callback(win_event->event_id, win_event->hwnd, win_event->obj_id, win_event->child_id,
                    win_event->thread_id, win_event->event_time);
            if (FAILED(hr))
                WARN("uia_com_win_event_callback failed with hr %#lx\n", hr);
 
            hr = uia_event_for_each(win_event_to_uia_event_id(win_event->event_id), uia_win_event_for_each_callback,
                    (void *)win_event, TRUE);
            break;
        }
 
        default:
            break;
        }
 
        if (FAILED(hr))
            WARN("Failed to raise event type %d with hr %#lx\n", event->queue_event_type, hr);
 
        free(event);
    }
}

Referenced by uia_event_thread_proc().

uia_event_thread_win_event_proc()

static void CALLBACK uia_event_thread_win_event_proc ( HWINEVENTHOOK  hook, DWORD  event_id, HWND  hwnd, LONG  obj_id, LONG  child_id, DWORD  thread_id, DWORD  event_time  )

static

Definition at line 858 of file uia_event.c.

{
    struct uia_queue_win_event *win_event;
 
    TRACE("%p, %ld, %p, %ld, %ld, %ld, %ld\n", hook, event_id, hwnd, obj_id, child_id, thread_id, event_time);
 
    if (!win_event_to_uia_event_id(event_id))
        return;
 
    if (!(win_event = calloc(1, sizeof(*win_event))))
    {
        ERR("Failed to allocate uia_queue_win_event structure\n");
        return;
    }
 
    win_event->hook = hook;
    win_event->event_id = event_id;
    win_event->hwnd = hwnd;
    win_event->obj_id = obj_id;
    win_event->child_id = child_id;
    win_event->thread_id = thread_id;
    win_event->event_time = event_time;
    uia_event_queue_push(&win_event->queue_entry, QUEUE_EVENT_TYPE_WIN_EVENT);
}

Referenced by uia_event_thread_proc().

uia_get_desktop_rt_id()

static SAFEARRAY * uia_get_desktop_rt_id ( void  )

static

Definition at line 42 of file uia_event.c.

{
    static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
 
    if (!uia_desktop_node_rt_id)
        InitOnceExecuteOnce(&once, uia_init_desktop_rt_id, NULL, NULL);
 
    return uia_desktop_node_rt_id;
}

Referenced by uia_event_map_add_event().

uia_get_event_map_entry_for_event()

static struct uia_event_map_entry * uia_get_event_map_entry_for_event ( int  event_id )

static

Definition at line 159 of file uia_event.c.

{
    struct uia_event_map_entry *map_entry = NULL;
    struct rb_entry *rb_entry;
 
    if (uia_event_map.event_count && (rb_entry = rb_get(&uia_event_map.event_map, &event_id)))
        map_entry = RB_ENTRY_VALUE(rb_entry, struct uia_event_map_entry, entry);
 
    return map_entry;
}

Referenced by uia_event_for_each(), and uia_event_map_add_event().

uia_init_desktop_rt_id()

static BOOL WINAPI uia_init_desktop_rt_id ( INIT_ONCE *  once, void *  param, void **  ctx  )

static

Definition at line 27 of file uia_event.c.

{
    SAFEARRAY *sa;
 
    if ((sa = SafeArrayCreateVector(VT_I4, 0, 2)))
    {
        if (SUCCEEDED(write_runtime_id_base(sa, GetDesktopWindow())))
            uia_desktop_node_rt_id = sa;
        else
            SafeArrayDestroy(sa);
    }
 
    return !!uia_desktop_node_rt_id;
}

Referenced by uia_get_desktop_rt_id().

uia_proxy_win_event_sink_AddAutomationEvent()

static HRESULT WINAPI uia_proxy_win_event_sink_AddAutomationEvent ( IProxyProviderWinEventSink *  iface, IRawElementProviderSimple *  elprov, EVENTID  event_id  )

static

Definition at line 419 of file uia_event.c.

{
    struct uia_proxy_win_event_sink *sink = impl_from_IProxyProviderWinEventSink(iface);
    struct uia_event_args *args;
    HRESULT hr = S_OK;
 
    TRACE("%p, %p, %d\n", iface, elprov, event_id);
 
    if (event_id != sink->event_id)
        return S_OK;
 
    args = create_uia_event_args(uia_event_info_from_id(event_id));
    if (!args)
        return E_OUTOFMEMORY;
 
    if (InterlockedCompareExchange(&sink->sink_defunct, 0, 0) == 0)
        hr = uia_event_sink_list_add_event(&sink->sink_events, elprov, args);
    uia_event_args_release(args);
    return hr;
}

uia_proxy_win_event_sink_AddAutomationPropertyChangedEvent()

static HRESULT WINAPI uia_proxy_win_event_sink_AddAutomationPropertyChangedEvent ( IProxyProviderWinEventSink *  iface, IRawElementProviderSimple *  elprov, PROPERTYID  prop_id, VARIANT  new_value  )

static

Definition at line 412 of file uia_event.c.

{
    FIXME("%p, %p, %d, %s: stub\n", iface, elprov, prop_id, debugstr_variant(&new_value));
    return E_NOTIMPL;
}

uia_proxy_win_event_sink_AddRef()

static ULONG WINAPI uia_proxy_win_event_sink_AddRef ( IProxyProviderWinEventSink *  iface )

static

Definition at line 385 of file uia_event.c.

{
    struct uia_proxy_win_event_sink *sink = impl_from_IProxyProviderWinEventSink(iface);
    ULONG ref = InterlockedIncrement(&sink->ref);
 
    TRACE("%p, refcount %ld\n", sink, ref);
 
    return ref;
}

uia_proxy_win_event_sink_AddStructureChangedEvent()

static HRESULT WINAPI uia_proxy_win_event_sink_AddStructureChangedEvent ( IProxyProviderWinEventSink *  iface, IRawElementProviderSimple *  elprov, enum StructureChangeType  structure_change_type, SAFEARRAY *  runtime_id  )

static

Definition at line 441 of file uia_event.c.

{
    FIXME("%p, %p, %d, %p: stub\n", iface, elprov, structure_change_type, runtime_id);
    return E_NOTIMPL;
}

uia_proxy_win_event_sink_QueryInterface()

static HRESULT WINAPI uia_proxy_win_event_sink_QueryInterface ( IProxyProviderWinEventSink *  iface, REFIID  riid, void **  obj  )

static

Definition at line 369 of file uia_event.c.

{
    struct uia_proxy_win_event_sink *sink = impl_from_IProxyProviderWinEventSink(iface);
 
    *obj = NULL;
    if (IsEqualIID(riid, &IID_IProxyProviderWinEventSink) || IsEqualIID(riid, &IID_IUnknown))
        *obj = iface;
    else if (IsEqualIID(riid, &IID_IMarshal))
        return IUnknown_QueryInterface(sink->marshal, riid, obj);
    else
        return E_NOINTERFACE;
 
    IProxyProviderWinEventSink_AddRef(iface);
    return S_OK;
}

uia_proxy_win_event_sink_Release()

static ULONG WINAPI uia_proxy_win_event_sink_Release ( IProxyProviderWinEventSink *  iface )

static

Definition at line 395 of file uia_event.c.

{
    struct uia_proxy_win_event_sink *sink = impl_from_IProxyProviderWinEventSink(iface);
    ULONG ref = InterlockedDecrement(&sink->ref);
 
    TRACE("%p, refcount %ld\n", sink, ref);
 
    if (!ref)
    {
        assert(list_empty(&sink->sink_events));
        IUnknown_Release(sink->marshal);
        free(sink);
    }
 
    return ref;
}

uia_raise_clientside_event()

static HRESULT uia_raise_clientside_event ( struct uia_queue_uia_event *  event )

static

Definition at line 590 of file uia_event.c.

{
    HUIANODE node, nav_start_node;
    HRESULT hr;
 
    node = nav_start_node = NULL;
    hr = uia_node_from_lresult(event->u.clientside.node, &node, 0);
    if (FAILED(hr))
    {
        WARN("Failed to create node from lresult, hr %#lx\n", hr);
        uia_node_lresult_release(event->u.clientside.nav_start_node);
        return hr;
    }
 
    if (event->u.clientside.nav_start_node)
    {
        hr = uia_node_from_lresult(event->u.clientside.nav_start_node, &nav_start_node, 0);
        if (FAILED(hr))
        {
            WARN("Failed to create nav_start_node from lresult, hr %#lx\n", hr);
            UiaNodeRelease(node);
            return hr;
        }
    }
 
    hr = uia_event_invoke(node, nav_start_node, event->args, event->event);
    UiaNodeRelease(node);
    UiaNodeRelease(nav_start_node);
 
    return hr;
}

Referenced by uia_event_thread_process_queue().

uia_raise_elprov_event()

static HRESULT uia_raise_elprov_event ( IRawElementProviderSimple *  elprov, struct uia_event_args *  args  )

static

Definition at line 1928 of file uia_event.c.

{
    struct uia_elprov_event_data event_data = { elprov, args };
    enum ProviderOptions prov_opts = 0;
    HRESULT hr;
 
    hr = IRawElementProviderSimple_get_ProviderOptions(elprov, &prov_opts);
    if (FAILED(hr))
        return hr;
 
    event_data.clientside_only = !(prov_opts & ProviderOptions_ServerSideProvider);
    hr = uia_event_for_each(args->simple_args.EventId, uia_raise_elprov_event_callback, (void *)&event_data,
            event_data.clientside_only);
    if (FAILED(hr))
        WARN("uia_event_for_each failed with hr %#lx\n", hr);
 
    UiaNodeRelease(event_data.node);
    SafeArrayDestroy(event_data.rt_id);
 
    return hr;
}

Referenced by UiaRaiseAutomationEvent().

uia_raise_elprov_event_callback()

static HRESULT uia_raise_elprov_event_callback ( struct uia_event *  event, void *  data  )

static

Definition at line 1899 of file uia_event.c.

{
    struct uia_elprov_event_data *event_data = (struct uia_elprov_event_data *)data;
    HUIANODE nav_node = NULL;
    HRESULT hr = S_OK;
 
    if (!event_data->node)
    {
        /*
         * For events raised on server-side providers, we don't want to add any
         * clientside HWND providers.
         */
        hr = create_uia_node_from_elprov(event_data->elprov, &event_data->node, event_data->clientside_only, 0);
        if (FAILED(hr))
            return hr;
 
        hr = UiaGetRuntimeId(event_data->node, &event_data->rt_id);
        if (FAILED(hr))
            return hr;
    }
 
    hr = uia_event_check_node_within_event_scope(event, event_data->node, event_data->rt_id, &nav_node);
    if (hr == S_OK)
        hr = uia_event_invoke(event_data->node, nav_node, event_data->args, event);
 
    UiaNodeRelease(nav_node);
    return hr;
}

Referenced by uia_raise_elprov_event(), and uia_win_event_for_each_callback().

uia_raise_serverside_event()

static HRESULT uia_raise_serverside_event ( struct uia_queue_uia_event *  event )

static

Definition at line 622 of file uia_event.c.

{
    HRESULT hr = S_OK;
    LRESULT lr, lr2;
    VARIANT v, v2;
 
    /*
     * uia_lresult_from_node is expected to release the node here upon
     * failure.
     */
    lr = lr2 = 0;
    if (!(lr = uia_lresult_from_node(event->u.serverside.node)))
    {
        UiaNodeRelease(event->u.serverside.nav_start_node);
        return E_FAIL;
    }
 
    if (event->u.serverside.nav_start_node && !(lr2 = uia_lresult_from_node(event->u.serverside.nav_start_node)))
    {
        uia_node_lresult_release(lr);
        return E_FAIL;
    }
 
    VariantInit(&v2);
    variant_init_i4(&v, lr);
    if (lr2)
        variant_init_i4(&v2, lr2);
 
    hr = IWineUiaEvent_raise_event(event->event->u.serverside.event_iface, v, v2);
    if (FAILED(hr))
    {
        uia_node_lresult_release(lr);
        uia_node_lresult_release(lr2);
    }
 
    return hr;
}

Referenced by uia_event_thread_process_queue().

uia_serverside_event_adviser_AddRef()

static ULONG WINAPI uia_serverside_event_adviser_AddRef ( IWineUiaEventAdviser *  iface )

static

Definition at line 1457 of file uia_event.c.

{
    struct uia_serverside_event_adviser *adv_events = impl_from_serverside_IWineUiaEventAdviser(iface);
    ULONG ref = InterlockedIncrement(&adv_events->ref);
 
    TRACE("%p, refcount %ld\n", adv_events, ref);
    return ref;
}

uia_serverside_event_adviser_advise()

static HRESULT WINAPI uia_serverside_event_adviser_advise ( IWineUiaEventAdviser *  iface, BOOL  advise_added, LONG_PTR  huiaevent  )

static

Definition at line 1480 of file uia_event.c.

{
    struct uia_serverside_event_adviser *adv_events = impl_from_serverside_IWineUiaEventAdviser(iface);
    struct uia_event *event_data = (struct uia_event *)huiaevent;
    HRESULT hr;
 
    TRACE("%p, %d, %#Ix\n", adv_events, advise_added, huiaevent);
 
    if (advise_added)
    {
        const struct uia_event_info *event_info = uia_event_info_from_id(event_data->event_id);
        VARIANT v;
 
        VariantInit(&v);
        if (event_data->runtime_id)
        {
            V_VT(&v) = VT_I4 | VT_ARRAY;
            V_ARRAY(&v) = event_data->runtime_id;
        }
 
        hr = IWineUiaEvent_set_event_data(adv_events->event_iface, event_info->guid, event_data->scope, v,
                &event_data->IWineUiaEvent_iface);
        if (FAILED(hr))
        {
            WARN("Failed to set event data on serverside event, hr %#lx\n", hr);
            return hr;
        }
    }
 
    return IWineUiaEvent_advise_events(adv_events->event_iface, advise_added, 0);
}

uia_serverside_event_adviser_QueryInterface()

static HRESULT WINAPI uia_serverside_event_adviser_QueryInterface ( IWineUiaEventAdviser *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 1445 of file uia_event.c.

{
    *ppv = NULL;
    if (IsEqualIID(riid, &IID_IWineUiaEventAdviser) || IsEqualIID(riid, &IID_IUnknown))
        *ppv = iface;
    else
        return E_NOINTERFACE;
 
    IWineUiaEventAdviser_AddRef(iface);
    return S_OK;
}

uia_serverside_event_adviser_Release()

static ULONG WINAPI uia_serverside_event_adviser_Release ( IWineUiaEventAdviser *  iface )

static

Definition at line 1466 of file uia_event.c.

{
    struct uia_serverside_event_adviser *adv_events = impl_from_serverside_IWineUiaEventAdviser(iface);
    ULONG ref = InterlockedDecrement(&adv_events->ref);
 
    TRACE("%p, refcount %ld\n", adv_events, ref);
    if (!ref)
    {
        IWineUiaEvent_Release(adv_events->event_iface);
        free(adv_events);
    }
    return ref;
}

uia_serverside_event_id_compare()

static int uia_serverside_event_id_compare ( const void *  key, const struct rb_entry *  entry  )

static

Definition at line 131 of file uia_event.c.

{
    struct uia_event *event = RB_ENTRY_VALUE(entry, struct uia_event, u.serverside.serverside_event_entry);
    struct uia_event_identifier *event_id = (struct uia_event_identifier *)key;
 
    if (event_id->proc_id != event->u.serverside.proc_id)
        return (event_id->proc_id > event->u.serverside.proc_id) - (event_id->proc_id < event->u.serverside.proc_id);
    else
        return (event_id->event_cookie > event->event_cookie) - (event_id->event_cookie < event->event_cookie);
}

Referenced by create_serverside_uia_event().

uia_start_event_thread()

static BOOL uia_start_event_thread ( void  )

static

Definition at line 932 of file uia_event.c.

{
    BOOL started = TRUE;
 
    EnterCriticalSection(&event_thread_cs);
    if (++event_thread.ref == 1)
    {
        HANDLE ready_event = NULL;
        HANDLE events[2];
        HMODULE hmodule;
        DWORD wait_obj;
 
        /* Increment DLL reference count. */
        GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
                (const WCHAR *)uia_start_event_thread, &hmodule);
 
        events[0] = ready_event = CreateEventW(NULL, FALSE, FALSE, NULL);
        if (!(event_thread.hthread = CreateThread(NULL, 0, uia_event_thread_proc,
                ready_event, 0, NULL)))
        {
            FreeLibrary(hmodule);
            started = FALSE;
            goto exit;
        }
 
        events[1] = event_thread.hthread;
        wait_obj = WaitForMultipleObjects(2, events, FALSE, INFINITE);
        if (wait_obj != WAIT_OBJECT_0)
        {
            CloseHandle(event_thread.hthread);
            started = FALSE;
        }
 
exit:
        if (ready_event)
            CloseHandle(ready_event);
        if (!started)
            memset(&event_thread, 0, sizeof(event_thread));
    }
 
    LeaveCriticalSection(&event_thread_cs);
    return started;
}

Referenced by create_serverside_uia_event(), uia_clientside_event_start_event_thread(), and uia_start_event_thread().

uia_stop_event_thread()

static void uia_stop_event_thread ( void  )

static

Definition at line 976 of file uia_event.c.

{
    EnterCriticalSection(&event_thread_cs);
    if (!--event_thread.ref)
    {
        PostMessageW(event_thread.hwnd, WM_UIA_EVENT_THREAD_STOP, 0, 0);
        CloseHandle(event_thread.hthread);
        memset(&event_thread, 0, sizeof(event_thread));
    }
    LeaveCriticalSection(&event_thread_cs);
}

Referenced by uia_event_Release().

uia_win_event_enum_top_level_hwnds()

static BOOL CALLBACK uia_win_event_enum_top_level_hwnds ( HWND  hwnd, LPARAM  lparam  )

static

Definition at line 68 of file uia_event.c.

{
    struct rb_tree *hwnd_map = (struct rb_tree *)lparam;
    HRESULT hr;
 
    if (!uia_hwnd_is_visible(hwnd))
        return TRUE;
 
    hr = uia_hwnd_map_add_hwnd(hwnd_map, hwnd);
    if (FAILED(hr))
        WARN("Failed to add hwnd to map, hr %#lx\n", hr);
 
    return TRUE;
}

Referenced by uia_event_add_win_event_hwnd().

uia_win_event_for_each_callback()

static HRESULT uia_win_event_for_each_callback ( struct uia_event *  event, void *  data  )

static

Definition at line 733 of file uia_event.c.

{
    struct uia_queue_win_event *win_event = (struct uia_queue_win_event *)data;
    struct event_sink_event *sink_event, *sink_event2;
    struct uia_proxy_win_event_sink *sink;
    IRawElementProviderSimple *elprov;
    struct uia_node *node_data;
    HUIANODE node;
    HRESULT hr;
    int i;
 
    /*
     * Check if this HWND, or any of it's ancestors (excluding the desktop)
     * are in our scope.
     */
    if (!uia_hwnd_map_check_hwnd(&event->u.clientside.win_event_hwnd_map, win_event->hwnd) &&
            !uia_win_event_hwnd_map_contains_ancestors(&event->u.clientside.win_event_hwnd_map, win_event->hwnd))
        return S_OK;
 
    /* Has a native serverside provider, no need to do WinEvent translation. */
    if (UiaHasServerSideProvider(win_event->hwnd))
        return S_OK;
 
    /*
     * Regardless of the object ID of the WinEvent, OBJID_CLIENT is queried
     * for the HWND with the same child ID as the WinEvent.
     */
    hr = create_msaa_provider_from_hwnd(win_event->hwnd, win_event->child_id, &elprov);
    if (FAILED(hr))
        return hr;
 
    hr = create_uia_node_from_elprov(elprov, &node, TRUE, NODE_FLAG_IGNORE_COM_THREADING);
    IRawElementProviderSimple_Release(elprov);
    if (FAILED(hr))
        return hr;
 
    hr = create_proxy_win_event_sink(&sink, event->event_id);
    if (SUCCEEDED(hr))
    {
        node_data = impl_from_IWineUiaNode((IWineUiaNode *)node);
        for (i = 0; i < node_data->prov_count; i++)
        {
            hr = respond_to_win_event_on_node_provider((IWineUiaNode *)node, i, win_event->event_id, win_event->hwnd, win_event->obj_id,
                    win_event->child_id, &sink->IProxyProviderWinEventSink_iface);
            if (FAILED(hr) || !list_empty(&sink->sink_events))
                break;
        }
 
        InterlockedIncrement(&sink->sink_defunct);
        LIST_FOR_EACH_ENTRY_SAFE(sink_event, sink_event2, &sink->sink_events, struct event_sink_event, event_sink_list_entry)
        {
            struct uia_elprov_event_data event_data = { sink_event->elprov, sink_event->args, TRUE };
            list_remove(&sink_event->event_sink_list_entry);
 
            hr = uia_raise_elprov_event_callback(event, (void *)&event_data);
            if (FAILED(hr))
                WARN("uia_raise_elprov_event_callback failed with hr %#lx\n", hr);
 
            UiaNodeRelease(event_data.node);
            SafeArrayDestroy(event_data.rt_id);
 
            IRawElementProviderSimple_Release(sink_event->elprov);
            uia_event_args_release(sink_event->args);
            free(sink_event);
        }
 
        IProxyProviderWinEventSink_Release(&sink->IProxyProviderWinEventSink_iface);
    }
 
    UiaNodeRelease(node);
    return hr;
}

Referenced by uia_event_thread_process_queue().

uia_win_event_hwnd_map_contains_ancestors()

static BOOL uia_win_event_hwnd_map_contains_ancestors ( struct rb_tree *  hwnd_map, HWND  hwnd  )

static

Definition at line 661 of file uia_event.c.

{
    HWND parent = GetAncestor(hwnd, GA_PARENT);
    const HWND desktop = GetDesktopWindow();
 
    while (parent && (parent != desktop))
    {
        if (uia_hwnd_map_check_hwnd(hwnd_map, parent))
            return TRUE;
 
        parent = GetAncestor(parent, GA_PARENT);
    }
 
    return FALSE;
}

Referenced by uia_win_event_for_each_callback().

UiaAddEvent()

HRESULT WINAPI UiaAddEvent	(	HUIANODE	huianode,
		EVENTID	event_id,
		UiaEventCallback *	callback,
		enum TreeScope	scope,
		PROPERTYID *	prop_ids,
		int	prop_ids_count,
		struct UiaCacheRequest *	cache_req,
		HUIAEVENT *	huiaevent
	)

Definition at line 1675 of file uia_event.c.

{
    const struct uia_event_info *event_info = uia_event_info_from_id(event_id);
    SAFEARRAY *sa;
    HRESULT hr;
 
    TRACE("(%p, %d, %p, %#x, %p, %d, %p, %p)\n", huianode, event_id, callback, scope, prop_ids, prop_ids_count,
            cache_req, huiaevent);
 
    if (!huianode || !callback || !cache_req || !huiaevent)
        return E_INVALIDARG;
 
    if (!event_info)
        WARN("No event information for event ID %d\n", event_id);
 
    *huiaevent = NULL;
    if (event_info && (event_info->event_arg_type == EventArgsType_PropertyChanged))
    {
        FIXME("Property changed event registration currently unimplemented\n");
        return E_NOTIMPL;
    }
 
    hr = UiaGetRuntimeId(huianode, &sa);
    if (FAILED(hr))
        return hr;
 
    hr = uia_add_clientside_event(huianode, event_id, scope, prop_ids, prop_ids_count, cache_req, sa,
            uia_clientside_event_callback, (void *)callback, huiaevent);
    SafeArrayDestroy(sa);
 
    return hr;
}

Referenced by test_uia_com_focus_change_event_handler_win_event_handling(), test_UiaAddEvent(), test_UiaAddEvent_args(), test_UiaAddEvent_client_proc(), and uia_proxy_provider_win_event_handler_test_thread().

UiaEventAddWindow()

HRESULT WINAPI UiaEventAddWindow	(	HUIAEVENT	huiaevent,
		HWND	hwnd
	)

Definition at line 1595 of file uia_event.c.

{
    struct uia_event *event = unsafe_impl_from_IWineUiaEvent((IWineUiaEvent *)huiaevent);
    HUIANODE node;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", huiaevent, hwnd);
 
    if (!event)
        return E_INVALIDARG;
 
    assert(event->event_type == EVENT_TYPE_CLIENTSIDE);
 
    hr = UiaNodeFromHandle(hwnd, &node);
    if (FAILED(hr))
        return hr;
 
    hr = uia_event_advise_node(event, node);
    UiaNodeRelease(node);
 
    return hr;
}

Referenced by test_UiaAddEvent_client_proc(), and uia_proxy_provider_win_event_handler_test_thread().

UiaRaiseAutomationEvent()

HRESULT WINAPI UiaRaiseAutomationEvent	(	IRawElementProviderSimple *	elprov,
		EVENTID	id
	)

Definition at line 1953 of file uia_event.c.

{
    const struct uia_event_info *event_info = uia_event_info_from_id(id);
    struct uia_event_args *args;
    HRESULT hr;
 
    TRACE("(%p, %d)\n", elprov, id);
 
    if (!elprov)
        return E_INVALIDARG;
 
    if (!event_info || event_info->event_arg_type != EventArgsType_Simple)
    {
        if (!event_info)
            FIXME("No event info structure for event id %d\n", id);
        else
            WARN("Wrong event raising function for event args type %d\n", event_info->event_arg_type);
 
        return S_OK;
    }
 
    args = create_uia_event_args(event_info);
    if (!args)
        return E_OUTOFMEMORY;
 
    hr = uia_raise_elprov_event(elprov, args);
    uia_event_args_release(args);
    if (FAILED(hr))
        return hr;
 
    return S_OK;
}

Referenced by test_IUIAutomationEventHandler(), test_IUIAutomationFocusChangedEventHandler(), test_UiaAddEvent(), test_UiaRaiseAutomationEvent_args(), and uia_com_event_handler_test_thread().

UiaRemoveEvent()

HRESULT WINAPI UiaRemoveEvent

(

HUIAEVENT

huiaevent

)

Definition at line 1712 of file uia_event.c.

{
    struct uia_event *event = unsafe_impl_from_IWineUiaEvent((IWineUiaEvent *)huiaevent);
    HRESULT hr;
 
    TRACE("(%p)\n", event);
 
    if (!event)
        return E_INVALIDARG;
 
    assert(event->event_type == EVENT_TYPE_CLIENTSIDE);
    hr = uia_event_advise(event, FALSE, 0);
    if (FAILED(hr))
        return hr;
 
    if (event->u.clientside.git_cookie)
    {
        hr = unregister_interface_in_git(event->u.clientside.git_cookie);
        if (FAILED(hr))
            return hr;
    }
 
    IWineUiaEvent_Release(&event->IWineUiaEvent_iface);
    return S_OK;
}

Referenced by test_uia_com_focus_change_event_handler_win_event_handling(), test_UiaAddEvent(), test_UiaAddEvent_args(), test_UiaAddEvent_client_proc(), test_UiaRemoveEvent_args(), uia_add_event_test_thread(), uia_event_handler_destroy(), and uia_proxy_provider_win_event_handler_test_thread().

unsafe_impl_from_IWineUiaEvent()

static struct uia_event * unsafe_impl_from_IWineUiaEvent ( IWineUiaEvent *  iface )

static

Definition at line 1186 of file uia_event.c.

{
    if (!iface || (iface->lpVtbl != &uia_event_vtbl))
        return NULL;
 
    return CONTAINING_RECORD(iface, struct uia_event, IWineUiaEvent_iface);
}

Referenced by UiaEventAddWindow(), and UiaRemoveEvent().

win_event_to_uia_event_id()

static int win_event_to_uia_event_id ( int  win_event )

static

Definition at line 52 of file uia_event.c.

{
    switch (win_event)
    {
    case EVENT_OBJECT_FOCUS: return UIA_AutomationFocusChangedEventId;
    case EVENT_SYSTEM_ALERT: return UIA_SystemAlertEventId;
    case EVENT_OBJECT_SHOW:  return UIA_StructureChangedEventId;
    case EVENT_OBJECT_DESTROY: return UIA_StructureChangedEventId;
 
    default:
        break;
    }
 
    return 0;
}

Referenced by uia_event_thread_process_queue(), and uia_event_thread_win_event_proc().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

uiautomation

)

Variable Documentation

event_map_cs

static CRITICAL_SECTION event_map_cs = { &event_map_cs_debug, -1, 0, 0, 0, 0 }

static

Definition at line 142 of file uia_event.c.

Referenced by create_serverside_uia_event(), uia_event_for_each(), uia_event_map_add_event(), uia_event_map_entry_release(), and uia_event_Release().

event_map_cs_debug

CRITICAL_SECTION_DEBUG event_map_cs_debug

static

Initial value:

=
{
    0, 0, &event_map_cs,
    { &event_map_cs_debug.ProcessLocksList, &event_map_cs_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": event_map_cs") }
}

Definition at line 143 of file uia_event.c.

event_thread

struct uia_event_thread event_thread

static

Definition at line 497 of file uia_event.c.

Referenced by uia_event_queue_push(), uia_event_thread_proc(), uia_start_event_thread(), and uia_stop_event_thread().

event_thread_cs

static CRITICAL_SECTION event_thread_cs = { &event_thread_cs_debug, -1, 0, 0, 0, 0 }

static

Definition at line 498 of file uia_event.c.

Referenced by uia_event_queue_pop(), uia_event_queue_push(), uia_start_event_thread(), and uia_stop_event_thread().

event_thread_cs_debug

CRITICAL_SECTION_DEBUG event_thread_cs_debug

static

Initial value:

=
{
    0, 0, &event_thread_cs,
    { &event_thread_cs_debug.ProcessLocksList, &event_thread_cs_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": event_thread_cs") }
}

Definition at line 499 of file uia_event.c.

uia_desktop_node_rt_id

SAFEARRAY* uia_desktop_node_rt_id

static

Definition at line 26 of file uia_event.c.

Referenced by uia_get_desktop_rt_id(), and uia_init_desktop_rt_id().

uia_event_adviser_vtbl

const IWineUiaEventAdviserVtbl uia_event_adviser_vtbl

static

Initial value:

= {
    uia_event_adviser_QueryInterface,
    uia_event_adviser_AddRef,
    uia_event_adviser_Release,
    uia_event_adviser_advise,
}

Definition at line 1378 of file uia_event.c.

Referenced by uia_event_add_provider_event_adviser().

uia_event_map

struct uia_event_map uia_event_map

static

uia_event_vtbl

const IWineUiaEventVtbl uia_event_vtbl

static

Initial value:

= {
    uia_event_QueryInterface,
    uia_event_AddRef,
    uia_event_Release,
    uia_event_advise_events,
    uia_event_set_event_data,
    uia_event_raise_event,
}

Definition at line 1177 of file uia_event.c.

Referenced by create_uia_event(), and unsafe_impl_from_IWineUiaEvent().

uia_proxy_event_sink_vtbl

const IProxyProviderWinEventSinkVtbl uia_proxy_event_sink_vtbl

static

Initial value:

= {
    uia_proxy_win_event_sink_QueryInterface,
    uia_proxy_win_event_sink_AddRef,
    uia_proxy_win_event_sink_Release,
    uia_proxy_win_event_sink_AddAutomationPropertyChangedEvent,
    uia_proxy_win_event_sink_AddAutomationEvent,
    uia_proxy_win_event_sink_AddStructureChangedEvent,
}

Definition at line 448 of file uia_event.c.

Referenced by create_proxy_win_event_sink().

uia_serverside_event_adviser_vtbl

const IWineUiaEventAdviserVtbl uia_serverside_event_adviser_vtbl

static

Initial value:

= {
    uia_serverside_event_adviser_QueryInterface,
    uia_serverside_event_adviser_AddRef,
    uia_serverside_event_adviser_Release,
    uia_serverside_event_adviser_advise,
}

Definition at line 1512 of file uia_event.c.

Referenced by uia_event_add_serverside_event_adviser().