5d71da7878717c6bfd3e38ea14bc23f3970b5c29
[WebKit.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 "HTMLInputElement.h"
36 #include "HTMLNames.h"
37 #include "HTMLParserIdioms.h"
38 #include "KeyboardEvent.h"
39 #include "RenderSlider.h"
40 #include "StepRange.h"
41 #include <limits>
42 #include <wtf/MathExtras.h>
43 #include <wtf/PassOwnPtr.h>
44
45 namespace WebCore {
46
47 using namespace HTMLNames;
48 using namespace std;
49
50 static const double rangeDefaultMinimum = 0.0;
51 static const double rangeDefaultMaximum = 100.0;
52 static const double rangeDefaultStep = 1.0;
53 static const double rangeStepScaleFactor = 1.0;
54
55 PassOwnPtr<InputType> RangeInputType::create(HTMLInputElement* element)
56 {
57     return adoptPtr(new RangeInputType(element));
58 }
59
60 bool RangeInputType::isRangeControl() const
61 {
62     return true;
63 }
64
65 const AtomicString& RangeInputType::formControlType() const
66 {
67     return InputTypeNames::range();
68 }
69
70 double RangeInputType::valueAsNumber() const
71 {
72     return parseToDouble(element()->value(), numeric_limits<double>::quiet_NaN());
73 }
74
75 void RangeInputType::setValueAsNumber(double newValue, ExceptionCode&) const
76 {
77     element()->setValue(serialize(newValue));
78 }
79
80 bool RangeInputType::supportsRequired() const
81 {
82     return false;
83 }
84
85 bool RangeInputType::rangeUnderflow(const String& value) const
86 {
87     // Guaranteed by sanitization.
88     ASSERT_UNUSED(value, parseToDouble(value, numeric_limits<double>::quiet_NaN()) >= minimum());
89     return false;
90 }
91
92 bool RangeInputType::rangeOverflow(const String& value) const
93 {
94     // Guaranteed by sanitization.
95     ASSERT_UNUSED(value, parseToDouble(value, numeric_limits<double>::quiet_NaN()) <= maximum());
96     return false;
97 }
98
99 bool RangeInputType::supportsRangeLimitation() const
100 {
101     return true;
102 }
103
104 double RangeInputType::minimum() const
105 {
106     return parseToDouble(element()->fastGetAttribute(minAttr), rangeDefaultMinimum);
107 }
108
109 double RangeInputType::maximum() const
110 {
111     double max = parseToDouble(element()->fastGetAttribute(maxAttr), rangeDefaultMaximum);
112     // A remedy for the inconsistent min/max values.
113     // Sets the maximum to the default or the minimum value.
114     double min = minimum();
115     if (max < min)
116         max = std::max(min, rangeDefaultMaximum);
117     return max;
118 }
119
120 bool RangeInputType::stepMismatch(const String&, double) const
121 {
122     // stepMismatch doesn't occur for type=range. RenderSlider guarantees the
123     // value matches to step on user input, and sanitization takes care
124     // of the general case.
125     return false;
126 }
127
128 double RangeInputType::stepBase() const
129 {
130     return minimum();
131 }
132
133 double RangeInputType::defaultStep() const
134 {
135     return rangeDefaultStep;
136 }
137
138 double RangeInputType::stepScaleFactor() const
139 {
140     return rangeStepScaleFactor;
141 }
142
143 void RangeInputType::handleKeydownEvent(KeyboardEvent* event)
144 {
145     const String& key = event->keyIdentifier();
146     if (key != "Up" && key != "Right" && key != "Down" && key != "Left")
147         return;
148
149     ExceptionCode ec;
150     if (equalIgnoringCase(element()->fastGetAttribute(stepAttr), "any")) {
151         double min = minimum();
152         double max = maximum();
153         // FIXME: We can't use stepUp() for the step value "any". So, we increase
154         // or decrease the value by 1/100 of the value range. Is it reasonable?
155         double step = (max - min) / 100;
156         double current = parseToDouble(element()->value(), numeric_limits<double>::quiet_NaN());
157         ASSERT(isfinite(current));
158         // Stepping-up and -down for step="any" are special cases for type="range" from renderer for convenient.
159         // No stepping normally for step="any". They cannot be handled by stepUp()/stepDown()/stepUpFromRenderer().
160         // So calculating values stepped-up or -down here.
161         double newValue;
162         if (key == "Up" || key == "Right") {
163             newValue = current + step;
164             if (newValue > max)
165                 newValue = max;
166         } else {
167             newValue = current - step;
168             if (newValue < min)
169                 newValue = min;
170         }
171         if (newValue != current) {
172             setValueAsNumber(newValue, ec);
173             element()->dispatchFormControlChangeEvent();
174         }
175     } else {
176         int stepMagnification = (key == "Up" || key == "Right") ? 1 : -1;
177         // Reasonable stepping-up/-down by stepUpFromRenderer() unless step="any"
178         element()->stepUpFromRenderer(stepMagnification);
179     }
180     event->setDefaultHandled();
181 }
182
183 void RangeInputType::forwardEvent(Event* event)
184 {
185     if (element()->renderer() && (event->isMouseEvent() || event->isDragEvent() || event->isWheelEvent()))
186         toRenderSlider(element()->renderer())->forwardEvent(event);
187 }
188
189 RenderObject* RangeInputType::createRenderer(RenderArena* arena, RenderStyle*) const
190 {
191     return new (arena) RenderSlider(element());
192 }
193
194 double RangeInputType::parseToDouble(const String& src, double defaultValue) const
195 {
196     double numberValue;
197     if (!parseToDoubleForNumberType(src, &numberValue))
198         return defaultValue;
199     ASSERT(isfinite(numberValue));
200     return numberValue;
201 }
202
203 String RangeInputType::serialize(double value) const
204 {
205     if (!isfinite(value))
206         return String();
207     return serializeForNumberType(value);
208 }
209
210 // FIXME: Could share this with BaseButtonInputType and BaseCheckableInputType if we had a common base class.
211 void RangeInputType::accessKeyAction(bool sendToAnyElement)
212 {
213     InputType::accessKeyAction(sendToAnyElement);
214
215     // Send mouse button events if the caller specified sendToAnyElement.
216     // FIXME: The comment above is no good. It says what we do, but not why.
217     element()->dispatchSimulatedClick(0, sendToAnyElement);
218 }
219
220 void RangeInputType::minOrMaxAttributeChanged()
221 {
222     InputType::minOrMaxAttributeChanged();
223
224     // Sanitize the value.
225     element()->setValue(element()->value());
226     element()->setNeedsStyleRecalc();
227 }
228
229 String RangeInputType::fallbackValue()
230 {
231     return serializeForNumberType(StepRange(element()).defaultValue());
232 }
233
234 String RangeInputType::sanitizeValue(const String& proposedValue)
235 {
236     // If the proposedValue is null than this is a reset scenario and we
237     // want the range input's value attribute to take priority over the
238     // calculated default (middle) value.
239     if (proposedValue.isNull())
240         return proposedValue;
241
242     return serializeForNumberType(StepRange(element()).clampValue(proposedValue));
243 }
244
245 bool RangeInputType::shouldRespectListAttribute()
246 {
247     return true;
248 }
249
250 } // namespace WebCore