Fixed some graphical glitches, along with streamlining the access to the visualizer.

7 files changed, 338 insertions, 205 deletions

diff --git a/unit-trace b/unit-trace
index 93ab169..5328b99 100755
--- a/unit-trace
+++ b/unit-trace
@@ -17,7 +17,7 @@ from unit_trace import sanitizer
 from unit_trace import gedf_test
 from unit_trace import stats
 from unit_trace import stdout_printer
-from unit_trace import visualizer
+from unit_trace import viz
 from unit_trace import progress
 from unit_trace import skipper
 from unit_trace import maxer
@@ -107,8 +107,8 @@ if options.stdout is True and options.visualize is True:
     import itertools
     stream1, stream2 = itertools.tee(stream,2)
     stdout_printer.stdout_printer(stream1)
-    visualizer.visualizer(stream2) 
+    viz.visualizer.visualizer(stream2) 
 elif options.stdout is True:
     stdout_printer.stdout_printer(stream)
 elif options.visualize is True:
-    visualizer.visualizer(stream)
+    viz.visualizer.visualizer(stream)
diff --git a/unit_trace/visualizer.py b/unit_trace/visualizer.py
deleted file mode 100755
index af2dc6a..0000000
--- a/unit_trace/visualizer.py
+++ /dev/null
@@ -1,35 +0,0 @@
-#!/usr/bin/python
-
-"""Runs the visualizer."""
-
-import viz
-import gtk
-import trace_reader
-
-TIME_PER_MAJ = 10000000
-
-def request_renderer_change(widget, file_list, params):
-    try:      
-        stream = trace_reader.trace_reader(file_list)
-        #stream = reader.sanitizer.sanitizer(stream)
-        #stream = reader.gedf_test.gedf_test(stream)
-        sched = viz.convert.convert_trace_to_schedule(stream)
-    except trace_reader.InvalidRecordError, e:
-        dialog = gtk.MessageDialog(widget, gtk.DIALOG_DESTROY_WITH_PARENT,
-                 gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, str(e))
-        dialog.run()
-        dialog.destroy()
-        return
-        
-    sched.scan(TIME_PER_MAJ)
-    
-    task_renderer = viz.renderer.Renderer(sched)
-    task_renderer.prepare_task_graph(attrs=viz.format.GraphFormat(time_per_maj=TIME_PER_MAJ))
-    cpu_renderer = viz.renderer.Renderer(sched)
-    cpu_renderer.prepare_cpu_graph(attrs=viz.format.GraphFormat(time_per_maj=TIME_PER_MAJ))
-    widget.set_renderers({'Tasks' : task_renderer, 'CPUs' : cpu_renderer})
-    
-if __name__ == '__main__':   
-    window = viz.viewer.MainWindow(request_renderer_change)
-    gtk.main()
-    
diff --git a/unit_trace/viz/__init__.py b/unit_trace/viz/__init__.py
index ab141e1..11505b9 100644
--- a/unit_trace/viz/__init__.py
+++ b/unit_trace/viz/__init__.py
@@ -1,3 +1,4 @@
+import visualizer
 import viewer
 import renderer
 import format
