WebCore/dom/Element.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 Peter Kelly (pmk@post.com)
   7  *           (C) 2001 Dirk Mueller (mueller@kde.org)
   8  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Library General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Library General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Library General Public License
  21  * along with this library; see the file COPYING.LIB.  If not, write to
  22  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23  * Boston, MA 02111-1307, USA.
  24  */
  25 #include "config.h"
  26 #include "Element.h"
  27
  28 #include "cssstyleselector.h"
  29 #include "Document.h"
  30 #include "ExceptionCode.h"
  31 #include "Frame.h"
  32 #include "HTMLNames.h"
  33 #include "NamedAttrMap.h"
  34 #include "RenderBlock.h"
  35 #include "SelectionController.h"
  36 #include "TextStream.h"
  37
  38 namespace WebCore {
  39
  40 using namespace HTMLNames;
  41
  42 Element::Element(const QualifiedName& qName, Document *doc)
  43     : ContainerNode(doc)
  44     , m_updateFocusAppearanceTimer(this, &Element::updateFocusAppearanceTimerFired)
  45     , m_needsFocusAppearanceUpdate(false)
  46     , m_tagName(qName)
  47 {
  48 }
  49
  50 Element::~Element()
  51 {
  52     if (namedAttrMap)
  53         namedAttrMap->detachFromElement();
  54 }
  55
  56 PassRefPtr<Node> Element::cloneNode(bool deep)
  57 {
  58     ExceptionCode ec = 0;
  59     RefPtr<Element> clone = document()->createElementNS(namespaceURI(), nodeName(), ec);
  60     assert(!ec);
  61
  62     // clone attributes
  63     if (namedAttrMap)
  64         *clone->attributes() = *namedAttrMap;
  65
  66     clone->copyNonAttributeProperties(this);
  67
  68     if (deep)
  69         cloneChildNodes(clone.get());
  70
  71     return clone.release();
  72 }
  73
  74 void Element::removeAttribute(const QualifiedName& name, ExceptionCode& ec)
  75 {
  76     if (namedAttrMap) {
  77         namedAttrMap->removeNamedItem(name, ec);
  78         if (ec == NOT_FOUND_ERR)
  79             ec = 0;
  80     }
  81 }
  82
  83 void Element::setAttribute(const QualifiedName& name, const String &value)
  84 {
  85     ExceptionCode ec = 0;
  86     setAttribute(name, value.impl(), ec);
  87 }
  88
  89 // Virtual function, defined in base class.
  90 NamedAttrMap *Element::attributes() const
  91 {
  92     return attributes(false);
  93 }
  94
  95 NamedAttrMap* Element::attributes(bool readonly) const
  96 {
  97     updateStyleAttributeIfNeeded();
  98     if (!readonly && !namedAttrMap)
  99         createAttributeMap();
 100     return namedAttrMap.get();
 101 }
 102
 103 Node::NodeType Element::nodeType() const
 104 {
 105     return ELEMENT_NODE;
 106 }
 107
 108 const AtomicStringList* Element::getClassList() const
 109 {
 110     return 0;
 111 }
 112
 113 const AtomicString& Element::getIDAttribute() const
 114 {
 115     return namedAttrMap ? namedAttrMap->id() : nullAtom;
 116 }
 117
 118 bool Element::hasAttribute(const QualifiedName& name) const
 119 {
 120     return hasAttributeNS(name.namespaceURI(), name.localName());
 121 }
 122
 123 const AtomicString& Element::getAttribute(const QualifiedName& name) const
 124 {
 125     if (name == styleAttr)
 126         updateStyleAttributeIfNeeded();
 127
 128     if (namedAttrMap)
 129         if (Attribute* a = namedAttrMap->getAttributeItem(name))
 130             return a->value();
 131
 132     return nullAtom;
 133 }
 134
 135 void Element::scrollIntoView(bool alignToTop)
 136 {
 137     document()->updateLayoutIgnorePendingStylesheets();
 138     IntRect bounds = getRect();
 139     if (renderer()) {
 140         // Align to the top / bottom and to the closest edge.
 141         if (alignToTop)
 142             renderer()->enclosingLayer()->scrollRectToVisible(bounds, RenderLayer::gAlignToEdgeIfNeeded, RenderLayer::gAlignTopAlways);
 143         else
 144             renderer()->enclosingLayer()->scrollRectToVisible(bounds, RenderLayer::gAlignToEdgeIfNeeded, RenderLayer::gAlignBottomAlways);
 145     }
 146 }
 147
 148 void Element::scrollIntoViewIfNeeded(bool centerIfNeeded)
 149 {
 150     document()->updateLayoutIgnorePendingStylesheets();
 151     IntRect bounds = getRect();
 152     if (renderer()) {
 153         if (centerIfNeeded)
 154             renderer()->enclosingLayer()->scrollRectToVisible(bounds, RenderLayer::gAlignCenterIfNeeded, RenderLayer::gAlignCenterIfNeeded);
 155         else
 156             renderer()->enclosingLayer()->scrollRectToVisible(bounds, RenderLayer::gAlignToEdgeIfNeeded, RenderLayer::gAlignToEdgeIfNeeded);
 157     }
 158 }
 159
 160 void Element::scrollByUnits(int units, ScrollGranularity granularity)
 161 {
 162     document()->updateLayoutIgnorePendingStylesheets();
 163     if (RenderObject *rend = renderer()) {
 164         if (rend->hasOverflowClip()) {
 165             ScrollDirection direction = ScrollDown;
 166             if (units < 0) {
 167                 direction = ScrollUp;
 168                 units = -units;
 169             }
 170             rend->layer()->scroll(direction, granularity, units);
 171         }
 172     }
 173 }
 174
 175 void Element::scrollByLines(int lines)
 176 {
 177     scrollByUnits(lines, ScrollByLine);
 178 }
 179
 180 void Element::scrollByPages(int pages)
 181 {
 182     scrollByUnits(pages, ScrollByPage);
 183 }
 184
 185 int Element::offsetLeft()
 186 {
 187     document()->updateLayoutIgnorePendingStylesheets();
 188     if (RenderObject* rend = renderer())
 189         return rend->offsetLeft();
 190     return 0;
 191 }
 192
 193 int Element::offsetTop()
 194 {
 195     document()->updateLayoutIgnorePendingStylesheets();
 196     if (RenderObject* rend = renderer())
 197         return rend->offsetTop();
 198     return 0;
 199 }
 200
 201 int Element::offsetWidth()
 202 {
 203     document()->updateLayoutIgnorePendingStylesheets();
 204     if (RenderObject* rend = renderer())
 205         return rend->offsetWidth();
 206     return 0;
 207 }
 208
 209 int Element::offsetHeight()
 210 {
 211     document()->updateLayoutIgnorePendingStylesheets();
 212     if (RenderObject* rend = renderer())
 213         return rend->offsetHeight();
 214     return 0;
 215 }
 216
 217 Element* Element::offsetParent()
 218 {
 219     document()->updateLayoutIgnorePendingStylesheets();
 220     if (RenderObject* rend = renderer())
 221         if (RenderObject* offsetParent = rend->offsetParent())
 222             return static_cast<Element*>(offsetParent->element());
 223     return 0;
 224 }
 225
 226 int Element::clientWidth()
 227 {
 228     document()->updateLayoutIgnorePendingStylesheets();
 229
 230     // When in strict mode, clientWidth for the document
 231     // element should return the width of the containing frame.
 232     if (!document()->inCompatMode() && document()->documentElement() == this)
 233         return document()->frame()->view()->visibleWidth();
 234
 235     if (RenderObject* rend = renderer())
 236         return rend->clientWidth();
 237     return 0;
 238 }
 239
 240 int Element::clientHeight()
 241 {
 242     document()->updateLayoutIgnorePendingStylesheets();
 243
 244     // When in strict mode, clientHeight for the document
 245     // element should return the height of the containing frame.
 246     if (!document()->inCompatMode() && document()->documentElement() == this)
 247         return document()->frame()->view()->visibleHeight();
 248
 249     if (RenderObject* rend = renderer())
 250         return rend->clientHeight();
 251     return 0;
 252 }
 253
 254 int Element::scrollLeft()
 255 {
 256     document()->updateLayoutIgnorePendingStylesheets();
 257     RenderObject* rend = renderer();
 258     if (rend && rend->layer())
 259         return rend->layer()->scrollXOffset();
 260     return 0;
 261 }
 262
 263 int Element::scrollTop()
 264 {
 265     document()->updateLayoutIgnorePendingStylesheets();
 266     RenderObject* rend = renderer();
 267     if (rend && rend->layer())
 268         return rend->layer()->scrollYOffset();
 269     return 0;
 270 }
 271
 272 void Element::setScrollLeft(int newLeft)
 273 {
 274     document()->updateLayoutIgnorePendingStylesheets();
 275     RenderObject *rend = renderer();
 276     if (rend && rend->hasOverflowClip())
 277         rend->layer()->scrollToXOffset(newLeft);
 278 }
 279
 280 void Element::setScrollTop(int newTop)
 281 {
 282     document()->updateLayoutIgnorePendingStylesheets();
 283     RenderObject *rend = renderer();
 284     if (rend && rend->hasOverflowClip())
 285         rend->layer()->scrollToYOffset(newTop);
 286 }
 287
 288 int Element::scrollWidth()
 289 {
 290     document()->updateLayoutIgnorePendingStylesheets();
 291     if (RenderObject* rend = renderer())
 292         return rend->scrollWidth();
 293     return 0;
 294 }
 295
 296 int Element::scrollHeight()
 297 {
 298     document()->updateLayoutIgnorePendingStylesheets();
 299     if (RenderObject* rend = renderer())
 300         return rend->scrollHeight();
 301     return 0;
 302 }
 303
 304 static inline bool inHTMLDocument(const Element* e)
 305 {
 306     return e && e->document()->isHTMLDocument();
 307 }
 308
 309 const AtomicString& Element::getAttribute(const String& name) const
 310 {
 311     String localName = inHTMLDocument(this) ? name.lower() : name;
 312     if (localName == styleAttr.localName())
 313         updateStyleAttributeIfNeeded();
 314
 315     if (namedAttrMap)
 316         if (Attribute* a = namedAttrMap->getAttributeItem(localName))
 317             return a->value();
 318
 319     return nullAtom;
 320 }
 321
 322 const AtomicString& Element::getAttributeNS(const String& namespaceURI, const String& localName) const
 323 {
 324     return getAttribute(QualifiedName(nullAtom, localName.impl(), namespaceURI.impl()));
 325 }
 326
 327 void Element::setAttribute(const String& name, const String& value, ExceptionCode& ec)
 328 {
 329     if (!Document::isValidName(name)) {
 330         ec = INVALID_CHARACTER_ERR;
 331         return;
 332     }
 333
 334     String localName = inHTMLDocument(this) ? name.lower() : name;
 335
 336     // allocate attributemap if necessary
 337     Attribute* old = attributes(false)->getAttributeItem(localName);
 338
 339     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
 340     if (namedAttrMap->isReadOnlyNode()) {
 341         ec = NO_MODIFICATION_ALLOWED_ERR;
 342         return;
 343     }
 344
 345     if (inDocument())
 346         document()->incDOMTreeVersion();
 347
 348     if (localName == idAttr.localName())
 349         updateId(old ? old->value() : nullAtom, value);
 350
 351     if (old && value.isNull())
 352         namedAttrMap->removeAttribute(old->name());
 353     else if (!old && !value.isNull())
 354         namedAttrMap->addAttribute(createAttribute(QualifiedName(nullAtom, localName.impl(), nullAtom), value.impl()));
 355     else if (old && !value.isNull()) {
 356         old->setValue(value);
 357         attributeChanged(old);
 358     }
 359 }
 360
 361 void Element::setAttribute(const QualifiedName& name, StringImpl* value, ExceptionCode& ec)
 362 {
 363     if (inDocument())
 364         document()->incDOMTreeVersion();
 365
 366     // allocate attributemap if necessary
 367     Attribute* old = attributes(false)->getAttributeItem(name);
 368
 369     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
 370     if (namedAttrMap->isReadOnlyNode()) {
 371         ec = NO_MODIFICATION_ALLOWED_ERR;
 372         return;
 373     }
 374
 375     if (name == idAttr)
 376         updateId(old ? old->value() : nullAtom, value);
 377
 378     if (old && !value)
 379         namedAttrMap->removeAttribute(name);
 380     else if (!old && value)
 381         namedAttrMap->addAttribute(createAttribute(name, value));
 382     else if (old && value) {
 383         old->setValue(value);
 384         attributeChanged(old);
 385     }
 386 }
 387
 388 Attribute* Element::createAttribute(const QualifiedName& name, StringImpl* value)
 389 {
 390     return new Attribute(name, value);
 391 }
 392
 393 void Element::setAttributeMap(NamedAttrMap* list)
 394 {
 395     if (inDocument())
 396         document()->incDOMTreeVersion();
 397
 398     // If setting the whole map changes the id attribute, we need to call updateId.
 399
 400     Attribute *oldId = namedAttrMap ? namedAttrMap->getAttributeItem(idAttr) : 0;
 401     Attribute *newId = list ? list->getAttributeItem(idAttr) : 0;
 402
 403     if (oldId || newId)
 404         updateId(oldId ? oldId->value() : nullAtom, newId ? newId->value() : nullAtom);
 405
 406     if (namedAttrMap)
 407         namedAttrMap->element = 0;
 408
 409     namedAttrMap = list;
 410
 411     if (namedAttrMap) {
 412         namedAttrMap->element = this;
 413         unsigned len = namedAttrMap->length();
 414         for (unsigned i = 0; i < len; i++)
 415             attributeChanged(namedAttrMap->attrs[i]);
 416         // FIXME: What about attributes that were in the old map that are not in the new map?
 417     }
 418 }
 419
 420 bool Element::hasAttributes() const
 421 {
 422     updateStyleAttributeIfNeeded();
 423     return namedAttrMap && namedAttrMap->length() > 0;
 424 }
 425
 426 String Element::nodeName() const
 427 {
 428     return m_tagName.toString();
 429 }
 430
 431 String Element::nodeNamePreservingCase() const
 432 {
 433     return m_tagName.toString();
 434 }
 435
 436 void Element::setPrefix(const AtomicString &_prefix, ExceptionCode& ec)
 437 {
 438     checkSetPrefix(_prefix, ec);
 439     if (ec)
 440         return;
 441
 442     m_tagName.setPrefix(_prefix);
 443 }
 444
 445 Node* Element::insertAdjacentElement(const String& where, Node* newChild, int& exception)
 446 {
 447     if (!newChild) {
 448         // IE throws COM Exception E_INVALIDARG; this is the best DOM exception alternative
 449         exception = TYPE_MISMATCH_ERR;
 450         return 0;
 451     }
 452
 453     // In Internet Explorer if the element has no parent and where is "beforeBegin" or "afterEnd",
 454     // a document fragment is created and the elements appended in the correct order. This document
 455     // fragment isn't returned anywhere.
 456     //
 457     // This is impossible for us to implement as the DOM tree does not allow for such structures,
 458     // Opera also appears to disallow such usage.
 459
 460     if (equalIgnoringCase(where, "beforeBegin")) {
 461         if (Node* p = parent())
 462             return p->insertBefore(newChild, this, exception) ? newChild : 0;
 463     } else if (equalIgnoringCase(where, "afterBegin")) {
 464         return insertBefore(newChild, firstChild(), exception) ? newChild : 0;
 465     } else if (equalIgnoringCase(where, "beforeEnd")) {
 466         return appendChild(newChild, exception) ? newChild : 0;
 467     } else if (equalIgnoringCase(where, "afterEnd")) {
 468         if (Node* p = parent())
 469             return p->insertBefore(newChild, nextSibling(), exception) ? newChild : 0;
 470     } else {
 471         // IE throws COM Exception E_INVALIDARG; this is the best DOM exception alternative
 472         exception = NOT_SUPPORTED_ERR;
 473     }
 474     return 0;
 475 }
 476
 477 bool Element::contains(const Element* element) const
 478 {
 479     if (!element)
 480         return false;
 481     return this == element || element->isAncestor(this);
 482 }
 483
 484 void Element::createAttributeMap() const
 485 {
 486     namedAttrMap = new NamedAttrMap(const_cast<Element*>(this));
 487 }
 488
 489 bool Element::isURLAttribute(Attribute *attr) const
 490 {
 491     return false;
 492 }
 493
 494 RenderStyle *Element::styleForRenderer(RenderObject *parentRenderer)
 495 {
 496     return document()->styleSelector()->styleForElement(this);
 497 }
 498
 499 RenderObject *Element::createRenderer(RenderArena *arena, RenderStyle *style)
 500 {
 501     if (document()->documentElement() == this && style->display() == NONE) {
 502         // Ignore display: none on root elements.  Force a display of block in that case.
 503         RenderBlock* result = new (arena) RenderBlock(this);
 504         if (result) result->setStyle(style);
 505         return result;
 506     }
 507     return RenderObject::createObject(this, style);
 508 }
 509
 510
 511 void Element::insertedIntoDocument()
 512 {
 513     // need to do superclass processing first so inDocument() is true
 514     // by the time we reach updateId
 515     ContainerNode::insertedIntoDocument();
 516
 517     if (hasID()) {
 518         NamedAttrMap* attrs = attributes(true);
 519         if (attrs) {
 520             Attribute* idItem = attrs->getAttributeItem(idAttr);
 521             if (idItem && !idItem->isNull())
 522                 updateId(nullAtom, idItem->value());
 523         }
 524     }
 525 }
 526
 527 void Element::removedFromDocument()
 528 {
 529     if (hasID()) {
 530         NamedAttrMap* attrs = attributes(true);
 531         if (attrs) {
 532             Attribute* idItem = attrs->getAttributeItem(idAttr);
 533             if (idItem && !idItem->isNull())
 534                 updateId(idItem->value(), nullAtom);
 535         }
 536     }
 537
 538     ContainerNode::removedFromDocument();
 539 }
 540
 541 void Element::attach()
 542 {
 543 #if SPEED_DEBUG < 1
 544     createRendererIfNeeded();
 545 #endif
 546     ContainerNode::attach();
 547     if (needsFocusAppearanceUpdate() && !m_updateFocusAppearanceTimer.isActive() && document()->focusNode() == this)
 548         m_updateFocusAppearanceTimer.startOneShot(0);
 549 }
 550
 551 void Element::detach()
 552 {
 553     stopUpdateFocusAppearanceTimer();
 554     ContainerNode::detach();
 555 }
 556
 557 void Element::recalcStyle(StyleChange change)
 558 {
 559     // ### should go away and be done in renderobject
 560     RenderStyle* _style = renderStyle();
 561     bool hasParentStyle = parentNode() ? parentNode()->renderStyle() : false;
 562
 563     if (hasParentStyle && (change >= Inherit || changed())) {
 564         RenderStyle *newStyle = document()->styleSelector()->styleForElement(this);
 565         StyleChange ch = diff(_style, newStyle);
 566         if (ch == Detach) {
 567             if (attached())
 568                 detach();
 569             // ### Suboptimal. Style gets calculated again.
 570             attach();
 571             // attach recalulates the style for all children. No need to do it twice.
 572             setChanged(false);
 573             setHasChangedChild(false);
 574             newStyle->deref(document()->renderArena());
 575             return;
 576         }
 577         else if (ch != NoChange) {
 578             if (newStyle)
 579                 setRenderStyle(newStyle);
 580         }
 581         else if (changed() && newStyle && (document()->usesSiblingRules() || document()->usesDescendantRules())) {
 582             // Although no change occurred, we use the new style so that the cousin style sharing code won't get
 583             // fooled into believing this style is the same.  This is only necessary if the document actually uses
 584             // sibling/descendant rules, since otherwise it isn't possible for ancestor styles to affect sharing of
 585             // descendants.
 586             if (renderer())
 587                 renderer()->setStyleInternal(newStyle);
 588             else
 589                 setRenderStyle(newStyle);
 590         }
 591
 592         newStyle->deref(document()->renderArena());
 593
 594         if (change != Force) {
 595             if (document()->usesDescendantRules())
 596                 change = Force;
 597             else
 598                 change = ch;
 599         }
 600     }
 601
 602     for (Node *n = fastFirstChild(); n; n = n->nextSibling()) {
 603         if (change >= Inherit || n->isTextNode() || n->hasChangedChild() || n->changed())
 604             n->recalcStyle(change);
 605     }
 606
 607     setChanged(false);
 608     setHasChangedChild(false);
 609 }
 610
 611 bool Element::childTypeAllowed(NodeType type)
 612 {
 613     switch (type) {
 614         case ELEMENT_NODE:
 615         case TEXT_NODE:
 616         case COMMENT_NODE:
 617         case PROCESSING_INSTRUCTION_NODE:
 618         case CDATA_SECTION_NODE:
 619         case ENTITY_REFERENCE_NODE:
 620             return true;
 621             break;
 622         default:
 623             return false;
 624     }
 625 }
 626
 627 void Element::dispatchAttrRemovalEvent(Attribute*)
 628 {
 629     assert(!eventDispatchForbidden());
 630 #if 0
 631     if (!document()->hasListenerType(Document::DOMATTRMODIFIED_LISTENER))
 632         return;
 633     ExceptionCode ec = 0;
 634     dispatchEvent(new MutationEvent(DOMAttrModifiedEvent, true, false, attr, attr->value(),
 635         attr->value(), document()->attrName(attr->id()), MutationEvent::REMOVAL), ec);
 636 #endif
 637 }
 638
 639 void Element::dispatchAttrAdditionEvent(Attribute *attr)
 640 {
 641     assert(!eventDispatchForbidden());
 642 #if 0
 643     if (!document()->hasListenerType(Document::DOMATTRMODIFIED_LISTENER))
 644         return;
 645     ExceptionCode ec = 0;
 646     dispatchEvent(new MutationEvent(DOMAttrModifiedEvent, true, false, attr, attr->value(),
 647         attr->value(),document()->attrName(attr->id()), MutationEvent::ADDITION), ec);
 648 #endif
 649 }
 650
 651 String Element::openTagStartToString() const
 652 {
 653     String result = "<" + nodeName();
 654
 655     NamedAttrMap *attrMap = attributes(true);
 656
 657     if (attrMap) {
 658         unsigned numAttrs = attrMap->length();
 659         for (unsigned i = 0; i < numAttrs; i++) {
 660             result += " ";
 661
 662             Attribute *attribute = attrMap->attributeItem(i);
 663             result += attribute->name().toString();
 664             if (!attribute->value().isNull()) {
 665                 result += "=\"";
 666                 // FIXME: substitute entities for any instances of " or '
 667                 result += attribute->value();
 668                 result += "\"";
 669             }
 670         }
 671     }
 672
 673     return result;
 674 }
 675
 676 String Element::toString() const
 677 {
 678     String result = openTagStartToString();
 679
 680     if (hasChildNodes()) {
 681         result += ">";
 682
 683         for (Node *child = firstChild(); child != NULL; child = child->nextSibling()) {
 684             result += child->toString();
 685         }
 686
 687         result += "</";
 688         result += nodeName();
 689         result += ">";
 690     } else {
 691         result += " />";
 692     }
 693
 694     return result;
 695 }
 696
 697 void Element::updateId(const AtomicString& oldId, const AtomicString& newId)
 698 {
 699     if (!inDocument())
 700         return;
 701
 702     if (oldId == newId)
 703         return;
 704
 705     Document* doc = document();
 706     if (!oldId.isEmpty())
 707         doc->removeElementById(oldId, this);
 708     if (!newId.isEmpty())
 709         doc->addElementById(newId, this);
 710 }
 711
 712 #ifndef NDEBUG
 713 void Element::dump(TextStream *stream, DeprecatedString ind) const
 714 {
 715     updateStyleAttributeIfNeeded();
 716     if (namedAttrMap) {
 717         for (unsigned i = 0; i < namedAttrMap->length(); i++) {
 718             Attribute *attr = namedAttrMap->attributeItem(i);
 719             *stream << " " << attr->name().localName().deprecatedString().ascii()
 720                     << "=\"" << attr->value().deprecatedString().ascii() << "\"";
 721         }
 722     }
 723
 724     ContainerNode::dump(stream,ind);
 725 }
 726 #endif
 727
 728 #ifndef NDEBUG
 729 void Element::formatForDebugger(char *buffer, unsigned length) const
 730 {
 731     String result;
 732     String s;
 733
 734     s = nodeName();
 735     if (s.length() > 0) {
 736         result += s;
 737     }
 738
 739     s = getAttribute(idAttr);
 740     if (s.length() > 0) {
 741         if (result.length() > 0)
 742             result += "; ";
 743         result += "id=";
 744         result += s;
 745     }
 746
 747     s = getAttribute(classAttr);
 748     if (s.length() > 0) {
 749         if (result.length() > 0)
 750             result += "; ";
 751         result += "class=";
 752         result += s;
 753     }
 754
 755     strncpy(buffer, result.deprecatedString().latin1(), length - 1);
 756 }
 757 #endif
 758
 759 PassRefPtr<Attr> Element::setAttributeNode(Attr *attr, ExceptionCode& ec)
 760 {
 761     ASSERT(attr);
 762     return static_pointer_cast<Attr>(attributes(false)->setNamedItem(attr, ec));
 763 }
 764
 765 PassRefPtr<Attr> Element::removeAttributeNode(Attr *attr, ExceptionCode& ec)
 766 {
 767     if (!attr || attr->ownerElement() != this) {
 768         ec = NOT_FOUND_ERR;
 769         return 0;
 770     }
 771     if (document() != attr->document()) {
 772         ec = WRONG_DOCUMENT_ERR;
 773         return 0;
 774     }
 775
 776     NamedAttrMap *attrs = attributes(true);
 777     if (!attrs)
 778         return 0;
 779
 780     return static_pointer_cast<Attr>(attrs->removeNamedItem(attr->qualifiedName(), ec));
 781 }
 782
 783 void Element::setAttributeNS(const String& namespaceURI, const String& qualifiedName, const String& value, ExceptionCode& ec)
 784 {
 785     String prefix, localName;
 786     if (!Document::parseQualifiedName(qualifiedName, prefix, localName)) {
 787         ec = INVALID_CHARACTER_ERR;
 788         return;
 789     }
 790     setAttribute(QualifiedName(prefix.impl(), localName.impl(), namespaceURI.impl()), value.impl(), ec);
 791 }
 792
 793 void Element::removeAttribute(const String& name, ExceptionCode& ec)
 794 {
 795     String localName = inHTMLDocument(this) ? name.lower() : name;
 796
 797     if (namedAttrMap) {
 798         namedAttrMap->removeNamedItem(localName, ec);
 799         if (ec == NOT_FOUND_ERR)
 800             ec = 0;
 801     }
 802 }
 803
 804 void Element::removeAttributeNS(const String& namespaceURI, const String& localName, ExceptionCode& ec)
 805 {
 806     removeAttribute(QualifiedName(nullAtom, localName.impl(), namespaceURI.impl()), ec);
 807 }
 808
 809 PassRefPtr<Attr> Element::getAttributeNode(const String& name)
 810 {
 811     NamedAttrMap *attrs = attributes(true);
 812     if (!attrs)
 813         return 0;
 814     String localName = inHTMLDocument(this) ? name.lower() : name;
 815     return static_pointer_cast<Attr>(attrs->getNamedItem(localName));
 816 }
 817
 818 PassRefPtr<Attr> Element::getAttributeNodeNS(const String& namespaceURI, const String& localName)
 819 {
 820     NamedAttrMap *attrs = attributes(true);
 821     if (!attrs)
 822         return 0;
 823     return static_pointer_cast<Attr>(attrs->getNamedItem(QualifiedName(nullAtom, localName.impl(), namespaceURI.impl())));
 824 }
 825
 826 bool Element::hasAttribute(const String& name) const
 827 {
 828     NamedAttrMap *attrs = attributes(true);
 829     if (!attrs)
 830         return false;
 831     String localName = inHTMLDocument(this) ? name.lower() : name;
 832     return attrs->getAttributeItem(localName);
 833 }
 834
 835 bool Element::hasAttributeNS(const String& namespaceURI, const String& localName) const
 836 {
 837     NamedAttrMap *attrs = attributes(true);
 838     if (!attrs)
 839         return false;
 840     return attrs->getAttributeItem(QualifiedName(nullAtom, localName.impl(), namespaceURI.impl()));
 841 }
 842
 843 CSSStyleDeclaration *Element::style()
 844 {
 845     return 0;
 846 }
 847
 848 void Element::focus()
 849 {
 850     Document* doc = document();
 851     doc->updateLayout();
 852
 853     if (!supportsFocus())
 854         return;
 855
 856     doc->setFocusNode(this);
 857
 858     if (!isFocusable()) {
 859         setNeedsFocusAppearanceUpdate(true);
 860         return;
 861     }
 862
 863     updateFocusAppearance();
 864 }
 865
 866 void Element::updateFocusAppearance()
 867 {
 868     if (this == rootEditableElement()) {
 869         Frame* frame = document()->frame();
 870         if (!frame)
 871             return;
 872
 873         // FIXME: We should restore the previous selection if there is one.
 874         Selection s = hasTagName(htmlTag) || hasTagName(bodyTag) ? Selection(Position(this, 0), DOWNSTREAM) : Selection::selectionFromContentsOfNode(this);
 875         SelectionController sc(s);
 876
 877         if (frame->shouldChangeSelection(sc)) {
 878             frame->setSelection(sc);
 879             frame->revealSelection();
 880         }
 881     } else if (renderer() && !renderer()->isWidget())
 882         renderer()->enclosingLayer()->scrollRectToVisible(getRect());
 883 }
 884
 885 void Element::updateFocusAppearanceTimerFired(Timer<Element>*)
 886 {
 887     stopUpdateFocusAppearanceTimer();
 888     Document* doc = document();
 889     doc->updateLayout();
 890     if (isFocusable())
 891         updateFocusAppearance();
 892 }
 893
 894 void Element::blur()
 895 {
 896     stopUpdateFocusAppearanceTimer();
 897     Document* doc = document();
 898     if (doc->focusNode() == this)
 899         doc->setFocusNode(0);
 900 }
 901
 902 void Element::stopUpdateFocusAppearanceTimer()
 903 {
 904     if (m_updateFocusAppearanceTimer.isActive()) {
 905         m_updateFocusAppearanceTimer.stop();
 906         setNeedsFocusAppearanceUpdate(false);
 907     }
 908 }
 909
 910 }