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