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 #pragma warning(pop)
52
53 #include <initguid.h>
54 // {3B0C0EFF-478B-4b0b-8290-D2321E08E23E}
55 DEFINE_GUID(IID_DOMElement, 0x3b0c0eff, 0x478b, 0x4b0b, 0x82, 0x90, 0xd2, 0x32, 0x1e, 0x8, 0xe2, 0x3e);
56
57 // Our normal style is just to say "using namespace WebCore" rather than having
58 // individual using directives for each type from that namespace. But
59 // "DOMObject" exists both in the WebCore namespace and unnamespaced in this
60 // file, which leads to ambiguities if we say "using namespace WebCore".
61 using namespace WebCore::HTMLNames;
62 using WebCore::AtomicString;
63 using WebCore::BString;
64 using WebCore::Element;
65 using WebCore::ExceptionCode;
66 using WebCore::FontDescription;
67 using WebCore::Frame;
68 using WebCore::IntRect;
69 using WebCore::String;
70
71 // DOMObject - IUnknown -------------------------------------------------------
72
QueryInterface(REFIID riid,void ** ppvObject)73 HRESULT STDMETHODCALLTYPE DOMObject::QueryInterface(REFIID riid, void** ppvObject)
74 {
75 *ppvObject = 0;
76 if (IsEqualGUID(riid, IID_IDOMObject))
77 *ppvObject = static_cast<IDOMObject*>(this);
78 else
79 return WebScriptObject::QueryInterface(riid, ppvObject);
80
81 AddRef();
82 return S_OK;
83 }
84
85 // DOMNode - IUnknown ---------------------------------------------------------
86
QueryInterface(REFIID riid,void ** ppvObject)87 HRESULT STDMETHODCALLTYPE DOMNode::QueryInterface(REFIID riid, void** ppvObject)
88 {
89 *ppvObject = 0;
90 if (IsEqualGUID(riid, IID_IDOMNode))
91 *ppvObject = static_cast<IDOMNode*>(this);
92 else if (IsEqualGUID(riid, __uuidof(DOMNode)))
93 *ppvObject = static_cast<DOMNode*>(this);
94 else
95 return DOMObject::QueryInterface(riid, ppvObject);
96
97 AddRef();
98 return S_OK;
99 }
100
101 // DOMNode --------------------------------------------------------------------
102
nodeName(BSTR * result)103 HRESULT STDMETHODCALLTYPE DOMNode::nodeName(
104 /* [retval][out] */ BSTR* result)
105 {
106 if (!result)
107 return E_POINTER;
108
109 if (!m_node)
110 return E_FAIL;
111
112 *result = BString(m_node->nodeName()).release();
113 return S_OK;
114 }
115
nodeValue(BSTR * result)116 HRESULT STDMETHODCALLTYPE DOMNode::nodeValue(
117 /* [retval][out] */ BSTR* result)
118 {
119 if (!m_node)
120 return E_FAIL;
121 WebCore::String nodeValueStr = m_node->nodeValue();
122 *result = SysAllocStringLen(nodeValueStr.characters(), nodeValueStr.length());
123 if (nodeValueStr.length() && !*result)
124 return E_OUTOFMEMORY;
125 return S_OK;
126 }
127
setNodeValue(BSTR)128 HRESULT STDMETHODCALLTYPE DOMNode::setNodeValue(
129 /* [in] */ BSTR /*value*/)
130 {
131 ASSERT_NOT_REACHED();
132 return E_NOTIMPL;
133 }
134
nodeType(unsigned short *)135 HRESULT STDMETHODCALLTYPE DOMNode::nodeType(
136 /* [retval][out] */ unsigned short* /*result*/)
137 {
138 ASSERT_NOT_REACHED();
139 return E_NOTIMPL;
140 }
141
parentNode(IDOMNode ** result)142 HRESULT STDMETHODCALLTYPE DOMNode::parentNode(
143 /* [retval][out] */ IDOMNode** result)
144 {
145 *result = 0;
146 if (!m_node || !m_node->parentNode())
147 return E_FAIL;
148 *result = DOMNode::createInstance(m_node->parentNode());
149 return *result ? S_OK : E_FAIL;
150 }
151
childNodes(IDOMNodeList ** result)152 HRESULT STDMETHODCALLTYPE DOMNode::childNodes(
153 /* [retval][out] */ IDOMNodeList** result)
154 {
155 if (!m_node)
156 return E_FAIL;
157
158 if (!result)
159 return E_POINTER;
160
161 *result = DOMNodeList::createInstance(m_node->childNodes().get());
162 return *result ? S_OK : E_FAIL;
163 }
164
firstChild(IDOMNode **)165 HRESULT STDMETHODCALLTYPE DOMNode::firstChild(
166 /* [retval][out] */ IDOMNode** /*result*/)
167 {
168 ASSERT_NOT_REACHED();
169 return E_NOTIMPL;
170 }
171
lastChild(IDOMNode **)172 HRESULT STDMETHODCALLTYPE DOMNode::lastChild(
173 /* [retval][out] */ IDOMNode** /*result*/)
174 {
175 ASSERT_NOT_REACHED();
176 return E_NOTIMPL;
177 }
178
previousSibling(IDOMNode **)179 HRESULT STDMETHODCALLTYPE DOMNode::previousSibling(
180 /* [retval][out] */ IDOMNode** /*result*/)
181 {
182 ASSERT_NOT_REACHED();
183 return E_NOTIMPL;
184 }
185
nextSibling(IDOMNode **)186 HRESULT STDMETHODCALLTYPE DOMNode::nextSibling(
187 /* [retval][out] */ IDOMNode** /*result*/)
188 {
189 ASSERT_NOT_REACHED();
190 return E_NOTIMPL;
191 }
192
attributes(IDOMNamedNodeMap **)193 HRESULT STDMETHODCALLTYPE DOMNode::attributes(
194 /* [retval][out] */ IDOMNamedNodeMap** /*result*/)
195 {
196 ASSERT_NOT_REACHED();
197 return E_NOTIMPL;
198 }
199
ownerDocument(IDOMDocument ** result)200 HRESULT STDMETHODCALLTYPE DOMNode::ownerDocument(
201 /* [retval][out] */ IDOMDocument** result)
202 {
203 if (!result)
204 return E_POINTER;
205 *result = 0;
206 if (!m_node)
207 return E_FAIL;
208 *result = DOMDocument::createInstance(m_node->ownerDocument());
209 return *result ? S_OK : E_FAIL;
210 }
211
insertBefore(IDOMNode *,IDOMNode *,IDOMNode **)212 HRESULT STDMETHODCALLTYPE DOMNode::insertBefore(
213 /* [in] */ IDOMNode* /*newChild*/,
214 /* [in] */ IDOMNode* /*refChild*/,
215 /* [retval][out] */ IDOMNode** /*result*/)
216 {
217 ASSERT_NOT_REACHED();
218 return E_NOTIMPL;
219 }
220
replaceChild(IDOMNode *,IDOMNode *,IDOMNode **)221 HRESULT STDMETHODCALLTYPE DOMNode::replaceChild(
222 /* [in] */ IDOMNode* /*newChild*/,
223 /* [in] */ IDOMNode* /*oldChild*/,
224 /* [retval][out] */ IDOMNode** /*result*/)
225 {
226 ASSERT_NOT_REACHED();
227 return E_NOTIMPL;
228 }
229
removeChild(IDOMNode *,IDOMNode **)230 HRESULT STDMETHODCALLTYPE DOMNode::removeChild(
231 /* [in] */ IDOMNode* /*oldChild*/,
232 /* [retval][out] */ IDOMNode** /*result*/)
233 {
234 ASSERT_NOT_REACHED();
235 return E_NOTIMPL;
236 }
237
appendChild(IDOMNode *,IDOMNode **)238 HRESULT STDMETHODCALLTYPE DOMNode::appendChild(
239 /* [in] */ IDOMNode* /*oldChild*/,
240 /* [retval][out] */ IDOMNode** /*result*/)
241 {
242 ASSERT_NOT_REACHED();
243 return E_NOTIMPL;
244 }
245
hasChildNodes(BOOL *)246 HRESULT STDMETHODCALLTYPE DOMNode::hasChildNodes(
247 /* [retval][out] */ BOOL* /*result*/)
248 {
249 ASSERT_NOT_REACHED();
250 return E_NOTIMPL;
251 }
252
cloneNode(BOOL,IDOMNode **)253 HRESULT STDMETHODCALLTYPE DOMNode::cloneNode(
254 /* [in] */ BOOL /*deep*/,
255 /* [retval][out] */ IDOMNode** /*result*/)
256 {
257 ASSERT_NOT_REACHED();
258 return E_NOTIMPL;
259 }
260
normalize(void)261 HRESULT STDMETHODCALLTYPE DOMNode::normalize( void)
262 {
263 ASSERT_NOT_REACHED();
264 return E_NOTIMPL;
265 }
266
isSupported(BSTR,BSTR,BOOL *)267 HRESULT STDMETHODCALLTYPE DOMNode::isSupported(
268 /* [in] */ BSTR /*feature*/,
269 /* [in] */ BSTR /*version*/,
270 /* [retval][out] */ BOOL* /*result*/)
271 {
272 ASSERT_NOT_REACHED();
273 return E_NOTIMPL;
274 }
275
namespaceURI(BSTR *)276 HRESULT STDMETHODCALLTYPE DOMNode::namespaceURI(
277 /* [retval][out] */ BSTR* /*result*/)
278 {
279 ASSERT_NOT_REACHED();
280 return E_NOTIMPL;
281 }
282
prefix(BSTR *)283 HRESULT STDMETHODCALLTYPE DOMNode::prefix(
284 /* [retval][out] */ BSTR* /*result*/)
285 {
286 ASSERT_NOT_REACHED();
287 return E_NOTIMPL;
288 }
289
setPrefix(BSTR)290 HRESULT STDMETHODCALLTYPE DOMNode::setPrefix(
291 /* [in] */ BSTR /*prefix*/)
292 {
293 ASSERT_NOT_REACHED();
294 return E_NOTIMPL;
295 }
296
localName(BSTR *)297 HRESULT STDMETHODCALLTYPE DOMNode::localName(
298 /* [retval][out] */ BSTR* /*result*/)
299 {
300 ASSERT_NOT_REACHED();
301 return E_NOTIMPL;
302 }
303
hasAttributes(BOOL *)304 HRESULT STDMETHODCALLTYPE DOMNode::hasAttributes(
305 /* [retval][out] */ BOOL* /*result*/)
306 {
307 ASSERT_NOT_REACHED();
308 return E_NOTIMPL;
309 }
310
isSameNode(IDOMNode * other,BOOL * result)311 HRESULT STDMETHODCALLTYPE DOMNode::isSameNode(
312 /* [in] */ IDOMNode* other,
313 /* [retval][out] */ BOOL* result)
314 {
315 if (!result) {
316 ASSERT_NOT_REACHED();
317 return E_POINTER;
318 }
319
320 *result = FALSE;
321
322 if (!other)
323 return E_POINTER;
324
325 COMPtr<DOMNode> domOther;
326 HRESULT hr = other->QueryInterface(__uuidof(DOMNode), (void**)&domOther);
327 if (FAILED(hr))
328 return hr;
329
330 *result = m_node->isSameNode(domOther->node()) ? TRUE : FALSE;
331 return S_OK;
332 }
333
isEqualNode(IDOMNode *,BOOL *)334 HRESULT STDMETHODCALLTYPE DOMNode::isEqualNode(
335 /* [in] */ IDOMNode* /*other*/,
336 /* [retval][out] */ BOOL* /*result*/)
337 {
338 ASSERT_NOT_REACHED();
339 return E_NOTIMPL;
340 }
341
textContent(BSTR * result)342 HRESULT STDMETHODCALLTYPE DOMNode::textContent(
343 /* [retval][out] */ BSTR* result)
344 {
345 if (!result)
346 return E_POINTER;
347
348 *result = BString(m_node->textContent()).release();
349
350 return S_OK;
351 }
352
setTextContent(BSTR)353 HRESULT STDMETHODCALLTYPE DOMNode::setTextContent(
354 /* [in] */ BSTR /*text*/)
355 {
356 ASSERT_NOT_REACHED();
357 return E_NOTIMPL;
358 }
359
360 // DOMNode - IDOMEventTarget --------------------------------------------------
361
addEventListener(BSTR,IDOMEventListener *,BOOL)362 HRESULT STDMETHODCALLTYPE DOMNode::addEventListener(
363 /* [in] */ BSTR /*type*/,
364 /* [in] */ IDOMEventListener* /*listener*/,
365 /* [in] */ BOOL /*useCapture*/)
366 {
367 return E_NOTIMPL;
368 }
369
removeEventListener(BSTR,IDOMEventListener *,BOOL)370 HRESULT STDMETHODCALLTYPE DOMNode::removeEventListener(
371 /* [in] */ BSTR /*type*/,
372 /* [in] */ IDOMEventListener* /*listener*/,
373 /* [in] */ BOOL /*useCapture*/)
374 {
375 return E_NOTIMPL;
376 }
377
dispatchEvent(IDOMEvent * evt,BOOL * result)378 HRESULT STDMETHODCALLTYPE DOMNode::dispatchEvent(
379 /* [in] */ IDOMEvent* evt,
380 /* [retval][out] */ BOOL* result)
381 {
382 if (!m_node || !evt)
383 return E_FAIL;
384
385 #if 0 // FIXME - raise dom exceptions
386 if (![self _node]->isEventTargetNode())
387 WebCore::raiseDOMException(DOM_NOT_SUPPORTED_ERR);
388 #endif
389
390 COMPtr<DOMEvent> domEvent;
391 HRESULT hr = evt->QueryInterface(IID_DOMEvent, (void**) &domEvent);
392 if (FAILED(hr))
393 return hr;
394
395 WebCore::ExceptionCode ec = 0;
396 *result = m_node->dispatchEvent(domEvent->coreEvent(), ec) ? TRUE : FALSE;
397 #if 0 // FIXME - raise dom exceptions
398 WebCore::raiseOnDOMError(ec);
399 #endif
400 return S_OK;
401 }
402
403 // DOMNode - DOMNode ----------------------------------------------------------
404
DOMNode(WebCore::Node * n)405 DOMNode::DOMNode(WebCore::Node* n)
406 : m_node(0)
407 {
408 if (n)
409 n->ref();
410
411 m_node = n;
412 }
413
~DOMNode()414 DOMNode::~DOMNode()
415 {
416 if (m_node)
417 m_node->deref();
418 }
419
createInstance(WebCore::Node * n)420 IDOMNode* DOMNode::createInstance(WebCore::Node* n)
421 {
422 if (!n)
423 return 0;
424
425 HRESULT hr = S_OK;
426 IDOMNode* domNode = 0;
427 WebCore::Node::NodeType nodeType = n->nodeType();
428
429 switch (nodeType) {
430 case WebCore::Node::ELEMENT_NODE:
431 {
432 IDOMElement* newElement = DOMElement::createInstance(static_cast<WebCore::Element*>(n));
433 if (newElement) {
434 hr = newElement->QueryInterface(IID_IDOMNode, (void**)&domNode);
435 newElement->Release();
436 }
437 }
438 break;
439 case WebCore::Node::DOCUMENT_NODE:
440 {
441 IDOMDocument* newDocument = DOMDocument::createInstance(n->document());
442 if (newDocument) {
443 hr = newDocument->QueryInterface(IID_IDOMNode, (void**)&domNode);
444 newDocument->Release();
445 }
446 }
447 break;
448 default:
449 {
450 DOMNode* newNode = new DOMNode(n);
451 hr = newNode->QueryInterface(IID_IDOMNode, (void**)&domNode);
452 }
453 break;
454 }
455
456 if (FAILED(hr))
457 return 0;
458
459 return domNode;
460 }
461
462 // DOMNodeList - IUnknown -----------------------------------------------------
463
QueryInterface(REFIID riid,void ** ppvObject)464 HRESULT STDMETHODCALLTYPE DOMNodeList::QueryInterface(REFIID riid, void** ppvObject)
465 {
466 *ppvObject = 0;
467 if (IsEqualGUID(riid, IID_IDOMNodeList))
468 *ppvObject = static_cast<IDOMNodeList*>(this);
469 else
470 return DOMObject::QueryInterface(riid, ppvObject);
471
472 AddRef();
473 return S_OK;
474 }
475
476 // IDOMNodeList ---------------------------------------------------------------
477
item(UINT index,IDOMNode ** result)478 HRESULT STDMETHODCALLTYPE DOMNodeList::item(
479 /* [in] */ UINT index,
480 /* [retval][out] */ IDOMNode **result)
481 {
482 *result = 0;
483 if (!m_nodeList)
484 return E_FAIL;
485
486 WebCore::Node* itemNode = m_nodeList->item(index);
487 if (!itemNode)
488 return E_FAIL;
489
490 *result = DOMNode::createInstance(itemNode);
491 return *result ? S_OK : E_FAIL;
492 }
493
length(UINT * result)494 HRESULT STDMETHODCALLTYPE DOMNodeList::length(
495 /* [retval][out] */ UINT *result)
496 {
497 *result = 0;
498 if (!m_nodeList)
499 return E_FAIL;
500 *result = m_nodeList->length();
501 return S_OK;
502 }
503
504 // DOMNodeList - DOMNodeList --------------------------------------------------
505
DOMNodeList(WebCore::NodeList * l)506 DOMNodeList::DOMNodeList(WebCore::NodeList* l)
507 : m_nodeList(0)
508 {
509 if (l)
510 l->ref();
511
512 m_nodeList = l;
513 }
514
~DOMNodeList()515 DOMNodeList::~DOMNodeList()
516 {
517 if (m_nodeList)
518 m_nodeList->deref();
519 }
520
createInstance(WebCore::NodeList * l)521 IDOMNodeList* DOMNodeList::createInstance(WebCore::NodeList* l)
522 {
523 if (!l)
524 return 0;
525
526 IDOMNodeList* domNodeList = 0;
527 DOMNodeList* newNodeList = new DOMNodeList(l);
528 if (FAILED(newNodeList->QueryInterface(IID_IDOMNodeList, (void**)&domNodeList)))
529 return 0;
530
531 return domNodeList;
532 }
533
534 // DOMDocument - IUnknown -----------------------------------------------------
535
QueryInterface(REFIID riid,void ** ppvObject)536 HRESULT STDMETHODCALLTYPE DOMDocument::QueryInterface(REFIID riid, void** ppvObject)
537 {
538 *ppvObject = 0;
539 if (IsEqualGUID(riid, IID_IDOMDocument))
540 *ppvObject = static_cast<IDOMDocument*>(this);
541 else if (IsEqualGUID(riid, IID_IDOMViewCSS))
542 *ppvObject = static_cast<IDOMViewCSS*>(this);
543 else if (IsEqualGUID(riid, IID_IDOMDocumentEvent))
544 *ppvObject = static_cast<IDOMDocumentEvent*>(this);
545 else
546 return DOMNode::QueryInterface(riid, ppvObject);
547
548 AddRef();
549 return S_OK;
550 }
551
552 // DOMDocument ----------------------------------------------------------------
553
doctype(IDOMDocumentType **)554 HRESULT STDMETHODCALLTYPE DOMDocument::doctype(
555 /* [retval][out] */ IDOMDocumentType** /*result*/)
556 {
557 ASSERT_NOT_REACHED();
558 return E_NOTIMPL;
559 }
560
implementation(IDOMImplementation **)561 HRESULT STDMETHODCALLTYPE DOMDocument::implementation(
562 /* [retval][out] */ IDOMImplementation** /*result*/)
563 {
564 ASSERT_NOT_REACHED();
565 return E_NOTIMPL;
566 }
567
documentElement(IDOMElement ** result)568 HRESULT STDMETHODCALLTYPE DOMDocument::documentElement(
569 /* [retval][out] */ IDOMElement** result)
570 {
571 *result = DOMElement::createInstance(m_document->documentElement());
572 return *result ? S_OK : E_FAIL;
573 }
574
createElement(BSTR tagName,IDOMElement ** result)575 HRESULT STDMETHODCALLTYPE DOMDocument::createElement(
576 /* [in] */ BSTR tagName,
577 /* [retval][out] */ IDOMElement** result)
578 {
579 if (!m_document)
580 return E_FAIL;
581
582 String tagNameString(tagName);
583 ExceptionCode ec;
584 *result = DOMElement::createInstance(m_document->createElement(tagNameString, ec).get());
585 return *result ? S_OK : E_FAIL;
586 }
587
createDocumentFragment(IDOMDocumentFragment **)588 HRESULT STDMETHODCALLTYPE DOMDocument::createDocumentFragment(
589 /* [retval][out] */ IDOMDocumentFragment** /*result*/)
590 {
591 ASSERT_NOT_REACHED();
592 return E_NOTIMPL;
593 }
594
createTextNode(BSTR,IDOMText **)595 HRESULT STDMETHODCALLTYPE DOMDocument::createTextNode(
596 /* [in] */ BSTR /*data*/,
597 /* [retval][out] */ IDOMText** /*result*/)
598 {
599 ASSERT_NOT_REACHED();
600 return E_NOTIMPL;
601 }
602
createComment(BSTR,IDOMComment **)603 HRESULT STDMETHODCALLTYPE DOMDocument::createComment(
604 /* [in] */ BSTR /*data*/,
605 /* [retval][out] */ IDOMComment** /*result*/)
606 {
607 ASSERT_NOT_REACHED();
608 return E_NOTIMPL;
609 }
610
createCDATASection(BSTR,IDOMCDATASection **)611 HRESULT STDMETHODCALLTYPE DOMDocument::createCDATASection(
612 /* [in] */ BSTR /*data*/,
613 /* [retval][out] */ IDOMCDATASection** /*result*/)
614 {
615 ASSERT_NOT_REACHED();
616 return E_NOTIMPL;
617 }
618
createProcessingInstruction(BSTR,BSTR,IDOMProcessingInstruction **)619 HRESULT STDMETHODCALLTYPE DOMDocument::createProcessingInstruction(
620 /* [in] */ BSTR /*target*/,
621 /* [in] */ BSTR /*data*/,
622 /* [retval][out] */ IDOMProcessingInstruction** /*result*/)
623 {
624 ASSERT_NOT_REACHED();
625 return E_NOTIMPL;
626 }
627
createAttribute(BSTR,IDOMAttr **)628 HRESULT STDMETHODCALLTYPE DOMDocument::createAttribute(
629 /* [in] */ BSTR /*name*/,
630 /* [retval][out] */ IDOMAttr** /*result*/)
631 {
632 ASSERT_NOT_REACHED();
633 return E_NOTIMPL;
634 }
635
createEntityReference(BSTR,IDOMEntityReference **)636 HRESULT STDMETHODCALLTYPE DOMDocument::createEntityReference(
637 /* [in] */ BSTR /*name*/,
638 /* [retval][out] */ IDOMEntityReference** /*result*/)
639 {
640 ASSERT_NOT_REACHED();
641 return E_NOTIMPL;
642 }
643
getElementsByTagName(BSTR tagName,IDOMNodeList ** result)644 HRESULT STDMETHODCALLTYPE DOMDocument::getElementsByTagName(
645 /* [in] */ BSTR tagName,
646 /* [retval][out] */ IDOMNodeList** result)
647 {
648 if (!m_document)
649 return E_FAIL;
650
651 String tagNameString(tagName);
652 *result = DOMNodeList::createInstance(m_document->getElementsByTagName(tagNameString).get());
653 return *result ? S_OK : E_FAIL;
654 }
655
importNode(IDOMNode *,BOOL,IDOMNode **)656 HRESULT STDMETHODCALLTYPE DOMDocument::importNode(
657 /* [in] */ IDOMNode* /*importedNode*/,
658 /* [in] */ BOOL /*deep*/,
659 /* [retval][out] */ IDOMNode** /*result*/)
660 {
661 ASSERT_NOT_REACHED();
662 return E_NOTIMPL;
663 }
664
createElementNS(BSTR,BSTR,IDOMElement **)665 HRESULT STDMETHODCALLTYPE DOMDocument::createElementNS(
666 /* [in] */ BSTR /*namespaceURI*/,
667 /* [in] */ BSTR /*qualifiedName*/,
668 /* [retval][out] */ IDOMElement** /*result*/)
669 {
670 ASSERT_NOT_REACHED();
671 return E_NOTIMPL;
672 }
673
createAttributeNS(BSTR,BSTR,IDOMAttr **)674 HRESULT STDMETHODCALLTYPE DOMDocument::createAttributeNS(
675 /* [in] */ BSTR /*namespaceURI*/,
676 /* [in] */ BSTR /*qualifiedName*/,
677 /* [retval][out] */ IDOMAttr** /*result*/)
678 {
679 ASSERT_NOT_REACHED();
680 return E_NOTIMPL;
681 }
682
getElementsByTagNameNS(BSTR namespaceURI,BSTR localName,IDOMNodeList ** result)683 HRESULT STDMETHODCALLTYPE DOMDocument::getElementsByTagNameNS(
684 /* [in] */ BSTR namespaceURI,
685 /* [in] */ BSTR localName,
686 /* [retval][out] */ IDOMNodeList** result)
687 {
688 if (!m_document)
689 return E_FAIL;
690
691 String namespaceURIString(namespaceURI);
692 String localNameString(localName);
693 *result = DOMNodeList::createInstance(m_document->getElementsByTagNameNS(namespaceURIString, localNameString).get());
694 return *result ? S_OK : E_FAIL;
695 }
696
getElementById(BSTR elementId,IDOMElement ** result)697 HRESULT STDMETHODCALLTYPE DOMDocument::getElementById(
698 /* [in] */ BSTR elementId,
699 /* [retval][out] */ IDOMElement** result)
700 {
701 if (!m_document)
702 return E_FAIL;
703
704 String idString(elementId);
705 *result = DOMElement::createInstance(m_document->getElementById(idString));
706 return *result ? S_OK : E_FAIL;
707 }
708
709 // DOMDocument - IDOMViewCSS --------------------------------------------------
710
getComputedStyle(IDOMElement * elt,BSTR pseudoElt,IDOMCSSStyleDeclaration ** result)711 HRESULT STDMETHODCALLTYPE DOMDocument::getComputedStyle(
712 /* [in] */ IDOMElement* elt,
713 /* [in] */ BSTR pseudoElt,
714 /* [retval][out] */ IDOMCSSStyleDeclaration** result)
715 {
716 if (!elt || !result)
717 return E_POINTER;
718
719 COMPtr<DOMElement> domEle;
720 HRESULT hr = elt->QueryInterface(IID_DOMElement, (void**)&domEle);
721 if (FAILED(hr))
722 return hr;
723 Element* element = domEle->element();
724
725 WebCore::DOMWindow* dv = m_document->defaultView();
726 String pseudoEltString(pseudoElt);
727
728 if (!dv)
729 return E_FAIL;
730
731 *result = DOMCSSStyleDeclaration::createInstance(dv->getComputedStyle(element, pseudoEltString.impl()).get());
732 return *result ? S_OK : E_FAIL;
733 }
734
735 // DOMDocument - IDOMDocumentEvent --------------------------------------------
736
createEvent(BSTR eventType,IDOMEvent ** result)737 HRESULT STDMETHODCALLTYPE DOMDocument::createEvent(
738 /* [in] */ BSTR eventType,
739 /* [retval][out] */ IDOMEvent **result)
740 {
741 String eventTypeString(eventType, SysStringLen(eventType));
742 WebCore::ExceptionCode ec = 0;
743 *result = DOMEvent::createInstance(m_document->createEvent(eventTypeString, ec));
744 return *result ? S_OK : E_FAIL;
745 }
746
747 // DOMDocument - DOMDocument --------------------------------------------------
748
DOMDocument(WebCore::Document * d)749 DOMDocument::DOMDocument(WebCore::Document* d)
750 : DOMNode(d)
751 , m_document(d)
752 {
753 }
754
~DOMDocument()755 DOMDocument::~DOMDocument()
756 {
757 }
758
createInstance(WebCore::Document * d)759 IDOMDocument* DOMDocument::createInstance(WebCore::Document* d)
760 {
761 if (!d)
762 return 0;
763
764 HRESULT hr;
765 IDOMDocument* domDocument = 0;
766
767 if (d->isHTMLDocument()) {
768 DOMHTMLDocument* newDocument = new DOMHTMLDocument(d);
769 hr = newDocument->QueryInterface(IID_IDOMDocument, (void**)&domDocument);
770 } else {
771 DOMDocument* newDocument = new DOMDocument(d);
772 hr = newDocument->QueryInterface(IID_IDOMDocument, (void**)&domDocument);
773 }
774
775 if (FAILED(hr))
776 return 0;
777
778 return domDocument;
779 }
780
781 // DOMElement - IUnknown ------------------------------------------------------
782
QueryInterface(REFIID riid,void ** ppvObject)783 HRESULT STDMETHODCALLTYPE DOMElement::QueryInterface(REFIID riid, void** ppvObject)
784 {
785 *ppvObject = 0;
786 if (IsEqualGUID(riid, IID_IDOMElement))
787 *ppvObject = static_cast<IDOMElement*>(this);
788 else if (IsEqualGUID(riid, IID_DOMElement))
789 *ppvObject = static_cast<DOMElement*>(this);
790 else if (IsEqualGUID(riid, IID_IDOMElementPrivate))
791 *ppvObject = static_cast<IDOMElementPrivate*>(this);
792 else if (IsEqualGUID(riid, IID_IDOMNodeExtensions))
793 *ppvObject = static_cast<IDOMNodeExtensions*>(this);
794 else if (IsEqualGUID(riid, IID_IDOMElementCSSInlineStyle))
795 *ppvObject = static_cast<IDOMElementCSSInlineStyle*>(this);
796 else if (IsEqualGUID(riid, IID_IDOMElementExtensions))
797 *ppvObject = static_cast<IDOMElementExtensions*>(this);
798 else
799 return DOMNode::QueryInterface(riid, ppvObject);
800
801 AddRef();
802 return S_OK;
803 }
804
805 // DOMElement - IDOMNodeExtensions---------------------------------------------
806
boundingBox(LPRECT rect)807 HRESULT STDMETHODCALLTYPE DOMElement::boundingBox(
808 /* [retval][out] */ LPRECT rect)
809 {
810 ::SetRectEmpty(rect);
811
812 if (!m_element)
813 return E_FAIL;
814
815 WebCore::RenderObject *renderer = m_element->renderer();
816 if (renderer) {
817 IntRect boundsIntRect = renderer->absoluteBoundingBoxRect();
818 rect->left = boundsIntRect.x();
819 rect->top = boundsIntRect.y();
820 rect->right = boundsIntRect.x() + boundsIntRect.width();
821 rect->bottom = boundsIntRect.y() + boundsIntRect.height();
822 }
823
824 return S_OK;
825 }
826
lineBoxRects(RECT *,int)827 HRESULT STDMETHODCALLTYPE DOMElement::lineBoxRects(
828 /* [size_is][in] */ RECT* /*rects*/,
829 /* [in] */ int /*cRects*/)
830 {
831 return E_NOTIMPL;
832 }
833
834 // IDOMElement ----------------------------------------------------------------
835
tagName(BSTR * result)836 HRESULT STDMETHODCALLTYPE DOMElement::tagName(
837 /* [retval][out] */ BSTR* result)
838 {
839 if (!m_element)
840 return E_FAIL;
841
842 if (!result)
843 return E_POINTER;
844
845 *result = BString(m_element->tagName()).release();
846 return S_OK;
847 }
848
getAttribute(BSTR name,BSTR * result)849 HRESULT STDMETHODCALLTYPE DOMElement::getAttribute(
850 /* [in] */ BSTR name,
851 /* [retval][out] */ BSTR* result)
852 {
853 if (!m_element)
854 return E_FAIL;
855 WebCore::String nameString(name, SysStringLen(name));
856 WebCore::String& attrValueString = (WebCore::String&) m_element->getAttribute(nameString);
857 *result = SysAllocStringLen(attrValueString.characters(), attrValueString.length());
858 if (attrValueString.length() && !*result)
859 return E_OUTOFMEMORY;
860 return S_OK;
861 }
862
setAttribute(BSTR name,BSTR value)863 HRESULT STDMETHODCALLTYPE DOMElement::setAttribute(
864 /* [in] */ BSTR name,
865 /* [in] */ BSTR value)
866 {
867 if (!m_element)
868 return E_FAIL;
869
870 WebCore::String nameString(name, SysStringLen(name));
871 WebCore::String valueString(value, SysStringLen(value));
872 WebCore::ExceptionCode ec = 0;
873 m_element->setAttribute(nameString, valueString, ec);
874 return ec ? E_FAIL : S_OK;
875 }
876
removeAttribute(BSTR)877 HRESULT STDMETHODCALLTYPE DOMElement::removeAttribute(
878 /* [in] */ BSTR /*name*/)
879 {
880 ASSERT_NOT_REACHED();
881 return E_NOTIMPL;
882 }
883
getAttributeNode(BSTR,IDOMAttr **)884 HRESULT STDMETHODCALLTYPE DOMElement::getAttributeNode(
885 /* [in] */ BSTR /*name*/,
886 /* [retval][out] */ IDOMAttr** /*result*/)
887 {
888 ASSERT_NOT_REACHED();
889 return E_NOTIMPL;
890 }
891
setAttributeNode(IDOMAttr *,IDOMAttr **)892 HRESULT STDMETHODCALLTYPE DOMElement::setAttributeNode(
893 /* [in] */ IDOMAttr* /*newAttr*/,
894 /* [retval][out] */ IDOMAttr** /*result*/)
895 {
896 ASSERT_NOT_REACHED();
897 return E_NOTIMPL;
898 }
899
removeAttributeNode(IDOMAttr *,IDOMAttr **)900 HRESULT STDMETHODCALLTYPE DOMElement::removeAttributeNode(
901 /* [in] */ IDOMAttr* /*oldAttr*/,
902 /* [retval][out] */ IDOMAttr** /*result*/)
903 {
904 ASSERT_NOT_REACHED();
905 return E_NOTIMPL;
906 }
907
getElementsByTagName(BSTR,IDOMNodeList **)908 HRESULT STDMETHODCALLTYPE DOMElement::getElementsByTagName(
909 /* [in] */ BSTR /*name*/,
910 /* [retval][out] */ IDOMNodeList** /*result*/)
911 {
912 ASSERT_NOT_REACHED();
913 return E_NOTIMPL;
914 }
915
getAttributeNS(BSTR,BSTR,BSTR *)916 HRESULT STDMETHODCALLTYPE DOMElement::getAttributeNS(
917 /* [in] */ BSTR /*namespaceURI*/,
918 /* [in] */ BSTR /*localName*/,
919 /* [retval][out] */ BSTR* /*result*/)
920 {
921 ASSERT_NOT_REACHED();
922 return E_NOTIMPL;
923 }
924
setAttributeNS(BSTR,BSTR,BSTR)925 HRESULT STDMETHODCALLTYPE DOMElement::setAttributeNS(
926 /* [in] */ BSTR /*namespaceURI*/,
927 /* [in] */ BSTR /*qualifiedName*/,
928 /* [in] */ BSTR /*value*/)
929 {
930 ASSERT_NOT_REACHED();
931 return E_NOTIMPL;
932 }
933
removeAttributeNS(BSTR,BSTR)934 HRESULT STDMETHODCALLTYPE DOMElement::removeAttributeNS(
935 /* [in] */ BSTR /*namespaceURI*/,
936 /* [in] */ BSTR /*localName*/)
937 {
938 ASSERT_NOT_REACHED();
939 return E_NOTIMPL;
940 }
941
getAttributeNodeNS(BSTR,BSTR,IDOMAttr **)942 HRESULT STDMETHODCALLTYPE DOMElement::getAttributeNodeNS(
943 /* [in] */ BSTR /*namespaceURI*/,
944 /* [in] */ BSTR /*localName*/,
945 /* [retval][out] */ IDOMAttr** /*result*/)
946 {
947 ASSERT_NOT_REACHED();
948 return E_NOTIMPL;
949 }
950
setAttributeNodeNS(IDOMAttr *,IDOMAttr **)951 HRESULT STDMETHODCALLTYPE DOMElement::setAttributeNodeNS(
952 /* [in] */ IDOMAttr* /*newAttr*/,
953 /* [retval][out] */ IDOMAttr** /*result*/)
954 {
955 ASSERT_NOT_REACHED();
956 return E_NOTIMPL;
957 }
958
getElementsByTagNameNS(BSTR,BSTR,IDOMNodeList **)959 HRESULT STDMETHODCALLTYPE DOMElement::getElementsByTagNameNS(
960 /* [in] */ BSTR /*namespaceURI*/,
961 /* [in] */ BSTR /*localName*/,
962 /* [retval][out] */ IDOMNodeList** /*result*/)
963 {
964 ASSERT_NOT_REACHED();
965 return E_NOTIMPL;
966 }
967
hasAttribute(BSTR,BOOL *)968 HRESULT STDMETHODCALLTYPE DOMElement::hasAttribute(
969 /* [in] */ BSTR /*name*/,
970 /* [retval][out] */ BOOL* /*result*/)
971 {
972 ASSERT_NOT_REACHED();
973 return E_NOTIMPL;
974 }
975
hasAttributeNS(BSTR,BSTR,BOOL *)976 HRESULT STDMETHODCALLTYPE DOMElement::hasAttributeNS(
977 /* [in] */ BSTR /*namespaceURI*/,
978 /* [in] */ BSTR /*localName*/,
979 /* [retval][out] */ BOOL* /*result*/)
980 {
981 ASSERT_NOT_REACHED();
982 return E_NOTIMPL;
983 }
984
focus(void)985 HRESULT STDMETHODCALLTYPE DOMElement::focus( void)
986 {
987 if (!m_element)
988 return E_FAIL;
989 m_element->focus();
990 return S_OK;
991 }
992
blur(void)993 HRESULT STDMETHODCALLTYPE DOMElement::blur( void)
994 {
995 if (!m_element)
996 return E_FAIL;
997 m_element->blur();
998 return S_OK;
999 }
1000
1001 // IDOMElementPrivate ---------------------------------------------------------
1002
coreElement(void ** element)1003 HRESULT DOMElement::coreElement(void **element)
1004 {
1005 if (!m_element)
1006 return E_FAIL;
1007 *element = (void*) m_element;
1008 return S_OK;
1009 }
1010
isEqual(IDOMElement * other,BOOL * result)1011 HRESULT STDMETHODCALLTYPE DOMElement::isEqual(
1012 /* [in] */ IDOMElement *other,
1013 /* [retval][out] */ BOOL *result)
1014 {
1015 *result = FALSE;
1016
1017 if (!other || !result)
1018 return E_POINTER;
1019
1020 IDOMElementPrivate* otherPriv;
1021 HRESULT hr = other->QueryInterface(IID_IDOMElementPrivate, (void**) &otherPriv);
1022 if (FAILED(hr))
1023 return hr;
1024
1025 void* otherCoreEle;
1026 hr = otherPriv->coreElement(&otherCoreEle);
1027 otherPriv->Release();
1028 if (FAILED(hr))
1029 return hr;
1030
1031 *result = (otherCoreEle == (void*)m_element) ? TRUE : FALSE;
1032 return S_OK;
1033 }
1034
isFocused(BOOL * result)1035 HRESULT STDMETHODCALLTYPE DOMElement::isFocused(
1036 /* [retval][out] */ BOOL *result)
1037 {
1038 if (!m_element)
1039 return E_FAIL;
1040
1041 if (m_element->document()->focusedNode() == m_element)
1042 *result = TRUE;
1043 else
1044 *result = FALSE;
1045
1046 return S_OK;
1047 }
1048
innerText(BSTR * result)1049 HRESULT STDMETHODCALLTYPE DOMElement::innerText(
1050 /* [retval][out] */ BSTR* result)
1051 {
1052 if (!result) {
1053 ASSERT_NOT_REACHED();
1054 return E_POINTER;
1055 }
1056
1057 if (!m_element) {
1058 ASSERT_NOT_REACHED();
1059 return E_FAIL;
1060 }
1061
1062 *result = BString(m_element->innerText()).release();
1063 return S_OK;
1064 }
1065
font(WebFontDescription * webFontDescription)1066 HRESULT STDMETHODCALLTYPE DOMElement::font(WebFontDescription* webFontDescription)
1067 {
1068 if (!webFontDescription) {
1069 ASSERT_NOT_REACHED();
1070 return E_POINTER;
1071 }
1072
1073 ASSERT(m_element);
1074
1075 WebCore::RenderObject* renderer = m_element->renderer();
1076 if (!renderer)
1077 return E_FAIL;
1078
1079 FontDescription fontDescription = renderer->style()->font().fontDescription();
1080 AtomicString family = fontDescription.family().family();
1081 webFontDescription->family = family.characters();
1082 webFontDescription->familyLength = family.length();
1083 webFontDescription->size = fontDescription.computedSize();
1084 webFontDescription->bold = fontDescription.weight() >= WebCore::FontWeight600;
1085 webFontDescription->italic = fontDescription.italic();
1086
1087 return S_OK;
1088 }
1089
renderedImage(HBITMAP * image)1090 HRESULT STDMETHODCALLTYPE DOMElement::renderedImage(HBITMAP* image)
1091 {
1092 if (!image) {
1093 ASSERT_NOT_REACHED();
1094 return E_POINTER;
1095 }
1096 *image = 0;
1097
1098 ASSERT(m_element);
1099
1100 Frame* frame = m_element->document()->frame();
1101 if (!frame)
1102 return E_FAIL;
1103
1104 *image = frame->nodeImage(m_element);
1105 if (!*image)
1106 return E_FAIL;
1107
1108 return S_OK;
1109 }
1110
1111 // IDOMElementCSSInlineStyle --------------------------------------------------
1112
style(IDOMCSSStyleDeclaration ** result)1113 HRESULT STDMETHODCALLTYPE DOMElement::style(
1114 /* [retval][out] */ IDOMCSSStyleDeclaration** result)
1115 {
1116 if (!result)
1117 return E_POINTER;
1118 if (!m_element)
1119 return E_FAIL;
1120
1121 WebCore::CSSStyleDeclaration* style = m_element->style();
1122 if (!style)
1123 return E_FAIL;
1124
1125 *result = DOMCSSStyleDeclaration::createInstance(style);
1126 return *result ? S_OK : E_FAIL;
1127 }
1128
1129 // IDOMElementExtensions ------------------------------------------------------
1130
offsetLeft(int * result)1131 HRESULT STDMETHODCALLTYPE DOMElement::offsetLeft(
1132 /* [retval][out] */ int* result)
1133 {
1134 if (!m_element)
1135 return E_FAIL;
1136
1137 *result = m_element->offsetLeft();
1138 return S_OK;
1139 }
1140
offsetTop(int * result)1141 HRESULT STDMETHODCALLTYPE DOMElement::offsetTop(
1142 /* [retval][out] */ int* result)
1143 {
1144 if (!m_element)
1145 return E_FAIL;
1146
1147 *result = m_element->offsetTop();
1148 return S_OK;
1149 }
1150
offsetWidth(int * result)1151 HRESULT STDMETHODCALLTYPE DOMElement::offsetWidth(
1152 /* [retval][out] */ int* result)
1153 {
1154 if (!m_element)
1155 return E_FAIL;
1156
1157 *result = m_element->offsetWidth();
1158 return S_OK;
1159 }
1160
offsetHeight(int * result)1161 HRESULT STDMETHODCALLTYPE DOMElement::offsetHeight(
1162 /* [retval][out] */ int* result)
1163 {
1164 if (!m_element)
1165 return E_FAIL;
1166
1167 *result = m_element->offsetHeight();
1168 return S_OK;
1169 }
1170
offsetParent(IDOMElement **)1171 HRESULT STDMETHODCALLTYPE DOMElement::offsetParent(
1172 /* [retval][out] */ IDOMElement** /*result*/)
1173 {
1174 // FIXME
1175 ASSERT_NOT_REACHED();
1176 return E_NOTIMPL;
1177 }
1178
clientWidth(int * result)1179 HRESULT STDMETHODCALLTYPE DOMElement::clientWidth(
1180 /* [retval][out] */ int* result)
1181 {
1182 if (!m_element)
1183 return E_FAIL;
1184
1185 *result = m_element->clientWidth();
1186 return S_OK;
1187 }
1188
clientHeight(int * result)1189 HRESULT STDMETHODCALLTYPE DOMElement::clientHeight(
1190 /* [retval][out] */ int* result)
1191 {
1192 if (!m_element)
1193 return E_FAIL;
1194
1195 *result = m_element->clientHeight();
1196 return S_OK;
1197 }
1198
scrollLeft(int * result)1199 HRESULT STDMETHODCALLTYPE DOMElement::scrollLeft(
1200 /* [retval][out] */ int* result)
1201 {
1202 if (!m_element)
1203 return E_FAIL;
1204
1205 *result = m_element->scrollLeft();
1206 return S_OK;
1207 }
1208
setScrollLeft(int)1209 HRESULT STDMETHODCALLTYPE DOMElement::setScrollLeft(
1210 /* [in] */ int /*newScrollLeft*/)
1211 {
1212 // FIXME
1213 ASSERT_NOT_REACHED();
1214 return E_NOTIMPL;
1215 }
1216
scrollTop(int * result)1217 HRESULT STDMETHODCALLTYPE DOMElement::scrollTop(
1218 /* [retval][out] */ int* result)
1219 {
1220 if (!m_element)
1221 return E_FAIL;
1222
1223 *result = m_element->scrollTop();
1224 return S_OK;
1225 }
1226
setScrollTop(int)1227 HRESULT STDMETHODCALLTYPE DOMElement::setScrollTop(
1228 /* [in] */ int /*newScrollTop*/)
1229 {
1230 // FIXME
1231 ASSERT_NOT_REACHED();
1232 return E_NOTIMPL;
1233 }
1234
scrollWidth(int * result)1235 HRESULT STDMETHODCALLTYPE DOMElement::scrollWidth(
1236 /* [retval][out] */ int* result)
1237 {
1238 if (!m_element)
1239 return E_FAIL;
1240
1241 *result = m_element->scrollWidth();
1242 return S_OK;
1243 }
1244
scrollHeight(int * result)1245 HRESULT STDMETHODCALLTYPE DOMElement::scrollHeight(
1246 /* [retval][out] */ int* result)
1247 {
1248 if (!m_element)
1249 return E_FAIL;
1250
1251 *result = m_element->scrollHeight();
1252 return S_OK;
1253 }
1254
scrollIntoView(BOOL alignWithTop)1255 HRESULT STDMETHODCALLTYPE DOMElement::scrollIntoView(
1256 /* [in] */ BOOL alignWithTop)
1257 {
1258 if (!m_element)
1259 return E_FAIL;
1260
1261 m_element->scrollIntoView(!!alignWithTop);
1262 return S_OK;
1263 }
1264
scrollIntoViewIfNeeded(BOOL centerIfNeeded)1265 HRESULT STDMETHODCALLTYPE DOMElement::scrollIntoViewIfNeeded(
1266 /* [in] */ BOOL centerIfNeeded)
1267 {
1268 if (!m_element)
1269 return E_FAIL;
1270
1271 m_element->scrollIntoViewIfNeeded(!!centerIfNeeded);
1272 return S_OK;
1273 }
1274
1275 // DOMElement -----------------------------------------------------------------
1276
DOMElement(WebCore::Element * e)1277 DOMElement::DOMElement(WebCore::Element* e)
1278 : DOMNode(e)
1279 , m_element(e)
1280 {
1281 }
1282
~DOMElement()1283 DOMElement::~DOMElement()
1284 {
1285 }
1286
createInstance(WebCore::Element * e)1287 IDOMElement* DOMElement::createInstance(WebCore::Element* e)
1288 {
1289 if (!e)
1290 return 0;
1291
1292 HRESULT hr;
1293 IDOMElement* domElement = 0;
1294
1295 if (e->hasTagName(formTag)) {
1296 DOMHTMLFormElement* newElement = new DOMHTMLFormElement(e);
1297 hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement);
1298 } else if (e->hasTagName(selectTag)) {
1299 DOMHTMLSelectElement* newElement = new DOMHTMLSelectElement(e);
1300 hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement);
1301 } else if (e->hasTagName(optionTag)) {
1302 DOMHTMLOptionElement* newElement = new DOMHTMLOptionElement(e);
1303 hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement);
1304 } else if (e->hasTagName(inputTag)) {
1305 DOMHTMLInputElement* newElement = new DOMHTMLInputElement(e);
1306 hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement);
1307 } else if (e->hasTagName(textareaTag)) {
1308 DOMHTMLTextAreaElement* newElement = new DOMHTMLTextAreaElement(e);
1309 hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement);
1310 } else if (e->isHTMLElement()) {
1311 DOMHTMLElement* newElement = new DOMHTMLElement(e);
1312 hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement);
1313 } else {
1314 DOMElement* newElement = new DOMElement(e);
1315 hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement);
1316 }
1317
1318 if (FAILED(hr))
1319 return 0;
1320
1321 return domElement;
1322 }
1323