[gnue] r9353 - trunk/gnue-forms/src/input/displayHandlers

[johannes]

Author: johannes
Date: 2007-02-06 08:05:20 -0600 (Tue, 06 Feb 2007)
New Revision: 9353

Modified:
   trunk/gnue-forms/src/input/displayHandlers/datehandler.py
Log:
Restructured code a bit


Modified: trunk/gnue-forms/src/input/displayHandlers/datehandler.py
===================================================================
--- trunk/gnue-forms/src/input/displayHandlers/datehandler.py   2007-02-06 
10:51:54 UTC (rev 9352)
+++ trunk/gnue-forms/src/input/displayHandlers/datehandler.py   2007-02-06 
14:05:20 UTC (rev 9353)
@@ -47,6 +47,7 @@
         msg = u_("'%(value)s' is not a valid time-literal") % {'value': value}
         errors.UserError.__init__ (self, msg)
 
+
 # =============================================================================
 # Base class for date related handlers
 # =============================================================================
@@ -54,14 +55,50 @@
 class DateRelated(BaseCursor):
     """
     Base class for all date- and time-related displayhandler
+
+    @cvar _config_display_mask_: name of the configuration setting for the
+        display mask in gnue.conf
+    @cvar _config_input_mask_: name of the configuration setting for the input
+        mask in gnue.conf
     """
 
+    _config_display_mask_ = ''
+    _config_input_mask_ = ''
+
     # -------------------------------------------------------------------------
+    # Constructor
+    # -------------------------------------------------------------------------
+
+    def __init__(self, entry, eventHandler, subEventHandler, display_mask,
+            input_mask):
+
+        BaseCursor.__init__(self, entry, eventHandler, subEventHandler,
+                display_mask, input_mask)
+
+        self._input_mask = input_mask or gConfigForms(self._config_input_mask_)
+        self._display_mask = display_mask or \
+                gConfigForms(self._config_display_mask_)
+
+        self._order = []
+        self._inter = []
+
+        self._get_ordering_()
+
+
+    # -------------------------------------------------------------------------
     # Create a display string for the current value
     # -------------------------------------------------------------------------
 
     def build_display(self, value, editing):
         """
+        Create a display string for the given date-, time- or datetime-value.
+
+        @param value: the value to create a display string for
+        @param editing: True if the display-string is for edit mode, False
+             otherwise
+
+        @returns: the display string for the given value
+        @rtype: string
         """
 
         if editing:
@@ -80,72 +117,75 @@
 
 
     # -------------------------------------------------------------------------
-    # Get the order of the date's components (as defined by the given mask)
+    # Get the tip for this kind of date/time field
     # -------------------------------------------------------------------------
 
-    def get_date_order(self, format):
+    def get_tip(self):
+        """
+        Derive the apropriate tip from the sample date.
+        """
+        sample = datetime.datetime(1978, 3, 21, 13, 24, 56)
+        result = sample.strftime(str(self._input_mask))
+        result = result.replace('13', u_('H') * 2)
+        result = result.replace('01', u_('H') * 2)
+        result = result.replace('24', u_('M') * 2)
+        result = result.replace('56', u_('S') * 2)
+        result = result.replace('21', u_('D') * 2)
+        result = result.replace('03', u_('M') * 2)
+        result = result.replace('3', u_('M'))
+        result = result.replace('78', u_('Y') * 2)
+        result = result.replace('19', u_('Y') * 2)
 
-        sample = datetime.date(1978, 3, 21)
-        text = sample.strftime(str(format))
-        order = []
-        inter = []
-        pat = re.compile('^(\d+)(\D*)')
+        return result
 
-        match = pat.match(text)
-        while match:
-            part, rest = match.groups()
-            if part in ['1978', '78']:
-                if len(part) == 2:
-                    order.append('year')
-                else:
-                    order.append('Year')
-            elif part in ['03', '3']:
-                order.append('month')
-            elif part == '21':
-                order.append('day')
-            else:
-                order.append('?')
+    # -------------------------------------------------------------------------
+    # Get the order of the date/time components
+    # -------------------------------------------------------------------------
 
-            if rest:
-                inter.append(rest)
+    def _get_ordering_(self):
+        pass
 
-            text = text[len(part + rest):]
-            if not text:
-                break
 
-            match = pat.match(text)
 
-        return (order, inter)
+# =============================================================================
+# Display handler for date fields
+# =============================================================================
 
+class Date(DateRelated):
+    """
+    Display handler for date values.
+    """
 
+    _config_display_mask_ = 'DateMask'
+    _config_input_mask_   = 'DateEditMask'
+
+
     # -------------------------------------------------------------------------
