htmlevent.h File Reference

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

Go to the source code of this file.

Typedefs
typedef struct HTMLEventObj	HTMLEventObj

Enumerations
enum	eventid_t {   EVENTID_ABORT , EVENTID_BEFOREUNLOAD , EVENTID_BLUR , EVENTID_CHANGE ,   EVENTID_CLICK , EVENTID_CONTEXTMENU , EVENTID_DATAAVAILABLE , EVENTID_DBLCLICK ,   EVENTID_DRAG , EVENTID_DRAGSTART , EVENTID_ERROR , EVENTID_FOCUS ,   EVENTID_FOCUSIN , EVENTID_HELP , EVENTID_KEYDOWN , EVENTID_KEYPRESS ,   EVENTID_KEYUP , EVENTID_LOAD , EVENTID_MOUSEDOWN , EVENTID_MOUSEMOVE ,   EVENTID_MOUSEOUT , EVENTID_MOUSEOVER , EVENTID_MOUSEUP , EVENTID_MOUSEWHEEL ,   EVENTID_PASTE , EVENTID_READYSTATECHANGE , EVENTID_RESIZE , EVENTID_SCROLL ,   EVENTID_SELECTSTART , EVENTID_SUBMIT , EVENTID_LAST }

Functions
eventid_t	str_to_eid (LPCWSTR) DECLSPEC_HIDDEN
void	check_event_attr (HTMLDocumentNode *, nsIDOMHTMLElement *) DECLSPEC_HIDDEN
void	release_event_target (event_target_t *) DECLSPEC_HIDDEN
void	fire_event (HTMLDocumentNode *, eventid_t, BOOL, nsIDOMNode *, nsIDOMEvent *, IDispatch *) DECLSPEC_HIDDEN
HRESULT	set_event_handler (EventTarget *, eventid_t, VARIANT *) DECLSPEC_HIDDEN
HRESULT	get_event_handler (EventTarget *, eventid_t, VARIANT *) DECLSPEC_HIDDEN
HRESULT	attach_event (EventTarget *, BSTR, IDispatch *, VARIANT_BOOL *) DECLSPEC_HIDDEN
HRESULT	detach_event (EventTarget *, BSTR, IDispatch *) DECLSPEC_HIDDEN
HRESULT	dispatch_event (HTMLDOMNode *, const WCHAR *, VARIANT *, VARIANT_BOOL *) DECLSPEC_HIDDEN
HRESULT	call_fire_event (HTMLDOMNode *, eventid_t) DECLSPEC_HIDDEN
void	update_doc_cp_events (HTMLDocumentNode *, cp_static_data_t *) DECLSPEC_HIDDEN
HRESULT	doc_init_events (HTMLDocumentNode *) DECLSPEC_HIDDEN
void	detach_events (HTMLDocumentNode *doc) DECLSPEC_HIDDEN
HRESULT	create_event_obj (IHTMLEventObj **) DECLSPEC_HIDDEN
void	bind_target_event (HTMLDocumentNode *, EventTarget *, const WCHAR *, IDispatch *) DECLSPEC_HIDDEN
HRESULT	ensure_doc_nsevent_handler (HTMLDocumentNode *, eventid_t) DECLSPEC_HIDDEN
void	call_event_handlers (HTMLDocumentNode *, HTMLEventObj *, EventTarget *, ConnectionPointContainer *, eventid_t, IDispatch *)
void	init_nsevents (HTMLDocumentNode *) DECLSPEC_HIDDEN
void	release_nsevents (HTMLDocumentNode *) DECLSPEC_HIDDEN
void	add_nsevent_listener (HTMLDocumentNode *, nsIDOMNode *, LPCWSTR) DECLSPEC_HIDDEN
void	detach_nsevent (HTMLDocumentNode *, const WCHAR *) DECLSPEC_HIDDEN
static HRESULT	set_node_event (HTMLDOMNode *node, eventid_t eid, VARIANT *var)
static HRESULT	get_node_event (HTMLDOMNode *node, eventid_t eid, VARIANT *var)
static HRESULT	set_doc_event (HTMLDocument *doc, eventid_t eid, VARIANT *var)
static HRESULT	get_doc_event (HTMLDocument *doc, eventid_t eid, VARIANT *var)

Typedef Documentation

HTMLEventObj

typedef struct HTMLEventObj HTMLEventObj

