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 PassRefPtrWillBeRawPtr<InputType> NumberInputType::create(HTMLInputElement& element)
  98 {
  99     return adoptRefWillBeNoop(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     element().setValue(serializeForNumberType(newValue), eventBehavior);
 127 }
 128
 129 void NumberInputType::setValueAsDecimal(const Decimal& newValue, TextFieldEventBehavior eventBehavior, ExceptionState& exceptionState) const
 130 {
 131     element().setValue(serializeForNumberType(newValue), eventBehavior);
 132 }
 133
 134 bool NumberInputType::typeMismatchFor(const String& value) const
 135 {
 136     return !value.isEmpty() && !std::isfinite(parseToDoubleForNumberType(value));
 137 }
 138
 139 bool NumberInputType::typeMismatch() const
 140 {
 141     ASSERT(!typeMismatchFor(element().value()));
 142     return false;
 143 }
 144
 145 StepRange NumberInputType::createStepRange(AnyStepHandling anyStepHandling) const
 146 {
 147     DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (numberDefaultStep, numberDefaultStepBase, numberStepScaleFactor));
 148     const Decimal doubleMax = Decimal::fromDouble(numeric_limits<double>::max());
 149     return InputType::createStepRange(anyStepHandling, numberDefaultStepBase, -doubleMax, doubleMax, stepDescription);
 150 }
 151
 152 bool NumberInputType::sizeShouldIncludeDecoration(int defaultSize, int& preferredSize) const
 153 {
 154     preferredSize = defaultSize;
 155
 156     const String stepString = element().fastGetAttribute(stepAttr);
 157     if (equalIgnoringCase(stepString, "any"))
 158         return false;
 159
 160     const Decimal minimum = parseToDecimalForNumberType(element().fastGetAttribute(minAttr));
 161     if (!minimum.isFinite())
 162         return false;
 163
 164     const Decimal maximum = parseToDecimalForNumberType(element().fastGetAttribute(maxAttr));
 165     if (!maximum.isFinite())
 166         return false;
 167
 168     const Decimal step = parseToDecimalForNumberType(stepString, 1);
 169     ASSERT(step.isFinite());
 170
 171     RealNumberRenderSize size = calculateRenderSize(minimum).max(calculateRenderSize(maximum).max(calculateRenderSize(step)));
 172
 173     preferredSize = size.sizeBeforeDecimalPoint + size.sizeAfteDecimalPoint + (size.sizeAfteDecimalPoint ? 1 : 0);
 174
 175     return true;
 176 }
 177
 178 bool NumberInputType::isSteppable() const
 179 {
 180     return true;
 181 }
 182
 183 void NumberInputType::handleKeydownEvent(KeyboardEvent* event)
 184 {
 185     handleKeydownEventForSpinButton(event);
 186     if (!event->defaultHandled())
 187         TextFieldInputType::handleKeydownEvent(event);
 188 }
 189
 190 Decimal NumberInputType::parseToNumber(const String& src, const Decimal& defaultValue) const
 191 {
 192     return parseToDecimalForNumberType(src, defaultValue);
 193 }
 194
 195 String NumberInputType::serialize(const Decimal& value) const
 196 {
 197     if (!value.isFinite())
 198         return String();
 199     return serializeForNumberType(value);
 200 }
 201
 202 static bool isE(UChar ch)
 203 {
 204     return ch == 'e' || ch == 'E';
 205 }
 206
 207 String NumberInputType::localizeValue(const String& proposedValue) const
 208 {
 209     if (proposedValue.isEmpty())
 210         return proposedValue;
 211     // We don't localize scientific notations.
 212     if (proposedValue.find(isE) != kNotFound)
 213         return proposedValue;
 214     return element().locale().convertToLocalizedNumber(proposedValue);
 215 }
 216
 217 String NumberInputType::visibleValue() const
 218 {
 219     return localizeValue(element().value());
 220 }
 221
 222 String NumberInputType::convertFromVisibleValue(const String& visibleValue) const
 223 {
 224     if (visibleValue.isEmpty())
 225         return visibleValue;
 226     // We don't localize scientific notations.
 227     if (visibleValue.find(isE) != kNotFound)
 228         return visibleValue;
 229     return element().locale().convertFromLocalizedNumber(visibleValue);
 230 }
 231
 232 String NumberInputType::sanitizeValue(const String& proposedValue) const
 233 {
 234     if (proposedValue.isEmpty())
 235         return proposedValue;
 236     return std::isfinite(parseToDoubleForNumberType(proposedValue)) ? proposedValue : emptyString();
 237 }
 238
 239 bool NumberInputType::hasBadInput() const
 240 {
 241     String standardValue = convertFromVisibleValue(element().innerTextValue());
 242     return !standardValue.isEmpty() && !std::isfinite(parseToDoubleForNumberType(standardValue));
 243 }
 244
 245 String NumberInputType::badInputText() const
 246 {
 247     return locale().queryString(WebLocalizedString::ValidationBadInputForNumber);
 248 }
 249
 250 String NumberInputType::rangeOverflowText(const Decimal& maximum) const
 251 {
 252     return locale().queryString(WebLocalizedString::ValidationRangeOverflow, localizeValue(serialize(maximum)));
 253 }
 254
 255 String NumberInputType::rangeUnderflowText(const Decimal& minimum) const
 256 {
 257     return locale().queryString(WebLocalizedString::ValidationRangeUnderflow, localizeValue(serialize(minimum)));
 258 }
 259
 260 bool NumberInputType::shouldRespectSpeechAttribute()
 261 {
 262     return true;
 263 }
 264
 265 bool NumberInputType::supportsPlaceholder() const
 266 {
 267     return true;
 268 }
 269
 270 bool NumberInputType::isNumberField() const
 271 {
 272     return true;
 273 }
 274
 275 void NumberInputType::minOrMaxAttributeChanged()
 276 {
 277     InputType::minOrMaxAttributeChanged();
 278
 279     if (element().renderer())
 280         element().renderer()->setNeedsLayoutAndPrefWidthsRecalc();
 281 }
 282
 283 void NumberInputType::stepAttributeChanged()
 284 {
 285     InputType::stepAttributeChanged();
 286
 287     if (element().renderer())
 288         element().renderer()->setNeedsLayoutAndPrefWidthsRecalc();
 289 }
 290
 291 bool NumberInputType::supportsSelectionAPI() const
 292 {
 293     return false;
 294 }
 295
 296 } // namespace WebCore