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