WebCore:
[WebKit-https.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 "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