Definition at line 72 of file htmlevent.h.

Enumeration Type Documentation

eventid_t

enum eventid_t

Enumerator
EVENTID_ABORT
EVENTID_BEFOREUNLOAD
EVENTID_BLUR
EVENTID_CHANGE
EVENTID_CLICK
EVENTID_CONTEXTMENU
EVENTID_DATAAVAILABLE
EVENTID_DBLCLICK
EVENTID_DRAG
EVENTID_DRAGSTART
EVENTID_ERROR
EVENTID_FOCUS
EVENTID_FOCUSIN
EVENTID_HELP
EVENTID_KEYDOWN
EVENTID_KEYPRESS
EVENTID_KEYUP
EVENTID_LOAD
EVENTID_MOUSEDOWN
EVENTID_MOUSEMOVE
EVENTID_MOUSEOUT
EVENTID_MOUSEOVER
EVENTID_MOUSEUP
EVENTID_MOUSEWHEEL
EVENTID_PASTE
EVENTID_READYSTATECHANGE
EVENTID_RESIZE
EVENTID_SCROLL
EVENTID_SELECTSTART
EVENTID_SUBMIT
EVENTID_LAST

Definition at line 21 of file htmlevent.h.

             {
    EVENTID_ABORT,
    EVENTID_BEFOREUNLOAD,
    EVENTID_BLUR,
    EVENTID_CHANGE,
    EVENTID_CLICK,
    EVENTID_CONTEXTMENU,
    EVENTID_DATAAVAILABLE,
    EVENTID_DBLCLICK,
    EVENTID_DRAG,
    EVENTID_DRAGSTART,
    EVENTID_ERROR,
    EVENTID_FOCUS,
    EVENTID_FOCUSIN,
    EVENTID_HELP,
    EVENTID_KEYDOWN,
    EVENTID_KEYPRESS,
    EVENTID_KEYUP,
    EVENTID_LOAD,
    EVENTID_MOUSEDOWN,
    EVENTID_MOUSEMOVE,
    EVENTID_MOUSEOUT,
    EVENTID_MOUSEOVER,
    EVENTID_MOUSEUP,
    EVENTID_MOUSEWHEEL,
    EVENTID_PASTE,
    EVENTID_READYSTATECHANGE,
    EVENTID_RESIZE,
    EVENTID_SCROLL,
    EVENTID_SELECTSTART,
    EVENTID_SUBMIT,
    EVENTID_LAST
} eventid_t;

Function Documentation

add_nsevent_listener()

void add_nsevent_listener	(	HTMLDocumentNode *	doc,
		nsIDOMNode *	nsnode,
		LPCWSTR	type
	)

Definition at line 346 of file nsevents.c.

{
    nsIDOMEventTarget *target;
    nsresult nsres;
 
    if(nsnode)
        nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMEventTarget, (void**)&target);
    else
        nsres = nsIDOMWindow_QueryInterface(doc->basedoc.window->nswindow, &IID_nsIDOMEventTarget, (void**)&target);
    if(NS_FAILED(nsres)) {
        ERR("Could not get nsIDOMEventTarget interface: %08x\n", nsres);
        return;
    }
 
    init_event(target, type, &doc->nsevent_listener->htmlevent_listener.nsIDOMEventListener_iface,
            TRUE);
    nsIDOMEventTarget_Release(target);
}

Referenced by ensure_doc_nsevent_handler().

attach_event()

HRESULT attach_event	(	EventTarget *	event_target,
		BSTR	name,
		IDispatch *	disp,
		VARIANT_BOOL *	res
	)

Definition at line 1469 of file htmlevent.c.

{
    event_target_t *data;
    eventid_t eid;
    DWORD i = 0;
 
    eid = attr_to_eid(name);
    if(eid == EVENTID_LAST) {
        WARN("Unknown event\n");
        *res = VARIANT_TRUE;
        return S_OK;
    }
 
    data = get_event_target_data(event_target, TRUE);
    if(!data)
        return E_OUTOFMEMORY;
 
    if(data->event_table[eid]) {
        while(i < data->event_table[eid]->handler_cnt && data->event_table[eid]->handlers[i])
            i++;
        if(i == data->event_table[eid]->handler_cnt && !alloc_handler_vector(data, eid, i+1))
            return E_OUTOFMEMORY;
    }else if(!alloc_handler_vector(data, eid, i+1)) {
        return E_OUTOFMEMORY;
    }
 
    IDispatch_AddRef(disp);
    data->event_table[eid]->handlers[i] = disp;
 
    bind_event(event_target, eid);
 
    *res = VARIANT_TRUE;
    return S_OK;
}

