[gnue] r8913 - trunk/gnue-forms/src/GFObjects

[reinhard]

Author: reinhard
Date: 2006-10-23 11:15:43 -0500 (Mon, 23 Oct 2006)
New Revision: 8913

Modified:
   trunk/gnue-forms/src/GFObjects/GFBlock.py
Log:
Code cleanup.


Modified: trunk/gnue-forms/src/GFObjects/GFBlock.py
===================================================================
--- trunk/gnue-forms/src/GFObjects/GFBlock.py   2006-10-23 15:58:01 UTC (rev 
8912)
+++ trunk/gnue-forms/src/GFObjects/GFBlock.py   2006-10-23 16:15:43 UTC (rev 
8913)
@@ -25,7 +25,6 @@
 Classes making up the Block object.
 """
 
-from gnue.common.apps import errors
 from gnue.common.datasources import GConditions
 from gnue.common.definitions import GParser
 from gnue.common import events
@@ -79,10 +78,10 @@
     changes and replaces the block's contents with a single empty record.
 
     In case the block is connected to an active datasource (especially the GNUe
-    AppServer), the L{updateCurrentRecordSet} method can be used to write the
-    block's changes to the backend without committing them, in order to run
-    trigger functions on the backend, while L{callFunction} directly calls a
-    backend function for the block's current record.
+    AppServer), the L{update} method can be used to write the block's changes
+    to the backend without committing them, in order to run trigger functions
+    on the backend, while L{call} directly calls a backend function for the
+    block's current record.
 
     The status of the current record can be determined by L{get_record_status},
     while L{is_pending} can be used to determine the status of the whole block.
@@ -112,12 +111,12 @@
 
         self.mode = 'normal'
 
-        self._resultSet      = None
-        self._dataSourceLink = None
+        self.__resultset     = None
+        self._dataSourceLink = None     # FIXME: make private!
 
-        self._currentRecord   = 0
-        self._recordCount     = 0
-        self._queryDefaults   = {}
+        self._currentRecord   = 0       # FIXME: make private!
+        self.__record_count   = 0
+        self._queryDefaults   = {}      # FIXME: make private!
 
         self.__query_values      = {}
         self.__last_query_values = {}
@@ -126,16 +125,16 @@
         self.__scrollbars = []
 
         # Populated by GFEntry's initialize
-        self._entryList = []
+        self._entryList = []            # FIXME: make private!
 
         # Populated by GFField's initialize
-        self._fieldMap  = {}
-        self._fieldList = []
+        self._fieldMap  = {}            # FIXME: make private!
+        self._fieldList = []            # FIXME: make private!
 
         # Current top of visible portion (only used for scrollbars, every entry
         # maintains its own visible portion because the number of visible rows
         # can differ per entry)
-        self.__visibleStart = 0
+        self.__visible_start = 0
 
         # If this is true, notifying attached objects of current record changes
         # is temporarily blocked
@@ -183,9 +182,9 @@
                 'undeleteRecord': {'function': self.undelete_record},
 
                 # Other stuff
-                'call': {'function': self.callFunction},
-                'update': {'function': self.updateCurrentRecordSet},
-                'getResultSet': {'function': self.getResultSet},
+                'call': {'function': self.call},
+                'update': {'function': self.update},
+                'getResultSet': {'function': self.get_resultset},# deprecated?
                 'get_data': {'function': self.get_data}}
 
 
@@ -245,19 +244,19 @@
         self._dataSourceLink = dsDict.get(self.datasource)
 
         if self._dataSourceLink is None:
-            raise DatasourceNotFoundError,(self.datasource, self)
+            raise DatasourceNotFoundError, (self.datasource, self)
 
         # Register event handling functions
         self._dataSourceLink.registerEventListeners({
-                'dsResultSetActivated': self.__dsResultSetActivated,
-                'dsResultSetChanged'  : self.__dsResultSetActivated, # sic!
-                'dsCursorMoved'       : self.__dsCursorMoved,
-                'dsRecordInserted'    : self.__dsRecordInserted,
-                'dsRecordLoaded'      : self.__dsRecordLoaded,
-                'dsRecordTouched'     : self.__dsRecordTouched,
-                'dsCommitInsert'      : self.__dsCommitInsert,
-                'dsCommitUpdate'      : self.__dsCommitUpdate,
-                'dsCommitDelete'      : self.__dsCommitDelete})
+                'dsResultSetActivated': self.__ds_resultset_activated,
+                'dsResultSetChanged'  : self.__ds_resultset_activated, # sic!
+                'dsCursorMoved'       : self.__ds_cursor_moved,
+                'dsRecordInserted'    : self.__ds_record_inserted,
+                'dsRecordLoaded'      : self.__ds_record_loaded,
+                'dsRecordTouched'     : self.__ds_record_touched,
+                'dsCommitInsert'      : self.__ds_commit_insert,
+                'dsCommitUpdate'      : self.__ds_commit_update,
+                'dsCommitDelete'      : self.__ds_commit_delete})
 
         # Get min and max child rows, if applicable
         self._minChildRows = getattr(self._dataSourceLink, 'detailmin', 0)
@@ -308,24 +307,24 @@
     # Event handling functions for datasource events
     # -------------------------------------------------------------------------
 
-    def __dsResultSetActivated(self, event):
+    def __ds_resultset_activated(self, event):
 
         # FIXME: If an exception appears here, we have a problem: it is 
probably
         # too late to cancel the operation.
         self._focus_out()
 
-        self._resultSet = event.resultSet
+        self.__resultset = event.resultSet
 
         # FIXME: during commit, master datasources navigate the current record
         # through the dirty record list and cause the detail blocks to follow
         # through this event. However, in that case, we wouldn't want the UI to
         # follow, so we wouldn't want to run the following lines in that case.
-        recno = self._resultSet.getRecordNumber()
+        recno = self.__resultset.getRecordNumber()
         if recno == -1:
             self.__scrolling_blocked = True
             try:
-                if not self._resultSet.firstRecord():
-                    self._resultSet.insertRecord(self._lastValues)
+                if not self.__resultset.firstRecord():
+                    self.__resultset.insertRecord(self._lastValues)
             finally:
                 self.__scrolling_blocked = False
 
@@ -336,19 +335,19 @@
 
     # -------------------------------------------------------------------------
 
-    def __dsCursorMoved(self, event):
+    def __ds_cursor_moved(self, event):
 
         if self.__scrolling_blocked:
             return
 
         # Blocks can't cope with current record #-1
-        recno = self._resultSet.getRecordNumber()
+        recno = self.__resultset.getRecordNumber()
         if recno != -1:
             self.__current_record_changed(False)
 
     # -------------------------------------------------------------------------
 
-    def __dsRecordInserted(self, event):
+    def __ds_record_inserted(self, event):
         self._initializingRecord = event.record
         oldmode = self.mode
         self.mode = 'init'
@@ -357,7 +356,7 @@
 
     # -------------------------------------------------------------------------
 
-    def __dsRecordLoaded(self, event):
+    def __ds_record_loaded(self, event):
         self._initializingRecord = event.record
         oldmode = self.mode
         self.mode = 'init'
@@ -366,32 +365,32 @@
 
     # -------------------------------------------------------------------------
 
-    def __dsRecordTouched(self, event):
+    def __ds_record_touched(self, event):
         # This already gets called by GFField??
-        # self.__fireRecordTrigger('PRE-CHANGE')
+        # self.__fire_record_trigger('PRE-CHANGE')
         pass
 
     # -------------------------------------------------------------------------
 
-    def __dsCommitInsert(self, event):
-        self.__fireRecordTrigger('PRE-INSERT')
-        self.__fireRecordTrigger('PRE-COMMIT')
+    def __ds_commit_insert(self, event):
+        self.__fire_record_trigger('PRE-INSERT')
+        self.__fire_record_trigger('PRE-COMMIT')
 
     # -------------------------------------------------------------------------
 
-    def __dsCommitUpdate(self, event):
-        self.__fireRecordTrigger('PRE-UPDATE')
-        self.__fireRecordTrigger('PRE-COMMIT')
+    def __ds_commit_update(self, event):
+        self.__fire_record_trigger('PRE-UPDATE')
+        self.__fire_record_trigger('PRE-COMMIT')
 
     # -------------------------------------------------------------------------
 
-    def __dsCommitDelete(self, event):
-        self.__fireRecordTrigger('PRE-DELETE')
-        self.__fireRecordTrigger('PRE-COMMIT')
+    def __ds_commit_delete(self, event):
+        self.__fire_record_trigger('PRE-DELETE')
+        self.__fire_record_trigger('PRE-COMMIT')
 
     # -------------------------------------------------------------------------
 
-    def __fireRecordTrigger(self, trigger):
+    def __fire_record_trigger(self, trigger):
         self.processTrigger(trigger)
         for field in self._fieldList:
             field.processTrigger(trigger)
@@ -412,7 +411,7 @@
 
         self._rows = new_rows
 
-        if self.__visibleStart + self._rows < self._currentRecord + 1:
+        if self.__visible_start + self._rows < self._currentRecord + 1:
             self.__switch_record(None, False)
         else:
             self.__adjust_scrollbars()
@@ -427,7 +426,7 @@
             record.
         """
   
