WebCore/kwq/DOM.mm

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