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