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 "ElementChildIterator.h"
  37 #include "EventNames.h"
  38 #include "HTMLInputElement.h"
  39 #include "HTMLParserIdioms.h"
  40 #include "InputTypeNames.h"
  41 #include "KeyboardEvent.h"
  42 #include "MouseEvent.h"
  43 #include "PlatformMouseEvent.h"
  44 #include "RenderSlider.h"
  45 #include "ScopedEventQueue.h"
  46 #include "ShadowRoot.h"
  47 #include "SliderThumbElement.h"
  48 #include <limits>
  49 #include <wtf/MathExtras.h>
  50 #include <wtf/NeverDestroyed.h>
  51
  52 #if ENABLE(TOUCH_EVENTS)
  53 #include "Touch.h"
  54 #include "TouchEvent.h"
  55 #include "TouchList.h"
  56 #endif
  57
  58 #if ENABLE(DATALIST_ELEMENT)
  59 #include "HTMLDataListElement.h"
  60 #include "HTMLOptionElement.h"
  61 #endif
  62
  63 namespace WebCore {
  64
  65 using namespace HTMLNames;
  66
  67 static const int rangeDefaultMinimum = 0;
  68 static const int rangeDefaultMaximum = 100;
  69 static const int rangeDefaultStep = 1;
  70 static const int rangeDefaultStepBase = 0;
  71 static const int rangeStepScaleFactor = 1;
  72
  73 static Decimal ensureMaximum(const Decimal& proposedValue, const Decimal& minimum, const Decimal& fallbackValue)
  74 {
  75     return proposedValue >= minimum ? proposedValue : std::max(minimum, fallbackValue);
  76 }
  77
  78 RangeInputType::RangeInputType(HTMLInputElement& element)
  79     : InputType(element)
  80 {
  81 }
  82
  83 bool RangeInputType::isRangeControl() const
  84 {
  85     return true;
  86 }
  87
  88 const AtomicString& RangeInputType::formControlType() const
  89 {
  90     return InputTypeNames::range();
  91 }
  92
  93 double RangeInputType::valueAsDouble() const
  94 {
  95     return parseToDoubleForNumberType(element().value());
  96 }
  97
  98 ExceptionOr<void> RangeInputType::setValueAsDecimal(const Decimal& newValue, TextFieldEventBehavior eventBehavior) const
  99 {
 100     element().setValue(serialize(newValue), eventBehavior);
 101     return { };
 102 }
 103
 104 bool RangeInputType::typeMismatchFor(const String& value) const
 105 {
 106     return !value.isEmpty() && !std::isfinite(parseToDoubleForNumberType(value));
 107 }
 108
 109 bool RangeInputType::supportsRequired() const
 110 {
 111     return false;
 112 }
 113
 114 StepRange RangeInputType::createStepRange(AnyStepHandling anyStepHandling) const
 115 {
 116     static NeverDestroyed<const StepRange::StepDescription> stepDescription(rangeDefaultStep, rangeDefaultStepBase, rangeStepScaleFactor);
 117
 118     const Decimal minimum = parseToNumber(element().attributeWithoutSynchronization(minAttr), rangeDefaultMinimum);
 119     const Decimal maximum = ensureMaximum(parseToNumber(element().attributeWithoutSynchronization(maxAttr), rangeDefaultMaximum), minimum, rangeDefaultMaximum);
 120
 121     const AtomicString& precisionValue = element().attributeWithoutSynchronization(precisionAttr);
 122     if (!precisionValue.isNull()) {
 123         const Decimal step = equalLettersIgnoringASCIICase(precisionValue, "float") ? Decimal::nan() : 1;
 124         return StepRange(minimum, RangeLimitations::Valid, minimum, maximum, step, stepDescription);
 125     }
 126
 127     const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element().attributeWithoutSynchronization(stepAttr));
 128     return StepRange(minimum, RangeLimitations::Valid, minimum, maximum, step, stepDescription);
 129 }
 130
 131 bool RangeInputType::isSteppable() const
 132 {
 133     return true;
 134 }
 135
 136 #if !PLATFORM(IOS)
 137 void RangeInputType::handleMouseDownEvent(MouseEvent& event)
 138 {
 139     if (element().isDisabledFormControl())
 140         return;
 141
 142     Node* targetNode = event.target()->toNode();
 143     if (event.button() != LeftButton || !targetNode)
 144         return;
 145     ASSERT(element().shadowRoot());
 146     if (targetNode != &element() && !targetNode->isDescendantOf(element().userAgentShadowRoot()))
 147         return;
 148     SliderThumbElement& thumb = typedSliderThumbElement();
 149     if (targetNode == &thumb)
 150         return;
 151     thumb.dragFrom(event.absoluteLocation());
 152 }
 153 #endif
 154
 155 #if ENABLE(TOUCH_EVENTS)
 156 void RangeInputType::handleTouchEvent(TouchEvent& event)
 157 {
 158 #if PLATFORM(IOS)
 159     typedSliderThumbElement().handleTouchEvent(event);
 160 #elif ENABLE(TOUCH_SLIDER)
 161     if (element().isDisabledFormControl())
 162         return;
 163
 164     if (event.type() == eventNames().touchendEvent) {
 165         event.setDefaultHandled();
 166         return;
 167     }
 168
 169     TouchList* touches = event.targetTouches();
 170     if (touches->length() == 1) {
 171         typedSliderThumbElement().setPositionFromPoint(touches->item(0)->absoluteLocation());
 172         event.setDefaultHandled();
 173     }
 174 #else
 175     UNUSED_PARAM(event);
 176 #endif
 177 }
 178
 179 #if ENABLE(TOUCH_SLIDER)
 180 bool RangeInputType::hasTouchEventHandler() const
 181 {
 182     return true;
 183 }
 184 #endif
 185 #endif // ENABLE(TOUCH_EVENTS)
 186
 187 void RangeInputType::disabledAttributeChanged()
 188 {
 189     typedSliderThumbElement().disabledAttributeChanged();
 190 }
 191
 192 void RangeInputType::handleKeydownEvent(KeyboardEvent& event)
 193 {
 194     if (element().isDisabledFormControl())
 195         return;
 196
 197     const String& key = event.keyIdentifier();
 198
 199     const Decimal current = parseToNumberOrNaN(element().value());
 200     ASSERT(current.isFinite());
 201
 202     StepRange stepRange(createStepRange(RejectAny));
 203
 204
 205     // FIXME: We can't use stepUp() for the step value "any". So, we increase
 206     // or decrease the value by 1/100 of the value range. Is it reasonable?
 207     const Decimal step = equalLettersIgnoringASCIICase(element().attributeWithoutSynchronization(stepAttr), "any") ? (stepRange.maximum() - stepRange.minimum()) / 100 : stepRange.step();
 208     const Decimal bigStep = std::max((stepRange.maximum() - stepRange.minimum()) / 10, step);
 209
 210     bool isVertical = false;
 211     if (element().renderer()) {
 212         ControlPart part = element().renderer()->style().appearance();
 213         isVertical = part == SliderVerticalPart || part == MediaVolumeSliderPart;
 214     }
 215
 216     Decimal newValue;
 217     if (key == "Up")
 218         newValue = current + step;
 219     else if (key == "Down")
 220         newValue = current - step;
 221     else if (key == "Left")
 222         newValue = isVertical ? current + step : current - step;
 223     else if (key == "Right")
 224         newValue = isVertical ? current - step : current + step;
 225     else if (key == "PageUp")
 226         newValue = current + bigStep;
 227     else if (key == "PageDown")
 228         newValue = current - bigStep;
 229     else if (key == "Home")
 230         newValue = isVertical ? stepRange.maximum() : stepRange.minimum();
 231     else if (key == "End")
 232         newValue = isVertical ? stepRange.minimum() : stepRange.maximum();
 233     else
 234         return; // Did not match any key binding.
 235
 236     newValue = stepRange.clampValue(newValue);
 237
 238     if (newValue != current) {
 239         EventQueueScope scope;
 240         setValueAsDecimal(newValue, DispatchInputAndChangeEvent);
 241
 242         if (AXObjectCache* cache = element().document().existingAXObjectCache())
 243             cache->postNotification(&element(), AXObjectCache::AXValueChanged);
 244     }
 245
 246     event.setDefaultHandled();
 247 }
 248
 249 void RangeInputType::createShadowSubtree()
 250 {
 251     ASSERT(element().userAgentShadowRoot());
 252
 253     Document& document = element().document();
 254     auto track = HTMLDivElement::create(document);
 255     track->setPseudo(AtomicString("-webkit-slider-runnable-track", AtomicString::ConstructFromLiteral));
 256     track->appendChild(SliderThumbElement::create(document));
 257     auto container = SliderContainerElement::create(document);
 258     container->appendChild(track);
 259     element().userAgentShadowRoot()->appendChild(container);
 260 }
 261
 262 HTMLElement* RangeInputType::sliderTrackElement() const
 263 {
 264     ASSERT(element().userAgentShadowRoot());
 265     ASSERT(element().userAgentShadowRoot()->firstChild()); // container
 266     ASSERT(element().userAgentShadowRoot()->firstChild()->isHTMLElement());
 267     ASSERT(element().userAgentShadowRoot()->firstChild()->firstChild()); // track
 268
 269     ShadowRoot* root = element().userAgentShadowRoot();
 270     if (!root)
 271         return nullptr;
 272
 273     auto* container = childrenOfType<SliderContainerElement>(*root).first();
 274     if (!container)
 275         return nullptr;
 276
 277     return childrenOfType<HTMLElement>(*container).first();
 278 }
 279
 280 SliderThumbElement& RangeInputType::typedSliderThumbElement() const
 281 {
 282     ASSERT(sliderTrackElement()->firstChild()); // thumb
 283     ASSERT(sliderTrackElement()->firstChild()->isHTMLElement());
 284
 285     return static_cast<SliderThumbElement&>(*sliderTrackElement()->firstChild());
 286 }
 287
 288 HTMLElement* RangeInputType::sliderThumbElement() const
 289 {
 290     return &typedSliderThumbElement();
 291 }
 292
 293 RenderPtr<RenderElement> RangeInputType::createInputRenderer(RenderStyle&& style)
 294 {
 295     return createRenderer<RenderSlider>(element(), WTFMove(style));
 296 }
 297
 298 Decimal RangeInputType::parseToNumber(const String& src, const Decimal& defaultValue) const
 299 {
 300     return parseToDecimalForNumberType(src, defaultValue);
 301 }
 302
 303 String RangeInputType::serialize(const Decimal& value) const
 304 {
 305     if (!value.isFinite())
 306         return String();
 307     return serializeForNumberType(value);
 308 }
 309
 310 // FIXME: Could share this with BaseClickableWithKeyInputType and BaseCheckableInputType if we had a common base class.
 311 void RangeInputType::accessKeyAction(bool sendMouseEvents)
 312 {
 313     InputType::accessKeyAction(sendMouseEvents);
 314
 315     element().dispatchSimulatedClick(0, sendMouseEvents ? SendMouseUpDownEvents : SendNoEvents);
 316 }
 317
 318 void RangeInputType::minOrMaxAttributeChanged()
 319 {
 320     InputType::minOrMaxAttributeChanged();
 321
 322     // Sanitize the value.
 323     if (element().hasDirtyValue())
 324         element().setValue(element().value());
 325
 326     typedSliderThumbElement().setPositionFromValue();
 327 }
 328
 329 void RangeInputType::setValue(const String& value, bool valueChanged, TextFieldEventBehavior eventBehavior)
 330 {
 331     InputType::setValue(value, valueChanged, eventBehavior);
 332
 333     if (!valueChanged)
 334         return;
 335
 336     if (eventBehavior == DispatchNoEvent)
 337         element().setTextAsOfLastFormControlChangeEvent(value);
 338
 339     typedSliderThumbElement().setPositionFromValue();
 340 }
 341
 342 String RangeInputType::fallbackValue() const
 343 {
 344     return serializeForNumberType(createStepRange(RejectAny).defaultValue());
 345 }
 346
 347 String RangeInputType::sanitizeValue(const String& proposedValue) const
 348 {
 349     StepRange stepRange(createStepRange(RejectAny));
 350     const Decimal proposedNumericValue = parseToNumber(proposedValue, stepRange.defaultValue());
 351     return serializeForNumberType(stepRange.clampValue(proposedNumericValue));
 352 }
 353
 354 bool RangeInputType::shouldRespectListAttribute()
 355 {
 356     return InputType::themeSupportsDataListUI(this);
 357 }
 358
 359 #if ENABLE(DATALIST_ELEMENT)
 360 void RangeInputType::listAttributeTargetChanged()
 361 {
 362     m_tickMarkValuesDirty = true;
 363     HTMLElement* sliderTrackElement = this->sliderTrackElement();
 364     if (sliderTrackElement->renderer())
 365         sliderTrackElement->renderer()->setNeedsLayout();
 366 }
 367
 368 void RangeInputType::updateTickMarkValues()
 369 {
 370     if (!m_tickMarkValuesDirty)
 371         return;
 372     m_tickMarkValues.clear();
 373     m_tickMarkValuesDirty = false;
 374     HTMLDataListElement* dataList = element().dataList();
 375     if (!dataList)
 376         return;
 377     Ref<HTMLCollection> options = dataList->options();
 378     m_tickMarkValues.reserveCapacity(options->length());
 379     for (unsigned i = 0; i < options->length(); ++i) {
 380         Node* node = options->item(i);
 381         HTMLOptionElement& optionElement = downcast<HTMLOptionElement>(*node);
 382         String optionValue = optionElement.value();
 383         if (!element().isValidValue(optionValue))
 384             continue;
 385         m_tickMarkValues.append(parseToNumber(optionValue, Decimal::nan()));
 386     }
 387     m_tickMarkValues.shrinkToFit();
 388     std::sort(m_tickMarkValues.begin(), m_tickMarkValues.end());
 389 }
 390
 391 std::optional<Decimal> RangeInputType::findClosestTickMarkValue(const Decimal& value)
 392 {
 393     updateTickMarkValues();
 394     if (!m_tickMarkValues.size())
 395         return std::nullopt;
 396
 397     size_t left = 0;
 398     size_t right = m_tickMarkValues.size();
 399     size_t middle;
 400     while (true) {
 401         ASSERT(left <= right);
 402         middle = left + (right - left) / 2;
 403         if (!middle)
 404             break;
 405         if (middle == m_tickMarkValues.size() - 1 && m_tickMarkValues[middle] < value) {
 406             middle++;
 407             break;
 408         }
 409         if (m_tickMarkValues[middle - 1] <= value && m_tickMarkValues[middle] >= value)
 410             break;
 411
 412         if (m_tickMarkValues[middle] < value)
 413             left = middle;
 414         else
 415             right = middle;
 416     }
 417
 418     std::optional<Decimal> closestLeft = middle ? std::make_optional(m_tickMarkValues[middle - 1]) : std::nullopt;
 419     std::optional<Decimal> closestRight = middle != m_tickMarkValues.size() ? std::make_optional(m_tickMarkValues[middle]) : std::nullopt;
 420
 421     if (!closestLeft)
 422         return closestRight;
 423     if (!closestRight)
 424         return closestLeft;
 425
 426     if (*closestRight - value < value - *closestLeft)
 427         return closestRight;
 428
 429     return closestLeft;
 430 }
 431 #endif
 432
 433 } // namespace WebCore