embedding/browser/activex/src/common/IEHtmlElement.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Adam Lock <adamlock@netscape.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "stdafx.h"
  40
  41 #include "nsCOMPtr.h"
  42 #include "nsIDOMElement.h"
  43
  44 #include "IEHtmlElement.h"
  45 #include "IEHtmlElementCollection.h"
  46
  47 #include "nsIDOMHTMLElement.h"
  48 #include "nsIDOMNSHTMLElement.h"
  49 #include "nsIDOM3Node.h"
  50 #include "nsIDOMDocumentRange.h"
  51 #include "nsIDOMRange.h"
  52 #include "nsIDOMNSRange.h"
  53 #include "nsIDOMDocumentFragment.h"
  54 #include "nsIDocumentEncoder.h"
  55 #include "nsContentCID.h"
  56
  57 CIEHtmlElement::CIEHtmlElement()
  58 {
  59     m_pNodeAgg = NULL;
  60 }
  61
  62 HRESULT CIEHtmlElement::FinalConstruct( )
  63 {
  64     return CComCreator<CComAggObject<CIEHtmlDomNode> >::CreateInstance(GetControllingUnknown(),
  65         IID_IUnknown, reinterpret_cast<void**>(&m_pNodeAgg));
  66 }
  67
  68 CIEHtmlElement::~CIEHtmlElement()
  69 {
  70 }
  71
  72 void CIEHtmlElement::FinalRelease( )
  73 {
  74     m_pNodeAgg->Release();
  75 }
  76
  77 HRESULT CIEHtmlElement::GetChildren(CIEHtmlElementCollectionInstance **ppCollection)
  78 {
  79     // Validate parameters
  80     if (ppCollection == NULL)
  81     {
  82         return E_INVALIDARG;
  83     }
  84
  85     *ppCollection = NULL;
  86
  87     // Create a collection representing the children of this node
  88     CIEHtmlElementCollectionInstance *pCollection = NULL;
  89     CIEHtmlElementCollection::CreateFromParentNode(this, FALSE, (CIEHtmlElementCollection **) &pCollection);
  90     if (pCollection)
  91     {
  92         pCollection->AddRef();
  93         *ppCollection = pCollection;
  94     }
  95
  96     return S_OK;
  97 }
  98
  99 HRESULT CIEHtmlElement::GetHtmlDomNode(CIEHtmlDomNode **ppHtmlDomNode)
 100 {
 101     if (ppHtmlDomNode == NULL)
 102         return E_FAIL;
 103     *ppHtmlDomNode = NULL;
 104     IHTMLDOMNode* pHtmlNode = NULL;
 105     // This causes an AddRef on outer unknown:
 106     HRESULT hr = m_pNodeAgg->QueryInterface(__uuidof(IHTMLDOMNode), (void**)&pHtmlNode);
 107     *ppHtmlDomNode = (CIEHtmlDomNode*)pHtmlNode;
 108     return hr;
 109 }
 110
 111 HRESULT CIEHtmlElement::SetDOMNode(nsIDOMNode *pDomNode)
 112 {
 113     mDOMNode = pDomNode;
 114     // Forward to aggregated object:
 115     CIEHtmlDomNode *pHtmlDomNode;
 116     GetHtmlDomNode(&pHtmlDomNode);
 117     HRESULT hr = pHtmlDomNode->SetDOMNode(pDomNode);
 118     // Release on outer unknown because GetHtmlDomNode does AddRef on it:
 119     GetControllingUnknown()->Release();
 120     return hr;
 121 }
 122
 123 HRESULT CIEHtmlElement::SetParent(CNode *pParent)
 124 {
 125     CNode::SetParent(pParent);
 126     // Forward to aggregated object:
 127     CIEHtmlDomNode *pHtmlDomNode;
 128     GetHtmlDomNode(&pHtmlDomNode);
 129     HRESULT hr = pHtmlDomNode->SetParent(pParent);
 130     // Release on outer unknown because GetHtmlDomNode does AddRef on it:
 131     GetControllingUnknown()->Release();
 132     return hr;
 133 }
 134
 135 ///////////////////////////////////////////////////////////////////////////////
 136 // IHTMLElement implementation
 137
 138 HRESULT STDMETHODCALLTYPE CIEHtmlElement::setAttribute(BSTR strAttributeName, VARIANT AttributeValue, LONG lFlags)
 139 {
 140     if (strAttributeName == NULL)
 141     {
 142         return E_INVALIDARG;
 143     }
 144
 145     nsCOMPtr<nsIDOMElement> element = do_QueryInterface(mDOMNode);
 146     if (!element)
 147     {
 148         return E_UNEXPECTED;
 149     }
 150
 151     // Get the name from the BSTR
 152     USES_CONVERSION;
 153     nsAutoString name(OLE2W(strAttributeName));
 154
 155     // Get the value from the variant
 156     CComVariant vValue;
 157     if (FAILED(vValue.ChangeType(VT_BSTR, &AttributeValue)))
 158     {
 159         return E_INVALIDARG;
 160     }
 161
 162     // Set the attribute
 163     nsAutoString value(OLE2W(vValue.bstrVal));
 164     element->SetAttribute(name, value);
 165
 166     return S_OK;
 167 }
 168
 169 HRESULT STDMETHODCALLTYPE CIEHtmlElement::getAttribute(BSTR strAttributeName, LONG lFlags, VARIANT __RPC_FAR *AttributeValue)
 170 {
 171     if (strAttributeName == NULL)
 172     {
 173         return E_INVALIDARG;
 174     }
 175     if (AttributeValue == NULL)
 176     {
 177         return E_INVALIDARG;
 178     }
 179     VariantInit(AttributeValue);
 180
 181     // Get the name from the BSTR
 182     USES_CONVERSION;
 183     nsAutoString name(OLE2W(strAttributeName));
 184
 185     nsCOMPtr<nsIDOMElement> element = do_QueryInterface(mDOMNode);
 186     if (!element)
 187     {
 188         return E_UNEXPECTED;
 189     }
 190
 191     BOOL bCaseSensitive = (lFlags == VARIANT_TRUE) ? TRUE : FALSE;
 192
 193
 194     // Get the attribute
 195     nsAutoString value;
 196     nsresult rv = element->GetAttribute(name, value);
 197     if (NS_SUCCEEDED(rv))
 198     {
 199         USES_CONVERSION;
 200         AttributeValue->vt = VT_BSTR;
 201         AttributeValue->bstrVal = SysAllocString(W2COLE(value.get()));
 202         return S_OK;
 203     }
 204     else
 205     {
 206         return S_FALSE;
 207     }
 208
 209     return S_OK;
 210 }
 211
 212 HRESULT STDMETHODCALLTYPE CIEHtmlElement::removeAttribute(BSTR strAttributeName, LONG lFlags, VARIANT_BOOL __RPC_FAR *pfSuccess)
 213 {
 214     if (strAttributeName == NULL)
 215     {
 216         return E_INVALIDARG;
 217     }
 218
 219     nsCOMPtr<nsIDOMElement> element = do_QueryInterface(mDOMNode);
 220     if (!element)
 221     {
 222         return E_UNEXPECTED;
 223     }
 224
 225     BOOL bCaseSensitive = (lFlags == VARIANT_TRUE) ? TRUE : FALSE;
 226
 227     // Get the name from the BSTR
 228     USES_CONVERSION;
 229     nsAutoString name(OLE2W(strAttributeName));
 230
 231     // Remove the attribute
 232     nsresult nr = element->RemoveAttribute(name);
 233     BOOL bRemoved = (nr == NS_OK) ? TRUE : FALSE;
 234
 235     if (pfSuccess)
 236     {
 237         *pfSuccess = (bRemoved) ? VARIANT_TRUE : VARIANT_FALSE;
 238     }
 239
 240     return S_OK;
 241 }
 242
 243 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_className(BSTR v)
 244 {
 245     return E_NOTIMPL;
 246 }
 247
 248 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_className(BSTR __RPC_FAR *p)
 249 {
 250     if (p == NULL)
 251     {
 252         return E_INVALIDARG;
 253     }
 254
 255     VARIANT vValue;
 256     VariantInit(&vValue);
 257     BSTR bstrName = SysAllocString(OLESTR("class"));
 258     getAttribute(bstrName, FALSE, &vValue);
 259     SysFreeString(bstrName);
 260
 261     *p = vValue.bstrVal;
 262     return S_OK;
 263 }
 264
 265 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_id(BSTR v)
 266 {
 267     nsCOMPtr<nsIDOMHTMLElement> domHtmlElmt = do_QueryInterface(mDOMNode);
 268     if (!domHtmlElmt)
 269         return E_UNEXPECTED;
 270     USES_CONVERSION;
 271     nsDependentString strID(OLE2CW(v));
 272     if (FAILED(domHtmlElmt->SetId(strID)))
 273         return E_FAIL;
 274     return S_OK;
 275 }
 276
 277 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_id(BSTR __RPC_FAR *p)
 278 {
 279     if (p == NULL)
 280     {
 281         return E_INVALIDARG;
 282     }
 283
 284     VARIANT vValue;
 285     VariantInit(&vValue);
 286     BSTR bstrName = SysAllocString(OLESTR("id"));
 287     getAttribute(bstrName, FALSE, &vValue);
 288     SysFreeString(bstrName);
 289
 290     *p = vValue.bstrVal;
 291     return S_OK;
 292 }
 293
 294 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_tagName(BSTR __RPC_FAR *p)
 295 {
 296     if (p == NULL)
 297     {
 298         return E_INVALIDARG;
 299     }
 300
 301     nsCOMPtr<nsIDOMElement> element = do_QueryInterface(mDOMNode);
 302     if (!element)
 303     {
 304         return E_UNEXPECTED;
 305     }
 306
 307     nsAutoString tagName;
 308     element->GetTagName(tagName);
 309
 310     USES_CONVERSION;
 311     *p = SysAllocString(W2COLE(tagName.get()));
 312     return S_OK;
 313 }
 314
 315 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_parentElement(IHTMLElement __RPC_FAR *__RPC_FAR *p)
 316 {
 317     if (p == NULL)
 318     {
 319         return E_INVALIDARG;
 320     }
 321
 322     *p = NULL;
 323     if (mParent)
 324     {
 325         CIEHtmlElement *pElt = static_cast<CIEHtmlElement *>(mParent);
 326         pElt->QueryInterface(IID_IHTMLElement, (void **) p);
 327     }
 328     else
 329     {
 330         nsCOMPtr<nsIDOMNode> parentNode;
 331         mDOMNode->GetParentNode(getter_AddRefs(parentNode));
 332         nsCOMPtr<nsIDOMElement> domElement = do_QueryInterface(parentNode);
 333         if (domElement)
 334         {
 335             CComPtr<IUnknown> pNode;
 336             HRESULT hr = CIEHtmlDomNode::FindOrCreateFromDOMNode(parentNode, &pNode);
 337             if (FAILED(hr))
 338                 return hr;
 339             if (FAILED(pNode->QueryInterface(IID_IHTMLElement, (void **) p)))
 340                 return E_UNEXPECTED;
 341         }
 342     }
 343
 344     return S_OK;
 345 }
 346
 347 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_style(IHTMLStyle __RPC_FAR *__RPC_FAR *p)
 348 {
 349     return E_NOTIMPL;
 350 }
 351
 352 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onhelp(VARIANT v)
 353 {
 354     return E_NOTIMPL;
 355 }
 356
 357 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onhelp(VARIANT __RPC_FAR *p)
 358 {
 359     return E_NOTIMPL;
 360 }
 361
 362 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onclick(VARIANT v)
 363 {
 364     return E_NOTIMPL;
 365 }
 366
 367 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onclick(VARIANT __RPC_FAR *p)
 368 {
 369     return E_NOTIMPL;
 370 }
 371
 372 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_ondblclick(VARIANT v)
 373 {
 374     return E_NOTIMPL;
 375 }
 376
 377 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_ondblclick(VARIANT __RPC_FAR *p)
 378 {
 379     return E_NOTIMPL;
 380 }
 381
 382 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onkeydown(VARIANT v)
 383 {
 384     return E_NOTIMPL;
 385 }
 386
 387 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onkeydown(VARIANT __RPC_FAR *p)
 388 {
 389     return E_NOTIMPL;
 390 }
 391
 392 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onkeyup(VARIANT v)
 393 {
 394     return E_NOTIMPL;
 395 }
 396
 397 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onkeyup(VARIANT __RPC_FAR *p)
 398 {
 399     return E_NOTIMPL;
 400 }
 401
 402 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onkeypress(VARIANT v)
 403 {
 404     return E_NOTIMPL;
 405 }
 406
 407 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onkeypress(VARIANT __RPC_FAR *p)
 408 {
 409     return E_NOTIMPL;
 410 }
 411
 412 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onmouseout(VARIANT v)
 413 {
 414     return E_NOTIMPL;
 415 }
 416
 417 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onmouseout(VARIANT __RPC_FAR *p)
 418 {
 419     return E_NOTIMPL;
 420 }
 421
 422 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onmouseover(VARIANT v)
 423 {
 424     return E_NOTIMPL;
 425 }
 426
 427 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onmouseover(VARIANT __RPC_FAR *p)
 428 {
 429     return E_NOTIMPL;
 430 }
 431
 432 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onmousemove(VARIANT v)
 433 {
 434     return E_NOTIMPL;
 435 }
 436
 437 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onmousemove(VARIANT __RPC_FAR *p)
 438 {
 439     return E_NOTIMPL;
 440 }
 441
 442 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onmousedown(VARIANT v)
 443 {
 444     return E_NOTIMPL;
 445 }
 446
 447 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onmousedown(VARIANT __RPC_FAR *p)
 448 {
 449     return E_NOTIMPL;
 450 }
 451
 452 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onmouseup(VARIANT v)
 453 {
 454     return E_NOTIMPL;
 455 }
 456
 457 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onmouseup(VARIANT __RPC_FAR *p)
 458 {
 459     return E_NOTIMPL;
 460 }
 461
 462 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_document(IDispatch __RPC_FAR *__RPC_FAR *p)
 463 {
 464     return E_NOTIMPL;
 465 }
 466
 467 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_title(BSTR v)
 468 {
 469     return E_NOTIMPL;
 470 }
 471
 472 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_title(BSTR __RPC_FAR *p)
 473 {
 474     return E_NOTIMPL;
 475 }
 476
 477 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_language(BSTR v)
 478 {
 479     return E_NOTIMPL;
 480 }
 481
 482 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_language(BSTR __RPC_FAR *p)
 483 {
 484     return E_NOTIMPL;
 485 }
 486
 487 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onselectstart(VARIANT v)
 488 {
 489     return E_NOTIMPL;
 490 }
 491
 492 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onselectstart(VARIANT __RPC_FAR *p)
 493 {
 494     return E_NOTIMPL;
 495 }
 496
 497 HRESULT STDMETHODCALLTYPE CIEHtmlElement::scrollIntoView(VARIANT varargStart)
 498 {
 499     return E_NOTIMPL;
 500 }
 501
 502 HRESULT STDMETHODCALLTYPE CIEHtmlElement::contains(IHTMLElement __RPC_FAR *pChild, VARIANT_BOOL __RPC_FAR *pfResult)
 503 {
 504     return E_NOTIMPL;
 505 }
 506
 507 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_sourceIndex(long __RPC_FAR *p)
 508 {
 509     return E_NOTIMPL;
 510 }
 511
 512 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_recordNumber(VARIANT __RPC_FAR *p)
 513 {
 514     return E_NOTIMPL;
 515 }
 516
 517 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_lang(BSTR v)
 518 {
 519     return E_NOTIMPL;
 520 }
 521
 522 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_lang(BSTR __RPC_FAR *p)
 523 {
 524     return E_NOTIMPL;
 525 }
 526
 527 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_offsetLeft(long __RPC_FAR *p)
 528 {
 529     nsCOMPtr<nsIDOMNSHTMLElement> nodeAsHTMLElement = do_QueryInterface(mDOMNode);
 530     if (!nodeAsHTMLElement)
 531     {
 532         return E_NOINTERFACE;
 533     }
 534
 535     PRInt32 nData;
 536     nodeAsHTMLElement->GetOffsetLeft(&nData);
 537     *p = nData;
 538     return S_OK;
 539 }
 540
 541 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_offsetTop(long __RPC_FAR *p)
 542 {
 543     nsCOMPtr<nsIDOMNSHTMLElement> nodeAsHTMLElement = do_QueryInterface(mDOMNode);
 544     if (!nodeAsHTMLElement)
 545     {
 546         return E_NOINTERFACE;
 547     }
 548
 549     PRInt32 nData;
 550     nodeAsHTMLElement->GetOffsetTop(&nData);
 551     *p = nData;
 552     return S_OK;
 553 }
 554
 555 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_offsetWidth(long __RPC_FAR *p)
 556 {
 557     nsCOMPtr<nsIDOMNSHTMLElement> nodeAsHTMLElement = do_QueryInterface(mDOMNode);
 558     if (!nodeAsHTMLElement)
 559     {
 560         return E_NOINTERFACE;
 561     }
 562
 563     PRInt32 nData;
 564     nodeAsHTMLElement->GetOffsetWidth(&nData);
 565     *p = nData;
 566     return S_OK;
 567 }
 568
 569 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_offsetHeight(long __RPC_FAR *p)
 570 {
 571     nsCOMPtr<nsIDOMNSHTMLElement> nodeAsHTMLElement = do_QueryInterface(mDOMNode);
 572     if (!nodeAsHTMLElement)
 573     {
 574         return E_NOINTERFACE;
 575     }
 576
 577     PRInt32 nData;
 578     nodeAsHTMLElement->GetOffsetHeight(&nData);
 579     *p = nData;
 580     return S_OK;
 581 }
 582
 583 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_offsetParent(IHTMLElement __RPC_FAR *__RPC_FAR *p)
 584 {
 585     return E_NOTIMPL;
 586 }
 587
 588 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_innerHTML(BSTR v)
 589 {
 590     nsCOMPtr<nsIDOMNSHTMLElement> elementHTML = do_QueryInterface(mDOMNode);
 591     if (!elementHTML)
 592     {
 593         return E_UNEXPECTED;
 594     }
 595
 596     USES_CONVERSION;
 597     nsAutoString innerHTML(OLE2W(v));
 598     elementHTML->SetInnerHTML(innerHTML);
 599     return S_OK;
 600 }
 601
 602 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_innerHTML(BSTR __RPC_FAR *p)
 603 {
 604     nsCOMPtr<nsIDOMNSHTMLElement> elementHTML = do_QueryInterface(mDOMNode);
 605     if (!elementHTML)
 606     {
 607         return E_UNEXPECTED;
 608     }
 609
 610     nsAutoString innerHTML;
 611     elementHTML->GetInnerHTML(innerHTML);
 612
 613     USES_CONVERSION;
 614     *p = SysAllocString(W2COLE(innerHTML.get()));
 615     return S_OK;
 616 }
 617
 618 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_innerText(BSTR v)
 619 {
 620     nsCOMPtr<nsIDOM3Node> node = do_QueryInterface(mDOMNode);
 621     if (!node)
 622     {
 623         return E_UNEXPECTED;
 624     }
 625
 626     USES_CONVERSION;
 627     nsAutoString innerText(OLE2W(v));
 628     node->SetTextContent(innerText);
 629
 630     return S_OK;
 631 }
 632
 633 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_innerText(BSTR __RPC_FAR *p)
 634 {
 635     nsCOMPtr<nsIDOM3Node> node = do_QueryInterface(mDOMNode);
 636     if (!node)
 637     {
 638         return E_UNEXPECTED;
 639     }
 640
 641     nsAutoString innerText;
 642     node->GetTextContent(innerText);
 643
 644     USES_CONVERSION;
 645     *p = SysAllocString(W2COLE(innerText.get()));
 646     return S_OK;
 647 }
 648
 649 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_outerHTML(BSTR v)
 650 {
 651     nsresult rv;
 652     nsCOMPtr<nsIDOMDocument> domDoc;
 653     nsCOMPtr<nsIDOMRange> domRange;
 654     nsCOMPtr<nsIDOMDocumentFragment> domDocFragment;
 655
 656     mDOMNode->GetOwnerDocument(getter_AddRefs(domDoc));
 657     nsCOMPtr<nsIDOMDocumentRange> domDocRange = do_QueryInterface(domDoc);
 658     if (!domDocRange)
 659         return E_FAIL;
 660     domDocRange->CreateRange(getter_AddRefs(domRange));
 661     if (!domRange)
 662         return E_FAIL;
 663     if (domRange->SetStartBefore(mDOMNode))
 664         return E_FAIL;
 665     if (domRange->DeleteContents())
 666         return E_FAIL;
 667     nsAutoString outerHTML(OLE2W(v));
 668     nsCOMPtr<nsIDOMNSRange> domNSRange = do_QueryInterface(domRange);
 669     rv = domNSRange->CreateContextualFragment(outerHTML, getter_AddRefs(domDocFragment));
 670     if (!domDocFragment)
 671         return E_FAIL;
 672     nsCOMPtr<nsIDOMNode> parentNode;
 673     mDOMNode->GetParentNode(getter_AddRefs(parentNode));
 674     nsCOMPtr<nsIDOMNode> domNode;
 675     parentNode->ReplaceChild(domDocFragment, mDOMNode, getter_AddRefs(domNode));
 676
 677     return S_OK;
 678 }
 679
 680 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_outerHTML(BSTR __RPC_FAR *p)
 681 {
 682     if (p == NULL)
 683     {
 684         return E_INVALIDARG;
 685     }
 686
 687     *p = NULL;
 688
 689     nsresult rv;
 690     nsAutoString outerHTML;
 691     nsCOMPtr<nsIDOMDocument> domDoc;
 692     nsCOMPtr<nsIDocumentEncoder> docEncoder;
 693     nsCOMPtr<nsIDOMRange> domRange;
 694
 695     mDOMNode->GetOwnerDocument(getter_AddRefs(domDoc));
 696     if (!domDoc)
 697         return E_FAIL;
 698
 699     docEncoder = do_CreateInstance(NS_DOC_ENCODER_CONTRACTID_BASE "text/html");
 700     NS_ENSURE_TRUE(docEncoder, NS_ERROR_FAILURE);
 701     docEncoder->Init(domDoc, NS_LITERAL_STRING("text/html"),
 702         nsIDocumentEncoder::OutputEncodeBasicEntities);
 703     nsCOMPtr<nsIDOMDocumentRange> domDocRange = do_QueryInterface(domDoc);
 704     if (!domDocRange)
 705         return E_FAIL;
 706     domDocRange->CreateRange(getter_AddRefs(domRange));
 707     if (!domRange)
 708         return E_FAIL;
 709     rv = domRange->SelectNode(mDOMNode);
 710     NS_ENSURE_SUCCESS(rv, rv);
 711     docEncoder->SetRange(domRange);
 712     docEncoder->EncodeToString(outerHTML);
 713
 714     USES_CONVERSION;
 715     *p = SysAllocString(W2COLE(outerHTML.get()));
 716
 717     return S_OK;
 718 }
 719
 720 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_outerText(BSTR v)
 721 {
 722     return E_NOTIMPL;
 723 }
 724
 725 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_outerText(BSTR __RPC_FAR *p)
 726 {
 727     return E_NOTIMPL;
 728 }
 729
 730 HRESULT STDMETHODCALLTYPE CIEHtmlElement::insertAdjacentHTML(BSTR where, BSTR html)
 731 {
 732     nsresult rv;
 733     nsCOMPtr<nsIDOMDocument> domDoc;
 734     nsCOMPtr<nsIDOMRange> domRange;
 735     nsCOMPtr<nsIDOMDocumentFragment> domDocFragment;
 736
 737     NS_ASSERTION(mDOMNode, "");
 738     //Create a range:
 739     mDOMNode->GetOwnerDocument(getter_AddRefs(domDoc));
 740     nsCOMPtr<nsIDOMDocumentRange> domDocRange = do_QueryInterface(domDoc);
 741     if (!domDocRange)
 742         return E_FAIL;
 743     domDocRange->CreateRange(getter_AddRefs(domRange));
 744     if (!domRange)
 745         return E_FAIL;
 746     // Must position range first before calling CreateContextualFragment:
 747     if (domRange->SetStartBefore(mDOMNode))
 748         return E_FAIL;
 749     USES_CONVERSION;
 750     // Create doc fragment:
 751     nsDependentString strAdjacentHTML(OLE2CW(html));
 752     nsCOMPtr<nsIDOMNSRange> domNSRange = do_QueryInterface(domRange);
 753     domNSRange->CreateContextualFragment(strAdjacentHTML, getter_AddRefs(domDocFragment));
 754     if (!domDocFragment)
 755         return E_FAIL;
 756     if (_wcsicmp(OLE2CW(where), L"beforeBegin") == 0)
 757     {
 758         // Insert fragment immediately before us:
 759         nsCOMPtr<nsIDOMNode> parentNode;
 760         mDOMNode->GetParentNode(getter_AddRefs(parentNode));
 761         nsCOMPtr<nsIDOMNode> dummyNode;
 762         rv = parentNode->InsertBefore(domDocFragment, mDOMNode, getter_AddRefs(dummyNode));
 763         return SUCCEEDED(rv)? S_OK: E_FAIL;
 764     }
 765     if (_wcsicmp(OLE2CW(where), L"afterEnd") == 0)
 766     {
 767         // Insert fragment immediately after us:
 768         nsCOMPtr<nsIDOMNode> parentNode;
 769         mDOMNode->GetParentNode(getter_AddRefs(parentNode));
 770         nsCOMPtr<nsIDOMNode> dummyNode;
 771         nsCOMPtr<nsIDOMNode> nextNode;
 772         mDOMNode->GetNextSibling(getter_AddRefs(nextNode));
 773         if (nextNode)
 774         {
 775             // Insert immediately before next node:
 776             rv = parentNode->InsertBefore(domDocFragment, nextNode, getter_AddRefs(dummyNode));
 777         }
 778         else
 779         {
 780             // We are the last child, insert after us:
 781             rv = parentNode->AppendChild(domDocFragment, getter_AddRefs(dummyNode));
 782         }
 783         return SUCCEEDED(rv)? S_OK: E_FAIL;
 784     }
 785     if (_wcsicmp(OLE2CW(where), L"afterBegin") == 0)
 786     {
 787         // Insert fragment immediately before first child:
 788         nsCOMPtr<nsIDOMNode> firstChildNode;
 789         mDOMNode->GetFirstChild(getter_AddRefs(firstChildNode));
 790         if (!firstChildNode)
 791             return E_FAIL; // IE fails when inserting into a tag that has no childs
 792         nsCOMPtr<nsIDOMNode> dummyNode;
 793         rv = mDOMNode->InsertBefore(domDocFragment, firstChildNode, getter_AddRefs(dummyNode));
 794         return SUCCEEDED(rv)? S_OK: E_FAIL;
 795     }
 796     if (_wcsicmp(OLE2CW(where), L"beforeEnd") == 0)
 797     {
 798         // Insert fragment immediately as last child:
 799         nsCOMPtr<nsIDOMNode> dummyNode;
 800         rv = mDOMNode->AppendChild(domDocFragment, getter_AddRefs(dummyNode));
 801         return SUCCEEDED(rv)? S_OK: E_FAIL;
 802     }
 803     return E_INVALIDARG;
 804 }
 805
 806 HRESULT STDMETHODCALLTYPE CIEHtmlElement::insertAdjacentText(BSTR where, BSTR text)
 807 {
 808     return E_NOTIMPL;
 809 }
 810
 811 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_parentTextEdit(IHTMLElement __RPC_FAR *__RPC_FAR *p)
 812 {
 813     return E_NOTIMPL;
 814 }
 815
 816 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_isTextEdit(VARIANT_BOOL __RPC_FAR *p)
 817 {
 818     return E_NOTIMPL;
 819 }
 820
 821 HRESULT STDMETHODCALLTYPE CIEHtmlElement::click(void)
 822 {
 823     return E_NOTIMPL;
 824 }
 825
 826 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_filters(IHTMLFiltersCollection __RPC_FAR *__RPC_FAR *p)
 827 {
 828     return E_NOTIMPL;
 829 }
 830
 831 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_ondragstart(VARIANT v)
 832 {
 833     return E_NOTIMPL;
 834 }
 835
 836 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_ondragstart(VARIANT __RPC_FAR *p)
 837 {
 838     return E_NOTIMPL;
 839 }
 840
 841 HRESULT STDMETHODCALLTYPE CIEHtmlElement::toString(BSTR __RPC_FAR *String)
 842 {
 843     return E_NOTIMPL;
 844 }
 845
 846 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onbeforeupdate(VARIANT v)
 847 {
 848     return E_NOTIMPL;
 849 }
 850
 851 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onbeforeupdate(VARIANT __RPC_FAR *p)
 852 {
 853     return E_NOTIMPL;
 854 }
 855
 856 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onafterupdate(VARIANT v)
 857 {
 858     return E_NOTIMPL;
 859 }
 860
 861 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onafterupdate(VARIANT __RPC_FAR *p)
 862 {
 863     return E_NOTIMPL;
 864 }
 865
 866 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onerrorupdate(VARIANT v)
 867 {
 868     return E_NOTIMPL;
 869 }
 870
 871 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onerrorupdate(VARIANT __RPC_FAR *p)
 872 {
 873     return E_NOTIMPL;
 874 }
 875
 876 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onrowexit(VARIANT v)
 877 {
 878     return E_NOTIMPL;
 879 }
 880
 881 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onrowexit(VARIANT __RPC_FAR *p)
 882 {
 883     return E_NOTIMPL;
 884 }
 885
 886 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onrowenter(VARIANT v)
 887 {
 888     return E_NOTIMPL;
 889 }
 890
 891 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onrowenter(VARIANT __RPC_FAR *p)
 892 {
 893     return E_NOTIMPL;
 894 }
 895
 896 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_ondatasetchanged(VARIANT v)
 897 {
 898     return E_NOTIMPL;
 899 }
 900
 901 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_ondatasetchanged(VARIANT __RPC_FAR *p)
 902 {
 903     return E_NOTIMPL;
 904 }
 905
 906 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_ondataavailable(VARIANT v)
 907 {
 908     return E_NOTIMPL;
 909 }
 910
 911 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_ondataavailable(VARIANT __RPC_FAR *p)
 912 {
 913     return E_NOTIMPL;
 914 }
 915
 916 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_ondatasetcomplete(VARIANT v)
 917 {
 918     return E_NOTIMPL;
 919 }
 920
 921 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_ondatasetcomplete(VARIANT __RPC_FAR *p)
 922 {
 923     return E_NOTIMPL;
 924 }
 925
 926 HRESULT STDMETHODCALLTYPE CIEHtmlElement::put_onfilterchange(VARIANT v)
 927 {
 928     return E_NOTIMPL;
 929 }
 930
 931 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_onfilterchange(VARIANT __RPC_FAR *p)
 932 {
 933     return E_NOTIMPL;
 934 }
 935
 936 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_children(IDispatch __RPC_FAR *__RPC_FAR *p)
 937 {
 938     // Validate parameters
 939     if (p == NULL)
 940     {
 941         return E_INVALIDARG;
 942     }
 943
 944     *p = NULL;
 945
 946     // Create a collection representing the children of this node
 947     CIEHtmlElementCollectionInstance *pCollection = NULL;
 948     HRESULT hr = GetChildren(&pCollection);
 949     if (SUCCEEDED(hr))
 950     {
 951         *p = pCollection;
 952     }
 953
 954     return hr;
 955 }
 956
 957 HRESULT STDMETHODCALLTYPE CIEHtmlElement::get_all(IDispatch __RPC_FAR *__RPC_FAR *p)
 958 {
 959     // Validate parameters
 960     if (p == NULL)
 961     {
 962         return E_INVALIDARG;
 963     }
 964
 965     *p = NULL;
 966
 967     // TODO get ALL contained elements, not just the immediate children
 968
 969     CIEHtmlElementCollectionInstance *pCollection = NULL;
 970     CIEHtmlElementCollection::CreateFromParentNode(this, TRUE, (CIEHtmlElementCollection **) &pCollection);
 971     if (pCollection)
 972     {
 973         pCollection->AddRef();
 974         *p = pCollection;
 975     }
 976
 977     return S_OK;
 978 }
 979