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