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