dlls/mshtml/tests/events.c

   1 /*
   2  * Copyright 2008-2011 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 #define COBJMACROS
  20 #define CONST_VTABLE
  21
  22 #include <wine/test.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "mshtml.h"
  30 #include "mshtmdid.h"
  31 #include "docobj.h"
  32 #include "hlink.h"
  33 #include "dispex.h"
  34
  35 #define DEFINE_EXPECT(func) \
  36     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  37
  38 #define SET_EXPECT(func) \
  39     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  40
  41 #define CHECK_EXPECT2(func) \
  42     do { \
  43     trace(#func "\n"); \
  44         ok(expect_ ##func, "unexpected call " #func "\n"); \
  45         called_ ## func = TRUE; \
  46     }while(0)
  47
  48 #define CHECK_EXPECT(func) \
  49     do { \
  50         CHECK_EXPECT2(func); \
  51         expect_ ## func = FALSE; \
  52     }while(0)
  53
  54 #define CHECK_CALLED(func) \
  55     do { \
  56         ok(called_ ## func, "expected " #func "\n"); \
  57         expect_ ## func = called_ ## func = FALSE; \
  58     }while(0)
  59
  60 DEFINE_EXPECT(document_onclick);
  61 DEFINE_EXPECT(body_onclick);
  62 DEFINE_EXPECT(doc_onclick_attached);
  63 DEFINE_EXPECT(div_onclick);
  64 DEFINE_EXPECT(div_onclick_attached);
  65 DEFINE_EXPECT(timeout);
  66 DEFINE_EXPECT(doccp_onclick);
  67 DEFINE_EXPECT(doccp_onclick_cancel);
  68 DEFINE_EXPECT(div_onclick_disp);
  69 DEFINE_EXPECT(invoke_onclick);
  70 DEFINE_EXPECT(iframe_onreadystatechange_loading);
  71 DEFINE_EXPECT(iframe_onreadystatechange_interactive);
  72 DEFINE_EXPECT(iframe_onreadystatechange_complete);
  73 DEFINE_EXPECT(iframedoc_onreadystatechange);
  74 DEFINE_EXPECT(img_onload);
  75 DEFINE_EXPECT(img_onerror);
  76 DEFINE_EXPECT(input_onfocus);
  77 DEFINE_EXPECT(input_onblur);
  78 DEFINE_EXPECT(form_onsubmit);
  79 DEFINE_EXPECT(form_onclick);
  80 DEFINE_EXPECT(submit_onclick);
  81 DEFINE_EXPECT(submit_onclick_cancel);
  82 DEFINE_EXPECT(submit_onclick_attached);
  83 DEFINE_EXPECT(submit_onclick_attached_check_cancel);
  84 DEFINE_EXPECT(submit_onclick_setret);
  85 DEFINE_EXPECT(elem2_cp_onclick);
  86
  87 static HWND container_hwnd = NULL;
  88 static IHTMLWindow2 *window;
  89 static IOleDocumentView *view;
  90 static BOOL xy_todo;
  91
  92 typedef struct {
  93     LONG x;
  94     LONG y;
  95     LONG offset_x;
  96     LONG offset_y;
  97 } xy_test_t;
  98
  99 static const xy_test_t no_xy = {-10,-10,-10,-10};
 100 static const xy_test_t zero_xy = {0,0,0,0};
 101
 102 static const char empty_doc_str[] =
 103     "<html></html>";
 104
 105 static const char click_doc_str[] =
 106     "<html><body>"
 107     "<div id=\"clickdiv\" style=\"text-align: center; background: red; font-size: 32\">click here</div>"
 108     "</body></html>";
 109
 110 static const char readystate_doc_str[] =
 111     "<html><body><iframe id=\"iframe\"></iframe></body></html>";
 112
 113 static const char img_doc_str[] =
 114     "<html><body><img id=\"imgid\"></img></body></html>";
 115
 116 static const char input_doc_str[] =
 117     "<html><body><input id=\"inputid\"></input></body></html>";
 118
 119 static const char iframe_doc_str[] =
 120     "<html><body><iframe id=\"ifr\">Testing</iframe></body></html>";
 121
 122 static const char form_doc_str[] =
 123     "<html><body><form id=\"formid\" method=\"post\" action=\"about:blank\">"
 124     "<input type=\"text\" value=\"test\" name=\"i\"/>"
 125     "<input type=\"submit\" id=\"submitid\" />"
 126     "</form></body></html>";
 127
 128 static int strcmp_wa(LPCWSTR strw, const char *stra)
 129 {
 130     CHAR buf[512];
 131     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 132     return lstrcmpA(stra, buf);
 133 }
 134
 135 static BSTR a2bstr(const char *str)
 136 {
 137     BSTR ret;
 138     int len;
 139
 140     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 141     ret = SysAllocStringLen(NULL, len-1);
 142     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 143
 144     return ret;
 145 }
 146
 147 static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
 148 {
 149     IUnknown *unk1, *unk2;
 150
 151     if(iface1 == iface2)
 152         return TRUE;
 153
 154     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
 155     IUnknown_Release(unk1);
 156     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk2);
 157     IUnknown_Release(unk2);
 158
 159     return unk1 == unk2;
 160 }
 161
 162 #define test_disp(u,id) _test_disp(__LINE__,u,id)
 163 static void _test_disp(unsigned line, IUnknown *unk, const IID *diid)
 164 {
 165     IDispatchEx *dispex;
 166     ITypeInfo *typeinfo;
 167     UINT ticnt;
 168     HRESULT hres;
 169
 170     hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);
 171     ok_(__FILE__,line) (hres == S_OK, "Could not get IDispatch: %08x\n", hres);
 172     if(FAILED(hres))
 173         return;
 174
 175     ticnt = 0xdeadbeef;
 176     hres = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
 177     ok_(__FILE__,line) (hres == S_OK, "GetTypeInfoCount failed: %08x\n", hres);
 178     ok_(__FILE__,line) (ticnt == 1, "ticnt=%u\n", ticnt);
 179
 180     hres = IDispatchEx_GetTypeInfo(dispex, 0, 0, &typeinfo);
 181     ok_(__FILE__,line) (hres == S_OK, "GetTypeInfo failed: %08x\n", hres);
 182
 183     if(SUCCEEDED(hres)) {
 184         TYPEATTR *type_attr;
 185
 186         hres = ITypeInfo_GetTypeAttr(typeinfo, &type_attr);
 187         ok_(__FILE__,line) (hres == S_OK, "GetTypeAttr failed: %08x\n", hres);
 188         ok_(__FILE__,line) (IsEqualGUID(&type_attr->guid, diid), "unexpected guid %s\n",
 189                             wine_dbgstr_guid(&type_attr->guid));
 190
 191         ITypeInfo_ReleaseTypeAttr(typeinfo, type_attr);
 192         ITypeInfo_Release(typeinfo);
 193     }
 194
 195     IDispatchEx_Release(dispex);
 196 }
 197
 198 #define get_doc3_iface(u) _get_doc3_iface(__LINE__,u)
 199 static IHTMLDocument3 *_get_doc3_iface(unsigned line, IUnknown *unk)
 200 {
 201     IHTMLDocument3 *doc3;
 202     HRESULT hres;
 203
 204     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDocument3, (void**)&doc3);
 205     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLDocument3 iface: %08x\n", hres);
 206
 207     return doc3;
 208 }
 209
 210 #define get_elem_iface(u) _get_elem_iface(__LINE__,u)
 211 static IHTMLElement *_get_elem_iface(unsigned line, IUnknown *unk)
 212 {
 213     IHTMLElement *elem;
 214     HRESULT hres;
 215
 216     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement, (void**)&elem);
 217     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement iface: %08x\n", hres);
 218
 219     return elem;
 220 }
 221
 222 #define get_elem2_iface(u) _get_elem2_iface(__LINE__,u)
 223 static IHTMLElement2 *_get_elem2_iface(unsigned line, IUnknown *unk)
 224 {
 225     IHTMLElement2 *elem2;
 226     HRESULT hres;
 227
 228     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement2, (void**)&elem2);
 229     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement2 iface: %08x\n", hres);
 230
 231     return elem2;
 232 }
 233
 234 #define get_elem3_iface(u) _get_elem3_iface(__LINE__,u)
 235 static IHTMLElement3 *_get_elem3_iface(unsigned line, IUnknown *unk)
 236 {
 237     IHTMLElement3 *elem3;
 238     HRESULT hres;
 239
 240     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement3, (void**)&elem3);
 241     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement3 iface: %08x\n", hres);
 242
 243     return elem3;
 244 }
 245
 246 #define doc_get_body(d) _doc_get_body(__LINE__,d)
 247 static IHTMLElement *_doc_get_body(unsigned line, IHTMLDocument2 *doc)
 248 {
 249     IHTMLElement *body = NULL;
 250     HRESULT hres;
 251
 252     hres = IHTMLDocument2_get_body(doc, &body);
 253     ok_(__FILE__,line) (hres == S_OK, "get_body failed: %08x\n", hres);
 254     ok_(__FILE__,line) (body != NULL, "body == NULL\n");
 255
 256     return body;
 257 }
 258
 259 #define get_elem_id(d,i) _get_elem_id(__LINE__,d,i)
 260 static IHTMLElement *_get_elem_id(unsigned line, IHTMLDocument2 *doc, const char *id)
 261 {
 262     IHTMLDocument3 *doc3 = _get_doc3_iface(line, (IUnknown*)doc);
 263     IHTMLElement *elem;
 264     BSTR str;
 265     HRESULT hres;
 266
 267     str = a2bstr(id);
 268     hres = IHTMLDocument3_getElementById(doc3, str, &elem);
 269     SysFreeString(str);
 270     IHTMLDocument3_Release(doc3);
 271     ok_(__FILE__,line) (hres == S_OK, "getElementById failed: %08x\n", hres);
 272
 273     return elem;
 274 }
 275
 276 #define test_elem_tag(u,n) _test_elem_tag(__LINE__,u,n)
 277 static void _test_elem_tag(unsigned line, IUnknown *unk, const char *extag)
 278 {
 279     IHTMLElement *elem = _get_elem_iface(line, unk);
 280     BSTR tag;
 281     HRESULT hres;
 282
 283     hres = IHTMLElement_get_tagName(elem, &tag);
 284     IHTMLElement_Release(elem);
 285     ok_(__FILE__, line) (hres == S_OK, "get_tagName failed: %08x\n", hres);
 286     ok_(__FILE__, line) (!strcmp_wa(tag, extag), "got tag: %s, expected %s\n", wine_dbgstr_w(tag), extag);
 287
 288     SysFreeString(tag);
 289 }
 290
 291 #define get_event_obj() _get_event_obj(__LINE__)
 292 static IHTMLEventObj *_get_event_obj(unsigned line)
 293 {
 294     IHTMLEventObj *event = NULL;
 295     HRESULT hres;
 296
 297     hres = IHTMLWindow2_get_event(window, &event);
 298     ok_(__FILE__,line) (hres == S_OK, "get_event failed: %08x\n", hres);
 299     ok_(__FILE__,line) (event != NULL, "event = NULL\n");
 300     _test_disp(line, (IUnknown*)event, &DIID_DispCEventObj);
 301
 302     return event;
 303 }
 304
 305 #define elem_fire_event(a,b,c) _elem_fire_event(__LINE__,a,b,c)
 306 static void _elem_fire_event(unsigned line, IUnknown *unk, const char *event, VARIANT *evobj)
 307 {
 308     IHTMLElement3 *elem3 = _get_elem3_iface(line, unk);
 309     VARIANT_BOOL b;
 310     BSTR str;
 311     HRESULT hres;
 312
 313     b = 100;
 314     str = a2bstr(event);
 315     hres = IHTMLElement3_fireEvent(elem3, str, evobj, &b);
 316     SysFreeString(str);
 317     ok_(__FILE__,line)(hres == S_OK, "fireEvent failed: %08x\n", hres);
 318     ok_(__FILE__,line)(b == VARIANT_TRUE, "fireEvent returned %x\n", b);
 319 }
 320
 321 #define test_event_args(a,b,c,d,e,f,g) _test_event_args(__LINE__,a,b,c,d,e,f,g)
 322 static void _test_event_args(unsigned line, const IID *dispiid, DISPID id, WORD wFlags, DISPPARAMS *pdp,
 323         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 324 {
 325     ok_(__FILE__,line) (id == DISPID_VALUE, "id = %d\n", id);
 326     ok_(__FILE__,line) (wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 327     ok_(__FILE__,line) (pdp != NULL, "pdp == NULL\n");
 328     ok_(__FILE__,line) (pdp->cArgs == 1, "pdp->cArgs = %d\n", pdp->cArgs);
 329     ok_(__FILE__,line) (pdp->cNamedArgs == 1, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 330     ok_(__FILE__,line) (pdp->rgdispidNamedArgs[0] == DISPID_THIS, "pdp->rgdispidNamedArgs[0] = %d\n",
 331                         pdp->rgdispidNamedArgs[0]);
 332     ok_(__FILE__,line) (V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(rgvarg) = %d\n", V_VT(pdp->rgvarg));
 333     ok_(__FILE__,line) (pvarRes != NULL, "pvarRes == NULL\n");
 334     ok_(__FILE__,line) (pei != NULL, "pei == NULL");
 335     ok_(__FILE__,line) (!pspCaller, "pspCaller != NULL\n");
 336
 337     if(dispiid)
 338         _test_disp(line, (IUnknown*)V_DISPATCH(pdp->rgvarg), dispiid);
 339 }
 340
 341 #define test_attached_event_args(a,b,c,d,e) _test_attached_event_args(__LINE__,a,b,c,d,e)
 342 static void _test_attached_event_args(unsigned line, DISPID id, WORD wFlags, DISPPARAMS *pdp,
 343         VARIANT *pvarRes, EXCEPINFO *pei)
 344 {
 345     IHTMLEventObj *event;
 346
 347     ok(id == DISPID_VALUE, "id = %d\n", id);
 348     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 349     ok(pdp != NULL, "pDispParams == NULL\n");
 350     ok(pdp->cArgs == 1, "pdp->cArgs = %d\n", pdp->cArgs);
 351     ok(!pdp->cNamedArgs, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 352     ok(!pdp->rgdispidNamedArgs, "pdp->rgdispidNamedArgs = %p\n", pdp->rgdispidNamedArgs);
 353     ok(pdp->rgvarg != NULL, "rgvarg = NULL\n");
 354     ok(pvarRes != NULL, "pvarRes = NULL\n");
 355     ok(pei != NULL, "pei = NULL\n");
 356     ok(V_VT(pvarRes) == VT_EMPTY, "V_VT(pVarRes) = %d\n", V_VT(pvarRes));
 357     ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(pdp->rgvarg) = %d\n", V_VT(pdp->rgvarg));
 358     ok(V_DISPATCH(pdp->rgvarg) != NULL, "V_DISPATCH(pdp->rgvarg) = %p\n", V_DISPATCH(pdp->rgvarg));
 359
 360     event = _get_event_obj(line);
 361     ok(iface_cmp((IUnknown*)event, (IUnknown*)V_DISPATCH(pdp->rgvarg)), "event != arg0\n");
 362     IHTMLEventObj_Release(event);
 363 }
 364
 365 #define get_event_src() _get_event_src(__LINE__)
 366 static IHTMLElement *_get_event_src(unsigned line)
 367 {
 368     IHTMLEventObj *event = _get_event_obj(line);
 369     IHTMLElement *src_elem = NULL;
 370     HRESULT hres;
 371
 372     hres = IHTMLEventObj_get_srcElement(event, &src_elem);
 373     IHTMLEventObj_Release(event);
 374     ok_(__FILE__,line) (hres == S_OK, "get_srcElement failed: %08x\n", hres);
 375
 376     return src_elem;
 377 }
 378
 379 #define test_event_src(t) _test_event_src(__LINE__,t)
 380 static void _test_event_src(unsigned line, const char *src_tag)
 381 {
 382     IHTMLElement *src_elem = _get_event_src(line);
 383
 384     if(src_tag) {
 385         ok_(__FILE__,line) (src_elem != NULL, "src_elem = NULL\n");
 386         _test_elem_tag(line, (IUnknown*)src_elem, src_tag);
 387         IHTMLElement_Release(src_elem);
 388     }else {
 389         ok_(__FILE__,line) (!src_elem, "src_elem != NULL\n");
 390     }
 391 }
 392
 393 static void _test_event_altkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 394 {
 395     VARIANT_BOOL b;
 396     HRESULT hres;
 397
 398     hres = IHTMLEventObj_get_altKey(event, &b);
 399     ok_(__FILE__,line)(hres == S_OK, "get_altKey failed: %08x\n", hres);
 400     ok_(__FILE__,line)(b == exval, "altKey = %x, expected %x\n", b, exval);
 401 }
 402
 403 static void _test_event_ctrlkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 404 {
 405     VARIANT_BOOL b;
 406     HRESULT hres;
 407
 408     hres = IHTMLEventObj_get_ctrlKey(event, &b);
 409     ok_(__FILE__,line)(hres == S_OK, "get_ctrlKey failed: %08x\n", hres);
 410     ok_(__FILE__,line)(b == exval, "ctrlKey = %x, expected %x\n", b, exval);
 411 }
 412
 413 static void _test_event_shiftkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 414 {
 415     VARIANT_BOOL b;
 416     HRESULT hres;
 417
 418     hres = IHTMLEventObj_get_shiftKey(event, &b);
 419     ok_(__FILE__,line)(hres == S_OK, "get_shiftKey failed: %08x\n", hres);
 420     ok_(__FILE__,line)(b == exval, "shiftKey = %x, expected %x\n", b, exval);
 421 }
 422
 423 #define test_event_cancelbubble(a,b) _test_event_cancelbubble(__LINE__,a,b)
 424 static void _test_event_cancelbubble(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 425 {
 426     VARIANT_BOOL b;
 427     HRESULT hres;
 428
 429     hres = IHTMLEventObj_get_cancelBubble(event, &b);
 430     ok_(__FILE__,line)(hres == S_OK, "get_cancelBubble failed: %08x\n", hres);
 431     ok_(__FILE__,line)(b == exval, "cancelBubble = %x, expected %x\n", b, exval);
 432 }
 433
 434 static void _test_event_fromelem(unsigned line, IHTMLEventObj *event, const char *from_tag)
 435 {
 436     IHTMLElement *elem;
 437     HRESULT hres;
 438
 439     hres = IHTMLEventObj_get_fromElement(event, &elem);
 440     ok_(__FILE__,line)(hres == S_OK, "get_fromElement failed: %08x\n", hres);
 441     if(from_tag)
 442         _test_elem_tag(line, (IUnknown*)elem, from_tag);
 443     else
 444         ok_(__FILE__,line)(elem == NULL, "fromElement != NULL\n");
 445     if(elem)
 446         IHTMLElement_Release(elem);
 447 }
 448
 449 static void _test_event_toelem(unsigned line, IHTMLEventObj *event, const char *to_tag)
 450 {
 451     IHTMLElement *elem;
 452     HRESULT hres;
 453
 454     hres = IHTMLEventObj_get_toElement(event, &elem);
 455     ok_(__FILE__,line)(hres == S_OK, "get_toElement failed: %08x\n", hres);
 456     if(to_tag)
 457         _test_elem_tag(line, (IUnknown*)elem, to_tag);
 458     else
 459         ok_(__FILE__,line)(elem == NULL, "toElement != NULL\n");
 460     if(elem)
 461         IHTMLElement_Release(elem);
 462 }
 463
 464 static void _test_event_keycode(unsigned line, IHTMLEventObj *event, LONG exl)
 465 {
 466     LONG l;
 467     HRESULT hres;
 468
 469     hres = IHTMLEventObj_get_keyCode(event, &l);
 470     ok_(__FILE__,line)(hres == S_OK, "get_keyCode failed: %08x\n", hres);
 471     ok_(__FILE__,line)(l == exl, "keyCode = %x, expected %x\n", l, exl);
 472 }
 473
 474 static void _test_event_button(unsigned line, IHTMLEventObj *event, LONG exl)
 475 {
 476     LONG l;
 477     HRESULT hres;
 478
 479     hres = IHTMLEventObj_get_button(event, &l);
 480     ok_(__FILE__,line)(hres == S_OK, "get_button failed: %08x\n", hres);
 481     ok_(__FILE__,line)(l == exl, "button = %x, expected %x\n", l, exl);
 482 }
 483
 484 static void _test_event_reason(unsigned line, IHTMLEventObj *event, LONG exl)
 485 {
 486     LONG l;
 487     HRESULT hres;
 488
 489     hres = IHTMLEventObj_get_reason(event, &l);
 490     ok_(__FILE__,line)(hres == S_OK, "get_reason failed: %08x\n", hres);
 491     ok_(__FILE__,line)(l == exl, "reason = %x, expected %x\n", l, exl);
 492 }
 493
 494 static void _test_event_x(unsigned line, IHTMLEventObj *event, LONG exl)
 495 {
 496     LONG l;
 497     HRESULT hres;
 498
 499     hres = IHTMLEventObj_get_x(event, &l);
 500     ok_(__FILE__,line)(hres == S_OK, "get_x failed: %08x\n", hres);
 501     if(exl != -10) /* don't test the exact value */
 502         ok_(__FILE__,line)(l == exl, "x = %d, expected %d\n", l, exl);
 503 }
 504
 505 static void _test_event_y(unsigned line, IHTMLEventObj *event, LONG exl)
 506 {
 507     LONG l;
 508     HRESULT hres;
 509
 510     hres = IHTMLEventObj_get_y(event, &l);
 511     ok_(__FILE__,line)(hres == S_OK, "get_y failed: %08x\n", hres);
 512     if(exl != -10) /* don't test the exact value */
 513         ok_(__FILE__,line)(l == exl, "y = %d, expected %d\n", l, exl);
 514 }
 515
 516 static void _test_event_clientx(unsigned line, IHTMLEventObj *event, LONG exl)
 517 {
 518     LONG l;
 519     HRESULT hres;
 520
 521     hres = IHTMLEventObj_get_clientX(event, &l);
 522     ok_(__FILE__,line)(hres == S_OK, "get_clientX failed: %08x\n", hres);
 523     if(exl != -10) /* don't test the exact value */
 524         ok_(__FILE__,line)(l == exl, "clientX = %d, expected %d\n", l, exl);
 525 }
 526
 527 static void _test_event_clienty(unsigned line, IHTMLEventObj *event, LONG exl)
 528 {
 529     LONG l;
 530     HRESULT hres;
 531
 532     hres = IHTMLEventObj_get_clientY(event, &l);
 533     ok_(__FILE__,line)(hres == S_OK, "get_clientY failed: %08x\n", hres);
 534     if(exl != -10) /* don't test the exact value */
 535         ok_(__FILE__,line)(l == exl, "clientY = %d, expected %d\n", l, exl);
 536 }
 537
 538 static void _test_event_offsetx(unsigned line, IHTMLEventObj *event, LONG exl)
 539 {
 540     LONG l;
 541     HRESULT hres;
 542
 543     hres = IHTMLEventObj_get_offsetX(event, &l);
 544     ok_(__FILE__,line)(hres == S_OK, "get_offsetX failed: %08x\n", hres);
 545     if(exl != -10) /* don't test the exact value */
 546         ok_(__FILE__,line)(l == exl, "offsetX = %d, expected %d\n", l, exl);
 547 }
 548
 549 static void _test_event_offsety(unsigned line, IHTMLEventObj *event, LONG exl)
 550 {
 551     LONG l;
 552     HRESULT hres;
 553
 554     hres = IHTMLEventObj_get_offsetY(event, &l);
 555     ok_(__FILE__,line)(hres == S_OK, "get_offsetY failed: %08x\n", hres);
 556     if(exl != -10) /* don't test the exact value */
 557         ok_(__FILE__,line)(l == exl, "offsetY = %d, expected %d\n", l, exl);
 558 }
 559
 560 static void _test_event_screenx(unsigned line, IHTMLEventObj *event, LONG exl)
 561 {
 562     LONG l;
 563     HRESULT hres;
 564
 565     hres = IHTMLEventObj_get_screenX(event, &l);
 566     ok_(__FILE__,line)(hres == S_OK, "get_screenX failed: %08x\n", hres);
 567     if(exl != -10) /* don't test the exact value */
 568         ok_(__FILE__,line)(l == exl, "screenX = %d, expected %d\n", l, exl);
 569 }
 570
 571 static void _test_event_screeny(unsigned line, IHTMLEventObj *event, LONG exl)
 572 {
 573     LONG l;
 574     HRESULT hres;
 575
 576     hres = IHTMLEventObj_get_screenY(event, &l);
 577     ok_(__FILE__,line)(hres == S_OK, "get_screenY failed: %08x\n", hres);
 578     if(exl != -10) /* don't test the exact value for -10 */
 579         ok_(__FILE__,line)(l == exl, "screenY = %d, expected %d\n", l, exl);
 580 }
 581
 582 static void _test_event_type(unsigned line, IHTMLEventObj *event, const char *exstr)
 583 {
 584     BSTR str;
 585     HRESULT hres;
 586
 587     hres = IHTMLEventObj_get_type(event, &str);
 588     ok_(__FILE__,line)(hres == S_OK, "get_type failed: %08x\n", hres);
 589     ok_(__FILE__,line)(!strcmp_wa(str, exstr), "type = %s, expected %s\n", wine_dbgstr_w(str), exstr);
 590 }
 591
 592 static void _test_event_qualifier(unsigned line, IHTMLEventObj *event, const char *exstr)
 593 {
 594     BSTR str;
 595     HRESULT hres;
 596
 597     hres = IHTMLEventObj_get_qualifier(event, &str);
 598     ok_(__FILE__,line)(hres == S_OK, "get_qualifier failed: %08x\n", hres);
 599     if(exstr)
 600         ok_(__FILE__,line)(!strcmp_wa(str, exstr), "qualifier = %s, expected %s\n", wine_dbgstr_w(str), exstr);
 601     else
 602         ok_(__FILE__,line)(!str, "qualifier != NULL\n");
 603 }
 604
 605 static void _test_event_srcfilter(unsigned line, IHTMLEventObj *event)
 606 {
 607     IDispatch *disp;
 608     HRESULT hres;
 609
 610     hres = IHTMLEventObj_get_srcFilter(event, &disp);
 611     ok_(__FILE__,line)(hres == S_OK, "get_srcFilter failed: %08x\n", hres);
 612     ok_(__FILE__,line)(!disp, "srcFilter != NULL\n");
 613 }
 614
 615 #define test_event_obj(t,x) _test_event_obj(__LINE__,t,x)
 616 static void _test_event_obj(unsigned line, const char *type, const xy_test_t *xy)
 617 {
 618     IHTMLEventObj *event = _get_event_obj(line);
 619     VARIANT v;
 620     HRESULT hres;
 621
 622     _test_event_altkey(line, event, VARIANT_FALSE);
 623     _test_event_ctrlkey(line, event, VARIANT_FALSE);
 624     _test_event_shiftkey(line, event, VARIANT_FALSE);
 625     _test_event_cancelbubble(line, event, VARIANT_FALSE);
 626     _test_event_fromelem(line, event, NULL);
 627     _test_event_toelem(line, event, NULL);
 628     _test_event_keycode(line, event, 0);
 629     _test_event_button(line, event, 0);
 630     _test_event_type(line, event, type);
 631     _test_event_qualifier(line, event, NULL);
 632     _test_event_reason(line, event, 0);
 633     _test_event_srcfilter(line, event);
 634     _test_event_x(line, event, xy->x);
 635     _test_event_y(line, event, xy->y);
 636     _test_event_clientx(line, event, -10);
 637     _test_event_clienty(line, event, -10);
 638     _test_event_offsetx(line, event, xy->offset_x);
 639     _test_event_offsety(line, event, xy->offset_y);
 640     _test_event_screenx(line, event, -10);
 641     _test_event_screeny(line, event, -10);
 642
 643     V_VT(&v) = VT_NULL;
 644     hres = IHTMLEventObj_get_returnValue(event, &v);
 645     ok_(__FILE__,line)(hres == S_OK, "get_returnValue failed: %08x\n", hres);
 646     ok_(__FILE__,line)(V_VT(&v) == VT_EMPTY, "V_VT(returnValue) = %d\n", V_VT(&v));
 647
 648     IHTMLEventObj_Release(event);
 649 }
 650
 651 #define elem_attach_event(a,b,c) _elem_attach_event(__LINE__,a,b,c)
 652 static void _elem_attach_event(unsigned line, IUnknown *unk, const char *namea, IDispatch *disp)
 653 {
 654     IHTMLElement2 *elem = _get_elem2_iface(line, unk);
 655     VARIANT_BOOL res;
 656     BSTR name;
 657     HRESULT hres;
 658
 659     name = a2bstr(namea);
 660     hres = IHTMLElement2_attachEvent(elem, name, disp, &res);
 661     IHTMLElement2_Release(elem);
 662     SysFreeString(name);
 663     ok_(__FILE__,line)(hres == S_OK, "attachEvent failed: %08x\n", hres);
 664     ok_(__FILE__,line)(res == VARIANT_TRUE, "attachEvent returned %x\n", res);
 665 }
 666
 667 #define elem_detach_event(a,b,c) _elem_detach_event(__LINE__,a,b,c)
 668 static void _elem_detach_event(unsigned line, IUnknown *unk, const char *namea, IDispatch *disp)
 669 {
 670     IHTMLElement2 *elem = _get_elem2_iface(line, unk);
 671     BSTR name;
 672     HRESULT hres;
 673
 674     name = a2bstr(namea);
 675     hres = IHTMLElement2_detachEvent(elem, name, disp);
 676     IHTMLElement2_Release(elem);
 677     SysFreeString(name);
 678     ok_(__FILE__,line)(hres == S_OK, "detachEvent failed: %08x\n", hres);
 679 }
 680
 681 #define doc_attach_event(a,b,c) _doc_attach_event(__LINE__,a,b,c)
 682 static void _doc_attach_event(unsigned line, IHTMLDocument2 *doc, const char *namea, IDispatch *disp)
 683 {
 684     IHTMLDocument3 *doc3 = _get_doc3_iface(line, (IUnknown*)doc);
 685     VARIANT_BOOL res;
 686     BSTR name;
 687     HRESULT hres;
 688
 689     name = a2bstr(namea);
 690     hres = IHTMLDocument3_attachEvent(doc3, name, disp, &res);
 691     IHTMLDocument3_Release(doc3);
 692     SysFreeString(name);
 693     ok_(__FILE__,line)(hres == S_OK, "attachEvent failed: %08x\n", hres);
 694     ok_(__FILE__,line)(res == VARIANT_TRUE, "attachEvent returned %x\n", res);
 695 }
 696
 697 #define doc_detach_event(a,b,c) _doc_detach_event(__LINE__,a,b,c)
 698 static void _doc_detach_event(unsigned line, IHTMLDocument2 *doc, const char *namea, IDispatch *disp)
 699 {
 700     IHTMLDocument3 *doc3 = _get_doc3_iface(line, (IUnknown*)doc);
 701     BSTR name;
 702     HRESULT hres;
 703
 704     name = a2bstr(namea);
 705     hres = IHTMLDocument3_detachEvent(doc3, name, disp);
 706     IHTMLDocument3_Release(doc3);
 707     SysFreeString(name);
 708     ok_(__FILE__,line)(hres == S_OK, "detachEvent failed: %08x\n", hres);
 709 }
 710
 711 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 712 {
 713     *ppv = NULL;
 714
 715     if(IsEqualGUID(riid, &IID_IUnknown)
 716        || IsEqualGUID(riid, &IID_IDispatch)
 717        || IsEqualGUID(riid, &IID_IDispatchEx))
 718         *ppv = iface;
 719     else {
 720         ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
 721         return E_NOINTERFACE;
 722     }
 723
 724     return S_OK;
 725 }
 726
 727 static HRESULT WINAPI Dispatch_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 728 {
 729     *ppv = NULL;
 730
 731     if(IsEqualGUID(riid, &IID_IUnknown)
 732        || IsEqualGUID(riid, &IID_IDispatch)) {
 733         *ppv = iface;
 734     }else if(IsEqualGUID(riid, &IID_IDispatchEx)) {
 735         return E_NOINTERFACE;
 736     }else {
 737         ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
 738         return E_NOINTERFACE;
 739     }
 740
 741     return S_OK;
 742 }
 743
 744 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 745 {
 746     return 2;
 747 }
 748
 749 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 750 {
 751     return 1;
 752 }
 753
 754 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 755 {
 756     ok(0, "unexpected call\n");
 757     return E_NOTIMPL;
 758 }
 759
 760 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 761                                               LCID lcid, ITypeInfo **ppTInfo)
 762 {
 763     ok(0, "unexpected call\n");
 764     return E_NOTIMPL;
 765 }
 766
 767 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 768                                                 LPOLESTR *rgszNames, UINT cNames,
 769                                                 LCID lcid, DISPID *rgDispId)
 770 {
 771     ok(0, "unexpected call\n");
 772     return E_NOTIMPL;
 773 }
 774
 775 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 776                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 777                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 778 {
 779     ok(0, "unexpected call\n");
 780     return E_NOTIMPL;
 781 }
 782
 783 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 784 {
 785     ok(0, "unexpected call\n");
 786     return E_NOTIMPL;
 787 }
 788
 789 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 790         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 791 {
 792     ok(0, "unexpected call\n");
 793     return E_NOTIMPL;
 794 }
 795
 796 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 797 {
 798     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 799     return E_NOTIMPL;
 800 }
 801
 802 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 803 {
 804     ok(0, "unexpected call\n");
 805     return E_NOTIMPL;
 806 }
 807
 808 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 809 {
 810     ok(0, "unexpected call\n");
 811     return E_NOTIMPL;
 812 }
 813
 814 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 815 {
 816     ok(0, "unexpected call\n");
 817     return E_NOTIMPL;
 818 }
 819
 820 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 821 {
 822     ok(0, "unexpected call\n");
 823     return E_NOTIMPL;
 824 }
 825
 826 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 827 {
 828     ok(0, "unexpected call\n");
 829     return E_NOTIMPL;
 830 }
 831
 832 #define EVENT_HANDLER_FUNC_OBJ(event) \
 833     static IDispatchExVtbl event ## FuncVtbl = { \
 834         DispatchEx_QueryInterface, \
 835         DispatchEx_AddRef, \
 836         DispatchEx_Release, \
 837         DispatchEx_GetTypeInfoCount, \
 838         DispatchEx_GetTypeInfo, \
 839         DispatchEx_GetIDsOfNames, \
 840         DispatchEx_Invoke, \
 841         DispatchEx_GetDispID, \
 842         event, \
 843         DispatchEx_DeleteMemberByName, \
 844         DispatchEx_DeleteMemberByDispID, \
 845         DispatchEx_GetMemberProperties, \
 846         DispatchEx_GetMemberName, \
 847         DispatchEx_GetNextDispID, \
 848         DispatchEx_GetNameSpaceParent \
 849     }; \
 850     static IDispatchEx event ## _obj = { &event ## FuncVtbl };
 851
 852 static HRESULT WINAPI document_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 853         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 854 {
 855     IHTMLDocument3 *doc3;
 856     CHECK_EXPECT(document_onclick);
 857     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 858     doc3 = get_doc3_iface((IUnknown*)V_DISPATCH(pdp->rgvarg));
 859     IHTMLDocument3_Release(doc3);
 860     test_event_src("DIV");
 861     test_event_obj("click", &no_xy);
 862     return S_OK;
 863 }
 864
 865 EVENT_HANDLER_FUNC_OBJ(document_onclick);
 866
 867 static HRESULT WINAPI div_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 868         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 869 {
 870     CHECK_EXPECT(div_onclick);
 871     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 872     test_event_src("DIV");
 873     return S_OK;
 874 }
 875
 876 EVENT_HANDLER_FUNC_OBJ(div_onclick);
 877
 878 static HRESULT WINAPI div_onclick_attached(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 879         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 880 {
 881     CHECK_EXPECT(div_onclick_attached);
 882
 883     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
 884     test_event_src("DIV");
 885     return S_OK;
 886 }
 887
 888 EVENT_HANDLER_FUNC_OBJ(div_onclick_attached);
 889
 890 static HRESULT WINAPI doc_onclick_attached(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 891         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 892 {
 893     CHECK_EXPECT(doc_onclick_attached);
 894
 895     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
 896     test_event_src("DIV");
 897     return S_OK;
 898 }
 899
 900 EVENT_HANDLER_FUNC_OBJ(doc_onclick_attached);
 901
 902 static HRESULT WINAPI body_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 903         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 904 {
 905     CHECK_EXPECT(body_onclick);
 906     test_event_args(&DIID_DispHTMLBody, id, wFlags, pdp, pvarRes, pei, pspCaller);
 907     test_event_src("DIV");
 908     return S_OK;
 909 }
 910
 911 EVENT_HANDLER_FUNC_OBJ(body_onclick);
 912
 913 static HRESULT WINAPI img_onload(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 914         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 915 {
 916     CHECK_EXPECT(img_onload);
 917     test_event_args(&DIID_DispHTMLImg, id, wFlags, pdp, pvarRes, pei, pspCaller);
 918     test_event_src("IMG");
 919     return S_OK;
 920 }
 921
 922 EVENT_HANDLER_FUNC_OBJ(img_onload);
 923
 924 static HRESULT WINAPI img_onerror(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 925         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 926 {
 927     CHECK_EXPECT(img_onerror);
 928     test_event_args(&DIID_DispHTMLImg, id, wFlags, pdp, pvarRes, pei, pspCaller);
 929     test_event_src("IMG");
 930     return S_OK;
 931 }
 932
 933 EVENT_HANDLER_FUNC_OBJ(img_onerror);
 934
 935 static HRESULT WINAPI input_onfocus(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 936         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 937 {
 938     CHECK_EXPECT(input_onfocus);
 939     test_event_args(&DIID_DispHTMLInputElement, id, wFlags, pdp, pvarRes, pei, pspCaller);
 940     test_event_src("INPUT");
 941     return S_OK;
 942 }
 943
 944 EVENT_HANDLER_FUNC_OBJ(input_onfocus);
 945
 946 static HRESULT WINAPI input_onblur(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 947         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 948 {
 949     CHECK_EXPECT(input_onblur);
 950     test_event_args(&DIID_DispHTMLInputElement, id, wFlags, pdp, pvarRes, pei, pspCaller);
 951     test_event_src("INPUT");
 952     return S_OK;
 953 }
 954
 955 EVENT_HANDLER_FUNC_OBJ(input_onblur);
 956
 957 static HRESULT WINAPI form_onsubmit(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 958         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 959 {
 960     CHECK_EXPECT(form_onsubmit);
 961     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 962     test_event_src("FORM");
 963
 964     V_VT(pvarRes) = VT_BOOL;
 965     V_BOOL(pvarRes) = VARIANT_FALSE;
 966     return S_OK;
 967 }
 968
 969 EVENT_HANDLER_FUNC_OBJ(form_onsubmit);
 970
 971 static HRESULT WINAPI form_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 972         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 973 {
 974     CHECK_EXPECT(form_onclick);
 975     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 976
 977     return S_OK;
 978 }
 979
 980 EVENT_HANDLER_FUNC_OBJ(form_onclick);
 981
 982 static HRESULT WINAPI submit_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 983         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 984 {
 985     CHECK_EXPECT(submit_onclick);
 986     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 987     test_event_src("INPUT");
 988
 989     V_VT(pvarRes) = VT_BOOL;
 990     V_BOOL(pvarRes) = VARIANT_FALSE;
 991     return S_OK;
 992 }
 993
 994 EVENT_HANDLER_FUNC_OBJ(submit_onclick);
 995
 996 static HRESULT WINAPI submit_onclick_attached(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 997         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 998 {
 999     CHECK_EXPECT(submit_onclick_attached);
1000     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
1001     test_event_src("INPUT");
1002
1003     V_VT(pvarRes) = VT_BOOL;
1004     V_BOOL(pvarRes) = VARIANT_FALSE;
1005     return S_OK;
1006 }
1007
1008 EVENT_HANDLER_FUNC_OBJ(submit_onclick_attached);
1009
1010 static HRESULT WINAPI submit_onclick_attached_check_cancel(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1011         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1012 {
1013     IHTMLEventObj *event;
1014     HRESULT hres;
1015
1016     CHECK_EXPECT(submit_onclick_attached_check_cancel);
1017     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
1018     test_event_src("INPUT");
1019
1020     event = NULL;
1021     hres = IHTMLWindow2_get_event(window, &event);
1022     ok(hres == S_OK, "get_event failed: %08x\n", hres);
1023     ok(event != NULL, "event == NULL\n");
1024
1025     test_event_cancelbubble(event, VARIANT_TRUE);
1026     return S_OK;
1027 }
1028
1029 EVENT_HANDLER_FUNC_OBJ(submit_onclick_attached_check_cancel);
1030
1031 static VARIANT onclick_retval, onclick_event_retval;
1032
1033 static HRESULT WINAPI submit_onclick_setret(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1034         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1035 {
1036     IHTMLEventObj *event;
1037     HRESULT hres;
1038
1039     CHECK_EXPECT(submit_onclick_setret);
1040     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
1041     test_event_src("INPUT");
1042
1043     event = NULL;
1044     hres = IHTMLWindow2_get_event(window, &event);
1045     ok(hres == S_OK, "get_event failed: %08x\n", hres);
1046     ok(event != NULL, "event == NULL\n");
1047
1048     hres = IHTMLEventObj_put_returnValue(event, onclick_event_retval);
1049     ok(hres == S_OK, "put_returnValue failed: %08x\n", hres);
1050     IHTMLEventObj_Release(event);
1051
1052     *pvarRes = onclick_retval;
1053     return S_OK;
1054 }
1055
1056 EVENT_HANDLER_FUNC_OBJ(submit_onclick_setret);
1057
1058 static HRESULT WINAPI submit_onclick_cancel(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1059         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1060 {
1061     IHTMLEventObj *event;
1062     HRESULT hres;
1063
1064     CHECK_EXPECT(submit_onclick_cancel);
1065     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
1066     test_event_src("INPUT");
1067
1068     event = NULL;
1069     hres = IHTMLWindow2_get_event(window, &event);
1070     ok(hres == S_OK, "get_event failed: %08x\n", hres);
1071     ok(event != NULL, "event == NULL\n");
1072
1073     test_event_cancelbubble(event, VARIANT_FALSE);
1074
1075     hres = IHTMLEventObj_put_cancelBubble(event, VARIANT_TRUE);
1076     ok(hres == S_OK, "put_returnValue failed: %08x\n", hres);
1077     IHTMLEventObj_Release(event);
1078
1079     test_event_cancelbubble(event, VARIANT_TRUE);
1080     return S_OK;
1081 }
1082
1083 EVENT_HANDLER_FUNC_OBJ(submit_onclick_cancel);
1084
1085 static HRESULT WINAPI iframedoc_onreadystatechange(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1086         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1087 {
1088     IHTMLEventObj *event = NULL;
1089     HRESULT hres;
1090
1091     CHECK_EXPECT2(iframedoc_onreadystatechange);
1092     test_event_args(&DIID_DispHTMLDocument, id, wFlags, pdp, pvarRes, pei, pspCaller);
1093
1094     event = (void*)0xdeadbeef;
1095     hres = IHTMLWindow2_get_event(window, &event);
1096     ok(hres == S_OK, "get_event failed: %08x\n", hres);
1097     ok(!event, "event = %p\n", event);
1098
1099     return S_OK;
1100 }
1101
1102 EVENT_HANDLER_FUNC_OBJ(iframedoc_onreadystatechange);
1103
1104 static HRESULT WINAPI iframe_onreadystatechange(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1105         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1106 {
1107     IHTMLWindow2 *iframe_window;
1108     IHTMLDocument2 *iframe_doc;
1109     IHTMLFrameBase2 *iframe;
1110     IHTMLElement2 *elem2;
1111     IHTMLElement *elem;
1112     VARIANT v;
1113     BSTR str, str2;
1114     HRESULT hres;
1115
1116     test_event_args(&DIID_DispHTMLIFrame, id, wFlags, pdp, pvarRes, pei, pspCaller);
1117     test_event_src("IFRAME");
1118
1119     elem = get_event_src();
1120     elem2 = get_elem2_iface((IUnknown*)elem);
1121     IHTMLElement_Release(elem);
1122
1123     V_VT(&v) = VT_EMPTY;
1124     hres = IHTMLElement2_get_readyState(elem2, &v);
1125     ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
1126     ok(V_VT(&v) == VT_BSTR, "V_VT(readyState) = %d\n", V_VT(&v));
1127
1128     hres = IHTMLElement2_QueryInterface(elem2, &IID_IHTMLFrameBase2, (void**)&iframe);
1129     IHTMLElement2_Release(elem2);
1130     ok(hres == S_OK, "Could not get IHTMLFrameBase2 iface: %08x\n", hres);
1131
1132     str = NULL;
1133     hres = IHTMLFrameBase2_get_readyState(iframe, &str);
1134     ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
1135     ok(str != NULL, "readyState == NULL\n");
1136     ok(!lstrcmpW(str, V_BSTR(&v)), "ready states differ\n");
1137     VariantClear(&v);
1138
1139     hres = IHTMLFrameBase2_get_contentWindow(iframe, &iframe_window);
1140     ok(hres == S_OK, "get_contentDocument failed: %08x\n", hres);
1141
1142     hres = IHTMLWindow2_get_document(iframe_window, &iframe_doc);
1143     IHTMLWindow2_Release(iframe_window);
1144     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1145
1146     hres = IHTMLDocument2_get_readyState(iframe_doc, &str2);
1147     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1148     ok(!lstrcmpW(str, str2), "unexpected document readyState %s\n", wine_dbgstr_w(str2));
1149     SysFreeString(str2);
1150
1151     if(!strcmp_wa(str, "loading")) {
1152         CHECK_EXPECT(iframe_onreadystatechange_loading);
1153
1154         V_VT(&v) = VT_DISPATCH;
1155         V_DISPATCH(&v) = (IDispatch*)&iframedoc_onreadystatechange_obj;
1156         hres = IHTMLDocument2_put_onreadystatechange(iframe_doc, v);
1157         ok(hres == S_OK, "put_onreadystatechange: %08x\n", hres);
1158     }else if(!strcmp_wa(str, "interactive"))
1159         CHECK_EXPECT(iframe_onreadystatechange_interactive);
1160     else if(!strcmp_wa(str, "complete"))
1161         CHECK_EXPECT(iframe_onreadystatechange_complete);
1162     else
1163         ok(0, "unexpected state %s\n", wine_dbgstr_w(str));
1164
1165     SysFreeString(str);
1166     IHTMLDocument2_Release(iframe_doc);
1167     IHTMLFrameBase2_Release(iframe);
1168     return S_OK;
1169 }
1170
1171 EVENT_HANDLER_FUNC_OBJ(iframe_onreadystatechange);
1172
1173 static HRESULT WINAPI nocall(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1174         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1175 {
1176     ok(0, "unexpected call\n");
1177     return S_OK;
1178 }
1179
1180 EVENT_HANDLER_FUNC_OBJ(nocall);
1181
1182 #define CONNECTION_POINT_OBJ(cpname, diid) \
1183     static HRESULT WINAPI cpname ## _QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv) \
1184     { \
1185         *ppv = NULL; \
1186         if(IsEqualGUID(riid, &IID_IUnknown) \
1187            || IsEqualGUID(riid, &IID_IDispatch) \
1188            || IsEqualGUID(riid, &diid)) \
1189             *ppv = iface; \
1190         else { \
1191             ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid)); \
1192             return E_NOINTERFACE; \
1193         } \
1194         return S_OK; \
1195     } \
1196     static IDispatchExVtbl cpname ## Vtbl = { \
1197         cpname ## _QueryInterface, \
1198         DispatchEx_AddRef,  \
1199         DispatchEx_Release, \
1200         DispatchEx_GetTypeInfoCount, \
1201         DispatchEx_GetTypeInfo, \
1202         DispatchEx_GetIDsOfNames, \
1203         cpname, \
1204         DispatchEx_GetDispID, \
1205         DispatchEx_InvokeEx, \
1206         DispatchEx_DeleteMemberByName, \
1207         DispatchEx_DeleteMemberByDispID, \
1208         DispatchEx_GetMemberProperties, \
1209         DispatchEx_GetMemberName, \
1210         DispatchEx_GetNextDispID, \
1211         DispatchEx_GetNameSpaceParent \
1212     }; \
1213     static IDispatchEx cpname ## _obj = { &cpname ## Vtbl }
1214
1215 #define test_cp_args(a,b,c,d,e,f) _test_cp_args(__LINE__,a,b,c,d,e,f)
1216 static void _test_cp_args(unsigned line, REFIID riid, WORD flags, DISPPARAMS *dp, VARIANT *vres, EXCEPINFO *ei, UINT *argerr)
1217 {
1218     ok_(__FILE__,line)(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", wine_dbgstr_guid(riid));
1219     ok_(__FILE__,line)(flags == DISPATCH_METHOD, "flags = %x\n", flags);
1220     ok_(__FILE__,line)(dp != NULL, "dp == NULL\n");
1221     ok_(__FILE__,line)(!dp->cArgs, "dp->cArgs = %d\n", dp->cArgs);
1222     ok_(__FILE__,line)(!dp->rgvarg, "dp->rgvarg = %p\n", dp->rgvarg);
1223     ok_(__FILE__,line)(!dp->cNamedArgs, "dp->cNamedArgs = %d\n", dp->cNamedArgs);
1224     ok_(__FILE__,line)(!dp->rgdispidNamedArgs, "dp->rgdispidNamedArgs = %p\n", dp->rgdispidNamedArgs);
1225     ok_(__FILE__,line)(vres != NULL, "vres == NULL\n");
1226     ok_(__FILE__,line)(V_VT(vres) == VT_EMPTY, "V_VT(vres) = %d\n", V_VT(vres));
1227     ok_(__FILE__,line)(ei != NULL, "ei == NULL\n");
1228     ok_(__FILE__,line)(argerr != NULL, "argerr == NULL\n");
1229 }
1230
1231 #define test_cp_eventarg(a,b,c,d,e,f) _test_cp_eventarg(__LINE__,a,b,c,d,e,f)
1232 static void _test_cp_eventarg(unsigned line, REFIID riid, WORD flags, DISPPARAMS *dp, VARIANT *vres, EXCEPINFO *ei, UINT *argerr)
1233 {
1234     IHTMLEventObj *event;
1235
1236     ok_(__FILE__,line)(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", wine_dbgstr_guid(riid));
1237     ok_(__FILE__,line)(flags == DISPATCH_METHOD, "flags = %x\n", flags);
1238     ok_(__FILE__,line)(dp != NULL, "dp == NULL\n");
1239     ok_(__FILE__,line)(dp->cArgs == 1, "dp->cArgs = %d\n", dp->cArgs);
1240     ok_(__FILE__,line)(dp->rgvarg != NULL, "dp->rgvarg = %p\n", dp->rgvarg);
1241     ok_(__FILE__,line)(!dp->cNamedArgs, "dp->cNamedArgs = %d\n", dp->cNamedArgs);
1242     ok_(__FILE__,line)(!dp->rgdispidNamedArgs, "dp->rgdispidNamedArgs = %p\n", dp->rgdispidNamedArgs);
1243     ok_(__FILE__,line)(vres != NULL, "vres == NULL\n");
1244     ok_(__FILE__,line)(V_VT(vres) == VT_EMPTY, "V_VT(vres) = %d\n", V_VT(vres));
1245     ok_(__FILE__,line)(ei != NULL, "ei == NULL\n");
1246     ok_(__FILE__,line)(argerr != NULL, "argerr == NULL\n");
1247
1248     ok(V_VT(dp->rgvarg) == VT_DISPATCH, "V_VT(dp->rgvarg) = %d\n", V_VT(dp->rgvarg));
1249     ok(V_DISPATCH(dp->rgvarg) != NULL, "V_DISPATCH(dp->rgvarg) = %p\n", V_DISPATCH(dp->rgvarg));
1250
1251     event = _get_event_obj(line);
1252     ok(iface_cmp((IUnknown*)event, (IUnknown*)V_DISPATCH(dp->rgvarg)), "event != arg0\n");
1253     IHTMLEventObj_Release(event);
1254 }
1255
1256 static HRESULT WINAPI doccp(IDispatchEx *iface, DISPID dispIdMember,
1257                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1258                             VARIANT *pVarResult, EXCEPINFO *pei, UINT *puArgErr)
1259 {
1260     switch(dispIdMember) {
1261     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
1262         CHECK_EXPECT(doccp_onclick);
1263         test_cp_args(riid, wFlags, pdp, pVarResult, pei, puArgErr);
1264         break;
1265     default:
1266         ok(0, "unexpected call %d\n", dispIdMember);
1267         return E_NOTIMPL;
1268     }
1269
1270     return S_OK;
1271 }
1272
1273 CONNECTION_POINT_OBJ(doccp, DIID_HTMLDocumentEvents);
1274
1275 static HRESULT WINAPI doccp_onclick_cancel(IDispatchEx *iface, DISPID dispIdMember,
1276         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pVarResult, EXCEPINFO *pei, UINT *puArgErr)
1277 {
1278     switch(dispIdMember) {
1279     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
1280         CHECK_EXPECT(doccp_onclick_cancel);
1281         test_cp_args(riid, wFlags, pdp, pVarResult, pei, puArgErr);
1282         V_VT(pVarResult) = VT_BOOL;
1283         V_BOOL(pVarResult) = VARIANT_FALSE;
1284         break;
1285     default:
1286         ok(0, "unexpected call %d\n", dispIdMember);
1287         return E_NOTIMPL;
1288     }
1289
1290     return S_OK;
1291 }
1292
1293 CONNECTION_POINT_OBJ(doccp_onclick_cancel, DIID_HTMLDocumentEvents);
1294
1295 static HRESULT WINAPI elem2_cp(IDispatchEx *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
1296         WORD wFlags, DISPPARAMS *pdp, VARIANT *pVarResult, EXCEPINFO *pei, UINT *puArgErr)
1297 {
1298     switch(dispIdMember) {
1299     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
1300         CHECK_EXPECT(elem2_cp_onclick);
1301         test_cp_eventarg(riid, wFlags, pdp, pVarResult, pei, puArgErr);
1302         break;
1303     default:
1304         ok(0, "unexpected call %d\n", dispIdMember);
1305         return E_NOTIMPL;
1306     }
1307
1308     return S_OK;
1309 }
1310
1311 CONNECTION_POINT_OBJ(elem2_cp, DIID_HTMLElementEvents2);
1312
1313 static HRESULT WINAPI timeoutFunc_Invoke(IDispatchEx *iface, DISPID dispIdMember,
1314                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1315                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1316 {
1317     CHECK_EXPECT(timeout);
1318
1319     ok(dispIdMember == DISPID_VALUE, "dispIdMember = %d\n", dispIdMember);
1320     ok(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", wine_dbgstr_guid(riid));
1321     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
1322     ok(!lcid, "lcid = %x\n", lcid);
1323     ok(pDispParams != NULL, "pDispParams == NULL\n");
1324     ok(!pDispParams->cArgs, "pdp->cArgs = %d\n", pDispParams->cArgs);
1325     ok(!pDispParams->cNamedArgs, "pdp->cNamedArgs = %d\n", pDispParams->cNamedArgs);
1326     ok(!pDispParams->rgdispidNamedArgs, "pdp->rgdispidNamedArgs = %p\n", pDispParams->rgdispidNamedArgs);
1327     ok(!pDispParams->rgvarg, "rgvarg = %p\n", pDispParams->rgvarg);
1328     ok(pVarResult != NULL, "pVarResult = NULL\n");
1329     ok(pExcepInfo != NULL, "pExcepInfo = NULL\n");
1330     ok(!puArgErr, "puArgErr = %p\n", puArgErr);
1331     ok(V_VT(pVarResult) == VT_EMPTY, "V_VT(pVarResult) = %d\n", V_VT(pVarResult));
1332
1333     return S_OK;
1334 }
1335
1336 static const IDispatchExVtbl timeoutFuncVtbl = {
1337     DispatchEx_QueryInterface,
1338     DispatchEx_AddRef,
1339     DispatchEx_Release,
1340     DispatchEx_GetTypeInfoCount,
1341     DispatchEx_GetTypeInfo,
1342     DispatchEx_GetIDsOfNames,
1343     timeoutFunc_Invoke,
1344     DispatchEx_GetDispID,
1345     DispatchEx_InvokeEx,
1346     DispatchEx_DeleteMemberByName,
1347     DispatchEx_DeleteMemberByDispID,
1348     DispatchEx_GetMemberProperties,
1349     DispatchEx_GetMemberName,
1350     DispatchEx_GetNextDispID,
1351     DispatchEx_GetNameSpaceParent
1352 };
1353
1354 static IDispatchEx timeoutFunc = { &timeoutFuncVtbl };
1355
1356 static HRESULT WINAPI div_onclick_disp_Invoke(IDispatchEx *iface, DISPID id,
1357         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1358         VARIANT *pvarRes, EXCEPINFO *pei, UINT *puArgErr)
1359 {
1360     CHECK_EXPECT(div_onclick_disp);
1361
1362     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
1363
1364     ok(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", wine_dbgstr_guid(riid));
1365     ok(!puArgErr, "puArgErr = %p\n", puArgErr);
1366
1367     return S_OK;
1368 }
1369
1370 static const IDispatchExVtbl div_onclick_dispVtbl = {
1371     Dispatch_QueryInterface,
1372     DispatchEx_AddRef,
1373     DispatchEx_Release,
1374     DispatchEx_GetTypeInfoCount,
1375     DispatchEx_GetTypeInfo,
1376     DispatchEx_GetIDsOfNames,
1377     div_onclick_disp_Invoke,
1378 };
1379
1380 static IDispatchEx div_onclick_disp = { &div_onclick_dispVtbl };
1381
1382 static void pump_msgs(BOOL *b)
1383 {
1384     MSG msg;
1385
1386     if(b) {
1387         while(!*b && GetMessageW(&msg, NULL, 0, 0)) {
1388             TranslateMessage(&msg);
1389             DispatchMessageW(&msg);
1390         }
1391     }else {
1392         while(!b && PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE)) {
1393             TranslateMessage(&msg);
1394             DispatchMessageW(&msg);
1395         }
1396     }
1397 }
1398
1399 static IConnectionPoint *get_cp(IUnknown *unk, REFIID riid)
1400 {
1401     IConnectionPointContainer *cp_container;
1402     IConnectionPoint *cp;
1403     HRESULT hres;
1404
1405     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&cp_container);
1406     ok(hres == S_OK, "Could not get IConnectionPointContainer: %08x\n", hres);
1407
1408     hres = IConnectionPointContainer_FindConnectionPoint(cp_container, riid, &cp);
1409     IConnectionPointContainer_Release(cp_container);
1410     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
1411
1412     return cp;
1413 }
1414
1415 static DWORD register_cp(IUnknown *unk, REFIID riid, IUnknown *sink)
1416 {
1417     IConnectionPoint *cp;
1418     DWORD cookie;
1419     HRESULT hres;
1420
1421     cp = get_cp(unk, riid);
1422     hres = IConnectionPoint_Advise(cp, sink, &cookie);
1423     IConnectionPoint_Release(cp);
1424     ok(hres == S_OK, "Advise failed: %08x\n", hres);
1425
1426     return cookie;
1427 }
1428
1429 static void unregister_cp(IUnknown *unk, REFIID riid, DWORD cookie)
1430 {
1431     IConnectionPoint *cp;
1432     HRESULT hres;
1433
1434     cp = get_cp(unk, riid);
1435     hres = IConnectionPoint_Unadvise(cp, cookie);
1436     IConnectionPoint_Release(cp);
1437     ok(hres == S_OK, "Unadvise failed: %08x\n", hres);
1438 }
1439
1440 static HRESULT WINAPI EventDispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
1441 {
1442     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IDispatch, riid)) {
1443         *ppv = iface;
1444         return S_OK;
1445     }
1446
1447     ok(0, "Unexpected call\n");
1448     return E_NOINTERFACE;
1449 }
1450
1451 static DWORD WINAPI EventDispatch_AddRef(IDispatch *iface)
1452 {
1453     return 2;
1454 }
1455
1456 static DWORD WINAPI EventDispatch_Release(IDispatch *iface)
1457 {
1458     return 1;
1459 }
1460
1461 static HRESULT WINAPI EventDispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
1462 {
1463     ok(0, "Unexpected call\n");
1464     return E_NOTIMPL;
1465 }
1466
1467 static HRESULT WINAPI EventDispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1468 {
1469     ok(0, "Unexpected call\n");
1470     return E_NOTIMPL;
1471 }
1472
1473 static HRESULT WINAPI EventDispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
1474         UINT cNames, LCID lcid, DISPID *rgDispId)
1475 {
1476     ok(0, "Unexpected call\n");
1477     return E_NOTIMPL;
1478 }
1479
1480 static HRESULT WINAPI EventDispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
1481         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1482         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1483 {
1484     ok(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", wine_dbgstr_guid(riid));
1485     ok(pDispParams != NULL, "pDispParams == NULL\n");
1486     ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
1487     ok(puArgErr != NULL, "puArgErr == NULL\n");
1488     ok(V_VT(pVarResult) == 0, "V_VT(pVarResult) = %d\n", V_VT(pVarResult));
1489     ok(wFlags == DISPATCH_METHOD, "wFlags = %d\n", wFlags);
1490
1491     switch(dispIdMember) {
1492     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
1493         CHECK_EXPECT2(invoke_onclick);
1494         break;
1495     case DISPID_HTMLDOCUMENTEVENTS2_ONPROPERTYCHANGE:
1496     case DISPID_HTMLDOCUMENTEVENTS2_ONREADYSTATECHANGE:
1497     case 1027:
1498     case 1034:
1499     case 1037:
1500     case 1044:
1501     case 1045:
1502     case 1047:
1503     case 1048:
1504     case 1049:
1505         break; /* TODO */
1506     default:
1507         ok(0, "Unexpected call: %d\n", dispIdMember);
1508     }
1509
1510     return S_OK;
1511 }
1512
1513 static const IDispatchVtbl EventDispatchVtbl = {
1514     EventDispatch_QueryInterface,
1515     EventDispatch_AddRef,
1516     EventDispatch_Release,
1517     EventDispatch_GetTypeInfoCount,
1518     EventDispatch_GetTypeInfo,
1519     EventDispatch_GetIDsOfNames,
1520     EventDispatch_Invoke
1521 };
1522
1523 static IDispatch EventDispatch = { &EventDispatchVtbl };
1524
1525 static void test_onclick(IHTMLDocument2 *doc)
1526 {
1527     DWORD cp_cookie, elem2_cp_cookie;
1528     IHTMLElement *div, *body;
1529     VARIANT v;
1530     HRESULT hres;
1531
1532     register_cp((IUnknown*)doc, &IID_IDispatch, (IUnknown*)&EventDispatch);
1533
1534     div = get_elem_id(doc, "clickdiv");
1535
1536     elem_attach_event((IUnknown*)div, "abcde", (IDispatch*)&nocall_obj);
1537     elem_attach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_attached_obj);
1538
1539     V_VT(&v) = VT_EMPTY;
1540     hres = IHTMLElement_get_onclick(div, &v);
1541     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1542     ok(V_VT(&v) == VT_NULL, "V_VT(onclick) = %d\n", V_VT(&v));
1543
1544     V_VT(&v) = VT_EMPTY;
1545     hres = IHTMLElement_put_onclick(div, v);
1546     ok(hres == E_NOTIMPL, "put_onclick failed: %08x\n", hres);
1547
1548     V_VT(&v) = VT_BSTR;
1549     V_BSTR(&v) = a2bstr("function();");
1550     hres = IHTMLElement_put_onclick(div, v);
1551     todo_wine ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1552
1553     if(hres == S_OK) {
1554         V_VT(&v) = VT_EMPTY;
1555         hres = IHTMLElement_get_onclick(div, &v);
1556         ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1557         ok(V_VT(&v) == VT_BSTR, "V_VT(onclick) = %d\n", V_VT(&v));
1558         ok(!strcmp_wa(V_BSTR(&v), "function();"), "V_BSTR(onclick) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1559     }
1560     VariantClear(&v);
1561
1562     V_VT(&v) = VT_DISPATCH;
1563     V_DISPATCH(&v) = (IDispatch*)&div_onclick_obj;
1564     hres = IHTMLElement_put_onclick(div, v);
1565     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1566
1567     V_VT(&v) = VT_NULL;
1568     hres = IHTMLElement_put_ondblclick(div, v);
1569     ok(hres == S_OK, "put_ondblclick failed: %08x\n", hres);
1570
1571     V_VT(&v) = VT_EMPTY;
1572     hres = IHTMLElement_get_onclick(div, &v);
1573     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1574     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onclick) = %d\n", V_VT(&v));
1575     ok(V_DISPATCH(&v) == (IDispatch*)&div_onclick_obj, "V_DISPATCH(onclick) != onclickFunc\n");
1576     VariantClear(&v);
1577
1578     V_VT(&v) = VT_EMPTY;
1579     hres = IHTMLDocument2_get_onclick(doc, &v);
1580     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1581     ok(V_VT(&v) == VT_NULL, "V_VT(onclick) = %d\n", V_VT(&v));
1582
1583     V_VT(&v) = VT_DISPATCH;
1584     V_DISPATCH(&v) = (IDispatch*)&document_onclick_obj;
1585     hres = IHTMLDocument2_put_onclick(doc, v);
1586     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1587
1588     V_VT(&v) = VT_EMPTY;
1589     hres = IHTMLDocument2_get_onclick(doc, &v);
1590     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1591     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onclick) = %d\n", V_VT(&v));
1592     ok(V_DISPATCH(&v) == (IDispatch*)&document_onclick_obj, "V_DISPATCH(onclick) != onclickFunc\n");
1593     VariantClear(&v);
1594
1595     body = doc_get_body(doc);
1596
1597     V_VT(&v) = VT_DISPATCH;
1598     V_DISPATCH(&v) = (IDispatch*)&body_onclick_obj;
1599     hres = IHTMLElement_put_onclick(body, v);
1600     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1601
1602     if(winetest_interactive) {
1603         SET_EXPECT(div_onclick);
1604         SET_EXPECT(div_onclick_attached);
1605         SET_EXPECT(body_onclick);
1606         SET_EXPECT(document_onclick);
1607         SET_EXPECT(invoke_onclick);
1608         pump_msgs(&called_document_onclick);
1609         CHECK_CALLED(div_onclick);
1610         CHECK_CALLED(div_onclick_attached);
1611         CHECK_CALLED(body_onclick);
1612         CHECK_CALLED(document_onclick);
1613         CHECK_CALLED(invoke_onclick);
1614     }
1615
1616     xy_todo = TRUE;
1617
1618     SET_EXPECT(div_onclick);
1619     SET_EXPECT(div_onclick_attached);
1620     SET_EXPECT(body_onclick);
1621     SET_EXPECT(document_onclick);
1622     SET_EXPECT(invoke_onclick);
1623
1624     hres = IHTMLElement_click(div);
1625     ok(hres == S_OK, "click failed: %08x\n", hres);
1626
1627     CHECK_CALLED(div_onclick);
1628     CHECK_CALLED(div_onclick_attached);
1629     CHECK_CALLED(body_onclick);
1630     CHECK_CALLED(document_onclick);
1631     CHECK_CALLED(invoke_onclick);
1632
1633     SET_EXPECT(div_onclick);
1634     SET_EXPECT(div_onclick_attached);
1635     SET_EXPECT(body_onclick);
1636     SET_EXPECT(document_onclick);
1637     SET_EXPECT(invoke_onclick);
1638
1639     V_VT(&v) = VT_EMPTY;
1640     elem_fire_event((IUnknown*)div, "onclick", &v);
1641
1642     CHECK_CALLED(div_onclick);
1643     CHECK_CALLED(div_onclick_attached);
1644     CHECK_CALLED(body_onclick);
1645     CHECK_CALLED(document_onclick);
1646     CHECK_CALLED(invoke_onclick);
1647
1648     cp_cookie = register_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, (IUnknown*)&doccp_obj);
1649     elem_attach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_disp);
1650     doc_attach_event(doc, "onclick", (IDispatch*)&doc_onclick_attached_obj);
1651
1652     SET_EXPECT(div_onclick);
1653     SET_EXPECT(div_onclick_disp);
1654     SET_EXPECT(div_onclick_attached);
1655     SET_EXPECT(body_onclick);
1656     SET_EXPECT(document_onclick);
1657     SET_EXPECT(doc_onclick_attached);
1658     SET_EXPECT(doccp_onclick);
1659     SET_EXPECT(invoke_onclick);
1660
1661     hres = IHTMLElement_click(div);
1662     ok(hres == S_OK, "click failed: %08x\n", hres);
1663
1664     CHECK_CALLED(div_onclick);
1665     CHECK_CALLED(div_onclick_disp);
1666     CHECK_CALLED(div_onclick_attached);
1667     CHECK_CALLED(body_onclick);
1668     CHECK_CALLED(document_onclick);
1669     CHECK_CALLED(doc_onclick_attached);
1670     CHECK_CALLED(doccp_onclick);
1671     CHECK_CALLED(invoke_onclick);
1672
1673     elem2_cp_cookie = register_cp((IUnknown*)div, &DIID_HTMLElementEvents2, (IUnknown*)&elem2_cp_obj);
1674
1675     SET_EXPECT(div_onclick);
1676     SET_EXPECT(div_onclick_disp);
1677     SET_EXPECT(div_onclick_attached);
1678     SET_EXPECT(elem2_cp_onclick);
1679     SET_EXPECT(body_onclick);
1680     SET_EXPECT(document_onclick);
1681     SET_EXPECT(doc_onclick_attached);
1682     SET_EXPECT(doccp_onclick);
1683     SET_EXPECT(invoke_onclick);
1684
1685     trace("click >>>\n");
1686     hres = IHTMLElement_click(div);
1687     ok(hres == S_OK, "click failed: %08x\n", hres);
1688     trace("click <<<\n");
1689
1690     CHECK_CALLED(div_onclick);
1691     CHECK_CALLED(div_onclick_disp);
1692     CHECK_CALLED(div_onclick_attached);
1693     CHECK_CALLED(elem2_cp_onclick);
1694     CHECK_CALLED(body_onclick);
1695     CHECK_CALLED(document_onclick);
1696     CHECK_CALLED(doc_onclick_attached);
1697     CHECK_CALLED(doccp_onclick);
1698     CHECK_CALLED(invoke_onclick);
1699
1700     unregister_cp((IUnknown*)div, &DIID_HTMLElementEvents2, elem2_cp_cookie);
1701     unregister_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, cp_cookie);
1702
1703     V_VT(&v) = VT_NULL;
1704     hres = IHTMLElement_put_onclick(div, v);
1705     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1706
1707     hres = IHTMLElement_get_onclick(div, &v);
1708     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1709     ok(V_VT(&v) == VT_NULL, "get_onclick returned vt %d\n", V_VT(&v));
1710
1711     elem_detach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_disp);
1712     elem_detach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_disp);
1713     elem_detach_event((IUnknown*)div, "test", (IDispatch*)&div_onclick_disp);
1714     doc_detach_event(doc, "onclick", (IDispatch*)&doc_onclick_attached_obj);
1715
1716     SET_EXPECT(div_onclick_attached);
1717     SET_EXPECT(body_onclick);
1718     SET_EXPECT(document_onclick);
1719     SET_EXPECT(invoke_onclick);
1720
1721     hres = IHTMLElement_click(div);
1722     ok(hres == S_OK, "click failed: %08x\n", hres);
1723
1724     CHECK_CALLED(div_onclick_attached);
1725     CHECK_CALLED(body_onclick);
1726     CHECK_CALLED(document_onclick);
1727     CHECK_CALLED(invoke_onclick);
1728
1729     IHTMLElement_Release(div);
1730     IHTMLElement_Release(body);
1731 }
1732
1733 static void test_onreadystatechange(IHTMLDocument2 *doc)
1734 {
1735     IHTMLFrameBase *iframe;
1736     IHTMLElement2 *elem2;
1737     IHTMLElement *elem;
1738     VARIANT v;
1739     BSTR str;
1740     HRESULT hres;
1741
1742     elem = get_elem_id(doc, "iframe");
1743     elem2 = get_elem2_iface((IUnknown*)elem);
1744     IHTMLElement_Release(elem);
1745
1746     V_VT(&v) = VT_EMPTY;
1747     hres = IHTMLElement2_get_onreadystatechange(elem2, &v);
1748     ok(hres == S_OK, "get_onreadystatechange failed: %08x\n", hres);
1749     ok(V_VT(&v) == VT_NULL, "V_VT(onreadystatechange) = %d\n", V_VT(&v));
1750
1751     V_VT(&v) = VT_DISPATCH;
1752     V_DISPATCH(&v) = (IDispatch*)&iframe_onreadystatechange_obj;
1753     hres = IHTMLElement2_put_onreadystatechange(elem2, v);
1754     ok(hres == S_OK, "put_onreadystatechange failed: %08x\n", hres);
1755
1756     V_VT(&v) = VT_EMPTY;
1757     hres = IHTMLElement2_get_onreadystatechange(elem2, &v);
1758     ok(hres == S_OK, "get_onreadystatechange failed: %08x\n", hres);
1759     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onreadystatechange) = %d\n", V_VT(&v));
1760     ok(V_DISPATCH(&v) == (IDispatch*)&iframe_onreadystatechange_obj, "unexpected onreadystatechange value\n");
1761
1762     hres = IHTMLElement2_QueryInterface(elem2, &IID_IHTMLFrameBase, (void**)&iframe);
1763     IHTMLElement2_Release(elem2);
1764     ok(hres == S_OK, "Could not get IHTMLFrameBase iface: %08x\n", hres);
1765
1766     hres = IHTMLFrameBase_put_src(iframe, (str = a2bstr("about:blank")));
1767     SysFreeString(str);
1768     ok(hres == S_OK, "put_src failed: %08x\n", hres);
1769
1770     SET_EXPECT(iframe_onreadystatechange_loading);
1771     SET_EXPECT(iframedoc_onreadystatechange);
1772     SET_EXPECT(iframe_onreadystatechange_interactive);
1773     SET_EXPECT(iframe_onreadystatechange_complete);
1774     pump_msgs(&called_iframe_onreadystatechange_complete);
1775     CHECK_CALLED(iframe_onreadystatechange_loading);
1776     CHECK_CALLED(iframedoc_onreadystatechange);
1777     CHECK_CALLED(iframe_onreadystatechange_interactive);
1778     CHECK_CALLED(iframe_onreadystatechange_complete);
1779
1780     IHTMLFrameBase_Release(iframe);
1781 }
1782
1783 static void test_imgload(IHTMLDocument2 *doc)
1784 {
1785     IHTMLImgElement *img;
1786     IHTMLElement *elem;
1787     VARIANT v;
1788     BSTR str;
1789     HRESULT hres;
1790
1791     elem = get_elem_id(doc, "imgid");
1792     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLImgElement, (void**)&img);
1793     IHTMLElement_Release(elem);
1794     ok(hres == S_OK, "Could not get IHTMLImgElement iface: %08x\n", hres);
1795
1796     V_VT(&v) = VT_EMPTY;
1797     hres = IHTMLImgElement_get_onload(img, &v);
1798     ok(hres == S_OK, "get_onload failed: %08x\n", hres);
1799     ok(V_VT(&v) == VT_NULL, "V_VT(onload) = %d\n", V_VT(&v));
1800
1801     V_VT(&v) = VT_DISPATCH;
1802     V_DISPATCH(&v) = (IDispatch*)&img_onload_obj;
1803     hres = IHTMLImgElement_put_onload(img, v);
1804     ok(hres == S_OK, "put_onload failed: %08x\n", hres);
1805
1806     V_VT(&v) = VT_EMPTY;
1807     hres = IHTMLImgElement_get_onload(img, &v);
1808     ok(hres == S_OK, "get_onload failed: %08x\n", hres);
1809     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onload) = %d\n", V_VT(&v));
1810     ok(V_DISPATCH(&v) == (IDispatch*)&img_onload_obj, "V_DISPATCH(onload) != onloadkFunc\n");
1811     VariantClear(&v);
1812
1813     V_VT(&v) = VT_DISPATCH;
1814     V_DISPATCH(&v) = (IDispatch*)&img_onerror_obj;
1815     hres = IHTMLImgElement_put_onerror(img, v);
1816     ok(hres == S_OK, "put_onerror failed: %08x\n", hres);
1817
1818     V_VT(&v) = VT_EMPTY;
1819     hres = IHTMLImgElement_get_onerror(img, &v);
1820     ok(hres == S_OK, "get_onerror failed: %08x\n", hres);
1821     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onerror) = %d\n", V_VT(&v));
1822     ok(V_DISPATCH(&v) == (IDispatch*)&img_onerror_obj, "V_DISPATCH(onerror) != onerrorFunc\n");
1823     VariantClear(&v);
1824
1825     str = a2bstr("http://www.winehq.org/images/winehq_logo_text.png");
1826     hres = IHTMLImgElement_put_src(img, str);
1827     ok(hres == S_OK, "put_src failed: %08x\n", hres);
1828     SysFreeString(str);
1829
1830     SET_EXPECT(img_onload);
1831     pump_msgs(&called_img_onload);
1832     CHECK_CALLED(img_onload);
1833
1834     SET_EXPECT(img_onerror);
1835
1836     str = a2bstr("about:blank");
1837     hres = IHTMLImgElement_put_src(img, str);
1838     ok(hres == S_OK, "put_src failed: %08x\n", hres);
1839     SysFreeString(str);
1840
1841     pump_msgs(&called_img_onerror); /* FIXME: should not be needed */
1842
1843     CHECK_CALLED(img_onerror);
1844
1845     IHTMLImgElement_Release(img);
1846 }
1847
1848 static void test_focus(IHTMLDocument2 *doc)
1849 {
1850     IHTMLElement2 *elem2;
1851     IHTMLElement *elem;
1852     VARIANT v;
1853     HRESULT hres;
1854
1855     elem = get_elem_id(doc, "inputid");
1856     elem2 = get_elem2_iface((IUnknown*)elem);
1857     IHTMLElement_Release(elem);
1858
1859     V_VT(&v) = VT_EMPTY;
1860     hres = IHTMLElement2_get_onfocus(elem2, &v);
1861     ok(hres == S_OK, "get_onfocus failed: %08x\n", hres);
1862     ok(V_VT(&v) == VT_NULL, "V_VT(onfocus) = %d\n", V_VT(&v));
1863
1864     V_VT(&v) = VT_DISPATCH;
1865     V_DISPATCH(&v) = (IDispatch*)&input_onfocus_obj;
1866     hres = IHTMLElement2_put_onfocus(elem2, v);
1867     ok(hres == S_OK, "put_onfocus failed: %08x\n", hres);
1868
1869     V_VT(&v) = VT_EMPTY;
1870     hres = IHTMLElement2_get_onfocus(elem2, &v);
1871     ok(hres == S_OK, "get_onfocus failed: %08x\n", hres);
1872     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onfocus) = %d\n", V_VT(&v));
1873     ok(V_DISPATCH(&v) == (IDispatch*)&input_onfocus_obj, "V_DISPATCH(onfocus) != onfocusFunc\n");
1874     VariantClear(&v);
1875
1876     if(!winetest_interactive)
1877         ShowWindow(container_hwnd, SW_SHOW);
1878
1879     SetFocus(NULL);
1880     ok(!IsChild(container_hwnd, GetFocus()), "focus belongs to document window\n");
1881
1882     hres = IHTMLWindow2_focus(window);
1883     ok(hres == S_OK, "focus failed: %08x\n", hres);
1884
1885     ok(IsChild(container_hwnd, GetFocus()), "focus does not belong to document window\n");
1886     pump_msgs(NULL);
1887
1888     SET_EXPECT(input_onfocus);
1889     hres = IHTMLElement2_focus(elem2);
1890     pump_msgs(NULL);
1891     CHECK_CALLED(input_onfocus);
1892     ok(hres == S_OK, "focus failed: %08x\n", hres);
1893
1894     V_VT(&v) = VT_DISPATCH;
1895     V_DISPATCH(&v) = (IDispatch*)&input_onblur_obj;
1896     hres = IHTMLElement2_put_onblur(elem2, v);
1897     ok(hres == S_OK, "put_onblur failed: %08x\n", hres);
1898
1899     SET_EXPECT(input_onblur);
1900     hres = IHTMLElement2_blur(elem2);
1901     pump_msgs(NULL);
1902     CHECK_CALLED(input_onblur);
1903     ok(hres == S_OK, "blur failed: %08x\n", hres);
1904
1905     if(!winetest_interactive)
1906         ShowWindow(container_hwnd, SW_HIDE);
1907
1908     IHTMLElement2_Release(elem2);
1909 }
1910
1911 static void test_submit(IHTMLDocument2 *doc)
1912 {
1913     IHTMLElement *elem, *submit;
1914     IHTMLFormElement *form;
1915     VARIANT v;
1916     DWORD cp_cookie;
1917     HRESULT hres;
1918
1919     elem = get_elem_id(doc, "formid");
1920
1921     V_VT(&v) = VT_DISPATCH;
1922     V_DISPATCH(&v) = (IDispatch*)&form_onclick_obj;
1923     hres = IHTMLElement_put_onclick(elem, v);
1924     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1925
1926     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLFormElement, (void**)&form);
1927     IHTMLElement_Release(elem);
1928     ok(hres == S_OK, "Could not get IHTMLFormElement iface: %08x\n", hres);
1929
1930     V_VT(&v) = VT_DISPATCH;
1931     V_DISPATCH(&v) = (IDispatch*)&form_onsubmit_obj;
1932     hres = IHTMLFormElement_put_onsubmit(form, v);
1933     ok(hres == S_OK, "put_onsubmit failed: %08x\n", hres);
1934
1935     IHTMLFormElement_Release(form);
1936
1937     submit = get_elem_id(doc, "submitid");
1938
1939     SET_EXPECT(form_onclick);
1940     SET_EXPECT(form_onsubmit);
1941     hres = IHTMLElement_click(submit);
1942     ok(hres == S_OK, "click failed: %08x\n", hres);
1943     CHECK_CALLED(form_onclick);
1944     CHECK_CALLED(form_onsubmit);
1945
1946     V_VT(&v) = VT_DISPATCH;
1947     V_DISPATCH(&v) = (IDispatch*)&submit_onclick_obj;
1948     hres = IHTMLElement_put_onclick(submit, v);
1949     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1950
1951     SET_EXPECT(form_onclick);
1952     SET_EXPECT(submit_onclick);
1953     hres = IHTMLElement_click(submit);
1954     ok(hres == S_OK, "click failed: %08x\n", hres);
1955     CHECK_CALLED(form_onclick);
1956     CHECK_CALLED(submit_onclick);
1957
1958     elem_attach_event((IUnknown*)submit, "onclick", (IDispatch*)&submit_onclick_attached_obj);
1959
1960     SET_EXPECT(form_onclick);
1961     SET_EXPECT(submit_onclick);
1962     SET_EXPECT(submit_onclick_attached);
1963     hres = IHTMLElement_click(submit);
1964     ok(hres == S_OK, "click failed: %08x\n", hres);
1965     CHECK_CALLED(form_onclick);
1966     CHECK_CALLED(submit_onclick);
1967     CHECK_CALLED(submit_onclick_attached);
1968
1969     V_VT(&v) = VT_NULL;
1970     hres = IHTMLElement_put_onclick(submit, v);
1971     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1972
1973     SET_EXPECT(form_onclick);
1974     SET_EXPECT(submit_onclick_attached);
1975     hres = IHTMLElement_click(submit);
1976     ok(hres == S_OK, "click failed: %08x\n", hres);
1977     CHECK_CALLED(form_onclick);
1978     CHECK_CALLED(submit_onclick_attached);
1979
1980     elem_detach_event((IUnknown*)submit, "onclick", (IDispatch*)&submit_onclick_attached_obj);
1981
1982     cp_cookie = register_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, (IUnknown*)&doccp_onclick_cancel_obj);
1983
1984     SET_EXPECT(form_onclick);
1985     SET_EXPECT(doccp_onclick_cancel);
1986     hres = IHTMLElement_click(submit);
1987     ok(hres == S_OK, "click failed: %08x\n", hres);
1988     CHECK_CALLED(form_onclick);
1989     CHECK_CALLED(doccp_onclick_cancel);
1990
1991     unregister_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, cp_cookie);
1992
1993     V_VT(&v) = VT_DISPATCH;
1994     V_DISPATCH(&v) = (IDispatch*)&submit_onclick_setret_obj;
1995     hres = IHTMLElement_put_onclick(submit, v);
1996     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1997
1998     V_VT(&onclick_retval) = VT_BOOL;
1999     V_BOOL(&onclick_retval) = VARIANT_TRUE;
2000     V_VT(&onclick_event_retval) = VT_BOOL;
2001     V_BOOL(&onclick_event_retval) = VARIANT_TRUE;
2002
2003     SET_EXPECT(submit_onclick_setret);
2004     SET_EXPECT(form_onclick);
2005     SET_EXPECT(form_onsubmit);
2006     hres = IHTMLElement_click(submit);
2007     ok(hres == S_OK, "click failed: %08x\n", hres);
2008     CHECK_CALLED(submit_onclick_setret);
2009     CHECK_CALLED(form_onclick);
2010     CHECK_CALLED(form_onsubmit);
2011
2012     V_VT(&onclick_event_retval) = VT_BOOL;
2013     V_BOOL(&onclick_event_retval) = VARIANT_FALSE;
2014
2015     SET_EXPECT(submit_onclick_setret);
2016     SET_EXPECT(form_onclick);
2017     hres = IHTMLElement_click(submit);
2018     ok(hres == S_OK, "click failed: %08x\n", hres);
2019     CHECK_CALLED(submit_onclick_setret);
2020     CHECK_CALLED(form_onclick);
2021
2022     V_VT(&onclick_retval) = VT_BOOL;
2023     V_BOOL(&onclick_retval) = VARIANT_FALSE;
2024     V_VT(&onclick_event_retval) = VT_BOOL;
2025     V_BOOL(&onclick_event_retval) = VARIANT_TRUE;
2026
2027     SET_EXPECT(submit_onclick_setret);
2028     SET_EXPECT(form_onclick);
2029     hres = IHTMLElement_click(submit);
2030     ok(hres == S_OK, "click failed: %08x\n", hres);
2031     CHECK_CALLED(submit_onclick_setret);
2032     CHECK_CALLED(form_onclick);
2033
2034     V_VT(&onclick_event_retval) = VT_BOOL;
2035     V_BOOL(&onclick_event_retval) = VARIANT_FALSE;
2036
2037     SET_EXPECT(submit_onclick_setret);
2038     SET_EXPECT(form_onclick);
2039     hres = IHTMLElement_click(submit);
2040     ok(hres == S_OK, "click failed: %08x\n", hres);
2041     CHECK_CALLED(submit_onclick_setret);
2042     CHECK_CALLED(form_onclick);
2043
2044     elem_attach_event((IUnknown*)submit, "onclick", (IDispatch*)&submit_onclick_attached_obj);
2045     elem_attach_event((IUnknown*)submit, "onclick", (IDispatch*)&submit_onclick_attached_check_cancel_obj);
2046
2047     V_VT(&v) = VT_DISPATCH;
2048     V_DISPATCH(&v) = (IDispatch*)&submit_onclick_cancel_obj;
2049     hres = IHTMLElement_put_onclick(submit, v);
2050     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
2051
2052     SET_EXPECT(submit_onclick_cancel);
2053     SET_EXPECT(submit_onclick_attached_check_cancel);
2054     SET_EXPECT(submit_onclick_attached);
2055     hres = IHTMLElement_click(submit);
2056     ok(hres == S_OK, "click failed: %08x\n", hres);
2057     CHECK_CALLED(submit_onclick_cancel);
2058     CHECK_CALLED(submit_onclick_attached_check_cancel);
2059     CHECK_CALLED(submit_onclick_attached);
2060
2061     IHTMLElement_Release(submit);
2062 }
2063
2064 static void test_timeout(IHTMLDocument2 *doc)
2065 {
2066     IHTMLWindow3 *win3;
2067     VARIANT expr, var;
2068     LONG id;
2069     HRESULT hres;
2070
2071     hres = IHTMLWindow2_QueryInterface(window, &IID_IHTMLWindow3, (void**)&win3);
2072     ok(hres == S_OK, "Could not get IHTMLWindow3 iface: %08x\n", hres);
2073
2074     V_VT(&expr) = VT_DISPATCH;
2075     V_DISPATCH(&expr) = (IDispatch*)&timeoutFunc;
2076     V_VT(&var) = VT_EMPTY;
2077     id = 0;
2078     hres = IHTMLWindow3_setTimeout(win3, &expr, 0, &var, &id);
2079     ok(hres == S_OK, "setTimeout failed: %08x\n", hres);
2080     ok(id, "id = 0\n");
2081
2082     SET_EXPECT(timeout);
2083     pump_msgs(&called_timeout);
2084     CHECK_CALLED(timeout);
2085
2086     V_VT(&expr) = VT_DISPATCH;
2087     V_DISPATCH(&expr) = (IDispatch*)&timeoutFunc;
2088     V_VT(&var) = VT_EMPTY;
2089     id = 0;
2090     hres = IHTMLWindow3_setTimeout(win3, &expr, 0, &var, &id);
2091     ok(hres == S_OK, "setTimeout failed: %08x\n", hres);
2092     ok(id, "id = 0\n");
2093
2094     hres = IHTMLWindow2_clearTimeout(window, id);
2095     ok(hres == S_OK, "clearTimeout failed: %08x\n", hres);
2096
2097     IHTMLWindow3_Release(win3);
2098 }
2099
2100 static IHTMLElement* find_element_by_id(IHTMLDocument2 *doc, const char *id)
2101 {
2102     HRESULT hres;
2103     IHTMLDocument3 *doc3;
2104     IHTMLElement *result;
2105     BSTR idW = a2bstr(id);
2106
2107     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument3, (void**)&doc3);
2108     ok(hres == S_OK, "QueryInterface(IID_IHTMLDocument3) failed: %08x\n", hres);
2109
2110     hres = IHTMLDocument3_getElementById(doc3, idW, &result);
2111     ok(hres == S_OK, "getElementById failed: %08x\n", hres);
2112     ok(result != NULL, "result == NULL\n");
2113     SysFreeString(idW);
2114
2115     IHTMLDocument3_Release(doc3);
2116     return result;
2117 }
2118
2119 static IHTMLDocument2* get_iframe_doc(IHTMLIFrameElement *iframe)
2120 {
2121     HRESULT hres;
2122     IHTMLFrameBase2 *base;
2123     IHTMLDocument2 *result = NULL;
2124
2125     hres = IHTMLIFrameElement_QueryInterface(iframe, &IID_IHTMLFrameBase2, (void**)&base);
2126     ok(hres == S_OK, "QueryInterface(IID_IHTMLFrameBase2) failed: %08x\n", hres);
2127     if(hres == S_OK) {
2128         IHTMLWindow2 *window;
2129
2130         hres = IHTMLFrameBase2_get_contentWindow(base, &window);
2131         ok(hres == S_OK, "get_contentWindow failed: %08x\n", hres);
2132         ok(window != NULL, "window == NULL\n");
2133         if(window) {
2134             hres = IHTMLWindow2_get_document(window, &result);
2135             ok(hres == S_OK, "get_document failed: %08x\n", hres);
2136             ok(result != NULL, "result == NULL\n");
2137             IHTMLWindow2_Release(window);
2138         }
2139     }
2140     if(base) IHTMLFrameBase2_Release(base);
2141
2142     return result;
2143 }
2144
2145 static void test_iframe_connections(IHTMLDocument2 *doc)
2146 {
2147     HRESULT hres;
2148     IHTMLIFrameElement *iframe;
2149     IHTMLDocument2 *iframes_doc;
2150     DWORD cookie;
2151     IConnectionPoint *cp;
2152     IHTMLElement *element = find_element_by_id(doc, "ifr");
2153
2154     hres = IHTMLElement_QueryInterface(element, &IID_IHTMLIFrameElement, (void**)&iframe);
2155     IHTMLElement_Release(element);
2156     ok(hres == S_OK, "QueryInterface(IID_IHTMLIFrameElement) failed: %08x\n", hres);
2157
2158     iframes_doc = get_iframe_doc(iframe);
2159     IHTMLIFrameElement_Release(iframe);
2160
2161     cookie = register_cp((IUnknown*)iframes_doc, &IID_IDispatch, (IUnknown*)&div_onclick_disp);
2162
2163     cp = get_cp((IUnknown*)doc, &IID_IDispatch);
2164     hres = IConnectionPoint_Unadvise(cp, cookie);
2165     IConnectionPoint_Release(cp);
2166     ok(hres == CONNECT_E_NOCONNECTION, "Unadvise returned %08x, expected CONNECT_E_NOCONNECTION\n", hres);
2167
2168     IHTMLDocument2_Release(iframes_doc);
2169 }
2170
2171 static HRESULT QueryInterface(REFIID,void**);
2172
2173 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
2174 {
2175     return E_NOINTERFACE;
2176 }
2177
2178 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
2179 {
2180     return 2;
2181 }
2182
2183 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
2184 {
2185     return 1;
2186 }
2187
2188 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
2189 {
2190     return E_NOTIMPL;
2191 }
2192
2193 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
2194 {
2195     return E_NOTIMPL;
2196 }
2197
2198 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
2199 {
2200     return E_NOTIMPL;
2201 }
2202
2203 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
2204         LPCBORDERWIDTHS pborderwidths)
2205 {
2206     return E_NOTIMPL;
2207 }
2208
2209 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
2210         LPCBORDERWIDTHS pborderwidths)
2211 {
2212     return S_OK;
2213 }
2214
2215 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
2216         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
2217 {
2218     return S_OK;
2219 }
2220
2221 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
2222         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
2223 {
2224     return S_OK;
2225 }
2226
2227 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
2228         LPOLEMENUGROUPWIDTHS lpMenuWidths)
2229 {
2230     return E_NOTIMPL;
2231 }
2232
2233 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
2234         HOLEMENU holemenu, HWND hwndActiveObject)
2235 {
2236     ok(0, "unexpected call\n");
2237     return E_NOTIMPL;
2238 }
2239
2240 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
2241 {
2242     ok(0, "unexpected call\n");
2243     return E_NOTIMPL;
2244 }
2245
2246 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
2247 {
2248     return S_OK;
2249 }
2250
2251 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
2252 {
2253     return E_NOTIMPL;
2254 }
2255
2256 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
2257 {
2258     ok(0, "unexpected call\n");
2259     return E_NOTIMPL;
2260 }
2261
2262 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
2263     InPlaceFrame_QueryInterface,
2264     InPlaceFrame_AddRef,
2265     InPlaceFrame_Release,
2266     InPlaceFrame_GetWindow,
2267     InPlaceFrame_ContextSensitiveHelp,
2268     InPlaceFrame_GetBorder,
2269     InPlaceFrame_RequestBorderSpace,
2270     InPlaceFrame_SetBorderSpace,
2271     InPlaceFrame_SetActiveObject,
2272     InPlaceFrame_InsertMenus,
2273     InPlaceFrame_SetMenu,
2274     InPlaceFrame_RemoveMenus,
2275     InPlaceFrame_SetStatusText,
2276     InPlaceFrame_EnableModeless,
2277     InPlaceFrame_TranslateAccelerator
2278 };
2279
2280 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
2281
2282 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
2283     InPlaceFrame_QueryInterface,
2284     InPlaceFrame_AddRef,
2285     InPlaceFrame_Release,
2286     InPlaceFrame_GetWindow,
2287     InPlaceFrame_ContextSensitiveHelp,
2288     InPlaceFrame_GetBorder,
2289     InPlaceFrame_RequestBorderSpace,
2290     InPlaceFrame_SetBorderSpace,
2291     InPlaceUIWindow_SetActiveObject,
2292 };
2293
2294 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
2295
2296 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
2297 {
2298     return QueryInterface(riid, ppv);
2299 }
2300
2301 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
2302 {
2303     return 2;
2304 }
2305
2306 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
2307 {
2308     return 1;
2309 }
2310
2311 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
2312 {
2313     *phwnd = container_hwnd;
2314     return S_OK;
2315 }
2316
2317 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
2318 {
2319     ok(0, "unexpected call\n");
2320     return E_NOTIMPL;
2321 }
2322
2323 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
2324 {
2325     return S_OK;
2326 }
2327
2328 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
2329 {
2330     return S_OK;
2331 }
2332
2333 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
2334 {
2335     return S_OK;
2336 }
2337
2338 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
2339         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
2340         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
2341 {
2342     static const RECT rect = {0,0,300,300};
2343
2344     *ppFrame = &InPlaceFrame;
2345     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
2346     *lprcPosRect = rect;
2347     *lprcClipRect = rect;
2348
2349     ok(lpFrameInfo->cb == sizeof(*lpFrameInfo), "lpFrameInfo->cb = %u, expected %u\n", lpFrameInfo->cb, (unsigned)sizeof(*lpFrameInfo));
2350     lpFrameInfo->fMDIApp = FALSE;
2351     lpFrameInfo->hwndFrame = container_hwnd;
2352     lpFrameInfo->haccel = NULL;
2353     lpFrameInfo->cAccelEntries = 0;
2354
2355     return S_OK;
2356 }
2357
2358 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
2359 {
2360     return E_NOTIMPL;
2361 }
2362
2363 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
2364 {
2365     return S_OK;
2366 }
2367
2368 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
2369 {
2370     return S_OK;
2371 }
2372
2373 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
2374 {
2375     return E_NOTIMPL;
2376 }
2377
2378 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
2379 {
2380     return E_NOTIMPL;
2381 }
2382
2383 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
2384 {
2385     return E_NOTIMPL;
2386 }
2387
2388 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
2389     InPlaceSite_QueryInterface,
2390     InPlaceSite_AddRef,
2391     InPlaceSite_Release,
2392     InPlaceSite_GetWindow,
2393     InPlaceSite_ContextSensitiveHelp,
2394     InPlaceSite_CanInPlaceActivate,
2395     InPlaceSite_OnInPlaceActivate,
2396     InPlaceSite_OnUIActivate,
2397     InPlaceSite_GetWindowContext,
2398     InPlaceSite_Scroll,
2399     InPlaceSite_OnUIDeactivate,
2400     InPlaceSite_OnInPlaceDeactivate,
2401     InPlaceSite_DiscardUndoState,
2402     InPlaceSite_DeactivateAndUndo,
2403     InPlaceSite_OnPosRectChange,
2404 };
2405
2406 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
2407
2408 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
2409 {
2410     return QueryInterface(riid, ppv);
2411 }
2412
2413 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
2414 {
2415     return 2;
2416 }
2417
2418 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
2419 {
2420     return 1;
2421 }
2422
2423 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
2424 {
2425     ok(0, "unexpected call\n");
2426     return E_NOTIMPL;
2427 }
2428
2429 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
2430         IMoniker **ppmon)
2431 {
2432     ok(0, "unexpected call\n");
2433     return E_NOTIMPL;
2434 }
2435
2436 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
2437 {
2438     return E_NOTIMPL;
2439 }
2440
2441 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
2442 {
2443     ok(0, "unexpected call\n");
2444     return E_NOTIMPL;
2445 }
2446
2447 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
2448 {
2449     ok(0, "unexpected call\n");
2450     return E_NOTIMPL;
2451 }
2452
2453 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
2454 {
2455     ok(0, "unexpected call\n");
2456     return E_NOTIMPL;
2457 }
2458
2459 static const IOleClientSiteVtbl ClientSiteVtbl = {
2460     ClientSite_QueryInterface,
2461     ClientSite_AddRef,
2462     ClientSite_Release,
2463     ClientSite_SaveObject,
2464     ClientSite_GetMoniker,
2465     ClientSite_GetContainer,
2466     ClientSite_ShowObject,
2467     ClientSite_OnShowWindow,
2468     ClientSite_RequestNewObjectLayout
2469 };
2470
2471 static IOleClientSite ClientSite = { &ClientSiteVtbl };
2472
2473 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
2474 {
2475     return QueryInterface(riid, ppv);
2476 }
2477
2478 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
2479 {
2480     return 2;
2481 }
2482
2483 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
2484 {
2485     return 1;
2486 }
2487
2488 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
2489 {
2490     RECT rect = {0,0,300,300};
2491     IOleDocument *document;
2492     HRESULT hres;
2493
2494     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
2495     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
2496
2497     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
2498     IOleDocument_Release(document);
2499     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
2500
2501     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
2502     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
2503
2504     hres = IOleDocumentView_UIActivate(view, TRUE);
2505     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
2506
2507     hres = IOleDocumentView_SetRect(view, &rect);
2508     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
2509
2510     hres = IOleDocumentView_Show(view, TRUE);
2511     ok(hres == S_OK, "Show failed: %08x\n", hres);
2512
2513     return S_OK;
2514 }
2515
2516 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
2517     DocumentSite_QueryInterface,
2518     DocumentSite_AddRef,
2519     DocumentSite_Release,
2520     DocumentSite_ActivateMe
2521 };
2522
2523 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
2524
2525 static HRESULT QueryInterface(REFIID riid, void **ppv)
2526 {
2527     *ppv = NULL;
2528
2529     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
2530         *ppv = &ClientSite;
2531     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
2532         *ppv = &DocumentSite;
2533     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
2534         *ppv = &InPlaceSite;
2535
2536     return *ppv ? S_OK : E_NOINTERFACE;
2537 }
2538
2539 static IHTMLDocument2 *notif_doc;
2540 static BOOL doc_complete;
2541
2542 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
2543         REFIID riid, void**ppv)
2544 {
2545     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
2546         *ppv = iface;
2547         return S_OK;
2548     }
2549
2550     ok(0, "unexpected call\n");
2551     return E_NOINTERFACE;
2552 }
2553
2554 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
2555 {
2556     return 2;
2557 }
2558
2559 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
2560 {
2561     return 1;
2562 }
2563
2564 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
2565 {
2566     if(dispID == DISPID_READYSTATE){
2567         BSTR state;
2568         HRESULT hres;
2569
2570         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
2571         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
2572
2573         if(!strcmp_wa(state, "complete"))
2574             doc_complete = TRUE;
2575
2576         SysFreeString(state);
2577     }
2578
2579     return S_OK;
2580 }
2581
2582 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
2583 {
2584     ok(0, "unexpected call\n");
2585     return E_NOTIMPL;
2586 }
2587
2588 static const IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
2589     PropertyNotifySink_QueryInterface,
2590     PropertyNotifySink_AddRef,
2591     PropertyNotifySink_Release,
2592     PropertyNotifySink_OnChanged,
2593     PropertyNotifySink_OnRequestEdit
2594 };
2595
2596 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
2597
2598 static void doc_load_string(IHTMLDocument2 *doc, const char *str)
2599 {
2600     IPersistStreamInit *init;
2601     IStream *stream;
2602     HGLOBAL mem;
2603     SIZE_T len;
2604
2605     notif_doc = doc;
2606
2607     doc_complete = FALSE;
2608     len = strlen(str);
2609     mem = GlobalAlloc(0, len);
2610     memcpy(mem, str, len);
2611     CreateStreamOnHGlobal(mem, TRUE, &stream);
2612
2613     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
2614
2615     IPersistStreamInit_Load(init, stream);
2616     IPersistStreamInit_Release(init);
2617     IStream_Release(stream);
2618 }
2619
2620 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
2621 {
2622     IConnectionPointContainer *container;
2623     IConnectionPoint *cp;
2624     DWORD cookie;
2625     HRESULT hres;
2626
2627     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
2628     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
2629
2630     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
2631     IConnectionPointContainer_Release(container);
2632     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
2633
2634     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
2635     IConnectionPoint_Release(cp);
2636     ok(hres == S_OK, "Advise failed: %08x\n", hres);
2637 }
2638
2639 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
2640 {
2641     IOleObject *oleobj;
2642     HRESULT hres;
2643
2644     if(!set && view) {
2645         IOleDocumentView_Show(view, FALSE);
2646         IOleDocumentView_CloseView(view, 0);
2647         IOleDocumentView_SetInPlaceSite(view, NULL);
2648         IOleDocumentView_Release(view);
2649         view = NULL;
2650     }
2651
2652     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
2653     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
2654
2655     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
2656     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
2657
2658     if(set) {
2659         IHlinkTarget *hlink;
2660
2661         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
2662         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
2663
2664         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
2665         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
2666
2667         IHlinkTarget_Release(hlink);
2668     }
2669
2670     IOleObject_Release(oleobj);
2671 }
2672 static IHTMLDocument2 *create_document(void)
2673 {
2674     IHTMLDocument2 *doc;
2675     IHTMLDocument5 *doc5;
2676     HRESULT hres;
2677
2678     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2679             &IID_IHTMLDocument2, (void**)&doc);
2680     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
2681     if (FAILED(hres))
2682         return NULL;
2683
2684     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument5, (void**)&doc5);
2685     if(FAILED(hres)) {
2686         win_skip("Could not get IHTMLDocument5 interface, probably too old IE\n");
2687         IHTMLDocument2_Release(doc);
2688         return NULL;
2689     }
2690
2691     IHTMLDocument5_Release(doc5);
2692     return doc;
2693 }
2694
2695
2696 typedef void (*testfunc_t)(IHTMLDocument2*);
2697
2698 static void run_test(const char *str, testfunc_t test)
2699 {
2700     IHTMLDocument2 *doc;
2701     IHTMLElement *body = NULL;
2702     MSG msg;
2703     HRESULT hres;
2704
2705     xy_todo = FALSE;
2706     doc = create_document();
2707     if (!doc)
2708         return;
2709     set_client_site(doc, TRUE);
2710     doc_load_string(doc, str);
2711     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
2712
2713     while(!doc_complete && GetMessageA(&msg, NULL, 0, 0)) {
2714         TranslateMessage(&msg);
2715         DispatchMessageA(&msg);
2716     }
2717
2718     hres = IHTMLDocument2_get_body(doc, &body);
2719     ok(hres == S_OK, "get_body failed: %08x\n", hres);
2720
2721     if(body) {
2722         IHTMLElement_Release(body);
2723
2724         hres = IHTMLDocument2_get_parentWindow(doc, &window);
2725         ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
2726         ok(window != NULL, "window == NULL\n");
2727
2728         test(doc);
2729
2730         IHTMLWindow2_Release(window);
2731         window = NULL;
2732     }else {
2733         skip("Could not get document body. Assuming no Gecko installed.\n");
2734     }
2735
2736     set_client_site(doc, FALSE);
2737     IHTMLDocument2_Release(doc);
2738 }
2739
2740 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2741 {
2742     return DefWindowProcA(hwnd, msg, wParam, lParam);
2743 }
2744
2745 static HWND create_container_window(void)
2746 {
2747     static const CHAR szHTMLDocumentTest[] = "HTMLDocumentTest";
2748     static WNDCLASSEXA wndclass = {
2749         sizeof(WNDCLASSEXA),
2750         0,
2751         wnd_proc,
2752         0, 0, NULL, NULL, NULL, NULL, NULL,
2753         szHTMLDocumentTest,
2754         NULL
2755     };
2756
2757     RegisterClassExA(&wndclass);
2758     return CreateWindowA(szHTMLDocumentTest, szHTMLDocumentTest,
2759             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
2760             300, 300, NULL, NULL, NULL, NULL);
2761 }
2762
2763 static void test_empty_document(void)
2764 {
2765     HRESULT hres;
2766     IHTMLWindow2 *window;
2767     IHTMLDocument2 *windows_doc, *doc;
2768     IConnectionPoint *cp;
2769     DWORD cookie;
2770
2771     doc = create_document();
2772     if(!doc)
2773         return;
2774
2775     hres = IHTMLDocument2_get_parentWindow(doc, &window);
2776     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
2777
2778     hres = IHTMLWindow2_get_document(window, &windows_doc);
2779     IHTMLWindow2_Release(window);
2780     ok(hres == S_OK, "get_document failed: %08x\n", hres);
2781
2782     cookie = register_cp((IUnknown*)windows_doc, &IID_IDispatch, (IUnknown*)&div_onclick_disp);
2783
2784     cp = get_cp((IUnknown*)doc, &IID_IDispatch);
2785     hres = IConnectionPoint_Unadvise(cp, cookie);
2786     IConnectionPoint_Release(cp);
2787     ok(hres == S_OK, "Unadvise failed: %08x\n", hres);
2788
2789     IHTMLDocument2_Release(windows_doc);
2790     IHTMLDocument2_Release(doc);
2791 }
2792
2793 START_TEST(events)
2794 {
2795     CoInitialize(NULL);
2796     container_hwnd = create_container_window();
2797
2798     if(winetest_interactive)
2799         ShowWindow(container_hwnd, SW_SHOW);
2800
2801     run_test(empty_doc_str, test_timeout);
2802     run_test(click_doc_str, test_onclick);
2803     run_test(readystate_doc_str, test_onreadystatechange);
2804     run_test(img_doc_str, test_imgload);
2805     run_test(input_doc_str, test_focus);
2806     run_test(form_doc_str, test_submit);
2807     run_test(iframe_doc_str, test_iframe_connections);
2808
2809     test_empty_document();
2810
2811     DestroyWindow(container_hwnd);
2812     CoUninitialize();
2813 }