Referenced by HTMLDocument3_attachEvent(), HTMLElement2_attachEvent(), and HTMLWindow3_attachEvent().

bind_target_event()

void bind_target_event	(	HTMLDocumentNode *	doc,
		EventTarget *	event_target,
		const WCHAR *	event,
		IDispatch *	disp
	)

Definition at line 1534 of file htmlevent.c.

{
    eventid_t eid;
 
    TRACE("(%p %p %s %p)\n", doc, event_target, debugstr_w(event), disp);
 
    eid = attr_to_eid(event);
    if(eid == EVENTID_LAST) {
        WARN("Unsupported event %s\n", debugstr_w(event));
        return;
    }
 
    set_event_handler_disp(event_target, eid, disp);
}

Referenced by bind_event_scripts().

call_event_handlers()

void call_event_handlers	(	HTMLDocumentNode *	doc,
		HTMLEventObj *	event_obj,
		EventTarget *	event_target,
		ConnectionPointContainer *	cp_container,
		eventid_t	eid,
		IDispatch *	this_obj
	)

Definition at line 952 of file htmlevent.c.

{
    event_target_t *data = get_event_target_data(event_target, FALSE);
    const BOOL cancelable = event_info[eid].flags & EVENT_CANCELABLE;
    VARIANT v;
    HRESULT hres;
 
    if(data && data->event_table[eid] && data->event_table[eid]->handler_prop) {
        DISPID named_arg = DISPID_THIS;
        VARIANTARG arg;
        DISPPARAMS dp = {&arg, &named_arg, 1, 1};
 
        V_VT(&arg) = VT_DISPATCH;
        V_DISPATCH(&arg) = this_obj;
        V_VT(&v) = VT_EMPTY;
 
        TRACE("%s >>>\n", debugstr_w(event_info[eid].name));
        hres = call_disp_func(data->event_table[eid]->handler_prop, &dp, &v);
        if(hres == S_OK) {
            TRACE("%s <<< %s\n", debugstr_w(event_info[eid].name), debugstr_variant(&v));
 
            if(cancelable) {
                if(V_VT(&v) == VT_BOOL) {
                    if(!V_BOOL(&v))
                        event_obj->prevent_default = TRUE;
                }else if(V_VT(&v) != VT_EMPTY) {
                    FIXME("unhandled result %s\n", debugstr_variant(&v));
                }
            }
            VariantClear(&v);
        }else {
            WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres);
        }
    }
 
    if(data && data->event_table[eid] && data->event_table[eid]->handler_cnt) {
        VARIANTARG arg;
        DISPPARAMS dp = {&arg, NULL, 1, 0};
        int i;
 
        V_VT(&arg) = VT_DISPATCH;
        V_DISPATCH(&arg) = (IDispatch*)event_obj;
 
        i = data->event_table[eid]->handler_cnt;
        while(i--) {
            if(data->event_table[eid]->handlers[i]) {
                V_VT(&v) = VT_EMPTY;
 
                TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
                hres = call_disp_func(data->event_table[eid]->handlers[i], &dp, &v);
                if(hres == S_OK) {
                    TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
 
                    if(cancelable) {
                        if(V_VT(&v) == VT_BOOL) {
                            if(!V_BOOL(&v))
                                event_obj->prevent_default = TRUE;
                        }else if(V_VT(&v) != VT_EMPTY) {
                            FIXME("unhandled result %s\n", debugstr_variant(&v));
                        }
                    }
                    VariantClear(&v);
                }else {
                    WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
                }
            }
        }
    }
 
    /*
     * NOTE: CP events may require doc_obj reference, which we don't own. We make sure that
     * it's safe to call event handler by checking nsevent_listener, which is NULL for
     * detached documents.
     */
    if(cp_container && cp_container->forward_container)
        cp_container = cp_container->forward_container;
    if(cp_container && cp_container->cps && doc->nsevent_listener) {
        ConnectionPoint *cp;
        unsigned i, j;
 
        for(j=0; cp_container->cp_entries[j].riid; j++) {
            cp = cp_container->cps + j;
            if(!cp->sinks_size || !is_cp_event(cp->data, event_info[eid].dispid))
                continue;
 
            for(i=0; doc->nsevent_listener && i < cp->sinks_size; i++) {
                if(!cp->sinks[i].disp)
                    continue;
 
                V_VT(&v) = VT_EMPTY;
 
                TRACE("cp %s [%u] >>>\n", debugstr_w(event_info[eid].name), i);
                hres = call_cp_func(cp->sinks[i].disp, event_info[eid].dispid,
                        cp->data->pass_event_arg ? event_obj : NULL, &v);
                if(hres == S_OK) {
                    TRACE("cp %s [%u] <<<\n", debugstr_w(event_info[eid].name), i);
 
                    if(cancelable) {
                        if(V_VT(&v) == VT_BOOL) {
                            if(!V_BOOL(&v))
                                event_obj->prevent_default = TRUE;
                        }else if(V_VT(&v) != VT_EMPTY) {
                            FIXME("unhandled result %s\n", debugstr_variant(&v));
                        }
                    }
                    VariantClear(&v);
                }else {
                    WARN("cp %s [%u] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
                }
            }
 
            if(!doc->nsevent_listener)
                break;
        }
    }
}

