WebCore/html/HTMLTextAreaElement.cpp

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
   5  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   6  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
   7  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public License
  20  * along with this library; see the file COPYING.LIB.  If not, write to
  21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  *
  24  */
  25
  26 #include "config.h"
  27 #include "HTMLTextAreaElement.h"
  28
  29 #include "ChromeClient.h"
  30 #include "Document.h"
  31 #include "Event.h"
  32 #include "EventNames.h"
  33 #include "FocusController.h"
  34 #include "FormDataList.h"
  35 #include "Frame.h"
  36 #include "HTMLNames.h"
  37 #include "MappedAttribute.h"
  38 #include "Page.h"
  39 #include "RenderStyle.h"
  40 #include "RenderTextControlMultiLine.h"
  41 #include "ScriptEventListener.h"
  42 #include "Text.h"
  43 #include "VisibleSelection.h"
  44 #include <wtf/StdLibExtras.h>
  45
  46 namespace WebCore {
  47
  48 using namespace HTMLNames;
  49
  50 static const int defaultRows = 2;
  51 static const int defaultCols = 20;
  52
  53 static inline void notifyFormStateChanged(const HTMLTextAreaElement* element)
  54 {
  55     Frame* frame = element->document()->frame();
  56     if (!frame)
  57         return;
  58     frame->page()->chrome()->client()->formStateDidChange(element);
  59 }
  60
  61 HTMLTextAreaElement::HTMLTextAreaElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
  62     : HTMLFormControlElementWithState(tagName, document, form)
  63     , m_rows(defaultRows)
  64     , m_cols(defaultCols)
  65     , m_wrap(SoftWrap)
  66     , m_cachedSelectionStart(-1)
  67     , m_cachedSelectionEnd(-1)
  68 {
  69     ASSERT(hasTagName(textareaTag));
  70     setFormControlValueMatchesRenderer(true);
  71     notifyFormStateChanged(this);
  72 }
  73
  74 const AtomicString& HTMLTextAreaElement::formControlType() const
  75 {
  76     DEFINE_STATIC_LOCAL(const AtomicString, textarea, ("textarea"));
  77     return textarea;
  78 }
  79
  80 bool HTMLTextAreaElement::saveFormControlState(String& result) const
  81 {
  82     result = value();
  83     return true;
  84 }
  85
  86 void HTMLTextAreaElement::restoreFormControlState(const String& state)
  87 {
  88     setDefaultValue(state);
  89 }
  90
  91 int HTMLTextAreaElement::selectionStart()
  92 {
  93     if (!renderer())
  94         return 0;
  95     if (document()->focusedNode() != this && m_cachedSelectionStart >= 0)
  96         return m_cachedSelectionStart;
  97     return toRenderTextControl(renderer())->selectionStart();
  98 }
  99
 100 int HTMLTextAreaElement::selectionEnd()
 101 {
 102     if (!renderer())
 103         return 0;
 104     if (document()->focusedNode() != this && m_cachedSelectionEnd >= 0)
 105         return m_cachedSelectionEnd;
 106     return toRenderTextControl(renderer())->selectionEnd();
 107 }
 108
 109 void HTMLTextAreaElement::setSelectionStart(int start)
 110 {
 111     if (!renderer())
 112         return;
 113     toRenderTextControl(renderer())->setSelectionStart(start);
 114 }
 115
 116 void HTMLTextAreaElement::setSelectionEnd(int end)
 117 {
 118     if (!renderer())
 119         return;
 120     toRenderTextControl(renderer())->setSelectionEnd(end);
 121 }
 122
 123 void HTMLTextAreaElement::select()
 124 {
 125     if (!renderer())
 126         return;
 127     toRenderTextControl(renderer())->select();
 128 }
 129
 130 void HTMLTextAreaElement::setSelectionRange(int start, int end)
 131 {
 132     if (!renderer())
 133         return;
 134     toRenderTextControl(renderer())->setSelectionRange(start, end);
 135 }
 136
 137 void HTMLTextAreaElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
 138 {
 139     setValue(defaultValue());
 140     HTMLElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
 141 }
 142
 143 void HTMLTextAreaElement::parseMappedAttribute(MappedAttribute* attr)
 144 {
 145     if (attr->name() == rowsAttr) {
 146         int rows = attr->value().toInt();
 147         if (rows <= 0)
 148             rows = defaultRows;
 149         if (m_rows != rows) {
 150             m_rows = rows;
 151             if (renderer())
 152                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
 153         }
 154     } else if (attr->name() == colsAttr) {
 155         int cols = attr->value().toInt();
 156         if (cols <= 0)
 157             cols = defaultCols;
 158         if (m_cols != cols) {
 159             m_cols = cols;
 160             if (renderer())
 161                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
 162         }
 163     } else if (attr->name() == wrapAttr) {
 164         // The virtual/physical values were a Netscape extension of HTML 3.0, now deprecated.
 165         // The soft/hard /off values are a recommendation for HTML 4 extension by IE and NS 4.
 166         WrapMethod wrap;
 167         if (equalIgnoringCase(attr->value(), "physical") || equalIgnoringCase(attr->value(), "hard") || equalIgnoringCase(attr->value(), "on"))
 168             wrap = HardWrap;
 169         else if (equalIgnoringCase(attr->value(), "off"))
 170             wrap = NoWrap;
 171         else
 172             wrap = SoftWrap;
 173         if (wrap != m_wrap) {
 174             m_wrap = wrap;
 175             if (renderer())
 176                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
 177         }
 178     } else if (attr->name() == accesskeyAttr) {
 179         // ignore for the moment
 180     } else if (attr->name() == alignAttr) {
 181         // Don't map 'align' attribute.  This matches what Firefox, Opera and IE do.
 182         // See http://bugs.webkit.org/show_bug.cgi?id=7075
 183     } else if (attr->name() == onfocusAttr)
 184         setAttributeEventListener(eventNames().focusEvent, createAttributeEventListener(this, attr));
 185     else if (attr->name() == onblurAttr)
 186         setAttributeEventListener(eventNames().blurEvent, createAttributeEventListener(this, attr));
 187     else if (attr->name() == onselectAttr)
 188         setAttributeEventListener(eventNames().selectEvent, createAttributeEventListener(this, attr));
 189     else if (attr->name() == onchangeAttr)
 190         setAttributeEventListener(eventNames().changeEvent, createAttributeEventListener(this, attr));
 191     else
 192         HTMLFormControlElementWithState::parseMappedAttribute(attr);
 193 }
 194
 195 RenderObject* HTMLTextAreaElement::createRenderer(RenderArena* arena, RenderStyle*)
 196 {
 197     return new (arena) RenderTextControlMultiLine(this);
 198 }
 199
 200 bool HTMLTextAreaElement::appendFormData(FormDataList& encoding, bool)
 201 {
 202     if (name().isEmpty())
 203         return false;
 204
 205     // FIXME: It's not acceptable to ignore the HardWrap setting when there is no renderer.
 206     // While we have no evidence this has ever been a practical problem, it would be best to fix it some day.
 207     RenderTextControl* control = toRenderTextControl(renderer());
 208     const String& text = (m_wrap == HardWrap && control) ? control->textWithHardLineBreaks() : value();
 209     encoding.appendData(name(), text);
 210     return true;
 211 }
 212
 213 void HTMLTextAreaElement::reset()
 214 {
 215     setValue(defaultValue());
 216 }
 217
 218 bool HTMLTextAreaElement::isKeyboardFocusable(KeyboardEvent*) const
 219 {
 220     // If a given text area can be focused at all, then it will always be keyboard focusable.
 221     return isFocusable();
 222 }
 223
 224 bool HTMLTextAreaElement::isMouseFocusable() const
 225 {
 226     return isFocusable();
 227 }
 228
 229 void HTMLTextAreaElement::updateFocusAppearance(bool restorePreviousSelection)
 230 {
 231     ASSERT(renderer());
 232
 233     if (!restorePreviousSelection || m_cachedSelectionStart < 0) {
 234 #if ENABLE(ON_FIRST_TEXTAREA_FOCUS_SELECT_ALL)
 235         // Devices with trackballs or d-pads may focus on a textarea in route
 236         // to another focusable node. By selecting all text, the next movement
 237         // can more readily be interpreted as moving to the next node.
 238         select();
 239 #else
 240         // If this is the first focus, set a caret at the beginning of the text.
 241         // This matches some browsers' behavior; see bug 11746 Comment #15.
 242         // http://bugs.webkit.org/show_bug.cgi?id=11746#c15
 243         setSelectionRange(0, 0);
 244 #endif
 245     } else {
 246         // Restore the cached selection.  This matches other browsers' behavior.
 247         setSelectionRange(m_cachedSelectionStart, m_cachedSelectionEnd);
 248     }
 249
 250     if (document()->frame())
 251         document()->frame()->revealSelection();
 252 }
 253
 254 void HTMLTextAreaElement::defaultEventHandler(Event* event)
 255 {
 256     if (renderer() && (event->isMouseEvent() || event->isDragEvent() || event->isWheelEvent() || event->type() == eventNames().blurEvent))
 257         static_cast<RenderTextControlMultiLine*>(renderer())->forwardEvent(event);
 258
 259     HTMLFormControlElementWithState::defaultEventHandler(event);
 260 }
 261
 262 void HTMLTextAreaElement::rendererWillBeDestroyed()
 263 {
 264     updateValue();
 265 }
 266
 267 void HTMLTextAreaElement::updateValue() const
 268 {
 269     if (formControlValueMatchesRenderer())
 270         return;
 271
 272     ASSERT(renderer());
 273     m_value = toRenderTextControl(renderer())->text();
 274     const_cast<HTMLTextAreaElement*>(this)->setFormControlValueMatchesRenderer(true);
 275     notifyFormStateChanged(this);
 276 }
 277
 278 String HTMLTextAreaElement::value() const
 279 {
 280     updateValue();
 281     return m_value;
 282 }
 283
 284 void HTMLTextAreaElement::setValue(const String& value)
 285 {
 286     // Code elsewhere normalizes line endings added by the user via the keyboard or pasting.
 287     // We normalize line endings coming from JavaScript here.
 288     String normalizedValue = value.isNull() ? "" : value;
 289     normalizedValue.replace("\r\n", "\n");
 290     normalizedValue.replace('\r', '\n');
 291
 292     // Return early because we don't want to move the caret or trigger other side effects
 293     // when the value isn't changing. This matches Firefox behavior, at least.
 294     if (normalizedValue == this->value())
 295         return;
 296
 297     m_value = normalizedValue;
 298     setFormControlValueMatchesRenderer(true);
 299     if (inDocument())
 300         document()->updateStyleIfNeeded();
 301     if (renderer())
 302         renderer()->updateFromElement();
 303
 304     // Set the caret to the end of the text value.
 305     if (document()->focusedNode() == this) {
 306         unsigned endOfString = m_value.length();
 307         setSelectionRange(endOfString, endOfString);
 308     }
 309
 310     setNeedsStyleRecalc();
 311     notifyFormStateChanged(this);
 312 }
 313
 314 String HTMLTextAreaElement::defaultValue() const
 315 {
 316     String value = "";
 317
 318     // Since there may be comments, ignore nodes other than text nodes.
 319     for (Node* n = firstChild(); n; n = n->nextSibling()) {
 320         if (n->isTextNode())
 321             value += static_cast<Text*>(n)->data();
 322     }
 323
 324     UChar firstCharacter = value[0];
 325     if (firstCharacter == '\r' && value[1] == '\n')
 326         value.remove(0, 2);
 327     else if (firstCharacter == '\r' || firstCharacter == '\n')
 328         value.remove(0, 1);
 329
 330     return value;
 331 }
 332
 333 void HTMLTextAreaElement::setDefaultValue(const String& defaultValue)
 334 {
 335     // To preserve comments, remove only the text nodes, then add a single text node.
 336
 337     Vector<RefPtr<Node> > textNodes;
 338     for (Node* n = firstChild(); n; n = n->nextSibling()) {
 339         if (n->isTextNode())
 340             textNodes.append(n);
 341     }
 342     ExceptionCode ec;
 343     size_t size = textNodes.size();
 344     for (size_t i = 0; i < size; ++i)
 345         removeChild(textNodes[i].get(), ec);
 346
 347     // Normalize line endings.
 348     // Add an extra line break if the string starts with one, since
 349     // the code to read default values from the DOM strips the leading one.
 350     String value = defaultValue;
 351     value.replace("\r\n", "\n");
 352     value.replace('\r', '\n');
 353     if (value[0] == '\n')
 354         value = "\n" + value;
 355
 356     insertBefore(document()->createTextNode(value), firstChild(), ec);
 357
 358     setValue(value);
 359 }
 360
 361 void HTMLTextAreaElement::accessKeyAction(bool)
 362 {
 363     focus();
 364 }
 365
 366 const AtomicString& HTMLTextAreaElement::accessKey() const
 367 {
 368     return getAttribute(accesskeyAttr);
 369 }
 370
 371 void HTMLTextAreaElement::setAccessKey(const String& value)
 372 {
 373     setAttribute(accesskeyAttr, value);
 374 }
 375
 376 void HTMLTextAreaElement::setCols(int cols)
 377 {
 378     setAttribute(colsAttr, String::number(cols));
 379 }
 380
 381 void HTMLTextAreaElement::setRows(int rows)
 382 {
 383     setAttribute(rowsAttr, String::number(rows));
 384 }
 385
 386 VisibleSelection HTMLTextAreaElement::selection() const
 387 {
 388     if (!renderer() || m_cachedSelectionStart < 0 || m_cachedSelectionEnd < 0)
 389         return VisibleSelection();
 390     return toRenderTextControl(renderer())->selection(m_cachedSelectionStart, m_cachedSelectionEnd);
 391 }
 392
 393 bool HTMLTextAreaElement::shouldUseInputMethod() const
 394 {
 395     return true;
 396 }
 397
 398 } // namespace