-    # Get the ordering of the time components according to the given format
+    # Get the order of the date's components (as defined by the given mask)
     # -------------------------------------------------------------------------
 
-    def get_time_order(self, format):
-        """
-        """
+    def _get_ordering_(self):
 
-        order = ''
-        inter = []
-
-        text = datetime.time(13, 24, 56).strftime(str(format))
+        sample = datetime.date(1978, 3, 21)
+        text = sample.strftime(str(self._input_mask))
+        self._order = []
+        self._inter = []
         pat = re.compile('^(\d+)(\D*)')
 
         match = pat.match(text)
         while match:
             part, rest = match.groups()
-            if part in ['13', '01']:
-                order += 'H'
-            elif part == '24':
-                order += 'M'
-            elif part == '56':
-                order += 'S'
+            if part in ['1978', '78']:
+                self._order.append('year')
+            elif part in ['03', '3']:
+                self._order.append('month')
+            elif part == '21':
+                self._order.append('day')
             else:
-                order += '?'
+                self._order.append('?')
 
             if rest:
-                inter.append(rest)
+                self._inter.append(rest)
 
             text = text[len(part + rest):]
             if not text:
@@ -153,61 +193,18 @@
 
             match = pat.match(text)
 
-        return (order, inter)
 
-
-
-
-# =============================================================================
-# Display handler for date fields
-# =============================================================================
-
-class Date(DateRelated):
-    """
-    Display handler for date values.
-    """
-
     # -------------------------------------------------------------------------
-    # Constructor
-    # -------------------------------------------------------------------------
-
-    def __init__(self, entry, eventHandler, subEventHandler, display_mask,
-                 input_mask):
-
-        DateRelated.__init__(self, entry, eventHandler, subEventHandler,
-                display_mask, input_mask)
-
-        self._input_mask = input_mask or gConfigForms('DateEditMask') or '%x'
-        self._display_mask = display_mask or gConfigForms('DateMask') or '%x'
-
-        self.__order, self.__inter = self.get_date_order(self._input_mask)
-
-
-    # -------------------------------------------------------------------------
-    # Build a tip for the date field
-    # -------------------------------------------------------------------------
-
-    def get_tip(self):
-        """
-        Derive the apropriate tip from the sample date.
-        """
-        sample = datetime.date(1978, 3, 21)
-        result = sample.strftime(str(self._input_mask))
-        result = result.replace('21', u_('D') * 2)
-        result = result.replace('03', u_('M') * 2)
-        result = result.replace('3', u_('M'))
-        result = result.replace('78', u_('Y') * 2)
-        result = result.replace('19', u_('Y') * 2)
-
-        return result
-
-
-    # -------------------------------------------------------------------------
     # Try to figure out which date the user meant
     # -------------------------------------------------------------------------
 
     def parse_display(self, display):
         """
+        Try to figure out which date is meant by the given string.
+
+        @param display: string with a (maybe incomplete) date
+        @returns: date matching the given string
+        @raises InvalidDateLiteral: if the given string is no valid date
         """
 
         if not display:
@@ -243,7 +240,7 @@
             else:
                 val1, val2 = display[:2], display[2:]
 
-            if self.__order.index('day') < self.__order.index('month'):
+            if self._order.index('day') < self._order.index('month'):
                 day = int(val1)
                 month = int(val2)
             else:
@@ -268,7 +265,7 @@
             kw = {}
             for index, item in enumerate(values):
                 value = int(item)
-                part = self.__order[index].lower()
+                part = self._order[index].lower()
 
                 # If the year is given without a century we will figure out
                 # which one to use.
@@ -290,7 +287,7 @@
         # derive the order of the elements from the order as given in the input
         # mask.
         if display.isdigit() and len(display) == 8:
-            for item in self.__order:
+            for item in self._order:
                 if item.lower() == 'year':
                     year = int(display[:4])
                     display = display[4:]
@@ -317,7 +314,7 @@
     def _autocomplete_(self, new_text, new_cursor):
 
         # We do not autocomplete dates starting with the year
-        if self.__order[0].lower() == 'year':
+        if self._order[0].lower() == 'year':
             return new_text, new_cursor
 
         today = datetime.date.today().strftime(str(self._input_mask))
@@ -325,35 +322,35 @@
         # If the text is a number it must be the first component
         if new_text.isdigit():
             if len(new_text) > 2:
-                new_text = new_text[:2] + self.__inter[0] + new_text[2:]
+                new_text = new_text[:2] + self._inter[0] + new_text[2:]
                 new_cursor += 1