Referenced by fire_event_obj(), and XMLHttpReqEventListener_HandleEvent().

call_fire_event()

HRESULT call_fire_event	(	HTMLDOMNode *	node,
		eventid_t	eid
	)

Definition at line 1282 of file htmlevent.c.

{
    HRESULT hres;
 
    if(node->vtbl->fire_event) {
        BOOL handled = FALSE;
 
        hres = node->vtbl->fire_event(node, eid, &handled);
        if(handled)
            return hres;
    }
 
    fire_event(node->doc, eid, TRUE, node->nsnode, NULL, NULL);
    return S_OK;
}

Referenced by HTMLElement_click().

check_event_attr()

void check_event_attr	(	HTMLDocumentNode *	doc,
		nsIDOMHTMLElement *	nselem
	)

Definition at line 1559 of file htmlevent.c.

{
    const PRUnichar *attr_value;
    nsAString attr_value_str;
    IDispatch *disp;
    HTMLDOMNode *node;
    int i;
    nsresult nsres;
    HRESULT hres;
 
    for(i=0; i < EVENTID_LAST; i++) {
        nsres = get_elem_attr_value(nselem, event_info[i].attr_name, &attr_value_str, &attr_value);
        if(NS_SUCCEEDED(nsres)) {
            if(!*attr_value)
                continue;
 
            TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value));
 
            disp = script_parse_event(doc->window, attr_value);
            if(disp) {
                hres = get_node(doc, (nsIDOMNode*)nselem, TRUE, &node);
                if(SUCCEEDED(hres)) {
                    set_event_handler_disp(&node->event_target, i, disp);
                    node_release(node);
                }
                IDispatch_Release(disp);
            }
            nsAString_Finish(&attr_value_str);
        }
    }
}

Referenced by nsDocumentObserver_BindToDocument().

create_event_obj()

HRESULT create_event_obj

(

IHTMLEventObj **

ret

)

Definition at line 858 of file htmlevent.c.

{
    HTMLEventObj *event;
 
    event = create_event();
    if(!event)
        return E_OUTOFMEMORY;
 
    *ret = &event->IHTMLEventObj_iface;
    return S_OK;
}

Referenced by HTMLDocument4_createEventObject().

detach_event()

HRESULT detach_event	(	EventTarget *	event_target,
		BSTR	name,
		IDispatch *	disp
	)

Definition at line 1504 of file htmlevent.c.

{
    event_target_t *data;
    eventid_t eid;
    DWORD i = 0;
 
    eid = attr_to_eid(name);
    if(eid == EVENTID_LAST) {
        WARN("Unknown event\n");
        return S_OK;
    }
 
    data = get_event_target_data(event_target, FALSE);
    if(!data)
        return S_OK;
 
    if(!data->event_table[eid])
        return S_OK;
 
    while(i < data->event_table[eid]->handler_cnt) {
        if(data->event_table[eid]->handlers[i] == disp) {
            IDispatch_Release(data->event_table[eid]->handlers[i]);
            data->event_table[eid]->handlers[i] = NULL;
        }
        i++;
    }
 
    return S_OK;
}

