Merge WebKit at r73109: Initial merge by git.

[android-x86/external-webkit.git] / WebCore / html / InputType.h

diff --git a/WebCore/html/InputType.h b/WebCore/html/InputType.h
index 3141f34..f275ae8 100644 (file)
--- a/WebCore/html/InputType.h
+++ b/WebCore/html/InputType.h
@@ -31,28 +31,121 @@
 #ifndef InputType_h
 #define InputType_h
 
+#include "ExceptionCode.h"
 #include <wtf/Forward.h>
 #include <wtf/Noncopyable.h>
 
 namespace WebCore {
 
+class DateComponents;
+class Event;
+class FormDataList;
 class HTMLInputElement;
+class KeyboardEvent;
+class MouseEvent;
+class RenderArena;
+class RenderObject;
+class RenderStyle;
 
+// An InputType object represents the type-specific part of an HTMLInputElement.
+// Do not expose instances of InputType and classes derived from it to classes
+// other than HTMLInputElement.
 class InputType : public Noncopyable {
 public:
     static PassOwnPtr<InputType> create(HTMLInputElement*, const AtomicString&);
     static PassOwnPtr<InputType> createText(HTMLInputElement*);
     virtual ~InputType();
 
+    // Type query functions
+
     virtual bool isTextField() const;
     virtual bool isTextType() const;
+    virtual bool isRangeControl() const;
     virtual const AtomicString& formControlType() const = 0;
 
+    // Form value functions
+
+    virtual bool saveFormControlState(String&) const;
+    virtual void restoreFormControlState(const String&) const;
+    virtual bool isFormDataAppendable() const;
+    virtual bool appendFormData(FormDataList&, bool multipart) const;
+
+    // DOM property functions
+
+    virtual double valueAsDate() const;
+    virtual void setValueAsDate(double, ExceptionCode&) const;
+    virtual double valueAsNumber() const;
+    virtual void setValueAsNumber(double, ExceptionCode&) const;
+
+    // Validation functions
+
+    virtual bool supportsValidation() const;
+    virtual bool typeMismatchFor(const String&) const;
+    // Type check for the current input value. We do nothing for some types
+    // though typeMismatchFor() does something for them because of value
+    // sanitization.
+    virtual bool typeMismatch() const;
+    virtual bool supportsRequired() const;
+    virtual bool valueMissing(const String&) const;
     virtual bool patternMismatch(const String&) const;
+    virtual bool rangeUnderflow(const String&) const;
+    virtual bool rangeOverflow(const String&) const;
+    virtual double defaultValueForStepUp() const;
+    virtual double minimum() const;
+    virtual double maximum() const;
+    virtual bool stepMismatch(const String&, double) const;
+    virtual double stepBase() const;
+    virtual double stepBaseWithDecimalPlaces(unsigned*) const;
+    virtual double defaultStep() const;
+    virtual double stepScaleFactor() const;
+    virtual bool parsedStepValueShouldBeInteger() const;
+    virtual bool scaledStepValeuShouldBeInteger() const;
+    virtual double acceptableError(double) const;
+    virtual String typeMismatchText() const;
+    virtual String valueMissingText() const;
+
+    // Event handlers
+    // If the return value is true, do no further default event handling in the
+    // default event handler. If an event handler calls Event::setDefaultHandled(),
+    // its return value must be true.
+
+    virtual bool handleClickEvent(MouseEvent*);
+    virtual bool handleDOMActivateEvent(Event*);
+    virtual bool handleKeydownEvent(KeyboardEvent*);
+    virtual bool handleKeypressEvent(KeyboardEvent*);
+    virtual bool handleKeyupEvent(KeyboardEvent*);
+    // A helper for event handlers.
+    virtual bool shouldSubmitImplicitly(Event*);
+
+    // Miscellaneous functions
+
+    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*) const;
+
+    // Parses the specified string for the type, and return
+    // the double value for the parsing result if the parsing
+    // succeeds; Returns defaultValue otherwise. This function can
+    // return NaN or Infinity only if defaultValue is NaN or Infinity.
+    virtual double parseToDouble(const String&, double defaultValue) const;
+    // Parses the specified string for the type as parseToDouble() does.
+    // In addition, it stores the number of digits after the decimal point
+    // into *decimalPlaces.
+    virtual double parseToDoubleWithDecimalPlaces(const String& src, double defaultValue, unsigned *decimalPlaces) const;
+    // Parses the specified string for this InputType, and returns true if it
+    // is successfully parsed. An instance pointed by the DateComponents*
+    // parameter will have parsed values and be modified even if the parsing
+    // fails. The DateComponents* parameter may be 0.
+    virtual bool parseToDateComponents(const String&, DateComponents*) const;
+    // Create a string representation of the specified double value for the
+    // input type. If NaN or Infinity is specified, this returns an empty
+    // string. This should not be called for types without valueAsNumber.
+    virtual String serialize(double) const;
 
 protected:
     InputType(HTMLInputElement* element) : m_element(element) { }
     HTMLInputElement* element() const { return m_element; }
+    void dispatchSimulatedClickIfActive(KeyboardEvent*) const;
+    // We can't make this a static const data member because VC++ doesn't like it.
+    static double defaultStepBase() { return 0.0; }
 
 private:
     // Raw pointer because the HTMLInputElement object owns this InputType object.