-        self._event_scroll_to_record(self.__visibleStart + adjustment)
+        self._event_scroll_to_record(self.__visible_start + adjustment)
 
     # -------------------------------------------------------------------------
 
@@ -440,11 +439,11 @@
         """
 
         # Make sure we don't scroll outside the available records
-        position = min(position, self._resultSet.getRecordCount() - self._rows)
+        position = min(position, self.__resultset.getRecordCount() - 
self._rows)
         position = max(position, 0)
 
         # Got anything to do at all?
-        if position == self.__visibleStart:
+        if position == self.__visible_start:
             return
 
         # Jump to another record if necessary
@@ -487,20 +486,20 @@
                 value = self._initializingRecord[field.field]
 
             else:
-                if self._resultSet and self._resultSet.current:
-                    value = self._resultSet.current[field.field]
+                if self.__resultset and self.__resultset.current:
+                    value = self.__resultset.current[field.field]
                 else:
                     value = None
         else:
-            if self.mode in ['query', 'init'] or self._resultSet is None:
+            if self.mode in ['query', 'init'] or self.__resultset is None:
                 value = None
             else:
-                record_number = self._resultSet.getRecordNumber() + offset
+                record_number = self.__resultset.getRecordNumber() + offset
                 if record_number < 0 or \
-                        record_number >= self._resultSet.getRecordCount():
+                        record_number >= self.__resultset.getRecordCount():
                     value = None
                 else:
-                    value = self._resultSet[record_number][field.field]
+                    value = self.__resultset[record_number][field.field]
 
         return value
 
@@ -526,7 +525,7 @@
             self.processTrigger('Pre-Change')
             field.processTrigger('Pre-Change')
 
-            self._resultSet.current[field.field] = value
+            self.__resultset.current[field.field] = value
             if field.defaultToLast:
                 self._lastValues[field.field] = value
 
@@ -553,10 +552,10 @@
         'modified', or 'deleted', or C{None} if there is no current record.
         """
 
