0286cbf2088bb1e9989af21ea12f36505968e312
[WebKit-https.git] / WebCore / bindings / objc / DOM.mm
1 /*
2  * Copyright (C) 2004-2006 Apple Computer, Inc.  All rights reserved.
3  * Copyright (C) 2006 James G. Speth (speth@end.com)
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #import "config.h"
28 #import "DOM.h"
29
30 #import "CDATASection.h"
31 #import "csshelper.h"
32 #import "CSSStyleSheet.h"
33 #import "Comment.h"
34 #import "DOMEventsInternal.h"
35 #import "DOMImplementationFront.h"
36 #import "DOMInternal.h"
37 #import "DOMPrivate.h"
38 #import "Document.h"
39 #import "DocumentFragment.h"
40 #import "DocumentType.h"
41 #import "Entity.h"
42 #import "EntityReference.h"
43 #import "Event.h"
44 #import "EventListener.h"
45 #import "FoundationExtras.h"
46 #import "FrameMac.h"
47 #import "HTMLDocument.h"
48 #import "HTMLNames.h"
49 #import "HTMLPlugInElement.h"
50 #import "NodeFilter.h"
51 #import "NodeFilterCondition.h"
52 #import "NodeIterator.h"
53 #import "NodeList.h"
54 #import "Notation.h"
55 #import "ProcessingInstruction.h"
56 #import "QualifiedName.h"
57 #import "Range.h"
58 #import "RenderImage.h"
59 #import "TreeWalker.h"
60 #import "WebScriptObjectPrivate.h"
61 #import <objc/objc-class.h>
62
63 using WebCore::AtomicString;
64 using WebCore::AtomicStringImpl;
65 using WebCore::Attr;
66 using WebCore::CharacterData;
67 using WebCore::DeprecatedValueList;
68 using WebCore::Document;
69 using WebCore::DocumentFragment;
70 using WebCore::DocumentType;
71 using WebCore::DOMImplementationFront;
72 using WebCore::Element;
73 using WebCore::Entity;
74 using WebCore::Event;
75 using WebCore::EventListener;
76 using WebCore::ExceptionCode;
77 using WebCore::HTMLDocument;
78 using WebCore::HTMLElement;
79 using WebCore::FrameMac;
80 using WebCore::IntRect;
81 using WebCore::KURL;
82 using WebCore::NamedNodeMap;
83 using WebCore::Node;
84 using WebCore::NodeFilter;
85 using WebCore::NodeFilterCondition;
86 using WebCore::NodeIterator;
87 using WebCore::NodeList;
88 using WebCore::Notation;
89 using WebCore::ProcessingInstruction;
90 using WebCore::QualifiedName;
91 using WebCore::Range;
92 using WebCore::RenderImage;
93 using WebCore::RenderObject;
94 using WebCore::String;
95 using WebCore::Text;
96 using WebCore::TreeWalker;
97
98 using namespace WebCore::HTMLNames;
99
100 @interface DOMAttr (WebCoreInternal)
101 + (DOMAttr *)_attrWith:(Attr *)impl;
102 - (Attr *)_attr;
103 @end
104
105 @interface DOMDocumentType (WebCoreInternal)
106 - (DocumentType *)_documentType;
107 @end
108
109 @interface DOMImplementation (WebCoreInternal)
110 + (DOMImplementation *)_DOMImplementationWith:(DOMImplementationFront *)impl;
111 - (DOMImplementationFront *)_DOMImplementation;
112 @end
113
114 class ObjCEventListener : public EventListener {
115 public:
116     static ObjCEventListener *find(id <DOMEventListener>);
117     static ObjCEventListener *create(id <DOMEventListener>);
118
119 private:
120     ObjCEventListener(id <DOMEventListener>);
121     virtual ~ObjCEventListener();
122
123     virtual void handleEvent(Event *, bool isWindowEvent);
124
125     id <DOMEventListener> m_listener;
126 };
127
128 typedef HashMap<id, ObjCEventListener*> ListenerMap;
129 typedef HashMap<AtomicStringImpl*, Class> ObjCClassMap;
130
131 static ObjCClassMap* elementClassMap;
132 static ListenerMap* listenerMap;
133
134 //------------------------------------------------------------------------------------------
135 // DOMObject
136
137 @implementation DOMObject
138
139 // Prevent creation of DOM objects by clients who just "[[xxx alloc] init]".
140 - (id)init
141 {
142     [NSException raise:NSGenericException format:@"+[%@ init]: should never be used", NSStringFromClass([self class])];
143     [self release];
144     return nil;
145 }
146
147 - (void)dealloc
148 {
149     if (_internal) {
150         removeDOMWrapper(_internal);
151     }
152     [super dealloc];
153 }
154
155 - (void)finalize
156 {
157     if (_internal) {
158         removeDOMWrapper(_internal);
159     }
160     [super finalize];
161 }
162
163 - (id)copyWithZone:(NSZone *)zone
164 {
165     return [self retain];
166 }
167
168 @end
169
170 @implementation DOMObject (WebCoreInternal)
171
172 - (id)_init
173 {
174     return [super _init];
175 }
176
177 @end
178
179 //------------------------------------------------------------------------------------------
180 // DOMNode
181
182 @implementation DOMNode
183
184 - (void)dealloc
185 {
186     if (_internal) {
187         DOM_cast<Node *>(_internal)->deref();
188     }
189     [super dealloc];
190 }
191
192 - (void)finalize
193 {
194     if (_internal) {
195         DOM_cast<Node *>(_internal)->deref();
196     }
197     [super finalize];
198 }
199
200 - (NSString *)description
201 {
202     if (!_internal) {
203         return [NSString stringWithFormat:@"<%@: null>",
204             [[self class] description], self];
205     }
206     NSString *value = [self nodeValue];
207     if (value) {
208         return [NSString stringWithFormat:@"<%@ [%@]: %p '%@'>",
209             [[self class] description], [self nodeName], _internal, value];
210     }
211     return [NSString stringWithFormat:@"<%@ [%@]: %p>",
212         [[self class] description], [self nodeName], _internal];
213 }
214
215 - (NSString *)nodeName
216 {
217     return [self _node]->nodeName();
218 }
219
220 - (NSString *)nodeValue
221 {
222     // Documentation says we can raise a DOMSTRING_SIZE_ERR.
223     // However, the lower layer does not report that error up to us.
224     return [self _node]->nodeValue();
225 }
226
227 - (void)setNodeValue:(NSString *)string
228 {
229     ASSERT(string);
230     
231     ExceptionCode ec = 0;
232     [self _node]->setNodeValue(string, ec);
233     raiseOnDOMError(ec);
234 }
235
236 - (unsigned short)nodeType
237 {
238     return [self _node]->nodeType();
239 }
240
241 - (DOMNode *)parentNode
242 {
243     return [DOMNode _nodeWith:[self _node]->parentNode()];
244 }
245
246 - (DOMNodeList *)childNodes
247 {
248     return [DOMNodeList _nodeListWith:[self _node]->childNodes().get()];
249 }
250
251 - (DOMNode *)firstChild
252 {
253     return [DOMNode _nodeWith:[self _node]->firstChild()];
254 }
255
256 - (DOMNode *)lastChild
257 {
258     return [DOMNode _nodeWith:[self _node]->lastChild()];
259 }
260
261 - (DOMNode *)previousSibling
262 {
263     return [DOMNode _nodeWith:[self _node]->previousSibling()];
264 }
265
266 - (DOMNode *)nextSibling
267 {
268     return [DOMNode _nodeWith:[self _node]->nextSibling()];
269 }
270
271 - (DOMNamedNodeMap *)attributes
272 {
273     // DOM level 2 core specification says: 
274     // A NamedNodeMap containing the attributes of this node (if it is an Element) or null otherwise.
275     return nil;
276 }
277
278 - (DOMDocument *)ownerDocument
279 {
280     return [DOMDocument _documentWith:[self _node]->document()];
281 }
282
283 - (DOMNode *)insertBefore:(DOMNode *)newChild :(DOMNode *)refChild
284 {
285     ASSERT(newChild);
286     ASSERT(refChild);
287
288     ExceptionCode ec = 0;
289     if ([self _node]->insertBefore([newChild _node], [refChild _node], ec))
290         return newChild;
291     raiseOnDOMError(ec);
292     return nil;
293 }
294
295 - (DOMNode *)replaceChild:(DOMNode *)newChild :(DOMNode *)oldChild
296 {
297     ASSERT(newChild);
298     ASSERT(oldChild);
299
300     ExceptionCode ec = 0;
301     if ([self _node]->replaceChild([newChild _node], [oldChild _node], ec))
302         return oldChild;
303     raiseOnDOMError(ec);
304     return nil;
305 }
306
307 - (DOMNode *)removeChild:(DOMNode *)oldChild
308 {
309     ASSERT(oldChild);
310
311     ExceptionCode ec = 0;
312     if ([self _node]->removeChild([oldChild _node], ec))
313         return oldChild;
314     raiseOnDOMError(ec);
315     return nil;
316 }
317
318 - (DOMNode *)appendChild:(DOMNode *)newChild
319 {
320     ASSERT(newChild);
321
322     ExceptionCode ec = 0;
323     if ([self _node]->appendChild([newChild _node], ec))
324         return newChild;
325     raiseOnDOMError(ec);
326     return nil;
327 }
328
329 - (BOOL)hasChildNodes
330 {
331     return [self _node]->hasChildNodes();
332 }
333
334 - (DOMNode *)cloneNode:(BOOL)deep
335 {
336     return [DOMNode _nodeWith:[self _node]->cloneNode(deep).get()];
337 }
338
339 - (void)normalize
340 {
341     [self _node]->normalize();
342 }
343
344 - (BOOL)isSupported:(NSString *)feature :(NSString *)version
345 {
346     ASSERT(feature);
347     ASSERT(version);
348
349     return [self _node]->isSupported(feature, version);
350 }
351
352 - (NSString *)namespaceURI
353 {
354     return [self _node]->namespaceURI();
355 }
356
357 - (NSString *)prefix
358 {
359     return [self _node]->prefix();
360 }
361
362 - (void)setPrefix:(NSString *)prefix
363 {
364     ASSERT(prefix);
365
366     ExceptionCode ec = 0;
367     String prefixStr(prefix);
368     [self _node]->setPrefix(prefixStr.impl(), ec);
369     raiseOnDOMError(ec);
370 }
371
372 - (NSString *)localName
373 {
374     return [self _node]->localName();
375 }
376
377 - (BOOL)hasAttributes
378 {
379     return [self _node]->hasAttributes();
380 }
381
382 - (BOOL)isSameNode:(DOMNode *)other
383 {
384     return [self _node]->isSameNode([other _node]);
385 }
386
387 - (BOOL)isEqualNode:(DOMNode *)other
388 {
389     return [self _node]->isEqualNode([other _node]);
390 }
391
392 - (BOOL)isDefaultNamespace:(NSString *)namespaceURI
393 {
394     return [self _node]->isDefaultNamespace(namespaceURI);
395 }
396
397 - (NSString *)lookupPrefix:(NSString *)namespaceURI
398 {
399     return [self _node]->lookupPrefix(namespaceURI);
400 }
401
402 - (NSString *)lookupNamespaceURI:(NSString *)prefix
403 {
404     return [self _node]->lookupNamespaceURI(prefix);
405 }
406
407 - (NSString *)textContent
408 {
409     return [self _node]->textContent();
410 }
411
412 - (void)setTextContent:(NSString *)text
413 {
414     ExceptionCode ec = 0;
415     [self _node]->setTextContent(text, ec);
416     raiseOnDOMError(ec);
417 }
418
419 - (NSRect)boundingBox
420 {
421     WebCore::RenderObject *renderer = [self _node]->renderer();
422     if (renderer)
423         return renderer->absoluteBoundingBoxRect();
424     return NSZeroRect;
425 }
426
427 - (NSArray *)lineBoxRects
428 {
429     WebCore::RenderObject *renderer = [self _node]->renderer();
430     if (renderer) {
431         NSMutableArray *results = [[NSMutableArray alloc] init];
432         DeprecatedValueList<IntRect> rects = renderer->lineBoxRects();
433         if (!rects.isEmpty()) {
434             for (DeprecatedValueList<IntRect>::ConstIterator it = rects.begin(); it != rects.end(); ++it)
435                 [results addObject:[NSValue valueWithRect:*it]];
436         }
437         return [results autorelease];
438     }
439     return nil;
440 }
441
442 @end
443
444 static void addElementClass(const QualifiedName& tag, Class objCClass)
445 {
446     elementClassMap->set(tag.localName().impl(), objCClass);
447 }
448
449 static void createHTMLElementClassMap()
450 {
451     // Create the table.
452     elementClassMap = new ObjCClassMap;
453     
454     // Populate it with HTML element classes.
455     addElementClass(aTag, [DOMHTMLAnchorElement class]);
456     addElementClass(appletTag, [DOMHTMLAppletElement class]);
457     addElementClass(areaTag, [DOMHTMLAreaElement class]);
458     addElementClass(baseTag, [DOMHTMLBaseElement class]);
459     addElementClass(basefontTag, [DOMHTMLBaseFontElement class]);
460     addElementClass(bodyTag, [DOMHTMLBodyElement class]);
461     addElementClass(brTag, [DOMHTMLBRElement class]);
462     addElementClass(buttonTag, [DOMHTMLButtonElement class]);
463     addElementClass(canvasTag, [DOMHTMLImageElement class]);
464     addElementClass(captionTag, [DOMHTMLTableCaptionElement class]);
465     addElementClass(colTag, [DOMHTMLTableColElement class]);
466     addElementClass(colgroupTag, [DOMHTMLTableColElement class]);
467     addElementClass(dirTag, [DOMHTMLDirectoryElement class]);
468     addElementClass(divTag, [DOMHTMLDivElement class]);
469     addElementClass(dlTag, [DOMHTMLDListElement class]);
470     addElementClass(fieldsetTag, [DOMHTMLFieldSetElement class]);
471     addElementClass(fontTag, [DOMHTMLFontElement class]);
472     addElementClass(formTag, [DOMHTMLFormElement class]);
473     addElementClass(frameTag, [DOMHTMLFrameElement class]);
474     addElementClass(framesetTag, [DOMHTMLFrameSetElement class]);
475     addElementClass(h1Tag, [DOMHTMLHeadingElement class]);
476     addElementClass(h2Tag, [DOMHTMLHeadingElement class]);
477     addElementClass(h3Tag, [DOMHTMLHeadingElement class]);
478     addElementClass(h4Tag, [DOMHTMLHeadingElement class]);
479     addElementClass(h5Tag, [DOMHTMLHeadingElement class]);
480     addElementClass(h6Tag, [DOMHTMLHeadingElement class]);
481     addElementClass(headTag, [DOMHTMLHeadElement class]);
482     addElementClass(hrTag, [DOMHTMLHRElement class]);
483     addElementClass(htmlTag, [DOMHTMLHtmlElement class]);
484     addElementClass(iframeTag, [DOMHTMLIFrameElement class]);
485     addElementClass(imgTag, [DOMHTMLImageElement class]);
486     addElementClass(inputTag, [DOMHTMLInputElement class]);
487     addElementClass(isindexTag, [DOMHTMLIsIndexElement class]);
488     addElementClass(labelTag, [DOMHTMLLabelElement class]);
489     addElementClass(legendTag, [DOMHTMLLegendElement class]);
490     addElementClass(liTag, [DOMHTMLLIElement class]);
491     addElementClass(linkTag, [DOMHTMLLinkElement class]);
492     addElementClass(listingTag, [DOMHTMLPreElement class]);
493     addElementClass(mapTag, [DOMHTMLMapElement class]);
494     addElementClass(menuTag, [DOMHTMLMenuElement class]);
495     addElementClass(metaTag, [DOMHTMLMetaElement class]);
496     addElementClass(objectTag, [DOMHTMLObjectElement class]);
497     addElementClass(olTag, [DOMHTMLOListElement class]);
498     addElementClass(optgroupTag, [DOMHTMLOptGroupElement class]);
499     addElementClass(optionTag, [DOMHTMLOptionElement class]);
500     addElementClass(pTag, [DOMHTMLParagraphElement class]);
501     addElementClass(paramTag, [DOMHTMLParamElement class]);
502     addElementClass(preTag, [DOMHTMLPreElement class]);
503     addElementClass(qTag, [DOMHTMLQuoteElement class]);
504     addElementClass(scriptTag, [DOMHTMLScriptElement class]);
505     addElementClass(selectTag, [DOMHTMLSelectElement class]);
506     addElementClass(styleTag, [DOMHTMLStyleElement class]);
507     addElementClass(tableTag, [DOMHTMLTableElement class]);
508     addElementClass(tbodyTag, [DOMHTMLTableSectionElement class]);
509     addElementClass(tdTag, [DOMHTMLTableCellElement class]);
510     addElementClass(textareaTag, [DOMHTMLTextAreaElement class]);
511     addElementClass(tfootTag, [DOMHTMLTableSectionElement class]);
512     addElementClass(theadTag, [DOMHTMLTableSectionElement class]);
513     addElementClass(titleTag, [DOMHTMLTitleElement class]);
514     addElementClass(trTag, [DOMHTMLTableRowElement class]);
515     addElementClass(ulTag, [DOMHTMLUListElement class]);
516
517     // FIXME: Reflect marquee once the API has been determined.
518 }
519
520 static Class elementClass(const AtomicString& tagName)
521 {
522     if (!elementClassMap)
523         createHTMLElementClassMap();
524     Class objcClass = elementClassMap->get(tagName.impl());
525     if (!objcClass)
526         objcClass = [DOMHTMLElement class];
527     return objcClass;
528 }
529
530 @implementation DOMNode (WebCoreInternal)
531
532 - (id)_initWithNode:(Node *)impl
533 {
534     ASSERT(impl);
535
536     [super _init];
537     _internal = DOM_cast<DOMObjectInternal *>(impl);
538     impl->ref();
539     addDOMWrapper(self, impl);
540     return self;
541 }
542
543 + (DOMNode *)_nodeWith:(Node *)impl
544 {
545     if (!impl)
546         return nil;
547     
548     id cachedInstance;
549     cachedInstance = getDOMWrapper(impl);
550     if (cachedInstance)
551         return [[cachedInstance retain] autorelease];
552     
553     Class wrapperClass = nil;
554     switch (impl->nodeType()) {
555         case Node::ELEMENT_NODE:
556             if (impl->isHTMLElement())
557                 wrapperClass = elementClass(static_cast<HTMLElement*>(impl)->localName());
558             else
559                 wrapperClass = [DOMElement class];
560             break;
561         case Node::ATTRIBUTE_NODE:
562             wrapperClass = [DOMAttr class];
563             break;
564         case Node::TEXT_NODE:
565             wrapperClass = [DOMText class];
566             break;
567         case Node::CDATA_SECTION_NODE:
568             wrapperClass = [DOMCDATASection class];
569             break;
570         case Node::ENTITY_REFERENCE_NODE:
571             wrapperClass = [DOMEntityReference class];
572             break;
573         case Node::ENTITY_NODE:
574             wrapperClass = [DOMEntity class];
575             break;
576         case Node::PROCESSING_INSTRUCTION_NODE:
577             wrapperClass = [DOMProcessingInstruction class];
578             break;
579         case Node::COMMENT_NODE:
580             wrapperClass = [DOMComment class];
581             break;
582         case Node::DOCUMENT_NODE:
583             if (static_cast<Document*>(impl)->isHTMLDocument())
584                 wrapperClass = [DOMHTMLDocument class];
585             else
586                 wrapperClass = [DOMDocument class];
587             break;
588         case Node::DOCUMENT_TYPE_NODE:
589             wrapperClass = [DOMDocumentType class];
590             break;
591         case Node::DOCUMENT_FRAGMENT_NODE:
592             wrapperClass = [DOMDocumentFragment class];
593             break;
594         case Node::NOTATION_NODE:
595             wrapperClass = [DOMNotation class];
596             break;
597         case Node::XPATH_NAMESPACE_NODE:
598             // FIXME: Create an XPath objective C wrapper
599             // See http://bugzilla.opendarwin.org/show_bug.cgi?id=8755
600             return nil;
601     }
602     return [[[wrapperClass alloc] _initWithNode:impl] autorelease];
603 }
604
605 - (Node *)_node
606 {
607     return DOM_cast<Node *>(_internal);
608 }
609
610 - (const KJS::Bindings::RootObject *)_executionContext
611 {
612     if (Node *n = [self _node])
613         if (FrameMac *f = Mac(n->document()->frame()))
614             return f->executionContextForDOM();
615
616     return 0;
617 }
618
619 @end
620
621 @implementation DOMNode (WebPrivate)
622
623 - (BOOL)isContentEditable
624 {
625     return [self _node]->isContentEditable();
626 }
627
628 @end
629
630 @implementation DOMNode (DOMEventTarget)
631
632 - (void)addEventListener:(NSString *)type :(id <DOMEventListener>)listener :(BOOL)useCapture
633 {
634     if (![self _node]->isEventTargetNode())
635         raiseDOMException(DOM_NOT_SUPPORTED_ERR);
636     
637     EventListener *wrapper = ObjCEventListener::create(listener);
638     EventTargetNodeCast([self _node])->addEventListener(type, wrapper, useCapture);
639     wrapper->deref();
640 }
641
642 - (void)removeEventListener:(NSString *)type :(id <DOMEventListener>)listener :(BOOL)useCapture
643 {
644     if (![self _node]->isEventTargetNode())
645         raiseDOMException(DOM_NOT_SUPPORTED_ERR);
646
647     if (EventListener *wrapper = ObjCEventListener::find(listener))
648         EventTargetNodeCast([self _node])->removeEventListener(type, wrapper, useCapture);
649 }
650
651 - (BOOL)dispatchEvent:(DOMEvent *)event
652 {
653     if (![self _node]->isEventTargetNode())
654         raiseDOMException(DOM_NOT_SUPPORTED_ERR);
655
656     ExceptionCode ec = 0;
657     BOOL result = EventTargetNodeCast([self _node])->dispatchEvent([event _event], ec);
658     raiseOnDOMError(ec);
659     return result;
660 }
661
662 @end
663
664 //------------------------------------------------------------------------------------------
665 // DOMNamedNodeMap
666
667 @implementation DOMNamedNodeMap
668
669 - (void)dealloc
670 {
671     if (_internal) {
672         DOM_cast<NamedNodeMap *>(_internal)->deref();
673     }
674     [super dealloc];
675 }
676
677 - (void)finalize
678 {
679     if (_internal) {
680         DOM_cast<NamedNodeMap *>(_internal)->deref();
681     }
682     [super finalize];
683 }
684
685 - (NamedNodeMap *)_namedNodeMap
686 {
687     return DOM_cast<NamedNodeMap *>(_internal);
688 }
689
690 - (DOMNode *)getNamedItem:(NSString *)name
691 {
692     ASSERT(name);
693
694     return [DOMNode _nodeWith:[self _namedNodeMap]->getNamedItem(name).get()];
695 }
696
697 - (DOMNode *)setNamedItem:(DOMNode *)arg
698 {
699     ASSERT(arg);
700
701     int exception = 0;
702     DOMNode *result = [DOMNode _nodeWith:[self _namedNodeMap]->setNamedItem([arg _node], exception).get()];
703     raiseOnDOMError(exception);
704     return result;
705 }
706
707 - (DOMNode *)removeNamedItem:(NSString *)name
708 {
709     ASSERT(name);
710
711     int exception = 0;
712     DOMNode *result = [DOMNode _nodeWith:[self _namedNodeMap]->removeNamedItem(name, exception).get()];
713     raiseOnDOMError(exception);
714     return result;
715 }
716
717 - (DOMNode *)item:(unsigned)index
718 {
719     return [DOMNode _nodeWith:[self _namedNodeMap]->item(index).get()];
720 }
721
722 - (unsigned)length
723 {
724     return [self _namedNodeMap]->length();
725 }
726
727 - (DOMNode *)getNamedItemNS:(NSString *)namespaceURI :(NSString *)localName
728 {
729     if (!namespaceURI || !localName) {
730         return nil;
731     }
732
733     return [DOMNode _nodeWith:[self _namedNodeMap]->getNamedItemNS(namespaceURI, localName).get()];
734 }
735
736 - (DOMNode *)setNamedItemNS:(DOMNode *)arg
737 {
738     ASSERT(arg);
739
740     int exception = 0;
741     DOMNode *result = [DOMNode _nodeWith:[self _namedNodeMap]->setNamedItemNS([arg _node], exception).get()];
742     raiseOnDOMError(exception);
743     return result;
744 }
745
746 - (DOMNode *)removeNamedItemNS:(NSString *)namespaceURI :(NSString *)localName
747 {
748     ASSERT(namespaceURI);
749     ASSERT(localName);
750
751     int exception = 0;
752     DOMNode *result = [DOMNode _nodeWith:[self _namedNodeMap]->removeNamedItemNS(namespaceURI, localName, exception).get()];
753     raiseOnDOMError(exception);
754     return result;
755 }
756
757 @end
758
759 @implementation DOMNamedNodeMap (WebCoreInternal)
760
761 - (id)_initWithNamedNodeMap:(NamedNodeMap *)impl
762 {
763     ASSERT(impl);
764
765     [super _init];
766     _internal = DOM_cast<DOMObjectInternal *>(impl);
767     impl->ref();
768     addDOMWrapper(self, impl);
769     return self;
770 }
771
772 + (DOMNamedNodeMap *)_namedNodeMapWith:(NamedNodeMap *)impl
773 {
774     if (!impl)
775         return nil;
776     
777     id cachedInstance;
778     cachedInstance = getDOMWrapper(impl);
779     if (cachedInstance)
780         return [[cachedInstance retain] autorelease];
781     
782     return [[[self alloc] _initWithNamedNodeMap:impl] autorelease];
783 }
784
785 @end
786
787 //------------------------------------------------------------------------------------------
788 // DOMNodeList
789
790 @implementation DOMNodeList
791
792 - (void)dealloc
793 {
794     if (_internal) {
795         DOM_cast<NodeList *>(_internal)->deref();
796     }
797     [super dealloc];
798 }
799
800 - (void)finalize
801 {
802     if (_internal) {
803         DOM_cast<NodeList *>(_internal)->deref();
804     }
805     [super finalize];
806 }
807
808 - (NodeList *)_nodeList
809 {
810     return DOM_cast<NodeList *>(_internal);
811 }
812
813 - (DOMNode *)item:(unsigned)index
814 {
815     return [DOMNode _nodeWith:[self _nodeList]->item(index)];
816 }
817
818 - (unsigned)length
819 {
820     return [self _nodeList]->length();
821 }
822
823 @end
824
825 @implementation DOMNodeList (WebCoreInternal)
826
827 - (id)_initWithNodeList:(NodeList *)impl
828 {
829     ASSERT(impl);
830
831     [super _init];
832     _internal = DOM_cast<DOMObjectInternal *>(impl);
833     impl->ref();
834     addDOMWrapper(self, impl);
835     return self;
836 }
837
838 + (DOMNodeList *)_nodeListWith:(NodeList *)impl
839 {
840     if (!impl)
841         return nil;
842     
843     id cachedInstance;
844     cachedInstance = getDOMWrapper(impl);
845     if (cachedInstance)
846         return [[cachedInstance retain] autorelease];
847     
848     return [[[self alloc] _initWithNodeList:impl] autorelease];
849 }
850
851 @end
852
853 //------------------------------------------------------------------------------------------
854 // DOMImplementation
855
856 @implementation DOMImplementation
857
858 - (void)dealloc
859 {
860     if (_internal)
861         DOM_cast<DOMImplementationFront *>(_internal)->deref();
862     [super dealloc];
863 }
864
865 - (void)finalize
866 {
867     if (_internal)
868         DOM_cast<DOMImplementationFront *>(_internal)->deref();
869     [super finalize];
870 }
871
872 - (BOOL)hasFeature:(NSString *)feature :(NSString *)version
873 {
874     ASSERT(feature);
875     ASSERT(version);
876
877     return [self _DOMImplementation]->hasFeature(feature, version);
878 }
879
880 - (DOMDocumentType *)createDocumentType:(NSString *)qualifiedName :(NSString *)publicId :(NSString *)systemId
881 {
882     ASSERT(qualifiedName);
883     ASSERT(publicId);
884     ASSERT(systemId);
885
886     ExceptionCode ec = 0;
887     RefPtr<DocumentType> impl = [self _DOMImplementation]->createDocumentType(qualifiedName, publicId, systemId, ec);
888     raiseOnDOMError(ec);
889     return static_cast<DOMDocumentType *>([DOMNode _nodeWith:impl.get()]);
890 }
891
892 - (DOMDocument *)createDocument:(NSString *)namespaceURI :(NSString *)qualifiedName :(DOMDocumentType *)doctype
893 {
894     ASSERT(namespaceURI);
895     ASSERT(qualifiedName);
896
897     ExceptionCode ec = 0;
898     RefPtr<Document> impl = [self _DOMImplementation]->createDocument(namespaceURI, qualifiedName, [doctype _documentType], ec);
899     raiseOnDOMError(ec);
900     return static_cast<DOMDocument *>([DOMNode _nodeWith:impl.get()]);
901 }
902
903 - (DOMHTMLDocument *)createHTMLDocument:(NSString *)title
904 {
905     RefPtr<HTMLDocument> impl = [self _DOMImplementation]->createHTMLDocument(title);
906     return static_cast<DOMHTMLDocument *>([DOMNode _nodeWith:impl.get()]);
907 }
908 @end
909
910 @implementation DOMImplementation (DOMImplementationCSS)
911
912 - (DOMCSSStyleSheet *)createCSSStyleSheet:(NSString *)title :(NSString *)media
913 {
914     ASSERT(title);
915     ASSERT(media);
916
917     ExceptionCode ec = 0;
918     DOMCSSStyleSheet *result = [DOMCSSStyleSheet _CSSStyleSheetWith:[self _DOMImplementation]->createCSSStyleSheet(title, media, ec).get()];
919     raiseOnDOMError(ec);
920     return result;
921 }
922
923 @end
924  
925 @implementation DOMImplementation (WebCoreInternal)
926
927 - (id)_initWithDOMImplementation:(DOMImplementationFront *)impl
928 {
929     ASSERT(impl);
930
931     [super _init];
932     _internal = DOM_cast<DOMObjectInternal *>(impl);
933     impl->ref();
934     addDOMWrapper(self, impl);
935     return self;
936 }
937
938 + (DOMImplementation *)_DOMImplementationWith:(DOMImplementationFront *)impl
939 {
940     if (!impl)
941         return nil;
942     
943     id cachedInstance;
944     cachedInstance = getDOMWrapper(impl);
945     if (cachedInstance)
946         return [[cachedInstance retain] autorelease];
947     
948     return [[[self alloc] _initWithDOMImplementation:impl] autorelease];
949 }
950
951 - (DOMImplementationFront *)_DOMImplementation
952 {
953     return DOM_cast<DOMImplementationFront *>(_internal);
954 }
955
956 @end
957
958 //------------------------------------------------------------------------------------------
959 // DOMDocumentFragment
960
961 @implementation DOMDocumentFragment
962
963 @end
964
965 @implementation DOMDocumentFragment (WebCoreInternal)
966
967 + (DOMDocumentFragment *)_documentFragmentWith:(DocumentFragment *)impl
968 {
969     return static_cast<DOMDocumentFragment *>([DOMNode _nodeWith:impl]);
970 }
971
972 - (DocumentFragment *)_fragment
973 {
974     return static_cast<DocumentFragment *>(DOM_cast<Node *>(_internal));
975 }
976
977 @end
978
979 //------------------------------------------------------------------------------------------
980 // DOMDocument
981
982 @implementation DOMDocument
983
984 - (DOMNode *)adoptNode:(DOMNode *)source
985 {
986     ExceptionCode ec = 0;
987     DOMNode *result = [DOMNode _nodeWith:[self _document]->adoptNode([source _node], ec).get()];
988     raiseOnDOMError(ec);
989     return result;
990 }
991
992 - (DOMDocumentType *)doctype
993 {
994     return static_cast<DOMDocumentType *>([DOMNode _nodeWith:[self _document]->doctype()]);
995 }
996
997 - (DOMImplementation *)implementation
998 {
999     return [DOMImplementation _DOMImplementationWith:implementationFront([self _document])];
1000 }
1001
1002 - (DOMElement *)documentElement
1003 {
1004     return static_cast<DOMElement *>([DOMNode _nodeWith:[self _document]->documentElement()]);
1005 }
1006
1007 - (DOMElement *)createElement:(NSString *)tagName
1008 {
1009     ASSERT(tagName);
1010
1011     ExceptionCode ec = 0;
1012     DOMElement *result = static_cast<DOMElement *>([DOMNode _nodeWith:[self _document]->createElement(tagName, ec).get()]);
1013     raiseOnDOMError(ec);
1014     return result;
1015 }
1016
1017 - (DOMDocumentFragment *)createDocumentFragment
1018 {
1019     return static_cast<DOMDocumentFragment *>([DOMNode _nodeWith:[self _document]->createDocumentFragment().get()]);
1020 }
1021
1022 - (DOMText *)createTextNode:(NSString *)data
1023 {
1024     ASSERT(data);
1025     return static_cast<DOMText *>([DOMNode _nodeWith:[self _document]->createTextNode(data).get()]);
1026 }
1027
1028 - (DOMComment *)createComment:(NSString *)data
1029 {
1030     ASSERT(data);
1031     return static_cast<DOMComment *>([DOMNode _nodeWith:[self _document]->createComment(data).get()]);
1032 }
1033
1034 - (DOMCDATASection *)createCDATASection:(NSString *)data
1035 {
1036     ASSERT(data);
1037     int exception = 0;
1038     DOMCDATASection *result = static_cast<DOMCDATASection *>([DOMNode _nodeWith:[self _document]->createCDATASection(data, exception).get()]);
1039     raiseOnDOMError(exception);
1040     return result;
1041 }
1042
1043 - (DOMProcessingInstruction *)createProcessingInstruction:(NSString *)target :(NSString *)data
1044 {
1045     ASSERT(target);
1046     ASSERT(data);
1047     int exception = 0;
1048     DOMProcessingInstruction *result = static_cast<DOMProcessingInstruction *>([DOMNode _nodeWith:[self _document]->createProcessingInstruction(target, data, exception).get()]);
1049     raiseOnDOMError(exception);
1050     return result;
1051 }
1052
1053 - (DOMAttr *)createAttribute:(NSString *)name
1054 {
1055     ASSERT(name);
1056     int exception = 0;
1057     DOMAttr *result = [DOMAttr _attrWith:[self _document]->createAttribute(name, exception).get()];
1058     raiseOnDOMError(exception);
1059     return result;
1060 }
1061
1062 - (DOMEntityReference *)createEntityReference:(NSString *)name
1063 {
1064     ASSERT(name);
1065     int exception = 0;
1066     DOMEntityReference *result = static_cast<DOMEntityReference *>([DOMNode _nodeWith:[self _document]->createEntityReference(name, exception).get()]);
1067     raiseOnDOMError(exception);
1068     return result;
1069 }
1070
1071 - (DOMNodeList *)getElementsByTagName:(NSString *)tagname
1072 {
1073     ASSERT(tagname);
1074     return [DOMNodeList _nodeListWith:[self _document]->getElementsByTagName(tagname).get()];
1075 }
1076
1077 - (DOMNode *)importNode:(DOMNode *)importedNode :(BOOL)deep
1078 {
1079     ExceptionCode ec = 0;
1080     DOMNode *result = [DOMNode _nodeWith:[self _document]->importNode([importedNode _node], deep, ec).get()];
1081     raiseOnDOMError(ec);
1082     return result;
1083 }
1084
1085 - (DOMElement *)createElementNS:(NSString *)namespaceURI :(NSString *)qualifiedName
1086 {
1087     ASSERT(namespaceURI);
1088     ASSERT(qualifiedName);
1089
1090     ExceptionCode ec = 0;
1091     DOMNode *result = [DOMNode _nodeWith:[self _document]->createElementNS(namespaceURI, qualifiedName, ec).get()];
1092     raiseOnDOMError(ec);
1093     return static_cast<DOMElement *>(result);
1094 }
1095
1096 - (DOMAttr *)createAttributeNS:(NSString *)namespaceURI :(NSString *)qualifiedName
1097 {
1098     ASSERT(namespaceURI);
1099     ASSERT(qualifiedName);
1100
1101     int exception = 0;
1102     DOMAttr *result = [DOMAttr _attrWith:[self _document]->createAttributeNS(namespaceURI, qualifiedName, exception).get()];
1103     raiseOnDOMError(exception);
1104     return result;
1105 }
1106
1107 - (DOMNodeList *)getElementsByTagNameNS:(NSString *)namespaceURI :(NSString *)localName
1108 {
1109     ASSERT(namespaceURI);
1110     ASSERT(localName);
1111
1112     return [DOMNodeList _nodeListWith:[self _document]->getElementsByTagNameNS(namespaceURI, localName).get()];
1113 }
1114
1115 - (DOMElement *)getElementById:(NSString *)elementId
1116 {
1117     ASSERT(elementId);
1118
1119     return static_cast<DOMElement *>([DOMNode _nodeWith:[self _document]->getElementById(elementId)]);
1120 }
1121
1122 @end
1123
1124 @implementation DOMDocument (DOMDocumentRange)
1125
1126 - (DOMRange *)createRange
1127 {
1128     return [DOMRange _rangeWith:[self _document]->createRange().get()];
1129 }
1130
1131 @end
1132
1133 @implementation DOMDocument (DOMDocumentCSS)
1134
1135 - (DOMCSSStyleDeclaration *)getOverrideStyle:(DOMElement *)elt :(NSString *)pseudoElt
1136 {
1137     Element *element = [elt _element];
1138     String pseudoEltString(pseudoElt);
1139     return [DOMCSSStyleDeclaration _styleDeclarationWith:[self _document]->getOverrideStyle(element, pseudoEltString.impl())];
1140 }
1141
1142 @end
1143
1144 @implementation DOMDocument (DOMDocumentStyle)
1145
1146 - (DOMStyleSheetList *)styleSheets
1147 {
1148     return [DOMStyleSheetList _styleSheetListWith:[self _document]->styleSheets()];
1149 }
1150
1151 @end
1152
1153 @implementation DOMDocument (DOMDocumentExtensions)
1154
1155 - (DOMCSSStyleDeclaration *)createCSSStyleDeclaration
1156 {
1157     return [DOMCSSStyleDeclaration _styleDeclarationWith:[self _document]->createCSSStyleDeclaration().get()];
1158 }
1159
1160 @end
1161
1162 @implementation DOMDocument (WebCoreInternal)
1163
1164 + (DOMDocument *)_documentWith:(Document *)impl
1165 {
1166     return static_cast<DOMDocument *>([DOMNode _nodeWith:impl]);
1167 }
1168
1169 - (Document *)_document
1170 {
1171     return static_cast<Document *>(DOM_cast<Node *>(_internal));
1172 }
1173
1174 - (DOMElement *)_ownerElement
1175 {
1176     return [DOMElement _elementWith:[self _document]->ownerElement()];
1177 }
1178
1179 @end
1180
1181 //------------------------------------------------------------------------------------------
1182 // DOMCharacterData
1183
1184 @implementation DOMCharacterData
1185
1186 - (CharacterData *)_characterData
1187 {
1188     return static_cast<CharacterData *>(DOM_cast<Node *>(_internal));
1189 }
1190
1191 - (NSString *)data
1192 {
1193     // Documentation says we can raise a DOMSTRING_SIZE_ERR.
1194     // However, the lower layer does not report that error up to us.
1195     return [self _characterData]->data();
1196 }
1197
1198 - (void)setData:(NSString *)data
1199 {
1200     ASSERT(data);
1201     
1202     ExceptionCode ec = 0;
1203     [self _characterData]->setData(data, ec);
1204     raiseOnDOMError(ec);
1205 }
1206
1207 - (unsigned)length
1208 {
1209     return [self _characterData]->length();
1210 }
1211
1212 - (NSString *)substringData:(unsigned)offset :(unsigned)count
1213 {
1214     ExceptionCode ec = 0;
1215     NSString *result = [self _characterData]->substringData(offset, count, ec);
1216     raiseOnDOMError(ec);
1217     return result;
1218 }
1219
1220 - (void)appendData:(NSString *)arg
1221 {
1222     ASSERT(arg);
1223     
1224     ExceptionCode ec = 0;
1225     [self _characterData]->appendData(arg, ec);
1226     raiseOnDOMError(ec);
1227 }
1228
1229 - (void)insertData:(unsigned)offset :(NSString *)arg
1230 {
1231     ASSERT(arg);
1232     
1233     ExceptionCode ec = 0;
1234     [self _characterData]->insertData(offset, arg, ec);
1235     raiseOnDOMError(ec);
1236 }
1237
1238 - (void)deleteData:(unsigned)offset :(unsigned) count
1239 {
1240     ExceptionCode ec = 0;
1241     [self _characterData]->deleteData(offset, count, ec);
1242     raiseOnDOMError(ec);
1243 }
1244
1245 - (void)replaceData:(unsigned)offset :(unsigned)count :(NSString *)arg
1246 {
1247     ASSERT(arg);
1248
1249     ExceptionCode ec = 0;
1250     [self _characterData]->replaceData(offset, count, arg, ec);
1251     raiseOnDOMError(ec);
1252 }
1253
1254 @end
1255
1256 //------------------------------------------------------------------------------------------
1257 // DOMAttr
1258
1259 @implementation DOMAttr
1260
1261 - (NSString *)name
1262 {
1263     return [self _attr]->nodeName();
1264 }
1265
1266 - (BOOL)specified
1267 {
1268     return [self _attr]->specified();
1269 }
1270
1271 - (NSString *)value
1272 {
1273     return [self _attr]->nodeValue();
1274 }
1275
1276 - (void)setValue:(NSString *)value
1277 {
1278     ASSERT(value);
1279
1280     ExceptionCode ec = 0;
1281     [self _attr]->setValue(value, ec);
1282     raiseOnDOMError(ec);
1283 }
1284
1285 - (DOMElement *)ownerElement
1286 {
1287     return [DOMElement _elementWith:[self _attr]->ownerElement()];
1288 }
1289
1290 - (DOMCSSStyleDeclaration *)style
1291 {
1292     return [DOMCSSStyleDeclaration _styleDeclarationWith: [self _attr]->style()];
1293 }
1294
1295 @end
1296
1297 @implementation DOMAttr (WebCoreInternal)
1298
1299 + (DOMAttr *)_attrWith:(Attr *)impl
1300 {
1301     return static_cast<DOMAttr *>([DOMNode _nodeWith:impl]);
1302 }
1303
1304 - (Attr *)_attr
1305 {
1306     return static_cast<Attr *>(DOM_cast<Node *>(_internal));
1307 }
1308
1309 @end
1310
1311 //------------------------------------------------------------------------------------------
1312 // DOMElement
1313
1314 @implementation DOMElement
1315
1316 - (NSString *)tagName
1317 {
1318     return [self _element]->nodeName();
1319 }
1320
1321 - (DOMNamedNodeMap *)attributes
1322 {
1323     return [DOMNamedNodeMap _namedNodeMapWith:[self _element]->attributes()];
1324 }
1325
1326 - (NSString *)getAttribute:(NSString *)name
1327 {
1328     ASSERT(name);
1329     return [self _element]->getAttribute(name);
1330 }
1331
1332 - (void)setAttribute:(NSString *)name :(NSString *)value
1333 {
1334     ASSERT(name);
1335     ASSERT(value);
1336
1337     int exception = 0;
1338     [self _element]->setAttribute(name, value, exception);
1339     raiseOnDOMError(exception);
1340 }
1341
1342 - (void)removeAttribute:(NSString *)name
1343 {
1344     ASSERT(name);
1345
1346     int exception = 0;
1347     [self _element]->removeAttribute(name, exception);
1348     raiseOnDOMError(exception);
1349 }
1350
1351 - (DOMAttr *)getAttributeNode:(NSString *)name
1352 {
1353     ASSERT(name);
1354
1355     return [DOMAttr _attrWith:[self _element]->getAttributeNode(name).get()];
1356 }
1357
1358 - (DOMAttr *)setAttributeNode:(DOMAttr *)newAttr
1359 {
1360     ASSERT(newAttr);
1361
1362     int exception = 0;
1363     DOMAttr *result = [DOMAttr _attrWith:[self _element]->setAttributeNode([newAttr _attr], exception).get()];
1364     raiseOnDOMError(exception);
1365     return result;
1366 }
1367
1368 - (DOMAttr *)removeAttributeNode:(DOMAttr *)oldAttr
1369 {
1370     ASSERT(oldAttr);
1371
1372     int exception = 0;
1373     DOMAttr *result = [DOMAttr _attrWith:[self _element]->removeAttributeNode([oldAttr _attr], exception).get()];
1374     raiseOnDOMError(exception);
1375     return result;
1376 }
1377
1378 - (DOMNodeList *)getElementsByTagName:(NSString *)name
1379 {
1380     ASSERT(name);
1381
1382     return [DOMNodeList _nodeListWith:[self _element]->getElementsByTagName(name).get()];
1383 }
1384
1385 - (NSString *)getAttributeNS:(NSString *)namespaceURI :(NSString *)localName
1386 {
1387     ASSERT(namespaceURI);
1388     ASSERT(localName);
1389
1390     return [self _element]->getAttributeNS(namespaceURI, localName);
1391 }
1392
1393 - (void)setAttributeNS:(NSString *)namespaceURI :(NSString *)qualifiedName :(NSString *)value
1394 {
1395     ASSERT(namespaceURI);
1396     ASSERT(qualifiedName);
1397     ASSERT(value);
1398
1399     int exception = 0;
1400     [self _element]->setAttributeNS(namespaceURI, qualifiedName, value, exception);
1401     raiseOnDOMError(exception);
1402 }
1403
1404 - (void)removeAttributeNS:(NSString *)namespaceURI :(NSString *)localName
1405 {
1406     ASSERT(namespaceURI);
1407     ASSERT(localName);
1408
1409     int exception = 0;
1410     [self _element]->removeAttributeNS(namespaceURI, localName, exception);
1411     raiseOnDOMError(exception);
1412 }
1413
1414 - (DOMAttr *)getAttributeNodeNS:(NSString *)namespaceURI :(NSString *)localName
1415 {
1416     ASSERT(namespaceURI);
1417     ASSERT(localName);
1418
1419     return [DOMAttr _attrWith:[self _element]->getAttributeNodeNS(namespaceURI, localName).get()];
1420 }
1421
1422 - (DOMAttr *)setAttributeNodeNS:(DOMAttr *)newAttr
1423 {
1424     ASSERT(newAttr);
1425
1426     int exception = 0;
1427     DOMAttr *result = [DOMAttr _attrWith:[self _element]->setAttributeNodeNS([newAttr _attr], exception).get()];
1428     raiseOnDOMError(exception);
1429     return result;
1430 }
1431
1432 - (DOMNodeList *)getElementsByTagNameNS:(NSString *)namespaceURI :(NSString *)localName
1433 {
1434     ASSERT(namespaceURI);
1435     ASSERT(localName);
1436
1437     return [DOMNodeList _nodeListWith:[self _element]->getElementsByTagNameNS(namespaceURI, localName).get()];
1438 }
1439
1440 - (BOOL)hasAttribute:(NSString *)name
1441 {
1442     ASSERT(name);
1443
1444     return [self _element]->hasAttribute(name);
1445 }
1446
1447 - (BOOL)hasAttributeNS:(NSString *)namespaceURI :(NSString *)localName
1448 {
1449     ASSERT(namespaceURI);
1450     ASSERT(localName);
1451
1452     return [self _element]->hasAttributeNS(namespaceURI, localName);
1453 }
1454
1455 - (void)focus
1456 {
1457     [self _element]->focus();
1458 }
1459
1460 - (void)blur
1461 {
1462     [self _element]->blur();
1463 }
1464
1465 @end
1466
1467 @implementation DOMElement (DOMElementCSSInlineStyle)
1468
1469 - (DOMCSSStyleDeclaration *)style
1470 {
1471     return [DOMCSSStyleDeclaration _styleDeclarationWith:[self _element]->style()];
1472 }
1473
1474 @end
1475
1476 @implementation DOMElement (DOMElementExtensions)
1477
1478 - (NSImage*)image
1479 {
1480     RenderObject* renderer = [self _element]->renderer();
1481     if (renderer && renderer->isImage()) {
1482         RenderImage* img = static_cast<RenderImage*>(renderer);
1483         if (img->cachedImage() && !img->cachedImage()->isErrorImage())
1484             return img->cachedImage()->image()->getNSImage();
1485     }
1486     return nil;
1487 }
1488
1489 - (void)scrollIntoView:(BOOL)alignTop
1490 {
1491     [self _element]->scrollIntoView(alignTop);
1492 }
1493
1494 - (void)scrollIntoViewIfNeeded:(BOOL)centerIfNeeded
1495 {
1496     [self _element]->scrollIntoViewIfNeeded(centerIfNeeded);
1497 }
1498
1499 @end
1500
1501 @implementation DOMElement (WebCoreInternal)
1502
1503 + (DOMElement *)_elementWith:(Element *)impl
1504 {
1505     return static_cast<DOMElement *>([DOMNode _nodeWith:impl]);
1506 }
1507
1508 - (Element *)_element
1509 {
1510     return static_cast<Element *>(DOM_cast<Node *>(_internal));
1511 }
1512
1513 @end
1514
1515 @implementation DOMElement (WebPrivate)
1516
1517 - (NSFont *)_font
1518 {
1519     RenderObject *renderer = [self _element]->renderer();
1520     if (renderer) {
1521         return renderer->style()->font().getNSFont();
1522     }
1523     return nil;
1524 }
1525
1526 - (NSData*)_imageTIFFRepresentation
1527 {
1528     RenderObject *renderer = [self _element]->renderer();
1529     if (renderer && renderer->isImage()) {
1530         RenderImage* img = static_cast<RenderImage*>(renderer);
1531         if (img->cachedImage() && !img->cachedImage()->isErrorImage())
1532             return (NSData*)(img->cachedImage()->image()->getTIFFRepresentation());
1533     }
1534     return nil;
1535 }
1536
1537 - (NSURL *)_getURLAttribute:(NSString *)name
1538 {
1539     ASSERT(name);
1540     Element *e = [self _element];
1541     ASSERT(e);
1542     return KURL(e->document()->completeURL(parseURL(e->getAttribute(name)).deprecatedString())).getNSURL();
1543 }
1544
1545 - (void *)_NPObject
1546 {
1547     Element* element = [self _element];
1548     if (element->hasTagName(appletTag) || element->hasTagName(embedTag) || element->hasTagName(objectTag))
1549         return static_cast<WebCore::HTMLPlugInElement*>(element)->getNPObject();
1550     else
1551         return 0;
1552 }
1553
1554 - (BOOL)isFocused
1555 {
1556     Element* impl = [self _element];
1557     if (impl->document()->focusNode() == impl)
1558         return YES;
1559     return NO;
1560 }
1561
1562 @end
1563
1564 //------------------------------------------------------------------------------------------
1565 // DOMText
1566
1567 @implementation DOMText
1568
1569 - (Text *)_text
1570 {
1571     return static_cast<Text *>(DOM_cast<Node *>(_internal));
1572 }
1573
1574 - (DOMText *)splitText:(unsigned)offset
1575 {
1576     ExceptionCode ec = 0;
1577     DOMNode *result = [DOMNode _nodeWith:[self _text]->splitText(offset, ec)];
1578     raiseOnDOMError(ec);
1579     return static_cast<DOMText *>(result);
1580 }
1581
1582 @end
1583
1584 //------------------------------------------------------------------------------------------
1585 // DOMComment
1586
1587 @implementation DOMComment
1588
1589 @end
1590
1591 //------------------------------------------------------------------------------------------
1592 // DOMCDATASection
1593
1594 @implementation DOMCDATASection
1595
1596 @end
1597
1598 //------------------------------------------------------------------------------------------
1599 // DOMDocumentType
1600
1601 @implementation DOMDocumentType
1602
1603 - (NSString *)name
1604 {
1605     return [self _documentType]->publicId();
1606 }
1607
1608 - (DOMNamedNodeMap *)entities
1609 {
1610     return [DOMNamedNodeMap _namedNodeMapWith:[self _documentType]->entities()];
1611 }
1612
1613 - (DOMNamedNodeMap *)notations
1614 {
1615     return [DOMNamedNodeMap _namedNodeMapWith:[self _documentType]->notations()];
1616 }
1617
1618 - (NSString *)publicId
1619 {
1620     return [self _documentType]->publicId();
1621 }
1622
1623 - (NSString *)systemId
1624 {
1625     return [self _documentType]->systemId();
1626 }
1627
1628 - (NSString *)internalSubset
1629 {
1630     return [self _documentType]->internalSubset();
1631 }
1632
1633 @end
1634
1635 @implementation DOMDocumentType (WebCoreInternal)
1636
1637 - (DocumentType *)_documentType
1638 {
1639     return static_cast<DocumentType *>(DOM_cast<Node *>(_internal));
1640 }
1641
1642 @end
1643
1644 //------------------------------------------------------------------------------------------
1645 // DOMNotation
1646
1647 @implementation DOMNotation
1648
1649 - (Notation *)_notation
1650 {
1651     return static_cast<Notation *>(DOM_cast<Node *>(_internal));
1652 }
1653
1654 - (NSString *)publicId
1655 {
1656     return [self _notation]->publicId();
1657 }
1658
1659 - (NSString *)systemId
1660 {
1661     return [self _notation]->systemId();
1662 }
1663
1664 @end
1665
1666 //------------------------------------------------------------------------------------------
1667 // DOMEntity
1668
1669 @implementation DOMEntity
1670
1671 - (Entity *)_entity
1672 {
1673     return static_cast<Entity *>(DOM_cast<Node *>(_internal));
1674 }
1675
1676 - (NSString *)publicId
1677 {
1678     return [self _entity]->publicId();
1679 }
1680
1681 - (NSString *)systemId
1682 {
1683     return [self _entity]->systemId();
1684 }
1685
1686 - (NSString *)notationName
1687 {
1688     return [self _entity]->notationName();
1689 }
1690
1691 @end
1692
1693 //------------------------------------------------------------------------------------------
1694 // DOMEntityReference
1695
1696 @implementation DOMEntityReference
1697
1698 @end
1699
1700 //------------------------------------------------------------------------------------------
1701 // DOMProcessingInstruction
1702
1703 @implementation DOMProcessingInstruction
1704
1705 - (ProcessingInstruction *)_processingInstruction
1706 {
1707     return static_cast<ProcessingInstruction *>(DOM_cast<Node *>(_internal));
1708 }
1709
1710 - (NSString *)target
1711 {
1712     return [self _processingInstruction]->target();
1713 }
1714
1715 - (NSString *)data
1716 {
1717     return [self _processingInstruction]->data();
1718 }
1719
1720 - (void)setData:(NSString *)data
1721 {
1722     ASSERT(data);
1723
1724     ExceptionCode ec = 0;
1725     [self _processingInstruction]->setData(data, ec);
1726     raiseOnDOMError(ec);
1727 }
1728
1729 @end
1730
1731 //------------------------------------------------------------------------------------------
1732 // DOMRange
1733
1734 @implementation DOMRange
1735
1736 - (void)dealloc
1737 {
1738     if (_internal) {
1739         DOM_cast<Range *>(_internal)->deref();
1740     }
1741     [super dealloc];
1742 }
1743
1744 - (void)finalize
1745 {
1746     if (_internal) {
1747         DOM_cast<Range *>(_internal)->deref();
1748     }
1749     [super finalize];
1750 }
1751
1752 - (NSString *)description
1753 {
1754     if (!_internal)
1755         return @"<DOMRange: null>";
1756     return [NSString stringWithFormat:@"<DOMRange: %@ %d %@ %d>",
1757         [self startContainer], [self startOffset],
1758         [self endContainer], [self endOffset]];
1759 }
1760
1761 - (DOMNode *)startContainer
1762 {
1763     ExceptionCode ec = 0;
1764     DOMNode *result = [DOMNode _nodeWith:[self _range]->startContainer(ec)];
1765     raiseOnDOMError(ec);
1766     return result;
1767 }
1768
1769 - (int)startOffset
1770 {
1771     ExceptionCode ec = 0;
1772     int result = [self _range]->startOffset(ec);
1773     raiseOnDOMError(ec);
1774     return result;
1775 }
1776
1777 - (DOMNode *)endContainer
1778 {
1779     ExceptionCode ec = 0;
1780     DOMNode *result = [DOMNode _nodeWith:[self _range]->endContainer(ec)];
1781     raiseOnDOMError(ec);
1782     return result;
1783 }
1784
1785 - (int)endOffset
1786 {
1787     ExceptionCode ec = 0;
1788     int result = [self _range]->endOffset(ec);
1789     raiseOnDOMError(ec);
1790     return result;
1791 }
1792
1793 - (BOOL)collapsed
1794 {
1795     ExceptionCode ec = 0;
1796     BOOL result = [self _range]->collapsed(ec);
1797     raiseOnDOMError(ec);
1798     return result;
1799 }
1800
1801 - (DOMNode *)commonAncestorContainer
1802 {
1803     ExceptionCode ec = 0;
1804     DOMNode *result = [DOMNode _nodeWith:[self _range]->commonAncestorContainer(ec)];
1805     raiseOnDOMError(ec);
1806     return result;
1807 }
1808
1809 - (void)setStart:(DOMNode *)refNode :(int)offset
1810 {
1811     ExceptionCode ec = 0;
1812     [self _range]->setStart([refNode _node], offset, ec);
1813     raiseOnDOMError(ec);
1814 }
1815
1816 - (void)setEnd:(DOMNode *)refNode :(int)offset
1817 {
1818     ExceptionCode ec = 0;
1819     [self _range]->setEnd([refNode _node], offset, ec);
1820     raiseOnDOMError(ec);
1821 }
1822
1823 - (void)setStartBefore:(DOMNode *)refNode
1824 {
1825     ExceptionCode ec = 0;
1826     [self _range]->setStartBefore([refNode _node], ec);
1827     raiseOnDOMError(ec);
1828 }
1829
1830 - (void)setStartAfter:(DOMNode *)refNode
1831 {
1832     ExceptionCode ec = 0;
1833     [self _range]->setStartAfter([refNode _node], ec);
1834     raiseOnDOMError(ec);
1835 }
1836
1837 - (void)setEndBefore:(DOMNode *)refNode
1838 {
1839     ExceptionCode ec = 0;
1840     [self _range]->setEndBefore([refNode _node], ec);
1841     raiseOnDOMError(ec);
1842 }
1843
1844 - (void)setEndAfter:(DOMNode *)refNode
1845 {
1846     ExceptionCode ec = 0;
1847     [self _range]->setEndAfter([refNode _node], ec);
1848     raiseOnDOMError(ec);
1849 }
1850
1851 - (void)collapse:(BOOL)toStart
1852 {
1853     ExceptionCode ec = 0;
1854     [self _range]->collapse(toStart, ec);
1855     raiseOnDOMError(ec);
1856 }
1857
1858 - (void)selectNode:(DOMNode *)refNode
1859 {
1860     ExceptionCode ec = 0;
1861     [self _range]->selectNode([refNode _node], ec);
1862     raiseOnDOMError(ec);
1863 }
1864
1865 - (void)selectNodeContents:(DOMNode *)refNode
1866 {
1867     ExceptionCode ec = 0;
1868     [self _range]->selectNodeContents([refNode _node], ec);
1869     raiseOnDOMError(ec);
1870 }
1871
1872 - (short)compareBoundaryPoints:(unsigned short)how :(DOMRange *)sourceRange
1873 {
1874     ExceptionCode ec = 0;
1875     short result = [self _range]->compareBoundaryPoints(static_cast<Range::CompareHow>(how), [sourceRange _range], ec);
1876     raiseOnDOMError(ec);
1877     return result;
1878 }
1879
1880 - (void)deleteContents
1881 {
1882     ExceptionCode ec = 0;
1883     [self _range]->deleteContents(ec);
1884     raiseOnDOMError(ec);
1885 }
1886
1887 - (DOMDocumentFragment *)extractContents
1888 {
1889     ExceptionCode ec = 0;
1890     DOMDocumentFragment *result = [DOMDocumentFragment _documentFragmentWith:[self _range]->extractContents(ec).get()];
1891     raiseOnDOMError(ec);
1892     return result;
1893 }
1894
1895 - (DOMDocumentFragment *)cloneContents
1896 {
1897     ExceptionCode ec = 0;
1898     DOMDocumentFragment *result = [DOMDocumentFragment _documentFragmentWith:[self _range]->cloneContents(ec).get()];
1899     raiseOnDOMError(ec);
1900     return result;
1901 }
1902
1903 - (void)insertNode:(DOMNode *)newNode
1904 {
1905     ExceptionCode ec = 0;
1906     [self _range]->insertNode([newNode _node], ec);
1907     raiseOnDOMError(ec);
1908 }
1909
1910 - (void)surroundContents:(DOMNode *)newParent
1911 {
1912     ExceptionCode ec = 0;
1913     [self _range]->surroundContents([newParent _node], ec);
1914     raiseOnDOMError(ec);
1915 }
1916
1917 - (DOMRange *)cloneRange
1918 {
1919     ExceptionCode ec = 0;
1920     DOMRange *result = [DOMRange _rangeWith:[self _range]->cloneRange(ec).get()];
1921     raiseOnDOMError(ec);
1922     return result;
1923 }
1924
1925 - (NSString *)toString
1926 {
1927     ExceptionCode ec = 0;
1928     NSString *result = [self _range]->toString(ec);
1929     raiseOnDOMError(ec);
1930     return result;
1931 }
1932
1933 - (NSString *)text
1934 {
1935     return [self _range]->text();
1936 }
1937
1938 - (void)detach
1939 {
1940     ExceptionCode ec = 0;
1941     [self _range]->detach(ec);
1942     raiseOnDOMError(ec);
1943 }
1944
1945 @end
1946
1947 @implementation DOMRange (WebCoreInternal)
1948
1949 - (id)_initWithRange:(Range *)impl
1950 {
1951     ASSERT(impl);
1952
1953     [super _init];
1954     _internal = DOM_cast<DOMObjectInternal *>(impl);
1955     impl->ref();
1956     addDOMWrapper(self, impl);
1957     return self;
1958 }
1959
1960 + (DOMRange *)_rangeWith:(Range *)impl
1961 {
1962     if (!impl)
1963         return nil;
1964     
1965     id cachedInstance;
1966     cachedInstance = getDOMWrapper(impl);
1967     if (cachedInstance)
1968         return [[cachedInstance retain] autorelease];
1969     
1970     return [[[self alloc] _initWithRange:impl] autorelease];
1971 }
1972
1973 - (Range *)_range
1974 {
1975     return DOM_cast<Range *>(_internal);
1976 }
1977
1978 @end
1979
1980 @implementation DOMRange (WebPrivate)
1981
1982 - (NSString *)_text
1983 {
1984     return [self text];
1985 }
1986
1987 @end
1988
1989 //------------------------------------------------------------------------------------------
1990
1991 //------------------------------------------------------------------------------------------
1992
1993 @implementation DOMNodeFilter
1994
1995 - (id)_initWithNodeFilter:(NodeFilter *)impl
1996 {
1997     ASSERT(impl);
1998
1999     [super _init];
2000     _internal = DOM_cast<DOMObjectInternal *>(impl);
2001     impl->ref();
2002     addDOMWrapper(self, impl);
2003     return self;
2004 }
2005
2006 + (DOMNodeFilter *)_nodeFilterWith:(NodeFilter *)impl
2007 {
2008     if (!impl)
2009         return nil;
2010     
2011     id cachedInstance;
2012     cachedInstance = getDOMWrapper(impl);
2013     if (cachedInstance)
2014         return [[cachedInstance retain] autorelease];
2015     
2016     return [[[self alloc] _initWithNodeFilter:impl] autorelease];
2017 }
2018
2019 - (NodeFilter *)_nodeFilter
2020 {
2021     return DOM_cast<NodeFilter *>(_internal);
2022 }
2023
2024 - (void)dealloc
2025 {
2026     if (_internal)
2027         DOM_cast<NodeFilter *>(_internal)->deref();
2028     [super dealloc];
2029 }
2030
2031 - (void)finalize
2032 {
2033     if (_internal)
2034         DOM_cast<NodeFilter *>(_internal)->deref();
2035     [super finalize];
2036 }
2037
2038 - (short)acceptNode:(DOMNode *)node
2039 {
2040     return [self _nodeFilter]->acceptNode([node _node]);
2041 }
2042
2043 @end
2044
2045
2046 @implementation DOMNodeIterator
2047
2048 - (id)_initWithNodeIterator:(NodeIterator *)impl filter:(id <DOMNodeFilter>)filter
2049 {
2050     ASSERT(impl);
2051
2052     [super _init];
2053     _internal = DOM_cast<DOMObjectInternal *>(impl);
2054     impl->ref();
2055     addDOMWrapper(self, impl);
2056     m_filter = [filter retain];
2057     return self;
2058 }
2059
2060 - (NodeIterator *)_nodeIterator
2061 {
2062     return DOM_cast<NodeIterator *>(_internal);
2063 }
2064
2065 - (void)dealloc
2066 {
2067     [m_filter release];
2068     if (_internal) {
2069         [self detach];
2070         DOM_cast<NodeIterator *>(_internal)->deref();
2071     }
2072     [super dealloc];
2073 }
2074
2075 - (void)finalize
2076 {
2077     if (_internal) {
2078         [self detach];
2079         DOM_cast<NodeIterator *>(_internal)->deref();
2080     }
2081     [super finalize];
2082 }
2083
2084 - (DOMNode *)root
2085 {
2086     return [DOMNode _nodeWith:[self _nodeIterator]->root()];
2087 }
2088
2089 - (unsigned)whatToShow
2090 {
2091     return [self _nodeIterator]->whatToShow();
2092 }
2093
2094 - (id <DOMNodeFilter>)filter
2095 {
2096     if (m_filter)
2097         // This node iterator was created from the objc side
2098         return [[m_filter retain] autorelease];
2099
2100     // This node iterator was created from the c++ side
2101     return [DOMNodeFilter _nodeFilterWith:[self _nodeIterator]->filter()];
2102 }
2103
2104 - (BOOL)expandEntityReferences
2105 {
2106     return [self _nodeIterator]->expandEntityReferences();
2107 }
2108
2109 - (DOMNode *)nextNode
2110 {
2111     ExceptionCode ec = 0;
2112     DOMNode *result = [DOMNode _nodeWith:[self _nodeIterator]->nextNode(ec)];
2113     raiseOnDOMError(ec);
2114     return result;
2115 }
2116
2117 - (DOMNode *)previousNode
2118 {
2119     ExceptionCode ec = 0;
2120     DOMNode *result = [DOMNode _nodeWith:[self _nodeIterator]->previousNode(ec)];
2121     raiseOnDOMError(ec);
2122     return result;
2123 }
2124
2125 - (void)detach
2126 {
2127     [self _nodeIterator]->detach();
2128 }
2129
2130 @end
2131
2132 @implementation DOMNodeIterator(WebCoreInternal)
2133
2134 + (DOMNodeIterator *)_nodeIteratorWith:(NodeIterator *)impl filter:(id <DOMNodeFilter>)filter
2135 {
2136     if (!impl)
2137         return nil;
2138     
2139     id cachedInstance;
2140     cachedInstance = getDOMWrapper(impl);
2141     if (cachedInstance)
2142         return [[cachedInstance retain] autorelease];
2143     
2144     return [[[self alloc] _initWithNodeIterator:impl filter:filter] autorelease];
2145 }
2146
2147 @end
2148
2149 @implementation DOMTreeWalker
2150
2151 - (id)_initWithTreeWalker:(TreeWalker *)impl filter:(id <DOMNodeFilter>)filter
2152 {
2153     ASSERT(impl);
2154
2155     [super _init];
2156     _internal = DOM_cast<DOMObjectInternal *>(impl);
2157     impl->ref();
2158     addDOMWrapper(self, impl);
2159     m_filter = [filter retain];
2160     return self;
2161 }
2162
2163 - (TreeWalker *)_treeWalker
2164 {
2165     return DOM_cast<TreeWalker *>(_internal);
2166 }
2167
2168 - (void)dealloc
2169 {
2170     if (m_filter)
2171         [m_filter release];
2172     if (_internal) {
2173         DOM_cast<TreeWalker *>(_internal)->deref();
2174     }
2175     [super dealloc];
2176 }
2177
2178 - (void)finalize
2179 {
2180     if (_internal) {
2181         DOM_cast<TreeWalker *>(_internal)->deref();
2182     }
2183     [super finalize];
2184 }
2185
2186 - (DOMNode *)root
2187 {
2188     return [DOMNode _nodeWith:[self _treeWalker]->root()];
2189 }
2190
2191 - (unsigned)whatToShow
2192 {
2193     return [self _treeWalker]->whatToShow();
2194 }
2195
2196 - (id <DOMNodeFilter>)filter
2197 {
2198     if (m_filter)
2199         // This tree walker was created from the objc side
2200         return [[m_filter retain] autorelease];
2201
2202     // This tree walker was created from the c++ side
2203     return [DOMNodeFilter _nodeFilterWith:[self _treeWalker]->filter()];
2204 }
2205
2206 - (BOOL)expandEntityReferences
2207 {
2208     return [self _treeWalker]->expandEntityReferences();
2209 }
2210
2211 - (DOMNode *)currentNode
2212 {
2213     return [DOMNode _nodeWith:[self _treeWalker]->currentNode()];
2214 }
2215
2216 - (void)setCurrentNode:(DOMNode *)currentNode
2217 {
2218     ExceptionCode ec = 0;
2219     [self _treeWalker]->setCurrentNode([currentNode _node], ec);
2220     raiseOnDOMError(ec);
2221 }
2222
2223 - (DOMNode *)parentNode
2224 {
2225     return [DOMNode _nodeWith:[self _treeWalker]->parentNode()];
2226 }
2227
2228 - (DOMNode *)firstChild
2229 {
2230     return [DOMNode _nodeWith:[self _treeWalker]->firstChild()];
2231 }
2232
2233 - (DOMNode *)lastChild
2234 {
2235     return [DOMNode _nodeWith:[self _treeWalker]->lastChild()];
2236 }
2237
2238 - (DOMNode *)previousSibling
2239 {
2240     return [DOMNode _nodeWith:[self _treeWalker]->previousSibling()];
2241 }
2242
2243 - (DOMNode *)nextSibling
2244 {
2245     return [DOMNode _nodeWith:[self _treeWalker]->nextSibling()];
2246 }
2247
2248 - (DOMNode *)previousNode
2249 {
2250     return [DOMNode _nodeWith:[self _treeWalker]->previousNode()];
2251 }
2252
2253 - (DOMNode *)nextNode
2254 {
2255     return [DOMNode _nodeWith:[self _treeWalker]->nextNode()];
2256 }
2257
2258 @end
2259
2260 @implementation DOMTreeWalker (WebCoreInternal)
2261
2262 + (DOMTreeWalker *)_treeWalkerWith:(TreeWalker *)impl filter:(id <DOMNodeFilter>)filter
2263 {
2264     if (!impl)
2265         return nil;
2266     
2267     id cachedInstance;
2268     cachedInstance = getDOMWrapper(impl);
2269     if (cachedInstance)
2270         return [[cachedInstance retain] autorelease];
2271     
2272     return [[[self alloc] _initWithTreeWalker:impl filter:filter] autorelease];
2273 }
2274
2275 @end
2276
2277 class ObjCNodeFilterCondition : public NodeFilterCondition 
2278 {
2279 public:
2280     ObjCNodeFilterCondition(id <DOMNodeFilter>);
2281     virtual ~ObjCNodeFilterCondition();
2282     virtual short acceptNode(Node*) const;
2283
2284 private:
2285     ObjCNodeFilterCondition(const ObjCNodeFilterCondition &);
2286     ObjCNodeFilterCondition &operator=(const ObjCNodeFilterCondition &);
2287
2288     id <DOMNodeFilter> m_filter;
2289 };
2290
2291 ObjCNodeFilterCondition::ObjCNodeFilterCondition(id <DOMNodeFilter> filter)
2292     : m_filter(filter)
2293 {
2294     ASSERT(m_filter);
2295     CFRetain(m_filter);
2296 }
2297
2298 ObjCNodeFilterCondition::~ObjCNodeFilterCondition()
2299 {
2300     CFRelease(m_filter);
2301 }
2302
2303 short ObjCNodeFilterCondition::acceptNode(Node* node) const
2304 {
2305     if (!node)
2306         return NodeFilter::FILTER_REJECT;
2307     return [m_filter acceptNode:[DOMNode _nodeWith:node]];
2308 }
2309
2310 @implementation DOMDocument (DOMDocumentTraversal)
2311
2312 - (DOMNodeIterator *)createNodeIterator:(DOMNode *)root :(unsigned)whatToShow :(id <DOMNodeFilter>)filter :(BOOL)expandEntityReferences
2313 {
2314     RefPtr<NodeFilter> cppFilter;
2315     if (filter)
2316         cppFilter = new NodeFilter(new ObjCNodeFilterCondition(filter));
2317     ExceptionCode ec = 0;
2318     RefPtr<NodeIterator> impl = [self _document]->createNodeIterator([root _node], whatToShow, cppFilter, expandEntityReferences, ec);
2319     raiseOnDOMError(ec);
2320     return [DOMNodeIterator _nodeIteratorWith:impl.get() filter:filter];
2321 }
2322
2323 - (DOMTreeWalker *)createTreeWalker:(DOMNode *)root :(unsigned)whatToShow :(id <DOMNodeFilter>)filter :(BOOL)expandEntityReferences
2324 {
2325     RefPtr<NodeFilter> cppFilter;
2326     if (filter)
2327         cppFilter = new NodeFilter(new ObjCNodeFilterCondition(filter));
2328     ExceptionCode ec = 0;
2329     RefPtr<TreeWalker> impl = [self _document]->createTreeWalker([root _node], whatToShow, cppFilter, expandEntityReferences, ec);
2330     raiseOnDOMError(ec);
2331     return [DOMTreeWalker _treeWalkerWith:impl.get() filter:filter];
2332 }
2333
2334 @end
2335
2336 ObjCEventListener* ObjCEventListener::find(id <DOMEventListener> listener)
2337 {
2338     if (ListenerMap* map = listenerMap)
2339         return map->get(listener);
2340     return NULL;
2341 }
2342
2343 ObjCEventListener *ObjCEventListener::create(id <DOMEventListener> listener)
2344 {
2345     ObjCEventListener *wrapper = find(listener);
2346     if (!wrapper)
2347         wrapper = new ObjCEventListener(listener);
2348     wrapper->ref();
2349     return wrapper;
2350 }
2351
2352 ObjCEventListener::ObjCEventListener(id <DOMEventListener> listener)
2353     : m_listener([listener retain])
2354 {
2355     ListenerMap* map = listenerMap;
2356     if (!map) {
2357         map = new ListenerMap;
2358         listenerMap = map;
2359     }
2360     map->set(listener, this);
2361 }
2362
2363 ObjCEventListener::~ObjCEventListener()
2364 {
2365     listenerMap->remove(m_listener);
2366     [m_listener release];
2367 }
2368
2369 void ObjCEventListener::handleEvent(Event *event, bool)
2370 {
2371     [m_listener handleEvent:[DOMEvent _eventWith:event]];
2372 }