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