-                new_text += self.__inter[1] + "%s" % datetime.date.today().year
+                new_text += self._inter[1] + "%s" % datetime.date.today().year
 
-            elif self.__order[0] != 'month':
-                new_text = new_text + today[today.index(self.__inter[0]):]
+            elif self._order[0] != 'month':
+                new_text = new_text + today[today.index(self._inter[0]):]
 
             return new_text, new_cursor
 
         else:
-            parts = new_text.split(self.__inter[0], 1)
+            parts = new_text.split(self._inter[0], 1)
             if len(parts) <> 2:
                 return new_text, new_cursor
 
-            lead = parts[0] + self.__inter[0]
+            lead = parts[0] + self._inter[0]
             rest = parts[1]
             # If we have nothing after the first intersection symbol, we have
             # to complete the rest
             if not rest:
-                if self.__order[0] <> 'month':
-                    new_text = parts[0] + today[today.index(self.__inter[0]):]
+                if self._order[0] <> 'month':
+                    new_text = parts[0] + today[today.index(self._inter[0]):]
                 return new_text, new_cursor
 
-            parts = rest.split(self.__inter[1], 1)
+            parts = rest.split(self._inter[1], 1)
             # If we have the first and the second component, stick it together
             if len(parts) == 1:
                 lead += parts[0]
                 new_cursor = len(lead)
-                new_text = lead + today[today.rindex(self.__inter[1]):]
+                new_text = lead + today[today.rindex(self._inter[1]):]
 
                 return new_text, new_cursor
 
@@ -369,25 +366,48 @@
     Display handler for time values.
     """
 
+    _config_display_mask_ = 'DateMask_Time'
+    _config_input_mask_   = 'DateEditMask_Time'
+
+
     # -------------------------------------------------------------------------
-    # Constructor
+    # Get the ordering of the time components according to the given format
     # -------------------------------------------------------------------------
 
-    def __init__(self, entry, eventHandler, subEventHandler, display_mask,
-                 input_mask):
+    def _get_ordering_(self):
+        """
+        Get the ordering of the time components according to the input mask
+        """
+        text = datetime.time(13, 24, 56).strftime(str(self._input_mask))
+        pat = re.compile('^(\d+)(\D*)')
 
-        DateRelated.__init__(self, entry, eventHandler, subEventHandler,
-                display_mask, input_mask)
+        match = pat.match(text)
+        while match:
+            part, rest = match.groups()
+            if part in ['13', '01']:
+                self._order.append('hour')
+            elif part == '24':
+                self._order.append('minute')
+            elif part == '56':
+                self._order.append('second')
+            else:
+                self._order += '?'
 
-        self._input_mask = input_mask or gConfigForms('DateEditMask_Time')
-        self._display_mask = display_mask or gConfigForms('DateMask_Time')
+            if rest:
+                self._inter.append(rest)
 
-        self.__order, self.__inter = self.get_time_order(self._input_mask)
+            text = text[len(part + rest):]
+            if not text:
+                break
 
+            match = pat.match(text)
 
+
+
     # -------------------------------------------------------------------------
     # Parsing a (maybe partial) value
     # -------------------------------------------------------------------------
+
     def parse_display(self, display):
         """
         Try to figure out which datetime.time value is meant by the given
@@ -400,25 +420,16 @@
         try:
             # First have a look wether the input follows the requested format 
             temp = time.strptime(display, self._input_mask)
-            return datetime.time(*temp[3:3+len(self.__order)])
+            return datetime.time(*temp[3:3+len(self._order)])
 
         except ValueError:
             pass
 
-        kw = {'hour': 0, 'minute': 0, 'second': 0}
-        order = []
-        for char in self.__order:
-            if char == 'S':
-                order.append('second')
-            elif char == 'M':
-                order.append('minute')
-            else:
-                order.append('hour')
-
+        kw = {}
         # If the input is a number of length 2 we treat it as the lowest part
         if display.isdigit() and len(display) <= 2:
             try:
-                kw[order[-1]] = int(display)
+                kw[self._order[-1]] = int(display)
                 return datetime.time(**kw)
 
             except ValueError:
@@ -435,8 +446,8 @@
             else:
                 val1, val2 = display[:2], display[2:]
 
-            kw[order[-2]] = int(val1)
-            kw[order[-1]] = int(val2)
+            kw[self._order[-2]] = int(val1)
+            kw[self._order[-1]] = int(val2)
 
             try:
                 return datetime.time(**kw)
@@ -454,9 +465,9 @@
             else:
                 val1, val2, val3 = display[:2], display[2:4], display[4:]
 
