d0bba23cf975de0520bb059e1e0bfa552060ab73
[WebKit-https.git] / WebCore / kwq / DOM.mm
1 /*
2  * Copyright (C) 2004 Apple Computer, 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 exceptionCode 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 #import "DOM.h"
27
28 #include <objc/objc-class.h>
29
30 #import <JavaScriptCore/WebScriptObjectPrivate.h>
31
32 #import "dom2_range.h"
33 #import "dom2_rangeimpl.h"
34 #import "dom2_traversal.h"
35 #import "dom2_viewsimpl.h"
36 #import "dom_doc.h"
37 #import "dom_docimpl.h"
38 #import "dom_element.h"
39 #import "dom_elementimpl.h"
40 #import "dom_exception.h"
41 #import "dom_node.h"
42 #import "dom_nodeimpl.h"
43 #import "dom_string.h"
44 #import "dom_stringimpl.h"
45 #import "dom_text.h"
46 #import "dom_textimpl.h"
47 #import "dom_xml.h"
48 #import "dom_xmlimpl.h"
49 #import "html_elementimpl.h"
50 #import "htmltags.h"
51
52 #import "DOMEventsInternal.h"
53 #import "DOMHTML.h"
54 #import "DOMInternal.h"
55 #import "DOMPrivate.h"
56 #import "KWQAssertions.h"
57 #import "KWQFoundationExtras.h"
58
59 using DOM::Attr;
60 using DOM::AttrImpl;
61 using DOM::CharacterDataImpl;
62 using DOM::DocumentFragmentImpl;
63 using DOM::DocumentType;
64 using DOM::DocumentTypeImpl;
65 using DOM::Document;
66 using DOM::DocumentImpl;
67 using DOM::DOMImplementationImpl;
68 using DOM::DOMString;
69 using DOM::DOMStringImpl;
70 using DOM::Element;
71 using DOM::ElementImpl;
72 using DOM::EntityImpl;
73 using DOM::HTMLElementImpl;
74 using DOM::NamedNodeMap;
75 using DOM::NamedNodeMapImpl;
76 using DOM::Node;
77 using DOM::NodeFilter;
78 using DOM::NodeFilterCondition;
79 using DOM::NodeFilterImpl;
80 using DOM::NodeImpl;
81 using DOM::NodeIteratorImpl;
82 using DOM::NodeListImpl;
83 using DOM::NotationImpl;
84 using DOM::ProcessingInstructionImpl;
85 using DOM::Range;
86 using DOM::RangeException;
87 using DOM::RangeImpl;
88 using DOM::TextImpl;
89 using DOM::TreeWalkerImpl;
90
91 @interface DOMAttr (WebCoreInternal)
92 + (DOMAttr *)_attrWithImpl:(AttrImpl *)impl;
93 - (AttrImpl *)_attrImpl;
94 @end
95
96 @interface DOMImplementation (WebCoreInternal)
97 + (DOMImplementation *)_DOMImplementationWithImpl:(DOMImplementationImpl *)impl;
98 - (DOMImplementationImpl *)_DOMImplementationImpl;
99 @end
100
101 @interface DOMNamedNodeMap (WebCoreInternal)
102 + (DOMNamedNodeMap *)_namedNodeMapWithImpl:(NamedNodeMapImpl *)impl;
103 @end
104
105 //------------------------------------------------------------------------------------------
106 // Factory methods
107
108 inline NamedNodeMap NamedNodeMapImpl::createInstance(NamedNodeMapImpl *impl)
109 {
110     return NamedNodeMap(impl);
111 }
112
113 inline Attr AttrImpl::createInstance(AttrImpl *impl)
114 {
115     return Attr(impl);
116 }
117
118 inline Element ElementImpl::createInstance(ElementImpl *impl)
119 {
120     return Element(impl);
121 }
122
123 inline DocumentType DocumentTypeImpl::createInstance(DocumentTypeImpl *impl)
124 {
125     return DocumentType(impl);
126 }
127
128 inline Document DocumentImpl::createInstance(DocumentImpl *impl)
129 {
130     return Document(impl);
131 }
132
133 //------------------------------------------------------------------------------------------
134 // DOMObject
135
136 @implementation DOMObject
137
138 // Prevent creation of DOM objects by clients who just "[[xxx alloc] init]".
139 - (id)init
140 {
141     [NSException raise:NSGenericException format:@"+[%s init]: should never be used", [self class]->name];
142     [self release];
143     return nil;
144 }
145
146 - (void)dealloc
147 {
148     if (_internal) {
149         removeDOMWrapper(_internal);
150     }
151     [super dealloc];
152 }
153
154 - (void)finalize
155 {
156     if (_internal) {
157         removeDOMWrapper(_internal);
158     }
159     [super finalize];
160 }
161
162 - (id)copyWithZone:(NSZone *)zone
163 {
164     return [self retain];
165 }
166
167 @end
168
169 @implementation DOMObject (WebCoreInternal)
170
171 - (id)_init
172 {
173     return [super _init];
174 }
175
176 @end
177
178 //------------------------------------------------------------------------------------------
179 // DOMNode
180
181 @implementation DOMNode
182
183 - (void)dealloc
184 {
185     if (_internal) {
186         DOM_cast<NodeImpl *>(_internal)->deref();
187     }
188     [super dealloc];
189 }
190
191 - (void)finalize
192 {
193     if (_internal) {
194         DOM_cast<NodeImpl *>(_internal)->deref();
195     }
196     [super finalize];
197 }
198
199 - (NSString *)nodeName
200 {
201     return [self _nodeImpl]->nodeName();
202 }
203
204 - (NSString *)nodeValue
205 {
206     // Documentation says we can raise a DOMSTRING_SIZE_ERR.
207     // However, the lower layer does not report that error up to us.
208     return [self _nodeImpl]->nodeValue();
209 }
210
211 - (void)setNodeValue:(NSString *)string
212 {
213     ASSERT(string);
214     
215     int exceptionCode = 0;
216     [self _nodeImpl]->setNodeValue(string, exceptionCode);
217     raiseOnDOMError(exceptionCode);
218 }
219
220 - (unsigned short)nodeType
221 {
222     return [self _nodeImpl]->nodeType();
223 }
224
225 - (DOMNode *)parentNode
226 {
227     return [DOMNode _nodeWithImpl:[self _nodeImpl]->parentNode()];
228 }
229
230 - (DOMNodeList *)childNodes
231 {
232     return [DOMNodeList _nodeListWithImpl:[self _nodeImpl]->childNodes()];
233 }
234
235 - (DOMNode *)firstChild
236 {
237     return [DOMNode _nodeWithImpl:[self _nodeImpl]->firstChild()];
238 }
239
240 - (DOMNode *)lastChild
241 {
242     return [DOMNode _nodeWithImpl:[self _nodeImpl]->lastChild()];
243 }
244
245 - (DOMNode *)previousSibling
246 {
247     return [DOMNode _nodeWithImpl:[self _nodeImpl]->previousSibling()];
248 }
249
250 - (DOMNode *)nextSibling
251 {
252     return [DOMNode _nodeWithImpl:[self _nodeImpl]->nextSibling()];
253 }
254
255 - (DOMNamedNodeMap *)attributes
256 {
257     // DOM level 2 core specification says: 
258     // A NamedNodeMap containing the attributes of this node (if it is an Element) or null otherwise.
259     return nil;
260 }
261
262 - (DOMDocument *)ownerDocument
263 {
264     return [DOMDocument _documentWithImpl:[self _nodeImpl]->getDocument()];
265 }
266
267 - (DOMNode *)insertBefore:(DOMNode *)newChild :(DOMNode *)refChild
268 {
269     ASSERT(newChild);
270     ASSERT(refChild);
271
272     int exceptionCode = 0;
273     DOMNode *result = [DOMNode _nodeWithImpl:[self _nodeImpl]->insertBefore([newChild _nodeImpl], [refChild _nodeImpl], exceptionCode)];
274     raiseOnDOMError(exceptionCode);
275     return result;
276 }
277
278 - (DOMNode *)replaceChild:(DOMNode *)newChild :(DOMNode *)oldChild
279 {
280     ASSERT(newChild);
281     ASSERT(oldChild);
282
283     int exceptionCode = 0;
284     DOMNode *result = [DOMNode _nodeWithImpl:[self _nodeImpl]->replaceChild([newChild _nodeImpl], [oldChild _nodeImpl], exceptionCode)];
285     raiseOnDOMError(exceptionCode);
286     return result;
287 }
288
289 - (DOMNode *)removeChild:(DOMNode *)oldChild
290 {
291     ASSERT(oldChild);
292
293     int exceptionCode = 0;
294     DOMNode *result = [DOMNode _nodeWithImpl:[self _nodeImpl]->removeChild([oldChild _nodeImpl], exceptionCode)];
295     raiseOnDOMError(exceptionCode);
296     return result;
297 }
298
299 - (DOMNode *)appendChild:(DOMNode *)newChild
300 {
301     ASSERT(newChild);
302
303     int exceptionCode = 0;
304     DOMNode *result = [DOMNode _nodeWithImpl:[self _nodeImpl]->appendChild([newChild _nodeImpl], exceptionCode)];
305     raiseOnDOMError(exceptionCode);
306     return result;
307 }
308
309 - (BOOL)hasChildNodes
310 {
311     return [self _nodeImpl]->hasChildNodes();
312 }
313
314 - (DOMNode *)cloneNode:(BOOL)deep
315 {
316     return [DOMNode _nodeWithImpl:[self _nodeImpl]->cloneNode(deep)];
317 }
318
319 - (void)normalize
320 {
321     [self _nodeImpl]->normalize();
322 }
323
324 - (BOOL)isSupported:(NSString *)feature :(NSString *)version
325 {
326     ASSERT(feature);
327     ASSERT(version);
328
329     // Method not reflected in DOM::NodeImpl interface
330     return Node([self _nodeImpl]).isSupported(feature, version);
331 }
332
333 - (NSString *)namespaceURI
334 {
335     // Method not reflected in DOM::NodeImpl interface
336     return Node([self _nodeImpl]).namespaceURI();
337 }
338
339 - (NSString *)prefix
340 {
341     return [self _nodeImpl]->prefix();
342 }
343
344 - (void)setPrefix:(NSString *)prefix
345 {
346     ASSERT(prefix);
347
348     int exceptionCode = 0;
349     [self _nodeImpl]->setPrefix(prefix, exceptionCode);
350     raiseOnDOMError(exceptionCode);
351 }
352
353 - (NSString *)localName
354 {
355     return [self _nodeImpl]->localName();
356 }
357
358 - (BOOL)hasAttributes
359 {
360     // Method not reflected in DOM::NodeImpl interface
361     return Node([self _nodeImpl]).hasAttributes();
362 }
363
364 - (void)addEventListener:(NSString *)type :(id <DOMEventListener>)listener :(BOOL)useCapture
365 {
366     ERROR("unimplemented");
367 }
368
369 - (void)removeEventListener:(NSString *)type :(id <DOMEventListener>)listener :(BOOL)useCapture
370 {
371     ERROR("unimplemented");
372 }
373
374 - (BOOL)dispatchEvent:(DOMEvent *)event
375 {
376     int exceptionCode = 0;
377     BOOL result = [self _nodeImpl]->dispatchEvent([event _eventImpl], exceptionCode);
378     raiseOnDOMError(exceptionCode);
379     return result;
380 }
381
382 @end
383
384 @implementation DOMNode (WebCoreInternal)
385
386 - (id)_initWithNodeImpl:(NodeImpl *)impl
387 {
388     ASSERT(impl);
389
390     [super _init];
391     _internal = DOM_cast<DOMObjectInternal *>(impl);
392     impl->ref();
393     addDOMWrapper(self, impl);
394     return self;
395 }
396
397 + (DOMNode *)_nodeWithImpl:(NodeImpl *)impl
398 {
399     if (!impl)
400         return nil;
401     
402     id cachedInstance;
403     cachedInstance = getDOMWrapper(impl);
404     if (cachedInstance)
405         return [[cachedInstance retain] autorelease];
406     
407     Class wrapperClass = nil;
408     switch (impl->nodeType()) {
409         case Node::ELEMENT_NODE:
410             if (impl->isHTMLElement()) {
411                 // FIXME: There are no identifiers for HTMLHeadingElement, HTMLModElement, 
412                 // HTMLTableCaptionElement, HTMLTableColElement, HTMLTableSectionElement.
413                 // Find other ways to identify them.
414                 switch (impl->identifier()) {
415                     case ID_HTML:
416                         wrapperClass = [DOMHTMLHtmlElement class];
417                         break;
418                     case ID_HEAD:
419                         wrapperClass = [DOMHTMLHeadElement class];
420                         break;
421                     case ID_LINK:
422                         wrapperClass = [DOMHTMLLinkElement class];
423                         break;
424                     case ID_TITLE:
425                         wrapperClass = [DOMHTMLTitleElement class];
426                         break;
427                     case ID_META:
428                         wrapperClass = [DOMHTMLMetaElement class];
429                         break;
430                     case ID_BASE:
431                         wrapperClass = [DOMHTMLBaseElement class];
432                         break;
433                     case ID_ISINDEX:
434                         wrapperClass = [DOMHTMLIsIndexElement class];
435                         break;
436                     case ID_STYLE:
437                         wrapperClass = [DOMHTMLStyleElement class];
438                         break;
439                     case ID_BODY:
440                         wrapperClass = [DOMHTMLBodyElement class];
441                         break;
442                     case ID_FORM:
443                         wrapperClass = [DOMHTMLFormElement class];
444                         break;
445                     case ID_SELECT:
446                         wrapperClass = [DOMHTMLSelectElement class];
447                         break;
448                     case ID_OPTGROUP:
449                         wrapperClass = [DOMHTMLOptGroupElement class];
450                         break;
451                     case ID_OPTION:
452                         wrapperClass = [DOMHTMLOptionElement class];
453                         break;
454                     case ID_INPUT:
455                         wrapperClass = [DOMHTMLInputElement class];
456                         break;
457                     case ID_TEXTAREA:
458                         wrapperClass = [DOMHTMLTextAreaElement class];
459                         break;
460                     case ID_BUTTON:
461                         wrapperClass = [DOMHTMLButtonElement class];
462                         break;
463                     case ID_LABEL:
464                         wrapperClass = [DOMHTMLLabelElement class];
465                         break;  
466                     case ID_FIELDSET:
467                         wrapperClass = [DOMHTMLFieldSetElement class];
468                         break;      
469                     case ID_LEGEND:
470                         wrapperClass = [DOMHTMLLegendElement class];
471                         break;
472                     case ID_UL:
473                         wrapperClass = [DOMHTMLUListElement class];
474                         break;
475                     case ID_OL:
476                         wrapperClass = [DOMHTMLOListElement class];
477                         break;
478                     case ID_DL:
479                         wrapperClass = [DOMHTMLDListElement class];
480                         break;
481                     case ID_DIR:
482                         wrapperClass = [DOMHTMLDirectoryElement class];
483                         break;
484                     case ID_MENU:
485                         wrapperClass = [DOMHTMLMenuElement class];
486                         break;
487                     case ID_LI:
488                         wrapperClass = [DOMHTMLLIElement class];
489                         break;
490                     case ID_DIV:
491                         wrapperClass = [DOMHTMLDivElement class];
492                         break;
493                     case ID_P:
494                         wrapperClass = [DOMHTMLParagraphElement class];
495                         break;
496                     case ID_Q:
497                         wrapperClass = [DOMHTMLQuoteElement class];
498                         break;
499                     case ID_PRE:
500                         wrapperClass = [DOMHTMLPreElement class];
501                         break;
502                     case ID_BR:
503                         wrapperClass = [DOMHTMLBRElement class];
504                         break;
505                     case ID_BASEFONT:
506                         wrapperClass = [DOMHTMLFontElement class];
507                         break;
508                     case ID_FONT:
509                         wrapperClass = [DOMHTMLFontElement class];
510                         break;
511                     case ID_HR:
512                         wrapperClass = [DOMHTMLHRElement class];
513                         break;
514                     case ID_A:
515                         wrapperClass = [DOMHTMLAnchorElement class];
516                         break;
517                     case ID_IMG:
518                         wrapperClass = [DOMHTMLImageElement class];
519                         break;
520                     case ID_OBJECT:
521                         wrapperClass = [DOMHTMLObjectElement class];
522                         break;
523                     case ID_PARAM:
524                         wrapperClass = [DOMHTMLParamElement class];
525                         break;
526                     case ID_APPLET:
527                         wrapperClass = [DOMHTMLAppletElement class];
528                         break;
529                     case ID_MAP:
530                         wrapperClass = [DOMHTMLMapElement class];
531                         break;
532                     case ID_AREA:
533                         wrapperClass = [DOMHTMLAreaElement class];
534                         break;
535                     case ID_SCRIPT:
536                         wrapperClass = [DOMHTMLScriptElement class];
537                         break;
538                     case ID_TABLE:
539                         wrapperClass = [DOMHTMLTableElement class];
540                         break;
541                     case ID_TD:
542                         wrapperClass = [DOMHTMLTableCellElement class];
543                         break;
544                     case ID_TR:
545                         wrapperClass = [DOMHTMLTableRowElement class];
546                         break;
547                     case ID_FRAMESET:
548                         wrapperClass = [DOMHTMLFrameSetElement class];
549                         break;
550                     case ID_FRAME:
551                         wrapperClass = [DOMHTMLFrameElement class];
552                         break;
553                     case ID_IFRAME:
554                         wrapperClass = [DOMHTMLIFrameElement class];
555                         break;
556                     default:
557                         wrapperClass = [DOMHTMLElement class];
558                 }
559             } else {
560                 wrapperClass = [DOMElement class];
561             }
562             break;
563         case Node::ATTRIBUTE_NODE:
564             wrapperClass = [DOMAttr class];
565             break;
566         case Node::TEXT_NODE:
567             wrapperClass = [DOMText class];
568             break;
569         case Node::CDATA_SECTION_NODE:
570             wrapperClass = [DOMCDATASection class];
571             break;
572         case Node::ENTITY_REFERENCE_NODE:
573             wrapperClass = [DOMEntityReference class];
574             break;
575         case Node::ENTITY_NODE:
576             wrapperClass = [DOMEntity class];
577             break;
578         case Node::PROCESSING_INSTRUCTION_NODE:
579             wrapperClass = [DOMProcessingInstruction class];
580             break;
581         case Node::COMMENT_NODE:
582             wrapperClass = [DOMComment class];
583             break;
584         case Node::DOCUMENT_NODE:
585             if (static_cast<DocumentImpl *>(impl)->isHTMLDocument()) {
586                 wrapperClass = [DOMHTMLDocument class];
587             } else {
588                 wrapperClass = [DOMDocument class];
589             }
590             break;
591         case Node::DOCUMENT_TYPE_NODE:
592             wrapperClass = [DOMDocumentType class];
593             break;
594         case Node::DOCUMENT_FRAGMENT_NODE:
595             wrapperClass = [DOMDocumentFragment class];
596             break;
597         case Node::NOTATION_NODE:
598             wrapperClass = [DOMNotation class];
599             break;
600     }
601     return [[[wrapperClass alloc] _initWithNodeImpl:impl] autorelease];
602 }
603
604 - (NodeImpl *)_nodeImpl
605 {
606     return DOM_cast<NodeImpl *>(_internal);
607 }
608
609 - (BOOL)isContentEditable
610 {
611     return [self _nodeImpl]->isContentEditable();
612 }
613
614 @end
615
616 //------------------------------------------------------------------------------------------
617 // DOMNamedNodeMap
618
619 @implementation DOMNamedNodeMap
620
621 - (void)dealloc
622 {
623     if (_internal) {
624         DOM_cast<NamedNodeMapImpl *>(_internal)->deref();
625     }
626     [super dealloc];
627 }
628
629 - (void)finalize
630 {
631     if (_internal) {
632         DOM_cast<NamedNodeMapImpl *>(_internal)->deref();
633     }
634     [super finalize];
635 }
636
637 - (NamedNodeMapImpl *)_namedNodeMapImpl
638 {
639     return DOM_cast<NamedNodeMapImpl *>(_internal);
640 }
641
642 - (DOMNode *)getNamedItem:(NSString *)name
643 {
644     ASSERT(name);
645
646     // Method not reflected in DOM::NamedNodeMapImpl interface
647     NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
648     Node result(map.getNamedItem(name));
649     return [DOMNode _nodeWithImpl:result.handle()];
650 }
651
652 - (DOMNode *)setNamedItem:(DOMNode *)arg
653 {
654     ASSERT(arg);
655
656     // Method not reflected in DOM::NamedNodeMapImpl interface
657     try {
658         NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
659         Node result(map.setNamedItem([arg _nodeImpl]));
660         return [DOMNode _nodeWithImpl:result.handle()];
661     } 
662     catch (const DOM::DOMException &e) {
663         raiseOnDOMError(e.code);
664         return nil;
665     }
666 }
667
668 - (DOMNode *)removeNamedItem:(NSString *)name
669 {
670     ASSERT(name);
671
672     // Method not reflected in DOM::NamedNodeMapImpl interface
673     try {
674         NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
675         Node result(map.removeNamedItem(name));
676         return [DOMNode _nodeWithImpl:result.handle()];
677     } 
678     catch (const DOM::DOMException &e) {
679         raiseOnDOMError(e.code);
680         return nil;
681     }
682 }
683
684 - (DOMNode *)item:(unsigned long)index
685 {
686     return [DOMNode _nodeWithImpl:[self _namedNodeMapImpl]->item(index)];
687 }
688
689 - (unsigned long)length
690 {
691     return [self _namedNodeMapImpl]->length();
692 }
693
694 - (DOMNode *)getNamedItemNS:(NSString *)namespaceURI :(NSString *)localName
695 {
696     if (!namespaceURI || !localName) {
697         return nil;
698     }
699
700     // Method not reflected in DOM::NamedNodeMapImpl interface
701     NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
702     Node result(map.getNamedItemNS(namespaceURI, localName));
703     return [DOMNode _nodeWithImpl:result.handle()];
704 }
705
706 - (DOMNode *)setNamedItemNS:(DOMNode *)arg
707 {
708     ASSERT(arg);
709
710     // Method not reflected in DOM::NamedNodeMapImpl interface
711     try {
712         NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
713         Node result(map.setNamedItemNS([arg _nodeImpl]));
714         return [DOMNode _nodeWithImpl:result.handle()];
715     } 
716     catch (const DOM::DOMException &e) {
717         raiseOnDOMError(e.code);
718         return nil;
719     }
720 }
721
722 - (DOMNode *)removeNamedItemNS:(NSString *)namespaceURI :(NSString *)localName
723 {
724     ASSERT(namespaceURI);
725     ASSERT(localName);
726
727     // Method not reflected in DOM::NamedNodeMapImpl interface
728     try {
729         NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
730         Node result(map.removeNamedItemNS(namespaceURI, localName));
731         return [DOMNode _nodeWithImpl:result.handle()];
732     } 
733     catch (const DOM::DOMException &e) {
734         raiseOnDOMError(e.code);
735         return nil;
736     }
737 }
738
739 @end
740
741 @implementation DOMNamedNodeMap (WebCoreInternal)
742
743 - (id)_initWithNamedNodeMapImpl:(NamedNodeMapImpl *)impl
744 {
745     ASSERT(impl);
746
747     [super _init];
748     _internal = DOM_cast<DOMObjectInternal *>(impl);
749     impl->ref();
750     addDOMWrapper(self, impl);
751     return self;
752 }
753
754 + (DOMNamedNodeMap *)_namedNodeMapWithImpl:(NamedNodeMapImpl *)impl
755 {
756     if (!impl)
757         return nil;
758     
759     id cachedInstance;
760     cachedInstance = getDOMWrapper(impl);
761     if (cachedInstance)
762         return [[cachedInstance retain] autorelease];
763     
764     return [[[self alloc] _initWithNamedNodeMapImpl:impl] autorelease];
765 }
766
767 @end
768
769 //------------------------------------------------------------------------------------------
770 // DOMNodeList
771
772 @implementation DOMNodeList
773
774 - (void)dealloc
775 {
776     if (_internal) {
777         DOM_cast<NodeListImpl *>(_internal)->deref();
778     }
779     [super dealloc];
780 }
781
782 - (void)finalize
783 {
784     if (_internal) {
785         DOM_cast<NodeListImpl *>(_internal)->deref();
786     }
787     [super finalize];
788 }
789
790 - (NodeListImpl *)_nodeListImpl
791 {
792     return DOM_cast<NodeListImpl *>(_internal);
793 }
794
795 - (DOMNode *)item:(unsigned long)index
796 {
797     return [DOMNode _nodeWithImpl:[self _nodeListImpl]->item(index)];
798 }
799
800 - (unsigned long)length
801 {
802     return [self _nodeListImpl]->length();
803 }
804
805 @end
806
807 @implementation DOMNodeList (WebCoreInternal)
808
809 - (id)_initWithNodeListImpl:(NodeListImpl *)impl
810 {
811     ASSERT(impl);
812
813     [super _init];
814     _internal = DOM_cast<DOMObjectInternal *>(impl);
815     impl->ref();
816     addDOMWrapper(self, impl);
817     return self;
818 }
819
820 + (DOMNodeList *)_nodeListWithImpl:(NodeListImpl *)impl
821 {
822     if (!impl)
823         return nil;
824     
825     id cachedInstance;
826     cachedInstance = getDOMWrapper(impl);
827     if (cachedInstance)
828         return [[cachedInstance retain] autorelease];
829     
830     return [[[self alloc] _initWithNodeListImpl:impl] autorelease];
831 }
832
833 @end
834
835 //------------------------------------------------------------------------------------------
836 // DOMImplementation
837
838 @implementation DOMImplementation
839
840 - (void)dealloc
841 {
842     if (_internal) {
843         DOM_cast<DOMImplementationImpl *>(_internal)->deref();
844     }
845     [super dealloc];
846 }
847
848 - (void)finalize
849 {
850     if (_internal) {
851         DOM_cast<DOMImplementationImpl *>(_internal)->deref();
852     }
853     [super finalize];
854 }
855
856 - (BOOL)hasFeature:(NSString *)feature :(NSString *)version
857 {
858     ASSERT(feature);
859     ASSERT(version);
860
861     return [self _DOMImplementationImpl]->hasFeature(feature, version);
862 }
863
864 - (DOMDocumentType *)createDocumentType:(NSString *)qualifiedName :(NSString *)publicId :(NSString *)systemId
865 {
866     ASSERT(qualifiedName);
867     ASSERT(publicId);
868     ASSERT(systemId);
869
870     int exceptionCode = 0;
871     DocumentTypeImpl *impl = [self _DOMImplementationImpl]->createDocumentType(qualifiedName, publicId, systemId, exceptionCode);
872     raiseOnDOMError(exceptionCode);
873     return static_cast<DOMDocumentType *>([DOMNode _nodeWithImpl:impl]);
874 }
875
876 - (DOMDocument *)createDocument:(NSString *)namespaceURI :(NSString *)qualifiedName :(DOMDocumentType *)doctype
877 {
878     ASSERT(namespaceURI);
879     ASSERT(qualifiedName);
880
881     int exceptionCode = 0;
882     DocumentType dt = DocumentTypeImpl::createInstance(static_cast<DocumentTypeImpl *>([doctype _nodeImpl]));
883     DocumentImpl *impl = [self _DOMImplementationImpl]->createDocument(namespaceURI, qualifiedName, dt, exceptionCode);
884     raiseOnDOMError(exceptionCode);
885     return static_cast<DOMDocument *>([DOMNode _nodeWithImpl:impl]);
886 }
887
888 @end
889
890 @implementation DOMImplementation (DOMImplementationCSS)
891
892 - (DOMCSSStyleSheet *)createCSSStyleSheet:(NSString *)title :(NSString *)media
893 {
894     ASSERT(title);
895     ASSERT(media);
896
897     int exceptionCode = 0;
898     DOMString titleString(title);
899     DOMString mediaString(media);
900     DOMCSSStyleSheet *result = [DOMCSSStyleSheet _CSSStyleSheetWithImpl:[self _DOMImplementationImpl]->createCSSStyleSheet(titleString.implementation(), mediaString.implementation(), exceptionCode)];
901     raiseOnDOMError(exceptionCode);
902     return result;
903 }
904
905 @end
906  
907 @implementation DOMImplementation (WebCoreInternal)
908
909 - (id)_initWithDOMImplementationImpl:(DOMImplementationImpl *)impl
910 {
911     ASSERT(impl);
912
913     [super _init];
914     _internal = DOM_cast<DOMObjectInternal *>(impl);
915     impl->ref();
916     addDOMWrapper(self, impl);
917     return self;
918 }
919
920 + (DOMImplementation *)_DOMImplementationWithImpl:(DOMImplementationImpl *)impl
921 {
922     if (!impl)
923         return nil;
924     
925     id cachedInstance;
926     cachedInstance = getDOMWrapper(impl);
927     if (cachedInstance)
928         return [[cachedInstance retain] autorelease];
929     
930     return [[[self alloc] _initWithDOMImplementationImpl:impl] autorelease];
931 }
932
933 - (DOMImplementationImpl *)_DOMImplementationImpl
934 {
935     return DOM_cast<DOMImplementationImpl *>(_internal);
936 }
937
938 @end
939
940 //------------------------------------------------------------------------------------------
941 // DOMDocumentFragment
942
943 @implementation DOMDocumentFragment
944
945 @end
946
947 @implementation DOMDocumentFragment (WebCoreInternal)
948
949 + (DOMDocumentFragment *)_documentFragmentWithImpl:(DocumentFragmentImpl *)impl
950 {
951     return static_cast<DOMDocumentFragment *>([DOMNode _nodeWithImpl:impl]);
952 }
953
954 - (DocumentFragmentImpl *)_fragmentImpl
955 {
956     return static_cast<DocumentFragmentImpl *>(DOM_cast<NodeImpl *>(_internal));
957 }
958
959 @end
960
961 //------------------------------------------------------------------------------------------
962 // DOMDocument
963
964 @implementation DOMDocument
965
966 - (DOMDocumentType *)doctype
967 {
968     return static_cast<DOMDocumentType *>([DOMNode _nodeWithImpl:[self _documentImpl]->doctype()]);
969 }
970
971 - (DOMImplementation *)implementation
972 {
973     return [DOMImplementation _DOMImplementationWithImpl:[self _documentImpl]->implementation()];
974 }
975
976 - (DOMElement *)documentElement
977 {
978     return static_cast<DOMElement *>([DOMNode _nodeWithImpl:[self _documentImpl]->documentElement()]);
979 }
980
981 - (DOMElement *)createElement:(NSString *)tagName
982 {
983     ASSERT(tagName);
984
985     int exceptionCode = 0;
986     DOMElement *result = static_cast<DOMElement *>([DOMNode _nodeWithImpl:[self _documentImpl]->createElement(tagName, exceptionCode)]);
987     raiseOnDOMError(exceptionCode);
988     return result;
989 }
990
991 - (DOMDocumentFragment *)createDocumentFragment
992 {
993     return static_cast<DOMDocumentFragment *>([DOMNode _nodeWithImpl:[self _documentImpl]->createDocumentFragment()]);
994 }
995
996 - (DOMText *)createTextNode:(NSString *)data
997 {
998     ASSERT(data);
999     return static_cast<DOMText *>([DOMNode _nodeWithImpl:[self _documentImpl]->createTextNode(data)]);
1000 }
1001
1002 - (DOMComment *)createComment:(NSString *)data
1003 {
1004     ASSERT(data);
1005     return static_cast<DOMComment *>([DOMNode _nodeWithImpl:[self _documentImpl]->createComment(data)]);
1006 }
1007
1008 - (DOMCDATASection *)createCDATASection:(NSString *)data
1009 {
1010     ASSERT(data);
1011
1012     // Documentation says we can raise a NOT_SUPPORTED_ERR.
1013     // However, the lower layer does not report that error up to us.
1014     return static_cast<DOMCDATASection *>([DOMNode _nodeWithImpl:[self _documentImpl]->createCDATASection(data)]);
1015 }
1016
1017 - (DOMProcessingInstruction *)createProcessingInstruction:(NSString *)target :(NSString *)data
1018 {
1019     ASSERT(target);
1020     ASSERT(data);
1021
1022     // Documentation says we can raise a INVALID_CHARACTER_ERR or a NOT_SUPPORTED_ERR.
1023     // However, the lower layer does not report these errors up to us.
1024     return static_cast<DOMProcessingInstruction *>([DOMNode _nodeWithImpl:[self _documentImpl]->createProcessingInstruction(target, data)]);
1025 }
1026
1027 - (DOMAttr *)createAttribute:(NSString *)name
1028 {
1029     ASSERT(name);
1030
1031     // Method not reflected in DOM::DocumentImpl interface
1032     try {
1033         Document doc(DocumentImpl::createInstance([self _documentImpl]));
1034         Attr result(doc.createAttribute(name));
1035         return static_cast<DOMAttr *>([DOMNode _nodeWithImpl:result.handle()]);
1036     } 
1037     catch (const DOM::DOMException &e) {
1038         raiseOnDOMError(e.code);
1039         return nil;
1040     }
1041 }
1042
1043 - (DOMEntityReference *)createEntityReference:(NSString *)name
1044 {
1045     ASSERT(name);
1046
1047     // Documentation says we can raise a INVALID_CHARACTER_ERR or a NOT_SUPPORTED_ERR.
1048     // However, the lower layer does not report these errors up to us.
1049     return static_cast<DOMEntityReference *>([DOMNode _nodeWithImpl:[self _documentImpl]->createEntityReference(name)]);
1050 }
1051
1052 - (DOMNodeList *)getElementsByTagName:(NSString *)tagname
1053 {
1054     ASSERT(tagname);
1055     return [DOMNodeList _nodeListWithImpl:[self _documentImpl]->getElementsByTagNameNS(0, DOMString(tagname).implementation())];
1056 }
1057
1058 - (DOMNode *)importNode:(DOMNode *)importedNode :(BOOL)deep
1059 {
1060     int exceptionCode = 0;
1061     DOMNode *result = [DOMNode _nodeWithImpl:[self _documentImpl]->importNode([importedNode _nodeImpl], deep, exceptionCode)];
1062     raiseOnDOMError(exceptionCode);
1063     return result;
1064 }
1065
1066 - (DOMElement *)createElementNS:(NSString *)namespaceURI :(NSString *)qualifiedName
1067 {
1068     ASSERT(namespaceURI);
1069     ASSERT(qualifiedName);
1070
1071     int exceptionCode = 0;
1072     DOMNode *result = [DOMNode _nodeWithImpl:[self _documentImpl]->createElementNS(namespaceURI, qualifiedName, exceptionCode)];
1073     raiseOnDOMError(exceptionCode);
1074     return static_cast<DOMElement *>(result);
1075 }
1076
1077 - (DOMAttr *)createAttributeNS:(NSString *)namespaceURI :(NSString *)qualifiedName
1078 {
1079     ASSERT(namespaceURI);
1080     ASSERT(qualifiedName);
1081
1082     // Method not reflected in DOM::DocumentImpl interface
1083     try {
1084         Document doc(DocumentImpl::createInstance([self _documentImpl]));
1085         Attr result(doc.createAttributeNS(namespaceURI, qualifiedName));
1086         return static_cast<DOMAttr *>([DOMNode _nodeWithImpl:result.handle()]);
1087     } 
1088     catch (const DOM::DOMException &e) {
1089         raiseOnDOMError(e.code);
1090         return nil;
1091     }
1092 }
1093
1094 - (DOMNodeList *)getElementsByTagNameNS:(NSString *)namespaceURI :(NSString *)localName
1095 {
1096     ASSERT(namespaceURI);
1097     ASSERT(localName);
1098
1099     return [DOMNodeList _nodeListWithImpl:[self _documentImpl]->getElementsByTagNameNS(DOMString(namespaceURI).implementation(), DOMString(localName).implementation())];
1100 }
1101
1102 - (DOMElement *)getElementById:(NSString *)elementId
1103 {
1104     ASSERT(elementId);
1105
1106     return static_cast<DOMElement *>([DOMNode _nodeWithImpl:[self _documentImpl]->getElementById(elementId)]);
1107 }
1108
1109 @end
1110
1111 @implementation DOMDocument (DOMDocumentRange)
1112
1113 - (DOMRange *)createRange
1114 {
1115     return [DOMRange _rangeWithImpl:[self _documentImpl]->createRange()];
1116 }
1117
1118 @end
1119
1120 @implementation DOMDocument (DOMDocumentCSS)
1121
1122 - (DOMCSSStyleDeclaration *)getComputedStyle:(DOMElement *)elt :(NSString *)pseudoElt
1123 {
1124     ElementImpl *elementImpl = [elt _elementImpl];
1125     DOMString pseudoEltString(pseudoElt);
1126     return [DOMCSSStyleDeclaration _styleDeclarationWithImpl:[self _documentImpl]->defaultView()->getComputedStyle(elementImpl, pseudoEltString.implementation())];
1127 }
1128
1129 - (DOMCSSStyleDeclaration *)getOverrideStyle:(DOMElement *)elt :(NSString *)pseudoElt;
1130 {
1131     // FIXME: This is unimplemented by khtml, 
1132     // so for now, we just return the computed style
1133     return [self getComputedStyle:elt :pseudoElt];
1134 }
1135
1136 @end
1137
1138 @implementation DOMDocument (DOMDocumentStyle)
1139
1140 - (DOMStyleSheetList *)styleSheets
1141 {
1142     return [DOMStyleSheetList _styleSheetListWithImpl:[self _documentImpl]->styleSheets()];
1143 }
1144
1145 @end
1146
1147 @implementation DOMDocument (DOMDocumentExtensions)
1148
1149 - (DOMCSSStyleDeclaration *)createCSSStyleDeclaration;
1150 {
1151     return [DOMCSSStyleDeclaration _styleDeclarationWithImpl:[self _documentImpl]->createCSSStyleDeclaration()];
1152 }
1153
1154 @end
1155
1156 @implementation DOMDocument (WebCoreInternal)
1157
1158 + (DOMDocument *)_documentWithImpl:(DocumentImpl *)impl
1159 {
1160     return static_cast<DOMDocument *>([DOMNode _nodeWithImpl:impl]);
1161 }
1162
1163 - (DocumentImpl *)_documentImpl
1164 {
1165     return static_cast<DocumentImpl *>(DOM_cast<NodeImpl *>(_internal));
1166 }
1167
1168 - (DOMElement *)_ownerElement
1169 {
1170     ElementImpl *element = [self _documentImpl]->ownerElement();
1171     return element ? [DOMElement _elementWithImpl:element] : nil;
1172 }
1173
1174 @end
1175
1176 //------------------------------------------------------------------------------------------
1177 // DOMCharacterData
1178
1179 @implementation DOMCharacterData
1180
1181 - (CharacterDataImpl *)_characterDataImpl
1182 {
1183     return static_cast<CharacterDataImpl *>(DOM_cast<NodeImpl *>(_internal));
1184 }
1185
1186 - (NSString *)data
1187 {
1188     // Documentation says we can raise a DOMSTRING_SIZE_ERR.
1189     // However, the lower layer does not report that error up to us.
1190     return [self _characterDataImpl]->data();
1191 }
1192
1193 - (void)setData:(NSString *)data
1194 {
1195     ASSERT(data);
1196     
1197     int exceptionCode = 0;
1198     [self _characterDataImpl]->setData(data, exceptionCode);
1199     raiseOnDOMError(exceptionCode);
1200 }
1201
1202 - (unsigned long)length
1203 {
1204     return [self _characterDataImpl]->length();
1205 }
1206
1207 - (NSString *)substringData:(unsigned long)offset :(unsigned long)count
1208 {
1209     int exceptionCode = 0;
1210     NSString *result = [self _characterDataImpl]->substringData(offset, count, exceptionCode);
1211     raiseOnDOMError(exceptionCode);
1212     return result;
1213 }
1214
1215 - (void)appendData:(NSString *)arg
1216 {
1217     ASSERT(arg);
1218     
1219     int exceptionCode = 0;
1220     [self _characterDataImpl]->appendData(arg, exceptionCode);
1221     raiseOnDOMError(exceptionCode);
1222 }
1223
1224 - (void)insertData:(unsigned long)offset :(NSString *)arg
1225 {
1226     ASSERT(arg);
1227     
1228     int exceptionCode = 0;
1229     [self _characterDataImpl]->insertData(offset, arg, exceptionCode);
1230     raiseOnDOMError(exceptionCode);
1231 }
1232
1233 - (void)deleteData:(unsigned long)offset :(unsigned long) count;
1234 {
1235     int exceptionCode = 0;
1236     [self _characterDataImpl]->deleteData(offset, count, exceptionCode);
1237     raiseOnDOMError(exceptionCode);
1238 }
1239
1240 - (void)replaceData:(unsigned long)offset :(unsigned long)count :(NSString *)arg
1241 {
1242     ASSERT(arg);
1243
1244     int exceptionCode = 0;
1245     [self _characterDataImpl]->replaceData(offset, count, arg, exceptionCode);
1246     raiseOnDOMError(exceptionCode);
1247 }
1248
1249 @end
1250
1251 //------------------------------------------------------------------------------------------
1252 // DOMAttr
1253
1254 @implementation DOMAttr
1255
1256 - (NSString *)name
1257 {
1258     return [self _attrImpl]->nodeName();
1259 }
1260
1261 - (BOOL)specified
1262 {
1263     return [self _attrImpl]->specified();
1264 }
1265
1266 - (NSString *)value
1267 {
1268     return [self _attrImpl]->nodeValue();
1269 }
1270
1271 - (void)setValue:(NSString *)value
1272 {
1273     ASSERT(value);
1274
1275     int exceptionCode = 0;
1276     [self _attrImpl]->setValue(value, exceptionCode);
1277     raiseOnDOMError(exceptionCode);
1278 }
1279
1280 - (DOMElement *)ownerElement
1281 {
1282     return [DOMElement _elementWithImpl:[self _attrImpl]->ownerElement()];
1283 }
1284
1285 @end
1286
1287 @implementation DOMAttr (WebCoreInternal)
1288
1289 + (DOMAttr *)_attrWithImpl:(AttrImpl *)impl
1290 {
1291     return static_cast<DOMAttr *>([DOMNode _nodeWithImpl:impl]);
1292 }
1293
1294 - (AttrImpl *)_attrImpl
1295 {
1296     return static_cast<AttrImpl *>(DOM_cast<NodeImpl *>(_internal));
1297 }
1298
1299 @end
1300
1301 //------------------------------------------------------------------------------------------
1302 // DOMElement
1303
1304 @implementation DOMElement
1305
1306 - (NSString *)tagName
1307 {
1308     return [self _elementImpl]->tagName();
1309 }
1310
1311 - (DOMNamedNodeMap *)attributes
1312 {
1313     return [DOMNamedNodeMap _namedNodeMapWithImpl:[self _elementImpl]->attributes()];
1314 }
1315
1316 - (NSString *)getAttribute:(NSString *)name
1317 {
1318     ASSERT(name);
1319     return [self _elementImpl]->getAttribute(name);
1320 }
1321
1322 - (void)setAttribute:(NSString *)name :(NSString *)value
1323 {
1324     ASSERT(name);
1325     ASSERT(value);
1326
1327     // Method not reflected in DOM::ElementImpl interface
1328     try {
1329         Element element(ElementImpl::createInstance([self _elementImpl]));
1330         element.setAttribute(name, value);
1331     } 
1332     catch (const DOM::DOMException &e) {
1333         raiseOnDOMError(e.code);
1334     }
1335 }
1336
1337 - (void)removeAttribute:(NSString *)name
1338 {
1339     ASSERT(name);
1340
1341     // Method not reflected in DOM::ElementImpl interface
1342     try {
1343         Element element(ElementImpl::createInstance([self _elementImpl]));
1344         element.removeAttribute(name);
1345     } 
1346     catch (const DOM::DOMException &e) {
1347         raiseOnDOMError(e.code);
1348     }
1349 }
1350
1351 - (DOMAttr *)getAttributeNode:(NSString *)name
1352 {
1353     ASSERT(name);
1354
1355     // Method not reflected in DOM::ElementImpl interface
1356     Element element(ElementImpl::createInstance([self _elementImpl]));
1357     Attr result(element.getAttributeNode(name));
1358     return [DOMAttr _attrWithImpl:static_cast<AttrImpl *>(result.handle())];
1359 }
1360
1361 - (DOMAttr *)setAttributeNode:(DOMAttr *)newAttr
1362 {
1363     ASSERT(newAttr);
1364
1365     // Method not reflected in DOM::ElementImpl interface
1366     try {
1367         Element element(ElementImpl::createInstance([self _elementImpl]));
1368         Attr attr(AttrImpl::createInstance([newAttr _attrImpl]));
1369         Attr result(element.setAttributeNode(attr));
1370         return [DOMAttr _attrWithImpl:static_cast<AttrImpl *>(result.handle())];
1371     } 
1372     catch (const DOM::DOMException &e) {
1373         raiseOnDOMError(e.code);
1374         return nil;
1375     }
1376 }
1377
1378 - (DOMAttr *)removeAttributeNode:(DOMAttr *)oldAttr
1379 {
1380     ASSERT(oldAttr);
1381
1382     // Method not reflected in DOM::ElementImpl interface
1383     try {
1384         Element element(ElementImpl::createInstance([self _elementImpl]));
1385         Attr attr(AttrImpl::createInstance([oldAttr _attrImpl]));
1386         Attr result(element.removeAttributeNode(attr));
1387         return [DOMAttr _attrWithImpl:static_cast<AttrImpl *>(result.handle())];
1388     } 
1389     catch (const DOM::DOMException &e) {
1390         raiseOnDOMError(e.code);
1391         return nil;
1392     }
1393 }
1394
1395 - (DOMNodeList *)getElementsByTagName:(NSString *)name
1396 {
1397     ASSERT(name);
1398
1399     return [DOMNodeList _nodeListWithImpl:[self _elementImpl]->getElementsByTagNameNS(0, DOMString(name).implementation())];
1400 }
1401
1402 - (NSString *)getAttributeNS:(NSString *)namespaceURI :(NSString *)localName
1403 {
1404     ASSERT(namespaceURI);
1405     ASSERT(localName);
1406
1407     Element element(ElementImpl::createInstance([self _elementImpl]));
1408     return element.getAttributeNS(namespaceURI, localName);
1409 }
1410
1411 - (void)setAttributeNS:(NSString *)namespaceURI :(NSString *)qualifiedName :(NSString *)value
1412 {
1413     ASSERT(namespaceURI);
1414     ASSERT(qualifiedName);
1415     ASSERT(value);
1416
1417     // Method not reflected in DOM::ElementImpl interface
1418     try {
1419         Element element(ElementImpl::createInstance([self _elementImpl]));
1420         element.setAttributeNS(namespaceURI, qualifiedName, value);
1421     }
1422     catch (const DOM::DOMException &e) {
1423         raiseOnDOMError(e.code);
1424     }
1425 }
1426
1427 - (void)removeAttributeNS:(NSString *)namespaceURI :(NSString *)localName
1428 {
1429     ASSERT(namespaceURI);
1430     ASSERT(localName);
1431
1432     // Method not reflected in DOM::ElementImpl interface
1433     try {
1434         Element element(ElementImpl::createInstance([self _elementImpl]));
1435         element.removeAttributeNS(namespaceURI, localName);
1436     } 
1437     catch (const DOM::DOMException &e) {
1438         raiseOnDOMError(e.code);
1439     }
1440 }
1441
1442 - (DOMAttr *)getAttributeNodeNS:(NSString *)namespaceURI :(NSString *)localName
1443 {
1444     ASSERT(namespaceURI);
1445     ASSERT(localName);
1446
1447     // Method not reflected in DOM::ElementImpl interface
1448     Element element(ElementImpl::createInstance([self _elementImpl]));
1449     Attr result(element.getAttributeNodeNS(namespaceURI, localName));
1450     return [DOMAttr _attrWithImpl:static_cast<AttrImpl *>(result.handle())];
1451 }
1452
1453 - (DOMAttr *)setAttributeNodeNS:(DOMAttr *)newAttr
1454 {
1455     ASSERT(newAttr);
1456
1457     // Method not reflected in DOM::ElementImpl interface
1458     try {
1459         Element element(ElementImpl::createInstance([self _elementImpl]));
1460         Attr attr(AttrImpl::createInstance([newAttr _attrImpl]));
1461         Attr result(element.setAttributeNodeNS(attr));
1462         return [DOMAttr _attrWithImpl:static_cast<AttrImpl *>(result.handle())];
1463     } 
1464     catch (const DOM::DOMException &e) {
1465         raiseOnDOMError(e.code);
1466         return nil;
1467     }
1468 }
1469
1470 - (DOMNodeList *)getElementsByTagNameNS:(NSString *)namespaceURI :(NSString *)localName
1471 {
1472     ASSERT(namespaceURI);
1473     ASSERT(localName);
1474
1475     return [DOMNodeList _nodeListWithImpl:[self _elementImpl]->getElementsByTagNameNS(DOMString(namespaceURI).implementation(), DOMString(localName).implementation())];
1476 }
1477
1478 - (BOOL)hasAttribute:(NSString *)name
1479 {
1480     ASSERT(name);
1481
1482     // Method not reflected in DOM::ElementImpl interface
1483     Element element(ElementImpl::createInstance([self _elementImpl]));
1484     return element.hasAttribute(name);
1485 }
1486
1487 - (BOOL)hasAttributeNS:(NSString *)namespaceURI :(NSString *)localName
1488 {
1489     ASSERT(namespaceURI);
1490     ASSERT(localName);
1491
1492     // Method not reflected in DOM::ElementImpl interface
1493     Element element(ElementImpl::createInstance([self _elementImpl]));
1494     return element.hasAttributeNS(namespaceURI, localName);
1495 }
1496
1497 @end
1498
1499 @implementation DOMElement (DOMElementCSSInlineStyle)
1500
1501 - (DOMCSSStyleDeclaration *)style
1502 {
1503     ElementImpl *impl = [self _elementImpl];
1504     if (impl->isHTMLElement())
1505         return [DOMCSSStyleDeclaration _styleDeclarationWithImpl:static_cast<HTMLElementImpl *>(impl)->getInlineStyleDecl()];
1506     return nil;
1507 }
1508
1509 @end
1510
1511 @implementation DOMElement (WebCoreInternal)
1512
1513 + (DOMElement *)_elementWithImpl:(ElementImpl *)impl
1514 {
1515     return static_cast<DOMElement *>([DOMNode _nodeWithImpl:impl]);
1516 }
1517
1518 - (ElementImpl *)_elementImpl
1519 {
1520     return static_cast<ElementImpl *>(DOM_cast<NodeImpl *>(_internal));
1521 }
1522
1523 @end
1524
1525 //------------------------------------------------------------------------------------------
1526 // DOMText
1527
1528 @implementation DOMText
1529
1530 - (TextImpl *)_textImpl
1531 {
1532     return static_cast<TextImpl *>(DOM_cast<NodeImpl *>(_internal));
1533 }
1534
1535 - (DOMText *)splitText:(unsigned long)offset
1536 {
1537     int exceptionCode = 0;
1538     DOMNode *result = [DOMNode _nodeWithImpl:[self _textImpl]->splitText(offset, exceptionCode)];
1539     raiseOnDOMError(exceptionCode);
1540     return static_cast<DOMText *>(result);
1541 }
1542
1543 @end
1544
1545 //------------------------------------------------------------------------------------------
1546 // DOMComment
1547
1548 @implementation DOMComment
1549
1550 @end
1551
1552 //------------------------------------------------------------------------------------------
1553 // DOMCDATASection
1554
1555 @implementation DOMCDATASection
1556
1557 @end
1558
1559 //------------------------------------------------------------------------------------------
1560 // DOMDocumentType
1561
1562 @implementation DOMDocumentType
1563
1564 - (DocumentTypeImpl *)_documentTypeImpl
1565 {
1566     return static_cast<DocumentTypeImpl *>(DOM_cast<NodeImpl *>(_internal));
1567 }
1568
1569 - (NSString *)name
1570 {
1571     return [self _documentTypeImpl]->publicId();
1572 }
1573
1574 - (DOMNamedNodeMap *)entities
1575 {
1576     return [DOMNamedNodeMap _namedNodeMapWithImpl:[self _documentTypeImpl]->entities()];
1577 }
1578
1579 - (DOMNamedNodeMap *)notations
1580 {
1581     return [DOMNamedNodeMap _namedNodeMapWithImpl:[self _documentTypeImpl]->notations()];
1582 }
1583
1584 - (NSString *)publicId
1585 {
1586     return [self _documentTypeImpl]->publicId();
1587 }
1588
1589 - (NSString *)systemId
1590 {
1591     return [self _documentTypeImpl]->systemId();
1592 }
1593
1594 - (NSString *)internalSubset
1595 {
1596     return [self _documentTypeImpl]->internalSubset();
1597 }
1598
1599 @end
1600
1601 //------------------------------------------------------------------------------------------
1602 // DOMNotation
1603
1604 @implementation DOMNotation
1605
1606 - (NotationImpl *)_notationImpl
1607 {
1608     return static_cast<NotationImpl *>(DOM_cast<NodeImpl *>(_internal));
1609 }
1610
1611 - (NSString *)publicId
1612 {
1613     return [self _notationImpl]->publicId();
1614 }
1615
1616 - (NSString *)systemId
1617 {
1618     return [self _notationImpl]->systemId();
1619 }
1620
1621 @end
1622
1623 //------------------------------------------------------------------------------------------
1624 // DOMEntity
1625
1626 @implementation DOMEntity
1627
1628 - (EntityImpl *)_entityImpl
1629 {
1630     return static_cast<EntityImpl *>(DOM_cast<NodeImpl *>(_internal));
1631 }
1632
1633 - (NSString *)publicId
1634 {
1635     return [self _entityImpl]->publicId();
1636 }
1637
1638 - (NSString *)systemId
1639 {
1640     return [self _entityImpl]->systemId();
1641 }
1642
1643 - (NSString *)notationName
1644 {
1645     return [self _entityImpl]->notationName();
1646 }
1647
1648 @end
1649
1650 //------------------------------------------------------------------------------------------
1651 // DOMEntityReference
1652
1653 @implementation DOMEntityReference
1654
1655 @end
1656
1657 //------------------------------------------------------------------------------------------
1658 // DOMProcessingInstruction
1659
1660 @implementation DOMProcessingInstruction
1661
1662 - (ProcessingInstructionImpl *)_processingInstructionImpl
1663 {
1664     return static_cast<ProcessingInstructionImpl *>(DOM_cast<NodeImpl *>(_internal));
1665 }
1666
1667 - (NSString *)target
1668 {
1669     return [self _processingInstructionImpl]->target();
1670 }
1671
1672 - (NSString *)data
1673 {
1674     return [self _processingInstructionImpl]->data();
1675 }
1676
1677 - (void)setData:(NSString *)data
1678 {
1679     ASSERT(data);
1680
1681     int exceptionCode = 0;
1682     [self _processingInstructionImpl]->setData(data, exceptionCode);
1683     raiseOnDOMError(exceptionCode);
1684 }
1685
1686 @end
1687
1688 //------------------------------------------------------------------------------------------
1689 // DOMRange
1690
1691 @implementation DOMRange
1692
1693 - (void)dealloc
1694 {
1695     if (_internal) {
1696         DOM_cast<RangeImpl *>(_internal)->deref();
1697     }
1698     [super dealloc];
1699 }
1700
1701 - (void)finalize
1702 {
1703     if (_internal) {
1704         DOM_cast<RangeImpl *>(_internal)->deref();
1705     }
1706     [super finalize];
1707 }
1708
1709 - (NSString *)description
1710 {
1711     if (!_internal)
1712         return @"DOMRange: null";
1713     return [NSString stringWithFormat:@"DOMRange: %@ %ld %@ %ld",
1714         [self startContainer], [self startOffset],
1715         [self endContainer], [self endOffset]];
1716 }
1717
1718 - (DOMNode *)startContainer
1719 {
1720     int exceptionCode = 0;
1721     DOMNode *result = [DOMNode _nodeWithImpl:[self _rangeImpl]->startContainer(exceptionCode)];
1722     raiseOnDOMError(exceptionCode);
1723     return result;
1724 }
1725
1726 - (long)startOffset
1727 {
1728     int exceptionCode = 0;
1729     long result = [self _rangeImpl]->startOffset(exceptionCode);
1730     raiseOnDOMError(exceptionCode);
1731     return result;
1732 }
1733
1734 - (DOMNode *)endContainer
1735 {
1736     int exceptionCode = 0;
1737     DOMNode *result = [DOMNode _nodeWithImpl:[self _rangeImpl]->endContainer(exceptionCode)];
1738     raiseOnDOMError(exceptionCode);
1739     return result;
1740 }
1741
1742 - (long)endOffset
1743 {
1744     int exceptionCode = 0;
1745     long result = [self _rangeImpl]->endOffset(exceptionCode);
1746     raiseOnDOMError(exceptionCode);
1747     return result;
1748 }
1749
1750 - (BOOL)collapsed
1751 {
1752     int exceptionCode = 0;
1753     BOOL result = [self _rangeImpl]->collapsed(exceptionCode);
1754     raiseOnDOMError(exceptionCode);
1755     return result;
1756 }
1757
1758 - (DOMNode *)commonAncestorContainer
1759 {
1760     int exceptionCode = 0;
1761     DOMNode *result = [DOMNode _nodeWithImpl:[self _rangeImpl]->commonAncestorContainer(exceptionCode)];
1762     raiseOnDOMError(exceptionCode);
1763     return result;
1764 }
1765
1766 - (void)setStart:(DOMNode *)refNode :(long)offset
1767 {
1768     int exceptionCode = 0;
1769     [self _rangeImpl]->setStart([refNode _nodeImpl], offset, exceptionCode);
1770     raiseOnDOMError(exceptionCode);
1771 }
1772
1773 - (void)setEnd:(DOMNode *)refNode :(long)offset
1774 {
1775     int exceptionCode = 0;
1776     [self _rangeImpl]->setEnd([refNode _nodeImpl], offset, exceptionCode);
1777     raiseOnDOMError(exceptionCode);
1778 }
1779
1780 - (void)setStartBefore:(DOMNode *)refNode
1781 {
1782     int exceptionCode = 0;
1783     [self _rangeImpl]->setStartBefore([refNode _nodeImpl], exceptionCode);
1784     raiseOnDOMError(exceptionCode);
1785 }
1786
1787 - (void)setStartAfter:(DOMNode *)refNode
1788 {
1789     int exceptionCode = 0;
1790     [self _rangeImpl]->setStartAfter([refNode _nodeImpl], exceptionCode);
1791     raiseOnDOMError(exceptionCode);
1792 }
1793
1794 - (void)setEndBefore:(DOMNode *)refNode
1795 {
1796     int exceptionCode = 0;
1797     [self _rangeImpl]->setEndBefore([refNode _nodeImpl], exceptionCode);
1798     raiseOnDOMError(exceptionCode);
1799 }
1800
1801 - (void)setEndAfter:(DOMNode *)refNode
1802 {
1803     int exceptionCode = 0;
1804     [self _rangeImpl]->setEndAfter([refNode _nodeImpl], exceptionCode);
1805     raiseOnDOMError(exceptionCode);
1806 }
1807
1808 - (void)collapse:(BOOL)toStart
1809 {
1810     int exceptionCode = 0;
1811     [self _rangeImpl]->collapse(toStart, exceptionCode);
1812     raiseOnDOMError(exceptionCode);
1813 }
1814
1815 - (void)selectNode:(DOMNode *)refNode
1816 {
1817     int exceptionCode = 0;
1818     [self _rangeImpl]->selectNode([refNode _nodeImpl], exceptionCode);
1819     raiseOnDOMError(exceptionCode);
1820 }
1821
1822 - (void)selectNodeContents:(DOMNode *)refNode
1823 {
1824     int exceptionCode = 0;
1825     [self _rangeImpl]->selectNodeContents([refNode _nodeImpl], exceptionCode);
1826     raiseOnDOMError(exceptionCode);
1827 }
1828
1829 - (short)compareBoundaryPoints:(unsigned short)how :(DOMRange *)sourceRange
1830 {
1831     int exceptionCode = 0;
1832     short result = [self _rangeImpl]->compareBoundaryPoints(static_cast<Range::CompareHow>(how), [sourceRange _rangeImpl], exceptionCode);
1833     raiseOnDOMError(exceptionCode);
1834     return result;
1835 }
1836
1837 - (void)deleteContents
1838 {
1839     int exceptionCode = 0;
1840     [self _rangeImpl]->deleteContents(exceptionCode);
1841     raiseOnDOMError(exceptionCode);
1842 }
1843
1844 - (DOMDocumentFragment *)extractContents
1845 {
1846     int exceptionCode = 0;
1847     DOMDocumentFragment *result = [DOMDocumentFragment _documentFragmentWithImpl:[self _rangeImpl]->extractContents(exceptionCode)];
1848     raiseOnDOMError(exceptionCode);
1849     return result;
1850 }
1851
1852 - (DOMDocumentFragment *)cloneContents
1853 {
1854     int exceptionCode = 0;
1855     DOMDocumentFragment *result = [DOMDocumentFragment _documentFragmentWithImpl:[self _rangeImpl]->cloneContents(exceptionCode)];
1856     raiseOnDOMError(exceptionCode);
1857     return result;
1858 }
1859
1860 - (void)insertNode:(DOMNode *)newNode
1861 {
1862     int exceptionCode = 0;
1863     [self _rangeImpl]->insertNode([newNode _nodeImpl], exceptionCode);
1864     raiseOnDOMError(exceptionCode);
1865 }
1866
1867 - (void)surroundContents:(DOMNode *)newParent
1868 {
1869     int exceptionCode = 0;
1870     [self _rangeImpl]->surroundContents([newParent _nodeImpl], exceptionCode);
1871     raiseOnDOMError(exceptionCode);
1872 }
1873
1874 - (DOMRange *)cloneRange
1875 {
1876     int exceptionCode = 0;
1877     DOMRange *result = [DOMRange _rangeWithImpl:[self _rangeImpl]->cloneRange(exceptionCode)];
1878     raiseOnDOMError(exceptionCode);
1879     return result;
1880 }
1881
1882 - (NSString *)toString
1883 {
1884     int exceptionCode = 0;
1885     NSString *result = [self _rangeImpl]->toString(exceptionCode);
1886     raiseOnDOMError(exceptionCode);
1887     return result;
1888 }
1889
1890 - (void)detach
1891 {
1892     int exceptionCode = 0;
1893     [self _rangeImpl]->detach(exceptionCode);
1894     raiseOnDOMError(exceptionCode);
1895 }
1896
1897 @end
1898
1899 @implementation DOMRange (WebCoreInternal)
1900
1901 - (id)_initWithRangeImpl:(RangeImpl *)impl
1902 {
1903     ASSERT(impl);
1904
1905     [super _init];
1906     _internal = DOM_cast<DOMObjectInternal *>(impl);
1907     impl->ref();
1908     addDOMWrapper(self, impl);
1909     return self;
1910 }
1911
1912 + (DOMRange *)_rangeWithImpl:(RangeImpl *)impl
1913 {
1914     if (!impl)
1915         return nil;
1916     
1917     id cachedInstance;
1918     cachedInstance = getDOMWrapper(impl);
1919     if (cachedInstance)
1920         return [[cachedInstance retain] autorelease];
1921     
1922     return [[[self alloc] _initWithRangeImpl:impl] autorelease];
1923 }
1924
1925 - (RangeImpl *)_rangeImpl
1926 {
1927     return DOM_cast<RangeImpl *>(_internal);
1928 }
1929
1930 @end
1931
1932 @implementation DOMRange (WebPrivate)
1933
1934 - (NSString *)_text
1935 {
1936     return [self _rangeImpl]->text().string().getNSString();
1937 }
1938
1939 @end
1940
1941 //------------------------------------------------------------------------------------------
1942
1943 //------------------------------------------------------------------------------------------
1944
1945 @implementation DOMNodeFilter
1946
1947 - (id)_initWithNodeFilterImpl:(NodeFilterImpl *)impl
1948 {
1949     ASSERT(impl);
1950
1951     [super _init];
1952     _internal = DOM_cast<DOMObjectInternal *>(impl);
1953     impl->ref();
1954     addDOMWrapper(self, impl);
1955     return self;
1956 }
1957
1958 + (DOMNodeFilter *)_nodeFilterWithImpl:(NodeFilterImpl *)impl
1959 {
1960     if (!impl)
1961         return nil;
1962     
1963     id cachedInstance;
1964     cachedInstance = getDOMWrapper(impl);
1965     if (cachedInstance)
1966         return [[cachedInstance retain] autorelease];
1967     
1968     return [[[self alloc] _initWithNodeFilterImpl:impl] autorelease];
1969 }
1970
1971 - (NodeFilterImpl *)_nodeFilterImpl
1972 {
1973     return DOM_cast<NodeFilterImpl *>(_internal);
1974 }
1975
1976 - (void)dealloc
1977 {
1978     if (_internal)
1979         DOM_cast<NodeFilterImpl *>(_internal)->deref();
1980     [super dealloc];
1981 }
1982
1983 - (void)finalize
1984 {
1985     if (_internal)
1986         DOM_cast<NodeFilterImpl *>(_internal)->deref();
1987     [super finalize];
1988 }
1989
1990 - (short)acceptNode:(DOMNode *)node
1991 {
1992     return [self _nodeFilterImpl]->acceptNode([node _nodeImpl]);
1993 }
1994
1995 @end
1996
1997
1998 @implementation DOMNodeIterator
1999
2000 - (id)_initWithNodeIteratorImpl:(NodeIteratorImpl *)impl filter:(id <DOMNodeFilter>)filter
2001 {
2002     ASSERT(impl);
2003
2004     [super _init];
2005     _internal = DOM_cast<DOMObjectInternal *>(impl);
2006     impl->ref();
2007     addDOMWrapper(self, impl);
2008     m_filter = [filter retain];
2009     return self;
2010 }
2011
2012 - (NodeIteratorImpl *)_nodeIteratorImpl
2013 {
2014     return DOM_cast<NodeIteratorImpl *>(_internal);
2015 }
2016
2017 - (void)dealloc
2018 {
2019     [m_filter release];
2020     if (_internal) {
2021         [self detach];
2022         DOM_cast<NodeIteratorImpl *>(_internal)->deref();
2023     }
2024     [super dealloc];
2025 }
2026
2027 - (void)finalize
2028 {
2029     if (_internal) {
2030         [self detach];
2031         DOM_cast<NodeIteratorImpl *>(_internal)->deref();
2032     }
2033     [super finalize];
2034 }
2035
2036 - (DOMNode *)root
2037 {
2038     return [DOMNode _nodeWithImpl:[self _nodeIteratorImpl]->root()];
2039 }
2040
2041 - (unsigned long)whatToShow
2042 {
2043     return [self _nodeIteratorImpl]->whatToShow();
2044 }
2045
2046 - (id <DOMNodeFilter>)filter
2047 {
2048     if (m_filter)
2049         // This node iterator was created from the objc side
2050         return [[m_filter retain] autorelease];
2051
2052     // This node iterator was created from the c++ side
2053     return [DOMNodeFilter _nodeFilterWithImpl:[self _nodeIteratorImpl]->filter()];
2054 }
2055
2056 - (BOOL)expandEntityReferences
2057 {
2058     return [self _nodeIteratorImpl]->expandEntityReferences();
2059 }
2060
2061 - (DOMNode *)nextNode
2062 {
2063     int exceptionCode = 0;
2064     DOMNode *result = [DOMNode _nodeWithImpl:[self _nodeIteratorImpl]->nextNode(exceptionCode)];
2065     raiseOnDOMError(exceptionCode);
2066     return result;
2067 }
2068
2069 - (DOMNode *)previousNode
2070 {
2071     int exceptionCode = 0;
2072     DOMNode *result = [DOMNode _nodeWithImpl:[self _nodeIteratorImpl]->previousNode(exceptionCode)];
2073     raiseOnDOMError(exceptionCode);
2074     return result;
2075 }
2076
2077 - (void)detach
2078 {
2079     int exceptionCode = 0;
2080     [self _nodeIteratorImpl]->detach(exceptionCode);
2081     raiseOnDOMError(exceptionCode);
2082 }
2083
2084 @end
2085
2086 @implementation DOMNodeIterator(WebCoreInternal)
2087
2088 + (DOMNodeIterator *)_nodeIteratorWithImpl:(NodeIteratorImpl *)impl filter:(id <DOMNodeFilter>)filter
2089 {
2090     if (!impl)
2091         return nil;
2092     
2093     id cachedInstance;
2094     cachedInstance = getDOMWrapper(impl);
2095     if (cachedInstance)
2096         return [[cachedInstance retain] autorelease];
2097     
2098     return [[[self alloc] _initWithNodeIteratorImpl:impl filter:filter] autorelease];
2099 }
2100
2101 @end
2102
2103 @implementation DOMTreeWalker
2104
2105 - (id)_initWithTreeWalkerImpl:(TreeWalkerImpl *)impl filter:(id <DOMNodeFilter>)filter
2106 {
2107     ASSERT(impl);
2108
2109     [super _init];
2110     _internal = DOM_cast<DOMObjectInternal *>(impl);
2111     impl->ref();
2112     addDOMWrapper(self, impl);
2113     m_filter = [filter retain];
2114     return self;
2115 }
2116
2117 - (TreeWalkerImpl *)_treeWalkerImpl
2118 {
2119     return DOM_cast<TreeWalkerImpl *>(_internal);
2120 }
2121
2122 - (void)dealloc
2123 {
2124     if (m_filter)
2125         [m_filter release];
2126     if (_internal) {
2127         DOM_cast<TreeWalkerImpl *>(_internal)->deref();
2128     }
2129     [super dealloc];
2130 }
2131
2132 - (void)finalize
2133 {
2134     if (_internal) {
2135         DOM_cast<TreeWalkerImpl *>(_internal)->deref();
2136     }
2137     [super finalize];
2138 }
2139
2140 - (DOMNode *)root
2141 {
2142     return [DOMNode _nodeWithImpl:[self _treeWalkerImpl]->root()];
2143 }
2144
2145 - (unsigned long)whatToShow
2146 {
2147     return [self _treeWalkerImpl]->whatToShow();
2148 }
2149
2150 - (id <DOMNodeFilter>)filter
2151 {
2152     if (m_filter)
2153         // This tree walker was created from the objc side
2154         return [[m_filter retain] autorelease];
2155
2156     // This tree walker was created from the c++ side
2157     return [DOMNodeFilter _nodeFilterWithImpl:[self _treeWalkerImpl]->filter()];
2158 }
2159
2160 - (BOOL)expandEntityReferences
2161 {
2162     return [self _treeWalkerImpl]->expandEntityReferences();
2163 }
2164
2165 - (DOMNode *)currentNode
2166 {
2167     return [DOMNode _nodeWithImpl:[self _treeWalkerImpl]->currentNode()];
2168 }
2169
2170 - (void)setCurrentNode:(DOMNode *)currentNode
2171 {
2172     int exceptionCode = 0;
2173     [self _treeWalkerImpl]->setCurrentNode([currentNode _nodeImpl], exceptionCode);
2174     raiseOnDOMError(exceptionCode);
2175 }
2176
2177 - (DOMNode *)parentNode
2178 {
2179     return [DOMNode _nodeWithImpl:[self _treeWalkerImpl]->parentNode()];
2180 }
2181
2182 - (DOMNode *)firstChild
2183 {
2184     return [DOMNode _nodeWithImpl:[self _treeWalkerImpl]->firstChild()];
2185 }
2186
2187 - (DOMNode *)lastChild
2188 {
2189     return [DOMNode _nodeWithImpl:[self _treeWalkerImpl]->lastChild()];
2190 }
2191
2192 - (DOMNode *)previousSibling
2193 {
2194     return [DOMNode _nodeWithImpl:[self _treeWalkerImpl]->previousSibling()];
2195 }
2196
2197 - (DOMNode *)nextSibling
2198 {
2199     return [DOMNode _nodeWithImpl:[self _treeWalkerImpl]->nextSibling()];
2200 }
2201
2202 - (DOMNode *)previousNode
2203 {
2204     return [DOMNode _nodeWithImpl:[self _treeWalkerImpl]->previousNode()];
2205 }
2206
2207 - (DOMNode *)nextNode
2208 {
2209     return [DOMNode _nodeWithImpl:[self _treeWalkerImpl]->nextNode()];
2210 }
2211
2212 @end
2213
2214 @implementation DOMTreeWalker (WebCoreInternal)
2215
2216 + (DOMTreeWalker *)_treeWalkerWithImpl:(TreeWalkerImpl *)impl filter:(id <DOMNodeFilter>)filter
2217 {
2218     if (!impl)
2219         return nil;
2220     
2221     id cachedInstance;
2222     cachedInstance = getDOMWrapper(impl);
2223     if (cachedInstance)
2224         return [[cachedInstance retain] autorelease];
2225     
2226     return [[[self alloc] _initWithTreeWalkerImpl:impl filter:filter] autorelease];
2227 }
2228
2229 @end
2230
2231 class ObjCNodeFilterCondition : public NodeFilterCondition 
2232 {
2233 public:
2234     ObjCNodeFilterCondition(id <DOMNodeFilter>);
2235     virtual ~ObjCNodeFilterCondition();
2236     virtual short acceptNode(const Node &) const;
2237
2238 private:
2239     ObjCNodeFilterCondition(const ObjCNodeFilterCondition &);
2240     ObjCNodeFilterCondition &operator=(const ObjCNodeFilterCondition &);
2241
2242     id <DOMNodeFilter> m_filter;
2243 };
2244
2245 ObjCNodeFilterCondition::ObjCNodeFilterCondition(id <DOMNodeFilter> filter)
2246     : m_filter(filter)
2247 {
2248     ASSERT(m_filter);
2249     CFRetain(m_filter);
2250 }
2251
2252 ObjCNodeFilterCondition::~ObjCNodeFilterCondition()
2253 {
2254     CFRelease(m_filter);
2255 }
2256
2257 short ObjCNodeFilterCondition::acceptNode(const Node &n) const
2258 {
2259     if (n.isNull())
2260         return NodeFilter::FILTER_REJECT;
2261
2262     return [m_filter acceptNode:[DOMNode _nodeWithImpl:n.handle()]];
2263 }
2264
2265 @implementation DOMDocument (DOMDocumentTraversal)
2266
2267 - (DOMNodeIterator *)createNodeIterator:(DOMNode *)root :(unsigned long)whatToShow :(id <DOMNodeFilter>)filter :(BOOL)expandEntityReferences
2268 {
2269     NodeFilter cppFilter;
2270     if (filter)
2271         cppFilter = NodeFilter(new ObjCNodeFilterCondition(filter));
2272     int exceptionCode = 0;
2273     NodeIteratorImpl *impl = [self _documentImpl]->createNodeIterator([root _nodeImpl], whatToShow, cppFilter.handle(), expandEntityReferences, exceptionCode);
2274     raiseOnDOMError(exceptionCode);
2275     return [DOMNodeIterator _nodeIteratorWithImpl:impl filter:filter];
2276 }
2277
2278 - (DOMTreeWalker *)createTreeWalker:(DOMNode *)root :(unsigned long)whatToShow :(id <DOMNodeFilter>)filter :(BOOL)expandEntityReferences
2279 {
2280     NodeFilter cppFilter;
2281     if (filter)
2282         cppFilter = NodeFilter(new ObjCNodeFilterCondition(filter));
2283     int exceptionCode = 0;
2284     TreeWalkerImpl *impl = [self _documentImpl]->createTreeWalker([root _nodeImpl], whatToShow, cppFilter.handle(), expandEntityReferences, exceptionCode);
2285     raiseOnDOMError(exceptionCode);
2286     return [DOMTreeWalker _treeWalkerWithImpl:impl filter:filter];
2287 }
2288
2289 @end
2290