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