@@ -11,5 +12,5 @@ gobject.signal_new('update-event-description', viewer.GraphArea, gobject.SIGNAL_
                         None, (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
 gobject.signal_new('request-context-menu', viewer.GraphArea, gobject.SIGNAL_RUN_FIRST,
                         None, (gtk.gdk.Event, gobject.TYPE_PYOBJECT))
-gobject.signal_new('request-renderer-change', viewer.MainWindow, gobject.SIGNAL_RUN_FIRST,
-                        None, (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
+#gobject.signal_new('request-renderer-change', viewer.MainWindow, gobject.SIGNAL_RUN_FIRST,
+#                        None, (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT))
diff --git a/unit_trace/viz/draw.py b/unit_trace/viz/draw.py
index c30ffe7..e28ed24 100644
--- a/unit_trace/viz/draw.py
+++ b/unit_trace/viz/draw.py
@@ -3,6 +3,7 @@
 import math
 import cairo
 import os
+import copy
 
 import util
 import schedule
@@ -15,7 +16,7 @@ def snap(pos):
     line of width 1 on integer coordinates, it will come out blurry unless we shift it,
     since the line will get distributed over two pixels. We actually apply this to all
     coordinates to make sure everything is aligned."""
-    return pos - 0.5
+    return pos
 
 class Surface(object):
     def __init__(self, fname='temp', ctx=None):
@@ -166,39 +167,40 @@ class Canvas(object):
     def scaled(self, *coors):
         return [coor * self.scale for coor in coors]
 
-    def draw_rect(self, x, y, width, height, color, thickness):
+    def draw_rect(self, x, y, width, height, color, thickness, snap=True):
         """Draws a rectangle somewhere (border only)."""
         raise NotImplementedError
     
-    def fill_rect(self, x, y, width, height, color):
+    def fill_rect(self, x, y, width, height, color, snap=True):
         """Draws a filled rectangle somewhere. ``color'' is a 3-tuple."""
         raise NotImplementedError
     
-    def fill_rect_fade(self, x, y, width, height, lcolor, rcolor):
+    def fill_rect_fade(self, x, y, width, height, lcolor, rcolor, snap=True):
         """Draws a rectangle somewhere, filled in with the fade."""
         raise NotImplementedError
             
-    def draw_line(self, p0, p1, color, thickness):
+    def draw_line(self, p0, p1, color, thickness, snap=True):
         """Draws a line from p0 to p1 with a certain color and thickness."""
         raise NotImplementedError
         
-    def draw_polyline(self, coor_list, color, thickness):
+    def draw_polyline(self, coor_list, color, thickness, snap=True):
         """Draws a polyline, where coor_list = [(x_0, y_0), (x_1, y_1), ... (x_m, y_m)]
         specifies a polyline from (x_0, y_0) to (x_1, y_1), etc."""
         raise NotImplementedError
     
-    def fill_polyline(self, coor_list, color, thickness):
+    def fill_polyline(self, coor_list, color, thickness, snap=True):
         """Draws a polyline (probably a polygon) and fills it."""
         raise NotImplementedError
             
-    def draw_label(self, text, x, y, fopts=GraphFormat.DEF_FOPTS_LABEL, halign=AlignMode.LEFT, valign=AlignMode.BOTTOM):
+    def draw_label(self, text, x, y, fopts=GraphFormat.DEF_FOPTS_LABEL,
+                   halign=AlignMode.LEFT, valign=AlignMode.BOTTOM, snap=True):
         """Draws text at a position with a certain alignment."""
         raise NotImplementedError   
     
     def draw_label_with_sscripts(self, text, supscript, subscript, x, y, \
                                  textfopts=GraphFormat.DEF_FOPTS_LABEL,
                                  sscriptfopts=GraphFormat.DEF_FOPTS_LABEL_SSCRIPT, \
-                                 halign=AlignMode.LEFT, valign=AlignMode.BOTTOM):
+                                 halign=AlignMode.LEFT, valign=AlignMode.BOTTOM, snap=True):
         """Draws text at a position with a certain alignment, along with optionally a superscript and
         subscript (which are None if either is not used.)"""
         raise NotImplementedError
@@ -288,7 +290,7 @@ class Canvas(object):
         ``start_tick'' and ``end_tick'' give the major ticks to start and end at for drawing vertical lines.
         ``start_item'' and ``end_item'' give the item boundaries to start and end drawing horizontal lines."""
         if start_tick > end_tick or start_item > end_item:
-            raise ValueError('start must be less than end')
+            return
             
         line_width = (end_tick - start_tick) * maj_sep
         line_height = (end_item - start_item) * item_size
@@ -490,7 +492,10 @@ class Canvas(object):
         
     def add_sel_region(self, region):
         self.selectable_regions[region.get_event()] = region
-        
+    
+    def get_sel_region(self, event):
+        return self.selectable_regions[event]
+            
     def get_selected_regions(self, real_x, real_y, width, height):
         x = real_x + self.surface.virt_x
         y = real_y + self.surface.virt_y
@@ -506,7 +511,7 @@ class Canvas(object):
     def whiteout(self, real_x, real_y, width, height):
         """Overwrites the surface completely white, but technically doesn't delete anything"""
         self.fill_rect(self.surface.virt_x + real_x, self.surface.virt_y + real_y, width,
-                       height, (1.0, 1.0, 1.0))
+                       height, (1.0, 1.0, 1.0), False)
             
     def get_item_color(self, n):
         """Gets the nth color in the item color list, which are the colors used to draw the items
@@ -552,65 +557,84 @@ class CairoCanvas(Canvas):
         """Gets the Surface that we are drawing on in its current state."""
         return self.surface
     
-    def _rect_common(self, x, y, width, height, color, thickness):
+    def _rect_common(self, x, y, width, height, color, thickness, do_snap=True):
         x, y, width, height = self.scaled(x, y, width, height)
         x, y = self.surface.get_real_coor(x, y)
-        self.surface.ctx.rectangle(snap(x), snap(y), width, height)
+        if do_snap:
+            self.surface.ctx.rectangle(snap(x), snap(y), width, height)
+        else:
+            self.surface.ctx.rectangle(x, y, width, height)
+            
         self.surface.ctx.set_line_width(thickness * self.scale)
         self.surface.ctx.set_source_rgb(color[0], color[1], color[2])
         
-    def draw_rect(self, x, y, width, height, color, thickness):
-        self._rect_common(x, y, width, height, color, thickness)
+    def draw_rect(self, x, y, width, height, color, thickness, do_snap=True):
+        self._rect_common(x, y, width, height, color, thickness, do_snap)
         self.surface.ctx.stroke()
     
-    def fill_rect(self, x, y, width, height, color):
-        self._rect_common(x, y, width, height, color, 1)
+    def fill_rect(self, x, y, width, height, color, do_snap=True):
+        self._rect_common(x, y, width, height, color, 1, do_snap)
         self.surface.ctx.fill()
     
-    def fill_rect_fade(self, x, y, width, height, lcolor, rcolor):
+    def fill_rect_fade(self, x, y, width, height, lcolor, rcolor, do_snap=True):
         """Draws a rectangle somewhere, filled in with the fade."""
         x, y, width, height = self.scaled(x, y, width, height)
         x, y = self.surface.get_real_coor(x, y)
         
-        linear = cairo.LinearGradient(snap(x), snap(y), \
+        if do_snap:
+            linear = cairo.LinearGradient(snap(x), snap(y), \
                                       snap(x + width), snap(y + height))
+        else:
+            linear = cairo.LinearGradient(x, y, \
+                                      x + width, y + height)
         linear.add_color_stop_rgb(0.0, lcolor[0], lcolor[1], lcolor[2])
         linear.add_color_stop_rgb(1.0, rcolor[0], rcolor[1], rcolor[2])
         self.surface.ctx.set_source(linear)
-        self.surface.ctx.rectangle(snap(x), snap(y), width, height)
+        if do_snap:
+            self.surface.ctx.rectangle(snap(x), snap(y), width, height)
+        else:
+            self.surface.ctx.rectangle(snap(x), snap(y), width, height)
         self.surface.ctx.fill()
             
-    def draw_line(self, p0, p1, color, thickness):
+    def draw_line(self, p0, p1, color, thickness, do_snap=True):
         """Draws a line from p0 to p1 with a certain color and thickness."""
         p0 = self.scaled(p0[0], p0[1])
         p0 = self.surface.get_real_coor(p0[0], p0[1])
         p1 = self.scaled(p1[0], p1[1])
         p1 = self.surface.get_real_coor(p1[0], p1[1])
+        if do_snap:
+            p0 = (snap(p0[0]), snap(p0[1]))
+            p1 = (snap(p1[0]), snap(p1[1]))
+            
         self.surface.ctx.move_to(p0[0], p0[1])
         self.surface.ctx.line_to(p1[0], p1[1])
         self.surface.ctx.set_source_rgb(color[0], color[1], color[2])
         self.surface.ctx.set_line_width(thickness * self.scale)
         self.surface.ctx.stroke()
         
-    def _polyline_common(self, coor_list, color, thickness):
+    def _polyline_common(self, coor_list, color, thickness, do_snap=True):
         real_coor_list = [self.surface.get_real_coor(coor[0], coor[1]) for coor in coor_list]
         self.surface.ctx.move_to(real_coor_list[0][0], real_coor_list[0][1])
+        if do_snap:
+            for i in range(0, len(real_coor_list)):
+                real_coor_list[i] = (snap(real_coor_list[i][0]), snap(real_coor_list[i][1]))
+                
         for coor in real_coor_list[1:]:
             self.surface.ctx.line_to(coor[0], coor[1])
         
         self.surface.ctx.set_line_width(thickness)    
         self.surface.ctx.set_source_rgb(color[0], color[1], color[2])
         
-    def draw_polyline(self, coor_list, color, thickness):
-        self._polyline_common(coor_list, color, thickness)
+    def draw_polyline(self, coor_list, color, thickness, do_snap=True):
+        self._polyline_common(coor_list, color, thickness, do_snap)
         self.surface.ctx.stroke()
         
-    def fill_polyline(self, coor_list, color, thickness):
-        self._polyline_common(coor_list, color, thickness)
+    def fill_polyline(self, coor_list, color, thickness, do_snap=True):
+        self._polyline_common(coor_list, color, thickness, do_snap)
         self.surface.ctx.fill()
      
     def _draw_label_common(self, text, x, y, fopts, x_bearing_factor, \
-                           f_descent_factor, width_factor, f_height_factor):
+                           f_descent_factor, width_factor, f_height_factor, do_snap=True):
         """Helper function for drawing a label with some alignment. Instead of taking in an alignment,
         it takes in the scale factor for the font extent parameters, which give the raw data of how much to adjust
         the x and y parameters. Only should be used internally."""
@@ -633,11 +657,14 @@ class CairoCanvas(Canvas):
         
         self.surface.ctx.set_source_rgb(fopts.color[0], fopts.color[1], fopts.color[2])
         
-        self.surface.ctx.move_to(snap(actual_x), snap(actual_y))
-                
+        if do_snap:
+            self.surface.ctx.move_to(snap(actual_x), snap(actual_y))
+        else:
+            self.surface.ctx.move_to(actual_x, actual_y)
+                    
         self.surface.ctx.show_text(text)
         
-    def draw_label(self, text, x, y, fopts=GraphFormat.DEF_FOPTS_LABEL, halign=AlignMode.LEFT, valign=AlignMode.BOTTOM):
+    def draw_label(self, text, x, y, fopts=GraphFormat.DEF_FOPTS_LABEL, halign=AlignMode.LEFT, valign=AlignMode.BOTTOM, do_snap=True):
         """Draws a label with the given parameters, with the given horizontal and vertical justification. One can override
         the color from ``fopts'' by passing something in to ``pattern'', which overrides the color with an arbitrary
         pattern."""
@@ -653,11 +680,11 @@ class CairoCanvas(Canvas):
         f_descent_factor, f_height_factor = valign_factors[valign]
             
         self._draw_label_common(text, x, y, fopts, x_bearing_factor, \
-                f_descent_factor, width_factor, f_height_factor)    
+                f_descent_factor, width_factor, f_height_factor, do_snap)    
     
     def draw_label_with_sscripts(self, text, supscript, subscript, x, y, \
                                  textfopts=GraphFormat.DEF_FOPTS_LABEL, sscriptfopts=GraphFormat.DEF_FOPTS_LABEL_SSCRIPT, \
-                                halign=AlignMode.LEFT, valign=AlignMode.BOTTOM):
+                                halign=AlignMode.LEFT, valign=AlignMode.BOTTOM, do_snap=True):
         """Draws a label, but also optionally allows a superscript and subscript to be rendered."""
         self.draw_label(text, x, y, textfopts, halign, valign)
         
@@ -672,14 +699,14 @@ class CairoCanvas(Canvas):
             xtmp = x + x_advance
             ytmp = y
             ytmp = y - f_height / 4.0
-            self.draw_label(supscript, xtmp, ytmp, sscriptfopts, halign, valign)
+            self.draw_label(supscript, xtmp, ytmp, sscriptfopts, halign, valign, do_snap)
         if subscript is not None:
             f_height = fe[2]
             x_advance = te[4]
             xtmp = x + x_advance
             ytmp = y
             ytmp = y + f_height / 4.0
-            self.draw_label(subscript, xtmp, ytmp, sscriptfopts, halign, valign)
+            self.draw_label(subscript, xtmp, ytmp, sscriptfopts, halign, valign, do_snap)
         
 # represents a selectable region of the graph
 class SelectableRegion(object):
@@ -769,11 +796,27 @@ class Graph(object):
     def get_attrs(self):
         return self.attrs
     
+    def add_sel_region(self, region):
+        self.canvas.add_sel_region(region)
+    
+    def get_sel_region(self, event):
+        return self.canvas.get_sel_region(event)
+        
     def update_view(self, x, y, width, height, ctx):
         """Proxy into the surface's pan."""
         self.canvas.surface.pan(x, y, width, height)
         self.canvas.surface.change_ctx(ctx)
     
+    def _recomp_min_max(self, start_time, end_time, start_item, end_item):
+        if self.min_time is None or start_time < self.min_time:
+            self.min_time = start_time
+        if self.max_time is None or end_time > self.max_time:
+            self.max_time = end_time
+        if self.min_item is None or start_item < self.min_item:
+            self.min_item = start_item
+        if self.max_item is None or end_item > self.max_item:
+            self.max_item = end_item
+        
     def _get_time_xpos(self, time):
         """get x so that x is at instant ``time'' on the graph"""
         return self.origin[0] + GraphFormat.X_AXIS_MEASURE_OFS + 1.0 * (time - self.start_time) / self.attrs.time_per_maj * self.attrs.maj_sep
@@ -820,7 +863,7 @@ class Graph(object):
         end_time = self.xcoor_to_time(self.canvas.surface.virt_x + real_x + width)
         
         start_item = self.ycoor_to_item_no(self.canvas.surface.virt_y + real_y)
-        end_item = 1 + self.ycoor_to_item_no(self.canvas.surface.virt_y + real_y + height)
+        end_item = 2 + self.ycoor_to_item_no(self.canvas.surface.virt_y + real_y + height)
         
         return (start_time, end_time, start_item, end_item)
     
@@ -829,7 +872,7 @@ class Graph(object):
         self.draw_x_axis_with_labels_at_time(start_time, end_time)
         self.draw_y_axis_with_labels()
             
-    def render_surface(self, sched, real_x, real_y, width, height, selectable=False):
+    def render_surface(self, sched, regions, selectable=False):
         raise NotImplementedError
     
     def render_all(self, schedule):
@@ -946,22 +989,40 @@ class Graph(object):
         raise NotImplementedError
             
 class TaskGraph(Graph):
-    def render_surface(self, sched, real_x, real_y, width, height, selectable=False):
-        if not selectable:
-            self.canvas.whiteout(real_x, real_y, width, height)
-        else:
-            self.canvas.clear_selectable_regions(real_x, real_y, width, height)
+    def render_surface(self, sched, regions, selectable=False):
+        events_to_render = {}
+        for layer in Canvas.LAYERS:
+            events_to_render[layer] = {}
+        
+        for region in regions:
+            x, y, width, height = region
+            if not selectable:
+                self.canvas.whiteout(x, y, width, height)
+            else:
+                self.canvas.clear_selectable_regions(x, y, width, height)
         
-        start_time, end_time, start_item, end_item = self.get_offset_params(real_x, real_y, width, height)
+        self.min_time, self.max_time, self.min_item, self.max_item = None, None, None, None  
+        for region in regions:
+            x, y, width, height = region
+            start_time, end_time, start_item, end_item = self.get_offset_params(x, y, width, height)
+            self._recomp_min_max(start_time, end_time, start_item, end_item)
+            
+            for event in sched.get_time_slot_array().iter_over_period(
+                        start_time, end_time, start_item, end_item,
+                        schedule.TimeSlotArray.TASK_LIST, schedule.EVENT_LIST):
+                events_to_render[event.get_layer()][event] = None
         
         if not selectable:
-            self.draw_skeleton(start_time, end_time, start_item, end_item)
+            self.draw_skeleton(self.min_time, self.max_time,
+                               self.min_item, self.max_item)
         
+        #if not selectable:
+        #    for layer in events_to_render:
+        #        print 'task render on layer', layer, ':', [str(e) for e in events_to_render[layer].keys()]
+            
         for layer in Canvas.LAYERS:
             prev_events = {}
-            for event in sched.get_time_slot_array().iter_over_period(
-                        start_time, end_time, start_item, end_item,
-                        schedule.TimeSlotArray.TASK_LIST, schedule.EVENT_LIST):
+            for event in events_to_render[layer]:
                 event.render(self, layer, prev_events, selectable)
         
     def draw_suspend_triangle_at_time(self, time, task_no, cpu_no, selected=False):
@@ -1093,42 +1154,54 @@ class TaskGraph(Graph):
         self.canvas.add_sel_mini_bar(x, y, width, height, event)
         
 class CpuGraph(Graph):
-    def render_surface(self, sched, real_x, real_y, width, height, selectable=False):
-        if not selectable:
-            self.canvas.whiteout(real_x, real_y, width, height)
-        else:
-            self.canvas.clear_selectable_regions(real_x, real_y, width, height)
-        
-        start_time, end_time, start_item, end_item = self.get_offset_params(real_x, real_y, width, height)
-        
-        if not selectable:
-            self.draw_skeleton(start_time, end_time, start_item, end_item)
-        
-        event_list = dict(schedule.EVENT_LIST)
+    def render_surface(self, sched, regions, selectable=False):
+        BOTTOM_EVENTS = [schedule.ReleaseEvent, schedule.DeadlineEvent, schedule.InversionStartEvent,
+                     schedule.InversionEndEvent, schedule.InversionDummy]
+        TOP_EVENTS = [schedule.SuspendEvent, schedule.ResumeEvent, schedule.CompleteEvent,
+                  schedule.SwitchAwayEvent, schedule.SwitchToEvent, schedule.IsRunningDummy]
+                  
+        events_to_render = {}
+        for layer in Canvas.LAYERS:
+            events_to_render[layer] = {}
+        
+        self.min_time, self.max_time, self.min_item, self.max_item = None, None, None, None
+        for region in regions:
+            x, y, width, height = region
+            if not selectable:
+                #self.canvas.whiteout(x, y, width, height)
+                self.canvas.whiteout(0, 0, self.canvas.surface.width, self.canvas.surface.height)
+            else:
+                self.canvas.clear_selectable_regions(x, y, width, height)
         
-        bottom_events = [schedule.ReleaseEvent, schedule.DeadlineEvent, schedule.InversionStartEvent,
-                         schedule.InversionEndEvent, schedule.InversionDummy]
+        for region in regions:
+            x, y, width, height = region
+            start_time, end_time, start_item, end_item = self.get_offset_params(x, y, width, height)
+            self._recomp_min_max(start_time, end_time, start_item, end_item)
             
-        for event in bottom_events:
-            del event_list[event]
-        
-        for layer in Canvas.LAYERS:
-            prev_events = {}
             for event in sched.get_time_slot_array().iter_over_period(
                         start_time, end_time, start_item, end_item,
-                        schedule.TimeSlotArray.CPU_LIST, schedule.EVENT_LIST):
-                event.render(self, layer, prev_events, selectable)
+                        schedule.TimeSlotArray.CPU_LIST,
+                        TOP_EVENTS):
+                events_to_render[event.get_layer()][event] = None
         
-        if end_item >= len(self.y_item_list):
-            # we are far down enough that we should render the releases and deadlines and inversions,
-            # which appear near the x-axis
-            for layer in Canvas.LAYERS:
-                prev_events = {}
+            if end_item >= len(self.y_item_list):
+                # we are far down enough that we should render the releases and deadlines and inversions,
+                # which appear near the x-axis
+                x, y, width, height = region
                 for event in sched.get_time_slot_array().iter_over_period(
                         start_time, end_time, 0, sched.get_num_cpus(),
                         schedule.TimeSlotArray.CPU_LIST,
-                        bottom_events):
-                    event.render(self, layer, prev_events, selectable)
+                        BOTTOM_EVENTS):
+                    events_to_render[event.get_layer()][event] = None
+        
+        if not selectable:
+            self.draw_skeleton(self.min_time, self.max_time,
+                               self.min_item, self.max_item)
+                                           
+        for layer in Canvas.LAYERS:
+            prev_events = {}
+            for event in events_to_render[layer]:
+                event.render(self, layer, prev_events, selectable)
                 
     def render(self, schedule, start_time=None, end_time=None):
         if end_time < start_time:
diff --git a/unit_trace/viz/format.py b/unit_trace/viz/format.py
index 6469467..33e0b03 100644
--- a/unit_trace/viz/format.py
+++ b/unit_trace/viz/format.py
@@ -31,6 +31,9 @@ class GraphFormat(object):
     GRID_THICKNESS = 1
     AXIS_THICKNESS = 1
     
+    BAND_THICKNESS = 1.5
+    BAND_COLOR = (0.85, 0.0, 0.0)
+    
     X_AXIS_MEASURE_OFS = 30
     X_AXIS_LABEL_GAP = 10
     Y_AXIS_ITEM_GAP = 10
diff --git a/unit_trace/viz/schedule.py b/unit_trace/viz/schedule.py
index ce062a3..4277f1a 100644
--- a/unit_trace/viz/schedule.py
+++ b/unit_trace/viz/schedule.py
@@ -65,6 +65,7 @@ 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
+                    dummy.corresp_end_event = event
                     
                     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)
