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