Update Node::appendChild() / replaceChild() / removeChild() / insertBefore() to take...
[WebKit-https.git] / Source / WebCore / html / RangeInputType.cpp
1 /*
2  * Copyright (C) 2010 Google Inc. All rights reserved.
3  * Copyright (C) 2011 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33 #include "RangeInputType.h"
34
35 #include "AXObjectCache.h"
36 #include "ExceptionCodePlaceholder.h"
37 #include "HTMLInputElement.h"
38 #include "HTMLParserIdioms.h"
39 #include "InputTypeNames.h"
40 #include "KeyboardEvent.h"
41 #include "MouseEvent.h"
42 #include "PlatformMouseEvent.h"
43 #include "RenderSlider.h"
44 #include "ScopedEventQueue.h"
45 #include "ShadowRoot.h"
46 #include "SliderThumbElement.h"
47 #include <limits>
48 #include <wtf/MathExtras.h>
49 #include <wtf/NeverDestroyed.h>
50
51 #if ENABLE(TOUCH_EVENTS)
52 #include "Touch.h"
53 #include "TouchEvent.h"
54 #include "TouchList.h"
55 #endif
56
57 #if ENABLE(DATALIST_ELEMENT)
58 #include "HTMLDataListElement.h"
59 #include "HTMLOptionElement.h"
60 #endif
61
62 namespace WebCore {
63
64 using namespace HTMLNames;
65
66 static const int rangeDefaultMinimum = 0;
67 static const int rangeDefaultMaximum = 100;
68 static const int rangeDefaultStep = 1;
69 static const int rangeDefaultStepBase = 0;
70 static const int rangeStepScaleFactor = 1;
71
72 static Decimal ensureMaximum(const Decimal& proposedValue, const Decimal& minimum, const Decimal& fallbackValue)
73 {
74     return proposedValue >= minimum ? proposedValue : std::max(minimum, fallbackValue);
75 }
76
77 RangeInputType::RangeInputType(HTMLInputElement& element)
78     : InputType(element)
79 #if ENABLE(DATALIST_ELEMENT)
80     , m_tickMarkValuesDirty(true)
81 #endif
82 {
83 }
84
85 bool RangeInputType::isRangeControl() const
86 {
87     return true;
88 }
89
90 const AtomicString& RangeInputType::formControlType() const
91 {
92     return InputTypeNames::range();
93 }
94
95 double RangeInputType::valueAsDouble() const
96 {
97     return parseToDoubleForNumberType(element().value());
98 }
99
100 void RangeInputType::setValueAsDecimal(const Decimal& newValue, TextFieldEventBehavior eventBehavior, ExceptionCode&) const
101 {
102     element().setValue(serialize(newValue), eventBehavior);
103 }
104
105 bool RangeInputType::typeMismatchFor(const String& value) const
106 {
107     return !value.isEmpty() && !std::isfinite(parseToDoubleForNumberType(value));
108 }
109
110 bool RangeInputType::supportsRequired() const
111 {
112     return false;
113 }
114
115 StepRange RangeInputType::createStepRange(AnyStepHandling anyStepHandling) const
116 {
117     static NeverDestroyed<const StepRange::StepDescription> stepDescription(rangeDefaultStep, rangeDefaultStepBase, rangeStepScaleFactor);
118
119     const Decimal minimum = parseToNumber(element().fastGetAttribute(minAttr), rangeDefaultMinimum);
120     const Decimal maximum = ensureMaximum(parseToNumber(element().fastGetAttribute(maxAttr), rangeDefaultMaximum), minimum, rangeDefaultMaximum);
121
122     const AtomicString& precisionValue = element().fastGetAttribute(precisionAttr);
123     if (!precisionValue.isNull()) {
124         const Decimal step = equalLettersIgnoringASCIICase(precisionValue, "float") ? Decimal::nan() : 1;
125         return StepRange(minimum, minimum, maximum, step, stepDescription);
126     }
127
128     const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element().fastGetAttribute(stepAttr));
129     return StepRange(minimum, minimum, maximum, step, stepDescription);
130 }
131
132 bool RangeInputType::isSteppable() const
133 {
134     return true;
135 }
136
137 #if !PLATFORM(IOS)
138 void RangeInputType::handleMouseDownEvent(MouseEvent* event)
139 {
140     if (element().isDisabledOrReadOnly())
141         return;
142
143     Node* targetNode = event->target()->toNode();
144     if (event->button() != LeftButton || !targetNode)
145         return;
146     ASSERT(element().shadowRoot());
147     if (targetNode != &element() && !targetNode->isDescendantOf(element().userAgentShadowRoot()))
148         return;
149     SliderThumbElement& thumb = typedSliderThumbElement();
150     if (targetNode == &thumb)
151         return;
152     thumb.dragFrom(event->absoluteLocation());
153 }
154 #endif
155
156 #if ENABLE(TOUCH_EVENTS)
157 void RangeInputType::handleTouchEvent(TouchEvent* event)
158 {
159 #if PLATFORM(IOS)
160     typedSliderThumbElement().handleTouchEvent(event);
161 #elif ENABLE(TOUCH_SLIDER)
162     if (element().isDisabledOrReadOnly())
163         return;
164
165     if (event->type() == eventNames().touchendEvent) {
166         event->setDefaultHandled();
167         return;
168     }
169
170     TouchList* touches = event->targetTouches();
171     if (touches->length() == 1) {
172         typedSliderThumbElement().setPositionFromPoint(touches->item(0)->absoluteLocation());
173         event->setDefaultHandled();
174     }
175 #else
176     UNUSED_PARAM(event);
177 #endif
178 }
179
180 #if ENABLE(TOUCH_SLIDER)
181 bool RangeInputType::hasTouchEventHandler() const
182 {
183     return true;
184 }
185 #endif
186
187 #if PLATFORM(IOS)
188 void RangeInputType::disabledAttributeChanged()
189 {
190     typedSliderThumbElement().disabledAttributeChanged();
191 }
192 #endif
193 #endif // ENABLE(TOUCH_EVENTS)
194
195 void RangeInputType::handleKeydownEvent(KeyboardEvent* event)
196 {
197     if (element().isDisabledOrReadOnly())
198         return;
199
200     const String& key = event->keyIdentifier();
201
202     const Decimal current = parseToNumberOrNaN(element().value());
203     ASSERT(current.isFinite());
204
205     StepRange stepRange(createStepRange(RejectAny));
206
207
208     // FIXME: We can't use stepUp() for the step value "any". So, we increase
209     // or decrease the value by 1/100 of the value range. Is it reasonable?
210     const Decimal step = equalLettersIgnoringASCIICase(element().fastGetAttribute(stepAttr), "any") ? (stepRange.maximum() - stepRange.minimum()) / 100 : stepRange.step();
211     const Decimal bigStep = std::max((stepRange.maximum() - stepRange.minimum()) / 10, step);
212
213     bool isVertical = false;
214     if (element().renderer()) {
215         ControlPart part = element().renderer()->style().appearance();
216         isVertical = part == SliderVerticalPart || part == MediaVolumeSliderPart;
217     }
218
219     Decimal newValue;
220     if (key == "Up")
221         newValue = current + step;
222     else if (key == "Down")
223         newValue = current - step;
224     else if (key == "Left")
225         newValue = isVertical ? current + step : current - step;
226     else if (key == "Right")
227         newValue = isVertical ? current - step : current + step;
228     else if (key == "PageUp")
229         newValue = current + bigStep;
230     else if (key == "PageDown")
231         newValue = current - bigStep;
232     else if (key == "Home")
233         newValue = isVertical ? stepRange.maximum() : stepRange.minimum();
234     else if (key == "End")
235         newValue = isVertical ? stepRange.minimum() : stepRange.maximum();
236     else
237         return; // Did not match any key binding.
238
239     newValue = stepRange.clampValue(newValue);
240
241     if (newValue != current) {
242         EventQueueScope scope;
243         setValueAsDecimal(newValue, DispatchInputAndChangeEvent, IGNORE_EXCEPTION);
244
245         if (AXObjectCache* cache = element().document().existingAXObjectCache())
246             cache->postNotification(&element(), AXObjectCache::AXValueChanged);
247     }
248
249     event->setDefaultHandled();
250 }
251
252 void RangeInputType::createShadowSubtree()
253 {
254     ASSERT(element().userAgentShadowRoot());
255
256     Document& document = element().document();
257     auto track = HTMLDivElement::create(document);
258     track->setPseudo(AtomicString("-webkit-slider-runnable-track", AtomicString::ConstructFromLiteral));
259     track->appendChild(SliderThumbElement::create(document), IGNORE_EXCEPTION);
260     auto container = SliderContainerElement::create(document);
261     container->appendChild(track, IGNORE_EXCEPTION);
262     element().userAgentShadowRoot()->appendChild(container, IGNORE_EXCEPTION);
263 }
264
265 HTMLElement* RangeInputType::sliderTrackElement() const
266 {
267     ASSERT(element().userAgentShadowRoot());
268     ASSERT(element().userAgentShadowRoot()->firstChild()); // container
269     ASSERT(element().userAgentShadowRoot()->firstChild()->isHTMLElement());
270     ASSERT(element().userAgentShadowRoot()->firstChild()->firstChild()); // track
271
272     return downcast<HTMLElement>(element().userAgentShadowRoot()->firstChild()->firstChild());
273 }
274
275 SliderThumbElement& RangeInputType::typedSliderThumbElement() const
276 {
277     ASSERT(sliderTrackElement()->firstChild()); // thumb
278     ASSERT(sliderTrackElement()->firstChild()->isHTMLElement());
279
280     return static_cast<SliderThumbElement&>(*sliderTrackElement()->firstChild());
281 }
282
283 HTMLElement* RangeInputType::sliderThumbElement() const
284 {
285     return &typedSliderThumbElement();
286 }
287
288 RenderPtr<RenderElement> RangeInputType::createInputRenderer(RenderStyle&& style)
289 {
290     return createRenderer<RenderSlider>(element(), WTFMove(style));
291 }
292
293 Decimal RangeInputType::parseToNumber(const String& src, const Decimal& defaultValue) const
294 {
295     return parseToDecimalForNumberType(src, defaultValue);
296 }
297
298 String RangeInputType::serialize(const Decimal& value) const
299 {
300     if (!value.isFinite())
301         return String();
302     return serializeForNumberType(value);
303 }
304
305 // FIXME: Could share this with BaseClickableWithKeyInputType and BaseCheckableInputType if we had a common base class.
306 void RangeInputType::accessKeyAction(bool sendMouseEvents)
307 {
308     InputType::accessKeyAction(sendMouseEvents);
309
310     element().dispatchSimulatedClick(0, sendMouseEvents ? SendMouseUpDownEvents : SendNoEvents);
311 }
312
313 void RangeInputType::minOrMaxAttributeChanged()
314 {
315     InputType::minOrMaxAttributeChanged();
316
317     // Sanitize the value.
318     if (element().hasDirtyValue())
319         element().setValue(element().value());
320
321     typedSliderThumbElement().setPositionFromValue();
322 }
323
324 void RangeInputType::setValue(const String& value, bool valueChanged, TextFieldEventBehavior eventBehavior)
325 {
326     InputType::setValue(value, valueChanged, eventBehavior);
327
328     if (!valueChanged)
329         return;
330
331     if (eventBehavior == DispatchNoEvent)
332         element().setTextAsOfLastFormControlChangeEvent(value);
333
334     typedSliderThumbElement().setPositionFromValue();
335 }
336
337 String RangeInputType::fallbackValue() const
338 {
339     return serializeForNumberType(createStepRange(RejectAny).defaultValue());
340 }
341
342 String RangeInputType::sanitizeValue(const String& proposedValue) const
343 {
344     StepRange stepRange(createStepRange(RejectAny));
345     const Decimal proposedNumericValue = parseToNumber(proposedValue, stepRange.defaultValue());
346     return serializeForNumberType(stepRange.clampValue(proposedNumericValue));
347 }
348
349 bool RangeInputType::shouldRespectListAttribute()
350 {
351     return InputType::themeSupportsDataListUI(this);
352 }
353
354 #if ENABLE(DATALIST_ELEMENT)
355 void RangeInputType::listAttributeTargetChanged()
356 {
357     m_tickMarkValuesDirty = true;
358     HTMLElement* sliderTrackElement = this->sliderTrackElement();
359     if (sliderTrackElement->renderer())
360         sliderTrackElement->renderer()->setNeedsLayout();
361 }
362
363 void RangeInputType::updateTickMarkValues()
364 {
365     if (!m_tickMarkValuesDirty)
366         return;
367     m_tickMarkValues.clear();
368     m_tickMarkValuesDirty = false;
369     HTMLDataListElement* dataList = element().dataList();
370     if (!dataList)
371         return;
372     Ref<HTMLCollection> options = dataList->options();
373     m_tickMarkValues.reserveCapacity(options->length());
374     for (unsigned i = 0; i < options->length(); ++i) {
375         Node* node = options->item(i);
376         HTMLOptionElement& optionElement = downcast<HTMLOptionElement>(*node);
377         String optionValue = optionElement.value();
378         if (!element().isValidValue(optionValue))
379             continue;
380         m_tickMarkValues.append(parseToNumber(optionValue, Decimal::nan()));
381     }
382     m_tickMarkValues.shrinkToFit();
383     std::sort(m_tickMarkValues.begin(), m_tickMarkValues.end());
384 }
385
386 Optional<Decimal> RangeInputType::findClosestTickMarkValue(const Decimal& value)
387 {
388     updateTickMarkValues();
389     if (!m_tickMarkValues.size())
390         return Nullopt;
391
392     size_t left = 0;
393     size_t right = m_tickMarkValues.size();
394     size_t middle;
395     while (true) {
396         ASSERT(left <= right);
397         middle = left + (right - left) / 2;
398         if (!middle)
399             break;
400         if (middle == m_tickMarkValues.size() - 1 && m_tickMarkValues[middle] < value) {
401             middle++;
402             break;
403         }
404         if (m_tickMarkValues[middle - 1] <= value && m_tickMarkValues[middle] >= value)
405             break;
406
407         if (m_tickMarkValues[middle] < value)
408             left = middle;
409         else
410             right = middle;
411     }
412
413     Optional<Decimal> closestLeft = middle ? makeOptional(m_tickMarkValues[middle - 1]) : Nullopt;
414     Optional<Decimal> closestRight = middle != m_tickMarkValues.size() ? makeOptional(m_tickMarkValues[middle]) : Nullopt;
415
416     if (!closestLeft)
417         return closestRight;
418     if (!closestRight)
419         return closestLeft;
420
421     if (*closestRight - value < value - *closestLeft)
422         return closestRight;
423
424     return closestLeft;
425 }
426 #endif
427
428 } // namespace WebCore