7aa66f5b75374ade62cada5b2470715c85d982fe
[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 "EventNames.h"
37 #include "ExceptionCodePlaceholder.h"
38 #include "HTMLInputElement.h"
39 #include "HTMLParserIdioms.h"
40 #include "InputTypeNames.h"
41 #include "KeyboardEvent.h"
42 #include "MouseEvent.h"
43 #include "PlatformMouseEvent.h"
44 #include "RenderSlider.h"
45 #include "ScopedEventQueue.h"
46 #include "ShadowRoot.h"
47 #include "SliderThumbElement.h"
48 #include <limits>
49 #include <wtf/MathExtras.h>
50 #include <wtf/NeverDestroyed.h>
51
52 #if ENABLE(TOUCH_EVENTS)
53 #include "Touch.h"
54 #include "TouchEvent.h"
55 #include "TouchList.h"
56 #endif
57
58 #if ENABLE(DATALIST_ELEMENT)
59 #include "HTMLDataListElement.h"
60 #include "HTMLOptionElement.h"
61 #endif
62
63 namespace WebCore {
64
65 using namespace HTMLNames;
66
67 static const int rangeDefaultMinimum = 0;
68 static const int rangeDefaultMaximum = 100;
69 static const int rangeDefaultStep = 1;
70 static const int rangeDefaultStepBase = 0;
71 static const int rangeStepScaleFactor = 1;
72
73 static Decimal ensureMaximum(const Decimal& proposedValue, const Decimal& minimum, const Decimal& fallbackValue)
74 {
75     return proposedValue >= minimum ? proposedValue : std::max(minimum, fallbackValue);
76 }
77
78 RangeInputType::RangeInputType(HTMLInputElement& element)
79     : InputType(element)
80 #if ENABLE(DATALIST_ELEMENT)
81     , m_tickMarkValuesDirty(true)
82 #endif
83 {
84 }
85
86 bool RangeInputType::isRangeControl() const
87 {
88     return true;
89 }
90
91 const AtomicString& RangeInputType::formControlType() const
92 {
93     return InputTypeNames::range();
94 }
95
96 double RangeInputType::valueAsDouble() const
97 {
98     return parseToDoubleForNumberType(element().value());
99 }
100
101 void RangeInputType::setValueAsDecimal(const Decimal& newValue, TextFieldEventBehavior eventBehavior, ExceptionCode&) const
102 {
103     element().setValue(serialize(newValue), eventBehavior);
104 }
105
106 bool RangeInputType::typeMismatchFor(const String& value) const
107 {
108     return !value.isEmpty() && !std::isfinite(parseToDoubleForNumberType(value));
109 }
110
111 bool RangeInputType::supportsRequired() const
112 {
113     return false;
114 }
115
116 StepRange RangeInputType::createStepRange(AnyStepHandling anyStepHandling) const
117 {
118     static NeverDestroyed<const StepRange::StepDescription> stepDescription(rangeDefaultStep, rangeDefaultStepBase, rangeStepScaleFactor);
119
120     const Decimal minimum = parseToNumber(element().attributeWithoutSynchronization(minAttr), rangeDefaultMinimum);
121     const Decimal maximum = ensureMaximum(parseToNumber(element().attributeWithoutSynchronization(maxAttr), rangeDefaultMaximum), minimum, rangeDefaultMaximum);
122
123     const AtomicString& precisionValue = element().attributeWithoutSynchronization(precisionAttr);
124     if (!precisionValue.isNull()) {
125         const Decimal step = equalLettersIgnoringASCIICase(precisionValue, "float") ? Decimal::nan() : 1;
126         return StepRange(minimum, RangeLimitations::Valid, minimum, maximum, step, stepDescription);
127     }
128
129     const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element().attributeWithoutSynchronization(stepAttr));
130     return StepRange(minimum, RangeLimitations::Valid, minimum, maximum, step, stepDescription);
131 }
132
133 bool RangeInputType::isSteppable() const
134 {
135     return true;
136 }
137
138 #if !PLATFORM(IOS)
139 void RangeInputType::handleMouseDownEvent(MouseEvent* event)
140 {
141     if (element().isDisabledOrReadOnly())
142         return;
143
144     Node* targetNode = event->target()->toNode();
145     if (event->button() != LeftButton || !targetNode)
146         return;
147     ASSERT(element().shadowRoot());
148     if (targetNode != &element() && !targetNode->isDescendantOf(element().userAgentShadowRoot()))
149         return;
150     SliderThumbElement& thumb = typedSliderThumbElement();
151     if (targetNode == &thumb)
152         return;
153     thumb.dragFrom(event->absoluteLocation());
154 }
155 #endif
156
157 #if ENABLE(TOUCH_EVENTS)
158 void RangeInputType::handleTouchEvent(TouchEvent* event)
159 {
160 #if PLATFORM(IOS)
161     typedSliderThumbElement().handleTouchEvent(event);
162 #elif ENABLE(TOUCH_SLIDER)
163     if (element().isDisabledOrReadOnly())
164         return;
165
166     if (event->type() == eventNames().touchendEvent) {
167         event->setDefaultHandled();
168         return;
169     }
170
171     TouchList* touches = event->targetTouches();
172     if (touches->length() == 1) {
173         typedSliderThumbElement().setPositionFromPoint(touches->item(0)->absoluteLocation());
174         event->setDefaultHandled();
175     }
176 #else
177     UNUSED_PARAM(event);
178 #endif
179 }
180
181 #if ENABLE(TOUCH_SLIDER)
182 bool RangeInputType::hasTouchEventHandler() const
183 {
184     return true;
185 }
186 #endif
187
188 #if PLATFORM(IOS)
189 void RangeInputType::disabledAttributeChanged()
190 {
191     typedSliderThumbElement().disabledAttributeChanged();
192 }
193 #endif
194 #endif // ENABLE(TOUCH_EVENTS)
195
196 void RangeInputType::handleKeydownEvent(KeyboardEvent* event)
197 {
198     if (element().isDisabledOrReadOnly())
199         return;
200
201     const String& key = event->keyIdentifier();
202
203     const Decimal current = parseToNumberOrNaN(element().value());
204     ASSERT(current.isFinite());
205
206     StepRange stepRange(createStepRange(RejectAny));
207
208
209     // FIXME: We can't use stepUp() for the step value "any". So, we increase
210     // or decrease the value by 1/100 of the value range. Is it reasonable?
211     const Decimal step = equalLettersIgnoringASCIICase(element().attributeWithoutSynchronization(stepAttr), "any") ? (stepRange.maximum() - stepRange.minimum()) / 100 : stepRange.step();
212     const Decimal bigStep = std::max((stepRange.maximum() - stepRange.minimum()) / 10, step);
213
214     bool isVertical = false;
215     if (element().renderer()) {
216         ControlPart part = element().renderer()->style().appearance();
217         isVertical = part == SliderVerticalPart || part == MediaVolumeSliderPart;
218     }
219
220     Decimal newValue;
221     if (key == "Up")
222         newValue = current + step;
223     else if (key == "Down")
224         newValue = current - step;
225     else if (key == "Left")
226         newValue = isVertical ? current + step : current - step;
227     else if (key == "Right")
228         newValue = isVertical ? current - step : current + step;
229     else if (key == "PageUp")
230         newValue = current + bigStep;
231     else if (key == "PageDown")
232         newValue = current - bigStep;
233     else if (key == "Home")
234         newValue = isVertical ? stepRange.maximum() : stepRange.minimum();
235     else if (key == "End")
236         newValue = isVertical ? stepRange.minimum() : stepRange.maximum();
237     else
238         return; // Did not match any key binding.
239
240     newValue = stepRange.clampValue(newValue);
241
242     if (newValue != current) {
243         EventQueueScope scope;
244         setValueAsDecimal(newValue, DispatchInputAndChangeEvent, IGNORE_EXCEPTION);
245
246         if (AXObjectCache* cache = element().document().existingAXObjectCache())
247             cache->postNotification(&element(), AXObjectCache::AXValueChanged);
248     }
249
250     event->setDefaultHandled();
251 }
252
253 void RangeInputType::createShadowSubtree()
254 {
255     ASSERT(element().userAgentShadowRoot());
256
257     Document& document = element().document();
258     auto track = HTMLDivElement::create(document);
259     track->setPseudo(AtomicString("-webkit-slider-runnable-track", AtomicString::ConstructFromLiteral));
260     track->appendChild(SliderThumbElement::create(document), IGNORE_EXCEPTION);
261     auto container = SliderContainerElement::create(document);
262     container->appendChild(track, IGNORE_EXCEPTION);
263     element().userAgentShadowRoot()->appendChild(container, IGNORE_EXCEPTION);
264 }
265
266 HTMLElement* RangeInputType::sliderTrackElement() const
267 {
268     ASSERT(element().userAgentShadowRoot());
269     ASSERT(element().userAgentShadowRoot()->firstChild()); // container
270     ASSERT(element().userAgentShadowRoot()->firstChild()->isHTMLElement());
271     ASSERT(element().userAgentShadowRoot()->firstChild()->firstChild()); // track
272
273     return downcast<HTMLElement>(element().userAgentShadowRoot()->firstChild()->firstChild());
274 }
275
276 SliderThumbElement& RangeInputType::typedSliderThumbElement() const
277 {
278     ASSERT(sliderTrackElement()->firstChild()); // thumb
279     ASSERT(sliderTrackElement()->firstChild()->isHTMLElement());
280
281     return static_cast<SliderThumbElement&>(*sliderTrackElement()->firstChild());
282 }
283
284 HTMLElement* RangeInputType::sliderThumbElement() const
285 {
286     return &typedSliderThumbElement();
287 }
288
289 RenderPtr<RenderElement> RangeInputType::createInputRenderer(RenderStyle&& style)
290 {
291     return createRenderer<RenderSlider>(element(), WTFMove(style));
292 }
293
294 Decimal RangeInputType::parseToNumber(const String& src, const Decimal& defaultValue) const
295 {
296     return parseToDecimalForNumberType(src, defaultValue);
297 }
298
299 String RangeInputType::serialize(const Decimal& value) const
300 {
301     if (!value.isFinite())
302         return String();
303     return serializeForNumberType(value);
304 }
305
306 // FIXME: Could share this with BaseClickableWithKeyInputType and BaseCheckableInputType if we had a common base class.
307 void RangeInputType::accessKeyAction(bool sendMouseEvents)
308 {
309     InputType::accessKeyAction(sendMouseEvents);
310
311     element().dispatchSimulatedClick(0, sendMouseEvents ? SendMouseUpDownEvents : SendNoEvents);
312 }
313
314 void RangeInputType::minOrMaxAttributeChanged()
315 {
316     InputType::minOrMaxAttributeChanged();
317
318     // Sanitize the value.
319     if (element().hasDirtyValue())
320         element().setValue(element().value());
321
322     typedSliderThumbElement().setPositionFromValue();
323 }
324
325 void RangeInputType::setValue(const String& value, bool valueChanged, TextFieldEventBehavior eventBehavior)
326 {
327     InputType::setValue(value, valueChanged, eventBehavior);
328
329     if (!valueChanged)
330         return;
331
332     if (eventBehavior == DispatchNoEvent)
333         element().setTextAsOfLastFormControlChangeEvent(value);
334
335     typedSliderThumbElement().setPositionFromValue();
336 }
337
338 String RangeInputType::fallbackValue() const
339 {
340     return serializeForNumberType(createStepRange(RejectAny).defaultValue());
341 }
342
343 String RangeInputType::sanitizeValue(const String& proposedValue) const
344 {
345     StepRange stepRange(createStepRange(RejectAny));
346     const Decimal proposedNumericValue = parseToNumber(proposedValue, stepRange.defaultValue());
347     return serializeForNumberType(stepRange.clampValue(proposedNumericValue));
348 }
349
350 bool RangeInputType::shouldRespectListAttribute()
351 {
352     return InputType::themeSupportsDataListUI(this);
353 }
354
355 #if ENABLE(DATALIST_ELEMENT)
356 void RangeInputType::listAttributeTargetChanged()
357 {
358     m_tickMarkValuesDirty = true;
359     HTMLElement* sliderTrackElement = this->sliderTrackElement();
360     if (sliderTrackElement->renderer())
361         sliderTrackElement->renderer()->setNeedsLayout();
362 }
363
364 void RangeInputType::updateTickMarkValues()
365 {
366     if (!m_tickMarkValuesDirty)
367         return;
368     m_tickMarkValues.clear();
369     m_tickMarkValuesDirty = false;
370     HTMLDataListElement* dataList = element().dataList();
371     if (!dataList)
372         return;
373     Ref<HTMLCollection> options = dataList->options();
374     m_tickMarkValues.reserveCapacity(options->length());
375     for (unsigned i = 0; i < options->length(); ++i) {
376         Node* node = options->item(i);
377         HTMLOptionElement& optionElement = downcast<HTMLOptionElement>(*node);
378         String optionValue = optionElement.value();
379         if (!element().isValidValue(optionValue))
380             continue;
381         m_tickMarkValues.append(parseToNumber(optionValue, Decimal::nan()));
382     }
383     m_tickMarkValues.shrinkToFit();
384     std::sort(m_tickMarkValues.begin(), m_tickMarkValues.end());
385 }
386
387 Optional<Decimal> RangeInputType::findClosestTickMarkValue(const Decimal& value)
388 {
389     updateTickMarkValues();
390     if (!m_tickMarkValues.size())
391         return Nullopt;
392
393     size_t left = 0;
394     size_t right = m_tickMarkValues.size();
395     size_t middle;
396     while (true) {
397         ASSERT(left <= right);
398         middle = left + (right - left) / 2;
399         if (!middle)
400             break;
401         if (middle == m_tickMarkValues.size() - 1 && m_tickMarkValues[middle] < value) {
402             middle++;
403             break;
404         }
405         if (m_tickMarkValues[middle - 1] <= value && m_tickMarkValues[middle] >= value)
406             break;
407
408         if (m_tickMarkValues[middle] < value)
409             left = middle;
410         else
411             right = middle;
412     }
413
414     Optional<Decimal> closestLeft = middle ? makeOptional(m_tickMarkValues[middle - 1]) : Nullopt;
415     Optional<Decimal> closestRight = middle != m_tickMarkValues.size() ? makeOptional(m_tickMarkValues[middle]) : Nullopt;
416
417     if (!closestLeft)
418         return closestRight;
419     if (!closestRight)
420         return closestLeft;
421
422     if (*closestRight - value < value - *closestLeft)
423         return closestRight;
424
425     return closestLeft;
426 }
427 #endif
428
429 } // namespace WebCore