git.oblomov.eu Git - wine/blob - dlls/mshtml/tests/events.c

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