Add WTF::move()
[WebKit-https.git] / Source / 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, 2010 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 "Attribute.h"
30 #include "BeforeTextInsertedEvent.h"
31 #include "CSSValueKeywords.h"
32 #include "Document.h"
33 #include "Editor.h"
34 #include "Event.h"
35 #include "EventHandler.h"
36 #include "EventNames.h"
37 #include "ExceptionCode.h"
38 #include "ExceptionCodePlaceholder.h"
39 #include "FormController.h"
40 #include "FormDataList.h"
41 #include "Frame.h"
42 #include "FrameSelection.h"
43 #include "HTMLNames.h"
44 #include "LocalizedStrings.h"
45 #include "RenderTextControlMultiLine.h"
46 #include "ShadowRoot.h"
47 #include "Text.h"
48 #include "TextBreakIterator.h"
49 #include "TextControlInnerElements.h"
50 #include "TextIterator.h"
51 #include "TextNodeTraversal.h"
52 #include <wtf/Ref.h>
53 #include <wtf/StdLibExtras.h>
54 #include <wtf/text/StringBuilder.h>
55
56 namespace WebCore {
57
58 using namespace HTMLNames;
59
60 static const int defaultRows = 2;
61 static const int defaultCols = 20;
62
63 // On submission, LF characters are converted into CRLF.
64 // This function returns number of characters considering this.
65 static inline unsigned computeLengthForSubmission(const String& text, unsigned numberOfLineBreaks)
66 {
67     return numGraphemeClusters(text) + numberOfLineBreaks;
68 }
69
70 static unsigned numberOfLineBreaks(const String& text)
71 {
72     unsigned length = text.length();
73     unsigned count = 0;
74     for (unsigned i = 0; i < length; i++) {
75         if (text[i] == '\n')
76             count++;
77     }
78     return count;
79 }
80
81 static inline unsigned computeLengthForSubmission(const String& text)
82 {
83     return numGraphemeClusters(text) + numberOfLineBreaks(text);
84 }
85
86 static inline unsigned upperBoundForLengthForSubmission(const String& text, unsigned numberOfLineBreaks)
87 {
88     return text.length() + numberOfLineBreaks;
89 }
90
91 HTMLTextAreaElement::HTMLTextAreaElement(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
92     : HTMLTextFormControlElement(tagName, document, form)
93     , m_rows(defaultRows)
94     , m_cols(defaultCols)
95     , m_wrap(SoftWrap)
96     , m_placeholder(0)
97     , m_isDirty(false)
98     , m_wasModifiedByUser(false)
99 {
100     ASSERT(hasTagName(textareaTag));
101     setFormControlValueMatchesRenderer(true);
102 }
103
104 PassRefPtr<HTMLTextAreaElement> HTMLTextAreaElement::create(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
105 {
106     RefPtr<HTMLTextAreaElement> textArea = adoptRef(new HTMLTextAreaElement(tagName, document, form));
107     textArea->ensureUserAgentShadowRoot();
108     return textArea.release();
109 }
110
111 void HTMLTextAreaElement::didAddUserAgentShadowRoot(ShadowRoot* root)
112 {
113     root->appendChild(TextControlInnerTextElement::create(document()), ASSERT_NO_EXCEPTION);
114     updateInnerTextElementEditability();
115 }
116
117 const AtomicString& HTMLTextAreaElement::formControlType() const
118 {
119     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, textarea, ("textarea", AtomicString::ConstructFromLiteral));
120     return textarea;
121 }
122
123 FormControlState HTMLTextAreaElement::saveFormControlState() const
124 {
125     return m_isDirty ? FormControlState(value()) : FormControlState();
126 }
127
128 void HTMLTextAreaElement::restoreFormControlState(const FormControlState& state)
129 {
130     setValue(state[0]);
131 }
132
133 void HTMLTextAreaElement::childrenChanged(const ChildChange& change)
134 {
135     HTMLElement::childrenChanged(change);
136     setLastChangeWasNotUserEdit();
137     if (m_isDirty)
138         setInnerTextValue(value());
139     else
140         setNonDirtyValue(defaultValue());
141 }
142
143 bool HTMLTextAreaElement::isPresentationAttribute(const QualifiedName& name) const
144 {
145     if (name == alignAttr) {
146         // Don't map 'align' attribute.  This matches what Firefox, Opera and IE do.
147         // See http://bugs.webkit.org/show_bug.cgi?id=7075
148         return false;
149     }
150
151     if (name == wrapAttr)
152         return true;
153     return HTMLTextFormControlElement::isPresentationAttribute(name);
154 }
155
156 void HTMLTextAreaElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStyleProperties& style)
157 {
158     if (name == wrapAttr) {
159         if (shouldWrapText()) {
160             addPropertyToPresentationAttributeStyle(style, CSSPropertyWhiteSpace, CSSValuePreWrap);
161             addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueBreakWord);
162         } else {
163             addPropertyToPresentationAttributeStyle(style, CSSPropertyWhiteSpace, CSSValuePre);
164             addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueNormal);
165         }
166     } else
167         HTMLTextFormControlElement::collectStyleForPresentationAttribute(name, value, style);
168 }
169
170 void HTMLTextAreaElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
171 {
172     if (name == rowsAttr) {
173         int rows = value.toInt();
174         if (rows <= 0)
175             rows = defaultRows;
176         if (m_rows != rows) {
177             m_rows = rows;
178             if (renderer())
179                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
180         }
181     } else if (name == colsAttr) {
182         int cols = value.toInt();
183         if (cols <= 0)
184             cols = defaultCols;
185         if (m_cols != cols) {
186             m_cols = cols;
187             if (renderer())
188                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
189         }
190     } else if (name == wrapAttr) {
191         // The virtual/physical values were a Netscape extension of HTML 3.0, now deprecated.
192         // The soft/hard /off values are a recommendation for HTML 4 extension by IE and NS 4.
193         WrapMethod wrap;
194         if (equalIgnoringCase(value, "physical") || equalIgnoringCase(value, "hard") || equalIgnoringCase(value, "on"))
195             wrap = HardWrap;
196         else if (equalIgnoringCase(value, "off"))
197             wrap = NoWrap;
198         else
199             wrap = SoftWrap;
200         if (wrap != m_wrap) {
201             m_wrap = wrap;
202             if (renderer())
203                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
204         }
205     } else if (name == accesskeyAttr) {
206         // ignore for the moment
207     } else if (name == maxlengthAttr)
208         setNeedsValidityCheck();
209     else
210         HTMLTextFormControlElement::parseAttribute(name, value);
211 }
212
213 RenderPtr<RenderElement> HTMLTextAreaElement::createElementRenderer(PassRef<RenderStyle> style)
214 {
215     return createRenderer<RenderTextControlMultiLine>(*this, WTF::move(style));
216 }
217
218 bool HTMLTextAreaElement::appendFormData(FormDataList& encoding, bool)
219 {
220     if (name().isEmpty())
221         return false;
222
223     document().updateLayout();
224
225     const String& text = (m_wrap == HardWrap) ? valueWithHardLineBreaks() : value();
226     encoding.appendData(name(), text);
227
228     const AtomicString& dirnameAttrValue = fastGetAttribute(dirnameAttr);
229     if (!dirnameAttrValue.isNull())
230         encoding.appendData(dirnameAttrValue, directionForFormData());
231     return true;    
232 }
233
234 void HTMLTextAreaElement::reset()
235 {
236     setNonDirtyValue(defaultValue());
237 }
238
239 bool HTMLTextAreaElement::hasCustomFocusLogic() const
240 {
241     return true;
242 }
243
244 bool HTMLTextAreaElement::isKeyboardFocusable(KeyboardEvent*) const
245 {
246     // If a given text area can be focused at all, then it will always be keyboard focusable.
247     return isFocusable();
248 }
249
250 bool HTMLTextAreaElement::isMouseFocusable() const
251 {
252     return isFocusable();
253 }
254
255 void HTMLTextAreaElement::updateFocusAppearance(bool restorePreviousSelection)
256 {
257     if (!restorePreviousSelection || !hasCachedSelection()) {
258         // If this is the first focus, set a caret at the beginning of the text.  
259         // This matches some browsers' behavior; see bug 11746 Comment #15.
260         // http://bugs.webkit.org/show_bug.cgi?id=11746#c15
261         setSelectionRange(0, 0);
262     } else
263         restoreCachedSelection();
264
265     if (document().frame())
266         document().frame()->selection().revealSelection();
267 }
268
269 void HTMLTextAreaElement::defaultEventHandler(Event* event)
270 {
271     if (renderer() && (event->isMouseEvent() || event->isDragEvent() || event->eventInterface() == WheelEventInterfaceType || event->type() == eventNames().blurEvent))
272         forwardEvent(event);
273     else if (renderer() && event->isBeforeTextInsertedEvent())
274         handleBeforeTextInsertedEvent(toBeforeTextInsertedEvent(event));
275
276     HTMLTextFormControlElement::defaultEventHandler(event);
277 }
278
279 void HTMLTextAreaElement::subtreeHasChanged()
280 {
281     setChangedSinceLastFormControlChangeEvent(true);
282     setFormControlValueMatchesRenderer(false);
283     setNeedsValidityCheck();
284
285     if (!focused())
286         return;
287
288     if (Frame* frame = document().frame())
289         frame->editor().textDidChangeInTextArea(this);
290     // When typing in a textarea, childrenChanged is not called, so we need to force the directionality check.
291     calculateAndAdjustDirectionality();
292 }
293
294 void HTMLTextAreaElement::handleBeforeTextInsertedEvent(BeforeTextInsertedEvent* event) const
295 {
296     ASSERT(event);
297     ASSERT(renderer());
298     int signedMaxLength = maxLength();
299     if (signedMaxLength < 0)
300         return;
301     unsigned unsignedMaxLength = static_cast<unsigned>(signedMaxLength);
302
303     const String& currentValue = innerTextValue();
304     unsigned numberOfLineBreaksInCurrentValue = numberOfLineBreaks(currentValue);
305     if (upperBoundForLengthForSubmission(currentValue, numberOfLineBreaksInCurrentValue)
306         + upperBoundForLengthForSubmission(event->text(), numberOfLineBreaks(event->text())) < unsignedMaxLength)
307         return;
308
309     unsigned currentLength = computeLengthForSubmission(currentValue, numberOfLineBreaksInCurrentValue);
310     // selectionLength represents the selection length of this text field to be
311     // removed by this insertion.
312     // If the text field has no focus, we don't need to take account of the
313     // selection length. The selection is the source of text drag-and-drop in
314     // that case, and nothing in the text field will be removed.
315     unsigned selectionLength = focused() ? computeLengthForSubmission(plainText(document().frame()->selection().selection().toNormalizedRange().get())) : 0;
316     ASSERT(currentLength >= selectionLength);
317     unsigned baseLength = currentLength - selectionLength;
318     unsigned appendableLength = unsignedMaxLength > baseLength ? unsignedMaxLength - baseLength : 0;
319     event->setText(sanitizeUserInputValue(event->text(), appendableLength));
320 }
321
322 String HTMLTextAreaElement::sanitizeUserInputValue(const String& proposedValue, unsigned maxLength)
323 {
324     return proposedValue.left(numCharactersInGraphemeClusters(proposedValue, maxLength));
325 }
326
327 TextControlInnerTextElement* HTMLTextAreaElement::innerTextElement() const
328 {
329     Node* node = userAgentShadowRoot()->firstChild();
330     return toTextControlInnerTextElement(node);
331 }
332
333 void HTMLTextAreaElement::rendererWillBeDestroyed()
334 {
335     updateValue();
336 }
337
338 void HTMLTextAreaElement::updateValue() const
339 {
340     if (formControlValueMatchesRenderer())
341         return;
342
343     ASSERT(renderer());
344     m_value = innerTextValue();
345     const_cast<HTMLTextAreaElement*>(this)->setFormControlValueMatchesRenderer(true);
346     m_isDirty = true;
347     m_wasModifiedByUser = true;
348     const_cast<HTMLTextAreaElement*>(this)->updatePlaceholderVisibility(false);
349 }
350
351 String HTMLTextAreaElement::value() const
352 {
353     updateValue();
354     return m_value;
355 }
356
357 void HTMLTextAreaElement::setValue(const String& value)
358 {
359     setValueCommon(value);
360     m_isDirty = true;
361     setNeedsValidityCheck();
362 }
363
364 void HTMLTextAreaElement::setNonDirtyValue(const String& value)
365 {
366     setValueCommon(value);
367     m_isDirty = false;
368     setNeedsValidityCheck();
369 }
370
371 void HTMLTextAreaElement::setValueCommon(const String& newValue)
372 {
373     m_wasModifiedByUser = false;
374     // Code elsewhere normalizes line endings added by the user via the keyboard or pasting.
375     // We normalize line endings coming from JavaScript here.
376     String normalizedValue = newValue.isNull() ? "" : newValue;
377     normalizedValue.replace("\r\n", "\n");
378     normalizedValue.replace('\r', '\n');
379
380     // Return early because we don't want to move the caret or trigger other side effects
381     // when the value isn't changing. This matches Firefox behavior, at least.
382     if (normalizedValue == value())
383         return;
384
385     m_value = normalizedValue;
386     setInnerTextValue(m_value);
387     setLastChangeWasNotUserEdit();
388     updatePlaceholderVisibility(false);
389     setNeedsStyleRecalc();
390     setFormControlValueMatchesRenderer(true);
391
392     // Set the caret to the end of the text value.
393     if (document().focusedElement() == this) {
394         unsigned endOfString = m_value.length();
395         setSelectionRange(endOfString, endOfString);
396     }
397
398     setTextAsOfLastFormControlChangeEvent(normalizedValue);
399 }
400
401 String HTMLTextAreaElement::defaultValue() const
402 {
403     return TextNodeTraversal::contentsAsString(this);
404 }
405
406 void HTMLTextAreaElement::setDefaultValue(const String& defaultValue)
407 {
408     Ref<HTMLTextAreaElement> protectFromMutationEvents(*this);
409
410     // To preserve comments, remove only the text nodes, then add a single text node.
411     Vector<RefPtr<Text>> textNodes;
412     for (Text* textNode = TextNodeTraversal::firstChild(this); textNode; textNode = TextNodeTraversal::nextSibling(textNode))
413         textNodes.append(textNode);
414
415     size_t size = textNodes.size();
416     for (size_t i = 0; i < size; ++i)
417         removeChild(textNodes[i].get(), IGNORE_EXCEPTION);
418
419     // Normalize line endings.
420     String value = defaultValue;
421     value.replace("\r\n", "\n");
422     value.replace('\r', '\n');
423
424     insertBefore(document().createTextNode(value), firstChild(), IGNORE_EXCEPTION);
425
426     if (!m_isDirty)
427         setNonDirtyValue(value);
428 }
429
430 int HTMLTextAreaElement::maxLength() const
431 {
432     bool ok;
433     int value = getAttribute(maxlengthAttr).string().toInt(&ok);
434     return ok && value >= 0 ? value : -1;
435 }
436
437 void HTMLTextAreaElement::setMaxLength(int newValue, ExceptionCode& ec)
438 {
439     if (newValue < 0)
440         ec = INDEX_SIZE_ERR;
441     else
442         setIntegralAttribute(maxlengthAttr, newValue);
443 }
444
445 String HTMLTextAreaElement::validationMessage() const
446 {
447     if (!willValidate())
448         return String();
449
450     if (customError())
451         return customValidationMessage();
452
453     if (valueMissing())
454         return validationMessageValueMissingText();
455
456     if (tooLong())
457         return validationMessageTooLongText(computeLengthForSubmission(value()), maxLength());
458
459     return String();
460 }
461
462 bool HTMLTextAreaElement::valueMissing() const
463 {
464     return willValidate() && valueMissing(value());
465 }
466
467 bool HTMLTextAreaElement::tooLong() const
468 {
469     return willValidate() && tooLong(value(), CheckDirtyFlag);
470 }
471
472 bool HTMLTextAreaElement::tooLong(const String& value, NeedsToCheckDirtyFlag check) const
473 {
474     // Return false for the default value or value set by script even if it is
475     // longer than maxLength.
476     if (check == CheckDirtyFlag && !m_wasModifiedByUser)
477         return false;
478
479     int max = maxLength();
480     if (max < 0)
481         return false;
482     unsigned unsignedMax = static_cast<unsigned>(max);
483     unsigned numberOfLineBreaksInValue = numberOfLineBreaks(value);
484     return upperBoundForLengthForSubmission(value, numberOfLineBreaksInValue) > unsignedMax
485         && computeLengthForSubmission(value, numberOfLineBreaksInValue) > unsignedMax;
486 }
487
488 bool HTMLTextAreaElement::isValidValue(const String& candidate) const
489 {
490     return !valueMissing(candidate) && !tooLong(candidate, IgnoreDirtyFlag);
491 }
492
493 void HTMLTextAreaElement::accessKeyAction(bool)
494 {
495     focus();
496 }
497
498 void HTMLTextAreaElement::setCols(int cols)
499 {
500     setIntegralAttribute(colsAttr, cols);
501 }
502
503 void HTMLTextAreaElement::setRows(int rows)
504 {
505     setIntegralAttribute(rowsAttr, rows);
506 }
507
508 bool HTMLTextAreaElement::shouldUseInputMethod()
509 {
510     return true;
511 }
512
513 HTMLElement* HTMLTextAreaElement::placeholderElement() const
514 {
515     return m_placeholder;
516 }
517
518 bool HTMLTextAreaElement::matchesReadOnlyPseudoClass() const
519 {
520     return isReadOnly();
521 }
522
523 bool HTMLTextAreaElement::matchesReadWritePseudoClass() const
524 {
525     return !isDisabledOrReadOnly();
526 }
527
528 void HTMLTextAreaElement::updatePlaceholderText()
529 {
530     String placeholderText = strippedPlaceholder();
531     if (placeholderText.isEmpty()) {
532         if (m_placeholder) {
533             userAgentShadowRoot()->removeChild(m_placeholder, ASSERT_NO_EXCEPTION);
534             m_placeholder = 0;
535         }
536         return;
537     }
538     if (!m_placeholder) {
539         RefPtr<HTMLDivElement> placeholder = HTMLDivElement::create(document());
540         m_placeholder = placeholder.get();
541         m_placeholder->setPseudo(AtomicString("-webkit-input-placeholder", AtomicString::ConstructFromLiteral));
542         userAgentShadowRoot()->insertBefore(m_placeholder, innerTextElement()->nextSibling());
543     }
544     m_placeholder->setInnerText(placeholderText, ASSERT_NO_EXCEPTION);
545 }
546
547 bool HTMLTextAreaElement::willRespondToMouseClickEvents()
548 {
549     return !isDisabledFormControl();
550 }
551
552 } // namespace WebCore