Some minor updates and optimizations, including support for keypresses

3 files changed, 89 insertions, 20 deletions

diff --git a/viz/draw.py b/viz/draw.py
index db246ec..c30ffe7 100644
--- a/viz/draw.py
+++ b/viz/draw.py
@@ -743,6 +743,7 @@ class Graph(object):
                 extra_width = cur_width
             
         width += extra_width
+        
         self.origin = (extra_width + GraphFormat.WIDTH_PAD / 2.0, height - GraphFormat.HEIGHT_PAD / 2.0)
         
         self.width = width
@@ -762,6 +763,9 @@ class Graph(object):
     def get_height(self):
         return self.height
     
+    def get_origin(self):
+        return self.origin
+        
     def get_attrs(self):
         return self.attrs
     
diff --git a/viz/schedule.py b/viz/schedule.py
index e525b17..ae7284b 100644
--- a/viz/schedule.py
+++ b/viz/schedule.py
@@ -35,25 +35,29 @@ class TimeSlotArray(object):
         for type in self.list_sizes:
             num = self.list_sizes[type]
             self.array[type] = []
-            for i in range(0, int((end - start) // self.time_per_maj + 1)):
+            for j in range(0, num):
                 # for each slot in the array, we need a list of all events under this type
                 # (for example, a list of all events that occur in this time slot, indexed
                 # by task).
-                self.array[type].append([])
-                for j in range(0, num):
-                    self.array[type][i].append(dict(zip(EVENT_LIST, \
-                                    [[] for j in range(0, len(EVENT_LIST))])))
+                for i in range(0, num):
+                    self.array[type].append(dict(zip(EVENT_LIST, \
+                                    [{} for j in range(0, len(EVENT_LIST))])))
     
     def get_time_slot(self, time):
         return int((time - self.start) // self.time_per_maj)
-            
+    
+    def _put_event_in_slot(self, list_type, no, klass, slot, event):
+        if slot not in self.array[list_type][no][klass]:
+            self.array[list_type][no][klass][slot] = []
+        self.array[list_type][no][klass][slot].append(event)
+                
     def add_event_to_time_slot(self, event):
         task_no = event.get_job().get_task().get_task_no()
         cpu = event.get_cpu()
         time_slot = self.get_time_slot(event.get_time())
         
-        self.array[TimeSlotArray.TASK_LIST][time_slot][task_no][event.__class__].append(event)
-        self.array[TimeSlotArray.CPU_LIST][time_slot][cpu][event.__class__].append(event)
+        self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, event.__class__, time_slot, event)
+        self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, event.__class__, time_slot, event)
             
         span_events = { SwitchAwayEvent : IsRunningDummy, InversionEndEvent : InversionDummy}
         
@@ -64,8 +68,9 @@ class TimeSlotArray(object):
                 for slot in range(start_slot + 1, end_slot):
                     dummy = span_events[span_event](task_no, cpu)
                     dummy.corresp_start_event = event.corresp_start_event
-                    self.array[TimeSlotArray.TASK_LIST][slot][task_no][dummy.__class__].append(dummy)
-                    self.array[TimeSlotArray.CPU_LIST][slot][cpu][dummy.__class__].append(dummy)
+                    
+                    self._put_event_in_slot(TimeSlotArray.TASK_LIST, task_no, dummy.__class__, slot, dummy)
+                    self._put_event_in_slot(TimeSlotArray.CPU_LIST, cpu, dummy.__class__, slot, dummy)
             
     def iter_over_period(self, start, end, start_no, end_no, list_type, event_types):
         if self.array is None:
@@ -76,17 +81,18 @@ class TimeSlotArray(object):
         if start_no > end_no:
             raise ValueError('start no should be less than end no')
         
-        start_slot = max(0, self.get_time_slot(start))
-        end_slot = min(len(self.array[list_type]), self.get_time_slot(end) + 2)
+        start_slot = self.get_time_slot(start)
+        end_slot = self.get_time_slot(end) + 2
         
         start_no = max(0, start_no)
         end_no = min(self.list_sizes[list_type] - 1, end_no)
         
-        for slot in range(start_slot, end_slot):
-            for no in range(start_no, end_no + 1):
-                for type in event_types:
-                    for event in self.array[list_type][slot][no][type]:
-                        yield event
+        for no in range(start_no, end_no + 1):
+            for type in event_types:
+                for slot in range(start_slot, end_slot):
+                    if slot in self.array[list_type][no][type]:
+                        for event in self.array[list_type][no][type][slot]:
+                            yield event
     
 class Schedule(object):
     """The total schedule (task system), consisting of a certain number of
diff --git a/viz/viewer.py b/viz/viewer.py
index a7871a7..18fa900 100644
--- a/viz/viewer.py
+++ b/viz/viewer.py
@@ -25,7 +25,7 @@ class GraphContextMenu(gtk.Menu):
             item.show()
             
 class GraphArea(gtk.DrawingArea):
-    HORIZ_PAGE_SCROLL_FACTOR = 4.8
+    HORIZ_PAGE_SCROLL_FACTOR = 10.8
     HORIZ_STEP_SCROLL_FACTOR = 0.8
     VERT_PAGE_SCROLL_FACTOR = 3.0
     VERT_STEP_SCROLL_FACTOR = 0.5
@@ -75,7 +75,13 @@ class GraphArea(gtk.DrawingArea):
             ctx.set_line_width(thickness)
             ctx.set_source_rgb(color[0], color[1], color[2])
             ctx.stroke()
+    
+    def get_renderer(self):
+        return self.renderer
         
+    def get_graph(self):
+        return self.renderer.get_graph()
+            
     def set_scroll_adjustments(self, widget, horizontal, vertical, data=None):
         graph = self.renderer.get_graph()
         width = graph.get_width()
@@ -243,10 +249,60 @@ class GraphWindow(gtk.ScrolledWindow):
     def __init__(self, renderer):
         super(GraphWindow, self).__init__(None, None)
         
+        self.add_events(gtk.gdk.KEY_PRESS_MASK)
+        
+        self.ctr = 0
+        self.connect('key-press-event', self.key_press)
+                                
         self.garea = GraphArea(renderer)
         self.add(self.garea)
         self.garea.show()
     
+    def key_press(self, widget, key_event):
+        hadj = self.get_hadjustment()
+        vadj = self.get_vadjustment()
+        if hadj is None or vadj is None:
+            return
+            
+        hupper = hadj.get_upper()
+        hlower = hadj.get_lower()
+        hpincr = hadj.get_page_increment()
+        hsincr = hadj.get_step_increment()
+        hpsize = hadj.get_page_size()
+        hval = hadj.get_value()
+        vupper = vadj.get_upper()
+        vlower = vadj.get_lower()
+        vval = vadj.get_value()
+        vpincr = vadj.get_page_increment()
+        vsincr = vadj.get_step_increment()
+        vpsize = vadj.get_page_size()
+        
+        ctrl_clicked = key_event.state & gtk.gdk.CONTROL_MASK
+        
+        adj_tuple = {'up' :     (vadj, -vsincr, 0, vval, max),
+                     'ctrl-up' :    (vadj, -vpincr, 0, vval, max),
+                     'down' :   (vadj, vsincr, vupper - vpsize, vval, min),
+                     'ctrl-down' :  (vadj, vpincr, vupper - vpsize, vval, min),
+                     'left' :   (hadj, -hsincr, 0, hval, max),
+                     'ctrl-left' :  (hadj, -hpincr, 0, hval, max),
+                     'right' :  (hadj, hsincr, hupper - hpsize, hval, min),
+                     'ctrl-right' : (hadj, hpincr, hupper - hpsize, hval, min)}
+                     
+        keystr = None
+        keymap = {gtk.keysyms.Up : 'up', gtk.keysyms.Down : 'down',
+                  gtk.keysyms.Left : 'left', gtk.keysyms.Right : 'right'}
+        if key_event.keyval in keymap:        
+            keystr = keymap[key_event.keyval]
+                  
+        if ctrl_clicked:
+            keystr = 'ctrl-' + keystr
+            
+        if keystr is not None:
+            adj, inc, lim, val, extr = adj_tuple[keystr]
+            adj.set_value(extr(val + inc, lim))
+            
+        return True
+        
     def get_graph_area(self):
         return self.garea
                         
@@ -321,8 +377,11 @@ class MainWindow(gtk.Window):
         
     def switch_page(self, widget, page, page_num):
         if self.notebook.last_page >= 0:
-            hvalue = self.notebook.get_nth_page(self.notebook.last_page).get_hadjustment().get_value()
-            self.notebook.get_nth_page(page_num).get_hadjustment().set_value(hvalue)
+            old_value = self.notebook.get_nth_page(self.notebook.last_page).get_hadjustment().get_value()
+            old_ofs = self.notebook.get_nth_page(self.notebook.last_page).get_graph_area().get_graph().get_origin()[0]
+            new_ofs = self.notebook.get_nth_page(page_num).get_graph_area().get_graph().get_origin()[0]
+            new_value = old_value - old_ofs + new_ofs
+            self.notebook.get_nth_page(page_num).get_hadjustment().set_value(new_value)
         
         self.notebook.last_page = page_num