Refactored the cache out of the listview.

1 files changed, 29 insertions, 92 deletions

diff --git a/listview.py b/listview.py
index a4daeda..bb44379 100644
--- a/listview.py
+++ b/listview.py
@@ -13,6 +13,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
 import os
 import logging
 
@@ -27,6 +28,7 @@ from sugar.graphics.canvasicon import CanvasIcon
 
 from collapsedentry import CollapsedEntry
 from expandedentry import ExpandedEntry
+import query
 
 class ListView(gtk.HBox):
     __gtype_name__ = 'ListView'
@@ -42,17 +44,12 @@ class ListView(gtk.HBox):
                            ([object]))
     }
 
-    _MAX_CACHE_PAGES = 5
-    _INITIAL_CACHE_PAGES = 3
-
     def __init__(self):
         self._expanded = False
         self._query = {}
+        self._result_set = None
         self._entries = []
-        self._cache = []
-        self._offset = 0
         self._page_size = 0
-        self._total_count = 0
 
         gtk.HBox.__init__(self)
         self.set_flags(gtk.HAS_FOCUS|gtk.CAN_FOCUS)
@@ -114,96 +111,40 @@ class ListView(gtk.HBox):
         import time
         t = time.time()
         value = int(vadjustment.props.value)
-        logging.debug('value: %i offset: %i cache: %i' %
-                      (value, self._offset, len(self._cache)))
-        
-        if value < self._offset:
-            remaining_forward_entries = 0
-        else:
-            remaining_forward_entries = self._offset + len(self._cache) - value
+        logging.debug('_vadjustment_value_changed_cb value: %i' % value)
 
-        if value > self._offset + len(self._cache):
-            remaining_backwards_entries = 0
-        else:
-            remaining_backwards_entries = value - self._offset
-
-        last_cached_entry = self._offset + len(self._cache)
-
-        if remaining_forward_entries < 1 and remaining_backwards_entries < 1:
-            # Total cache miss: remake it
-            offset = max(0, value - ListView._INITIAL_CACHE_PAGES * \
-                                    self._page_size / 2)
-            logging.debug('remaking cache, offset: %r' % offset)
-            jobjects, self._total_count = datastore.find(self._query,
-                    sorting=['-mtime'],
-                    offset=offset,
-                    limit=ListView._INITIAL_CACHE_PAGES * self._page_size)
-
-            self._cache = jobjects
-            self._offset = offset
-            
-        elif remaining_forward_entries < 20 and last_cached_entry < self._total_count:
-            # Add one page to the end of cache
-            logging.debug('appending one more page, offset: %r' % last_cached_entry)
-            jobjects, self._total_count = datastore.find(self._query,
-                                                         sorting=['-mtime'],
-                                                         offset=last_cached_entry,
-                                                         limit=self._page_size)
-
-            self._cache.extend(jobjects)
-
-            if len(self._cache) > ListView._MAX_CACHE_PAGES * self._page_size:
-                self._offset += len(jobjects)
-                self._cache = self._cache[len(jobjects):]
-
-        elif remaining_backwards_entries < 20 and self._offset >= self._page_size:
-            # Add one page to the beginning of cache
-            logging.debug('prepending one more page, offset: %r' %
-                          (self._offset - self._page_size))
-            jobjects, self._total_count = datastore.find(self._query,
-                    sorting=['-mtime'],
-                    offset=self._offset - self._page_size,
-                    limit=self._page_size)
-
-            max_cache_size = ListView._MAX_CACHE_PAGES * self._page_size
-            if len(self._cache) + len(jobjects) > max_cache_size:
-                to_delete = len(self._cache) + len(jobjects) - max_cache_size
-                self._cache = self._cache[:-to_delete]
-
-            self._offset -= len(jobjects)
-            jobjects.extend(self._cache)
-            self._cache = jobjects
-
-        if self._total_count != self._vadjustment.props.upper:
-            self._vadjustment.props.upper = self._total_count
+        self._result_set.seek(value)
+        jobjects = self._result_set.read(self._page_size)
+
+        if self._result_set.length != self._vadjustment.props.upper:
+            self._vadjustment.props.upper = self._result_set.length
             self._vadjustment.changed()
 
-        self._refresh_view(value)
+        self._refresh_view(jobjects)
         
         logging.debug('_vadjustment_value_changed_cb %r\n' % (time.time() - t))
 
