--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/html/HTMLTextAreaElement.cpp Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,417 @@
+/*
+ * 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 "Chrome.h"
+#include "ChromeClient.h"
+#include "Document.h"
+#include "Event.h"
+#include "EventNames.h"
+#include "ExceptionCode.h"
+#include "FocusController.h"
+#include "FormDataList.h"
+#include "Frame.h"
+#include "HTMLNames.h"
+#include "InputElement.h"
+#include "Page.h"
+#include "RenderStyle.h"
+#include "RenderTextControlMultiLine.h"
+#include "ScriptEventListener.h"
+#include "Text.h"
+#include "TextIterator.h"
+#include "VisibleSelection.h"
+#include <wtf/StdLibExtras.h>
+
+namespace WebCore {
+
+using namespace HTMLNames;
+
+static const int defaultRows = 2;
+static const int defaultCols = 20;
+
+static inline void notifyFormStateChanged(const HTMLTextAreaElement* element)
+{
+ Frame* frame = element->document()->frame();
+ if (!frame)
+ return;
+ frame->page()->chrome()->client()->formStateDidChange(element);
+}
+
+HTMLTextAreaElement::HTMLTextAreaElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
+ : HTMLTextFormControlElement(tagName, document, form)
+ , m_rows(defaultRows)
+ , m_cols(defaultCols)
+ , m_wrap(SoftWrap)
+ , m_cachedSelectionStart(-1)
+ , m_cachedSelectionEnd(-1)
+ , m_isDirty(false)
+{
+ ASSERT(hasTagName(textareaTag));
+ setFormControlValueMatchesRenderer(true);
+}
+
+PassRefPtr<HTMLTextAreaElement> HTMLTextAreaElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
+{
+ return adoptRef(new HTMLTextAreaElement(tagName, document, form));
+}
+
+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)
+{
+ setNonDirtyValue(defaultValue());
+ 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, placeholderShouldBeVisible());
+}
+
+bool HTMLTextAreaElement::appendFormData(FormDataList& encoding, bool)
+{
+ if (name().isEmpty())
+ return false;
+
+ document()->updateLayout();
+
+ // FIXME: It's not acceptable to ignore the HardWrap setting when there is no renderer.
+ // While we have no evidence this has ever been a practical problem, it would be best to fix it some day.
+ RenderTextControl* control = toRenderTextControl(renderer());
+ const String& text = (m_wrap == HardWrap && control) ? control->textWithHardLineBreaks() : value();
+ encoding.appendData(name(), text);
+ 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)
+{
+ ASSERT(renderer());
+ ASSERT(!document()->childNeedsAndNotInStyleRecalc());
+
+ if (!restorePreviousSelection || m_cachedSelectionStart < 0) {
+#if ENABLE(ON_FIRST_TEXTAREA_FOCUS_SELECT_ALL)
+ // Devices with trackballs or d-pads may focus on a textarea in route
+ // to another focusable node. By selecting all text, the next movement
+ // can more readily be interpreted as moving to the next node.
+ select();
+#else
+ // 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);
+#endif
+ } else {
+ // Restore the cached selection. This matches other browsers' behavior.
+ setSelectionRange(m_cachedSelectionStart, m_cachedSelectionEnd);
+ }
+
+ if (document()->frame())
+ document()->frame()->revealSelection();
+}
+
+void HTMLTextAreaElement::defaultEventHandler(Event* event)
+{
+ if (renderer() && (event->isMouseEvent() || event->isDragEvent() || event->isWheelEvent() || event->type() == eventNames().blurEvent))
+ toRenderTextControlMultiLine(renderer())->forwardEvent(event);
+ else if (renderer() && event->isBeforeTextInsertedEvent())
+ handleBeforeTextInsertedEvent(static_cast<BeforeTextInsertedEvent*>(event));
+
+ HTMLFormControlElementWithState::defaultEventHandler(event);
+}
+
+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 = numGraphemeClusters(toRenderTextControl(renderer())->text());
+ // 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() ? numGraphemeClusters(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));
+}
+
+void HTMLTextAreaElement::rendererWillBeDestroyed()
+{
+ updateValue();
+}
+
+void HTMLTextAreaElement::updateValue() const
+{
+ if (formControlValueMatchesRenderer())
+ return;
+
+ ASSERT(renderer());
+ m_value = toRenderTextControl(renderer())->text();
+ const_cast<HTMLTextAreaElement*>(this)->setFormControlValueMatchesRenderer(true);
+ notifyFormStateChanged(this);
+ m_isDirty = true;
+}
+
+String HTMLTextAreaElement::value() const
+{
+ updateValue();
+ return m_value;
+}
+
+void HTMLTextAreaElement::setValue(const String& value)
+{
+ setNonDirtyValue(value);
+ m_isDirty = true;
+}
+
+void HTMLTextAreaElement::setNonDirtyValue(const String& value)
+{
+ // Code elsewhere normalizes line endings added by the user via the keyboard or pasting.
+ // We normalize line endings coming from JavaScript here.
+ String normalizedValue = value.isNull() ? "" : value;
+ 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 == this->value())
+ return;
+
+ m_value = normalizedValue;
+ updatePlaceholderVisibility(false);
+ setNeedsStyleRecalc();
+ setNeedsValidityCheck();
+ m_isDirty = false;
+ 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(this);
+}
+
+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();
+ }
+
+ UChar firstCharacter = value[0];
+ if (firstCharacter == '\r' && value[1] == '\n')
+ value.remove(0, 2);
+ else if (firstCharacter == '\r' || firstCharacter == '\n')
+ value.remove(0, 1);
+
+ 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.
+ // Add an extra line break if the string starts with one, since
+ // the code to read default values from the DOM strips the leading one.
+ String value = defaultValue;
+ value.replace("\r\n", "\n");
+ value.replace('\r', '\n');
+ if (value[0] == '\n')
+ value = "\n" + value;
+
+ insertBefore(document()->createTextNode(value), firstChild(), ec);
+
+ 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
+{
+ // Return false for the default value even if it is longer than maxLength.
+ if (!m_isDirty)
+ return false;
+
+ int max = maxLength();
+ if (max < 0)
+ return false;
+ return numGraphemeClusters(value()) > static_cast<unsigned>(max);
+}
+
+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() const
+{
+ return true;
+}
+
+} // namespace