[Forms] Move numeric related methods in HTMLInputElement class to another place
[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 "ElementShadow.h"
37 #include "HTMLDivElement.h"
38 #include "HTMLInputElement.h"
39 #include "HTMLNames.h"
40 #include "HTMLParserIdioms.h"
41 #include "KeyboardEvent.h"
42 #include "MouseEvent.h"
43 #include "PlatformMouseEvent.h"
44 #include "RenderSlider.h"
45 #include "ShadowRoot.h"
46 #include "SliderThumbElement.h"
47 #include "StepRange.h"
48 #include <limits>
49 #include <wtf/MathExtras.h>
50 #include <wtf/PassOwnPtr.h>
51
52 namespace WebCore {
53
54 using namespace HTMLNames;
55 using namespace std;
56
57 static const double rangeDefaultMinimum = 0.0;
58 static const double rangeDefaultMaximum = 100.0;
59 static const double rangeDefaultStep = 1.0;
60 static const double rangeDefaultStepBase = 0.0;
61 static const double rangeStepScaleFactor = 1.0;
62
63 PassOwnPtr<InputType> RangeInputType::create(HTMLInputElement* element)
64 {
65     return adoptPtr(new RangeInputType(element));
66 }
67
68 bool RangeInputType::isRangeControl() const
69 {
70     return true;
71 }
72
73 const AtomicString& RangeInputType::formControlType() const
74 {
75     return InputTypeNames::range();
76 }
77
78 double RangeInputType::valueAsNumber() const
79 {
80     return parseToDouble(element()->value(), numeric_limits<double>::quiet_NaN());
81 }
82
83 void RangeInputType::setValueAsNumber(double newValue, TextFieldEventBehavior eventBehavior, ExceptionCode&) const
84 {
85     element()->setValue(serialize(newValue), eventBehavior);
86 }
87
88 bool RangeInputType::supportsRequired() const
89 {
90     return false;
91 }
92
93 StepRange RangeInputType::createStepRange(AnyStepHandling anyStepHandling) const
94 {
95     DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (rangeDefaultStep, rangeDefaultStepBase, rangeStepScaleFactor));
96
97     double minimum = parseToDouble(element()->fastGetAttribute(minAttr), rangeDefaultMinimum);
98     double maximum = parseToDouble(element()->fastGetAttribute(maxAttr), rangeDefaultMaximum);
99     if (maximum < minimum)
100         maximum = max(minimum, rangeDefaultMaximum);
101
102     const AtomicString& precisionValue = element()->fastGetAttribute(precisionAttr);
103     if (!precisionValue.isNull()) {
104         StepRange::DoubleWithDecimalPlacesOrMissing step(1, !equalIgnoringCase(precisionValue, "float"));
105         return StepRange(minimum, minimum, maximum, step, stepDescription);
106     }
107
108     StepRange::DoubleWithDecimalPlacesOrMissing step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
109     return StepRange(minimum, minimum, maximum, step, stepDescription);
110 }
111
112 bool RangeInputType::isSteppable() const
113 {
114     return true;
115 }
116
117 void RangeInputType::handleMouseDownEvent(MouseEvent* event)
118 {
119     if (element()->disabled() || element()->readOnly())
120         return;
121
122     Node* targetNode = event->target()->toNode();
123     if (event->button() != LeftButton || !targetNode)
124         return;
125     ASSERT(element()->shadow());
126     if (targetNode != element() && !targetNode->isDescendantOf(element()->shadow()->oldestShadowRoot()))
127         return;
128     SliderThumbElement* thumb = sliderThumbElementOf(element());
129     if (targetNode == thumb)
130         return;
131     thumb->dragFrom(event->absoluteLocation());
132 }
133
134 void RangeInputType::handleKeydownEvent(KeyboardEvent* event)
135 {
136     if (element()->disabled() || element()->readOnly())
137         return;
138
139     const String& key = event->keyIdentifier();
140
141     double current = parseToDouble(element()->value(), numeric_limits<double>::quiet_NaN());
142     ASSERT(isfinite(current));
143
144     StepRange stepRange(createStepRange(RejectAny));
145
146     double step, bigStep;
147     if (equalIgnoringCase(element()->fastGetAttribute(stepAttr), "any")) {
148         // FIXME: We can't use stepUp() for the step value "any". So, we increase
149         // or decrease the value by 1/100 of the value range. Is it reasonable?
150         step = (stepRange.maximum() - stepRange.minimum()) / 100;
151         bigStep = step * 10;
152     } else {
153         if (!element()->getAllowedValueStep(&step))
154             ASSERT_NOT_REACHED();
155
156         bigStep = (stepRange.maximum() - stepRange.minimum()) / 10;
157         if (bigStep < step)
158             bigStep = step;
159     }
160
161     bool isVertical = false;
162     if (element()->renderer()) {
163         ControlPart part = element()->renderer()->style()->appearance();
164         isVertical = part == SliderVerticalPart || part == MediaVolumeSliderPart;
165     }
166
167     double newValue;
168     if (key == "Up")
169         newValue = current + step;
170     else if (key == "Down")
171         newValue = current - step;
172     else if (key == "Left")
173         newValue = isVertical ? current + step : current - step;
174     else if (key == "Right")
175         newValue = isVertical ? current - step : current + step;
176     else if (key == "PageUp")
177         newValue = current + bigStep;
178     else if (key == "PageDown")
179         newValue = current - bigStep;
180     else if (key == "Home")
181         newValue = isVertical ? stepRange.maximum() : stepRange.minimum();
182     else if (key == "End")
183         newValue = isVertical ? stepRange.minimum() : stepRange.maximum();
184     else
185         return; // Did not match any key binding.
186
187     newValue = stepRange.clampValue(newValue);
188
189     if (newValue != current) {
190         ExceptionCode ec;
191         TextFieldEventBehavior eventBehavior = DispatchChangeEvent;
192         setValueAsNumber(newValue, eventBehavior, ec);
193
194         if (AXObjectCache::accessibilityEnabled())
195             element()->document()->axObjectCache()->postNotification(element()->renderer(), AXObjectCache::AXValueChanged, true);
196         element()->dispatchFormControlChangeEvent();
197     }
198
199     event->setDefaultHandled();
200 }
201
202 void RangeInputType::createShadowSubtree()
203 {
204     ASSERT(element()->shadow());
205
206     Document* document = element()->document();
207     RefPtr<HTMLDivElement> track = HTMLDivElement::create(document);
208     track->setShadowPseudoId("-webkit-slider-runnable-track");
209     ExceptionCode ec = 0;
210     track->appendChild(SliderThumbElement::create(document), ec);
211     RefPtr<HTMLElement> container = SliderContainerElement::create(document);
212     container->appendChild(track.release(), ec);
213     container->appendChild(TrackLimiterElement::create(document), ec);
214     element()->shadow()->oldestShadowRoot()->appendChild(container.release(), ec);
215 }
216
217 RenderObject* RangeInputType::createRenderer(RenderArena* arena, RenderStyle*) const
218 {
219     return new (arena) RenderSlider(element());
220 }
221
222 double RangeInputType::parseToDouble(const String& src, double defaultValue) const
223 {
224     double numberValue;
225     if (!parseToDoubleForNumberType(src, &numberValue))
226         return defaultValue;
227     ASSERT(isfinite(numberValue));
228     return numberValue;
229 }
230
231 String RangeInputType::serialize(double value) const
232 {
233     if (!isfinite(value))
234         return String();
235     return serializeForNumberType(value);
236 }
237
238 // FIXME: Could share this with BaseClickableWithKeyInputType and BaseCheckableInputType if we had a common base class.
239 void RangeInputType::accessKeyAction(bool sendMouseEvents)
240 {
241     InputType::accessKeyAction(sendMouseEvents);
242
243     // Send mouse button events if the caller specified sendMouseEvents.
244     // FIXME: The comment above is no good. It says what we do, but not why.
245     element()->dispatchSimulatedClick(0, sendMouseEvents);
246 }
247
248 void RangeInputType::minOrMaxAttributeChanged()
249 {
250     InputType::minOrMaxAttributeChanged();
251
252     // Sanitize the value.
253     if (element()->hasDirtyValue())
254         element()->setValue(element()->value());
255     element()->setNeedsStyleRecalc();
256 }
257
258 void RangeInputType::setValue(const String& value, bool valueChanged, TextFieldEventBehavior eventBehavior)
259 {
260     InputType::setValue(value, valueChanged, eventBehavior);
261
262     if (!valueChanged)
263         return;
264
265     sliderThumbElementOf(element())->setPositionFromValue();
266 }
267
268 String RangeInputType::fallbackValue() const
269 {
270     return serializeForNumberType(createStepRange(RejectAny).defaultValue());
271 }
272
273 String RangeInputType::sanitizeValue(const String& proposedValue) const
274 {
275     StepRange stepRange(createStepRange(RejectAny));
276     double proposedDoubleValue = parseToDouble(proposedValue, stepRange.defaultValue());
277     return serializeForNumberType(stepRange.clampValue(proposedDoubleValue));
278 }
279
280 bool RangeInputType::shouldRespectListAttribute()
281 {
282     return InputType::themeSupportsDataListUI(this);
283 }
284
285 } // namespace WebCore