Imported Upstream version 0.1.0~b2upstream/0.1.0.b2

1 files changed, 383 insertions, 0 deletions

diff --git a/rapid/ValidatedEntry.py b/rapid/ValidatedEntry.py
new file mode 100644
index 0000000..cb453f4
--- /dev/null
+++ b/rapid/ValidatedEntry.py
@@ -0,0 +1,383 @@
+# Copyright (c) 2006, Daniel J. Popowich
+# 
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+# Send bug reports and contributions to:
+#
+#    dpopowich AT astro dot umass dot edu
+#
+
+'''
+ValidatedEntry.py
+
+Provides ValidatedEntry, a subclass of gtk.Entry which validates
+input.
+
+Usage: create an instance of ValidatedEntry, specifying the function
+to validate input.  E.g.:
+
+ :   def money(text):
+ :       "validate input to be monetary value"
+ :       ...
+ :
+ :   money_entry = ValidatedEntry(money)
+
+Validation functions must accept one argument, the text to be
+validated, and must return one of:
+
+    1: the input is valid.
+    0: the input is invalid and should not be displayed.
+   -1: the input is partially valid and will be displayed (and by
+       default with a different background color).
+
+Three module-level variables are defined for the convenience of
+validation function writers: VALID (1), INVALID (0), PARTIAL (-1).
+
+There is one public method, isvalid(), which will return True if the
+current text is valid.
+
+Note: care should be taken when implementing validation functions to
+allow empty strings to be VALID or at least PARTIAL.  An empty string
+should never be INVALID.
+
+Note: the hooks for calling the validation function are implemented by
+connecting the object to handlers for the gtk.Editable "insert-text"
+and "delete-text" signals.  These handlers are connected to instances
+in the constructor, so will, by default, be called before other
+handlers connected to the widgets for "*-text" signals.  When input is
+INVALID, stop_emission() is called, so later handlers for "*-text"
+signals will not be called.
+
+See the doc string for ValidatedEntry.__init__ for more details.
+
+'''
+
+import pygtk
+pygtk.require('2.0')
+
+import gtk
+import gtk.gdk
+
+if gtk.gtk_version < (2, 8):
+    import warnings
+
+    msg ='''This module was developed and tested with version 2.8.9 of gtk.
+You are using version %d.%d.%d.  Your milage may vary''' % gtk.gtk_version
+    warnings.warn(msg)
+
+# major, minor, patch
+version = 1, 0, 4
+
+PARTIAL, INVALID, VALID = range(-1,2)
+
+class ValidatedEntry(gtk.Entry):
+
+    white = gtk.gdk.color_parse('white')
+    yellow = gtk.gdk.color_parse('yellow')
+
+    def __init__(self, valid_func,
+                 max=0,
+                 use_bg=True, valid_bg=white, partial_bg=yellow,
+                 error_func=None):
+        '''
+        Create instance of validating gtk.Entry.
+
+        valid_func: the function to validate input.  See module doc
+                    string for details.
+
+        max: passed to gtk.Entry constructor. (default: 0)
+
+        use_bg: if True (the default) set the base color of the
+                widget to indicate validity; see valid_bg and partial_bg.
+
+        valid_bg: a gtk.gdk.Color; the base color of the widget when
+                  the input is valid. (default: white)
+
+        partial_bg: a gtk.gdk.Color; the base color of the widget when
+                    the input is partially valid. (default: yellow)
+
+        error_func: a function to call (with no arguments) when
+                    valid_func returns INVALID.  If None (the default)
+                    the default action will be to emit a short beep.
+        '''
+
+        assert valid_func('') != INVALID, 'valid_func cannot return INVALID for an empty string'
+        
+        gtk.Entry.__init__(self, max)
+
+        self.__valid_func = valid_func
+        self.__use_bg = use_bg
+        self.__valid_bg = valid_bg
+        self.__partial_bg = partial_bg
+        self.__error_func = (error_func or
+                             gtk.gdk.display_get_default().beep)
+
+        self.connect('insert-text', self.__insert_text_cb)
+        self.connect('delete-text', self.__delete_text_cb)
+
+        # bootstrap with an empty string (so the box will appear with
+        # the partial_bg if an empty string is PARTIAL)
+        self.insert_text('')
+
+    def isvalid(self):
+        return self.__isvalid
+
+    def __insert_text_cb(self, entry, text, length, position):
+        'callback for "insert-text" signal'
+
+        # generate what the new text will be
+        text = text[:length]
+        pos = self.get_position()
+        old = self.get_text()
+        new = old[:pos] + text + old[pos:]
+
+        # validate the new text
+        self.__validate(new, 'insert-text')
+        
+    def __delete_text_cb(self, entry, start, end):
+        'callback for "delete-text" signal'
+
+        # generate what the new text will be
+        old = self.get_text()
+        new = old[:start] + old[end:]
+        
+        # validate the new text
+        self.__validate(new, 'delete-text')
+
+    def __validate(self, text, signal):
+        'calls the user-provided validation function'
+        
+        # validate
+        r = self.__valid_func(text)
+        if r == VALID:
+            self.__isvalid = True
+            if self.__use_bg:
+                self.modify_base(gtk.STATE_NORMAL, self.__valid_bg)
+        elif r == PARTIAL:
+            self.__isvalid = False
+            if self.__use_bg:
+                self.modify_base(gtk.STATE_NORMAL, self.__partial_bg)
+        else:
+            # don't set self.__isvalid: since we're not displaying the
+            # new value, the validity should be whatever it was before
+            self.stop_emission(signal)
+            self.__error_func()
+
+
+######################################################################
+#            
+# Sample validation functions to use with ValidatedEntry
+#
+######################################################################
+
+import re
+
+
+# STRING (non-empty after stripping)
+def v_nonemptystring(value):
+    '''
+    VALID: non-empty string after stripping whitespace
+    PARTAL: empty or all whitespace
+    INVALID: N/A
+    '''
+    if value.strip():
+        return VALID
+    return PARTIAL
+
+# INT
+def v_int(value):
+    '''
+    VALID: any postive or negative integer
+    PARTAL: empty or leading "-"
+    INVALID: non-numeral
+    '''
+    v = value.strip()
+    if not v or v == '-':
+        return PARTIAL
+    try:
+        int(value)
+        return VALID
+    except:
+        return INVALID
+
+# FLOAT
+def v_float(value):
+    '''
+    VALID: any postive or negative floating point
+    PARTAL: empty or leading "-", "."
+    INVALID: non-numeral
+    '''
+    v = value.strip()
+    if not v or v in ('-', '.', '-.'):
+        return PARTIAL
+    try:
+        float(value)
+        return VALID
+    except:
+        return INVALID
+
+
+# ISBN
+_isbnpartial = re.compile('[0-9]{0,9}[0-9xX]?$')
+def v_isbn(v):
+
+    '''Validate ISBN input.
+
+    From the isbn manual, section 4.4:
+     
+    The check digit is the last digit of an ISBN. It is calculated on
+    a modulus 11 with weights 10-2, using X in lieu of 10 where ten
+    would occur as a check digit.  This means that each of the first
+    nine digits of the ISBN -- excluding the check digit itself -- is
+    multiplied by a number ranging from 10 to 2 and that the resulting
+    sum of the products, plus the check digit, must be divisible by 11
+    without a remainder.'''
+
+    
+    if _isbnpartial.match(v):
+        # isbn is ten characters in length
+        if len(v) < 10:
+            return PARTIAL
+
+        s = 0
+
+        for i, c in enumerate(v):
+            s += (c in 'xX' and 10 or int(c)) * (10 - i)
+
+        if s % 11 == 0:
+            return VALID
+
+    return INVALID
+
+# MONEY
+# re for (possibly negative) money
+_money_re = re.compile('-?\d*(\.\d{1,2})?$')
+# validation function for money
+def v_money(value):
+    '''
+    VALID: any postive or negative floating point with at most two
+           digits after the decimal point.
+    PARTAL: empty or leading "-", "."
+    INVALID: non-numeral or more than two digits after the decimal
+             point.
+    '''
+    if not value or value == '-' or value[-1] == '.':
+        return PARTIAL
+
+    if _money_re.match(value):
+        return VALID
+
+    return INVALID
+
+# PHONE
+# the characters in a phone number
+_phonechars = re.compile('[- 0-9]*$')
+# valid phone number: [AC +]EXT-LINE
+_phone = re.compile('([2-9][0-8][0-9]\s+)?[2-9][0-9]{2}-[0-9]{4}$')
+def v_phone(value):
+    '''
+    VALID: any phone number of the form: EXT-LINE -or- AC EXT-LINE.
+    PARTAL: any characters that make up a valid #.
+    INVALID: characters that are not used in a phone #.
+    '''
+    if _phone.match(value):
+	return VALID
+    if _phonechars.match(value):
+        return PARTIAL
+    return INVALID
+
+def empty_valid(vfunc):
+
+    '''
+    empty_valid is a factory function returning a validation function.
+    All of the validation functions in this module return PARTIAL for
+    empty strings which, in effect, forces non-empty input.  There may
+    be a case where, e.g., you want money input to be optional, but
+    v_money will not consider empty input VALID.  Instead of writing
+    another validation function you can instead use empty_valid().  By
+    wrapping a validation function with empty_valid(), input (after
+    stripping), if empty, will be considered VALID.  E.g.:
+
+        ventry = ValidatedEntry(empty_valid(v_money))
+
+    It is recommended that all your validation functions treat empty
+    input as PARTIAL, for consistency across all validation functions
+    and for use with empty_valid().
+    '''
+
+    def validate(value):
+        if not value.strip():
+            return VALID
+        return vfunc(value)
+
+    return validate
+
+
+def bounded(vfunc, conv, minv=None, maxv=None):
+
+    '''
+    bounded is a factory function returning a validation function
+    providing bounded input.  E.g., you may want an entry that accepts
+    integers, but within a range, say, a score on a test graded in
+    whole numbers from 0 to 100:
+
+        score_entry = ValidatedEntry(bounded(v_int, int, 0, 100))
+
+    Arguments:
+
+        vfunc: A validation function.
+        conv: A callable that accepts a string argument (the text in
+              the entry) and returns a value to be compared to minv
+              and maxv.
+        minv: None or a value of the same type returned by conv.  If
+              None, there is no minimum value enforced.  If a value,
+              it will be the minimum value considered VALID.
+        maxv: None or a value of the same type returned by conv.  If
+              None, there is no maximum value enforced.  If a value,
+              it will be the maximum value considered VALID.
+
+    One or both of minv/maxv must be specified.
+
+    The function returned will call vfunc on entry input and if vfunc
+    returns VALID, the input will be converted by conv and compared to
+    minv/maxv.  If the converted value is within the bounds of
+    minv/maxv then VALID will be returned, else PARTIAL will be
+    returned.
+
+    '''
+
+    assert minv is not None or maxv is not None, \
+           'One of minv/maxv must be specified'
+
+    def F(value):
+
+        r = vfunc(value)
+        if r == VALID:
+            v = conv(value)
+            if minv is not None and v < minv:
+                return PARTIAL
+            if maxv is not None and v > maxv:
+                return PARTIAL
+        return r
+
+    return F
+
+