Referenced by HTMLDocument3_detachEvent(), HTMLElement2_detachEvent(), and HTMLWindow3_detachEvent().

detach_events()

void detach_events

(

HTMLDocumentNode *

doc

)

Definition at line 1341 of file htmlevent.c.

{
    if(doc->event_vector) {
        int i;
 
        for(i=0; i < EVENTID_LAST; i++) {
            if(doc->event_vector[i]) {
                detach_nsevent(doc, event_info[i].name);
                doc->event_vector[i] = FALSE;
            }
        }
    }
 
    release_nsevents(doc);
}

Referenced by detach_inner_window(), and HTMLDocumentNode_destructor().

detach_nsevent()

void detach_nsevent	(	HTMLDocumentNode *	doc,
		const WCHAR *	type
	)

Definition at line 389 of file nsevents.c.

{
    detach_nslistener(doc, type, &doc->nsevent_listener->htmlevent_listener, TRUE);
}

Referenced by detach_events().

dispatch_event()

HRESULT dispatch_event	(	HTMLDOMNode *	node,
		const WCHAR *	event_name,
		VARIANT *	event_var,
		VARIANT_BOOL *	cancelled
	)

Definition at line 1225 of file htmlevent.c.

{
    HTMLEventObj *event_obj = NULL;
    eventid_t eid;
    HRESULT hres;
 
    eid = attr_to_eid(event_name);
    if(eid == EVENTID_LAST) {
        WARN("unknown event %s\n", debugstr_w(event_name));
        return E_INVALIDARG;
    }
 
    if(event_var && V_VT(event_var) != VT_EMPTY && V_VT(event_var) != VT_ERROR) {
        if(V_VT(event_var) != VT_DISPATCH) {
            FIXME("event_var %s not supported\n", debugstr_variant(event_var));
            return E_NOTIMPL;
        }
 
        if(V_DISPATCH(event_var)) {
            IHTMLEventObj *event_iface;
 
            hres = IDispatch_QueryInterface(V_DISPATCH(event_var), &IID_IHTMLEventObj, (void**)&event_iface);
            if(FAILED(hres)) {
                FIXME("No IHTMLEventObj iface\n");
                return hres;
            }
 
            event_obj = unsafe_impl_from_IHTMLEventObj(event_iface);
            if(!event_obj) {
                ERR("Not our IHTMLEventObj?\n");
                IHTMLEventObj_Release(event_iface);
                return E_FAIL;
            }
        }
    }
 
    if(event_obj) {
        hres = set_event_info(event_obj, node, eid, NULL);
        if(SUCCEEDED(hres))
            fire_event_obj(node->doc, eid, event_obj, node->nsnode, NULL);
 
        IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
        if(FAILED(hres))
            return hres;
    }else {
        if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER)) {
            FIXME("not EVENT_DEFAULTEVENTHANDLER\n");
            return E_NOTIMPL;
        }
 
        fire_event(node->doc, eid, TRUE, node->nsnode, NULL, NULL);
    }
 
    *cancelled = VARIANT_TRUE; /* FIXME */
    return S_OK;
}

Referenced by HTMLDocument4_fireEvent(), and HTMLElement3_fireEvent().

doc_init_events()

HRESULT doc_init_events

(

HTMLDocumentNode *

doc

)

Definition at line 1591 of file htmlevent.c.

{
    unsigned i;
    HRESULT hres;
 
    doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
    if(!doc->event_vector)
        return E_OUTOFMEMORY;
 
    init_nsevents(doc);
 
    for(i=0; i < EVENTID_LAST; i++) {
        if(event_info[i].flags & EVENT_HASDEFAULTHANDLERS) {
            hres = ensure_doc_nsevent_handler(doc, i);
            if(FAILED(hres))
                return hres;
        }
    }
 
    return S_OK;
}

Referenced by create_doc_from_nsdoc().

ensure_doc_nsevent_handler()

HRESULT ensure_doc_nsevent_handler	(	HTMLDocumentNode *	doc,
		eventid_t	eid
	)

Definition at line 1319 of file htmlevent.c.