@@ -151,7 +152,7 @@ class Schedule(object):
                 for event_time in sorted(job.get_events().keys()):
                     # could have multiple events at the same time (unlikely but possible)
                     for event in job.get_events()[event_time]:
-                        print 'task, job, event:', task.name, job.job_no, event.__class__.__name__
+                        #print 'task, job, event:', task.name, job.job_no, event.__class__.__name__
                         event.scan(cur_cpu, switches)
         
     def add_task(self, task):
@@ -395,7 +396,7 @@ class SwitchAwayEvent(Event):
     def __str__(self):
         if self.corresp_start_event is None:
             return 'Switch Away (w/o Switch To)' + self._common_str() + 'TIME=' \
-                   + self.get_time()
+                   + str(self.get_time())
         return str(self.corresp_start_event)
             
     def scan(self, cur_cpu, switches):
@@ -422,9 +423,25 @@ class SwitchAwayEvent(Event):
         super(SwitchAwayEvent, self).scan(cur_cpu, switches)
             
     def render(self, graph, layer, prev_events, selectable=False):
-        if self.corresp_start_event is None or self.corresp_start_event in prev_events:
-            return # erroneous switch away or already rendered
-        self.corresp_start_event.render(graph, layer, prev_events, selectable)
+        if self.corresp_start_event is None:
+            # We never found a corresponding start event. In that case, we can assume it lies
+            # in some part of the trace that was never read in. So draw a bar starting from
+            # the very beginning.
+            if layer == self.layer:
+                prev_events[self] = None
+                cpu = self.get_cpu()
+                task_no = self.get_job().get_task().get_task_no()
+                if selectable:
+                    start = self.get_job().get_task().get_schedule().start
+                    graph.add_sel_bar_at_time(start, self.get_time(),
+                                     task_no, cpu, self)
+                else:
+                    graph.draw_bar_at_time(start, self.get_time(),
+                                   task_no, cpu, self.get_job().get_job_no(), self.is_selected())
+        else:
+            if self.corresp_start_event in prev_events:
+                return # already rendered the bar
+            self.corresp_start_event.render(graph, layer, prev_events, selectable)
         
 class SwitchToEvent(Event):
     def __init__(self, time, cpu):
