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