HTMLInputElement.cpp [plain text]
#include "config.h"
#include "HTMLInputElement.h"
#include "AXObjectCache.h"
#include "Attribute.h"
#include "BeforeTextInsertedEvent.h"
#include "Chrome.h"
#include "ChromeClient.h"
#include "CSSPropertyNames.h"
#include "Document.h"
#include "EventNames.h"
#include "ExceptionCode.h"
#include "FileList.h"
#include "Frame.h"
#include "HTMLCollection.h"
#include "HTMLDataListElement.h"
#include "HTMLFormElement.h"
#include "HTMLNames.h"
#include "HTMLOptionElement.h"
#include "HTMLParserIdioms.h"
#include "InputType.h"
#include "KeyboardEvent.h"
#include "LocalizedStrings.h"
#include "MouseEvent.h"
#include "Page.h"
#include "PlatformMouseEvent.h"
#include "RenderTextControlSingleLine.h"
#include "RenderTheme.h"
#include "RuntimeEnabledFeatures.h"
#include "ScriptEventListener.h"
#include "WheelEvent.h"
#include <wtf/MathExtras.h>
#include <wtf/StdLibExtras.h>
using namespace std;
namespace WebCore {
using namespace HTMLNames;
const int HTMLInputElement::maximumLength = 524288;
const int defaultSize = 20;
const int maxSavedResults = 256;
HTMLInputElement::HTMLInputElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form, bool createdByParser)
: HTMLTextFormControlElement(tagName, document, form)
, m_size(defaultSize)
, m_maxLength(maximumLength)
, m_cachedSelectionStart(-1)
, m_cachedSelectionEnd(-1)
#if ENABLE(WCSS)
, m_inputFormatMask("*m")
, m_maxInputCharsAllowed(maximumLength)
#endif
, m_maxResults(-1)
, m_isChecked(false)
, m_reflectsCheckedAttribute(true)
, m_isIndeterminate(false)
, m_hasType(false)
, m_isActivatedSubmit(false)
, m_autocomplete(Uninitialized)
, m_isAutofilled(false)
, m_stateRestored(false)
, m_parsingInProgress(createdByParser)
, m_inputType(InputType::createText(this))
{
ASSERT(hasTagName(inputTag) || hasTagName(isindexTag));
}
PassRefPtr<HTMLInputElement> HTMLInputElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form, bool createdByParser)
{
return adoptRef(new HTMLInputElement(tagName, document, form, createdByParser));
}
HTMLInputElement::~HTMLInputElement()
{
if (needsActivationCallback())
document()->unregisterForDocumentActivationCallbacks(this);
document()->checkedRadioButtons().removeButton(this);
removeFromForm();
}
const AtomicString& HTMLInputElement::formControlName() const
{
return m_name.isNull() ? emptyAtom : m_name;
}
bool HTMLInputElement::autoComplete() const
{
if (m_autocomplete != Uninitialized)
return m_autocomplete == On;
return HTMLTextFormControlElement::autoComplete();
}
void HTMLInputElement::updateCheckedRadioButtons()
{
if (attached() && checked())
checkedRadioButtons().addButton(this);
if (form()) {
const Vector<FormAssociatedElement*>& controls = form()->associatedElements();
for (unsigned i = 0; i < controls.size(); ++i) {
if (!controls[i]->isFormControlElement())
continue;
HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(controls[i]);
if (control->name() != name())
continue;
if (control->type() != type())
continue;
control->setNeedsValidityCheck();
}
} else {
for (Node* node = document()->body(); node; node = node->traverseNextNode()) {
if (!node->isElementNode())
continue;
Element* element = static_cast<Element*>(node);
if (element->formControlName() != name())
continue;
if (element->formControlType() != type())
continue;
HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(element);
if (control->form())
continue;
control->setNeedsValidityCheck();
}
}
if (renderer() && renderer()->style()->hasAppearance())
renderer()->theme()->stateChanged(renderer(), CheckedState);
}
bool HTMLInputElement::lastChangeWasUserEdit() const
{
if (!isTextField())
return false;
if (!renderer())
return false;
return toRenderTextControl(renderer())->lastChangeWasUserEdit();
}
bool HTMLInputElement::isValidValue(const String& value) const
{
if (!m_inputType->canSetStringValue()) {
ASSERT_NOT_REACHED();
return false;
}
return !m_inputType->typeMismatchFor(value)
&& !stepMismatch(value)
&& !rangeUnderflow(value)
&& !rangeOverflow(value)
&& !tooLong(value, IgnoreDirtyFlag)
&& !patternMismatch(value)
&& !valueMissing(value);
}
bool HTMLInputElement::typeMismatch() const
{
return m_inputType->typeMismatch();
}
bool HTMLInputElement::valueMissing(const String& value) const
{
if (!isRequiredFormControl() || readOnly() || disabled())
return false;
return m_inputType->valueMissing(value);
}
bool HTMLInputElement::patternMismatch(const String& value) const
{
return m_inputType->patternMismatch(value);
}
bool HTMLInputElement::tooLong(const String& value, NeedsToCheckDirtyFlag check) const
{
if (!isTextType())
return false;
int max = maxLength();
if (max < 0)
return false;
if (check == CheckDirtyFlag) {
bool userEdited = !m_value.isNull();
if (!userEdited)
return false;
}
return numGraphemeClusters(value) > static_cast<unsigned>(max);
}
bool HTMLInputElement::rangeUnderflow(const String& value) const
{
return m_inputType->rangeUnderflow(value);
}
bool HTMLInputElement::rangeOverflow(const String& value) const
{
return m_inputType->rangeOverflow(value);
}
double HTMLInputElement::minimum() const
{
return m_inputType->minimum();
}
double HTMLInputElement::maximum() const
{
return m_inputType->maximum();
}
bool HTMLInputElement::stepMismatch(const String& value) const
{
double step;
if (!getAllowedValueStep(&step))
return false;
return m_inputType->stepMismatch(value, step);
}
String HTMLInputElement::minimumString() const
{
return m_inputType->serialize(minimum());
}
String HTMLInputElement::maximumString() const
{
return m_inputType->serialize(maximum());
}
String HTMLInputElement::stepBaseString() const
{
return m_inputType->serialize(m_inputType->stepBase());
}
String HTMLInputElement::stepString() const
{
double step;
if (!getAllowedValueStep(&step)) {
ASSERT_NOT_REACHED();
return String();
}
return serializeForNumberType(step / m_inputType->stepScaleFactor());
}
String HTMLInputElement::typeMismatchText() const
{
return m_inputType->typeMismatchText();
}
String HTMLInputElement::valueMissingText() const
{
return m_inputType->valueMissingText();
}
bool HTMLInputElement::getAllowedValueStep(double* step) const
{
return getAllowedValueStepWithDecimalPlaces(step, 0);
}
bool HTMLInputElement::getAllowedValueStepWithDecimalPlaces(double* step, unsigned* decimalPlaces) const
{
ASSERT(step);
double defaultStep = m_inputType->defaultStep();
double stepScaleFactor = m_inputType->stepScaleFactor();
if (!isfinite(defaultStep) || !isfinite(stepScaleFactor))
return false;
const AtomicString& stepString = fastGetAttribute(stepAttr);
if (stepString.isEmpty()) {
*step = defaultStep * stepScaleFactor;
if (decimalPlaces)
*decimalPlaces = 0;
return true;
}
if (equalIgnoringCase(stepString, "any"))
return false;
double parsed;
if (!decimalPlaces) {
if (!parseToDoubleForNumberType(stepString, &parsed) || parsed <= 0.0) {
*step = defaultStep * stepScaleFactor;
return true;
}
} else {
if (!parseToDoubleForNumberTypeWithDecimalPlaces(stepString, &parsed, decimalPlaces) || parsed <= 0.0) {
*step = defaultStep * stepScaleFactor;
*decimalPlaces = 0;
return true;
}
}
if (m_inputType->parsedStepValueShouldBeInteger())
parsed = max(round(parsed), 1.0);
double result = parsed * stepScaleFactor;
if (m_inputType->scaledStepValueShouldBeInteger())
result = max(round(result), 1.0);
ASSERT(result > 0);
*step = result;
return true;
}
void HTMLInputElement::applyStep(double count, ExceptionCode& ec)
{
double step;
unsigned stepDecimalPlaces, currentDecimalPlaces;
if (!getAllowedValueStepWithDecimalPlaces(&step, &stepDecimalPlaces)) {
ec = INVALID_STATE_ERR;
return;
}
const double nan = numeric_limits<double>::quiet_NaN();
double current = m_inputType->parseToDoubleWithDecimalPlaces(value(), nan, ¤tDecimalPlaces);
if (!isfinite(current)) {
ec = INVALID_STATE_ERR;
return;
}
double newValue = current + step * count;
if (isinf(newValue)) {
ec = INVALID_STATE_ERR;
return;
}
double acceptableError = m_inputType->acceptableError(step);
if (newValue - m_inputType->minimum() < -acceptableError) {
ec = INVALID_STATE_ERR;
return;
}
if (newValue < m_inputType->minimum())
newValue = m_inputType->minimum();
unsigned baseDecimalPlaces;
double base = m_inputType->stepBaseWithDecimalPlaces(&baseDecimalPlaces);
baseDecimalPlaces = min(baseDecimalPlaces, 16u);
if (newValue < pow(10.0, 21.0)) {
if (stepMismatch(value())) {
double scale = pow(10.0, static_cast<double>(max(stepDecimalPlaces, currentDecimalPlaces)));
newValue = round(newValue * scale) / scale;
} else {
double scale = pow(10.0, static_cast<double>(max(stepDecimalPlaces, baseDecimalPlaces)));
newValue = round((base + round((newValue - base) / step) * step) * scale) / scale;
}
}
if (newValue - m_inputType->maximum() > acceptableError) {
ec = INVALID_STATE_ERR;
return;
}
if (newValue > m_inputType->maximum())
newValue = m_inputType->maximum();
setValueAsNumber(newValue, ec);
if (AXObjectCache::accessibilityEnabled())
document()->axObjectCache()->postNotification(renderer(), AXObjectCache::AXValueChanged, true);
}
void HTMLInputElement::stepUp(int n, ExceptionCode& ec)
{
applyStep(n, ec);
}
void HTMLInputElement::stepDown(int n, ExceptionCode& ec)
{
applyStep(-n, ec);
}
bool HTMLInputElement::isKeyboardFocusable(KeyboardEvent* event) const
{
if (isTextField())
return HTMLFormControlElementWithState::isFocusable();
return HTMLFormControlElementWithState::isKeyboardFocusable(event) && m_inputType->isKeyboardFocusable();
}
bool HTMLInputElement::isMouseFocusable() const
{
if (isTextField())
return HTMLFormControlElementWithState::isFocusable();
return HTMLFormControlElementWithState::isMouseFocusable();
}
void HTMLInputElement::updateFocusAppearance(bool restorePreviousSelection)
{
if (isTextField()) {
if (!restorePreviousSelection || m_cachedSelectionStart == -1)
select();
else {
WebCore::setSelectionRange(this, m_cachedSelectionStart, m_cachedSelectionEnd);
}
if (document()->frame())
document()->frame()->selection()->revealSelection();
} else
HTMLFormControlElementWithState::updateFocusAppearance(restorePreviousSelection);
}
void HTMLInputElement::aboutToUnload()
{
if (!isTextField() || !focused())
return;
Frame* frame = document()->frame();
if (!frame)
return;
frame->editor()->textFieldDidEndEditing(this);
}
bool HTMLInputElement::shouldUseInputMethod() const
{
return m_inputType->shouldUseInputMethod();
}
void HTMLInputElement::handleFocusEvent()
{
if (!isTextField())
return;
if (isPasswordField() && document()->frame())
document()->setUseSecureKeyboardEntryWhenActive(true);
}
void HTMLInputElement::handleBlurEvent()
{
m_inputType->handleBlurEvent();
if (!isTextField())
return;
Frame* frame = document()->frame();
if (!frame)
return;
if (isPasswordField())
document()->setUseSecureKeyboardEntryWhenActive(false);
frame->editor()->textFieldDidEndEditing(this);
}
void HTMLInputElement::setType(const String& type)
{
if (type.isEmpty()) {
ExceptionCode ec;
removeAttribute(typeAttr, ec);
} else
setAttribute(typeAttr, type);
}
void HTMLInputElement::updateType()
{
OwnPtr<InputType> newType = InputType::create(this, fastGetAttribute(typeAttr));
bool hadType = m_hasType;
m_hasType = true;
if (m_inputType->formControlType() == newType->formControlType())
return;
if (hadType && !newType->canChangeFromAnotherType()) {
setAttribute(typeAttr, type());
return;
}
checkedRadioButtons().removeButton(this);
bool wasAttached = attached();
if (wasAttached)
detach();
bool didStoreValue = m_inputType->storesValueSeparateFromAttribute();
bool neededActivationCallback = needsActivationCallback();
bool didRespectHeightAndWidth = m_inputType->shouldRespectHeightAndWidthAttributes();
m_inputType->destroyShadowSubtree();
m_inputType = newType.release();
m_inputType->createShadowSubtree();
setNeedsWillValidateCheck();
bool willStoreValue = m_inputType->storesValueSeparateFromAttribute();
if (didStoreValue && !willStoreValue && !m_value.isNull()) {
setAttribute(valueAttr, m_value);
m_value = String();
}
if (!didStoreValue && willStoreValue)
m_value = sanitizeValue(fastGetAttribute(valueAttr));
else
updateValueIfNeeded();
if (neededActivationCallback)
unregisterForActivationCallbackIfNeeded();
else
registerForActivationCallbackIfNeeded();
if (didRespectHeightAndWidth != m_inputType->shouldRespectHeightAndWidthAttributes()) {
NamedNodeMap* map = attributeMap();
ASSERT(map);
if (Attribute* height = map->getAttributeItem(heightAttr))
attributeChanged(height, false);
if (Attribute* width = map->getAttributeItem(widthAttr))
attributeChanged(width, false);
if (Attribute* align = map->getAttributeItem(alignAttr))
attributeChanged(align, false);
}
if (wasAttached) {
attach();
if (document()->focusedNode() == this)
updateFocusAppearance(true);
}
setChangedSinceLastFormControlChangeEvent(false);
checkedRadioButtons().addButton(this);
setNeedsValidityCheck();
notifyFormStateChanged();
}
const AtomicString& HTMLInputElement::formControlType() const
{
return m_inputType->formControlType();
}
bool HTMLInputElement::saveFormControlState(String& result) const
{
return m_inputType->saveFormControlState(result);
}
void HTMLInputElement::restoreFormControlState(const String& state)
{
m_inputType->restoreFormControlState(state);
m_stateRestored = true;
}
bool HTMLInputElement::canStartSelection() const
{
if (!isTextField())
return false;
return HTMLFormControlElementWithState::canStartSelection();
}
bool HTMLInputElement::canHaveSelection() const
{
return isTextField();
}
void HTMLInputElement::accessKeyAction(bool sendToAnyElement)
{
m_inputType->accessKeyAction(sendToAnyElement);
}
bool HTMLInputElement::mapToEntry(const QualifiedName& attrName, MappedAttributeEntry& result) const
{
if (((attrName == heightAttr || attrName == widthAttr) && m_inputType->shouldRespectHeightAndWidthAttributes())
|| attrName == vspaceAttr
|| attrName == hspaceAttr) {
result = eUniversal;
return false;
}
if (attrName == alignAttr && m_inputType->shouldRespectAlignAttribute()) {
result = eReplaced;
return false;
}
return HTMLElement::mapToEntry(attrName, result);
}
void HTMLInputElement::parseMappedAttribute(Attribute* attr)
{
if (attr->name() == nameAttr) {
checkedRadioButtons().removeButton(this);
m_name = attr->value();
checkedRadioButtons().addButton(this);
HTMLFormControlElementWithState::parseMappedAttribute(attr);
} else if (attr->name() == autocompleteAttr) {
if (equalIgnoringCase(attr->value(), "off")) {
m_autocomplete = Off;
registerForActivationCallbackIfNeeded();
} else {
bool needsToUnregister = m_autocomplete == Off;
if (attr->isEmpty())
m_autocomplete = Uninitialized;
else
m_autocomplete = On;
if (needsToUnregister)
unregisterForActivationCallbackIfNeeded();
}
} else if (attr->name() == typeAttr) {
updateType();
} else if (attr->name() == valueAttr) {
if (m_value.isNull())
setNeedsStyleRecalc();
setFormControlValueMatchesRenderer(false);
setNeedsValidityCheck();
} else if (attr->name() == checkedAttr) {
if (!m_parsingInProgress && m_reflectsCheckedAttribute) {
setChecked(!attr->isNull());
m_reflectsCheckedAttribute = true;
}
} else if (attr->name() == maxlengthAttr)
parseMaxLengthAttribute(attr);
else if (attr->name() == sizeAttr) {
m_size = attr->isNull() ? defaultSize : attr->value().toInt();
if (renderer())
renderer()->setNeedsLayoutAndPrefWidthsRecalc();
} else if (attr->name() == altAttr)
m_inputType->altAttributeChanged();
else if (attr->name() == srcAttr)
m_inputType->srcAttributeChanged();
else if (attr->name() == usemapAttr || attr->name() == accesskeyAttr) {
} else if (attr->name() == vspaceAttr) {
addCSSLength(attr, CSSPropertyMarginTop, attr->value());
addCSSLength(attr, CSSPropertyMarginBottom, attr->value());
} else if (attr->name() == hspaceAttr) {
addCSSLength(attr, CSSPropertyMarginLeft, attr->value());
addCSSLength(attr, CSSPropertyMarginRight, attr->value());
} else if (attr->name() == alignAttr) {
if (m_inputType->shouldRespectAlignAttribute())
addHTMLAlignment(attr);
} else if (attr->name() == widthAttr) {
if (m_inputType->shouldRespectHeightAndWidthAttributes())
addCSSLength(attr, CSSPropertyWidth, attr->value());
} else if (attr->name() == heightAttr) {
if (m_inputType->shouldRespectHeightAndWidthAttributes())
addCSSLength(attr, CSSPropertyHeight, attr->value());
} else if (attr->name() == onsearchAttr) {
setAttributeEventListener(eventNames().searchEvent, createAttributeEventListener(this, attr));
} else if (attr->name() == resultsAttr) {
int oldResults = m_maxResults;
m_maxResults = !attr->isNull() ? std::min(attr->value().toInt(), maxSavedResults) : -1;
if (m_maxResults != oldResults && (m_maxResults <= 0 || oldResults <= 0) && attached()) {
detach();
attach();
}
setNeedsStyleRecalc();
} else if (attr->name() == autosaveAttr || attr->name() == incrementalAttr)
setNeedsStyleRecalc();
else if (attr->name() == minAttr || attr->name() == maxAttr) {
m_inputType->minOrMaxAttributeChanged();
setNeedsValidityCheck();
} else if (attr->name() == multipleAttr || attr->name() == patternAttr || attr->name() == precisionAttr || attr->name() == stepAttr)
setNeedsValidityCheck();
#if ENABLE(DATALIST)
else if (attr->name() == listAttr)
m_hasNonEmptyList = !attr->isEmpty();
#endif
#if ENABLE(INPUT_SPEECH)
else if (attr->name() == webkitspeechAttr) {
if (renderer()) {
detach();
attach();
}
setNeedsStyleRecalc();
} else if (attr->name() == onwebkitspeechchangeAttr)
setAttributeEventListener(eventNames().webkitspeechchangeEvent, createAttributeEventListener(this, attr));
#endif
else
HTMLTextFormControlElement::parseMappedAttribute(attr);
}
void HTMLInputElement::finishParsingChildren()
{
m_parsingInProgress = false;
HTMLFormControlElementWithState::finishParsingChildren();
if (!m_stateRestored) {
bool checked = hasAttribute(checkedAttr);
if (checked)
setChecked(checked);
m_reflectsCheckedAttribute = true;
}
}
bool HTMLInputElement::rendererIsNeeded(RenderStyle* style)
{
return m_inputType->rendererIsNeeded() && HTMLFormControlElementWithState::rendererIsNeeded(style);
}
RenderObject* HTMLInputElement::createRenderer(RenderArena* arena, RenderStyle* style)
{
return m_inputType->createRenderer(arena, style);
}
void HTMLInputElement::attach()
{
suspendPostAttachCallbacks();
if (!m_hasType)
updateType();
HTMLFormControlElementWithState::attach();
m_inputType->attach();
if (document()->focusedNode() == this)
document()->updateFocusAppearanceSoon(true );
resumePostAttachCallbacks();
}
void HTMLInputElement::detach()
{
HTMLFormControlElementWithState::detach();
setFormControlValueMatchesRenderer(false);
}
String HTMLInputElement::altText() const
{
String alt = fastGetAttribute(altAttr);
if (alt.isNull())
alt = getAttribute(titleAttr);
if (alt.isNull())
alt = getAttribute(valueAttr);
if (alt.isEmpty())
alt = inputElementAltText();
return alt;
}
bool HTMLInputElement::isSuccessfulSubmitButton() const
{
return !disabled() && m_inputType->canBeSuccessfulSubmitButton();
}
bool HTMLInputElement::isActivatedSubmit() const
{
return m_isActivatedSubmit;
}
void HTMLInputElement::setActivatedSubmit(bool flag)
{
m_isActivatedSubmit = flag;
}
bool HTMLInputElement::appendFormData(FormDataList& encoding, bool multipart)
{
return m_inputType->isFormDataAppendable() && m_inputType->appendFormData(encoding, multipart);
}
void HTMLInputElement::reset()
{
if (m_inputType->storesValueSeparateFromAttribute())
setValue(String());
setAutofilled(false);
setChecked(hasAttribute(checkedAttr));
m_reflectsCheckedAttribute = true;
}
bool HTMLInputElement::isTextField() const
{
return m_inputType->isTextField();
}
bool HTMLInputElement::isTextType() const
{
return m_inputType->isTextType();
}
void HTMLInputElement::setChecked(bool nowChecked, bool sendChangeEvent)
{
if (checked() == nowChecked)
return;
checkedRadioButtons().removeButton(this);
m_reflectsCheckedAttribute = false;
m_isChecked = nowChecked;
setNeedsStyleRecalc();
updateCheckedRadioButtons();
setNeedsValidityCheck();
if (renderer() && AXObjectCache::accessibilityEnabled())
renderer()->document()->axObjectCache()->postNotification(renderer(), AXObjectCache::AXCheckedStateChanged, true);
if (sendChangeEvent && inDocument() && m_inputType->shouldSendChangeEventAfterCheckedChanged()) {
setTextAsOfLastFormControlChangeEvent(String());
dispatchFormControlChangeEvent();
}
}
void HTMLInputElement::setIndeterminate(bool newValue)
{
if (!m_inputType->isCheckable() || indeterminate() == newValue)
return;
m_isIndeterminate = newValue;
setNeedsStyleRecalc();
if (renderer() && renderer()->style()->hasAppearance())
renderer()->theme()->stateChanged(renderer(), CheckedState);
}
int HTMLInputElement::size() const
{
return m_size;
}
void HTMLInputElement::copyNonAttributeProperties(const Element* source)
{
const HTMLInputElement* sourceElement = static_cast<const HTMLInputElement*>(source);
m_value = sourceElement->m_value;
setChecked(sourceElement->m_isChecked);
m_reflectsCheckedAttribute = sourceElement->m_reflectsCheckedAttribute;
m_isIndeterminate = sourceElement->m_isIndeterminate;
HTMLFormControlElementWithState::copyNonAttributeProperties(source);
}
String HTMLInputElement::value() const
{
String value;
if (m_inputType->getTypeSpecificValue(value))
return value;
value = m_value;
if (!value.isNull())
return value;
value = sanitizeValue(fastGetAttribute(valueAttr));
if (!value.isNull())
return value;
return m_inputType->fallbackValue();
}
String HTMLInputElement::valueWithDefault() const
{
String value = this->value();
if (!value.isNull())
return value;
return m_inputType->defaultValue();
}
void HTMLInputElement::setValueForUser(const String& value)
{
setValue(value, true);
}
const String& HTMLInputElement::suggestedValue() const
{
return m_suggestedValue;
}
void HTMLInputElement::setSuggestedValue(const String& value)
{
if (!m_inputType->canSetSuggestedValue())
return;
setFormControlValueMatchesRenderer(false);
m_suggestedValue = sanitizeValue(value);
updatePlaceholderVisibility(false);
if (renderer())
renderer()->updateFromElement();
setNeedsStyleRecalc();
}
void HTMLInputElement::setValue(const String& value, bool sendChangeEvent)
{
if (!m_inputType->canSetValue(value))
return;
setFormControlValueMatchesRenderer(false);
if (m_inputType->storesValueSeparateFromAttribute()) {
if (files())
files()->clear();
else {
m_value = sanitizeValue(value);
if (isTextField())
updatePlaceholderVisibility(false);
}
setNeedsStyleRecalc();
} else
setAttribute(valueAttr, sanitizeValue(value));
setNeedsValidityCheck();
if (isTextField()) {
unsigned max = m_value.length();
if (document()->focusedNode() == this)
WebCore::setSelectionRange(this, max, max);
else
cacheSelection(max, max);
m_suggestedValue = String();
}
m_inputType->valueChanged();
if (sendChangeEvent) {
if (isTextField() && focused())
dispatchFormControlInputEvent();
else
dispatchFormControlChangeEvent();
}
if (isText() && (!focused() || !sendChangeEvent))
setTextAsOfLastFormControlChangeEvent(value);
notifyFormStateChanged();
}
double HTMLInputElement::valueAsDate() const
{
return m_inputType->valueAsDate();
}
void HTMLInputElement::setValueAsDate(double value, ExceptionCode& ec)
{
m_inputType->setValueAsDate(value, ec);
}
double HTMLInputElement::valueAsNumber() const
{
return m_inputType->valueAsNumber();
}
void HTMLInputElement::setValueAsNumber(double newValue, ExceptionCode& ec)
{
if (!isfinite(newValue)) {
ec = NOT_SUPPORTED_ERR;
return;
}
m_inputType->setValueAsNumber(newValue, ec);
}
String HTMLInputElement::placeholder() const
{
return fastGetAttribute(placeholderAttr).string();
}
void HTMLInputElement::setPlaceholder(const String& value)
{
setAttribute(placeholderAttr, value);
}
bool HTMLInputElement::searchEventsShouldBeDispatched() const
{
return hasAttribute(incrementalAttr);
}
void HTMLInputElement::setValueFromRenderer(const String& value)
{
ASSERT(!isFileUpload());
m_suggestedValue = String();
ASSERT(value == sanitizeValue(value) || sanitizeValue(value).isEmpty());
m_value = value == "\n" ? String("") : value;
setFormControlValueMatchesRenderer(true);
if (!isTextField())
dispatchInputEvent();
notifyFormStateChanged();
updatePlaceholderVisibility(false);
setNeedsValidityCheck();
setAutofilled(false);
}
void HTMLInputElement::setFileListFromRenderer(const Vector<String>& paths)
{
m_inputType->setFileList(paths);
setFormControlValueMatchesRenderer(true);
notifyFormStateChanged();
setNeedsValidityCheck();
}
void* HTMLInputElement::preDispatchEventHandler(Event* event)
{
if (event->type() == eventNames().textInputEvent && m_inputType->shouldSubmitImplicitly(event)) {
event->stopPropagation();
return 0;
}
if (event->type() != eventNames().clickEvent)
return 0;
if (!event->isMouseEvent() || static_cast<MouseEvent*>(event)->button() != LeftButton)
return 0;
return m_inputType->willDispatchClick().leakPtr();
}
void HTMLInputElement::postDispatchEventHandler(Event* event, void* dataFromPreDispatch)
{
OwnPtr<ClickHandlingState> state = adoptPtr(static_cast<ClickHandlingState*>(dataFromPreDispatch));
if (!state)
return;
m_inputType->didDispatchClick(event, *state);
}
void HTMLInputElement::defaultEventHandler(Event* evt)
{
if (evt->isMouseEvent() && evt->type() == eventNames().clickEvent && static_cast<MouseEvent*>(evt)->button() == LeftButton) {
m_inputType->handleClickEvent(static_cast<MouseEvent*>(evt));
if (evt->defaultHandled())
return;
}
if (evt->isKeyboardEvent() && evt->type() == eventNames().keydownEvent) {
m_inputType->handleKeydownEvent(static_cast<KeyboardEvent*>(evt));
if (evt->defaultHandled())
return;
}
bool callBaseClassEarly = isTextField() && (evt->type() == eventNames().keydownEvent || evt->type() == eventNames().keypressEvent);
if (callBaseClassEarly) {
HTMLFormControlElementWithState::defaultEventHandler(evt);
if (evt->defaultHandled())
return;
}
if (evt->type() == eventNames().DOMActivateEvent) {
m_inputType->handleDOMActivateEvent(evt);
if (evt->defaultHandled())
return;
}
if (evt->isKeyboardEvent() && evt->type() == eventNames().keypressEvent) {
m_inputType->handleKeypressEvent(static_cast<KeyboardEvent*>(evt));
if (evt->defaultHandled())
return;
}
if (evt->isKeyboardEvent() && evt->type() == eventNames().keyupEvent) {
m_inputType->handleKeyupEvent(static_cast<KeyboardEvent*>(evt));
if (evt->defaultHandled())
return;
}
if (m_inputType->shouldSubmitImplicitly(evt)) {
if (isSearchField()) {
addSearchResult();
onSearch();
}
if (wasChangedSinceLastFormControlChangeEvent())
dispatchFormControlChangeEvent();
RefPtr<HTMLFormElement> formForSubmission = m_inputType->formForSubmission();
if (formForSubmission)
formForSubmission->submitImplicitly(evt, canTriggerImplicitSubmission());
evt->setDefaultHandled();
return;
}
if (evt->isBeforeTextInsertedEvent())
m_inputType->handleBeforeTextInsertedEvent(static_cast<BeforeTextInsertedEvent*>(evt));
if (evt->isWheelEvent()) {
m_inputType->handleWheelEvent(static_cast<WheelEvent*>(evt));
if (evt->defaultHandled())
return;
}
if (evt->isMouseEvent() && evt->type() == eventNames().mousedownEvent) {
m_inputType->handleMouseDownEvent(static_cast<MouseEvent*>(evt));
if (evt->defaultHandled())
return;
}
m_inputType->forwardEvent(evt);
if (!callBaseClassEarly && !evt->defaultHandled())
HTMLFormControlElementWithState::defaultEventHandler(evt);
}
bool HTMLInputElement::isURLAttribute(Attribute *attr) const
{
return (attr->name() == srcAttr || attr->name() == formactionAttr);
}
String HTMLInputElement::defaultValue() const
{
return fastGetAttribute(valueAttr);
}
void HTMLInputElement::setDefaultValue(const String &value)
{
setAttribute(valueAttr, value);
}
void HTMLInputElement::setDefaultName(const AtomicString& name)
{
m_name = name;
}
String HTMLInputElement::accept() const
{
return fastGetAttribute(acceptAttr);
}
String HTMLInputElement::alt() const
{
return fastGetAttribute(altAttr);
}
int HTMLInputElement::maxLength() const
{
return m_maxLength;
}
void HTMLInputElement::setMaxLength(int maxLength, ExceptionCode& ec)
{
if (maxLength < 0)
ec = INDEX_SIZE_ERR;
else
setAttribute(maxlengthAttr, String::number(maxLength));
}
bool HTMLInputElement::multiple() const
{
return fastHasAttribute(multipleAttr);
}
void HTMLInputElement::setSize(unsigned size)
{
setAttribute(sizeAttr, String::number(size));
}
KURL HTMLInputElement::src() const
{
return document()->completeURL(fastGetAttribute(srcAttr));
}
void HTMLInputElement::setAutofilled(bool autofilled)
{
if (autofilled == m_isAutofilled)
return;
m_isAutofilled = autofilled;
setNeedsStyleRecalc();
}
FileList* HTMLInputElement::files()
{
return m_inputType->files();
}
String HTMLInputElement::visibleValue() const
{
return m_inputType->visibleValue();
}
String HTMLInputElement::convertFromVisibleValue(const String& visibleValue) const
{
return m_inputType->convertFromVisibleValue(visibleValue);
}
bool HTMLInputElement::isAcceptableValue(const String& proposedValue) const
{
return m_inputType->isAcceptableValue(proposedValue);
}
String HTMLInputElement::sanitizeValue(const String& proposedValue) const
{
return m_inputType->sanitizeValue(proposedValue);
}
bool HTMLInputElement::hasUnacceptableValue() const
{
return m_inputType->hasUnacceptableValue();
}
bool HTMLInputElement::isInRange() const
{
return m_inputType->supportsRangeLimitation() && !rangeUnderflow(value()) && !rangeOverflow(value());
}
bool HTMLInputElement::isOutOfRange() const
{
return m_inputType->supportsRangeLimitation() && (rangeUnderflow(value()) || rangeOverflow(value()));
}
bool HTMLInputElement::needsActivationCallback()
{
return m_autocomplete == Off || m_inputType->shouldResetOnDocumentActivation();
}
void HTMLInputElement::registerForActivationCallbackIfNeeded()
{
if (needsActivationCallback())
document()->registerForDocumentActivationCallbacks(this);
}
void HTMLInputElement::unregisterForActivationCallbackIfNeeded()
{
if (!needsActivationCallback())
document()->unregisterForDocumentActivationCallbacks(this);
}
bool HTMLInputElement::isRequiredFormControl() const
{
return m_inputType->supportsRequired() && required();
}
void HTMLInputElement::cacheSelection(int start, int end)
{
m_cachedSelectionStart = start;
m_cachedSelectionEnd = end;
}
void HTMLInputElement::addSearchResult()
{
ASSERT(isSearchField());
if (renderer())
toRenderTextControlSingleLine(renderer())->addSearchResult();
}
void HTMLInputElement::onSearch()
{
ASSERT(isSearchField());
if (renderer())
toRenderTextControlSingleLine(renderer())->stopSearchEventTimer();
dispatchEvent(Event::create(eventNames().searchEvent, true, false));
}
void HTMLInputElement::documentDidBecomeActive()
{
ASSERT(needsActivationCallback());
reset();
}
void HTMLInputElement::willMoveToNewOwnerDocument()
{
m_inputType->willMoveToNewOwnerDocument();
if (needsActivationCallback())
document()->unregisterForDocumentActivationCallbacks(this);
document()->checkedRadioButtons().removeButton(this);
HTMLFormControlElementWithState::willMoveToNewOwnerDocument();
}
void HTMLInputElement::didMoveToNewOwnerDocument()
{
registerForActivationCallbackIfNeeded();
HTMLFormControlElementWithState::didMoveToNewOwnerDocument();
}
void HTMLInputElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
{
HTMLFormControlElementWithState::addSubresourceAttributeURLs(urls);
addSubresourceURL(urls, src());
}
bool HTMLInputElement::recalcWillValidate() const
{
return m_inputType->supportsValidation() && HTMLFormControlElementWithState::recalcWillValidate();
}
#if ENABLE(DATALIST)
HTMLElement* HTMLInputElement::list() const
{
return dataList();
}
HTMLDataListElement* HTMLInputElement::dataList() const
{
if (!m_hasNonEmptyList)
return 0;
if (!m_inputType->shouldRespectListAttribute())
return 0;
Element* element = treeScope()->getElementById(fastGetAttribute(listAttr));
if (!element)
return 0;
if (!element->hasTagName(datalistTag))
return 0;
return static_cast<HTMLDataListElement*>(element);
}
HTMLOptionElement* HTMLInputElement::selectedOption() const
{
String value = this->value();
if (value.isEmpty())
return 0;
HTMLDataListElement* sourceElement = dataList();
if (!sourceElement)
return 0;
RefPtr<HTMLCollection> options = sourceElement->options();
if (!options)
return 0;
unsigned length = options->length();
for (unsigned i = 0; i < length; ++i) {
HTMLOptionElement* option = static_cast<HTMLOptionElement*>(options->item(i));
if (!option->disabled() && value == option->value())
return option;
}
return 0;
}
#endif // ENABLE(DATALIST)
bool HTMLInputElement::isSteppable() const
{
return m_inputType->isSteppable();
}
void HTMLInputElement::stepUpFromRenderer(int n)
{
ASSERT(isSteppable());
if (!isSteppable())
return;
ASSERT(n);
if (!n)
return;
unsigned stepDecimalPlaces, baseDecimalPlaces;
double step, base;
if (equalIgnoringCase(fastGetAttribute(stepAttr), "any"))
step = 0;
else if (!getAllowedValueStepWithDecimalPlaces(&step, &stepDecimalPlaces))
return;
base = m_inputType->stepBaseWithDecimalPlaces(&baseDecimalPlaces);
baseDecimalPlaces = min(baseDecimalPlaces, 16u);
int sign;
if (step > 0)
sign = n;
else if (step < 0)
sign = -n;
else
sign = 0;
const double nan = numeric_limits<double>::quiet_NaN();
String currentStringValue = value();
double current = m_inputType->parseToDouble(currentStringValue, nan);
if (!isfinite(current)) {
ExceptionCode ec;
current = m_inputType->defaultValueForStepUp();
double nextDiff = step * n;
if (current < m_inputType->minimum() - nextDiff)
current = m_inputType->minimum() - nextDiff;
if (current > m_inputType->maximum() - nextDiff)
current = m_inputType->maximum() - nextDiff;
setValueAsNumber(current, ec);
}
if ((sign > 0 && current < m_inputType->minimum()) || (sign < 0 && current > m_inputType->maximum()))
setValue(m_inputType->serialize(sign > 0 ? m_inputType->minimum() : m_inputType->maximum()));
else {
ExceptionCode ec;
if (stepMismatch(value())) {
ASSERT(step);
double newValue;
double scale = pow(10.0, static_cast<double>(max(stepDecimalPlaces, baseDecimalPlaces)));
if (sign < 0)
newValue = round((base + floor((current - base) / step) * step) * scale) / scale;
else if (sign > 0)
newValue = round((base + ceil((current - base) / step) * step) * scale) / scale;
else
newValue = current;
if (newValue < m_inputType->minimum())
newValue = m_inputType->minimum();
if (newValue > m_inputType->maximum())
newValue = m_inputType->maximum();
setValueAsNumber(newValue, ec);
current = newValue;
if (n > 1)
applyStep(n - 1, ec);
else if (n < -1)
applyStep(n + 1, ec);
} else
applyStep(n, ec);
}
if (currentStringValue != value()) {
if (m_inputType->isRangeControl())
dispatchFormControlChangeEvent();
else
dispatchFormControlInputEvent();
}
}
#if ENABLE(WCSS)
static inline const AtomicString& formatCodes()
{
DEFINE_STATIC_LOCAL(AtomicString, codes, ("AaNnXxMm"));
return codes;
}
static unsigned cursorPositionToMaskIndex(const String& inputFormatMask, unsigned cursorPosition)
{
UChar mask;
int index = -1;
do {
mask = inputFormatMask[++index];
if (mask == '\\')
++index;
else if (mask == '*' || (isASCIIDigit(mask) && mask != '0')) {
index = inputFormatMask.length() - 1;
break;
}
} while (cursorPosition--);
return index;
}
bool HTMLInputElement::isConformToInputMask(const String& inputChars) const
{
for (unsigned i = 0; i < inputChars.length(); ++i) {
if (!isConformToInputMask(inputChars[i], i))
return false;
}
return true;
}
bool HTMLInputElement::isConformToInputMask(UChar inChar, unsigned cursorPosition) const
{
if (m_inputFormatMask.isEmpty() || m_inputFormatMask == "*M" || m_inputFormatMask == "*m")
return true;
if (cursorPosition >= m_maxInputCharsAllowed())
return false;
unsigned maskIndex = cursorPositionToMaskIndex(m_inputFormatMask, cursorPosition);
bool ok = true;
UChar mask = m_inputFormatMask[maskIndex];
switch (mask) {
case 'A':
ok = !isASCIIDigit(inChar) && !isASCIILower(inChar) && isASCIIPrintable(inChar);
break;
case 'a':
ok = !isASCIIDigit(inChar) && !isASCIIUpper(inChar) && isASCIIPrintable(inChar);
break;
case 'N':
ok = isASCIIDigit(inChar);
break;
case 'n':
ok = !isASCIIAlpha(inChar) && isASCIIPrintable(inChar);
break;
case 'X':
ok = !isASCIILower(inChar) && isASCIIPrintable(inChar);
break;
case 'x':
ok = !isASCIIUpper(inChar) && isASCIIPrintable(inChar);
break;
case 'M':
case 'm':
ok = isASCIIPrintable(inChar);
break;
default:
ok = (mask == inChar);
break;
}
return ok;
}
String HTMLInputElement::validateInputMask(String& inputMask)
{
inputMask.replace("\\\\", "\\");
bool isValid = true;
bool hasWildcard = false;
unsigned escapeCharCount = 0;
unsigned maskLength = inputMask.length();
UChar formatCode;
for (unsigned i = 0; i < maskLength; ++i) {
formatCode = inputMask[i];
if (formatCodes().find(formatCode) == -1) {
if (formatCode == '*' || (isASCIIDigit(formatCode) && formatCode != '0')) {
formatCode = inputMask[++i];
if ((i + 1 != maskLength) || formatCodes().find(formatCode) == -1) {
isValid = false;
break;
}
hasWildcard = true;
} else if (formatCode == '\\') {
++i;
++escapeCharCount;
} else {
isValid = false;
break;
}
}
}
if (!isValid)
return String();
unsigned allowedLength = maskLength;
if (escapeCharCount)
allowedLength -= escapeCharCount;
if (hasWildcard) {
formatCode = inputMask[maskLength - 2];
if (formatCode == '*')
allowedLength = m_maxInputCharsAllowed;
else {
unsigned leftLen = String(&formatCode).toInt();
allowedLength = leftLen + allowedLength - 2;
}
}
if (allowedLength < m_maxInputCharsAllowed)
m_maxInputCharsAllowed = allowedLength;
return inputMask;
}
void HTMLInputElement::setWapInputFormat(String& mask)
{
String validateMask = validateInputMask(mask);
if (!validateMask.isEmpty())
m_inputFormatMask = validateMask;
}
#endif
#if ENABLE(INPUT_SPEECH)
bool HTMLInputElement::isSpeechEnabled() const
{
return m_inputType->shouldRespectSpeechAttribute() && RuntimeEnabledFeatures::speechInputEnabled() && hasAttribute(webkitspeechAttr);
}
#endif
bool HTMLInputElement::isTextButton() const
{
return m_inputType->isTextButton();
}
bool HTMLInputElement::isRadioButton() const
{
return m_inputType->isRadioButton();
}
bool HTMLInputElement::isSearchField() const
{
return m_inputType->isSearchField();
}
bool HTMLInputElement::isInputTypeHidden() const
{
return m_inputType->isHiddenType();
}
bool HTMLInputElement::isPasswordField() const
{
return m_inputType->isPasswordField();
}
bool HTMLInputElement::isCheckbox() const
{
return m_inputType->isCheckbox();
}
bool HTMLInputElement::isRangeControl() const
{
return m_inputType->isRangeControl();
}
bool HTMLInputElement::isText() const
{
return m_inputType->isTextType();
}
bool HTMLInputElement::isEmailField() const
{
return m_inputType->isEmailField();
}
bool HTMLInputElement::isFileUpload() const
{
return m_inputType->isFileUpload();
}
bool HTMLInputElement::isImageButton() const
{
return m_inputType->isImageButton();
}
bool HTMLInputElement::isNumberField() const
{
return m_inputType->isNumberField();
}
bool HTMLInputElement::isSubmitButton() const
{
return m_inputType->isSubmitButton();
}
bool HTMLInputElement::isTelephoneField() const
{
return m_inputType->isTelephoneField();
}
bool HTMLInputElement::isURLField() const
{
return m_inputType->isURLField();
}
bool HTMLInputElement::isEnumeratable() const
{
return m_inputType->isEnumeratable();
}
bool HTMLInputElement::isChecked() const
{
return checked() && m_inputType->isCheckable();
}
bool HTMLInputElement::supportsPlaceholder() const
{
return isTextType();
}
CheckedRadioButtons& HTMLInputElement::checkedRadioButtons() const
{
if (HTMLFormElement* formElement = form())
return formElement->checkedRadioButtons();
return document()->checkedRadioButtons();
}
void HTMLInputElement::notifyFormStateChanged()
{
Frame* frame = document()->frame();
if (!frame)
return;
if (Page* page = frame->page())
page->chrome()->client()->formStateDidChange(this);
}
void HTMLInputElement::parseMaxLengthAttribute(Attribute* attribute)
{
int maxLength = attribute->isNull() ? maximumLength : attribute->value().toInt();
if (maxLength <= 0 || maxLength > maximumLength)
maxLength = maximumLength;
int oldMaxLength = m_maxLength;
m_maxLength = maxLength;
if (oldMaxLength != maxLength)
updateValueIfNeeded();
setNeedsStyleRecalc();
setNeedsValidityCheck();
}
void HTMLInputElement::updateValueIfNeeded()
{
String newValue = sanitizeValue(m_value);
if (newValue != m_value)
setValue(newValue);
}
}