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