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