@@ -434,7 +451,7 @@ class SwitchToEvent(Event):
     def __str__(self):
         if self.corresp_end_event is None:
             return 'Switch To (w/o Switch Away)' + self._common_str() + ', TIME=' \
-                   + self.get_time()
+                   + str(self.get_time())
         return 'Scheduled' + self._common_str() + ', START=' \
                + util.format_float(self.get_time(), Event.NUM_DEC_PLACES) \
                + ', END=' + util.format_float(self.corresp_end_event.get_time(), Event.NUM_DEC_PLACES)
@@ -454,15 +471,21 @@ class SwitchToEvent(Event):
     def render(self, graph, layer, prev_events, selectable=False):
         if self.corresp_end_event is None:
             return # fatally erroneous switch to
-        if layer == Canvas.BOTTOM_LAYER:
+        if layer == self.layer:
+            end_time = None
+            if self.corresp_end_event is None:
+                end_time = self.get_job().get_task().get_schedule().end
+            else:
+                end_time = self.corresp_end_event.get_time()
+            
             prev_events[self] = None
             cpu = self.get_cpu()
             task_no = self.get_job().get_task().get_task_no()
             if selectable:
-                graph.add_sel_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
+                graph.add_sel_bar_at_time(self.get_time(), end_time,
                                      task_no, cpu, self)
             else:
-                graph.draw_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
+                graph.draw_bar_at_time(self.get_time(), end_time,
                                    task_no, cpu, self.get_job().get_job_no(), self.is_selected())
         
 class ReleaseEvent(Event):
@@ -530,15 +553,21 @@ class InversionStartEvent(ErrorEvent):
         super(InversionStartEvent, self).scan(cur_cpu, switches)
     
     def render(self, graph, layer, prev_events, selectable=False):
-        if layer == Canvas.BOTTOM_LAYER:
+        end_time = None
+        if self.corresp_end_event is None:
+            end_time = self.get_job().get_task().get_schedule().end
+        else:
+            end_time = self.corresp_end_event.get_time()
+            
+        if layer == self.layer:
             prev_events[self] = None
             cpu = self.get_cpu()
             task_no = self.get_job().get_task().get_task_no()
             if selectable:
-                graph.add_sel_mini_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
+                graph.add_sel_mini_bar_at_time(self.get_time(), end_time,
                                      task_no, cpu, self)
             else:
-                graph.draw_mini_bar_at_time(self.get_time(), self.corresp_end_event.get_time(),
+                graph.draw_mini_bar_at_time(self.get_time(), end_time,
                                    task_no, cpu, self.get_job().get_job_no(), self.is_selected())
             
 
@@ -570,19 +599,45 @@ class InversionEndEvent(ErrorEvent):
         super(InversionEndEvent, self).scan(cur_cpu, switches)
         
     def render(self, graph, layer, prev_events, selectable=False):
-        if self.corresp_start_event is None or self.corresp_start_event in prev_events:
-            return # erroneous inversion end or already rendered
-        self.corresp_start_event.render(graph, layer, prev_events, selectable)
+        if self.corresp_start_event is None:
+            # We never found a corresponding start event. In that case, we can assume it lies
+            # in some part of the trace that was never read in. So draw a bar starting from
+            # the very beginning.
+            if layer == self.layer:
+                prev_events[self] = None
+                cpu = self.get_cpu()
+                task_no = self.get_job().get_task().get_task_no()
+                if selectable:
+                    start = self.get_job().get_task().get_schedule().start
+                    graph.add_sel_mini_bar_at_time(start, self.get_time(),
+                                     task_no, cpu, self)
+                else:
+                    graph.draw_mini_bar_at_time(start, self.get_time(),
+                                   task_no, cpu, self.get_job().get_job_no(), self.is_selected())
+        else:
+            if self.corresp_start_event in prev_events:
+                return # already rendered the bar
+            self.corresp_start_event.render(graph, layer, prev_events, selectable)
         
 class InversionDummy(DummyEvent):
+    def __init__(self, time, cpu):
+        super(InversionDummy, self).__init__(time, Event.NO_CPU)
+        self.layer = Canvas.BOTTOM_LAYER
+        
     def render(self, graph, layer, prev_events, selectable=False):
-        if self.corresp_start_event in prev_events:
+        if self.corresp_start_event is not None and self.corresp_start_event in prev_events:
             return # we have already been rendered
+        if self.corresp_end_event is not None and self.corresp_end_event in prev_events:
+            return
         self.corresp_start_event.render(graph, layer, prev_events, selectable)
         
 class IsRunningDummy(DummyEvent):
+    def __init__(self, time, cpu):
+        super(IsRunningDummy, self).__init__(time, Event.NO_CPU)
+        self.layer = Canvas.BOTTOM_LAYER
+        
     def render(self, graph, layer, prev_events, selectable=False):
-        if self.corresp_start_event in prev_events:
+        if self.corresp_start_event is None or self.corresp_start_event in prev_events:
             return # we have already been rendered
         self.corresp_start_event.render(graph, layer, prev_events, selectable)
 
diff --git a/unit_trace/viz/viewer.py b/unit_trace/viz/viewer.py
index 120c7e7..236a467 100644
--- a/unit_trace/viz/viewer.py
+++ b/unit_trace/viz/viewer.py
@@ -9,6 +9,7 @@ from renderer import *
 import pygtk
 import gtk
 import gobject
+import copy
 
 class GraphContextMenu(gtk.Menu):
     MAX_STR_LEN = 80
@@ -30,8 +31,7 @@ class GraphArea(gtk.DrawingArea):
     VERT_PAGE_SCROLL_FACTOR = 3.0
     VERT_STEP_SCROLL_FACTOR = 0.5
     
-    SELECT_THICKNESS = 1.5
-    SELECT_COLOR = (0.85, 0.0, 0.0)
+    REFRESH_INFLATION_FACTOR = 20.0
     
     def __init__(self, renderer):
         super(GraphArea, self).__init__()
@@ -46,11 +46,11 @@ class GraphArea(gtk.DrawingArea):
         self.set_set_scroll_adjustments_signal('set-scroll-adjustments')
         
         self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK |
-                        gtk.gdk.BUTTON_RELEASE_MASK)
+                        gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.EXPOSURE_MASK)
         
