# Source code for wtforms.fields.simple

    from .. import widgets
    from .core import Field

    __all__ = (
        "BooleanField",
        "TextAreaField",
        "PasswordField",
        "FileField",
        "MultipleFileField",
        "HiddenField",
        "SearchField",
        "SubmitField",
        "StringField",
        "TelField",
        "URLField",
        "EmailField",
        "ColorField",
    )

    class BooleanField(Field):
        """
        Represents an ``<input type="checkbox">``. Set the ``checked``-status by using the
        ``default``-option. Any value for ``default``, e.g. ``default="checked"`` puts
        ``checked`` into the html-element and sets the ``data`` to ``True``

        :param false_values:
            If provided, a sequence of strings each of which is an exact match
            string of what is considered a "false" value. Defaults to the tuple
            ``(False, "false", "")``
        """

        widget = widgets.CheckboxInput()
        false_values = (False, "false", "")

        def __init__(self, label=None, validators=None, false_values=None, **kwargs):
            super().__init__(label, validators, **kwargs)
            if false_values is not None:
                self.false_values = false_values

        def process_data(self, value):
            self.data = bool(value)

        def process_formdata(self, valuelist):
            if not valuelist or valuelist[0] in self.false_values:
                self.data = False
            else:
                self.data = True

        def _value(self):
            if self.raw_data:
                return str(self.raw_data[0])
            return "y"

    class StringField(Field):
        """
        This field is the base for most of the more complicated fields, and
        represents an ``<input type="text">``.
        """

        widget = widgets.TextInput()

        def process_formdata(self, valuelist):
            if valuelist:
                self.data = valuelist[0]

        def _value(self):
            return str(self.data) if self.data is not None else ""

    class TextAreaField(StringField):
        """
        This field represents an HTML ``<textarea>`` and can be used to take
        multi-line input.
        """

        widget = widgets.TextArea()

    class PasswordField(StringField):
        """
        A StringField, except renders an ``<input type="password">``.

        Also, whatever value is accepted by this field is not rendered back
        to the browser like normal fields.
        """

        widget = widgets.PasswordInput()

    class FileField(Field):
        """Renders a file upload field.

        By default, the value will be the filename sent in the form data.
        WTForms **does not** deal with frameworks' file handling capabilities.
        A WTForms extension for a framework may replace the filename value
        with an object representing the uploaded data.
        """

        widget = widgets.FileInput()

        def _value(self):
            # browser ignores value of file input for security
            return False

    class MultipleFileField(FileField):
        """A :class:`FileField` that allows choosing multiple files."""

        widget = widgets.FileInput(multiple=True)

        def process_formdata(self, valuelist):
            self.data = valuelist

    class HiddenField(StringField):
        """
        HiddenField is a convenience for a StringField with a HiddenInput widget.

        It will render as an ``<input type="hidden">`` but otherwise coerce to a string.
        """

        widget = widgets.HiddenInput()

    class SubmitField(BooleanField):
        """
        Represents an ``<input type="submit">``.  This allows checking if a given
        submit button has been pressed.
        """

        widget = widgets.SubmitInput()

    class SearchField(StringField):
        """
        Represents an ``<input type="search">``.
        """

        widget = widgets.SearchInput()

    class TelField(StringField):
        """
        Represents an ``<input type="tel">``.
        """

        widget = widgets.TelInput()

    class URLField(StringField):
        """
        Represents an ``<input type="url">``.
        """

        widget = widgets.URLInput()

    class EmailField(StringField):
        """
        Represents an ``<input type="email">``.
        """

        widget = widgets.EmailInput()

    class ColorField(StringField):
        """
        Represents an ``<input type="color">``.
        """

        widget = widgets.ColorInput()