1 /*

     2  * Copyright (C) 2006, 2007, 2009 Apple Inc.  All rights reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  * 1. Redistributions of source code must retain the above copyright

     8  *    notice, this list of conditions and the following disclaimer.

     9  * 2. Redistributions in binary form must reproduce the above copyright

    10  *    notice, this list of conditions and the following disclaimer in the

    11  *    documentation and/or other materials provided with the distribution.

    12  *

    13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

    14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

    24  */

    25 

    26 #include "config.h"

    27 #include "WebKitDLL.h"

    28 #include "DOMCoreClasses.h"

    29 

    30 #include "COMPtr.h"

    31 #include "DOMCSSClasses.h"

    32 #include "DOMEventsClasses.h"

    33 #include "DOMHTMLClasses.h"

    34 #include "WebKitGraphics.h"

    35 

    36 #pragma warning(push, 0)

    37 #include <WebCore/BString.h>

    38 #include <WebCore/DOMWindow.h>

    39 #include <WebCore/Document.h>

    40 #include <WebCore/Element.h>

    41 #include <WebCore/Frame.h>

    42 #include <WebCore/SimpleFontData.h>

    43 #include <WebCore/HTMLFormElement.h>

    44 #include <WebCore/HTMLInputElement.h>

    45 #include <WebCore/HTMLNames.h>

    46 #include <WebCore/HTMLOptionElement.h>

    47 #include <WebCore/HTMLSelectElement.h>

    48 #include <WebCore/HTMLTextAreaElement.h>

    49 #include <WebCore/NodeList.h>

    50 #include <WebCore/RenderObject.h>

    51 #include <WebCore/RenderTreeAsText.h>

    52 #pragma warning(pop)

    53 

    54 #include <initguid.h>

    55 // {3B0C0EFF-478B-4b0b-8290-D2321E08E23E}

    56 DEFINE_GUID(IID_DOMElement, 0x3b0c0eff, 0x478b, 0x4b0b, 0x82, 0x90, 0xd2, 0x32, 0x1e, 0x8, 0xe2, 0x3e);

    57 

    58 // Our normal style is just to say "using namespace WebCore" rather than having

    59 // individual using directives for each type from that namespace. But

    60 // "DOMObject" exists both in the WebCore namespace and unnamespaced in this

    61 // file, which leads to ambiguities if we say "using namespace WebCore".

    62 using namespace WebCore::HTMLNames;

    63 using WebCore::AtomicString;

    64 using WebCore::BString;

    65 using WebCore::Element;

    66 using WebCore::ExceptionCode;

    67 using WebCore::FontDescription;

    68 using WebCore::Frame;

    69 using WebCore::IntRect;

    70 using WebCore::String;

    71 

    72 // DOMObject - IUnknown -------------------------------------------------------

    73 

    74 HRESULT STDMETHODCALLTYPE DOMObject::QueryInterface(REFIID riid, void** ppvObject)

    75 {

    76     *ppvObject = 0;

    77     if (IsEqualGUID(riid, IID_IDOMObject))

    78         *ppvObject = static_cast<IDOMObject*>(this);

    79     else

    80         return WebScriptObject::QueryInterface(riid, ppvObject);

    81 

    82     AddRef();

    83     return S_OK;

    84 }

    85 

    86 // DOMNode - IUnknown ---------------------------------------------------------

    87 

    88 HRESULT STDMETHODCALLTYPE DOMNode::QueryInterface(REFIID riid, void** ppvObject)

    89 {

    90     *ppvObject = 0;

    91     if (IsEqualGUID(riid, IID_IDOMNode))

    92         *ppvObject = static_cast<IDOMNode*>(this);

    93     else if (IsEqualGUID(riid, __uuidof(DOMNode)))

    94         *ppvObject = static_cast<DOMNode*>(this);

    95     else

    96         return DOMObject::QueryInterface(riid, ppvObject);

    97 

    98     AddRef();

    99     return S_OK;

   100 }

   101 

   102 // DOMNode --------------------------------------------------------------------

   103 

   104 HRESULT STDMETHODCALLTYPE DOMNode::nodeName( 

   105     /* [retval][out] */ BSTR* result)

   106 {

   107     if (!result)

   108         return E_POINTER;

   109 

   110     if (!m_node)

   111         return E_FAIL;

   112 

   113     *result = BString(m_node->nodeName()).release();

   114     return S_OK;

   115 }

   116 

   117 HRESULT STDMETHODCALLTYPE DOMNode::nodeValue( 

   118     /* [retval][out] */ BSTR* result)

   119 {

   120     if (!m_node)

   121         return E_FAIL;

   122     WebCore::String nodeValueStr = m_node->nodeValue();

   123     *result = SysAllocStringLen(nodeValueStr.characters(), nodeValueStr.length());

   124     if (nodeValueStr.length() && !*result)

   125         return E_OUTOFMEMORY;

   126     return S_OK;

   127 }

   128 

   129 HRESULT STDMETHODCALLTYPE DOMNode::setNodeValue( 

   130     /* [in] */ BSTR /*value*/)

   131 {

   132     ASSERT_NOT_REACHED();

   133     return E_NOTIMPL;

   134 }

   135 

   136 HRESULT STDMETHODCALLTYPE DOMNode::nodeType( 

   137     /* [retval][out] */ unsigned short* /*result*/)

   138 {

   139     ASSERT_NOT_REACHED();

   140     return E_NOTIMPL;

   141 }

   142 

   143 HRESULT STDMETHODCALLTYPE DOMNode::parentNode( 

   144     /* [retval][out] */ IDOMNode** result)

   145 {

   146     *result = 0;

   147     if (!m_node || !m_node->parentNode())

   148         return E_FAIL;

   149     *result = DOMNode::createInstance(m_node->parentNode());

   150     return *result ? S_OK : E_FAIL;

   151 }

   152 

   153 HRESULT STDMETHODCALLTYPE DOMNode::childNodes( 

   154     /* [retval][out] */ IDOMNodeList** result)

   155 {

   156     if (!m_node)

   157         return E_FAIL;

   158 

   159     if (!result)

   160         return E_POINTER;

   161 

   162     *result = DOMNodeList::createInstance(m_node->childNodes().get());

   163     return *result ? S_OK : E_FAIL;

   164 }

   165 

   166 HRESULT STDMETHODCALLTYPE DOMNode::firstChild( 

   167     /* [retval][out] */ IDOMNode** /*result*/)

   168 {

   169     ASSERT_NOT_REACHED();

   170     return E_NOTIMPL;

   171 }

   172 

   173 HRESULT STDMETHODCALLTYPE DOMNode::lastChild( 

   174     /* [retval][out] */ IDOMNode** /*result*/)

   175 {

   176     ASSERT_NOT_REACHED();

   177     return E_NOTIMPL;

   178 }

   179 

   180 HRESULT STDMETHODCALLTYPE DOMNode::previousSibling( 

   181     /* [retval][out] */ IDOMNode** /*result*/)

   182 {

   183     ASSERT_NOT_REACHED();

   184     return E_NOTIMPL;

   185 }

   186 

   187 HRESULT STDMETHODCALLTYPE DOMNode::nextSibling( 

   188     /* [retval][out] */ IDOMNode** result)

   189 {

   190     if (!result)

   191         return E_POINTER;

   192     *result = 0;

   193     if (!m_node)

   194         return E_FAIL;

   195     *result = DOMNode::createInstance(m_node->nextSibling());

   196     return *result ? S_OK : E_FAIL;

   197 }

   198 

   199 HRESULT STDMETHODCALLTYPE DOMNode::attributes( 

   200     /* [retval][out] */ IDOMNamedNodeMap** /*result*/)

   201 {

   202     ASSERT_NOT_REACHED();

   203     return E_NOTIMPL;

   204 }

   205 

   206 HRESULT STDMETHODCALLTYPE DOMNode::ownerDocument( 

   207     /* [retval][out] */ IDOMDocument** result)

   208 {

   209     if (!result)

   210         return E_POINTER;

   211     *result = 0;

   212     if (!m_node)

   213         return E_FAIL;

   214     *result = DOMDocument::createInstance(m_node->ownerDocument());

   215     return *result ? S_OK : E_FAIL;

   216 }

   217 

   218 HRESULT STDMETHODCALLTYPE DOMNode::insertBefore( 

   219     /* [in] */ IDOMNode* newChild,

   220     /* [in] */ IDOMNode* refChild,

   221     /* [retval][out] */ IDOMNode** result)

   222 {

   223     if (!result)

   224         return E_POINTER;

   225 

   226     *result = 0;

   227 

   228     if (!m_node)

   229         return E_FAIL;

   230 

   231     COMPtr<DOMNode> newChildNode(Query, newChild);

   232     if (!newChildNode)

   233         return E_FAIL;

   234 

   235     COMPtr<DOMNode> refChildNode(Query, refChild);

   236 

   237     ExceptionCode ec;

   238     if (!m_node->insertBefore(newChildNode->node(), refChildNode ? refChildNode->node() : 0, ec))

   239         return E_FAIL;

   240 

   241     *result = newChild;

   242     (*result)->AddRef();

   243     return S_OK;

   244 }

   245 

   246 HRESULT STDMETHODCALLTYPE DOMNode::replaceChild( 

   247     /* [in] */ IDOMNode* /*newChild*/,

   248     /* [in] */ IDOMNode* /*oldChild*/,

   249     /* [retval][out] */ IDOMNode** /*result*/)

   250 {

   251     ASSERT_NOT_REACHED();

   252     return E_NOTIMPL;

   253 }

   254 

   255 HRESULT STDMETHODCALLTYPE DOMNode::removeChild( 

   256     /* [in] */ IDOMNode* oldChild,

   257     /* [retval][out] */ IDOMNode** result)

   258 {

   259     if (!result)

   260         return E_POINTER;

   261 

   262     *result = 0;

   263 

   264     if (!m_node)

   265         return E_FAIL;

   266 

   267     COMPtr<DOMNode> oldChildNode(Query, oldChild);

   268     if (!oldChildNode)

   269         return E_FAIL;

   270 

   271     ExceptionCode ec;

   272     if (!m_node->removeChild(oldChildNode->node(), ec))

   273         return E_FAIL;

   274 

   275     *result = oldChild;

   276     (*result)->AddRef();

   277     return S_OK;

   278 }

   279 

   280 HRESULT STDMETHODCALLTYPE DOMNode::appendChild( 

   281     /* [in] */ IDOMNode* /*oldChild*/,

   282     /* [retval][out] */ IDOMNode** /*result*/)

   283 {

   284     ASSERT_NOT_REACHED();

   285     return E_NOTIMPL;

   286 }

   287 

   288 HRESULT STDMETHODCALLTYPE DOMNode::hasChildNodes( 

   289     /* [retval][out] */ BOOL* /*result*/)

   290 {

   291     ASSERT_NOT_REACHED();

   292     return E_NOTIMPL;

   293 }

   294 

   295 HRESULT STDMETHODCALLTYPE DOMNode::cloneNode( 

   296     /* [in] */ BOOL /*deep*/,

   297     /* [retval][out] */ IDOMNode** /*result*/)

   298 {

   299     ASSERT_NOT_REACHED();

   300     return E_NOTIMPL;

   301 }

   302 

   303 HRESULT STDMETHODCALLTYPE DOMNode::normalize( void)

   304 {

   305     ASSERT_NOT_REACHED();

   306     return E_NOTIMPL;

   307 }

   308 

   309 HRESULT STDMETHODCALLTYPE DOMNode::isSupported( 

   310     /* [in] */ BSTR /*feature*/,

   311     /* [in] */ BSTR /*version*/,

   312     /* [retval][out] */ BOOL* /*result*/)

   313 {

   314     ASSERT_NOT_REACHED();

   315     return E_NOTIMPL;

   316 }

   317 

   318 HRESULT STDMETHODCALLTYPE DOMNode::namespaceURI( 

   319     /* [retval][out] */ BSTR* /*result*/)

   320 {

   321     ASSERT_NOT_REACHED();

   322     return E_NOTIMPL;

   323 }

   324 

   325 HRESULT STDMETHODCALLTYPE DOMNode::prefix( 

   326     /* [retval][out] */ BSTR* /*result*/)

   327 {

   328     ASSERT_NOT_REACHED();

   329     return E_NOTIMPL;

   330 }

   331 

   332 HRESULT STDMETHODCALLTYPE DOMNode::setPrefix( 

   333     /* [in] */ BSTR /*prefix*/)

   334 {

   335     ASSERT_NOT_REACHED();

   336     return E_NOTIMPL;

   337 }

   338 

   339 HRESULT STDMETHODCALLTYPE DOMNode::localName( 

   340     /* [retval][out] */ BSTR* /*result*/)

   341 {

   342     ASSERT_NOT_REACHED();

   343     return E_NOTIMPL;

   344 }

   345 

   346 HRESULT STDMETHODCALLTYPE DOMNode::hasAttributes( 

   347     /* [retval][out] */ BOOL* /*result*/)

   348 {

   349     ASSERT_NOT_REACHED();

   350     return E_NOTIMPL;

   351 }

   352 

   353 HRESULT STDMETHODCALLTYPE DOMNode::isSameNode( 

   354     /* [in] */ IDOMNode* other,

   355     /* [retval][out] */ BOOL* result)

   356 {

   357     if (!result) {

   358         ASSERT_NOT_REACHED();

   359         return E_POINTER;

   360     }

   361 

   362     *result = FALSE;

   363 

   364     if (!other)

   365         return E_POINTER;

   366 

   367     COMPtr<DOMNode> domOther;

   368     HRESULT hr = other->QueryInterface(__uuidof(DOMNode), (void**)&domOther);

   369     if (FAILED(hr))

   370         return hr;

   371 

   372     *result = m_node->isSameNode(domOther->node()) ? TRUE : FALSE;

   373     return S_OK;

   374 }

   375 

   376 HRESULT STDMETHODCALLTYPE DOMNode::isEqualNode( 

   377     /* [in] */ IDOMNode* /*other*/,

   378     /* [retval][out] */ BOOL* /*result*/)

   379 {

   380     ASSERT_NOT_REACHED();

   381     return E_NOTIMPL;

   382 }

   383 

   384 HRESULT STDMETHODCALLTYPE DOMNode::textContent( 

   385     /* [retval][out] */ BSTR* result)

   386 {

   387     if (!result)

   388         return E_POINTER;

   389 

   390     *result = BString(m_node->textContent()).release();

   391 

   392     return S_OK;

   393 }

   394 

   395 HRESULT STDMETHODCALLTYPE DOMNode::setTextContent( 

   396     /* [in] */ BSTR /*text*/)

   397 {

   398     ASSERT_NOT_REACHED();

   399     return E_NOTIMPL;

   400 }

   401 

   402 // DOMNode - IDOMEventTarget --------------------------------------------------

   403 

   404 HRESULT STDMETHODCALLTYPE DOMNode::addEventListener( 

   405     /* [in] */ BSTR /*type*/,

   406     /* [in] */ IDOMEventListener* /*listener*/,

   407     /* [in] */ BOOL /*useCapture*/)

   408 {

   409     return E_NOTIMPL;

   410 }

   411 

   412 HRESULT STDMETHODCALLTYPE DOMNode::removeEventListener( 

   413     /* [in] */ BSTR /*type*/,

   414     /* [in] */ IDOMEventListener* /*listener*/,

   415     /* [in] */ BOOL /*useCapture*/)

   416 {

   417     return E_NOTIMPL;

   418 }

   419 

   420 HRESULT STDMETHODCALLTYPE DOMNode::dispatchEvent( 

   421     /* [in] */ IDOMEvent* evt,

   422     /* [retval][out] */ BOOL* result)

   423 {

   424     if (!m_node || !evt)

   425         return E_FAIL;

   426 

   427 #if 0   // FIXME - raise dom exceptions

   428     if (![self _node]->isEventTargetNode())

   429         WebCore::raiseDOMException(DOM_NOT_SUPPORTED_ERR);

   430 #endif

   431 

   432     COMPtr<DOMEvent> domEvent;

   433     HRESULT hr = evt->QueryInterface(IID_DOMEvent, (void**) &domEvent);

   434     if (FAILED(hr))

   435         return hr;

   436 

   437     WebCore::ExceptionCode ec = 0;

   438     *result = m_node->dispatchEvent(domEvent->coreEvent(), ec) ? TRUE : FALSE;

   439 #if 0   // FIXME - raise dom exceptions

   440     WebCore::raiseOnDOMError(ec);

   441 #endif

   442     return S_OK;

   443 }

   444 

   445 // DOMNode - DOMNode ----------------------------------------------------------

   446 

   447 DOMNode::DOMNode(WebCore::Node* n)

   448 : m_node(0)

   449 {

   450     if (n)

   451         n->ref();

   452 

   453     m_node = n;

   454 }

   455 

   456 DOMNode::~DOMNode()

   457 {

   458     if (m_node)

   459         m_node->deref();

   460 }

   461 

   462 IDOMNode* DOMNode::createInstance(WebCore::Node* n)

   463 {

   464     if (!n)

   465         return 0;

   466 

   467     HRESULT hr = S_OK;

   468     IDOMNode* domNode = 0;

   469     WebCore::Node::NodeType nodeType = n->nodeType();

   470 

   471     switch (nodeType) {

   472         case WebCore::Node::ELEMENT_NODE: 

   473         {

   474             IDOMElement* newElement = DOMElement::createInstance(static_cast<WebCore::Element*>(n));

   475             if (newElement) {

   476                 hr = newElement->QueryInterface(IID_IDOMNode, (void**)&domNode);

   477                 newElement->Release();

   478             }

   479         }

   480         break;

   481         case WebCore::Node::DOCUMENT_NODE:

   482         {

   483             IDOMDocument* newDocument = DOMDocument::createInstance(n->document());

   484             if (newDocument) {

   485                 hr = newDocument->QueryInterface(IID_IDOMNode, (void**)&domNode);

   486                 newDocument->Release();

   487             }

   488         }

   489         break;

   490         default:

   491         {

   492             DOMNode* newNode = new DOMNode(n);

   493             hr = newNode->QueryInterface(IID_IDOMNode, (void**)&domNode);

   494         }

   495         break;

   496     }

   497 

   498     if (FAILED(hr))

   499         return 0;

   500 

   501     return domNode;

   502 }

   503 

   504 // DOMNodeList - IUnknown -----------------------------------------------------

   505 

   506 HRESULT STDMETHODCALLTYPE DOMNodeList::QueryInterface(REFIID riid, void** ppvObject)

   507 {

   508     *ppvObject = 0;

   509     if (IsEqualGUID(riid, IID_IDOMNodeList))

   510         *ppvObject = static_cast<IDOMNodeList*>(this);

   511     else

   512         return DOMObject::QueryInterface(riid, ppvObject);

   513 

   514     AddRef();

   515     return S_OK;

   516 }

   517 

   518 // IDOMNodeList ---------------------------------------------------------------

   519 

   520 HRESULT STDMETHODCALLTYPE DOMNodeList::item( 

   521     /* [in] */ UINT index,

   522     /* [retval][out] */ IDOMNode **result)

   523 {

   524     *result = 0;

   525     if (!m_nodeList)

   526         return E_FAIL;

   527 

   528     WebCore::Node* itemNode = m_nodeList->item(index);

   529     if (!itemNode)

   530         return E_FAIL;

   531 

   532     *result = DOMNode::createInstance(itemNode);

   533     return *result ? S_OK : E_FAIL;

   534 }

   535 

   536 HRESULT STDMETHODCALLTYPE DOMNodeList::length( 

   537         /* [retval][out] */ UINT *result)

   538 {

   539     *result = 0;

   540     if (!m_nodeList)

   541         return E_FAIL;

   542     *result = m_nodeList->length();

   543     return S_OK;

   544 }

   545 

   546 // DOMNodeList - DOMNodeList --------------------------------------------------

   547 

   548 DOMNodeList::DOMNodeList(WebCore::NodeList* l)

   549 : m_nodeList(0)

   550 {

   551     if (l)

   552         l->ref();

   553 

   554     m_nodeList = l;

   555 }

   556 

   557 DOMNodeList::~DOMNodeList()

   558 {

   559     if (m_nodeList)

   560         m_nodeList->deref();

   561 }

   562 

   563 IDOMNodeList* DOMNodeList::createInstance(WebCore::NodeList* l)

   564 {

   565     if (!l)

   566         return 0;

   567 

   568     IDOMNodeList* domNodeList = 0;

   569     DOMNodeList* newNodeList = new DOMNodeList(l);

   570     if (FAILED(newNodeList->QueryInterface(IID_IDOMNodeList, (void**)&domNodeList)))

   571         return 0;

   572 

   573     return domNodeList;

   574 }

   575 

   576 // DOMDocument - IUnknown -----------------------------------------------------

   577 

   578 HRESULT STDMETHODCALLTYPE DOMDocument::QueryInterface(REFIID riid, void** ppvObject)

   579 {

   580     *ppvObject = 0;

   581     if (IsEqualGUID(riid, IID_IDOMDocument))

   582         *ppvObject = static_cast<IDOMDocument*>(this);

   583     else if (IsEqualGUID(riid, IID_IDOMViewCSS))

   584         *ppvObject = static_cast<IDOMViewCSS*>(this);

   585     else if (IsEqualGUID(riid, IID_IDOMDocumentEvent))

   586         *ppvObject = static_cast<IDOMDocumentEvent*>(this);

   587     else

   588         return DOMNode::QueryInterface(riid, ppvObject);

   589 

   590     AddRef();

   591     return S_OK;

   592 }

   593 

   594 // DOMDocument ----------------------------------------------------------------

   595 

   596 HRESULT STDMETHODCALLTYPE DOMDocument::doctype( 

   597     /* [retval][out] */ IDOMDocumentType** /*result*/)

   598 {

   599     ASSERT_NOT_REACHED();

   600     return E_NOTIMPL;

   601 }

   602 

   603 HRESULT STDMETHODCALLTYPE DOMDocument::implementation( 

   604     /* [retval][out] */ IDOMImplementation** /*result*/)

   605 {

   606     ASSERT_NOT_REACHED();

   607     return E_NOTIMPL;

   608 }

   609 

   610 HRESULT STDMETHODCALLTYPE DOMDocument::documentElement( 

   611     /* [retval][out] */ IDOMElement** result)

   612 {

   613     *result = DOMElement::createInstance(m_document->documentElement());

   614     return *result ? S_OK : E_FAIL;

   615 }

   616 

   617 HRESULT STDMETHODCALLTYPE DOMDocument::createElement( 

   618     /* [in] */ BSTR tagName,

   619     /* [retval][out] */ IDOMElement** result)

   620 {

   621     if (!m_document)

   622         return E_FAIL;

   623 

   624     String tagNameString(tagName);

   625     ExceptionCode ec;

   626     *result = DOMElement::createInstance(m_document->createElement(tagNameString, ec).get());

   627     return *result ? S_OK : E_FAIL;

   628 }

   629 

   630 HRESULT STDMETHODCALLTYPE DOMDocument::createDocumentFragment( 

   631     /* [retval][out] */ IDOMDocumentFragment** /*result*/)

   632 {

   633     ASSERT_NOT_REACHED();

   634     return E_NOTIMPL;

   635 }

   636 

   637 HRESULT STDMETHODCALLTYPE DOMDocument::createTextNode( 

   638     /* [in] */ BSTR /*data*/,

   639     /* [retval][out] */ IDOMText** /*result*/)

   640 {

   641     ASSERT_NOT_REACHED();

   642     return E_NOTIMPL;

   643 }

   644 

   645 HRESULT STDMETHODCALLTYPE DOMDocument::createComment( 

   646     /* [in] */ BSTR /*data*/,

   647     /* [retval][out] */ IDOMComment** /*result*/)

   648 {

   649     ASSERT_NOT_REACHED();

   650     return E_NOTIMPL;

   651 }

   652 

   653 HRESULT STDMETHODCALLTYPE DOMDocument::createCDATASection( 

   654     /* [in] */ BSTR /*data*/,

   655     /* [retval][out] */ IDOMCDATASection** /*result*/)

   656 {

   657     ASSERT_NOT_REACHED();

   658     return E_NOTIMPL;

   659 }

   660 

   661 HRESULT STDMETHODCALLTYPE DOMDocument::createProcessingInstruction( 

   662     /* [in] */ BSTR /*target*/,

   663     /* [in] */ BSTR /*data*/,

   664     /* [retval][out] */ IDOMProcessingInstruction** /*result*/)

   665 {

   666     ASSERT_NOT_REACHED();

   667     return E_NOTIMPL;

   668 }

   669 

   670 HRESULT STDMETHODCALLTYPE DOMDocument::createAttribute( 

   671     /* [in] */ BSTR /*name*/,

   672     /* [retval][out] */ IDOMAttr** /*result*/)

   673 {

   674     ASSERT_NOT_REACHED();

   675     return E_NOTIMPL;

   676 }

   677 

   678 HRESULT STDMETHODCALLTYPE DOMDocument::createEntityReference( 

   679     /* [in] */ BSTR /*name*/,

   680     /* [retval][out] */ IDOMEntityReference** /*result*/)

   681 {

   682     ASSERT_NOT_REACHED();

   683     return E_NOTIMPL;

   684 }

   685 

   686 HRESULT STDMETHODCALLTYPE DOMDocument::getElementsByTagName( 

   687     /* [in] */ BSTR tagName,

   688     /* [retval][out] */ IDOMNodeList** result)

   689 {

   690     if (!m_document)

   691         return E_FAIL;

   692 

   693     String tagNameString(tagName);

   694     *result = DOMNodeList::createInstance(m_document->getElementsByTagName(tagNameString).get());

   695     return *result ? S_OK : E_FAIL;

   696 }

   697 

   698 HRESULT STDMETHODCALLTYPE DOMDocument::importNode( 

   699     /* [in] */ IDOMNode* /*importedNode*/,

   700     /* [in] */ BOOL /*deep*/,

   701     /* [retval][out] */ IDOMNode** /*result*/)

   702 {

   703     ASSERT_NOT_REACHED();

   704     return E_NOTIMPL;

   705 }

   706 

   707 HRESULT STDMETHODCALLTYPE DOMDocument::createElementNS( 

   708     /* [in] */ BSTR /*namespaceURI*/,

   709     /* [in] */ BSTR /*qualifiedName*/,

   710     /* [retval][out] */ IDOMElement** /*result*/)

   711 {

   712     ASSERT_NOT_REACHED();

   713     return E_NOTIMPL;

   714 }

   715 

   716 HRESULT STDMETHODCALLTYPE DOMDocument::createAttributeNS( 

   717     /* [in] */ BSTR /*namespaceURI*/,

   718     /* [in] */ BSTR /*qualifiedName*/,

   719     /* [retval][out] */ IDOMAttr** /*result*/)

   720 {

   721     ASSERT_NOT_REACHED();

   722     return E_NOTIMPL;

   723 }

   724 

   725 HRESULT STDMETHODCALLTYPE DOMDocument::getElementsByTagNameNS( 

   726     /* [in] */ BSTR namespaceURI,

   727     /* [in] */ BSTR localName,

   728     /* [retval][out] */ IDOMNodeList** result)

   729 {

   730     if (!m_document)

   731         return E_FAIL;

   732 

   733     String namespaceURIString(namespaceURI);

   734     String localNameString(localName);

   735     *result = DOMNodeList::createInstance(m_document->getElementsByTagNameNS(namespaceURIString, localNameString).get());

   736     return *result ? S_OK : E_FAIL;

   737 }

   738 

   739 HRESULT STDMETHODCALLTYPE DOMDocument::getElementById( 

   740     /* [in] */ BSTR elementId,

   741     /* [retval][out] */ IDOMElement** result)

   742 {

   743     if (!m_document)

   744         return E_FAIL;

   745 

   746     String idString(elementId);

   747     *result = DOMElement::createInstance(m_document->getElementById(idString));

   748     return *result ? S_OK : E_FAIL;

   749 }

   750 

   751 // DOMDocument - IDOMViewCSS --------------------------------------------------

   752 

   753 HRESULT STDMETHODCALLTYPE DOMDocument::getComputedStyle( 

   754     /* [in] */ IDOMElement* elt,

   755     /* [in] */ BSTR pseudoElt,

   756     /* [retval][out] */ IDOMCSSStyleDeclaration** result)

   757 {

   758     if (!elt || !result)

   759         return E_POINTER;

   760 

   761     COMPtr<DOMElement> domEle;

   762     HRESULT hr = elt->QueryInterface(IID_DOMElement, (void**)&domEle);

   763     if (FAILED(hr))

   764         return hr;

   765     Element* element = domEle->element();

   766 

   767     WebCore::DOMWindow* dv = m_document->defaultView();

   768     String pseudoEltString(pseudoElt);

   769     

   770     if (!dv)

   771         return E_FAIL;

   772     

   773     *result = DOMCSSStyleDeclaration::createInstance(dv->getComputedStyle(element, pseudoEltString.impl()).get());

   774     return *result ? S_OK : E_FAIL;

   775 }

   776 

   777 // DOMDocument - IDOMDocumentEvent --------------------------------------------

   778 

   779 HRESULT STDMETHODCALLTYPE DOMDocument::createEvent( 

   780     /* [in] */ BSTR eventType,

   781     /* [retval][out] */ IDOMEvent **result)

   782 {

   783     String eventTypeString(eventType, SysStringLen(eventType));

   784     WebCore::ExceptionCode ec = 0;

   785     *result = DOMEvent::createInstance(m_document->createEvent(eventTypeString, ec));

   786     return *result ? S_OK : E_FAIL;

   787 }

   788 

   789 // DOMDocument - DOMDocument --------------------------------------------------

   790 

   791 DOMDocument::DOMDocument(WebCore::Document* d)

   792 : DOMNode(d)

   793 , m_document(d)

   794 {

   795 }

   796 

   797 DOMDocument::~DOMDocument()

   798 {

   799 }

   800 

   801 IDOMDocument* DOMDocument::createInstance(WebCore::Document* d)

   802 {

   803     if (!d)

   804         return 0;

   805 

   806     HRESULT hr;

   807     IDOMDocument* domDocument = 0;

   808 

   809     if (d->isHTMLDocument()) {

   810         DOMHTMLDocument* newDocument = new DOMHTMLDocument(d);

   811         hr = newDocument->QueryInterface(IID_IDOMDocument, (void**)&domDocument);

   812     } else {

   813         DOMDocument* newDocument = new DOMDocument(d);

   814         hr = newDocument->QueryInterface(IID_IDOMDocument, (void**)&domDocument);

   815     }

   816 

   817     if (FAILED(hr))

   818         return 0;

   819 

   820     return domDocument;

   821 }

   822 

   823 // DOMElement - IUnknown ------------------------------------------------------

   824 

   825 HRESULT STDMETHODCALLTYPE DOMElement::QueryInterface(REFIID riid, void** ppvObject)

   826 {

   827     *ppvObject = 0;

   828     if (IsEqualGUID(riid, IID_IDOMElement))

   829         *ppvObject = static_cast<IDOMElement*>(this);

   830     else if (IsEqualGUID(riid, IID_DOMElement))

   831         *ppvObject = static_cast<DOMElement*>(this);

   832     else if (IsEqualGUID(riid, IID_IDOMElementPrivate))

   833         *ppvObject = static_cast<IDOMElementPrivate*>(this);

   834     else if (IsEqualGUID(riid, IID_IDOMNodeExtensions))

   835         *ppvObject = static_cast<IDOMNodeExtensions*>(this);

   836     else if (IsEqualGUID(riid, IID_IDOMElementCSSInlineStyle))

   837         *ppvObject = static_cast<IDOMElementCSSInlineStyle*>(this);

   838     else if (IsEqualGUID(riid, IID_IDOMElementExtensions))

   839         *ppvObject = static_cast<IDOMElementExtensions*>(this);

   840     else

   841         return DOMNode::QueryInterface(riid, ppvObject);

   842 

   843     AddRef();

   844     return S_OK;

   845 }

   846 

   847 // DOMElement - IDOMNodeExtensions---------------------------------------------

   848 

   849 HRESULT STDMETHODCALLTYPE DOMElement::boundingBox( 

   850     /* [retval][out] */ LPRECT rect)

   851 {

   852     ::SetRectEmpty(rect);

   853 

   854     if (!m_element)

   855         return E_FAIL;

   856 

   857     WebCore::RenderObject *renderer = m_element->renderer();

   858     if (renderer) {

   859         IntRect boundsIntRect = renderer->absoluteBoundingBoxRect();

   860         rect->left = boundsIntRect.x();

   861         rect->top = boundsIntRect.y();

   862         rect->right = boundsIntRect.x() + boundsIntRect.width();

   863         rect->bottom = boundsIntRect.y() + boundsIntRect.height();

   864     }

   865 

   866     return S_OK;

   867 }

   868 

   869 HRESULT STDMETHODCALLTYPE DOMElement::lineBoxRects( 

   870     /* [size_is][in] */ RECT* /*rects*/,

   871     /* [in] */ int /*cRects*/)

   872 {

   873     return E_NOTIMPL;

   874 }

   875 

   876 // IDOMElement ----------------------------------------------------------------

   877 

   878 HRESULT STDMETHODCALLTYPE DOMElement::tagName( 

   879         /* [retval][out] */ BSTR* result)

   880 {

   881     if (!m_element)

   882         return E_FAIL;

   883 

   884     if (!result)

   885         return E_POINTER;

   886 

   887     *result = BString(m_element->tagName()).release();

   888     return S_OK;

   889 }

   890     

   891 HRESULT STDMETHODCALLTYPE DOMElement::getAttribute( 

   892         /* [in] */ BSTR name,

   893         /* [retval][out] */ BSTR* result)

   894 {

   895     if (!m_element)

   896         return E_FAIL;

   897     WebCore::String nameString(name, SysStringLen(name));

   898     WebCore::String& attrValueString = (WebCore::String&) m_element->getAttribute(nameString);

   899     *result = SysAllocStringLen(attrValueString.characters(), attrValueString.length());

   900     if (attrValueString.length() && !*result)

   901         return E_OUTOFMEMORY;

   902     return S_OK;

   903 }

   904     

   905 HRESULT STDMETHODCALLTYPE DOMElement::setAttribute( 

   906         /* [in] */ BSTR name,

   907         /* [in] */ BSTR value)

   908 {

   909     if (!m_element)

   910         return E_FAIL;

   911 

   912     WebCore::String nameString(name, SysStringLen(name));

   913     WebCore::String valueString(value, SysStringLen(value));

   914     WebCore::ExceptionCode ec = 0;

   915     m_element->setAttribute(nameString, valueString, ec);

   916     return ec ? E_FAIL : S_OK;

   917 }

   918     

   919 HRESULT STDMETHODCALLTYPE DOMElement::removeAttribute( 

   920         /* [in] */ BSTR /*name*/)

   921 {

   922     ASSERT_NOT_REACHED();

   923     return E_NOTIMPL;

   924 }

   925     

   926 HRESULT STDMETHODCALLTYPE DOMElement::getAttributeNode( 

   927         /* [in] */ BSTR /*name*/,

   928         /* [retval][out] */ IDOMAttr** /*result*/)

   929 {

   930     ASSERT_NOT_REACHED();

   931     return E_NOTIMPL;

   932 }

   933     

   934 HRESULT STDMETHODCALLTYPE DOMElement::setAttributeNode( 

   935         /* [in] */ IDOMAttr* /*newAttr*/,

   936         /* [retval][out] */ IDOMAttr** /*result*/)

   937 {

   938     ASSERT_NOT_REACHED();

   939     return E_NOTIMPL;

   940 }

   941     

   942 HRESULT STDMETHODCALLTYPE DOMElement::removeAttributeNode( 

   943         /* [in] */ IDOMAttr* /*oldAttr*/,

   944         /* [retval][out] */ IDOMAttr** /*result*/)

   945 {

   946     ASSERT_NOT_REACHED();

   947     return E_NOTIMPL;

   948 }

   949     

   950 HRESULT STDMETHODCALLTYPE DOMElement::getElementsByTagName( 

   951         /* [in] */ BSTR /*name*/,

   952         /* [retval][out] */ IDOMNodeList** /*result*/)

   953 {

   954     ASSERT_NOT_REACHED();

   955     return E_NOTIMPL;

   956 }

   957     

   958 HRESULT STDMETHODCALLTYPE DOMElement::getAttributeNS( 

   959         /* [in] */ BSTR /*namespaceURI*/,

   960         /* [in] */ BSTR /*localName*/,

   961         /* [retval][out] */ BSTR* /*result*/)

   962 {

   963     ASSERT_NOT_REACHED();

   964     return E_NOTIMPL;

   965 }

   966     

   967 HRESULT STDMETHODCALLTYPE DOMElement::setAttributeNS( 

   968         /* [in] */ BSTR /*namespaceURI*/,

   969         /* [in] */ BSTR /*qualifiedName*/,

   970         /* [in] */ BSTR /*value*/)

   971 {

   972     ASSERT_NOT_REACHED();

   973     return E_NOTIMPL;

   974 }

   975     

   976 HRESULT STDMETHODCALLTYPE DOMElement::removeAttributeNS( 

   977         /* [in] */ BSTR /*namespaceURI*/,

   978         /* [in] */ BSTR /*localName*/)

   979 {

   980     ASSERT_NOT_REACHED();

   981     return E_NOTIMPL;

   982 }

   983     

   984 HRESULT STDMETHODCALLTYPE DOMElement::getAttributeNodeNS( 

   985         /* [in] */ BSTR /*namespaceURI*/,

   986         /* [in] */ BSTR /*localName*/,

   987         /* [retval][out] */ IDOMAttr** /*result*/)

   988 {

   989     ASSERT_NOT_REACHED();

   990     return E_NOTIMPL;

   991 }

   992     

   993 HRESULT STDMETHODCALLTYPE DOMElement::setAttributeNodeNS( 

   994         /* [in] */ IDOMAttr* /*newAttr*/,

   995         /* [retval][out] */ IDOMAttr** /*result*/)

   996 {

   997     ASSERT_NOT_REACHED();

   998     return E_NOTIMPL;

   999 }

  1000     

  1001 HRESULT STDMETHODCALLTYPE DOMElement::getElementsByTagNameNS( 

  1002         /* [in] */ BSTR /*namespaceURI*/,

  1003         /* [in] */ BSTR /*localName*/,

  1004         /* [retval][out] */ IDOMNodeList** /*result*/)

  1005 {

  1006     ASSERT_NOT_REACHED();

  1007     return E_NOTIMPL;

  1008 }

  1009     

  1010 HRESULT STDMETHODCALLTYPE DOMElement::hasAttribute( 

  1011         /* [in] */ BSTR /*name*/,

  1012         /* [retval][out] */ BOOL* /*result*/)

  1013 {

  1014     ASSERT_NOT_REACHED();

  1015     return E_NOTIMPL;

  1016 }

  1017     

  1018 HRESULT STDMETHODCALLTYPE DOMElement::hasAttributeNS( 

  1019         /* [in] */ BSTR /*namespaceURI*/,

  1020         /* [in] */ BSTR /*localName*/,

  1021         /* [retval][out] */ BOOL* /*result*/)

  1022 {

  1023     ASSERT_NOT_REACHED();

  1024     return E_NOTIMPL;

  1025 }

  1026 

  1027 HRESULT STDMETHODCALLTYPE DOMElement::focus( void)

  1028 {

  1029     if (!m_element)

  1030         return E_FAIL;

  1031     m_element->focus();

  1032     return S_OK;

  1033 }

  1034 

  1035 HRESULT STDMETHODCALLTYPE DOMElement::blur( void)

  1036 {

  1037     if (!m_element)

  1038         return E_FAIL;

  1039     m_element->blur();

  1040     return S_OK;

  1041 }

  1042 

  1043 // IDOMElementPrivate ---------------------------------------------------------

  1044 

  1045 HRESULT DOMElement::coreElement(void **element)

  1046 {

  1047     if (!m_element)

  1048         return E_FAIL;

  1049     *element = (void*) m_element;

  1050     return S_OK;

  1051 }

  1052 

  1053 HRESULT STDMETHODCALLTYPE DOMElement::isEqual( 

  1054     /* [in] */ IDOMElement *other,

  1055     /* [retval][out] */ BOOL *result)

  1056 {

  1057     *result = FALSE;

  1058 

  1059     if (!other || !result)

  1060         return E_POINTER;

  1061 

  1062     IDOMElementPrivate* otherPriv;

  1063     HRESULT hr = other->QueryInterface(IID_IDOMElementPrivate, (void**) &otherPriv);

  1064     if (FAILED(hr))

  1065         return hr;

  1066     

  1067     void* otherCoreEle;

  1068     hr = otherPriv->coreElement(&otherCoreEle);

  1069     otherPriv->Release();

  1070     if (FAILED(hr))

  1071         return hr;

  1072 

  1073     *result = (otherCoreEle == (void*)m_element) ? TRUE : FALSE;

  1074     return S_OK;

  1075 }

  1076 

  1077 HRESULT STDMETHODCALLTYPE DOMElement::isFocused( 

  1078     /* [retval][out] */ BOOL *result)

  1079 {

  1080     if (!m_element)

  1081         return E_FAIL;

  1082 

  1083     if (m_element->document()->focusedNode() == m_element)

  1084         *result = TRUE;

  1085     else

  1086         *result = FALSE;

  1087 

  1088     return S_OK;

  1089 }

  1090 

  1091 HRESULT STDMETHODCALLTYPE DOMElement::innerText(

  1092     /* [retval][out] */ BSTR* result)

  1093 {

  1094     if (!result) {

  1095         ASSERT_NOT_REACHED();

  1096         return E_POINTER;

  1097     }

  1098 

  1099     if (!m_element) {

  1100         ASSERT_NOT_REACHED();

  1101         return E_FAIL;

  1102     }

  1103 

  1104     *result = BString(m_element->innerText()).release();

  1105     return S_OK;

  1106 }

  1107 

  1108 HRESULT STDMETHODCALLTYPE DOMElement::font(WebFontDescription* webFontDescription)

  1109 {

  1110     if (!webFontDescription) {

  1111         ASSERT_NOT_REACHED();

  1112         return E_POINTER;

  1113     }

  1114 

  1115     ASSERT(m_element);

  1116 

  1117     WebCore::RenderObject* renderer = m_element->renderer();

  1118     if (!renderer)

  1119         return E_FAIL;

  1120 

  1121     FontDescription fontDescription = renderer->style()->font().fontDescription();

  1122     AtomicString family = fontDescription.family().family();

  1123     webFontDescription->family = family.characters();

  1124     webFontDescription->familyLength = family.length();

  1125     webFontDescription->size = fontDescription.computedSize();

  1126     webFontDescription->bold = fontDescription.weight() >= WebCore::FontWeight600;

  1127     webFontDescription->italic = fontDescription.italic();

  1128 

  1129     return S_OK;

  1130 }

  1131 

  1132 HRESULT STDMETHODCALLTYPE DOMElement::renderedImage(HBITMAP* image)

  1133 {

  1134     if (!image) {

  1135         ASSERT_NOT_REACHED();