{
    nsIDOMNode *nsnode = NULL;
 
    TRACE("%s\n", debugstr_w(event_info[eid].name));
 
    if(!doc->nsdoc || doc->event_vector[eid] || !(event_info[eid].flags & (EVENT_DEFAULTLISTENER|EVENT_BIND_TO_BODY)))
        return S_OK;
 
    if(event_info[eid].flags & EVENT_BIND_TO_BODY) {
        nsnode = doc->node.nsnode;
        nsIDOMNode_AddRef(nsnode);
    }
 
    doc->event_vector[eid] = TRUE;
    add_nsevent_listener(doc, nsnode, event_info[eid].name);
 
    if(nsnode)
        nsIDOMNode_Release(nsnode);
    return S_OK;
}

Referenced by doc_init_events(), HTMLDocumentNode_bind_event(), and update_doc_cp_events().

fire_event()

void fire_event	(	HTMLDocumentNode *	doc,
		eventid_t	eid,
		BOOL	set_event,
		nsIDOMNode *	target,
		nsIDOMEvent *	nsevent,
		IDispatch *	script_this
	)

Definition at line 1195 of file htmlevent.c.

{
    HTMLEventObj *event_obj = NULL;
    HTMLDOMNode *node;
    HRESULT hres;
 
    if(set_event) {
        hres = get_node(doc, target, TRUE, &node);
        if(FAILED(hres))
            return;
 
        event_obj = create_event();
        node_release(node);
        if(!event_obj)
            return;
 
        hres = set_event_info(event_obj, node, eid, nsevent);
        if(FAILED(hres)) {
            IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
            return;
        }
    }
 
    fire_event_obj(doc, eid, event_obj, target, script_this);
 
    if(event_obj)
        IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
}

Referenced by call_fire_event(), dispatch_event(), fire_readystatechange_proc(), handle_htmlevent(), handle_load(), HTMLElement_handle_event(), notif_readystate(), nsContextMenuListener_OnShowContextMenu(), and set_script_elem_readystate().

get_doc_event()

static HRESULT get_doc_event ( HTMLDocument *  doc, eventid_t  eid, VARIANT *  var  )

inlinestatic

Definition at line 95 of file htmlevent.h.

{
    return get_node_event(&doc->doc_node->node, eid, var);
}

Referenced by HTMLDocument3_get_oncontextmenu(), HTMLDocument_get_onclick(), HTMLDocument_get_ondblclick(), HTMLDocument_get_ondragstart(), HTMLDocument_get_onkeydown(), HTMLDocument_get_onkeypress(), HTMLDocument_get_onkeyup(), HTMLDocument_get_onmousedown(), HTMLDocument_get_onmousemove(), HTMLDocument_get_onmouseout(), HTMLDocument_get_onmouseover(), HTMLDocument_get_onmouseup(), HTMLDocument_get_onreadystatechange(), and HTMLDocument_get_onselectstart().

get_event_handler()

HRESULT get_event_handler	(	EventTarget *	event_target,
		eventid_t	eid,
		VARIANT *	var
	)

Definition at line 1447 of file htmlevent.c.

{
    event_target_t *data;
    VARIANT *v;
    HRESULT hres;
 
    hres = dispex_get_dprop_ref(&event_target->dispex, event_info[eid].attr_name, FALSE, &v);
    if(SUCCEEDED(hres) && V_VT(v) != VT_EMPTY)
        return VariantCopy(var, v);
 
    data = get_event_target_data(event_target, FALSE);
    if(data && data->event_table[eid] && data->event_table[eid]->handler_prop) {
        V_VT(var) = VT_DISPATCH;
        V_DISPATCH(var) = data->event_table[eid]->handler_prop;
        IDispatch_AddRef(V_DISPATCH(var));
    }else {
        V_VT(var) = VT_NULL;
    }
 
    return S_OK;
}

Referenced by get_node_event(), get_window_event(), and HTMLXMLHttpRequest_get_onreadystatechange().

get_node_event()

static HRESULT get_node_event ( HTMLDOMNode *  node, eventid_t  eid, VARIANT *  var  )

inlinestatic

Definition at line 85 of file htmlevent.h.

{
    return get_event_handler(&node->event_target, eid, var);
}

