A lot

InputQueue.py

@@ -1,5 +1,7 @@
 import clutter
 import gobject
+import pygtk
+import gtk
 
 #########################################################
 # The input queue controls fast user input by queing up
@@ -18,6 +20,10 @@ class InputQueue(gobject.GObject):
             gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, [])
         }
     
+    accelerating = False
+    acceleration_factor = 10 #Timelines will run at regular speed times this
+    acceleration_threshold = 5 #The queue size at which accleration kicks in
+    
     def __init__(self):
         gobject.GObject.__init__(self)
         
@@ -31,8 +37,13 @@ class InputQueue(gobject.GObject):
         self.action_south = None
         self.action_west = None
         
+        gtk.settings_get_default().set_long_property("gtk-timeout-repeat", 5000, "gloss")
+        
     def set_timeline(self, timeline):
         self.timeline = timeline
+        if self.accelerating:
+            fps = self.timeline.get_speed() * self.acceleration_factor
+            self.timeline.set_speed(fps)
         self.timeline.connect('completed', self.flush_queue)
         
     def input(self, event):
@@ -47,16 +58,16 @@ class InputQueue(gobject.GObject):
         self.emit("entering-queue")
         
         if event.keyval == clutter.keysyms.Left:
-            self.queue_west = self.queue_west + 1
+            self.queue_west += 1
             return True
         elif event.keyval == clutter.keysyms.Right:
-            self.queue_east = self.queue_east + 1
+            self.queue_east += 1
             return True
         elif event.keyval == clutter.keysyms.Down:
-            self.queue_south = self.queue_south + 1
+            self.queue_south += 1
             return True
         elif event.keyval == clutter.keysyms.Up:
-            self.queue_north = self.queue_north + 1
+            self.queue_north += 1
             return True
         
         #If we get to this point, we haven't handled the input, so return False
@@ -70,19 +81,45 @@ class InputQueue(gobject.GObject):
         
     def flush_queue(self, data):
         #Consolodate north/south, east/west volumes
-        self.queue_north =  self.queue_north - self.queue_south
+        if self.queue_north > self.queue_south: 
-        self.queue_south =  self.queue_south - self.queue_north
+            self.queue_north = self.queue_north - self.queue_south
-        self.queue_east =  self.queue_east - self.queue_west
+            self.queue_south = 0
-        self.queue_west =  self.queue_west - self.queue_east        
+        elif self.queue_south > self.queue_north:
+            self.queue_south =  self.queue_south - self.queue_north
+            self.queue_north = 0
+        if self.queue_east > self.queue_west: 
+            self.queue_east =  self.queue_east - self.queue_west
+            self.queue_west = 0
+        elif self.queue_west > self.queue_east:
+            self.queue_west =  self.queue_west - self.queue_east        
+            self.queue_east = 0
         
-        if self.queue_north > 0:
+        if (self.queue_north > 0) or (self.queue_east > 0) or (self.queue_south > 0) or (self.queue_west > 0):
-            self.action_north()    
+            self.timeline.connect('completed', self.flush_queue)
-        if self.queue_east > 0:
+            
-            self.action_east()
+            absolute_queue_size = self.queue_north + self.queue_east + self.queue_south + self.queue_west
-        if self.queue_south > 0:
+            if absolute_queue_size > self.acceleration_threshold:
-            self.action_south()
+                self.accelerating = True
-        if self.queue_west > 0:
+            else:
-            self.action_west()
+                self.accelerating = False
+            
+            print "Queue Size: N=%s E=%s S=%s W=%s" % (self.queue_north, self.queue_east, self.queue_south, self.queue_west)
+            
+            if self.queue_north > 0:
+                self.queue_north -= 1
+                self.action_north()
+            if self.queue_east > 0:
+                self.queue_east -= 1
+                self.action_east()
+            if self.queue_south > 0:
+                self.queue_south -= 1
+                self.action_south()
+            if self.queue_west > 0:
+                self.queue_west -= 1
+                self.action_west()
+
+                
+            return
 
         self.queue_east = 0
         self.queue_south = 0

modules/music_player/backends/myth_music.py

@@ -66,6 +66,7 @@ class Backend(gobject.GObject):
     def get_albums_by_artistID(self, id, no_cache = False):
         #Check cache
         if (not no_cache) and (self.cache_albums_by_artistID.has_key(str(id))):
+            self.emit("query-complete")
             return self.cache_albums_by_artistID[str(id)]
         
         #Generate some SQL
@@ -99,6 +100,7 @@ class Backend(gobject.GObject):
     def get_songs_by_albumID(self, id, no_cache = False):
         #Check cache
         if (not no_cache) and (self.cache_songs_by_albumID.has_key(str(id))):
+            self.emit("query-complete")
             return self.cache_songs_by_albumID[str(id)]
         
         

modules/music_player/music_player.py

@@ -134,7 +134,6 @@ class Module:
         
     def update_for_albums(self, data, artist = None):
 
-
         if not artist == self.artistImageRow.get_current_object(): return
         if self.backend.handler_is_connected(self.conn_id): self.backend.disconnect(self.conn_id)
         albums = self.backend.get_albums_by_artistID(artist.artistID)
@@ -150,6 +149,8 @@ class Module:
         pixbuf = albums[0].get_image()
         if not pixbuf is None:
             self.main_img.set_pixbuf(pixbuf)
+        else:
+            self.main_img.set_pixbuf(None)
         clutter.threads_leave()
         
     def begin(self, glossMgr):

ui_elements/image_frame.py

@@ -71,12 +71,20 @@ class ImageFrame(clutter.Group):
         return pixbuf
         
     def set_pixbuf(self, pixbuf):
-        pixbuf = self.resize_pixbuf(pixbuf)
+        if pixbuf is None:
-        self.main_pic.set_pixbuf(pixbuf)
+            self.main_pic.hide()
-        self.main_pic.set_position(self.x, self.y)
+            if not self.reflection is None: self.reflection.hide()
-        self.main_pic.show()
+            return
+        else:
+            pixbuf = self.resize_pixbuf(pixbuf)
+            self.main_pic.set_pixbuf(pixbuf)
+            self.main_pic.set_position(self.x, self.y)
+            self.main_pic.show()
         
+        #For the most part the Reflection texture automatically takes car of pixbuf changes
+        #So we only need to set the flection the first time arouns (ie self.reflection is None)
         if self.use_reflection:
+            if self.reflection is None:
                 self.reflection = Texture_Reflection(self.main_pic)
                 self.add(self.reflection)
                 self.reflection.show()