Move setting of some layout bits to RenderElement
[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 "HTMLDivElement.h"
38 #include "HTMLInputElement.h"
39 #include "HTMLNames.h"
40 #include "HTMLParserIdioms.h"
41 #include "InputTypeNames.h"
42 #include "KeyboardEvent.h"
43 #include "MouseEvent.h"
44 #include "PlatformMouseEvent.h"
45 #include "RenderSlider.h"
46 #include "ScopedEventQueue.h"
47 #include "ShadowRoot.h"
48 #include "SliderThumbElement.h"
49 #include "StepRange.h"
50 #include <limits>
51 #include <wtf/MathExtras.h>
52 #include <wtf/PassOwnPtr.h>
53
54 #if ENABLE(TOUCH_EVENTS)
55 #include "Touch.h"
56 #include "TouchEvent.h"
57 #include "TouchList.h"
58 #endif
59
60 #if ENABLE(DATALIST_ELEMENT)
61 #include "HTMLDataListElement.h"
62 #include "HTMLOptionElement.h"
63 #endif
64
65 namespace WebCore {
66
67 using namespace HTMLNames;
68 using namespace std;
69
70 static const int rangeDefaultMinimum = 0;
71 static const int rangeDefaultMaximum = 100;
72 static const int rangeDefaultStep = 1;
73 static const int rangeDefaultStepBase = 0;
74 static const int rangeStepScaleFactor = 1;
75
76 static Decimal ensureMaximum(const Decimal& proposedValue, const Decimal& minimum, const Decimal& fallbackValue)
77 {
78     return proposedValue >= minimum ? proposedValue : std::max(minimum, fallbackValue);
79 }
80
81 OwnPtr<InputType> RangeInputType::create(HTMLInputElement& element)
82 {
83     return adoptPtr(new RangeInputType(element));
84 }
85
86 RangeInputType::RangeInputType(HTMLInputElement& element)
87     : InputType(element)
88 #if ENABLE(DATALIST_ELEMENT)
89     , m_tickMarkValuesDirty(true)
90 #endif
91 {
92 }
93
94 void RangeInputType::attach()
95 {
96     observeFeatureIfVisible(FeatureObserver::InputTypeRange);
97 }
98
99 bool RangeInputType::isRangeControl() const
100 {
101     return true;
102 }
103
104 const AtomicString& RangeInputType::formControlType() const
105 {
106     return InputTypeNames::range();
107 }
108
109 double RangeInputType::valueAsDouble() const
110 {
111     return parseToDoubleForNumberType(element().value());
112 }
113
114 void RangeInputType::setValueAsDecimal(const Decimal& newValue, TextFieldEventBehavior eventBehavior, ExceptionCode&) const
115 {
116     element().setValue(serialize(newValue), eventBehavior);
117 }
118
119 bool RangeInputType::typeMismatchFor(const String& value) const
120 {
121     return !value.isEmpty() && !std::isfinite(parseToDoubleForNumberType(value));
122 }
123
124 bool RangeInputType::supportsRequired() const
125 {
126     return false;
127 }
128
129 StepRange RangeInputType::createStepRange(AnyStepHandling anyStepHandling) const
130 {
131     DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (rangeDefaultStep, rangeDefaultStepBase, rangeStepScaleFactor));
132
133     const Decimal minimum = parseToNumber(element().fastGetAttribute(minAttr), rangeDefaultMinimum);
134     const Decimal maximum = ensureMaximum(parseToNumber(element().fastGetAttribute(maxAttr), rangeDefaultMaximum), minimum, rangeDefaultMaximum);
135
136     const AtomicString& precisionValue = element().fastGetAttribute(precisionAttr);
137     if (!precisionValue.isNull()) {
138         const Decimal step = equalIgnoringCase(precisionValue, "float") ? Decimal::nan() : 1;
139         return StepRange(minimum, minimum, maximum, step, stepDescription);
140     }
141
142     const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element().fastGetAttribute(stepAttr));
143     return StepRange(minimum, minimum, maximum, step, stepDescription);
144 }
145
146 bool RangeInputType::isSteppable() const
147 {
148     return true;
149 }
150
151 void RangeInputType::handleMouseDownEvent(MouseEvent* event)
152 {
153     if (element().isDisabledOrReadOnly())
154         return;
155
156     Node* targetNode = event->target()->toNode();
157     if (event->button() != LeftButton || !targetNode)
158         return;
159     ASSERT(element().shadowRoot());
160     if (targetNode != &element() && !targetNode->isDescendantOf(element().userAgentShadowRoot()))
161         return;
162     SliderThumbElement* thumb = sliderThumbElementOf(element());
163     if (targetNode == thumb)
164         return;
165     thumb->dragFrom(event->absoluteLocation());
166 }
167
168 #if ENABLE(TOUCH_EVENTS)
169 #if ENABLE(TOUCH_SLIDER)
170 void RangeInputType::handleTouchEvent(TouchEvent* event)
171 {
172     if (element().isDisabledOrReadOnly())
173         return;
174
175     if (event->type() == eventNames().touchendEvent) {
176         event->setDefaultHandled();
177         return;
178     }
179
180     TouchList* touches = event->targetTouches();
181     if (touches->length() == 1) {
182         Touch* touch = touches->item(0);
183         SliderThumbElement* thumb = sliderThumbElementOf(element());
184         thumb->setPositionFromPoint(touch->absoluteLocation());
185         event->setDefaultHandled();
186     }
187 }
188
189 bool RangeInputType::hasTouchEventHandler() const
190 {
191     return true;
192 }
193 #endif
194 #endif
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 = equalIgnoringCase(element().fastGetAttribute(stepAttr), "any") ? (stepRange.maximum() - stepRange.minimum()) / 100 : stepRange.step();
212     const Decimal bigStep = 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         TextFieldEventBehavior eventBehavior = DispatchChangeEvent;
245         setValueAsDecimal(newValue, eventBehavior, IGNORE_EXCEPTION);
246
247         if (AXObjectCache* cache = element().document().existingAXObjectCache())
248             cache->postNotification(&element(), AXObjectCache::AXValueChanged);
249         element().dispatchFormControlChangeEvent();
250     }
251
252     event->setDefaultHandled();
253 }
254
255 void RangeInputType::createShadowSubtree()
256 {
257     ASSERT(element().shadowRoot());
258
259     Document& document = element().document();
260     RefPtr<HTMLDivElement> track = HTMLDivElement::create(document);
261     track->setPseudo(AtomicString("-webkit-slider-runnable-track", AtomicString::ConstructFromLiteral));
262     track->appendChild(SliderThumbElement::create(document), IGNORE_EXCEPTION);
263     RefPtr<HTMLElement> container = SliderContainerElement::create(document);
264     container->appendChild(track.release(), IGNORE_EXCEPTION);
265     element().userAgentShadowRoot()->appendChild(container.release(), IGNORE_EXCEPTION);
266 }
267
268 RenderElement* RangeInputType::createRenderer(RenderArena& arena, RenderStyle&) const
269 {
270     return new (arena) RenderSlider(&element());
271 }
272
273 Decimal RangeInputType::parseToNumber(const String& src, const Decimal& defaultValue) const
274 {
275     return parseToDecimalForNumberType(src, defaultValue);
276 }
277
278 String RangeInputType::serialize(const Decimal& value) const
279 {
280     if (!value.isFinite())
281         return String();
282     return serializeForNumberType(value);
283 }
284
285 // FIXME: Could share this with BaseClickableWithKeyInputType and BaseCheckableInputType if we had a common base class.
286 void RangeInputType::accessKeyAction(bool sendMouseEvents)
287 {
288     InputType::accessKeyAction(sendMouseEvents);
289
290     element().dispatchSimulatedClick(0, sendMouseEvents ? SendMouseUpDownEvents : SendNoEvents);
291 }
292
293 void RangeInputType::minOrMaxAttributeChanged()
294 {
295     InputType::minOrMaxAttributeChanged();
296
297     // Sanitize the value.
298     if (element().hasDirtyValue())
299         element().setValue(element().value());
300
301     sliderThumbElementOf(element())->setPositionFromValue();
302 }
303
304 void RangeInputType::setValue(const String& value, bool valueChanged, TextFieldEventBehavior eventBehavior)
305 {
306     InputType::setValue(value, valueChanged, eventBehavior);
307
308     if (!valueChanged)
309         return;
310
311     sliderThumbElementOf(element())->setPositionFromValue();
312 }
313
314 String RangeInputType::fallbackValue() const
315 {
316     return serializeForNumberType(createStepRange(RejectAny).defaultValue());
317 }
318
319 String RangeInputType::sanitizeValue(const String& proposedValue) const
320 {
321     StepRange stepRange(createStepRange(RejectAny));
322     const Decimal proposedNumericValue = parseToNumber(proposedValue, stepRange.defaultValue());
323     return serializeForNumberType(stepRange.clampValue(proposedNumericValue));
324 }
325
326 bool RangeInputType::shouldRespectListAttribute()
327 {
328     return InputType::themeSupportsDataListUI(this);
329 }
330
331 HTMLElement* RangeInputType::sliderThumbElement() const
332 {
333     return sliderThumbElementOf(element());
334 }
335
336 HTMLElement* RangeInputType::sliderTrackElement() const
337 {
338     return sliderTrackElementOf(element());
339 }
340
341 #if ENABLE(DATALIST_ELEMENT)
342 void RangeInputType::listAttributeTargetChanged()
343 {
344     m_tickMarkValuesDirty = true;
345     HTMLElement* sliderTrackElement = sliderTrackElementOf(element());
346     if (sliderTrackElement->renderer())
347         sliderTrackElement->renderer()->setNeedsLayout();
348 }
349
350 void RangeInputType::updateTickMarkValues()
351 {
352     if (!m_tickMarkValuesDirty)
353         return;
354     m_tickMarkValues.clear();
355     m_tickMarkValuesDirty = false;
356     HTMLDataListElement* dataList = element().dataList();
357     if (!dataList)
358         return;
359     RefPtr<HTMLCollection> options = dataList->options();
360     m_tickMarkValues.reserveCapacity(options->length());
361     for (unsigned i = 0; i < options->length(); ++i) {
362         Node* node = options->item(i);
363         HTMLOptionElement* optionElement = toHTMLOptionElement(node);
364         String optionValue = optionElement->value();
365         if (!element().isValidValue(optionValue))
366             continue;
367         m_tickMarkValues.append(parseToNumber(optionValue, Decimal::nan()));
368     }
369     m_tickMarkValues.shrinkToFit();
370     std::sort(m_tickMarkValues.begin(), m_tickMarkValues.end());
371 }
372
373 Decimal RangeInputType::findClosestTickMarkValue(const Decimal& value)
374 {
375     updateTickMarkValues();
376     if (!m_tickMarkValues.size())
377         return Decimal::nan();
378
379     size_t left = 0;
380     size_t right = m_tickMarkValues.size();
381     size_t middle;
382     while (true) {
383         ASSERT(left <= right);
384         middle = left + (right - left) / 2;
385         if (!middle)
386             break;
387         if (middle == m_tickMarkValues.size() - 1 && m_tickMarkValues[middle] < value) {
388             middle++;
389             break;
390         }
391         if (m_tickMarkValues[middle - 1] <= value && m_tickMarkValues[middle] >= value)
392             break;
393
394         if (m_tickMarkValues[middle] < value)
395             left = middle;
396         else
397             right = middle;
398     }
399     const Decimal closestLeft = middle ? m_tickMarkValues[middle - 1] : Decimal::infinity(Decimal::Negative);
400     const Decimal closestRight = middle != m_tickMarkValues.size() ? m_tickMarkValues[middle] : Decimal::infinity(Decimal::Positive);
401     if (closestRight - value < value - closestLeft)
402         return closestRight;
403     return closestLeft;
404 }
405 #endif
406
407 } // namespace WebCore