diff options
Diffstat (limited to 'Source/WebCore/html/HTMLTextAreaElement.cpp')
| -rw-r--r-- | Source/WebCore/html/HTMLTextAreaElement.cpp | 473 |
1 files changed, 473 insertions, 0 deletions
diff --git a/Source/WebCore/html/HTMLTextAreaElement.cpp b/Source/WebCore/html/HTMLTextAreaElement.cpp new file mode 100644 index 000000000..b5ac63390 --- /dev/null +++ b/Source/WebCore/html/HTMLTextAreaElement.cpp @@ -0,0 +1,473 @@ +/* + * Copyright (C) 1999 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2001 Dirk Mueller (mueller@kde.org) + * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 Apple Inc. All rights reserved. + * (C) 2006 Alexey Proskuryakov (ap@nypop.com) + * Copyright (C) 2007 Samuel Weinig (sam@webkit.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include "config.h" +#include "HTMLTextAreaElement.h" + +#include "Attribute.h" +#include "BeforeTextInsertedEvent.h" +#include "CSSValueKeywords.h" +#include "Document.h" +#include "Event.h" +#include "EventNames.h" +#include "ExceptionCode.h" +#include "FormDataList.h" +#include "Frame.h" +#include "HTMLNames.h" +#include "RenderTextControlMultiLine.h" +#include "ShadowRoot.h" +#include "Text.h" +#include "TextControlInnerElements.h" +#include "TextIterator.h" +#include <wtf/StdLibExtras.h> + +namespace WebCore { + +using namespace HTMLNames; + +static const int defaultRows = 2; +static const int defaultCols = 20; + +// On submission, LF characters are converted into CRLF. +// This function returns number of characters considering this. +static unsigned computeLengthForSubmission(const String& text) +{ + unsigned count = numGraphemeClusters(text); + unsigned length = text.length(); + for (unsigned i = 0; i < length; i++) { + if (text[i] == '\n') + count++; + } + return count; +} + +HTMLTextAreaElement::HTMLTextAreaElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form) + : HTMLTextFormControlElement(tagName, document, form) + , m_rows(defaultRows) + , m_cols(defaultCols) + , m_wrap(SoftWrap) + , m_isDirty(false) + , m_wasModifiedByUser(false) +{ + ASSERT(hasTagName(textareaTag)); + setFormControlValueMatchesRenderer(true); +} + +PassRefPtr<HTMLTextAreaElement> HTMLTextAreaElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form) +{ + RefPtr<HTMLTextAreaElement> textArea = adoptRef(new HTMLTextAreaElement(tagName, document, form)); + textArea->createShadowSubtree(); + return textArea.release(); +} + +void HTMLTextAreaElement::createShadowSubtree() +{ + ExceptionCode ec = 0; + ensureShadowRoot()->appendChild(TextControlInnerTextElement::create(document()), ec); +} + +const AtomicString& HTMLTextAreaElement::formControlType() const +{ + DEFINE_STATIC_LOCAL(const AtomicString, textarea, ("textarea")); + return textarea; +} + +bool HTMLTextAreaElement::saveFormControlState(String& result) const +{ + String currentValue = value(); + if (currentValue == defaultValue()) + return false; + result = currentValue; + return true; +} + +void HTMLTextAreaElement::restoreFormControlState(const String& state) +{ + setValue(state); +} + +void HTMLTextAreaElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta) +{ + setLastChangeWasNotUserEdit(); + if (!m_isDirty) + setNonDirtyValue(defaultValue()); + setInnerTextValue(value()); + HTMLElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta); +} + +void HTMLTextAreaElement::parseMappedAttribute(Attribute* attr) +{ + if (attr->name() == rowsAttr) { + int rows = attr->value().toInt(); + if (rows <= 0) + rows = defaultRows; + if (m_rows != rows) { + m_rows = rows; + if (renderer()) + renderer()->setNeedsLayoutAndPrefWidthsRecalc(); + } + } else if (attr->name() == colsAttr) { + int cols = attr->value().toInt(); + if (cols <= 0) + cols = defaultCols; + if (m_cols != cols) { + m_cols = cols; + if (renderer()) + renderer()->setNeedsLayoutAndPrefWidthsRecalc(); + } + } else if (attr->name() == wrapAttr) { + // The virtual/physical values were a Netscape extension of HTML 3.0, now deprecated. + // The soft/hard /off values are a recommendation for HTML 4 extension by IE and NS 4. + WrapMethod wrap; + if (equalIgnoringCase(attr->value(), "physical") || equalIgnoringCase(attr->value(), "hard") || equalIgnoringCase(attr->value(), "on")) + wrap = HardWrap; + else if (equalIgnoringCase(attr->value(), "off")) + wrap = NoWrap; + else + wrap = SoftWrap; + if (wrap != m_wrap) { + m_wrap = wrap; + + if (shouldWrapText()) { + addCSSProperty(attr, CSSPropertyWhiteSpace, CSSValuePreWrap); + addCSSProperty(attr, CSSPropertyWordWrap, CSSValueBreakWord); + } else { + addCSSProperty(attr, CSSPropertyWhiteSpace, CSSValuePre); + addCSSProperty(attr, CSSPropertyWordWrap, CSSValueNormal); + } + + if (renderer()) + renderer()->setNeedsLayoutAndPrefWidthsRecalc(); + } + } else if (attr->name() == accesskeyAttr) { + // ignore for the moment + } else if (attr->name() == alignAttr) { + // Don't map 'align' attribute. This matches what Firefox, Opera and IE do. + // See http://bugs.webkit.org/show_bug.cgi?id=7075 + } else if (attr->name() == maxlengthAttr) + setNeedsValidityCheck(); + else + HTMLTextFormControlElement::parseMappedAttribute(attr); +} + +RenderObject* HTMLTextAreaElement::createRenderer(RenderArena* arena, RenderStyle*) +{ + return new (arena) RenderTextControlMultiLine(this); +} + +bool HTMLTextAreaElement::appendFormData(FormDataList& encoding, bool) +{ + if (name().isEmpty()) + return false; + + document()->updateLayout(); + + const String& text = (m_wrap == HardWrap) ? valueWithHardLineBreaks() : value(); + encoding.appendData(name(), text); + + const AtomicString& dirnameAttrValue = fastGetAttribute(dirnameAttr); + if (!dirnameAttrValue.isNull()) + encoding.appendData(dirnameAttrValue, directionForFormData()); + return true; +} + +void HTMLTextAreaElement::reset() +{ + setNonDirtyValue(defaultValue()); +} + +bool HTMLTextAreaElement::isKeyboardFocusable(KeyboardEvent*) const +{ + // If a given text area can be focused at all, then it will always be keyboard focusable. + return isFocusable(); +} + +bool HTMLTextAreaElement::isMouseFocusable() const +{ + return isFocusable(); +} + +void HTMLTextAreaElement::updateFocusAppearance(bool restorePreviousSelection) +{ + if (!restorePreviousSelection || !hasCachedSelection()) { + // If this is the first focus, set a caret at the beginning of the text. + // This matches some browsers' behavior; see bug 11746 Comment #15. + // http://bugs.webkit.org/show_bug.cgi?id=11746#c15 + setSelectionRange(0, 0); + } else + restoreCachedSelection(); + + if (document()->frame()) + document()->frame()->selection()->revealSelection(); +} + +void HTMLTextAreaElement::defaultEventHandler(Event* event) +{ + if (renderer() && (event->isMouseEvent() || event->isDragEvent() || event->hasInterface(eventNames().interfaceForWheelEvent) || event->type() == eventNames().blurEvent)) + forwardEvent(event); + else if (renderer() && event->isBeforeTextInsertedEvent()) + handleBeforeTextInsertedEvent(static_cast<BeforeTextInsertedEvent*>(event)); + + HTMLTextFormControlElement::defaultEventHandler(event); +} + +void HTMLTextAreaElement::subtreeHasChanged() +{ + setChangedSinceLastFormControlChangeEvent(true); + setFormControlValueMatchesRenderer(false); + setNeedsValidityCheck(); + + if (!focused()) + return; + + if (Frame* frame = document()->frame()) + frame->editor()->textDidChangeInTextArea(this); + // When typing in a textarea, childrenChanged is not called, so we need to force the directionality check. + calculateAndAdjustDirectionality(); +} + +void HTMLTextAreaElement::handleBeforeTextInsertedEvent(BeforeTextInsertedEvent* event) const +{ + ASSERT(event); + ASSERT(renderer()); + int signedMaxLength = maxLength(); + if (signedMaxLength < 0) + return; + unsigned unsignedMaxLength = static_cast<unsigned>(signedMaxLength); + + unsigned currentLength = computeLengthForSubmission(innerTextValue()); + // selectionLength represents the selection length of this text field to be + // removed by this insertion. + // If the text field has no focus, we don't need to take account of the + // selection length. The selection is the source of text drag-and-drop in + // that case, and nothing in the text field will be removed. + unsigned selectionLength = focused() ? computeLengthForSubmission(plainText(document()->frame()->selection()->selection().toNormalizedRange().get())) : 0; + ASSERT(currentLength >= selectionLength); + unsigned baseLength = currentLength - selectionLength; + unsigned appendableLength = unsignedMaxLength > baseLength ? unsignedMaxLength - baseLength : 0; + event->setText(sanitizeUserInputValue(event->text(), appendableLength)); +} + +String HTMLTextAreaElement::sanitizeUserInputValue(const String& proposedValue, unsigned maxLength) +{ + return proposedValue.left(numCharactersInGraphemeClusters(proposedValue, maxLength)); +} + +HTMLElement* HTMLTextAreaElement::innerTextElement() const +{ + Node* node = shadowRoot()->firstChild(); + ASSERT(!node || node->hasTagName(divTag)); + return toHTMLElement(node); +} + +void HTMLTextAreaElement::rendererWillBeDestroyed() +{ + updateValue(); +} + +void HTMLTextAreaElement::updateValue() const +{ + if (formControlValueMatchesRenderer()) + return; + + ASSERT(renderer()); + m_value = innerTextValue(); + const_cast<HTMLTextAreaElement*>(this)->setFormControlValueMatchesRenderer(true); + const_cast<HTMLTextAreaElement*>(this)->notifyFormStateChanged(); + m_isDirty = true; + m_wasModifiedByUser = true; + const_cast<HTMLTextAreaElement*>(this)->updatePlaceholderVisibility(false); +} + +String HTMLTextAreaElement::value() const +{ + updateValue(); + return m_value; +} + +void HTMLTextAreaElement::setValue(const String& value) +{ + setValueCommon(value); + m_isDirty = true; + setNeedsValidityCheck(); +} + +void HTMLTextAreaElement::setNonDirtyValue(const String& value) +{ + setValueCommon(value); + m_isDirty = false; + setNeedsValidityCheck(); +} + +void HTMLTextAreaElement::setValueCommon(const String& newValue) +{ + m_wasModifiedByUser = false; + // Code elsewhere normalizes line endings added by the user via the keyboard or pasting. + // We normalize line endings coming from JavaScript here. + String normalizedValue = newValue.isNull() ? "" : newValue; + normalizedValue.replace("\r\n", "\n"); + normalizedValue.replace('\r', '\n'); + + // Return early because we don't want to move the caret or trigger other side effects + // when the value isn't changing. This matches Firefox behavior, at least. + if (normalizedValue == value()) + return; + + m_value = normalizedValue; + setInnerTextValue(m_value); + setLastChangeWasNotUserEdit(); + updatePlaceholderVisibility(false); + setNeedsStyleRecalc(); + setFormControlValueMatchesRenderer(true); + + // Set the caret to the end of the text value. + if (document()->focusedNode() == this) { + unsigned endOfString = m_value.length(); + setSelectionRange(endOfString, endOfString); + } + + notifyFormStateChanged(); + setTextAsOfLastFormControlChangeEvent(normalizedValue); +} + +String HTMLTextAreaElement::defaultValue() const +{ + String value = ""; + + // Since there may be comments, ignore nodes other than text nodes. + for (Node* n = firstChild(); n; n = n->nextSibling()) { + if (n->isTextNode()) + value += static_cast<Text*>(n)->data(); + } + + return value; +} + +void HTMLTextAreaElement::setDefaultValue(const String& defaultValue) +{ + // To preserve comments, remove only the text nodes, then add a single text node. + + Vector<RefPtr<Node> > textNodes; + for (Node* n = firstChild(); n; n = n->nextSibling()) { + if (n->isTextNode()) + textNodes.append(n); + } + ExceptionCode ec; + size_t size = textNodes.size(); + for (size_t i = 0; i < size; ++i) + removeChild(textNodes[i].get(), ec); + + // Normalize line endings. + String value = defaultValue; + value.replace("\r\n", "\n"); + value.replace('\r', '\n'); + + insertBefore(document()->createTextNode(value), firstChild(), ec); + + if (!m_isDirty) + setNonDirtyValue(value); +} + +int HTMLTextAreaElement::maxLength() const +{ + bool ok; + int value = getAttribute(maxlengthAttr).string().toInt(&ok); + return ok && value >= 0 ? value : -1; +} + +void HTMLTextAreaElement::setMaxLength(int newValue, ExceptionCode& ec) +{ + if (newValue < 0) + ec = INDEX_SIZE_ERR; + else + setAttribute(maxlengthAttr, String::number(newValue)); +} + +bool HTMLTextAreaElement::tooLong(const String& value, NeedsToCheckDirtyFlag check) const +{ + // Return false for the default value or value set by script even if it is + // longer than maxLength. + if (check == CheckDirtyFlag && !m_wasModifiedByUser) + return false; + + int max = maxLength(); + if (max < 0) + return false; + return computeLengthForSubmission(value) > static_cast<unsigned>(max); +} + +bool HTMLTextAreaElement::isValidValue(const String& candidate) const +{ + return !valueMissing(candidate) && !tooLong(candidate, IgnoreDirtyFlag); +} + +void HTMLTextAreaElement::accessKeyAction(bool) +{ + focus(); +} + +void HTMLTextAreaElement::setCols(int cols) +{ + setAttribute(colsAttr, String::number(cols)); +} + +void HTMLTextAreaElement::setRows(int rows) +{ + setAttribute(rowsAttr, String::number(rows)); +} + +bool HTMLTextAreaElement::shouldUseInputMethod() +{ + return true; +} + +HTMLElement* HTMLTextAreaElement::placeholderElement() const +{ + return m_placeholder.get(); +} + +void HTMLTextAreaElement::updatePlaceholderText() +{ + ExceptionCode ec = 0; + String placeholderText = strippedPlaceholder(); + if (placeholderText.isEmpty()) { + if (m_placeholder) { + shadowRoot()->removeChild(m_placeholder.get(), ec); + ASSERT(!ec); + m_placeholder.clear(); + } + return; + } + if (!m_placeholder) { + m_placeholder = HTMLDivElement::create(document()); + m_placeholder->setShadowPseudoId("-webkit-input-placeholder"); + shadowRoot()->insertBefore(m_placeholder, shadowRoot()->firstChild()->nextSibling(), ec); + ASSERT(!ec); + } + m_placeholder->setInnerText(placeholderText, ec); + ASSERT(!ec); +} + +} |