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