std::pair<String, String> InputType::validationMessage(const InputTypeView& inputTypeView) const { const String value = element().value(); // The order of the following checks is meaningful. e.g. We'd like to show the // badInput message even if the control has other validation errors. if (inputTypeView.hasBadInput()) return std::make_pair(badInputText(), emptyString()); if (valueMissing(value)) return std::make_pair(valueMissingText(), emptyString()); if (typeMismatch()) return std::make_pair(typeMismatchText(), emptyString()); if (patternMismatch(value)) { // https://html.spec.whatwg.org/multipage/forms.html#attr-input-pattern // When an input element has a pattern attribute specified, authors // should include a title attribute to give a description of the // pattern. User agents may use the contents of this attribute, if it // is present, when informing the user that the pattern is not matched return std::make_pair(locale().queryString(WebLocalizedString::ValidationPatternMismatch), element().fastGetAttribute(titleAttr).getString()); } if (element().tooLong()) return std::make_pair(locale().validationMessageTooLongText(value.length(), element().maxLength()), emptyString()); if (element().tooShort()) return std::make_pair(locale().validationMessageTooShortText(value.length(), element().minLength()), emptyString()); if (!isSteppable()) return std::make_pair(emptyString(), emptyString()); const Decimal numericValue = parseToNumberOrNaN(value); if (!numericValue.isFinite()) return std::make_pair(emptyString(), emptyString()); StepRange stepRange(createStepRange(RejectAny)); if (numericValue < stepRange.minimum()) return std::make_pair(rangeUnderflowText(stepRange.minimum()), emptyString()); if (numericValue > stepRange.maximum()) return std::make_pair(rangeOverflowText(stepRange.maximum()), emptyString()); if (stepRange.stepMismatch(numericValue)) { DCHECK(stepRange.hasStep()); Decimal candidate1 = stepRange.clampValue(numericValue); String localizedCandidate1 = localizeValue(serialize(candidate1)); Decimal candidate2 = candidate1 < numericValue ? candidate1 + stepRange.step() : candidate1 - stepRange.step(); if (!candidate2.isFinite() || candidate2 < stepRange.minimum() || candidate2 > stepRange.maximum()) return std::make_pair(locale().queryString(WebLocalizedString::ValidationStepMismatchCloseToLimit, localizedCandidate1), emptyString()); String localizedCandidate2 = localizeValue(serialize(candidate2)); if (candidate1 < candidate2) return std::make_pair(locale().queryString(WebLocalizedString::ValidationStepMismatch, localizedCandidate1, localizedCandidate2), emptyString()); return std::make_pair(locale().queryString(WebLocalizedString::ValidationStepMismatch, localizedCandidate2, localizedCandidate1), emptyString()); } return std::make_pair(emptyString(), emptyString()); }
void InputType::stepUp(int n, ExceptionCode& ec) { if (!isSteppable()) { ec = INVALID_STATE_ERR; return; } applyStep(n, RejectAny, DispatchNoEvent, ec); }
void InputType::stepUp(int n, ExceptionState& exceptionState) { if (!isSteppable()) { exceptionState.throwDOMException(InvalidStateError, "This form element is not steppable."); return; } const Decimal current = parseToNumber(element().value(), 0); applyStep(current, n, RejectAny, DispatchNoEvent, exceptionState); }
bool InputType::stepMismatch(const String& value) const { if (!isSteppable()) return false; const Decimal numericValue = parseToNumberOrNaN(value); if (!numericValue.isFinite()) return false; return createStepRange(RejectAny).stepMismatch(numericValue); }
bool InputType::rangeOverflow(const String& value) const { if (!isSteppable()) return false; const Decimal numericValue = parseToNumberOrNaN(value); if (!numericValue.isFinite()) return false; return numericValue > createStepRange(RejectAny).maximum(); }
bool InputType::isOutOfRange(const String& value) const { if (!isSteppable()) return false; const Decimal numericValue = parseToNumberOrNaN(value); if (!numericValue.isFinite()) return true; StepRange stepRange(createStepRange(RejectAny)); return numericValue < stepRange.minimum() || numericValue > stepRange.maximum(); }
bool InputType::isOutOfRange(const String& value) const { if (!isSteppable()) return false; // This function should return true if either validity.rangeUnderflow or // validity.rangeOverflow are true. // If the INPUT has no value, they are false. const Decimal numericValue = parseToNumberOrNaN(value); if (!numericValue.isFinite()) return false; StepRange stepRange(createStepRange(RejectAny)); return stepRange.hasRangeLimitations() && (numericValue < stepRange.minimum() || numericValue > stepRange.maximum()); }
bool InputType::isInRange(const String& value) const { if (!isSteppable()) return false; // This function should return true if both of validity.rangeUnderflow and // validity.rangeOverflow are false. // If the INPUT has no value, they are false. const Decimal numericValue = parseToNumberOrNaN(value); if (!numericValue.isFinite()) return true; StepRange stepRange(createStepRange(RejectAny)); return numericValue >= stepRange.minimum() && numericValue <= stepRange.maximum(); }
String InputType::validationMessage() const { String value = element().value(); // The order of the following checks is meaningful. e.g. We'd like to show the // badInput message even if the control has other validation errors. if (hasBadInput()) return badInputText(); if (valueMissing(value)) return valueMissingText(); if (typeMismatch()) return typeMismatchText(); if (patternMismatch(value)) return validationMessagePatternMismatchText(); if (element().tooLong()) return validationMessageTooLongText(numGraphemeClusters(value), element().maxLength()); if (!isSteppable()) return emptyString(); const Decimal numericValue = parseToNumberOrNaN(value); if (!numericValue.isFinite()) return emptyString(); StepRange stepRange(createStepRange(RejectAny)); if (numericValue < stepRange.minimum()) return validationMessageRangeUnderflowText(serialize(stepRange.minimum())); if (numericValue > stepRange.maximum()) return validationMessageRangeOverflowText(serialize(stepRange.maximum())); if (stepRange.stepMismatch(numericValue)) { const String stepString = stepRange.hasStep() ? serializeForNumberType(stepRange.step() / stepRange.stepScaleFactor()) : emptyString(); return validationMessageStepMismatchText(serialize(stepRange.stepBase()), stepString); } return emptyString(); }
void InputType::stepUpFromRenderer(int n) { // The differences from stepUp()/stepDown(): // // Difference 1: the current value // If the current value is not a number, including empty, the current value is assumed as 0. // * If 0 is in-range, and matches to step value // - The value should be the +step if n > 0 // - The value should be the -step if n < 0 // If -step or +step is out of range, new value should be 0. // * If 0 is smaller than the minimum value // - The value should be the minimum value for any n // * If 0 is larger than the maximum value // - The value should be the maximum value for any n // * If 0 is in-range, but not matched to step value // - The value should be the larger matched value nearest to 0 if n > 0 // e.g. <input type=number min=-100 step=3> -> 2 // - The value should be the smaler matched value nearest to 0 if n < 0 // e.g. <input type=number min=-100 step=3> -> -1 // As for date/datetime-local/month/time/week types, the current value is assumed as "the current local date/time". // As for datetime type, the current value is assumed as "the current date/time in UTC". // If the current value is smaller than the minimum value: // - The value should be the minimum value if n > 0 // - Nothing should happen if n < 0 // If the current value is larger than the maximum value: // - The value should be the maximum value if n < 0 // - Nothing should happen if n > 0 // // Difference 2: clamping steps // If the current value is not matched to step value: // - The value should be the larger matched value nearest to 0 if n > 0 // e.g. <input type=number value=3 min=-100 step=3> -> 5 // - The value should be the smaler matched value nearest to 0 if n < 0 // e.g. <input type=number value=3 min=-100 step=3> -> 2 // // n is assumed as -n if step < 0. ASSERT(isSteppable()); if (!isSteppable()) return; ASSERT(n); if (!n) return; StepRange stepRange(createStepRange(AnyIsDefaultStep)); // FIXME: Not any changes after stepping, even if it is an invalid value, may be better. // (e.g. Stepping-up for <input type="number" value="foo" step="any" /> => "foo") if (!stepRange.hasStep()) return; EventQueueScope scope; const Decimal step = stepRange.step(); int sign; if (step > 0) sign = n; else if (step < 0) sign = -n; else sign = 0; String currentStringValue = element().value(); Decimal current = parseToNumberOrNaN(currentStringValue); if (!current.isFinite()) { current = defaultValueForStepUp(); const Decimal nextDiff = step * n; if (current < stepRange.minimum() - nextDiff) current = stepRange.minimum() - nextDiff; if (current > stepRange.maximum() - nextDiff) current = stepRange.maximum() - nextDiff; setValueAsDecimal(current, DispatchNoEvent, IGNORE_EXCEPTION); } if ((sign > 0 && current < stepRange.minimum()) || (sign < 0 && current > stepRange.maximum())) setValueAsDecimal(sign > 0 ? stepRange.minimum() : stepRange.maximum(), DispatchInputAndChangeEvent, IGNORE_EXCEPTION); else { if (stepMismatch(element().value())) { ASSERT(!step.isZero()); const Decimal base = stepRange.stepBase(); Decimal newValue; if (sign < 0) newValue = base + ((current - base) / step).floor() * step; else if (sign > 0) newValue = base + ((current - base) / step).ceiling() * step; else newValue = current; if (newValue < stepRange.minimum()) newValue = stepRange.minimum(); if (newValue > stepRange.maximum()) newValue = stepRange.maximum(); setValueAsDecimal(newValue, n == 1 || n == -1 ? DispatchInputAndChangeEvent : DispatchNoEvent, IGNORE_EXCEPTION); if (n > 1) applyStep(n - 1, AnyIsDefaultStep, DispatchInputAndChangeEvent, IGNORE_EXCEPTION); else if (n < -1) applyStep(n + 1, AnyIsDefaultStep, DispatchInputAndChangeEvent, IGNORE_EXCEPTION); } else applyStep(n, AnyIsDefaultStep, DispatchInputAndChangeEvent, IGNORE_EXCEPTION); } }
void InputType::stepUpFromLayoutObject(int n) { // The only difference from stepUp()/stepDown() is the extra treatment // of the current value before applying the step: // // If the current value is not a number, including empty, the current value is assumed as 0. // * If 0 is in-range, and matches to step value // - The value should be the +step if n > 0 // - The value should be the -step if n < 0 // If -step or +step is out of range, new value should be 0. // * If 0 is smaller than the minimum value // - The value should be the minimum value for any n // * If 0 is larger than the maximum value // - The value should be the maximum value for any n // * If 0 is in-range, but not matched to step value // - The value should be the larger matched value nearest to 0 if n > 0 // e.g. <input type=number min=-100 step=3> -> 2 // - The value should be the smaler matched value nearest to 0 if n < 0 // e.g. <input type=number min=-100 step=3> -> -1 // As for date/datetime-local/month/time/week types, the current value is assumed as "the current local date/time". // As for datetime type, the current value is assumed as "the current date/time in UTC". // If the current value is smaller than the minimum value: // - The value should be the minimum value if n > 0 // - Nothing should happen if n < 0 // If the current value is larger than the maximum value: // - The value should be the maximum value if n < 0 // - Nothing should happen if n > 0 // // n is assumed as -n if step < 0. DCHECK(isSteppable()); if (!isSteppable()) return; DCHECK(n); if (!n) return; StepRange stepRange(createStepRange(AnyIsDefaultStep)); // FIXME: Not any changes after stepping, even if it is an invalid value, may be better. // (e.g. Stepping-up for <input type="number" value="foo" step="any" /> => "foo") if (!stepRange.hasStep()) return; EventQueueScope scope; const Decimal step = stepRange.step(); int sign; if (step > 0) sign = n; else if (step < 0) sign = -n; else sign = 0; Decimal current = parseToNumberOrNaN(element().value()); if (!current.isFinite()) { current = defaultValueForStepUp(); const Decimal nextDiff = step * n; if (current < stepRange.minimum() - nextDiff) current = stepRange.minimum() - nextDiff; if (current > stepRange.maximum() - nextDiff) current = stepRange.maximum() - nextDiff; setValueAsDecimal(current, DispatchNoEvent, IGNORE_EXCEPTION); } if ((sign > 0 && current < stepRange.minimum()) || (sign < 0 && current > stepRange.maximum())) { setValueAsDecimal(sign > 0 ? stepRange.minimum() : stepRange.maximum(), DispatchChangeEvent, IGNORE_EXCEPTION); return; } if ((sign > 0 && current >= stepRange.maximum()) || (sign < 0 && current <= stepRange.minimum())) return; applyStep(current, n, AnyIsDefaultStep, DispatchChangeEvent, IGNORE_EXCEPTION); }