BaseDateAndTimeInputType.cpp [plain text]
#include "config.h"
#include "BaseDateAndTimeInputType.h"
#if ENABLE(DATE_AND_TIME_INPUT_TYPES)
#include "Decimal.h"
#include "HTMLInputElement.h"
#include "HTMLNames.h"
#include "KeyboardEvent.h"
#include "PlatformLocale.h"
#include <limits>
#include <wtf/DateMath.h>
#include <wtf/MathExtras.h>
#include <wtf/text/StringView.h>
namespace WebCore {
using namespace HTMLNames;
static const int msecPerMinute = 60 * 1000;
static const int msecPerSecond = 1000;
double BaseDateAndTimeInputType::valueAsDate() const
{
return valueAsDouble();
}
ExceptionOr<void> BaseDateAndTimeInputType::setValueAsDate(double value) const
{
ASSERT(element());
element()->setValue(serializeWithMilliseconds(value));
return { };
}
double BaseDateAndTimeInputType::valueAsDouble() const
{
ASSERT(element());
const Decimal value = parseToNumber(element()->value(), Decimal::nan());
return value.isFinite() ? value.toDouble() : DateComponents::invalidMilliseconds();
}
ExceptionOr<void> BaseDateAndTimeInputType::setValueAsDecimal(const Decimal& newValue, TextFieldEventBehavior eventBehavior) const
{
ASSERT(element());
element()->setValue(serialize(newValue), eventBehavior);
return { };
}
bool BaseDateAndTimeInputType::typeMismatchFor(const String& value) const
{
return !value.isEmpty() && !parseToDateComponents(value);
}
bool BaseDateAndTimeInputType::typeMismatch() const
{
ASSERT(element());
return typeMismatchFor(element()->value());
}
Decimal BaseDateAndTimeInputType::defaultValueForStepUp() const
{
double ms = WallTime::now().secondsSinceEpoch().milliseconds();
int offset = calculateLocalTimeOffset(ms).offset / msPerMinute;
return Decimal::fromDouble(ms + (offset * msPerMinute));
}
bool BaseDateAndTimeInputType::isSteppable() const
{
return true;
}
void BaseDateAndTimeInputType::attributeChanged(const QualifiedName& name)
{
if (name == maxAttr || name == minAttr) {
if (auto* element = this->element())
element->invalidateStyleForSubtree();
}
InputType::attributeChanged(name);
}
Decimal BaseDateAndTimeInputType::parseToNumber(const String& source, const Decimal& defaultValue) const
{
auto date = parseToDateComponents(source);
if (!date)
return defaultValue;
double msec = date->millisecondsSinceEpoch();
ASSERT(std::isfinite(msec));
return Decimal::fromDouble(msec);
}
String BaseDateAndTimeInputType::serialize(const Decimal& value) const
{
if (!value.isFinite())
return { };
auto date = setMillisecondToDateComponents(value.toDouble());
if (!date)
return { };
return serializeWithComponents(*date);
}
String BaseDateAndTimeInputType::serializeWithComponents(const DateComponents& date) const
{
ASSERT(element());
Decimal step;
if (!element()->getAllowedValueStep(&step))
return date.toString();
if (step.remainder(msecPerMinute).isZero())
return date.toString(DateComponents::None);
if (step.remainder(msecPerSecond).isZero())
return date.toString(DateComponents::Second);
return date.toString(DateComponents::Millisecond);
}
String BaseDateAndTimeInputType::serializeWithMilliseconds(double value) const
{
return serialize(Decimal::fromDouble(value));
}
String BaseDateAndTimeInputType::localizeValue(const String& proposedValue) const
{
auto date = parseToDateComponents(proposedValue);
if (!date)
return proposedValue;
ASSERT(element());
String localized = element()->locale().formatDateTime(*date);
return localized.isEmpty() ? proposedValue : localized;
}
String BaseDateAndTimeInputType::visibleValue() const
{
ASSERT(element());
return localizeValue(element()->value());
}
String BaseDateAndTimeInputType::sanitizeValue(const String& proposedValue) const
{
return typeMismatchFor(proposedValue) ? String() : proposedValue;
}
bool BaseDateAndTimeInputType::supportsReadOnly() const
{
return true;
}
bool BaseDateAndTimeInputType::shouldRespectListAttribute()
{
return InputType::themeSupportsDataListUI(this);
}
bool BaseDateAndTimeInputType::valueMissing(const String& value) const
{
ASSERT(element());
return element()->isRequired() && value.isEmpty();
}
#if PLATFORM(IOS_FAMILY)
bool BaseDateAndTimeInputType::isKeyboardFocusable(KeyboardEvent*) const
{
ASSERT(element());
return !element()->isReadOnly() && element()->isTextFormControlFocusable();
}
#endif
} #endif