Referenced by get_doc_event(), HTMLBodyElement_get_onload(), HTMLElement2_get_onblur(), HTMLElement2_get_ondrag(), HTMLElement2_get_onfocus(), HTMLElement2_get_onpaste(), HTMLElement2_get_onreadystatechange(), HTMLElement4_get_onfocusin(), HTMLElement4_get_onmousewheel(), HTMLElement_get_onclick(), HTMLElement_get_ondataavailable(), HTMLElement_get_ondblclick(), HTMLElement_get_onkeydown(), HTMLElement_get_onkeypress(), HTMLElement_get_onmousedown(), HTMLElement_get_onmousemove(), HTMLElement_get_onmouseout(), HTMLElement_get_onmouseover(), HTMLElement_get_onmouseup(), HTMLElement_get_onselectstart(), HTMLFormElement_get_onsubmit(), HTMLFrameBase2_get_onload(), HTMLImgElement_get_onabort(), HTMLImgElement_get_onerror(), HTMLImgElement_get_onload(), HTMLInputElement_get_onchange(), and HTMLScriptElement_get_onerror().

init_nsevents()

void init_nsevents

(

HTMLDocumentNode *

doc

)

Definition at line 413 of file nsevents.c.

{
    nsDocumentEventListener *listener;
    nsIDOMEventTarget *target;
    nsresult nsres;
 
    listener = heap_alloc(sizeof(nsDocumentEventListener));
    if(!listener)
        return;
 
    TRACE("%p %p\n", doc, listener);
 
    listener->ref = 1;
    listener->doc = doc;
 
    init_listener(&listener->blur_listener,        listener, &blur_vtbl);
    init_listener(&listener->focus_listener,       listener, &focus_vtbl);
    init_listener(&listener->keypress_listener,    listener, &keypress_vtbl);
    init_listener(&listener->load_listener,        listener, &load_vtbl);
    init_listener(&listener->htmlevent_listener,   listener, &htmlevent_vtbl);
 
    doc->nsevent_listener = listener;
 
    nsres = nsIDOMWindow_QueryInterface(doc->basedoc.window->nswindow, &IID_nsIDOMEventTarget, (void**)&target);
    if(NS_FAILED(nsres)) {
        ERR("Could not get nsIDOMEventTarget interface: %08x\n", nsres);
        return;
    }
 
    init_event(target, blurW,     &listener->blur_listener.nsIDOMEventListener_iface,     TRUE);
    init_event(target, focusW,    &listener->focus_listener.nsIDOMEventListener_iface,    TRUE);
    init_event(target, keypressW, &listener->keypress_listener.nsIDOMEventListener_iface, FALSE);
    init_event(target, loadW,     &listener->load_listener.nsIDOMEventListener_iface,     TRUE);
 
    nsIDOMEventTarget_Release(target);
}

Referenced by doc_init_events().

release_event_target()

void release_event_target

(

event_target_t *

event_target

)

Definition at line 1613 of file htmlevent.c.

{
    int i;
    unsigned int j;
 
    for(i=0; i < EVENTID_LAST; i++) {
        if(event_target->event_table[i]) {
            if(event_target->event_table[i]->handler_prop)
                IDispatch_Release(event_target->event_table[i]->handler_prop);
            for(j=0; j < event_target->event_table[i]->handler_cnt; j++)
                if(event_target->event_table[i]->handlers[j])
                    IDispatch_Release(event_target->event_table[i]->handlers[j]);
        }
    }
 
    heap_free(event_target);
}

Referenced by HTMLDocumentNode_destructor(), and HTMLDOMNode_destructor().

release_nsevents()

void release_nsevents

(

HTMLDocumentNode *

doc

)

Definition at line 394 of file nsevents.c.

{
    nsDocumentEventListener *listener = doc->nsevent_listener;
 
    TRACE("%p %p\n", doc, doc->nsevent_listener);
 
    if(!listener)
        return;
 
    detach_nslistener(doc, blurW,     &listener->blur_listener,     TRUE);
    detach_nslistener(doc, focusW,    &listener->focus_listener,    TRUE);
    detach_nslistener(doc, keypressW, &listener->keypress_listener, FALSE);
    detach_nslistener(doc, loadW,     &listener->load_listener,     TRUE);
 
    listener->doc = NULL;
    release_listener(listener);
    doc->nsevent_listener = NULL;
}

Referenced by detach_events().

set_doc_event()

static HRESULT set_doc_event ( HTMLDocument *  doc, eventid_t  eid, VARIANT *  var  )

inlinestatic

Definition at line 90 of file htmlevent.h.

{
    return set_node_event(&doc->doc_node->node, eid, var);
}