-            kw[order[-3]] = int(val1)
-            kw[order[-2]] = int(val2)
-            kw[order[-1]] = int(val3)
+            kw[self._order[-3]] = int(val1)
+            kw[self._order[-2]] = int(val2)
+            kw[self._order[-1]] = int(val3)
 
             try:
                 return datetime.time(**kw)
@@ -468,25 +479,6 @@
         raise InvalidTimeLiteral, display
 
 
-    # -------------------------------------------------------------------------
-    # Build a tip for the time field
-    # -------------------------------------------------------------------------
-
-    def get_tip(self):
-        """
-        Derive the apropriate tip from the sample time.
-        """
-        sample = datetime.time(13, 24, 56)
-        result = sample.strftime(str(self._input_mask))
-        result = result.replace('13', u_('H') * 2)
-        result = result.replace('01', u_('H') * 2)
-        result = result.replace('24', u_('M') * 2)
-        result = result.replace('56', u_('S') * 2)
-
-        return result
-
-
-
 # =============================================================================
 # Displayhandler for date- and time-values
 # =============================================================================
@@ -496,55 +488,43 @@
     Class to handle the display and entry of date based fields.
     """
 
-    # -------------------------------------------------------------------------
-    # Constructor
-    # -------------------------------------------------------------------------
+    _config_display_mask_ = 'DateMask_Timestamp'
+    _config_input_mask_   = 'DateEditMask_Timestamp'
 
-    def __init__(self, entry, eventHandler, subEventHandler, display_mask,
-                 input_mask):
 
-        DateRelated.__init__(self, entry, eventHandler, subEventHandler,
-                display_mask, input_mask)
-
-        self._input_mask = input_mask or gConfigForms('DateEditMask_Timestamp')
-        self._display_mask = display_mask or gConfigForms('DateMask_Timestamp')
-
-        self.__get_ordering()
-
-
     # -------------------------------------------------------------------------
     # Get the ordering for the components
     # -------------------------------------------------------------------------
 
-    def __get_ordering(self):
+    def _get_ordering_(self):
 
         sample = datetime.datetime(1978, 3, 21, 13, 24, 56)
         text = sample.strftime(str(self._input_mask))
 
-        self.__order = []
-        self.__inter = []
+        self._order = []
+        self._inter = []
         pat = re.compile('^(\d+)(\D*)')
 
         match = pat.match(text)
         while match:
             part, rest = match.groups()
             if part in ['1978', '78']:
-                self.__order.append('year')
+                self._order.append('year')
             elif part in ['03', '3']:
-                self.__order.append('month')
+                self._order.append('month')
             elif part == '21':
-                self.__order.append('day')
+                self._order.append('day')
             elif part in ['13', '01']:
-                self.__order.append('hour')
+                self._order.append('hour')
             elif part == '24':
-                self.__order.append('minute')
+                self._order.append('minute')
             elif part == '56':
-                self.__order.append('second')
+                self._order.append('second')
             else:
-                self.__order.append('?')
+                self._order.append('?')
 
             if rest:
-                self.__inter.append(rest)
+                self._inter.append(rest)
 
             text = text[len(part + rest):]
             if not text:
@@ -592,7 +572,7 @@
             else:
                 val1, val2 = display[:2], display[2:]
 
-            if self.__order.index('day') < self.__order.index('month'):
+            if self._order.index('day') < self._order.index('month'):
                 day = int(val1)
                 month = int(val2)
             else:
@@ -617,7 +597,7 @@
             kw = {}
             for index, item in enumerate(values):
                 value = int(item)
-                part = self.__order[index].lower()
+                part = self._order[index].lower()
 
                 # If the year is given without a century we will figure out
                 # which one to use.
@@ -639,7 +619,7 @@
         # derive the order of the elements from the order as given in the input
         # mask.
         if display.isdigit() and len(display) == 8:
-            for item in self.__order:
+            for item in self._order:
                 if item.lower() == 'year':
                     year = int(display[:4])
                     display = display[4:]
@@ -668,7 +648,7 @@
             kw = {}
             for index, item in enumerate(values):
                 value = int(item)
-                part = self.__order[index].lower()
+                part = self._order[index].lower()
 
                 # If the year is given without a century we will figure out
                 # which one to use.
@@ -698,7 +678,7 @@
     def __parse_time(self, display):
 
         # Catch the ordering of the time components
-        order = [i for i in self.__order if i in ['hour', 'minute', 'second']]
+        order = [i for i in self._order if i in ['hour', 'minute', 'second']]
 
         kw = {'hour': 0, 'minute': 0, 'second': 0}