-        if self._resultSet is None:
+        if self.__resultset is None:
             return None
 
-        rec = self._resultSet.current
+        rec = self.__resultset.current
         if rec is None:
             return None
 
@@ -594,9 +593,9 @@
             result.append('cancel_query')
             result.append('execute_query')
         else:
-            rs = self._resultSet
+            rs = self.__resultset
             if rs is not None:
-                rec = self._resultSet.current
+                rec = self.__resultset.current
                 status = self.get_record_status()
 
                 if rec is not None:
@@ -645,7 +644,7 @@
         Return True if the block is pending any uncommited changes.
         """
 
-        return self._resultSet is not None and self._resultSet.isPending()
+        return self.__resultset is not None and self.__resultset.isPending()
 
     # -------------------------------------------------------------------------
 
@@ -658,8 +657,8 @@
         status other than empty.
         """
 
-        return self._resultSet is None or self._resultSet.current is None \
-                or self._resultSet.current.isEmpty()
+        return self.__resultset is None or self.__resultset.current is None \
+                or self.__resultset.current.isEmpty()
 
     # -------------------------------------------------------------------------
 
@@ -668,7 +667,7 @@
         Returns True if the current record is the first one in the ResultSet
         """
 
-        return self._resultSet.isFirstRecord()
+        return self.__resultset.isFirstRecord()
 
     # -------------------------------------------------------------------------
 
@@ -677,7 +676,7 @@
         Returns True if the current record is the last one in the ResultSet.
         """
 