-    def _refresh_view(self, position):
+    def _refresh_view(self, jobjects):
         # Don't expand the entries if the view is not full.
-        if self._offset + len(self._cache) < position + self._page_size:
+        if len(jobjects) < self._page_size:
             packing = 0     # hippo.PACK_START
         else:
             packing = hippo.PACK_EXPAND
 
         # Refresh view and create the entries if they don't exist yet.
         for i in range(0, self._page_size):
-            if (position - self._offset + i) in range(0, len(self._cache)):
+            if i < len(jobjects):
                 if i >= len(self._entries):
-                    entry = CollapsedEntry(self._cache[position - self._offset + i])
+                    entry = CollapsedEntry(jobjects[i])
                     entry.connect('entry-activated', self._entry_activated_cb)
                     self._box.append(entry, packing)
                     self._entries.append(entry)
                 else:
                     entry = self._entries[i]
-                    entry.jobject = self._cache[position - self._offset + i]
+                    entry.jobject = jobjects[i]
                     entry.set_visible(True)
                     self._box.set_child_packing(entry, packing)
-            else:
-                if i < len(self._entries):
+            elif i < len(self._entries):
                     entry = self._entries[i]
                     entry.set_visible(False)
                     self._box.set_child_packing(entry, packing)
@@ -218,15 +159,12 @@ class ListView(gtk.HBox):
                 self._vadjustment.props.value = 0
 
     def refresh(self):
-        self._offset = 0
-        self._cache, self._total_count = datastore.find(self._query,
-                sorting=['-mtime'],
-                limit=ListView._INITIAL_CACHE_PAGES * self._page_size)
-        self._vadjustment.props.upper = self._total_count
+        self._result_set = query.find(self._query)
+        self._vadjustment.props.upper = self._result_set.length
         self._vadjustment.changed()
         
         self._vadjustment.props.value = min(self._vadjustment.props.value,
-                                            self._total_count - self._page_size)
+                                            self._result_set.length - self._page_size)
 
     def do_set_property(self, pspec, value):
         if pspec.name == 'expanded':
@@ -246,7 +184,8 @@ class ListView(gtk.HBox):
             if self._vadjustment.props.value > self._vadjustment.props.lower:
                 self._vadjustment.props.value -= 1
         elif event.direction == gtk.gdk.SCROLL_DOWN:
-            if self._vadjustment.props.value < self._total_count - self._page_size:
+            max_value = self._result_set.length - self._page_size
+            if self._vadjustment.props.value < max_value:
                 self._vadjustment.props.value += 1
 
     def do_focus(self, direction):
@@ -264,7 +203,8 @@ class ListView(gtk.HBox):
             else:
                 return False
         elif keyname == 'Down':
-            if self._vadjustment.props.value < self._total_count - self._page_size:
+            max_value = self._result_set.length - self._page_size
+            if self._vadjustment.props.value < max_value:
                 self._vadjustment.props.value += 1
                 return True
             else:
@@ -277,7 +217,7 @@ class ListView(gtk.HBox):
             else:
                 return False
         elif keyname == 'Page_Down':
-            new_position = min(self._total_count - self._page_size,
+            new_position = min(self._result_set.length - self._page_size,
                                self._vadjustment.props.value + self._page_size)
             if new_position != self._vadjustment.props.value:
                 self._vadjustment.props.value = new_position
@@ -291,27 +231,24 @@ class ListView(gtk.HBox):
         gtk.HBox.do_size_allocate(self, allocation)
         new_page_size = allocation.height / 69
         
-        if self._entries:
-            print self._entries[0].get_allocation()
-        
         if new_page_size == self._page_size:
             return
 
-        logging.debug("do_size_allocate: %r" % (allocation.height / 65))
+        logging.debug("do_size_allocate: %r" % new_page_size)
 
         self._page_size = new_page_size
 
         self._box.clear()
         self._entries = []
-        self._cache = []
-        self._offset = 0
-        self._total_count = 0
 
         self._vadjustment.props.page_size = self._page_size
         self._vadjustment.props.page_increment = self._page_size
         self._vadjustment.changed()
 
-        max_value = max(0, self._total_count - self._page_size)
+        if self._result_set is None:
+            self._result_set = query.find(self._query)
+
+        max_value = max(0, self._result_set.length - self._page_size)
         if self._vadjustment.props.value > max_value:
             self._vadjustment.props.value = max_value
         else: