?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dx9: Do not weld self.
[wine.git] / dlls / mshtml / htmlevent.c
blob290ca715572ae0b5f196702fc1650205f8a70cfc
1 /*
2 * Copyright 2008-2009 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20
21 #define COBJMACROS
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winuser.h"
26 #include "ole2.h"
27 #include "mshtmdid.h"
28
29 #include "mshtml_private.h"
30 #include "htmlevent.h"
31
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
35
36 typedef struct {
37 IDispatch *handler_prop;
38 DWORD handler_cnt;
39 IDispatch *handlers[0];
40 } handler_vector_t;
41
42 struct event_target_t {
43 DWORD node_handlers_mask;
44 handler_vector_t *event_table[EVENTID_LAST];
45 };
46
47 static const WCHAR beforeunloadW[] = {'b','e','f','o','r','e','u','n','l','o','a','d',0};
48 static const WCHAR onbeforeunloadW[] = {'o','n','b','e','f','o','r','e','u','n','l','o','a','d',0};
49
50 static const WCHAR blurW[] = {'b','l','u','r',0};
51 static const WCHAR onblurW[] = {'o','n','b','l','u','r',0};
52
53 static const WCHAR changeW[] = {'c','h','a','n','g','e',0};
54 static const WCHAR onchangeW[] = {'o','n','c','h','a','n','g','e',0};
55
56 static const WCHAR clickW[] = {'c','l','i','c','k',0};
57 static const WCHAR onclickW[] = {'o','n','c','l','i','c','k',0};
58
59 static const WCHAR contextmenuW[] = {'c','o','n','t','e','x','t','m','e','n','u',0};
60 static const WCHAR oncontextmenuW[] = {'o','n','c','o','n','t','e','x','t','m','e','n','u',0};
61
62 static const WCHAR dblclickW[] = {'d','b','l','c','l','i','c','k',0};
63 static const WCHAR ondblclickW[] = {'o','n','d','b','l','c','l','i','c','k',0};
64
65 static const WCHAR dragW[] = {'d','r','a','g',0};
66 static const WCHAR ondragW[] = {'o','n','d','r','a','g',0};
67
68 static const WCHAR dragstartW[] = {'d','r','a','g','s','t','a','r','t',0};
69 static const WCHAR ondragstartW[] = {'o','n','d','r','a','g','s','t','a','r','t',0};
70
71 static const WCHAR focusW[] = {'f','o','c','u','s',0};
72 static const WCHAR onfocusW[] = {'o','n','f','o','c','u','s',0};
73
74 static const WCHAR keydownW[] = {'k','e','y','d','o','w','n',0};
75 static const WCHAR onkeydownW[] = {'o','n','k','e','y','d','o','w','n',0};
76
77 static const WCHAR keyupW[] = {'k','e','y','u','p',0};
78 static const WCHAR onkeyupW[] = {'o','n','k','e','y','u','p',0};
79
80 static const WCHAR loadW[] = {'l','o','a','d',0};
81 static const WCHAR onloadW[] = {'o','n','l','o','a','d',0};
82
83 static const WCHAR mousedownW[] = {'m','o','u','s','e','d','o','w','n',0};
84 static const WCHAR onmousedownW[] = {'o','n','m','o','u','s','e','d','o','w','n',0};
85
86 static const WCHAR mousemoveW[] = {'m','o','u','s','e','m','o','v','e',0};
87 static const WCHAR onmousemoveW[] = {'o','n','m','o','u','s','e','m','o','v','e',0};
88
89 static const WCHAR mouseoutW[] = {'m','o','u','s','e','o','u','t',0};
90 static const WCHAR onmouseoutW[] = {'o','n','m','o','u','s','e','o','u','t',0};
91
92 static const WCHAR mouseoverW[] = {'m','o','u','s','e','o','v','e','r',0};
93 static const WCHAR onmouseoverW[] = {'o','n','m','o','u','s','e','o','v','e','r',0};
94
95 static const WCHAR mouseupW[] = {'m','o','u','s','e','u','p',0};
96 static const WCHAR onmouseupW[] = {'o','n','m','o','u','s','e','u','p',0};
97
98 static const WCHAR pasteW[] = {'p','a','s','t','e',0};
99 static const WCHAR onpasteW[] = {'o','n','p','a','s','t','e',0};
100
101 static const WCHAR readystatechangeW[] = {'r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
102 static const WCHAR onreadystatechangeW[] = {'o','n','r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
103
104 static const WCHAR resizeW[] = {'r','e','s','i','z','e',0};
105 static const WCHAR onresizeW[] = {'o','n','r','e','s','i','z','e',0};
106
107 static const WCHAR selectstartW[] = {'s','e','l','e','c','t','s','t','a','r','t',0};
108 static const WCHAR onselectstartW[] = {'o','n','s','e','l','e','c','t','s','t','a','r','t',0};
109
110 static const WCHAR submitW[] = {'s','u','b','m','i','t',0};
111 static const WCHAR onsubmitW[] = {'o','n','s','u','b','m','i','t',0};
112
113 static const WCHAR HTMLEventsW[] = {'H','T','M','L','E','v','e','n','t','s',0};
114 static const WCHAR KeyboardEventW[] = {'K','e','y','b','o','a','r','d','E','v','e','n','t',0};
115 static const WCHAR MouseEventW[] = {'M','o','u','s','e','E','v','e','n','t',0};
116
117 enum {
118 EVENTT_NONE,
119 EVENTT_HTML,
120 EVENTT_KEY,
121 EVENTT_MOUSE
122 };
123
124 static const WCHAR *event_types[] = {
125 NULL,
126 HTMLEventsW,
127 KeyboardEventW,
128 MouseEventW
129 };
130
131 typedef struct {
132 LPCWSTR name;
133 LPCWSTR attr_name;
134 DWORD type;
135 DISPID dispid;
136 DWORD flags;
137 } event_info_t;
138
139 #define EVENT_DEFAULTLISTENER 0x0001
140 #define EVENT_BUBBLE 0x0002
141 #define EVENT_FORWARDBODY 0x0004
142 #define EVENT_NODEHANDLER 0x0008
143 #define EVENT_CANCELABLE 0x0010
144 #define EVENT_HASDEFAULTHANDLERS 0x0020
145
146 static const event_info_t event_info[] = {
147 {beforeunloadW, onbeforeunloadW, EVENTT_NONE, DISPID_EVMETH_ONBEFOREUNLOAD,
148 EVENT_DEFAULTLISTENER|EVENT_FORWARDBODY},
149 {blurW, onblurW, EVENTT_HTML, DISPID_EVMETH_ONBLUR,
150 EVENT_DEFAULTLISTENER},
151 {changeW, onchangeW, EVENTT_HTML, DISPID_EVMETH_ONCHANGE,
152 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
153 {clickW, onclickW, EVENTT_MOUSE, DISPID_EVMETH_ONCLICK,
154 EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE|EVENT_HASDEFAULTHANDLERS},
155 {contextmenuW, oncontextmenuW, EVENTT_MOUSE, DISPID_EVMETH_ONCONTEXTMENU,
156 EVENT_BUBBLE|EVENT_CANCELABLE},
157 {dblclickW, ondblclickW, EVENTT_MOUSE, DISPID_EVMETH_ONDBLCLICK,
158 EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE},
159 {dragW, ondragW, EVENTT_MOUSE, DISPID_EVMETH_ONDRAG,
160 EVENT_CANCELABLE},
161 {dragstartW, ondragstartW, EVENTT_MOUSE, DISPID_EVMETH_ONDRAGSTART,
162 EVENT_CANCELABLE},
163 {focusW, onfocusW, EVENTT_HTML, DISPID_EVMETH_ONFOCUS,
164 EVENT_DEFAULTLISTENER},
165 {keydownW, onkeydownW, EVENTT_KEY, DISPID_EVMETH_ONKEYDOWN,
166 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
167 {keyupW, onkeyupW, EVENTT_KEY, DISPID_EVMETH_ONKEYUP,
168 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
169 {loadW, onloadW, EVENTT_HTML, DISPID_EVMETH_ONLOAD,
170 EVENT_NODEHANDLER},
171 {mousedownW, onmousedownW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEDOWN,
172 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
173 {mousemoveW, onmousemoveW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEMOVE,
174 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
175 {mouseoutW, onmouseoutW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEOUT,
176 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
177 {mouseoverW, onmouseoverW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEOVER,
178 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
179 {mouseupW, onmouseupW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEUP,
180 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
181 {pasteW, onpasteW, EVENTT_NONE, DISPID_EVMETH_ONPASTE,
182 EVENT_CANCELABLE},
183 {readystatechangeW, onreadystatechangeW, EVENTT_NONE, DISPID_EVMETH_ONREADYSTATECHANGE,
184 0},
185 {resizeW, onresizeW, EVENTT_NONE, DISPID_EVMETH_ONRESIZE,
186 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
187 {selectstartW, onselectstartW, EVENTT_MOUSE, DISPID_EVMETH_ONSELECTSTART,
188 EVENT_CANCELABLE},
189 {submitW, onsubmitW, EVENTT_HTML, DISPID_EVMETH_ONSUBMIT,
190 EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE}
191 };
192
193 static const eventid_t node_handled_list[] = { EVENTID_LOAD };
194
195 eventid_t str_to_eid(LPCWSTR str)
196 {
197 int i;
198
199 for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
200 if(!strcmpW(event_info[i].name, str))
201 return i;
202 }
203
204 ERR("unknown type %s\n", debugstr_w(str));
205 return EVENTID_LAST;
206 }
207
208 static eventid_t attr_to_eid(LPCWSTR str)
209 {
210 int i;
211
212 for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
213 if(!strcmpW(event_info[i].attr_name, str))
214 return i;
215 }
216
217 return EVENTID_LAST;
218 }
219
220 static DWORD get_node_handler_mask(eventid_t eid)
221 {
222 DWORD i;
223
224 for(i=0; i<sizeof(node_handled_list)/sizeof(*node_handled_list); i++) {
225 if(node_handled_list[i] == eid)
226 return 1 << i;
227 }
228
229 ERR("Invalid eid %d\n", eid);
230 return ~0;
231 }
232
233 typedef struct {
234 DispatchEx dispex;
235 IHTMLEventObj IHTMLEventObj_iface;
236
237 LONG ref;
238
239 HTMLDOMNode *target;
240 const event_info_t *type;
241 nsIDOMEvent *nsevent;
242 BOOL prevent_default;
243 } HTMLEventObj;
244
245 static inline HTMLEventObj *impl_from_IHTMLEventObj(IHTMLEventObj *iface)
246 {
247 return CONTAINING_RECORD(iface, HTMLEventObj, IHTMLEventObj_iface);
248 }
249
250 static HRESULT WINAPI HTMLEventObj_QueryInterface(IHTMLEventObj *iface, REFIID riid, void **ppv)
251 {
252 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
253
254 *ppv = NULL;
255
256 if(IsEqualGUID(&IID_IUnknown, riid)) {
257 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
258 *ppv = &This->IHTMLEventObj_iface;
259 }else if(IsEqualGUID(&IID_IHTMLEventObj, riid)) {
260 TRACE("(%p)->(IID_IHTMLEventObj %p)\n", This, ppv);
261 *ppv = &This->IHTMLEventObj_iface;
262 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
263 return *ppv ? S_OK : E_NOINTERFACE;
264 }
265
266 if(*ppv) {
267 IUnknown_AddRef((IUnknown*)*ppv);
268 return S_OK;
269 }
270
271 WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
272 return E_NOINTERFACE;
273 }
274
275 static ULONG WINAPI HTMLEventObj_AddRef(IHTMLEventObj *iface)
276 {
277 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
278 LONG ref = InterlockedIncrement(&This->ref);
279
280 TRACE("(%p) ref=%d\n", This, ref);
281
282 return ref;
283 }
284
285 static ULONG WINAPI HTMLEventObj_Release(IHTMLEventObj *iface)
286 {
287 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
288 LONG ref = InterlockedDecrement(&This->ref);
289
290 TRACE("(%p) ref=%d\n", This, ref);
291
292 if(!ref) {
293 if(This->target)
294 IHTMLDOMNode_Release(&This->target->IHTMLDOMNode_iface);
295 if(This->nsevent)
296 nsIDOMEvent_Release(This->nsevent);
297 release_dispex(&This->dispex);
298 heap_free(This);
299 }
300
301 return ref;
302 }
303
304 static HRESULT WINAPI HTMLEventObj_GetTypeInfoCount(IHTMLEventObj *iface, UINT *pctinfo)
305 {
306 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
307 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
308 }
309
310 static HRESULT WINAPI HTMLEventObj_GetTypeInfo(IHTMLEventObj *iface, UINT iTInfo,
311 LCID lcid, ITypeInfo **ppTInfo)
312 {
313 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
314 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
315 }
316
317 static HRESULT WINAPI HTMLEventObj_GetIDsOfNames(IHTMLEventObj *iface, REFIID riid,
318 LPOLESTR *rgszNames, UINT cNames,
319 LCID lcid, DISPID *rgDispId)
320 {
321 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
322 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
323 lcid, rgDispId);
324 }
325
326 static HRESULT WINAPI HTMLEventObj_Invoke(IHTMLEventObj *iface, DISPID dispIdMember,
327 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
328 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
329 {
330 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
331 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
332 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
333 }
334
335 static HRESULT WINAPI HTMLEventObj_get_srcElement(IHTMLEventObj *iface, IHTMLElement **p)
336 {
337 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
338
339 TRACE("(%p)->(%p)\n", This, p);
340
341 return IHTMLDOMNode_QueryInterface(&This->target->IHTMLDOMNode_iface, &IID_IHTMLElement,
342 (void**)p);
343 }
344
345 static HRESULT WINAPI HTMLEventObj_get_altKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
346 {
347 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
348 cpp_bool ret = FALSE;
349
350 TRACE("(%p)->(%p)\n", This, p);
351
352 if(This->nsevent) {
353 nsIDOMKeyEvent *key_event;
354 nsresult nsres;
355
356 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
357 if(NS_SUCCEEDED(nsres)) {
358 nsIDOMKeyEvent_GetAltKey(key_event, &ret);
359 nsIDOMKeyEvent_Release(key_event);
360 }else {
361 nsIDOMMouseEvent *mouse_event;
362
363 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
364 if(NS_SUCCEEDED(nsres)) {
365 nsIDOMMouseEvent_GetAltKey(mouse_event, &ret);
366 nsIDOMMouseEvent_Release(mouse_event);
367 }
368 }
369 }
370
371 *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
372 return S_OK;
373 }
374
375 static HRESULT WINAPI HTMLEventObj_get_ctrlKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
376 {
377 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
378 cpp_bool ret = FALSE;
379
380 TRACE("(%p)->(%p)\n", This, p);
381
382 if(This->nsevent) {
383 nsIDOMKeyEvent *key_event;
384 nsresult nsres;
385
386 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
387 if(NS_SUCCEEDED(nsres)) {
388 nsIDOMKeyEvent_GetCtrlKey(key_event, &ret);
389 nsIDOMKeyEvent_Release(key_event);
390 }else {
391 nsIDOMMouseEvent *mouse_event;
392
393 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
394 if(NS_SUCCEEDED(nsres)) {
395 nsIDOMMouseEvent_GetCtrlKey(mouse_event, &ret);
396 nsIDOMMouseEvent_Release(mouse_event);
397 }
398 }
399 }
400
401 *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
402 return S_OK;
403 }
404
405 static HRESULT WINAPI HTMLEventObj_get_shiftKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
406 {
407 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
408 cpp_bool ret = FALSE;
409
410 TRACE("(%p)->(%p)\n", This, p);
411
412 if(This->nsevent) {
413 nsIDOMKeyEvent *key_event;
414 nsresult nsres;
415
416 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
417 if(NS_SUCCEEDED(nsres)) {
418 nsIDOMKeyEvent_GetShiftKey(key_event, &ret);
419 nsIDOMKeyEvent_Release(key_event);
420 }else {
421 nsIDOMMouseEvent *mouse_event;
422
423 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
424 if(NS_SUCCEEDED(nsres)) {
425 nsIDOMMouseEvent_GetShiftKey(mouse_event, &ret);
426 nsIDOMMouseEvent_Release(mouse_event);
427 }
428 }
429 }
430
431 *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
432 return S_OK;
433 }
434
435 static HRESULT WINAPI HTMLEventObj_put_returnValue(IHTMLEventObj *iface, VARIANT v)
436 {
437 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
438
439 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
440
441 if(V_VT(&v) != VT_BOOL) {
442 FIXME("unsupported vt %d\n", V_VT(&v));
443 return DISP_E_BADVARTYPE;
444 }
445
446 if(!V_BOOL(&v))
447 This->prevent_default = TRUE;
448 return S_OK;
449 }
450
451 static HRESULT WINAPI HTMLEventObj_get_returnValue(IHTMLEventObj *iface, VARIANT *p)
452 {
453 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
454
455 FIXME("(%p)->(%p)\n", This, p);
456
457 V_VT(p) = VT_EMPTY;
458 return S_OK;
459 }
460
461 static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v)
462 {
463 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
464 FIXME("(%p)->(%x)\n", This, v);
465 return E_NOTIMPL;
466 }
467
468 static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p)
469 {
470 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
471
472 FIXME("(%p)->(%p)\n", This, p);
473
474 *p = VARIANT_FALSE;
475 return S_OK;
476 }
477
478 static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p)
479 {
480 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
481
482 FIXME("(%p)->(%p)\n", This, p);
483
484 *p = NULL;
485 return S_OK;
486 }
487
488 static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p)
489 {
490 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
491
492 FIXME("(%p)->(%p)\n", This, p);
493
494 *p = NULL;
495 return S_OK;
496 }
497
498 static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, LONG v)
499 {
500 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
501 FIXME("(%p)->(%d)\n", This, v);
502 return E_NOTIMPL;
503 }
504
505 static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p)
506 {
507 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
508 PRUint32 key_code = 0;
509
510 TRACE("(%p)->(%p)\n", This, p);
511
512 if(This->nsevent) {
513 nsIDOMKeyEvent *key_event;
514 nsresult nsres;
515
516 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
517 if(NS_SUCCEEDED(nsres)) {
518 nsIDOMKeyEvent_GetKeyCode(key_event, &key_code);
519 nsIDOMKeyEvent_Release(key_event);
520 }
521 }
522
523 *p = key_code;
524 return S_OK;
525 }
526
527 static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p)
528 {
529 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
530 PRUint16 button = 0;
531
532 TRACE("(%p)->(%p)\n", This, p);
533
534 if(This->nsevent) {
535 nsIDOMMouseEvent *mouse_event;
536 nsresult nsres;
537
538 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
539 if(NS_SUCCEEDED(nsres)) {
540 nsIDOMMouseEvent_GetButton(mouse_event, &button);
541 nsIDOMMouseEvent_Release(mouse_event);
542 }
543 }
544
545 *p = button;
546 return S_OK;
547 }
548
549 static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p)
550 {
551 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
552
553 TRACE("(%p)->(%p)\n", This, p);
554
555 *p = SysAllocString(This->type->name);
556 return *p ? S_OK : E_OUTOFMEMORY;
557 }
558
559 static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p)
560 {
561 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
562
563 FIXME("(%p)->(%p)\n", This, p);
564
565 *p = NULL;
566 return S_OK;
567 }
568
569 static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, LONG *p)
570 {
571 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
572
573 FIXME("(%p)->(%p)\n", This, p);
574
575 *p = 0;
576 return S_OK;
577 }
578
579 static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, LONG *p)
580 {
581 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
582
583 FIXME("(%p)->(%p)\n", This, p);
584
585 *p = -1;
586 return S_OK;
587 }
588
589 static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, LONG *p)
590 {
591 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
592
593 FIXME("(%p)->(%p)\n", This, p);
594
595 *p = -1;
596 return S_OK;
597 }
598
599 static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, LONG *p)
600 {
601 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
602 PRInt32 x = 0;
603
604 TRACE("(%p)->(%p)\n", This, p);
605
606 if(This->nsevent) {
607 nsIDOMMouseEvent *mouse_event;
608 nsresult nsres;
609
610 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
611 if(NS_SUCCEEDED(nsres)) {
612 nsIDOMMouseEvent_GetClientX(mouse_event, &x);
613 nsIDOMMouseEvent_Release(mouse_event);
614 }
615 }
616
617 *p = x;
618 return S_OK;
619 }
620
621 static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, LONG *p)
622 {
623 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
624 PRInt32 y = 0;
625
626 TRACE("(%p)->(%p)\n", This, p);
627
628 if(This->nsevent) {
629 nsIDOMMouseEvent *mouse_event;
630 nsresult nsres;
631
632 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
633 if(NS_SUCCEEDED(nsres)) {
634 nsIDOMMouseEvent_GetClientY(mouse_event, &y);
635 nsIDOMMouseEvent_Release(mouse_event);
636 }
637 }
638
639 *p = y;
640 return S_OK;
641 }
642
643 static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, LONG *p)
644 {
645 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
646
647 FIXME("(%p)->(%p)\n", This, p);
648
649 *p = 0;
650 return S_OK;
651 }
652
653 static HRESULT WINAPI HTMLEventObj_get_offsetY(IHTMLEventObj *iface, LONG *p)
654 {
655 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
656
657 FIXME("(%p)->(%p)\n", This, p);
658
659 *p = 0;
660 return S_OK;
661 }
662
663 static HRESULT WINAPI HTMLEventObj_get_screenX(IHTMLEventObj *iface, LONG *p)
664 {
665 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
666 PRInt32 x = 0;
667
668 TRACE("(%p)->(%p)\n", This, p);
669
670 if(This->nsevent) {
671 nsIDOMMouseEvent *mouse_event;
672 nsresult nsres;
673
674 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
675 if(NS_SUCCEEDED(nsres)) {
676 nsIDOMMouseEvent_GetScreenX(mouse_event, &x);
677 nsIDOMMouseEvent_Release(mouse_event);
678 }
679 }
680
681 *p = x;
682 return S_OK;
683 }
684
685 static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, LONG *p)
686 {
687 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
688 PRInt32 y = 0;
689
690 TRACE("(%p)->(%p)\n", This, p);
691
692 if(This->nsevent) {
693 nsIDOMMouseEvent *mouse_event;
694 nsresult nsres;
695
696 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
697 if(NS_SUCCEEDED(nsres)) {
698 nsIDOMMouseEvent_GetScreenY(mouse_event, &y);
699 nsIDOMMouseEvent_Release(mouse_event);
700 }
701 }
702
703 *p = y;
704 return S_OK;
705 }
706
707 static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p)
708 {
709 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
710
711 FIXME("(%p)->(%p)\n", This, p);
712
713 *p = NULL;
714 return S_OK;
715 }
716
717 static const IHTMLEventObjVtbl HTMLEventObjVtbl = {
718 HTMLEventObj_QueryInterface,
719 HTMLEventObj_AddRef,
720 HTMLEventObj_Release,
721 HTMLEventObj_GetTypeInfoCount,
722 HTMLEventObj_GetTypeInfo,
723 HTMLEventObj_GetIDsOfNames,
724 HTMLEventObj_Invoke,
725 HTMLEventObj_get_srcElement,
726 HTMLEventObj_get_altKey,
727 HTMLEventObj_get_ctrlKey,
728 HTMLEventObj_get_shiftKey,
729 HTMLEventObj_put_returnValue,
730 HTMLEventObj_get_returnValue,
731 HTMLEventObj_put_cancelBubble,
732 HTMLEventObj_get_cancelBubble,
733 HTMLEventObj_get_fromElement,
734 HTMLEventObj_get_toElement,
735 HTMLEventObj_put_keyCode,
736 HTMLEventObj_get_keyCode,
737 HTMLEventObj_get_button,
738 HTMLEventObj_get_type,
739 HTMLEventObj_get_qualifier,
740 HTMLEventObj_get_reason,
741 HTMLEventObj_get_x,
742 HTMLEventObj_get_y,
743 HTMLEventObj_get_clientX,
744 HTMLEventObj_get_clientY,
745 HTMLEventObj_get_offsetX,
746 HTMLEventObj_get_offsetY,
747 HTMLEventObj_get_screenX,
748 HTMLEventObj_get_screenY,
749 HTMLEventObj_get_srcFilter
750 };
751
752 static const tid_t HTMLEventObj_iface_tids[] = {
753 IHTMLEventObj_tid,
754 0
755 };
756
757 static dispex_static_data_t HTMLEventObj_dispex = {
758 NULL,
759 DispCEventObj_tid,
760 NULL,
761 HTMLEventObj_iface_tids
762 };
763
764 static HTMLEventObj *create_event(HTMLDOMNode *target, eventid_t eid, nsIDOMEvent *nsevent)
765 {
766 HTMLEventObj *ret;
767
768 ret = heap_alloc_zero(sizeof(*ret));
769 if(!ret)
770 return NULL;
771
772 ret->IHTMLEventObj_iface.lpVtbl = &HTMLEventObjVtbl;
773 ret->ref = 1;
774 ret->type = event_info+eid;
775
776 ret->nsevent = nsevent;
777 if(nsevent) {
778 nsIDOMEvent_AddRef(nsevent);
779 }else if(event_types[event_info[eid].type]) {
780 nsAString type_str;
781 nsresult nsres;
782
783 nsAString_InitDepend(&type_str, event_types[event_info[eid].type]);
784 nsres = nsIDOMHTMLDocument_CreateEvent(target->doc->nsdoc, &type_str, &ret->nsevent);
785 nsAString_Finish(&type_str);
786 if(NS_FAILED(nsres)) {
787 ERR("Could not create event: %08x\n", nsres);
788 IHTMLEventObj_Release(&ret->IHTMLEventObj_iface);
789 return NULL;
790 }
791 }
792
793 ret->target = target;
794 IHTMLDOMNode_AddRef(&target->IHTMLDOMNode_iface);
795
796 init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLEventObj_iface, &HTMLEventObj_dispex);
797
798 return ret;
799 }
800
801 static HRESULT call_disp_func(IDispatch *disp, DISPPARAMS *dp, VARIANT *retv)
802 {
803 IDispatchEx *dispex;
804 EXCEPINFO ei;
805 HRESULT hres;
806
807 memset(&ei, 0, sizeof(ei));
808
809 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
810 if(SUCCEEDED(hres)) {
811 hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL);
812 IDispatchEx_Release(dispex);
813 }else {
814 TRACE("Could not get IDispatchEx interface: %08x\n", hres);
815 hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD,
816 dp, retv, &ei, NULL);
817 }
818
819 return hres;
820 }
821
822 static HRESULT call_cp_func(IDispatch *disp, DISPID dispid, VARIANT *retv)
823 {
824 DISPPARAMS dp = {NULL,NULL,0,0};
825 ULONG argerr;
826 EXCEPINFO ei;
827
828 memset(&ei, 0, sizeof(ei));
829 return IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, retv, &ei, &argerr);
830 }
831
832 static BOOL is_cp_event(cp_static_data_t *data, DISPID dispid)
833 {
834 int min, max, i;
835 HRESULT hres;
836
837 if(!data)
838 return FALSE;
839
840 if(!data->ids) {
841 hres = get_dispids(data->tid, &data->id_cnt, &data->ids);
842 if(FAILED(hres))
843 return FALSE;
844 }
845
846 min = 0;
847 max = data->id_cnt-1;
848 while(min <= max) {
849 i = (min+max)/2;
850 if(data->ids[i] == dispid)
851 return TRUE;
852
853 if(data->ids[i] < dispid)
854 min = i+1;
855 else
856 max = i-1;
857 }
858
859 return FALSE;
860 }
861
862 static void call_event_handlers(HTMLDocumentNode *doc, HTMLEventObj *event_obj, event_target_t *event_target,
863 ConnectionPointContainer *cp_container, eventid_t eid, IDispatch *this_obj)
864 {
865 const BOOL cancelable = event_info[eid].flags & EVENT_CANCELABLE;
866 handler_vector_t *handler_vector = NULL;
867 VARIANT v;
868 int i;
869 HRESULT hres;
870
871 if(event_target)
872 handler_vector = event_target->event_table[eid];
873
874 if(handler_vector && handler_vector->handler_prop) {
875 DISPID named_arg = DISPID_THIS;
876 VARIANTARG arg;
877 DISPPARAMS dp = {&arg, &named_arg, 1, 1};
878
879 V_VT(&arg) = VT_DISPATCH;
880 V_DISPATCH(&arg) = this_obj;
881 V_VT(&v) = VT_EMPTY;
882
883 TRACE("%s >>>\n", debugstr_w(event_info[eid].name));
884 hres = call_disp_func(handler_vector->handler_prop, &dp, &v);
885 if(hres == S_OK) {
886 TRACE("%s <<< %s\n", debugstr_w(event_info[eid].name), debugstr_variant(&v));
887
888 if(cancelable) {
889 if(V_VT(&v) == VT_BOOL) {
890 if(!V_BOOL(&v))
891 event_obj->prevent_default = TRUE;
892 }else if(V_VT(&v) != VT_EMPTY) {
893 FIXME("unhandled result %s\n", debugstr_variant(&v));
894 }
895 }
896 VariantClear(&v);
897 }else {
898 WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres);
899 }
900 }
901
902 if(handler_vector && handler_vector->handler_cnt) {
903 VARIANTARG arg;
904 DISPPARAMS dp = {&arg, NULL, 1, 0};
905
906 V_VT(&arg) = VT_DISPATCH;
907 V_DISPATCH(&arg) = (IDispatch*)event_obj;
908
909 i = handler_vector->handler_cnt;
910 while(i--) {
911 if(handler_vector->handlers[i]) {
912 V_VT(&v) = VT_EMPTY;
913
914 TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
915 hres = call_disp_func(handler_vector->handlers[i], &dp, &v);
916 if(hres == S_OK) {
917 TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
918
919 if(cancelable) {
920 if(V_VT(&v) == VT_BOOL) {
921 if(!V_BOOL(&v))
922 event_obj->prevent_default = TRUE;
923 }else if(V_VT(&v) != VT_EMPTY) {
924 FIXME("unhandled result %s\n", debugstr_variant(&v));
925 }
926 }
927 VariantClear(&v);
928 }else {
929 WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
930 }
931 }
932 }
933 }
934
935 if(cp_container) {
936 ConnectionPoint *cp;
937
938 if(cp_container->forward_container)
939 cp_container = cp_container->forward_container;
940
941 for(cp = cp_container->cp_list; cp; cp = cp->next) {
942 if(cp->sinks_size && is_cp_event(cp->data, event_info[eid].dispid)) {
943 for(i=0; i < cp->sinks_size; i++) {
944 if(!cp->sinks[i].disp)
945 continue;
946
947 V_VT(&v) = VT_EMPTY;
948
949 TRACE("cp %s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
950 hres = call_cp_func(cp->sinks[i].disp, event_info[eid].dispid, &v);
951 if(hres == S_OK) {
952 TRACE("cp %s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
953
954 if(cancelable) {
955 if(V_VT(&v) == VT_BOOL) {
956 if(!V_BOOL(&v))
957 event_obj->prevent_default = TRUE;
958 }else if(V_VT(&v) != VT_EMPTY) {
959 FIXME("unhandled result %s\n", debugstr_variant(&v));
960 }
961 }
962 VariantClear(&v);
963 }else {
964 WARN("cp %s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
965 }
966 }
967 }
968 }
969 }
970 }
971
972 void fire_event(HTMLDocumentNode *doc, eventid_t eid, BOOL set_event, nsIDOMNode *target, nsIDOMEvent *nsevent)
973 {
974 HTMLEventObj *event_obj = NULL;
975 IHTMLEventObj *prev_event;
976 nsIDOMNode *parent, *nsnode;
977 BOOL prevent_default = FALSE;
978 HTMLDOMNode *node;
979 PRUint16 node_type;
980 nsresult nsres;
981 HRESULT hres;
982
983 TRACE("(%p) %s\n", doc, debugstr_w(event_info[eid].name));
984
985 prev_event = doc->basedoc.window->event;
986 if(set_event) {
987 hres = get_node(doc, target, TRUE, &node);
988 if(FAILED(hres))
989 return;
990
991 event_obj = create_event(node, eid, nsevent);
992 doc->basedoc.window->event = &event_obj->IHTMLEventObj_iface;
993 }else {
994 doc->basedoc.window->event = NULL;
995 }
996
997 nsIDOMNode_GetNodeType(target, &node_type);
998 nsnode = target;
999 nsIDOMNode_AddRef(nsnode);
1000
1001 switch(node_type) {
1002 case ELEMENT_NODE:
1003 do {
1004 hres = get_node(doc, nsnode, FALSE, &node);
1005 if(SUCCEEDED(hres) && node)
1006 call_event_handlers(doc, event_obj, *get_node_event_target(node),
1007 node->cp_container, eid, (IDispatch*)&node->IHTMLDOMNode_iface);
1008
1009 if(!(event_info[eid].flags & EVENT_BUBBLE))
1010 break;
1011
1012 nsIDOMNode_GetParentNode(nsnode, &parent);
1013 nsIDOMNode_Release(nsnode);
1014 nsnode = parent;
1015 if(!nsnode)
1016 break;
1017
1018 nsIDOMNode_GetNodeType(nsnode, &node_type);
1019 }while(node_type == ELEMENT_NODE);
1020
1021 if(!(event_info[eid].flags & EVENT_BUBBLE))
1022 break;
1023
1024 case DOCUMENT_NODE:
1025 if(event_info[eid].flags & EVENT_FORWARDBODY) {
1026 nsIDOMHTMLElement *nsbody;
1027 nsresult nsres;
1028
1029 nsres = nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody);
1030 if(NS_SUCCEEDED(nsres) && nsbody) {
1031 hres = get_node(doc, (nsIDOMNode*)nsbody, FALSE, &node);
1032 if(SUCCEEDED(hres) && node)
1033 call_event_handlers(doc, event_obj, *get_node_event_target(node),
1034 node->cp_container, eid, (IDispatch*)&node->IHTMLDOMNode_iface);
1035 nsIDOMHTMLElement_Release(nsbody);
1036 }else {
1037 ERR("Could not get body: %08x\n", nsres);
1038 }
1039 }
1040
1041 call_event_handlers(doc, event_obj, doc->node.event_target, &doc->basedoc.cp_container, eid,
1042 (IDispatch*)&doc->basedoc.IHTMLDocument2_iface);
1043 break;
1044
1045 default:
1046 FIXME("unimplemented node type %d\n", node_type);
1047 }
1048
1049 if(nsnode)
1050 nsIDOMNode_Release(nsnode);
1051
1052 if(event_obj && event_obj->prevent_default)
1053 prevent_default = TRUE;
1054 doc->basedoc.window->event = prev_event;
1055 if(event_obj)
1056 IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
1057
1058 if(!prevent_default && (event_info[eid].flags & EVENT_HASDEFAULTHANDLERS)) {
1059 nsIDOMNode_AddRef(target);
1060 nsnode = target;
1061
1062 do {
1063 hres = get_node(doc, nsnode, TRUE, &node);
1064 if(FAILED(hres))
1065 break;
1066
1067 if(node && node->vtbl->handle_event) {
1068 hres = node->vtbl->handle_event(node, eid, nsevent, &prevent_default);
1069 if(FAILED(hres) || prevent_default)
1070 break;
1071 }
1072
1073 nsres = nsIDOMNode_GetParentNode(nsnode, &parent);
1074 if(NS_FAILED(nsres))
1075 break;
1076
1077 nsIDOMNode_Release(nsnode);
1078 nsnode = parent;
1079 } while(nsnode);
1080
1081 if(nsnode)
1082 nsIDOMNode_Release(nsnode);
1083 }
1084
1085 if(prevent_default && nsevent) {
1086 TRACE("calling PreventDefault\n");
1087 nsIDOMEvent_PreventDefault(nsevent);
1088 }
1089 }
1090
1091 HRESULT dispatch_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_obj, VARIANT_BOOL *cancelled)
1092 {
1093 eventid_t eid;
1094
1095 eid = attr_to_eid(event_name);
1096 if(eid == EVENTID_LAST) {
1097 WARN("unknown event %s\n", debugstr_w(event_name));
1098 return E_INVALIDARG;
1099 }
1100
1101 if(event_obj && V_VT(event_obj) != VT_EMPTY && V_VT(event_obj) != VT_ERROR)
1102 FIXME("event_obj not implemented\n");
1103
1104 if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER)) {
1105 FIXME("not EVENT_DEFAULTEVENTHANDLER\n");
1106 return E_NOTIMPL;
1107 }
1108
1109 fire_event(node->doc, eid, TRUE, node->nsnode, NULL);
1110
1111 *cancelled = VARIANT_TRUE; /* FIXME */
1112 return S_OK;
1113 }
1114
1115 HRESULT call_fire_event(HTMLDOMNode *node, eventid_t eid)
1116 {
1117 HRESULT hres;
1118
1119 if(node->vtbl->fire_event) {
1120 BOOL handled = FALSE;
1121
1122 hres = node->vtbl->fire_event(node, eid, &handled);
1123 if(handled)
1124 return hres;
1125 }
1126
1127 fire_event(node->doc, eid, TRUE, node->nsnode, NULL);
1128 return S_OK;
1129 }
1130
1131 static inline event_target_t *get_event_target(event_target_t **event_target_ptr)
1132 {
1133 if(!*event_target_ptr)
1134 *event_target_ptr = heap_alloc_zero(sizeof(event_target_t));
1135 return *event_target_ptr;
1136 }
1137
1138 static BOOL alloc_handler_vector(event_target_t *event_target, eventid_t eid, int cnt)
1139 {
1140 handler_vector_t *new_vector, *handler_vector = event_target->event_table[eid];
1141
1142 if(handler_vector) {
1143 if(cnt <= handler_vector->handler_cnt)
1144 return TRUE;
1145
1146 new_vector = heap_realloc_zero(handler_vector, sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1147 }else {
1148 new_vector = heap_alloc_zero(sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1149 }
1150
1151 if(!new_vector)
1152 return FALSE;
1153
1154 new_vector->handler_cnt = cnt;
1155 event_target->event_table[eid] = new_vector;
1156 return TRUE;
1157 }
1158
1159 static HRESULT ensure_nsevent_handler(HTMLDocumentNode *doc, event_target_t *event_target, nsIDOMNode *nsnode, eventid_t eid)
1160 {
1161 if(!doc->nsdoc)
1162 return S_OK;
1163
1164 if(event_info[eid].flags & EVENT_NODEHANDLER) {
1165 DWORD mask;
1166
1167 mask = get_node_handler_mask(eid);
1168 if(event_target->node_handlers_mask & mask)
1169 return S_OK;
1170
1171 add_nsevent_listener(doc, nsnode, event_info[eid].name);
1172 event_target->node_handlers_mask |= mask;
1173 return S_OK;
1174 }
1175
1176 if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER))
1177 return S_OK;
1178
1179 if(!doc->event_vector[eid]) {
1180 doc->event_vector[eid] = TRUE;
1181 add_nsevent_listener(doc, NULL, event_info[eid].name);
1182 }
1183
1184 return S_OK;
1185 }
1186
1187 void detach_events(HTMLDocumentNode *doc)
1188 {
1189 int i;
1190
1191 if(!doc->event_vector)
1192 return;
1193
1194 for(i=0; i < EVENTID_LAST; i++) {
1195 if(doc->event_vector[i])
1196 detach_nsevent(doc, event_info[i].name);
1197 }
1198 }
1199
1200
1201 static HRESULT remove_event_handler(event_target_t **event_target, eventid_t eid)
1202 {
1203 if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
1204 IDispatch_Release((*event_target)->event_table[eid]->handler_prop);
1205 (*event_target)->event_table[eid]->handler_prop = NULL;
1206 }
1207
1208 return S_OK;
1209 }
1210
1211 static HRESULT set_event_handler_disp(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocumentNode *doc,
1212 eventid_t eid, IDispatch *disp)
1213 {
1214 event_target_t *event_target;
1215
1216 if(!disp)
1217 return remove_event_handler(event_target_ptr, eid);
1218
1219 event_target = get_event_target(event_target_ptr);
1220 if(!event_target)
1221 return E_OUTOFMEMORY;
1222
1223 if(!alloc_handler_vector(event_target, eid, 0))
1224 return E_OUTOFMEMORY;
1225
1226 if(event_target->event_table[eid]->handler_prop)
1227 IDispatch_Release(event_target->event_table[eid]->handler_prop);
1228
1229 event_target->event_table[eid]->handler_prop = disp;
1230 IDispatch_AddRef(disp);
1231
1232 return ensure_nsevent_handler(doc, event_target, nsnode, eid);
1233 }
1234
1235 HRESULT set_event_handler(event_target_t **event_target, nsIDOMNode *nsnode, HTMLDocumentNode *doc, eventid_t eid, VARIANT *var)
1236 {
1237 switch(V_VT(var)) {
1238 case VT_NULL:
1239 return remove_event_handler(event_target, eid);
1240
1241 case VT_DISPATCH:
1242 return set_event_handler_disp(event_target, nsnode, doc, eid, V_DISPATCH(var));
1243
1244 default:
1245 FIXME("not supported vt=%d\n", V_VT(var));
1246 /* fall through */
1247 case VT_EMPTY:
1248 return E_NOTIMPL;
1249 }
1250
1251 return S_OK;
1252 }
1253
1254 HRESULT get_event_handler(event_target_t **event_target, eventid_t eid, VARIANT *var)
1255 {
1256 if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
1257 V_VT(var) = VT_DISPATCH;
1258 V_DISPATCH(var) = (*event_target)->event_table[eid]->handler_prop;
1259 IDispatch_AddRef(V_DISPATCH(var));
1260 }else {
1261 V_VT(var) = VT_NULL;
1262 }
1263
1264 return S_OK;
1265 }
1266
1267 HRESULT attach_event(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocument *doc, BSTR name,
1268 IDispatch *disp, VARIANT_BOOL *res)
1269 {
1270 event_target_t *event_target;
1271 eventid_t eid;
1272 DWORD i = 0;
1273
1274 eid = attr_to_eid(name);
1275 if(eid == EVENTID_LAST) {
1276 WARN("Unknown event\n");
1277 *res = VARIANT_TRUE;
1278 return S_OK;
1279 }
1280
1281 event_target = get_event_target(event_target_ptr);
1282 if(!event_target)
1283 return E_OUTOFMEMORY;
1284
1285 if(event_target->event_table[eid]) {
1286 while(i < event_target->event_table[eid]->handler_cnt && event_target->event_table[eid]->handlers[i])
1287 i++;
1288 if(i == event_target->event_table[eid]->handler_cnt && !alloc_handler_vector(event_target, eid, i+1))
1289 return E_OUTOFMEMORY;
1290 }else if(!alloc_handler_vector(event_target, eid, i+1)) {
1291 return E_OUTOFMEMORY;
1292 }
1293
1294 IDispatch_AddRef(disp);
1295 event_target->event_table[eid]->handlers[i] = disp;
1296
1297 *res = VARIANT_TRUE;
1298 return ensure_nsevent_handler(doc->doc_node, event_target, nsnode, eid);
1299 }
1300
1301 HRESULT detach_event(event_target_t *event_target, HTMLDocument *doc, BSTR name, IDispatch *disp)
1302 {
1303 eventid_t eid;
1304 DWORD i = 0;
1305
1306 if(!event_target)
1307 return S_OK;
1308
1309 eid = attr_to_eid(name);
1310 if(eid == EVENTID_LAST) {
1311 WARN("Unknown event\n");
1312 return S_OK;
1313 }
1314
1315 if(!event_target->event_table[eid])
1316 return S_OK;
1317
1318 while(i < event_target->event_table[eid]->handler_cnt) {
1319 if(event_target->event_table[eid]->handlers[i] == disp) {
1320 IDispatch_Release(event_target->event_table[eid]->handlers[i]);
1321 event_target->event_table[eid]->handlers[i] = NULL;
1322 }
1323 i++;
1324 }
1325
1326 return S_OK;
1327 }
1328
1329 void update_cp_events(HTMLWindow *window, event_target_t **event_target_ptr, cp_static_data_t *cp, nsIDOMNode *nsnode)
1330 {
1331 event_target_t *event_target;
1332 int i;
1333
1334 event_target = get_event_target(event_target_ptr);
1335 if(!event_target)
1336 return; /* FIXME */
1337
1338 for(i=0; i < EVENTID_LAST; i++) {
1339 if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid))
1340 ensure_nsevent_handler(window->doc, event_target, nsnode, i);
1341 }
1342 }
1343
1344 void check_event_attr(HTMLDocumentNode *doc, nsIDOMElement *nselem)
1345 {
1346 const PRUnichar *attr_value;
1347 nsAString attr_name_str, attr_value_str;
1348 IDispatch *disp;
1349 HTMLDOMNode *node;
1350 int i;
1351 nsresult nsres;
1352 HRESULT hres;
1353
1354 nsAString_Init(&attr_value_str, NULL);
1355 nsAString_Init(&attr_name_str, NULL);
1356
1357 for(i=0; i < EVENTID_LAST; i++) {
1358 nsAString_SetData(&attr_name_str, event_info[i].attr_name);
1359 nsres = nsIDOMElement_GetAttribute(nselem, &attr_name_str, &attr_value_str);
1360 if(NS_SUCCEEDED(nsres)) {
1361 nsAString_GetData(&attr_value_str, &attr_value);
1362 if(!*attr_value)
1363 continue;
1364
1365 TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value));
1366
1367 disp = script_parse_event(doc->basedoc.window, attr_value);
1368 if(disp) {
1369 hres = get_node(doc, (nsIDOMNode*)nselem, TRUE, &node);
1370 if(SUCCEEDED(hres))
1371 set_event_handler_disp(get_node_event_target(node), node->nsnode, node->doc, i, disp);
1372 IDispatch_Release(disp);
1373 }
1374 }
1375 }
1376
1377 nsAString_Finish(&attr_value_str);
1378 nsAString_Finish(&attr_name_str);
1379 }
1380
1381 HRESULT doc_init_events(HTMLDocumentNode *doc)
1382 {
1383 unsigned i;
1384 HRESULT hres;
1385
1386 doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
1387 if(!doc->event_vector)
1388 return E_OUTOFMEMORY;
1389
1390 init_nsevents(doc);
1391
1392 for(i=0; i < EVENTID_LAST; i++) {
1393 if(event_info[i].flags & EVENT_HASDEFAULTHANDLERS) {
1394 hres = ensure_nsevent_handler(doc, NULL, NULL, i);
1395 if(FAILED(hres))
1396 return hres;
1397 }
1398 }
1399
1400 return S_OK;
1401 }
1402
1403 void release_event_target(event_target_t *event_target)
1404 {
1405 int i, j;
1406
1407 for(i=0; i < EVENTID_LAST; i++) {
1408 if(event_target->event_table[i]) {
1409 if(event_target->event_table[i]->handler_prop)
1410 IDispatch_Release(event_target->event_table[i]->handler_prop);
1411 for(j=0; j < event_target->event_table[i]->handler_cnt; j++)
1412 if(event_target->event_table[i]->handlers[j])
1413 IDispatch_Release(event_target->event_table[i]->handlers[j]);
1414 }
1415 }
1416
1417 heap_free(event_target);
1418 }
Windows API implementation