src/third_party/WebKit/Source/core/html/forms/NumberInputType.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 "core/html/forms/NumberInputType.h"
  34
  35 #include "HTMLNames.h"
  36 #include "InputTypeNames.h"
  37 #include "bindings/v8/ExceptionState.h"
  38 #include "core/dom/ExceptionCode.h"
  39 #include "core/events/KeyboardEvent.h"
  40 #include "core/html/HTMLInputElement.h"
  41 #include "core/html/parser/HTMLParserIdioms.h"
  42 #include "core/rendering/RenderTextControl.h"
  43 #include "platform/text/PlatformLocale.h"
  44 #include "wtf/MathExtras.h"
  45 #include "wtf/PassOwnPtr.h"
  46 #include <limits>
  47
  48 namespace WebCore {
  49
  50 using blink::WebLocalizedString;
  51 using namespace HTMLNames;
  52 using namespace std;
  53
  54 static const int numberDefaultStep = 1;
  55 static const int numberDefaultStepBase = 0;
  56 static const int numberStepScaleFactor = 1;
  57
  58 struct RealNumberRenderSize {
  59     unsigned sizeBeforeDecimalPoint;
  60     unsigned sizeAfteDecimalPoint;
  61
  62     RealNumberRenderSize(unsigned before, unsigned after)
  63         : sizeBeforeDecimalPoint(before)
  64         , sizeAfteDecimalPoint(after)
  65     {
  66     }
  67
  68     RealNumberRenderSize max(const RealNumberRenderSize& other) const
  69     {
  70         return RealNumberRenderSize(
  71             std::max(sizeBeforeDecimalPoint, other.sizeBeforeDecimalPoint),
  72             std::max(sizeAfteDecimalPoint, other.sizeAfteDecimalPoint));
  73     }
  74 };
  75
  76 static RealNumberRenderSize calculateRenderSize(const Decimal& value)
  77 {
  78     ASSERT(value.isFinite());
  79     const unsigned sizeOfDigits = String::number(value.value().coefficient()).length();
  80     const unsigned sizeOfSign = value.isNegative() ? 1 : 0;
  81     const int exponent = value.exponent();
  82     if (exponent >= 0)
  83         return RealNumberRenderSize(sizeOfSign + sizeOfDigits, 0);
  84
  85     const int sizeBeforeDecimalPoint = exponent + sizeOfDigits;
  86     if (sizeBeforeDecimalPoint > 0) {
  87         // In case of "123.456"
  88         return RealNumberRenderSize(sizeOfSign + sizeBeforeDecimalPoint, sizeOfDigits - sizeBeforeDecimalPoint);
  89     }
  90
  91     // In case of "0.00012345"
  92     const unsigned sizeOfZero = 1;
  93     const unsigned numberOfZeroAfterDecimalPoint = -sizeBeforeDecimalPoint;
  94     return RealNumberRenderSize(sizeOfSign + sizeOfZero , numberOfZeroAfterDecimalPoint + sizeOfDigits);
  95 }
  96
  97 PassRefPtr<InputType> NumberInputType::create(HTMLInputElement& element)
  98 {
  99     return adoptRef(new NumberInputType(element));
 100 }
 101
 102 void NumberInputType::countUsage()
 103 {
 104     countUsageIfVisible(UseCounter::InputTypeNumber);
 105 }
 106
 107 const AtomicString& NumberInputType::formControlType() const
 108 {
 109     return InputTypeNames::number;
 110 }
 111
 112 void NumberInputType::setValue(const String& sanitizedValue, bool valueChanged, TextFieldEventBehavior eventBehavior)
 113 {
 114     if (!valueChanged && sanitizedValue.isEmpty() && !element().innerTextValue().isEmpty())
 115         element().updateView();
 116     TextFieldInputType::setValue(sanitizedValue, valueChanged, eventBehavior);
 117 }
 118
 119 double NumberInputType::valueAsDouble() const
 120 {
 121     return parseToDoubleForNumberType(element().value());
 122 }
 123
 124 void NumberInputType::setValueAsDouble(double newValue, TextFieldEventBehavior eventBehavior, ExceptionState& exceptionState) const
 125 {
 126     // FIXME: We should use numeric_limits<double>::max for number input type.
 127     // (NOTE: the range check will not be true for NaN.)
 128     const double floatMax = numeric_limits<float>::max();
 129     if (newValue < -floatMax || newValue > floatMax) {
 130         exceptionState.throwDOMException(InvalidStateError, "The value provided (" + String::number(newValue) + ") is outside the range (" + String::number(-floatMax) + ", " + String::number(floatMax) + ").");
 131         return;
 132     }
 133     element().setValue(serializeForNumberType(newValue), eventBehavior);
 134 }
 135
 136 void NumberInputType::setValueAsDecimal(const Decimal& newValue, TextFieldEventBehavior eventBehavior, ExceptionState& exceptionState) const
 137 {
 138     // FIXME: We should use numeric_limits<double>::max for number input type.
 139     const Decimal floatMax = Decimal::fromDouble(numeric_limits<float>::max());
 140     if (newValue < -floatMax || newValue > floatMax) {
 141         exceptionState.throwDOMException(InvalidStateError, "The value provided (" + newValue.toString() + ") is outside the range (-" + floatMax.toString() + ", " + floatMax.toString() + ").");
 142         return;
 143     }
 144     element().setValue(serializeForNumberType(newValue), eventBehavior);
 145 }
 146
 147 bool NumberInputType::typeMismatchFor(const String& value) const
 148 {
 149     return !value.isEmpty() && !std::isfinite(parseToDoubleForNumberType(value));
 150 }
 151
 152 bool NumberInputType::typeMismatch() const
 153 {
 154     ASSERT(!typeMismatchFor(element().value()));
 155     return false;
 156 }
 157
 158 StepRange NumberInputType::createStepRange(AnyStepHandling anyStepHandling) const
 159 {
 160     DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (numberDefaultStep, numberDefaultStepBase, numberStepScaleFactor));
 161
 162     // FIXME: We should use numeric_limits<double>::max for number input type.
 163     const Decimal floatMax = Decimal::fromDouble(numeric_limits<float>::max());
 164     return InputType::createStepRange(anyStepHandling, numberDefaultStepBase, -floatMax, floatMax, stepDescription);
 165 }
 166
 167 bool NumberInputType::sizeShouldIncludeDecoration(int defaultSize, int& preferredSize) const
 168 {
 169     preferredSize = defaultSize;
 170
 171     const String stepString = element().fastGetAttribute(stepAttr);
 172     if (equalIgnoringCase(stepString, "any"))
 173         return false;
 174
 175     const Decimal minimum = parseToDecimalForNumberType(element().fastGetAttribute(minAttr));
 176     if (!minimum.isFinite())
 177         return false;
 178
 179     const Decimal maximum = parseToDecimalForNumberType(element().fastGetAttribute(maxAttr));
 180     if (!maximum.isFinite())
 181         return false;
 182
 183     const Decimal step = parseToDecimalForNumberType(stepString, 1);
 184     ASSERT(step.isFinite());
 185
 186     RealNumberRenderSize size = calculateRenderSize(minimum).max(calculateRenderSize(maximum).max(calculateRenderSize(step)));
 187
 188     preferredSize = size.sizeBeforeDecimalPoint + size.sizeAfteDecimalPoint + (size.sizeAfteDecimalPoint ? 1 : 0);
 189
 190     return true;
 191 }
 192
 193 bool NumberInputType::isSteppable() const
 194 {
 195     return true;
 196 }
 197
 198 void NumberInputType::handleKeydownEvent(KeyboardEvent* event)
 199 {
 200     handleKeydownEventForSpinButton(event);
 201     if (!event->defaultHandled())
 202         TextFieldInputType::handleKeydownEvent(event);
 203 }
 204
 205 Decimal NumberInputType::parseToNumber(const String& src, const Decimal& defaultValue) const
 206 {
 207     return parseToDecimalForNumberType(src, defaultValue);
 208 }
 209
 210 String NumberInputType::serialize(const Decimal& value) const
 211 {
 212     if (!value.isFinite())
 213         return String();
 214     return serializeForNumberType(value);
 215 }
 216
 217 static bool isE(UChar ch)
 218 {
 219     return ch == 'e' || ch == 'E';
 220 }
 221
 222 String NumberInputType::localizeValue(const String& proposedValue) const
 223 {
 224     if (proposedValue.isEmpty())
 225         return proposedValue;
 226     // We don't localize scientific notations.
 227     if (proposedValue.find(isE) != kNotFound)
 228         return proposedValue;
 229     return element().locale().convertToLocalizedNumber(proposedValue);
 230 }
 231
 232 String NumberInputType::visibleValue() const
 233 {
 234     return localizeValue(element().value());
 235 }
 236
 237 String NumberInputType::convertFromVisibleValue(const String& visibleValue) const
 238 {
 239     if (visibleValue.isEmpty())
 240         return visibleValue;
 241     // We don't localize scientific notations.
 242     if (visibleValue.find(isE) != kNotFound)
 243         return visibleValue;
 244     return element().locale().convertFromLocalizedNumber(visibleValue);
 245 }
 246
 247 String NumberInputType::sanitizeValue(const String& proposedValue) const
 248 {
 249     if (proposedValue.isEmpty())
 250         return proposedValue;
 251     return std::isfinite(parseToDoubleForNumberType(proposedValue)) ? proposedValue : emptyString();
 252 }
 253
 254 bool NumberInputType::hasBadInput() const
 255 {
 256     String standardValue = convertFromVisibleValue(element().innerTextValue());
 257     return !standardValue.isEmpty() && !std::isfinite(parseToDoubleForNumberType(standardValue));
 258 }
 259
 260 String NumberInputType::badInputText() const
 261 {
 262     return locale().queryString(WebLocalizedString::ValidationBadInputForNumber);
 263 }
 264
 265 String NumberInputType::rangeOverflowText(const Decimal& maximum) const
 266 {
 267     return locale().queryString(WebLocalizedString::ValidationRangeOverflow, localizeValue(serialize(maximum)));
 268 }
 269
 270 String NumberInputType::rangeUnderflowText(const Decimal& minimum) const
 271 {
 272     return locale().queryString(WebLocalizedString::ValidationRangeUnderflow, localizeValue(serialize(minimum)));
 273 }
 274
 275 bool NumberInputType::shouldRespectSpeechAttribute()
 276 {
 277     return true;
 278 }
 279
 280 bool NumberInputType::supportsPlaceholder() const
 281 {
 282     return true;
 283 }
 284
 285 bool NumberInputType::isNumberField() const
 286 {
 287     return true;
 288 }
 289
 290 void NumberInputType::minOrMaxAttributeChanged()
 291 {
 292     InputType::minOrMaxAttributeChanged();
 293
 294     if (element().renderer())
 295         element().renderer()->setNeedsLayoutAndPrefWidthsRecalc();
 296 }
 297
 298 void NumberInputType::stepAttributeChanged()
 299 {
 300     InputType::stepAttributeChanged();
 301
 302     if (element().renderer())
 303         element().renderer()->setNeedsLayoutAndPrefWidthsRecalc();
 304 }
 305
 306 bool NumberInputType::supportsSelectionAPI() const
 307 {
 308     return false;
 309 }
 310
 311 } // namespace WebCore