WebCore:
[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 <dom/dom_doc.h>
31 #import <dom/dom_element.h>
32 #import <dom/dom_exception.h>
33 #import <dom/dom_node.h>
34 #import <dom/dom_string.h>
35 #import <dom/dom_text.h>
36 #import <dom/dom_xml.h>
37 #import <dom/dom2_range.h>
38 #import <html/html_elementimpl.h>
39 #import <xml/dom_docimpl.h>
40 #import <xml/dom_elementimpl.h>
41 #import <xml/dom_nodeimpl.h>
42 #import <xml/dom_stringimpl.h>
43 #import <xml/dom_textimpl.h>
44 #import <xml/dom_xmlimpl.h>
45 #import <xml/dom2_rangeimpl.h>
46 #import <xml/dom2_viewsimpl.h>
47
48 #import "DOMInternal.h"
49 #import "KWQAssertions.h"
50
51 using DOM::Attr;
52 using DOM::AttrImpl;
53 using DOM::CharacterDataImpl;
54 using DOM::DocumentFragmentImpl;
55 using DOM::DocumentType;
56 using DOM::DocumentTypeImpl;
57 using DOM::Document;
58 using DOM::DocumentImpl;
59 using DOM::DOMImplementationImpl;
60 using DOM::DOMString;
61 using DOM::DOMStringImpl;
62 using DOM::Element;
63 using DOM::ElementImpl;
64 using DOM::EntityImpl;
65 using DOM::HTMLElementImpl;
66 using DOM::NamedNodeMap;
67 using DOM::NamedNodeMapImpl;
68 using DOM::Node;
69 using DOM::NodeImpl;
70 using DOM::NodeListImpl;
71 using DOM::NotationImpl;
72 using DOM::ProcessingInstructionImpl;
73 using DOM::Range;
74 using DOM::RangeException;
75 using DOM::RangeImpl;
76 using DOM::TextImpl;
77
78 @interface DOMAttr (WebCoreInternal)
79 + (DOMAttr *)_attrWithImpl:(AttrImpl *)impl;
80 - (AttrImpl *)_attrImpl;
81 @end
82
83 @interface DOMDocumentFragment (WebCoreInternal)
84 + (DOMDocumentFragment *)_documentFragmentWithImpl:(DocumentFragmentImpl *)impl;
85 @end
86
87 @interface DOMImplementation (WebCoreInternal)
88 + (DOMImplementation *)_DOMImplementationWithImpl:(DOMImplementationImpl *)impl;
89 @end
90
91 @interface DOMNamedNodeMap (WebCoreInternal)
92 + (DOMNamedNodeMap *)_namedNodeMapWithImpl:(NamedNodeMapImpl *)impl;
93 @end
94
95 //------------------------------------------------------------------------------------------
96 // Factory methods
97
98 inline NamedNodeMap NamedNodeMapImpl::createInstance(NamedNodeMapImpl *impl)
99 {
100     return NamedNodeMap(impl);
101 }
102
103 inline Attr AttrImpl::createInstance(AttrImpl *impl)
104 {
105     return Attr(impl);
106 }
107
108 inline Element ElementImpl::createInstance(ElementImpl *impl)
109 {
110     return Element(impl);
111 }
112
113 inline DocumentType DocumentTypeImpl::createInstance(DocumentTypeImpl *impl)
114 {
115     return DocumentType(impl);
116 }
117
118 inline Document DocumentImpl::createInstance(DocumentImpl *impl)
119 {
120     return Document(impl);
121 }
122
123 //------------------------------------------------------------------------------------------
124 // DOMObject
125
126 @implementation DOMObject
127
128 // Prevent creation of DOM objects by clients who just "[[xxx alloc] init]".
129 - (id)init
130 {
131     [NSException raise:NSGenericException format:@"+[%s init]: should never be used", [self class]->name];
132     [self release];
133     return nil;
134 }
135
136 - (void)dealloc
137 {
138     if (_internal) {
139         removeDOMWrapperForImpl(_internal);
140     }
141     [super dealloc];
142 }
143
144 - (id)copyWithZone:(NSZone *)zone
145 {
146     return [self retain];
147 }
148
149 @end
150
151 @implementation DOMObject (WebCoreInternal)
152
153 - (id)_init
154 {
155     return [super init];
156 }
157
158 @end
159
160 //------------------------------------------------------------------------------------------
161 // DOMNode
162
163 @implementation DOMNode
164
165 - (void)dealloc
166 {
167     if (_internal) {
168         reinterpret_cast<NodeImpl *>(_internal)->deref();
169     }
170     [super dealloc];
171 }
172
173 - (NSString *)nodeName
174 {
175     return [self _nodeImpl]->nodeName();
176 }
177
178 - (NSString *)nodeValue
179 {
180     // Documentation says we can raise a DOMSTRING_SIZE_ERR.
181     // However, the lower layer does not report that error up to us.
182     return [self _nodeImpl]->nodeValue();
183 }
184
185 - (void)setNodeValue:(NSString *)string
186 {
187     ASSERT(string);
188     
189     int exceptionCode = 0;
190     [self _nodeImpl]->setNodeValue(string, exceptionCode);
191     raiseOnDOMError(exceptionCode);
192 }
193
194 - (unsigned short)nodeType
195 {
196     return [self _nodeImpl]->nodeType();
197 }
198
199 - (DOMNode *)parentNode
200 {
201     return [DOMNode _nodeWithImpl:[self _nodeImpl]->parentNode()];
202 }
203
204 - (DOMNodeList *)childNodes
205 {
206     return [DOMNodeList _nodeListWithImpl:[self _nodeImpl]->childNodes()];
207 }
208
209 - (DOMNode *)firstChild
210 {
211     return [DOMNode _nodeWithImpl:[self _nodeImpl]->firstChild()];
212 }
213
214 - (DOMNode *)lastChild
215 {
216     return [DOMNode _nodeWithImpl:[self _nodeImpl]->lastChild()];
217 }
218
219 - (DOMNode *)previousSibling
220 {
221     return [DOMNode _nodeWithImpl:[self _nodeImpl]->previousSibling()];
222 }
223
224 - (DOMNode *)nextSibling
225 {
226     return [DOMNode _nodeWithImpl:[self _nodeImpl]->nextSibling()];
227 }
228
229 - (DOMNamedNodeMap *)attributes
230 {
231     // DOM level 2 core specification says: 
232     // A NamedNodeMap containing the attributes of this node (if it is an Element) or null otherwise.
233     return nil;
234 }
235
236 - (DOMDocument *)ownerDocument
237 {
238     return [DOMDocument _documentWithImpl:[self _nodeImpl]->getDocument()];
239 }
240
241 - (DOMNode *)insertBefore:(DOMNode *)newChild :(DOMNode *)refChild
242 {
243     ASSERT(newChild);
244     ASSERT(refChild);
245
246     int exceptionCode = 0;
247     DOMNode *result = [DOMNode _nodeWithImpl:[self _nodeImpl]->insertBefore([newChild _nodeImpl], [refChild _nodeImpl], exceptionCode)];
248     raiseOnDOMError(exceptionCode);
249     return result;
250 }
251
252 - (DOMNode *)replaceChild:(DOMNode *)newChild :(DOMNode *)oldChild
253 {
254     ASSERT(newChild);
255     ASSERT(oldChild);
256
257     int exceptionCode = 0;
258     DOMNode *result = [DOMNode _nodeWithImpl:[self _nodeImpl]->replaceChild([newChild _nodeImpl], [oldChild _nodeImpl], exceptionCode)];
259     raiseOnDOMError(exceptionCode);
260     return result;
261 }
262
263 - (DOMNode *)removeChild:(DOMNode *)oldChild
264 {
265     ASSERT(oldChild);
266
267     int exceptionCode = 0;
268     DOMNode *result = [DOMNode _nodeWithImpl:[self _nodeImpl]->removeChild([oldChild _nodeImpl], exceptionCode)];
269     raiseOnDOMError(exceptionCode);
270     return result;
271 }
272
273 - (DOMNode *)appendChild:(DOMNode *)newChild
274 {
275     ASSERT(newChild);
276
277     int exceptionCode = 0;
278     DOMNode *result = [DOMNode _nodeWithImpl:[self _nodeImpl]->appendChild([newChild _nodeImpl], exceptionCode)];
279     raiseOnDOMError(exceptionCode);
280     return result;
281 }
282
283 - (BOOL)hasChildNodes
284 {
285     return [self _nodeImpl]->hasChildNodes();
286 }
287
288 - (DOMNode *)cloneNode:(BOOL)deep
289 {
290     return [DOMNode _nodeWithImpl:[self _nodeImpl]->cloneNode(deep)];
291 }
292
293 - (void)normalize
294 {
295     [self _nodeImpl]->normalize();
296 }
297
298 - (BOOL)isSupported:(NSString *)feature :(NSString *)version
299 {
300     ASSERT(feature);
301     ASSERT(version);
302
303     // Method not reflected in DOM::NodeImpl interface
304     return Node([self _nodeImpl]).isSupported(feature, version);
305 }
306
307 - (NSString *)namespaceURI
308 {
309     // Method not reflected in DOM::NodeImpl interface
310     return Node([self _nodeImpl]).namespaceURI();
311 }
312
313 - (NSString *)prefix
314 {
315     return [self _nodeImpl]->prefix();
316 }
317
318 - (void)setPrefix:(NSString *)prefix
319 {
320     ASSERT(prefix);
321
322     int exceptionCode = 0;
323     [self _nodeImpl]->setPrefix(prefix, exceptionCode);
324     raiseOnDOMError(exceptionCode);
325 }
326
327 - (NSString *)localName
328 {
329     return [self _nodeImpl]->localName();
330 }
331
332 - (BOOL)hasAttributes
333 {
334     // Method not reflected in DOM::NodeImpl interface
335     return Node([self _nodeImpl]).hasAttributes();
336 }
337
338 - (NSString *)HTMLString
339 {
340     return [self _nodeImpl]->recursive_toHTML(true).getNSString();
341 }
342
343 @end
344
345 @implementation DOMNode (WebCoreInternal)
346
347 - (id)_initWithNodeImpl:(NodeImpl *)impl
348 {
349     ASSERT(impl);
350
351     [super _init];
352     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
353     impl->ref();
354     setDOMWrapperForImpl(self, impl);
355     return self;
356 }
357
358 + (DOMNode *)_nodeWithImpl:(NodeImpl *)impl
359 {
360     if (!impl)
361         return nil;
362     
363     id cachedInstance;
364     cachedInstance = getDOMWrapperForImpl(impl);
365     if (cachedInstance)
366         return [[cachedInstance retain] autorelease];
367     
368     Class wrapperClass = nil;
369     switch (impl->nodeType()) {
370     case Node::ELEMENT_NODE:
371         wrapperClass = [DOMElement class];
372         break;
373     case Node::ATTRIBUTE_NODE:
374         wrapperClass = [DOMAttr class];
375         break;
376     case Node::TEXT_NODE:
377         wrapperClass = [DOMText class];
378         break;
379     case Node::CDATA_SECTION_NODE:
380         wrapperClass = [DOMCDATASection class];
381         break;
382     case Node::ENTITY_REFERENCE_NODE:
383         wrapperClass = [DOMEntityReference class];
384         break;
385     case Node::ENTITY_NODE:
386         wrapperClass = [DOMEntity class];
387         break;
388     case Node::PROCESSING_INSTRUCTION_NODE:
389         wrapperClass = [DOMProcessingInstruction class];
390         break;
391     case Node::COMMENT_NODE:
392         wrapperClass = [DOMComment class];
393         break;
394     case Node::DOCUMENT_NODE:
395         wrapperClass = [DOMDocument class];
396         break;
397     case Node::DOCUMENT_TYPE_NODE:
398         wrapperClass = [DOMDocumentType class];
399         break;
400     case Node::DOCUMENT_FRAGMENT_NODE:
401         wrapperClass = [DOMDocumentFragment class];
402         break;
403     case Node::NOTATION_NODE:
404         wrapperClass = [DOMNotation class];
405         break;
406     }
407     return [[[wrapperClass alloc] _initWithNodeImpl:impl] autorelease];
408 }
409
410 - (NodeImpl *)_nodeImpl
411 {
412     return reinterpret_cast<NodeImpl *>(_internal);
413 }
414
415 @end
416
417 //------------------------------------------------------------------------------------------
418 // DOMNamedNodeMap
419
420 @implementation DOMNamedNodeMap
421
422 - (void)dealloc
423 {
424     if (_internal) {
425         reinterpret_cast<NamedNodeMapImpl *>(_internal)->deref();
426     }
427     [super dealloc];
428 }
429
430 - (NamedNodeMapImpl *)_namedNodeMapImpl
431 {
432     return reinterpret_cast<NamedNodeMapImpl *>(_internal);
433 }
434
435 - (DOMNode *)getNamedItem:(NSString *)name
436 {
437     ASSERT(name);
438
439     // Method not reflected in DOM::NamedNodeMapImpl interface
440     NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
441     Node result(map.getNamedItem(name));
442     return [DOMNode _nodeWithImpl:result.handle()];
443 }
444
445 - (DOMNode *)setNamedItem:(DOMNode *)arg
446 {
447     ASSERT(arg);
448
449     // Method not reflected in DOM::NamedNodeMapImpl interface
450     try {
451         NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
452         Node result(map.setNamedItem([arg _nodeImpl]));
453         return [DOMNode _nodeWithImpl:result.handle()];
454     } 
455     catch (const DOM::DOMException &e) {
456         raiseOnDOMError(e.code);
457         return nil;
458     }
459 }
460
461 - (DOMNode *)removeNamedItem:(NSString *)name
462 {
463     ASSERT(name);
464
465     // Method not reflected in DOM::NamedNodeMapImpl interface
466     try {
467         NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
468         Node result(map.removeNamedItem(name));
469         return [DOMNode _nodeWithImpl:result.handle()];
470     } 
471     catch (const DOM::DOMException &e) {
472         raiseOnDOMError(e.code);
473         return nil;
474     }
475 }
476
477 - (DOMNode *)item:(unsigned long)index
478 {
479     return [DOMNode _nodeWithImpl:[self _namedNodeMapImpl]->item(index)];
480 }
481
482 - (unsigned long)length
483 {
484     return [self _namedNodeMapImpl]->length();
485 }
486
487 - (DOMNode *)getNamedItemNS:(NSString *)namespaceURI :(NSString *)localName
488 {
489     if (!namespaceURI || !localName) {
490         return nil;
491     }
492
493     // Method not reflected in DOM::NamedNodeMapImpl interface
494     NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
495     Node result(map.getNamedItemNS(namespaceURI, localName));
496     return [DOMNode _nodeWithImpl:result.handle()];
497 }
498
499 - (DOMNode *)setNamedItemNS:(DOMNode *)arg
500 {
501     ASSERT(arg);
502
503     // Method not reflected in DOM::NamedNodeMapImpl interface
504     try {
505         NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
506         Node result(map.setNamedItemNS([arg _nodeImpl]));
507         return [DOMNode _nodeWithImpl:result.handle()];
508     } 
509     catch (const DOM::DOMException &e) {
510         raiseOnDOMError(e.code);
511         return nil;
512     }
513 }
514
515 - (DOMNode *)removeNamedItemNS:(NSString *)namespaceURI :(NSString *)localName
516 {
517     ASSERT(namespaceURI);
518     ASSERT(localName);
519
520     // Method not reflected in DOM::NamedNodeMapImpl interface
521     try {
522         NamedNodeMap map = NamedNodeMapImpl::createInstance([self _namedNodeMapImpl]);
523         Node result(map.removeNamedItemNS(namespaceURI, localName));
524         return [DOMNode _nodeWithImpl:result.handle()];
525     } 
526     catch (const DOM::DOMException &e) {
527         raiseOnDOMError(e.code);
528         return nil;
529     }
530 }
531
532 @end
533
534 @implementation DOMNamedNodeMap (WebCoreInternal)
535
536 - (id)_initWithNamedNodeMapImpl:(NamedNodeMapImpl *)impl
537 {
538     ASSERT(impl);
539
540     [super _init];
541     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
542     impl->ref();
543     setDOMWrapperForImpl(self, impl);
544     return self;
545 }
546
547 + (DOMNamedNodeMap *)_namedNodeMapWithImpl:(NamedNodeMapImpl *)impl
548 {
549     if (!impl)
550         return nil;
551     
552     id cachedInstance;
553     cachedInstance = getDOMWrapperForImpl(impl);
554     if (cachedInstance)
555         return [[cachedInstance retain] autorelease];
556     
557     return [[[self alloc] _initWithNamedNodeMapImpl:impl] autorelease];
558 }
559
560 @end
561
562 //------------------------------------------------------------------------------------------
563 // DOMNodeList
564
565 @implementation DOMNodeList
566
567 - (void)dealloc
568 {
569     if (_internal) {
570         reinterpret_cast<NodeListImpl *>(_internal)->deref();
571     }
572     [super dealloc];
573 }
574
575 - (NodeListImpl *)_nodeListImpl
576 {
577     return reinterpret_cast<NodeListImpl *>(_internal);
578 }
579
580 - (DOMNode *)item:(unsigned long)index
581 {
582     return [DOMNode _nodeWithImpl:[self _nodeListImpl]->item(index)];
583 }
584
585 - (unsigned long)length
586 {
587     return [self _nodeListImpl]->length();
588 }
589
590 @end
591
592 @implementation DOMNodeList (WebCoreInternal)
593
594 - (id)_initWithNodeListImpl:(NodeListImpl *)impl
595 {
596     ASSERT(impl);
597
598     [super _init];
599     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
600     impl->ref();
601     setDOMWrapperForImpl(self, impl);
602     return self;
603 }
604
605 + (DOMNodeList *)_nodeListWithImpl:(NodeListImpl *)impl
606 {
607     if (!impl)
608         return nil;
609     
610     id cachedInstance;
611     cachedInstance = getDOMWrapperForImpl(impl);
612     if (cachedInstance)
613         return [[cachedInstance retain] autorelease];
614     
615     return [[[self alloc] _initWithNodeListImpl:impl] autorelease];
616 }
617
618 @end
619
620 //------------------------------------------------------------------------------------------
621 // DOMImplementation
622
623 @implementation DOMImplementation
624
625 - (void)dealloc
626 {
627     if (_internal) {
628         reinterpret_cast<DOMImplementationImpl *>(_internal)->deref();
629     }
630     [super dealloc];
631 }
632
633 - (DOMImplementationImpl *)_DOMImplementationImpl
634 {
635     return reinterpret_cast<DOMImplementationImpl *>(_internal);
636 }
637
638 - (BOOL)hasFeature:(NSString *)feature :(NSString *)version
639 {
640     ASSERT(feature);
641     ASSERT(version);
642
643     return [self _DOMImplementationImpl]->hasFeature(feature, version);
644 }
645
646 - (DOMDocumentType *)createDocumentType:(NSString *)qualifiedName :(NSString *)publicId :(NSString *)systemId
647 {
648     ASSERT(qualifiedName);
649     ASSERT(publicId);
650     ASSERT(systemId);
651
652     int exceptionCode = 0;
653     DocumentTypeImpl *impl = [self _DOMImplementationImpl]->createDocumentType(qualifiedName, publicId, systemId, exceptionCode);
654     raiseOnDOMError(exceptionCode);
655     return static_cast<DOMDocumentType *>([DOMNode _nodeWithImpl:impl]);
656 }
657
658 - (DOMDocument *)createDocument:(NSString *)namespaceURI :(NSString *)qualifiedName :(DOMDocumentType *)doctype
659 {
660     ASSERT(namespaceURI);
661     ASSERT(qualifiedName);
662
663     int exceptionCode = 0;
664     DocumentType dt = DocumentTypeImpl::createInstance(static_cast<DocumentTypeImpl *>([doctype _nodeImpl]));
665     DocumentImpl *impl = [self _DOMImplementationImpl]->createDocument(namespaceURI, qualifiedName, dt, exceptionCode);
666     raiseOnDOMError(exceptionCode);
667     return static_cast<DOMDocument *>([DOMNode _nodeWithImpl:impl]);
668 }
669
670 - (DOMCSSStyleSheet *)createCSSStyleSheet:(NSString *)title :(NSString *)media
671 {
672     ASSERT(title);
673     ASSERT(media);
674
675     int exceptionCode = 0;
676     DOMString titleString(title);
677     DOMString mediaString(media);
678     DOMCSSStyleSheet *result = [DOMCSSStyleSheet _CSSStyleSheetWithImpl:[self _DOMImplementationImpl]->createCSSStyleSheet(titleString.implementation(), mediaString.implementation(), exceptionCode)];
679     raiseOnDOMError(exceptionCode);
680     return result;
681 }
682
683 @end
684  
685 @implementation DOMImplementation (WebInternal)
686
687 - (id)_initWithDOMImplementationImpl:(DOMImplementationImpl *)impl
688 {
689     ASSERT(impl);
690
691     [super _init];
692     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
693     impl->ref();
694     setDOMWrapperForImpl(self, impl);
695     return self;
696 }
697
698 + (DOMImplementation *)_DOMImplementationWithImpl:(DOMImplementationImpl *)impl
699 {
700     if (!impl)
701         return nil;
702     
703     id cachedInstance;
704     cachedInstance = getDOMWrapperForImpl(impl);
705     if (cachedInstance)
706         return [[cachedInstance retain] autorelease];
707     
708     return [[[self alloc] _initWithDOMImplementationImpl:impl] autorelease];
709 }
710
711 @end
712
713 //------------------------------------------------------------------------------------------
714 // DOMDocumentFragment
715
716 @implementation DOMDocumentFragment
717
718 @end
719
720 @implementation DOMDocumentFragment (WebCoreInternal)
721
722 + (DOMDocumentFragment *)_documentFragmentWithImpl:(DocumentFragmentImpl *)impl
723 {
724     return static_cast<DOMDocumentFragment *>([DOMNode _nodeWithImpl:impl]);
725 }
726
727 @end
728
729 //------------------------------------------------------------------------------------------
730 // DOMDocument
731
732 @implementation DOMDocument
733
734 - (DocumentImpl *)_documentImpl
735 {
736     return static_cast<DocumentImpl *>(reinterpret_cast<NodeImpl *>(_internal));
737 }
738
739 - (DOMDocumentType *)doctype
740 {
741     return static_cast<DOMDocumentType *>([DOMNode _nodeWithImpl:[self _documentImpl]->doctype()]);
742 }
743
744 - (DOMImplementation *)implementation
745 {
746     return [DOMImplementation _DOMImplementationWithImpl:[self _documentImpl]->implementation()];
747 }
748
749 - (DOMElement *)documentElement
750 {
751     return static_cast<DOMElement *>([DOMNode _nodeWithImpl:[self _documentImpl]->documentElement()]);
752 }
753
754 - (DOMElement *)createElement:(NSString *)tagName
755 {
756     ASSERT(tagName);
757
758     int exceptionCode = 0;
759     DOMElement *result = static_cast<DOMElement *>([DOMNode _nodeWithImpl:[self _documentImpl]->createElement(tagName, exceptionCode)]);
760     raiseOnDOMError(exceptionCode);
761     return result;
762 }
763
764 - (DOMDocumentFragment *)createDocumentFragment
765 {
766     return static_cast<DOMDocumentFragment *>([DOMNode _nodeWithImpl:[self _documentImpl]->createDocumentFragment()]);
767 }
768
769 - (DOMText *)createTextNode:(NSString *)data
770 {
771     ASSERT(data);
772     return static_cast<DOMText *>([DOMNode _nodeWithImpl:[self _documentImpl]->createTextNode(data)]);
773 }
774
775 - (DOMComment *)createComment:(NSString *)data
776 {
777     ASSERT(data);
778     return static_cast<DOMComment *>([DOMNode _nodeWithImpl:[self _documentImpl]->createComment(data)]);
779 }
780
781 - (DOMCDATASection *)createCDATASection:(NSString *)data
782 {
783     ASSERT(data);
784
785     // Documentation says we can raise a NOT_SUPPORTED_ERR.
786     // However, the lower layer does not report that error up to us.
787     return static_cast<DOMCDATASection *>([DOMNode _nodeWithImpl:[self _documentImpl]->createCDATASection(data)]);
788 }
789
790 - (DOMProcessingInstruction *)createProcessingInstruction:(NSString *)target :(NSString *)data
791 {
792     ASSERT(target);
793     ASSERT(data);
794
795     // Documentation says we can raise a INVALID_CHARACTER_ERR or a NOT_SUPPORTED_ERR.
796     // However, the lower layer does not report these errors up to us.
797     return static_cast<DOMProcessingInstruction *>([DOMNode _nodeWithImpl:[self _documentImpl]->createProcessingInstruction(target, data)]);
798 }
799
800 - (DOMAttr *)createAttribute:(NSString *)name
801 {
802     ASSERT(name);
803
804     // Method not reflected in DOM::DocumentImpl interface
805     try {
806         Document doc(DocumentImpl::createInstance([self _documentImpl]));
807         Attr result(doc.createAttribute(name));
808         return static_cast<DOMAttr *>([DOMNode _nodeWithImpl:result.handle()]);
809     } 
810     catch (const DOM::DOMException &e) {
811         raiseOnDOMError(e.code);
812         return nil;
813     }
814 }
815
816 - (DOMEntityReference *)createEntityReference:(NSString *)name
817 {
818     ASSERT(name);
819
820     // Documentation says we can raise a INVALID_CHARACTER_ERR or a NOT_SUPPORTED_ERR.
821     // However, the lower layer does not report these errors up to us.
822     return static_cast<DOMEntityReference *>([DOMNode _nodeWithImpl:[self _documentImpl]->createEntityReference(name)]);
823 }
824
825 - (DOMNodeList *)getElementsByTagName:(NSString *)tagname
826 {
827     ASSERT(tagname);
828     return [DOMNodeList _nodeListWithImpl:[self _documentImpl]->getElementsByTagNameNS(0, DOMString(tagname).implementation())];
829 }
830
831 - (DOMNode *)importNode:(DOMNode *)importedNode :(BOOL)deep
832 {
833     int exceptionCode = 0;
834     DOMNode *result = [DOMNode _nodeWithImpl:[self _documentImpl]->importNode([importedNode _nodeImpl], deep, exceptionCode)];
835     raiseOnDOMError(exceptionCode);
836     return result;
837 }
838
839 - (DOMElement *)createElementNS:(NSString *)namespaceURI :(NSString *)qualifiedName
840 {
841     ASSERT(namespaceURI);
842     ASSERT(qualifiedName);
843
844     int exceptionCode = 0;
845     DOMNode *result = [DOMNode _nodeWithImpl:[self _documentImpl]->createElementNS(namespaceURI, qualifiedName, exceptionCode)];
846     raiseOnDOMError(exceptionCode);
847     return static_cast<DOMElement *>(result);
848 }
849
850 - (DOMAttr *)createAttributeNS:(NSString *)namespaceURI :(NSString *)qualifiedName
851 {
852     ASSERT(namespaceURI);
853     ASSERT(qualifiedName);
854
855     // Method not reflected in DOM::DocumentImpl interface
856     try {
857         Document doc(DocumentImpl::createInstance([self _documentImpl]));
858         Attr result(doc.createAttributeNS(namespaceURI, qualifiedName));
859         return static_cast<DOMAttr *>([DOMNode _nodeWithImpl:result.handle()]);
860     } 
861     catch (const DOM::DOMException &e) {
862         raiseOnDOMError(e.code);
863         return nil;
864     }
865 }
866
867 - (DOMNodeList *)getElementsByTagNameNS:(NSString *)namespaceURI :(NSString *)localName
868 {
869     ASSERT(namespaceURI);
870     ASSERT(localName);
871
872     return [DOMNodeList _nodeListWithImpl:[self _documentImpl]->getElementsByTagNameNS(DOMString(namespaceURI).implementation(), DOMString(localName).implementation())];
873 }
874
875 - (DOMElement *)getElementById:(NSString *)elementId
876 {
877     ASSERT(elementId);
878
879     return static_cast<DOMElement *>([DOMNode _nodeWithImpl:[self _documentImpl]->getElementById(elementId)]);
880 }
881
882 - (DOMRange *)createRange
883 {
884     return [DOMRange _rangeWithImpl:[self _documentImpl]->createRange()];
885 }
886
887 - (DOMCSSStyleDeclaration *)getComputedStyle:(DOMElement *)elt :(NSString *)pseudoElt
888 {
889     ElementImpl *elementImpl = [elt _elementImpl];
890     DOMString pseudoEltString(pseudoElt);
891     return [DOMCSSStyleDeclaration _styleDeclarationWithImpl:[self _documentImpl]->defaultView()->getComputedStyle(elementImpl, pseudoEltString.implementation())];
892 }
893
894 - (DOMCSSStyleDeclaration *)getOverrideStyle:(DOMElement *)elt :(NSString *)pseudoElt;
895 {
896     // FIXME: This is unimplemented by khtml, 
897     // so for now, we just return the computed style
898     return [self getComputedStyle:elt :pseudoElt];
899 }
900
901 - (DOMStyleSheetList *)styleSheets
902 {
903     return [DOMStyleSheetList _styleSheetListWithImpl:[self _documentImpl]->styleSheets()];
904 }
905
906 @end
907
908 @implementation DOMDocument (WebCoreInternal)
909
910 + (DOMDocument *)_documentWithImpl:(DocumentImpl *)impl
911 {
912     return static_cast<DOMDocument *>([DOMNode _nodeWithImpl:impl]);
913 }
914
915 @end
916
917 //------------------------------------------------------------------------------------------
918 // DOMCharacterData
919
920 @implementation DOMCharacterData
921
922 - (CharacterDataImpl *)_characterDataImpl
923 {
924     return static_cast<CharacterDataImpl *>(reinterpret_cast<NodeImpl *>(_internal));
925 }
926
927 - (NSString *)data
928 {
929     // Documentation says we can raise a DOMSTRING_SIZE_ERR.
930     // However, the lower layer does not report that error up to us.
931     return [self _characterDataImpl]->data();
932 }
933
934 - (void)setData:(NSString *)data
935 {
936     ASSERT(data);
937     
938     int exceptionCode = 0;
939     [self _characterDataImpl]->setData(data, exceptionCode);
940     raiseOnDOMError(exceptionCode);
941 }
942
943 - (unsigned long)length
944 {
945     return [self _characterDataImpl]->length();
946 }
947
948 - (NSString *)substringData:(unsigned long)offset :(unsigned long)count
949 {
950     int exceptionCode = 0;
951     NSString *result = [self _characterDataImpl]->substringData(offset, count, exceptionCode);
952     raiseOnDOMError(exceptionCode);
953     return result;
954 }
955
956 - (void)appendData:(NSString *)arg
957 {
958     ASSERT(arg);
959     
960     int exceptionCode = 0;
961     [self _characterDataImpl]->appendData(arg, exceptionCode);
962     raiseOnDOMError(exceptionCode);
963 }
964
965 - (void)insertData:(unsigned long)offset :(NSString *)arg
966 {
967     ASSERT(arg);
968     
969     int exceptionCode = 0;
970     [self _characterDataImpl]->insertData(offset, arg, exceptionCode);
971     raiseOnDOMError(exceptionCode);
972 }
973
974 - (void)deleteData:(unsigned long)offset :(unsigned long) count;
975 {
976     int exceptionCode = 0;
977     [self _characterDataImpl]->deleteData(offset, count, exceptionCode);
978     raiseOnDOMError(exceptionCode);
979 }
980
981 - (void)replaceData:(unsigned long)offset :(unsigned long)count :(NSString *)arg
982 {
983     ASSERT(arg);
984
985     int exceptionCode = 0;
986     [self _characterDataImpl]->replaceData(offset, count, arg, exceptionCode);
987     raiseOnDOMError(exceptionCode);
988 }
989
990 @end
991
992 //------------------------------------------------------------------------------------------
993 // DOMAttr
994
995 @implementation DOMAttr
996
997 - (NSString *)name
998 {
999     return [self _attrImpl]->nodeName();
1000 }
1001
1002 - (BOOL)specified
1003 {
1004     return [self _attrImpl]->specified();
1005 }
1006
1007 - (NSString *)value
1008 {
1009     return [self _attrImpl]->nodeValue();
1010 }
1011
1012 - (void)setValue:(NSString *)value
1013 {
1014     ASSERT(value);
1015
1016     int exceptionCode = 0;
1017     [self _attrImpl]->setValue(value, exceptionCode);
1018     raiseOnDOMError(exceptionCode);
1019 }
1020
1021 - (DOMElement *)ownerElement
1022 {
1023     return [DOMElement _elementWithImpl:[self _attrImpl]->ownerElement()];
1024 }
1025
1026 @end
1027
1028 @implementation DOMAttr (WebCoreInternal)
1029
1030 + (DOMAttr *)_attrWithImpl:(AttrImpl *)impl
1031 {
1032     return static_cast<DOMAttr *>([DOMNode _nodeWithImpl:impl]);
1033 }
1034
1035 - (AttrImpl *)_attrImpl
1036 {
1037     return static_cast<AttrImpl *>(reinterpret_cast<NodeImpl *>(_internal));
1038 }
1039
1040 @end
1041
1042 //------------------------------------------------------------------------------------------
1043 // DOMElement
1044
1045 @implementation DOMElement
1046
1047 - (NSString *)tagName
1048 {
1049     return [self _elementImpl]->tagName();
1050 }
1051
1052 - (DOMNamedNodeMap *)attributes
1053 {
1054     return [DOMNamedNodeMap _namedNodeMapWithImpl:[self _elementImpl]->attributes()];
1055 }
1056
1057 - (NSString *)getAttribute:(NSString *)name
1058 {
1059     ASSERT(name);
1060     return [self _elementImpl]->getAttribute(name);
1061 }
1062
1063 - (void)setAttribute:(NSString *)name :(NSString *)value
1064 {
1065     ASSERT(name);
1066     ASSERT(value);
1067
1068     // Method not reflected in DOM::ElementImpl interface
1069     try {
1070         Element element(ElementImpl::createInstance([self _elementImpl]));
1071         element.setAttribute(name, value);
1072     } 
1073     catch (const DOM::DOMException &e) {
1074         raiseOnDOMError(e.code);
1075     }
1076 }
1077
1078 - (void)removeAttribute:(NSString *)name
1079 {
1080     ASSERT(name);
1081
1082     // Method not reflected in DOM::ElementImpl interface
1083     try {
1084         Element element(ElementImpl::createInstance([self _elementImpl]));
1085         element.removeAttribute(name);
1086     } 
1087     catch (const DOM::DOMException &e) {
1088         raiseOnDOMError(e.code);
1089     }
1090 }
1091
1092 - (DOMAttr *)getAttributeNode:(NSString *)name
1093 {
1094     ASSERT(name);
1095
1096     // Method not reflected in DOM::ElementImpl interface
1097     Element element(ElementImpl::createInstance([self _elementImpl]));
1098     Attr result(element.getAttributeNode(name));
1099     return [DOMAttr _attrWithImpl:static_cast<AttrImpl *>(result.handle())];
1100 }
1101
1102 - (DOMAttr *)setAttributeNode:(DOMAttr *)newAttr
1103 {
1104     ASSERT(newAttr);
1105
1106     // Method not reflected in DOM::ElementImpl interface
1107     try {
1108         Element element(ElementImpl::createInstance([self _elementImpl]));
1109         Attr attr(AttrImpl::createInstance([newAttr _attrImpl]));
1110         Attr result(element.setAttributeNode(attr));
1111         return [DOMAttr _attrWithImpl:static_cast<AttrImpl *>(result.handle())];
1112     } 
1113     catch (const DOM::DOMException &e) {
1114         raiseOnDOMError(e.code);
1115         return nil;
1116     }
1117 }
1118
1119 - (DOMAttr *)removeAttributeNode:(DOMAttr *)oldAttr
1120 {
1121     ASSERT(oldAttr);
1122
1123     // Method not reflected in DOM::ElementImpl interface
1124     try {
1125         Element element(ElementImpl::createInstance([self _elementImpl]));
1126         Attr attr(AttrImpl::createInstance([oldAttr _attrImpl]));
1127         Attr result(element.removeAttributeNode(attr));
1128         return [DOMAttr _attrWithImpl:static_cast<AttrImpl *>(result.handle())];
1129     } 
1130     catch (const DOM::DOMException &e) {
1131         raiseOnDOMError(e.code);
1132         return nil;
1133     }
1134 }
1135
1136 - (DOMNodeList *)getElementsByTagName:(NSString *)name
1137 {
1138     ASSERT(name);
1139
1140     return [DOMNodeList _nodeListWithImpl:[self _elementImpl]->getElementsByTagNameNS(0, DOMString(name).implementation())];
1141 }
1142
1143 - (NSString *)getAttributeNS:(NSString *)namespaceURI :(NSString *)localName
1144 {
1145     ASSERT(namespaceURI);
1146     ASSERT(localName);
1147
1148     Element element(ElementImpl::createInstance([self _elementImpl]));
1149     return element.getAttributeNS(namespaceURI, localName);
1150 }
1151
1152 - (void)setAttributeNS:(NSString *)namespaceURI :(NSString *)qualifiedName :(NSString *)value
1153 {
1154     ASSERT(namespaceURI);
1155     ASSERT(qualifiedName);
1156     ASSERT(value);
1157
1158     // Method not reflected in DOM::ElementImpl interface
1159     try {
1160         Element element(ElementImpl::createInstance([self _elementImpl]));
1161         element.setAttributeNS(namespaceURI, qualifiedName, value);
1162     }
1163     catch (const DOM::DOMException &e) {
1164         raiseOnDOMError(e.code);
1165     }
1166 }
1167
1168 - (void)removeAttributeNS:(NSString *)namespaceURI :(NSString *)localName
1169 {
1170     ASSERT(namespaceURI);
1171     ASSERT(localName);
1172
1173     // Method not reflected in DOM::ElementImpl interface
1174     try {
1175         Element element(ElementImpl::createInstance([self _elementImpl]));
1176         element.removeAttributeNS(namespaceURI, localName);
1177     } 
1178     catch (const DOM::DOMException &e) {
1179         raiseOnDOMError(e.code);
1180     }
1181 }
1182
1183 - (DOMAttr *)getAttributeNodeNS:(NSString *)namespaceURI :(NSString *)localName
1184 {
1185     ASSERT(namespaceURI);
1186     ASSERT(localName);
1187
1188     // Method not reflected in DOM::ElementImpl interface
1189     Element element(ElementImpl::createInstance([self _elementImpl]));
1190     Attr result(element.getAttributeNodeNS(namespaceURI, localName));
1191     return [DOMAttr _attrWithImpl:static_cast<AttrImpl *>(result.handle())];
1192 }
1193
1194 - (DOMAttr *)setAttributeNodeNS:(DOMAttr *)newAttr
1195 {
1196     ASSERT(newAttr);
1197
1198     // Method not reflected in DOM::ElementImpl interface
1199     try {
1200         Element element(ElementImpl::createInstance([self _elementImpl]));
1201         Attr attr(AttrImpl::createInstance([newAttr _attrImpl]));
1202         Attr result(element.setAttributeNodeNS(attr));
1203         return [DOMAttr _attrWithImpl:static_cast<AttrImpl *>(result.handle())];
1204     } 
1205     catch (const DOM::DOMException &e) {
1206         raiseOnDOMError(e.code);
1207         return nil;
1208     }
1209 }
1210
1211 - (DOMNodeList *)getElementsByTagNameNS:(NSString *)namespaceURI :(NSString *)localName
1212 {
1213     ASSERT(namespaceURI);
1214     ASSERT(localName);
1215
1216     return [DOMNodeList _nodeListWithImpl:[self _elementImpl]->getElementsByTagNameNS(DOMString(namespaceURI).implementation(), DOMString(localName).implementation())];
1217 }
1218
1219 - (BOOL)hasAttribute:(NSString *)name
1220 {
1221     ASSERT(name);
1222
1223     // Method not reflected in DOM::ElementImpl interface
1224     Element element(ElementImpl::createInstance([self _elementImpl]));
1225     return element.hasAttribute(name);
1226 }
1227
1228 - (BOOL)hasAttributeNS:(NSString *)namespaceURI :(NSString *)localName
1229 {
1230     ASSERT(namespaceURI);
1231     ASSERT(localName);
1232
1233     // Method not reflected in DOM::ElementImpl interface
1234     Element element(ElementImpl::createInstance([self _elementImpl]));
1235     return element.hasAttributeNS(namespaceURI, localName);
1236 }
1237
1238 - (DOMCSSStyleDeclaration *)style
1239 {
1240     ElementImpl *impl = [self _elementImpl];
1241     if (impl->isHTMLElement())
1242         return [DOMCSSStyleDeclaration _styleDeclarationWithImpl:static_cast<HTMLElementImpl *>(impl)->getInlineStyleDecl()];
1243     return nil;
1244 }
1245
1246 @end
1247
1248 @implementation DOMElement (WebCoreInternal)
1249
1250 + (DOMElement *)_elementWithImpl:(ElementImpl *)impl
1251 {
1252     return static_cast<DOMElement *>([DOMNode _nodeWithImpl:impl]);
1253 }
1254
1255 - (ElementImpl *)_elementImpl
1256 {
1257     return static_cast<ElementImpl *>(reinterpret_cast<NodeImpl *>(_internal));
1258 }
1259
1260 @end
1261
1262 //------------------------------------------------------------------------------------------
1263 // DOMText
1264
1265 @implementation DOMText
1266
1267 - (TextImpl *)_textImpl
1268 {
1269     return static_cast<TextImpl *>(reinterpret_cast<NodeImpl *>(_internal));
1270 }
1271
1272 - (DOMText *)splitText:(unsigned long)offset
1273 {
1274     int exceptionCode = 0;
1275     DOMNode *result = [DOMNode _nodeWithImpl:[self _textImpl]->splitText(offset, exceptionCode)];
1276     raiseOnDOMError(exceptionCode);
1277     return static_cast<DOMText *>(result);
1278 }
1279
1280 @end
1281
1282 //------------------------------------------------------------------------------------------
1283 // DOMComment
1284
1285 @implementation DOMComment
1286
1287 @end
1288
1289 //------------------------------------------------------------------------------------------
1290 // DOMCDATASection
1291
1292 @implementation DOMCDATASection
1293
1294 @end
1295
1296 //------------------------------------------------------------------------------------------
1297 // DOMDocumentType
1298
1299 @implementation DOMDocumentType
1300
1301 - (DocumentTypeImpl *)_documentTypeImpl
1302 {
1303     return static_cast<DocumentTypeImpl *>(reinterpret_cast<NodeImpl *>(_internal));
1304 }
1305
1306 - (NSString *)name
1307 {
1308     return [self _documentTypeImpl]->publicId();
1309 }
1310
1311 - (DOMNamedNodeMap *)entities
1312 {
1313     return [DOMNamedNodeMap _namedNodeMapWithImpl:[self _documentTypeImpl]->entities()];
1314 }
1315
1316 - (DOMNamedNodeMap *)notations
1317 {
1318     return [DOMNamedNodeMap _namedNodeMapWithImpl:[self _documentTypeImpl]->notations()];
1319 }
1320
1321 - (NSString *)publicId
1322 {
1323     return [self _documentTypeImpl]->publicId();
1324 }
1325
1326 - (NSString *)systemId
1327 {
1328     return [self _documentTypeImpl]->systemId();
1329 }
1330
1331 - (NSString *)internalSubset
1332 {
1333     return [self _documentTypeImpl]->internalSubset();
1334 }
1335
1336 @end
1337
1338 //------------------------------------------------------------------------------------------
1339 // DOMNotation
1340
1341 @implementation DOMNotation
1342
1343 - (NotationImpl *)_notationImpl
1344 {
1345     return static_cast<NotationImpl *>(reinterpret_cast<NodeImpl *>(_internal));
1346 }
1347
1348 - (NSString *)publicId
1349 {
1350     return [self _notationImpl]->publicId();
1351 }
1352
1353 - (NSString *)systemId
1354 {
1355     return [self _notationImpl]->systemId();
1356 }
1357
1358 @end
1359
1360 //------------------------------------------------------------------------------------------
1361 // DOMEntity
1362
1363 @implementation DOMEntity
1364
1365 - (EntityImpl *)_entityImpl
1366 {
1367     return static_cast<EntityImpl *>(reinterpret_cast<NodeImpl *>(_internal));
1368 }
1369
1370 - (NSString *)publicId
1371 {
1372     return [self _entityImpl]->publicId();
1373 }
1374
1375 - (NSString *)systemId
1376 {
1377     return [self _entityImpl]->systemId();
1378 }
1379
1380 - (NSString *)notationName
1381 {
1382     return [self _entityImpl]->notationName();
1383 }
1384
1385 @end
1386
1387 //------------------------------------------------------------------------------------------
1388 // DOMEntityReference
1389
1390 @implementation DOMEntityReference
1391
1392 @end
1393
1394 //------------------------------------------------------------------------------------------
1395 // DOMProcessingInstruction
1396
1397 @implementation DOMProcessingInstruction
1398
1399 - (ProcessingInstructionImpl *)_processingInstructionImpl
1400 {
1401     return static_cast<ProcessingInstructionImpl *>(reinterpret_cast<NodeImpl *>(_internal));
1402 }
1403
1404 - (NSString *)target
1405 {
1406     return [self _processingInstructionImpl]->target();
1407 }
1408
1409 - (NSString *)data
1410 {
1411     return [self _processingInstructionImpl]->data();
1412 }
1413
1414 - (void)setData:(NSString *)data
1415 {
1416     ASSERT(data);
1417
1418     int exceptionCode = 0;
1419     [self _processingInstructionImpl]->setData(data, exceptionCode);
1420     raiseOnDOMError(exceptionCode);
1421 }
1422
1423 @end
1424
1425 //------------------------------------------------------------------------------------------
1426 // DOMRange
1427
1428 @implementation DOMRange
1429
1430 - (void)dealloc
1431 {
1432     if (_internal) {
1433         reinterpret_cast<RangeImpl *>(_internal)->deref();
1434     }
1435     [super dealloc];
1436 }
1437
1438 - (DOMNode *)startContainer
1439 {
1440     int exceptionCode = 0;
1441     DOMNode *result = [DOMNode _nodeWithImpl:[self _rangeImpl]->startContainer(exceptionCode)];
1442     raiseOnDOMError(exceptionCode);
1443     return result;
1444 }
1445
1446 - (long)startOffset
1447 {
1448     int exceptionCode = 0;
1449     long result = [self _rangeImpl]->startOffset(exceptionCode);
1450     raiseOnDOMError(exceptionCode);
1451     return result;
1452 }
1453
1454 - (DOMNode *)endContainer
1455 {
1456     int exceptionCode = 0;
1457     DOMNode *result = [DOMNode _nodeWithImpl:[self _rangeImpl]->endContainer(exceptionCode)];
1458     raiseOnDOMError(exceptionCode);
1459     return result;
1460 }
1461
1462 - (long)endOffset
1463 {
1464     int exceptionCode = 0;
1465     long result = [self _rangeImpl]->endOffset(exceptionCode);
1466     raiseOnDOMError(exceptionCode);
1467     return result;
1468 }
1469
1470 - (BOOL)collapsed
1471 {
1472     int exceptionCode = 0;
1473     BOOL result = [self _rangeImpl]->collapsed(exceptionCode);
1474     raiseOnDOMError(exceptionCode);
1475     return result;
1476 }
1477
1478 - (DOMNode *)commonAncestorContainer
1479 {
1480     int exceptionCode = 0;
1481     DOMNode *result = [DOMNode _nodeWithImpl:[self _rangeImpl]->commonAncestorContainer(exceptionCode)];
1482     raiseOnDOMError(exceptionCode);
1483     return result;
1484 }
1485
1486 - (void)setStart:(DOMNode *)refNode :(long)offset
1487 {
1488     int exceptionCode = 0;
1489     [self _rangeImpl]->setStart([refNode _nodeImpl], offset, exceptionCode);
1490     raiseOnDOMError(exceptionCode);
1491 }
1492
1493 - (void)setEnd:(DOMNode *)refNode :(long)offset
1494 {
1495     int exceptionCode = 0;
1496     [self _rangeImpl]->setEnd([refNode _nodeImpl], offset, exceptionCode);
1497     raiseOnDOMError(exceptionCode);
1498 }
1499
1500 - (void)setStartBefore:(DOMNode *)refNode
1501 {
1502     int exceptionCode = 0;
1503     [self _rangeImpl]->setStartBefore([refNode _nodeImpl], exceptionCode);
1504     raiseOnDOMError(exceptionCode);
1505 }
1506
1507 - (void)setStartAfter:(DOMNode *)refNode
1508 {
1509     int exceptionCode = 0;
1510     [self _rangeImpl]->setStartAfter([refNode _nodeImpl], exceptionCode);
1511     raiseOnDOMError(exceptionCode);
1512 }
1513
1514 - (void)setEndBefore:(DOMNode *)refNode
1515 {
1516     int exceptionCode = 0;
1517     [self _rangeImpl]->setEndBefore([refNode _nodeImpl], exceptionCode);
1518     raiseOnDOMError(exceptionCode);
1519 }
1520
1521 - (void)setEndAfter:(DOMNode *)refNode
1522 {
1523     int exceptionCode = 0;
1524     [self _rangeImpl]->setEndAfter([refNode _nodeImpl], exceptionCode);
1525     raiseOnDOMError(exceptionCode);
1526 }
1527
1528 - (void)collapse:(BOOL)toStart
1529 {
1530     int exceptionCode = 0;
1531     [self _rangeImpl]->collapse(toStart, exceptionCode);
1532     raiseOnDOMError(exceptionCode);
1533 }
1534
1535 - (void)selectNode:(DOMNode *)refNode
1536 {
1537     int exceptionCode = 0;
1538     [self _rangeImpl]->selectNode([refNode _nodeImpl], exceptionCode);
1539     raiseOnDOMError(exceptionCode);
1540 }
1541
1542 - (void)selectNodeContents:(DOMNode *)refNode
1543 {
1544     int exceptionCode = 0;
1545     [self _rangeImpl]->selectNodeContents([refNode _nodeImpl], exceptionCode);
1546     raiseOnDOMError(exceptionCode);
1547 }
1548
1549 - (short)compareBoundaryPoints:(unsigned short)how :(DOMRange *)sourceRange
1550 {
1551     int exceptionCode = 0;
1552     short result = [self _rangeImpl]->compareBoundaryPoints(static_cast<Range::CompareHow>(how), [sourceRange _rangeImpl], exceptionCode);
1553     raiseOnDOMError(exceptionCode);
1554     return result;
1555 }
1556
1557 - (void)deleteContents
1558 {
1559     int exceptionCode = 0;
1560     [self _rangeImpl]->deleteContents(exceptionCode);
1561     raiseOnDOMError(exceptionCode);
1562 }
1563
1564 - (DOMDocumentFragment *)extractContents
1565 {
1566     int exceptionCode = 0;
1567     DOMDocumentFragment *result = [DOMDocumentFragment _documentFragmentWithImpl:[self _rangeImpl]->extractContents(exceptionCode)];
1568     raiseOnDOMError(exceptionCode);
1569     return result;
1570 }
1571
1572 - (DOMDocumentFragment *)cloneContents
1573 {
1574     int exceptionCode = 0;
1575     DOMDocumentFragment *result = [DOMDocumentFragment _documentFragmentWithImpl:[self _rangeImpl]->cloneContents(exceptionCode)];
1576     raiseOnDOMError(exceptionCode);
1577     return result;
1578 }
1579
1580 - (void)insertNode:(DOMNode *)newNode
1581 {
1582     int exceptionCode = 0;
1583     [self _rangeImpl]->insertNode([newNode _nodeImpl], exceptionCode);
1584     raiseOnDOMError(exceptionCode);
1585 }
1586
1587 - (void)surroundContents:(DOMNode *)newParent
1588 {
1589     int exceptionCode = 0;
1590     [self _rangeImpl]->surroundContents([newParent _nodeImpl], exceptionCode);
1591     raiseOnDOMError(exceptionCode);
1592 }
1593
1594 - (DOMRange *)cloneRange
1595 {
1596     int exceptionCode = 0;
1597     DOMRange *result = [DOMRange _rangeWithImpl:[self _rangeImpl]->cloneRange(exceptionCode)];
1598     raiseOnDOMError(exceptionCode);
1599     return result;
1600 }
1601
1602 - (NSString *)toString
1603 {
1604     int exceptionCode = 0;
1605     NSString *result = [self _rangeImpl]->toString(exceptionCode);
1606     raiseOnDOMError(exceptionCode);
1607     return result;
1608 }
1609
1610 - (void)detach
1611 {
1612     int exceptionCode = 0;
1613     [self _rangeImpl]->detach(exceptionCode);
1614     raiseOnDOMError(exceptionCode);
1615 }
1616
1617 @end
1618
1619 @implementation DOMRange (WebCoreInternal)
1620
1621 - (id)_initWithRangeImpl:(RangeImpl *)impl
1622 {
1623     ASSERT(impl);
1624
1625     [super _init];
1626     _internal = reinterpret_cast<DOMObjectInternal *>(impl);
1627     impl->ref();
1628     setDOMWrapperForImpl(self, impl);
1629     return self;
1630 }
1631
1632 + (DOMRange *)_rangeWithImpl:(RangeImpl *)impl
1633 {
1634     if (!impl)
1635         return nil;
1636     
1637     id cachedInstance;
1638     cachedInstance = getDOMWrapperForImpl(impl);
1639     if (cachedInstance)
1640         return [[cachedInstance retain] autorelease];
1641     
1642     return [[[self alloc] _initWithRangeImpl:impl] autorelease];
1643 }
1644
1645 - (RangeImpl *)_rangeImpl
1646 {
1647     return reinterpret_cast<RangeImpl *>(_internal);
1648 }
1649
1650 @end
1651
1652 //------------------------------------------------------------------------------------------