src/third_party/WebKit/Source/core/html/forms/StepRange.cpp

   1 /*
   2  * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public License
  15  * along with this library; see the file COPYING.LIB.  If not, write to
  16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  *
  19  */
  20
  21 #include "config.h"
  22 #include "core/html/forms/StepRange.h"
  23
  24 #include "core/HTMLNames.h"
  25 #include "core/html/parser/HTMLParserIdioms.h"
  26 #include "wtf/MathExtras.h"
  27 #include "wtf/text/WTFString.h"
  28 #include <float.h>
  29
  30 namespace blink {
  31
  32 using namespace HTMLNames;
  33
  34 StepRange::StepRange()
  35     : m_maximum(100)
  36     , m_minimum(0)
  37     , m_step(1)
  38     , m_stepBase(0)
  39     , m_hasStep(false)
  40 {
  41 }
  42
  43 StepRange::StepRange(const StepRange& stepRange)
  44     : m_maximum(stepRange.m_maximum)
  45     , m_minimum(stepRange.m_minimum)
  46     , m_step(stepRange.m_step)
  47     , m_stepBase(stepRange.m_stepBase)
  48     , m_stepDescription(stepRange.m_stepDescription)
  49     , m_hasStep(stepRange.m_hasStep)
  50 {
  51 }
  52
  53 StepRange::StepRange(const Decimal& stepBase, const Decimal& minimum, const Decimal& maximum, const Decimal& step, const StepDescription& stepDescription)
  54     : m_maximum(maximum)
  55     , m_minimum(minimum)
  56     , m_step(step.isFinite() ? step : 1)
  57     , m_stepBase(stepBase.isFinite() ? stepBase : 1)
  58     , m_stepDescription(stepDescription)
  59     , m_hasStep(step.isFinite())
  60 {
  61     ASSERT(m_maximum.isFinite());
  62     ASSERT(m_minimum.isFinite());
  63     ASSERT(m_step.isFinite());
  64     ASSERT(m_stepBase.isFinite());
  65 }
  66
  67 Decimal StepRange::acceptableError() const
  68 {
  69     // FIXME: We should use DBL_MANT_DIG instead of FLT_MANT_DIG regarding to HTML5 specification.
  70     DEFINE_STATIC_LOCAL(const Decimal, twoPowerOfFloatMantissaBits, (Decimal::Positive, 0, UINT64_C(1) << FLT_MANT_DIG));
  71     return m_stepDescription.stepValueShouldBe == StepValueShouldBeReal ? m_step / twoPowerOfFloatMantissaBits : Decimal(0);
  72 }
  73
  74 Decimal StepRange::alignValueForStep(const Decimal& currentValue, const Decimal& newValue) const
  75 {
  76     DEFINE_STATIC_LOCAL(const Decimal, tenPowerOf21, (Decimal::Positive, 21, 1));
  77     if (newValue >= tenPowerOf21)
  78         return newValue;
  79
  80     return stepMismatch(currentValue) ? newValue : roundByStep(newValue, m_stepBase);
  81 }
  82
  83 Decimal StepRange::clampValue(const Decimal& value) const
  84 {
  85     const Decimal inRangeValue = std::max(m_minimum, std::min(value, m_maximum));
  86     if (!m_hasStep)
  87         return inRangeValue;
  88     // Rounds inRangeValue to stepBase + N * step.
  89     const Decimal roundedValue = roundByStep(inRangeValue, m_stepBase);
  90     const Decimal clampedValue = roundedValue > m_maximum ? roundedValue - m_step : (roundedValue < m_minimum ? roundedValue + m_step : roundedValue);
  91     ASSERT(clampedValue >= m_minimum);
  92     ASSERT(clampedValue <= m_maximum);
  93     return clampedValue;
  94 }
  95
  96 Decimal StepRange::parseStep(AnyStepHandling anyStepHandling, const StepDescription& stepDescription, const String& stepString)
  97 {
  98     if (stepString.isEmpty())
  99         return stepDescription.defaultValue();
 100
 101     if (equalIgnoringCase(stepString, "any")) {
 102         switch (anyStepHandling) {
 103         case RejectAny:
 104             return Decimal::nan();
 105         case AnyIsDefaultStep:
 106             return stepDescription.defaultValue();
 107         default:
 108             ASSERT_NOT_REACHED();
 109         }
 110     }
 111
 112     Decimal step = parseToDecimalForNumberType(stepString);
 113     if (!step.isFinite() || step <= 0)
 114         return stepDescription.defaultValue();
 115
 116     switch (stepDescription.stepValueShouldBe) {
 117     case StepValueShouldBeReal:
 118         step *= stepDescription.stepScaleFactor;
 119         break;
 120     case ParsedStepValueShouldBeInteger:
 121         // For date, month, and week, the parsed value should be an integer for some types.
 122         step = std::max(step.round(), Decimal(1));
 123         step *= stepDescription.stepScaleFactor;
 124         break;
 125     case ScaledStepValueShouldBeInteger:
 126         // For datetime, datetime-local, time, the result should be an integer.
 127         step *= stepDescription.stepScaleFactor;
 128         step = std::max(step.round(), Decimal(1));
 129         break;
 130     default:
 131         ASSERT_NOT_REACHED();
 132     }
 133
 134     ASSERT(step > 0);
 135     return step;
 136 }
 137
 138 Decimal StepRange::roundByStep(const Decimal& value, const Decimal& base) const
 139 {
 140     return base + ((value - base) / m_step).round() * m_step;
 141 }
 142
 143 bool StepRange::stepMismatch(const Decimal& valueForCheck) const
 144 {
 145     if (!m_hasStep)
 146         return false;
 147     if (!valueForCheck.isFinite())
 148         return false;
 149     const Decimal value = (valueForCheck - m_stepBase).abs();
 150     if (!value.isFinite())
 151         return false;
 152     // Decimal's fractional part size is DBL_MAN_DIG-bit. If the current value
 153     // is greater than step*2^DBL_MANT_DIG, the following computation for
 154     // remainder makes no sense.
 155     DEFINE_STATIC_LOCAL(const Decimal, twoPowerOfDoubleMantissaBits, (Decimal::Positive, 0, UINT64_C(1) << DBL_MANT_DIG));
 156     if (value / twoPowerOfDoubleMantissaBits > m_step)
 157         return false;
 158     // The computation follows HTML5 4.10.7.2.10 `The step attribute' :
 159     // ... that number subtracted from the step base is not an integral multiple
 160     // of the allowed value step, the element is suffering from a step mismatch.
 161     const Decimal remainder = (value - m_step * (value / m_step).round()).abs();
 162     // Accepts errors in lower fractional part which IEEE 754 single-precision
 163     // can't represent.
 164     const Decimal computedAcceptableError = acceptableError();
 165     return computedAcceptableError < remainder && remainder < (m_step - computedAcceptableError);
 166 }
 167
 168 } // namespace blink