RangeInputType.cpp [plain text]
#include "config.h"
#include "RangeInputType.h"
#include "AXObjectCache.h"
#include "HTMLDivElement.h"
#include "HTMLInputElement.h"
#include "HTMLNames.h"
#include "HTMLParserIdioms.h"
#include "KeyboardEvent.h"
#include "MouseEvent.h"
#include "PlatformMouseEvent.h"
#include "RenderSlider.h"
#include "ShadowRoot.h"
#include "ShadowTree.h"
#include "SliderThumbElement.h"
#include "StepRange.h"
#include <limits>
#include <wtf/MathExtras.h>
#include <wtf/PassOwnPtr.h>
namespace WebCore {
using namespace HTMLNames;
using namespace std;
static const double rangeDefaultMinimum = 0.0;
static const double rangeDefaultMaximum = 100.0;
static const double rangeDefaultStep = 1.0;
static const double rangeStepScaleFactor = 1.0;
PassOwnPtr<InputType> RangeInputType::create(HTMLInputElement* element)
{
return adoptPtr(new RangeInputType(element));
}
bool RangeInputType::isRangeControl() const
{
return true;
}
const AtomicString& RangeInputType::formControlType() const
{
return InputTypeNames::range();
}
double RangeInputType::valueAsNumber() const
{
return parseToDouble(element()->value(), numeric_limits<double>::quiet_NaN());
}
void RangeInputType::setValueAsNumber(double newValue, TextFieldEventBehavior eventBehavior, ExceptionCode&) const
{
element()->setValue(serialize(newValue), eventBehavior);
}
bool RangeInputType::supportsRequired() const
{
return false;
}
bool RangeInputType::rangeUnderflow(const String& value) const
{
ASSERT_UNUSED(value, parseToDouble(value, numeric_limits<double>::quiet_NaN()) >= minimum());
return false;
}
bool RangeInputType::rangeOverflow(const String& value) const
{
ASSERT_UNUSED(value, parseToDouble(value, numeric_limits<double>::quiet_NaN()) <= maximum());
return false;
}
bool RangeInputType::supportsRangeLimitation() const
{
return true;
}
double RangeInputType::minimum() const
{
return parseToDouble(element()->fastGetAttribute(minAttr), rangeDefaultMinimum);
}
double RangeInputType::maximum() const
{
double max = parseToDouble(element()->fastGetAttribute(maxAttr), rangeDefaultMaximum);
double min = minimum();
if (max < min)
max = std::max(min, rangeDefaultMaximum);
return max;
}
bool RangeInputType::isSteppable() const
{
return true;
}
bool RangeInputType::stepMismatch(const String&, double) const
{
return false;
}
double RangeInputType::stepBase() const
{
return minimum();
}
double RangeInputType::defaultStep() const
{
return rangeDefaultStep;
}
double RangeInputType::stepScaleFactor() const
{
return rangeStepScaleFactor;
}
void RangeInputType::handleMouseDownEvent(MouseEvent* event)
{
if (element()->disabled() || element()->readOnly())
return;
Node* targetNode = event->target()->toNode();
if (event->button() != LeftButton || !targetNode)
return;
ASSERT(element()->hasShadowRoot());
if (targetNode != element() && !targetNode->isDescendantOf(element()->shadowTree()->oldestShadowRoot()))
return;
SliderThumbElement* thumb = sliderThumbElementOf(element());
if (targetNode == thumb)
return;
thumb->dragFrom(event->absoluteLocation());
}
void RangeInputType::handleKeydownEvent(KeyboardEvent* event)
{
if (element()->disabled() || element()->readOnly())
return;
const String& key = event->keyIdentifier();
double current = parseToDouble(element()->value(), numeric_limits<double>::quiet_NaN());
ASSERT(isfinite(current));
double step, bigStep;
if (equalIgnoringCase(element()->fastGetAttribute(stepAttr), "any")) {
step = (maximum() - minimum()) / 100;
bigStep = step * 10;
} else {
if (!element()->getAllowedValueStep(&step))
ASSERT_NOT_REACHED();
bigStep = (maximum() - minimum()) / 10;
if (bigStep < step)
bigStep = step;
}
bool isVertical = false;
if (element()->renderer()) {
ControlPart part = element()->renderer()->style()->appearance();
isVertical = part == SliderVerticalPart || part == MediaVolumeSliderPart;
}
double newValue;
if (key == "Up")
newValue = current + step;
else if (key == "Down")
newValue = current - step;
else if (key == "Left")
newValue = isVertical ? current + step : current - step;
else if (key == "Right")
newValue = isVertical ? current - step : current + step;
else if (key == "PageUp")
newValue = current + bigStep;
else if (key == "PageDown")
newValue = current - bigStep;
else if (key == "Home")
newValue = isVertical ? maximum() : minimum();
else if (key == "End")
newValue = isVertical ? minimum() : maximum();
else
return;
newValue = StepRange(element()).clampValue(newValue);
if (newValue != current) {
ExceptionCode ec;
TextFieldEventBehavior eventBehavior = DispatchChangeEvent;
setValueAsNumber(newValue, eventBehavior, ec);
if (AXObjectCache::accessibilityEnabled())
element()->document()->axObjectCache()->postNotification(element()->renderer(), AXObjectCache::AXValueChanged, true);
element()->dispatchFormControlChangeEvent();
}
event->setDefaultHandled();
}
void RangeInputType::createShadowSubtree()
{
ASSERT(element()->hasShadowRoot());
Document* document = element()->document();
RefPtr<HTMLDivElement> track = HTMLDivElement::create(document);
track->setShadowPseudoId("-webkit-slider-runnable-track");
ExceptionCode ec = 0;
track->appendChild(SliderThumbElement::create(document), ec);
RefPtr<HTMLElement> container = SliderContainerElement::create(document);
container->appendChild(track.release(), ec);
container->appendChild(TrackLimiterElement::create(document), ec);
element()->shadowTree()->oldestShadowRoot()->appendChild(container.release(), ec);
}
RenderObject* RangeInputType::createRenderer(RenderArena* arena, RenderStyle*) const
{
return new (arena) RenderSlider(element());
}
double RangeInputType::parseToDouble(const String& src, double defaultValue) const
{
double numberValue;
if (!parseToDoubleForNumberType(src, &numberValue))
return defaultValue;
ASSERT(isfinite(numberValue));
return numberValue;
}
String RangeInputType::serialize(double value) const
{
if (!isfinite(value))
return String();
return serializeForNumberType(value);
}
void RangeInputType::accessKeyAction(bool sendMouseEvents)
{
InputType::accessKeyAction(sendMouseEvents);
element()->dispatchSimulatedClick(0, sendMouseEvents);
}
void RangeInputType::minOrMaxAttributeChanged()
{
InputType::minOrMaxAttributeChanged();
if (element()->hasDirtyValue())
element()->setValue(element()->value());
element()->setNeedsStyleRecalc();
}
void RangeInputType::setValue(const String& value, bool valueChanged, TextFieldEventBehavior eventBehavior)
{
InputType::setValue(value, valueChanged, eventBehavior);
if (!valueChanged)
return;
sliderThumbElementOf(element())->setPositionFromValue();
}
String RangeInputType::fallbackValue() const
{
return serializeForNumberType(StepRange(element()).defaultValue());
}
String RangeInputType::sanitizeValue(const String& proposedValue) const
{
return serializeForNumberType(StepRange(element()).clampValue(proposedValue));
}
bool RangeInputType::shouldRespectListAttribute()
{
return InputType::themeSupportsDataListUI(this);
}
}