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