Referenced by HTMLDocument3_put_oncontextmenu(), HTMLDocument_put_onclick(), HTMLDocument_put_ondblclick(), HTMLDocument_put_ondragstart(), HTMLDocument_put_onkeydown(), HTMLDocument_put_onkeypress(), HTMLDocument_put_onkeyup(), HTMLDocument_put_onmousedown(), HTMLDocument_put_onmousemove(), HTMLDocument_put_onmouseout(), HTMLDocument_put_onmouseover(), HTMLDocument_put_onmouseup(), HTMLDocument_put_onreadystatechange(), and HTMLDocument_put_onselectstart().

set_event_handler()

HRESULT set_event_handler	(	EventTarget *	event_target,
		eventid_t	eid,
		VARIANT *	var
	)

Definition at line 1404 of file htmlevent.c.

{
    switch(V_VT(var)) {
    case VT_NULL:
        remove_event_handler(event_target, eid);
        return S_OK;
 
    case VT_DISPATCH:
        return set_event_handler_disp(event_target, eid, V_DISPATCH(var));
 
    case VT_BSTR: {
        VARIANT *v;
        HRESULT hres;
 
        /*
         * Setting event handler to string is a rare case and we don't want to
         * complicate nor increase memory of event_target_t for that. Instead,
         * we store the value in DispatchEx, which can already handle custom
         * properties.
         */
        remove_event_handler(event_target, eid);
 
        hres = dispex_get_dprop_ref(&event_target->dispex, event_info[eid].attr_name, TRUE, &v);
        if(FAILED(hres))
            return hres;
 
        V_BSTR(v) = SysAllocString(V_BSTR(var));
        if(!V_BSTR(v))
            return E_OUTOFMEMORY;
        V_VT(v) = VT_BSTR;
        return S_OK;
    }
 
    default:
        FIXME("not handler %s\n", debugstr_variant(var));
        /* fall through */
    case VT_EMPTY:
        return E_NOTIMPL;
    }
 
    return S_OK;
}

Referenced by HTMLXMLHttpRequest_put_onreadystatechange(), set_node_event(), and set_window_event().

set_node_event()

static HRESULT set_node_event ( HTMLDOMNode *  node, eventid_t  eid, VARIANT *  var  )

inlinestatic

Definition at line 80 of file htmlevent.h.

{
    return set_event_handler(&node->event_target, eid, var);
}

Referenced by HTMLBodyElement_put_onload(), HTMLElement2_put_onblur(), HTMLElement2_put_ondrag(), HTMLElement2_put_onfocus(), HTMLElement2_put_onpaste(), HTMLElement2_put_onreadystatechange(), HTMLElement4_put_onfocusin(), HTMLElement4_put_onmousewheel(), HTMLElement_put_onclick(), HTMLElement_put_ondataavailable(), HTMLElement_put_ondblclick(), HTMLElement_put_onkeydown(), HTMLElement_put_onkeypress(), HTMLElement_put_onkeyup(), HTMLElement_put_onmousedown(), HTMLElement_put_onmousemove(), HTMLElement_put_onmouseout(), HTMLElement_put_onmouseover(), HTMLElement_put_onmouseup(), HTMLElement_put_onselectstart(), HTMLFormElement_put_onsubmit(), HTMLFrameBase2_put_onload(), HTMLImgElement_put_onabort(), HTMLImgElement_put_onerror(), HTMLImgElement_put_onload(), HTMLInputElement_put_onchange(), HTMLScriptElement_put_onerror(), HTMLSelectElement_put_onchange(), and set_doc_event().

str_to_eid()

eventid_t str_to_eid

(

LPCWSTR

str

)

Definition at line 217 of file htmlevent.c.

{
    int i;
 
    for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
        if(!strcmpW(event_info[i].name, str))
            return i;
    }
 
    ERR("unknown type %s\n", debugstr_w(str));
    return EVENTID_LAST;
}

Referenced by handle_htmlevent().

update_doc_cp_events()

void update_doc_cp_events	(	HTMLDocumentNode *	doc,
		cp_static_data_t *	cp
	)

Definition at line 1549 of file htmlevent.c.

{
    int i;
 
    for(i=0; i < EVENTID_LAST; i++) {
        if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid))
            ensure_doc_nsevent_handler(doc, i);
    }
}

Referenced by HTMLDocument_on_advise().