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