NAME

     QValidator - Validation of input text

SYNOPSIS

     #include <qvalidator.h>

     Inherits QObject.

     Inherited by QIntValidator, QDoubleValidator, and
     QRegExpValidator.

  Public Members
     QValidator ( QObject * parent, const char * name = 0 )
     ~QValidator ()
     enum State { Invalid, Intermediate, Valid = Intermediate,
         Acceptable }
     virtual State validate ( QString & input, int & pos ) const
         = 0
     virtual void fixup ( QString & input ) const

DESCRIPTION

     The QValidator class provides validation of input text.

     The class itself is abstract. Two subclasses, QIntValidator
     and QDoubleValidator, provide basic numeric-range checking,
     and QRegExpValidator provides general checking using a
     custom regular expression.

     If the built-in validators aren't sufficient, you can
     subclass QValidator. The class has two virtual functions:
     validate() and fixup().

     validate() must be implemented by every subclass. It returns
     Invalid, Intermediate or Acceptable depending on whether its
     argument is valid (for the subclass's definition of valid).

     These three states require some explanation. An Invalid
     string is clearly invalid. Intermediate is less obvious: the
     concept of validity is slippery when the string is
     incomplete (still being edited). QValidator defines
     Intermediate as the property of a string that is neither
     clearly invalid nor acceptable as a final result. Acceptable
     means that the string is acceptable as a final result. One
     might say that any string that is a plausible intermediate
     state during entry of an Acceptable string is Intermediate.

     Here are some examples:



and 666 are Acceptable, the empty string and 1114 are
Intermediate and asdf is Invalid.
     For a line edit that accepts integers from 0 to 999 inclusive, 42



is Acceptable, "http://www.trolltech.com/," is Intermediate (it
might be a cut-and-paste that accidentally took in a comma at the
end), the empty string is valid (the user might select and delete
all of the text in preparation of entering a new URL) and"
http:///./" is Invalid.
     For an editable combobox that accepts URLs, any well-
          formed URL



Acceptable, "11" and the empty string are Intermediate and"
http://www.trolltech.com" and "hour" are Invalid.
     For a spin box that accepts lengths, "11cm" and "1in" are



     fixup() is provided for validators that can repair some user
     errors. The default implementation does nothing. QLineEdit,
     for example, will call fixup() if the user presses Enter (or
     Return) and the content is not currently valid. This allows
     the fixup() function the opportunity of performing some
     magic to make an Invalid string Acceptable.

     QValidator is typically used with QLineEdit, QSpinBox and
     QComboBox.

     See also Miscellaneous Classes.

  Member Type Documentation

QValidator::State

     This enum type defines the states in which a validated
     string can exist.

     QValidator::Invalid - the string is clearly invalid.

value during editing.
     QValidator::Intermediate -
           the string is a plausible intermediate

result, i.e. it is valid.
     QValidator::Acceptable - the string is acceptable as a final

MEMBER FUNCTION DOCUMENTATION

QValidator::QValidator ( QObject * parent, const char * name = 0

     )
     Sets up the validator. The parent and name parameters are
     passed on to the QObject constructor.

QValidator::~QValidator ()

     Destroys the validator, freeing any storage and other
     resources used.

void QValidator::fixup ( QString & input ) const [virtual]

     This function attempts to change input to be valid according
     to this validator's rules. It need not result in a valid
     string: callers of this function must re-test afterwards;
     the default does nothing.

     Reimplementations of this function can change input even if
     they do not produce a valid string. For example, an ISBN
     validator might want to delete every character except digits
     and "-", even if the result is still not a valid ISBN; a
     surname validator might want to remove whitespace from the
     start and end of the string, even if the resulting string is
     not in the list of accepted surnames.

State QValidator::validate ( QString & input, int & pos ) const

     [pure virtual]
     This pure virtual function returns Invalid if input is
     invalid according to this validator's rules, Intermediate if
     it is likely that a little more editing will make the input
     acceptable (e.g. the user types '4' into a widget which
     accepts integers between 10 and 99) and Acceptable if the
     input is valid.

     The function can change input and pos (the cursor position)
     if it wants to.

     Reimplemented in QIntValidator, QDoubleValidator, and
     QRegExpValidator.

SEE ALSO

     http://doc.trolltech.com/qvalidator.html
     http://www.trolltech.com/faq/tech.html

COPYRIGHT

     Copyright 1992-2001 Trolltech AS, http://www.trolltech.com.
     See the license file included in the distribution for a
     complete license statement.

AUTHOR

     Generated automatically from the source code.

BUGS

     If you find a bug in Qt, please report it as described in
     http://doc.trolltech.com/bughowto.html.  Good bug reports
     help us to help you. Thank you.


     The definitive Qt documentation is provided in HTML format;
     it is located at $QTDIR/doc/html and can be read using Qt
     Assistant or with a web browser. This man page is provided
     as a convenience for those users who prefer man pages,
     although this format is not officially supported by
     Trolltech.

     If you find errors in this manual page, please report them
     to qt-bugs@trolltech.com.  Please include the name of the
     manual page (qvalidator.3qt) and the Qt version (3.2.0b2).