-        self.left_button_start_coor = None
-        self.select_rect = None
+        self.band_rect = None
         self.ctrl_clicked = False
+        self.dirtied_regions = []
         
         self.connect('expose-event', self.expose)
         self.connect('size-allocate', self.size_allocate)
@@ -59,23 +59,34 @@ class GraphArea(gtk.DrawingArea):
         self.connect('button-release-event', self.button_release)
         self.connect('motion-notify-event', self.motion_notify)
         
-    def expose(self, widget, event, data=None):
+    def expose(self, widget, expose_event, data=None):
         ctx = widget.window.cairo_create()
         graph = self.renderer.get_graph()
         graph.update_view(self.cur_x, self.cur_y, self.width, self.height, ctx)
-        graph.render_surface(self.renderer.get_schedule(), 0, 0, self.width, self.height)
         
-        # render dragging rectangle, if there is one
-        if self.select_rect is not None:
-            x, y, width, height = self.select_rect
-            thickness = GraphArea.SELECT_THICKNESS
-            color = GraphArea.SELECT_COLOR
+        # We ourselves didn't update dirtied_regions, so this means that X or the
+        # window manager must have caused the expose event. So just update the
+        # expose_event's bounding area.
+        if not self.dirtied_regions or expose_event.send_event:
+            print 'forced expose'
+            self.dirtied_regions = [(expose_event.area.x, expose_event.area.y,
+                                     expose_event.area.width, expose_event.area.height)]
+                                  
+        graph.render_surface(self.renderer.get_schedule(), self.dirtied_regions)
+        
+        # render dragging band rectangle, if there is one
+        if self.band_rect is not None:
+            x, y, width, height = self.band_rect
+            thickness = GraphFormat.BAND_THICKNESS
+            color = GraphFormat.BAND_COLOR
             
             ctx.rectangle(x, y, width, height)            
             ctx.set_line_width(thickness)
             ctx.set_source_rgb(color[0], color[1], color[2])
             ctx.stroke()