-        return self._resultSet.isLastRecord()
+        return self.__resultset.isLastRecord()
 
 
     # -------------------------------------------------------------------------
@@ -694,12 +693,12 @@
         if self.mode == 'query':
             return
 
-        if self._resultSet.isFirstRecord():
+        if self.__resultset.isFirstRecord():
             return
 
         self._focus_out()
 
-        self._resultSet.firstRecord()
+        self.__resultset.firstRecord()
 
         self._focus_in()
 
@@ -715,12 +714,12 @@
         if self.mode == 'query':
             return
 
-        if self._resultSet.isFirstRecord():
+        if self.__resultset.isFirstRecord():
             return
 
         self._focus_out()
 
-        self._resultSet.prevRecord()
+        self.__resultset.prevRecord()
 
         self._focus_in()
 
@@ -738,7 +737,7 @@
         if self.mode == 'query':
             return
 
-        if self._resultSet.isLastRecord():
+        if self.__resultset.isLastRecord():
             if self.autoCreate and not self.is_empty() and \
                     not self.editable in('update', 'N'):
                 self.new_record()
@@ -746,7 +745,7 @@
 
         self._focus_out()
 
-        self._resultSet.nextRecord()
+        self.__resultset.nextRecord()
 
         self._focus_in()
 
@@ -762,12 +761,12 @@
         if self.mode == 'query':
             return
 
-        if self._resultSet.isLastRecord():
+        if self.__resultset.isLastRecord():
             return
 
         self._focus_out()
 
-        self._resultSet.lastRecord()
+        self.__resultset.lastRecord()
 
         self._focus_in()
 
@@ -788,17 +787,17 @@
 
         # If record_number is negative, move relative to last record
         if record_number < 0:
-            record_number += self._resultSet.getRecordCount()
+            record_number += self.__resultset.getRecordCount()
         if record_number < 0:
             record_number = 0
 
-        if record_number == self._resultSet.getRecordNumber():
+        if record_number == self.__resultset.getRecordNumber():
             return
 
         self._focus_out()
 
-        if not self._resultSet.setRecord(record_number):
-            self._resultSet.lastRecord()
+        if not self.__resultset.setRecord(record_number):
+            self.__resultset.lastRecord()
 
         self._focus_in()
 
