dlls/mshtml/tests/events.c

   1 /*
   2  * Copyright 2008-2009 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #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(div_onclick);
  63 DEFINE_EXPECT(div_onclick_attached);
  64 DEFINE_EXPECT(timeout);
  65 DEFINE_EXPECT(doccp_onclick);
  66 DEFINE_EXPECT(iframe_onreadystatechange_loading);
  67 DEFINE_EXPECT(iframe_onreadystatechange_interactive);
  68 DEFINE_EXPECT(iframe_onreadystatechange_complete);
  69
  70 static HWND container_hwnd = NULL;
  71 static IHTMLWindow2 *window;
  72 static IOleDocumentView *view;
  73 static BOOL xy_todo;
  74
  75 typedef struct {
  76     LONG x;
  77     LONG y;
  78     LONG offset_x;
  79     LONG offset_y;
  80 } xy_test_t;
  81
  82 static const xy_test_t no_xy = {-10,-10,-10,-10};
  83 static const xy_test_t zero_xy = {0,0,0,0};
  84
  85 static const char empty_doc_str[] =
  86     "<html></html>";
  87
  88 static const char click_doc_str[] =
  89     "<html><body>"
  90     "<div id=\"clickdiv\" style=\"text-align: center; background: red; font-size: 32\">click here</div>"
  91     "</body></html>";
  92
  93 static const char readystate_doc_str[] =
  94     "<<html><body><iframe id=\"iframe\"></iframe></body></html>";
  95
  96 static const char *debugstr_guid(REFIID riid)
  97 {
  98     static char buf[50];
  99
 100     sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
 101             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 102             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 103             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 104
 105     return buf;
 106 }
 107
 108 static int strcmp_wa(LPCWSTR strw, const char *stra)
 109 {
 110     CHAR buf[512];
 111     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 112     return lstrcmpA(stra, buf);
 113 }
 114
 115 static BSTR a2bstr(const char *str)
 116 {
 117     BSTR ret;
 118     int len;
 119
 120     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 121     ret = SysAllocStringLen(NULL, len-1);
 122     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 123
 124     return ret;
 125 }
 126
 127 static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
 128 {
 129     IUnknown *unk1, *unk2;
 130
 131     if(iface1 == iface2)
 132         return TRUE;
 133
 134     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
 135     IUnknown_Release(unk1);
 136     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk2);
 137     IUnknown_Release(unk2);
 138
 139     return unk1 == unk2;
 140 }
 141
 142 #define test_disp(u,id) _test_disp(__LINE__,u,id)
 143 static void _test_disp(unsigned line, IUnknown *unk, const IID *diid)
 144 {
 145     IDispatchEx *dispex;
 146     ITypeInfo *typeinfo;
 147     UINT ticnt;
 148     HRESULT hres;
 149
 150     hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&dispex);
 151     ok_(__FILE__,line) (hres == S_OK, "Could not get IDispatch: %08x\n", hres);
 152     if(FAILED(hres))
 153         return;
 154
 155     ticnt = 0xdeadbeef;
 156     hres = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
 157     ok_(__FILE__,line) (hres == S_OK, "GetTypeInfoCount failed: %08x\n", hres);
 158     ok_(__FILE__,line) (ticnt == 1, "ticnt=%u\n", ticnt);
 159
 160     hres = IDispatchEx_GetTypeInfo(dispex, 0, 0, &typeinfo);
 161     ok_(__FILE__,line) (hres == S_OK, "GetTypeInfo failed: %08x\n", hres);
 162
 163     if(SUCCEEDED(hres)) {
 164         TYPEATTR *type_attr;
 165
 166         hres = ITypeInfo_GetTypeAttr(typeinfo, &type_attr);
 167         ok_(__FILE__,line) (hres == S_OK, "GetTypeAttr failed: %08x\n", hres);
 168         ok_(__FILE__,line) (IsEqualGUID(&type_attr->guid, diid), "unexpected guid %s\n",
 169                             debugstr_guid(&type_attr->guid));
 170
 171         ITypeInfo_ReleaseTypeAttr(typeinfo, type_attr);
 172         ITypeInfo_Release(typeinfo);
 173     }
 174
 175     IDispatchEx_Release(dispex);
 176 }
 177
 178 #define get_doc3_iface(u) _get_doc3_iface(__LINE__,u)
 179 static IHTMLDocument3 *_get_doc3_iface(unsigned line, IUnknown *unk)
 180 {
 181     IHTMLDocument3 *doc3;
 182     HRESULT hres;
 183
 184     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDocument3, (void**)&doc3);
 185     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLDocument3 iface: %08x\n", hres);
 186
 187     return doc3;
 188 }
 189
 190 #define get_elem_iface(u) _get_elem_iface(__LINE__,u)
 191 static IHTMLElement *_get_elem_iface(unsigned line, IUnknown *unk)
 192 {
 193     IHTMLElement *elem;
 194     HRESULT hres;
 195
 196     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement, (void**)&elem);
 197     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement iface: %08x\n", hres);
 198
 199     return elem;
 200 }
 201
 202 #define get_elem2_iface(u) _get_elem2_iface(__LINE__,u)
 203 static IHTMLElement2 *_get_elem2_iface(unsigned line, IUnknown *unk)
 204 {
 205     IHTMLElement2 *elem2;
 206     HRESULT hres;
 207
 208     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement2, (void**)&elem2);
 209     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement2 iface: %08x\n", hres);
 210
 211     return elem2;
 212 }
 213
 214 #define get_elem3_iface(u) _get_elem3_iface(__LINE__,u)
 215 static IHTMLElement3 *_get_elem3_iface(unsigned line, IUnknown *unk)
 216 {
 217     IHTMLElement3 *elem3;
 218     HRESULT hres;
 219
 220     hres = IUnknown_QueryInterface(unk, &IID_IHTMLElement3, (void**)&elem3);
 221     ok_(__FILE__,line) (hres == S_OK, "Could not get IHTMLElement3 iface: %08x\n", hres);
 222
 223     return elem3;
 224 }
 225
 226 #define doc_get_body(d) _doc_get_body(__LINE__,d)
 227 static IHTMLElement *_doc_get_body(unsigned line, IHTMLDocument2 *doc)
 228 {
 229     IHTMLElement *body = NULL;
 230     HRESULT hres;
 231
 232     hres = IHTMLDocument2_get_body(doc, &body);
 233     ok_(__FILE__,line) (hres == S_OK, "get_body failed: %08x\n", hres);
 234     ok_(__FILE__,line) (body != NULL, "body == NULL\n");
 235
 236     return body;
 237 }
 238
 239 #define get_elem_id(d,i) _get_elem_id(__LINE__,d,i)
 240 static IHTMLElement *_get_elem_id(unsigned line, IHTMLDocument2 *doc, const char *id)
 241 {
 242     IHTMLDocument3 *doc3 = _get_doc3_iface(line, (IUnknown*)doc);
 243     IHTMLElement *elem;
 244     BSTR str;
 245     HRESULT hres;
 246
 247     str = a2bstr(id);
 248     hres = IHTMLDocument3_getElementById(doc3, str, &elem);
 249     SysFreeString(str);
 250     IHTMLDocument3_Release(doc3);
 251     ok_(__FILE__,line) (hres == S_OK, "getElementById failed: %08x\n", hres);
 252
 253     return elem;
 254 }
 255
 256 #define test_elem_tag(u,n) _test_elem_tag(__LINE__,u,n)
 257 static void _test_elem_tag(unsigned line, IUnknown *unk, const char *extag)
 258 {
 259     IHTMLElement *elem = _get_elem_iface(line, unk);
 260     BSTR tag;
 261     HRESULT hres;
 262
 263     hres = IHTMLElement_get_tagName(elem, &tag);
 264     IHTMLElement_Release(elem);
 265     ok_(__FILE__, line) (hres == S_OK, "get_tagName failed: %08x\n", hres);
 266     ok_(__FILE__, line) (!strcmp_wa(tag, extag), "got tag: %s, expected %s\n", wine_dbgstr_w(tag), extag);
 267
 268     SysFreeString(tag);
 269 }
 270
 271 #define get_event_obj() _get_event_obj(__LINE__)
 272 static IHTMLEventObj *_get_event_obj(unsigned line)
 273 {
 274     IHTMLEventObj *event = NULL;
 275     HRESULT hres;
 276
 277     hres = IHTMLWindow2_get_event(window, &event);
 278     ok_(__FILE__,line) (hres == S_OK, "get_event failed: %08x\n", hres);
 279     ok_(__FILE__,line) (event != NULL, "event = NULL\n");
 280     _test_disp(line, (IUnknown*)event, &DIID_DispCEventObj);
 281
 282     return event;
 283 }
 284
 285 #define elem_fire_event(a,b,c) _elem_fire_event(__LINE__,a,b,c)
 286 static void _elem_fire_event(unsigned line, IUnknown *unk, const char *event, VARIANT *evobj)
 287 {
 288     IHTMLElement3 *elem3 = _get_elem3_iface(line, unk);
 289     VARIANT_BOOL b;
 290     BSTR str;
 291     HRESULT hres;
 292
 293     b = 100;
 294     str = a2bstr(event);
 295     hres = IHTMLElement3_fireEvent(elem3, str, evobj, &b);
 296     SysFreeString(str);
 297     ok_(__FILE__,line)(hres == S_OK, "fireEvent failed: %08x\n", hres);
 298     ok_(__FILE__,line)(b == VARIANT_TRUE, "fireEvent returned %x\n", b);
 299 }
 300
 301 #define test_event_args(a,b,c,d,e,f,g) _test_event_args(__LINE__,a,b,c,d,e,f,g)
 302 static void _test_event_args(unsigned line, const IID *dispiid, DISPID id, WORD wFlags, DISPPARAMS *pdp,
 303         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 304 {
 305     ok_(__FILE__,line) (id == DISPID_VALUE, "id = %d\n", id);
 306     ok_(__FILE__,line) (wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 307     ok_(__FILE__,line) (pdp != NULL, "pdp == NULL\n");
 308     ok_(__FILE__,line) (pdp->cArgs == 1, "pdp->cArgs = %d\n", pdp->cArgs);
 309     ok_(__FILE__,line) (pdp->cNamedArgs == 1, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 310     ok_(__FILE__,line) (pdp->rgdispidNamedArgs[0] == DISPID_THIS, "pdp->rgdispidNamedArgs[0] = %d\n",
 311                         pdp->rgdispidNamedArgs[0]);
 312     ok_(__FILE__,line) (V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(rgvarg) = %d\n", V_VT(pdp->rgvarg));
 313     ok_(__FILE__,line) (pvarRes != NULL, "pvarRes == NULL\n");
 314     ok_(__FILE__,line) (pei != NULL, "pei == NULL");
 315     ok_(__FILE__,line) (!pspCaller, "pspCaller != NULL\n");
 316
 317     if(dispiid)
 318         _test_disp(line, (IUnknown*)V_DISPATCH(pdp->rgvarg), dispiid);
 319 }
 320
 321 #define test_attached_event_args(a,b,c,d,e) _test_attached_event_args(__LINE__,a,b,c,d,e)
 322 static void _test_attached_event_args(unsigned line, DISPID id, WORD wFlags, DISPPARAMS *pdp,
 323         VARIANT *pvarRes, EXCEPINFO *pei)
 324 {
 325     IHTMLEventObj *event;
 326
 327     ok(id == DISPID_VALUE, "id = %d\n", id);
 328     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 329     ok(pdp != NULL, "pDispParams == NULL\n");
 330     ok(pdp->cArgs == 1, "pdp->cArgs = %d\n", pdp->cArgs);
 331     ok(!pdp->cNamedArgs, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
 332     ok(!pdp->rgdispidNamedArgs, "pdp->rgdispidNamedArgs = %p\n", pdp->rgdispidNamedArgs);
 333     ok(pdp->rgvarg != NULL, "rgvarg = NULL\n");
 334     ok(pvarRes != NULL, "pvarRes = NULL\n");
 335     ok(pei != NULL, "pei = NULL\n");
 336     ok(V_VT(pvarRes) == VT_EMPTY, "V_VT(pVarRes) = %d\n", V_VT(pvarRes));
 337     ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(pdp->rgvarg) = %d\n", V_VT(pdp->rgvarg));
 338     ok(V_DISPATCH(pdp->rgvarg) != NULL, "V_DISPATCH(pdp->rgvarg) = %p\n", V_DISPATCH(pdp->rgvarg));
 339
 340     event = _get_event_obj(line);
 341     ok(iface_cmp((IUnknown*)event, (IUnknown*)V_DISPATCH(pdp->rgvarg)), "event != arg0\n");
 342     IHTMLEventObj_Release(event);
 343 }
 344
 345 #define get_event_src(t) _get_event_src(__LINE__)
 346 static IHTMLElement *_get_event_src(unsigned line)
 347 {
 348     IHTMLEventObj *event = _get_event_obj(line);
 349     IHTMLElement *src_elem = NULL;
 350     HRESULT hres;
 351
 352     hres = IHTMLEventObj_get_srcElement(event, &src_elem);
 353     IHTMLEventObj_Release(event);
 354     ok_(__FILE__,line) (hres == S_OK, "get_srcElement failed: %08x\n", hres);
 355
 356     return src_elem;
 357 }
 358
 359 #define test_event_src(t) _test_event_src(__LINE__,t)
 360 static void _test_event_src(unsigned line, const char *src_tag)
 361 {
 362     IHTMLElement *src_elem = _get_event_src(line);
 363
 364     if(src_tag) {
 365         ok_(__FILE__,line) (src_elem != NULL, "src_elem = NULL\n");
 366         _test_elem_tag(line, (IUnknown*)src_elem, src_tag);
 367         IHTMLElement_Release(src_elem);
 368     }else {
 369         ok_(__FILE__,line) (!src_elem, "src_elem != NULL\n");
 370     }
 371 }
 372
 373 static void _test_event_altkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 374 {
 375     VARIANT_BOOL b;
 376     HRESULT hres;
 377
 378     hres = IHTMLEventObj_get_altKey(event, &b);
 379     ok_(__FILE__,line)(hres == S_OK, "get_altKey failed: %08x\n", hres);
 380     ok_(__FILE__,line)(b == exval, "altKey = %x, expected %x\n", b, exval);
 381 }
 382
 383 static void _test_event_ctrlkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 384 {
 385     VARIANT_BOOL b;
 386     HRESULT hres;
 387
 388     hres = IHTMLEventObj_get_ctrlKey(event, &b);
 389     ok_(__FILE__,line)(hres == S_OK, "get_ctrlKey failed: %08x\n", hres);
 390     ok_(__FILE__,line)(b == exval, "ctrlKey = %x, expected %x\n", b, exval);
 391 }
 392
 393 static void _test_event_shiftkey(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 394 {
 395     VARIANT_BOOL b;
 396     HRESULT hres;
 397
 398     hres = IHTMLEventObj_get_shiftKey(event, &b);
 399     ok_(__FILE__,line)(hres == S_OK, "get_shiftKey failed: %08x\n", hres);
 400     ok_(__FILE__,line)(b == exval, "shiftKey = %x, expected %x\n", b, exval);
 401 }
 402
 403 static void _test_event_cancelbubble(unsigned line, IHTMLEventObj *event, VARIANT_BOOL exval)
 404 {
 405     VARIANT_BOOL b;
 406     HRESULT hres;
 407
 408     hres = IHTMLEventObj_get_cancelBubble(event, &b);
 409     ok_(__FILE__,line)(hres == S_OK, "get_cancelBubble failed: %08x\n", hres);
 410     ok_(__FILE__,line)(b == exval, "cancelBubble = %x, expected %x\n", b, exval);
 411 }
 412
 413 static void _test_event_fromelem(unsigned line, IHTMLEventObj *event, const char *from_tag)
 414 {
 415     IHTMLElement *elem;
 416     HRESULT hres;
 417
 418     hres = IHTMLEventObj_get_fromElement(event, &elem);
 419     ok_(__FILE__,line)(hres == S_OK, "get_fromElement failed: %08x\n", hres);
 420     if(from_tag)
 421         _test_elem_tag(line, (IUnknown*)elem, from_tag);
 422     else
 423         ok_(__FILE__,line)(elem == NULL, "fromElement != NULL\n");
 424     if(elem)
 425         IHTMLElement_Release(elem);
 426 }
 427
 428 static void _test_event_toelem(unsigned line, IHTMLEventObj *event, const char *to_tag)
 429 {
 430     IHTMLElement *elem;
 431     HRESULT hres;
 432
 433     hres = IHTMLEventObj_get_toElement(event, &elem);
 434     ok_(__FILE__,line)(hres == S_OK, "get_toElement failed: %08x\n", hres);
 435     if(to_tag)
 436         _test_elem_tag(line, (IUnknown*)elem, to_tag);
 437     else
 438         ok_(__FILE__,line)(elem == NULL, "toElement != NULL\n");
 439     if(elem)
 440         IHTMLElement_Release(elem);
 441 }
 442
 443 static void _test_event_keycode(unsigned line, IHTMLEventObj *event, LONG exl)
 444 {
 445     LONG l;
 446     HRESULT hres;
 447
 448     hres = IHTMLEventObj_get_keyCode(event, &l);
 449     ok_(__FILE__,line)(hres == S_OK, "get_keyCode failed: %08x\n", hres);
 450     ok_(__FILE__,line)(l == exl, "keyCode = %x, expected %x\n", l, exl);
 451 }
 452
 453 static void _test_event_button(unsigned line, IHTMLEventObj *event, LONG exl)
 454 {
 455     LONG l;
 456     HRESULT hres;
 457
 458     hres = IHTMLEventObj_get_button(event, &l);
 459     ok_(__FILE__,line)(hres == S_OK, "get_button failed: %08x\n", hres);
 460     ok_(__FILE__,line)(l == exl, "button = %x, expected %x\n", l, exl);
 461 }
 462
 463 static void _test_event_reason(unsigned line, IHTMLEventObj *event, LONG exl)
 464 {
 465     LONG l;
 466     HRESULT hres;
 467
 468     hres = IHTMLEventObj_get_reason(event, &l);
 469     ok_(__FILE__,line)(hres == S_OK, "get_reason failed: %08x\n", hres);
 470     ok_(__FILE__,line)(l == exl, "reason = %x, expected %x\n", l, exl);
 471 }
 472
 473 static void _test_event_x(unsigned line, IHTMLEventObj *event, LONG exl)
 474 {
 475     LONG l;
 476     HRESULT hres;
 477
 478     hres = IHTMLEventObj_get_x(event, &l);
 479     ok_(__FILE__,line)(hres == S_OK, "get_x failed: %08x\n", hres);
 480     if(exl == -10) /* don't test the exact value */
 481         todo_wine ok_(__FILE__,line)(l > 0, "x = %d\n", l);
 482     else
 483         ok_(__FILE__,line)(l == exl, "x = %d, expected %d\n", l, exl);
 484 }
 485
 486 static void _test_event_y(unsigned line, IHTMLEventObj *event, LONG exl)
 487 {
 488     LONG l;
 489     HRESULT hres;
 490
 491     hres = IHTMLEventObj_get_y(event, &l);
 492     ok_(__FILE__,line)(hres == S_OK, "get_y failed: %08x\n", hres);
 493     if(exl == -10) /* don't test the exact value */
 494         todo_wine ok_(__FILE__,line)(l > 0, "y = %d\n", l);
 495     else
 496         ok_(__FILE__,line)(l == exl, "y = %d, expected %d\n", l, exl);
 497 }
 498
 499 static void _test_event_clientx(unsigned line, IHTMLEventObj *event, LONG exl)
 500 {
 501     LONG l;
 502     HRESULT hres;
 503
 504     hres = IHTMLEventObj_get_clientX(event, &l);
 505     ok_(__FILE__,line)(hres == S_OK, "get_clientX failed: %08x\n", hres);
 506     if(exl == -10)  {/* don't test the exact value */
 507         if(xy_todo)
 508             todo_wine ok_(__FILE__,line)(l > 0, "clientX = %d\n", l);
 509         else
 510             ok_(__FILE__,line)(l > 0, "clientX = %d\n", l);
 511     }else {
 512         ok_(__FILE__,line)(l == exl, "clientX = %d, expected %d\n", l, exl);
 513     }
 514 }
 515
 516 static void _test_event_clienty(unsigned line, IHTMLEventObj *event, LONG exl)
 517 {
 518     LONG l;
 519     HRESULT hres;
 520
 521     hres = IHTMLEventObj_get_clientY(event, &l);
 522     ok_(__FILE__,line)(hres == S_OK, "get_clientY failed: %08x\n", hres);
 523     if(exl == -10)  {/* don't test the exact value */
 524         if(xy_todo)
 525             todo_wine ok_(__FILE__,line)(l > 0, "clientY = %d\n", l);
 526         else
 527             ok_(__FILE__,line)(l > 0, "clientY = %d\n", l);
 528     }else {
 529         ok_(__FILE__,line)(l == exl, "clientY = %d, expected %d\n", l, exl);
 530     }
 531 }
 532
 533 static void _test_event_offsetx(unsigned line, IHTMLEventObj *event, LONG exl)
 534 {
 535     LONG l;
 536     HRESULT hres;
 537
 538     hres = IHTMLEventObj_get_offsetX(event, &l);
 539     ok_(__FILE__,line)(hres == S_OK, "get_offsetX failed: %08x\n", hres);
 540     if(exl == -10) /* don't test the exact value */
 541         todo_wine ok_(__FILE__,line)(l > 0, "offsetX = %d\n", l);
 542     else
 543         ok_(__FILE__,line)(l == exl, "offsetX = %d, expected %d\n", l, exl);
 544 }
 545
 546 static void _test_event_offsety(unsigned line, IHTMLEventObj *event, LONG exl)
 547 {
 548     LONG l;
 549     HRESULT hres;
 550
 551     hres = IHTMLEventObj_get_offsetY(event, &l);
 552     ok_(__FILE__,line)(hres == S_OK, "get_offsetY failed: %08x\n", hres);
 553     if(exl == -10) /* don't test the exact value */
 554         todo_wine ok_(__FILE__,line)(l > 0, "offsetY = %d\n", l);
 555     else
 556         ok_(__FILE__,line)(l == exl, "offsetY = %d, expected %d\n", l, exl);
 557 }
 558
 559 static void _test_event_screenx(unsigned line, IHTMLEventObj *event, LONG exl)
 560 {
 561     LONG l;
 562     HRESULT hres;
 563
 564     hres = IHTMLEventObj_get_screenX(event, &l);
 565     ok_(__FILE__,line)(hres == S_OK, "get_screenX failed: %08x\n", hres);
 566     if(exl == -10) { /* don't test the exact value */
 567         if(xy_todo)
 568             todo_wine ok_(__FILE__,line)(l > 0, "screenX = %d\n", l);
 569         else
 570             ok_(__FILE__,line)(l > 0, "screenX = %d\n", l);
 571     }else {
 572         ok_(__FILE__,line)(l == exl, "screenX = %d, expected %d\n", l, exl);
 573     }
 574 }
 575
 576 static void _test_event_screeny(unsigned line, IHTMLEventObj *event, LONG exl)
 577 {
 578     LONG l;
 579     HRESULT hres;
 580
 581     hres = IHTMLEventObj_get_screenY(event, &l);
 582     ok_(__FILE__,line)(hres == S_OK, "get_screenY failed: %08x\n", hres);
 583     if(exl == -10) { /* don't test the exact value */
 584         if(xy_todo)
 585             todo_wine ok_(__FILE__,line)(l > 0, "screenY = %d\n", l);
 586         else
 587             ok_(__FILE__,line)(l > 0, "screenY = %d\n", l);
 588     }else {
 589         ok_(__FILE__,line)(l == exl, "screenY = %d, expected %d\n", l, exl);
 590     }
 591 }
 592
 593 static void _test_event_type(unsigned line, IHTMLEventObj *event, const char *exstr)
 594 {
 595     BSTR str;
 596     HRESULT hres;
 597
 598     hres = IHTMLEventObj_get_type(event, &str);
 599     ok_(__FILE__,line)(hres == S_OK, "get_type failed: %08x\n", hres);
 600     ok_(__FILE__,line)(!strcmp_wa(str, exstr), "type = %s, expected %s\n", wine_dbgstr_w(str), exstr);
 601 }
 602
 603 static void _test_event_qualifier(unsigned line, IHTMLEventObj *event, const char *exstr)
 604 {
 605     BSTR str;
 606     HRESULT hres;
 607
 608     hres = IHTMLEventObj_get_qualifier(event, &str);
 609     ok_(__FILE__,line)(hres == S_OK, "get_qualifier failed: %08x\n", hres);
 610     if(exstr)
 611         ok_(__FILE__,line)(!strcmp_wa(str, exstr), "qualifier = %s, expected %s\n", wine_dbgstr_w(str), exstr);
 612     else
 613         ok_(__FILE__,line)(!str, "qualifier != NULL\n");
 614 }
 615
 616 static void _test_event_srcfilter(unsigned line, IHTMLEventObj *event)
 617 {
 618     IDispatch *disp;
 619     HRESULT hres;
 620
 621     hres = IHTMLEventObj_get_srcFilter(event, &disp);
 622     ok_(__FILE__,line)(hres == S_OK, "get_srcFilter failed: %08x\n", hres);
 623     ok_(__FILE__,line)(!disp, "srcFilter != NULL\n");
 624 }
 625
 626 #define test_event_obj(t,x) _test_event_obj(__LINE__,t,x)
 627 static void _test_event_obj(unsigned line, const char *type, const xy_test_t *xy)
 628 {
 629     IHTMLEventObj *event = _get_event_obj(line);
 630     VARIANT v;
 631     HRESULT hres;
 632
 633     _test_event_altkey(line, event, VARIANT_FALSE);
 634     _test_event_ctrlkey(line, event, VARIANT_FALSE);
 635     _test_event_shiftkey(line, event, VARIANT_FALSE);
 636     _test_event_cancelbubble(line, event, VARIANT_FALSE);
 637     _test_event_fromelem(line, event, NULL);
 638     _test_event_toelem(line, event, NULL);
 639     _test_event_keycode(line, event, 0);
 640     _test_event_button(line, event, 0);
 641     _test_event_type(line, event, type);
 642     _test_event_qualifier(line, event, NULL);
 643     _test_event_reason(line, event, 0);
 644     _test_event_srcfilter(line, event);
 645     _test_event_x(line, event, xy->x);
 646     _test_event_y(line, event, xy->y);
 647     _test_event_clientx(line, event, -10);
 648     _test_event_clienty(line, event, -10);
 649     _test_event_offsetx(line, event, xy->offset_x);
 650     _test_event_offsety(line, event, xy->offset_y);
 651     _test_event_screenx(line, event, -10);
 652     _test_event_screeny(line, event, -10);
 653
 654     hres = IHTMLEventObj_get_returnValue(event, &v);
 655     ok_(__FILE__,line)(hres == S_OK, "get_returnValue failed: %08x\n", hres);
 656     ok_(__FILE__,line)(V_VT(&v) == VT_EMPTY, "V_VT(returnValue) = %d\n", V_VT(&v));
 657
 658     IHTMLEventObj_Release(event);
 659 }
 660
 661 #define elem_attach_event(a,b,c) _elem_attach_event(__LINE__,a,b,c)
 662 static void _elem_attach_event(unsigned line, IUnknown *unk, const char *namea, IDispatch *disp)
 663 {
 664     IHTMLElement2 *elem = _get_elem2_iface(line, unk);
 665     VARIANT_BOOL res;
 666     BSTR name;
 667     HRESULT hres;
 668
 669     name = a2bstr(namea);
 670     hres = IHTMLElement2_attachEvent(elem, name, disp, &res);
 671     IHTMLElement2_Release(elem);
 672     SysFreeString(name);
 673     ok_(__FILE__,line)(hres == S_OK, "attachEvent failed: %08x\n", hres);
 674     ok_(__FILE__,line)(res == VARIANT_TRUE, "attachEvent returned %x\n", res);
 675 }
 676
 677 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 678 {
 679     *ppv = NULL;
 680
 681     if(IsEqualGUID(riid, &IID_IUnknown)
 682        || IsEqualGUID(riid, &IID_IDispatch)
 683        || IsEqualGUID(riid, &IID_IDispatchEx))
 684         *ppv = iface;
 685     else {
 686         ok(0, "unexpected riid %s\n", debugstr_guid(riid));
 687         return E_NOINTERFACE;
 688     }
 689
 690     return S_OK;
 691 }
 692
 693 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 694 {
 695     return 2;
 696 }
 697
 698 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 699 {
 700     return 1;
 701 }
 702
 703 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 704 {
 705     ok(0, "unexpected call\n");
 706     return E_NOTIMPL;
 707 }
 708
 709 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 710                                               LCID lcid, ITypeInfo **ppTInfo)
 711 {
 712     ok(0, "unexpected call\n");
 713     return E_NOTIMPL;
 714 }
 715
 716 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 717                                                 LPOLESTR *rgszNames, UINT cNames,
 718                                                 LCID lcid, DISPID *rgDispId)
 719 {
 720     ok(0, "unexpected call\n");
 721     return E_NOTIMPL;
 722 }
 723
 724 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 725                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 726                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 727 {
 728     ok(0, "unexpected call\n");
 729     return E_NOTIMPL;
 730 }
 731
 732 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 733 {
 734     ok(0, "unexpected call\n");
 735     return E_NOTIMPL;
 736 }
 737
 738 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 739         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 740 {
 741     ok(0, "unexpected call\n");
 742     return E_NOTIMPL;
 743 }
 744
 745 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 746 {
 747     ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
 748     return E_NOTIMPL;
 749 }
 750
 751 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 752 {
 753     ok(0, "unexpected call\n");
 754     return E_NOTIMPL;
 755 }
 756
 757 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 758 {
 759     ok(0, "unexpected call\n");
 760     return E_NOTIMPL;
 761 }
 762
 763 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 764 {
 765     ok(0, "unexpected call\n");
 766     return E_NOTIMPL;
 767 }
 768
 769 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 770 {
 771     ok(0, "unexpected call\n");
 772     return E_NOTIMPL;
 773 }
 774
 775 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 776 {
 777     ok(0, "unexpected call\n");
 778     return E_NOTIMPL;
 779 }
 780
 781 #define EVENT_HANDLER_FUNC_OBJ(event) \
 782     static IDispatchExVtbl event ## FuncVtbl = { \
 783         DispatchEx_QueryInterface, \
 784         DispatchEx_AddRef, \
 785         DispatchEx_Release, \
 786         DispatchEx_GetTypeInfoCount, \
 787         DispatchEx_GetTypeInfo, \
 788         DispatchEx_GetIDsOfNames, \
 789         DispatchEx_Invoke, \
 790         DispatchEx_GetDispID, \
 791         event, \
 792         DispatchEx_DeleteMemberByName, \
 793         DispatchEx_DeleteMemberByDispID, \
 794         DispatchEx_GetMemberProperties, \
 795         DispatchEx_GetMemberName, \
 796         DispatchEx_GetNextDispID, \
 797         DispatchEx_GetNameSpaceParent \
 798     }; \
 799     static IDispatchEx event ## _obj = { &event ## FuncVtbl };
 800
 801 static HRESULT WINAPI document_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 802         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 803 {
 804     IHTMLDocument3 *doc3;
 805     CHECK_EXPECT(document_onclick);
 806     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 807     doc3 = get_doc3_iface((IUnknown*)V_DISPATCH(pdp->rgvarg));
 808     IHTMLDocument3_Release(doc3);
 809     test_event_src("DIV");
 810     test_event_obj("click", &no_xy);
 811     return S_OK;
 812 }
 813
 814 EVENT_HANDLER_FUNC_OBJ(document_onclick);
 815
 816 static HRESULT WINAPI div_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 817         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 818 {
 819     CHECK_EXPECT(div_onclick);
 820     test_event_args(NULL, id, wFlags, pdp, pvarRes, pei, pspCaller);
 821     test_event_src("DIV");
 822     return S_OK;
 823 }
 824
 825 EVENT_HANDLER_FUNC_OBJ(div_onclick);
 826
 827 static HRESULT WINAPI div_onclick_attached(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 828         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 829 {
 830     CHECK_EXPECT(div_onclick_attached);
 831
 832     test_attached_event_args(id, wFlags, pdp, pvarRes, pei);
 833     test_event_src("DIV");
 834     return S_OK;
 835 }
 836
 837 EVENT_HANDLER_FUNC_OBJ(div_onclick_attached);
 838
 839 static HRESULT WINAPI body_onclick(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 840         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 841 {
 842     CHECK_EXPECT(body_onclick);
 843     test_event_args(&DIID_DispHTMLBody, id, wFlags, pdp, pvarRes, pei, pspCaller);
 844     test_event_src("DIV");
 845     return S_OK;
 846 }
 847
 848 EVENT_HANDLER_FUNC_OBJ(body_onclick);
 849
 850 static HRESULT WINAPI iframe_onreadystatechange(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 851         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 852 {
 853     IHTMLFrameBase2 *iframe;
 854     IHTMLElement2 *elem2;
 855     IHTMLElement *elem;
 856     VARIANT v;
 857     BSTR str;
 858     HRESULT hres;
 859
 860     test_event_args(&DIID_DispHTMLIFrame, id, wFlags, pdp, pvarRes, pei, pspCaller);
 861     test_event_src("IFRAME");
 862
 863     elem = get_event_src();
 864     elem2 = get_elem2_iface((IUnknown*)elem);
 865     IHTMLElement_Release(elem);
 866
 867     V_VT(&v) = VT_EMPTY;
 868     hres = IHTMLElement2_get_readyState(elem2, &v);
 869     ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
 870     ok(V_VT(&v) == VT_BSTR, "V_VT(readyState) = %d\n", V_VT(&v));
 871
 872     hres = IHTMLElement2_QueryInterface(elem2, &IID_IHTMLFrameBase2, (void**)&iframe);
 873     IHTMLElement2_Release(elem2);
 874     ok(hres == S_OK, "Could not get IHTMLFrameBase2 iface: %08x\n", hres);
 875
 876     str = NULL;
 877     hres = IHTMLFrameBase2_get_readyState(iframe, &str);
 878     IHTMLFrameBase2_Release(iframe);
 879     ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
 880     ok(str != NULL, "readyState == NULL\n");
 881     ok(!lstrcmpW(str, V_BSTR(&v)), "ready states differ\n");
 882     VariantClear(&v);
 883
 884     if(!strcmp_wa(str, "loading"))
 885         CHECK_EXPECT(iframe_onreadystatechange_loading);
 886     else if(!strcmp_wa(str, "interactive"))
 887         CHECK_EXPECT(iframe_onreadystatechange_interactive);
 888     else if(!strcmp_wa(str, "complete"))
 889         CHECK_EXPECT(iframe_onreadystatechange_complete);
 890     else
 891         ok(0, "unexpected state %s\n", wine_dbgstr_w(str));
 892
 893     return S_OK;
 894 }
 895
 896 EVENT_HANDLER_FUNC_OBJ(iframe_onreadystatechange);
 897
 898 static HRESULT WINAPI nocall(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 899         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 900 {
 901     ok(0, "unexpected call\n");
 902     return S_OK;
 903 }
 904
 905 EVENT_HANDLER_FUNC_OBJ(nocall);
 906
 907 #define CONNECTION_POINT_OBJ(cpname, diid) \
 908     static HRESULT WINAPI cpname ## _QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv) \
 909     { \
 910         *ppv = NULL; \
 911         if(IsEqualGUID(riid, &IID_IUnknown) \
 912            || IsEqualGUID(riid, &IID_IDispatch) \
 913            || IsEqualGUID(riid, &diid)) \
 914             *ppv = iface; \
 915         else { \
 916             ok(0, "unexpected riid %s\n", debugstr_guid(riid)); \
 917             return E_NOINTERFACE; \
 918         } \
 919         return S_OK; \
 920     } \
 921     static IDispatchExVtbl cpname ## Vtbl = { \
 922         cpname ## _QueryInterface, \
 923         DispatchEx_AddRef,  \
 924         DispatchEx_Release, \
 925         DispatchEx_GetTypeInfoCount, \
 926         DispatchEx_GetTypeInfo, \
 927         DispatchEx_GetIDsOfNames, \
 928         cpname, \
 929         DispatchEx_GetDispID, \
 930         DispatchEx_InvokeEx, \
 931         DispatchEx_DeleteMemberByName, \
 932         DispatchEx_DeleteMemberByDispID, \
 933         DispatchEx_GetMemberProperties, \
 934         DispatchEx_GetMemberName, \
 935         DispatchEx_GetNextDispID, \
 936         DispatchEx_GetNameSpaceParent \
 937     }; \
 938     static IDispatchEx cpname ## _obj = { &cpname ## Vtbl }
 939
 940 #define test_cp_args(a,b,c,d,e,f) _test_cp_args(__LINE__,a,b,c,d,e,f)
 941 static void _test_cp_args(unsigned line, REFIID riid, WORD flags, DISPPARAMS *dp, VARIANT *vres, EXCEPINFO *ei, UINT *argerr)
 942 {
 943     ok_(__FILE__,line)(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", debugstr_guid(riid));
 944     ok_(__FILE__,line)(flags == DISPATCH_METHOD, "flags = %x\n", flags);
 945     ok_(__FILE__,line)(dp != NULL, "dp == NULL\n");
 946     ok_(__FILE__,line)(!dp->cArgs, "dp->cArgs = %d\n", dp->cArgs);
 947     ok_(__FILE__,line)(!dp->rgvarg, "dp->rgvarg = %p\n", dp->rgvarg);
 948     ok_(__FILE__,line)(!dp->cNamedArgs, "dp->cNamedArgs = %d\n", dp->cNamedArgs);
 949     ok_(__FILE__,line)(!dp->rgdispidNamedArgs, "dp->rgdispidNamedArgs = %p\n", dp->rgdispidNamedArgs);
 950     ok_(__FILE__,line)(vres != NULL, "vres == NULL\n");
 951     ok_(__FILE__,line)(V_VT(vres) == VT_EMPTY, "V_VT(vres) = %d\n", V_VT(vres));
 952     ok_(__FILE__,line)(ei != NULL, "ei == NULL\n");
 953     ok_(__FILE__,line)(argerr != NULL, "argerr == NULL\n");
 954 }
 955
 956 static HRESULT WINAPI doccp(IDispatchEx *iface, DISPID dispIdMember,
 957                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 958                             VARIANT *pVarResult, EXCEPINFO *pei, UINT *puArgErr)
 959 {
 960     switch(dispIdMember) {
 961     case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
 962         CHECK_EXPECT(doccp_onclick);
 963         test_cp_args(riid, wFlags, pdp, pVarResult, pei, puArgErr);
 964         break;
 965     default:
 966         ok(0, "unexpected call %d\n", dispIdMember);
 967         return E_NOTIMPL;
 968     }
 969
 970     return S_OK;
 971 }
 972
 973 CONNECTION_POINT_OBJ(doccp, DIID_HTMLDocumentEvents);
 974
 975 static HRESULT WINAPI timeoutFunc_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 976                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 977                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 978 {
 979     CHECK_EXPECT(timeout);
 980
 981     ok(dispIdMember == DISPID_VALUE, "dispIdMember = %d\n", dispIdMember);
 982     ok(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", debugstr_guid(riid));
 983     ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 984     ok(!lcid, "lcid = %x\n", lcid);
 985     ok(pDispParams != NULL, "pDispParams == NULL\n");
 986     ok(!pDispParams->cArgs, "pdp->cArgs = %d\n", pDispParams->cArgs);
 987     ok(!pDispParams->cNamedArgs, "pdp->cNamedArgs = %d\n", pDispParams->cNamedArgs);
 988     ok(!pDispParams->rgdispidNamedArgs, "pdp->rgdispidNamedArgs = %p\n", pDispParams->rgdispidNamedArgs);
 989     ok(!pDispParams->rgvarg, "rgvarg = %p\n", pDispParams->rgvarg);
 990     ok(pVarResult != NULL, "pVarResult = NULL\n");
 991     ok(pExcepInfo != NULL, "pExcepInfo = NULL\n");
 992     ok(!puArgErr, "puArgErr = %p\n", puArgErr);
 993     ok(V_VT(pVarResult) == VT_EMPTY, "V_VT(pVarResult) = %d\n", V_VT(pVarResult));
 994
 995     return S_OK;
 996 }
 997
 998 static IDispatchExVtbl timeoutFuncVtbl = {
 999     DispatchEx_QueryInterface,
1000     DispatchEx_AddRef,
1001     DispatchEx_Release,
1002     DispatchEx_GetTypeInfoCount,
1003     DispatchEx_GetTypeInfo,
1004     DispatchEx_GetIDsOfNames,
1005     timeoutFunc_Invoke,
1006     DispatchEx_GetDispID,
1007     DispatchEx_InvokeEx,
1008     DispatchEx_DeleteMemberByName,
1009     DispatchEx_DeleteMemberByDispID,
1010     DispatchEx_GetMemberProperties,
1011     DispatchEx_GetMemberName,
1012     DispatchEx_GetNextDispID,
1013     DispatchEx_GetNameSpaceParent
1014 };
1015
1016 static IDispatchEx timeoutFunc = { &timeoutFuncVtbl };
1017
1018 static void pump_msgs(BOOL *b)
1019 {
1020     MSG msg;
1021     while(!*b && GetMessage(&msg, NULL, 0, 0)) {
1022         TranslateMessage(&msg);
1023         DispatchMessage(&msg);
1024     }
1025 }
1026
1027 static IConnectionPoint *get_cp(IUnknown *unk, REFIID riid)
1028 {
1029     IConnectionPointContainer *cp_container;
1030     IConnectionPoint *cp;
1031     HRESULT hres;
1032
1033     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&cp_container);
1034     ok(hres == S_OK, "Could not get IConnectionPointContainer: %08x\n", hres);
1035
1036     hres = IConnectionPointContainer_FindConnectionPoint(cp_container, riid, &cp);
1037     IConnectionPointContainer_Release(cp_container);
1038     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
1039
1040     return cp;
1041 }
1042
1043 static DWORD register_cp(IUnknown *unk, REFIID riid, IUnknown *sink)
1044 {
1045     IConnectionPoint *cp;
1046     DWORD cookie;
1047     HRESULT hres;
1048
1049     cp = get_cp(unk, riid);
1050     hres = IConnectionPoint_Advise(cp, sink, &cookie);
1051     IConnectionPoint_Release(cp);
1052     ok(hres == S_OK, "Advise failed: %08x\n", hres);
1053
1054     return cookie;
1055 }
1056
1057 static void unregister_cp(IUnknown *unk, REFIID riid, DWORD cookie)
1058 {
1059     IConnectionPoint *cp;
1060     HRESULT hres;
1061
1062     cp = get_cp(unk, riid);
1063     hres = IConnectionPoint_Unadvise(cp, cookie);
1064     IConnectionPoint_Release(cp);
1065     ok(hres == S_OK, "Unadvise failed: %08x\n", hres);
1066 }
1067
1068 static void test_onclick(IHTMLDocument2 *doc)
1069 {
1070     IHTMLElement *div, *body;
1071     DWORD cp_cookie;
1072     VARIANT v;
1073     HRESULT hres;
1074
1075     div = get_elem_id(doc, "clickdiv");
1076
1077     elem_attach_event((IUnknown*)div, "abcde", (IDispatch*)&nocall_obj);
1078     elem_attach_event((IUnknown*)div, "onclick", (IDispatch*)&div_onclick_attached_obj);
1079
1080     V_VT(&v) = VT_EMPTY;
1081     hres = IHTMLElement_get_onclick(div, &v);
1082     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1083     ok(V_VT(&v) == VT_NULL, "V_VT(onclick) = %d\n", V_VT(&v));
1084
1085     V_VT(&v) = VT_DISPATCH;
1086     V_DISPATCH(&v) = (IDispatch*)&div_onclick_obj;
1087     hres = IHTMLElement_put_onclick(div, v);
1088     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1089
1090     V_VT(&v) = VT_EMPTY;
1091     hres = IHTMLElement_get_onclick(div, &v);
1092     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1093     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onclick) = %d\n", V_VT(&v));
1094     ok(V_DISPATCH(&v) == (IDispatch*)&div_onclick_obj, "V_DISPATCH(onclick) != onclickFunc\n");
1095     VariantClear(&v);
1096
1097     V_VT(&v) = VT_EMPTY;
1098     hres = IHTMLDocument2_get_onclick(doc, &v);
1099     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1100     ok(V_VT(&v) == VT_NULL, "V_VT(onclick) = %d\n", V_VT(&v));
1101
1102     V_VT(&v) = VT_DISPATCH;
1103     V_DISPATCH(&v) = (IDispatch*)&document_onclick_obj;
1104     hres = IHTMLDocument2_put_onclick(doc, v);
1105     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1106
1107     V_VT(&v) = VT_EMPTY;
1108     hres = IHTMLDocument2_get_onclick(doc, &v);
1109     ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
1110     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onclick) = %d\n", V_VT(&v));
1111     ok(V_DISPATCH(&v) == (IDispatch*)&document_onclick_obj, "V_DISPATCH(onclick) != onclickFunc\n");
1112     VariantClear(&v);
1113
1114     body = doc_get_body(doc);
1115
1116     V_VT(&v) = VT_DISPATCH;
1117     V_DISPATCH(&v) = (IDispatch*)&body_onclick_obj;
1118     hres = IHTMLElement_put_onclick(body, v);
1119     ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
1120
1121     if(winetest_interactive) {
1122         SET_EXPECT(div_onclick);
1123         SET_EXPECT(div_onclick_attached);
1124         SET_EXPECT(body_onclick);
1125         SET_EXPECT(document_onclick);
1126         pump_msgs(&called_document_onclick);
1127         CHECK_CALLED(div_onclick);
1128         CHECK_CALLED(div_onclick_attached);
1129         CHECK_CALLED(body_onclick);
1130         CHECK_CALLED(document_onclick);
1131     }
1132
1133     xy_todo = TRUE;
1134
1135     SET_EXPECT(div_onclick);
1136     SET_EXPECT(div_onclick_attached);
1137     SET_EXPECT(body_onclick);
1138     SET_EXPECT(document_onclick);
1139
1140     hres = IHTMLElement_click(div);
1141     ok(hres == S_OK, "click failed: %08x\n", hres);
1142
1143     CHECK_CALLED(div_onclick);
1144     CHECK_CALLED(div_onclick_attached);
1145     CHECK_CALLED(body_onclick);
1146     CHECK_CALLED(document_onclick);
1147
1148     SET_EXPECT(div_onclick);
1149     SET_EXPECT(div_onclick_attached);
1150     SET_EXPECT(body_onclick);
1151     SET_EXPECT(document_onclick);
1152
1153     V_VT(&v) = VT_EMPTY;
1154     elem_fire_event((IUnknown*)div, "onclick", &v);
1155
1156     CHECK_CALLED(div_onclick);
1157     CHECK_CALLED(div_onclick_attached);
1158     CHECK_CALLED(body_onclick);
1159     CHECK_CALLED(document_onclick);
1160
1161     cp_cookie = register_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, (IUnknown*)&doccp_obj);
1162
1163     SET_EXPECT(div_onclick);
1164     SET_EXPECT(div_onclick_attached);
1165     SET_EXPECT(body_onclick);
1166     SET_EXPECT(document_onclick);
1167     SET_EXPECT(doccp_onclick);
1168
1169     hres = IHTMLElement_click(div);
1170     ok(hres == S_OK, "click failed: %08x\n", hres);
1171
1172     CHECK_CALLED(div_onclick);
1173     CHECK_CALLED(div_onclick_attached);
1174     CHECK_CALLED(body_onclick);
1175     CHECK_CALLED(document_onclick);
1176     CHECK_CALLED(doccp_onclick);
1177
1178     unregister_cp((IUnknown*)doc, &DIID_HTMLDocumentEvents, cp_cookie);
1179
1180     IHTMLElement_Release(div);
1181     IHTMLElement_Release(body);
1182 }
1183
1184 static void test_onreadystatechange(IHTMLDocument2 *doc)
1185 {
1186     IHTMLFrameBase *iframe;
1187     IHTMLElement2 *elem2;
1188     IHTMLElement *elem;
1189     VARIANT v;
1190     BSTR str;
1191     HRESULT hres;
1192
1193     elem = get_elem_id(doc, "iframe");
1194     elem2 = get_elem2_iface((IUnknown*)elem);
1195     IHTMLElement_Release(elem);
1196
1197     V_VT(&v) = VT_EMPTY;
1198     hres = IHTMLElement2_get_onreadystatechange(elem2, &v);
1199     ok(hres == S_OK, "get_onreadystatechange failed: %08x\n", hres);
1200     ok(V_VT(&v) == VT_NULL, "V_VT(onreadystatechange) = %d\n", V_VT(&v));
1201
1202     V_VT(&v) = VT_DISPATCH;
1203     V_DISPATCH(&v) = (IDispatch*)&iframe_onreadystatechange_obj;
1204     hres = IHTMLElement2_put_onreadystatechange(elem2, v);
1205     ok(hres == S_OK, "put_onreadystatechange failed: %08x\n", hres);
1206
1207     V_VT(&v) = VT_EMPTY;
1208     hres = IHTMLElement2_get_onreadystatechange(elem2, &v);
1209     ok(hres == S_OK, "get_onreadystatechange failed: %08x\n", hres);
1210     ok(V_VT(&v) == VT_DISPATCH, "V_VT(onreadystatechange) = %d\n", V_VT(&v));
1211     ok(V_DISPATCH(&v) == (IDispatch*)&iframe_onreadystatechange_obj, "unexpected onreadystatechange value\n");
1212
1213     hres = IHTMLElement2_QueryInterface(elem2, &IID_IHTMLFrameBase, (void**)&iframe);
1214     IHTMLElement2_Release(elem2);
1215     ok(hres == S_OK, "Could not get IHTMLFrameBase iface: %08x\n", hres);
1216
1217     hres = IHTMLFrameBase_put_src(iframe, (str = a2bstr("about:blank")));
1218     SysFreeString(str);
1219     ok(hres == S_OK, "put_src failed: %08x\n", hres);
1220
1221     SET_EXPECT(iframe_onreadystatechange_loading);
1222     SET_EXPECT(iframe_onreadystatechange_interactive);
1223     SET_EXPECT(iframe_onreadystatechange_complete);
1224     pump_msgs(&called_iframe_onreadystatechange_complete);
1225     todo_wine
1226     CHECK_CALLED(iframe_onreadystatechange_loading);
1227     CHECK_CALLED(iframe_onreadystatechange_interactive);
1228     CHECK_CALLED(iframe_onreadystatechange_complete);
1229
1230     IHTMLFrameBase_Release(iframe);
1231 }
1232
1233 static void test_timeout(IHTMLDocument2 *doc)
1234 {
1235     IHTMLWindow3 *win3;
1236     VARIANT expr, var;
1237     LONG id;
1238     HRESULT hres;
1239
1240     hres = IHTMLWindow2_QueryInterface(window, &IID_IHTMLWindow3, (void**)&win3);
1241     ok(hres == S_OK, "Could not get IHTMLWindow3 iface: %08x\n", hres);
1242
1243     V_VT(&expr) = VT_DISPATCH;
1244     V_DISPATCH(&expr) = (IDispatch*)&timeoutFunc;
1245     V_VT(&var) = VT_EMPTY;
1246     id = 0;
1247     hres = IHTMLWindow3_setTimeout(win3, &expr, 0, &var, &id);
1248     ok(hres == S_OK, "setTimeout failed: %08x\n", hres);
1249     ok(id, "id = 0\n");
1250
1251     SET_EXPECT(timeout);
1252     pump_msgs(&called_timeout);
1253     CHECK_CALLED(timeout);
1254
1255     V_VT(&expr) = VT_DISPATCH;
1256     V_DISPATCH(&expr) = (IDispatch*)&timeoutFunc;
1257     V_VT(&var) = VT_EMPTY;
1258     id = 0;
1259     hres = IHTMLWindow3_setTimeout(win3, &expr, 0, &var, &id);
1260     ok(hres == S_OK, "setTimeout failed: %08x\n", hres);
1261     ok(id, "id = 0\n");
1262
1263     hres = IHTMLWindow2_clearTimeout(window, id);
1264     ok(hres == S_OK, "clearTimeout failed: %08x\n", hres);
1265
1266     IHTMLWindow3_Release(win3);
1267 }
1268
1269 static HRESULT QueryInterface(REFIID,void**);
1270
1271 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
1272 {
1273     return E_NOINTERFACE;
1274 }
1275
1276 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
1277 {
1278     return 2;
1279 }
1280
1281 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
1282 {
1283     return 1;
1284 }
1285
1286 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
1287 {
1288     return E_NOTIMPL;
1289 }
1290
1291 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
1292 {
1293     return E_NOTIMPL;
1294 }
1295
1296 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
1297 {
1298     return E_NOTIMPL;
1299 }
1300
1301 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
1302         LPCBORDERWIDTHS pborderwidths)
1303 {
1304     return E_NOTIMPL;
1305 }
1306
1307 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
1308         LPCBORDERWIDTHS pborderwidths)
1309 {
1310     return S_OK;
1311 }
1312
1313 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
1314         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1315 {
1316     return S_OK;
1317 }
1318
1319 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
1320         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1321 {
1322     return S_OK;
1323 }
1324
1325 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
1326         LPOLEMENUGROUPWIDTHS lpMenuWidths)
1327 {
1328     return E_NOTIMPL;
1329 }
1330
1331 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
1332         HOLEMENU holemenu, HWND hwndActiveObject)
1333 {
1334     ok(0, "unexpected call\n");
1335     return E_NOTIMPL;
1336 }
1337
1338 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
1339 {
1340     ok(0, "unexpected call\n");
1341     return E_NOTIMPL;
1342 }
1343
1344 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
1345 {
1346     return S_OK;
1347 }
1348
1349 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
1350 {
1351     return E_NOTIMPL;
1352 }
1353
1354 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
1355 {
1356     ok(0, "unexpected call\n");
1357     return E_NOTIMPL;
1358 }
1359
1360 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
1361     InPlaceFrame_QueryInterface,
1362     InPlaceFrame_AddRef,
1363     InPlaceFrame_Release,
1364     InPlaceFrame_GetWindow,
1365     InPlaceFrame_ContextSensitiveHelp,
1366     InPlaceFrame_GetBorder,
1367     InPlaceFrame_RequestBorderSpace,
1368     InPlaceFrame_SetBorderSpace,
1369     InPlaceFrame_SetActiveObject,
1370     InPlaceFrame_InsertMenus,
1371     InPlaceFrame_SetMenu,
1372     InPlaceFrame_RemoveMenus,
1373     InPlaceFrame_SetStatusText,
1374     InPlaceFrame_EnableModeless,
1375     InPlaceFrame_TranslateAccelerator
1376 };
1377
1378 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
1379
1380 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
1381     InPlaceFrame_QueryInterface,
1382     InPlaceFrame_AddRef,
1383     InPlaceFrame_Release,
1384     InPlaceFrame_GetWindow,
1385     InPlaceFrame_ContextSensitiveHelp,
1386     InPlaceFrame_GetBorder,
1387     InPlaceFrame_RequestBorderSpace,
1388     InPlaceFrame_SetBorderSpace,
1389     InPlaceUIWindow_SetActiveObject,
1390 };
1391
1392 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
1393
1394 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
1395 {
1396     return QueryInterface(riid, ppv);
1397 }
1398
1399 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
1400 {
1401     return 2;
1402 }
1403
1404 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
1405 {
1406     return 1;
1407 }
1408
1409 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
1410 {
1411     *phwnd = container_hwnd;
1412     return S_OK;
1413 }
1414
1415 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
1416 {
1417     ok(0, "unexpected call\n");
1418     return E_NOTIMPL;
1419 }
1420
1421 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
1422 {
1423     return S_OK;
1424 }
1425
1426 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
1427 {
1428     return S_OK;
1429 }
1430
1431 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
1432 {
1433     return S_OK;
1434 }
1435
1436 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
1437         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1438         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1439 {
1440     static const RECT rect = {0,0,300,300};
1441
1442     *ppFrame = &InPlaceFrame;
1443     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
1444     *lprcPosRect = rect;
1445     *lprcClipRect = rect;
1446
1447     lpFrameInfo->cb = sizeof(*lpFrameInfo);
1448     lpFrameInfo->fMDIApp = FALSE;
1449     lpFrameInfo->hwndFrame = container_hwnd;
1450     lpFrameInfo->haccel = NULL;
1451     lpFrameInfo->cAccelEntries = 0;
1452
1453     return S_OK;
1454 }
1455
1456 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
1457 {
1458     return E_NOTIMPL;
1459 }
1460
1461 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
1462 {
1463     return S_OK;
1464 }
1465
1466 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
1467 {
1468     return S_OK;
1469 }
1470
1471 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
1472 {
1473     return E_NOTIMPL;
1474 }
1475
1476 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
1477 {
1478     return E_NOTIMPL;
1479 }
1480
1481 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
1482 {
1483     return E_NOTIMPL;
1484 }
1485
1486 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
1487     InPlaceSite_QueryInterface,
1488     InPlaceSite_AddRef,
1489     InPlaceSite_Release,
1490     InPlaceSite_GetWindow,
1491     InPlaceSite_ContextSensitiveHelp,
1492     InPlaceSite_CanInPlaceActivate,
1493     InPlaceSite_OnInPlaceActivate,
1494     InPlaceSite_OnUIActivate,
1495     InPlaceSite_GetWindowContext,
1496     InPlaceSite_Scroll,
1497     InPlaceSite_OnUIDeactivate,
1498     InPlaceSite_OnInPlaceDeactivate,
1499     InPlaceSite_DiscardUndoState,
1500     InPlaceSite_DeactivateAndUndo,
1501     InPlaceSite_OnPosRectChange,
1502 };
1503
1504 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
1505
1506 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
1507 {
1508     return QueryInterface(riid, ppv);
1509 }
1510
1511 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
1512 {
1513     return 2;
1514 }
1515
1516 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
1517 {
1518     return 1;
1519 }
1520
1521 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
1522 {
1523     ok(0, "unexpected call\n");
1524     return E_NOTIMPL;
1525 }
1526
1527 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
1528         IMoniker **ppmon)
1529 {
1530     ok(0, "unexpected call\n");
1531     return E_NOTIMPL;
1532 }
1533
1534 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
1535 {
1536     return E_NOTIMPL;
1537 }
1538
1539 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
1540 {
1541     ok(0, "unexpected call\n");
1542     return E_NOTIMPL;
1543 }
1544
1545 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
1546 {
1547     ok(0, "unexpected call\n");
1548     return E_NOTIMPL;
1549 }
1550
1551 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
1552 {
1553     ok(0, "unexpected call\n");
1554     return E_NOTIMPL;
1555 }
1556
1557 static const IOleClientSiteVtbl ClientSiteVtbl = {
1558     ClientSite_QueryInterface,
1559     ClientSite_AddRef,
1560     ClientSite_Release,
1561     ClientSite_SaveObject,
1562     ClientSite_GetMoniker,
1563     ClientSite_GetContainer,
1564     ClientSite_ShowObject,
1565     ClientSite_OnShowWindow,
1566     ClientSite_RequestNewObjectLayout
1567 };
1568
1569 static IOleClientSite ClientSite = { &ClientSiteVtbl };
1570
1571 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
1572 {
1573     return QueryInterface(riid, ppv);
1574 }
1575
1576 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
1577 {
1578     return 2;
1579 }
1580
1581 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
1582 {
1583     return 1;
1584 }
1585
1586 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
1587 {
1588     RECT rect = {0,0,300,300};
1589     IOleDocument *document;
1590     HRESULT hres;
1591
1592     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
1593     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
1594
1595     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
1596     IOleDocument_Release(document);
1597     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
1598
1599     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
1600     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
1601
1602     hres = IOleDocumentView_UIActivate(view, TRUE);
1603     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
1604
1605     hres = IOleDocumentView_SetRect(view, &rect);
1606     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
1607
1608     hres = IOleDocumentView_Show(view, TRUE);
1609     ok(hres == S_OK, "Show failed: %08x\n", hres);
1610
1611     return S_OK;
1612 }
1613
1614 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
1615     DocumentSite_QueryInterface,
1616     DocumentSite_AddRef,
1617     DocumentSite_Release,
1618     DocumentSite_ActivateMe
1619 };
1620
1621 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
1622
1623 static HRESULT QueryInterface(REFIID riid, void **ppv)
1624 {
1625     *ppv = NULL;
1626
1627     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1628         *ppv = &ClientSite;
1629     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1630         *ppv = &DocumentSite;
1631     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1632         *ppv = &InPlaceSite;
1633
1634     return *ppv ? S_OK : E_NOINTERFACE;
1635 }
1636
1637 static IHTMLDocument2 *notif_doc;
1638 static BOOL doc_complete;
1639
1640 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
1641         REFIID riid, void**ppv)
1642 {
1643     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
1644         *ppv = iface;
1645         return S_OK;
1646     }
1647
1648     ok(0, "unexpected call\n");
1649     return E_NOINTERFACE;
1650 }
1651
1652 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
1653 {
1654     return 2;
1655 }
1656
1657 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
1658 {
1659     return 1;
1660 }
1661
1662 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
1663 {
1664     if(dispID == DISPID_READYSTATE){
1665         BSTR state;
1666         HRESULT hres;
1667
1668         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
1669         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
1670
1671         if(!strcmp_wa(state, "complete"))
1672             doc_complete = TRUE;
1673
1674         SysFreeString(state);
1675     }
1676
1677     return S_OK;
1678 }
1679
1680 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
1681 {
1682     ok(0, "unexpected call\n");
1683     return E_NOTIMPL;
1684 }
1685
1686 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
1687     PropertyNotifySink_QueryInterface,
1688     PropertyNotifySink_AddRef,
1689     PropertyNotifySink_Release,
1690     PropertyNotifySink_OnChanged,
1691     PropertyNotifySink_OnRequestEdit
1692 };
1693
1694 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
1695
1696 static void doc_load_string(IHTMLDocument2 *doc, const char *str)
1697 {
1698     IPersistStreamInit *init;
1699     IStream *stream;
1700     HGLOBAL mem;
1701     SIZE_T len;
1702
1703     notif_doc = doc;
1704
1705     doc_complete = FALSE;
1706     len = strlen(str);
1707     mem = GlobalAlloc(0, len);
1708     memcpy(mem, str, len);
1709     CreateStreamOnHGlobal(mem, TRUE, &stream);
1710
1711     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
1712
1713     IPersistStreamInit_Load(init, stream);
1714     IPersistStreamInit_Release(init);
1715     IStream_Release(stream);
1716 }
1717
1718 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
1719 {
1720     IConnectionPointContainer *container;
1721     IConnectionPoint *cp;
1722     DWORD cookie;
1723     HRESULT hres;
1724
1725     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
1726     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
1727
1728     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
1729     IConnectionPointContainer_Release(container);
1730     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
1731
1732     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
1733     IConnectionPoint_Release(cp);
1734     ok(hres == S_OK, "Advise failed: %08x\n", hres);
1735 }
1736
1737 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
1738 {
1739     IOleObject *oleobj;
1740     HRESULT hres;
1741
1742     if(!set && view) {
1743         IOleDocumentView_Show(view, FALSE);
1744         IOleDocumentView_CloseView(view, 0);
1745         IOleDocumentView_SetInPlaceSite(view, NULL);
1746         IOleDocumentView_Release(view);
1747         view = NULL;
1748     }
1749
1750     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
1751     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
1752
1753     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
1754     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
1755
1756     if(set) {
1757         IHlinkTarget *hlink;
1758
1759         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
1760         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
1761
1762         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
1763         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
1764
1765         IHlinkTarget_Release(hlink);
1766     }
1767
1768     IOleObject_Release(oleobj);
1769 }
1770 static IHTMLDocument2 *create_document(void)
1771 {
1772     IHTMLDocument2 *doc;
1773     HRESULT hres;
1774
1775     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1776             &IID_IHTMLDocument2, (void**)&doc);
1777     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
1778
1779     return doc;
1780 }
1781
1782
1783 typedef void (*testfunc_t)(IHTMLDocument2*);
1784
1785 static void run_test(const char *str, testfunc_t test)
1786 {
1787     IHTMLDocument2 *doc;
1788     IHTMLElement *body = NULL;
1789     ULONG ref;
1790     MSG msg;
1791     HRESULT hres;
1792
1793     xy_todo = FALSE;
1794     doc = create_document();
1795     set_client_site(doc, TRUE);
1796     doc_load_string(doc, str);
1797     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
1798
1799     while(!doc_complete && GetMessage(&msg, NULL, 0, 0)) {
1800         TranslateMessage(&msg);
1801         DispatchMessage(&msg);
1802     }
1803
1804     hres = IHTMLDocument2_get_body(doc, &body);
1805     ok(hres == S_OK, "get_body failed: %08x\n", hres);
1806
1807     if(body) {
1808         IHTMLElement_Release(body);
1809
1810         hres = IHTMLDocument2_get_parentWindow(doc, &window);
1811         ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
1812         ok(window != NULL, "window == NULL\n");
1813
1814         test(doc);
1815
1816         IHTMLWindow2_Release(window);
1817         window = NULL;
1818     }else {
1819         skip("Could not get document body. Assuming no Gecko installed.\n");
1820     }
1821
1822     set_client_site(doc, FALSE);
1823     ref = IHTMLDocument2_Release(doc);
1824     ok(!ref, "ref = %d\n", ref);
1825 }
1826
1827 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
1828 {
1829     return DefWindowProc(hwnd, msg, wParam, lParam);
1830 }
1831
1832 static HWND create_container_window(void)
1833 {
1834     static const CHAR szHTMLDocumentTest[] = "HTMLDocumentTest";
1835     static WNDCLASSEXA wndclass = {
1836         sizeof(WNDCLASSEXA),
1837         0,
1838         wnd_proc,
1839         0, 0, NULL, NULL, NULL, NULL, NULL,
1840         szHTMLDocumentTest,
1841         NULL
1842     };
1843
1844     RegisterClassExA(&wndclass);
1845     return CreateWindowA(szHTMLDocumentTest, szHTMLDocumentTest,
1846             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
1847             300, 300, NULL, NULL, NULL, NULL);
1848 }
1849
1850 START_TEST(events)
1851 {
1852     CoInitialize(NULL);
1853     container_hwnd = create_container_window();
1854
1855     if(winetest_interactive)
1856         ShowWindow(container_hwnd, SW_SHOW);
1857
1858     run_test(empty_doc_str, test_timeout);
1859     run_test(click_doc_str, test_onclick);
1860     run_test(readystate_doc_str, test_onreadystatechange);
1861
1862     DestroyWindow(container_hwnd);
1863     CoUninitialize();
1864 }