-    
+        
+        self.dirtied_regions = []
+        
     def get_renderer(self):
         return self.renderer
         
@@ -100,15 +111,13 @@ class GraphArea(gtk.DrawingArea):
         self.cur_x = min(adjustment.value, self.renderer.get_graph().get_width())
         self.cur_x = max(adjustment.value, 0.0)
         
-        rect = gtk.gdk.Rectangle(0, 0, self.width, self.height)
-        self.window.invalidate_rect(rect, True)
+        self._dirty(0, 0, self.width, self.height)
     
     def vertical_value_changed(self, adjustment):
         self.cur_y = min(adjustment.value, self.renderer.get_graph().get_height())
         self.cur_y = max(adjustment.value, 0.0)
         
-        rect = gtk.gdk.Rectangle(0, 0, self.width, self.height)
-        self.window.invalidate_rect(rect, True)
+        self._dirty(0, 0, self.width, self.height)
             
     def size_allocate(self, widget, allocation):
         self.width = allocation.width
@@ -133,13 +142,25 @@ class GraphArea(gtk.DrawingArea):
             if event.get_layer() > max_layer:
                 max_layer = event.get_layer()
         return max_layer
-        
+    
+    def _update_event_changes(self, list1, list2):
+        # if an event changed selected status, update the bounding area
+        for event in list1:
+            if event not in list2:
+                x, y, width, height = list1[event].get_dimensions()
+                self._dirty_inflate(x - self.cur_x, y - self.cur_y, width, height, GraphFormat.BORDER_THICKNESS)
+        for event in list2:
+            if event not in list1:
+                x, y, width, height = list2[event].get_dimensions()
+                self._dirty_inflate(x - self.cur_x, y - self.cur_y, width, height, GraphFormat.BORDER_THICKNESS)
+                        
     def motion_notify(self, widget, motion_event, data=None):
         msg = None
         
         graph = self.renderer.get_graph()
         
-        graph.render_surface(self.renderer.get_schedule(), motion_event.x, motion_event.y, 0, 0, True)
+        graph.render_surface(self.renderer.get_schedule(), [(motion_event.x, motion_event.y,
+                             0, 0)], True)
         just_selected = graph.get_selected_regions(motion_event.x, motion_event.y, 0, 0)
         if not just_selected:
             msg = ''
@@ -156,25 +177,31 @@ class GraphArea(gtk.DrawingArea):
         
         self.emit('update-event-description', the_event, msg)
         
-        if self.left_button_start_coor is not None:
+        if self.band_rect is not None:
             selected = {}
+            was_selected = self.renderer.get_schedule().get_selected()
             if self.ctrl_clicked:
-                selected = dict(self.last_selected)
+                selected = copy.copy(was_selected)
                 
             # dragging a rectangle
-            x = min(self.left_button_start_coor[0], motion_event.x)
-            y = min(self.left_button_start_coor[1], motion_event.y)
-            width = abs(self.left_button_start_coor[0] - motion_event.x)
-            height = abs(self.left_button_start_coor[1] - motion_event.y)
+            x = self.band_rect[0]
+            y = self.band_rect[1]
+            width = motion_event.x - self.band_rect[0]
+            height = motion_event.y - self.band_rect[1]
             
-            graph.render_surface(self.renderer.get_schedule(), x, y, width, height, True)
-            selected.update(graph.get_selected_regions(x, y, width, height))
+            x_p, y_p, width_p, height_p = self._positivify(x, y, width, height)
+            graph.render_surface(self.renderer.get_schedule(), [(x_p, y_p, width_p, height_p)], True)
+            selected.update(graph.get_selected_regions(x_p, y_p, width_p, height_p))
             self.renderer.get_schedule().set_selected(selected)
     
-            self.select_rect = (x, y, width, height)
+            old_x, old_y, old_width, old_height = self.band_rect
+            self.band_rect = (x, y, width, height)
             
-            self._dirty()
+            self._dirty_rect_border(old_x, old_y, old_width, old_height, GraphFormat.BAND_THICKNESS)
+            self._dirty_rect_border(x, y, width, height, GraphFormat.BAND_THICKNESS)
         
+            self._update_event_changes(was_selected, selected)
+            
     def button_press(self, widget, button_event, data=None):
         graph = self.renderer.get_graph()
         