@@ -812,10 +811,10 @@
         @param count: the number of records to move from the current record.
         """
 
-        record_number = self._resultSet.getRecordNumber() + count
+        record_number = self.__resultset.getRecordNumber() + count
 
         record_number = max(record_number, 0)
-        record_number = min(record_number, self._resultSet.getRecordCount())
+        record_number = min(record_number, self.__resultset.getRecordCount())
 
         self.goto_record(record_number)
 
@@ -835,7 +834,7 @@
 
         self._focus_out()
 
-        self._resultSet.insertRecord(self._lastValues)
+        self.__resultset.insertRecord(self._lastValues)
 
         self._focus_in()
 
@@ -857,7 +856,7 @@
 
         self._focus_out()
 
-        self._resultSet.duplicateRecord(exclude=exclude, include=include)
+        self.__resultset.duplicateRecord(exclude=exclude, include=include)
 
         self._focus_in()
 
@@ -872,7 +871,7 @@
         if self.mode == 'query':
             return
 
-        self._resultSet.current.delete()
+        self.__resultset.current.delete()
 
         if self._form.get_focus_block() is self:
             self.__update_record_status()
@@ -887,7 +886,7 @@
         if self.mode == 'query':
             return
 
-        self._resultSet.current.undelete()
+        self.__resultset.current.undelete()
 
         if self._form.get_focus_block() is self:
             self.__update_record_status()
@@ -999,7 +998,7 @@
 
         self.mode = 'commit'
 
-        self._resultSet.setRecord(self._precommitRecord)
+        self.__resultset.setRecord(self._precommitRecord)
 
         if self._getMasterBlock() is None:
             self._dataSourceLink.postAll()
@@ -1018,10 +1017,10 @@
             self._dataSourceLink.requeryAll(commit)
 
         # If the last record was deleted, insert a new one
-        if not self._resultSet.getRecordCount():
+        if not self.__resultset.getRecordCount():
             self.__scrolling_blocked = True
             try:
-                self._resultSet.insertRecord(self._lastValues)
+                self.__resultset.insertRecord(self._lastValues)
             finally:
                 self._scrolling_blocked = False
 
@@ -1045,11 +1044,11 @@
     # Function and Update
     # -------------------------------------------------------------------------
 
-    def callFunction(self, name, parameters):
+    def call(self, name, parameters):
 
         # Remember the current record; the record pointer is not reliable
         # between postAll and requeryAll!
-        current = self._resultSet.current
+        current = self.__resultset.current
         self._dataSourceLink.postAll()
 
         try:
@@ -1061,7 +1060,7 @@
 
     # -------------------------------------------------------------------------
 
-    def updateCurrentRecordSet(self):
+    def update(self):
 
         self._dataSourceLink.postAll()
         self._dataSourceLink.requeryAll(False)
@@ -1071,12 +1070,12 @@
     # Raw data access
     # -------------------------------------------------------------------------
 
-    def getResultSet(self):
+    def get_resultset(self):
         """
         Return the current ResultSet of the block.
         """
 
-        return self._resultSet
+        return self.__resultset
 
     # -------------------------------------------------------------------------
 
@@ -1095,7 +1094,7 @@
         else:
             fields = [self._fieldMap[fld] for fld in fieldnames]
 
-        for r in self._resultSet:
+        for r in self.__resultset:
             add = {}
             for field in fields:
                 fname = field.field
@@ -1212,25 +1211,25 @@
             newRecord = 0
             newRecordCount = 1
         else:
-            newRecord      = self._resultSet.getRecordNumber()
-            newRecordCount = self._resultSet.getRecordCount()
+            newRecord      = self.__resultset.getRecordNumber()
+            newRecordCount = self.__resultset.getRecordCount()
 
         adjustment = newRecord - self._currentRecord
 
         if new_visible_start is None:
-            new_visible_start = self.__visibleStart
+            new_visible_start = self.__visible_start
         new_visible_start = min(new_visible_start, newRecord)
         new_visible_start = max(new_visible_start, newRecord - self._rows + 1)
         new_visible_start = max(new_visible_start, 0)
 
-        adjustment += self.__visibleStart - new_visible_start
-        self.__visibleStart = new_visible_start
+        adjustment += self.__visible_start - new_visible_start
+        self.__visible_start = new_visible_start
 
         # Find out which ui entries to refresh
         if refresh_all:
             # Result set completely changed, refresh everything
             refresh = 'all'
-        elif newRecordCount != self._recordCount:
+        elif newRecordCount != self.__record_count:
             # Newly inserted or deleted record, so all records starting from
             # this one have moved, so refresh them
             refresh = 'current'
@@ -1238,11 +1237,11 @@
             refresh = 'none'
 
         self._currentRecord = newRecord
-        self._recordCount   = newRecordCount
+        self.__record_count = newRecordCount
 
         for entry in self._entryList:
             entry.recalculate_visible(adjustment, self._currentRecord,
-                    self._recordCount, refresh)
+                    self.__record_count, refresh)
 
         self.__adjust_scrollbars()
 
@@ -1270,8 +1269,8 @@
             record_count = 1
             record_status = 'QRY'
         else:
-            record_number = self._resultSet.getRecordNumber()+1
-            record_count = self._resultSet.getRecordCount()
+            record_number = self.__resultset.getRecordNumber()+1
+            record_count = self.__resultset.getRecordCount()
             record_status = {
                     None:       '',
                     'empty':    'NEW',
@@ -1294,8 +1293,8 @@
     def __adjust_scrollbars(self):
 
         for sb in self.__scrollbars:
-            sb.adjust_scrollbar(self.__visibleStart,
-                    max(self._recordCount, self.__visibleStart + self._rows))
+            sb.adjust_scrollbar(self.__visible_start,
+                    max(self.__record_count, self.__visible_start + 
self._rows))
 
 
     # -------------------------------------------------------------------------
@@ -1369,7 +1368,7 @@
                     if isinstance(val, basestring) and \
                             val[:2+len(comparison)].lower() == "%s%s%s" % \
                         (comparisonDelimiter, comparison, comparisonDelimiter):
-                        value=val[2+len(comparison):]
+                        value = val[2 + len(comparison):]
 
                         if baseComparisons[comparison][1]:
                             field = ['field', entry.field]