WebCore/kwq/DOM.mm

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