@@ -183,15 +210,16 @@ class GraphArea(gtk.DrawingArea):
         if button_event.button == 1:
             self.left_button_start_coor = (button_event.x, button_event.y)
             graph.render_surface(self.renderer.get_schedule(), \
-                                 button_event.x, button_event.y, 0, 0, True)
+                                 [(button_event.x, button_event.y, 0, 0)], True)
             
             just_selected = graph.get_selected_regions(button_event.x, button_event.y, 0, 0)
             
             max_layer = self._find_max_layer(just_selected)
             
             new_now_selected = None
+            was_selected = self.renderer.get_schedule().get_selected()
             if self.ctrl_clicked:
-                new_now_selected = self.renderer.get_schedule().get_selected()
+                new_now_selected = copy.copy(was_selected)
             else:
                 new_now_selected = {}
                 
@@ -206,45 +234,75 @@ class GraphArea(gtk.DrawingArea):
                     if (len(now_selected) == 1 or self.ctrl_clicked) and event in now_selected:
                         val = not event.is_selected
                     if val:
-                        new_now_selected[event] = None
+                        new_now_selected[event] = graph.get_sel_region(event)
                     elif event in new_now_selected:
                         del new_now_selected[event]
                     break # only pick one event when just clicking
             
             self.renderer.get_schedule().set_selected(new_now_selected)
-            self.last_selected = dict(new_now_selected)
+            #self.last_selected = new_now_selected
             
-            self._dirty()
+            self._update_event_changes(new_now_selected, was_selected)
+            
+            if self.band_rect is None:
+                self.band_rect = (button_event.x, button_event.y, 0, 0)
+                    
         elif button_event.button == 3:
             self._release_band()
             self.emit('request-context-menu', button_event, self.renderer.get_schedule().get_selected())
                                     
     def button_release(self, widget, button_event, data=None):
         self.ctrl_clicked = False
-        self.last_selected = dict(self.renderer.get_schedule().get_selected())
+        #self.last_selected = copy.copy(self.renderer.get_schedule().get_selected())
         
         if button_event.button == 1:
             self._release_band()
     
     def _release_band(self):
-        old_select_rect = self.select_rect
-        self.left_button_start_coor = None
-        self.select_rect = None
-        if old_select_rect is not None:
-            self._dirty()
+        if self.band_rect is not None:
+            x, y, width, height = self.band_rect
+            self._dirty_rect_border(x, y, width, height, GraphFormat.BAND_THICKNESS)
+            self.band_rect = None
                             
-    def _dirty(self, x=None, y=None, width=None, height=None):
-        if x is None:
-            x = 0
-        if y is None:
-            y = 0
-        if width is None:
-            width = self.width
-        if height is None:
-            height = self.height
+    def _dirty(self, x, y, width, height):
+        x = max(int(math.floor(x)), 0)
+        y = max(int(math.floor(y)), 0)
+        width = min(int(math.ceil(width)), self.width)
+        height = min(int(math.ceil(height)), self.height)
+        
+        self.dirtied_regions.append((x, y, width, height))
+        
         rect = gtk.gdk.Rectangle(x, y, width, height)
         self.window.invalidate_rect(rect, True)
-                 
+    
+    def _dirty_inflate(self, x, y, width, height, thickness):
+        t = thickness * GraphArea.REFRESH_INFLATION_FACTOR
+        x -= t / 2.0
+        y -= t / 2.0
+        width += t
+        height += t
+        self._dirty(x, y, width, height)
+        
+    def _dirty_rect_border(self, x, y, width, height, thickness):
+        # support rectangles with negative width and height (i.e. -width = width, but going leftwards
+        # instead of rightwards)
+        x, y, width, height = self._positivify(x, y, width, height)
+        
+        self._dirty_inflate(x, y, width, 0, thickness)
+        self._dirty_inflate(x, y, 0, height, thickness)
+        self._dirty_inflate(x, y + height, width, 0, thickness)
+        self._dirty_inflate(x + width, y, 0, height, thickness)
+    
+    def _positivify(self, x, y, width, height):
+        if width < 0:
+            x += width
+            width = -width
+        if height < 0:
+            y += height
+            height = -height
+        
+        return x, y, width, height
+        
 class GraphWindow(gtk.ScrolledWindow):    
     def __init__(self, renderer):
         super(GraphWindow, self).__init__(None, None)
@@ -310,20 +368,13 @@ class MainWindow(gtk.Window):
     WINDOW_WIDTH_REQ = 500
     WINDOW_HEIGHT_REQ = 300
     
-    def __init__(self, request_renderer_change):
+    def __init__(self):
         super(MainWindow, self).__init__(gtk.WINDOW_TOPLEVEL)
         
         self.connect('delete_event', self.delete_event)
         self.connect('destroy', self.die)
-    
-        self.connect('request-renderer-change', request_renderer_change)
         
         self.file_menu = gtk.Menu()
-        self.open_item = gtk.MenuItem('_Open', True)
-        self.open_item.connect('activate', self.open_item_activate)
-        self.file_menu.append(self.open_item)
-        self.open_item.show()
-        
         self.quit_item = gtk.MenuItem('_Quit', True)
         self.quit_item.connect('activate', self.quit_item_activate)
         self.quit_item.show()
@@ -397,21 +448,6 @@ class MainWindow(gtk.Window):
         menu = GraphContextMenu(selected)
         menu.popup(None, None, None, button, time)
         
-    def open_item_activate(self, widget):
-        dialog = gtk.FileChooserDialog('Open File', self,
-                                   gtk.FILE_CHOOSER_ACTION_OPEN,
-                                   (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
-                                               gtk.STOCK_OPEN, gtk.RESPONSE_ACCEPT))
-        dialog.set_select_multiple(True)
-            
-        if dialog.run() == gtk.RESPONSE_ACCEPT:
-            filenames = dialog.get_filenames()
-            dialog.destroy()
-            self.emit('request-renderer-change', filenames, None)
-        else:
-            dialog.destroy()
-        
-        
     def quit_item_activate(self, widget):
         self.destroy()