dlls/mshtml/htmldoc.c

   1 /*
   2  * Copyright 2005-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 #include "config.h"
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23 #include <assert.h>
  24
  25 #define COBJMACROS
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "wininet.h"
  31 #include "ole2.h"
  32 #include "perhist.h"
  33 #include "mshtmdid.h"
  34 #include "mshtmcid.h"
  35
  36 #include "wine/debug.h"
  37
  38 #include "mshtml_private.h"
  39 #include "htmlevent.h"
  40 #include "pluginhost.h"
  41 #include "binding.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  44
  45 static HRESULT create_document_fragment(nsIDOMNode *nsnode, HTMLDocumentNode *doc_node, HTMLDocumentNode **ret);
  46
  47 HRESULT get_doc_elem_by_id(HTMLDocumentNode *doc, const WCHAR *id, HTMLElement **ret)
  48 {
  49     nsIDOMNodeList *nsnode_list;
  50     nsIDOMElement *nselem;
  51     nsIDOMNode *nsnode;
  52     nsAString id_str;
  53     nsresult nsres;
  54     HRESULT hres;
  55
  56     if(!doc->nsdoc) {
  57         WARN("NULL nsdoc\n");
  58         return E_UNEXPECTED;
  59     }
  60
  61     nsAString_InitDepend(&id_str, id);
  62     /* get element by id attribute */
  63     nsres = nsIDOMHTMLDocument_GetElementById(doc->nsdoc, &id_str, &nselem);
  64     if(FAILED(nsres)) {
  65         ERR("GetElementById failed: %08x\n", nsres);
  66         nsAString_Finish(&id_str);
  67         return E_FAIL;
  68     }
  69
  70     /* get first element by name attribute */
  71     nsres = nsIDOMHTMLDocument_GetElementsByName(doc->nsdoc, &id_str, &nsnode_list);
  72     nsAString_Finish(&id_str);
  73     if(FAILED(nsres)) {
  74         ERR("getElementsByName failed: %08x\n", nsres);
  75         if(nselem)
  76             nsIDOMElement_Release(nselem);
  77         return E_FAIL;
  78     }
  79
  80     nsres = nsIDOMNodeList_Item(nsnode_list, 0, &nsnode);
  81     nsIDOMNodeList_Release(nsnode_list);
  82     assert(nsres == NS_OK);
  83
  84     if(nsnode && nselem) {
  85         UINT16 pos;
  86
  87         nsres = nsIDOMNode_CompareDocumentPosition(nsnode, (nsIDOMNode*)nselem, &pos);
  88         if(NS_FAILED(nsres)) {
  89             FIXME("CompareDocumentPosition failed: 0x%08x\n", nsres);
  90             nsIDOMNode_Release(nsnode);
  91             nsIDOMElement_Release(nselem);
  92             return E_FAIL;
  93         }
  94
  95         TRACE("CompareDocumentPosition gave: 0x%x\n", pos);
  96         if(!(pos & (DOCUMENT_POSITION_PRECEDING | DOCUMENT_POSITION_CONTAINS))) {
  97             nsIDOMElement_Release(nselem);
  98             nselem = NULL;
  99         }
 100     }
 101
 102     if(nsnode) {
 103         if(!nselem) {
 104             nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMElement, (void**)&nselem);
 105             assert(nsres == NS_OK);
 106         }
 107         nsIDOMNode_Release(nsnode);
 108     }
 109
 110     if(!nselem) {
 111         *ret = NULL;
 112         return S_OK;
 113     }
 114
 115     hres = get_element(nselem, ret);
 116     nsIDOMElement_Release(nselem);
 117     return hres;
 118 }
 119
 120 UINT get_document_charset(HTMLDocumentNode *doc)
 121 {
 122     nsAString charset_str;
 123     UINT ret = 0;
 124     nsresult nsres;
 125
 126     if(doc->charset)
 127         return doc->charset;
 128
 129     nsAString_Init(&charset_str, NULL);
 130     nsres = nsIDOMHTMLDocument_GetCharacterSet(doc->nsdoc, &charset_str);
 131     if(NS_SUCCEEDED(nsres)) {
 132         const PRUnichar *charset;
 133
 134         nsAString_GetData(&charset_str, &charset);
 135
 136         if(*charset) {
 137             BSTR str = SysAllocString(charset);
 138             ret = cp_from_charset_string(str);
 139             SysFreeString(str);
 140         }
 141     }else {
 142         ERR("GetCharset failed: %08x\n", nsres);
 143     }
 144     nsAString_Finish(&charset_str);
 145
 146     if(!ret)
 147         return CP_UTF8;
 148
 149     return doc->charset = ret;
 150 }
 151
 152 static inline HTMLDocument *impl_from_IHTMLDocument2(IHTMLDocument2 *iface)
 153 {
 154     return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument2_iface);
 155 }
 156
 157 static HRESULT WINAPI HTMLDocument_QueryInterface(IHTMLDocument2 *iface, REFIID riid, void **ppv)
 158 {
 159     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 160
 161     return htmldoc_query_interface(This, riid, ppv);
 162 }
 163
 164 static ULONG WINAPI HTMLDocument_AddRef(IHTMLDocument2 *iface)
 165 {
 166     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 167
 168     return htmldoc_addref(This);
 169 }
 170
 171 static ULONG WINAPI HTMLDocument_Release(IHTMLDocument2 *iface)
 172 {
 173     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 174
 175     return htmldoc_release(This);
 176 }
 177
 178 static HRESULT WINAPI HTMLDocument_GetTypeInfoCount(IHTMLDocument2 *iface, UINT *pctinfo)
 179 {
 180     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 181
 182     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
 183 }
 184
 185 static HRESULT WINAPI HTMLDocument_GetTypeInfo(IHTMLDocument2 *iface, UINT iTInfo,
 186                                                 LCID lcid, ITypeInfo **ppTInfo)
 187 {
 188     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 189
 190     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 191 }
 192
 193 static HRESULT WINAPI HTMLDocument_GetIDsOfNames(IHTMLDocument2 *iface, REFIID riid,
 194                                                 LPOLESTR *rgszNames, UINT cNames,
 195                                                 LCID lcid, DISPID *rgDispId)
 196 {
 197     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 198
 199     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
 200             rgDispId);
 201 }
 202
 203 static HRESULT WINAPI HTMLDocument_Invoke(IHTMLDocument2 *iface, DISPID dispIdMember,
 204                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 205                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 206 {
 207     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 208
 209     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 210             pDispParams, pVarResult, pExcepInfo, puArgErr);
 211 }
 212
 213 static HRESULT WINAPI HTMLDocument_get_Script(IHTMLDocument2 *iface, IDispatch **p)
 214 {
 215     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 216
 217     TRACE("(%p)->(%p)\n", This, p);
 218
 219     *p = (IDispatch*)&This->window->base.IHTMLWindow2_iface;
 220     IDispatch_AddRef(*p);
 221     return S_OK;
 222 }
 223
 224 static HRESULT WINAPI HTMLDocument_get_all(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 225 {
 226     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 227     nsIDOMElement *nselem = NULL;
 228     HTMLDOMNode *node;
 229     nsresult nsres;
 230     HRESULT hres;
 231
 232     TRACE("(%p)->(%p)\n", This, p);
 233
 234     if(!This->doc_node->nsdoc) {
 235         WARN("NULL nsdoc\n");
 236         return E_UNEXPECTED;
 237     }
 238
 239     nsres = nsIDOMHTMLDocument_GetDocumentElement(This->doc_node->nsdoc, &nselem);
 240     if(NS_FAILED(nsres)) {
 241         ERR("GetDocumentElement failed: %08x\n", nsres);
 242         return E_FAIL;
 243     }
 244
 245     if(!nselem) {
 246         *p = NULL;
 247         return S_OK;
 248     }
 249
 250     hres = get_node((nsIDOMNode*)nselem, TRUE, &node);
 251     nsIDOMElement_Release(nselem);
 252     if(FAILED(hres))
 253         return hres;
 254
 255     *p = create_all_collection(node, TRUE);
 256     node_release(node);
 257     return hres;
 258 }
 259
 260 static HRESULT WINAPI HTMLDocument_get_body(IHTMLDocument2 *iface, IHTMLElement **p)
 261 {
 262     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 263     nsIDOMHTMLElement *nsbody = NULL;
 264     HTMLElement *element;
 265     HRESULT hres;
 266
 267     TRACE("(%p)->(%p)\n", This, p);
 268
 269     if(This->doc_node->nsdoc) {
 270         nsresult nsres;
 271
 272         nsres = nsIDOMHTMLDocument_GetBody(This->doc_node->nsdoc, &nsbody);
 273         if(NS_FAILED(nsres)) {
 274             TRACE("Could not get body: %08x\n", nsres);
 275             return E_UNEXPECTED;
 276         }
 277     }
 278
 279     if(!nsbody) {
 280         *p = NULL;
 281         return S_OK;
 282     }
 283
 284     hres = get_element((nsIDOMElement*)nsbody, &element);
 285     nsIDOMHTMLElement_Release(nsbody);
 286     if(FAILED(hres))
 287         return hres;
 288
 289     *p = &element->IHTMLElement_iface;
 290     return S_OK;
 291 }
 292
 293 static HRESULT WINAPI HTMLDocument_get_activeElement(IHTMLDocument2 *iface, IHTMLElement **p)
 294 {
 295     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 296     nsIDOMElement *nselem;
 297     HTMLElement *elem;
 298     nsresult nsres;
 299     HRESULT hres;
 300
 301     TRACE("(%p)->(%p)\n", This, p);
 302
 303     if(!This->doc_node->nsdoc) {
 304         *p = NULL;
 305         return S_OK;
 306     }
 307
 308     /*
 309      * NOTE: Gecko may return an active element even if the document is not visible.
 310      * IE returns NULL in this case.
 311      */
 312     nsres = nsIDOMHTMLDocument_GetActiveElement(This->doc_node->nsdoc, &nselem);
 313     if(NS_FAILED(nsres)) {
 314         ERR("GetActiveElement failed: %08x\n", nsres);
 315         return E_FAIL;
 316     }
 317
 318     if(!nselem) {
 319         *p = NULL;
 320         return S_OK;
 321     }
 322
 323     hres = get_element(nselem, &elem);
 324     nsIDOMElement_Release(nselem);
 325     if(FAILED(hres))
 326         return hres;
 327
 328     *p = &elem->IHTMLElement_iface;
 329     return S_OK;
 330 }
 331
 332 static HRESULT WINAPI HTMLDocument_get_images(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 333 {
 334     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 335     nsIDOMHTMLCollection *nscoll = NULL;
 336     nsresult nsres;
 337
 338     TRACE("(%p)->(%p)\n", This, p);
 339
 340     if(!p)
 341         return E_INVALIDARG;
 342
 343     *p = NULL;
 344
 345     if(!This->doc_node->nsdoc) {
 346         WARN("NULL nsdoc\n");
 347         return E_UNEXPECTED;
 348     }
 349
 350     nsres = nsIDOMHTMLDocument_GetImages(This->doc_node->nsdoc, &nscoll);
 351     if(NS_FAILED(nsres)) {
 352         ERR("GetImages failed: %08x\n", nsres);
 353         return E_FAIL;
 354     }
 355
 356     if(nscoll) {
 357         *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
 358         nsIDOMHTMLCollection_Release(nscoll);
 359     }
 360
 361     return S_OK;
 362 }
 363
 364 static HRESULT WINAPI HTMLDocument_get_applets(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 365 {
 366     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 367     nsIDOMHTMLCollection *nscoll = NULL;
 368     nsresult nsres;
 369
 370     TRACE("(%p)->(%p)\n", This, p);
 371
 372     if(!p)
 373         return E_INVALIDARG;
 374
 375     *p = NULL;
 376
 377     if(!This->doc_node->nsdoc) {
 378         WARN("NULL nsdoc\n");
 379         return E_UNEXPECTED;
 380     }
 381
 382     nsres = nsIDOMHTMLDocument_GetApplets(This->doc_node->nsdoc, &nscoll);
 383     if(NS_FAILED(nsres)) {
 384         ERR("GetApplets failed: %08x\n", nsres);
 385         return E_FAIL;
 386     }
 387
 388     if(nscoll) {
 389         *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
 390         nsIDOMHTMLCollection_Release(nscoll);
 391     }
 392
 393     return S_OK;
 394 }
 395
 396 static HRESULT WINAPI HTMLDocument_get_links(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 397 {
 398     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 399     nsIDOMHTMLCollection *nscoll = NULL;
 400     nsresult nsres;
 401
 402     TRACE("(%p)->(%p)\n", This, p);
 403
 404     if(!p)
 405         return E_INVALIDARG;
 406
 407     *p = NULL;
 408
 409     if(!This->doc_node->nsdoc) {
 410         WARN("NULL nsdoc\n");
 411         return E_UNEXPECTED;
 412     }
 413
 414     nsres = nsIDOMHTMLDocument_GetLinks(This->doc_node->nsdoc, &nscoll);
 415     if(NS_FAILED(nsres)) {
 416         ERR("GetLinks failed: %08x\n", nsres);
 417         return E_FAIL;
 418     }
 419
 420     if(nscoll) {
 421         *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
 422         nsIDOMHTMLCollection_Release(nscoll);
 423     }
 424
 425     return S_OK;
 426 }
 427
 428 static HRESULT WINAPI HTMLDocument_get_forms(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 429 {
 430     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 431     nsIDOMHTMLCollection *nscoll = NULL;
 432     nsresult nsres;
 433
 434     TRACE("(%p)->(%p)\n", This, p);
 435
 436     if(!p)
 437         return E_INVALIDARG;
 438
 439     *p = NULL;
 440
 441     if(!This->doc_node->nsdoc) {
 442         WARN("NULL nsdoc\n");
 443         return E_UNEXPECTED;
 444     }
 445
 446     nsres = nsIDOMHTMLDocument_GetForms(This->doc_node->nsdoc, &nscoll);
 447     if(NS_FAILED(nsres)) {
 448         ERR("GetForms failed: %08x\n", nsres);
 449         return E_FAIL;
 450     }
 451
 452     if(nscoll) {
 453         *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
 454         nsIDOMHTMLCollection_Release(nscoll);
 455     }
 456
 457     return S_OK;
 458 }
 459
 460 static HRESULT WINAPI HTMLDocument_get_anchors(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 461 {
 462     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 463     nsIDOMHTMLCollection *nscoll = NULL;
 464     nsresult nsres;
 465
 466     TRACE("(%p)->(%p)\n", This, p);
 467
 468     if(!p)
 469         return E_INVALIDARG;
 470
 471     *p = NULL;
 472
 473     if(!This->doc_node->nsdoc) {
 474         WARN("NULL nsdoc\n");
 475         return E_UNEXPECTED;
 476     }
 477
 478     nsres = nsIDOMHTMLDocument_GetAnchors(This->doc_node->nsdoc, &nscoll);
 479     if(NS_FAILED(nsres)) {
 480         ERR("GetAnchors failed: %08x\n", nsres);
 481         return E_FAIL;
 482     }
 483
 484     if(nscoll) {
 485         *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
 486         nsIDOMHTMLCollection_Release(nscoll);
 487     }
 488
 489     return S_OK;
 490 }
 491
 492 static HRESULT WINAPI HTMLDocument_put_title(IHTMLDocument2 *iface, BSTR v)
 493 {
 494     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 495     nsAString nsstr;
 496     nsresult nsres;
 497
 498     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 499
 500     if(!This->doc_node->nsdoc) {
 501         WARN("NULL nsdoc\n");
 502         return E_UNEXPECTED;
 503     }
 504
 505     nsAString_InitDepend(&nsstr, v);
 506     nsres = nsIDOMHTMLDocument_SetTitle(This->doc_node->nsdoc, &nsstr);
 507     nsAString_Finish(&nsstr);
 508     if(NS_FAILED(nsres))
 509         ERR("SetTitle failed: %08x\n", nsres);
 510
 511     return S_OK;
 512 }
 513
 514 static HRESULT WINAPI HTMLDocument_get_title(IHTMLDocument2 *iface, BSTR *p)
 515 {
 516     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 517     const PRUnichar *ret;
 518     nsAString nsstr;
 519     nsresult nsres;
 520
 521     TRACE("(%p)->(%p)\n", This, p);
 522
 523     if(!This->doc_node->nsdoc) {
 524         WARN("NULL nsdoc\n");
 525         return E_UNEXPECTED;
 526     }
 527
 528
 529     nsAString_Init(&nsstr, NULL);
 530     nsres = nsIDOMHTMLDocument_GetTitle(This->doc_node->nsdoc, &nsstr);
 531     if (NS_SUCCEEDED(nsres)) {
 532         nsAString_GetData(&nsstr, &ret);
 533         *p = SysAllocString(ret);
 534     }
 535     nsAString_Finish(&nsstr);
 536
 537     if(NS_FAILED(nsres)) {
 538         ERR("GetTitle failed: %08x\n", nsres);
 539         return E_FAIL;
 540     }
 541
 542     return S_OK;
 543 }
 544
 545 static HRESULT WINAPI HTMLDocument_get_scripts(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 546 {
 547     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 548     nsIDOMHTMLCollection *nscoll = NULL;
 549     nsresult nsres;
 550
 551     TRACE("(%p)->(%p)\n", This, p);
 552
 553     if(!p)
 554         return E_INVALIDARG;
 555
 556     *p = NULL;
 557
 558     if(!This->doc_node->nsdoc) {
 559         WARN("NULL nsdoc\n");
 560         return E_UNEXPECTED;
 561     }
 562
 563     nsres = nsIDOMHTMLDocument_GetScripts(This->doc_node->nsdoc, &nscoll);
 564     if(NS_FAILED(nsres)) {
 565         ERR("GetImages failed: %08x\n", nsres);
 566         return E_FAIL;
 567     }
 568
 569     if(nscoll) {
 570         *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
 571         nsIDOMHTMLCollection_Release(nscoll);
 572     }
 573
 574     return S_OK;
 575 }
 576
 577 static HRESULT WINAPI HTMLDocument_put_designMode(IHTMLDocument2 *iface, BSTR v)
 578 {
 579     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 580     HRESULT hres;
 581
 582     static const WCHAR onW[] = {'o','n',0};
 583
 584     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 585
 586     if(strcmpiW(v, onW)) {
 587         FIXME("Unsupported arg %s\n", debugstr_w(v));
 588         return E_NOTIMPL;
 589     }
 590
 591     hres = setup_edit_mode(This->doc_obj);
 592     if(FAILED(hres))
 593         return hres;
 594
 595     call_property_onchanged(&This->cp_container, DISPID_IHTMLDOCUMENT2_DESIGNMODE);
 596     return S_OK;
 597 }
 598
 599 static HRESULT WINAPI HTMLDocument_get_designMode(IHTMLDocument2 *iface, BSTR *p)
 600 {
 601     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 602     static const WCHAR szOff[] = {'O','f','f',0};
 603     FIXME("(%p)->(%p) always returning Off\n", This, p);
 604
 605     if(!p)
 606         return E_INVALIDARG;
 607
 608     *p = SysAllocString(szOff);
 609
 610     return S_OK;
 611 }
 612
 613 static HRESULT WINAPI HTMLDocument_get_selection(IHTMLDocument2 *iface, IHTMLSelectionObject **p)
 614 {
 615     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 616     nsISelection *nsselection;
 617     nsresult nsres;
 618
 619     TRACE("(%p)->(%p)\n", This, p);
 620
 621     nsres = nsIDOMWindow_GetSelection(This->window->nswindow, &nsselection);
 622     if(NS_FAILED(nsres)) {
 623         ERR("GetSelection failed: %08x\n", nsres);
 624         return E_FAIL;
 625     }
 626
 627     return HTMLSelectionObject_Create(This->doc_node, nsselection, p);
 628 }
 629
 630 static HRESULT WINAPI HTMLDocument_get_readyState(IHTMLDocument2 *iface, BSTR *p)
 631 {
 632     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 633
 634
 635     TRACE("(%p)->(%p)\n", iface, p);
 636
 637     if(!p)
 638         return E_POINTER;
 639
 640     return get_readystate_string(This->window->readystate, p);
 641 }
 642
 643 static HRESULT WINAPI HTMLDocument_get_frames(IHTMLDocument2 *iface, IHTMLFramesCollection2 **p)
 644 {
 645     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 646
 647     TRACE("(%p)->(%p)\n", This, p);
 648
 649     return IHTMLWindow2_get_frames(&This->window->base.IHTMLWindow2_iface, p);
 650 }
 651
 652 static HRESULT WINAPI HTMLDocument_get_embeds(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 653 {
 654     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 655     FIXME("(%p)->(%p)\n", This, p);
 656     return E_NOTIMPL;
 657 }
 658
 659 static HRESULT WINAPI HTMLDocument_get_plugins(IHTMLDocument2 *iface, IHTMLElementCollection **p)
 660 {
 661     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 662     FIXME("(%p)->(%p)\n", This, p);
 663     return E_NOTIMPL;
 664 }
 665
 666 static HRESULT WINAPI HTMLDocument_put_alinkColor(IHTMLDocument2 *iface, VARIANT v)
 667 {
 668     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 669     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI HTMLDocument_get_alinkColor(IHTMLDocument2 *iface, VARIANT *p)
 674 {
 675     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 676     FIXME("(%p)->(%p)\n", This, p);
 677     return E_NOTIMPL;
 678 }
 679
 680 static HRESULT WINAPI HTMLDocument_put_bgColor(IHTMLDocument2 *iface, VARIANT v)
 681 {
 682     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 683     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 684     return E_NOTIMPL;
 685 }
 686
 687 static HRESULT WINAPI HTMLDocument_get_bgColor(IHTMLDocument2 *iface, VARIANT *p)
 688 {
 689     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 690     FIXME("(%p)->(%p)\n", This, p);
 691     return E_NOTIMPL;
 692 }
 693
 694 static HRESULT WINAPI HTMLDocument_put_fgColor(IHTMLDocument2 *iface, VARIANT v)
 695 {
 696     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 697     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 698     return E_NOTIMPL;
 699 }
 700
 701 static HRESULT WINAPI HTMLDocument_get_fgColor(IHTMLDocument2 *iface, VARIANT *p)
 702 {
 703     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 704     FIXME("(%p)->(%p)\n", This, p);
 705     return E_NOTIMPL;
 706 }
 707
 708 static HRESULT WINAPI HTMLDocument_put_linkColor(IHTMLDocument2 *iface, VARIANT v)
 709 {
 710     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 711     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 712     return E_NOTIMPL;
 713 }
 714
 715 static HRESULT WINAPI HTMLDocument_get_linkColor(IHTMLDocument2 *iface, VARIANT *p)
 716 {
 717     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 718     FIXME("(%p)->(%p)\n", This, p);
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI HTMLDocument_put_vlinkColor(IHTMLDocument2 *iface, VARIANT v)
 723 {
 724     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 725     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 726     return E_NOTIMPL;
 727 }
 728
 729 static HRESULT WINAPI HTMLDocument_get_vlinkColor(IHTMLDocument2 *iface, VARIANT *p)
 730 {
 731     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 732     FIXME("(%p)->(%p)\n", This, p);
 733     return E_NOTIMPL;
 734 }
 735
 736 static HRESULT WINAPI HTMLDocument_get_referrer(IHTMLDocument2 *iface, BSTR *p)
 737 {
 738     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 739
 740     FIXME("(%p)->(%p)\n", This, p);
 741
 742     *p = NULL;
 743     return S_OK;
 744  }
 745
 746 static HRESULT WINAPI HTMLDocument_get_location(IHTMLDocument2 *iface, IHTMLLocation **p)
 747 {
 748     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 749
 750     TRACE("(%p)->(%p)\n", This, p);
 751
 752     if(!This->doc_node->nsdoc) {
 753         WARN("NULL nsdoc\n");
 754         return E_UNEXPECTED;
 755     }
 756
 757     return IHTMLWindow2_get_location(&This->window->base.IHTMLWindow2_iface, p);
 758 }
 759
 760 static HRESULT WINAPI HTMLDocument_get_lastModified(IHTMLDocument2 *iface, BSTR *p)
 761 {
 762     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 763     FIXME("(%p)->(%p)\n", This, p);
 764     return E_NOTIMPL;
 765 }
 766
 767 static HRESULT WINAPI HTMLDocument_put_URL(IHTMLDocument2 *iface, BSTR v)
 768 {
 769     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 770
 771     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 772
 773     if(!This->window) {
 774         FIXME("No window available\n");
 775         return E_FAIL;
 776     }
 777
 778     return navigate_url(This->window, v, This->window->uri, BINDING_NAVIGATED);
 779 }
 780
 781 static HRESULT WINAPI HTMLDocument_get_URL(IHTMLDocument2 *iface, BSTR *p)
 782 {
 783     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 784
 785     static const WCHAR about_blank_url[] =
 786         {'a','b','o','u','t',':','b','l','a','n','k',0};
 787
 788     TRACE("(%p)->(%p)\n", iface, p);
 789
 790     *p = SysAllocString(This->window->url ? This->window->url : about_blank_url);
 791     return *p ? S_OK : E_OUTOFMEMORY;
 792 }
 793
 794 static HRESULT WINAPI HTMLDocument_put_domain(IHTMLDocument2 *iface, BSTR v)
 795 {
 796     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 797     nsAString nsstr;
 798     nsresult nsres;
 799
 800     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 801
 802     nsAString_InitDepend(&nsstr, v);
 803     nsres = nsIDOMHTMLDocument_SetDomain(This->doc_node->nsdoc, &nsstr);
 804     nsAString_Finish(&nsstr);
 805     if(NS_FAILED(nsres)) {
 806         ERR("SetDomain failed: %08x\n", nsres);
 807         return E_INVALIDARG;
 808     }
 809
 810     return S_OK;
 811 }
 812
 813 static HRESULT WINAPI HTMLDocument_get_domain(IHTMLDocument2 *iface, BSTR *p)
 814 {
 815     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 816     nsAString nsstr;
 817     nsresult nsres;
 818
 819     TRACE("(%p)->(%p)\n", This, p);
 820
 821     nsAString_Init(&nsstr, NULL);
 822     nsres = nsIDOMHTMLDocument_GetDomain(This->doc_node->nsdoc, &nsstr);
 823     if(NS_SUCCEEDED(nsres) && This->window && This->window->uri) {
 824         const PRUnichar *str;
 825         HRESULT hres;
 826
 827         nsAString_GetData(&nsstr, &str);
 828         if(!*str) {
 829             TRACE("Gecko returned empty string, fallback to loaded URL.\n");
 830             nsAString_Finish(&nsstr);
 831             hres = IUri_GetHost(This->window->uri, p);
 832             return FAILED(hres) ? hres : S_OK;
 833         }
 834     }
 835
 836     return return_nsstr(nsres, &nsstr, p);
 837 }
 838
 839 static HRESULT WINAPI HTMLDocument_put_cookie(IHTMLDocument2 *iface, BSTR v)
 840 {
 841     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 842     BOOL bret;
 843
 844     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 845
 846     bret = InternetSetCookieExW(This->window->url, NULL, v, 0, 0);
 847     if(!bret) {
 848         FIXME("InternetSetCookieExW failed: %u\n", GetLastError());
 849         return HRESULT_FROM_WIN32(GetLastError());
 850     }
 851
 852     return S_OK;
 853 }
 854
 855 static HRESULT WINAPI HTMLDocument_get_cookie(IHTMLDocument2 *iface, BSTR *p)
 856 {
 857     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 858     DWORD size;
 859     BOOL bret;
 860
 861     TRACE("(%p)->(%p)\n", This, p);
 862
 863     size = 0;
 864     bret = InternetGetCookieExW(This->window->url, NULL, NULL, &size, 0, NULL);
 865     if(!bret) {
 866         switch(GetLastError()) {
 867         case ERROR_INSUFFICIENT_BUFFER:
 868             break;
 869         case ERROR_NO_MORE_ITEMS:
 870             *p = NULL;
 871             return S_OK;
 872         default:
 873             FIXME("InternetGetCookieExW failed: %u\n", GetLastError());
 874             return HRESULT_FROM_WIN32(GetLastError());
 875         }
 876     }
 877
 878     if(!size) {
 879         *p = NULL;
 880         return S_OK;
 881     }
 882
 883     *p = SysAllocStringLen(NULL, size/sizeof(WCHAR)-1);
 884     if(!*p)
 885         return E_OUTOFMEMORY;
 886
 887     bret = InternetGetCookieExW(This->window->url, NULL, *p, &size, 0, NULL);
 888     if(!bret) {
 889         ERR("InternetGetCookieExW failed: %u\n", GetLastError());
 890         return E_FAIL;
 891     }
 892
 893     return S_OK;
 894 }
 895
 896 static HRESULT WINAPI HTMLDocument_put_expando(IHTMLDocument2 *iface, VARIANT_BOOL v)
 897 {
 898     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 899     FIXME("(%p)->(%x)\n", This, v);
 900     return E_NOTIMPL;
 901 }
 902
 903 static HRESULT WINAPI HTMLDocument_get_expando(IHTMLDocument2 *iface, VARIANT_BOOL *p)
 904 {
 905     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 906     FIXME("(%p)->(%p)\n", This, p);
 907     return E_NOTIMPL;
 908 }
 909
 910 static HRESULT WINAPI HTMLDocument_put_charset(IHTMLDocument2 *iface, BSTR v)
 911 {
 912     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 913     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 914     return E_NOTIMPL;
 915 }
 916
 917 static HRESULT WINAPI HTMLDocument_get_charset(IHTMLDocument2 *iface, BSTR *p)
 918 {
 919     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 920
 921     TRACE("(%p)->(%p)\n", This, p);
 922
 923     return IHTMLDocument7_get_characterSet(&This->IHTMLDocument7_iface, p);
 924 }
 925
 926 static HRESULT WINAPI HTMLDocument_put_defaultCharset(IHTMLDocument2 *iface, BSTR v)
 927 {
 928     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 929     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 930     return E_NOTIMPL;
 931 }
 932
 933 static HRESULT WINAPI HTMLDocument_get_defaultCharset(IHTMLDocument2 *iface, BSTR *p)
 934 {
 935     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 936
 937     TRACE("(%p)->(%p)\n", This, p);
 938
 939     *p = charset_string_from_cp(GetACP());
 940     return *p ? S_OK : E_OUTOFMEMORY;
 941 }
 942
 943 static HRESULT WINAPI HTMLDocument_get_mimeType(IHTMLDocument2 *iface, BSTR *p)
 944 {
 945     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 946     FIXME("(%p)->(%p)\n", This, p);
 947     return E_NOTIMPL;
 948 }
 949
 950 static HRESULT WINAPI HTMLDocument_get_fileSize(IHTMLDocument2 *iface, BSTR *p)
 951 {
 952     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 953     FIXME("(%p)->(%p)\n", This, p);
 954     return E_NOTIMPL;
 955 }
 956
 957 static HRESULT WINAPI HTMLDocument_get_fileCreatedDate(IHTMLDocument2 *iface, BSTR *p)
 958 {
 959     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 960     FIXME("(%p)->(%p)\n", This, p);
 961     return E_NOTIMPL;
 962 }
 963
 964 static HRESULT WINAPI HTMLDocument_get_fileModifiedDate(IHTMLDocument2 *iface, BSTR *p)
 965 {
 966     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 967     FIXME("(%p)->(%p)\n", This, p);
 968     return E_NOTIMPL;
 969 }
 970
 971 static HRESULT WINAPI HTMLDocument_get_fileUpdatedDate(IHTMLDocument2 *iface, BSTR *p)
 972 {
 973     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 974     FIXME("(%p)->(%p)\n", This, p);
 975     return E_NOTIMPL;
 976 }
 977
 978 static HRESULT WINAPI HTMLDocument_get_security(IHTMLDocument2 *iface, BSTR *p)
 979 {
 980     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 981     FIXME("(%p)->(%p)\n", This, p);
 982     return E_NOTIMPL;
 983 }
 984
 985 static HRESULT WINAPI HTMLDocument_get_protocol(IHTMLDocument2 *iface, BSTR *p)
 986 {
 987     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 988     FIXME("(%p)->(%p)\n", This, p);
 989     return E_NOTIMPL;
 990 }
 991
 992 static HRESULT WINAPI HTMLDocument_get_nameProp(IHTMLDocument2 *iface, BSTR *p)
 993 {
 994     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
 995     FIXME("(%p)->(%p)\n", This, p);
 996     return E_NOTIMPL;
 997 }
 998
 999 static HRESULT document_write(HTMLDocument *This, SAFEARRAY *psarray, BOOL ln)
1000 {
1001     VARIANT *var, tmp;
1002     JSContext *jsctx;
1003     nsAString nsstr;
1004     ULONG i, argc;
1005     nsresult nsres;
1006     HRESULT hres;
1007
1008     if(!This->doc_node->nsdoc) {
1009         WARN("NULL nsdoc\n");
1010         return E_UNEXPECTED;
1011     }
1012
1013     if (!psarray)
1014         return S_OK;
1015
1016     if(psarray->cDims != 1) {
1017         FIXME("cDims=%d\n", psarray->cDims);
1018         return E_INVALIDARG;
1019     }
1020
1021     hres = SafeArrayAccessData(psarray, (void**)&var);
1022     if(FAILED(hres)) {
1023         WARN("SafeArrayAccessData failed: %08x\n", hres);
1024         return hres;
1025     }
1026
1027     V_VT(&tmp) = VT_EMPTY;
1028
1029     jsctx = get_context_from_document(This->doc_node->nsdoc);
1030     argc = psarray->rgsabound[0].cElements;
1031     for(i=0; i < argc; i++) {
1032         if(V_VT(var+i) == VT_BSTR) {
1033             nsAString_InitDepend(&nsstr, V_BSTR(var+i));
1034         }else {
1035             hres = VariantChangeTypeEx(&tmp, var+i, MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT), 0, VT_BSTR);
1036             if(FAILED(hres)) {
1037                 WARN("Could not convert %s to string\n", debugstr_variant(var+i));
1038                 break;
1039             }
1040             nsAString_InitDepend(&nsstr, V_BSTR(&tmp));
1041         }
1042
1043         if(!ln || i != argc-1)
1044             nsres = nsIDOMHTMLDocument_Write(This->doc_node->nsdoc, &nsstr, jsctx);
1045         else
1046             nsres = nsIDOMHTMLDocument_Writeln(This->doc_node->nsdoc, &nsstr, jsctx);
1047         nsAString_Finish(&nsstr);
1048         if(V_VT(var+i) != VT_BSTR)
1049             VariantClear(&tmp);
1050         if(NS_FAILED(nsres)) {
1051             ERR("Write failed: %08x\n", nsres);
1052             hres = E_FAIL;
1053             break;
1054         }
1055     }
1056
1057     SafeArrayUnaccessData(psarray);
1058
1059     return hres;
1060 }
1061
1062 static HRESULT WINAPI HTMLDocument_write(IHTMLDocument2 *iface, SAFEARRAY *psarray)
1063 {
1064     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1065
1066     TRACE("(%p)->(%p)\n", iface, psarray);
1067
1068     return document_write(This, psarray, FALSE);
1069 }
1070
1071 static HRESULT WINAPI HTMLDocument_writeln(IHTMLDocument2 *iface, SAFEARRAY *psarray)
1072 {
1073     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1074
1075     TRACE("(%p)->(%p)\n", This, psarray);
1076
1077     return document_write(This, psarray, TRUE);
1078 }
1079
1080 static HRESULT WINAPI HTMLDocument_open(IHTMLDocument2 *iface, BSTR url, VARIANT name,
1081                         VARIANT features, VARIANT replace, IDispatch **pomWindowResult)
1082 {
1083     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1084     nsISupports *tmp;
1085     nsresult nsres;
1086
1087     static const WCHAR text_htmlW[] = {'t','e','x','t','/','h','t','m','l',0};
1088
1089     TRACE("(%p)->(%s %s %s %s %p)\n", This, debugstr_w(url), debugstr_variant(&name),
1090           debugstr_variant(&features), debugstr_variant(&replace), pomWindowResult);
1091
1092     if(!This->doc_node->nsdoc) {
1093         ERR("!nsdoc\n");
1094         return E_NOTIMPL;
1095     }
1096
1097     if(!url || strcmpW(url, text_htmlW) || V_VT(&name) != VT_ERROR
1098        || V_VT(&features) != VT_ERROR || V_VT(&replace) != VT_ERROR)
1099         FIXME("unsupported args\n");
1100
1101     nsres = nsIDOMHTMLDocument_Open(This->doc_node->nsdoc, NULL, NULL, NULL,
1102             get_context_from_document(This->doc_node->nsdoc), 0, &tmp);
1103     if(NS_FAILED(nsres)) {
1104         ERR("Open failed: %08x\n", nsres);
1105         return E_FAIL;
1106     }
1107
1108     if(tmp)
1109         nsISupports_Release(tmp);
1110
1111     *pomWindowResult = (IDispatch*)&This->window->base.IHTMLWindow2_iface;
1112     IHTMLWindow2_AddRef(&This->window->base.IHTMLWindow2_iface);
1113     return S_OK;
1114 }
1115
1116 static HRESULT WINAPI HTMLDocument_close(IHTMLDocument2 *iface)
1117 {
1118     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1119     nsresult nsres;
1120
1121     TRACE("(%p)\n", This);
1122
1123     if(!This->doc_node->nsdoc) {
1124         ERR("!nsdoc\n");
1125         return E_NOTIMPL;
1126     }
1127
1128     nsres = nsIDOMHTMLDocument_Close(This->doc_node->nsdoc);
1129     if(NS_FAILED(nsres)) {
1130         ERR("Close failed: %08x\n", nsres);
1131         return E_FAIL;
1132     }
1133
1134     return S_OK;
1135 }
1136
1137 static HRESULT WINAPI HTMLDocument_clear(IHTMLDocument2 *iface)
1138 {
1139     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1140     nsresult nsres;
1141
1142     TRACE("(%p)\n", This);
1143
1144     nsres = nsIDOMHTMLDocument_Clear(This->doc_node->nsdoc);
1145     if(NS_FAILED(nsres)) {
1146         ERR("Clear failed: %08x\n", nsres);
1147         return E_FAIL;
1148     }
1149
1150     return S_OK;
1151 }
1152
1153 static const WCHAR copyW[] =
1154     {'c','o','p','y',0};
1155 static const WCHAR cutW[] =
1156     {'c','u','t',0};
1157 static const WCHAR fontnameW[] =
1158     {'f','o','n','t','n','a','m','e',0};
1159 static const WCHAR fontsizeW[] =
1160     {'f','o','n','t','s','i','z','e',0};
1161 static const WCHAR indentW[] =
1162     {'i','n','d','e','n','t',0};
1163 static const WCHAR insertorderedlistW[] =
1164     {'i','n','s','e','r','t','o','r','d','e','r','e','d','l','i','s','t',0};
1165 static const WCHAR insertunorderedlistW[] =
1166     {'i','n','s','e','r','t','u','n','o','r','d','e','r','e','d','l','i','s','t',0};
1167 static const WCHAR outdentW[] =
1168     {'o','u','t','d','e','n','t',0};
1169 static const WCHAR pasteW[] =
1170     {'p','a','s','t','e',0};
1171 static const WCHAR respectvisibilityindesignW[] =
1172     {'r','e','s','p','e','c','t','v','i','s','i','b','i','l','i','t','y','i','n','d','e','s','i','g','n',0};
1173
1174 static const struct {
1175     const WCHAR *name;
1176     OLECMDID id;
1177 }command_names[] = {
1178     {copyW, IDM_COPY},
1179     {cutW, IDM_CUT},
1180     {fontnameW, IDM_FONTNAME},
1181     {fontsizeW, IDM_FONTSIZE},
1182     {indentW, IDM_INDENT},
1183     {insertorderedlistW, IDM_ORDERLIST},
1184     {insertunorderedlistW, IDM_UNORDERLIST},
1185     {outdentW, IDM_OUTDENT},
1186     {pasteW, IDM_PASTE},
1187     {respectvisibilityindesignW, IDM_RESPECTVISIBILITY_INDESIGN}
1188 };
1189
1190 static BOOL cmdid_from_string(const WCHAR *str, OLECMDID *cmdid)
1191 {
1192     int i;
1193
1194     for(i = 0; i < ARRAY_SIZE(command_names); i++) {
1195         if(!strcmpiW(command_names[i].name, str)) {
1196             *cmdid = command_names[i].id;
1197             return TRUE;
1198         }
1199     }
1200
1201     FIXME("Unknown command %s\n", debugstr_w(str));
1202     return FALSE;
1203 }
1204
1205 static HRESULT WINAPI HTMLDocument_queryCommandSupported(IHTMLDocument2 *iface, BSTR cmdID,
1206                                                         VARIANT_BOOL *pfRet)
1207 {
1208     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1209     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1210     return E_NOTIMPL;
1211 }
1212
1213 static HRESULT WINAPI HTMLDocument_queryCommandEnabled(IHTMLDocument2 *iface, BSTR cmdID,
1214                                                         VARIANT_BOOL *pfRet)
1215 {
1216     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1217     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1218     return E_NOTIMPL;
1219 }
1220
1221 static HRESULT WINAPI HTMLDocument_queryCommandState(IHTMLDocument2 *iface, BSTR cmdID,
1222                                                         VARIANT_BOOL *pfRet)
1223 {
1224     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1225     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1226     return E_NOTIMPL;
1227 }
1228
1229 static HRESULT WINAPI HTMLDocument_queryCommandIndeterm(IHTMLDocument2 *iface, BSTR cmdID,
1230                                                         VARIANT_BOOL *pfRet)
1231 {
1232     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1233     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1234     return E_NOTIMPL;
1235 }
1236
1237 static HRESULT WINAPI HTMLDocument_queryCommandText(IHTMLDocument2 *iface, BSTR cmdID,
1238                                                         BSTR *pfRet)
1239 {
1240     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1241     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1242     return E_NOTIMPL;
1243 }
1244
1245 static HRESULT WINAPI HTMLDocument_queryCommandValue(IHTMLDocument2 *iface, BSTR cmdID,
1246                                                         VARIANT *pfRet)
1247 {
1248     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1249     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1250     return E_NOTIMPL;
1251 }
1252
1253 static HRESULT WINAPI HTMLDocument_execCommand(IHTMLDocument2 *iface, BSTR cmdID,
1254                                 VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet)
1255 {
1256     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1257     OLECMDID cmdid;
1258     VARIANT ret;
1259     HRESULT hres;
1260
1261     TRACE("(%p)->(%s %x %s %p)\n", This, debugstr_w(cmdID), showUI, debugstr_variant(&value), pfRet);
1262
1263     if(!cmdid_from_string(cmdID, &cmdid))
1264         return OLECMDERR_E_NOTSUPPORTED;
1265
1266     V_VT(&ret) = VT_EMPTY;
1267     hres = IOleCommandTarget_Exec(&This->IOleCommandTarget_iface, &CGID_MSHTML, cmdid,
1268             showUI ? 0 : OLECMDEXECOPT_DONTPROMPTUSER, &value, &ret);
1269     if(FAILED(hres))
1270         return hres;
1271
1272     if(V_VT(&ret) != VT_EMPTY) {
1273         FIXME("Handle ret %s\n", debugstr_variant(&ret));
1274         VariantClear(&ret);
1275     }
1276
1277     *pfRet = VARIANT_TRUE;
1278     return S_OK;
1279 }
1280
1281 static HRESULT WINAPI HTMLDocument_execCommandShowHelp(IHTMLDocument2 *iface, BSTR cmdID,
1282                                                         VARIANT_BOOL *pfRet)
1283 {
1284     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1285     FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1286     return E_NOTIMPL;
1287 }
1288
1289 static HRESULT WINAPI HTMLDocument_createElement(IHTMLDocument2 *iface, BSTR eTag,
1290                                                  IHTMLElement **newElem)
1291 {
1292     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1293     HTMLElement *elem;
1294     HRESULT hres;
1295
1296     TRACE("(%p)->(%s %p)\n", This, debugstr_w(eTag), newElem);
1297
1298     hres = create_element(This->doc_node, eTag, &elem);
1299     if(FAILED(hres))
1300         return hres;
1301
1302     *newElem = &elem->IHTMLElement_iface;
1303     return S_OK;
1304 }
1305
1306 static HRESULT WINAPI HTMLDocument_put_onhelp(IHTMLDocument2 *iface, VARIANT v)
1307 {
1308     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1309     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1310     return E_NOTIMPL;
1311 }
1312
1313 static HRESULT WINAPI HTMLDocument_get_onhelp(IHTMLDocument2 *iface, VARIANT *p)
1314 {
1315     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1316     FIXME("(%p)->(%p)\n", This, p);
1317     return E_NOTIMPL;
1318 }
1319
1320 static HRESULT WINAPI HTMLDocument_put_onclick(IHTMLDocument2 *iface, VARIANT v)
1321 {
1322     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1323
1324     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1325
1326     return set_doc_event(This, EVENTID_CLICK, &v);
1327 }
1328
1329 static HRESULT WINAPI HTMLDocument_get_onclick(IHTMLDocument2 *iface, VARIANT *p)
1330 {
1331     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1332
1333     TRACE("(%p)->(%p)\n", This, p);
1334
1335     return get_doc_event(This, EVENTID_CLICK, p);
1336 }
1337
1338 static HRESULT WINAPI HTMLDocument_put_ondblclick(IHTMLDocument2 *iface, VARIANT v)
1339 {
1340     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1341
1342     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1343
1344     return set_doc_event(This, EVENTID_DBLCLICK, &v);
1345 }
1346
1347 static HRESULT WINAPI HTMLDocument_get_ondblclick(IHTMLDocument2 *iface, VARIANT *p)
1348 {
1349     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1350
1351     TRACE("(%p)->(%p)\n", This, p);
1352
1353     return get_doc_event(This, EVENTID_DBLCLICK, p);
1354 }
1355
1356 static HRESULT WINAPI HTMLDocument_put_onkeyup(IHTMLDocument2 *iface, VARIANT v)
1357 {
1358     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1359
1360     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1361
1362     return set_doc_event(This, EVENTID_KEYUP, &v);
1363 }
1364
1365 static HRESULT WINAPI HTMLDocument_get_onkeyup(IHTMLDocument2 *iface, VARIANT *p)
1366 {
1367     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1368
1369     TRACE("(%p)->(%p)\n", This, p);
1370
1371     return get_doc_event(This, EVENTID_KEYUP, p);
1372 }
1373
1374 static HRESULT WINAPI HTMLDocument_put_onkeydown(IHTMLDocument2 *iface, VARIANT v)
1375 {
1376     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1377
1378     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1379
1380     return set_doc_event(This, EVENTID_KEYDOWN, &v);
1381 }
1382
1383 static HRESULT WINAPI HTMLDocument_get_onkeydown(IHTMLDocument2 *iface, VARIANT *p)
1384 {
1385     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1386
1387     TRACE("(%p)->(%p)\n", This, p);
1388
1389     return get_doc_event(This, EVENTID_KEYDOWN, p);
1390 }
1391
1392 static HRESULT WINAPI HTMLDocument_put_onkeypress(IHTMLDocument2 *iface, VARIANT v)
1393 {
1394     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1395
1396     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1397
1398     return set_doc_event(This, EVENTID_KEYPRESS, &v);
1399 }
1400
1401 static HRESULT WINAPI HTMLDocument_get_onkeypress(IHTMLDocument2 *iface, VARIANT *p)
1402 {
1403     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1404
1405     TRACE("(%p)->(%p)\n", This, p);
1406
1407     return get_doc_event(This, EVENTID_KEYPRESS, p);
1408 }
1409
1410 static HRESULT WINAPI HTMLDocument_put_onmouseup(IHTMLDocument2 *iface, VARIANT v)
1411 {
1412     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1413
1414     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1415
1416     return set_doc_event(This, EVENTID_MOUSEUP, &v);
1417 }
1418
1419 static HRESULT WINAPI HTMLDocument_get_onmouseup(IHTMLDocument2 *iface, VARIANT *p)
1420 {
1421     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1422
1423     TRACE("(%p)->(%p)\n", This, p);
1424
1425     return get_doc_event(This, EVENTID_MOUSEUP, p);
1426 }
1427
1428 static HRESULT WINAPI HTMLDocument_put_onmousedown(IHTMLDocument2 *iface, VARIANT v)
1429 {
1430     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1431
1432     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1433
1434     return set_doc_event(This, EVENTID_MOUSEDOWN, &v);
1435 }
1436
1437 static HRESULT WINAPI HTMLDocument_get_onmousedown(IHTMLDocument2 *iface, VARIANT *p)
1438 {
1439     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1440
1441     TRACE("(%p)->(%p)\n", This, p);
1442
1443     return get_doc_event(This, EVENTID_MOUSEDOWN, p);
1444 }
1445
1446 static HRESULT WINAPI HTMLDocument_put_onmousemove(IHTMLDocument2 *iface, VARIANT v)
1447 {
1448     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1449
1450     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1451
1452     return set_doc_event(This, EVENTID_MOUSEMOVE, &v);
1453 }
1454
1455 static HRESULT WINAPI HTMLDocument_get_onmousemove(IHTMLDocument2 *iface, VARIANT *p)
1456 {
1457     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1458
1459     TRACE("(%p)->(%p)\n", This, p);
1460
1461     return get_doc_event(This, EVENTID_MOUSEMOVE, p);
1462 }
1463
1464 static HRESULT WINAPI HTMLDocument_put_onmouseout(IHTMLDocument2 *iface, VARIANT v)
1465 {
1466     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1467
1468     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1469
1470     return set_doc_event(This, EVENTID_MOUSEOUT, &v);
1471 }
1472
1473 static HRESULT WINAPI HTMLDocument_get_onmouseout(IHTMLDocument2 *iface, VARIANT *p)
1474 {
1475     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1476
1477     TRACE("(%p)->(%p)\n", This, p);
1478
1479     return get_doc_event(This, EVENTID_MOUSEOUT, p);
1480 }
1481
1482 static HRESULT WINAPI HTMLDocument_put_onmouseover(IHTMLDocument2 *iface, VARIANT v)
1483 {
1484     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1485
1486     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1487
1488     return set_doc_event(This, EVENTID_MOUSEOVER, &v);
1489 }
1490
1491 static HRESULT WINAPI HTMLDocument_get_onmouseover(IHTMLDocument2 *iface, VARIANT *p)
1492 {
1493     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1494
1495     TRACE("(%p)->(%p)\n", This, p);
1496
1497     return get_doc_event(This, EVENTID_MOUSEOVER, p);
1498 }
1499
1500 static HRESULT WINAPI HTMLDocument_put_onreadystatechange(IHTMLDocument2 *iface, VARIANT v)
1501 {
1502     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1503
1504     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1505
1506     return set_doc_event(This, EVENTID_READYSTATECHANGE, &v);
1507 }
1508
1509 static HRESULT WINAPI HTMLDocument_get_onreadystatechange(IHTMLDocument2 *iface, VARIANT *p)
1510 {
1511     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1512
1513     TRACE("(%p)->(%p)\n", This, p);
1514
1515     return get_doc_event(This, EVENTID_READYSTATECHANGE, p);
1516 }
1517
1518 static HRESULT WINAPI HTMLDocument_put_onafterupdate(IHTMLDocument2 *iface, VARIANT v)
1519 {
1520     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1521     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1522     return E_NOTIMPL;
1523 }
1524
1525 static HRESULT WINAPI HTMLDocument_get_onafterupdate(IHTMLDocument2 *iface, VARIANT *p)
1526 {
1527     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1528     FIXME("(%p)->(%p)\n", This, p);
1529     return E_NOTIMPL;
1530 }
1531
1532 static HRESULT WINAPI HTMLDocument_put_onrowexit(IHTMLDocument2 *iface, VARIANT v)
1533 {
1534     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1535     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1536     return E_NOTIMPL;
1537 }
1538
1539 static HRESULT WINAPI HTMLDocument_get_onrowexit(IHTMLDocument2 *iface, VARIANT *p)
1540 {
1541     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1542     FIXME("(%p)->(%p)\n", This, p);
1543     return E_NOTIMPL;
1544 }
1545
1546 static HRESULT WINAPI HTMLDocument_put_onrowenter(IHTMLDocument2 *iface, VARIANT v)
1547 {
1548     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1549     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1550     return E_NOTIMPL;
1551 }
1552
1553 static HRESULT WINAPI HTMLDocument_get_onrowenter(IHTMLDocument2 *iface, VARIANT *p)
1554 {
1555     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1556     FIXME("(%p)->(%p)\n", This, p);
1557     return E_NOTIMPL;
1558 }
1559
1560 static HRESULT WINAPI HTMLDocument_put_ondragstart(IHTMLDocument2 *iface, VARIANT v)
1561 {
1562     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1563
1564     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1565
1566     return set_doc_event(This, EVENTID_DRAGSTART, &v);
1567 }
1568
1569 static HRESULT WINAPI HTMLDocument_get_ondragstart(IHTMLDocument2 *iface, VARIANT *p)
1570 {
1571     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1572
1573     TRACE("(%p)->(%p)\n", This, p);
1574
1575     return get_doc_event(This, EVENTID_DRAGSTART, p);
1576 }
1577
1578 static HRESULT WINAPI HTMLDocument_put_onselectstart(IHTMLDocument2 *iface, VARIANT v)
1579 {
1580     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1581
1582     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1583
1584     return set_doc_event(This, EVENTID_SELECTSTART, &v);
1585 }
1586
1587 static HRESULT WINAPI HTMLDocument_get_onselectstart(IHTMLDocument2 *iface, VARIANT *p)
1588 {
1589     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1590
1591     TRACE("(%p)->(%p)\n", This, p);
1592
1593     return get_doc_event(This, EVENTID_SELECTSTART, p);
1594 }
1595
1596 static HRESULT WINAPI HTMLDocument_elementFromPoint(IHTMLDocument2 *iface, LONG x, LONG y,
1597                                                     IHTMLElement **elementHit)
1598 {
1599     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1600     nsIDOMElement *nselem;
1601     HTMLElement *element;
1602     nsresult nsres;
1603     HRESULT hres;
1604
1605     TRACE("(%p)->(%d %d %p)\n", This, x, y, elementHit);
1606
1607     nsres = nsIDOMHTMLDocument_ElementFromPoint(This->doc_node->nsdoc, x, y, &nselem);
1608     if(NS_FAILED(nsres)) {
1609         ERR("ElementFromPoint failed: %08x\n", nsres);
1610         return E_FAIL;
1611     }
1612
1613     if(!nselem) {
1614         *elementHit = NULL;
1615         return S_OK;
1616     }
1617
1618     hres = get_element(nselem, &element);
1619     nsIDOMElement_Release(nselem);
1620     if(FAILED(hres))
1621         return hres;
1622
1623     *elementHit = &element->IHTMLElement_iface;
1624     return S_OK;
1625 }
1626
1627 static HRESULT WINAPI HTMLDocument_get_parentWindow(IHTMLDocument2 *iface, IHTMLWindow2 **p)
1628 {
1629     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1630
1631     TRACE("(%p)->(%p)\n", This, p);
1632
1633     return IHTMLDocument7_get_defaultView(&This->IHTMLDocument7_iface, p);
1634 }
1635
1636 static HRESULT WINAPI HTMLDocument_get_styleSheets(IHTMLDocument2 *iface,
1637                                                    IHTMLStyleSheetsCollection **p)
1638 {
1639     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1640     nsIDOMStyleSheetList *nsstylelist;
1641     nsresult nsres;
1642
1643     TRACE("(%p)->(%p)\n", This, p);
1644
1645     *p = NULL;
1646
1647     if(!This->doc_node->nsdoc) {
1648         WARN("NULL nsdoc\n");
1649         return E_UNEXPECTED;
1650     }
1651
1652     nsres = nsIDOMHTMLDocument_GetStyleSheets(This->doc_node->nsdoc, &nsstylelist);
1653     if(NS_FAILED(nsres)) {
1654         ERR("GetStyleSheets failed: %08x\n", nsres);
1655         return E_FAIL;
1656     }
1657
1658     *p = HTMLStyleSheetsCollection_Create(nsstylelist);
1659     nsIDOMStyleSheetList_Release(nsstylelist);
1660
1661     return S_OK;
1662 }
1663
1664 static HRESULT WINAPI HTMLDocument_put_onbeforeupdate(IHTMLDocument2 *iface, VARIANT v)
1665 {
1666     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1667     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1668     return E_NOTIMPL;
1669 }
1670
1671 static HRESULT WINAPI HTMLDocument_get_onbeforeupdate(IHTMLDocument2 *iface, VARIANT *p)
1672 {
1673     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1674     FIXME("(%p)->(%p)\n", This, p);
1675     return E_NOTIMPL;
1676 }
1677
1678 static HRESULT WINAPI HTMLDocument_put_onerrorupdate(IHTMLDocument2 *iface, VARIANT v)
1679 {
1680     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1681     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1682     return E_NOTIMPL;
1683 }
1684
1685 static HRESULT WINAPI HTMLDocument_get_onerrorupdate(IHTMLDocument2 *iface, VARIANT *p)
1686 {
1687     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1688     FIXME("(%p)->(%p)\n", This, p);
1689     return E_NOTIMPL;
1690 }
1691
1692 static HRESULT WINAPI HTMLDocument_toString(IHTMLDocument2 *iface, BSTR *String)
1693 {
1694     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1695
1696     static const WCHAR objectW[] = {'[','o','b','j','e','c','t',']',0};
1697
1698     TRACE("(%p)->(%p)\n", This, String);
1699
1700     if(!String)
1701         return E_INVALIDARG;
1702
1703     *String = SysAllocString(objectW);
1704     return *String ? S_OK : E_OUTOFMEMORY;
1705
1706 }
1707
1708 static HRESULT WINAPI HTMLDocument_createStyleSheet(IHTMLDocument2 *iface, BSTR bstrHref,
1709                                             LONG lIndex, IHTMLStyleSheet **ppnewStyleSheet)
1710 {
1711     HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1712     nsIDOMHTMLHeadElement *head_elem;
1713     IHTMLStyleElement *style_elem;
1714     HTMLElement *elem;
1715     nsresult nsres;
1716     HRESULT hres;
1717
1718     static const WCHAR styleW[] = {'s','t','y','l','e',0};
1719
1720     TRACE("(%p)->(%s %d %p)\n", This, debugstr_w(bstrHref), lIndex, ppnewStyleSheet);
1721
1722     if(!This->doc_node->nsdoc) {
1723         FIXME("not a real doc object\n");
1724         return E_NOTIMPL;
1725     }
1726
1727     if(lIndex != -1)
1728         FIXME("Unsupported lIndex %d\n", lIndex);
1729
1730     if(bstrHref && *bstrHref) {
1731         FIXME("semi-stub for href %s\n", debugstr_w(bstrHref));
1732         *ppnewStyleSheet = HTMLStyleSheet_Create(NULL);
1733         return S_OK;
1734     }
1735
1736     hres = create_element(This->doc_node, styleW, &elem);
1737     if(FAILED(hres))
1738         return hres;
1739
1740     nsres = nsIDOMHTMLDocument_GetHead(This->doc_node->nsdoc, &head_elem);
1741     if(NS_SUCCEEDED(nsres)) {
1742         nsIDOMNode *head_node, *tmp_node;
1743
1744         nsres = nsIDOMHTMLHeadElement_QueryInterface(head_elem, &IID_nsIDOMNode, (void**)&head_node);
1745         nsIDOMHTMLHeadElement_Release(head_elem);
1746         assert(nsres == NS_OK);
1747
1748         nsres = nsIDOMNode_AppendChild(head_node, elem->node.nsnode, &tmp_node);
1749         nsIDOMNode_Release(head_node);
1750         if(NS_SUCCEEDED(nsres) && tmp_node)
1751             nsIDOMNode_Release(tmp_node);
1752     }
1753     if(NS_FAILED(nsres)) {
1754         IHTMLElement_Release(&elem->IHTMLElement_iface);
1755         return E_FAIL;
1756     }
1757
1758     hres = IHTMLElement_QueryInterface(&elem->IHTMLElement_iface, &IID_IHTMLStyleElement, (void**)&style_elem);
1759     assert(hres == S_OK);
1760     IHTMLElement_Release(&elem->IHTMLElement_iface);
1761
1762     hres = IHTMLStyleElement_get_styleSheet(style_elem, ppnewStyleSheet);
1763     IHTMLStyleElement_Release(style_elem);
1764     return hres;
1765 }
1766
1767 static const IHTMLDocument2Vtbl HTMLDocumentVtbl = {
1768     HTMLDocument_QueryInterface,
1769     HTMLDocument_AddRef,
1770     HTMLDocument_Release,
1771     HTMLDocument_GetTypeInfoCount,
1772     HTMLDocument_GetTypeInfo,
1773     HTMLDocument_GetIDsOfNames,
1774     HTMLDocument_Invoke,
1775     HTMLDocument_get_Script,
1776     HTMLDocument_get_all,
1777     HTMLDocument_get_body,
1778     HTMLDocument_get_activeElement,
1779     HTMLDocument_get_images,
1780     HTMLDocument_get_applets,
1781     HTMLDocument_get_links,
1782     HTMLDocument_get_forms,
1783     HTMLDocument_get_anchors,
1784     HTMLDocument_put_title,
1785     HTMLDocument_get_title,
1786     HTMLDocument_get_scripts,
1787     HTMLDocument_put_designMode,
1788     HTMLDocument_get_designMode,
1789     HTMLDocument_get_selection,
1790     HTMLDocument_get_readyState,
1791     HTMLDocument_get_frames,
1792     HTMLDocument_get_embeds,
1793     HTMLDocument_get_plugins,
1794     HTMLDocument_put_alinkColor,
1795     HTMLDocument_get_alinkColor,
1796     HTMLDocument_put_bgColor,
1797     HTMLDocument_get_bgColor,
1798     HTMLDocument_put_fgColor,
1799     HTMLDocument_get_fgColor,
1800     HTMLDocument_put_linkColor,
1801     HTMLDocument_get_linkColor,
1802     HTMLDocument_put_vlinkColor,
1803     HTMLDocument_get_vlinkColor,
1804     HTMLDocument_get_referrer,
1805     HTMLDocument_get_location,
1806     HTMLDocument_get_lastModified,
1807     HTMLDocument_put_URL,
1808     HTMLDocument_get_URL,
1809     HTMLDocument_put_domain,
1810     HTMLDocument_get_domain,
1811     HTMLDocument_put_cookie,
1812     HTMLDocument_get_cookie,
1813     HTMLDocument_put_expando,
1814     HTMLDocument_get_expando,
1815     HTMLDocument_put_charset,
1816     HTMLDocument_get_charset,
1817     HTMLDocument_put_defaultCharset,
1818     HTMLDocument_get_defaultCharset,
1819     HTMLDocument_get_mimeType,
1820     HTMLDocument_get_fileSize,
1821     HTMLDocument_get_fileCreatedDate,
1822     HTMLDocument_get_fileModifiedDate,
1823     HTMLDocument_get_fileUpdatedDate,
1824     HTMLDocument_get_security,
1825     HTMLDocument_get_protocol,
1826     HTMLDocument_get_nameProp,
1827     HTMLDocument_write,
1828     HTMLDocument_writeln,
1829     HTMLDocument_open,
1830     HTMLDocument_close,
1831     HTMLDocument_clear,
1832     HTMLDocument_queryCommandSupported,
1833     HTMLDocument_queryCommandEnabled,
1834     HTMLDocument_queryCommandState,
1835     HTMLDocument_queryCommandIndeterm,
1836     HTMLDocument_queryCommandText,
1837     HTMLDocument_queryCommandValue,
1838     HTMLDocument_execCommand,
1839     HTMLDocument_execCommandShowHelp,
1840     HTMLDocument_createElement,
1841     HTMLDocument_put_onhelp,
1842     HTMLDocument_get_onhelp,
1843     HTMLDocument_put_onclick,
1844     HTMLDocument_get_onclick,
1845     HTMLDocument_put_ondblclick,
1846     HTMLDocument_get_ondblclick,
1847     HTMLDocument_put_onkeyup,
1848     HTMLDocument_get_onkeyup,
1849     HTMLDocument_put_onkeydown,
1850     HTMLDocument_get_onkeydown,
1851     HTMLDocument_put_onkeypress,
1852     HTMLDocument_get_onkeypress,
1853     HTMLDocument_put_onmouseup,
1854     HTMLDocument_get_onmouseup,
1855     HTMLDocument_put_onmousedown,
1856     HTMLDocument_get_onmousedown,
1857     HTMLDocument_put_onmousemove,
1858     HTMLDocument_get_onmousemove,
1859     HTMLDocument_put_onmouseout,
1860     HTMLDocument_get_onmouseout,
1861     HTMLDocument_put_onmouseover,
1862     HTMLDocument_get_onmouseover,
1863     HTMLDocument_put_onreadystatechange,
1864     HTMLDocument_get_onreadystatechange,
1865     HTMLDocument_put_onafterupdate,
1866     HTMLDocument_get_onafterupdate,
1867     HTMLDocument_put_onrowexit,
1868     HTMLDocument_get_onrowexit,
1869     HTMLDocument_put_onrowenter,
1870     HTMLDocument_get_onrowenter,
1871     HTMLDocument_put_ondragstart,
1872     HTMLDocument_get_ondragstart,
1873     HTMLDocument_put_onselectstart,
1874     HTMLDocument_get_onselectstart,
1875     HTMLDocument_elementFromPoint,
1876     HTMLDocument_get_parentWindow,
1877     HTMLDocument_get_styleSheets,
1878     HTMLDocument_put_onbeforeupdate,
1879     HTMLDocument_get_onbeforeupdate,
1880     HTMLDocument_put_onerrorupdate,
1881     HTMLDocument_get_onerrorupdate,
1882     HTMLDocument_toString,
1883     HTMLDocument_createStyleSheet
1884 };
1885
1886 static inline HTMLDocument *impl_from_IHTMLDocument3(IHTMLDocument3 *iface)
1887 {
1888     return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument3_iface);
1889 }
1890
1891 static HRESULT WINAPI HTMLDocument3_QueryInterface(IHTMLDocument3 *iface,
1892                                                   REFIID riid, void **ppv)
1893 {
1894     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1895     return htmldoc_query_interface(This, riid, ppv);
1896 }
1897
1898 static ULONG WINAPI HTMLDocument3_AddRef(IHTMLDocument3 *iface)
1899 {
1900     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1901     return htmldoc_addref(This);
1902 }
1903
1904 static ULONG WINAPI HTMLDocument3_Release(IHTMLDocument3 *iface)
1905 {
1906     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1907     return htmldoc_release(This);
1908 }
1909
1910 static HRESULT WINAPI HTMLDocument3_GetTypeInfoCount(IHTMLDocument3 *iface, UINT *pctinfo)
1911 {
1912     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1913     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1914 }
1915
1916 static HRESULT WINAPI HTMLDocument3_GetTypeInfo(IHTMLDocument3 *iface, UINT iTInfo,
1917                                                 LCID lcid, ITypeInfo **ppTInfo)
1918 {
1919     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1920     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1921 }
1922
1923 static HRESULT WINAPI HTMLDocument3_GetIDsOfNames(IHTMLDocument3 *iface, REFIID riid,
1924                                                 LPOLESTR *rgszNames, UINT cNames,
1925                                                 LCID lcid, DISPID *rgDispId)
1926 {
1927     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1928     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1929             rgDispId);
1930 }
1931
1932 static HRESULT WINAPI HTMLDocument3_Invoke(IHTMLDocument3 *iface, DISPID dispIdMember,
1933                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1934                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1935 {
1936     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1937     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1938             pDispParams, pVarResult, pExcepInfo, puArgErr);
1939 }
1940
1941 static HRESULT WINAPI HTMLDocument3_releaseCapture(IHTMLDocument3 *iface)
1942 {
1943     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1944     FIXME("(%p)\n", This);
1945     return E_NOTIMPL;
1946 }
1947
1948 static HRESULT WINAPI HTMLDocument3_recalc(IHTMLDocument3 *iface, VARIANT_BOOL fForce)
1949 {
1950     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1951
1952     WARN("(%p)->(%x)\n", This, fForce);
1953
1954     /* Doing nothing here should be fine for us. */
1955     return S_OK;
1956 }
1957
1958 static HRESULT WINAPI HTMLDocument3_createTextNode(IHTMLDocument3 *iface, BSTR text,
1959                                                    IHTMLDOMNode **newTextNode)
1960 {
1961     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1962     nsIDOMText *nstext;
1963     HTMLDOMNode *node;
1964     nsAString text_str;
1965     nsresult nsres;
1966     HRESULT hres;
1967
1968     TRACE("(%p)->(%s %p)\n", This, debugstr_w(text), newTextNode);
1969
1970     if(!This->doc_node->nsdoc) {
1971         WARN("NULL nsdoc\n");
1972         return E_UNEXPECTED;
1973     }
1974
1975     nsAString_InitDepend(&text_str, text);
1976     nsres = nsIDOMHTMLDocument_CreateTextNode(This->doc_node->nsdoc, &text_str, &nstext);
1977     nsAString_Finish(&text_str);
1978     if(NS_FAILED(nsres)) {
1979         ERR("CreateTextNode failed: %08x\n", nsres);
1980         return E_FAIL;
1981     }
1982
1983     hres = HTMLDOMTextNode_Create(This->doc_node, (nsIDOMNode*)nstext, &node);
1984     nsIDOMText_Release(nstext);
1985     if(FAILED(hres))
1986         return hres;
1987
1988     *newTextNode = &node->IHTMLDOMNode_iface;
1989     return S_OK;
1990 }
1991
1992 static HRESULT WINAPI HTMLDocument3_get_documentElement(IHTMLDocument3 *iface, IHTMLElement **p)
1993 {
1994     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1995     nsIDOMElement *nselem = NULL;
1996     HTMLElement *element;
1997     nsresult nsres;
1998     HRESULT hres;
1999
2000     TRACE("(%p)->(%p)\n", This, p);
2001
2002     if(This->window->readystate == READYSTATE_UNINITIALIZED) {
2003         *p = NULL;
2004         return S_OK;
2005     }
2006
2007     if(!This->doc_node->nsdoc) {
2008         WARN("NULL nsdoc\n");
2009         return E_UNEXPECTED;
2010     }
2011
2012     nsres = nsIDOMHTMLDocument_GetDocumentElement(This->doc_node->nsdoc, &nselem);
2013     if(NS_FAILED(nsres)) {
2014         ERR("GetDocumentElement failed: %08x\n", nsres);
2015         return E_FAIL;
2016     }
2017
2018     if(!nselem) {
2019         *p = NULL;
2020         return S_OK;
2021     }
2022
2023     hres = get_element(nselem, &element);
2024     nsIDOMElement_Release(nselem);
2025     if(FAILED(hres))
2026         return hres;
2027
2028     *p = &element->IHTMLElement_iface;
2029     return hres;
2030 }
2031
2032 static HRESULT WINAPI HTMLDocument3_get_uniqueID(IHTMLDocument3 *iface, BSTR *p)
2033 {
2034     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2035
2036     TRACE("(%p)->(%p)\n", This, p);
2037
2038     return elem_unique_id(++This->doc_node->unique_id, p);
2039 }
2040
2041 static HRESULT WINAPI HTMLDocument3_attachEvent(IHTMLDocument3 *iface, BSTR event,
2042                                                 IDispatch* pDisp, VARIANT_BOOL *pfResult)
2043 {
2044     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2045
2046     TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(event), pDisp, pfResult);
2047
2048     return attach_event(&This->doc_node->node.event_target, event, pDisp, pfResult);
2049 }
2050
2051 static HRESULT WINAPI HTMLDocument3_detachEvent(IHTMLDocument3 *iface, BSTR event,
2052                                                 IDispatch *pDisp)
2053 {
2054     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2055
2056     TRACE("(%p)->(%s %p)\n", This, debugstr_w(event), pDisp);
2057
2058     return detach_event(&This->doc_node->node.event_target, event, pDisp);
2059 }
2060
2061 static HRESULT WINAPI HTMLDocument3_put_onrowsdelete(IHTMLDocument3 *iface, VARIANT v)
2062 {
2063     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2064     FIXME("(%p)->()\n", This);
2065     return E_NOTIMPL;
2066 }
2067
2068 static HRESULT WINAPI HTMLDocument3_get_onrowsdelete(IHTMLDocument3 *iface, VARIANT *p)
2069 {
2070     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2071     FIXME("(%p)->(%p)\n", This, p);
2072     return E_NOTIMPL;
2073 }
2074
2075 static HRESULT WINAPI HTMLDocument3_put_onrowsinserted(IHTMLDocument3 *iface, VARIANT v)
2076 {
2077     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2078     FIXME("(%p)->()\n", This);
2079     return E_NOTIMPL;
2080 }
2081
2082 static HRESULT WINAPI HTMLDocument3_get_onrowsinserted(IHTMLDocument3 *iface, VARIANT *p)
2083 {
2084     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2085     FIXME("(%p)->(%p)\n", This, p);
2086     return E_NOTIMPL;
2087 }
2088
2089 static HRESULT WINAPI HTMLDocument3_put_oncellchange(IHTMLDocument3 *iface, VARIANT v)
2090 {
2091     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2092     FIXME("(%p)->()\n", This);
2093     return E_NOTIMPL;
2094 }
2095
2096 static HRESULT WINAPI HTMLDocument3_get_oncellchange(IHTMLDocument3 *iface, VARIANT *p)
2097 {
2098     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2099     FIXME("(%p)->(%p)\n", This, p);
2100     return E_NOTIMPL;
2101 }
2102
2103 static HRESULT WINAPI HTMLDocument3_put_ondatasetchanged(IHTMLDocument3 *iface, VARIANT v)
2104 {
2105     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2106     FIXME("(%p)->()\n", This);
2107     return E_NOTIMPL;
2108 }
2109
2110 static HRESULT WINAPI HTMLDocument3_get_ondatasetchanged(IHTMLDocument3 *iface, VARIANT *p)
2111 {
2112     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2113     FIXME("(%p)->(%p)\n", This, p);
2114     return E_NOTIMPL;
2115 }
2116
2117 static HRESULT WINAPI HTMLDocument3_put_ondataavailable(IHTMLDocument3 *iface, VARIANT v)
2118 {
2119     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2120     FIXME("(%p)->()\n", This);
2121     return E_NOTIMPL;
2122 }
2123
2124 static HRESULT WINAPI HTMLDocument3_get_ondataavailable(IHTMLDocument3 *iface, VARIANT *p)
2125 {
2126     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2127     FIXME("(%p)->(%p)\n", This, p);
2128     return E_NOTIMPL;
2129 }
2130
2131 static HRESULT WINAPI HTMLDocument3_put_ondatasetcomplete(IHTMLDocument3 *iface, VARIANT v)
2132 {
2133     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2134     FIXME("(%p)->()\n", This);
2135     return E_NOTIMPL;
2136 }
2137
2138 static HRESULT WINAPI HTMLDocument3_get_ondatasetcomplete(IHTMLDocument3 *iface, VARIANT *p)
2139 {
2140     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2141     FIXME("(%p)->(%p)\n", This, p);
2142     return E_NOTIMPL;
2143 }
2144
2145 static HRESULT WINAPI HTMLDocument3_put_onpropertychange(IHTMLDocument3 *iface, VARIANT v)
2146 {
2147     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2148     FIXME("(%p)->()\n", This);
2149     return E_NOTIMPL;
2150 }
2151
2152 static HRESULT WINAPI HTMLDocument3_get_onpropertychange(IHTMLDocument3 *iface, VARIANT *p)
2153 {
2154     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2155     FIXME("(%p)->(%p)\n", This, p);
2156     return E_NOTIMPL;
2157 }
2158
2159 static HRESULT WINAPI HTMLDocument3_put_dir(IHTMLDocument3 *iface, BSTR v)
2160 {
2161     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2162     nsAString dir_str;
2163     nsresult nsres;
2164
2165     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2166
2167     if(!This->doc_node->nsdoc) {
2168         FIXME("NULL nsdoc\n");
2169         return E_UNEXPECTED;
2170     }
2171
2172     nsAString_InitDepend(&dir_str, v);
2173     nsres = nsIDOMHTMLDocument_SetDir(This->doc_node->nsdoc, &dir_str);
2174     nsAString_Finish(&dir_str);
2175     if(NS_FAILED(nsres)) {
2176         ERR("SetDir failed: %08x\n", nsres);
2177         return E_FAIL;
2178     }
2179
2180     return S_OK;
2181 }
2182
2183 static HRESULT WINAPI HTMLDocument3_get_dir(IHTMLDocument3 *iface, BSTR *p)
2184 {
2185     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2186     nsAString dir_str;
2187     nsresult nsres;
2188
2189     TRACE("(%p)->(%p)\n", This, p);
2190
2191     if(!This->doc_node->nsdoc) {
2192         FIXME("NULL nsdoc\n");
2193         return E_UNEXPECTED;
2194     }
2195
2196     nsAString_Init(&dir_str, NULL);
2197     nsres = nsIDOMHTMLDocument_GetDir(This->doc_node->nsdoc, &dir_str);
2198     return return_nsstr(nsres, &dir_str, p);
2199 }
2200
2201 static HRESULT WINAPI HTMLDocument3_put_oncontextmenu(IHTMLDocument3 *iface, VARIANT v)
2202 {
2203     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2204
2205     TRACE("(%p)->()\n", This);
2206
2207     return set_doc_event(This, EVENTID_CONTEXTMENU, &v);
2208 }
2209
2210 static HRESULT WINAPI HTMLDocument3_get_oncontextmenu(IHTMLDocument3 *iface, VARIANT *p)
2211 {
2212     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2213
2214     TRACE("(%p)->(%p)\n", This, p);
2215
2216     return get_doc_event(This, EVENTID_CONTEXTMENU, p);
2217 }
2218
2219 static HRESULT WINAPI HTMLDocument3_put_onstop(IHTMLDocument3 *iface, VARIANT v)
2220 {
2221     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2222     FIXME("(%p)->()\n", This);
2223     return E_NOTIMPL;
2224 }
2225
2226 static HRESULT WINAPI HTMLDocument3_get_onstop(IHTMLDocument3 *iface, VARIANT *p)
2227 {
2228     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2229     FIXME("(%p)->(%p)\n", This, p);
2230     return E_NOTIMPL;
2231 }
2232
2233 static HRESULT WINAPI HTMLDocument3_createDocumentFragment(IHTMLDocument3 *iface,
2234                                                            IHTMLDocument2 **ppNewDoc)
2235 {
2236     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2237     nsIDOMDocumentFragment *doc_frag;
2238     HTMLDocumentNode *docnode;
2239     nsresult nsres;
2240     HRESULT hres;
2241
2242     TRACE("(%p)->(%p)\n", This, ppNewDoc);
2243
2244     if(!This->doc_node->nsdoc) {
2245         FIXME("NULL nsdoc\n");
2246         return E_NOTIMPL;
2247     }
2248
2249     nsres = nsIDOMHTMLDocument_CreateDocumentFragment(This->doc_node->nsdoc, &doc_frag);
2250     if(NS_FAILED(nsres)) {
2251         ERR("CreateDocumentFragment failed: %08x\n", nsres);
2252         return E_FAIL;
2253     }
2254
2255     hres = create_document_fragment((nsIDOMNode*)doc_frag, This->doc_node, &docnode);
2256     nsIDOMDocumentFragment_Release(doc_frag);
2257     if(FAILED(hres))
2258         return hres;
2259
2260     *ppNewDoc = &docnode->basedoc.IHTMLDocument2_iface;
2261     return S_OK;
2262 }
2263
2264 static HRESULT WINAPI HTMLDocument3_get_parentDocument(IHTMLDocument3 *iface,
2265                                                        IHTMLDocument2 **p)
2266 {
2267     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2268     FIXME("(%p)->(%p)\n", This, p);
2269     return E_NOTIMPL;
2270 }
2271
2272 static HRESULT WINAPI HTMLDocument3_put_enableDownload(IHTMLDocument3 *iface,
2273                                                        VARIANT_BOOL v)
2274 {
2275     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2276     FIXME("(%p)->(%x)\n", This, v);
2277     return E_NOTIMPL;
2278 }
2279
2280 static HRESULT WINAPI HTMLDocument3_get_enableDownload(IHTMLDocument3 *iface,
2281                                                        VARIANT_BOOL *p)
2282 {
2283     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2284     FIXME("(%p)->(%p)\n", This, p);
2285     return E_NOTIMPL;
2286 }
2287
2288 static HRESULT WINAPI HTMLDocument3_put_baseUrl(IHTMLDocument3 *iface, BSTR v)
2289 {
2290     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2291     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2292     return E_NOTIMPL;
2293 }
2294
2295 static HRESULT WINAPI HTMLDocument3_get_baseUrl(IHTMLDocument3 *iface, BSTR *p)
2296 {
2297     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2298     FIXME("(%p)->(%p)\n", This, p);
2299     return E_NOTIMPL;
2300 }
2301
2302 static HRESULT WINAPI HTMLDocument3_get_childNodes(IHTMLDocument3 *iface, IDispatch **p)
2303 {
2304     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2305
2306     TRACE("(%p)->(%p)\n", This, p);
2307
2308     return IHTMLDOMNode_get_childNodes(&This->doc_node->node.IHTMLDOMNode_iface, p);
2309 }
2310
2311 static HRESULT WINAPI HTMLDocument3_put_inheritStyleSheets(IHTMLDocument3 *iface,
2312                                                            VARIANT_BOOL v)
2313 {
2314     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2315     FIXME("(%p)->()\n", This);
2316     return E_NOTIMPL;
2317 }
2318
2319 static HRESULT WINAPI HTMLDocument3_get_inheritStyleSheets(IHTMLDocument3 *iface,
2320                                                            VARIANT_BOOL *p)
2321 {
2322     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2323     FIXME("(%p)->(%p)\n", This, p);
2324     return E_NOTIMPL;
2325 }
2326
2327 static HRESULT WINAPI HTMLDocument3_put_onbeforeeditfocus(IHTMLDocument3 *iface, VARIANT v)
2328 {
2329     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2330     FIXME("(%p)->()\n", This);
2331     return E_NOTIMPL;
2332 }
2333
2334 static HRESULT WINAPI HTMLDocument3_get_onbeforeeditfocus(IHTMLDocument3 *iface, VARIANT *p)
2335 {
2336     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2337     FIXME("(%p)->(%p)\n", This, p);
2338     return E_NOTIMPL;
2339 }
2340
2341 static HRESULT WINAPI HTMLDocument3_getElementsByName(IHTMLDocument3 *iface, BSTR v,
2342                                                       IHTMLElementCollection **ppelColl)
2343 {
2344     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2345     nsIDOMNodeList *node_list;
2346     nsAString selector_str;
2347     WCHAR *selector;
2348     nsresult nsres;
2349
2350     static const WCHAR formatW[] = {'*','[','i','d','=','%','s',']',',','*','[','n','a','m','e','=','%','s',']',0};
2351
2352     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), ppelColl);
2353
2354     if(!This->doc_node || !This->doc_node->nsdoc) {
2355         /* We should probably return an empty collection. */
2356         FIXME("No nsdoc\n");
2357         return E_NOTIMPL;
2358     }
2359
2360     selector = heap_alloc(2*SysStringLen(v)*sizeof(WCHAR) + sizeof(formatW));
2361     if(!selector)
2362         return E_OUTOFMEMORY;
2363     sprintfW(selector, formatW, v, v);
2364
2365     /*
2366      * NOTE: IE getElementsByName implementation differs from Gecko. It searches both name and id attributes.
2367      * That's why we use CSS selector instead. We should also use name only when it applies to given element
2368      * types and search should be case insensitive. Those are currently not supported properly.
2369      */
2370     nsAString_InitDepend(&selector_str, selector);
2371     nsres = nsIDOMHTMLDocument_QuerySelectorAll(This->doc_node->nsdoc, &selector_str, &node_list);
2372     nsAString_Finish(&selector_str);
2373     heap_free(selector);
2374     if(NS_FAILED(nsres)) {
2375         ERR("QuerySelectorAll failed: %08x\n", nsres);
2376         return E_FAIL;
2377     }
2378
2379     *ppelColl = create_collection_from_nodelist(node_list, This->doc_node->document_mode);
2380     nsIDOMNodeList_Release(node_list);
2381     return S_OK;
2382 }
2383
2384
2385 static HRESULT WINAPI HTMLDocument3_getElementById(IHTMLDocument3 *iface, BSTR v,
2386                                                    IHTMLElement **pel)
2387 {
2388     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2389     HTMLElement *elem;
2390     HRESULT hres;
2391
2392     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
2393
2394     hres = get_doc_elem_by_id(This->doc_node, v, &elem);
2395     if(FAILED(hres) || !elem) {
2396         *pel = NULL;
2397         return hres;
2398     }
2399
2400     *pel = &elem->IHTMLElement_iface;
2401     return S_OK;
2402 }
2403
2404
2405 static HRESULT WINAPI HTMLDocument3_getElementsByTagName(IHTMLDocument3 *iface, BSTR v,
2406                                                          IHTMLElementCollection **pelColl)
2407 {
2408     HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2409     nsIDOMNodeList *nslist;
2410     nsAString id_str;
2411     nsresult nsres;
2412
2413     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pelColl);
2414
2415     if(This->doc_node->nsdoc) {
2416         nsAString_InitDepend(&id_str, v);
2417         nsres = nsIDOMHTMLDocument_GetElementsByTagName(This->doc_node->nsdoc, &id_str, &nslist);
2418         nsAString_Finish(&id_str);
2419         if(FAILED(nsres)) {
2420             ERR("GetElementByName failed: %08x\n", nsres);
2421             return E_FAIL;
2422         }
2423     }else {
2424         nsIDOMDocumentFragment *docfrag;
2425         nsAString nsstr;
2426
2427         if(v) {
2428             const WCHAR *ptr;
2429             for(ptr=v; *ptr; ptr++) {
2430                 if(!isalnumW(*ptr)) {
2431                     FIXME("Unsupported invalid tag %s\n", debugstr_w(v));
2432                     return E_NOTIMPL;
2433                 }
2434             }
2435         }
2436
2437         nsres = nsIDOMNode_QueryInterface(This->doc_node->node.nsnode, &IID_nsIDOMDocumentFragment, (void**)&docfrag);
2438         if(NS_FAILED(nsres)) {
2439             ERR("Could not get nsIDOMDocumentFragment iface: %08x\n", nsres);
2440             return E_UNEXPECTED;
2441         }
2442
2443         nsAString_InitDepend(&nsstr, v);
2444         nsres = nsIDOMDocumentFragment_QuerySelectorAll(docfrag, &nsstr, &nslist);
2445         nsAString_Finish(&nsstr);
2446         nsIDOMDocumentFragment_Release(docfrag);
2447         if(NS_FAILED(nsres)) {
2448             ERR("QuerySelectorAll failed: %08x\n", nsres);
2449             return E_FAIL;
2450         }
2451     }
2452
2453
2454     *pelColl = create_collection_from_nodelist(nslist, This->doc_node->document_mode);
2455     nsIDOMNodeList_Release(nslist);
2456
2457     return S_OK;
2458 }
2459
2460 static const IHTMLDocument3Vtbl HTMLDocument3Vtbl = {
2461     HTMLDocument3_QueryInterface,
2462     HTMLDocument3_AddRef,
2463     HTMLDocument3_Release,
2464     HTMLDocument3_GetTypeInfoCount,
2465     HTMLDocument3_GetTypeInfo,
2466     HTMLDocument3_GetIDsOfNames,
2467     HTMLDocument3_Invoke,
2468     HTMLDocument3_releaseCapture,
2469     HTMLDocument3_recalc,
2470     HTMLDocument3_createTextNode,
2471     HTMLDocument3_get_documentElement,
2472     HTMLDocument3_get_uniqueID,
2473     HTMLDocument3_attachEvent,
2474     HTMLDocument3_detachEvent,
2475     HTMLDocument3_put_onrowsdelete,
2476     HTMLDocument3_get_onrowsdelete,
2477     HTMLDocument3_put_onrowsinserted,
2478     HTMLDocument3_get_onrowsinserted,
2479     HTMLDocument3_put_oncellchange,
2480     HTMLDocument3_get_oncellchange,
2481     HTMLDocument3_put_ondatasetchanged,
2482     HTMLDocument3_get_ondatasetchanged,
2483     HTMLDocument3_put_ondataavailable,
2484     HTMLDocument3_get_ondataavailable,
2485     HTMLDocument3_put_ondatasetcomplete,
2486     HTMLDocument3_get_ondatasetcomplete,
2487     HTMLDocument3_put_onpropertychange,
2488     HTMLDocument3_get_onpropertychange,
2489     HTMLDocument3_put_dir,
2490     HTMLDocument3_get_dir,
2491     HTMLDocument3_put_oncontextmenu,
2492     HTMLDocument3_get_oncontextmenu,
2493     HTMLDocument3_put_onstop,
2494     HTMLDocument3_get_onstop,
2495     HTMLDocument3_createDocumentFragment,
2496     HTMLDocument3_get_parentDocument,
2497     HTMLDocument3_put_enableDownload,
2498     HTMLDocument3_get_enableDownload,
2499     HTMLDocument3_put_baseUrl,
2500     HTMLDocument3_get_baseUrl,
2501     HTMLDocument3_get_childNodes,
2502     HTMLDocument3_put_inheritStyleSheets,
2503     HTMLDocument3_get_inheritStyleSheets,
2504     HTMLDocument3_put_onbeforeeditfocus,
2505     HTMLDocument3_get_onbeforeeditfocus,
2506     HTMLDocument3_getElementsByName,
2507     HTMLDocument3_getElementById,
2508     HTMLDocument3_getElementsByTagName
2509 };
2510
2511 static inline HTMLDocument *impl_from_IHTMLDocument4(IHTMLDocument4 *iface)
2512 {
2513     return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument4_iface);
2514 }
2515
2516 static HRESULT WINAPI HTMLDocument4_QueryInterface(IHTMLDocument4 *iface,
2517                                                    REFIID riid, void **ppv)
2518 {
2519     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2520     return htmldoc_query_interface(This, riid, ppv);
2521 }
2522
2523 static ULONG WINAPI HTMLDocument4_AddRef(IHTMLDocument4 *iface)
2524 {
2525     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2526     return htmldoc_addref(This);
2527 }
2528
2529 static ULONG WINAPI HTMLDocument4_Release(IHTMLDocument4 *iface)
2530 {
2531     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2532     return htmldoc_release(This);
2533 }
2534
2535 static HRESULT WINAPI HTMLDocument4_GetTypeInfoCount(IHTMLDocument4 *iface, UINT *pctinfo)
2536 {
2537     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2538     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
2539 }
2540
2541 static HRESULT WINAPI HTMLDocument4_GetTypeInfo(IHTMLDocument4 *iface, UINT iTInfo,
2542                                                 LCID lcid, ITypeInfo **ppTInfo)
2543 {
2544     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2545     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2546 }
2547
2548 static HRESULT WINAPI HTMLDocument4_GetIDsOfNames(IHTMLDocument4 *iface, REFIID riid,
2549                                                 LPOLESTR *rgszNames, UINT cNames,
2550                                                 LCID lcid, DISPID *rgDispId)
2551 {
2552     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2553     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
2554             rgDispId);
2555 }
2556
2557 static HRESULT WINAPI HTMLDocument4_Invoke(IHTMLDocument4 *iface, DISPID dispIdMember,
2558                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2559                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2560 {
2561     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2562     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2563             pDispParams, pVarResult, pExcepInfo, puArgErr);
2564 }
2565
2566 static HRESULT WINAPI HTMLDocument4_focus(IHTMLDocument4 *iface)
2567 {
2568     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2569     nsIDOMHTMLElement *nsbody;
2570     nsresult nsres;
2571
2572     TRACE("(%p)->()\n", This);
2573
2574     nsres = nsIDOMHTMLDocument_GetBody(This->doc_node->nsdoc, &nsbody);
2575     if(NS_FAILED(nsres) || !nsbody) {
2576         ERR("GetBody failed: %08x\n", nsres);
2577         return E_FAIL;
2578     }
2579
2580     nsres = nsIDOMHTMLElement_Focus(nsbody);
2581     nsIDOMHTMLElement_Release(nsbody);
2582     if(NS_FAILED(nsres)) {
2583         ERR("Focus failed: %08x\n", nsres);
2584         return E_FAIL;
2585     }
2586
2587     return S_OK;
2588 }
2589
2590 static HRESULT WINAPI HTMLDocument4_hasFocus(IHTMLDocument4 *iface, VARIANT_BOOL *pfFocus)
2591 {
2592     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2593     cpp_bool has_focus;
2594     nsresult nsres;
2595
2596     TRACE("(%p)->(%p)\n", This, pfFocus);
2597
2598     if(!This->doc_node->nsdoc) {
2599         FIXME("Unimplemented for fragments.\n");
2600         return E_NOTIMPL;
2601     }
2602
2603     nsres = nsIDOMHTMLDocument_HasFocus(This->doc_node->nsdoc, &has_focus);
2604     assert(nsres == NS_OK);
2605
2606     *pfFocus = variant_bool(has_focus);
2607     return S_OK;
2608 }
2609
2610 static HRESULT WINAPI HTMLDocument4_put_onselectionchange(IHTMLDocument4 *iface, VARIANT v)
2611 {
2612     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2613
2614     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2615
2616     return set_doc_event(This, EVENTID_SELECTIONCHANGE, &v);
2617 }
2618
2619 static HRESULT WINAPI HTMLDocument4_get_onselectionchange(IHTMLDocument4 *iface, VARIANT *p)
2620 {
2621     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2622
2623     TRACE("(%p)->(%p)\n", This, p);
2624
2625     return get_doc_event(This, EVENTID_SELECTIONCHANGE, p);
2626 }
2627
2628 static HRESULT WINAPI HTMLDocument4_get_namespace(IHTMLDocument4 *iface, IDispatch **p)
2629 {
2630     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2631     FIXME("(%p)->(%p)\n", This, p);
2632     return E_NOTIMPL;
2633 }
2634
2635 static HRESULT WINAPI HTMLDocument4_createDocumentFromUrl(IHTMLDocument4 *iface, BSTR bstrUrl,
2636         BSTR bstrOptions, IHTMLDocument2 **newDoc)
2637 {
2638     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2639     FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(bstrUrl), debugstr_w(bstrOptions), newDoc);
2640     return E_NOTIMPL;
2641 }
2642
2643 static HRESULT WINAPI HTMLDocument4_put_media(IHTMLDocument4 *iface, BSTR v)
2644 {
2645     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2646     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2647     return E_NOTIMPL;
2648 }
2649
2650 static HRESULT WINAPI HTMLDocument4_get_media(IHTMLDocument4 *iface, BSTR *p)
2651 {
2652     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2653     FIXME("(%p)->(%p)\n", This, p);
2654     return E_NOTIMPL;
2655 }
2656
2657 static HRESULT WINAPI HTMLDocument4_createEventObject(IHTMLDocument4 *iface,
2658         VARIANT *pvarEventObject, IHTMLEventObj **ppEventObj)
2659 {
2660     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2661
2662     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(pvarEventObject), ppEventObj);
2663
2664     if(pvarEventObject && V_VT(pvarEventObject) != VT_ERROR && V_VT(pvarEventObject) != VT_EMPTY) {
2665         FIXME("unsupported pvarEventObject %s\n", debugstr_variant(pvarEventObject));
2666         return E_NOTIMPL;
2667     }
2668
2669     return create_event_obj(ppEventObj);
2670 }
2671
2672 static HRESULT WINAPI HTMLDocument4_fireEvent(IHTMLDocument4 *iface, BSTR bstrEventName,
2673         VARIANT *pvarEventObject, VARIANT_BOOL *pfCanceled)
2674 {
2675     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2676
2677     TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(bstrEventName), pvarEventObject, pfCanceled);
2678
2679     return fire_event(&This->doc_node->node, bstrEventName, pvarEventObject, pfCanceled);
2680 }
2681
2682 static HRESULT WINAPI HTMLDocument4_createRenderStyle(IHTMLDocument4 *iface, BSTR v,
2683         IHTMLRenderStyle **ppIHTMLRenderStyle)
2684 {
2685     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2686     FIXME("(%p)->(%s %p)\n", This, debugstr_w(v), ppIHTMLRenderStyle);
2687     return E_NOTIMPL;
2688 }
2689
2690 static HRESULT WINAPI HTMLDocument4_put_oncontrolselect(IHTMLDocument4 *iface, VARIANT v)
2691 {
2692     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2693     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2694     return E_NOTIMPL;
2695 }
2696
2697 static HRESULT WINAPI HTMLDocument4_get_oncontrolselect(IHTMLDocument4 *iface, VARIANT *p)
2698 {
2699     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2700     FIXME("(%p)->(%p)\n", This, p);
2701     return E_NOTIMPL;
2702 }
2703
2704 static HRESULT WINAPI HTMLDocument4_get_URLEncoded(IHTMLDocument4 *iface, BSTR *p)
2705 {
2706     HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2707     FIXME("(%p)->(%p)\n", This, p);
2708     return E_NOTIMPL;
2709 }
2710
2711 static const IHTMLDocument4Vtbl HTMLDocument4Vtbl = {
2712     HTMLDocument4_QueryInterface,
2713     HTMLDocument4_AddRef,
2714     HTMLDocument4_Release,
2715     HTMLDocument4_GetTypeInfoCount,
2716     HTMLDocument4_GetTypeInfo,
2717     HTMLDocument4_GetIDsOfNames,
2718     HTMLDocument4_Invoke,
2719     HTMLDocument4_focus,
2720     HTMLDocument4_hasFocus,
2721     HTMLDocument4_put_onselectionchange,
2722     HTMLDocument4_get_onselectionchange,
2723     HTMLDocument4_get_namespace,
2724     HTMLDocument4_createDocumentFromUrl,
2725     HTMLDocument4_put_media,
2726     HTMLDocument4_get_media,
2727     HTMLDocument4_createEventObject,
2728     HTMLDocument4_fireEvent,
2729     HTMLDocument4_createRenderStyle,
2730     HTMLDocument4_put_oncontrolselect,
2731     HTMLDocument4_get_oncontrolselect,
2732     HTMLDocument4_get_URLEncoded
2733 };
2734
2735 static inline HTMLDocument *impl_from_IHTMLDocument5(IHTMLDocument5 *iface)
2736 {
2737     return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument5_iface);
2738 }
2739
2740 static HRESULT WINAPI HTMLDocument5_QueryInterface(IHTMLDocument5 *iface,
2741         REFIID riid, void **ppv)
2742 {
2743     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2744     return htmldoc_query_interface(This, riid, ppv);
2745 }
2746
2747 static ULONG WINAPI HTMLDocument5_AddRef(IHTMLDocument5 *iface)
2748 {
2749     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2750     return htmldoc_addref(This);
2751 }
2752
2753 static ULONG WINAPI HTMLDocument5_Release(IHTMLDocument5 *iface)
2754 {
2755     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2756     return htmldoc_release(This);
2757 }
2758
2759 static HRESULT WINAPI HTMLDocument5_GetTypeInfoCount(IHTMLDocument5 *iface, UINT *pctinfo)
2760 {
2761     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2762     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
2763 }
2764
2765 static HRESULT WINAPI HTMLDocument5_GetTypeInfo(IHTMLDocument5 *iface, UINT iTInfo,
2766         LCID lcid, ITypeInfo **ppTInfo)
2767 {
2768     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2769     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2770 }
2771
2772 static HRESULT WINAPI HTMLDocument5_GetIDsOfNames(IHTMLDocument5 *iface, REFIID riid,
2773         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2774 {
2775     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2776     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
2777             rgDispId);
2778 }
2779
2780 static HRESULT WINAPI HTMLDocument5_Invoke(IHTMLDocument5 *iface, DISPID dispIdMember,
2781                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2782                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2783 {
2784     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2785     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2786             pDispParams, pVarResult, pExcepInfo, puArgErr);
2787 }
2788
2789 static HRESULT WINAPI HTMLDocument5_put_onmousewheel(IHTMLDocument5 *iface, VARIANT v)
2790 {
2791     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2792
2793     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2794
2795     return set_doc_event(This, EVENTID_MOUSEWHEEL, &v);
2796 }
2797
2798 static HRESULT WINAPI HTMLDocument5_get_onmousewheel(IHTMLDocument5 *iface, VARIANT *p)
2799 {
2800     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2801
2802     TRACE("(%p)->(%p)\n", This, p);
2803
2804     return get_doc_event(This, EVENTID_MOUSEWHEEL, p);
2805 }
2806
2807 static HRESULT WINAPI HTMLDocument5_get_doctype(IHTMLDocument5 *iface, IHTMLDOMNode **p)
2808 {
2809     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2810     FIXME("(%p)->(%p)\n", This, p);
2811     return E_NOTIMPL;
2812 }
2813
2814 static HRESULT WINAPI HTMLDocument5_get_implementation(IHTMLDocument5 *iface, IHTMLDOMImplementation **p)
2815 {
2816     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2817     HTMLDocumentNode *doc_node = This->doc_node;
2818
2819     TRACE("(%p)->(%p)\n", This, p);
2820
2821     if(!doc_node->dom_implementation) {
2822         HRESULT hres;
2823
2824         hres = create_dom_implementation(&doc_node->dom_implementation);
2825         if(FAILED(hres))
2826             return hres;
2827     }
2828
2829     IHTMLDOMImplementation_AddRef(doc_node->dom_implementation);
2830     *p = doc_node->dom_implementation;
2831     return S_OK;
2832 }
2833
2834 static HRESULT WINAPI HTMLDocument5_createAttribute(IHTMLDocument5 *iface, BSTR bstrattrName,
2835         IHTMLDOMAttribute **ppattribute)
2836 {
2837     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2838     HTMLDOMAttribute *attr;
2839     HRESULT hres;
2840
2841     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrattrName), ppattribute);
2842
2843     hres = HTMLDOMAttribute_Create(bstrattrName, NULL, 0, &attr);
2844     if(FAILED(hres))
2845         return hres;
2846
2847     *ppattribute = &attr->IHTMLDOMAttribute_iface;
2848     return S_OK;
2849 }
2850
2851 static HRESULT WINAPI HTMLDocument5_createComment(IHTMLDocument5 *iface, BSTR bstrdata,
2852         IHTMLDOMNode **ppRetNode)
2853 {
2854     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2855     nsIDOMComment *nscomment;
2856     HTMLElement *elem;
2857     nsAString str;
2858     nsresult nsres;
2859     HRESULT hres;
2860
2861     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrdata), ppRetNode);
2862
2863     if(!This->doc_node->nsdoc) {
2864         WARN("NULL nsdoc\n");
2865         return E_UNEXPECTED;
2866     }
2867
2868     nsAString_InitDepend(&str, bstrdata);
2869     nsres = nsIDOMHTMLDocument_CreateComment(This->doc_node->nsdoc, &str, &nscomment);
2870     nsAString_Finish(&str);
2871     if(NS_FAILED(nsres)) {
2872         ERR("CreateTextNode failed: %08x\n", nsres);
2873         return E_FAIL;
2874     }
2875
2876     hres = HTMLCommentElement_Create(This->doc_node, (nsIDOMNode*)nscomment, &elem);
2877     nsIDOMComment_Release(nscomment);
2878     if(FAILED(hres))
2879         return hres;
2880
2881     *ppRetNode = &elem->node.IHTMLDOMNode_iface;
2882     return S_OK;
2883 }
2884
2885 static HRESULT WINAPI HTMLDocument5_put_onfocusin(IHTMLDocument5 *iface, VARIANT v)
2886 {
2887     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2888
2889     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2890
2891     return set_doc_event(This, EVENTID_FOCUSIN, &v);
2892 }
2893
2894 static HRESULT WINAPI HTMLDocument5_get_onfocusin(IHTMLDocument5 *iface, VARIANT *p)
2895 {
2896     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2897
2898     TRACE("(%p)->(%p)\n", This, p);
2899
2900     return get_doc_event(This, EVENTID_FOCUSIN, p);
2901 }
2902
2903 static HRESULT WINAPI HTMLDocument5_put_onfocusout(IHTMLDocument5 *iface, VARIANT v)
2904 {
2905     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2906
2907     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2908
2909     return set_doc_event(This, EVENTID_FOCUSOUT, &v);
2910 }
2911
2912 static HRESULT WINAPI HTMLDocument5_get_onfocusout(IHTMLDocument5 *iface, VARIANT *p)
2913 {
2914     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2915
2916     TRACE("(%p)->(%p)\n", This, p);
2917
2918     return get_doc_event(This, EVENTID_FOCUSOUT, p);
2919 }
2920
2921 static HRESULT WINAPI HTMLDocument5_put_onactivate(IHTMLDocument5 *iface, VARIANT v)
2922 {
2923     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2924     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2925     return E_NOTIMPL;
2926 }
2927
2928 static HRESULT WINAPI HTMLDocument5_get_onactivate(IHTMLDocument5 *iface, VARIANT *p)
2929 {
2930     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2931     FIXME("(%p)->(%p)\n", This, p);
2932     return E_NOTIMPL;
2933 }
2934
2935 static HRESULT WINAPI HTMLDocument5_put_ondeactivate(IHTMLDocument5 *iface, VARIANT v)
2936 {
2937     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2938     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2939     return E_NOTIMPL;
2940 }
2941
2942 static HRESULT WINAPI HTMLDocument5_get_ondeactivate(IHTMLDocument5 *iface, VARIANT *p)
2943 {
2944     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2945     FIXME("(%p)->(%p)\n", This, p);
2946     return E_NOTIMPL;
2947 }
2948
2949 static HRESULT WINAPI HTMLDocument5_put_onbeforeactivate(IHTMLDocument5 *iface, VARIANT v)
2950 {
2951     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2952     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2953     return E_NOTIMPL;
2954 }
2955
2956 static HRESULT WINAPI HTMLDocument5_get_onbeforeactivate(IHTMLDocument5 *iface, VARIANT *p)
2957 {
2958     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2959     FIXME("(%p)->(%p)\n", This, p);
2960     return E_NOTIMPL;
2961 }
2962
2963 static HRESULT WINAPI HTMLDocument5_put_onbeforedeactivate(IHTMLDocument5 *iface, VARIANT v)
2964 {
2965     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2966     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2967     return E_NOTIMPL;
2968 }
2969
2970 static HRESULT WINAPI HTMLDocument5_get_onbeforedeactivate(IHTMLDocument5 *iface, VARIANT *p)
2971 {
2972     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2973     FIXME("(%p)->(%p)\n", This, p);
2974     return E_NOTIMPL;
2975 }
2976
2977 static HRESULT WINAPI HTMLDocument5_get_compatMode(IHTMLDocument5 *iface, BSTR *p)
2978 {
2979     HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2980
2981     static const WCHAR BackCompatW[] = {'B','a','c','k','C','o','m','p','a','t',0};
2982     static const WCHAR CSS1CompatW[] = {'C','S','S','1','C','o','m','p','a','t',0};
2983
2984     TRACE("(%p)->(%p)\n", This, p);
2985
2986     *p = SysAllocString(This->doc_node->document_mode <= COMPAT_MODE_IE5 ? BackCompatW : CSS1CompatW);
2987     return *p ? S_OK : E_OUTOFMEMORY;
2988 }
2989
2990 static const IHTMLDocument5Vtbl HTMLDocument5Vtbl = {
2991     HTMLDocument5_QueryInterface,
2992     HTMLDocument5_AddRef,
2993     HTMLDocument5_Release,
2994     HTMLDocument5_GetTypeInfoCount,
2995     HTMLDocument5_GetTypeInfo,
2996     HTMLDocument5_GetIDsOfNames,
2997     HTMLDocument5_Invoke,
2998     HTMLDocument5_put_onmousewheel,
2999     HTMLDocument5_get_onmousewheel,
3000     HTMLDocument5_get_doctype,
3001     HTMLDocument5_get_implementation,
3002     HTMLDocument5_createAttribute,
3003     HTMLDocument5_createComment,
3004     HTMLDocument5_put_onfocusin,
3005     HTMLDocument5_get_onfocusin,
3006     HTMLDocument5_put_onfocusout,
3007     HTMLDocument5_get_onfocusout,
3008     HTMLDocument5_put_onactivate,
3009     HTMLDocument5_get_onactivate,
3010     HTMLDocument5_put_ondeactivate,
3011     HTMLDocument5_get_ondeactivate,
3012     HTMLDocument5_put_onbeforeactivate,
3013     HTMLDocument5_get_onbeforeactivate,
3014     HTMLDocument5_put_onbeforedeactivate,
3015     HTMLDocument5_get_onbeforedeactivate,
3016     HTMLDocument5_get_compatMode
3017 };
3018
3019 static inline HTMLDocument *impl_from_IHTMLDocument6(IHTMLDocument6 *iface)
3020 {
3021     return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument6_iface);
3022 }
3023
3024 static HRESULT WINAPI HTMLDocument6_QueryInterface(IHTMLDocument6 *iface,
3025         REFIID riid, void **ppv)
3026 {
3027     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3028     return htmldoc_query_interface(This, riid, ppv);
3029 }
3030
3031 static ULONG WINAPI HTMLDocument6_AddRef(IHTMLDocument6 *iface)
3032 {
3033     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3034     return htmldoc_addref(This);
3035 }
3036
3037 static ULONG WINAPI HTMLDocument6_Release(IHTMLDocument6 *iface)
3038 {
3039     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3040     return htmldoc_release(This);
3041 }
3042
3043 static HRESULT WINAPI HTMLDocument6_GetTypeInfoCount(IHTMLDocument6 *iface, UINT *pctinfo)
3044 {
3045     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3046     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
3047 }
3048
3049 static HRESULT WINAPI HTMLDocument6_GetTypeInfo(IHTMLDocument6 *iface, UINT iTInfo,
3050         LCID lcid, ITypeInfo **ppTInfo)
3051 {
3052     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3053     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3054 }
3055
3056 static HRESULT WINAPI HTMLDocument6_GetIDsOfNames(IHTMLDocument6 *iface, REFIID riid,
3057         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
3058 {
3059     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3060     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
3061             rgDispId);
3062 }
3063
3064 static HRESULT WINAPI HTMLDocument6_Invoke(IHTMLDocument6 *iface, DISPID dispIdMember,
3065                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
3066                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3067 {
3068     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3069     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
3070             pDispParams, pVarResult, pExcepInfo, puArgErr);
3071 }
3072
3073 static HRESULT WINAPI HTMLDocument6_get_compatible(IHTMLDocument6 *iface,
3074         IHTMLDocumentCompatibleInfoCollection **p)
3075 {
3076     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3077     FIXME("(%p)->(%p)\n", This, p);
3078     return E_NOTIMPL;
3079 }
3080
3081 static HRESULT WINAPI HTMLDocument6_get_documentMode(IHTMLDocument6 *iface, VARIANT *p)
3082 {
3083     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3084
3085     TRACE("(%p)->(%p)\n", This, p);
3086
3087     if(!This->doc_node) {
3088         FIXME("NULL doc_node\n");
3089         return E_UNEXPECTED;
3090     }
3091
3092     V_VT(p) = VT_R4;
3093     V_R4(p) = compat_mode_info[This->doc_node->document_mode].document_mode;
3094     return S_OK;
3095 }
3096
3097 static HRESULT WINAPI HTMLDocument6_get_onstorage(IHTMLDocument6 *iface,
3098         VARIANT *p)
3099 {
3100     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3101     FIXME("(%p)->(%p)\n", This, p);
3102     return E_NOTIMPL;
3103 }
3104
3105 static HRESULT WINAPI HTMLDocument6_put_onstorage(IHTMLDocument6 *iface, VARIANT v)
3106 {
3107     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3108     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3109     return E_NOTIMPL;
3110 }
3111
3112 static HRESULT WINAPI HTMLDocument6_get_onstoragecommit(IHTMLDocument6 *iface,
3113         VARIANT *p)
3114 {
3115     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3116     FIXME("(%p)->(%p)\n", This, p);
3117     return E_NOTIMPL;
3118 }
3119
3120 static HRESULT WINAPI HTMLDocument6_put_onstoragecommit(IHTMLDocument6 *iface, VARIANT v)
3121 {
3122     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3123     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3124     return E_NOTIMPL;
3125 }
3126
3127 static HRESULT WINAPI HTMLDocument6_getElementById(IHTMLDocument6 *iface,
3128         BSTR bstrId, IHTMLElement2 **p)
3129 {
3130     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3131     nsIDOMElement *nselem;
3132     HTMLElement *elem;
3133     nsAString nsstr;
3134     nsresult nsres;
3135     HRESULT hres;
3136
3137     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrId), p);
3138
3139     /*
3140      * Unlike IHTMLDocument3 implementation, this is standard compliant and does
3141      * not search for name attributes, so we may simply let Gecko do the right thing.
3142      */
3143
3144     if(!This->doc_node->nsdoc) {
3145         FIXME("Not a document\n");
3146         return E_FAIL;
3147     }
3148
3149     nsAString_InitDepend(&nsstr, bstrId);
3150     nsres = nsIDOMHTMLDocument_GetElementById(This->doc_node->nsdoc, &nsstr, &nselem);
3151     nsAString_Finish(&nsstr);
3152     if(NS_FAILED(nsres)) {
3153         ERR("GetElementById failed: %08x\n", nsres);
3154         return E_FAIL;
3155     }
3156
3157     if(!nselem) {
3158         *p = NULL;
3159         return S_OK;
3160     }
3161
3162     hres = get_element(nselem, &elem);
3163     nsIDOMElement_Release(nselem);
3164     if(FAILED(hres))
3165         return hres;
3166
3167     *p = &elem->IHTMLElement2_iface;
3168     return S_OK;
3169 }
3170
3171 static HRESULT WINAPI HTMLDocument6_updateSettings(IHTMLDocument6 *iface)
3172 {
3173     HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3174     FIXME("(%p)->()\n", This);
3175     return E_NOTIMPL;
3176 }
3177
3178 static const IHTMLDocument6Vtbl HTMLDocument6Vtbl = {
3179     HTMLDocument6_QueryInterface,
3180     HTMLDocument6_AddRef,
3181     HTMLDocument6_Release,
3182     HTMLDocument6_GetTypeInfoCount,
3183     HTMLDocument6_GetTypeInfo,
3184     HTMLDocument6_GetIDsOfNames,
3185     HTMLDocument6_Invoke,
3186     HTMLDocument6_get_compatible,
3187     HTMLDocument6_get_documentMode,
3188     HTMLDocument6_put_onstorage,
3189     HTMLDocument6_get_onstorage,
3190     HTMLDocument6_put_onstoragecommit,
3191     HTMLDocument6_get_onstoragecommit,
3192     HTMLDocument6_getElementById,
3193     HTMLDocument6_updateSettings
3194 };
3195
3196 static inline HTMLDocument *impl_from_IHTMLDocument7(IHTMLDocument7 *iface)
3197 {
3198     return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument7_iface);
3199 }
3200
3201 static HRESULT WINAPI HTMLDocument7_QueryInterface(IHTMLDocument7 *iface, REFIID riid, void **ppv)
3202 {
3203     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3204     return htmldoc_query_interface(This, riid, ppv);
3205 }
3206
3207 static ULONG WINAPI HTMLDocument7_AddRef(IHTMLDocument7 *iface)
3208 {
3209     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3210     return htmldoc_addref(This);
3211 }
3212
3213 static ULONG WINAPI HTMLDocument7_Release(IHTMLDocument7 *iface)
3214 {
3215     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3216     return htmldoc_release(This);
3217 }
3218
3219 static HRESULT WINAPI HTMLDocument7_GetTypeInfoCount(IHTMLDocument7 *iface, UINT *pctinfo)
3220 {
3221     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3222     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
3223 }
3224
3225 static HRESULT WINAPI HTMLDocument7_GetTypeInfo(IHTMLDocument7 *iface, UINT iTInfo,
3226         LCID lcid, ITypeInfo **ppTInfo)
3227 {
3228     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3229     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3230 }
3231
3232 static HRESULT WINAPI HTMLDocument7_GetIDsOfNames(IHTMLDocument7 *iface, REFIID riid,
3233         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
3234 {
3235     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3236     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
3237             rgDispId);
3238 }
3239
3240 static HRESULT WINAPI HTMLDocument7_Invoke(IHTMLDocument7 *iface, DISPID dispIdMember,
3241                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
3242                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3243 {
3244     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3245     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
3246             pDispParams, pVarResult, pExcepInfo, puArgErr);
3247 }
3248
3249 static HRESULT WINAPI HTMLDocument7_get_defaultView(IHTMLDocument7 *iface, IHTMLWindow2 **p)
3250 {
3251     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3252
3253     TRACE("(%p)->(%p)\n", This, p);
3254
3255     *p = &This->window->base.IHTMLWindow2_iface;
3256     IHTMLWindow2_AddRef(*p);
3257     return S_OK;
3258 }
3259
3260 static HRESULT WINAPI HTMLDocument7_createCDATASection(IHTMLDocument7 *iface, BSTR text, IHTMLDOMNode **newCDATASectionNode)
3261 {
3262     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3263     FIXME("(%p)->(%p)\n", This, newCDATASectionNode);
3264     return E_NOTIMPL;
3265 }
3266
3267 static HRESULT WINAPI HTMLDocument7_getSelection(IHTMLDocument7 *iface, IHTMLSelection **ppIHTMLSelection)
3268 {
3269     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3270     FIXME("(%p)->(%p)\n", This, ppIHTMLSelection);
3271     return E_NOTIMPL;
3272 }
3273
3274 static HRESULT WINAPI HTMLDocument7_getElementsByTagNameNS(IHTMLDocument7 *iface, VARIANT *pvarNS,
3275         BSTR bstrLocalName, IHTMLElementCollection **pelColl)
3276 {
3277     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3278     FIXME("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(bstrLocalName), pelColl);
3279     return E_NOTIMPL;
3280 }
3281
3282 static HRESULT WINAPI HTMLDocument7_createElementNS(IHTMLDocument7 *iface, VARIANT *pvarNS, BSTR bstrTag, IHTMLElement **newElem)
3283 {
3284     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3285     FIXME("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(bstrTag), newElem);
3286     return E_NOTIMPL;
3287 }
3288
3289 static HRESULT WINAPI HTMLDocument7_createAttributeNS(IHTMLDocument7 *iface, VARIANT *pvarNS,
3290         BSTR bstrAttrName, IHTMLDOMAttribute **ppAttribute)
3291 {
3292     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3293     FIXME("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(bstrAttrName), ppAttribute);
3294     return E_NOTIMPL;
3295 }
3296
3297 static HRESULT WINAPI HTMLDocument7_put_onmsthumbnailclick(IHTMLDocument7 *iface, VARIANT v)
3298 {
3299     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3300     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3301     return E_NOTIMPL;
3302 }
3303
3304 static HRESULT WINAPI HTMLDocument7_get_onmsthumbnailclick(IHTMLDocument7 *iface, VARIANT *p)
3305 {
3306     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3307     FIXME("(%p)->(%p)\n", This, p);
3308     return E_NOTIMPL;
3309 }
3310
3311 static HRESULT WINAPI HTMLDocument7_get_characterSet(IHTMLDocument7 *iface, BSTR *p)
3312 {
3313     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3314     nsAString charset_str;
3315     nsresult nsres;
3316
3317     TRACE("(%p)->(%p)\n", This, p);
3318
3319     if(!This->doc_node->nsdoc) {
3320         FIXME("NULL nsdoc\n");
3321         return E_FAIL;
3322     }
3323
3324     nsAString_Init(&charset_str, NULL);
3325     nsres = nsIDOMHTMLDocument_GetCharacterSet(This->doc_node->nsdoc, &charset_str);
3326     return return_nsstr(nsres, &charset_str, p);
3327 }
3328
3329 static HRESULT WINAPI HTMLDocument7_createElement(IHTMLDocument7 *iface, BSTR bstrTag, IHTMLElement **newElem)
3330 {
3331     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3332
3333     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrTag), newElem);
3334
3335     return IHTMLDocument2_createElement(&This->IHTMLDocument2_iface, bstrTag, newElem);
3336 }
3337
3338 static HRESULT WINAPI HTMLDocument7_createAttribute(IHTMLDocument7 *iface, BSTR bstrAttrName, IHTMLDOMAttribute **ppAttribute)
3339 {
3340     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3341
3342     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrAttrName), ppAttribute);
3343
3344     return IHTMLDocument5_createAttribute(&This->IHTMLDocument5_iface, bstrAttrName, ppAttribute);
3345 }
3346
3347 static HRESULT WINAPI HTMLDocument7_getElementsByClassName(IHTMLDocument7 *iface, BSTR v, IHTMLElementCollection **pel)
3348 {
3349     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3350     nsIDOMNodeList *nslist;
3351     nsAString nsstr;
3352     nsresult nsres;
3353
3354     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
3355
3356     if(!This->doc_node->nsdoc) {
3357         FIXME("NULL nsdoc not supported\n");
3358         return E_NOTIMPL;
3359     }
3360
3361     nsAString_InitDepend(&nsstr, v);
3362     nsres = nsIDOMHTMLDocument_GetElementsByClassName(This->doc_node->nsdoc, &nsstr, &nslist);
3363     nsAString_Finish(&nsstr);
3364     if(FAILED(nsres)) {
3365         ERR("GetElementByClassName failed: %08x\n", nsres);
3366         return E_FAIL;
3367     }
3368
3369
3370     *pel = create_collection_from_nodelist(nslist, This->doc_node->document_mode);
3371     nsIDOMNodeList_Release(nslist);
3372     return S_OK;
3373 }
3374
3375 static HRESULT WINAPI HTMLDocument7_createProcessingInstruction(IHTMLDocument7 *iface, BSTR target,
3376         BSTR data, IDOMProcessingInstruction **newProcessingInstruction)
3377 {
3378     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3379     FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(target), debugstr_w(data), newProcessingInstruction);
3380     return E_NOTIMPL;
3381 }
3382
3383 static HRESULT WINAPI HTMLDocument7_adoptNode(IHTMLDocument7 *iface, IHTMLDOMNode *pNodeSource, IHTMLDOMNode3 **ppNodeDest)
3384 {
3385     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3386     FIXME("(%p)->(%p %p)\n", This, pNodeSource, ppNodeDest);
3387     return E_NOTIMPL;
3388 }
3389
3390 static HRESULT WINAPI HTMLDocument7_put_onmssitemodejumplistitemremoved(IHTMLDocument7 *iface, VARIANT v)
3391 {
3392     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3393     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3394     return E_NOTIMPL;
3395 }
3396
3397 static HRESULT WINAPI HTMLDocument7_get_onmssitemodejumplistitemremoved(IHTMLDocument7 *iface, VARIANT *p)
3398 {
3399     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3400     FIXME("(%p)->(%p)\n", This, p);
3401     return E_NOTIMPL;
3402 }
3403
3404 static HRESULT WINAPI HTMLDocument7_get_all(IHTMLDocument7 *iface, IHTMLElementCollection **p)
3405 {
3406     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3407
3408     TRACE("(%p)->(%p)\n", This, p);
3409
3410     return IHTMLDocument2_get_all(&This->IHTMLDocument2_iface, p);
3411 }
3412
3413 static HRESULT WINAPI HTMLDocument7_get_inputEncoding(IHTMLDocument7 *iface, BSTR *p)
3414 {
3415     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3416     FIXME("(%p)->(%p)\n", This, p);
3417     return E_NOTIMPL;
3418 }
3419
3420 static HRESULT WINAPI HTMLDocument7_get_xmlEncoding(IHTMLDocument7 *iface, BSTR *p)
3421 {
3422     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3423     FIXME("(%p)->(%p)\n", This, p);
3424     return E_NOTIMPL;
3425 }
3426
3427 static HRESULT WINAPI HTMLDocument7_put_xmlStandalone(IHTMLDocument7 *iface, VARIANT_BOOL v)
3428 {
3429     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3430     FIXME("(%p)->(%x)\n", This, v);
3431     return E_NOTIMPL;
3432 }
3433
3434 static HRESULT WINAPI HTMLDocument7_get_xmlStandalone(IHTMLDocument7 *iface, VARIANT_BOOL *p)
3435 {
3436     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3437     FIXME("(%p)->(%p)\n", This, p);
3438     return E_NOTIMPL;
3439 }
3440
3441 static HRESULT WINAPI HTMLDocument7_put_xmlVersion(IHTMLDocument7 *iface, BSTR v)
3442 {
3443     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3444     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3445     return E_NOTIMPL;
3446 }
3447
3448 static HRESULT WINAPI HTMLDocument7_get_xmlVersion(IHTMLDocument7 *iface, BSTR *p)
3449 {
3450     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3451     FIXME("(%p)->(%p)\n", This, p);
3452     return E_NOTIMPL;
3453 }
3454
3455 static HRESULT WINAPI HTMLDocument7_hasAttributes(IHTMLDocument7 *iface, VARIANT_BOOL *pfHasAttributes)
3456 {
3457     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3458     FIXME("(%p)->(%p)\n", This, pfHasAttributes);
3459     return E_NOTIMPL;
3460 }
3461
3462 static HRESULT WINAPI HTMLDocument7_put_onabort(IHTMLDocument7 *iface, VARIANT v)
3463 {
3464     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3465
3466     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3467
3468     return set_doc_event(This, EVENTID_ABORT, &v);
3469 }
3470
3471 static HRESULT WINAPI HTMLDocument7_get_onabort(IHTMLDocument7 *iface, VARIANT *p)
3472 {
3473     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3474
3475     TRACE("(%p)->(%p)\n", This, p);
3476
3477     return get_doc_event(This, EVENTID_ABORT, p);
3478 }
3479
3480 static HRESULT WINAPI HTMLDocument7_put_onblur(IHTMLDocument7 *iface, VARIANT v)
3481 {
3482     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3483
3484     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3485
3486     return set_doc_event(This, EVENTID_BLUR, &v);
3487 }
3488
3489 static HRESULT WINAPI HTMLDocument7_get_onblur(IHTMLDocument7 *iface, VARIANT *p)
3490 {
3491     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3492
3493     TRACE("(%p)->(%p)\n", This, p);
3494
3495     return get_doc_event(This, EVENTID_BLUR, p);
3496 }
3497
3498 static HRESULT WINAPI HTMLDocument7_put_oncanplay(IHTMLDocument7 *iface, VARIANT v)
3499 {
3500     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3501     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3502     return E_NOTIMPL;
3503 }
3504
3505 static HRESULT WINAPI HTMLDocument7_get_oncanplay(IHTMLDocument7 *iface, VARIANT *p)
3506 {
3507     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3508     FIXME("(%p)->(%p)\n", This, p);
3509     return E_NOTIMPL;
3510 }
3511
3512 static HRESULT WINAPI HTMLDocument7_put_oncanplaythrough(IHTMLDocument7 *iface, VARIANT v)
3513 {
3514     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3515     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3516     return E_NOTIMPL;
3517 }
3518
3519 static HRESULT WINAPI HTMLDocument7_get_oncanplaythrough(IHTMLDocument7 *iface, VARIANT *p)
3520 {
3521     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3522     FIXME("(%p)->(%p)\n", This, p);
3523     return E_NOTIMPL;
3524 }
3525
3526 static HRESULT WINAPI HTMLDocument7_put_onchange(IHTMLDocument7 *iface, VARIANT v)
3527 {
3528     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3529
3530     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3531
3532     return set_doc_event(This, EVENTID_CHANGE, &v);
3533 }
3534
3535 static HRESULT WINAPI HTMLDocument7_get_onchange(IHTMLDocument7 *iface, VARIANT *p)
3536 {
3537     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3538
3539     TRACE("(%p)->(%p)\n", This, p);
3540
3541     return get_doc_event(This, EVENTID_CHANGE, p);
3542 }
3543
3544 static HRESULT WINAPI HTMLDocument7_put_ondrag(IHTMLDocument7 *iface, VARIANT v)
3545 {
3546     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3547
3548     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3549
3550     return set_doc_event(This, EVENTID_DRAG, &v);
3551 }
3552
3553 static HRESULT WINAPI HTMLDocument7_get_ondrag(IHTMLDocument7 *iface, VARIANT *p)
3554 {
3555     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3556
3557     TRACE("(%p)->(%p)\n", This, p);
3558
3559     return get_doc_event(This, EVENTID_DRAG, p);
3560 }
3561
3562 static HRESULT WINAPI HTMLDocument7_put_ondragend(IHTMLDocument7 *iface, VARIANT v)
3563 {
3564     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3565     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3566     return E_NOTIMPL;
3567 }
3568
3569 static HRESULT WINAPI HTMLDocument7_get_ondragend(IHTMLDocument7 *iface, VARIANT *p)
3570 {
3571     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3572     FIXME("(%p)->(%p)\n", This, p);
3573     return E_NOTIMPL;
3574 }
3575
3576 static HRESULT WINAPI HTMLDocument7_put_ondragenter(IHTMLDocument7 *iface, VARIANT v)
3577 {
3578     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3579     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3580     return E_NOTIMPL;
3581 }
3582
3583 static HRESULT WINAPI HTMLDocument7_get_ondragenter(IHTMLDocument7 *iface, VARIANT *p)
3584 {
3585     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3586     FIXME("(%p)->(%p)\n", This, p);
3587     return E_NOTIMPL;
3588 }
3589
3590 static HRESULT WINAPI HTMLDocument7_put_ondragleave(IHTMLDocument7 *iface, VARIANT v)
3591 {
3592     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3593     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3594     return E_NOTIMPL;
3595 }
3596
3597 static HRESULT WINAPI HTMLDocument7_get_ondragleave(IHTMLDocument7 *iface, VARIANT *p)
3598 {
3599     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3600     FIXME("(%p)->(%p)\n", This, p);
3601     return E_NOTIMPL;
3602 }
3603
3604 static HRESULT WINAPI HTMLDocument7_put_ondragover(IHTMLDocument7 *iface, VARIANT v)
3605 {
3606     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3607     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3608     return E_NOTIMPL;
3609 }
3610
3611 static HRESULT WINAPI HTMLDocument7_get_ondragover(IHTMLDocument7 *iface, VARIANT *p)
3612 {
3613     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3614     FIXME("(%p)->(%p)\n", This, p);
3615     return E_NOTIMPL;
3616 }
3617
3618 static HRESULT WINAPI HTMLDocument7_put_ondrop(IHTMLDocument7 *iface, VARIANT v)
3619 {
3620     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3621     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3622     return E_NOTIMPL;
3623 }
3624
3625 static HRESULT WINAPI HTMLDocument7_get_ondrop(IHTMLDocument7 *iface, VARIANT *p)
3626 {
3627     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3628     FIXME("(%p)->(%p)\n", This, p);
3629     return E_NOTIMPL;
3630 }
3631
3632 static HRESULT WINAPI HTMLDocument7_put_ondurationchange(IHTMLDocument7 *iface, VARIANT v)
3633 {
3634     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3635     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3636     return E_NOTIMPL;
3637 }
3638
3639 static HRESULT WINAPI HTMLDocument7_get_ondurationchange(IHTMLDocument7 *iface, VARIANT *p)
3640 {
3641     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3642     FIXME("(%p)->(%p)\n", This, p);
3643     return E_NOTIMPL;
3644 }
3645
3646 static HRESULT WINAPI HTMLDocument7_put_onemptied(IHTMLDocument7 *iface, VARIANT v)
3647 {
3648     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3649     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3650     return E_NOTIMPL;
3651 }
3652
3653 static HRESULT WINAPI HTMLDocument7_get_onemptied(IHTMLDocument7 *iface, VARIANT *p)
3654 {
3655     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3656     FIXME("(%p)->(%p)\n", This, p);
3657     return E_NOTIMPL;
3658 }
3659
3660 static HRESULT WINAPI HTMLDocument7_put_onended(IHTMLDocument7 *iface, VARIANT v)
3661 {
3662     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3663     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3664     return E_NOTIMPL;
3665 }
3666
3667 static HRESULT WINAPI HTMLDocument7_get_onended(IHTMLDocument7 *iface, VARIANT *p)
3668 {
3669     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3670     FIXME("(%p)->(%p)\n", This, p);
3671     return E_NOTIMPL;
3672 }
3673
3674 static HRESULT WINAPI HTMLDocument7_put_onerror(IHTMLDocument7 *iface, VARIANT v)
3675 {
3676     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3677
3678     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3679
3680     return set_doc_event(This, EVENTID_ERROR, &v);
3681 }
3682
3683 static HRESULT WINAPI HTMLDocument7_get_onerror(IHTMLDocument7 *iface, VARIANT *p)
3684 {
3685     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3686
3687     TRACE("(%p)->(%p)\n", This, p);
3688
3689     return get_doc_event(This, EVENTID_ERROR, p);
3690 }
3691
3692 static HRESULT WINAPI HTMLDocument7_put_onfocus(IHTMLDocument7 *iface, VARIANT v)
3693 {
3694     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3695
3696     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3697
3698     return set_doc_event(This, EVENTID_FOCUS, &v);
3699 }
3700
3701 static HRESULT WINAPI HTMLDocument7_get_onfocus(IHTMLDocument7 *iface, VARIANT *p)
3702 {
3703     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3704
3705     TRACE("(%p)->(%p)\n", This, p);
3706
3707     return get_doc_event(This, EVENTID_FOCUS, p);
3708 }
3709
3710 static HRESULT WINAPI HTMLDocument7_put_oninput(IHTMLDocument7 *iface, VARIANT v)
3711 {
3712     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3713
3714     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3715
3716     return set_doc_event(This, EVENTID_INPUT, &v);
3717 }
3718
3719 static HRESULT WINAPI HTMLDocument7_get_oninput(IHTMLDocument7 *iface, VARIANT *p)
3720 {
3721     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3722
3723     TRACE("(%p)->(%p)\n", This, p);
3724
3725     return get_doc_event(This, EVENTID_INPUT, p);
3726 }
3727
3728 static HRESULT WINAPI HTMLDocument7_put_onload(IHTMLDocument7 *iface, VARIANT v)
3729 {
3730     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3731
3732     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3733
3734     return set_doc_event(This, EVENTID_LOAD, &v);
3735 }
3736
3737 static HRESULT WINAPI HTMLDocument7_get_onload(IHTMLDocument7 *iface, VARIANT *p)
3738 {
3739     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3740
3741     TRACE("(%p)->(%p)\n", This, p);
3742
3743     return get_doc_event(This, EVENTID_LOAD, p);
3744 }
3745
3746 static HRESULT WINAPI HTMLDocument7_put_onloadeddata(IHTMLDocument7 *iface, VARIANT v)
3747 {
3748     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3749     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3750     return E_NOTIMPL;
3751 }
3752
3753 static HRESULT WINAPI HTMLDocument7_get_onloadeddata(IHTMLDocument7 *iface, VARIANT *p)
3754 {
3755     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3756     FIXME("(%p)->(%p)\n", This, p);
3757     return E_NOTIMPL;
3758 }
3759
3760 static HRESULT WINAPI HTMLDocument7_put_onloadedmetadata(IHTMLDocument7 *iface, VARIANT v)
3761 {
3762     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3763     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3764     return E_NOTIMPL;
3765 }
3766
3767 static HRESULT WINAPI HTMLDocument7_get_onloadedmetadata(IHTMLDocument7 *iface, VARIANT *p)
3768 {
3769     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3770     FIXME("(%p)->(%p)\n", This, p);
3771     return E_NOTIMPL;
3772 }
3773
3774 static HRESULT WINAPI HTMLDocument7_put_onloadstart(IHTMLDocument7 *iface, VARIANT v)
3775 {
3776     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3777     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3778     return E_NOTIMPL;
3779 }
3780
3781 static HRESULT WINAPI HTMLDocument7_get_onloadstart(IHTMLDocument7 *iface, VARIANT *p)
3782 {
3783     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3784     FIXME("(%p)->(%p)\n", This, p);
3785     return E_NOTIMPL;
3786 }
3787
3788 static HRESULT WINAPI HTMLDocument7_put_onpause(IHTMLDocument7 *iface, VARIANT v)
3789 {
3790     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3791     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3792     return E_NOTIMPL;
3793 }
3794
3795 static HRESULT WINAPI HTMLDocument7_get_onpause(IHTMLDocument7 *iface, VARIANT *p)
3796 {
3797     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3798     FIXME("(%p)->(%p)\n", This, p);
3799     return E_NOTIMPL;
3800 }
3801
3802 static HRESULT WINAPI HTMLDocument7_put_onplay(IHTMLDocument7 *iface, VARIANT v)
3803 {
3804     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3805     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3806     return E_NOTIMPL;
3807 }
3808
3809 static HRESULT WINAPI HTMLDocument7_get_onplay(IHTMLDocument7 *iface, VARIANT *p)
3810 {
3811     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3812     FIXME("(%p)->(%p)\n", This, p);
3813     return E_NOTIMPL;
3814 }
3815
3816 static HRESULT WINAPI HTMLDocument7_put_onplaying(IHTMLDocument7 *iface, VARIANT v)
3817 {
3818     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3819     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3820     return E_NOTIMPL;
3821 }
3822
3823 static HRESULT WINAPI HTMLDocument7_get_onplaying(IHTMLDocument7 *iface, VARIANT *p)
3824 {
3825     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3826     FIXME("(%p)->(%p)\n", This, p);
3827     return E_NOTIMPL;
3828 }
3829
3830 static HRESULT WINAPI HTMLDocument7_put_onprogress(IHTMLDocument7 *iface, VARIANT v)
3831 {
3832     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3833     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3834     return E_NOTIMPL;
3835 }
3836
3837 static HRESULT WINAPI HTMLDocument7_get_onprogress(IHTMLDocument7 *iface, VARIANT *p)
3838 {
3839     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3840     FIXME("(%p)->(%p)\n", This, p);
3841     return E_NOTIMPL;
3842 }
3843
3844 static HRESULT WINAPI HTMLDocument7_put_onratechange(IHTMLDocument7 *iface, VARIANT v)
3845 {
3846     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3847     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3848     return E_NOTIMPL;
3849 }
3850
3851 static HRESULT WINAPI HTMLDocument7_get_onratechange(IHTMLDocument7 *iface, VARIANT *p)
3852 {
3853     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3854     FIXME("(%p)->(%p)\n", This, p);
3855     return E_NOTIMPL;
3856 }
3857
3858 static HRESULT WINAPI HTMLDocument7_put_onreset(IHTMLDocument7 *iface, VARIANT v)
3859 {
3860     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3861     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3862     return E_NOTIMPL;
3863 }
3864
3865 static HRESULT WINAPI HTMLDocument7_get_onreset(IHTMLDocument7 *iface, VARIANT *p)
3866 {
3867     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3868     FIXME("(%p)->(%p)\n", This, p);
3869     return E_NOTIMPL;
3870 }
3871
3872 static HRESULT WINAPI HTMLDocument7_put_onscroll(IHTMLDocument7 *iface, VARIANT v)
3873 {
3874     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3875
3876     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3877
3878     return set_doc_event(This, EVENTID_SCROLL, &v);
3879 }
3880
3881 static HRESULT WINAPI HTMLDocument7_get_onscroll(IHTMLDocument7 *iface, VARIANT *p)
3882 {
3883     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3884
3885     TRACE("(%p)->(%p)\n", This, p);
3886
3887     return get_doc_event(This, EVENTID_SCROLL, p);
3888 }
3889
3890 static HRESULT WINAPI HTMLDocument7_put_onseekend(IHTMLDocument7 *iface, VARIANT v)
3891 {
3892     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3893     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3894     return E_NOTIMPL;
3895 }
3896
3897 static HRESULT WINAPI HTMLDocument7_get_onseekend(IHTMLDocument7 *iface, VARIANT *p)
3898 {
3899     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3900     FIXME("(%p)->(%p)\n", This, p);
3901     return E_NOTIMPL;
3902 }
3903
3904 static HRESULT WINAPI HTMLDocument7_put_onseeking(IHTMLDocument7 *iface, VARIANT v)
3905 {
3906     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3907     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3908     return E_NOTIMPL;
3909 }
3910
3911 static HRESULT WINAPI HTMLDocument7_get_onseeking(IHTMLDocument7 *iface, VARIANT *p)
3912 {
3913     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3914     FIXME("(%p)->(%p)\n", This, p);
3915     return E_NOTIMPL;
3916 }
3917
3918 static HRESULT WINAPI HTMLDocument7_put_onselect(IHTMLDocument7 *iface, VARIANT v)
3919 {
3920     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3921     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3922     return E_NOTIMPL;
3923 }
3924
3925 static HRESULT WINAPI HTMLDocument7_get_onselect(IHTMLDocument7 *iface, VARIANT *p)
3926 {
3927     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3928     FIXME("(%p)->(%p)\n", This, p);
3929     return E_NOTIMPL;
3930 }
3931
3932 static HRESULT WINAPI HTMLDocument7_put_onstalled(IHTMLDocument7 *iface, VARIANT v)
3933 {
3934     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3935     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3936     return E_NOTIMPL;
3937 }
3938
3939 static HRESULT WINAPI HTMLDocument7_get_onstalled(IHTMLDocument7 *iface, VARIANT *p)
3940 {
3941     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3942     FIXME("(%p)->(%p)\n", This, p);
3943     return E_NOTIMPL;
3944 }
3945
3946 static HRESULT WINAPI HTMLDocument7_put_onsubmit(IHTMLDocument7 *iface, VARIANT v)
3947 {
3948     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3949
3950     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3951
3952     return set_doc_event(This, EVENTID_SUBMIT, &v);
3953 }
3954
3955 static HRESULT WINAPI HTMLDocument7_get_onsubmit(IHTMLDocument7 *iface, VARIANT *p)
3956 {
3957     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3958
3959     TRACE("(%p)->(%p)\n", This, p);
3960
3961     return get_doc_event(This, EVENTID_SUBMIT, p);
3962 }
3963
3964 static HRESULT WINAPI HTMLDocument7_put_onsuspend(IHTMLDocument7 *iface, VARIANT v)
3965 {
3966     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3967     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3968     return E_NOTIMPL;
3969 }
3970
3971 static HRESULT WINAPI HTMLDocument7_get_onsuspend(IHTMLDocument7 *iface, VARIANT *p)
3972 {
3973     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3974     FIXME("(%p)->(%p)\n", This, p);
3975     return E_NOTIMPL;
3976 }
3977
3978 static HRESULT WINAPI HTMLDocument7_put_ontimeupdate(IHTMLDocument7 *iface, VARIANT v)
3979 {
3980     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3981     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3982     return E_NOTIMPL;
3983 }
3984
3985 static HRESULT WINAPI HTMLDocument7_get_ontimeupdate(IHTMLDocument7 *iface, VARIANT *p)
3986 {
3987     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3988     FIXME("(%p)->(%p)\n", This, p);
3989     return E_NOTIMPL;
3990 }
3991
3992 static HRESULT WINAPI HTMLDocument7_put_onvolumechange(IHTMLDocument7 *iface, VARIANT v)
3993 {
3994     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3995     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3996     return E_NOTIMPL;
3997 }
3998
3999 static HRESULT WINAPI HTMLDocument7_get_onvolumechange(IHTMLDocument7 *iface, VARIANT *p)
4000 {
4001     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4002     FIXME("(%p)->(%p)\n", This, p);
4003     return E_NOTIMPL;
4004 }
4005
4006 static HRESULT WINAPI HTMLDocument7_put_onwaiting(IHTMLDocument7 *iface, VARIANT v)
4007 {
4008     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4009     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4010     return E_NOTIMPL;
4011 }
4012
4013 static HRESULT WINAPI HTMLDocument7_get_onwaiting(IHTMLDocument7 *iface, VARIANT *p)
4014 {
4015     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4016     FIXME("(%p)->(%p)\n", This, p);
4017     return E_NOTIMPL;
4018 }
4019
4020 static HRESULT WINAPI HTMLDocument7_normalize(IHTMLDocument7 *iface)
4021 {
4022     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4023     FIXME("(%p)\n", This);
4024     return E_NOTIMPL;
4025 }
4026
4027 static HRESULT WINAPI HTMLDocument7_importNode(IHTMLDocument7 *iface, IHTMLDOMNode *pNodeSource,
4028         VARIANT_BOOL fDeep, IHTMLDOMNode3 **ppNodeDest)
4029 {
4030     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4031     FIXME("(%p)->(%p %x %p)\n", This, pNodeSource, fDeep, ppNodeDest);
4032     return E_NOTIMPL;
4033 }
4034
4035 static HRESULT WINAPI HTMLDocument7_get_parentWindow(IHTMLDocument7 *iface, IHTMLWindow2 **p)
4036 {
4037     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4038
4039     TRACE("(%p)->(%p)\n", This, p);
4040
4041     return IHTMLDocument7_get_defaultView(&This->IHTMLDocument7_iface, p);
4042 }
4043
4044 static HRESULT WINAPI HTMLDocument7_put_body(IHTMLDocument7 *iface, IHTMLElement *v)
4045 {
4046     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4047     FIXME("(%p)->(%p)\n", This, v);
4048     return E_NOTIMPL;
4049 }
4050
4051 static HRESULT WINAPI HTMLDocument7_get_body(IHTMLDocument7 *iface, IHTMLElement **p)
4052 {
4053     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4054
4055     TRACE("(%p)->(%p)\n", This, p);
4056
4057     return IHTMLDocument2_get_body(&This->IHTMLDocument2_iface, p);
4058 }
4059
4060 static HRESULT WINAPI HTMLDocument7_get_head(IHTMLDocument7 *iface, IHTMLElement **p)
4061 {
4062     HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4063     nsIDOMHTMLHeadElement *nshead;
4064     nsIDOMElement *nselem;
4065     HTMLElement *elem;
4066     nsresult nsres;
4067     HRESULT hres;
4068
4069     TRACE("(%p)->(%p)\n", This, p);
4070
4071     if(!This->doc_node->nsdoc) {
4072         FIXME("No document\n");
4073         return E_FAIL;
4074     }
4075
4076     nsres = nsIDOMHTMLDocument_GetHead(This->doc_node->nsdoc, &nshead);
4077     assert(nsres == NS_OK);
4078
4079     if(!nshead) {
4080         *p = NULL;
4081         return S_OK;
4082     }
4083
4084     nsres = nsIDOMHTMLHeadElement_QueryInterface(nshead, &IID_nsIDOMElement, (void**)&nselem);
4085     nsIDOMHTMLHeadElement_Release(nshead);
4086     assert(nsres == NS_OK);
4087
4088     hres = get_element(nselem, &elem);
4089     nsIDOMElement_Release(nselem);
4090     if(FAILED(hres))
4091         return hres;
4092
4093     *p = &elem->IHTMLElement_iface;
4094     return S_OK;
4095 }
4096
4097 static const IHTMLDocument7Vtbl HTMLDocument7Vtbl = {
4098     HTMLDocument7_QueryInterface,
4099     HTMLDocument7_AddRef,
4100     HTMLDocument7_Release,
4101     HTMLDocument7_GetTypeInfoCount,
4102     HTMLDocument7_GetTypeInfo,
4103     HTMLDocument7_GetIDsOfNames,
4104     HTMLDocument7_Invoke,
4105     HTMLDocument7_get_defaultView,
4106     HTMLDocument7_createCDATASection,
4107     HTMLDocument7_getSelection,
4108     HTMLDocument7_getElementsByTagNameNS,
4109     HTMLDocument7_createElementNS,
4110     HTMLDocument7_createAttributeNS,
4111     HTMLDocument7_put_onmsthumbnailclick,
4112     HTMLDocument7_get_onmsthumbnailclick,
4113     HTMLDocument7_get_characterSet,
4114     HTMLDocument7_createElement,
4115     HTMLDocument7_createAttribute,
4116     HTMLDocument7_getElementsByClassName,
4117     HTMLDocument7_createProcessingInstruction,
4118     HTMLDocument7_adoptNode,
4119     HTMLDocument7_put_onmssitemodejumplistitemremoved,
4120     HTMLDocument7_get_onmssitemodejumplistitemremoved,
4121     HTMLDocument7_get_all,
4122     HTMLDocument7_get_inputEncoding,
4123     HTMLDocument7_get_xmlEncoding,
4124     HTMLDocument7_put_xmlStandalone,
4125     HTMLDocument7_get_xmlStandalone,
4126     HTMLDocument7_put_xmlVersion,
4127     HTMLDocument7_get_xmlVersion,
4128     HTMLDocument7_hasAttributes,
4129     HTMLDocument7_put_onabort,
4130     HTMLDocument7_get_onabort,
4131     HTMLDocument7_put_onblur,
4132     HTMLDocument7_get_onblur,
4133     HTMLDocument7_put_oncanplay,
4134     HTMLDocument7_get_oncanplay,
4135     HTMLDocument7_put_oncanplaythrough,
4136     HTMLDocument7_get_oncanplaythrough,
4137     HTMLDocument7_put_onchange,
4138     HTMLDocument7_get_onchange,
4139     HTMLDocument7_put_ondrag,
4140     HTMLDocument7_get_ondrag,
4141     HTMLDocument7_put_ondragend,
4142     HTMLDocument7_get_ondragend,
4143     HTMLDocument7_put_ondragenter,
4144     HTMLDocument7_get_ondragenter,
4145     HTMLDocument7_put_ondragleave,
4146     HTMLDocument7_get_ondragleave,
4147     HTMLDocument7_put_ondragover,
4148     HTMLDocument7_get_ondragover,
4149     HTMLDocument7_put_ondrop,
4150     HTMLDocument7_get_ondrop,
4151     HTMLDocument7_put_ondurationchange,
4152     HTMLDocument7_get_ondurationchange,
4153     HTMLDocument7_put_onemptied,
4154     HTMLDocument7_get_onemptied,
4155     HTMLDocument7_put_onended,
4156     HTMLDocument7_get_onended,
4157     HTMLDocument7_put_onerror,
4158     HTMLDocument7_get_onerror,
4159     HTMLDocument7_put_onfocus,
4160     HTMLDocument7_get_onfocus,
4161     HTMLDocument7_put_oninput,
4162     HTMLDocument7_get_oninput,
4163     HTMLDocument7_put_onload,
4164     HTMLDocument7_get_onload,
4165     HTMLDocument7_put_onloadeddata,
4166     HTMLDocument7_get_onloadeddata,
4167     HTMLDocument7_put_onloadedmetadata,
4168     HTMLDocument7_get_onloadedmetadata,
4169     HTMLDocument7_put_onloadstart,
4170     HTMLDocument7_get_onloadstart,
4171     HTMLDocument7_put_onpause,
4172     HTMLDocument7_get_onpause,
4173     HTMLDocument7_put_onplay,
4174     HTMLDocument7_get_onplay,
4175     HTMLDocument7_put_onplaying,
4176     HTMLDocument7_get_onplaying,
4177     HTMLDocument7_put_onprogress,
4178     HTMLDocument7_get_onprogress,
4179     HTMLDocument7_put_onratechange,
4180     HTMLDocument7_get_onratechange,
4181     HTMLDocument7_put_onreset,
4182     HTMLDocument7_get_onreset,
4183     HTMLDocument7_put_onscroll,
4184     HTMLDocument7_get_onscroll,
4185     HTMLDocument7_put_onseekend,
4186     HTMLDocument7_get_onseekend,
4187     HTMLDocument7_put_onseeking,
4188     HTMLDocument7_get_onseeking,
4189     HTMLDocument7_put_onselect,
4190     HTMLDocument7_get_onselect,
4191     HTMLDocument7_put_onstalled,
4192     HTMLDocument7_get_onstalled,
4193     HTMLDocument7_put_onsubmit,
4194     HTMLDocument7_get_onsubmit,
4195     HTMLDocument7_put_onsuspend,
4196     HTMLDocument7_get_onsuspend,
4197     HTMLDocument7_put_ontimeupdate,
4198     HTMLDocument7_get_ontimeupdate,
4199     HTMLDocument7_put_onvolumechange,
4200     HTMLDocument7_get_onvolumechange,
4201     HTMLDocument7_put_onwaiting,
4202     HTMLDocument7_get_onwaiting,
4203     HTMLDocument7_normalize,
4204     HTMLDocument7_importNode,
4205     HTMLDocument7_get_parentWindow,
4206     HTMLDocument7_put_body,
4207     HTMLDocument7_get_body,
4208     HTMLDocument7_get_head
4209 };
4210
4211 static inline HTMLDocument *impl_from_IDocumentSelector(IDocumentSelector *iface)
4212 {
4213     return CONTAINING_RECORD(iface, HTMLDocument, IDocumentSelector_iface);
4214 }
4215
4216 static HRESULT WINAPI DocumentSelector_QueryInterface(IDocumentSelector *iface, REFIID riid, void **ppv)
4217 {
4218     HTMLDocument *This = impl_from_IDocumentSelector(iface);
4219     return htmldoc_query_interface(This, riid, ppv);
4220 }
4221
4222 static ULONG WINAPI DocumentSelector_AddRef(IDocumentSelector *iface)
4223 {
4224     HTMLDocument *This = impl_from_IDocumentSelector(iface);
4225     return htmldoc_addref(This);
4226 }
4227
4228 static ULONG WINAPI DocumentSelector_Release(IDocumentSelector *iface)
4229 {
4230     HTMLDocument *This = impl_from_IDocumentSelector(iface);
4231     return htmldoc_release(This);
4232 }
4233
4234 static HRESULT WINAPI DocumentSelector_GetTypeInfoCount(IDocumentSelector *iface, UINT *pctinfo)
4235 {
4236     HTMLDocument *This = impl_from_IDocumentSelector(iface);
4237     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
4238 }
4239
4240 static HRESULT WINAPI DocumentSelector_GetTypeInfo(IDocumentSelector *iface, UINT iTInfo,
4241         LCID lcid, ITypeInfo **ppTInfo)
4242 {
4243     HTMLDocument *This = impl_from_IDocumentSelector(iface);
4244     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4245 }
4246
4247 static HRESULT WINAPI DocumentSelector_GetIDsOfNames(IDocumentSelector *iface, REFIID riid,
4248         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4249 {
4250     HTMLDocument *This = impl_from_IDocumentSelector(iface);
4251     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
4252             rgDispId);
4253 }
4254
4255 static HRESULT WINAPI DocumentSelector_Invoke(IDocumentSelector *iface, DISPID dispIdMember, REFIID riid,
4256         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4257 {
4258     HTMLDocument *This = impl_from_IDocumentSelector(iface);
4259     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
4260             pDispParams, pVarResult, pExcepInfo, puArgErr);
4261 }
4262
4263 static HRESULT WINAPI DocumentSelector_querySelector(IDocumentSelector *iface, BSTR v, IHTMLElement **pel)
4264 {
4265     HTMLDocument *This = impl_from_IDocumentSelector(iface);
4266     nsIDOMElement *nselem;
4267     HTMLElement *elem;
4268     nsAString nsstr;
4269     nsresult nsres;
4270     HRESULT hres;
4271
4272     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
4273
4274     nsAString_InitDepend(&nsstr, v);
4275     nsres = nsIDOMHTMLDocument_QuerySelector(This->doc_node->nsdoc, &nsstr, &nselem);
4276     nsAString_Finish(&nsstr);
4277     if(NS_FAILED(nsres)) {
4278         ERR("QuerySelector failed: %08x\n", nsres);
4279         return E_FAIL;
4280     }
4281
4282     if(!nselem) {
4283         *pel = NULL;
4284         return S_OK;
4285     }
4286
4287     hres = get_element(nselem, &elem);
4288     nsIDOMElement_Release(nselem);
4289     if(FAILED(hres))
4290         return hres;
4291
4292     *pel = &elem->IHTMLElement_iface;
4293     return S_OK;
4294 }
4295
4296 static HRESULT WINAPI DocumentSelector_querySelectorAll(IDocumentSelector *iface, BSTR v, IHTMLDOMChildrenCollection **pel)
4297 {
4298     HTMLDocument *This = impl_from_IDocumentSelector(iface);
4299     nsIDOMNodeList *node_list;
4300     nsAString nsstr;
4301     nsresult nsres;
4302
4303     TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
4304
4305     nsAString_InitDepend(&nsstr, v);
4306     nsres = nsIDOMHTMLDocument_QuerySelectorAll(This->doc_node->nsdoc, &nsstr, &node_list);
4307     nsAString_Finish(&nsstr);
4308     if(NS_FAILED(nsres)) {
4309         ERR("QuerySelectorAll failed: %08x\n", nsres);
4310         return E_FAIL;
4311     }
4312
4313     *pel = create_child_collection(node_list);
4314     nsIDOMNodeList_Release(node_list);
4315     return *pel ? S_OK : E_OUTOFMEMORY;
4316 }
4317
4318 static const IDocumentSelectorVtbl DocumentSelectorVtbl = {
4319     DocumentSelector_QueryInterface,
4320     DocumentSelector_AddRef,
4321     DocumentSelector_Release,
4322     DocumentSelector_GetTypeInfoCount,
4323     DocumentSelector_GetTypeInfo,
4324     DocumentSelector_GetIDsOfNames,
4325     DocumentSelector_Invoke,
4326     DocumentSelector_querySelector,
4327     DocumentSelector_querySelectorAll
4328 };
4329
4330 static inline HTMLDocument *impl_from_IDocumentEvent(IDocumentEvent *iface)
4331 {
4332     return CONTAINING_RECORD(iface, HTMLDocument, IDocumentEvent_iface);
4333 }
4334
4335 static HRESULT WINAPI DocumentEvent_QueryInterface(IDocumentEvent *iface, REFIID riid, void **ppv)
4336 {
4337     HTMLDocument *This = impl_from_IDocumentEvent(iface);
4338     return htmldoc_query_interface(This, riid, ppv);
4339 }
4340
4341 static ULONG WINAPI DocumentEvent_AddRef(IDocumentEvent *iface)
4342 {
4343     HTMLDocument *This = impl_from_IDocumentEvent(iface);
4344     return htmldoc_addref(This);
4345 }
4346
4347 static ULONG WINAPI DocumentEvent_Release(IDocumentEvent *iface)
4348 {
4349     HTMLDocument *This = impl_from_IDocumentEvent(iface);
4350     return htmldoc_release(This);
4351 }
4352
4353 static HRESULT WINAPI DocumentEvent_GetTypeInfoCount(IDocumentEvent *iface, UINT *pctinfo)
4354 {
4355     HTMLDocument *This = impl_from_IDocumentEvent(iface);
4356     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
4357 }
4358
4359 static HRESULT WINAPI DocumentEvent_GetTypeInfo(IDocumentEvent *iface, UINT iTInfo,
4360         LCID lcid, ITypeInfo **ppTInfo)
4361 {
4362     HTMLDocument *This = impl_from_IDocumentEvent(iface);
4363     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4364 }
4365
4366 static HRESULT WINAPI DocumentEvent_GetIDsOfNames(IDocumentEvent *iface, REFIID riid,
4367         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4368 {
4369     HTMLDocument *This = impl_from_IDocumentEvent(iface);
4370     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
4371             rgDispId);
4372 }
4373
4374 static HRESULT WINAPI DocumentEvent_Invoke(IDocumentEvent *iface, DISPID dispIdMember, REFIID riid,
4375         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4376 {
4377     HTMLDocument *This = impl_from_IDocumentEvent(iface);
4378     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
4379             pDispParams, pVarResult, pExcepInfo, puArgErr);
4380 }
4381
4382 static HRESULT WINAPI DocumentEvent_createEvent(IDocumentEvent *iface, BSTR eventType, IDOMEvent **p)
4383 {
4384     HTMLDocument *This = impl_from_IDocumentEvent(iface);
4385
4386     TRACE("(%p)->(%s %p)\n", This, debugstr_w(eventType), p);
4387
4388     return create_document_event_str(This->doc_node, eventType, p);
4389 }
4390
4391 static const IDocumentEventVtbl DocumentEventVtbl = {
4392     DocumentEvent_QueryInterface,
4393     DocumentEvent_AddRef,
4394     DocumentEvent_Release,
4395     DocumentEvent_GetTypeInfoCount,
4396     DocumentEvent_GetTypeInfo,
4397     DocumentEvent_GetIDsOfNames,
4398     DocumentEvent_Invoke,
4399     DocumentEvent_createEvent
4400 };
4401
4402 static void HTMLDocument_on_advise(IUnknown *iface, cp_static_data_t *cp)
4403 {
4404     HTMLDocument *This = impl_from_IHTMLDocument2((IHTMLDocument2*)iface);
4405
4406     if(This->window)
4407         update_doc_cp_events(This->doc_node, cp);
4408 }
4409
4410 static inline HTMLDocument *impl_from_ISupportErrorInfo(ISupportErrorInfo *iface)
4411 {
4412     return CONTAINING_RECORD(iface, HTMLDocument, ISupportErrorInfo_iface);
4413 }
4414
4415 static HRESULT WINAPI SupportErrorInfo_QueryInterface(ISupportErrorInfo *iface, REFIID riid, void **ppv)
4416 {
4417     HTMLDocument *This = impl_from_ISupportErrorInfo(iface);
4418     return htmldoc_query_interface(This, riid, ppv);
4419 }
4420
4421 static ULONG WINAPI SupportErrorInfo_AddRef(ISupportErrorInfo *iface)
4422 {
4423     HTMLDocument *This = impl_from_ISupportErrorInfo(iface);
4424     return htmldoc_addref(This);
4425 }
4426
4427 static ULONG WINAPI SupportErrorInfo_Release(ISupportErrorInfo *iface)
4428 {
4429     HTMLDocument *This = impl_from_ISupportErrorInfo(iface);
4430     return htmldoc_release(This);
4431 }
4432
4433 static HRESULT WINAPI SupportErrorInfo_InterfaceSupportsErrorInfo(ISupportErrorInfo *iface, REFIID riid)
4434 {
4435     FIXME("(%p)->(%s)\n", iface, debugstr_mshtml_guid(riid));
4436     return S_FALSE;
4437 }
4438
4439 static const ISupportErrorInfoVtbl SupportErrorInfoVtbl = {
4440     SupportErrorInfo_QueryInterface,
4441     SupportErrorInfo_AddRef,
4442     SupportErrorInfo_Release,
4443     SupportErrorInfo_InterfaceSupportsErrorInfo
4444 };
4445
4446 static inline HTMLDocument *impl_from_IDispatchEx(IDispatchEx *iface)
4447 {
4448     return CONTAINING_RECORD(iface, HTMLDocument, IDispatchEx_iface);
4449 }
4450
4451 static HRESULT dispid_from_elem_name(HTMLDocumentNode *This, BSTR name, DISPID *dispid)
4452 {
4453     nsIDOMNodeList *node_list;
4454     nsAString name_str;
4455     UINT32 len;
4456     unsigned i;
4457     nsresult nsres;
4458
4459     if(!This->nsdoc)
4460         return DISP_E_UNKNOWNNAME;
4461
4462     nsAString_InitDepend(&name_str, name);
4463     nsres = nsIDOMHTMLDocument_GetElementsByName(This->nsdoc, &name_str, &node_list);
4464     nsAString_Finish(&name_str);
4465     if(NS_FAILED(nsres))
4466         return E_FAIL;
4467
4468     nsres = nsIDOMNodeList_GetLength(node_list, &len);
4469     nsIDOMNodeList_Release(node_list);
4470     if(NS_FAILED(nsres))
4471         return E_FAIL;
4472
4473     if(!len)
4474         return DISP_E_UNKNOWNNAME;
4475
4476     for(i=0; i < This->elem_vars_cnt; i++) {
4477         if(!strcmpW(name, This->elem_vars[i])) {
4478             *dispid = MSHTML_DISPID_CUSTOM_MIN+i;
4479             return S_OK;
4480         }
4481     }
4482
4483     if(This->elem_vars_cnt == This->elem_vars_size) {
4484         WCHAR **new_vars;
4485
4486         if(This->elem_vars_size) {
4487             new_vars = heap_realloc(This->elem_vars, This->elem_vars_size*2*sizeof(WCHAR*));
4488             if(!new_vars)
4489                 return E_OUTOFMEMORY;
4490             This->elem_vars_size *= 2;
4491         }else {
4492             new_vars = heap_alloc(16*sizeof(WCHAR*));
4493             if(!new_vars)
4494                 return E_OUTOFMEMORY;
4495             This->elem_vars_size = 16;
4496         }
4497
4498         This->elem_vars = new_vars;
4499     }
4500
4501     This->elem_vars[This->elem_vars_cnt] = heap_strdupW(name);
4502     if(!This->elem_vars[This->elem_vars_cnt])
4503         return E_OUTOFMEMORY;
4504
4505     *dispid = MSHTML_DISPID_CUSTOM_MIN+This->elem_vars_cnt++;
4506     return S_OK;
4507 }
4508
4509 static HRESULT WINAPI DocDispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
4510 {
4511     HTMLDocument *This = impl_from_IDispatchEx(iface);
4512
4513     return htmldoc_query_interface(This, riid, ppv);
4514 }
4515
4516 static ULONG WINAPI DocDispatchEx_AddRef(IDispatchEx *iface)
4517 {
4518     HTMLDocument *This = impl_from_IDispatchEx(iface);
4519
4520     return htmldoc_addref(This);
4521 }
4522
4523 static ULONG WINAPI DocDispatchEx_Release(IDispatchEx *iface)
4524 {
4525     HTMLDocument *This = impl_from_IDispatchEx(iface);
4526
4527     return htmldoc_release(This);
4528 }
4529
4530 static HRESULT WINAPI DocDispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
4531 {
4532     HTMLDocument *This = impl_from_IDispatchEx(iface);
4533
4534     return IDispatchEx_GetTypeInfoCount(This->dispex, pctinfo);
4535 }
4536
4537 static HRESULT WINAPI DocDispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
4538                                                LCID lcid, ITypeInfo **ppTInfo)
4539 {
4540     HTMLDocument *This = impl_from_IDispatchEx(iface);
4541
4542     return IDispatchEx_GetTypeInfo(This->dispex, iTInfo, lcid, ppTInfo);
4543 }
4544
4545 static HRESULT WINAPI DocDispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
4546                                                  LPOLESTR *rgszNames, UINT cNames,
4547                                                  LCID lcid, DISPID *rgDispId)
4548 {
4549     HTMLDocument *This = impl_from_IDispatchEx(iface);
4550
4551     return IDispatchEx_GetIDsOfNames(This->dispex, riid, rgszNames, cNames, lcid, rgDispId);
4552 }
4553
4554 static HRESULT WINAPI DocDispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
4555                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
4556                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4557 {
4558     HTMLDocument *This = impl_from_IDispatchEx(iface);
4559
4560     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
4561           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4562
4563     switch(dispIdMember) {
4564     case DISPID_READYSTATE:
4565         TRACE("DISPID_READYSTATE\n");
4566
4567         if(!(wFlags & DISPATCH_PROPERTYGET))
4568             return E_INVALIDARG;
4569
4570         V_VT(pVarResult) = VT_I4;
4571         V_I4(pVarResult) = This->window->readystate;
4572         return S_OK;
4573     }
4574
4575     return IDispatchEx_Invoke(This->dispex, dispIdMember, riid, lcid, wFlags, pDispParams,
4576                               pVarResult, pExcepInfo, puArgErr);
4577 }
4578
4579 static HRESULT WINAPI DocDispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
4580 {
4581     HTMLDocument *This = impl_from_IDispatchEx(iface);
4582     HRESULT hres;
4583
4584     hres = IDispatchEx_GetDispID(This->dispex, bstrName, grfdex, pid);
4585     if(hres != DISP_E_UNKNOWNNAME)
4586         return hres;
4587
4588     return  dispid_from_elem_name(This->doc_node, bstrName, pid);
4589 }
4590
4591 static HRESULT WINAPI DocDispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
4592         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
4593 {
4594     HTMLDocument *This = impl_from_IDispatchEx(iface);
4595
4596     if(This->window && id == DISPID_IHTMLDOCUMENT2_LOCATION && (wFlags & DISPATCH_PROPERTYPUT))
4597         return IDispatchEx_InvokeEx(&This->window->base.IDispatchEx_iface, DISPID_IHTMLWINDOW2_LOCATION,
4598                 lcid, wFlags, pdp, pvarRes, pei, pspCaller);
4599
4600
4601     return IDispatchEx_InvokeEx(This->dispex, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
4602 }
4603
4604 static HRESULT WINAPI DocDispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
4605 {
4606     HTMLDocument *This = impl_from_IDispatchEx(iface);
4607
4608     return IDispatchEx_DeleteMemberByName(This->dispex, bstrName, grfdex);
4609 }
4610
4611 static HRESULT WINAPI DocDispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
4612 {
4613     HTMLDocument *This = impl_from_IDispatchEx(iface);
4614
4615     return IDispatchEx_DeleteMemberByDispID(This->dispex, id);
4616 }
4617
4618 static HRESULT WINAPI DocDispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
4619 {
4620     HTMLDocument *This = impl_from_IDispatchEx(iface);
4621
4622     return IDispatchEx_GetMemberProperties(This->dispex, id, grfdexFetch, pgrfdex);
4623 }
4624
4625 static HRESULT WINAPI DocDispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
4626 {
4627     HTMLDocument *This = impl_from_IDispatchEx(iface);
4628
4629     return IDispatchEx_GetMemberName(This->dispex, id, pbstrName);
4630 }
4631
4632 static HRESULT WINAPI DocDispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
4633 {
4634     HTMLDocument *This = impl_from_IDispatchEx(iface);
4635
4636     return IDispatchEx_GetNextDispID(This->dispex, grfdex, id, pid);
4637 }
4638
4639 static HRESULT WINAPI DocDispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
4640 {
4641     HTMLDocument *This = impl_from_IDispatchEx(iface);
4642
4643     return IDispatchEx_GetNameSpaceParent(This->dispex, ppunk);
4644 }
4645
4646 static const IDispatchExVtbl DocDispatchExVtbl = {
4647     DocDispatchEx_QueryInterface,
4648     DocDispatchEx_AddRef,
4649     DocDispatchEx_Release,
4650     DocDispatchEx_GetTypeInfoCount,
4651     DocDispatchEx_GetTypeInfo,
4652     DocDispatchEx_GetIDsOfNames,
4653     DocDispatchEx_Invoke,
4654     DocDispatchEx_GetDispID,
4655     DocDispatchEx_InvokeEx,
4656     DocDispatchEx_DeleteMemberByName,
4657     DocDispatchEx_DeleteMemberByDispID,
4658     DocDispatchEx_GetMemberProperties,
4659     DocDispatchEx_GetMemberName,
4660     DocDispatchEx_GetNextDispID,
4661     DocDispatchEx_GetNameSpaceParent
4662 };
4663
4664 static inline HTMLDocument *impl_from_IProvideMultipleClassInfo(IProvideMultipleClassInfo *iface)
4665 {
4666     return CONTAINING_RECORD(iface, HTMLDocument, IProvideMultipleClassInfo_iface);
4667 }
4668
4669 static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideMultipleClassInfo *iface,
4670         REFIID riid, void **ppv)
4671 {
4672     HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4673     return htmldoc_query_interface(This, riid, ppv);
4674 }
4675
4676 static ULONG WINAPI ProvideClassInfo_AddRef(IProvideMultipleClassInfo *iface)
4677 {
4678     HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4679     return htmldoc_addref(This);
4680 }
4681
4682 static ULONG WINAPI ProvideClassInfo_Release(IProvideMultipleClassInfo *iface)
4683 {
4684     HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4685     return htmldoc_release(This);
4686 }
4687
4688 static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideMultipleClassInfo *iface, ITypeInfo **ppTI)
4689 {
4690     HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4691     TRACE("(%p)->(%p)\n", This, ppTI);
4692     return get_class_typeinfo(&CLSID_HTMLDocument, ppTI);
4693 }
4694
4695 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideMultipleClassInfo *iface, DWORD dwGuidKind, GUID *pGUID)
4696 {
4697     HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4698     FIXME("(%p)->(%u %p)\n", This, dwGuidKind, pGUID);
4699     return E_NOTIMPL;
4700 }
4701
4702 static HRESULT WINAPI ProvideMultipleClassInfo_GetMultiTypeInfoCount(IProvideMultipleClassInfo *iface, ULONG *pcti)
4703 {
4704     HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4705     FIXME("(%p)->(%p)\n", This, pcti);
4706     *pcti = 1;
4707     return S_OK;
4708 }
4709
4710 static HRESULT WINAPI ProvideMultipleClassInfo_GetInfoOfIndex(IProvideMultipleClassInfo *iface, ULONG iti,
4711         DWORD dwFlags, ITypeInfo **pptiCoClass, DWORD *pdwTIFlags, ULONG *pcdispidReserved, IID *piidPrimary, IID *piidSource)
4712 {
4713     HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4714     FIXME("(%p)->(%u %x %p %p %p %p %p)\n", This, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource);
4715     return E_NOTIMPL;
4716 }
4717
4718 static const IProvideMultipleClassInfoVtbl ProvideMultipleClassInfoVtbl = {
4719     ProvideClassInfo_QueryInterface,
4720     ProvideClassInfo_AddRef,
4721     ProvideClassInfo_Release,
4722     ProvideClassInfo_GetClassInfo,
4723     ProvideClassInfo2_GetGUID,
4724     ProvideMultipleClassInfo_GetMultiTypeInfoCount,
4725     ProvideMultipleClassInfo_GetInfoOfIndex
4726 };
4727
4728 static BOOL htmldoc_qi(HTMLDocument *This, REFIID riid, void **ppv)
4729 {
4730     *ppv = NULL;
4731
4732     if(IsEqualGUID(&IID_IUnknown, riid))
4733         *ppv = &This->IHTMLDocument2_iface;
4734     else if(IsEqualGUID(&IID_IDispatch, riid))
4735         *ppv = &This->IDispatchEx_iface;
4736     else if(IsEqualGUID(&IID_IDispatchEx, riid))
4737         *ppv = &This->IDispatchEx_iface;
4738     else if(IsEqualGUID(&IID_IHTMLDocument, riid))
4739         *ppv = &This->IHTMLDocument2_iface;
4740     else if(IsEqualGUID(&IID_IHTMLDocument2, riid))
4741         *ppv = &This->IHTMLDocument2_iface;
4742     else if(IsEqualGUID(&IID_IHTMLDocument3, riid))
4743         *ppv = &This->IHTMLDocument3_iface;
4744     else if(IsEqualGUID(&IID_IHTMLDocument4, riid))
4745         *ppv = &This->IHTMLDocument4_iface;
4746     else if(IsEqualGUID(&IID_IHTMLDocument5, riid))
4747         *ppv = &This->IHTMLDocument5_iface;
4748     else if(IsEqualGUID(&IID_IHTMLDocument6, riid))
4749         *ppv = &This->IHTMLDocument6_iface;
4750     else if(IsEqualGUID(&IID_IHTMLDocument7, riid))
4751         *ppv = &This->IHTMLDocument7_iface;
4752     else if(IsEqualGUID(&IID_IDocumentSelector, riid))
4753         *ppv = &This->IDocumentSelector_iface;
4754     else if(IsEqualGUID(&IID_IDocumentEvent, riid))
4755         *ppv = &This->IDocumentEvent_iface;
4756     else if(IsEqualGUID(&IID_IPersist, riid))
4757         *ppv = &This->IPersistFile_iface;
4758     else if(IsEqualGUID(&IID_IPersistMoniker, riid))
4759         *ppv = &This->IPersistMoniker_iface;
4760     else if(IsEqualGUID(&IID_IPersistFile, riid))
4761         *ppv = &This->IPersistFile_iface;
4762     else if(IsEqualGUID(&IID_IMonikerProp, riid))
4763         *ppv = &This->IMonikerProp_iface;
4764     else if(IsEqualGUID(&IID_IOleObject, riid))
4765         *ppv = &This->IOleObject_iface;
4766     else if(IsEqualGUID(&IID_IOleDocument, riid))
4767         *ppv = &This->IOleDocument_iface;
4768     else if(IsEqualGUID(&IID_IOleInPlaceActiveObject, riid))
4769         *ppv = &This->IOleInPlaceActiveObject_iface;
4770     else if(IsEqualGUID(&IID_IOleWindow, riid))
4771         *ppv = &This->IOleInPlaceActiveObject_iface;
4772     else if(IsEqualGUID(&IID_IOleInPlaceObject, riid))
4773         *ppv = &This->IOleInPlaceObjectWindowless_iface;
4774     else if(IsEqualGUID(&IID_IOleInPlaceObjectWindowless, riid))
4775         *ppv = &This->IOleInPlaceObjectWindowless_iface;
4776     else if(IsEqualGUID(&IID_IServiceProvider, riid))
4777         *ppv = &This->IServiceProvider_iface;
4778     else if(IsEqualGUID(&IID_IOleCommandTarget, riid))
4779         *ppv = &This->IOleCommandTarget_iface;
4780     else if(IsEqualGUID(&IID_IOleControl, riid))
4781         *ppv = &This->IOleControl_iface;
4782     else if(IsEqualGUID(&IID_IHlinkTarget, riid))
4783         *ppv = &This->IHlinkTarget_iface;
4784     else if(IsEqualGUID(&IID_IConnectionPointContainer, riid))
4785         *ppv = &This->cp_container.IConnectionPointContainer_iface;
4786     else if(IsEqualGUID(&IID_IPersistStreamInit, riid))
4787         *ppv = &This->IPersistStreamInit_iface;
4788     else if(IsEqualGUID(&DIID_DispHTMLDocument, riid))
4789         *ppv = &This->IHTMLDocument2_iface;
4790     else if(IsEqualGUID(&IID_ISupportErrorInfo, riid))
4791         *ppv = &This->ISupportErrorInfo_iface;
4792     else if(IsEqualGUID(&IID_IPersistHistory, riid))
4793         *ppv = &This->IPersistHistory_iface;
4794     else if(IsEqualGUID(&IID_IObjectWithSite, riid))
4795         *ppv = &This->IObjectWithSite_iface;
4796     else if(IsEqualGUID(&IID_IOleContainer, riid))
4797         *ppv = &This->IOleContainer_iface;
4798     else if(IsEqualGUID(&IID_IObjectSafety, riid))
4799         *ppv = &This->IObjectSafety_iface;
4800     else if(IsEqualGUID(&IID_IProvideClassInfo, riid))
4801         *ppv = &This->IProvideMultipleClassInfo_iface;
4802     else if(IsEqualGUID(&IID_IProvideClassInfo2, riid))
4803         *ppv = &This->IProvideMultipleClassInfo_iface;
4804     else if(IsEqualGUID(&IID_IProvideMultipleClassInfo, riid))
4805         *ppv = &This->IProvideMultipleClassInfo_iface;
4806     else if(IsEqualGUID(&CLSID_CMarkup, riid)) {
4807         FIXME("(%p)->(CLSID_CMarkup %p)\n", This, ppv);
4808         *ppv = NULL;
4809     }else if(IsEqualGUID(&IID_IRunnableObject, riid)) {
4810         TRACE("(%p)->(IID_IRunnableObject %p) returning NULL\n", This, ppv);
4811         *ppv = NULL;
4812     }else if(IsEqualGUID(&IID_IPersistPropertyBag, riid)) {
4813         TRACE("(%p)->(IID_IPersistPropertyBag %p) returning NULL\n", This, ppv);
4814         *ppv = NULL;
4815     }else if(IsEqualGUID(&IID_IExternalConnection, riid)) {
4816         TRACE("(%p)->(IID_IExternalConnection %p) returning NULL\n", This, ppv);
4817         *ppv = NULL;
4818     }else if(IsEqualGUID(&IID_IStdMarshalInfo, riid)) {
4819         TRACE("(%p)->(IID_IStdMarshalInfo %p) returning NULL\n", This, ppv);
4820         *ppv = NULL;
4821     }else {
4822         return FALSE;
4823     }
4824
4825     if(*ppv)
4826         IUnknown_AddRef((IUnknown*)*ppv);
4827     return TRUE;
4828 }
4829
4830 static cp_static_data_t HTMLDocumentEvents_data = { HTMLDocumentEvents_tid, HTMLDocument_on_advise };
4831
4832 static const cpc_entry_t HTMLDocument_cpc[] = {
4833     {&IID_IDispatch, &HTMLDocumentEvents_data},
4834     {&IID_IPropertyNotifySink},
4835     {&DIID_HTMLDocumentEvents, &HTMLDocumentEvents_data},
4836     {&DIID_HTMLDocumentEvents2},
4837     {NULL}
4838 };
4839
4840 static void init_doc(HTMLDocument *doc, IUnknown *outer, IDispatchEx *dispex)
4841 {
4842     doc->IHTMLDocument2_iface.lpVtbl = &HTMLDocumentVtbl;
4843     doc->IHTMLDocument3_iface.lpVtbl = &HTMLDocument3Vtbl;
4844     doc->IHTMLDocument4_iface.lpVtbl = &HTMLDocument4Vtbl;
4845     doc->IHTMLDocument5_iface.lpVtbl = &HTMLDocument5Vtbl;
4846     doc->IHTMLDocument6_iface.lpVtbl = &HTMLDocument6Vtbl;
4847     doc->IHTMLDocument7_iface.lpVtbl = &HTMLDocument7Vtbl;
4848     doc->IDispatchEx_iface.lpVtbl = &DocDispatchExVtbl;
4849     doc->IDocumentSelector_iface.lpVtbl = &DocumentSelectorVtbl;
4850     doc->IDocumentEvent_iface.lpVtbl = &DocumentEventVtbl;
4851     doc->ISupportErrorInfo_iface.lpVtbl = &SupportErrorInfoVtbl;
4852     doc->IProvideMultipleClassInfo_iface.lpVtbl = &ProvideMultipleClassInfoVtbl;
4853
4854     doc->outer_unk = outer;
4855     doc->dispex = dispex;
4856
4857     HTMLDocument_Persist_Init(doc);
4858     HTMLDocument_OleCmd_Init(doc);
4859     HTMLDocument_OleObj_Init(doc);
4860     HTMLDocument_Service_Init(doc);
4861
4862     ConnectionPointContainer_Init(&doc->cp_container, (IUnknown*)&doc->IHTMLDocument2_iface, HTMLDocument_cpc);
4863 }
4864
4865 static inline HTMLDocumentNode *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
4866 {
4867     return CONTAINING_RECORD(iface, HTMLDocumentNode, node);
4868 }
4869
4870 static HRESULT HTMLDocumentNode_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
4871 {
4872     HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
4873
4874     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
4875
4876     if(htmldoc_qi(&This->basedoc, riid, ppv))
4877         return *ppv ? S_OK : E_NOINTERFACE;
4878
4879     if(IsEqualGUID(&IID_IInternetHostSecurityManager, riid))
4880         *ppv = &This->IInternetHostSecurityManager_iface;
4881     else
4882         return HTMLDOMNode_QI(&This->node, riid, ppv);
4883
4884     IUnknown_AddRef((IUnknown*)*ppv);
4885     return S_OK;
4886 }
4887
4888 static void HTMLDocumentNode_destructor(HTMLDOMNode *iface)
4889 {
4890     HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
4891     unsigned i;
4892
4893     for(i=0; i < This->elem_vars_cnt; i++)
4894         heap_free(This->elem_vars[i]);
4895     heap_free(This->elem_vars);
4896
4897     detach_events(This);
4898     if(This->catmgr)
4899         ICatInformation_Release(This->catmgr);
4900
4901     detach_selection(This);
4902     detach_ranges(This);
4903
4904     while(!list_empty(&This->plugin_hosts))
4905         detach_plugin_host(LIST_ENTRY(list_head(&This->plugin_hosts), PluginHost, entry));
4906
4907     if(!This->nsdoc && This->window) {
4908         /* document fragments own reference to inner window */
4909         IHTMLWindow2_Release(&This->window->base.IHTMLWindow2_iface);
4910         This->window = NULL;
4911     }
4912
4913     heap_free(This->event_vector);
4914     ConnectionPointContainer_Destroy(&This->basedoc.cp_container);
4915 }
4916
4917 static HRESULT HTMLDocumentNode_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
4918 {
4919     HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
4920     FIXME("%p\n", This);
4921     return E_NOTIMPL;
4922 }
4923
4924 static void HTMLDocumentNode_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
4925 {
4926     HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
4927
4928     if(This->nsdoc)
4929         note_cc_edge((nsISupports*)This->nsdoc, "This->nsdoc", cb);
4930 }
4931
4932 static void HTMLDocumentNode_unlink(HTMLDOMNode *iface)
4933 {
4934     HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
4935
4936     if(This->nsdoc) {
4937         nsIDOMHTMLDocument *nsdoc = This->nsdoc;
4938
4939         release_document_mutation(This);
4940         This->nsdoc = NULL;
4941         nsIDOMHTMLDocument_Release(nsdoc);
4942         This->window = NULL;
4943     }
4944 }
4945
4946 static const NodeImplVtbl HTMLDocumentNodeImplVtbl = {
4947     &CLSID_HTMLDocument,
4948     HTMLDocumentNode_QI,
4949     HTMLDocumentNode_destructor,
4950     HTMLDocument_cpc,
4951     HTMLDocumentNode_clone,
4952     NULL,
4953     NULL,
4954     NULL,
4955     NULL,
4956     NULL,
4957     NULL,
4958     NULL,
4959     NULL,
4960     NULL,
4961     NULL,
4962     HTMLDocumentNode_traverse,
4963     HTMLDocumentNode_unlink
4964 };
4965
4966 static HRESULT HTMLDocumentFragment_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
4967 {
4968     HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
4969     HTMLDocumentNode *new_node;
4970     HRESULT hres;
4971
4972     hres = create_document_fragment(nsnode, This->node.doc, &new_node);
4973     if(FAILED(hres))
4974         return hres;
4975
4976     *ret = &new_node->node;
4977     return S_OK;
4978 }
4979
4980 static inline HTMLDocumentNode *impl_from_DispatchEx(DispatchEx *iface)
4981 {
4982     return CONTAINING_RECORD(iface, HTMLDocumentNode, node.event_target.dispex);
4983 }
4984
4985 static HRESULT HTMLDocumentNode_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
4986         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
4987 {
4988     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
4989     nsIDOMNodeList *node_list;
4990     nsAString name_str;
4991     nsIDOMNode *nsnode;
4992     HTMLDOMNode *node;
4993     unsigned i;
4994     nsresult nsres;
4995     HRESULT hres;
4996
4997     if(flags != DISPATCH_PROPERTYGET && flags != (DISPATCH_METHOD|DISPATCH_PROPERTYGET)) {
4998         FIXME("unsupported flags %x\n", flags);
4999         return E_NOTIMPL;
5000     }
5001
5002     i = id - MSHTML_DISPID_CUSTOM_MIN;
5003
5004     if(!This->nsdoc || i >= This->elem_vars_cnt)
5005         return DISP_E_UNKNOWNNAME;
5006
5007     nsAString_InitDepend(&name_str, This->elem_vars[i]);
5008     nsres = nsIDOMHTMLDocument_GetElementsByName(This->nsdoc, &name_str, &node_list);
5009     nsAString_Finish(&name_str);
5010     if(NS_FAILED(nsres))
5011         return E_FAIL;
5012
5013     nsres = nsIDOMNodeList_Item(node_list, 0, &nsnode);
5014     nsIDOMNodeList_Release(node_list);
5015     if(NS_FAILED(nsres) || !nsnode)
5016         return DISP_E_UNKNOWNNAME;
5017
5018     hres = get_node(nsnode, TRUE, &node);
5019     if(FAILED(hres))
5020         return hres;
5021
5022     V_VT(res) = VT_DISPATCH;
5023     V_DISPATCH(res) = (IDispatch*)&node->IHTMLDOMNode_iface;
5024     return S_OK;
5025 }
5026
5027 static compat_mode_t HTMLDocumentNode_get_compat_mode(DispatchEx *dispex)
5028 {
5029     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5030
5031     TRACE("(%p) returning %u\n", This, This->document_mode);
5032
5033     return lock_document_mode(This);
5034 }
5035
5036 static nsISupports *HTMLDocumentNode_get_gecko_target(DispatchEx *dispex)
5037 {
5038     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5039     return (nsISupports*)This->node.nsnode;
5040 }
5041
5042 static void HTMLDocumentNode_bind_event(DispatchEx *dispex, eventid_t eid)
5043 {
5044     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5045     ensure_doc_nsevent_handler(This, This->node.nsnode, eid);
5046 }
5047
5048 static EventTarget *HTMLDocumentNode_get_parent_event_target(DispatchEx *dispex)
5049 {
5050     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5051     if(!This->window)
5052         return NULL;
5053     IHTMLWindow2_AddRef(&This->window->base.IHTMLWindow2_iface);
5054     return &This->window->event_target;
5055 }
5056
5057 static ConnectionPointContainer *HTMLDocumentNode_get_cp_container(DispatchEx *dispex)
5058 {
5059     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5060     ConnectionPointContainer *container = This->basedoc.doc_obj
5061         ? &This->basedoc.doc_obj->basedoc.cp_container : &This->basedoc.cp_container;
5062     IConnectionPointContainer_AddRef(&container->IConnectionPointContainer_iface);
5063     return container;
5064 }
5065
5066 static IHTMLEventObj *HTMLDocumentNode_set_current_event(DispatchEx *dispex, IHTMLEventObj *event)
5067 {
5068     HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5069     return default_set_current_event(This->window, event);
5070 }
5071
5072 static const event_target_vtbl_t HTMLDocumentNode_event_target_vtbl = {
5073     {
5074         NULL,
5075         NULL,
5076         HTMLDocumentNode_invoke,
5077         HTMLDocumentNode_get_compat_mode,
5078         NULL
5079     },
5080     HTMLDocumentNode_get_gecko_target,
5081     HTMLDocumentNode_bind_event,
5082     HTMLDocumentNode_get_parent_event_target,
5083     NULL,
5084     HTMLDocumentNode_get_cp_container,
5085     HTMLDocumentNode_set_current_event
5086 };
5087
5088 static const NodeImplVtbl HTMLDocumentFragmentImplVtbl = {
5089     &CLSID_HTMLDocument,
5090     HTMLDocumentNode_QI,
5091     HTMLDocumentNode_destructor,
5092     HTMLDocument_cpc,
5093     HTMLDocumentFragment_clone
5094 };
5095
5096 static const tid_t HTMLDocumentNode_iface_tids[] = {
5097     IHTMLDOMNode_tid,
5098     IHTMLDOMNode2_tid,
5099     IHTMLDocument2_tid,
5100     IHTMLDocument4_tid,
5101     IHTMLDocument5_tid,
5102     IDocumentSelector_tid,
5103     0
5104 };
5105
5106 static void HTMLDocumentNode_init_dispex_info(dispex_data_t *info, compat_mode_t mode)
5107 {
5108     HTMLDOMNode_init_dispex_info(info, mode);
5109
5110     if(mode >= COMPAT_MODE_IE9) {
5111         dispex_info_add_interface(info, IHTMLDocument7_tid, NULL);
5112         dispex_info_add_interface(info, IDocumentEvent_tid, NULL);
5113     }
5114
5115     /* Depending on compatibility version, we add interfaces in different order
5116      * so that the right getElementById implementation is used. */
5117     if(mode < COMPAT_MODE_IE8) {
5118         dispex_info_add_interface(info, IHTMLDocument3_tid, NULL);
5119         dispex_info_add_interface(info, IHTMLDocument6_tid, NULL);
5120     }else {
5121         dispex_info_add_interface(info, IHTMLDocument6_tid, NULL);
5122         dispex_info_add_interface(info, IHTMLDocument3_tid, NULL);
5123     }
5124 }
5125
5126 static dispex_static_data_t HTMLDocumentNode_dispex = {
5127     &HTMLDocumentNode_event_target_vtbl.dispex_vtbl,
5128     DispHTMLDocument_tid,
5129     HTMLDocumentNode_iface_tids,
5130     HTMLDocumentNode_init_dispex_info
5131 };
5132
5133 static HTMLDocumentNode *alloc_doc_node(HTMLDocumentObj *doc_obj, HTMLInnerWindow *window)
5134 {
5135     HTMLDocumentNode *doc;
5136
5137     doc = heap_alloc_zero(sizeof(HTMLDocumentNode));
5138     if(!doc)
5139         return NULL;
5140
5141     doc->ref = 1;
5142     doc->basedoc.doc_node = doc;
5143     doc->basedoc.doc_obj = doc_obj;
5144     doc->basedoc.window = window->base.outer_window;
5145     doc->window = window;
5146
5147     init_doc(&doc->basedoc, (IUnknown*)&doc->node.IHTMLDOMNode_iface,
5148             &doc->node.event_target.dispex.IDispatchEx_iface);
5149     HTMLDocumentNode_SecMgr_Init(doc);
5150
5151     list_init(&doc->selection_list);
5152     list_init(&doc->range_list);
5153     list_init(&doc->plugin_hosts);
5154
5155     return doc;
5156 }
5157
5158 HRESULT create_doc_from_nsdoc(nsIDOMHTMLDocument *nsdoc, HTMLDocumentObj *doc_obj, HTMLInnerWindow *window, HTMLDocumentNode **ret)
5159 {
5160     HTMLDocumentNode *doc;
5161
5162     doc = alloc_doc_node(doc_obj, window);
5163     if(!doc)
5164         return E_OUTOFMEMORY;
5165
5166     if(window->base.outer_window->parent) {
5167         compat_mode_t parent_mode = window->base.outer_window->parent->base.inner_window->doc->document_mode;
5168         TRACE("parent mode %u\n", parent_mode);
5169         if(parent_mode >= COMPAT_MODE_IE9) {
5170             doc->document_mode = parent_mode;
5171             lock_document_mode(doc);
5172         }
5173     }
5174
5175     if(!doc_obj->basedoc.window || window->base.outer_window == doc_obj->basedoc.window)
5176         doc->basedoc.cp_container.forward_container = &doc_obj->basedoc.cp_container;
5177
5178     HTMLDOMNode_Init(doc, &doc->node, (nsIDOMNode*)nsdoc, &HTMLDocumentNode_dispex);
5179
5180     nsIDOMHTMLDocument_AddRef(nsdoc);
5181     doc->nsdoc = nsdoc;
5182
5183     init_document_mutation(doc);
5184     doc_init_events(doc);
5185
5186     doc->node.vtbl = &HTMLDocumentNodeImplVtbl;
5187
5188     *ret = doc;
5189     return S_OK;
5190 }
5191
5192 static HRESULT create_document_fragment(nsIDOMNode *nsnode, HTMLDocumentNode *doc_node, HTMLDocumentNode **ret)
5193 {
5194     HTMLDocumentNode *doc_frag;
5195
5196     doc_frag = alloc_doc_node(doc_node->basedoc.doc_obj, doc_node->window);
5197     if(!doc_frag)
5198         return E_OUTOFMEMORY;
5199
5200     IHTMLWindow2_AddRef(&doc_frag->window->base.IHTMLWindow2_iface);
5201
5202     HTMLDOMNode_Init(doc_node, &doc_frag->node, nsnode, &HTMLDocumentNode_dispex);
5203     doc_frag->node.vtbl = &HTMLDocumentFragmentImplVtbl;
5204     doc_frag->document_mode = lock_document_mode(doc_node);
5205
5206     *ret = doc_frag;
5207     return S_OK;
5208 }
5209
5210 HRESULT get_document_node(nsIDOMDocument *dom_document, HTMLDocumentNode **ret)
5211 {
5212     HTMLDOMNode *node;
5213     HRESULT hres;
5214
5215     hres = get_node((nsIDOMNode*)dom_document, FALSE, &node);
5216     if(FAILED(hres))
5217         return hres;
5218
5219     if(!node) {
5220         ERR("document not initialized\n");
5221         return E_FAIL;
5222     }
5223
5224     assert(node->vtbl == &HTMLDocumentNodeImplVtbl);
5225     *ret = impl_from_HTMLDOMNode(node);
5226     return S_OK;
5227 }
5228
5229 static inline HTMLDocumentObj *impl_from_IUnknown(IUnknown *iface)
5230 {
5231     return CONTAINING_RECORD(iface, HTMLDocumentObj, IUnknown_outer);
5232 }
5233
5234 static HRESULT WINAPI HTMLDocumentObj_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
5235 {
5236     HTMLDocumentObj *This = impl_from_IUnknown(iface);
5237
5238     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
5239
5240     if(IsEqualGUID(&IID_IUnknown, riid)) {
5241         *ppv = &This->IUnknown_outer;
5242     }else if(htmldoc_qi(&This->basedoc, riid, ppv)) {
5243         return *ppv ? S_OK : E_NOINTERFACE;
5244     }else if(IsEqualGUID(&IID_ICustomDoc, riid)) {
5245         *ppv = &This->ICustomDoc_iface;
5246     }else if(IsEqualGUID(&IID_IOleDocumentView, riid)) {
5247         *ppv = &This->IOleDocumentView_iface;
5248     }else if(IsEqualGUID(&IID_IViewObject, riid)) {
5249         *ppv = &This->IViewObjectEx_iface;
5250     }else if(IsEqualGUID(&IID_IViewObject2, riid)) {
5251         *ppv = &This->IViewObjectEx_iface;
5252     }else if(IsEqualGUID(&IID_IViewObjectEx, riid)) {
5253         *ppv = &This->IViewObjectEx_iface;
5254     }else if(IsEqualGUID(&IID_ITargetContainer, riid)) {
5255         *ppv = &This->ITargetContainer_iface;
5256     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
5257         return *ppv ? S_OK : E_NOINTERFACE;
5258     }else {
5259         FIXME("Unimplemented interface %s\n", debugstr_mshtml_guid(riid));
5260         *ppv = NULL;
5261         return E_NOINTERFACE;
5262     }
5263
5264     IUnknown_AddRef((IUnknown*)*ppv);
5265     return S_OK;
5266 }
5267
5268 static ULONG WINAPI HTMLDocumentObj_AddRef(IUnknown *iface)
5269 {
5270     HTMLDocumentObj *This = impl_from_IUnknown(iface);
5271     ULONG ref = InterlockedIncrement(&This->ref);
5272
5273     TRACE("(%p) ref = %u\n", This, ref);
5274
5275     return ref;
5276 }
5277
5278 static ULONG WINAPI HTMLDocumentObj_Release(IUnknown *iface)
5279 {
5280     HTMLDocumentObj *This = impl_from_IUnknown(iface);
5281     ULONG ref = InterlockedDecrement(&This->ref);
5282
5283     TRACE("(%p) ref = %u\n", This, ref);
5284
5285     if(!ref) {
5286         nsIDOMWindowUtils *window_utils = NULL;
5287
5288         if(This->basedoc.window && This->basedoc.window->nswindow)
5289             get_nsinterface((nsISupports*)This->basedoc.window->nswindow, &IID_nsIDOMWindowUtils, (void**)&window_utils);
5290
5291         if(This->basedoc.doc_node) {
5292             This->basedoc.doc_node->basedoc.doc_obj = NULL;
5293             htmldoc_release(&This->basedoc.doc_node->basedoc);
5294         }
5295         if(This->basedoc.window) {
5296             This->basedoc.window->doc_obj = NULL;
5297             IHTMLWindow2_Release(&This->basedoc.window->base.IHTMLWindow2_iface);
5298         }
5299         if(This->advise_holder)
5300             IOleAdviseHolder_Release(This->advise_holder);
5301
5302         if(This->view_sink)
5303             IAdviseSink_Release(This->view_sink);
5304         if(This->client)
5305             IOleObject_SetClientSite(&This->basedoc.IOleObject_iface, NULL);
5306         if(This->hostui)
5307             ICustomDoc_SetUIHandler(&This->ICustomDoc_iface, NULL);
5308         if(This->in_place_active)
5309             IOleInPlaceObjectWindowless_InPlaceDeactivate(&This->basedoc.IOleInPlaceObjectWindowless_iface);
5310         if(This->ipsite)
5311             IOleDocumentView_SetInPlaceSite(&This->IOleDocumentView_iface, NULL);
5312         if(This->undomgr)
5313             IOleUndoManager_Release(This->undomgr);
5314         if(This->editsvcs)
5315             IHTMLEditServices_Release(This->editsvcs);
5316         if(This->tooltips_hwnd)
5317             DestroyWindow(This->tooltips_hwnd);
5318
5319         if(This->hwnd)
5320             DestroyWindow(This->hwnd);
5321         heap_free(This->mime);
5322
5323         remove_target_tasks(This->task_magic);
5324         ConnectionPointContainer_Destroy(&This->basedoc.cp_container);
5325         release_dispex(&This->dispex);
5326
5327         if(This->nscontainer)
5328             NSContainer_Release(This->nscontainer);
5329         heap_free(This);
5330
5331         /* Force cycle collection */
5332         if(window_utils) {
5333             nsIDOMWindowUtils_CycleCollect(window_utils, NULL, 0);
5334             nsIDOMWindowUtils_Release(window_utils);
5335         }
5336     }
5337
5338     return ref;
5339 }
5340
5341 static const IUnknownVtbl HTMLDocumentObjVtbl = {
5342     HTMLDocumentObj_QueryInterface,
5343     HTMLDocumentObj_AddRef,
5344     HTMLDocumentObj_Release
5345 };
5346
5347 /**********************************************************
5348  * ICustomDoc implementation
5349  */
5350
5351 static inline HTMLDocumentObj *impl_from_ICustomDoc(ICustomDoc *iface)
5352 {
5353     return CONTAINING_RECORD(iface, HTMLDocumentObj, ICustomDoc_iface);
5354 }
5355
5356 static HRESULT WINAPI CustomDoc_QueryInterface(ICustomDoc *iface, REFIID riid, void **ppv)
5357 {
5358     HTMLDocumentObj *This = impl_from_ICustomDoc(iface);
5359
5360     return htmldoc_query_interface(&This->basedoc, riid, ppv);
5361 }
5362
5363 static ULONG WINAPI CustomDoc_AddRef(ICustomDoc *iface)
5364 {
5365     HTMLDocumentObj *This = impl_from_ICustomDoc(iface);
5366
5367     return htmldoc_addref(&This->basedoc);
5368 }
5369
5370 static ULONG WINAPI CustomDoc_Release(ICustomDoc *iface)
5371 {
5372     HTMLDocumentObj *This = impl_from_ICustomDoc(iface);
5373
5374     return htmldoc_release(&This->basedoc);
5375 }
5376
5377 static HRESULT WINAPI CustomDoc_SetUIHandler(ICustomDoc *iface, IDocHostUIHandler *pUIHandler)
5378 {
5379     HTMLDocumentObj *This = impl_from_ICustomDoc(iface);
5380     IOleCommandTarget *cmdtrg;
5381     HRESULT hres;
5382
5383     TRACE("(%p)->(%p)\n", This, pUIHandler);
5384
5385     if(This->custom_hostui && This->hostui == pUIHandler)
5386         return S_OK;
5387
5388     This->custom_hostui = TRUE;
5389
5390     if(This->hostui)
5391         IDocHostUIHandler_Release(This->hostui);
5392     if(pUIHandler)
5393         IDocHostUIHandler_AddRef(pUIHandler);
5394     This->hostui = pUIHandler;
5395     if(!pUIHandler)
5396         return S_OK;
5397
5398     hres = IDocHostUIHandler_QueryInterface(pUIHandler, &IID_IOleCommandTarget, (void**)&cmdtrg);
5399     if(SUCCEEDED(hres)) {
5400         FIXME("custom UI handler supports IOleCommandTarget\n");
5401         IOleCommandTarget_Release(cmdtrg);
5402     }
5403
5404     return S_OK;
5405 }
5406
5407 static const ICustomDocVtbl CustomDocVtbl = {
5408     CustomDoc_QueryInterface,
5409     CustomDoc_AddRef,
5410     CustomDoc_Release,
5411     CustomDoc_SetUIHandler
5412 };
5413
5414 static const tid_t HTMLDocumentObj_iface_tids[] = {
5415     IHTMLDocument2_tid,
5416     IHTMLDocument3_tid,
5417     IHTMLDocument4_tid,
5418     IHTMLDocument5_tid,
5419     0
5420 };
5421 static dispex_static_data_t HTMLDocumentObj_dispex = {
5422     NULL,
5423     DispHTMLDocument_tid,
5424     HTMLDocumentObj_iface_tids
5425 };
5426
5427 static HRESULT create_document_object(BOOL is_mhtml, IUnknown *outer, REFIID riid, void **ppv)
5428 {
5429     mozIDOMWindowProxy *mozwindow;
5430     HTMLDocumentObj *doc;
5431     nsIDOMWindow *nswindow = NULL;
5432     nsresult nsres;
5433     HRESULT hres;
5434
5435     if(outer && !IsEqualGUID(&IID_IUnknown, riid)) {
5436         *ppv = NULL;
5437         return E_INVALIDARG;
5438     }
5439
5440     doc = heap_alloc_zero(sizeof(HTMLDocumentObj));
5441     if(!doc)
5442         return E_OUTOFMEMORY;
5443
5444     doc->ref = 1;
5445     doc->IUnknown_outer.lpVtbl = &HTMLDocumentObjVtbl;
5446     doc->ICustomDoc_iface.lpVtbl = &CustomDocVtbl;
5447
5448     init_dispex(&doc->dispex, (IUnknown*)&doc->ICustomDoc_iface, &HTMLDocumentObj_dispex);
5449     init_doc(&doc->basedoc, outer ? outer : &doc->IUnknown_outer, &doc->dispex.IDispatchEx_iface);
5450     TargetContainer_Init(doc);
5451     doc->basedoc.doc_obj = doc;
5452     doc->is_mhtml = is_mhtml;
5453
5454     doc->usermode = UNKNOWN_USERMODE;
5455     doc->task_magic = get_task_target_magic();
5456
5457     HTMLDocument_View_Init(doc);
5458
5459     hres = create_nscontainer(doc, &doc->nscontainer);
5460     if(FAILED(hres)) {
5461         ERR("Failed to init Gecko, returning CLASS_E_CLASSNOTAVAILABLE\n");
5462         htmldoc_release(&doc->basedoc);
5463         return hres;
5464     }
5465
5466     if(IsEqualGUID(&IID_IUnknown, riid)) {
5467         *ppv = &doc->IUnknown_outer;
5468     }else {
5469         hres = htmldoc_query_interface(&doc->basedoc, riid, ppv);
5470         htmldoc_release(&doc->basedoc);
5471         if(FAILED(hres))
5472             return hres;
5473     }
5474
5475     nsres = nsIWebBrowser_GetContentDOMWindow(doc->nscontainer->webbrowser, &mozwindow);
5476     if(NS_FAILED(nsres))
5477         ERR("GetContentDOMWindow failed: %08x\n", nsres);
5478
5479     nsres = mozIDOMWindowProxy_QueryInterface(mozwindow, &IID_nsIDOMWindow, (void**)&nswindow);
5480     mozIDOMWindowProxy_Release(mozwindow);
5481     assert(nsres == NS_OK);
5482
5483     hres = HTMLOuterWindow_Create(doc, nswindow, NULL /* FIXME */, &doc->basedoc.window);
5484     if(nswindow)
5485         nsIDOMWindow_Release(nswindow);
5486     if(FAILED(hres)) {
5487         htmldoc_release(&doc->basedoc);
5488         return hres;
5489     }
5490
5491     if(!doc->basedoc.doc_node && doc->basedoc.window->base.inner_window->doc) {
5492         doc->basedoc.doc_node = doc->basedoc.window->base.inner_window->doc;
5493         htmldoc_addref(&doc->basedoc.doc_node->basedoc);
5494     }
5495
5496     get_thread_hwnd();
5497
5498     return S_OK;
5499 }
5500
5501 HRESULT HTMLDocument_Create(IUnknown *outer, REFIID riid, void **ppv)
5502 {
5503     TRACE("(%p %s %p)\n", outer, debugstr_mshtml_guid(riid), ppv);
5504     return create_document_object(FALSE, outer, riid, ppv);
5505 }
5506
5507 HRESULT MHTMLDocument_Create(IUnknown *outer, REFIID riid, void **ppv)
5508 {
5509     TRACE("(%p %s %p)\n", outer, debugstr_mshtml_guid(riid), ppv);
5510     return create_document_object(TRUE, outer, riid, ppv);
5511 }