WebCore/html/HTMLElement.cpp

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public License
  17  * along with this library; see the file COPYING.LIB.  If not, write to
  18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  *
  21  */
  22
  23 #include "config.h"
  24 #include "HTMLElement.h"
  25
  26 #include "CSSPropertyNames.h"
  27 #include "CSSValueKeywords.h"
  28 #include "DocumentFragment.h"
  29 #include "Event.h"
  30 #include "EventListener.h"
  31 #include "EventNames.h"
  32 #include "ExceptionCode.h"
  33 #include "Frame.h"
  34 #include "HTMLBRElement.h"
  35 #include "HTMLDocument.h"
  36 #include "HTMLElementFactory.h"
  37 #include "HTMLFormElement.h"
  38 #include "HTMLNames.h"
  39 #include "HTMLTokenizer.h" // parseHTMLDocumentFragment
  40 #include "RenderWordBreak.h"
  41 #include "Settings.h"
  42 #include "Text.h"
  43 #include "TextIterator.h"
  44 #include "XMLTokenizer.h"
  45 #include "markup.h"
  46 #include <wtf/StdLibExtras.h>
  47
  48 namespace WebCore {
  49
  50 using namespace HTMLNames;
  51
  52 using std::min;
  53 using std::max;
  54
  55 HTMLElement::HTMLElement(const QualifiedName& tagName, Document *doc)
  56     : StyledElement(tagName, doc)
  57 {
  58 }
  59
  60 HTMLElement::~HTMLElement()
  61 {
  62 }
  63
  64 String HTMLElement::nodeName() const
  65 {
  66     // FIXME: Would be nice to have an atomicstring lookup based off uppercase chars that does not have to copy
  67     // the string on a hit in the hash.
  68     if (document()->isHTMLDocument())
  69         return tagQName().localName().string().upper();
  70     return Element::nodeName();
  71 }
  72
  73 HTMLTagStatus HTMLElement::endTagRequirement() const
  74 {
  75     if (hasLocalName(wbrTag))
  76         return TagStatusForbidden;
  77     if (hasLocalName(dtTag) || hasLocalName(ddTag))
  78         return TagStatusOptional;
  79
  80     // Same values as <span>.  This way custom tag name elements will behave like inline spans.
  81     return TagStatusRequired;
  82 }
  83
  84 int HTMLElement::tagPriority() const
  85 {
  86     if (hasLocalName(wbrTag))
  87         return 0;
  88     if (hasLocalName(addressTag) || hasLocalName(ddTag) || hasLocalName(dtTag) || hasLocalName(noscriptTag))
  89         return 3;
  90     if (hasLocalName(centerTag) || hasLocalName(nobrTag))
  91         return 5;
  92     if (hasLocalName(noembedTag) || hasLocalName(noframesTag))
  93         return 10;
  94
  95     // Same values as <span>.  This way custom tag name elements will behave like inline spans.
  96     return 1;
  97 }
  98
  99 PassRefPtr<Node> HTMLElement::cloneNode(bool deep)
 100 {
 101     RefPtr<HTMLElement> clone = HTMLElementFactory::createHTMLElement(tagQName(), document(), 0, false);
 102     if (!clone)
 103         return 0;
 104
 105     if (namedAttrMap)
 106         clone->attributes()->setAttributes(*namedAttrMap);
 107
 108     clone->copyNonAttributeProperties(this);
 109
 110     if (deep)
 111         cloneChildNodes(clone.get());
 112
 113     return clone.release();
 114 }
 115
 116 bool HTMLElement::mapToEntry(const QualifiedName& attrName, MappedAttributeEntry& result) const
 117 {
 118     if (attrName == alignAttr ||
 119         attrName == contenteditableAttr) {
 120         result = eUniversal;
 121         return false;
 122     }
 123     if (attrName == dirAttr) {
 124         result = hasLocalName(bdoTag) ? eBDO : eUniversal;
 125         return false;
 126     }
 127
 128     return StyledElement::mapToEntry(attrName, result);
 129 }
 130
 131 void HTMLElement::parseMappedAttribute(MappedAttribute *attr)
 132 {
 133     if (attr->name() == idAttr || attr->name() == classAttr || attr->name() == styleAttr)
 134         return StyledElement::parseMappedAttribute(attr);
 135
 136     String indexstring;
 137     if (attr->name() == alignAttr) {
 138         if (equalIgnoringCase(attr->value(), "middle"))
 139             addCSSProperty(attr, CSSPropertyTextAlign, "center");
 140         else
 141             addCSSProperty(attr, CSSPropertyTextAlign, attr->value());
 142     } else if (attr->name() == contenteditableAttr) {
 143         setContentEditable(attr);
 144     } else if (attr->name() == tabindexAttr) {
 145         indexstring = getAttribute(tabindexAttr);
 146         if (indexstring.length()) {
 147             bool parsedOK;
 148             int tabindex = indexstring.toIntStrict(&parsedOK);
 149             if (parsedOK)
 150                 // Clamp tabindex to the range of 'short' to match Firefox's behavior.
 151                 setTabIndexExplicitly(max(static_cast<int>(std::numeric_limits<short>::min()), min(tabindex, static_cast<int>(std::numeric_limits<short>::max()))));
 152         }
 153     } else if (attr->name() == langAttr) {
 154         // FIXME: Implement
 155     } else if (attr->name() == dirAttr) {
 156         addCSSProperty(attr, CSSPropertyDirection, attr->value());
 157         addCSSProperty(attr, CSSPropertyUnicodeBidi, hasLocalName(bdoTag) ? CSSValueBidiOverride : CSSValueEmbed);
 158     }
 159 // standard events
 160     else if (attr->name() == onclickAttr) {
 161         setInlineEventListenerForTypeAndAttribute(eventNames().clickEvent, attr);
 162     } else if (attr->name() == oncontextmenuAttr) {
 163         setInlineEventListenerForTypeAndAttribute(eventNames().contextmenuEvent, attr);
 164     } else if (attr->name() == ondblclickAttr) {
 165         setInlineEventListenerForTypeAndAttribute(eventNames().dblclickEvent, attr);
 166     } else if (attr->name() == onmousedownAttr) {
 167         setInlineEventListenerForTypeAndAttribute(eventNames().mousedownEvent, attr);
 168     } else if (attr->name() == onmousemoveAttr) {
 169         setInlineEventListenerForTypeAndAttribute(eventNames().mousemoveEvent, attr);
 170     } else if (attr->name() == onmouseoutAttr) {
 171         setInlineEventListenerForTypeAndAttribute(eventNames().mouseoutEvent, attr);
 172     } else if (attr->name() == onmouseoverAttr) {
 173         setInlineEventListenerForTypeAndAttribute(eventNames().mouseoverEvent, attr);
 174     } else if (attr->name() == onmouseupAttr) {
 175         setInlineEventListenerForTypeAndAttribute(eventNames().mouseupEvent, attr);
 176     } else if (attr->name() == onmousewheelAttr) {
 177         setInlineEventListenerForTypeAndAttribute(eventNames().mousewheelEvent, attr);
 178     } else if (attr->name() == onfocusAttr) {
 179         setInlineEventListenerForTypeAndAttribute(eventNames().focusEvent, attr);
 180     } else if (attr->name() == onblurAttr) {
 181         setInlineEventListenerForTypeAndAttribute(eventNames().blurEvent, attr);
 182     } else if (attr->name() == onkeydownAttr) {
 183         setInlineEventListenerForTypeAndAttribute(eventNames().keydownEvent, attr);
 184     } else if (attr->name() == onkeypressAttr) {
 185         setInlineEventListenerForTypeAndAttribute(eventNames().keypressEvent, attr);
 186     } else if (attr->name() == onkeyupAttr) {
 187         setInlineEventListenerForTypeAndAttribute(eventNames().keyupEvent, attr);
 188     } else if (attr->name() == onscrollAttr) {
 189         setInlineEventListenerForTypeAndAttribute(eventNames().scrollEvent, attr);
 190     } else if (attr->name() == onbeforecutAttr) {
 191         setInlineEventListenerForTypeAndAttribute(eventNames().beforecutEvent, attr);
 192     } else if (attr->name() == oncutAttr) {
 193         setInlineEventListenerForTypeAndAttribute(eventNames().cutEvent, attr);
 194     } else if (attr->name() == onbeforecopyAttr) {
 195         setInlineEventListenerForTypeAndAttribute(eventNames().beforecopyEvent, attr);
 196     } else if (attr->name() == oncopyAttr) {
 197         setInlineEventListenerForTypeAndAttribute(eventNames().copyEvent, attr);
 198     } else if (attr->name() == onbeforepasteAttr) {
 199         setInlineEventListenerForTypeAndAttribute(eventNames().beforepasteEvent, attr);
 200     } else if (attr->name() == onpasteAttr) {
 201         setInlineEventListenerForTypeAndAttribute(eventNames().pasteEvent, attr);
 202     } else if (attr->name() == ondragenterAttr) {
 203         setInlineEventListenerForTypeAndAttribute(eventNames().dragenterEvent, attr);
 204     } else if (attr->name() == ondragoverAttr) {
 205         setInlineEventListenerForTypeAndAttribute(eventNames().dragoverEvent, attr);
 206     } else if (attr->name() == ondragleaveAttr) {
 207         setInlineEventListenerForTypeAndAttribute(eventNames().dragleaveEvent, attr);
 208     } else if (attr->name() == ondropAttr) {
 209         setInlineEventListenerForTypeAndAttribute(eventNames().dropEvent, attr);
 210     } else if (attr->name() == ondragstartAttr) {
 211         setInlineEventListenerForTypeAndAttribute(eventNames().dragstartEvent, attr);
 212     } else if (attr->name() == ondragAttr) {
 213         setInlineEventListenerForTypeAndAttribute(eventNames().dragEvent, attr);
 214     } else if (attr->name() == ondragendAttr) {
 215         setInlineEventListenerForTypeAndAttribute(eventNames().dragendEvent, attr);
 216     } else if (attr->name() == onselectstartAttr) {
 217         setInlineEventListenerForTypeAndAttribute(eventNames().selectstartEvent, attr);
 218     } else if (attr->name() == onsubmitAttr) {
 219         setInlineEventListenerForTypeAndAttribute(eventNames().submitEvent, attr);
 220     } else if (attr->name() == onerrorAttr) {
 221         setInlineEventListenerForTypeAndAttribute(eventNames().errorEvent, attr);
 222     } else if (attr->name() == onwebkitanimationstartAttr) {
 223         setInlineEventListenerForTypeAndAttribute(eventNames().webkitAnimationStartEvent, attr);
 224     } else if (attr->name() == onwebkitanimationiterationAttr) {
 225         setInlineEventListenerForTypeAndAttribute(eventNames().webkitAnimationIterationEvent, attr);
 226     } else if (attr->name() == onwebkitanimationendAttr) {
 227         setInlineEventListenerForTypeAndAttribute(eventNames().webkitAnimationEndEvent, attr);
 228     } else if (attr->name() == onwebkittransitionendAttr) {
 229         setInlineEventListenerForTypeAndAttribute(eventNames().webkitTransitionEndEvent, attr);
 230     }
 231 }
 232
 233 String HTMLElement::innerHTML() const
 234 {
 235     return createMarkup(this, ChildrenOnly);
 236 }
 237
 238 String HTMLElement::outerHTML() const
 239 {
 240     return createMarkup(this);
 241 }
 242
 243 PassRefPtr<DocumentFragment> HTMLElement::createContextualFragment(const String &html)
 244 {
 245     // the following is in accordance with the definition as used by IE
 246     if (endTagRequirement() == TagStatusForbidden)
 247         return 0;
 248
 249     if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag) ||
 250         hasLocalName(headTag) || hasLocalName(styleTag) || hasLocalName(titleTag))
 251         return 0;
 252
 253     RefPtr<DocumentFragment> fragment = new DocumentFragment(document());
 254
 255     if (document()->isHTMLDocument())
 256          parseHTMLDocumentFragment(html, fragment.get());
 257     else {
 258         if (!parseXMLDocumentFragment(html, fragment.get(), this))
 259             // FIXME: We should propagate a syntax error exception out here.
 260             return 0;
 261     }
 262
 263     // Exceptions are ignored because none ought to happen here.
 264     int ignoredExceptionCode;
 265
 266     // we need to pop <html> and <body> elements and remove <head> to
 267     // accommodate folks passing complete HTML documents to make the
 268     // child of an element.
 269
 270     RefPtr<Node> nextNode;
 271     for (RefPtr<Node> node = fragment->firstChild(); node; node = nextNode) {
 272         nextNode = node->nextSibling();
 273         if (node->hasTagName(htmlTag) || node->hasTagName(bodyTag)) {
 274             Node *firstChild = node->firstChild();
 275             if (firstChild)
 276                 nextNode = firstChild;
 277             RefPtr<Node> nextChild;
 278             for (RefPtr<Node> child = firstChild; child; child = nextChild) {
 279                 nextChild = child->nextSibling();
 280                 node->removeChild(child.get(), ignoredExceptionCode);
 281                 ASSERT(!ignoredExceptionCode);
 282                 fragment->insertBefore(child, node.get(), ignoredExceptionCode);
 283                 ASSERT(!ignoredExceptionCode);
 284             }
 285             fragment->removeChild(node.get(), ignoredExceptionCode);
 286             ASSERT(!ignoredExceptionCode);
 287         } else if (node->hasTagName(headTag)) {
 288             fragment->removeChild(node.get(), ignoredExceptionCode);
 289             ASSERT(!ignoredExceptionCode);
 290         }
 291     }
 292
 293     return fragment.release();
 294 }
 295
 296 static inline bool hasOneChild(ContainerNode* node)
 297 {
 298     Node* firstChild = node->firstChild();
 299     return firstChild && !firstChild->nextSibling();
 300 }
 301
 302 static inline bool hasOneTextChild(ContainerNode* node)
 303 {
 304     return hasOneChild(node) && node->firstChild()->isTextNode();
 305 }
 306
 307 static void replaceChildrenWithFragment(HTMLElement* element, PassRefPtr<DocumentFragment> fragment, ExceptionCode& ec)
 308 {
 309     if (!fragment->firstChild()) {
 310         element->removeChildren();
 311         return;
 312     }
 313
 314     if (hasOneTextChild(element) && hasOneTextChild(fragment.get())) {
 315         static_cast<Text*>(element->firstChild())->setData(static_cast<Text*>(fragment->firstChild())->string(), ec);
 316         return;
 317     }
 318
 319     if (hasOneChild(element)) {
 320         element->replaceChild(fragment, element->firstChild(), ec);
 321         return;
 322     }
 323
 324     element->removeChildren();
 325     element->appendChild(fragment, ec);
 326 }
 327
 328 static void replaceChildrenWithText(HTMLElement* element, const String& text, ExceptionCode& ec)
 329 {
 330     if (hasOneTextChild(element)) {
 331         static_cast<Text*>(element->firstChild())->setData(text, ec);
 332         return;
 333     }
 334
 335     RefPtr<Text> textNode = new Text(element->document(), text);
 336
 337     if (hasOneChild(element)) {
 338         element->replaceChild(textNode.release(), element->firstChild(), ec);
 339         return;
 340     }
 341
 342     element->removeChildren();
 343     element->appendChild(textNode.release(), ec);
 344 }
 345
 346 void HTMLElement::setInnerHTML(const String& html, ExceptionCode& ec)
 347 {
 348     RefPtr<DocumentFragment> fragment = createContextualFragment(html);
 349     if (!fragment) {
 350         ec = NO_MODIFICATION_ALLOWED_ERR;
 351         return;
 352     }
 353
 354     replaceChildrenWithFragment(this, fragment.release(), ec);
 355 }
 356
 357 void HTMLElement::setOuterHTML(const String& html, ExceptionCode& ec)
 358 {
 359     Node* p = parent();
 360     if (!p || !p->isHTMLElement()) {
 361         ec = NO_MODIFICATION_ALLOWED_ERR;
 362         return;
 363     }
 364
 365     HTMLElement* parent = static_cast<HTMLElement*>(p);
 366     RefPtr<DocumentFragment> fragment = parent->createContextualFragment(html);
 367     if (!fragment) {
 368         ec = NO_MODIFICATION_ALLOWED_ERR;
 369         return;
 370     }
 371
 372     // FIXME: Why doesn't this have code to merge neighboring text nodes the way setOuterText does?
 373
 374     parent->replaceChild(fragment.release(), this, ec);
 375 }
 376
 377 void HTMLElement::setInnerText(const String& text, ExceptionCode& ec)
 378 {
 379     // follow the IE specs about when this is allowed
 380     if (endTagRequirement() == TagStatusForbidden) {
 381         ec = NO_MODIFICATION_ALLOWED_ERR;
 382         return;
 383     }
 384     if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag) ||
 385         hasLocalName(headTag) || hasLocalName(htmlTag) || hasLocalName(tableTag) ||
 386         hasLocalName(tbodyTag) || hasLocalName(tfootTag) || hasLocalName(theadTag) ||
 387         hasLocalName(trTag)) {
 388         ec = NO_MODIFICATION_ALLOWED_ERR;
 389         return;
 390     }
 391
 392     // FIXME: This doesn't take whitespace collapsing into account at all.
 393
 394     if (!text.contains('\n') && !text.contains('\r')) {
 395         if (text.isEmpty()) {
 396             removeChildren();
 397             return;
 398         }
 399         replaceChildrenWithText(this, text, ec);
 400         return;
 401     }
 402
 403     // FIXME: Do we need to be able to detect preserveNewline style even when there's no renderer?
 404     // FIXME: Can the renderer be out of date here? Do we need to call updateRendering?
 405     // For example, for the contents of textarea elements that are display:none?
 406     RenderObject* r = renderer();
 407     if (r && r->style()->preserveNewline()) {
 408         if (!text.contains('\r')) {
 409             replaceChildrenWithText(this, text, ec);
 410             return;
 411         }
 412         String textWithConsistentLineBreaks = text;
 413         textWithConsistentLineBreaks.replace("\r\n", "\n");
 414         textWithConsistentLineBreaks.replace('\r', '\n');
 415         replaceChildrenWithText(this, textWithConsistentLineBreaks, ec);
 416         return;
 417     }
 418
 419     // Add text nodes and <br> elements.
 420     ec = 0;
 421     RefPtr<DocumentFragment> fragment = new DocumentFragment(document());
 422     int lineStart = 0;
 423     UChar prev = 0;
 424     int length = text.length();
 425     for (int i = 0; i < length; ++i) {
 426         UChar c = text[i];
 427         if (c == '\n' || c == '\r') {
 428             if (i > lineStart) {
 429                 fragment->appendChild(new Text(document(), text.substring(lineStart, i - lineStart)), ec);
 430                 if (ec)
 431                     return;
 432             }
 433             if (!(c == '\n' && i != 0 && prev == '\r')) {
 434                 fragment->appendChild(new HTMLBRElement(brTag, document()), ec);
 435                 if (ec)
 436                     return;
 437             }
 438             lineStart = i + 1;
 439         }
 440         prev = c;
 441     }
 442     if (length > lineStart)
 443         fragment->appendChild(new Text(document(), text.substring(lineStart, length - lineStart)), ec);
 444     replaceChildrenWithFragment(this, fragment.release(), ec);
 445 }
 446
 447 void HTMLElement::setOuterText(const String &text, ExceptionCode& ec)
 448 {
 449     // follow the IE specs about when this is allowed
 450     if (endTagRequirement() == TagStatusForbidden) {
 451         ec = NO_MODIFICATION_ALLOWED_ERR;
 452         return;
 453     }
 454     if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag) ||
 455         hasLocalName(headTag) || hasLocalName(htmlTag) || hasLocalName(tableTag) ||
 456         hasLocalName(tbodyTag) || hasLocalName(tfootTag) || hasLocalName(theadTag) ||
 457         hasLocalName(trTag)) {
 458         ec = NO_MODIFICATION_ALLOWED_ERR;
 459         return;
 460     }
 461
 462     Node* parent = parentNode();
 463     if (!parent) {
 464         ec = NO_MODIFICATION_ALLOWED_ERR;
 465         return;
 466     }
 467
 468     // FIXME: This creates a new text node even when the text is empty.
 469     // FIXME: This creates a single text node even when the text has CR and LF
 470     // characters in it. Instead it should create <br> elements.
 471     RefPtr<Text> t = new Text(document(), text);
 472     ec = 0;
 473     parent->replaceChild(t, this, ec);
 474     if (ec)
 475         return;
 476
 477     // is previous node a text node? if so, merge into it
 478     Node* prev = t->previousSibling();
 479     if (prev && prev->isTextNode()) {
 480         Text* textPrev = static_cast<Text*>(prev);
 481         textPrev->appendData(t->data(), ec);
 482         if (ec)
 483             return;
 484         t->remove(ec);
 485         if (ec)
 486             return;
 487         t = textPrev;
 488     }
 489
 490     // is next node a text node? if so, merge it in
 491     Node* next = t->nextSibling();
 492     if (next && next->isTextNode()) {
 493         Text* textNext = static_cast<Text*>(next);
 494         t->appendData(textNext->data(), ec);
 495         if (ec)
 496             return;
 497         textNext->remove(ec);
 498         if (ec)
 499             return;
 500     }
 501 }
 502
 503 Node* HTMLElement::insertAdjacent(const String& where, Node* newChild, ExceptionCode& ec)
 504 {
 505     // In Internet Explorer if the element has no parent and where is "beforeBegin" or "afterEnd",
 506     // a document fragment is created and the elements appended in the correct order. This document
 507     // fragment isn't returned anywhere.
 508     //
 509     // This is impossible for us to implement as the DOM tree does not allow for such structures,
 510     // Opera also appears to disallow such usage.
 511
 512     if (equalIgnoringCase(where, "beforeBegin")) {
 513         if (Node* p = parent())
 514             return p->insertBefore(newChild, this, ec) ? newChild : 0;
 515         return 0;
 516     }
 517
 518     if (equalIgnoringCase(where, "afterBegin"))
 519         return insertBefore(newChild, firstChild(), ec) ? newChild : 0;
 520
 521     if (equalIgnoringCase(where, "beforeEnd"))
 522         return appendChild(newChild, ec) ? newChild : 0;
 523
 524     if (equalIgnoringCase(where, "afterEnd")) {
 525         if (Node* p = parent())
 526             return p->insertBefore(newChild, nextSibling(), ec) ? newChild : 0;
 527         return 0;
 528     }
 529
 530     // IE throws COM Exception E_INVALIDARG; this is the best DOM exception alternative
 531     ec = NOT_SUPPORTED_ERR;
 532     return 0;
 533 }
 534
 535 Element* HTMLElement::insertAdjacentElement(const String& where, Element* newChild, ExceptionCode& ec)
 536 {
 537     if (!newChild) {
 538         // IE throws COM Exception E_INVALIDARG; this is the best DOM exception alternative
 539         ec = TYPE_MISMATCH_ERR;
 540         return 0;
 541     }
 542
 543     Node* returnValue = insertAdjacent(where, newChild, ec);
 544     ASSERT(!returnValue || returnValue->isElementNode());
 545     return static_cast<Element*>(returnValue);
 546 }
 547
 548 void HTMLElement::insertAdjacentHTML(const String& where, const String& html, ExceptionCode& ec)
 549 {
 550     RefPtr<DocumentFragment> fragment = document()->createDocumentFragment();
 551     if (document()->isHTMLDocument())
 552          parseHTMLDocumentFragment(html, fragment.get());
 553     else {
 554         if (!parseXMLDocumentFragment(html, fragment.get(), this))
 555             // FIXME: We should propagate a syntax error exception out here.
 556             return;
 557     }
 558
 559     insertAdjacent(where, fragment.get(), ec);
 560 }
 561
 562 void HTMLElement::insertAdjacentText(const String& where, const String& text, ExceptionCode& ec)
 563 {
 564     RefPtr<Text> textNode = document()->createTextNode(text);
 565     insertAdjacent(where, textNode.get(), ec);
 566 }
 567
 568 void HTMLElement::addHTMLAlignment(MappedAttribute* attr)
 569 {
 570     addHTMLAlignmentToStyledElement(this, attr);
 571 }
 572
 573 void HTMLElement::addHTMLAlignmentToStyledElement(StyledElement* element, MappedAttribute* attr)
 574 {
 575     // vertical alignment with respect to the current baseline of the text
 576     // right or left means floating images
 577     int floatValue = CSSValueInvalid;
 578     int verticalAlignValue = CSSValueInvalid;
 579
 580     const AtomicString& alignment = attr->value();
 581     if (equalIgnoringCase(alignment, "absmiddle"))
 582         verticalAlignValue = CSSValueMiddle;
 583     else if (equalIgnoringCase(alignment, "absbottom"))
 584         verticalAlignValue = CSSValueBottom;
 585     else if (equalIgnoringCase(alignment, "left")) {
 586         floatValue = CSSValueLeft;
 587         verticalAlignValue = CSSValueTop;
 588     } else if (equalIgnoringCase(alignment, "right")) {
 589         floatValue = CSSValueRight;
 590         verticalAlignValue = CSSValueTop;
 591     } else if (equalIgnoringCase(alignment, "top"))
 592         verticalAlignValue = CSSValueTop;
 593     else if (equalIgnoringCase(alignment, "middle"))
 594         verticalAlignValue = CSSValueWebkitBaselineMiddle;
 595     else if (equalIgnoringCase(alignment, "center"))
 596         verticalAlignValue = CSSValueMiddle;
 597     else if (equalIgnoringCase(alignment, "bottom"))
 598         verticalAlignValue = CSSValueBaseline;
 599     else if (equalIgnoringCase(alignment, "texttop"))
 600         verticalAlignValue = CSSValueTextTop;
 601
 602     if (floatValue != CSSValueInvalid)
 603         element->addCSSProperty(attr, CSSPropertyFloat, floatValue);
 604
 605     if (verticalAlignValue != CSSValueInvalid)
 606         element->addCSSProperty(attr, CSSPropertyVerticalAlign, verticalAlignValue);
 607 }
 608
 609 bool HTMLElement::isFocusable() const
 610 {
 611     return Element::isFocusable() || (isContentEditable() && parent() && !parent()->isContentEditable());
 612 }
 613
 614 bool HTMLElement::isContentEditable() const
 615 {
 616     if (document()->frame() && document()->frame()->isContentEditable())
 617         return true;
 618
 619     // FIXME: this is a terrible thing to do here:
 620     // https://bugs.webkit.org/show_bug.cgi?id=21834
 621     document()->updateRendering();
 622
 623     if (!renderer()) {
 624         if (parentNode())
 625             return parentNode()->isContentEditable();
 626         else
 627             return false;
 628     }
 629
 630     return renderer()->style()->userModify() == READ_WRITE || renderer()->style()->userModify() == READ_WRITE_PLAINTEXT_ONLY;
 631 }
 632
 633 bool HTMLElement::isContentRichlyEditable() const
 634 {
 635     if (document()->frame() && document()->frame()->isContentEditable())
 636         return true;
 637
 638     document()->updateRendering();
 639
 640     if (!renderer()) {
 641         if (parentNode())
 642             return parentNode()->isContentEditable();
 643         else
 644             return false;
 645     }
 646
 647     return renderer()->style()->userModify() == READ_WRITE;
 648 }
 649
 650 String HTMLElement::contentEditable() const
 651 {
 652     document()->updateRendering();
 653
 654     if (!renderer())
 655         return "false";
 656
 657     switch (renderer()->style()->userModify()) {
 658         case READ_WRITE:
 659             return "true";
 660         case READ_ONLY:
 661             return "false";
 662         case READ_WRITE_PLAINTEXT_ONLY:
 663             return "plaintext-only";
 664         default:
 665             return "inherit";
 666     }
 667 }
 668
 669 void HTMLElement::setContentEditable(MappedAttribute* attr)
 670 {
 671     const AtomicString& enabled = attr->value();
 672     if (enabled.isEmpty() || equalIgnoringCase(enabled, "true")) {
 673         addCSSProperty(attr, CSSPropertyWebkitUserModify, CSSValueReadWrite);
 674         addCSSProperty(attr, CSSPropertyWordWrap, CSSValueBreakWord);
 675         addCSSProperty(attr, CSSPropertyWebkitNbspMode, CSSValueSpace);
 676         addCSSProperty(attr, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
 677     } else if (equalIgnoringCase(enabled, "false")) {
 678         addCSSProperty(attr, CSSPropertyWebkitUserModify, CSSValueReadOnly);
 679         attr->decl()->removeProperty(CSSPropertyWordWrap, false);
 680         attr->decl()->removeProperty(CSSPropertyWebkitNbspMode, false);
 681         attr->decl()->removeProperty(CSSPropertyWebkitLineBreak, false);
 682     } else if (equalIgnoringCase(enabled, "inherit")) {
 683         addCSSProperty(attr, CSSPropertyWebkitUserModify, CSSValueInherit);
 684         attr->decl()->removeProperty(CSSPropertyWordWrap, false);
 685         attr->decl()->removeProperty(CSSPropertyWebkitNbspMode, false);
 686         attr->decl()->removeProperty(CSSPropertyWebkitLineBreak, false);
 687     } else if (equalIgnoringCase(enabled, "plaintext-only")) {
 688         addCSSProperty(attr, CSSPropertyWebkitUserModify, CSSValueReadWritePlaintextOnly);
 689         addCSSProperty(attr, CSSPropertyWordWrap, CSSValueBreakWord);
 690         addCSSProperty(attr, CSSPropertyWebkitNbspMode, CSSValueSpace);
 691         addCSSProperty(attr, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
 692     }
 693 }
 694
 695 void HTMLElement::setContentEditable(const String &enabled)
 696 {
 697     if (enabled == "inherit") {
 698         ExceptionCode ec;
 699         removeAttribute(contenteditableAttr, ec);
 700     }
 701     else
 702         setAttribute(contenteditableAttr, enabled.isEmpty() ? "true" : enabled);
 703 }
 704
 705 void HTMLElement::click()
 706 {
 707     dispatchSimulatedClick(0, false, false);
 708 }
 709
 710 // accessKeyAction is used by the accessibility support code
 711 // to send events to elements that our JavaScript caller does
 712 // does not.  The elements JS is interested in have subclasses
 713 // that override this method to direct the click appropriately.
 714 // Here in the base class, then, we only send the click if
 715 // the caller wants it to go to any HTMLElement, and we say
 716 // to send the mouse events in addition to the click.
 717 void HTMLElement::accessKeyAction(bool sendToAnyElement)
 718 {
 719     if (sendToAnyElement)
 720         dispatchSimulatedClick(0, true);
 721 }
 722
 723 String HTMLElement::id() const
 724 {
 725     return getAttribute(idAttr);
 726 }
 727
 728 void HTMLElement::setId(const String& value)
 729 {
 730     setAttribute(idAttr, value);
 731 }
 732
 733 String HTMLElement::title() const
 734 {
 735     return getAttribute(titleAttr);
 736 }
 737
 738 void HTMLElement::setTitle(const String& value)
 739 {
 740     setAttribute(titleAttr, value);
 741 }
 742
 743 String HTMLElement::lang() const
 744 {
 745     return getAttribute(langAttr);
 746 }
 747
 748 void HTMLElement::setLang(const String& value)
 749 {
 750     setAttribute(langAttr, value);
 751 }
 752
 753 String HTMLElement::dir() const
 754 {
 755     return getAttribute(dirAttr);
 756 }
 757
 758 void HTMLElement::setDir(const String &value)
 759 {
 760     setAttribute(dirAttr, value);
 761 }
 762
 763 String HTMLElement::className() const
 764 {
 765     return getAttribute(classAttr);
 766 }
 767
 768 void HTMLElement::setClassName(const String &value)
 769 {
 770     setAttribute(classAttr, value);
 771 }
 772
 773 short HTMLElement::tabIndex() const
 774 {
 775     if (supportsFocus())
 776         return Element::tabIndex();
 777     return -1;
 778 }
 779
 780 void HTMLElement::setTabIndex(int value)
 781 {
 782     setAttribute(tabindexAttr, String::number(value));
 783 }
 784
 785 PassRefPtr<HTMLCollection> HTMLElement::children()
 786 {
 787     return HTMLCollection::create(this, HTMLCollection::NodeChildren);
 788 }
 789
 790 // DOM Section 1.1.1
 791 bool HTMLElement::childAllowed(Node *newChild)
 792 {
 793     if (!Element::childAllowed(newChild))
 794         return false;
 795
 796     // For XML documents, we are non-validating and do not check against a DTD, even for HTML elements.
 797     if (!document()->isHTMLDocument())
 798         return true;
 799
 800     // Future-proof for XML content inside HTML documents (we may allow this some day).
 801     if (newChild->isElementNode() && !newChild->isHTMLElement())
 802         return true;
 803
 804     // Elements with forbidden tag status can never have children
 805     if (endTagRequirement() == TagStatusForbidden)
 806         return false;
 807
 808     // Comment nodes are always allowed.
 809     if (newChild->isCommentNode())
 810         return true;
 811
 812     // Now call checkDTD.
 813     return checkDTD(newChild);
 814 }
 815
 816 // DTD Stuff
 817 // This unfortunate function is only needed when checking against the DTD.  Other languages (like SVG) won't need this.
 818 bool HTMLElement::isRecognizedTagName(const QualifiedName& tagName)
 819 {
 820     DEFINE_STATIC_LOCAL(HashSet<AtomicStringImpl*>, tagList, ());
 821     if (tagList.isEmpty()) {
 822         size_t tagCount = 0;
 823         WebCore::QualifiedName** tags = HTMLNames::getHTMLTags(&tagCount);
 824         for (size_t i = 0; i < tagCount; i++)
 825             tagList.add(tags[i]->localName().impl());
 826     }
 827     return tagList.contains(tagName.localName().impl());
 828 }
 829
 830 // The terms inline and block are used here loosely.  Don't make the mistake of assuming all inlines or all blocks
 831 // need to be in these two lists.
 832 HashSet<AtomicStringImpl*>* inlineTagList()
 833 {
 834     DEFINE_STATIC_LOCAL(HashSet<AtomicStringImpl*>, tagList, ());
 835     if (tagList.isEmpty()) {
 836         tagList.add(ttTag.localName().impl());
 837         tagList.add(iTag.localName().impl());
 838         tagList.add(bTag.localName().impl());
 839         tagList.add(uTag.localName().impl());
 840         tagList.add(sTag.localName().impl());
 841         tagList.add(strikeTag.localName().impl());
 842         tagList.add(bigTag.localName().impl());
 843         tagList.add(smallTag.localName().impl());
 844         tagList.add(emTag.localName().impl());
 845         tagList.add(strongTag.localName().impl());
 846         tagList.add(dfnTag.localName().impl());
 847         tagList.add(codeTag.localName().impl());
 848         tagList.add(sampTag.localName().impl());
 849         tagList.add(kbdTag.localName().impl());
 850         tagList.add(varTag.localName().impl());
 851         tagList.add(citeTag.localName().impl());
 852         tagList.add(abbrTag.localName().impl());
 853         tagList.add(acronymTag.localName().impl());
 854         tagList.add(aTag.localName().impl());
 855         tagList.add(canvasTag.localName().impl());
 856         tagList.add(imgTag.localName().impl());
 857         tagList.add(appletTag.localName().impl());
 858         tagList.add(objectTag.localName().impl());
 859         tagList.add(embedTag.localName().impl());
 860         tagList.add(fontTag.localName().impl());
 861         tagList.add(basefontTag.localName().impl());
 862         tagList.add(brTag.localName().impl());
 863         tagList.add(scriptTag.localName().impl());
 864         tagList.add(styleTag.localName().impl());
 865         tagList.add(linkTag.localName().impl());
 866         tagList.add(mapTag.localName().impl());
 867         tagList.add(qTag.localName().impl());
 868         tagList.add(subTag.localName().impl());
 869         tagList.add(supTag.localName().impl());
 870         tagList.add(spanTag.localName().impl());
 871         tagList.add(bdoTag.localName().impl());
 872         tagList.add(iframeTag.localName().impl());
 873         tagList.add(inputTag.localName().impl());
 874         tagList.add(keygenTag.localName().impl());
 875         tagList.add(selectTag.localName().impl());
 876         tagList.add(textareaTag.localName().impl());
 877         tagList.add(labelTag.localName().impl());
 878         tagList.add(buttonTag.localName().impl());
 879         tagList.add(insTag.localName().impl());
 880         tagList.add(delTag.localName().impl());
 881         tagList.add(nobrTag.localName().impl());
 882         tagList.add(wbrTag.localName().impl());
 883 #if ENABLE(VIDEO)
 884         tagList.add(audioTag.localName().impl());
 885         tagList.add(videoTag.localName().impl());
 886 #endif
 887     }
 888     return &tagList;
 889 }
 890
 891 HashSet<AtomicStringImpl*>* blockTagList()
 892 {
 893     DEFINE_STATIC_LOCAL(HashSet<AtomicStringImpl*>, tagList, ());
 894     if (tagList.isEmpty()) {
 895         tagList.add(addressTag.localName().impl());
 896         tagList.add(blockquoteTag.localName().impl());
 897         tagList.add(centerTag.localName().impl());
 898         tagList.add(ddTag.localName().impl());
 899         tagList.add(dirTag.localName().impl());
 900         tagList.add(divTag.localName().impl());
 901         tagList.add(dlTag.localName().impl());
 902         tagList.add(dtTag.localName().impl());
 903         tagList.add(fieldsetTag.localName().impl());
 904         tagList.add(formTag.localName().impl());
 905         tagList.add(h1Tag.localName().impl());
 906         tagList.add(h2Tag.localName().impl());
 907         tagList.add(h3Tag.localName().impl());
 908         tagList.add(h4Tag.localName().impl());
 909         tagList.add(h5Tag.localName().impl());
 910         tagList.add(h6Tag.localName().impl());
 911         tagList.add(hrTag.localName().impl());
 912         tagList.add(isindexTag.localName().impl());
 913         tagList.add(layerTag.localName().impl());
 914         tagList.add(liTag.localName().impl());
 915         tagList.add(listingTag.localName().impl());
 916         tagList.add(marqueeTag.localName().impl());
 917         tagList.add(menuTag.localName().impl());
 918         tagList.add(noembedTag.localName().impl());
 919         tagList.add(noframesTag.localName().impl());
 920         tagList.add(nolayerTag.localName().impl());
 921         tagList.add(noscriptTag.localName().impl());
 922         tagList.add(olTag.localName().impl());
 923         tagList.add(pTag.localName().impl());
 924         tagList.add(plaintextTag.localName().impl());
 925         tagList.add(preTag.localName().impl());
 926         tagList.add(tableTag.localName().impl());
 927         tagList.add(ulTag.localName().impl());
 928         tagList.add(xmpTag.localName().impl());
 929     }
 930     return &tagList;
 931 }
 932
 933 bool HTMLElement::inEitherTagList(const Node* newChild)
 934 {
 935     if (newChild->isTextNode())
 936         return true;
 937
 938     if (newChild->isHTMLElement()) {
 939         const HTMLElement* child = static_cast<const HTMLElement*>(newChild);
 940         if (inlineTagList()->contains(child->tagQName().localName().impl()))
 941             return true;
 942         if (blockTagList()->contains(child->tagQName().localName().impl()))
 943             return true;
 944         return !isRecognizedTagName(child->tagQName()); // Accept custom html tags
 945     }
 946
 947     return false;
 948 }
 949
 950 bool HTMLElement::inInlineTagList(const Node* newChild)
 951 {
 952     if (newChild->isTextNode())
 953         return true;
 954
 955     if (newChild->isHTMLElement()) {
 956         const HTMLElement* child = static_cast<const HTMLElement*>(newChild);
 957         if (inlineTagList()->contains(child->tagQName().localName().impl()))
 958             return true;
 959         return !isRecognizedTagName(child->tagQName()); // Accept custom html tags
 960     }
 961
 962     return false;
 963 }
 964
 965 bool HTMLElement::inBlockTagList(const Node* newChild)
 966 {
 967     if (newChild->isTextNode())
 968         return true;
 969
 970     if (newChild->isHTMLElement()) {
 971         const HTMLElement* child = static_cast<const HTMLElement*>(newChild);
 972         return (blockTagList()->contains(child->tagQName().localName().impl()));
 973     }
 974
 975     return false;
 976 }
 977
 978 bool HTMLElement::checkDTD(const Node* newChild)
 979 {
 980     if (hasLocalName(addressTag) && newChild->hasTagName(pTag))
 981         return true;
 982     return inEitherTagList(newChild);
 983 }
 984
 985 bool HTMLElement::rendererIsNeeded(RenderStyle *style)
 986 {
 987     if (hasLocalName(noscriptTag)) {
 988         Settings* settings = document()->settings();
 989         if (settings && settings->isJavaScriptEnabled())
 990             return false;
 991     }
 992     return (document()->documentElement() == this) || (style->display() != NONE);
 993 }
 994
 995 RenderObject* HTMLElement::createRenderer(RenderArena* arena, RenderStyle* style)
 996 {
 997     if (hasLocalName(wbrTag))
 998         return new (arena) RenderWordBreak(this);
 999     return RenderObject::createObject(this, style);
1000 }
1001
1002 HTMLFormElement* HTMLElement::findFormAncestor() const
1003 {
1004     for (Node* ancestor = parentNode(); ancestor; ancestor = ancestor->parentNode())
1005         if (ancestor->hasTagName(formTag))
1006             return static_cast<HTMLFormElement*>(ancestor);
1007     return 0;
1008 }
1009
1010 HTMLFormElement* HTMLElement::virtualForm() const
1011 {
1012     return findFormAncestor();
1013 }
1014
1015 } // namespace WebCore
1016
1017 #ifndef NDEBUG
1018 void dumpInnerHTML(WebCore::HTMLElement* element)
1019 {
1020     printf("%s\n", element->innerHTML().ascii().data());
1021 }
1022 #endif