WebCore/khtml/xml/dom_nodeimpl.cpp

   1 /**
   2  * This file is part of the DOM implementation for KDE.
   3  *
   4  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   5  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   6  *           (C) 2001 Dirk Mueller (mueller@kde.org)
   7  * Copyright (C) 2004 Apple Computer, Inc.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public License
  20  * along with this library; see the file COPYING.LIB.  If not, write to
  21  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 #include "xml/dom_nodeimpl.h"
  26
  27 #include "dom/dom_exception.h"
  28 #include "misc/htmlattrs.h"
  29 #include "misc/htmltags.h"
  30 #include "xml/dom_elementimpl.h"
  31 #include "xml/dom_textimpl.h"
  32 #include "xml/dom2_eventsimpl.h"
  33 #include "xml/dom_docimpl.h"
  34 #include "xml/dom_position.h"
  35 #include "xml/dom2_rangeimpl.h"
  36 #include "css/csshelper.h"
  37 #include "css/cssstyleselector.h"
  38 #include "editing/selection.h"
  39
  40 #include <kglobal.h>
  41 #include <kdebug.h>
  42
  43 #include "rendering/render_object.h"
  44 #include "rendering/render_text.h"
  45
  46 #include "ecma/kjs_binding.h"
  47 #include "ecma/kjs_proxy.h"
  48 #include "khtmlview.h"
  49 #include "khtml_part.h"
  50
  51 #include "html/dtd.h"
  52
  53 #ifndef KHTML_NO_XBL
  54 #include "xbl/xbl_binding_manager.h"
  55 #endif
  56
  57 #if APPLE_CHANGES
  58 #include "KWQAssertions.h"
  59 #include "KWQLogging.h"
  60 #else
  61 #define ASSERT(assertion) assert(assertion)
  62 #define LOG(channel, formatAndArgs...) ((void)0)
  63 #endif
  64
  65 using namespace DOM;
  66 using namespace khtml;
  67
  68 NodeImpl::NodeImpl(DocumentPtr *doc)
  69     : document(doc),
  70       m_previous(0),
  71       m_next(0),
  72       m_render(0),
  73       m_regdListeners( 0 ),
  74       m_nodeLists( 0 ),
  75       m_tabIndex( 0 ),
  76       m_hasId( false ),
  77       m_hasClass( false ),
  78       m_hasStyle( false ),
  79       m_attached(false),
  80       m_changed( false ),
  81       m_hasChangedChild( false ),
  82       m_inDocument( false ),
  83       m_hasAnchor( false ),
  84       m_specified( false ),
  85       m_focused( false ),
  86       m_active( false ),
  87       m_styleElement( false ),
  88       m_implicit( false )
  89 {
  90     if (document)
  91         document->ref();
  92 }
  93
  94 void NodeImpl::setDocument(DocumentPtr *doc)
  95 {
  96     if (inDocument())
  97         return;
  98
  99     if (doc)
 100         doc->ref();
 101
 102     if (document)
 103         document->deref();
 104
 105     document = doc;
 106 }
 107
 108 NodeImpl::~NodeImpl()
 109 {
 110     if (m_render)
 111         detach();
 112     delete m_regdListeners;
 113     delete m_nodeLists;
 114     if (document)
 115         document->deref();
 116     if (m_previous)
 117         m_previous->setNextSibling(0);
 118     if (m_next)
 119         m_next->setPreviousSibling(0);
 120 }
 121
 122 DOMString NodeImpl::nodeValue() const
 123 {
 124   return DOMString();
 125 }
 126
 127 void NodeImpl::setNodeValue( const DOMString &/*_nodeValue*/, int &exceptioncode )
 128 {
 129     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
 130     if (isReadOnly()) {
 131         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
 132         return;
 133     }
 134
 135     // be default nodeValue is null, so setting it has no effect
 136 }
 137
 138 DOMString NodeImpl::nodeName() const
 139 {
 140   return DOMString();
 141 }
 142
 143 unsigned short NodeImpl::nodeType() const
 144 {
 145   return 0;
 146 }
 147
 148 NodeListImpl *NodeImpl::childNodes()
 149 {
 150   return new ChildNodeListImpl(this);
 151 }
 152
 153 NodeImpl *NodeImpl::firstChild() const
 154 {
 155   return 0;
 156 }
 157
 158 NodeImpl *NodeImpl::lastChild() const
 159 {
 160   return 0;
 161 }
 162
 163 NodeImpl *NodeImpl::insertBefore( NodeImpl *, NodeImpl *, int &exceptioncode )
 164 {
 165     exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
 166     return 0;
 167 }
 168
 169 NodeImpl *NodeImpl::replaceChild( NodeImpl *, NodeImpl *, int &exceptioncode )
 170 {
 171   exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
 172   return 0;
 173 }
 174
 175 NodeImpl *NodeImpl::removeChild( NodeImpl *, int &exceptioncode )
 176 {
 177   exceptioncode = DOMException::NOT_FOUND_ERR;
 178   return 0;
 179 }
 180
 181 NodeImpl *NodeImpl::appendChild( NodeImpl *, int &exceptioncode )
 182 {
 183   exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
 184   return 0;
 185 }
 186
 187 void NodeImpl::remove(int &exceptioncode)
 188 {
 189     exceptioncode = 0;
 190     if (!parentNode()) {
 191         exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
 192         return;
 193     }
 194
 195     parentNode()->removeChild(this, exceptioncode);
 196 }
 197
 198 bool NodeImpl::hasChildNodes(  ) const
 199 {
 200   return false;
 201 }
 202
 203 void NodeImpl::normalize ()
 204 {
 205     // ### normalize attributes? (when we store attributes using child nodes)
 206     int exceptioncode = 0;
 207     NodeImpl *child = firstChild();
 208
 209     // Recursively go through the subtree beneath us, normalizing all nodes. In the case
 210     // where there are two adjacent text nodes, they are merged together
 211     while (child) {
 212         NodeImpl *nextChild = child->nextSibling();
 213
 214         if (nextChild && child->nodeType() == Node::TEXT_NODE && nextChild->nodeType() == Node::TEXT_NODE) {
 215             // Current child and the next one are both text nodes... merge them
 216             TextImpl *currentText = static_cast<TextImpl*>(child);
 217             TextImpl *nextText = static_cast<TextImpl*>(nextChild);
 218
 219             currentText->appendData(nextText->data(),exceptioncode);
 220             if (exceptioncode)
 221                 return;
 222
 223             removeChild(nextChild,exceptioncode);
 224             if (exceptioncode)
 225                 return;
 226         }
 227         else {
 228             child->normalize();
 229             child = nextChild;
 230         }
 231     }
 232 }
 233
 234 DOMString NodeImpl::prefix() const
 235 {
 236     // For nodes other than elements and attributes, the prefix is always null
 237     return DOMString();
 238 }
 239
 240 void NodeImpl::setPrefix(const DOMString &/*_prefix*/, int &exceptioncode )
 241 {
 242     // The spec says that for nodes other than elements and attributes, prefix is always null.
 243     // It does not say what to do when the user tries to set the prefix on another type of
 244     // node, however mozilla throws a NAMESPACE_ERR exception
 245     exceptioncode = DOMException::NAMESPACE_ERR;
 246 }
 247
 248 DOMString NodeImpl::localName() const
 249 {
 250     return DOMString();
 251 }
 252
 253 void NodeImpl::setFirstChild(NodeImpl *)
 254 {
 255 }
 256
 257 void NodeImpl::setLastChild(NodeImpl *)
 258 {
 259 }
 260
 261 NodeImpl *NodeImpl::addChild(NodeImpl *)
 262 {
 263   return 0;
 264 }
 265
 266 QString NodeImpl::toHTML() const
 267 {
 268     return recursive_toHTML(true);
 269 }
 270
 271 static QString escapeHTML( const QString& in )
 272 {
 273     QString s;
 274     for ( unsigned int i = 0; i < in.length(); ++i ) {
 275         switch( in[i].latin1() ) {
 276         case '&':
 277             s += "&amp;";
 278             break;
 279         case '<':
 280             s += "&lt;";
 281             break;
 282         case '>':
 283             s += "&gt;";
 284             break;
 285         default:
 286             s += in[i];
 287         }
 288     }
 289
 290     return s;
 291 }
 292
 293 QString NodeImpl::startMarkup(const DOM::RangeImpl *range) const
 294 {
 295     unsigned short type = nodeType();
 296     if (type == Node::TEXT_NODE) {
 297         DOMString str = nodeValue().copy();
 298         if (range) {
 299             int exceptionCode;
 300             if (this == range->endContainer(exceptionCode)) {
 301                 str.truncate(range->endOffset(exceptionCode));
 302             }
 303             if (this == range->startContainer(exceptionCode)) {
 304                 str.remove(0, range->startOffset(exceptionCode));
 305             }
 306         }
 307         Id parentID = parentNode()->id();
 308         bool dontEscape = (parentID == ID_SCRIPT || parentID == ID_TEXTAREA || parentID == ID_STYLE);
 309         return dontEscape ? str.string() : escapeHTML(str.string());
 310     } else if (type != Node::DOCUMENT_NODE) {
 311         QString markup = QChar('<') + nodeName().string();
 312         if (type == Node::ELEMENT_NODE) {
 313             const ElementImpl *el = static_cast<const ElementImpl *>(this);
 314             NamedAttrMapImpl *attrs = el->attributes();
 315             unsigned long length = attrs->length();
 316             for (unsigned int i=0; i<length; i++) {
 317                 AttributeImpl *attr = attrs->attributeItem(i);
 318                 markup += " " + getDocument()->attrName(attr->id()).string() + "=\"" + attr->value().string() + "\"";
 319             }
 320         }
 321         markup += isHTMLElement() ? ">" : "/>";
 322         return markup;
 323     }
 324     return "";
 325 }
 326
 327 QString NodeImpl::endMarkup(void) const
 328 {
 329     if ((!isHTMLElement() || endTag[id()] != FORBIDDEN) && nodeType() != Node::TEXT_NODE && nodeType() != Node::DOCUMENT_NODE) {
 330         return "</" + nodeName().string() + ">";
 331     }
 332     return "";
 333 }
 334
 335 QString NodeImpl::recursive_toString(const NodeImpl *startNode, bool onlyIncludeChildren, bool includeSiblings, QPtrList<NodeImpl> *nodes)
 336 {
 337     // Doesn't make sense to only include children and include siblings.
 338     assert(!(onlyIncludeChildren && includeSiblings));
 339     QString me = "";
 340     for (const NodeImpl *current = startNode; current != NULL; current = includeSiblings ? current->nextSibling() : NULL) {
 341         if (!onlyIncludeChildren) {
 342             if (nodes) {
 343                 nodes->append(current);
 344             }
 345             me += current->startMarkup(0);
 346         }
 347         if (!current->isHTMLElement() || endTag[current->id()] != FORBIDDEN) {
 348             // print children
 349             if (NodeImpl *n = current->firstChild()) {
 350                 me += recursive_toString(n, false, true, nodes);
 351             }
 352             // Print my ending tag
 353             if (!onlyIncludeChildren) {
 354                 me += current->endMarkup();
 355             }
 356         }
 357     }
 358     return me;
 359 }
 360
 361 QString NodeImpl::recursive_toHTML(bool onlyIncludeChildren, QPtrList<NodeImpl> *nodes) const
 362 {
 363     return NodeImpl::recursive_toString(this, onlyIncludeChildren, false, nodes);
 364 }
 365
 366 void NodeImpl::recursive_completeURLs(QString baseURL)
 367 {
 368     if (nodeType() == Node::ELEMENT_NODE) {
 369         ElementImpl *el = static_cast<ElementImpl *>(this);
 370         NamedAttrMapImpl *attrs = el->attributes();
 371         unsigned long length = attrs->length();
 372         for (unsigned int i=0; i<length; i++) {
 373             AttributeImpl *attr = attrs->attributeItem(i);
 374             if (el->isURLAttribute(attr)) {
 375                 el->setAttribute(attr->id(), KURL(baseURL, attr->value().string()).url());
 376             }
 377         }
 378     }
 379
 380     NodeImpl *n;
 381     if ((n = firstChild())) {
 382         n->recursive_completeURLs(baseURL);
 383     }
 384     if ((n = nextSibling())) {
 385         n->recursive_completeURLs(baseURL);
 386     }
 387 }
 388
 389 bool NodeImpl::isContentEditable() const
 390 {
 391     return m_parent ? m_parent->isContentEditable() : false;
 392 }
 393
 394 QRect NodeImpl::getRect() const
 395 {
 396     int _x, _y;
 397     if(m_render && m_render->absolutePosition(_x, _y))
 398         return QRect( _x, _y, m_render->width(), m_render->height() );
 399
 400     return QRect();
 401 }
 402
 403 void NodeImpl::setChanged(bool b)
 404 {
 405     if (b && !attached()) // changed compared to what?
 406         return;
 407
 408     m_changed = b;
 409     if ( b ) {
 410         NodeImpl *p = parentNode();
 411         while ( p ) {
 412             p->setHasChangedChild( true );
 413             p = p->parentNode();
 414         }
 415         getDocument()->setDocumentChanged(true);
 416     }
 417 }
 418
 419 bool NodeImpl::isInline() const
 420 {
 421     if (m_render) return m_render->style()->display() == khtml::INLINE;
 422     return !isElementNode();
 423 }
 424
 425 bool NodeImpl::isFocusable() const
 426 {
 427     return false;
 428 }
 429
 430 bool NodeImpl::isKeyboardFocusable() const
 431 {
 432     return isFocusable();
 433 }
 434
 435 bool NodeImpl::isMouseFocusable() const
 436 {
 437     return isFocusable();
 438 }
 439
 440 unsigned long NodeImpl::nodeIndex() const
 441 {
 442     NodeImpl *_tempNode = previousSibling();
 443     unsigned long count=0;
 444     for( count=0; _tempNode; count++ )
 445         _tempNode = _tempNode->previousSibling();
 446     return count;
 447 }
 448
 449 void NodeImpl::addEventListener(int id, EventListener *listener, const bool useCapture)
 450 {
 451     switch (id) {
 452         case EventImpl::DOMSUBTREEMODIFIED_EVENT:
 453             getDocument()->addListenerType(DocumentImpl::DOMSUBTREEMODIFIED_LISTENER);
 454             break;
 455         case EventImpl::DOMNODEINSERTED_EVENT:
 456             getDocument()->addListenerType(DocumentImpl::DOMNODEINSERTED_LISTENER);
 457             break;
 458         case EventImpl::DOMNODEREMOVED_EVENT:
 459             getDocument()->addListenerType(DocumentImpl::DOMNODEREMOVED_LISTENER);
 460             break;
 461         case EventImpl::DOMNODEREMOVEDFROMDOCUMENT_EVENT:
 462             getDocument()->addListenerType(DocumentImpl::DOMNODEREMOVEDFROMDOCUMENT_LISTENER);
 463             break;
 464         case EventImpl::DOMNODEINSERTEDINTODOCUMENT_EVENT:
 465             getDocument()->addListenerType(DocumentImpl::DOMNODEINSERTEDINTODOCUMENT_LISTENER);
 466             break;
 467         case EventImpl::DOMATTRMODIFIED_EVENT:
 468             getDocument()->addListenerType(DocumentImpl::DOMATTRMODIFIED_LISTENER);
 469             break;
 470         case EventImpl::DOMCHARACTERDATAMODIFIED_EVENT:
 471             getDocument()->addListenerType(DocumentImpl::DOMCHARACTERDATAMODIFIED_LISTENER);
 472             break;
 473         default:
 474             break;
 475     }
 476
 477     RegisteredEventListener *rl = new RegisteredEventListener(static_cast<EventImpl::EventId>(id),listener,useCapture);
 478     if (!m_regdListeners) {
 479         m_regdListeners = new QPtrList<RegisteredEventListener>;
 480         m_regdListeners->setAutoDelete(true);
 481     }
 482
 483     listener->ref();
 484
 485     // remove existing identical listener set with identical arguments - the DOM2
 486     // spec says that "duplicate instances are discarded" in this case.
 487     removeEventListener(id,listener,useCapture);
 488
 489     m_regdListeners->append(rl);
 490     listener->deref();
 491 }
 492
 493 void NodeImpl::removeEventListener(int id, EventListener *listener, bool useCapture)
 494 {
 495     if (!m_regdListeners) // nothing to remove
 496         return;
 497
 498     RegisteredEventListener rl(static_cast<EventImpl::EventId>(id),listener,useCapture);
 499
 500     QPtrListIterator<RegisteredEventListener> it(*m_regdListeners);
 501     for (; it.current(); ++it)
 502         if (*(it.current()) == rl) {
 503             m_regdListeners->removeRef(it.current());
 504             return;
 505         }
 506 }
 507
 508 void NodeImpl::removeHTMLEventListener(int id)
 509 {
 510     if (!m_regdListeners) // nothing to remove
 511         return;
 512
 513     QPtrListIterator<RegisteredEventListener> it(*m_regdListeners);
 514     for (; it.current(); ++it)
 515         if (it.current()->id == id &&
 516             it.current()->listener->eventListenerType() == "_khtml_HTMLEventListener") {
 517             m_regdListeners->removeRef(it.current());
 518             return;
 519         }
 520 }
 521
 522 void NodeImpl::setHTMLEventListener(int id, EventListener *listener)
 523 {
 524     // in case we already have it, we don't want removeHTMLEventListener to destroy it
 525     if (listener)
 526         listener->ref();
 527     removeHTMLEventListener(id);
 528     if (listener)
 529     {
 530         addEventListener(id,listener,false);
 531         listener->deref();
 532     }
 533 }
 534
 535 EventListener *NodeImpl::getHTMLEventListener(int id)
 536 {
 537     if (!m_regdListeners)
 538         return 0;
 539
 540     QPtrListIterator<RegisteredEventListener> it(*m_regdListeners);
 541     for (; it.current(); ++it)
 542         if (it.current()->id == id &&
 543             it.current()->listener->eventListenerType() == "_khtml_HTMLEventListener") {
 544             return it.current()->listener;
 545         }
 546     return 0;
 547 }
 548
 549
 550 bool NodeImpl::dispatchEvent(EventImpl *evt, int &exceptioncode, bool tempEvent)
 551 {
 552     evt->ref();
 553
 554     evt->setTarget(this);
 555
 556     // We've had at least one report of a crash on a page where document is nil here.
 557     // Unfortunately that page no longer exists, but we'll make this code robust against
 558     // that anyway.
 559     // FIXME: Much code in this class assumes document is non-nil; it would be better to
 560     // ensure that document can never be nil.
 561     KHTMLPart *part = nil;
 562     KHTMLView *view = nil;
 563
 564     if (document && document->document()) {
 565         part = document->document()->part();
 566         view = document->document()->view();
 567         // Since event handling code could cause this object to be deleted, grab a reference to the view now
 568         if (view)
 569             view->ref();
 570     }
 571
 572     bool ret = dispatchGenericEvent( evt, exceptioncode );
 573
 574     // If tempEvent is true, this means that the DOM implementation will not be storing a reference to the event, i.e.
 575     // there is no way to retrieve it from javascript if a script does not already have a reference to it in a variable.
 576     // So there is no need for the interpreter to keep the event in it's cache
 577     if (tempEvent && part && part->jScript())
 578         part->jScript()->finishedWithEvent(evt);
 579
 580     if (view)
 581         view->deref();
 582
 583     evt->deref();
 584
 585     return ret;
 586 }
 587
 588 bool NodeImpl::dispatchGenericEvent( EventImpl *evt, int &/*exceptioncode */)
 589 {
 590     evt->ref();
 591
 592     // ### check that type specified
 593
 594     // work out what nodes to send event to
 595     QPtrList<NodeImpl> nodeChain;
 596     NodeImpl *n;
 597     for (n = this; n; n = n->parentNode()) {
 598         n->ref();
 599         nodeChain.prepend(n);
 600     }
 601
 602     // trigger any capturing event handlers on our way down
 603     evt->setEventPhase(Event::CAPTURING_PHASE);
 604     QPtrListIterator<NodeImpl> it(nodeChain);
 605     for (; it.current() && it.current() != this && !evt->propagationStopped(); ++it) {
 606         evt->setCurrentTarget(it.current());
 607         it.current()->handleLocalEvents(evt,true);
 608     }
 609
 610     // dispatch to the actual target node
 611     it.toLast();
 612     if (!evt->propagationStopped()) {
 613         evt->setEventPhase(Event::AT_TARGET);
 614         evt->setCurrentTarget(it.current());
 615
 616         // Capturing first. -dwh
 617         it.current()->handleLocalEvents(evt,true);
 618
 619         // Bubbling second. -dwh
 620         if (!evt->propagationStopped())
 621           it.current()->handleLocalEvents(evt,false);
 622     }
 623     --it;
 624
 625     // ok, now bubble up again (only non-capturing event handlers will be called)
 626     // ### recalculate the node chain here? (e.g. if target node moved in document by previous event handlers)
 627     // no. the DOM specs says:
 628     // The chain of EventTargets from the event target to the top of the tree
 629     // is determined before the initial dispatch of the event.
 630     // If modifications occur to the tree during event processing,
 631     // event flow will proceed based on the initial state of the tree.
 632     //
 633     // since the initial dispatch is before the capturing phase,
 634     // there's no need to recalculate the node chain.
 635     // (tobias)
 636
 637     if (evt->bubbles()) {
 638         evt->setEventPhase(Event::BUBBLING_PHASE);
 639         for (; it.current() && !evt->propagationStopped() && !evt->getCancelBubble(); --it) {
 640             evt->setCurrentTarget(it.current());
 641             it.current()->handleLocalEvents(evt,false);
 642         }
 643     }
 644
 645     evt->setCurrentTarget(0);
 646     evt->setEventPhase(0); // I guess this is correct, the spec does not seem to say
 647                            // anything about the default event handler phase.
 648
 649
 650     if (evt->bubbles()) {
 651         // now we call all default event handlers (this is not part of DOM - it is internal to khtml)
 652
 653         it.toLast();
 654         for (; it.current() && !evt->propagationStopped() && !evt->defaultPrevented() && !evt->defaultHandled(); --it)
 655             it.current()->defaultEventHandler(evt);
 656     }
 657
 658     // In the case of a mouse click, also send a DOMActivate event, which causes things like form submissions
 659     // to occur. Note that this only happens for _real_ mouse clicks (for which we get a KHTML_CLICK_EVENT or
 660     // KHTML_DBLCLICK_EVENT), not the standard DOM "click" event that could be sent from js code.
 661     if (!evt->defaultPrevented() && !disabled())
 662         if (evt->id() == EventImpl::KHTML_CLICK_EVENT)
 663             dispatchUIEvent(EventImpl::DOMACTIVATE_EVENT, 1);
 664         else if (evt->id() == EventImpl::KHTML_DBLCLICK_EVENT)
 665             dispatchUIEvent(EventImpl::DOMACTIVATE_EVENT, 2);
 666
 667     // deref all nodes in chain
 668     it.toFirst();
 669     for (; it.current(); ++it)
 670         it.current()->deref(); // this may delete us
 671
 672     DocumentImpl::updateDocumentsRendering();
 673
 674     bool defaultPrevented = evt->defaultPrevented();
 675
 676     evt->deref();
 677
 678     return !defaultPrevented; // ### what if defaultPrevented was called before dispatchEvent?
 679 }
 680
 681 bool NodeImpl::dispatchHTMLEvent(int _id, bool canBubbleArg, bool cancelableArg)
 682 {
 683     int exceptioncode = 0;
 684     EventImpl *evt = new EventImpl(static_cast<EventImpl::EventId>(_id),canBubbleArg,cancelableArg);
 685     return dispatchEvent(evt,exceptioncode,true);
 686 }
 687
 688 bool NodeImpl::dispatchWindowEvent(int _id, bool canBubbleArg, bool cancelableArg)
 689 {
 690     int exceptioncode = 0;
 691     EventImpl *evt = new EventImpl(static_cast<EventImpl::EventId>(_id),canBubbleArg,cancelableArg);
 692     evt->setTarget( 0 );
 693     evt->ref();
 694     DocumentPtr *doc = document;
 695     doc->ref();
 696     bool r = dispatchGenericEvent( evt, exceptioncode );
 697     if (!evt->defaultPrevented() && doc->document())
 698         doc->document()->defaultEventHandler(evt);
 699
 700     if (_id == EventImpl::LOAD_EVENT && !evt->propagationStopped() && doc->document()) {
 701         // For onload events, send them to the enclosing frame only.
 702         // This is a DOM extension and is independent of bubbling/capturing rules of
 703         // the DOM.  You send the event only to the enclosing frame.  It does not
 704         // bubble through the parent document.
 705         DOM::ElementImpl* elt = doc->document()->ownerElement();
 706         if (elt && (elt->getDocument()->domain().isNull() ||
 707                     elt->getDocument()->domain() == doc->document()->domain())) {
 708             // We also do a security check, since we don't want to allow the enclosing
 709             // iframe to see loads of child documents in other domains.
 710             evt->setCurrentTarget(elt);
 711
 712             // Capturing first.
 713             elt->handleLocalEvents(evt,true);
 714
 715             // Bubbling second.
 716             if (!evt->propagationStopped())
 717                 elt->handleLocalEvents(evt,false);
 718             r = !evt->defaultPrevented();
 719         }
 720     }
 721
 722     doc->deref();
 723     evt->deref();
 724
 725     return r;
 726 }
 727
 728 bool NodeImpl::dispatchMouseEvent(QMouseEvent *_mouse, int overrideId, int overrideDetail)
 729 {
 730     bool cancelable = true;
 731     int detail = overrideDetail; // defaults to 0
 732     EventImpl::EventId evtId = EventImpl::UNKNOWN_EVENT;
 733     if (overrideId) {
 734         evtId = static_cast<EventImpl::EventId>(overrideId);
 735     }
 736     else {
 737         switch (_mouse->type()) {
 738             case QEvent::MouseButtonPress:
 739                 evtId = EventImpl::MOUSEDOWN_EVENT;
 740                 break;
 741             case QEvent::MouseButtonRelease:
 742                 evtId = EventImpl::MOUSEUP_EVENT;
 743                 break;
 744             case QEvent::MouseButtonDblClick:
 745                 evtId = EventImpl::CLICK_EVENT;
 746                 detail = 1; // ### support for multiple double clicks
 747                 break;
 748             case QEvent::MouseMove:
 749                 evtId = EventImpl::MOUSEMOVE_EVENT;
 750                 cancelable = false;
 751                 break;
 752             default:
 753                 break;
 754         }
 755     }
 756     if (evtId == EventImpl::UNKNOWN_EVENT)
 757         return false; // shouldn't happen
 758
 759
 760     int exceptioncode = 0;
 761
 762 #if APPLE_CHANGES
 763 // Careful here - our viewportToContents() converts points from NSEvents, in NSWindow coord system to
 764 // our khtmlview's coord system.  This works for QMouseEvents coming from Cocoa because those events
 765 // hold the location from the NSEvent.  The QMouseEvent param here was made by other khtml code, so it
 766 // will be a "proper" QT event with coords in terms of this widget.  So in WebCore it would never be
 767 // right to pass coords from _mouse to viewportToContents().
 768 #endif
 769 //    int clientX, clientY;
 770 //    viewportToContents(_mouse->x(), _mouse->y(), clientX, clientY);
 771     int clientX = _mouse->x(); // ### adjust to be relative to view
 772     int clientY = _mouse->y(); // ### adjust to be relative to view
 773
 774 #if APPLE_CHANGES
 775     int screenX;
 776     int screenY;
 777     KHTMLView *view = document->document()->view();
 778     if (view) {
 779         // This gets us as far as NSWindow coords
 780         QPoint windowLoc = view->contentsToViewport(_mouse->pos());
 781         // Then from NSWindow coords to screen coords
 782         QPoint screenLoc = view->viewportToGlobal(windowLoc);
 783         screenX = screenLoc.x();
 784         screenY = screenLoc.y();
 785     } else {
 786         screenX = _mouse->x();
 787         screenY = _mouse->y();
 788     }
 789 #else
 790     int screenX = _mouse->globalX();
 791     int screenY = _mouse->globalY();
 792 #endif
 793
 794     int button = -1;
 795     switch (_mouse->button()) {
 796         case Qt::LeftButton:
 797             button = 0;
 798             break;
 799         case Qt::MidButton:
 800             button = 1;
 801             break;
 802         case Qt::RightButton:
 803             button = 2;
 804             break;
 805         default:
 806             break;
 807     }
 808     bool ctrlKey = (_mouse->state() & Qt::ControlButton);
 809     bool altKey = (_mouse->state() & Qt::AltButton);
 810     bool shiftKey = (_mouse->state() & Qt::ShiftButton);
 811     bool metaKey = false; // ### qt support?
 812
 813     EventImpl *evt = new MouseEventImpl(evtId,true,cancelable,getDocument()->defaultView(),
 814                    detail,screenX,screenY,clientX,clientY,ctrlKey,altKey,shiftKey,metaKey,
 815                    button,0);
 816     return dispatchEvent(evt,exceptioncode,true);
 817
 818 }
 819
 820 bool NodeImpl::dispatchUIEvent(int _id, int detail)
 821 {
 822     assert (!( (_id != EventImpl::DOMFOCUSIN_EVENT &&
 823         _id != EventImpl::DOMFOCUSOUT_EVENT &&
 824                 _id != EventImpl::DOMACTIVATE_EVENT)));
 825
 826     bool cancelable = false;
 827     if (_id == EventImpl::DOMACTIVATE_EVENT)
 828         cancelable = true;
 829
 830     int exceptioncode = 0;
 831     UIEventImpl *evt = new UIEventImpl(static_cast<EventImpl::EventId>(_id),true,
 832                                        cancelable,getDocument()->defaultView(),detail);
 833     return dispatchEvent(evt,exceptioncode,true);
 834 }
 835
 836 void NodeImpl::registerNodeList(NodeListImpl *list)
 837 {
 838     if (!m_nodeLists) {
 839         m_nodeLists = new QPtrDict<NodeListImpl>;
 840     }
 841
 842     m_nodeLists->insert(list, list);
 843 }
 844
 845 void NodeImpl::unregisterNodeList(NodeListImpl *list)
 846 {
 847     if (!m_nodeLists)
 848         return;
 849
 850     m_nodeLists->remove(list);
 851 }
 852
 853 void NodeImpl::notifyLocalNodeListsSubtreeModified()
 854 {
 855     if (!m_nodeLists)
 856         return;
 857
 858     QPtrDictIterator<NodeListImpl> i(*m_nodeLists);
 859
 860     while (NodeListImpl *list = i.current()) {
 861         list->rootNodeSubtreeModified();
 862         ++i;
 863     }
 864 }
 865
 866 void NodeImpl::notifyNodeListsSubtreeModified()
 867 {
 868     for (NodeImpl *n = this; n; n = n->parentNode()) {
 869         n->notifyLocalNodeListsSubtreeModified();
 870     }
 871 }
 872
 873 bool NodeImpl::dispatchSubtreeModifiedEvent()
 874 {
 875     notifyNodeListsSubtreeModified();
 876     childrenChanged();
 877     if (!getDocument()->hasListenerType(DocumentImpl::DOMSUBTREEMODIFIED_LISTENER))
 878         return false;
 879     int exceptioncode = 0;
 880     return dispatchEvent(new MutationEventImpl(EventImpl::DOMSUBTREEMODIFIED_EVENT,
 881                          true,false,0,DOMString(),DOMString(),DOMString(),0),exceptioncode,true);
 882 }
 883
 884 bool NodeImpl::dispatchKeyEvent(QKeyEvent *key)
 885 {
 886     int exceptioncode = 0;
 887     //kdDebug(6010) << "DOM::NodeImpl: dispatching keyboard event" << endl;
 888     KeyboardEventImpl *keyboardEventImpl = new KeyboardEventImpl(key, getDocument()->defaultView());
 889     keyboardEventImpl->ref();
 890     bool r = dispatchEvent(keyboardEventImpl,exceptioncode,true);
 891
 892 #if APPLE_CHANGES
 893     // we want to return false if default is prevented (already taken care of)
 894     // or if the element is default-handled by the DOM. Otherwise we let it just
 895     // let it get handled by AppKit
 896     if (keyboardEventImpl->defaultHandled())
 897 #else
 898     // the default event handler should accept() the internal QKeyEvent
 899     // to prevent the view from further evaluating it.
 900     if (!keyboardEventImpl->defaultPrevented() && !keyboardEventImpl->qKeyEvent->isAccepted())
 901 #endif
 902       r = false;
 903
 904     keyboardEventImpl->deref();
 905     return r;
 906 }
 907
 908 void NodeImpl::handleLocalEvents(EventImpl *evt, bool useCapture)
 909 {
 910     if (!m_regdListeners)
 911         return;
 912
 913     if (disabled() && evt->isMouseEvent())
 914         return;
 915
 916     QPtrList<RegisteredEventListener> listenersCopy = *m_regdListeners;
 917     QPtrListIterator<RegisteredEventListener> it(listenersCopy);
 918     Event ev = evt;
 919     for (; it.current(); ++it) {
 920         if (it.current()->id == evt->id() && it.current()->useCapture == useCapture)
 921             it.current()->listener->handleEvent(ev, false);
 922     }
 923
 924 }
 925
 926 void NodeImpl::defaultEventHandler(EventImpl *evt)
 927 {
 928 }
 929
 930 unsigned long NodeImpl::childNodeCount() const
 931 {
 932     return 0;
 933 }
 934
 935 NodeImpl *NodeImpl::childNode(unsigned long /*index*/)
 936 {
 937     return 0;
 938 }
 939
 940 NodeImpl *NodeImpl::traverseNextNode(NodeImpl *stayWithin) const
 941 {
 942     if (firstChild())
 943         return firstChild();
 944     if (nextSibling())
 945         return nextSibling();
 946     const NodeImpl *n = this;
 947     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
 948         n = n->parentNode();
 949     if (n)
 950         return n->nextSibling();
 951     return 0;
 952 }
 953
 954 NodeImpl *NodeImpl::traverseNextSibling(NodeImpl *stayWithin) const
 955 {
 956     if (nextSibling())
 957         return nextSibling();
 958     const NodeImpl *n = this;
 959     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
 960         n = n->parentNode();
 961     if (n)
 962         return n->nextSibling();
 963     return 0;
 964 }
 965
 966 NodeImpl *NodeImpl::traversePreviousNode() const
 967 {
 968     if (previousSibling()) {
 969         NodeImpl *n = previousSibling();
 970         while (n->lastChild())
 971             n = n->lastChild();
 972         return n;
 973     }
 974     else if (parentNode()) {
 975         return parentNode();
 976     }
 977     else {
 978         return 0;
 979     }
 980 }
 981
 982 NodeImpl *NodeImpl::traversePreviousNodePostOrder(NodeImpl *stayWithin) const
 983 {
 984     if (lastChild())
 985         return lastChild();
 986     if (previousSibling())
 987         return previousSibling();
 988     const NodeImpl *n = this;
 989     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
 990         n = n->parentNode();
 991     if (n)
 992         return n->previousSibling();
 993     return 0;
 994 }
 995
 996 void NodeImpl::checkSetPrefix(const DOMString &_prefix, int &exceptioncode)
 997 {
 998     // Perform error checking as required by spec for setting Node.prefix. Used by
 999     // ElementImpl::setPrefix() and AttrImpl::setPrefix()
1000
1001     // INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character.
1002     if (!Element::khtmlValidPrefix(_prefix)) {
1003         exceptioncode = DOMException::INVALID_CHARACTER_ERR;
1004         return;
1005     }
1006
1007     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
1008     if (isReadOnly()) {
1009         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
1010         return;
1011     }
1012
1013     // NAMESPACE_ERR: - Raised if the specified prefix is malformed
1014     // - if the namespaceURI of this node is null,
1015     // - if the specified prefix is "xml" and the namespaceURI of this node is different from
1016     //   "http://www.w3.org/XML/1998/namespace",
1017     // - if this node is an attribute and the specified prefix is "xmlns" and
1018     //   the namespaceURI of this node is different from "http://www.w3.org/2000/xmlns/",
1019     // - or if this node is an attribute and the qualifiedName of this node is "xmlns" [Namespaces].
1020     if (Element::khtmlMalformedPrefix(_prefix) || (namespacePart(id()) == noNamespace && id() > ID_LAST_TAG) ||
1021         (_prefix == "xml" && DOMString(getDocument()->namespaceURI(id())) != "http://www.w3.org/XML/1998/namespace")) {
1022         exceptioncode = DOMException::NAMESPACE_ERR;
1023         return;
1024     }
1025 }
1026
1027 void NodeImpl::checkAddChild(NodeImpl *newChild, int &exceptioncode)
1028 {
1029     // Perform error checking as required by spec for adding a new child. Used by
1030     // appendChild(), replaceChild() and insertBefore()
1031
1032     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
1033     if (!newChild) {
1034         exceptioncode = DOMException::NOT_FOUND_ERR;
1035         return;
1036     }
1037
1038     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
1039     if (isReadOnly()) {
1040         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
1041         return;
1042     }
1043
1044     bool shouldAdoptChild = false;
1045
1046     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
1047     // created this node.
1048     // We assume that if newChild is a DocumentFragment, all children are created from the same document
1049     // as the fragment itself (otherwise they could not have been added as children)
1050     if (newChild->getDocument() != getDocument()) {
1051         // but if the child is not in a document yet then loosen the
1052         // restriction, so that e.g. creating an element with the Option()
1053         // constructor and then adding it to a different document works,
1054         // as it does in Mozilla and Mac IE.
1055         if (!newChild->inDocument()) {
1056             shouldAdoptChild = true;
1057         } else {
1058             exceptioncode = DOMException::WRONG_DOCUMENT_ERR;
1059             return;
1060         }
1061     }
1062
1063     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
1064     // newChild node, or if the node to append is one of this node's ancestors.
1065
1066     // check for ancestor/same node
1067     if (newChild == this || isAncestor(newChild)) {
1068         exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
1069         return;
1070     }
1071
1072     // only do this once we know there won't be an exception
1073     if (shouldAdoptChild) {
1074         KJS::ScriptInterpreter::updateDOMObjectDocument(newChild, newChild->getDocument(), getDocument());
1075         newChild->setDocument(getDocument()->docPtr());
1076     }
1077 }
1078
1079 bool NodeImpl::isAncestor(const NodeImpl *other) const
1080 {
1081     // Return true if other is an ancestor of this, otherwise false
1082     for (const NodeImpl *n = parentNode(); n; n = n->parentNode()) {
1083         if (n == other)
1084             return true;
1085     }
1086     return false;
1087 }
1088
1089 bool NodeImpl::childAllowed( NodeImpl *newChild )
1090 {
1091     return childTypeAllowed(newChild->nodeType());
1092 }
1093
1094 NodeImpl::StyleChange NodeImpl::diff( khtml::RenderStyle *s1, khtml::RenderStyle *s2 ) const
1095 {
1096     // FIXME: The behavior of this function is just totally wrong.  It doesn't handle
1097     // explicit inheritance of non-inherited properties and so you end up not re-resolving
1098     // style in cases where you need to.
1099     StyleChange ch = NoInherit;
1100     EDisplay display1 = s1 ? s1->display() : NONE;
1101     bool fl1 = s1 ? s1->hasPseudoStyle(RenderStyle::FIRST_LETTER) : false;
1102     EDisplay display2 = s2 ? s2->display() : NONE;
1103     bool fl2 = s2 ? s2->hasPseudoStyle(RenderStyle::FIRST_LETTER) : false;
1104     if (display1 != display2 || fl1 != fl2)
1105         ch = Detach;
1106     else if ( !s1 || !s2 )
1107         ch = Inherit;
1108     else if ( *s1 == *s2 )
1109         ch = NoChange;
1110     else if ( s1->inheritedNotEqual( s2 ) )
1111         ch = Inherit;
1112     return ch;
1113 }
1114
1115 #ifndef NDEBUG
1116 void NodeImpl::dump(QTextStream *stream, QString ind) const
1117 {
1118     // ### implement dump() for all appropriate subclasses
1119
1120     if (m_hasId) { *stream << " hasId"; }
1121     if (m_hasClass) { *stream << " hasClass"; }
1122     if (m_hasStyle) { *stream << " hasStyle"; }
1123     if (m_specified) { *stream << " specified"; }
1124     if (m_focused) { *stream << " focused"; }
1125     if (m_active) { *stream << " active"; }
1126     if (m_styleElement) { *stream << " styleElement"; }
1127     if (m_implicit) { *stream << " implicit"; }
1128
1129     *stream << " tabIndex=" << m_tabIndex;
1130     if (m_regdListeners)
1131         *stream << " #regdListeners=" << m_regdListeners->count(); // ### more detail
1132     *stream << endl;
1133
1134     NodeImpl *child = firstChild();
1135     while( child != 0 )
1136     {
1137         *stream << ind << child->nodeName().string().ascii() << ": ";
1138         child->dump(stream,ind+"  ");
1139         child = child->nextSibling();
1140     }
1141 }
1142 #endif
1143
1144 void NodeImpl::attach()
1145 {
1146     assert(!attached());
1147     assert(!m_render || (m_render->style() && m_render->parent()));
1148     m_attached = true;
1149 }
1150
1151 void NodeImpl::detach()
1152 {
1153 //    assert(m_attached);
1154
1155     if (m_render)
1156         m_render->detach();
1157
1158     m_render = 0;
1159     m_attached = false;
1160 }
1161
1162 bool NodeImpl::maintainsState()
1163 {
1164     return false;
1165 }
1166
1167 QString NodeImpl::state()
1168 {
1169     return QString::null;
1170 }
1171
1172 void NodeImpl::restoreState(QStringList &/*states*/)
1173 {
1174 }
1175
1176 void NodeImpl::insertedIntoDocument()
1177 {
1178     setInDocument(true);
1179 }
1180
1181 void NodeImpl::removedFromDocument()
1182 {
1183     setInDocument(false);
1184 }
1185
1186 void NodeImpl::childrenChanged()
1187 {
1188 }
1189
1190 bool NodeImpl::disabled() const
1191 {
1192     return false;
1193 }
1194
1195 bool NodeImpl::isReadOnly()
1196 {
1197     // Entity & Entity Reference nodes and their descendants are read-only
1198     NodeImpl *n = this;
1199     while (n) {
1200         if (n->nodeType() == Node::ENTITY_NODE ||
1201             n->nodeType() == Node::ENTITY_REFERENCE_NODE)
1202             return true;
1203         n = n->parentNode();
1204     }
1205     return false;
1206 }
1207
1208 NodeImpl *NodeImpl::previousEditable() const
1209 {
1210     NodeImpl *node = previousLeafNode();
1211     while (node) {
1212         if (node->isContentEditable())
1213             return node;
1214         node = node->previousLeafNode();
1215     }
1216     return 0;
1217 }
1218
1219 NodeImpl *NodeImpl::nextEditable() const
1220 {
1221     NodeImpl *node = nextLeafNode();
1222     while (node) {
1223         if (node->isContentEditable())
1224             return node;
1225         node = node->nextLeafNode();
1226     }
1227     return 0;
1228 }
1229
1230 RenderObject * NodeImpl::previousRenderer()
1231 {
1232     for (NodeImpl *n = previousSibling(); n; n = n->previousSibling()) {
1233         if (n->renderer())
1234             return n->renderer();
1235     }
1236     return 0;
1237 }
1238
1239 RenderObject * NodeImpl::nextRenderer()
1240 {
1241     for (NodeImpl *n = nextSibling(); n; n = n->nextSibling()) {
1242         if (n->renderer())
1243             return n->renderer();
1244     }
1245     return 0;
1246 }
1247
1248 bool NodeImpl::isAtomicNode() const
1249 {
1250     return !hasChildNodes() || (id() == ID_OBJECT && renderer() && renderer()->isReplaced());
1251 }
1252
1253 NodeImpl *NodeImpl::previousNodeConsideringAtomicNodes() const
1254 {
1255     if (previousSibling()) {
1256         NodeImpl *n = previousSibling();
1257         while (!n->isAtomicNode() && n->lastChild())
1258             n = n->lastChild();
1259         return n;
1260     }
1261     else if (parentNode()) {
1262         return parentNode();
1263     }
1264     else {
1265         return 0;
1266     }
1267 }
1268
1269 NodeImpl *NodeImpl::nextNodeConsideringAtomicNodes() const
1270 {
1271     if (!isAtomicNode() && firstChild())
1272         return firstChild();
1273     if (nextSibling())
1274         return nextSibling();
1275     const NodeImpl *n = this;
1276     while (n && !n->nextSibling())
1277         n = n->parentNode();
1278     if (n)
1279         return n->nextSibling();
1280     return 0;
1281 }
1282
1283 NodeImpl *NodeImpl::previousLeafNode() const
1284 {
1285     NodeImpl *node = previousNodeConsideringAtomicNodes();
1286     while (node) {
1287         if (node->isAtomicNode())
1288             return node;
1289         node = node->previousNodeConsideringAtomicNodes();
1290     }
1291     return 0;
1292 }
1293
1294 NodeImpl *NodeImpl::nextLeafNode() const
1295 {
1296     NodeImpl *node = nextNodeConsideringAtomicNodes();
1297     while (node) {
1298         if (node->isAtomicNode())
1299             return node;
1300         node = node->nextNodeConsideringAtomicNodes();
1301     }
1302     return 0;
1303 }
1304
1305 void NodeImpl::createRendererIfNeeded()
1306 {
1307
1308 #if APPLE_CHANGES
1309     if (!getDocument()->shouldCreateRenderers())
1310         return;
1311 #endif
1312
1313     assert(!attached());
1314     assert(!m_render);
1315
1316     NodeImpl *parent = parentNode();
1317     assert(parent);
1318
1319     RenderObject *parentRenderer = parent->renderer();
1320     if (parentRenderer && parentRenderer->canHaveChildren()) {
1321         RenderStyle *style = styleForRenderer(parentRenderer);
1322         style->ref();
1323 #ifndef KHTML_NO_XBL
1324         bool resolveStyle = false;
1325         if (getDocument()->bindingManager()->loadBindings(this, style->bindingURIs(), true, &resolveStyle) &&
1326             rendererIsNeeded(style)) {
1327             if (resolveStyle) {
1328                 style->deref();
1329                 style = styleForRenderer(parentRenderer);
1330             }
1331 #else
1332         if (rendererIsNeeded(style)) {
1333 #endif
1334             m_render = createRenderer(getDocument()->renderArena(), style);
1335             m_render->setStyle(style);
1336             parentRenderer->addChild(m_render, nextRenderer());
1337 #ifndef KHTML_NO_XBL
1338         } // avoid confusing the change log code parser by having two close braces to match the two open braces above
1339 #else
1340         }
1341 #endif
1342         style->deref(getDocument()->renderArena());
1343     }
1344 }
1345
1346 RenderStyle *NodeImpl::styleForRenderer(RenderObject *parent)
1347 {
1348     return parent->style();
1349 }
1350
1351 bool NodeImpl::rendererIsNeeded(RenderStyle *style)
1352 {
1353     return (getDocument()->documentElement() == this) || (style->display() != NONE);
1354 }
1355
1356 RenderObject *NodeImpl::createRenderer(RenderArena *arena, RenderStyle *style)
1357 {
1358     assert(false);
1359     return 0;
1360 }
1361
1362 long NodeImpl::maxOffset() const
1363 {
1364     return 1;
1365 }
1366
1367 long NodeImpl::caretMinOffset() const
1368 {
1369     return renderer() ? renderer()->caretMinOffset() : 0;
1370 }
1371
1372 long NodeImpl::caretMaxOffset() const
1373 {
1374     return renderer() ? renderer()->caretMaxOffset() : 1;
1375 }
1376
1377 unsigned long NodeImpl::caretMaxRenderedOffset() const
1378 {
1379     return renderer() ? renderer()->caretMaxRenderedOffset() : 1;
1380 }
1381
1382 bool NodeImpl::isBlockFlow() const
1383 {
1384     return renderer() && renderer()->isBlockFlow();
1385 }
1386
1387 bool NodeImpl::isEditableBlock() const
1388 {
1389     return isContentEditable() && isBlockFlow();
1390 }
1391
1392 ElementImpl *NodeImpl::enclosingBlockFlowElement() const
1393 {
1394     NodeImpl *n = const_cast<NodeImpl *>(this);
1395     if (isBlockFlow())
1396         return static_cast<ElementImpl *>(n);
1397
1398     while (1) {
1399         n = n->parentNode();
1400         if (!n)
1401             break;
1402         if (n->isBlockFlow() || n->id() == ID_BODY)
1403             return static_cast<ElementImpl *>(n);
1404     }
1405     return 0;
1406 }
1407
1408 ElementImpl *NodeImpl::enclosingInlineElement() const
1409 {
1410     NodeImpl *n = const_cast<NodeImpl *>(this);
1411     NodeImpl *p;
1412
1413     while (1) {
1414         p = n->parentNode();
1415         if (!p || p->isBlockFlow() || p->id() == ID_BODY)
1416             return static_cast<ElementImpl *>(n);
1417         n = p;
1418     }
1419     ASSERT_NOT_REACHED();
1420     return 0;
1421 }
1422
1423 ElementImpl *NodeImpl::rootEditableElement() const
1424 {
1425     if (!isContentEditable())
1426         return 0;
1427
1428     NodeImpl *n = const_cast<NodeImpl *>(this);
1429     if (n->id() == ID_BODY)
1430         return static_cast<ElementImpl *>(n);
1431
1432     NodeImpl *result = n->isEditableBlock() ? n : 0;
1433     while (1) {
1434         n = n->parentNode();
1435         if (!n || !n->isContentEditable())
1436             break;
1437         if (n->id() == ID_BODY) {
1438             result = n;
1439             break;
1440         }
1441         if (n->isBlockFlow())
1442             result = n;
1443     }
1444     return static_cast<ElementImpl *>(result);
1445 }
1446
1447 bool NodeImpl::inSameRootEditableElement(NodeImpl *n)
1448 {
1449     return n ? rootEditableElement() == n->rootEditableElement() : false;
1450 }
1451
1452 bool NodeImpl::inSameContainingBlockFlowElement(NodeImpl *n)
1453 {
1454     return n ? enclosingBlockFlowElement() == n->enclosingBlockFlowElement() : false;
1455 }
1456
1457 #if APPLE_CHANGES
1458 NodeImpl::Id NodeImpl::identifier() const
1459 {
1460     return id();
1461 }
1462 #endif
1463
1464 #ifndef NDEBUG
1465 void NodeImpl::formatForDebugger(char *buffer, unsigned length) const
1466 {
1467     DOMString result;
1468     DOMString s;
1469
1470     s = nodeName();
1471     if (s.length() == 0)
1472         result += "<none>";
1473     else
1474         result += s;
1475
1476     strncpy(buffer, result.string().latin1(), length - 1);
1477 }
1478 #endif
1479
1480 //-------------------------------------------------------------------------
1481
1482 NodeBaseImpl::NodeBaseImpl(DocumentPtr *doc)
1483     : NodeImpl(doc)
1484 {
1485     _first = _last = 0;
1486 }
1487
1488
1489 NodeBaseImpl::~NodeBaseImpl()
1490 {
1491     //kdDebug( 6020 ) << "NodeBaseImpl destructor" << endl;
1492
1493     // Avoid deep recursion when destroying the node tree.
1494     static bool alreadyInsideDestructor;
1495     bool topLevel = !alreadyInsideDestructor;
1496     if (topLevel)
1497         alreadyInsideDestructor = true;
1498
1499     // List of nodes to be deleted.
1500     static NodeImpl *head;
1501     static NodeImpl *tail;
1502
1503     // We have to tell all children that their parent has died.
1504     NodeImpl *n;
1505     NodeImpl *next;
1506
1507     for( n = _first; n != 0; n = next ) {
1508         next = n->nextSibling();
1509         n->setPreviousSibling(0);
1510         n->setNextSibling(0);
1511         n->setParent(0);
1512
1513         if ( !n->refCount() ) {
1514             // Add the node to the list of nodes to be deleted.
1515             // Reuse the nextSibling pointer for this purpose.
1516             if (tail)
1517                 tail->setNextSibling(n);
1518             else
1519                 head = n;
1520             tail = n;
1521         }
1522     }
1523
1524     // Only for the top level call, do the actual deleting.
1525     if (topLevel) {
1526         while ((n = head) != 0) {
1527             next = n->nextSibling();
1528             n->setNextSibling(0);
1529
1530             head = next;
1531             if (next == 0)
1532                 tail = 0;
1533
1534             delete n;
1535         }
1536
1537         alreadyInsideDestructor = false;
1538     }
1539 }
1540
1541
1542 NodeImpl *NodeBaseImpl::firstChild() const
1543 {
1544     return _first;
1545 }
1546
1547 NodeImpl *NodeBaseImpl::lastChild() const
1548 {
1549     return _last;
1550 }
1551
1552 NodeImpl *NodeBaseImpl::insertBefore ( NodeImpl *newChild, NodeImpl *refChild, int &exceptioncode )
1553 {
1554     exceptioncode = 0;
1555
1556     // insertBefore(...,null) is equivalent to appendChild()
1557     if(!refChild)
1558         return appendChild(newChild, exceptioncode);
1559
1560     // Make sure adding the new child is ok
1561     checkAddChild(newChild, exceptioncode);
1562     if (exceptioncode)
1563         return 0;
1564
1565     // NOT_FOUND_ERR: Raised if refChild is not a child of this node
1566     if (refChild->parentNode() != this) {
1567         exceptioncode = DOMException::NOT_FOUND_ERR;
1568         return 0;
1569     }
1570
1571     bool isFragment = newChild->nodeType() == Node::DOCUMENT_FRAGMENT_NODE;
1572
1573     // If newChild is a DocumentFragment with no children.... there's nothing to do.
1574     // Just return the document fragment
1575     if (isFragment && !newChild->firstChild())
1576         return newChild;
1577
1578     // Now actually add the child(ren)
1579     NodeImpl *nextChild;
1580     NodeImpl *child = isFragment ? newChild->firstChild() : newChild;
1581
1582     NodeImpl *prev = refChild->previousSibling();
1583     if ( prev == newChild || refChild == newChild ) // nothing to do
1584         return newChild;
1585
1586     while (child) {
1587         nextChild = isFragment ? child->nextSibling() : 0;
1588
1589         // If child is already present in the tree, first remove it
1590         NodeImpl *newParent = child->parentNode();
1591         if(newParent)
1592             newParent->removeChild( child, exceptioncode );
1593         if ( exceptioncode )
1594             return 0;
1595
1596         // Add child in the correct position
1597         if (prev)
1598             prev->setNextSibling(child);
1599         else
1600             _first = child;
1601         refChild->setPreviousSibling(child);
1602         child->setParent(this);
1603         child->setPreviousSibling(prev);
1604         child->setNextSibling(refChild);
1605
1606         // Add child to the rendering tree
1607         // ### should we detach() it first if it's already attached?
1608         if (attached() && !child->attached())
1609             child->attach();
1610
1611         // Dispatch the mutation events
1612         dispatchChildInsertedEvents(child,exceptioncode);
1613
1614         prev = child;
1615         child = nextChild;
1616     }
1617
1618     getDocument()->setDocumentChanged(true);
1619     dispatchSubtreeModifiedEvent();
1620     return newChild;
1621 }
1622
1623 NodeImpl *NodeBaseImpl::replaceChild ( NodeImpl *newChild, NodeImpl *oldChild, int &exceptioncode )
1624 {
1625     exceptioncode = 0;
1626
1627     if ( oldChild == newChild ) // nothing to do
1628         return oldChild;
1629
1630     // Make sure adding the new child is ok
1631     checkAddChild(newChild, exceptioncode);
1632     if (exceptioncode)
1633         return 0;
1634
1635     // NOT_FOUND_ERR: Raised if oldChild is not a child of this node.
1636     if (!oldChild || oldChild->parentNode() != this) {
1637         exceptioncode = DOMException::NOT_FOUND_ERR;
1638         return 0;
1639     }
1640
1641     bool isFragment = newChild->nodeType() == Node::DOCUMENT_FRAGMENT_NODE;
1642     NodeImpl *nextChild;
1643     NodeImpl *child = isFragment ? newChild->firstChild() : newChild;
1644
1645
1646     // Remove the old child
1647     NodeImpl *prev = oldChild->previousSibling();
1648     NodeImpl *next = oldChild->nextSibling();
1649
1650     removeChild(oldChild, exceptioncode);
1651     if (exceptioncode)
1652         return 0;
1653
1654     // Add the new child(ren)
1655     while (child) {
1656         nextChild = isFragment ? child->nextSibling() : 0;
1657
1658         // If child is already present in the tree, first remove it
1659         NodeImpl *newParent = child->parentNode();
1660         if(newParent)
1661             newParent->removeChild( child, exceptioncode );
1662         if (exceptioncode)
1663             return 0;
1664
1665         // Add child in the correct position
1666         if (prev) prev->setNextSibling(child);
1667         if (next) next->setPreviousSibling(child);
1668         if(!prev) _first = child;
1669         if(!next) _last = child;
1670         child->setParent(this);
1671         child->setPreviousSibling(prev);
1672         child->setNextSibling(next);
1673
1674         // Add child to the rendering tree
1675         // ### should we detach() it first if it's already attached?
1676         if (attached() && !child->attached())
1677             child->attach();
1678
1679         // Dispatch the mutation events
1680         dispatchChildInsertedEvents(child,exceptioncode);
1681
1682         prev = child;
1683         child = nextChild;
1684     }
1685
1686     // ### set style in case it's attached
1687     getDocument()->setDocumentChanged(true);
1688     dispatchSubtreeModifiedEvent();
1689     return oldChild;
1690 }
1691
1692 NodeImpl *NodeBaseImpl::removeChild ( NodeImpl *oldChild, int &exceptioncode )
1693 {
1694     exceptioncode = 0;
1695
1696     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
1697     if (isReadOnly()) {
1698         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
1699         return 0;
1700     }
1701
1702     // NOT_FOUND_ERR: Raised if oldChild is not a child of this node.
1703     if (!oldChild || oldChild->parentNode() != this) {
1704         exceptioncode = DOMException::NOT_FOUND_ERR;
1705         return 0;
1706     }
1707
1708     // Dispatch pre-removal mutation events
1709     getDocument()->notifyBeforeNodeRemoval(oldChild); // ### use events instead
1710     if (getDocument()->hasListenerType(DocumentImpl::DOMNODEREMOVED_LISTENER)) {
1711         oldChild->dispatchEvent(new MutationEventImpl(EventImpl::DOMNODEREMOVED_EVENT,
1712                              true,false,this,DOMString(),DOMString(),DOMString(),0),exceptioncode,true);
1713         if (exceptioncode)
1714             return 0;
1715     }
1716
1717     dispatchChildRemovalEvents(oldChild,exceptioncode);
1718     if (exceptioncode)
1719         return 0;
1720
1721     // Remove from rendering tree
1722     if (oldChild->attached())
1723         oldChild->detach();
1724
1725     // Remove the child
1726     NodeImpl *prev, *next;
1727     prev = oldChild->previousSibling();
1728     next = oldChild->nextSibling();
1729
1730     if(next) next->setPreviousSibling(prev);
1731     if(prev) prev->setNextSibling(next);
1732     if(_first == oldChild) _first = next;
1733     if(_last == oldChild) _last = prev;
1734
1735     oldChild->setPreviousSibling(0);
1736     oldChild->setNextSibling(0);
1737     oldChild->setParent(0);
1738
1739     getDocument()->setDocumentChanged(true);
1740
1741     // Dispatch post-removal mutation events
1742     dispatchSubtreeModifiedEvent();
1743
1744     if (oldChild->inDocument())
1745         oldChild->removedFromDocument();
1746
1747     return oldChild;
1748 }
1749
1750 void NodeBaseImpl::removeChildren()
1751 {
1752     int exceptionCode;
1753     while (NodeImpl *n = _first) {
1754         NodeImpl *next = n->nextSibling();
1755
1756         n->ref();
1757
1758         // Fire removed from document mutation events.
1759         dispatchChildRemovalEvents(n, exceptionCode);
1760
1761         if (n->attached())
1762             n->detach();
1763         n->setPreviousSibling(0);
1764         n->setNextSibling(0);
1765         n->setParent(0);
1766
1767         if (n->inDocument())
1768             n->removedFromDocument();
1769
1770         n->deref();
1771
1772         _first = next;
1773     }
1774     _last = 0;
1775
1776     // Dispatch a single post-removal mutation event denoting a modified subtree.
1777     dispatchSubtreeModifiedEvent();
1778 }
1779
1780
1781 NodeImpl *NodeBaseImpl::appendChild ( NodeImpl *newChild, int &exceptioncode )
1782 {
1783     exceptioncode = 0;
1784
1785     // Make sure adding the new child is ok
1786     checkAddChild(newChild, exceptioncode);
1787     if (exceptioncode)
1788         return 0;
1789
1790     if ( newChild == _last ) // nothing to do
1791         return newChild;
1792
1793     bool isFragment = newChild->nodeType() == Node::DOCUMENT_FRAGMENT_NODE;
1794
1795     // If newChild is a DocumentFragment with no children.... there's nothing to do.
1796     // Just return the document fragment
1797     if (isFragment && !newChild->firstChild())
1798         return newChild;
1799
1800     // Now actually add the child(ren)
1801     NodeImpl *nextChild;
1802     NodeImpl *child = isFragment ? newChild->firstChild() : newChild;
1803
1804     while (child) {
1805         nextChild = isFragment ? child->nextSibling() : 0;
1806
1807         // If child is already present in the tree, first remove it
1808         NodeImpl *oldParent = child->parentNode();
1809         if(oldParent) {
1810             oldParent->removeChild( child, exceptioncode );
1811             if (exceptioncode)
1812                 return 0;
1813         }
1814
1815         // Append child to the end of the list
1816         child->setParent(this);
1817
1818         if(_last)
1819         {
1820             child->setPreviousSibling(_last);
1821             _last->setNextSibling(child);
1822             _last = child;
1823         }
1824         else
1825         {
1826             _first = _last = child;
1827         }
1828
1829         // Add child to the rendering tree
1830         // ### should we detach() it first if it's already attached?
1831         if (attached() && !child->attached())
1832             child->attach();
1833
1834         // Dispatch the mutation events
1835         dispatchChildInsertedEvents(child,exceptioncode);
1836
1837         child = nextChild;
1838     }
1839
1840     getDocument()->setDocumentChanged(true);
1841     // ### set style in case it's attached
1842     dispatchSubtreeModifiedEvent();
1843     return newChild;
1844 }
1845
1846 bool NodeBaseImpl::hasChildNodes (  ) const
1847 {
1848     return _first != 0;
1849 }
1850
1851 // not part of the DOM
1852 void NodeBaseImpl::setFirstChild(NodeImpl *child)
1853 {
1854     _first = child;
1855 }
1856
1857 void NodeBaseImpl::setLastChild(NodeImpl *child)
1858 {
1859     _last = child;
1860 }
1861
1862 // check for same source document:
1863 bool NodeBaseImpl::checkSameDocument( NodeImpl *newChild, int &exceptioncode )
1864 {
1865     exceptioncode = 0;
1866     DocumentImpl *ownerDocThis = getDocument();
1867     DocumentImpl *ownerDocNew = getDocument();
1868     if(ownerDocThis != ownerDocNew) {
1869         kdDebug(6010)<< "not same document, newChild = " << newChild << "document = " << getDocument() << endl;
1870         exceptioncode = DOMException::WRONG_DOCUMENT_ERR;
1871         return true;
1872     }
1873     return false;
1874 }
1875
1876 // check for being (grand-..)father:
1877 // ### remove in favor or isAncestor()
1878 bool NodeBaseImpl::checkNoOwner( NodeImpl *newChild, int &exceptioncode )
1879 {
1880   //check if newChild is parent of this...
1881   NodeImpl *n;
1882   for( n = this; (n != getDocument()) && (n!= 0); n = n->parentNode() )
1883       if(n == newChild) {
1884           exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
1885           return true;
1886       }
1887   return false;
1888 }
1889
1890 // check for being child:
1891 bool NodeBaseImpl::checkIsChild( NodeImpl *oldChild, int &exceptioncode )
1892 {
1893     if(!oldChild || oldChild->parentNode() != this) {
1894         exceptioncode = DOMException::NOT_FOUND_ERR;
1895         return true;
1896     }
1897     return false;
1898 }
1899
1900 NodeImpl *NodeBaseImpl::addChild(NodeImpl *newChild)
1901 {
1902     // do not add applyChanges here! This function is only used during parsing
1903
1904     // short check for consistency with DTD
1905     if(!isXMLElementNode() && !newChild->isXMLElementNode() && !childAllowed(newChild))
1906     {
1907         //kdDebug( 6020 ) << "AddChild failed! id=" << id() << ", child->id=" << newChild->id() << endl;
1908         return 0;
1909     }
1910
1911     // just add it...
1912     newChild->setParent(this);
1913
1914     if(_last)
1915     {
1916         newChild->setPreviousSibling(_last);
1917         _last->setNextSibling(newChild);
1918         _last = newChild;
1919     }
1920     else
1921     {
1922         _first = _last = newChild;
1923     }
1924
1925     newChild->insertedIntoDocument();
1926     childrenChanged();
1927
1928     if(newChild->nodeType() == Node::ELEMENT_NODE)
1929         return newChild;
1930     return this;
1931 }
1932
1933 void NodeBaseImpl::attach()
1934 {
1935     NodeImpl *child = _first;
1936     while(child != 0)
1937     {
1938         child->attach();
1939         child = child->nextSibling();
1940     }
1941     NodeImpl::attach();
1942 }
1943
1944 void NodeBaseImpl::detach()
1945 {
1946     NodeImpl *child = _first;
1947     while(child != 0)
1948     {
1949         NodeImpl* prev = child;
1950         child = child->nextSibling();
1951         prev->detach();
1952     }
1953     NodeImpl::detach();
1954 }
1955
1956 void NodeBaseImpl::insertedIntoDocument()
1957 {
1958     NodeImpl::insertedIntoDocument();
1959     for (NodeImpl *child = _first; child; child = child->nextSibling())
1960         child->insertedIntoDocument();
1961 }
1962
1963 void NodeBaseImpl::removedFromDocument()
1964 {
1965     NodeImpl::removedFromDocument();
1966     for (NodeImpl *child = _first; child; child = child->nextSibling())
1967         child->removedFromDocument();
1968 }
1969
1970 void NodeBaseImpl::cloneChildNodes(NodeImpl *clone)
1971 {
1972     int exceptioncode = 0;
1973     NodeImpl *n;
1974     for(n = firstChild(); n && !exceptioncode; n = n->nextSibling())
1975     {
1976         clone->appendChild(n->cloneNode(true),exceptioncode);
1977     }
1978 }
1979
1980 NodeListImpl* NodeBaseImpl::getElementsByTagNameNS ( DOMStringImpl* namespaceURI,
1981                                                      DOMStringImpl* localName )
1982 {
1983     if (!localName) return 0;
1984
1985     NodeImpl::Id idMask = namespaceMask | localNameMask;
1986     if (localName->l && localName->s[0] == '*')
1987         idMask &= ~localNameMask;
1988     if (namespaceURI && namespaceURI->l && namespaceURI->s[0] == '*')
1989         idMask &= ~namespaceMask;
1990
1991     Id id = 0; // 0 means "all items"
1992     if ( (idMask & localNameMask) || namespaceURI ) // not getElementsByTagName("*")
1993     {
1994         id = getDocument()->tagId( namespaceURI, localName, true);
1995         if ( !id ) // not found -> we want to return an empty list, not "all items"
1996             id = (Id)-1; // HACK. HEAD has a cleaner implementation of TagNodeListImpl it seems.
1997     }
1998
1999     return new TagNodeListImpl( this, id, idMask );
2000 }
2001
2002 // I don't like this way of implementing the method, but I didn't find any
2003 // other way. Lars
2004 bool NodeBaseImpl::getUpperLeftCorner(int &xPos, int &yPos) const
2005 {
2006     if (!m_render)
2007         return false;
2008     RenderObject *o = m_render;
2009     xPos = yPos = 0;
2010     if ( !o->isInline() || o->isReplaced() ) {
2011         o->absolutePosition( xPos, yPos );
2012         return true;
2013     }
2014
2015     // find the next text/image child, to get a position
2016     while(o) {
2017         if(o->firstChild())
2018             o = o->firstChild();
2019         else if(o->nextSibling())
2020             o = o->nextSibling();
2021         else {
2022             RenderObject *next = 0;
2023             while(!next) {
2024                 o = o->parent();
2025                 if(!o) return false;
2026                 next = o->nextSibling();
2027             }
2028             o = next;
2029         }
2030         if((o->isText() && !o->isBR()) || o->isReplaced()) {
2031             o->container()->absolutePosition( xPos, yPos );
2032             if (o->isText())
2033                 xPos += static_cast<RenderText *>(o)->minXPos();
2034             else
2035                 xPos += o->xPos();
2036             yPos += o->yPos();
2037             return true;
2038         }
2039     }
2040     return true;
2041 }
2042
2043 bool NodeBaseImpl::getLowerRightCorner(int &xPos, int &yPos) const
2044 {
2045     if (!m_render)
2046         return false;
2047
2048     RenderObject *o = m_render;
2049     xPos = yPos = 0;
2050     if (!o->isInline() || o->isReplaced())
2051     {
2052         o->absolutePosition( xPos, yPos );
2053         xPos += o->width();
2054         yPos += o->height();
2055         return true;
2056     }
2057     // find the last text/image child, to get a position
2058     while(o) {
2059         if(o->lastChild())
2060             o = o->lastChild();
2061         else if(o->previousSibling())
2062             o = o->previousSibling();
2063         else {
2064             RenderObject *prev = 0;
2065             while(!prev) {
2066                 o = o->parent();
2067                 if(!o) return false;
2068                 prev = o->previousSibling();
2069             }
2070             o = prev;
2071         }
2072         if(o->isText() || o->isReplaced()) {
2073             o->container()->absolutePosition(xPos, yPos);
2074             if (o->isText())
2075                 xPos += static_cast<RenderText *>(o)->minXPos() + o->width();
2076             else
2077                 xPos += o->xPos()+o->width();
2078             yPos += o->yPos()+o->height();
2079             return true;
2080         }
2081     }
2082     return true;
2083 }
2084
2085 QRect NodeBaseImpl::getRect() const
2086 {
2087     int xPos, yPos;
2088     if (!getUpperLeftCorner(xPos,yPos))
2089     {
2090         xPos=0;
2091         yPos=0;
2092     }
2093     int xEnd, yEnd;
2094     if (!getLowerRightCorner(xEnd,yEnd))
2095     {
2096         if (xPos)
2097             xEnd = xPos;
2098         if (yPos)
2099             yEnd = yPos;
2100     }
2101     else
2102     {
2103         if (xPos==0)
2104             xPos = xEnd;
2105         if (yPos==0)
2106             yPos = yEnd;
2107     }
2108     if ( xEnd <= xPos || yEnd <= yPos )
2109         return QRect( QPoint( xPos, yPos ), QSize() );
2110
2111     return QRect(xPos, yPos, xEnd - xPos, yEnd - yPos);
2112 }
2113
2114 void NodeBaseImpl::setFocus(bool received)
2115 {
2116     if (m_focused == received) return;
2117
2118     NodeImpl::setFocus(received);
2119
2120     if (received && isEditableBlock() && !hasChildNodes()) {
2121         getDocument()->part()->setSelection(Position(this, 0));
2122     }
2123
2124     // note that we need to recalc the style
2125     setChanged();
2126 }
2127
2128 void NodeBaseImpl::setActive(bool down)
2129 {
2130     if (down == active()) return;
2131
2132     NodeImpl::setActive(down);
2133
2134     // note that we need to recalc the style
2135     if (m_render && m_render->style()->affectedByActiveRules())
2136         setChanged();
2137 }
2138
2139 unsigned long NodeBaseImpl::childNodeCount() const
2140 {
2141     unsigned long count = 0;
2142     NodeImpl *n;
2143     for (n = firstChild(); n; n = n->nextSibling())
2144         count++;
2145     return count;
2146 }
2147
2148 NodeImpl *NodeBaseImpl::childNode(unsigned long index)
2149 {
2150     unsigned long i;
2151     NodeImpl *n = firstChild();
2152     for (i = 0; i < index; i++)
2153         n = n->nextSibling();
2154     return n;
2155 }
2156
2157 void NodeBaseImpl::dispatchChildInsertedEvents( NodeImpl *child, int &exceptioncode )
2158 {
2159     if (getDocument()->hasListenerType(DocumentImpl::DOMNODEINSERTED_LISTENER)) {
2160         child->dispatchEvent(new MutationEventImpl(EventImpl::DOMNODEINSERTED_EVENT,
2161                                                    true,false,this,DOMString(),DOMString(),DOMString(),0),exceptioncode,true);
2162         if (exceptioncode)
2163             return;
2164     }
2165
2166     // dispatch the DOMNOdeInsertedInfoDocument event to all descendants
2167     bool hasInsertedListeners = getDocument()->hasListenerType(DocumentImpl::DOMNODEINSERTEDINTODOCUMENT_LISTENER);
2168     NodeImpl *p = this;
2169     while (p->parentNode())
2170         p = p->parentNode();
2171     if (p->nodeType() == Node::DOCUMENT_NODE) {
2172         for (NodeImpl *c = child; c; c = c->traverseNextNode(child)) {
2173             c->insertedIntoDocument();
2174
2175             if (hasInsertedListeners) {
2176                 c->dispatchEvent(new MutationEventImpl(EventImpl::DOMNODEINSERTEDINTODOCUMENT_EVENT,
2177                                                        false,false,0,DOMString(),DOMString(),DOMString(),0),exceptioncode,true);
2178                 if (exceptioncode)
2179                     return;
2180             }
2181         }
2182     }
2183 }
2184
2185 void NodeBaseImpl::dispatchChildRemovalEvents( NodeImpl *child, int &exceptioncode )
2186 {
2187     // Dispatch pre-removal mutation events
2188     getDocument()->notifyBeforeNodeRemoval(child); // ### use events instead
2189     if (getDocument()->hasListenerType(DocumentImpl::DOMNODEREMOVED_LISTENER)) {
2190         child->dispatchEvent(new MutationEventImpl(EventImpl::DOMNODEREMOVED_EVENT,
2191                              true,false,this,DOMString(),DOMString(),DOMString(),0),exceptioncode,true);
2192         if (exceptioncode)
2193             return;
2194     }
2195
2196     bool hasRemovalListeners = getDocument()->hasListenerType(DocumentImpl::DOMNODEREMOVEDFROMDOCUMENT_LISTENER);
2197
2198     // dispatch the DOMNOdeRemovedFromDocument event to all descendants
2199     if (inDocument()) {
2200         for (NodeImpl *c = child; c; c = c->traverseNextNode(child)) {
2201             if (hasRemovalListeners) {
2202                 c->dispatchEvent(new MutationEventImpl(EventImpl::DOMNODEREMOVEDFROMDOCUMENT_EVENT,
2203                                  false,false,0,DOMString(),DOMString(),DOMString(),0),exceptioncode,true);
2204                 if (exceptioncode)
2205                     return;
2206             }
2207         }
2208     }
2209 }
2210
2211 // ---------------------------------------------------------------------------
2212
2213
2214 NodeListImpl::NodeListImpl(NodeImpl *_rootNode)
2215     : rootNode(_rootNode),
2216       isCacheValid(false)
2217 {
2218     rootNode->ref();
2219     rootNode->registerNodeList(this);
2220 }
2221
2222 NodeListImpl::~NodeListImpl()
2223 {
2224     rootNode->unregisterNodeList(this);
2225     rootNode->deref();
2226 }
2227
2228 unsigned long NodeListImpl::recursiveLength( NodeImpl *start ) const
2229 {
2230     if (!start)
2231         start = rootNode;
2232
2233     if (isCacheValid && start == rootNode) {
2234         return cachedLength;
2235     }
2236
2237     unsigned long len = 0;
2238
2239     for(NodeImpl *n = start->firstChild(); n != 0; n = n->nextSibling()) {
2240         if ( n->nodeType() == Node::ELEMENT_NODE ) {
2241             if (nodeMatches(n))
2242                 len++;
2243             len+= recursiveLength(n);
2244         }
2245     }
2246
2247     if (start == rootNode) {
2248         cachedLength = len;
2249         isCacheValid = true;
2250     }
2251
2252     return len;
2253 }
2254
2255 NodeImpl *NodeListImpl::recursiveItem ( unsigned long &offset, NodeImpl *start ) const
2256 {
2257     if (!start)
2258         start = rootNode;
2259
2260     for(NodeImpl *n = start->firstChild(); n != 0; n = n->nextSibling()) {
2261         if ( n->nodeType() == Node::ELEMENT_NODE ) {
2262             if (nodeMatches(n))
2263                 if (!offset--)
2264                     return n;
2265
2266             NodeImpl *depthSearch= recursiveItem(offset, n);
2267             if (depthSearch)
2268                 return depthSearch;
2269         }
2270     }
2271
2272     return 0; // no matching node in this subtree
2273 }
2274
2275 NodeImpl *NodeListImpl::itemById (const DOMString& elementId) const
2276 {
2277     if (rootNode->isDocumentNode()) {
2278         DOM::NodeImpl *node = static_cast<DocumentImpl *>(rootNode)->getElementById(elementId);
2279         if (nodeMatches(node))
2280             return node;
2281
2282         return 0;
2283     }
2284
2285     unsigned long l = length();
2286
2287     for ( unsigned long i = 0; i < l; i++ ) {
2288         DOM::NodeImpl *node = item(i);
2289
2290         if ( static_cast<ElementImpl *>(node)->getIDAttribute() == elementId ) {
2291             return node;
2292         }
2293     }
2294
2295     return 0;
2296 }
2297
2298
2299 void NodeListImpl::rootNodeSubtreeModified()
2300 {
2301     isCacheValid = false;
2302 }
2303
2304
2305 ChildNodeListImpl::ChildNodeListImpl( NodeImpl *n )
2306     : NodeListImpl(n)
2307 {
2308 }
2309
2310 unsigned long ChildNodeListImpl::length() const
2311 {
2312     unsigned long len = 0;
2313     NodeImpl *n;
2314     for(n = rootNode->firstChild(); n != 0; n = n->nextSibling())
2315         len++;
2316
2317     return len;
2318 }
2319
2320 NodeImpl *ChildNodeListImpl::item ( unsigned long index ) const
2321 {
2322     unsigned int pos = 0;
2323     NodeImpl *n = rootNode->firstChild();
2324
2325     while( n != 0 && pos < index )
2326     {
2327         n = n->nextSibling();
2328         pos++;
2329     }
2330
2331     return n;
2332 }
2333
2334 bool ChildNodeListImpl::nodeMatches(NodeImpl *testNode) const
2335 {
2336     return testNode->parentNode() == rootNode;
2337 }
2338
2339 TagNodeListImpl::TagNodeListImpl(NodeImpl *n, NodeImpl::Id _id, NodeImpl::Id _idMask )
2340     : NodeListImpl(n),
2341       m_id(_id & _idMask),
2342       m_idMask(_idMask)
2343 {
2344 }
2345
2346 unsigned long TagNodeListImpl::length() const
2347 {
2348     return recursiveLength();
2349 }
2350
2351 NodeImpl *TagNodeListImpl::item ( unsigned long index ) const
2352 {
2353     return recursiveItem( index );
2354 }
2355
2356 bool TagNodeListImpl::nodeMatches( NodeImpl *testNode ) const
2357 {
2358     return ( testNode->isElementNode() &&
2359              (testNode->id() & m_idMask) == m_id);
2360 }
2361
2362 NameNodeListImpl::NameNodeListImpl(NodeImpl *n, const DOMString &t )
2363   : NodeListImpl(n), nodeName(t)
2364 {
2365 }
2366
2367 unsigned long NameNodeListImpl::length() const
2368 {
2369     return recursiveLength();
2370 }
2371
2372 NodeImpl *NameNodeListImpl::item ( unsigned long index ) const
2373 {
2374     return recursiveItem( index );
2375 }
2376
2377 bool NameNodeListImpl::nodeMatches( NodeImpl *testNode ) const
2378 {
2379     return static_cast<ElementImpl *>(testNode)->getAttribute(ATTR_NAME) == nodeName;
2380 }
2381
2382 // ---------------------------------------------------------------------------
2383
2384 NamedNodeMapImpl::NamedNodeMapImpl()
2385 {
2386 }
2387
2388 NamedNodeMapImpl::~NamedNodeMapImpl()
2389 {
2390 }
2391
2392 // ----------------------------------------------------------------------------
2393
2394 // ### unused
2395 #if 0
2396 GenericRONamedNodeMapImpl::GenericRONamedNodeMapImpl(DocumentPtr* doc)
2397     : NamedNodeMapImpl()
2398 {
2399     m_doc = doc->document();
2400     m_contents = new QPtrList<NodeImpl>;
2401 }
2402
2403 GenericRONamedNodeMapImpl::~GenericRONamedNodeMapImpl()
2404 {
2405     while (m_contents->count() > 0)
2406         m_contents->take(0)->deref();
2407
2408     delete m_contents;
2409 }
2410
2411 NodeImpl *GenericRONamedNodeMapImpl::getNamedItem ( const DOMString &name, int &/*exceptioncode*/ ) const
2412 {
2413     QPtrListIterator<NodeImpl> it(*m_contents);
2414     for (; it.current(); ++it)
2415         if (it.current()->nodeName() == name)
2416             return it.current();
2417     return 0;
2418 }
2419
2420 Node GenericRONamedNodeMapImpl::setNamedItem ( const Node &/*arg*/, int &exceptioncode )
2421 {
2422     // can't modify this list through standard DOM functions
2423     // NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly
2424     exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
2425     return 0;
2426 }
2427
2428 Node GenericRONamedNodeMapImpl::removeNamedItem ( const DOMString &/*name*/, int &exceptioncode )
2429 {
2430     // can't modify this list through standard DOM functions
2431     // NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly
2432     exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
2433     return 0;
2434 }
2435
2436 NodeImpl *GenericRONamedNodeMapImpl::item ( unsigned long index ) const
2437 {
2438     // ### check this when calling from javascript using -1 = 2^sizeof(int)-1
2439     // (also for other similar methods)
2440     if (index >= m_contents->count())
2441         return 0;
2442
2443     return m_contents->at(index);
2444 }
2445
2446 unsigned long GenericRONamedNodeMapImpl::length(  ) const
2447 {
2448     return m_contents->count();
2449 }
2450
2451 NodeImpl *GenericRONamedNodeMapImpl::getNamedItemNS( const DOMString &namespaceURI,
2452                                                      const DOMString &localName,
2453                                                      int &/*exceptioncode*/ ) const
2454 {
2455     NodeImpl::Id searchId = m_doc->tagId(namespaceURI.implementation(),
2456                                                    localName.implementation(), true);
2457
2458     QPtrListIterator<NodeImpl> it(*m_contents);
2459     for (; it.current(); ++it)
2460         if (it.current()->id() == searchId)
2461             return it.current();
2462
2463     return 0;
2464 }
2465
2466 NodeImpl *GenericRONamedNodeMapImpl::setNamedItemNS( NodeImpl */*arg*/, int &exceptioncode )
2467 {
2468     // can't modify this list through standard DOM functions
2469     // NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly
2470     exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
2471     return 0;
2472 }
2473
2474 NodeImpl *GenericRONamedNodeMapImpl::removeNamedItemNS( const DOMString &/*namespaceURI*/,
2475                                                         const DOMString &/*localName*/,
2476                                                         int &exceptioncode )
2477 {
2478     // can't modify this list through standard DOM functions
2479     exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
2480     return 0;
2481 }
2482
2483 void GenericRONamedNodeMapImpl::addNode(NodeImpl *n)
2484 {
2485     // The spec says that in the case of duplicates we only keep the first one
2486     int exceptioncode = 0;
2487     if (getNamedItem(n->nodeName(),exceptioncode))
2488         return;
2489
2490     n->ref();
2491     m_contents->append(n);
2492 }
2493
2494 #endif